diff --git a/.gitignore b/.gitignore
index 71986661..c647db94 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,3 @@
 /.project
 /.DS_Store
-/.DS_Store
+/.idea
diff --git "a/AdavancedPart/1.\347\203\255\344\277\256\345\244\215\345\256\236\347\216\260(\344\270\200).md" "b/AdavancedPart/1.\347\203\255\344\277\256\345\244\215\345\256\236\347\216\260(\344\270\200).md"
new file mode 100644
index 00000000..bf052c89
--- /dev/null
+++ "b/AdavancedPart/1.\347\203\255\344\277\256\345\244\215\345\256\236\347\216\260(\344\270\200).md"
@@ -0,0 +1,731 @@
+
+热修复实现(一)
+===
+
+
+现在的热修复方案已经有很多了，例如`alibaba`的[dexposed](https://github.com/alibaba/dexposed)、[AndFix](https://github.com/alibaba/AndFix)以及`jasonross`的[Nuwa](https://github.com/jasonross/Nuwa)等等。原来没有仔细去分析过也没想写这篇文章，但是之前[InstantRun详解][1]这篇文章中介绍了`Android Studio Instant Run`的
+实现原理，这不就是活生生的一个热修复吗？ 随心情久久不能平复，我们何不用这种方式来实现。    
+
+
+方案有很多种，我就只说明下我想到的方式，也就是`Instant Run`的方式:    
+分拆到不同的`dex`中，然后通过`classloader`来进行加载。但是在之前[`InstantRun`详解](https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/InstantRun%E8%AF%A6%E8%A7%A3.md)中只说到会通过内部的`server`去判断该类是否有更新，如果有的话就去从新的`dex`中加载该类，否则就从旧的`dex`中加载，但这是如何实现的呢？ 怎么去从不同的`dex`中选择最新的那个来进行加载。    
+
+讲到这里需要先介绍一下`ClassLoader`：       
+
+< `A class loader is an object that is responsible for loading classes. The class ClassLoader is an abstract class. Given the binary name of a class, a class loader should attempt to locate or generate data that constitutes a definition for the class. A typical strategy is to transform the name into a file name and then read a "class file" of that name from a file system.`     
+
+
+在一般情况下，应用程序不需要创建`ClassLoader`对象，而是使用当前环境已经存在的`ClassLoader`。因为`Java`的`Runtime`环境在初始化时，其内部会创建一个`ClassLoader`对象用于加载`Runtime`所需的各种`Java`类。    
+每个`ClassLoader`必须有一个父类，在装载`Class`文件时，子`ClassLoader`会先请求父`ClassLoader`加载该`Class`文件，只有当其父`ClassLoader`找不到该`Class`文件时，子`ClassLoader`才会继续装载该类，这是一种安全机制。    
+
+对于`Android`的应用程序，本质上虽然也是用`Java`开发，并且使用标准的`Java`编译器编译出`Class`文件，但最终的`APK`文件中包含的却是`dex`类型的文件。`dex`文件是将所需的所有`Class`文件重新打包，打包的规则不是简单的压缩，而是完全对`Class`文件内部的各种函数表、变量表等进行优化，并产生一个新的文件，这就是`dex`文件。由于`dex`文件是一种经过优化的`Class`文件，因此要加载这样特殊的`Class`文件就需要特殊的类装载器，这就是`DexClassLoader`，`Android SDK`中提供的D`exClassLoader`类就是出于这个目的。
+
+
+总体来说，`Android` 默认主要有三个`ClassLoader`:   
+
+- `BootClassLoader`: 系统启动时创建            
+    `Provides an explicit representation of the boot class loader. It sits at the
+    head of the class loader chain and delegates requests to the VM's internal
+    class loading mechanism.`
+- `PathClassLoader`: 可以加载`/data/app`目录下的`apk`，这也意味着，它只能加载已经安装的`apk`；
+- `DexClassLoader`: 可以加载文件系统上的`jar`、`dex`、`apk`；可以从`SD`卡中加载未安装的`apk`
+
+
+通过上面的分析知道，如果用多个`dex`的话肯定会用到`DexClassLoader`类，我们首先来看一下它的源码(这里
+插一嘴，源码可以去[googlesource](https://android.googlesource.com/platform/libcore-snapshot/+/ics-mr1/dalvik/src/main/java/dalvik/system)中找):  
+```java
+/**
+ * A class loader that loads classes from {@code .jar} and {@code .apk} files
+ * containing a {@code classes.dex} entry. This can be used to execute code not
+ * installed as part of an application.
+ *
+ * <p>This class loader requires an application-private, writable directory to
+ * cache optimized classes. Use {@code Context.getDir(String, int)} to create
+ * such a directory: <pre>   {@code
+ *   File dexOutputDir = context.getDir("dex", 0);
+ * }</pre>
+ *
+ * <p><strong>Do not cache optimized classes on external storage.</strong>
+ * External storage does not provide access controls necessary to protect your
+ * application from code injection attacks.
+ */
+public class DexClassLoader extends BaseDexClassLoader {
+    /**
+     * Creates a {@code DexClassLoader} that finds interpreted and native
+     * code.  Interpreted classes are found in a set of DEX files contained
+     * in Jar or APK files.
+     *
+     * <p>The path lists are separated using the character specified by the
+     * {@code path.separator} system property, which defaults to {@code :}.
+     *
+     * @param dexPath the list of jar/apk files containing classes and
+     *     resources, delimited by {@code File.pathSeparator}, which
+     *     defaults to {@code ":"} on Android
+     * @param optimizedDirectory directory where optimized dex files
+     *     should be written; must not be {@code null}
+     * @param libraryPath the list of directories containing native
+     *     libraries, delimited by {@code File.pathSeparator}; may be
+     *     {@code null}
+     * @param parent the parent class loader
+     */
+    public DexClassLoader(String dexPath, String optimizedDirectory,
+            String libraryPath, ClassLoader parent) {
+        super(dexPath, new File(optimizedDirectory), libraryPath, parent);
+    }
+}
+```
+注释说的太明白了，这里就不翻译了，但是我们并没有找到加载的代码，去它的父类中查找，
+因为家在都是从`loadClass()`方法中，所以我们去`ClassLoader`类中看一下`loadClass()`方法:   
+```java
+/**
+     * Loads the class with the specified name. Invoking this method is
+     * equivalent to calling {@code loadClass(className, false)}.
+     * <p>
+     * <strong>Note:</strong> In the Android reference implementation, the
+     * second parameter of {@link #loadClass(String, boolean)} is ignored
+     * anyway.
+     * </p>
+     *
+     * @return the {@code Class} object.
+     * @param className
+     *            the name of the class to look for.
+     * @throws ClassNotFoundException
+     *             if the class can not be found.
+     */
+    public Class<?> loadClass(String className) throws ClassNotFoundException {
+        return loadClass(className, false);
+    }
+
+    /**
+     * Loads the class with the specified name, optionally linking it after
+     * loading. The following steps are performed:
+     * <ol>
+     * <li> Call {@link #findLoadedClass(String)} to determine if the requested
+     * class has already been loaded.</li>
+     * <li>If the class has not yet been loaded: Invoke this method on the
+     * parent class loader.</li>
+     * <li>If the class has still not been loaded: Call
+     * {@link #findClass(String)} to find the class.</li>
+     * </ol>
+     * <p>
+     * <strong>Note:</strong> In the Android reference implementation, the
+     * {@code resolve} parameter is ignored; classes are never linked.
+     * </p>
+     *
+     * @return the {@code Class} object.
+     * @param className
+     *            the name of the class to look for.
+     * @param resolve
+     *            Indicates if the class should be resolved after loading. This
+     *            parameter is ignored on the Android reference implementation;
+     *            classes are not resolved.
+     * @throws ClassNotFoundException
+     *             if the class can not be found.
+     */
+    protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
+        Class<?> clazz = findLoadedClass(className);
+
+        if (clazz == null) {
+            ClassNotFoundException suppressed = null;
+            try {
+            	// 先检查父ClassLoader是否已经家在过该类
+                clazz = parent.loadClass(className, false);
+            } catch (ClassNotFoundException e) {
+                suppressed = e;
+            }
+
+            if (clazz == null) {
+                try {
+                	// 调用DexClassLoader.findClass()方法。
+                    clazz = findClass(className);
+                } catch (ClassNotFoundException e) {
+                    e.addSuppressed(suppressed);
+                    throw e;
+                }
+            }
+        }
+
+        return clazz;
+    }
+```
+上面会调用`DexClassLoader.findClass()`方法，但是`DexClassLoader`没有实现该方法，所以去它的父类`BaseDexClassLoader`中看，接着看一下`BaseDexClassLoader`的源码:    
+```java
+/**
+ * Base class for common functionality between various dex-based
+ * {@link ClassLoader} implementations.
+ */
+public class BaseDexClassLoader extends ClassLoader {
+    /** originally specified path (just used for {@code toString()}) */
+    private final String originalPath;
+    /** structured lists of path elements */
+    private final DexPathList pathList;
+    /**
+     * Constructs an instance.
+     *
+     * @param dexPath the list of jar/apk files containing classes and
+     * resources, delimited by {@code File.pathSeparator}, which
+     * defaults to {@code ":"} on Android
+     * @param optimizedDirectory directory where optimized dex files
+     * should be written; may be {@code null}
+     * @param libraryPath the list of directories containing native
+     * libraries, delimited by {@code File.pathSeparator}; may be
+     * {@code null}
+     * @param parent the parent class loader
+     */
+    public BaseDexClassLoader(String dexPath, File optimizedDirectory,
+            String libraryPath, ClassLoader parent) {
+        super(parent);
+        this.originalPath = dexPath;
+        this.pathList =
+            new DexPathList(this, dexPath, libraryPath, optimizedDirectory);
+    }
+    @Override
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+        // 从DexPathList中找
+        Class clazz = pathList.findClass(name);
+        if (clazz == null) {
+            throw new ClassNotFoundException(name);
+        }
+        return clazz;
+    }
+    @Override
+    protected URL findResource(String name) {
+        return pathList.findResource(name);
+    }
+    @Override
+    protected Enumeration<URL> findResources(String name) {
+        return pathList.findResources(name);
+    }
+    @Override
+    public String findLibrary(String name) {
+        return pathList.findLibrary(name);
+    }
+
+```
+在`findClass()`方法中我们看到调用了`DexPathList.findClass()`方法:   
+```java
+/**
+ * A pair of lists of entries, associated with a {@code ClassLoader}.
+ * One of the lists is a dex/resource path &mdash; typically referred
+ * to as a "class path" &mdash; list, and the other names directories
+ * containing native code libraries. Class path entries may be any of:
+ * a {@code .jar} or {@code .zip} file containing an optional
+ * top-level {@code classes.dex} file as well as arbitrary resources,
+ * or a plain {@code .dex} file (with no possibility of associated
+ * resources).
+ *
+ * <p>This class also contains methods to use these lists to look up
+ * classes and resources.</p>
+ */
+/*package*/ final class DexPathList {
+    private static final String DEX_SUFFIX = ".dex";
+    private static final String JAR_SUFFIX = ".jar";
+    private static final String ZIP_SUFFIX = ".zip";
+    private static final String APK_SUFFIX = ".apk";
+    /** class definition context */
+    private final ClassLoader definingContext;
+    /** list of dex/resource (class path) elements */ 
+    // 把dex封装成一个数组，每个Element代表一个dex
+    private final Element[] dexElements;
+    /** list of native library directory elements */
+    private final File[] nativeLibraryDirectories;
+
+    // .....
+
+    /**
+     * Finds the named class in one of the dex files pointed at by
+     * this instance. This will find the one in the earliest listed
+     * path element. If the class is found but has not yet been
+     * defined, then this method will define it in the defining
+     * context that this instance was constructed with.
+     *
+     * @return the named class or {@code null} if the class is not
+     * found in any of the dex files
+     */
+    public Class findClass(String name) {
+        for (Element element : dexElements) {
+            DexFile dex = element.dexFile;
+            // 遍历数组，拿到第一个就返回
+            if (dex != null) {
+                Class clazz = dex.loadClassBinaryName(name, definingContext);
+                if (clazz != null) {
+                    return clazz;
+                }
+            }
+        }
+        return null;
+    }
+}
+```
+从上面的源码中分析，我知道系统会把所有相关的`dex`维护到一个数组中，然后在加载类的时候会从该数组中的第一个元素中取，然后返回。那我们只要保证将我们热修复后的`dex`对应的`Element`放到该数组的第一个位置就可以了，这样系统就会加载我们热修复的`dex`中的类。   
+所以方案出来了，只要把有问题的类修复后，放到一个单独的`dex`，然后把该`Dex`转换成对应的`Element`后再将该`Element`插入到`dexElements`数组的第一个位置就可以了。那该如何去将其插入到`dexElements`数组的第一个位置呢？-- 暴力反射。      
+
+
+
+到这里我感觉初步的思路已经有了:      
+
+- 将补丁作为`dex`发布。 
+- 通过反射修改该`dex`所对应的`Element`在数组中的位置。 
+
+但是我也想到肯定还会有类似下面的问题:     
+
+- 资源文件的处理
+- 四大组件的处理
+- 清单文件的处理
+
+
+虽然我知道没有这么简单，但是我还是决定抱着不作不死的宗旨继续前行。    
+
+好了，`demo`走起来。    
+
+
+怎么生成`dex`文件呢？ 这要讲过两部分:   
+
+- `.class`-> `.jar` : `jar  -cvf test.jar com/charon/instantfix_sample/MainActivity.class`
+- `.jar`-> `.dex`: `dx --dex --output=target.jar test.jar` `target.jar`就是包含`.dex`的`jar`包
+
+
+生成好`dex`后我们为了模拟先将其放到`asset`目录下(实际开发中肯定要从接口中去下载，当然还会有一些版本号的判断等)，然后就是将该`dex`转换成
+   
+
+方案中采用的是`MultiDex`，对其进行一部分改造，具体代码:    
+
+- 添加`dex`文件，并执行`install`
+
+```java
+/**
+* 添加apk包外的dex文件
+* 自动执行install
+* @param dexFile
+*/
+public static void addDexFileAutoInstall(Context context, List<File> dexFile,File optimizedDirectory) {
+    if (dexFile != null && !dexFile.isEmpty() &&!dexFiles.contains(dexFile)) {
+         dexFiles.addAll(dexFile);
+         LogUtil.d(TAG, "add other dexfile");
+         installDexFile(context,optimizedDirectory);
+     }
+}
+```
+
+- `installDexFile`直接调用`MultiDex`的`installSecondaryDexes`方法 
+
+```java
+/**
+ * 添加apk包外的dex文件，
+ * @param context
+ */
+publicstatic void installDexFile(Context context, File optimizedDirectory){
+    if (checkValidZipFiles(dexFiles)) {
+        try {
+            installSecondaryDexes(context.getClassLoader(), optimizedDirectory, dexFiles);
+        } catch (IllegalAccessExceptione){
+           e.printStackTrace();
+        } catch (NoSuchFieldExceptione) {
+           e.printStackTrace();
+        } catch (InvocationTargetExceptione){
+           e.printStackTrace();
+        } catch (NoSuchMethodExceptione) {
+           e.printStackTrace();
+        } catch (IOExceptione) {
+           e.printStackTrace();
+        }
+    }
+}
+```
+
+- 将`patch.dex`放在所有`dex`最前面
+
+```java
+private static voidexpandFieldArray(Object instance, String fieldName, Object[]extraElements) throws NoSuchFieldException, IllegalArgumentException,
+IllegalAccessException {
+    Field jlrField = findField(instance, fieldName);
+    Object[]original = (Object[]) jlrField.get(instance);
+    Object[]combined = (Object[]) Array.newInstance(original.getClass().getComponentType(),original.length + extraElements.length);
+    // 将后来的dex放在前面，主dex放在最后。
+    System.arraycopy(extraElements, 0, combined, 0, extraElements.length);
+    System.arraycopy(original, 0, combined, extraElements.length,original.length);
+    // 原始的dex合并，是将主dex放在前面，其他的dex依次放在后面。
+    //System.arraycopy(original, 0, combined, 0, original.length);
+    //System.arraycopy(extraElements, 0, combined, original.length,extraElements.length);
+    jlrField.set(instance, combined);
+}
+```
+
+到此将`patch.dex`放进了`Element`，接下来的问题就是加载`Class`，当加载`patch.dex`中类的时候，会遇到一个问题，这个问题就是`QQ`空间团队遇到的`Class`的`CLASS_ISPREVERIFIED`。具体原因是`dvmResolveClass`这个方法对`Class`进行了校验。判断这个要`Resolve`的`class`是否和其引用来自一个`dex`。如果不是，就会遇到问题。
+ 
+当引用这和被引用者不在同一个`dex`中就会抛出异常，导致`Resolve`失败。`QQ`空间团队的方案是阻止所有的`Class`类打上`CLASS_ISPREVERIFIED`来逃过校验，这种方式其实是影响性能。
+我们的方案是和`QQ`团队的类似，但是和`QQ`空间不同的是，我们将`fromUnverifiedConstant`设置为`true`，来逃过校验，达到补丁的路径。具体怎么实现呢？
+要引用`Cydia Hook`技术来`hook Native dalvik`中`dvmResolveClass`这个方法。有关`Cydia Hook`技术请参考:   
+
+- [官网地址](http://www.cydiasubstrate.com/)
+- [官方教程](http://www.cydiasubstrate.com/id/38be592b-bda7-4dd2-b049-cec44ef7a73b)
+- [SDK下载地址](http://asdk.cydiasubstrate.com/zips/cydia_substrate-r2.zip)
+
+
+具体代码如下:   
+```java
+//指明要hook的lib ：
+MSConfig(MSFilterLibrary,"/system/lib/libdvm.so")
+ 
+// 在初始化的时候进行hook
+MSInitialize {
+    LOGD("Cydia Init");
+    MSImageRef image;
+    //载入lib
+    image = MSGetImageByName("/system/lib/libdvm.so");
+    if (image != NULL) {
+        LOGD("image is not null");
+        void *dexload=MSFindSymbol(image,"dvmResolveClass");
+        if(dexload != NULL) {
+            LOGD("dexloadis not null");
+            MSHookFunction(dexload, (void*)proxyDvmResolveClass, (void**)&dvmResolveClass_Proxy);
+        } else{
+            LOGD("errorfind dvmResolveClass");
+        }
+    }
+}
+// 在初始化的时候进行hook//保留原来的地址
+ClassObject* (*dvmResolveClass_Proxy)(ClassObject* referrer, u4 classIdx, boolfromUnverifiedConstant);
+// 新方法地址
+static ClassObject* proxyDvmResolveClass(ClassObject* referrer, u4 classIdx,bool fromUnverifiedConstant) {
+        return dvmResolveClass_Proxy(referrer, classIdx,true);
+}
+```
+
+说到此处，似乎已经是一个完整的方案了，但在实践中，会发现运行加载类的时候报`preverified`错误，原来在`DexPrepare.cpp`，将`dex`转化成`odex`的过程中，会在`DexVerify.cpp`进行校验，
+验证如果直接引用到的类和`clazz`是否在同一个`dex`，如果是，则会打上`CLASS_ISPREVERIFIED`标志。通过在所有类（`Application`除外，当时还没加载自定义类的代码）的构造函数插入一个对在单独的`dex`的类的引用，就可以解决这个问题。空间使用了`javaassist`进行编译时字节码插入。
+
+所以为了实现补丁方案，所以必须从这些方法中入手，防止类被打上`CLASS_ISPREVERIFIED`标志。 最终空间的方案是往所有类的构造函数里面插入了一段代码，代码如下：
+
+```java
+if (ClassVerifier.PREVENT_VERIFY) {
+    System.out.println(AntilazyLoad.class);
+}
+```
+
+其中`AntilazyLoad`类会被打包成单独的`antilazy.dex`，这样当安装`apk`的时候，`classes.dex`内的类都会引用一个在不相同`dex`中的`AntilazyLoad`类，这样就防止了类被打上`CLASS_ISPREVERIFIED`的标志了，只要没被打上这个标志的类都可以进行打补丁操作。 然后在应用启动的时候加载进来`AntilazyLoad`类所在的`dex`包必须被先加载进来,不然`AntilazyLoad`类会被标记为不存在，即使后续加载了`hack.dex`包，那么他也是不存在的，这样屏幕就会出现茫茫多的类`AntilazyLoad`找不到的`log`。 所以`Application`作为应用的入口不能插入这段代码。（因为载入`hack.dex`的代码是在`Application`中`onCreate`中执行的，如果在`Application`的构造函数里面插入了这段代码，那么就是在`hack.dex`加载之前就使用该类，该类一次找不到，会被永远的打上找不到的标志)
+
+如何打包补丁包:    
+
+１. 空间在正式版本发布的时候，会生成一份缓存文件，里面记录了所有`class`文件的`md5`，还有一份`mapping`混淆文件。
+２. 在后续的版本中使用`-applymapping`选项，应用正式版本的`mapping`文件，然后计算编译完成后的`class`文件的`md5`和正式版本进行比较，把不相同的`class`文件打包成补丁包。
+备注:该方案现在也应用到我们的编译过程当中,编译不需要重新打包`dex`,只需要把修改过的类的`class`文件打包成`patch dex`,然后放到`sdcard`下,那么就会让改变的代码生效。
+
+在`Java`中，只有当两个实例的类名、包名以及加载其的`ClassLoader`都相同，才会被认为是同一种类型。上面分别加载的新类和旧类，虽然包名和类名都完全一样，但是由于加载的`ClassLoader`不同，所以并不是同一种类型，在实际使用中可能会出现类型不符异常。
+同一个`Class`=相同的`ClassName + PackageName + ClassLoader`
+以上问题在采用动态加载功能的开发中容易出现，请注意。
+
+通过上面的分析，我们知道使用`ClassLoader`动态加载一个外部的类是非常容易的事情，所以很容易就能实现动态加载新的可执行代码的功能，但是比起一般的`Java`程序，在`Android`程序中使用动态加载主要有两个麻烦的问题:    
+
+- `Android`中许多组件类(如`Activity、Service`等)是需要在`Manifest`文件里面注册后才能工作的(系统会检查该组件有没有注册)，所以即使动态加载了一个新的组件类进来，没有注册的话还是无法工作；
+- `Res`资源是`Android`开发中经常用到的，而`Android`是把这些资源用对应的`R.id`注册好，运行时通过这些`ID`从`Resource`实例中获取对应的资源。如果是运行时动态加载进来的新类，那类里面用到`R.id`的地方将会抛出找不到资源或者用错资源的异常，因为新类的资源ID根本和现有的`Resource`实例中保存的资源`ID`对不上；
+
+说到底，抛开虚拟机的差别不说，一个`Android`程序和标准的`Java`程序最大的区别就在于他们的上下文环境`(Context)`不同。`Android`中，这个环境可以给程序提供组件需要用到的功能，也可以提供一些主题、`Res`等资源，其实上面说到的两个问题都可以统一说是这个环境的问题，而现在的各种`Android`动态加载框架中，核心要解决的东西也正是“如何给外部的新类提供上下文环境”的问题。
+
+`DexClassLoader`的使用方法一般有两种:   
+
+- 从已安装的`apk`中读取`dex`
+- 从`apk`文件中读取`dex`
+
+假如有两个`APK`，一个是宿主`APK`，叫作`HOST`，一个是插件`APK`，叫作`Plugin`。`Plugin`中有一个类叫`PluginClass`，代码如下:  
+```java
+public class PluginClass {
+    public PluginClass() {
+        Log.d("JG","初始化PluginClass");
+    }
+
+    public int function(int a, int b){
+        return a+b;  
+    }  
+}
+```
+现在如果想调用插件`APK`中`PluginClass`内的方法，应该怎么办？
+
+#### 从已安装的apk中读取dex
+
+先来看第一种方法，这种方法必须建一个`Activity`，在清单文件中配置`Action`.
+
+```java
+<activity android:name=".MainActivity">
+         <intent-filter>
+             <action android:name="com.maplejaw.plugin"/>
+         </intent-filter>
+</activity>
+```
+然后在宿主`APK`中如下使用:       
+```java
+/**
+   * 这种方式用于从已安装的apk中读取，必须要有一个activity，且需要配置ACTION
+   */
+private void useDexClassLoader(){
+      //创建一个意图，用来找到指定的apk
+      Intent intent = new Intent("com.maplejaw.plugin");
+      //获得包管理器
+      PackageManager pm = getPackageManager();
+      List<ResolveInfo> resolveinfoes =  pm.queryIntentActivities(intent, 0);
+      if(resolveinfoes.size()==0){
+          return;
+      }
+      //获得指定的activity的信息
+      ActivityInfo actInfo = resolveinfoes.get(0).activityInfo;
+
+      //获得包名
+      String packageName = actInfo.packageName;
+      //获得apk的目录或者jar的目录
+      String apkPath = actInfo.applicationInfo.sourceDir;
+      //dex解压后的目录,注意，这个用宿主程序的目录，android中只允许程序读取写自己
+      //目录下的文件
+      String dexOutputDir = getApplicationInfo().dataDir;
+
+      //native代码的目录
+      String libPath = actInfo.applicationInfo.nativeLibraryDir;
+
+      //创建类加载器，把dex加载到虚拟机中
+      DexClassLoader calssLoader = new DexClassLoader(apkPath, dexOutputDir, libPath,
+              this.getClass().getClassLoader());
+
+      //利用反射调用插件包内的类的方法
+
+      try {
+          Class<?> clazz = calssLoader.loadClass(packageName+".PluginClass");
+
+          Object obj = clazz.newInstance();
+          Class[] param = new Class[2];
+          param[0] = Integer.TYPE;
+          param[1] = Integer.TYPE;
+
+          Method method = clazz.getMethod("function", param);
+
+          Integer ret = (Integer)method.invoke(obj, 12,34);
+
+          Log.d("JG", "返回的调用结果为:" + ret);
+
+      } catch (Exception e) {
+          e.printStackTrace();
+      } 
+  }
+```
+我们安装完两个`APK`后，在宿主中就可以直接调用，调用示例如下。
+
+```java
+public void btnClick(View view){
+    useDexClassLoader();
+}
+```
+
+#### 从apk文件中读取dex
+
+这种方法由于并不需要安装，所以不需要通过`Intent`从`activity`中解析信息。换言之，这种方法不需要创建`Activity`。无需配置清单文件。我们只需要打包一个`apk`，然后放到`SD`卡中即可。
+核心代码如下:    
+
+```java
+//apk路径
+String path=Environment.getExternalStorageDirectory().getAbsolutePath()+"/1.apk";
+
+private void useDexClassLoader(String path){
+  
+    File codeDir=getDir("dex", Context.MODE_PRIVATE);
+
+    //创建类加载器，把dex加载到虚拟机中
+    DexClassLoader calssLoader = new DexClassLoader(path, codeDir.getAbsolutePath(), null,
+            this.getClass().getClassLoader());
+
+    //利用反射调用插件包内的类的方法
+
+    try {
+        Class<?> clazz = calssLoader.loadClass("com.maplejaw.plugin.PluginClass");
+
+        Object obj = clazz.newInstance();
+        Class[] param = new Class[2];
+        param[0] = Integer.TYPE;
+        param[1] = Integer.TYPE;
+
+        Method method = clazz.getMethod("function", param);
+
+        Integer ret = (Integer)method.invoke(obj, 12,21);
+
+        Log.d("JG", "返回的调用结果为: " + ret);
+
+    } catch (Exception e) {
+        e.printStackTrace();
+    } 
+
+```
+
+
+动态加载的几个关键问题:    
+
+- 资源访问:无法找到某某`id`所对应的资源
+    因为将`apk`加载到宿主程序中去执行，就无法通过宿主程序的`Context`去取到`apk`中的资源,比如图片、文本等，这是很好理解的，因为`apk`已经不存在上下文了，它执行时所采用的上下文是宿主程序的上下文，
+    用别人的`Context`是无法得到自己的资源的
+    
+    - 解决方案一：插件中的资源在宿主程序中也预置一份；     
+        缺点：增加了宿主`apk`的大小；在这种模式下，每次发布一个插件都需要将资源复制到宿主程序中，这意味着每发布一个插件都要更新一下宿主程序；
+    - 解决方案二：将插件中的资源解压出来，然后通过文件流去读取资源；      
+        缺点：实际操作起来还是有很大难度的。首先不同资源有不同的文件流格式，比如图片、XML等，其次针对不同设备加载的资源可能是不一样的，如何选择合适的资源也是一个需要解决的问题；
+    实际解决方案:    
+    `Activity`中有一个叫`mBase`的成员变量，它的类型就是`ContextImpl`。注意到`Context`中有如下两个抽象方法，看起来是和资源有关的，实际上`Context`就是通过它们来获取资源的。这两个抽象方法的真正实现在`ContextImpl`中；
+
+
+```java
+/** Return an AssetManager instance for your application's package. */
+    public abstract AssetManager getAssets();
+
+    /** Return a Resources instance for your application's package. */
+    public abstract Resources getResources();
+```
+具体实现:   
+```java
+protected void loadResources() {
+    try {
+        AssetManager assetManager = AssetManager.class.newInstance();
+        Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);
+        addAssetPath.invoke(assetManager, mDexPath);
+        mAssetManager = assetManager;
+    } catch (Exception e) {
+        e.printStackTrace();
+    }
+    Resources superRes = super.getResources();
+    mResources = new Resources(mAssetManager, superRes.getDisplayMetrics(),
+            superRes.getConfiguration());
+    mTheme = mResources.newTheme();
+    mTheme.setTo(super.getTheme());
+}
+
+```
+
+加载资源的方法是通过反射，通过调用`AssetManager`中的`addAssetPath`方法，我们可以将一个`apk`中的资源加载到`Resources`对象中，由于`addAssetPath`是隐藏`API`我们无法直接调用，所以只能通过反射。
+
+```java
+@hide
+    public final int addAssetPath(String path) {
+    synchronized (this) {
+        int res = addAssetPathNative(path);
+        makeStringBlocks(mStringBlocks);
+        return res;
+    }
+}
+```
+
+`Activity`生命周期的管理:反射方式和接口方式。   
+反射的方式很好理解，首先通过`Java`的反射去获取`Activity`的各种生命周期方法，比如`onCreate`、`onStart`、`onResume`等，然后在代理`Activity`中去调用插件`Activity`对应的生命周期方法即可:   
+缺点：一方面是反射代码写起来比较复杂，另一方面是过多使用反射会有一定的性能开销。
+
+反射方式
+```java
+@Override
+protected void onResume() {
+    super.onResume();
+    Method onResume = mActivityLifecircleMethods.get("onResume");
+    if (onResume != null) {
+        try {
+            onResume.invoke(mRemoteActivity, new Object[] { });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+@Override
+protected void onPause() {
+    Method onPause = mActivityLifecircleMethods.get("onPause");
+    if (onPause != null) {
+        try {
+            onPause.invoke(mRemoteActivity, new Object[] { });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    super.onPause();
+}
+```
+
+接口方式
+
+```java
+public interface DLPlugin {
+
+    public void onStart();
+
+    public void onRestart();
+
+    public void onActivityResult(int requestCode, int resultCode, Intent
+
+    data);
+
+    public void onResume();
+
+    public void onPause();
+
+    public void onStop();
+
+    public void onDestroy();
+
+    public void onCreate(Bundle savedInstanceState);
+
+    public void setProxy(Activity proxyActivity, String dexPath);
+
+    public void onSaveInstanceState(Bundle outState);
+
+    public void onNewIntent(Intent intent);
+
+    public void onRestoreInstanceState(Bundle savedInstanceState);
+
+    public boolean onTouchEvent(MotionEvent event);
+
+    public boolean onKeyUp(int keyCode, KeyEvent event);
+
+    public void onWindowAttributesChanged(LayoutParams params);
+
+    public void onWindowFocusChanged(boolean hasFocus);
+
+    public void onBackPressed();
+
+…
+
+}
+```
+代理`Activity`中只需要按如下方式即可调用插件`Activity`的生命周期方法，这就完成了插件`Activity`的生命周期的管理;插件`Activity`需要实现`DLPlugin`接口:   
+```java
+@Override
+protected void onStart() {
+    mRemoteActivity.onStart();
+    super.onStart();
+}
+
+@Override
+protected void onRestart() {
+    mRemoteActivity.onRestart();
+    super.onRestart();
+}
+
+@Override
+protected void onResume() {
+    mRemoteActivity.onResume();
+    super.onResume();
+}
+```
+
+
+
+- [Google Instant app](https://developer.android.com/topic/instant-apps/index.html)
+- [微信热补丁实现](https://github.com/WeMobileDev/article/blob/master/%E5%BE%AE%E4%BF%A1Android%E7%83%AD%E8%A1%A5%E4%B8%81%E5%AE%9E%E8%B7%B5%E6%BC%94%E8%BF%9B%E4%B9%8B%E8%B7%AF.md#rd)
+- [多dex分拆](http://my.oschina.net/853294317/blog/308583)
+- [QQ空间热修复方案](https://mp.weixin.qq.com/s?__biz=MzI1MTA1MzM2Nw==&mid=400118620&idx=1&sn=b4fdd5055731290eef12ad0d17f39d4a)
+- [Android dex分包方案](http://my.oschina.net/853294317/blog/308583)
+- [类加载器DexClassLoader](http://www.maplejaw.com/2016/05/24/Android%E6%8F%92%E4%BB%B6%E5%8C%96%E6%8E%A2%E7%B4%A2%EF%BC%88%E4%B8%80%EF%BC%89%E7%B1%BB%E5%8A%A0%E8%BD%BD%E5%99%A8DexClassLoader/)
+- [基于cydia Hook在线热修复补丁方案](http://blog.csdn.net/xwl198937/article/details/49801975)
+- [Android 热补丁动态修复框架小结](http://blog.csdn.net/lmj623565791/article/details/49883661)
+- [美团Android DEX自动拆包及动态加载简介](http://tech.meituan.com/mt-android-auto-split-dex.html)
+- [插件化从放弃到捡起](http://kymjs.com/column/plugin.html)
+- [无需Root也能使用Xposed！](http://weishu.me/)
+- [当你准备开发一个热修复框架的时候，你需要了解的一切](http://www.zjutkz.net/2016/05/23/%E5%BD%93%E4%BD%A0%E5%87%86%E5%A4%87%E5%BC%80%E5%8F%91%E4%B8%80%E4%B8%AA%E7%83%AD%E4%BF%AE%E5%A4%8D%E6%A1%86%E6%9E%B6%E7%9A%84%E6%97%B6%E5%80%99%EF%BC%8C%E4%BD%A0%E9%9C%80%E8%A6%81%E4%BA%86%E8%A7%A3%E7%9A%84%E4%B8%80%E5%88%87/)		
+
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/InstantRun%E8%AF%A6%E8%A7%A3.md "InstantRun详解"
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/AdavancedPart/2.\347\203\255\344\277\256\345\244\215\345\256\236\347\216\260(\344\272\214).md" "b/AdavancedPart/2.\347\203\255\344\277\256\345\244\215\345\256\236\347\216\260(\344\272\214).md"
new file mode 100644
index 00000000..7d02b934
--- /dev/null
+++ "b/AdavancedPart/2.\347\203\255\344\277\256\345\244\215\345\256\236\347\216\260(\344\272\214).md"
@@ -0,0 +1,97 @@
+
+热修复实现(二)
+===
+
+之前也分析过`InstantRun`的源码，前面也写了一篇热修复实现原理的文章。
+
+But，最近遇到困难了，所在项目要做插件化，同事在开发过程中遇到了一个在5.0以下手机崩溃的问题，想着一起找找原因修复下。
+但是这个bug已经折腾了我两天了，只找到原因，并没有找出任何解决方案。
+
+深深的感觉到之前的那些都是皮毛，没有真正的去做，真正的去处理一些细节，那些都是没任何意义的。
+
+所以这里系统学习一下，既然学习，就找一个做的最好的来学。 
+
+
+前面的文章也介绍了，目前存在的几个开源框架:   
+
+- 手机淘宝基于Xposed进行了改进，产生了针对Android Dalvik虚拟机运行时的Java Method Hook技术-Dexposed。
+但这个方案犹豫底层Dalvik结构过于依赖，最终无法兼容Android 5.0以后的ART虚拟机。 
+
+- 支付宝提出了新的方案Andfix，它同样是一种底层结构替换的方案，也达到了运行时生效即时修复的效果，而且做到了Dalvik和ART全版本的兼容。然而它也
+是由局限性的，且不说其底层固定结构的替换方案稳定性不好，其使用范文也存在着诸多限制，虽然可以通过代码改造来绕过限制达到同样的
+修复目的，但是这种方式即不优雅也不方便。而且更大的问题是Andfix只提供了代码层面的修复，对于资源和so的修复都还未实现。 
+
+- 其他的就是微信Tinker、饿了么的Amigo、美团的Robust，不过他们都各自有各自的局限性，或者不够稳定、或者补丁过大、或者效率低下
+，或者使用起来太繁琐，大部分技术上看起来似乎可行，但是实际体验并不好。
+
+我们学习的就是阿里巴巴的新一代非侵入式Android热修复方案-Sophix。
+它各个方面都比较优秀，使用也比较方便，唯一不支持的就是四大组件的修复。这是因为如果修复四大组件，必须在AndroidManifest里面预先插入代码组件，并且尽可能声明所有权限，这样就会给
+原先的app添加很多臃肿的代码，对app运行流程的侵入性很强。 
+
+
+在Sophix中，唯一需要的就是初始化和请求补丁两行代码，甚至连入口Application类我们都不需要做任何修改。
+
+这样就给了开发者最大的透明度和自由度。我们甚至重新开发了打包工具，使的补丁工具操作图形界面化，这种所见即所得的补丁生成
+方式也是阿里热修复独家的，因此，Sophix的接入成本也是目前市面上所有方案里最低的。 
+
+
+
+
+代码修复
+---
+
+代码修复有两大主要方案:   
+
+- 阿里系的底层替换方案:底层替换方案限制颇多，但是时效性最好，加载轻快，立即见效。
+
+	底层替换方案是在已经加载了的类中直接替换掉原有的方法，是在原来类的基础上进行修改的。因而无法实现对原有类进行方法和字段的增减，因为这样将破坏原有类的结构。    
+	一旦补丁类中出现了方法的增加和减少，就会导致这个类以及整个dex的方法数的变化，方法数的变化伴随着方法索引的变化，这样在
+	访问方法时就无法正常的索引到正确的方法了。如果字段发生了增加或减少，和方法变化的情况一样，所有字段的索引都会发生变化。
+	而新方法中使用到这些老的示例对象时，访问新增字段就会会产生不可预期的结果。   
+
+	这是该类方案的固有限制，而底层替换方案最为人逅病的地方，在于底层替换的不稳定性。因为Hook方案，都是直接依赖修改虚拟机方法实体的具体字段。因为Art虚拟机和Dalvik虚拟机的不同，每个版本的虚拟机都要适配，而且Android系统是开源的，各个厂商都可以对代码进行改造，如果某个厂商进行了修改，那么这种通用性的替换机制就会出问题。这便是不稳定的根源。   
+
+
+
+- 腾讯系的类加载方案:类加载方案时效性差，需要重新冷启动才能见效，但修复范围广、限制少。   
+
+类加载方案的原理是在app重新启动后让classloader去加载新的类。因为在app运行到一半的时候，所有需要发生变更的类已经被加载过了，在Android上是无法对一个类进行卸载的。如果不重启，原来的类还在虚拟机中，就无法加载新类，因此只有在下次重启的时候，
+在还没走到业务逻辑之前抢先加载补丁中的新类，这样后续访问这个类的时候，就会用新类，从而达到热修复的目的。   
+
+
+为什么sophix更好?
+---
+
+既然底层替换方案和类加载方案各有优点，把他们联合起来就是最好的选择。Sophix就是同时涵盖了这两种方案，可以实现优势互补、完全兼顾的作用，可以灵活的根据实际情况自动切换。    
+
+
+
+
+
+
+但是[Sophix](https://help.aliyun.com/document_detail/57064.html?spm=a2c4g.11186623.6.543.SPhMhO)有一个缺点就是，他不是开源的，而且是收费的。但是确实强大。
+
+
+
+
+- [Google Instant app](https://developer.android.com/topic/instant-apps/index.html)
+- [微信热补丁实现](https://github.com/WeMobileDev/article/blob/master/%E5%BE%AE%E4%BF%A1Android%E7%83%AD%E8%A1%A5%E4%B8%81%E5%AE%9E%E8%B7%B5%E6%BC%94%E8%BF%9B%E4%B9%8B%E8%B7%AF.md#rd)
+- [多dex分拆](http://my.oschina.net/853294317/blog/308583)
+- [QQ空间热修复方案](https://mp.weixin.qq.com/s?__biz=MzI1MTA1MzM2Nw==&mid=400118620&idx=1&sn=b4fdd5055731290eef12ad0d17f39d4a)
+- [Android dex分包方案](http://my.oschina.net/853294317/blog/308583)
+- [类加载器DexClassLoader](http://www.maplejaw.com/2016/05/24/Android%E6%8F%92%E4%BB%B6%E5%8C%96%E6%8E%A2%E7%B4%A2%EF%BC%88%E4%B8%80%EF%BC%89%E7%B1%BB%E5%8A%A0%E8%BD%BD%E5%99%A8DexClassLoader/)
+- [基于cydia Hook在线热修复补丁方案](http://blog.csdn.net/xwl198937/article/details/49801975)
+- [Android 热补丁动态修复框架小结](http://blog.csdn.net/lmj623565791/article/details/49883661)
+- [美团Android DEX自动拆包及动态加载简介](http://tech.meituan.com/mt-android-auto-split-dex.html)
+- [插件化从放弃到捡起](http://kymjs.com/column/plugin.html)
+- [无需Root也能使用Xposed！](http://weishu.me/)
+- [当你准备开发一个热修复框架的时候，你需要了解的一切](http://www.zjutkz.net/2016/05/23/%E5%BD%93%E4%BD%A0%E5%87%86%E5%A4%87%E5%BC%80%E5%8F%91%E4%B8%80%E4%B8%AA%E7%83%AD%E4%BF%AE%E5%A4%8D%E6%A1%86%E6%9E%B6%E7%9A%84%E6%97%B6%E5%80%99%EF%BC%8C%E4%BD%A0%E9%9C%80%E8%A6%81%E4%BA%86%E8%A7%A3%E7%9A%84%E4%B8%80%E5%88%87/)		
+
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/InstantRun%E8%AF%A6%E8%A7%A3.md "InstantRun详解"
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/AdavancedPart/3.\347\203\255\344\277\256\345\244\215_addAssetPath\344\270\215\345\220\214\347\211\210\346\234\254\345\214\272\345\210\253\345\216\237\345\233\240(\344\270\211).md" "b/AdavancedPart/3.\347\203\255\344\277\256\345\244\215_addAssetPath\344\270\215\345\220\214\347\211\210\346\234\254\345\214\272\345\210\253\345\216\237\345\233\240(\344\270\211).md"
new file mode 100644
index 00000000..4da9dd5c
--- /dev/null
+++ "b/AdavancedPart/3.\347\203\255\344\277\256\345\244\215_addAssetPath\344\270\215\345\220\214\347\211\210\346\234\254\345\214\272\345\210\253\345\216\237\345\233\240(\344\270\211).md"
@@ -0,0 +1,395 @@
+在做热修复功能时Java层通过反射调用addAssetPath在Android5.0及以上系统没有问题，在Android 4.x版本找不到资源。 
+
+addAssetPath方法:   
+```java
+/**
+ * Add an additional set of assets to the asset manager.  This can be
+ * either a directory or ZIP file.  Not for use by applications.  Returns
+ * the cookie of the added asset, or 0 on failure.
+ * {@hide}
+ */
+public final int addAssetPath(String path) {
+    int res = addAssetPathNative(path);
+    return res;
+}
+private native final int addAssetPathNative(String path);
+```
+
+addAssetPath具体的实现方法是native层的。
+
+[AssetManager.cpp源码](https://android.googlesource.com/platform/frameworks/base/+/android-4.4_r1.0.1/libs/androidfw/AssetManager.cpp)
+
+4.4及以前的版本调用addAssetPath方法时，只是把补丁包的路径添加到mAssetPath中，不会去重新解析，真正解析的代码是在app第一次执行AssetManager.getResTable()`方法的时候。
+一旦解析完一次后，mResource对象就不为nil，以后就会直接return掉，不会重新解析。  
+
+```c
+bool AssetManager::addAssetPath(const String8& path, void** cookie)
+{
+    AutoMutex _l(mLock);
+    asset_path ap;
+    String8 realPath(path);
+    if (kAppZipName) {
+        realPath.appendPath(kAppZipName);
+    }
+    ap.type = ::getFileType(realPath.string());
+    if (ap.type == kFileTypeRegular) {
+        ap.path = realPath;
+    } else {
+        ap.path = path;
+        ap.type = ::getFileType(path.string());
+        if (ap.type != kFileTypeDirectory && ap.type != kFileTypeRegular) {
+            ALOGW("Asset path %s is neither a directory nor file (type=%d).",
+                 path.string(), (int)ap.type);
+            return false;
+        }
+    }
+    // Skip if we have it already.
+    for (size_t i=0; i<mAssetPaths.size(); i++) {
+        if (mAssetPaths[i].path == ap.path) {
+            if (cookie) {
+                *cookie = (void*)(i+1);
+            }
+            return true;
+        }
+    }
+    ALOGV("In %p Asset %s path: %s", this,
+         ap.type == kFileTypeDirectory ? "dir" : "zip", ap.path.string());
+    mAssetPaths.add(ap);
+    // new paths are always added at the end
+    if (cookie) {
+        *cookie = (void*)mAssetPaths.size();
+    }
+    // add overlay packages for /system/framework; apps are handled by the
+    // (Java) package manager
+    if (strncmp(path.string(), "/system/framework/", 18) == 0) {
+        // When there is an environment variable for /vendor, this
+        // should be changed to something similar to how ANDROID_ROOT
+        // and ANDROID_DATA are used in this file.
+        String8 overlayPath("/vendor/overlay/framework/");
+        overlayPath.append(path.getPathLeaf());
+        if (TEMP_FAILURE_RETRY(access(overlayPath.string(), R_OK)) == 0) {
+            asset_path oap;
+            oap.path = overlayPath;
+            oap.type = ::getFileType(overlayPath.string());
+            bool addOverlay = (oap.type == kFileTypeRegular); // only .apks supported as overlay
+            if (addOverlay) {
+                oap.idmap = idmapPathForPackagePath(overlayPath);
+                if (isIdmapStaleLocked(ap.path, oap.path, oap.idmap)) {
+                    addOverlay = createIdmapFileLocked(ap.path, oap.path, oap.idmap);
+                }
+            }
+            if (addOverlay) {
+                mAssetPaths.add(oap);
+            } else {
+                ALOGW("failed to add overlay package %s\n", overlayPath.string());
+            }
+        }
+    }
+    return true;
+}
+```
+
+```c
+const ResTable* AssetManager::getResTable(bool required) const
+{
+    // 执行该方法第一次之后，就都会return
+    ResTable* rt = mResources;
+    if (rt) {
+        return rt;
+    }
+    // Iterate through all asset packages, collecting resources from each.
+    AutoMutex _l(mLock);
+    if (mResources != NULL) {
+        return mResources;
+    }
+    if (required) {
+        LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");
+    }
+    if (mCacheMode != CACHE_OFF && !mCacheValid)
+        const_cast<AssetManager*>(this)->loadFileNameCacheLocked();
+    const size_t N = mAssetPaths.size();
+    // 真正解析package的地方
+    for (size_t i=0; i<N; i++) {
+        Asset* ass = NULL;
+        ResTable* sharedRes = NULL;
+        bool shared = true;
+        const asset_path& ap = mAssetPaths.itemAt(i);
+        MY_TRACE_BEGIN(ap.path.string());
+        Asset* idmap = openIdmapLocked(ap);
+        ALOGV("Looking for resource asset in '%s'\n", ap.path.string());
+        if (ap.type != kFileTypeDirectory) {
+            if (i == 0) {
+                // The first item is typically the framework resources,
+                // which we want to avoid parsing every time.
+                sharedRes = const_cast<AssetManager*>(this)->
+                    mZipSet.getZipResourceTable(ap.path);
+            }
+            if (sharedRes == NULL) {
+                ass = const_cast<AssetManager*>(this)->
+                    mZipSet.getZipResourceTableAsset(ap.path);
+                if (ass == NULL) {
+                    ALOGV("loading resource table %s\n", ap.path.string());
+                    ass = const_cast<AssetManager*>(this)->
+                        openNonAssetInPathLocked("resources.arsc",
+                                                 Asset::ACCESS_BUFFER,
+                                                 ap);
+                    if (ass != NULL && ass != kExcludedAsset) {
+                        ass = const_cast<AssetManager*>(this)->
+                            mZipSet.setZipResourceTableAsset(ap.path, ass);
+                    }
+                }
+                
+                if (i == 0 && ass != NULL) {
+                    // If this is the first resource table in the asset
+                    // manager, then we are going to cache it so that we
+                    // can quickly copy it out for others.
+                    ALOGV("Creating shared resources for %s", ap.path.string());
+                    sharedRes = new ResTable();
+                    sharedRes->add(ass, (void*)(i+1), false, idmap);
+                    sharedRes = const_cast<AssetManager*>(this)->
+                        mZipSet.setZipResourceTable(ap.path, sharedRes);
+                }
+            }
+        } else {
+            ALOGV("loading resource table %s\n", ap.path.string());
+            Asset* ass = const_cast<AssetManager*>(this)->
+                openNonAssetInPathLocked("resources.arsc",
+                                         Asset::ACCESS_BUFFER,
+                                         ap);
+            shared = false;
+        }
+        if ((ass != NULL || sharedRes != NULL) && ass != kExcludedAsset) {
+            if (rt == NULL) {
+                mResources = rt = new ResTable();
+                updateResourceParamsLocked();
+            }
+            ALOGV("Installing resource asset %p in to table %p\n", ass, mResources);
+            if (sharedRes != NULL) {
+                ALOGV("Copying existing resources for %s", ap.path.string());
+                rt->add(sharedRes);
+            } else {
+                ALOGV("Parsing resources for %s", ap.path.string());
+                rt->add(ass, (void*)(i+1), !shared, idmap);
+            }
+            if (!shared) {
+                delete ass;
+            }
+        }
+        if (idmap != NULL) {
+            delete idmap;
+        }
+        MY_TRACE_END();
+    }
+    if (required && !rt) ALOGW("Unable to find resources file resources.arsc");
+    if (!rt) {
+        mResources = rt = new ResTable();
+    }
+    return rt;
+}
+
+
+const ResTable& AssetManager::getResources(bool required) const
+{
+    const ResTable* rt = getResTable(required);
+    return *rt;
+}
+```
+而当我们执行加载补丁的代码的时候，getResTable已经执行过多次了，Android Framework里面的代码会多次调用该方法。所以即使是使用addAssetPath，也只是添加到了mAssetPath，并不会发生解析，所以补丁包里面的资源就是完全不生效的。 
+
+而在android 5.0及以上的代码中:   
+
+[Android 5.0 AssetManager.cpp源码](https://android.googlesource.com/platform/frameworks/base/+/android-5.0.0_r7/libs/androidfw/AssetManager.cpp)
+
+```c
+bool AssetManager::addAssetPath(const String8& path, int32_t* cookie)
+{
+    AutoMutex _l(mLock);
+    asset_path ap;
+    String8 realPath(path);
+    if (kAppZipName) {
+        realPath.appendPath(kAppZipName);
+    }
+    ap.type = ::getFileType(realPath.string());
+    if (ap.type == kFileTypeRegular) {
+        ap.path = realPath;
+    } else {
+        ap.path = path;
+        ap.type = ::getFileType(path.string());
+        if (ap.type != kFileTypeDirectory && ap.type != kFileTypeRegular) {
+            ALOGW("Asset path %s is neither a directory nor file (type=%d).",
+                 path.string(), (int)ap.type);
+            return false;
+        }
+    }
+    // Skip if we have it already.
+    for (size_t i=0; i<mAssetPaths.size(); i++) {
+        if (mAssetPaths[i].path == ap.path) {
+            if (cookie) {
+                *cookie = static_cast<int32_t>(i+1);
+            }
+            return true;
+        }
+    }
+    ALOGV("In %p Asset %s path: %s", this,
+         ap.type == kFileTypeDirectory ? "dir" : "zip", ap.path.string());
+    // Check that the path has an AndroidManifest.xml
+    Asset* manifestAsset = const_cast<AssetManager*>(this)->openNonAssetInPathLocked(
+            kAndroidManifest, Asset::ACCESS_BUFFER, ap);
+    if (manifestAsset == NULL) {
+        // This asset path does not contain any resources.
+        delete manifestAsset;
+        return false;
+    }
+    delete manifestAsset;
+    mAssetPaths.add(ap);
+    // new paths are always added at the end
+    if (cookie) {
+        *cookie = static_cast<int32_t>(mAssetPaths.size());
+    }
+#ifdef HAVE_ANDROID_OS
+    // Load overlays, if any
+    asset_path oap;
+    for (size_t idx = 0; mZipSet.getOverlay(ap.path, idx, &oap); idx++) {
+        mAssetPaths.add(oap);
+    }
+#endif
+    if (mResources != NULL) {
+    // 重新调用该方法去解析package
+        appendPathToResTable(ap);
+    }
+    return true;
+}
+```
+
+```c
+bool AssetManager::appendPathToResTable(const asset_path& ap) const {
+    Asset* ass = NULL;
+    ResTable* sharedRes = NULL;
+    bool shared = true;
+    bool onlyEmptyResources = true;
+    MY_TRACE_BEGIN(ap.path.string());
+    Asset* idmap = openIdmapLocked(ap);
+    size_t nextEntryIdx = mResources->getTableCount();
+    ALOGV("Looking for resource asset in '%s'\n", ap.path.string());
+    if (ap.type != kFileTypeDirectory) {
+        if (nextEntryIdx == 0) {
+            // The first item is typically the framework resources,
+            // which we want to avoid parsing every time.
+            sharedRes = const_cast<AssetManager*>(this)->
+                mZipSet.getZipResourceTable(ap.path);
+            if (sharedRes != NULL) {
+                // skip ahead the number of system overlay packages preloaded
+                nextEntryIdx = sharedRes->getTableCount();
+            }
+        }
+        if (sharedRes == NULL) {
+            ass = const_cast<AssetManager*>(this)->
+                mZipSet.getZipResourceTableAsset(ap.path);
+            if (ass == NULL) {
+                ALOGV("loading resource table %s\n", ap.path.string());
+                ass = const_cast<AssetManager*>(this)->
+                    openNonAssetInPathLocked("resources.arsc",
+                                             Asset::ACCESS_BUFFER,
+                                             ap);
+                if (ass != NULL && ass != kExcludedAsset) {
+                    ass = const_cast<AssetManager*>(this)->
+                        mZipSet.setZipResourceTableAsset(ap.path, ass);
+                }
+            }
+            
+            if (nextEntryIdx == 0 && ass != NULL) {
+                // If this is the first resource table in the asset
+                // manager, then we are going to cache it so that we
+                // can quickly copy it out for others.
+                ALOGV("Creating shared resources for %s", ap.path.string());
+                sharedRes = new ResTable();
+                sharedRes->add(ass, idmap, nextEntryIdx + 1, false);
+#ifdef HAVE_ANDROID_OS
+                const char* data = getenv("ANDROID_DATA");
+                LOG_ALWAYS_FATAL_IF(data == NULL, "ANDROID_DATA not set");
+                String8 overlaysListPath(data);
+                overlaysListPath.appendPath(kResourceCache);
+                overlaysListPath.appendPath("overlays.list");
+                addSystemOverlays(overlaysListPath.string(), ap.path, sharedRes, nextEntryIdx);
+#endif
+                sharedRes = const_cast<AssetManager*>(this)->
+                    mZipSet.setZipResourceTable(ap.path, sharedRes);
+            }
+        }
+    } else {
+        ALOGV("loading resource table %s\n", ap.path.string());
+        ass = const_cast<AssetManager*>(this)->
+            openNonAssetInPathLocked("resources.arsc",
+                                     Asset::ACCESS_BUFFER,
+                                     ap);
+        shared = false;
+    }
+    if ((ass != NULL || sharedRes != NULL) && ass != kExcludedAsset) {
+        ALOGV("Installing resource asset %p in to table %p\n", ass, mResources);
+        if (sharedRes != NULL) {
+            ALOGV("Copying existing resources for %s", ap.path.string());
+            mResources->add(sharedRes);
+        } else {
+            ALOGV("Parsing resources for %s", ap.path.string());
+            mResources->add(ass, idmap, nextEntryIdx + 1, !shared);
+        }
+        onlyEmptyResources = false;
+        if (!shared) {
+            delete ass;
+        }
+    } else {
+        ALOGV("Installing empty resources in to table %p\n", mResources);
+        mResources->addEmpty(nextEntryIdx + 1);
+    }
+    if (idmap != NULL) {
+        delete idmap;
+    }
+    MY_TRACE_END();
+    return onlyEmptyResources;
+}
+const ResTable* AssetManager::getResTable(bool required) const
+{
+    ResTable* rt = mResources;
+    if (rt) {
+        return rt;
+    }
+    // Iterate through all asset packages, collecting resources from each.
+    AutoMutex _l(mLock);
+    if (mResources != NULL) {
+        return mResources;
+    }
+    if (required) {
+        LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");
+    }
+    if (mCacheMode != CACHE_OFF && !mCacheValid) {
+        const_cast<AssetManager*>(this)->loadFileNameCacheLocked();
+    }
+    mResources = new ResTable();
+    updateResourceParamsLocked();
+    bool onlyEmptyResources = true;
+    const size_t N = mAssetPaths.size();
+    // 也是调用appendPathToResTable去解析
+    for (size_t i=0; i<N; i++) {
+        bool empty = appendPathToResTable(mAssetPaths.itemAt(i));
+        onlyEmptyResources = onlyEmptyResources && empty;
+    }
+    if (required && onlyEmptyResources) {
+        ALOGW("Unable to find resources file resources.arsc");
+        delete mResources;
+        mResources = NULL;
+    }
+    return mResources;
+}
+```
+
+也就是说在Android5.0及以上的系统中native层的addAssetPath方法会再调用appendPathToResTable去解析，所以在5.0及以上系统通过反射调用addAssetPath方法就不会有问题。
+
+解决方案就是根据Google [Instant Run](https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/InstantRun%E8%AF%A6%E8%A7%A3.md)实现的原理:创建一个新的AssetManager，然后加入完整的新资源包，替换掉原有的AssetManager。
+
+具体可参考:[深度理解Android InstantRun原理以及源码分析](https://blog.csdn.net/nupt123456789/article/details/51828701)中的`2.2 monkeyPatchExistingResources`部分
+
+
+
+通过aapt工具编译apk包，package id是0x7f，系统的资源包(framework-res.jar)，package id为0x01，如果addAssetPath补丁包中的package id也是0x7f，就会使得同一个pakcage id的包被加载两次，在Android L后，会把后来的包添加到之前的包的同一个PackageGoup下，但是在get资源时，会从前往后便利，也就是说先得到原有安装包里的资源，补丁中的资源就永远无法生效。可以构建一个package id为0x66的资源包。这样就不会与已经加载的0x7f冲突。
+
+
diff --git a/AdavancedPart/AOP.md b/AdavancedPart/AOP.md
new file mode 100644
index 00000000..53c518aa
--- /dev/null
+++ b/AdavancedPart/AOP.md
@@ -0,0 +1,51 @@
+AOP
+---
+
+
+AOP(Aspect Oriented Programing),面向切面编程。
+是OOP(Object Oriented Programing)面向对象编程的延续。
+
+在OOP思想中，我们会把问题划分为各个模块，如语言、表情等。     
+在划分这些模块的过程中，也会出现一些共同特征(如埋点)。它的逻辑被分散到了各个模块，导致了代码复杂度提高，可复用性降低。
+
+而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/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/AdavancedPart/Android WorkManager.md b/AdavancedPart/Android WorkManager.md
new file mode 100644
index 00000000..17f51c57
--- /dev/null
+++ b/AdavancedPart/Android WorkManager.md	
@@ -0,0 +1,173 @@
+Android WorkManager
+===
+
+谷歌在今年的`Google I/O`上宣布了一项非常令人兴奋的功能，该功能允许开发人员执行传统上需要详细了解各种API级别和可用于这些API的后台任务库的后台任务(简单点说就是”管理一些要在后台工作的任务, – 即使你的应用没启动也能保证任务能被执行”)，这就是[WorkManager](https://developer.android.com/reference/androidx/work/WorkManager),`WorkManager`提供了从其他`API`（例如`JobScheduler`，`Firebase.JobDispatcher`，`AlarmManager`和`Services`）中获得的功能，而无需研究哪种`API`可用于您的设备或`API`。
+
+这句话是什么意思？既然能用`JobScheduler`和`AlarmManager`等，何必再出来个`WorkManager`呢？其实`WorkManager`在底层也是看你是什么版本来选到底是`JobScheduler`,`AlamarManager`来做。 
+`JobScheduler`是在`SDK`21中才有的，而且在`SDK`21中还有`Bug`，稳定可用是从`SDK`23开始的. 而`AlarmManager`一直存在，但是`AlarmManager`也不是最好的选择，
+注意：如果您的应用程序的目标是`API`级别26或更高，则当应用程序本身不在前台时，系统会对运行后台服务施加限制。在大多数情况下，您的应用程序应该使用预定作业。所以`WorkManager`在底层, 会根据你的设备情况, 选用`JobScheduler`,`Firebase`的`JobDispatcher`,或是`AlarmManager`。
+
+
+`WorkManager`,它在应用被杀, 甚至设备重启后仍能保证你安排给他的任务能得到执行。那这样我们以后是不是可以把后台任务都用它来实现了?其实`Google`自己也说了:`WorkManager`并不是为了那种在应用内的后台线程而设计出来的. 这种需求你应该使用`ThreadPool`。
+
+具体的规则如下:   
+
+`WorkManager`根据以下标准在可用时使用对应的底层工作服务:    
+
+- 在`API 23+`使用`JobScheduler`
+- 在`API 14-22`中    
+    - 如果在应用中使用了`Firebase JobDispatcher`并且有可选的`Firebase`依赖项就使用`Firebase JobDispatcher`
+    - 否则使用自定义的`AlarmManager + BroadcastReceiver`的实现方式
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/workmanager.png)
+
+
+
+
+组成部分:   
+
+- `WorkManager`:通过对应的参数来接受`work`并排队执行`work`。
+- `Worker`:通过实现`doWork()`方法来指定在后台执行的具体功能。
+- `WorkRequest`:代表一个独立的任务。它会告诉你哪个`worker`加入了，以及它需要满足哪些约束才能运行。`WorkRequest`是一个抽象类，您将使用[OneTimeWorkRequest](https://developer.android.com/reference/androidx/work/OneTimeWorkRequest)或[PeriodicWorkRequest](https://developer.android.com/reference/androidx/work/PeriodicWorkRequest)。
+- `WorkStatus`:为每个WorkRequest对象提供数据。
+
+
+
+好了下面开始演示:  
+
+首先加入依赖:   
+
+```
+dependencies {
+    def work_version = "1.0.0-alpha02"
+    implementation "android.arch.work:work-runtime:$work_version"
+}
+```
+
+- 继承`Worker`类并实现`doWork()`方法
+
+```kotlin
+class MineWorker : Worker() {
+    override fun doWork(): WorkerResult {
+        Log.e("@@@", "dang dang dang !!!")
+        return WorkerResult.SUCCESS
+    }
+}
+```
+
+- 接下来如果想要该`Worker`执行，需要调用`WorkManager`将该`Worker`添加到队列中
+
+```kotlin
+class MainActivity : AppCompatActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+
+        val workRequest = OneTimeWorkRequest.Builder(MineWorker::class.java).build()
+        val instance = WorkManager.getInstance()
+        instance.enqueue(workRequest)
+
+    }
+}
+```
+
+好了，执行下:  
+```
+05-29 12:15:51.066 6360-6406/com.charon.workmanagerdemo E/@@@: dang dang dang !!!
+```
+
+并没什么卵用，因为这个示例代码就上来就执行一次。 很显然这个不合理啊，我想给该`worker`添加一些限制条件，例如我想在手机充电时，并且有网的情况下执行某个任务，
+而且我想让它执行多次，这里可以通过`Constraints`来限制:   
+
+```kotlin
+override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    setContentView(R.layout.activity_main)
+
+    val constraints = Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .setRequiresCharging(true)
+            .build()
+
+    val workRequest = OneTimeWorkRequest.Builder(MineWorker::class.java)
+            .setConstraints(constraints).build()
+
+    val instance = WorkManager.getInstance()
+    instance.enqueue(workRequest)
+}
+```
+我们把手机网络关掉运行下，这次运行后并没有`log`打印。那现在把网络打开:   
+
+```
+05-29 12:21:02.061 7092-7241/? E/@@@: dang dang dang !!!
+```
+
+
+当然我们可以获取每个请求的状态，以及取消该请求:   
+```kotlin
+val statusById: LiveData<WorkStatus> = instance.getStatusById(workRequest.id)
+instance.cancelWorkById(workRequest.id)
+```
+如果想要顺序的去执行不同的`OneTimeWorker`也是很方便的:  
+```kotlin
+WorkContinuation chain1 = WorkManager.getInstance()
+    .beginWith(workA)
+    .then(workB);
+WorkContinuation chain2 = WorkManager.getInstance()
+    .beginWith(workC)
+    .then(workD);
+WorkContinuation chain3 = WorkContinuation
+    .combine(chain1, chain2)
+    .then(workE);
+chain3.enqueue();
+```
+
+上面都是用了`OneTimeWorkRequest`，如果你想定期的去执行某一个`worker`的话，可以使用`PeriodicWorkRequest`:   
+```kotlin
+val workRequest = PeriodicWorkRequest.Builder(MineWorker::class.java, 3, TimeUnit.SECONDS)
+        .setConstraints(constraints)
+        .setInputData(data)
+        .build()
+```
+
+但是我使用这个定期任务执行的时候也只是执行了一次，并没有像上面的代码中那样3秒执行一次，什么鬼？ 
+我们看看`PeriodicWorkRequest`的源码:    
+
+```kotlin
+/**
+ * A class that represents a request for repeating work.
+ */
+
+public final class PeriodicWorkRequest extends WorkRequest {
+
+    /**
+     * The minimum interval duration for {@link PeriodicWorkRequest}, in milliseconds.
+     * Based on {@see https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/app/job/JobInfo.java#110}.
+     */
+    public static final long MIN_PERIODIC_INTERVAL_MILLIS = 15 * 60 * 1000L; // 15 minutes.
+```
+
+上面说的很明白，最小间隔15分钟，- -！
+
+
+总体来说,`WorkManager`并不是要取代线程池`AsyncTask/RxJava`.反而是像`AlarmManager`来做定时任务的意思.即保证你给它的任务能完成, 即使你的应用都没有被打开, 或是设备重启后也能让你的任务被执行.`WorkManager`在设计上设计得比较好.没有把`worker`,任务混为一谈,而是把它们解耦成`Worker`,`WorkRequest`.这样分层就清晰多了, 也好扩展.
+
+
+到了这里突然有了一个大胆的想法。看到没有它能保证任务的执行。
+我们之前写过一篇文章[Android卸载反馈](https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Android%E5%8D%B8%E8%BD%BD%E5%8F%8D%E9%A6%88.md)
+里面用到了`c`中的`fork`来保证存活，达到常驻内存的功能，如果`PeriodicWorkRequest`的最小间隔时间比较短不是15分钟的话，那这里是不是也可以用`WorkManager`来实现？ 好了，不说了。
+
+
+
+参考:   
+
+- [官方文档](https://developer.android.com/topic/libraries/architecture/workmanager)
+- [Codelabs android-workmanager](https://codelabs.developers.google.com/codelabs/android-workmanager/#0)
+- [示例代码](https://github.com/googlecodelabs/android-workmanager)
+		
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/AdavancedPart/Android6.0\346\235\203\351\231\220\347\263\273\347\273\237.md" "b/AdavancedPart/Android6.0\346\235\203\351\231\220\347\263\273\347\273\237.md"
new file mode 100644
index 00000000..d7f32de9
--- /dev/null
+++ "b/AdavancedPart/Android6.0\346\235\203\351\231\220\347\263\273\347\273\237.md"
@@ -0,0 +1,603 @@
+Android6.0权限系统
+===
+
+`Android`权限系统是一个非常重要的安全问题，因为它只有在安装时会询问一次。一旦软件本安装之后，应用程序可以在用户毫不知情的情况下使用这些权限来获取所有的内容。     
+
+很多坏蛋会通过这个安全缺陷来收集用户的个人信息并使用它们来做坏事的情况就不足为奇了。    
+
+`Android`团队也意识到了这个问题。在经过了7年后，权限系统终于被重新设置了。从`Anroid 6.0(API Level 23)`开始，应用程序在安装时不会被授予任何权限，取而代之的是在运行时应用回去请求用户授予对应的权限。这样可以让用户能更好的去控制应用功能。例如，一个用户可能会同一个拍照应用使用摄像头的权限，但是不同授权它获取设备位置的权限。用户可以在任何时候通过去应用的设置页面来撤销授权。    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/runtimepermission.jpg?raw=true)  
+
+注意:上面请求权限的对话框不会自动弹出。开发者需要手动的调用。如果开发者调用了一些需要权限的功能，但是用户又拒绝授权的话，应用就会`crash`。   
+
+系统权限被分为两类，`normal`和`dangerous`:    
+
+- `Normal Permissions`不需要用户直接授权，如果你的应用在清单文件中声明了`Normal Permissions`，系统会自动授权该权限。    
+- `Dangerous Permissions`可以让应用获取用户的私人数据。如果你的应用在清单文件中申请了`Dangerous Permissions`，那就必须要用户来授权给应用。   
+
+`Normal Permissions`:    
+`Normal Permission`是当用户安装或更新应用时，系统将授予应用所请求的权限，又称为`PROTECTION_NORMAL`（安装时授权的一类基本权限）。该类权限只需要在`manifest`文件中声明即可，安装时就授权，不需要每次使用时进行检查，而且用户不能取消以上授权。   
+
+
+- ACCESS_LOCATION_EXTRA_COMMANDS
+- ACCESS_NETWORK_STATE
+- ACCESS_NOTIFICATION_POLICY
+- ACCESS_WIFI_STATE
+- BLUETOOTH
+- BLUETOOTH_ADMIN
+- BROADCAST_STICKY
+- CHANGE_NETWORK_STATE
+- CHANGE_WIFI_MULTICAST_STATE
+- CHANGE_WIFI_STATE
+- DISABLE_KEYGUARD
+- EXPAND_STATUS_BAR
+- GET_PACKAGE_SIZE
+- INSTALL_SHORTCUT
+- INTERNET
+- KILL_BACKGROUND_PROCESSES
+- MODIFY_AUDIO_SETTINGS
+- NFC
+- READ_SYNC_SETTINGS
+- READ_SYNC_STATS
+- RECEIVE_BOOT_COMPLETED
+- REORDER_TASKS
+- REQUEST_IGNORE_BATTERY_OPTIMIZATIONS
+- REQUEST_INSTALL_PACKAGES
+- SET_ALARM
+- SET_TIME_ZONE
+- SET_WALLPAPER
+- SET_WALLPAPER_HINTS
+- TRANSMIT_IR
+- UNINSTALL_SHORTCUT
+- USE_FINGERPRINT
+- VIBRATE
+- WAKE_LOCK
+- WRITE_SYNC_SETTINGS
+
+
+
+下图为`Dangerous permissions and permission groups`:  
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/permgroup.png?raw=true)     
+
+
+在所有的`Android`版本中，你的应用都需要在`manifest`文件中声明`normal`和`dangerous`权限。然而声明所影响的效果会因系统版本和你应用的`target SDK lever`有关:     
+
+- 如果设备运行的是`Android 5.1`或者之前的系统，或者应用的`targetSdkVersion`是22或者之前版本：如果你在`manifest`中声明了`dangerous permission`，用户需要在安装应用时授权这些权限。如果用户不授权这些权限，系统就不会安装该应用。(我试了下发现即使`targetSdkVersion`是22及以下，在6.0的手机上时，如果你安装时你不同意一些权限，也仍然可以安装的)  
+- 如果设备运行的是`Android 6.0`或者更高的系统，并且你应用的`targetSdkVersion`是23或者更高:应用必须在`manifest`文件中申请这些权限，而且必须要在运行时对所需要的`dangerous permission`申请授权。用户可以统一或者拒绝授权，并且及时用户拒绝了授权，应用在无法使用一些功能的情况下也要保证能继续运行。     
+
+也就是说新的运行时权限仅当我们设置`targetSdkVersion`是23及以上时才会起作用。      
+如果你的`targtSdkVersion`低于23，那将被认为该应用没有经过`android 6.0`的测试，当该应用被安装到了6.0的手机上时，仍然会使用之前的旧权限规则，在安装时会提示所有需要的权限(这样做是有道理的，不然对于之前开发的应用，我们都要立马去修改让它适应6.0，来不及的话就导致6.0的手机都无法使用了，显然Android开发团队不会考虑不到这种情况)，当然用户可以在安装的界面不允许一些权限，那当程序使用到了这些权限时，会崩溃吗？答案是在`Android 6.0`及以上的手机会直接`crash`，但是在`23`之前的手机上不会`crash`。     
+
+所以如果你的应用没有支持运行时权限的功能，那千万不要讲`targetSdkVersion`设置为23，否则就麻烦了。  
+
+> 注意:从`Android 6.0(API Level 23)`开始，即使应用的`targetSdkVersion`是比较低的版本，但是用户仍然可以在任何时候撤销对应用的授权。所以不管应用的`targetSdkVerison`是什么版本，你都要测试你的应用在不能获取权限时能不能正常运行。 
+
+下面介绍下如何使用`Android Support Library`来检查和请求权限。`Android`框架在`6.0`开始也提供了相同的方法。然而使用`support`包会比较简单，因为这样你就不需要在请求方法时判断当前的系统版本。(后面说的这几个类都是`android.support.v4`中的)    
+
+### 检查权限    
+
+如果应用需要使用`dangerous permission`，在任何时候执行需要该权限的操作时你都需要检查是否已经授权。用户可能会经常取消授权，所以即使昨天应用已经使用了摄像头，这也不能保证今天仍然有使用摄像头的权限。    
+
+为了检查是否可以使用该权限，调用`ContextCompat.checkSelfPermission()`。   
+例如:    
+```java
+// Assume thisActivity is the current activity
+int permissionCheck = ContextCompat.checkSelfPermission(thisActivity,
+        Manifest.permission.WRITE_CALENDAR);
+```
+如果应用有该权限，该方法将返回`PackageManager.PERMISSION_GRANTED`，应用可以进行相关的操作。如果应用不能使用该权限，该方法将返回`PERMISSION_DENIED`，这是应用将必须要向用户申请该权限。    
+
+
+### 申请使用权限
+
+如果应用需要使用清单文件中申明的`dangerous permission`，它必须要向用户申请来授权。`Android`提供了几种申请授权的方法。使用这些方法时将会弹出一个标准的系统对话框，该对话框不能自定义。     
+
+##### 说明为什么应用需要使用这些权限      
+
+在一些情况下，你可能需要帮助用力理解为什么需要该权限。例如，一个用户使用了一个照相的应用，用户不会奇怪为什么应用申请使用摄像头的权限，但是用户可能会不理解为什么应用需要获取位置或者联系人的权限。在请求一个权限之前，你需要该用户一个说明。一定要切记不要通过说明来压倒用户。如果你提供了太多的说明，用户可能会感觉沮丧并且会卸载它。   
+
+一个你需要提供说明的合适时机就是在用户之前已经不同意授权该权限的情况下。如果一个用户继续尝试使用需要权限的功能时，但是之前确禁止了该权限的请求，这就可能是因为用户不理解为什么该功能需要使用该权限。在这种情况下，提供一个说明是非常合适的。  
+
+为了能找到用户可能需要说明的情况，`android`提供了一个工具类方法`ActivityCompat.shouldShowRequestPermissionRationale().`。如果应用之前申请了该权限但是用户拒绝授权后该方法会返回`true`。(在Android 6.0之前调用的时候会直接返回false)     
+
+> 注意:如果用户之前拒绝了权限申请并且选择了请求权限对话框中的`Don’t ask again`选项，该方法就会返回`false`。如果设备策略禁止了该应用使用该权限，该方法也会返回`false`。(我测试的时候发现请求权限的对话框中并没有`Don’t asdk again`这一项)
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/request_permission_dialog.png?raw=true" width="100%" height="100%">
+
+##### 申请需要的权限      
+
+如果应用没有所需的权限时，应用必须调用`ActivityCompat.requestPermissions (Activity activity, 
+                String[] permissions, 
+                int requestCode)`方法来申请对用的权限。参数传递对应所需的权限以及一个整数型的`request code`来标记该权限申请。 该方法是异步的:该方法会立即返回，在用户响应了请求权限的对话框之后，系统会调用对用的回调方法来通知结果，并且会传递在`reqeustPermissions()`方法中的`request code`。(在Android 6.0之前调用的时候会直接去调用`onRequestPermissionsResult()`的回调方法)         
+如图:    
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/requestpermission.jpg?raw=true)  
+
+
+下面是检查是否读取联系人权限，并且在必要时申请权限的代码:    
+
+```java
+// Here, thisActivity is the current activity
+if (ContextCompat.checkSelfPermission(thisActivity,
+                Manifest.permission.READ_CONTACTS)
+        != PackageManager.PERMISSION_GRANTED) {
+
+    // Should we show an explanation?
+    if (ActivityCompat.shouldShowRequestPermissionRationale(thisActivity,
+            Manifest.permission.READ_CONTACTS)) {
+
+        // Show an expanation to the user *asynchronously* -- don't block
+        // this thread waiting for the user's response! After the user
+        // sees the explanation, try again to request the permission.
+
+    } else {
+
+        // No explanation needed, we can request the permission.
+
+        ActivityCompat.requestPermissions(thisActivity,
+                new String[]{Manifest.permission.READ_CONTACTS},
+                MY_PERMISSIONS_REQUEST_READ_CONTACTS);
+
+        // MY_PERMISSIONS_REQUEST_READ_CONTACTS is an
+        // app-defined int constant. The callback method gets the
+        // result of the request.
+    }
+}
+```
+
+> 注意:当调用`requestPermissions()`方法时，系统会显示一个标准的对话框。应用不能指定或者改变该对话框。如果你想提供一些信息或者说明给用户，你需要在调用`requestPermissions()`之前处理。    
+
+##### 处理请求权限的的结果     
+
+如果应用申请权限，系统会显示一个对话框。当用户相应后，系统会调用应用中的`onRequestPermissionsResult (int requestCode, 
+                String[] permissions, 
+                int[] grantResults)`方法并传递用户的操作结果。在应用中必须要重写该方法来查找授权了什么权限。该回调方法会传递你在`requestPermisssions()`方法中传递的`request code`。直接在`Activity`或者`Fragment`中重写`onRequestPermissionsResult()`方法即可。例如，申请`READ_CONTACTS`的权限可能会有下面的回到方法:     
+
+```java
+@Override
+public void onRequestPermissionsResult(int requestCode,
+        String permissions[], int[] grantResults) {
+    switch (requestCode) {
+        case MY_PERMISSIONS_REQUEST_READ_CONTACTS: {
+            // If request is cancelled, the result arrays are empty.
+            if (grantResults.length > 0
+                && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+
+                // permission was granted, yay! Do the
+                // contacts-related task you need to do.
+
+            } else {
+
+                // permission denied, boo! Disable the
+                // functionality that depends on this permission.
+            }
+            return;
+        }
+
+        // other 'case' lines to check for other
+        // permissions this app might request
+    }
+}
+
+```
+
+系统提示的对话框会描述应用所需的`permission groud`。它不会列出特定的权限。例如，如果你申请了`READ_CONTACTS`权限，系统的对话框只会说你的应用需要获取设备的联系人信息。用户只需要授权每个`permission group`一次。如果你应用需要申请其他任何一个在该`permission group`中的权限时，系统会自动授权。在申请这些授权时，系统会像用户明确通过系统对话框统一授权时一样去调用`onRequestPermissionsResult()`方法并且传递`PERMISSION_GRANTED`参数。    
+
+> 注意:虽然用户已经授权了同一`permission group`中其他的任何权限，但是应用仍然需要明确申请每个需要的权限。例外，`permission group`中的权限在以后可能会发生变化。    
+
+例如，假设在应用的`manifest`文件中同时声明了`READ_CONTACTS`和`WRITE_CONTACTS`权限。如果你申请`READ_CONTACTS`权限而且用户同意了该权限，如果你想继续申请`WRITE_CONTACTS`权限，系统不会与用户有任何交互就会直接进行授权。     
+
+如果用户拒绝了一个权限申请，你的应用进行合适的处理。例如，你的应用可能显示一个对话框来表明无法执行用户请求的需要该权限的操作。
+
+如果系统向用户申请权限授权，用户选择了让系统以后不要再申请该权限。 在这种情况下，应用在任何时间调用`reqeustPermissions()`方法来再次申请权限时，系统都会直接拒绝该请求。系统会直接调用`onRequestPermissionResult()`回调方法并且传递`PERMISSION_DENIED`参数，和用户明确拒绝应用申请该权限时一样。 这就意味着在你调用`requestPermissions()`方法是，你无法确定是否会和用户有直接的交互操作。   
+
+
+示例代码:     
+```java
+
+final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124;
+  
+private void insertDummyContactWrapper() {
+    List<String> permissionsNeeded = new ArrayList<String>();
+  
+    final List<String> permissionsList = new ArrayList<String>();
+    if (!addPermission(permissionsList, Manifest.permission.ACCESS_FINE_LOCATION))
+        permissionsNeeded.add("GPS");
+    if (!addPermission(permissionsList, Manifest.permission.READ_CONTACTS))
+        permissionsNeeded.add("Read Contacts");
+    if (!addPermission(permissionsList, Manifest.permission.WRITE_CONTACTS))
+        permissionsNeeded.add("Write Contacts");
+  
+    if (permissionsList.size() > 0) {
+        if (permissionsNeeded.size() > 0) {
+            // Need Rationale
+            String message = "You need to grant access to " + permissionsNeeded.get(0);
+            for (int i = 1; i < permissionsNeeded.size(); i++)
+                message = message + ", " + permissionsNeeded.get(i);
+            showMessageOKCancel(message,
+                    new DialogInterface.OnClickListener() {
+                        @Override
+                        public void onClick(DialogInterface dialog, int which) {
+                            requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
+                                    REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS);
+                        }
+                    });
+            return;
+        }
+        requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
+                REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS);
+        return;
+    }
+  
+    insertDummyContact();
+}
+  
+private boolean addPermission(List<String> permissionsList, String permission) {
+    if (checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
+        permissionsList.add(permission);
+        // Check for Rationale Option
+        if (!shouldShowRequestPermissionRationale(permission))
+            return false;
+    }
+    return true;
+}
+```
+
+
+上面讲到的都是`Activity`中的使用方法，那`Fragment`中怎么授权呢？
+如果在`Fragment`中使用，用`v13`包中的`FragmentCompat.requestPermissions()`和`FragmentCompat.shouldShowRequestPermissionRationale()`。 
+
+
+
+在`Fragment`中申请权限，不要使用`ActivityCompat.requestPermissions`, 直接使用`Fragment.requestPermissions`方法，
+否则会回调到`Activity`的`onRequestPermissionsResult`。但是虽然你使用`Fragment.requestPermissions`方法，也照样回调不到`Fragment.onRequestPermissionsResult`中。这是`Android`的`Bug`,[详见](https://code.google.com/p/android/issues/detail?can=2&start=0&num=100&q=&colspec=ID%20Status%20Priority%20Owner%20Summary%20Stars%20Reporter%20Opened&groupby=&sort=&id=189121)，`Google`已经在`23.3.0`修复了该问题，所以要尽快升级。
+
+所以升级到`23.3.0`及以上就没问题了。如果不升级该怎么处理呢？就是在`Activity.onRequestPermissionsResult`方法中去手动调用每个`Fragment`的方法(当然你要判断下权限个数，不然申请一个权限的情况下会重复调用).    
+```java
+@Override
+public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+    List<Fragment> fragments = getSupportFragmentManager().getFragments();
+    if (fragments != null) {
+        for (Fragment fragment : fragments) {
+            fragment.onRequestPermissionsResult(requestCode, permissions, grantResults);
+        }
+    }
+}
+```
+
+我简单的写了一个工具类:    
+
+```java
+public class PermissionUtil {
+    /**
+     * 在调用需要权限的功能时使用该方法进行检查。
+     *
+     * @param activity
+     * @param requestCode
+     * @param iPermission
+     * @param permissions
+     */
+    public static void checkPermissions(Activity activity, int requestCode, IPermission iPermission, String... permissions) {
+        handleRequestPermissions(activity, requestCode, iPermission, permissions);
+    }
+
+    public static void checkPermissions(Fragment fragment, int requestCode, IPermission iPermission, String... permissions) {
+        handleRequestPermissions(fragment, requestCode, iPermission, permissions);
+    }
+
+    public static void checkPermissions(android.app.Fragment fragment, int requestCode, IPermission iPermission, String... permissions) {
+        handleRequestPermissions(fragment, requestCode, iPermission, permissions);
+    }
+
+    /**
+     * 在Actvitiy或者Fragment中重写onRequestPermissionsResult方法后调用该方法。
+     *
+     * @param activity
+     * @param requestCode
+     * @param permissions
+     * @param grantResults
+     * @param iPermission
+     */
+    public static void onRequestPermissionsResult(Activity activity, int requestCode, String[] permissions,
+                                                  int[] grantResults, IPermission iPermission) {
+        requestResult(activity, requestCode, permissions, grantResults, iPermission);
+
+    }
+
+    public static void onRequestPermissionsResult(Fragment fragment, int requestCode, String[] permissions,
+                                                  int[] grantResults, IPermission iPermission) {
+        requestResult(fragment, requestCode, permissions, grantResults, iPermission);
+    }
+
+    public static void onRequestPermissionsResult(android.app.Fragment fragment, int requestCode, String[] permissions,
+                                                  int[] grantResults, IPermission iPermission) {
+        requestResult(fragment, requestCode, permissions, grantResults, iPermission);
+    }
+
+    public static <T> void requestPermission(T t, int requestCode, String... permission) {
+        List<String> permissions = new ArrayList<>();
+        for (String s : permission) {
+            permissions.add(s);
+        }
+        requestPermissions(t, requestCode, permissions);
+    }
+
+    /**
+     * 在检查权限后自己处理权限说明的逻辑后调用该方法，直接申请权限。
+     *
+     * @param t
+     * @param requestCode
+     * @param permissions
+     * @param <T>
+     */
+    public static <T> void requestPermission(T t, int requestCode, List<String> permissions) {
+        if (permissions == null || permissions.size() == 0) {
+            return;
+        }
+        requestPermissions(t, requestCode, permissions);
+    }
+
+    public static boolean checkSelfPermission(Context context, String permission) {
+        if (context == null || TextUtils.isEmpty(permission)) {
+            throw new IllegalArgumentException("invalidate params: the params is null !");
+        }
+
+        context = context.getApplicationContext();
+
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+            int result = ContextCompat.checkSelfPermission(context, permission);
+            if (PackageManager.PERMISSION_DENIED == result) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static <T> void handleRequestPermissions(T t, int requestCode, IPermission iPermission, String... permissions) {
+        if (t == null || permissions == null || permissions.length == 0) {
+            throw new IllegalArgumentException("invalidate params");
+        }
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+            Activity activity = getActivity(t);
+            List<String> deniedPermissions = getDeniedPermissions(activity, permissions);
+            if (deniedPermissions != null && deniedPermissions.size() > 0) {
+
+                List<String> rationalPermissions = new ArrayList<>();
+                for (String deniedPermission : deniedPermissions) {
+                    if (ActivityCompat.shouldShowRequestPermissionRationale(activity,
+                            deniedPermission)) {
+                        rationalPermissions.add(deniedPermission);
+                    }
+                }
+
+                boolean showRational = false;
+                if (iPermission != null) {
+                    showRational = iPermission.showRational(requestCode);
+                }
+
+                if (rationalPermissions.size() > 0 && showRational) {
+                    if (iPermission != null) {
+                        iPermission.onRational(requestCode, deniedPermissions);
+                    }
+                } else {
+                    requestPermissions(t, requestCode, deniedPermissions);
+                }
+            } else {
+                if (iPermission != null) {
+                    iPermission.onGranted(requestCode);
+                }
+            }
+        } else {
+            if (iPermission != null) {
+                iPermission.onGranted(requestCode);
+            }
+        }
+    }
+
+    @Nullable
+    private static <T> Activity getActivity(T t) {
+        Activity activity = null;
+        if (t instanceof Activity) {
+            activity = (Activity) t;
+        } else if (t instanceof Fragment) {
+            activity = ((Fragment) t).getActivity();
+        } else if (t instanceof android.app.Fragment) {
+            activity = ((android.app.Fragment) t).getActivity();
+        }
+        return activity;
+    }
+
+    @TargetApi(Build.VERSION_CODES.M)
+    private static <T> void requestPermissions(T t, int requestCode, List<String> deniedPermissions) {
+        if (deniedPermissions == null || deniedPermissions.size() == 0) {
+            return;
+        }
+        // has denied permissions
+        if (t instanceof Activity) {
+            ((Activity) t).requestPermissions(deniedPermissions.toArray(new String[deniedPermissions.size()]), requestCode);
+        } else if (t instanceof Fragment) {
+            ((Fragment) t).requestPermissions(deniedPermissions.toArray(new String[deniedPermissions.size()]), requestCode);
+        } else if (t instanceof android.app.Fragment) {
+            ((android.app.Fragment) t).requestPermissions(deniedPermissions.toArray(new String[deniedPermissions.size()]), requestCode);
+        }
+    }
+
+    private static List<String> getDeniedPermissions(Context context, String... permissions) {
+        if (context == null || permissions == null || permissions.length == 0) {
+            return null;
+        }
+        List<String> denyPermissions = new ArrayList<>();
+        for (String permission : permissions) {
+            if (!checkSelfPermission(context, permission)) {
+                denyPermissions.add(permission);
+            }
+        }
+        return denyPermissions;
+    }
+
+
+    private static <T> void requestResult(T t, int requestCode, String[] permissions,
+                                          int[] grantResults, IPermission iPermission) {
+        List<String> deniedPermissions = new ArrayList<>();
+        for (int i = 0; i < grantResults.length; i++) {
+            if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
+                deniedPermissions.add(permissions[i]);
+            }
+        }
+        if (deniedPermissions.size() > 0) {
+            if (iPermission != null) {
+                iPermission.onDenied(requestCode);
+            }
+        } else {
+            if (iPermission != null) {
+                iPermission.onGranted(requestCode);
+            }
+        }
+    }
+
+}
+
+interface IPermission {
+    void onGranted(int requestCode);
+
+    void onDenied(int requestCode);
+
+    void onRational(int requestCode, List<String> permissions);
+
+    /**
+     * 是否需要提示用户该权限的作用，提示后需要再调用requestPermission()方法来申请。
+     *
+     * @return true 为提示，false为不提示
+     */
+    boolean showRational(int requestCode);
+}
+
+```
+
+使用方法:    
+```java
+public class MainFragment extends Fragment implements View.OnClickListener {
+    private Button mReqCameraBt;
+    private Button mReqContactsBt;
+    private Button mReqMoreBt;
+
+    @Nullable
+    @Override
+    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_main, container, false);
+        findView(view);
+        initView();
+        return view;
+    }
+
+    private void findView(View view) {
+        mReqCameraBt = (Button) view.findViewById(R.id.bt_requestCamera);
+        mReqContactsBt = (Button) view.findViewById(R.id.bt_requestContacts);
+        mReqMoreBt = (Button) view.findViewById(R.id.bt_requestMore);
+    }
+
+    private void initView() {
+        mReqCameraBt.setOnClickListener(this);
+        mReqContactsBt.setOnClickListener(this);
+        mReqMoreBt.setOnClickListener(this);
+    }
+
+
+    public static final int REQUEST_CODE_CAMERA = 0;
+    public static final int REQUEST_CODE_CONTACTS = 1;
+    public static final int REQUEST_CODE_MORE = 2;
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+        PermissionUtil.onRequestPermissionsResult(this, requestCode, permissions, grantResults, mPermission);
+    }
+
+    public void requestCamera() {
+        PermissionUtil.checkPermissions(this, REQUEST_CODE_CAMERA, mPermission, Manifest.permission.CAMERA);
+    }
+
+    public void requestReadContacts() {
+        PermissionUtil.checkPermissions(this, REQUEST_CODE_CONTACTS, mPermission, Manifest.permission.READ_CONTACTS);
+    }
+
+    public void requestMore() {
+        PermissionUtil.checkPermissions(this, REQUEST_CODE_MORE, mPermission, Manifest.permission.READ_CONTACTS, Manifest.permission.READ_CALENDAR, Manifest.permission.CALL_PHONE);
+    }
+
+    private void showPermissionTipDialog(final int requestCode, final List<String> permissions) {
+        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+        builder.setMessage("I want you permissions");
+        builder.setTitle("Hello Permission");
+        builder.setPositiveButton("确认", new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialog, int which) {
+                dialog.dismiss();
+                PermissionUtil.requestPermission(MainFragment.this, requestCode, permissions);
+            }
+        });
+        builder.setNegativeButton("取消", new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialog, int which) {
+                dialog.dismiss();
+            }
+        });
+        builder.create().show();
+    }
+
+    public IPermission mPermission = new IPermission() {
+        @Override
+        public void onGranted(int requestCode) {
+            Toast.makeText(getActivity(), "onGranted :" + requestCode, Toast.LENGTH_SHORT).show();
+        }
+
+        @Override
+        public void onDenied(int requestCode) {
+            Toast.makeText(getActivity(), "onDenied :" + requestCode, Toast.LENGTH_SHORT).show();
+        }
+
+        @Override
+        public void onRational(int requestCode, List<String> permission) {
+            showPermissionTipDialog(requestCode, permission);
+        }
+
+        @Override
+        public boolean showRational(int requestCode) {
+            switch (requestCode) {
+                case REQUEST_CODE_MORE:
+                    return true;
+
+                default:
+                    break;
+            }
+            return false;
+        }
+    };
+
+    @Override
+    public void onClick(View v) {
+        int id = v.getId();
+        switch (id) {
+            case R.id.bt_requestCamera:
+                requestCamera();
+                break;
+            case R.id.bt_requestContacts:
+                requestReadContacts();
+                break;
+            case R.id.bt_requestMore:
+                requestMore();
+                break;
+        }
+    }
+}
+
+```
+
+		
+---
+
+- 邮箱 ：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..7efca459
--- /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! 
diff --git "a/AdavancedPart/Android\345\215\270\350\275\275\345\217\215\351\246\210.md" "b/AdavancedPart/Android\345\215\270\350\275\275\345\217\215\351\246\210.md"
new file mode 100644
index 00000000..b6b73b52
--- /dev/null
+++ "b/AdavancedPart/Android\345\215\270\350\275\275\345\217\215\351\246\210.md"
@@ -0,0 +1,140 @@
+Android卸载反馈
+===
+
+最初记得是在360安全卫士中出现的，在手机上卸载他的应用之后浏览器就会弹出一个反馈页面，让用户进行反馈，感觉这种功能对于产品改进特别有帮助。
+但是仔细一想该怎么去实现却犯愁了，最开始想这也简单啊，不就是监听下自身被卸载就可以了，应该系统会有卸载的广播，可惜没有。甚至其他的一些
+方法也是不行的，因为你程序都被卸载了，你的代码怎么会执行呢？皮之不存，毛将焉附。那360是怎样实现的呢？说句真心话360做的产品还是非常有创新
+的，虽然有些时候他会损坏用户的利益，不过但从技术方面，着实让人信服。
+
+既然`Java`实现不了，那就得考虑下其他的了，自然最先想到的就是`JNI`了，可惜`C`的部分不懂，上网搜了很多资料和介绍，找得到可以通过一下方式实现:   
+- 通过`c`中的`fork`方法来复制一个子进程。复制出来的子进程在父进程被销毁后，仍然可以存在。
+    `pid_t fpid = fork()`被调用前，就一个进程执行该段代码，这条语句执行之后，就会有两个进程执行该代码，两个进程执行没有固定先后顺序，只要看
+	系统调度策略，`fork()`函数的特别之处在于调用一次会返回两次结果：   
+	    - 返回值大于0，当前是父进程。
+		- 返回0，当前是子进程。
+		- 返回小于0的负值。(出错了，可能是内存不足或者是进程数已经达到系统最大值)
+
+- `fork`出子进程后让子进程一直去监听`/data/data/packageName`是否存在，如果不存在了，那就说明程序被卸载了，但是这样一直去轮训判断肯定会浪费
+    系统资源的，当然也会更加费电，对用户来讲肯定是有损害的。所以这种技术最好也不好用，不然大家的手机以后还能了得。万恶的产品。
+
+- 得到程序被卸载之后弹出浏览器打开指定反馈页面。这就要用到`am`命令了，最早知道这个命令是在开发`TV`版的时候，遥控器找不到了，程序安装后无法
+   打开了，用该命令就不怕了，哈哈。但是在`c`中怎么执行`am`命令呢？这就要用到`execlp()`函数，该函数就是`c`中执行系统命令的函数。
+   
+
+好了，主要的内容上面都分析完了，下面上代码。
+
+- `Java`层定义`natvie`方法。   
+```java
+public class MainActivity extends Activity {
+	private static final String TAG = "@@@";
+
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		setContentView(R.layout.activity_main);
+		String packageDir = "/data/data/" + getPackageName();
+		initUninstallFeedback(packageDir, Build.VERSION.SDK_INT);
+	}
+
+	private native void initUninstallFeedback(String packagePath, int sdkVersion);
+
+	static {
+		System.loadLibrary("uninstall_feedback");
+	}
+}
+```
+
+- 创建jni目录，增加`Android.mk`以及`uninstall_feedback.c`文件。
+`Android.mk`的内容:
+
+```c
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE    := uninstall_feedback
+LOCAL_SRC_FILES := uninstall_feedback.c
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
+LOCAL_LDLIBS += -L$(SYSROOT)/usr/lib -llog
+
+include $(BUILD_SHARED_LIBRARY)
+```
+
+`uninstall_feedback.c`的实现: 
+
+```c
+/**
+ * 将Java中的String转换成c中的char字符串
+ */
+char* Jstring2CStr(JNIEnv* env, jstring jstr) {
+	char* rtn = NULL;
+	jclass clsstring = (*env)->FindClass(env, "java/lang/String"); //String
+	jstring strencode = (*env)->NewStringUTF(env, "GB2312"); // 得到一个java字符串 "GB2312"
+	jmethodID mid = (*env)->GetMethodID(env, clsstring, "getBytes",
+			"(Ljava/lang/String;)[B"); //[ String.getBytes("gb2312");
+	jbyteArray barr = (jbyteArray)(*env)->CallObjectMethod(env, jstr, mid,
+			strencode); // String .getByte("GB2312");
+	jsize alen = (*env)->GetArrayLength(env, barr); // byte数组的长度
+	jbyte* ba = (*env)->GetByteArrayElements(env, barr, JNI_FALSE);
+	if (alen > 0) {
+		rtn = (char*) malloc(alen + 1); //""
+		memcpy(rtn, ba, alen);
+		rtn[alen] = 0;
+	}
+	(*env)->ReleaseByteArrayElements(env, barr, ba, 0); //
+	return rtn;
+}
+
+void Java_com_charon_uninstallfeedback_MainActivity_initUninstallFeedback(
+		JNIEnv* env, jobject thiz, jstring packageDir, jint sdkVersion) {
+
+	char * pd = Jstring2CStr(env, packageDir);
+
+	//fork子进程，以执行轮询任务
+	pid_t pid = fork();
+
+	if (pid < 0) {
+		// fork失败了
+	} else if (pid == 0) {
+		// 可以一直采用一直判断文件是否存在的方式去判断，但是这样效率稍低，下面使用监听的方式，死循环，每个一秒判断一次，这样太浪费资源了。
+		int check = 1;
+		while (check) {
+			FILE* file = fopen(pd, "rt");
+			if (file == NULL) {
+				if (sdkVersion >= 17) {
+					// Android4.2系统之后支持多用户操作，所以得指定用户
+					execlp("am", "am", "start", "--user", "0", "-a",
+							"android.intent.action.VIEW", "-d",
+							"http://shouji.360.cn/web/uninstall/uninstall.html",
+							(char*) NULL);
+				} else {
+					// Android4.2以前的版本无需指定用户
+					execlp("am", "am", "start", "-a",
+						"android.intent.action.VIEW", "-d",
+							"http://shouji.360.cn/web/uninstall/uninstall.html",
+							(char*) NULL);
+				}
+				check = 0;
+			} else {
+			}
+			sleep(1);
+		}
+	} else {
+	}
+}
+
+```
+
+- 编译so文件。`Windows`下要用`cygwin`来操作。
+上面的介绍是在`Eclipse`中进行的，用`ndk-build`命令来编译`so`。具体请看之前写的`JNI基础`这篇文章。
+
+有关如何在[Android Stuido中进行ndk开发请看][1]。
+   		
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/AndroidStudioCourse/AndroidStudio%E4%B8%AD%E8%BF%9B%E8%A1%8Cndk%E5%BC%80%E5%8F%91.md "Android Stuido中进行ndk开发"
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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"
new file mode 100644
index 00000000..5008840f
--- /dev/null
+++ "b/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
@@ -0,0 +1,65 @@
+Android启动模式详解
+===
+
+- `standard`    
+    默认模式。在该模式下，`Activity`可以拥有多个实例，并且这些实例既可以位于同一个`task`，也可以位于不同的`task`。每次都会新创建。
+- `singleTop`        
+    该模式下，在同一个`task`中，如果存在该`Activity`的实例，并且该`Activity`实例位于栈顶则不会创建该`Activity`的示例,而仅仅只是调用`Activity`的`onNewIntent()`。否则的话，则新建该`Activity`的实例，并将其置于栈顶。
+- `singleTask`     
+    顾名思义，只容许有一个包含该`Activity`实例的`task`存在！
+    在`android`浏览器`browser`中，`BrowserActivity`的`launcherMode="singleTask"`，因为`browser`不断地启动自己，所以要求这个栈中保持只能有一个自己的实例，`browser`上网的时候，
+	遇到播放视频的链接，就会通过隐式`intent`方式跳转找`Gallery3D`中的`MovieView`这个类来播放视频，这时候如果你点击`home`键，再点击`browser`，你会发现`MovieView`这个类已经销毁不存在了，
+	而不会像保存这个`MovieView`的类对象，给客户带来的用户体验特别的不好。就像别人总结的`singleTask`模式的`Activity`不管是位于栈顶还是栈底，再次运行这个`Activity`时，都会`destory`掉它上面的`Activity`来保证整个栈中只有一个自己。                   
+    下面是官方文档中的介绍:      
+    `The system creates a new task and instantiates the activity at the root of the new task. However, if an instance of the activity already exists in a separate task, the system routes the intent to the existing 
+	instance through a call to its onNewIntent() method, rather than creating a new instance. Only one instance of the activity can exist at a time.`
+    以`singleTask`方式启动的`Activity`，全局只有唯一个实例存在，因此，当我们第一次启动这个`Activity`时，系统便会创建一个新的任务栈，并且初始化一个`Activity`实例，放在新任务栈的底部，如果下次再启动这个`Activity`时，
+	系统发现已经存在这样的`Activity`实例，就会调用这个`Activity`实例的`onNewIntent`方法，从而把它激活起来。从这句话就可以推断出，以`singleTask`方式启动的`Activity`总是属于一个任务栈的根`Activity`。
+    下面我们看一下示例图:　
+    ![image](https://github.com/CharonChui/Pictures/blob/master/singletask.gif?raw=true)          
+     坑爹啊！有木有！前面刚说`singleTask`会在新的任务中运行，并且位于任务堆栈的底部，这里在`Task B`中，一个赤裸裸的带着`singleTask`标签的箭头无情地指向`Task B`堆栈顶端的`Activity Y`，什么鬼？               
+这其实是和`taskAffinity`有关，在将要启动时，系统会根据要启动的`Activity`的`taskAffinity`属性值在系统中查找这样的一个`Task`：`Task`的`affinity`属性值与即将要启动的`Activity`的`taskAffinity`属性值一致。如果存在，
+就返回这个`Task`堆栈顶端的`Activity`回去，不重新创建任务栈了，再去启动另外一个`singletask`的`activity`时就会在跟它有相同`taskAffinity`的任务中启动，并且位于这个任务的堆栈顶端，于是，前面那个图中，
+就会出现一个带着`singleTask`标签的箭头指向一个任务堆栈顶端的`Activity Y`了。在上面的`AndroidManifest.xml`文件中，没有配置`MainActivity`和`SubActivity`的`taskAffinity`属性，
+于是它们的`taskAffinity`属性值就默认为父标签`application`的`taskAffinity`属性值，这里，标签`application`的`taskAffinity`也没有配置，于是它们就默认为包名。                               
+总的来说：`singleTask`的结论与`android:taskAffinity`相关:    　　           
+    - 设置了`singleTask`启动模式的`Activity`，它在启动的时候，会先在系统中查找属性值`affinity`等于它的属性值`taskAffinity`的任务栈的存在；如果存在这样的任务栈，它就会在这个任务栈中启动，否则就会在新任务栈中启动。
+	因此，如果我们想要设置了`singleTask`启动模式的`Activity`在新的任务栈中启动，就要为它设置一个独立的`taskAffinity`属性值。以`A`启动`B`来说当`A`和`B`的`taskAffinity`相同时：第一次创建`B`的实例时，并不会启动新的`task`，
+	而是直接将`B`添加到`A`所在的`task`；否则，将`B`所在`task`中位于`B`之上的全部`Activity`都删除，然后跳转到`B`中。
+    - 如果设置了`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`有相同之处，也有不同之处。           
+相同之处: 任意时刻，最多只允许存在一个实例。             
+不同之处:       
+
+- `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实例的问题。
+
+假设现在有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)     
+
+
+
+
+
+
+    
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/AdavancedPart/Android\345\274\200\345\217\221\344\270\215\347\224\263\350\257\267\346\235\203\351\231\220\346\235\245\344\275\277\347\224\250\345\257\271\345\272\224\345\212\237\350\203\275.md" "b/AdavancedPart/Android\345\274\200\345\217\221\344\270\215\347\224\263\350\257\267\346\235\203\351\231\220\346\235\245\344\275\277\347\224\250\345\257\271\345\272\224\345\212\237\350\203\275.md"
new file mode 100644
index 00000000..102de73a
--- /dev/null
+++ "b/AdavancedPart/Android\345\274\200\345\217\221\344\270\215\347\224\263\350\257\267\346\235\203\351\231\220\346\235\245\344\275\277\347\224\250\345\257\271\345\272\224\345\212\237\350\203\275.md"
@@ -0,0 +1,56 @@
+Android开发不申请权限来使用对应功能
+===
+
+从用户角度来说很难获取到正确的`android`权限。通常你只需要做一些很基础的事(例如编辑一个联系人)但实际你申请的权限却远远比这更强大(例如可以获取到所有的联系人明细等)。
+
+这样能很容易的理解到用户会怀疑到你的应用。如果你的应用不是开源的，那他们就没有方法来验证你会不会下载所有的联系人数据并上传到服务器。及时你去解释为什么需要这个权限，但是人们不会相信你。原来我会选择不去使用这些敏感的权限来防止用户产生不信任。(当然很多应用他们申请权限只是为了后台获取你的联系人数据上传- -!以及之前被爆的某宝使用摄像头拍照的问题)
+
+这就是说，有一件事在困扰着我，**如何能在做一些操作时不去申请权限。**
+
+打个比方说:`android.permission.CALL_PHONE`这个权限。你需要它来在应用中拨打电话，是吗？这就是你怎么去实现拨号的吗？ 
+```java
+Intent intent = new Intent(Intent.ACTION_CALL);
+intent.setData(Uri.parse("tel:1234567890"))
+startActivity(intent);
+```
+错！，你通过这段代码需要该权限的原因是因为你可以在任何时间在不需要用户操作的情况下打电话。也就是说如果我的应用申请了这个权限，我可以在你不知情的情况下每天凌晨三点去拨打骚扰电话。
+
+正确的方式是使用`ACTION_VIEW`或者`ACTION_DIAL`:    
+```java
+Intent intent = new Intent(Intent.ACTION_DIAL);
+intent.setData(Uri.parse("tel:1234567890"))
+startActivity(intent);
+```
+
+这个问题的完美解决方案就是不需要申请权限了。原因就是你不是直接拨号，而是用指定的号码调起拨号器，仍然需要用户点击”拨号”来开始打电话。老实的说，这样让人感觉更好。
+
+简单的说就是如果我想要的操作不是让用户在应用内点击某个按钮就直接开始拨打电话，而是让用户点击在应用内点击某个按钮是我们去调起拨号程序，并且显示指定号码，让用户在拨号器中点击拨号后再开始拨打电话。这样的话我们就完全不用申请拨号权限了。
+
+另一个例子: 我想获取某一个联系人的号码，你可能会想这需要申请获取所有联系人的权限。这是错的！。
+```java
+Intent intent = new Intent(Intent.ACTION_PICK);
+intent.setType(StructuredPostal.CONTENT_TYPE);
+startActivityForResult(intent, 1);
+```
+我们可以使用上面的代码，来启动联系人管理器，让用户来选择某一个联系人。这样不仅是不需要申请任何权限，也不需要提供任何联系人相关的`UI`。这样也能完全保证你选择联系人时的体验。
+
+
+`Android`系统最酷的部分之一就是`Intent`系统，这意味着我不需要自己来实现所有的东西。应用可以注册处理它所擅长的指定数据，像电话号码、短信或者联系人。如果这些都要自己在一个应用中去实现，那这将会是很大的工作量，也会让应用变得臃肿。
+
+`Android`系统的另一个优势就是你可以使用其他应用申请的权限，而不用自己申请。这样才保证了上面的情况。拨号器需要申请拨打电话的权限，我只需要一个能调起拨号器的`Intent`就好了。用户信任拨号器拨打电话，而不是我们的应用。他们无论如何都宁愿使用系统的拨号器。
+
+写这篇文章的意义是**在你想要申请一个权限的时候，你需要至少看看[Intent的官方文档](https://developer.android.com/reference/android/content/Intent.html)看能否请求另外一个应用来帮我们做这些操作。**如果想要深入的研究，可以学习下[关于权限的详细介绍](https://developer.android.com/guide/topics/security/permissions.html)，这里面包含了很多精细的权限。
+
+使用更少的权限可以不但可以让用户更加信任你，而且可以让用户有一个更好的体验，因为他们仍然在使用他们所期望的应用。
+
+1. 遗憾的是，不是一个真实的号码。
+2. 不幸的是，`Intent`系统的属性也建立了[可能会被滥用的漏洞](http://css.csail.mit.edu/6.858/2012/projects/ocderby-dennisw-kcasteel.pdf)，但你也不会写一个滥用的应用，是吗？
+
+
+- (译)[感谢Dan Lew](http://blog.danlew.net/2014/11/26/i-dont-need-your-permission/)
+
+		
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/AdavancedPart/Android\345\274\200\345\217\221\344\270\255\347\232\204MVP\346\250\241\345\274\217\350\257\246\350\247\243.md" "b/AdavancedPart/Android\345\274\200\345\217\221\344\270\255\347\232\204MVP\346\250\241\345\274\217\350\257\246\350\247\243.md"
new file mode 100644
index 00000000..4653b0a9
--- /dev/null
+++ "b/AdavancedPart/Android\345\274\200\345\217\221\344\270\255\347\232\204MVP\346\250\241\345\274\217\350\257\246\350\247\243.md"
@@ -0,0 +1,600 @@
+Android开发中的MVP模式详解
+===
+
+[MVC、MVP、MVVM介绍][1]
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_mvp.jpg?raw=true)
+
+在`Android`开发中，如果不注重架构的话，`Activity`类就会变得愈发庞大。这是因为在`Android`开发中`View`和其他的线程可以共存于`Activity`内。那最大的问题是什么呢？ 其实就是`Activity`中同时存在业务逻辑和`UI`逻辑。这导致增加了单元测试和维护的成本。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/activity_is_god.png?raw=true)
+        
+这就是为什么要清晰架构的原因之一。不仅是因为`Activity`类变得臃肿，也是其他的一些问题，例如`Activity`和`Fragment`相结合时的生命周期、数据绑定等等。   
+
+### MVP简介
+
+`MVP(Model,View,Presenter)`      
+
+- `View`：负责处理用户时间和视图展现。在`Android`中就可能是`Activity`或者`Fragment`。
+- `Model`： 负责数据访问。数据可以是从接口或者本地数据库中获取。
+- `Presenter`: 负责连接`View`和`Model`。
+
+用一句话来说:`MVP`其实就是面向接口编程，`V`实现接口，`P`使用接口。
+
+清晰的架构:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/mvp_a.png?raw=true)
+
+
+举个栗子:
+在`Android Studio`中新建一个`Activity`，系统提供了`LoginActivity`，直接用它是极好的。    
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/loginactivity.png?raw=true" width="50%" height="50%" />
+
+不得不说，`Material Design`的效果真是美美哒！
+
+好，那我们就用用户登录页来按照`MVP`的模式实现一下:     
+
+- M: 很显然Model应该是`User`类。
+- V: `View`就是`LoginActivity`。
+- P: P那我们一会就创建一个`LoginPresenter`类。
+
+齐了，那接下来就详细分析下他们这三部分:   
+
+- `User`: 应该有`email`, `password`, `boolean login(email, password)`。
+- `LoginActivity`:点击登录应该要出`loading`页。登录成功后要进入下一个页面。如果登录失败应该弹`toast`提示。那就需要`void showLoading()`，`void hideLoading()`，`void showErrorTip()`,`void doLoginSuccess()`这四个方法。
+- `LoginPresenter`:这是`Model`和`View`的桥梁。他需要做的处理业务逻辑，直接与`Model`打交道，然后将`UI`的逻辑交给`LoginActivity`处理。
+那怎么做呢？ 按照我上面总结的那一句话，、`MVP`其实就是面向接口编程，`V`实现接口，`P`使用接口。很显然我们需要提供一个接口。那就新建一个`ILoginView`的接口。这里面有哪些方法呢？ 当然是上面我们在分析`LoginActiity`时提出的那四个方法。这样`LoginActivity`直接实现`ILoginView`接口就好。
+
+
+开始做:   
+
+- 先把`Model`做好吧，创建`User`类。  
+
+    ```java
+    public class User {
+        private String email;
+        private String password;
+        public User(String email, String password) {
+            this.email = email;
+            this.password = password;
+        }
+    
+        public boolean login() {
+            // do login request..
+            return true;
+        }
+    }
+    ```
+
+- 创建`ILoginView`接口，定义登录所需要的`ui`逻辑。    
+
+    ```java
+    public interface ILoginView {
+        void showLoading();
+        void hideLoading();
+        void showErrorTip();
+        void doLoginSuccess();
+    }
+    ```
+
+- 创建`LoginPresenter`类，使用`ILoginView`接口，那该类主要有什么功能呢？ 它主要是处理业务逻辑的，
+    对于登录的话，当然是用户在`UI`页面输入邮箱和密码，然后`Presenter`去开线程、请求接口。然后得到登录结果再去让`UI`显示对应的视图。那自然就是有一个`void login(String email, String passowrd)`的方法了  
+
+    ```java
+    public class LoginPresenter {
+        private ILoginView mLoginView;
+    
+        public LoginPresenter(ILoginView loginView) {
+            mLoginView = loginView;
+        }
+    
+        public void login(String email, String password) {
+            if (TextUtils.isEmpty(email) || TextUtils.isEmpty(password)) {
+                //
+                mLoginView.showErrorTip();
+                return;
+            }
+            mLoginView.showLoading();
+            User user = new User(email, password);
+    
+            // do network request....
+            // ....
+            onSuccess() {
+                boolean login = user.login();
+                if (login) {
+                    mLoginView.doLoginSuccess();
+                } else {
+                    mLoginView.showErrorTip();
+                }
+                mLoginView.hideLoading();
+            }
+    
+            onFailde() {
+                mLoginView.showErrorTip();
+                mLoginView.hideLoading();
+            }
+        }
+    }       
+    ```
+- 创建`LoginActivity`，实现`ILoginView`的接口，然后内部调用`LoginPresenter`来处理业务逻辑。
+
+    ```java
+    public class LoginActivity extends AppCompatActivity implements ILoginView {
+        private LoginPresenter mLoginPresenter;
+    
+        private AutoCompleteTextView mEmailView;
+        private EditText mPasswordView;
+        private View mProgressView;
+        private View mLoginButton;
+    
+        @Override
+        protected void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+            setContentView(R.layout.activity_login);
+            mEmailView = (AutoCompleteTextView) findViewById(R.id.email);
+            mPasswordView = (EditText) findViewById(R.id.password);
+            mLoginButton = findViewById(R.id.email_sign_in_button);
+            mProgressView = findViewById(R.id.login_progress);
+    
+            mLoginPresenter = new LoginPresenter(this);
+    
+            mLoginButton.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    mLoginPresenter.login(mEmailView.getText().toString().trim(), mPasswordView.getText().toString().trim());
+                }
+            });
+        }
+    
+        @Override
+        public void showLoading() {
+            mProgressView.setVisibility(View.VISIBLE);
+        }
+    
+        @Override
+        public void hideLoading() {
+            mProgressView.setVisibility(View.GONE);
+        }
+    
+        @Override
+        public void showErrorTip() {
+            Toast.makeText(this, "login faled", Toast.LENGTH_SHORT).show();
+        }
+    
+        @Override
+        public void doLoginSuccess() {
+            Toast.makeText(this, "login success", Toast.LENGTH_SHORT).show();
+        }
+    }
+    ```
+
+---
+
+
+上面只是抛砖引玉。`MVP`的优点十分明显，就是代码解耦、可以让逻辑清晰，但是同样它也会有缺点，它的缺点就是项目的复杂程度会增加，项目中会多出很多类。
+之前很多人都在讨论该如何去正确的设计使用`MVP`来避免它的缺点，众说纷纭，很多人讨论的你死我活。直到`Google`发布了`MVP架构蓝图`，大家才意识到这才是规范。     
+
+项目地址:[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.
+
+
+
+已完成的示例:  
+
+- todo-mvp/ - Basic Model-View-Presenter architecture.
+- todo-mvp-loaders/ - Based on todo-mvp, fetches data using Loaders.
+- todo-mvp-databinding/ - Based on todo-mvp, uses the Data Binding Library.
+- todo-mvp-clean/ - Based on todo-mvp, uses concepts from Clean Architecture.
+- todo-mvp-dagger/ - Based on todo-mvp, uses Dagger2 for Dependency Injection
+- todo-mvp-contentproviders/ - Based on todo-mvp-loaders, fetches data using Loaders and uses Content Providers
+- todo-mvp-rxjava/ - Based on todo-mvp, uses RxJava for concurrency and data layer abstraction.
+
+
+我们接下来就用`todo-mvp`来进行分析，这个应用非常简单，主要有以下几个功能:     
+
+- 列表页:展示所有的`todo`项   
+- 添加页:添加`todo`项
+- 详情页:查看`todo`项的详情
+- 统计页:查看当前所有已完成`todo`及未完成项的统计数据     
+
+代码并不多:   
+
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/google_mvp.png?raw=true" width="50%" height="50%" />
+
+功能也比较简单:    
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/google_todo_main.png?raw=true" width="40%" height="40%" />    <img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/google_todp_add.png?raw=true" width="40%" height="40%" />
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/google_todo_list.png?raw=true" width="40%" height="40%" />          <img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/google_todo_delete.png?raw=true" width="40%" height="40%" />
+
+我们先从两个`Base`类开始看，分别是`BaseView`以及`BasePresenter`类。 
+
+`BaseView`类:   
+
+```java
+public interface BaseView<T> {
+
+    void setPresenter(T presenter);
+
+}
+```
+`BaseView`中的`setPresenter()`是将`Presenter`的实例传入到`View`中。    
+`BasePresenter`类:   
+```java
+public interface BasePresenter {
+
+    void start();
+
+}
+```
+`BasePresenter`中只有一个`start()`方法，从名字上我们就能看出他的作用。 
+
+接下来继续看一下项目的入口`Activity`，`TaskDetailActivity`的实现: 
+```java
+public class TaskDetailActivity extends AppCompatActivity {
+
+    public static final String EXTRA_TASK_ID = "TASK_ID";
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.taskdetail_act);
+
+        // Set up the toolbar.
+        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
+        setSupportActionBar(toolbar);
+        ActionBar ab = getSupportActionBar();
+        ab.setDisplayHomeAsUpEnabled(true);
+        ab.setDisplayShowHomeEnabled(true);
+
+        // Get the requested task id
+        String taskId = getIntent().getStringExtra(EXTRA_TASK_ID);
+        
+        TaskDetailFragment taskDetailFragment = (TaskDetailFragment) getSupportFragmentManager()
+                .findFragmentById(R.id.contentFrame);
+
+        if (taskDetailFragment == null) {
+            // 创建对应的Fragment
+            taskDetailFragment = TaskDetailFragment.newInstance(taskId);
+
+            ActivityUtils.addFragmentToActivity(getSupportFragmentManager(),
+                    taskDetailFragment, R.id.contentFrame);
+        }
+
+        // Create the presenter，因为Presenter是M和V的连接桥，所以在第二个参数中会传入TasksRepository
+        new TaskDetailPresenter(
+                taskId,
+                Injection.provideTasksRepository(getApplicationContext()),
+                taskDetailFragment);
+    }
+
+    @Override
+    public boolean onSupportNavigateUp() {
+        onBackPressed();
+        return true;
+    }
+}
+```
+
+可以看到这里`Activity`相当于一个管理类，里面控制着`MVP`中的`V`和`P`,上面的代码主要做了两部分:  
+
+- 创建对应的`Fragment`
+- 创建对应的`Presenter`
+
+这里分别看一下`TaskDetailFragment`和`TaskDetailPresenter`的源码:   
+```java
+public class TaskDetailFragment extends Fragment implements TaskDetailContract.View {
+    private TaskDetailContract.Presenter mPresenter;
+
+    public static TaskDetailFragment newInstance(@Nullable String taskId) {
+        Bundle arguments = new Bundle();
+        arguments.putString(ARGUMENT_TASK_ID, taskId);
+        TaskDetailFragment fragment = new TaskDetailFragment();
+        fragment.setArguments(arguments);
+        return fragment;
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        // 调用Presenter.start()方法
+        mPresenter.start();
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+                             Bundle savedInstanceState) {
+        ....
+    }
+
+    @Override
+    public void setPresenter(@NonNull TaskDetailContract.Presenter presenter) {
+        // 将Prsenter传递给V中 
+        mPresenter = checkNotNull(presenter);
+    }
+
+    ....
+}
+```
+及
+```java
+public class TaskDetailPresenter implements TaskDetailContract.Presenter {
+    private final TasksRepository mTasksRepository;
+
+    private final TaskDetailContract.View mTaskDetailView;
+
+    @Nullable
+    private String mTaskId;
+
+    // 把M和V传递进来
+    public TaskDetailPresenter(@Nullable String taskId,
+                               @NonNull TasksRepository tasksRepository,
+                               @NonNull TaskDetailContract.View taskDetailView) {
+        mTaskId = taskId;
+        mTasksRepository = checkNotNull(tasksRepository, "tasksRepository cannot be null!");
+        mTaskDetailView = checkNotNull(taskDetailView, "taskDetailView cannot be null!");
+        // 将该Presenter设置给V
+        mTaskDetailView.setPresenter(this);
+    }
+
+    @Override
+    public void start() {
+        // 调用获取数据的方法
+        openTask();
+    }
+    ....
+}
+```
+
+可以看到上面分别实现了`TaskDetailContract`类中的`Presenter`和`View`接口，而不是`BasePresenter`和`BaseView`中的接口，那这个`TaskDetailContract`类是什么呢？ 
+```java
+/**
+ * This specifies the contract between the view and the presenter.
+ */
+public interface TaskDetailContract {
+
+    interface View extends BaseView<Presenter> {
+
+        void setLoadingIndicator(boolean active);
+
+        void showMissingTask();
+
+        void hideTitle();
+
+        void showTitle(String title);
+
+        void hideDescription();
+
+        void showDescription(String description);
+
+        void showCompletionStatus(boolean complete);
+
+        void showEditTask(String taskId);
+
+        void showTaskDeleted();
+
+        void showTaskMarkedComplete();
+
+        void showTaskMarkedActive();
+
+        boolean isActive();
+    }
+
+    interface Presenter extends BasePresenter {
+
+        void editTask();
+
+        void deleteTask();
+
+        void completeTask();
+
+        void activateTask();
+    }
+}
+```
+按照上面描述的介绍可以看出通过这个连接类将`VP`联系到了一起，它统一管理`view`和`presenter`中的所有接口，这样比起分开写会更加清晰。
+
+分析完`VP`之后我们继续看一下`TaskDetailPresenter`类，因为`Presenter`是`MV`的桥梁。
+```java
+public TaskDetailPresenter(@Nullable String taskId,
+                               @NonNull TasksRepository tasksRepository,
+                               @NonNull TaskDetailContract.View taskDetailView) {
+        mTaskId = taskId;
+        mTasksRepository = checkNotNull(tasksRepository, "tasksRepository cannot be null!");
+        mTaskDetailView = checkNotNull(taskDetailView, "taskDetailView cannot be null!");
+
+        mTaskDetailView.setPresenter(this);
+    }
+
+    @Override
+    public void start() {
+        openTask();
+    }
+
+    private void openTask() {
+        if (Strings.isNullOrEmpty(mTaskId)) {
+            mTaskDetailView.showMissingTask();
+            return;
+        }
+        // 控制V显示UI
+        mTaskDetailView.setLoadingIndicator(true);
+    // 通过M去获取数据
+        mTasksRepository.getTask(mTaskId, new TasksDataSource.GetTaskCallback() {
+            @Override
+            public void onTaskLoaded(Task task) {
+                // The view may not be able to handle UI updates anymore
+                if (!mTaskDetailView.isActive()) {
+                    return;
+                }
+                mTaskDetailView.setLoadingIndicator(false);
+                if (null == task) {
+                    mTaskDetailView.showMissingTask();
+                } else {
+                    showTask(task);
+                }
+            }
+
+            @Override
+            public void onDataNotAvailable() {
+                // The view may not be able to handle UI updates anymore
+                if (!mTaskDetailView.isActive()) {
+                    return;
+                }
+                mTaskDetailView.showMissingTask();
+            }
+        });
+    }
+
+```
+在它的构造函数中传入了一个`TasksRepository`，这个就是`Model`层。而在该`Presenter`中的`start()`方法回去调用获取数据的方法。   
+
+我们继续看一下`M`层`TasksRepository`的实现:    
+```java
+/**
+ * Concrete implementation to load tasks from the data sources into a cache.
+ * <p>
+ * For simplicity, this implements a dumb synchronisation between locally persisted data and data
+ * obtained from the server, by using the remote data source only if the local database doesn't
+ * exist or is empty.
+ */
+public class TasksRepository implements TasksDataSource {
+    ....
+}
+```
+
+先看一下`TasksDataSource`接口:   
+
+```java
+/**
+ * Main entry point for accessing tasks data.
+ * <p>
+ * For simplicity, only getTasks() and getTask() have callbacks. Consider adding callbacks to other
+ * methods to inform the user of network/database errors or successful operations.
+ * For example, when a new task is created, it's synchronously stored in cache but usually every
+ * operation on database or network should be executed in a different thread.
+ */
+public interface TasksDataSource {
+
+    interface LoadTasksCallback {
+
+        void onTasksLoaded(List<Task> tasks);
+
+        void onDataNotAvailable();
+    }
+
+    interface GetTaskCallback {
+
+        void onTaskLoaded(Task task);
+
+        void onDataNotAvailable();
+    }
+
+    void getTasks(@NonNull LoadTasksCallback callback);
+
+    void getTask(@NonNull String taskId, @NonNull GetTaskCallback callback);
+
+    void saveTask(@NonNull Task task);
+
+    void completeTask(@NonNull Task task);
+
+    void completeTask(@NonNull String taskId);
+
+    void activateTask(@NonNull Task task);
+
+    void activateTask(@NonNull String taskId);
+
+    void clearCompletedTasks();
+
+    void refreshTasks();
+
+    void deleteAllTasks();
+
+    void deleteTask(@NonNull String taskId);
+}
+
+```
+
+可以看出`M`层被赋予了数据获取的功能，与之前我们写的`M`层只定义实体对象截然不同，数据的增删改查都是`M`层实现的。`Presenter`只需要调用`M`层的方法即可。这样`model、presenter、view`都只处理各自的任务，此种实现确实是单一职责最好的诠释。
+
+这里我们就以上面用到的`getTasks()`方法为例来介绍一下:   
+```java
+public void getTask(@NonNull final String taskId, @NonNull final GetTaskCallback callback) {
+        checkNotNull(taskId);
+        checkNotNull(callback);
+        // 从缓存中获取数据
+        Task cachedTask = getTaskWithId(taskId);
+
+        // Respond immediately with cache if available
+        if (cachedTask != null) {
+            callback.onTaskLoaded(cachedTask);
+            return;
+        }
+
+        // Load from server/persisted if needed.
+
+        // Is the task in the local data source? If not, query the network.
+        mTasksLocalDataSource.getTask(taskId, new GetTaskCallback() {
+            @Override
+            public void onTaskLoaded(Task task) {
+                // Do in memory cache update to keep the app UI up to date
+                if (mCachedTasks == null) {
+                    mCachedTasks = new LinkedHashMap<>();
+                }
+                mCachedTasks.put(task.getId(), task);
+                callback.onTaskLoaded(task);
+            }
+
+            @Override
+            public void onDataNotAvailable() {
+                // 服务器的数据源
+                mTasksRemoteDataSource.getTask(taskId, new GetTaskCallback() {
+                    @Override
+                    public void onTaskLoaded(Task task) {
+                        // Do in memory cache update to keep the app UI up to date
+                        if (mCachedTasks == null) {
+                            mCachedTasks = new LinkedHashMap<>();
+                        }
+                        mCachedTasks.put(task.getId(), task);
+                        callback.onTaskLoaded(task);
+                    }
+
+                    @Override
+                    public void onDataNotAvailable() {
+                        callback.onDataNotAvailable();
+                    }
+                });
+            }
+        });
+    }
+```
+
+上面的注释说的非常明白了，这里就不去仔细看了。
+
+
+下面用一张图来总结一下:   
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/google_todo_mvp.png?raw=true)
+
+
+由于架构的引入，虽然代码量有了一定的上升，但是功能分离的非常清晰明确，而且每个部分都可以进行单独的测试，对于后期的扩展维护会更加简单容易。
+
+
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/MVC%E4%B8%8EMVP%E5%8F%8AMVVM.md  "MVC、MVP、MVVM介绍"
+
+---
+
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git a/AdavancedPart/ApplicationId vs PackageName.md b/AdavancedPart/ApplicationId vs PackageName.md
new file mode 100644
index 00000000..35dc2f0a
--- /dev/null
+++ b/AdavancedPart/ApplicationId vs PackageName.md	
@@ -0,0 +1,89 @@
+ApplicationId vs PackageName
+===
+
+曾几何时，自从转入`Studio`阵营后就发现多了个`applicationId "com.xx.xxx"`，虽然知道肯定会有区别，但是我却没有仔细去看，只想着把它和`packageName`设置成相同即可(原谅我的懒惰- -!)。         
+
+直到今天在官网看`Gradle`使用时，终于忍不住要搞明白它俩的区别。         
+
+在`Android`官方文档中有一句是这样描述`applicationId`的:`applicationId : the effective packageName`，真是言简意赅，那既然`applicationId`是有效的包明了，`packageName`算啥？     
+
+所有`Android`应用都有一个包名。包名在设备上能唯一的标识一个应用，它在`Google Play`应用商店中也是唯一的。这就意味着一旦你使用一个包名发布应用后，你就永 远不能改变它的包名；如果你改了包名就会导致你的应用被认为是一个新的应用，并且已经使用你之前应用的用户将不会看到作为更新的新应用包。          
+
+之前的`Android Gradle`构建系统中，应用的包名是由你的`manifest`文件中的根元素中的`package`属性定义的:       
+ 
+`AndroidManifest.xml: `          
+
+```
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.example.my.app"
+    android:versionCode="1"
+    android:versionName="1.0" >
+```
+然而，这里定义的包也有第二个目的：就是被用来命名你的`R`资源类(以及解析任何与`Activities`相关的类名)的包。在上面的示例中，生成的`R`类就是`com.example.my.app.R`，所以如果你在其他的包中想引用资源，就需要导入`com.example.my.app.R`。      
+  
+伴随着新的`Android Gradle`构建系统，你可以很简单的为你的应用构建多个不同的版本；例如，你可以同时为你的应用构建一个免费版本和一个专业版(使用`flavors`)，并且他们应该在`Google Play`商店中有不同的包，这样才能让他们可以被单独安装和购买，同时安装两个，等等。同样的你也可能同时为你的应用构建`debug`版、`alpha`版和`beta`版(使用`build types`)，这些也可以同样使用不同的包名。    
+ 
+在这同时，你在代码中导入的`R`类必须一直保持一直；在为应用构建不同的版本时`.java`源文件都不应该发生变化。
+       
+因此,我们解耦了`package name`的两种用法:       
+
+- 在生成的`.apk`中的`manifest`文件中使用的最终的包名以及在你的设备和`Google Play`商店中用来标示你的包名叫做`application id`的值。
+- 在源代码中指向`R`类的包名以及在解析任何与`activity/service`注册相关的包名继续叫做`package name`。
+
+可以在`gradle`文件中像如下指定`application id`:  
+    
+`app/build.gradle:`         
+
+```
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 19
+    buildToolsVersion "19.1"
+
+    defaultConfig {
+        applicationId "com.example.my.app"
+        minSdkVersion 15
+        targetSdkVersion 19
+        versionCode 1
+        versionName "1.0"
+    }
+    ...
+```
+
+像之前一样，你需要在`Manifest`文件中指定你在代码中使用的`package name`，像上面`AndroidManifest.xml`的例子。        
+下面进入关键部分了:当你按照上面的方式做完后，这两个包就是相互独立的了。你现在可以很简单的重构你的代码-通过修改`Manifest`中的包名来修改在你的`activitise`和`services`中使用的包和在重构你在代码中的引用声明。这不会影响你应用的最终`id`，也就是在`Gradle`文件中的`applicationId`。       
+
+你可以通过以下`Gradle DSL`方法为应用的`flavors`和`build types`指定不同的`applicationId`:       
+
+`app/buid.gradle: `      
+
+```
+productFlavors {
+    pro {
+        applicationId = "com.example.my.pkg.pro"
+    }
+    free {
+        applicationId = "com.example.my.pkg.free"
+    }
+}
+
+buildTypes {
+    debug {
+        applicationIdSuffix ".debug"
+    }
+}
+....
+```
+(在`Android Studio`中你也可以通过图形化的`Project Structure`的对话框来更改上面所有的配置)
+
+注意:为了兼容性，如果你在`build.gradle`文件中没有定义`applicationId` ，那`applicationId`就是与`AndroidManifest.xml`中配置的包名相同的默认值。在这种情况下，这两者显然脱不了干系，如果你试图重构代码中的包就将会导致同时会改变你应用程序的`id`！在`Android Studio`中新创建的项目都是同时指定他们俩。     
+
+注意2:`package name`必须在默认的`AndroidManifest.xml`文件中指定。如果有多个`manifest`文件(例如对每个`flavor`制定一个`manifest`或者每个`build type`制定一个`manifest`)时，`package name`是可选的，但是如果你指定的话，它必须与主`manifest`中指定的`pakcage`相同。
+
+		
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Android\345\212\240\345\274\272/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"
similarity index 95%
rename from "Android\345\212\240\345\274\272/BroadcastReceiver\345\256\211\345\205\250\351\227\256\351\242\230.md"
rename to "AdavancedPart/BroadcastReceiver\345\256\211\345\205\250\351\227\256\351\242\230.md"
index 9321459b..0a6a7f1a 100644
--- "a/Android\345\212\240\345\274\272/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"
@@ -1,11 +1,11 @@
-BroadcastReceiver安全问题
+BroadcastReceiver安全问题
 ===
 
 `BroadcastReceiver`设计的初衷是从全局考虑可以方便应用程序和系统、应用程序之间、应用程序内的通信，所以对单个应用程序而言`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/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/ConstraintLaayout\347\256\200\344\273\213.md" "b/AdavancedPart/ConstraintLaayout\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..f46d2dc2
--- /dev/null
+++ "b/AdavancedPart/ConstraintLaayout\347\256\200\344\273\213.md"
@@ -0,0 +1,233 @@
+ConstraintLaayout简介
+===
+
+`ConstraintLayout`从发布到现在也得有两年的时间了，但是目前在项目中却很少用到他。今天闲下来记录一下，以后可以用来解决一些布局的嵌套问题。 
+`ConstraintLayout`是`RelativeLayout`的升级版本，但是比`RelativeLayout`更加强调约束，它能让你的布局更加扁平化，一般来说一个界面一层就够了。
+而且它可以直接在布局编辑页面通过拖拖拖的方式就可以把控件摆放好，但是我还是习惯手写。   
+
+在`Android Studio`中可以很方便的将目前的布局直接转换成`ConstraintLayout`，可以在布局的编辑页面上直接右键然后选择就可以了。        
+
+当然项目中要添加它的依赖，目前最新版本: 
+```
+implementation 'com.android.support.constraint:constraint-layout:1.1.0'
+```
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/constraintlayout_convert.png?raw=true" width = "80%" />
+
+然后会提示添加`ConstraintLayout`支持库。   
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/constraintlayout_convert_tip.png?raw=true" width = "80%" />
+
+
+相对于传统布局`ConstraintLayout`在以下方面提供了一些新的特性:      
+
+- 相对定位        
+
+    这个和`RelativeLayout`比较像，就是一个控件相对于另一个控件的位置约束关系:  
+    
+    - 横向:`Left、Right、Start、End`
+    - 纵向:`Top、Bottom、Baseline(文本底部的基准线)`
+        
+        ```xml
+    	<Button android:id="@+id/buttonA" ... />
+		<Button android:id="@+id/buttonB" ...
+			// 这样系统就会知道B的左侧被约束在A的右侧
+		    app:layout_constraintLeft_toRightOf="@+id/buttonA" />
+        ```
+        常用的有:     
+        ```xml
+		* layout_constraintLeft_toLeftOf          // 左边左对齐
+		* layout_constraintLeft_toRightOf         // 左边右对齐
+		* layout_constraintRight_toLeftOf         // 右边左对齐
+		* layout_constraintRight_toRightOf        // 右边右对齐
+		* layout_constraintTop_toTopOf            // 上边顶部对齐
+		* layout_constraintTop_toBottomOf         // 上边底部对齐
+		* layout_constraintBottom_toTopOf         // 下边顶部对齐
+		* layout_constraintBottom_toBottomOf      // 下边底部对齐
+		* layout_constraintBaseline_toBaselineOf  // 文本内容基准线对齐
+		* layout_constraintStart_toEndOf          // 起始边向尾部对齐
+		* layout_constraintStart_toStartOf        // 起始边向起始边对齐
+		* layout_constraintEnd_toStartOf          // 尾部向起始边对齐
+		* layout_constraintEnd_toEndOf            // 尾部向尾部对齐
+
+        ```
+
+		上面的这些属性需要结合`id`才能进行约束，这些id可以指向控件也可以指向父容器（也就是`ConstraintLayout`），比如:    
+		```xml
+		<Button android:id="@+id/buttonB" ...
+		    app:layout_constraintLeft_toLeftOf="parent" />
+		```
+
+- 外边距
+
+    ```xml
+    * android:layout_marginStart
+	* android:layout_marginEnd
+	* android:layout_marginLeft
+	* android:layout_marginTop
+	* android:layout_marginRight
+	* android:layout_marginBottom
+	// 这里的gone margin指的是B向A添加约束后，如果A的可见性变为GONE，这时候B的外边距可以改变，也就是B的外边距根据A的可见性分为两种状态。
+	* layout_goneMarginStart
+	* layout_goneMarginEnd
+	* layout_goneMarginLeft
+	* layout_goneMarginTop
+	* layout_goneMarginRight
+	* layout_goneMarginBottom
+
+    ```
+
+- 居中和倾向       
+	- 居中     
+		在`RelativeLayout`中我们可以`centerHorizontal`等来进行居中操作，但是在`ConstraintLayout`中没有类似的方法。 
+	    ```xml
+	    <android.support.constraint.ConstraintLayout ...>
+	    <Button android:id="@+id/button" ...
+	        app:layout_constraintLeft_toLeftOf="parent"
+	        app:layout_constraintRight_toRightOf="parent/>
+			<android.support.constraint.ConstraintLayout/>
+	    ```
+		这种情况就感觉像是控件两边有两个反向相等大小的力在拉动它一样，所以才会产生控件居中的效果。
+
+	- 倾向     
+        在这种约束是同向相反的情况下，默认控件是居中的，但是也可以像拔河一样，让两个约束的力大小不等，这样就产生了倾向，其属性是：
+        ```xml
+		* layout_constraintHorizontal_bias
+		* layout_constraintVertical_bias
+		```
+
+		下面这段代码就是让左边占30%，右边占70%（默认两边各占50%），这样左边就会短一些，如图5所示，此时代码是这样的:    
+		```xml		
+		<android.support.constraint.ConstraintLayout ...>
+		    <Button android:id="@+id/button" ...
+		        app:layout_constraintHorizontal_bias="0.3"
+		        app:layout_constraintLeft_toLeftOf="parent"
+		        app:layout_constraintRight_toRightOf="parent/>
+		<android.support.constraint.ConstraintLayout/>
+		```
+
+- 可见性的表现
+
+    `ConstraintLayout`对可见性被标记`View.GONE`的控件（后称`GONE`控件）有特殊的处理。一般情况下，`GONG`控件是不可见的，且不再是布局的一部分，但是在布局计算上，`ConstraintLayout`与传统布局有一个很重要的区别:    
+
+    - 传统布局下，`GONE`控件的尺寸会被认为是0（当做点来处理）
+    - 在`ConstraintLayout`中，`GONE`控件尺寸仍然按其可见时的大小计算，但是其外边距大小按0计算
+
+
+- 尺寸约束
+
+    `ConstraintLayout`本身可以定义自己的最小尺寸:   
+
+    - `android:minWidth`设置布局的最小宽度
+    - `android:minHeight`设置布局的最小高度
+
+    这些最小尺寸当`ConstraintLayout`被设置为`WRAP_CONTENT`时有效。
+    
+    控件的尺寸可以通过`android:layout_width`和`android:layout_height`来设置，有三种方式:   
+    
+    - 使用固定值
+    - 使用`WRAP_CONTENT`
+    - 使用0dp（相当于`MATCH_CONSTRAINT`)
+
+    为什么不用`MATCH_PARENT`呢？ 这是因为:   
+     
+    `Important: MATCH_PARENT is not supported for widgets contained in a ConstraintLayout, though similar behavior can be defined by using MATCH_CONSTRAINT with the corresponding left/right or top/bottom constraints being set to “parent”.`
+
+    比例
+    这里的比例指的是宽高比，通过设置比例，让宽高的其中一个随另一个变化。为了实现比例，需要让控件宽或高受约束，且尺寸设置为0dp（也可以是MATCH_CONSTRAINT），实现代码如下:   
+    
+    ```java
+    <Button android:layout_width="wrap_content"
+        android:layout_height="0dp"
+        app:layout_constraintTop_toTopOf="parent"
+        app:layout_constraintDimensionRatio="1:1" />
+    ```
+
+    上述代码中，按钮的高度满足受约束且设置为0dp的条件，所以其尺寸会按照比例随宽度调整。
+
+    比例的设置有两种格式：
+
+    - 宽度与高度的比，可理解为受约束的一方尺寸:另一方尺寸
+    - 受约束的一方尺寸/另一方尺寸得到的浮点数值
+
+- `Chain`
+
+    `Chain`是一系列双向连接的控件连接在一起的形态(可以理解成一个包含几个子`View`的`LinearLayout`)
+    横向上，`Chain`头部是`Chain`最左边的控件；纵向上，`Chain`头部是`Chain`最顶部的控件。
+
+    `Chain`样式:    
+    当对`Chain`的第一个元素设置`layout_constraintHorizontal_chainStyle`或`layout_constraintVertical_chainStyle`属性，
+    `Chain`就会根据特定的样式（默认样式为`CHAIN_SPREAD`）进行相应变化，样式类型如下:   
+
+    - `CHAIN_SPREAD`元素被分散开（默认样式）
+    - 在`CHAIN_SPREAD`模式下，如果一些控件被设置为`MATCH_CONSTRAINT`，那么控件将会把所有剩余的空间均分后“吃掉”
+    - `CHAIN_SPREAD_INSIDE`:`Chain`两边的元素贴着父容器，其他元素在剩余的空间中采用`CHAIN_SPREAD`模式
+    - `CHAIN_PACKED`:`Chain`中的所有控件合并在一起后在剩余的空间中居中
+    
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/chain.png?raw=true)
+    
+    带权重的`Chain`:        
+    默认的`Chain`会在空间里平均散开。如果其中有一个或多个元素使用了`MATCH_CONSTRAINT`属性，那么他们会将剩余的空间平均填满。
+    属性`layout_constraintHorizontal_height`和`layout_constraintVertical_weight`控制使用`MATCH_CONSTRAINT`的元素如何均分空间。
+    例如，一个`Chain`中包含两个使用`MATCH_CONSTRAINT`的元素，第一个元素使用的权重为2，第二个元素使用的权重为1，
+    那么被第一个元素占用的空间是第二个元素的2倍。
+    
+
+- 辅助工具
+
+    `android.support.constraint.Guideline`该类比较简单，主要用于辅助布局，即类似为辅助线，横向的、纵向的。
+    该布局是不会显示到界面上的。
+    
+    所以其有个属性为:`android:orientation`取值为`vertical`和`horizontal`.
+    
+    除此以外，还差个属性，决定该辅助线的位置:    
+    
+    - `layout_constraintGuide_begin`
+    - `layout_constraintGuide_end`
+    - `layout_constraintGuide_percent`
+    
+    可以通过上面3个属性其中之一来确定属性值位置。`begin=30dp`，即可认为距离顶部30dp的地方有个辅助线，
+    根据`orientation`来决定是横向还是纵向。`end=30dp`，即为距离底部。`percent=0.8`即为距离顶部`80%`。
+    
+    好了，下面看一个例子，在一个布局的右下角添加浮点按钮，我决定通过两根辅助线来定位，一根横向距离底部80%，一个纵向距离顶部80%，浮点按钮就定位在他们交叉的地方。
+    
+    ```xml
+    <android.support.constraint.ConstraintLayout 
+        ...
+        tools:context="com.zhy.constrantlayout_learn.MainActivity">
+        <android.support.constraint.Guideline
+            android:id="@+id/guideline_h"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal"
+            app:layout_constraintGuide_percent="0.8" />
+        <android.support.constraint.Guideline
+            android:id="@+id/guideline_w"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            app:layout_constraintGuide_percent="0.8" />
+        <TextView
+            android:layout_width="60dp"
+            android:layout_height="60dp"
+            android:background="#612"
+            app:layout_constraintLeft_toRightOf="@id/guideline_w"
+            app:layout_constraintTop_toBottomOf="@id/guideline_h" />
+    </....>
+    ```
+
+`ConstraintLayout`究竟有什么用呢？ 
+---
+
+`ConstraintLayout`允许您构建复杂的布局，而不必嵌套`View`和`ViewGroup`元素。
+它可以有效地解决布局嵌套过多的问题。我们平时编写界面，复杂的布局总会伴随着多层的嵌套，而嵌套越多，
+程序的性能也就越差。`ConstraintLayout`则是使用约束的方式来指定各个控件的位置和关系的，
+它有点类似于`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! 
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"
new file mode 100644
index 00000000..54dcdcfa
--- /dev/null
+++ "b/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
@@ -0,0 +1,127 @@
+# 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分析
+
+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获取
+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：线程本身的地址
diff --git a/AdavancedPart/Java b/AdavancedPart/Java
new file mode 100644
index 00000000..e69de29b
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..d4faa6f6
--- /dev/null
+++ "b/AdavancedPart/KMP\345\274\200\345\217\221.md"
@@ -0,0 +1,30 @@
+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 转换为不同平台的中间表示形式，最终生成目标代码。
+
+
+    	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/AdavancedPart/Library\351\241\271\347\233\256\344\270\255\350\265\204\346\272\220id\344\275\277\347\224\250case\346\227\266\346\212\245\351\224\231.md" "b/AdavancedPart/Library\351\241\271\347\233\256\344\270\255\350\265\204\346\272\220id\344\275\277\347\224\250case\346\227\266\346\212\245\351\224\231.md"
new file mode 100644
index 00000000..001a762b
--- /dev/null
+++ "b/AdavancedPart/Library\351\241\271\347\233\256\344\270\255\350\265\204\346\272\220id\344\275\277\347\224\250case\346\227\266\346\212\245\351\224\231.md"
@@ -0,0 +1,71 @@
+Library项目中资源id使用case时报错
+===
+
+在平时开发的过程中对一些常量的判断，都是使用`switch case`语句，因为`switch case`比`if else`的效率稍高。     
+但是也遇到了问题，就是在`library`中使用时会报错:      
+```java
+public void testClick(View view) {
+    int id = view.getId();
+    switch (id) {
+        case R.id.bt_pull:
+
+            break;
+        case R.id.bt_push:
+
+            break;
+    }
+}
+```
+我们来看一下错误提示:     
+
+![Image](https://github.com/CharonChui/Pictures/blob/master/library_r.error.png?raw=true)
+
+意思就是在`Android Library`的`Module`中的`switch`语句不能使用资源`ID`.这是为什么呢？ 我们都知道`R`文件中都是常量啊，`public static final`的，为什么不能用在`switch`语句中，继续看下去:      
+```
+Resource IDs are non final in th library projects since SDK tools r14, means that the library code cannot treat this IDs as constants.
+```
+说的灰常明白了，也就是说从14开始，library中的资源`id`就不是`final`类型的了，所以不是常量了。       
+
+在一个常规的`Android`项目中，资源`R`文件中的常量都是如下这样声明的:      
+`public static final int main=0x7f030004;`
+然后，从`ADT`14开始，在`library`项目中，它们将被这样声明:       
+`public static int main=0x7f030004;`
+
+也就是说在`library`项目中这些常量不是`final`的了。为什么这样做的原因也非常简单：当多个`library`项目结合时，这些字段的实际值(必须唯一的值)可能会冲突。在`ADT`14之前，所有的字段都是`final`的，这样就导致了一个结果，就是所有的`libraries`不论何时在被使用时都必须把他们所有的资源和相关的`Java`代码都伴随着主项目一起重新编译。这样做是不合理的，因为它会导致编译非常慢。这也会阻碍一些没有源码的`libraray`项目进行发布，极大的限制了`library`项目的使用范围。      
+
+那些字段不再是`final`的原因就是意味着`library jars`可以被编译一次，然后在其他项目中直接被服用。也就是意味着允许发布二进制版本的`library`项目(r15中开始支持)，这让编译变的更快。
+
+然而，这对`library`的源码会有一个影响。类似下面这样的代码就将无法编译:    
+```java
+public void testClick(View view) {
+    int id = view.getId();
+    switch (id) {
+        case R.id.bt_pull:
+
+            break;
+        case R.id.bt_push:
+
+            break;
+    }
+}
+```
+这是因为`swtich`语句要求所有`case`后的字段，例如`R.di.bt_pull`在编译的时候都应该是常量(就像可以直接把值拷贝进`.class`文件中)
+
+当然针对这个问题的解决方法也很简单：就是把`switch`语句改成`if-else`语句。幸运的是，在`eclise`中这是非常简单的。只需要在`switch`的关键字上按`Ctrl+1`（`Mac`上是`Cmd+1`)。(`eclipse`都辣么方便了，`Studio`更不用说了啊，直接按修复的快捷键就阔以了)。      
+上面的代码就将变成如下:     
+
+```java
+public void testClick(View view) {
+    int id = view.getId();
+    if (id == R.id.bt_pull) {
+    } else if (id == R.id.bt_push) {
+    }
+}
+```
+这在UI代码和性能的影响通常是微不足道的 - -！。
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git "a/Android\345\212\240\345\274\272/Mac\344\270\213\351\205\215\347\275\256adb\345\217\212Android\345\221\275\344\273\244.md" "b/AdavancedPart/Mac\344\270\213\351\205\215\347\275\256adb\345\217\212Android\345\221\275\344\273\244.md"
similarity index 84%
rename from "Android\345\212\240\345\274\272/Mac\344\270\213\351\205\215\347\275\256adb\345\217\212Android\345\221\275\344\273\244.md"
rename to "AdavancedPart/Mac\344\270\213\351\205\215\347\275\256adb\345\217\212Android\345\221\275\344\273\244.md"
index b4a40767..0f0ff7b6 100644
--- "a/Android\345\212\240\345\274\272/Mac\344\270\213\351\205\215\347\275\256adb\345\217\212Android\345\221\275\344\273\244.md"
+++ "b/AdavancedPart/Mac\344\270\213\351\205\215\347\275\256adb\345\217\212Android\345\221\275\344\273\244.md"
@@ -1,7 +1,7 @@
 Mac下配置adb及Android命令
 ===
 
-    带着欣喜若狂的心情，买了一个`Mac`本，刚拿到它的时候感觉真的是一件艺术品，哈哈。废话不多说，里面配置`Android`开发环境。
+带着欣喜若狂的心情，买了一个`Mac`本，刚拿到它的时候感觉真的是一件艺术品，哈哈。废话不多说，里面配置`Android`开发环境。
 
 1. 找到`android sdk`的本地路径，
     我的是：
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"
new file mode 100644
index 00000000..e7dcaaa0
--- /dev/null
+++ "b/AdavancedPart/OOM\351\227\256\351\242\230\345\210\206\346\236\220.md"
@@ -0,0 +1,941 @@
+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的长度所致，这种情况比较少。
+
+#### java.lang.OutOfMemoryError:  "Failed to allocate a " << byte_count << " byte allocation with " << total_bytes_free  << " free bytes and " << PrettySize(GetFreeMemoryUntilOOME()) << " until OOM";
+
+通常情况下是因为`java`堆内存不足导致的，即`Runtime.getRuntime().maxMemory()`获取到的最大内存无法满足要申请的内存大小时，这种情况比较好模拟，例如我们可以通过`new byte[]`的方式来申请超过`maxMemory()`的内存,但是也有一些情况是堆内存充裕，而且设备内存也充裕的情况下发生的。
+#### java.lang.OutOfMemoryError: Could not allocate JNI Env(代号JNIEnv)
+
+- cat /proc/pid/limits 描述linux系统对对应进程的限制:   
+```
+Limit                     Soft Limit           Hard Limit           Units     
+Max cpu time              unlimited            unlimited            seconds   
+Max file size             unlimited            unlimited            bytes     
+Max data size             unlimited            unlimited            bytes     
+Max stack size            8388608              unlimited            bytes   // 整个系统的   
+Max core file size        0                    unlimited            bytes     
+Max resident set          unlimited            unlimited            bytes     
+Max processes             17235                17235                processes // 整个系统的最大进程数，底层只有进程，线程也是通过进程实现的
+Max open files            32768                32768                files   // 每个进程最大打开文件的数量
+Max locked memory         67108864             67108864             bytes   // 线程创建过程中分配线程私有stack使用的mmap调用没有设置MAP_LOCKED，所以这个限制与线程创建过程无关  
+Max address space         unlimited            unlimited            bytes     
+Max file locks            unlimited            unlimited            locks     
+Max pending signals       17235                17235                signals   // c层信号个数阈值，与线程创建过程无关
+Max msgqueue size         819200               819200               bytes     
+Max nice priority         40                   40                   
+Max realtime priority     0                    0                    
+Max realtime timeout      unlimited            unlimited            us  
+```
+里面`Max open files`表示每个进程最大打开文件的数目，进程每打开一个文件就会产生一个文件描述符`fd`(记录在/proc/pid/fd中)
+
+验证: 触发大量的网络连接或者打开文件，每个连接处于独立的线程中并报出，每打开一个socket都会增加一个fd
+```java
+  private Runnable increaseFDRunnable = new Runnable() {
+      @Override
+      public void run() {
+          try {
+              for (int i = 0; i < 1000; i++) {
+                  new BufferedReader(new FileReader("/proc/" + Process.myPid() + "/status"));
+              }
+              Thread.sleep(Long.MAX_VALUE);
+          } catch (InterruptedException e) {
+              e.printStackTrace();
+          } catch (FileNotFoundException e) {
+              e.printStackTrace();
+          }
+      }
+  };
+```
+#### java.lang.OutOfMemoryError: pthread_create(1040KB statck) failed: Out of memory(代号1040)
+
+根据OOM的crash日志，我们发现都是从`Thread.start()`方法开始的,
+```java
+  public synchronized void start() {
+      /**
+       * This method is not invoked for the main method thread or "system"
+       * group threads created/set up by the VM. Any new functionality added
+       * to this method in the future may have to also be added to the VM.
+       *
+       * A zero status value corresponds to state "NEW".
+       */
+      // Android-changed: throw if 'started' is true
+      if (threadStatus != 0 || started)
+          throw new IllegalThreadStateException();
+
+      /* Notify the group that this thread is about to be started
+       * so that it can be added to the group's list of threads
+       * and the group's unstarted count can be decremented. */
+      group.add(this);
+
+      started = false;
+      try {
+          nativeCreate(this, stackSize, daemon);
+          started = true;
+      } finally {
+          try {
+              if (!started) {
+                  group.threadStartFailed(this);
+              }
+          } catch (Throwable ignore) {
+              /* do nothing. If start0 threw a Throwable then
+                it will be passed up the call stack */
+          }
+      }
+  }
+```
+上面的核心方法是`nativeCreate(this, stackSize, daemon);`
+这个方法有三个参数:  
+- this : Thread对象自身
+- stackSize : the desired stack size for the new thread, or zero to indicate that this parameter is to be ignored.该新创建的线程的栈的大小，单位是byte，一般默认情况下都是0，我们全局搜这个变量复制的地方，可以看到Thread有一个构造函数可以设置这个值
+```
+public Thread(ThreadGroup group, Runnable target, String name,
+              long stackSize) {
+    init(group, target, name, stackSize);
+}
+```
+- daemon : Whether or not the thread is a daemon thread.
+
+而nativeCreate方法的native实现，是在art/runtime/native/java_lang_thread.cc中，因为OOM主要是在Android 9.0系统发生，所以这里基于9.0系统的源码分析：`https://android.googlesource.com/platform/art/+/refs/tags/android-9.0.0_r41/runtime/native/java_lang_Thread.cc`。
+```java
+static void Thread_nativeCreate(JNIEnv* env, jclass, jobject java_thread, jlong stack_size,
+                                jboolean daemon) {
+  // There are sections in the zygote that forbid thread creation.
+  Runtime* runtime = Runtime::Current();
+  if (runtime->IsZygote() && runtime->IsZygoteNoThreadSection()) {
+    jclass internal_error = env->FindClass("java/lang/InternalError");
+    CHECK(internal_error != nullptr);
+    env->ThrowNew(internal_error, "Cannot create threads in zygote");
+    return;
+  }
+  Thread::CreateNativeThread(env, java_thread, stack_size, daemon == JNI_TRUE);
+}
+```
+里面又会调用到[art/runtime/thread.cc](https://android.googlesource.com/platform/art/+/refs/tags/android-9.0.0_r41/runtime/thread.cc)中的Thread::CreateNativeThread方法:    
+```java
+void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) {
+  CHECK(java_peer != nullptr);
+  Thread* self = static_cast<JNIEnvExt*>(env)->GetSelf();
+  if (VLOG_IS_ON(threads)) {
+    ScopedObjectAccess soa(env);
+    ArtField* f = jni::DecodeArtField(WellKnownClasses::java_lang_Thread_name);
+    ObjPtr<mirror::String> java_name =
+        f->GetObject(soa.Decode<mirror::Object>(java_peer))->AsString();
+    std::string thread_name;
+    if (java_name != nullptr) {
+      thread_name = java_name->ToModifiedUtf8();
+    } else {
+      thread_name = "(Unnamed)";
+    }
+    VLOG(threads) << "Creating native thread for " << thread_name;
+    self->Dump(LOG_STREAM(INFO));
+  }
+  Runtime* runtime = Runtime::Current();
+  // Atomically start the birth of the thread ensuring the runtime isn't shutting down.
+  bool thread_start_during_shutdown = false;
+  {
+    MutexLock mu(self, *Locks::runtime_shutdown_lock_);
+    if (runtime->IsShuttingDownLocked()) {
+      thread_start_during_shutdown = true;
+    } else {
+      runtime->StartThreadBirth();
+    }
+  }
+  if (thread_start_during_shutdown) {
+    ScopedLocalRef<jclass> error_class(env, env->FindClass("java/lang/InternalError"));
+    env->ThrowNew(error_class.get(), "Thread starting during runtime shutdown");
+    return;
+  }
+
+  // 1. native层创建thread
+  Thread* child_thread = new Thread(is_daemon);
+  // Use global JNI ref to hold peer live while child thread starts.
+  child_thread->tlsPtr_.jpeer = env->NewGlobalRef(java_peer);
+  // 2. FixStackSize方法里面会返回具体的Stack内存的大小
+  stack_size = FixStackSize(stack_size);
+  // Thread.start is synchronized, so we know that nativePeer is 0, and know that we're not racing
+  // to assign it.
+  env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer,
+                    reinterpret_cast<jlong>(child_thread));
+
+  // 3. java中的每一个线程都都应一个JNIEnv结构，这里的JNIEnvExt就是ART中的JNIEnv。下面的注释说明的很明白，这里可能会有oom
+  // Try to allocate a JNIEnvExt for the thread. We do this here as we might be out of memory and
+  // do not have a good way to report this on the child's side.
+  std::string error_msg;
+  std::unique_ptr<JNIEnvExt> child_jni_env_ext(
+      JNIEnvExt::Create(child_thread, Runtime::Current()->GetJavaVM(), &error_msg));
+  int pthread_create_result = 0;
+  if (child_jni_env_ext.get() != nullptr) {
+    // 4. child_jni_env_ext.get() != nullptr 才会继续
+    pthread_t new_pthread;
+    pthread_attr_t attr;
+    child_thread->tlsPtr_.tmp_jni_env = child_jni_env_ext.get();
+    CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
+    CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED),
+                       "PTHREAD_CREATE_DETACHED");
+    CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
+    // 5. 调用pthread_create创建线程，并返回结果
+    pthread_create_result = pthread_create(&new_pthread,
+                                           &attr,
+                                           Thread::CreateCallback,
+                                           child_thread);
+    CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
+    if (pthread_create_result == 0) {
+      // 6. 结果为0才是创建成功
+      // pthread_create started the new thread. The child is now responsible for managing the
+      // JNIEnvExt we created.
+      // Note: we can't check for tmp_jni_env == nullptr, as that would require synchronization
+      //       between the threads.
+      child_jni_env_ext.release();
+      return;
+    }
+  }
+  // Either JNIEnvExt::Create or pthread_create(3) failed, so clean up.
+  {
+    MutexLock mu(self, *Locks::runtime_shutdown_lock_);
+    runtime->EndThreadBirth();
+  }
+  // Manually delete the global reference since Thread::Init will not have been run.
+  env->DeleteGlobalRef(child_thread->tlsPtr_.jpeer);
+  child_thread->tlsPtr_.jpeer = nullptr;
+  delete child_thread;
+  child_thread = nullptr;
+  // TODO: remove from thread group?
+  env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer, 0);
+  {
+    std::string msg(child_jni_env_ext.get() == nullptr ?
+        StringPrintf("Could not allocate JNI Env: %s", error_msg.c_str()) :
+        // 具体的错误信息由pthread_create_result的返回的错误码给出。
+        StringPrintf("pthread_create (%s stack) failed: %s",
+                                 PrettySize(stack_size).c_str(), strerror(pthread_create_result)));
+    ScopedObjectAccess soa(env);
+    soa.Self()->ThrowOutOfMemoryError(msg.c_str());
+  }
+}
+```
+上面代码太多，分了四个部分:  
+1. native层创建thread
+2. FixStackSize方法里面会返回具体的Stack内存的大小
+```
+static size_t FixStackSize(size_t stack_size) {
+  // A stack size of zero means "use the default".
+  if (stack_size == 0) {
+    stack_size = Runtime::Current()->GetDefaultStackSize();
+  }
+  // Dalvik used the bionic pthread default stack size for native threads,
+  // so include that here to support apps that expect large native stacks.
+  stack_size += 1 * MB;
+  // It's not possible to request a stack smaller than the system-defined PTHREAD_STACK_MIN.
+  if (stack_size < PTHREAD_STACK_MIN) {
+    stack_size = PTHREAD_STACK_MIN;
+  }
+  if (Runtime::Current()->ExplicitStackOverflowChecks()) {
+    // It's likely that callers are trying to ensure they have at least a certain amount of
+    // stack space, so we should add our reserved space on top of what they requested, rather
+    // than implicitly take it away from them.
+    // 8k
+    stack_size += GetStackOverflowReservedBytes(kRuntimeISA);
+  } else {
+    // If we are going to use implicit stack checks, allocate space for the protected
+    // region at the bottom of the stack.
+    // 8k 8k
+    stack_size += Thread::kStackOverflowImplicitCheckSize +
+        GetStackOverflowReservedBytes(kRuntimeISA);
+  }
+  // Some systems require the stack size to be a multiple of the system page size, so round up.
+  stack_size = RoundUp(stack_size, kPageSize);
+  return stack_size;
+}
+```
+
+// static const size_t kStackOverflowImplicitCheckSize = 8 * KB;
+上面kStackOverflowImplicitCheckSize的值是8k，而前面是1m，1024k+8k+8k=1040k，这就是为什么crash信息里面java.lang.OutOfMemoryError pthread_create (1040KB stack) failed: Out of memory是1040kb的原因。
+
+3. java中的每一个线程都都应一个JNIEnv结构，这里的JNIEnvExt就是ART中的JNIEnv。下面的注释说明的很明白，这里可能会有oom，这里具体要看[JNIEnvExt::Create()](https://android.googlesource.com/platform/art/+/refs/tags/android-9.0.0_r41/runtime/jni_env_ext.cc)方法
+```
+const JNINativeInterface* JNIEnvExt::table_override_ = nullptr;
+
+JNIEnvExt* JNIEnvExt::Create(Thread* self_in, JavaVMExt* vm_in, std::string* error_msg) {
+  // 调用new JNIEnvExt构造函数
+  std::unique_ptr<JNIEnvExt> ret(new JNIEnvExt(self_in, vm_in, error_msg));
+  if (CheckLocalsValid(ret.get())) {
+    return ret.release();
+  }
+  return nullptr;
+}
+```
+代码中发现特确实会返回nullptr，只有在CheckLocalsValid(ret.get())返回false的时候才会
+```
+bool JNIEnvExt::CheckLocalsValid(JNIEnvExt* in) NO_THREAD_SAFETY_ANALYSIS {
+  if (in == nullptr) {
+    return false;
+  }
+  return in->locals_.IsValid();
+}
+```
+从代码上看，基本排除是传入的参数nullptr导致的，所以根本原因是locals.IsValid返回了false，而locals是JNIEnvExt的一个成员变量，在JNIEnvExt构造的时候通过成员列表方式初始化
+```
+JNIEnvExt::JNIEnvExt(Thread* self_in, JavaVMExt* vm_in, std::string* error_msg)
+    : self_(self_in),
+      vm_(vm_in),
+      local_ref_cookie_(kIRTFirstSegment),
+      locals_(kLocalsInitial, kLocal, IndirectReferenceTable::ResizableCapacity::kYes, error_msg),
+      monitors_("monitors", kMonitorsInitial, kMonitorsMax),
+      critical_(0),
+      check_jni_(false),
+      runtime_deleted_(false) {
+  MutexLock mu(Thread::Current(), *Locks::jni_function_table_lock_);
+  check_jni_ = vm_in->IsCheckJniEnabled();
+  functions = GetFunctionTable(check_jni_);
+  unchecked_functions_ = GetJniNativeInterface();
+}
+```
+
+而[locals_.isValid](https://android.googlesource.com/platform/art/+/refs/tags/android-9.0.0_r41/runtime/indirect_reference_table.cc)的方法的源码为:  
+```
+bool IndirectReferenceTable::IsValid() const {
+  return table_mem_map_.get() != nullptr;
+}
+```
+所以只可能是table_men_map为nullptr导致的。
+而[IndirectReferenceTable](https://android.googlesource.com/platform/art/+/refs/tags/android-9.0.0_r41/runtime/indirect_reference_table.cc)类，他的构造函数为
+```
+IndirectReferenceTable::IndirectReferenceTable(size_t max_count,
+                                               IndirectRefKind desired_kind,
+                                               ResizableCapacity resizable,
+                                               std::string* error_msg)
+    : segment_state_(kIRTFirstSegment),
+      kind_(desired_kind),
+      max_entries_(max_count),
+      current_num_holes_(0),
+      resizable_(resizable) {
+  CHECK(error_msg != nullptr);
+  CHECK_NE(desired_kind, kHandleScopeOrInvalid);
+  // Overflow and maximum check.
+  CHECK_LE(max_count, kMaxTableSizeInBytes / sizeof(IrtEntry));
+  // max_count是常量512，而sizeof(IrtEntry)是8，所以table_bytes = 512 * 8 = 4k
+  const size_t table_bytes = max_count * sizeof(IrtEntry);
+  table_mem_map_.reset(MemMap::MapAnonymous("indirect ref table", nullptr, table_bytes,
+                                            PROT_READ | PROT_WRITE, false, false, error_msg));
+  if (table_mem_map_.get() == nullptr && error_msg->empty()) {
+    *error_msg = "Unable to map memory for indirect ref table";
+  }
+  if (table_mem_map_.get() != nullptr) {
+    table_ = reinterpret_cast<IrtEntry*>(table_mem_map_->Begin());
+  } else {
+    table_ = nullptr;
+  }
+  segment_state_ = kIRTFirstSegment;
+  last_known_previous_state_ = kIRTFirstSegment;
+}
+```
+
+
+如果上面失败的话，那就只有一种情况就是 MemMap::MapAnonymous 失败了，而MemMap::MapAnonymous的作用是为JNIEnv结构体中的Indirect_Reference_table(C层用于存储JNI局部/全局变量)申请内存，我们继续看[MemMap](https://android.googlesource.com/platform/art/+/refs/tags/android-9.0.0_r41/runtime/mem_map.cc)
+```
+MemMap* MemMap::MapAnonymous(const char* name,
+                             uint8_t* expected_ptr,
+                             size_t byte_count,
+                             int prot,
+                             bool low_4gb,
+                             bool reuse,
+                             std::string* error_msg,
+                             bool use_ashmem) {
+#ifndef __LP64__
+  UNUSED(low_4gb);
+#endif
+  use_ashmem = use_ashmem && !kIsTargetLinux;
+  if (byte_count == 0) {
+    return new MemMap(name, nullptr, 0, nullptr, 0, prot, false);
+  }
+  size_t page_aligned_byte_count = RoundUp(byte_count, kPageSize);
+  int flags = MAP_PRIVATE | MAP_ANONYMOUS;
+  if (reuse) {
+    // reuse means it is okay that it overlaps an existing page mapping.
+    // Only use this if you actually made the page reservation yourself.
+    CHECK(expected_ptr != nullptr);
+    DCHECK(ContainedWithinExistingMap(expected_ptr, byte_count, error_msg)) << *error_msg;
+    flags |= MAP_FIXED;
+  }
+  if (use_ashmem) {
+    if (!kIsTargetBuild) {
+      // When not on Android (either host or assuming a linux target) ashmem is faked using
+      // files in /tmp. Ensure that such files won't fail due to ulimit restrictions. If they
+      // will then use a regular mmap.
+      struct rlimit rlimit_fsize;
+      CHECK_EQ(getrlimit(RLIMIT_FSIZE, &rlimit_fsize), 0);
+      use_ashmem = (rlimit_fsize.rlim_cur == RLIM_INFINITY) ||
+        (page_aligned_byte_count < rlimit_fsize.rlim_cur);
+    }
+  }
+  unique_fd fd;
+  if (use_ashmem) {
+    // android_os_Debug.cpp read_mapinfo assumes all ashmem regions associated with the VM are
+    // prefixed "dalvik-".
+    std::string debug_friendly_name("dalvik-");
+    debug_friendly_name += name;
+    // 1. 创建
+    fd.reset(ashmem_create_region(debug_friendly_name.c_str(), page_aligned_byte_count));
+    // == -1 就说明是fd超过了系统限制的最大fd量，错误信息中会有Too many open files的提示
+    if (fd.get() == -1) {
+      // We failed to create the ashmem region. Print a warning, but continue
+      // anyway by creating a true anonymous mmap with an fd of -1. It is
+      // better to use an unlabelled anonymous map than to fail to create a
+      // map at all.
+      PLOG(WARNING) << "ashmem_create_region failed for '" << name << "'";
+    } else {
+      // We succeeded in creating the ashmem region. Use the created ashmem
+      // region as backing for the mmap.
+      flags &= ~MAP_ANONYMOUS;
+    }
+  }
+  // We need to store and potentially set an error number for pretty printing of errors
+  int saved_errno = 0;
+  // 2. 调用mmap映射到用户态内存地址空间
+  void* actual = MapInternal(expected_ptr,
+                             page_aligned_byte_count,
+                             prot,
+                             flags,
+                             fd.get(),
+                             0,
+                             low_4gb);
+  saved_errno = errno;
+  if (actual == MAP_FAILED) {
+    if (error_msg != nullptr) {
+      if (kIsDebugBuild || VLOG_IS_ON(oat)) {
+        PrintFileToLog("/proc/self/maps", LogSeverity::WARNING);
+      }
+      *error_msg = StringPrintf("Failed anonymous mmap(%p, %zd, 0x%x, 0x%x, %d, 0): %s. "
+                                    "See process maps in the log.",
+                                expected_ptr,
+                                page_aligned_byte_count,
+                                prot,
+                                flags,
+                                fd.get(),
+                                strerror(saved_errno));
+    }
+    return nullptr;
+  }
+  if (!CheckMapRequest(expected_ptr, actual, page_aligned_byte_count, error_msg)) {
+    return nullptr;
+  }
+  return new MemMap(name, reinterpret_cast<uint8_t*>(actual), byte_count, actual,
+                    page_aligned_byte_count, prot, reuse);
+}
+```
+这里面又用到了`ashmem_create_region()`方法，该方法的作用就是创建一块匿名共享内存（Anonymous Shared Memory-Ashmem），并返回一个文件描述符，我们看一下[ashmem_create_region](https://android.googlesource.com/platform/system/core/+/4f6e8d7a00cbeda1e70cc15be9c4af1018bdad53/libcutils/ashmem-dev.c)的源码:   
+```
+/*
+ * ashmem_create_region - creates a new ashmem region and returns the file
+ * descriptor, or <0 on error
+ *
+ * `name' is an optional label to give the region (visible in /proc/pid/maps)
+ * `size' is the size of the region, in page-aligned bytes
+ */
+int ashmem_create_region(const char *name, size_t size)
+{
+	int fd, ret;
+  // 打开一个fd
+	fd = open(ASHMEM_DEVICE, O_RDWR);
+	if (fd < 0)
+		return fd;
+	if (name) {
+		char buf[ASHMEM_NAME_LEN];
+		strlcpy(buf, name, sizeof(buf));
+		ret = ioctl(fd, ASHMEM_SET_NAME, buf);
+		if (ret < 0)
+			goto error;
+	}
+	ret = ioctl(fd, ASHMEM_SET_SIZE, size);
+	if (ret < 0)
+		goto error;
+	return fd;
+error:
+	close(fd);
+	return ret;
+}
+```
+
+
+上面的两个步骤中，不论第一个步骤执行成功与否，都会执行第二步，但是执行的行为不同
+
+- 如果第一步执行成功，就会通过Andorid的匿名共享内存（Anonymous Shared Memory）分配4KB（一个page）内核态内存，然后再通过Linux的mmap调用映射到用户态虚拟内存地址空间。
+- 如果第一步执行失败，第二步就会通过Linux的mmap调用创建一段虚拟内存。
+
+而上面失败的情况主要有:  
+- 第一步失败的情况一般是内核分配内存失败，这种情况下，整个设备OS的内存应该都处于非常紧张的状态。但是我们从crash的信息里面看用户的内存还是挺充足的，所以排除这种情况。
+- 第二步失败的情况一般是进程虚拟内存地址空间耗尽。而且会打印Failed anonymous mmap的错误
+
+所以这里child_jni_env_ext.get() == nullptr 通常是因为第二步失败，也就是进程虚拟内存地址空间耗尽。所以这就是代号JNIEnv OOM的原因。
+
+```
+__BIONIC_ERRDEF( ENOMEM         ,  12, "Out of memory" )       
+__BIONIC_ERRDEF( EMFILE         ,  24, "Too many open files" ) 
+```
+当然代号JNIEnv还有一种原因就是FD打开太多，到达了最大限制。
+
+4. child_jni_env_ext.get() != nullptr 才会继续
+5. 调用pthread_create创建线程，并返回结果
+看一下[pthread_create](https://android.googlesource.com/platform/bionic.git/+/refs/tags/android-9.0.0_r41/libc/bionic/pthread_create.cpp)的代码
+```
+__BIONIC_WEAK_FOR_NATIVE_BRIDGE
+int pthread_create(pthread_t* thread_out, pthread_attr_t const* attr,
+                   void* (*start_routine)(void*), void* arg) {
+  ErrnoRestorer errno_restorer;
+  pthread_attr_t thread_attr;
+  if (attr == NULL) {
+    pthread_attr_init(&thread_attr);
+  } else {
+    thread_attr = *attr;
+    attr = NULL; // Prevent misuse below.
+  }
+  pthread_internal_t* thread = NULL;
+  void* child_stack = NULL;
+  // 1. 分配该线程对应的栈内存空间，如果返回result != 0 就直接返回result就说明失败了
+  int result = __allocate_thread(&thread_attr, &thread, &child_stack);
+  if (result != 0) {
+    return result;
+  }
+  // Create a lock for the thread to wait on once it starts so we can keep
+  // it from doing anything until after we notify the debugger about it
+  //
+  // This also provides the memory barrier we need to ensure that all
+  // memory accesses previously performed by this thread are visible to
+  // the new thread.
+  thread->startup_handshake_lock.init(false);
+  thread->startup_handshake_lock.lock();
+  thread->start_routine = start_routine;
+  thread->start_routine_arg = arg;
+  thread->set_cached_pid(getpid());
+  int flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM |
+      CLONE_SETTLS | CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID;
+  void* tls = reinterpret_cast<void*>(thread->tls);
+#if defined(__i386__)
+  // On x86 (but not x86-64), CLONE_SETTLS takes a pointer to a struct user_desc rather than
+  // a pointer to the TLS itself.
+  user_desc tls_descriptor;
+  __init_user_desc(&tls_descriptor, false, tls);
+  tls = &tls_descriptor;
+#endif
+  // 2. linux系统调用clone，执行真正的创建动作,而这个clone是创建新进程，Unix里面其实只有进程，而线程是POSIX标准定义的，因此这里的clone只是实现线程的一种手段。 clone后父进程和子进程共享内存， 因此当两个进程的内存共享之后，完全就符合“线程”的定义了。
+  int rc = clone(__pthread_start, child_stack, flags, thread, &(thread->tid), tls, &(thread->tid));
+  if (rc == -1) {
+    int clone_errno = errno;
+    // We don't have to unlock the mutex at all because clone(2) failed so there's no child waiting to
+    // be unblocked, but we're about to unmap the memory the mutex is stored in, so this serves as a
+    // reminder that you can't rewrite this function to use a ScopedPthreadMutexLocker.
+    thread->startup_handshake_lock.unlock();
+    if (thread->mmap_size != 0) {
+      munmap(thread->attr.stack_base, thread->mmap_size);
+    }
+    // clone失败就会报出clone failed的错误
+    async_safe_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: clone failed: %s",
+                          strerror(clone_errno));
+    return clone_errno;
+  }
+  int init_errno = __init_thread(thread);
+  if (init_errno != 0) {
+    // Mark the thread detached and replace its start_routine with a no-op.
+    // Letting the thread run is the easiest way to clean up its resources.
+    atomic_store(&thread->join_state, THREAD_DETACHED);
+    __pthread_internal_add(thread);
+    thread->start_routine = __do_nothing;
+    thread->startup_handshake_lock.unlock();
+    return init_errno;
+  }
+  // Publish the pthread_t and unlock the mutex to let the new thread start running.
+  *thread_out = __pthread_internal_add(thread);
+  thread->startup_handshake_lock.unlock();
+  return 0;
+}
+```
+上面第一步中__allocate_thread方法的源码为:   
+```
+static int __allocate_thread(pthread_attr_t* attr, pthread_internal_t** threadp, void** child_stack) {
+  size_t mmap_size;
+  uint8_t* stack_top;
+  if (attr->stack_base == NULL) {
+    // The caller didn't provide a stack, so allocate one.
+    // Make sure the stack size and guard size are multiples of PAGE_SIZE.
+    if (__builtin_add_overflow(attr->stack_size, attr->guard_size, &mmap_size)) return EAGAIN;
+    if (__builtin_add_overflow(mmap_size, sizeof(pthread_internal_t), &mmap_size)) return EAGAIN;
+    mmap_size = __BIONIC_ALIGN(mmap_size, PAGE_SIZE);
+    attr->guard_size = __BIONIC_ALIGN(attr->guard_size, PAGE_SIZE);
+    // 调用mmap分配栈内存，而mmap分配的内存赋值给了stack_base, stack_base不光是线程执行的栈，其中还存储了线程的其他信息(线程名、ThreadLocal变量等，这些信息都定义在pthread_internal_t结构体中)，而这个具体的大小就是前面我们分析的 1M + 8K + 8K = 1040K
+    attr->stack_base = __create_thread_mapped_space(mmap_size, attr->guard_size);
+    if (attr->stack_base == NULL) {
+      return EAGAIN;
+    }
+    stack_top = reinterpret_cast<uint8_t*>(attr->stack_base) + mmap_size;
+  } else {
+    // Remember the mmap size is zero and we don't need to free it.
+    mmap_size = 0;
+    stack_top = reinterpret_cast<uint8_t*>(attr->stack_base) + attr->stack_size;
+  }
+  // Mapped space(or user allocated stack) is used for:
+  //   pthread_internal_t
+  //   thread stack (including guard)
+  // To safely access the pthread_internal_t and thread stack, we need to find a 16-byte aligned boundary.
+  stack_top = reinterpret_cast<uint8_t*>(
+                (reinterpret_cast<uintptr_t>(stack_top) - sizeof(pthread_internal_t)) & ~0xf);
+  pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(stack_top);
+  if (mmap_size == 0) {
+    // If thread was not allocated by mmap(), it may not have been cleared to zero.
+    // So assume the worst and zero it.
+    memset(thread, 0, sizeof(pthread_internal_t));
+  }
+  attr->stack_size = stack_top - reinterpret_cast<uint8_t*>(attr->stack_base);
+  thread->mmap_size = mmap_size;
+  thread->attr = *attr;
+  if (!__init_tls(thread)) {
+    if (thread->mmap_size != 0) munmap(thread->attr.stack_base, thread->mmap_size);
+    return EAGAIN;
+  }
+  __init_thread_stack_guard(thread);
+  *threadp = thread;
+  *child_stack = stack_top;
+  return 0;
+}
+```
+而__create_thread_mapped_space方法的源码为
+```
+static void* __create_thread_mapped_space(size_t mmap_size, size_t stack_guard_size) {
+  // Create a new private anonymous map.
+  int prot = PROT_READ | PROT_WRITE;
+  // MAP_ANONYMOUS即匿名内存映射是在Linux中分配大块内存的常用方式。其分配的是虚拟内存，对应页的物理内存并不会立即分配，而是在用到的时候，触发内核的缺页中断，然后中断处理函数再分配物理内存。
+  int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
+  void* space = mmap(NULL, mmap_size, prot, flags, -1, 0);
+  if (space == MAP_FAILED) {
+    async_safe_format_log(ANDROID_LOG_WARN,
+                      "libc",
+                      "pthread_create failed: couldn't allocate %zu-bytes mapped space: %s",
+                      mmap_size, strerror(errno));
+    return NULL;
+  }
+  // Stack is at the lower end of mapped space, stack guard region is at the lower end of stack.
+  // Set the stack guard region to PROT_NONE, so we can detect thread stack overflow.
+  if (mprotect(space, stack_guard_size, PROT_NONE) == -1) {
+    async_safe_format_log(ANDROID_LOG_WARN, "libc",
+                          "pthread_create failed: couldn't mprotect PROT_NONE %zu-byte stack guard region: %s",
+                          stack_guard_size, strerror(errno));
+    munmap(space, mmap_size);
+    return NULL;
+  }
+  return space;
+}
+```
+
+而对于结果不为0的情况，那就只能是这里mmap分配虚拟内存失败。
+所以代号1040的OOM也是因为虚拟内存分配失败导致的。
+
+6. 结果为0才是创建成功
+7. 调用ThrowOutOfMemoryError报出错误信息
+如果child_jni_env_ext.get() == nullptr则报"Could not allocate JNI Env: %s", error_msg.c_str()的错误
+否则如果pthread_create_result != 0则报"pthread_create (%s stack) failed: %s"
+
+  ```
+  void Thread::ThrowOutOfMemoryError(const char* msg) {
+    LOG(ERROR) << StringPrintf("Throwing OutOfMemoryError \"%s\"%s",
+        msg, (throwing_OutOfMemoryError_ ? " (recursive case)" : ""));
+    ThrowLocation throw_location = GetCurrentLocationForThrow();
+    if (!throwing_OutOfMemoryError_) {
+      throwing_OutOfMemoryError_ = true;
+      ThrowNewException(throw_location, "Ljava/lang/OutOfMemoryError;", msg);
+      throwing_OutOfMemoryError_ = false;
+    } else {
+      Dump(LOG(ERROR));  // The pre-allocated OOME has no stack, so help out and log one.
+      SetException(throw_location, Runtime::Current()->GetPreAllocatedOutOfMemoryError());
+    }
+  }
+  ```
+
+
+
+最后总结一下: 不管是代号JNIEnv还是1040的OOM都是因为进程内虚拟内存地址空间耗尽导致的。
+在一个32位系统中，如果是4G的内存空间，系统内核将使用最上层的1G虚拟空间，用户空间的内存就只剩下3G或者更少，而创建一个进程需要1040k的虚拟内存，所以假设创建一个线程什么都不干，那最多也只能最大能创建3000个线程。当逻辑地址空间不足(已用逻辑空间地址可以查看 /proc/pid/status中的VmPeak/VmSize查看)，就会报出创建线程的OOM问题，`W/libc: pthread_create failed: couldn't allocate 1069056-bytes mapped space: Out of memory
+W/art: Throwing OutOfMemoryError "pthread_create (1040KB stack) failed: Try again"`
+
+
+
+而我在项目中遇到的问题是第二个也就是线程过多导致的，Android系统基于linux，所以linux的限制对Android同样实用，
+
+- cat /proc/sys/kernel/threads-max 规定了每个进程创建线程数量的上限
+
+验证:创建大量空线程，不做任何事情，直接sleep.
+```java
+private Runnable emptyRunnable = new Runnable() {
+    @Override
+    public void run() {
+        try {
+            for (int i = 0; i < 3000 ; i++) {
+                Thread.sleep(Long.MAX_VALUE);
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+};
+```
+
+
+连接手机
+```
+adb shell
+ps -A -l 
+```
+
+```
+1 S     0 15304     2 0  19   0   -     0 0      ?        00:00:00 kworker/7:2
+5 S  1000 15701  1001 0  19   0   - 1092845 0    ?        00:00:00 ndroid.keychain
+5 S 10458 15834  1001 0  29 -10   - 1100514 0    ?        00:00:02 com.example.oom
+5 S 10014 15956  1001 0  19   0   - 1106511 0    ?        00:00:01 com.android.mms
+1 S     0 16275     2 0  19   0   -     0 0      ?        00:00:00 kworker/1:2
+1 S     0 16542     2 0  19   0   -     0 0      ?        00:00:00 kworker/3:2
+1 S     0 16603     2 0  19   0   -     0 0      ?        00:00:00 kworker/2:2
+```
+
+pid为15834
+```
+cat proc/15834/status 
+```
+
+```
+PD1806:/ $ cat proc/15834/status                                                                                   
+Name:   com.example.oom
+Umask:  0077
+State:  S (sleeping)
+Tgid:   15834    // 进程组的ID
+Ngid:   0
+Pid:    15834     // 进程ID
+PPid:   1001      // 当前进程的父进程
+TracerPid:      0   // 跟踪当前进程的进程ID,如果是0表示没有跟踪
+Uid:    10458   10458   10458   10458
+Gid:    10458   10458   10458   10458
+FDSize: 128  // 当前分配的文件描述符，这个值不是当前进程使用文件描述符的上线
+Groups: 9997 20458 50458 
+VmPeak:  4403108 kB    // 当前进程运行过程中所占用内存的峰值
+VmSize:  4402056 kB    // 已用逻辑空间地址，虚拟内存大小。整个进程使用虚拟内存大小，是VmLib, VmExe, VmData, 和 VmStk的总和。
+VmLck:         0 kB
+VmPin:         0 kB
+VmHWM:     49108 kB    // 程序得到分配到物理内存的峰值
+VmRSS:     48920 kB    // 程序现在正在使用的物理内存
+RssAnon:            9268 kB
+RssFile:           39540 kB
+RssShmem:            112 kB
+VmData:  1737808 kB        // 所占用的虚拟内存
+VmStk:      8192 kB        // 任务在用户态的栈的大小 (stack_vm) 
+VmExe:        20 kB        // 程序所拥有的可执行虚拟内存的大小，代码段，不包括任务使用的库 (end_code-start_code) 
+VmLib:    163804 kB        // 被映像到任务的虚拟内存空间的库的大小 (exec_lib) 
+VmPTE:      1000 kB        // 该进程的所有页表的大小，单位：kb 
+VmPMD:        32 kB
+VmSwap:    15776 kB
+Threads:        17        // 当前的线程数
+SigQ:   0/21568
+SigPnd: 0000000000000000
+ShdPnd: 0000000000000000
+SigBlk: 0000000000001204
+SigIgn: 0000000000000000
+SigCgt: 00000006400084f8
+CapInh: 0000000000000000
+CapPrm: 0000000000000000
+CapEff: 0000000000000000
+CapBnd: 0000000000000000
+CapAmb: 0000000000000000
+Seccomp:        2
+Cpus_allowed:   ff
+Cpus_allowed_list:      0-7
+Mems_allowed:   1
+Mems_allowed_list:      0
+voluntary_ctxt_switches:        2132
+nonvoluntary_ctxt_switches:     328
+
+```
+
+```
+当线程数（可以在/proc/pid/status 中的threads项实时查看）超过/proc/sys/kernel/threads-max 中规定的上限时产生 OOM 崩溃。
+```
+
+## 定位验证方法:  
+
+Thread.UncaughtExceptionHandler捕获到OutOfMemoryError时记录/proc/pid目录下的如下信息:  
+
+- /proc/pid/fd目录下文件数(fd数)
+- /proc/pid/status中threads项（当前线程数目）
+- 当前设备的内存信息
+- OOM的日志信息（出了堆栈信息还包含其他的一些warning信息
+- 在灰度版本中通过一个定时器10分钟dump出应用所有的线程，当线程数超过一定阈值时，将当前的线程上报并预警，通过对这种异常情况的捕捉
+
+
+
+## 什么情况下虚拟内存地址空间才会耗尽
+
+
+说面分析了那么多，结论就是因为虚拟内存空间耗尽导致的，但是究竟什么情况才会出现耗尽的情况？
+
+内存是程序运行时的存储地址空间，可分为虚拟地址空间和物理地址空间。虚拟地址空间是相对进程而言的，每个进程都有独立的地址空间（如32位程序都有4GB的虚拟地址空间）。物理地址空间就是由硬件（内存条）提供的存储空间，物理地址空间被所有进程共享。
+
+Linux采用虚拟内存管理技术，每个进程都有各自独立的进程地址空间(即4G的线性虚拟空间)，无法直接访问物理内存。这样起到保护操作系统，并且让用户程序可使用比实际物理内存更大的地址空间。
+
+4G进程地址空间被划分两部分，内核空间和用户空间。用户空间(包括代码、数据、堆、共享库以及栈)从0到3G，内核空间(包括内核中的代码和数据结构)从3G到4G；
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/vm_linux.png?raw=true)  
+
+用户进程通常情况只能访问用户空间的虚拟地址，不能访问内核空间虚拟地址。只有用户进程进行系统调用(代表用户进程在内核态执行)等情况可访问到内核空间；
+用户空间对应进程，所以当进程切换，用户空间也会跟着变化；
+内核空间是由内核负责映射，不会跟着进程变化；内核空间地址有自己对应的页表，用户进程各自有不同额页表。
+
+从程序角度看，我们谈到的地址空间一般是虚拟地址空间，通过malloc或new分配的内存都虚拟地址空间的内存。虚拟地址空间与物理地址空间的都是以page为最小管理单元，page的大小因系统而异，一般都是4KB。虚拟地址空间有到物理地址空间的映射，如果要访问的虚拟地址空间没有映射到物理地址空间，操作系统会产生缺页中断，将虚拟地址空间映射到物理地址空间。
+
+因此，程度的虚拟地址空间比物理的地址空间要大的多。在较多进程同时运行时，物理地址空间有可能不够，操作系统会将一部物理地址空间的内容交换到磁盘，从而腾挪出一部分物理地址空间来。磁盘上的交换区，在linux上叫swap area，windows时叫page file。
+
+android底层基于linux，不过android是没有交换区的（为什么没有？），所以android系统的内存资源就更加宝贵。为更合理、充分利用有限内存资源，android引入一个low-memory-killer机制，在内存不足，根据规则回收一部分低优先级的进程，从而释放他们占有的内存。
+
+进程的内存空间只是虚拟内存，而程序运行需要的是物理内存(ram)，在必要时，操作系统会将程序运行中申请的虚拟内存映射到ram，让进程能够使用物理内存。进程所操作的空间都是虚拟地址空间，无法直接操作ram。java程序发生OOM并不表示ram不足，如果ram真的不足，android的memory killer就会发挥作用，它会杀死一些优先级比较低的进程来释放物理内存，让高优先级程序得到更多的内存。
+
+
+Android系统给每个进程分配了一定的虚拟地址空间大小，进程使用的虚拟空间如果超过阈值，就会触发OOM。所以只可能是线程太多，消耗了大部分虚拟内存地址空间，从而引发了当前进程空间不足。
+
+`adb shell dumpsys meminfo packagename` 可以查看占用的内存信息
+```
+PD1806:/system/bin $ dumpsys meminfo com.example.oom                                                   
+Applications Memory Usage (in Kilobytes):
+Uptime: 31807223 Realtime: 31807223
+
+** MEMINFO in pid 11380 [com.example.oom] **
+                   Pss  Private  Private  SwapPss     Heap     Heap     Heap
+                 Total    Dirty    Clean    Dirty     Size    Alloc     Free
+                ------   ------   ------   ------   ------   ------   ------
+  Native Heap    64227    64176        0       28    77824    72483     5340
+  Dalvik Heap     2158     2124        0       24     3590     2693      897
+ Dalvik Other    20804    20804        0        0                           
+        Stack       92       92        0        0                           
+       Ashmem        2        0        0        0                           
+      Gfx dev      892      892        0        0                           
+    Other dev       12        0       12        0                           
+     .so mmap     8595      212     6180       16                           
+    .apk mmap     2388     1964       60        0                           
+    .ttf mmap      105        0        0        0                           
+    .dex mmap     2375      176      552        0                           
+    .oat mmap      176        0      112        0                           
+    .art mmap     6796     6356      120        0                           
+   Other mmap       60        4        4        0                           
+   EGL mtrack    29808    29808        0        0                           
+    GL mtrack     3000     3000        0        0                           
+      Unknown    44350    44332        0        1                           
+        TOTAL   185909   173940     7040       69    81414    75176     6237
+ 
+ App Summary
+                       Pss(KB)
+                        ------
+           Java Heap:     8600
+         Native Heap:    64176
+                Code:     9256
+               Stack:       92
+            Graphics:    33700
+       Private Other:    65156
+              System:     4929
+ 
+               TOTAL:   185909       TOTAL SWAP PSS:       69
+ 
+ Objects
+               Views:       27         ViewRootImpl:        1
+         AppContexts:        5           Activities:        1
+              Assets:        7        AssetManagers:        0
+       Local Binders:       14        Proxy Binders:       31
+       Parcel memory:        4         Parcel count:       20
+    Death Recipients:        1      OpenSSL Sockets:        0
+            WebViews:        0
+ 
+ SQL
+         MEMORY_USED:        0
+  PAGECACHE_OVERFLOW:        0          MALLOC_SIZE:        0
+```
+
+查看当前手机的内存信息可以通过`cat /proc/meminfo`来查看
+```
+1|PD1806:/ $ cat /proc/meminfo                                                                                                                                    
+MemTotal:        5772000 kB
+MemFree:          129500 kB
+MemAvailable:    2594764 kB
+Buffers:            3968 kB
+Cached:          2330100 kB
+SwapCached:        12780 kB
+Active:          2678740 kB
+Inactive:         759120 kB
+Active(anon):     804284 kB
+Inactive(anon):   303532 kB
+Active(file):    1874456 kB
+Inactive(file):   455588 kB
+Unevictable:        3500 kB
+Mlocked:            3500 kB
+SwapTotal:       2097148 kB
+SwapFree:         488020 kB
+Dirty:                60 kB
+Writeback:             0 kB
+AnonPages:       1102064 kB
+Mapped:           743796 kB    映射文件大小
+Shmem:              1416 kB
+Slab:             548448 kB
+SReclaimable:     241428 kB
+SUnreclaim:       307020 kB
+KernelStack:      171856 kB
+PageTables:       108432 kB
+NFS_Unstable:          0 kB
+Bounce:                0 kB
+WritebackTmp:          0 kB
+CommitLimit:     4983148 kB  // 请的内存总数超过这个阈值就算overcommit，CommitLimit 就是overcommit的阈值，申请的内存总数超过CommitLimit的话就算是overcommit。
+Committed_AS:   131533804 kB // 表示所有进程已经申请的内存总大小，（注意是已经申请的，不是已经分配的），如果 Committed_AS 超过 CommitLimit 就表示发生了 overcommit，超出越多表示 overcommit 越严重。Committed_AS 的含义换一种说法就是，如果要绝对保证不发生OOM (out of memory) 需要多少物理内存。
+VmallocTotal:   263061440 kB
+VmallocUsed:           0 kB
+VmallocChunk:          0 kB
+CmaTotal:         217088 kB
+CmaFree:            1740 kB
+NR_KMALLOC:        23312 kB
+NR_VMALLOC:        33844 kB
+NR_DMA_NOR:            0 kB
+NR_DMA_CMA:        58348 kB
+NR_ION:           268600 kB
+free_ion:         121060 kB
+free_ion_pool:    121060 kB
+free_ion_heap:         0 kB
+NR_GPU:           267812 kB
+free_gpu:         154260 kB
+zram_size:        609440 kB
+zcache_size:           0 kB
+pcppages:           6944 kB
+ALL_MEM:         5675448 kB
+```
+
+
+- [Virtual Memory and Linux](https://events.linuxfoundation.org/sites/events/files/slides/elc_2016_mem.pdf)
+- [Android进程的内存管理分析](https://blog.csdn.net/gemmem/article/details/8920039)
+- [Android系统匿名共享内存（Anonymous Shared Memory）C++调用接口分析](https://blog.csdn.net/luoshengyang/article/details/6939890)
+- [Android系统匿名共享内存Ashmem（Anonymous Shared Memory）驱动程序源代码分析](https://blog.csdn.net/luoshengyang/article/details/6664554)
+- [Android系统匿名共享内存Ashmem（Anonymous Shared Memory）简要介绍和学习计划](https://blog.csdn.net/luoshengyang/article/details/6651971)
+- [虚拟内存那点事](https://sylvanassun.github.io/2017/10/29/2017-10-29-virtual_memory/ )
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git "a/AdavancedPart/RecyclerView\344\270\223\351\242\230.md" "b/AdavancedPart/RecyclerView\344\270\223\351\242\230.md"
new file mode 100644
index 00000000..1d381553
--- /dev/null
+++ "b/AdavancedPart/RecyclerView\344\270\223\351\242\230.md"
@@ -0,0 +1,594 @@
+RecyclerView专题
+===
+
+### 简介
+
+`RecyclerView`是`Android 5.0`提供的新控件，已经用了很长时间了，但是一直没有时间去仔细的梳理一下。现在项目不太紧，决定来整理下。
+
+官方文档中是这样介绍的:     
+`A flexible view for providing a limited window into a large data set.`
+
+`RecyclerView`比`listview`更先进更灵活，对于很多的视图它就是一个容器，可以有效的重用和滚动。当数据动态变化的时候请使用它。
+
+
+
+##### 专业术语:
+
+- `Adapter`: `A subclass of RecyclerView.Adapter responsible for providing views that represent items in a data set.`
+- `Position`: `The position of a data item within an Adapter.`
+- `Index`: `The index of an attached child view as used in a call to getChildAt(int). Contrast with Position.`
+- `Binding`: `The process of preparing a child view to display data corresponding to a position within the adapter.`
+- `Recycle (view)`: `A view previously used to display data for a specific adapter position may be placed in a cache for later reuse to display the same type of data again later. This can drastically improve performance by skipping initial layout inflation or construction.`
+- `Scrap (view)`: `A child view that has entered into a temporarily detached state during layout. Scrap views may be reused without becoming fully detached from the parent RecyclerView, either unmodified if no rebinding is required or modified by the adapter if the view was considered dirty.`
+- `Dirty (view)`: `A child view that must be rebound by the adapter before being displayed.`
+
+##### `RecyclerView`中的位置:      
+
+`RecyclerView`在`RecyclerView.Adapter`和`RecyclerView.LayoutManager`中引进了一个抽象的额外中间层来保证在布局计算的过程中能批量的监听到数据变化。这样介绍了`LayoutManager`追踪`adapter`数据变化来计算动画的时间。因为所有的`View`绑定都是在同一时间执行，所以这样也提高了性能和避免了一些非必要的绑定。       
+因为这个原因，在`RecylcerView`中有两种`position`类型相关的方法:     
+- `layout position`:  在最近一次`layout`计算是`item`的位置。这是`LayoutManager`角度中的位置。   
+- `adapter position`: `item`在`adapter`中的位置。这是从`Adapter`的角度中的位置。
+      
+这两种`position`除了在分发`adapter.notify`事件与之后计算布局更新的这段时间之内外都是相同的。  
+可以通过`getLayoutPosition(),findViewHolderForLayoutPosition(int)`方法来获取最近一次布局计算的`LayoutPosition`。这些`positions`包括从最近一次布局计算的所有改变。你可以根据这些位置来方便的得到用户当前从屏幕上所看到的。例如，如果在屏幕上有一个列表，用户请求的是第五个条目，你可以通过该方法来匹配当前用户正在看的内容。
+            
+另一种`AdapterPosition`相关的方法是`getAdapterPosition(),findViewHolderForAdapterPosition(int)`，当及时一些数据可能没有来得及被展现到布局上时便需要获取最新的`adapter`位置可以使用这些相关的方法。例如，如果你想获取一个条目的`ViewHOlder`的`click`事件时，你应该使用`getAdapterPosition()`。需要知道这些方法在`notifyDataSetChange()`方法被调用和新布局还没有被计算之前是不能使用的。鉴于这个原因，你应该小心的去处理这些方法有可能返回`NO_POSITION`或者`null`的情况。
+
+
+
+### 结构
+
+- `RecyclerView.Adapter`: 创建`View`并将数据集合绑定到`View`上
+- `ViewHolder`: 持有所有的用于绑定数据或者需要操作的`View`
+- `LayoutManager`: 布局管理器，负责摆放视图等相关操作
+- `ItemDecoration`: 负责绘制`Item`附近的分割线，通过`RecyclerView.addItemDecoration()`使用
+- `ItemAnimator`: 为`Item`的操作添加动画效果，如，增删条目等，通过`RecyclerView.setItemAnimator(new DefaultItemAnimator());`使用
+
+下图能更直观的了解:   
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/RecyclerView.png?raw=true)
+
+##### `RecyclerView`提供这些内置布局管理器:    
+
+- `LinearLayoutManager`: 以垂直或水平滚动列表方式显示项目。
+- `GridLayoutManager`: 在网格中显示项目。
+- `StaggeredGridLayoutManager`: 在分散对齐网格中显示项目。
+
+##### `RecyclerView.ItemDecoration`是一个抽象类，可以通过重写以下三个方法，来实现Item之间的偏移量或者装饰效果:     
+
+- `public void onDraw(Canvas c, RecyclerView parent)` 装饰的绘制在Item条目绘制之前调用，所以这有可能被Item的内容所遮挡
+- `public void onDrawOver(Canvas c, RecyclerView parent)` 装饰的绘制在Item条目绘制之后调用，因此装饰将浮于Item之上
+- `public void getItemOffsets(Rect outRect, int itemPosition, RecyclerView parent)` 与padding或margin类似，LayoutManager在测量阶段会调用该方法，计算出每一个Item的正确尺寸并设置偏移量。
+
+
+##### `ItemAnimator`触发于以下三种事件:    
+
+- 某条数据被插入到数据集合中
+- 从数据集合中移除某条数据
+- 更改数据集合中的某条数据
+
+在之前的版本中，当时据集合发生改变时通过调用`notifyDataSetChanged()`，来刷新列表，因为这样做会触发列表的重绘，所以并不会出现任何动画效果，因此需要调用一些以`notifyItem*()`作为前缀的特殊方法，比如:    
+
+- `public final void notifyItemInserted(int position)` 向指定位置插入`Item`
+- `public final void notifyItemRemoved(int position)` 移除指定位置`Item`
+- `public final void notifyItemChanged(int position)` 更新指定位置`Item`
+
+
+
+### 使用介绍:     
+
+- 添加依赖库           
+    ```
+    dependencies {
+        compile 'com.android.support:recyclerview-v7:23.4.0'
+    }
+    ```
+- 示例代码        
+
+    ```java
+    public class MainActivity extends AppCompatActivity {
+        private RecyclerView mRecyclerView;
+        private LinearLayoutManager mLayoutManager;
+        private RecyclerView.Adapter mAdapter;
+    
+        private String [] mDatas = {"Android","ios","jack","tony","window","mac","1234","hehe","495948", "89757", "66666"};
+    
+    
+        @Override
+        protected void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+            setContentView(R.layout.activity_main);
+            findView();
+            initView();
+        }
+    
+        private void findView() {
+            mRecyclerView = (RecyclerView) findViewById(R.id.rv);
+        }
+    
+        private void initView() {
+            // use this setting to improve performance if you know that changes
+            // in content do not change the layout size of the RecyclerView
+            mRecyclerView.setHasFixedSize(true);
+    
+            // use a linear layout manager
+            mLayoutManager = new LinearLayoutManager(this);
+            mLayoutManager.setOrientation(LinearLayoutManager.VERTICAL);
+            mRecyclerView.setLayoutManager(mLayoutManager);
+            mAdapter = new MyAdapter(mDatas);
+            mRecyclerView.setAdapter(mAdapter);
+        }
+    
+        private class MyAdapter extends RecyclerView.Adapter<MyHolder> {
+            private String[] mData;
+    
+            public MyAdapter(String[] data) {
+                mData = data;
+            }
+    
+            @Override
+            public MyHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+                // create a new view
+                View v = LayoutInflater.from(parent.getContext()).inflate(
+                        R.layout.item, parent, false);
+                MyHolder holder = new MyHolder(v);
+                return holder;
+            }
+    
+            @Override
+            public void onBindViewHolder(MyHolder holder, int position) {
+                holder.mTitleTv.setText(mData[position]);
+            }
+    
+            @Override
+            public int getItemCount() {
+                return mData == null ? 0 : mData.length;
+            }
+        }
+    
+        static class MyHolder extends RecyclerView.ViewHolder {
+            public TextView mTitleTv;
+    
+            public MyHolder(View itemView) {
+                super(itemView);
+                mTitleTv = (TextView) itemView;
+            }
+        }
+    }
+    ```
+    
+    `activity_main的内容如下: `     
+    ```xml
+    <android.support.v7.widget.RecyclerView xmlns:android="http://schemas.android.com/apk/res/android"
+        android:id="@+id/rv"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+    ```
+    
+    `item的内容如下：`     
+    ```xml
+    <?xml version="1.0" encoding="utf-8"?>
+    <TextView xmlns:android="http://schemas.android.com/apk/res/android"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:padding="20dp"
+        android:gravity="center_horizontal"
+        android:textSize="30dp">
+    
+    </TextView>
+    ```
+
+
+
+### 点击事件
+
+之前在使用`ListView`的时候，设置点击事件是非常方便的。    
+```java
+mListView.setOnItemClickListener();
+mListView.setOnItemLongClickListener();
+```
+但是`RecylcerView`确没有提供类似的方法。那我们只能是自己去处理。处理的方式也有两种:       
+
+
+- 通过`itemView.onClickListener()`以及`onLongClickListener()`     
+
+    ```java
+    public class MainActivity extends AppCompatActivity {
+        private RecyclerView mRecyclerView;
+        private LinearLayoutManager mLayoutManager;
+        private MyAdapter mAdapter;
+    
+        private String[] mDatas = {"Android", "ios", "jack", "tony", "window", "mac", "1234", "hehe", "495948", "89757", "66666"};
+    
+    
+        @Override
+        protected void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+            setContentView(R.layout.activity_main);
+            findView();
+            initView();
+        }
+    
+        private void findView() {
+            mRecyclerView = (RecyclerView) findViewById(R.id.rv);
+        }
+    
+        private void initView() {
+            // use this setting to improve performance if you know that changes
+            // in content do not change the layout size of the RecyclerView
+            mRecyclerView.setHasFixedSize(true);
+    
+            // use a linear layout manager
+            mLayoutManager = new LinearLayoutManager(this);
+            mLayoutManager.setOrientation(LinearLayoutManager.VERTICAL);
+            mRecyclerView.setLayoutManager(mLayoutManager);
+            mAdapter = new MyAdapter(mDatas);
+            mAdapter.setOnItemClickListener(new OnItemClickListener() {
+                @Override
+                public void onItemClick(View view, int position) {
+                    Toast.makeText(MainActivity.this, "click " + mDatas[position], Toast.LENGTH_SHORT).show();
+                }
+            });
+            mAdapter.setOnItemLongClickListener(new OnItemLongClickListener() {
+                @Override
+                public void onItemLongClick(View view, int position) {
+                    Toast.makeText(MainActivity.this, "long click " + mDatas[position], Toast.LENGTH_SHORT).show();
+                }
+            });
+            mRecyclerView.setAdapter(mAdapter);
+        }
+    
+        class MyAdapter extends RecyclerView.Adapter<MyHolder> {
+            private String[] mData;
+    
+            public MyAdapter(String[] data) {
+                mData = data;
+            }
+    
+            @Override
+            public MyHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+                // create a new view
+                View v = LayoutInflater.from(parent.getContext()).inflate(
+                        R.layout.item, parent, false);
+                MyHolder holder = new MyHolder(v);
+                return holder;
+            }
+    
+            @Override
+            public void onBindViewHolder(final MyHolder holder, final int position) {
+                holder.mTitleTv.setText(mData[position]);
+                if (mOnItemClickListener != null) {
+                    holder.itemView.setOnClickListener(new View.OnClickListener() {
+                        @Override
+                        public void onClick(View v) {
+                            mOnItemClickListener.onItemClick(holder.itemView, position);
+                        }
+                    });
+                }
+                if (mOnItemLongClickListener != null) {
+                    holder.itemView.setOnLongClickListener(new View.OnLongClickListener() {
+                        @Override
+                        public boolean onLongClick(View v) {
+                            mOnItemLongClickListener.onItemLongClick(holder.itemView, position);
+                            return true;
+                        }
+                    });
+                }
+            }
+    
+            @Override
+            public int getItemCount() {
+                return mData == null ? 0 : mData.length;
+            }
+    
+            private OnItemClickListener mOnItemClickListener;
+            private OnItemLongClickListener mOnItemLongClickListener;
+    
+            public void setOnItemClickListener(OnItemClickListener mOnItemClickListener) {
+                this.mOnItemClickListener = mOnItemClickListener;
+            }
+    
+            public void setOnItemLongClickListener(OnItemLongClickListener mOnItemLongClickListener) {
+                this.mOnItemLongClickListener = mOnItemLongClickListener;
+            }
+    
+        }
+    
+        static class MyHolder extends RecyclerView.ViewHolder {
+            public TextView mTitleTv;
+    
+            public MyHolder(View itemView) {
+                super(itemView);
+                mTitleTv = (TextView) itemView;
+            }
+        }
+    
+        public interface OnItemClickListener {
+            void onItemClick(View view, int position);
+        }
+    
+        public interface OnItemLongClickListener {
+            void onItemLongClick(View view, int position);
+        }
+    
+    }
+    ```
+- 使用`RecyclerView.OnItemTouchListener`           
+
+    虽然没有提供现成的监听器，但是提供了一个内部接口`OnItemTouchListener`。    
+    先来看看它的介绍:    
+    ```
+    /**
+     * An OnItemTouchListener allows the application to intercept touch events in progress at the
+     * view hierarchy level of the RecyclerView before those touch events are considered for
+     * RecyclerView's own scrolling behavior.
+     *
+     * <p>This can be useful for applications that wish to implement various forms of gestural
+     * manipulation of item views within the RecyclerView. OnItemTouchListeners may intercept
+     * a touch interaction already in progress even if the RecyclerView is already handling that
+     * gesture stream itself for the purposes of scrolling.</p>
+     *
+     * @see SimpleOnItemTouchListener
+     */
+    public static interface OnItemTouchListener {
+        ...
+    }
+    ```
+
+    说的和明白了，而且还让你看`SimpleOnItemTouchListener`，猜也能猜出来是一个默认的实现类。
+    好了直接上代码:      
+    ```java
+    public class MainActivity extends AppCompatActivity {
+    private RecyclerView mRecyclerView;
+    private LinearLayoutManager mLayoutManager;
+    private MyAdapter mAdapter;
+    private String[] mDatas = {"Android", "ios", "jack", "tony", "window", "mac", "1234", "hehe", "495948", "89757", "66666"};
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+        findView();
+        initView();
+    }
+
+    private void findView() {
+        mRecyclerView = (RecyclerView) findViewById(R.id.rv);
+    }
+
+    private void initView() {
+        // use this setting to improve performance if you know that changes
+        // in content do not change the layout size of the RecyclerView
+        mRecyclerView.setHasFixedSize(true);
+
+        // use a linear layout manager
+        mLayoutManager = new LinearLayoutManager(this);
+        mLayoutManager.setOrientation(LinearLayoutManager.VERTICAL);
+        mRecyclerView.setLayoutManager(mLayoutManager);
+        mAdapter = new MyAdapter(mDatas);
+        mRecyclerView.setAdapter(mAdapter);
+        mRecyclerView.addOnItemTouchListener(new RecyclerViewClickListener(this, mRecyclerView, new OnItemClickListener() {
+            @Override
+            public void onItemClick(View view, int position) {
+                Toast.makeText(MainActivity.this, mDatas[position], Toast.LENGTH_SHORT).show();
+            }
+
+            @Override
+            public void onItemLongClick(View view, int position) {
+                Toast.makeText(MainActivity.this, "Long Click " + mDatas[position], Toast.LENGTH_SHORT).show();
+            }
+        }));
+    }
+
+    class RecyclerViewClickListener extends RecyclerView.SimpleOnItemTouchListener {
+        private GestureDetector mGestureDetector;
+        private OnItemClickListener mListener;
+
+        public RecyclerViewClickListener(Context context, final RecyclerView recyclerView, OnItemClickListener listener) {
+            mListener = listener;
+            mGestureDetector = new GestureDetector(context,
+                    new GestureDetector.SimpleOnGestureListener() {
+                        @Override
+                        public boolean onSingleTapUp(MotionEvent e) {
+                            View childView = recyclerView.findChildViewUnder(e.getX(), e.getY());
+                            if (childView != null && mListener != null) {
+                                mListener.onItemClick(childView, recyclerView.getChildLayoutPosition(childView));
+                                return true;
+                            }
+                            return false;
+                        }
+
+                        @Override
+                        public void onLongPress(MotionEvent e) {
+                            View childView = recyclerView.findChildViewUnder(e.getX(), e.getY());
+                            if (childView != null && mListener != null) {
+                                mListener.onItemLongClick(childView, recyclerView.getChildLayoutPosition(childView));
+                            }
+                        }
+                    });
+        }
+
+        @Override
+        public boolean onInterceptTouchEvent(RecyclerView rv, MotionEvent e) {
+            if (mGestureDetector.onTouchEvent(e)) {
+                return true;
+            } else
+                return super.onInterceptTouchEvent(rv, e);
+        }
+
+        @Override
+        public void onTouchEvent(RecyclerView rv, MotionEvent e) {
+            super.onTouchEvent(rv, e);
+        }
+
+        @Override
+        public void onRequestDisallowInterceptTouchEvent(boolean disallowIntercept) {
+            super.onRequestDisallowInterceptTouchEvent(disallowIntercept);
+        }
+    }
+
+    interface OnItemClickListener {
+        void onItemClick(View view, int position);
+
+        void onItemLongClick(View view, int position);
+    }
+    ```
+    上面的实现稍微有些缺陷，就是如果我手指按住某个条目一直不抬起，他也会执行`Long click`事件，这显然是不合理的，至于怎么解决，就是可以不用`GestureDetector`，自己在`DOWN`和`UP`事件中去判断处理。
+
+### Headerview FooterView
+
+之前在`ListView`中提供了`addHeaderView()`和`addFooterView()`等方法，但是在`RecyclerView`中并没有提供类似的方法，那我们该如何添加呢？ 也很简单，就是通过`Adapter`中去添加，利用不同的`itemViewType`，然后根据不同的类型去在`onCreateViewHOlder`中创建不同的视图，通过这种方式来达到`headerview`和`FooterView`的效果。
+
+上一段简单的示例代码:     
+```java
+    public class HeaderAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
+    private static final int TYPE_HEADER = 0;
+    private static final int TYPE_ITEM = 1;
+    String[] data;
+
+    public HeaderAdapter(String[] data) {
+        this.data = data;
+    }
+
+    @Override
+    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+        if (viewType == TYPE_ITEM) {
+            //inflate your layout and pass it to view holder
+            return new VHItem(null);
+        } else if (viewType == TYPE_HEADER) {
+            //inflate your layout and pass it to view holder
+            return new VHHeader(null);
+        }
+
+        throw new RuntimeException("there is no type that matches the type " + viewType + " + make sure your using types correctly");
+    }
+
+    @Override
+    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
+        if (holder instanceof VHItem) {
+            String dataItem = getItem(position);
+            //cast holder to VHItem and set data
+        } else if (holder instanceof VHHeader) {
+            //cast holder to VHHeader and set data for header.
+        }
+    }
+
+    @Override
+    public int getItemCount() {
+        return data.length + 1;
+    }
+
+    @Override
+    public int getItemViewType(int position) {
+        if (isPositionHeader(position))
+            return TYPE_HEADER;
+
+        return TYPE_ITEM;
+    }
+
+    private boolean isPositionHeader(int position) {
+        return position == 0;
+    }
+
+    private String getItem(int position) {
+        return data[position - 1];
+    }
+
+    class VHItem extends RecyclerView.ViewHolder {
+        TextView title;
+
+        public VHItem(View itemView) {
+            super(itemView);
+        }
+    }
+
+    class VHHeader extends RecyclerView.ViewHolder {
+        Button button;
+
+        public VHHeader(View itemView) {
+            super(itemView);
+        }
+    }
+}
+```
+上面的代码对`LinearLayoutManger`是没问题的，但是使用`GridLayoutManager`呢？ 如果是两列，那添加的`HeaderView`并不是占据上第一行，而是`HeaderView`与第二个`ItemView`一起占据第一行。那该怎么处理呢？ 
+那就是使用`setSpanSizeLookup()`方法。
+比如:      
+```java
+recyclerView.setLayoutManager(new GridLayoutManager(this, 2));
+```
+在上面的基本设置中，我们的`spanCount`为2，每个`item`的`span size`为1，因此一个`header`需要的`span size`则为2。在我尝试着添加`header`之前，我想先看看如何设置`span size`。其实很简单。
+```java
+final GridLayoutManager manager = new GridLayoutManager(this, 2);
+recyclerView.setLayoutManager(manager);
+manager.setSpanSizeLookup(new GridLayoutManager.SpanSizeLookup() {
+  @Override
+  public int getSpanSize(int position) {
+    return adapter.isHeader(position) ? manager.getSpanCount() : 1;
+  }
+});
+```
+
+### 下拉刷新、自动加载
+
+##### 实现下拉刷新      
+实现下拉刷新也很简单了，可以使用`SwipeRefrshLayout`,`SwipeRefrshLayout`是`Google`官方提供的组件，可以实现下拉刷新的功能。已包含到`support.v4`包中。
+
+主要方法有:      
+
+- `setOnRefreshListener(OnRefreshListener)`:添加下拉刷新监听器
+- `setRefreshing(boolean)`:显示或者隐藏刷新进度条
+- `isRefreshing()`:检查是否处于刷新状态
+- `setColorSchemeResources()`:设置进度条的颜色主题，最多设置四种。
+
+```xml
+<android.support.v4.widget.SwipeRefreshLayout
+   android:layout_width="fill_parent"
+   android:layout_height="fill_parent"
+    android:scrollbars="vertical"
+    >
+   <android.support.v7.widget.RecyclerView
+       android:layout_width="fill_parent"
+       android:layout_height="fill_parent"
+       ></android.support.v7.widget.RecyclerView>
+</android.support.v4.widget.SwipeRefreshLayout>
+```
+具体实现就不写了。
+
+##### 实现滑动自动加载更多功能
+
+实现方式和`ListView`的实现方式类似，就是通过监听`scroll`时间，然后判断当前显示的`item`。
+
+```java
+//RecyclerView滑动监听
+mRecylcerView.setOnScrollListener(new RecyclerView.OnScrollListener() {
+    @Override
+    public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
+       super.onScrollStateChanged(recyclerView, newState);
+        if (newState ==RecyclerView.SCROLL_STATE_IDLE && lastVisibleItem + 1 ==adapter.getItemCount()) {
+            new Handler().postDelayed(new Runnable() {
+                @Override
+                public void run() {
+                    List<String> newDatas = new ArrayList<String>();
+                    for (int i = 0; i< 5; i++) {
+                        int index = i +1;
+                       newDatas.add("more item" + index);
+                    }
+                   adapter.addMoreItem(newDatas);
+                }
+            },1000);
+        }
+    }
+    @Override
+    public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
+        super.onScrolled(recyclerView,dx, dy);
+        lastVisibleItem =linearLayoutManager.findLastVisibleItemPosition();
+    }
+});
+```
+
+然后再通过结合`FooterView`以及增加几种状态就可以实现自动加载更多了。
+
+    	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/AdavancedPart/\345\246\202\344\275\225\350\256\251Service\345\270\270\351\251\273\345\206\205\345\255\230.md" "b/AdavancedPart/\345\246\202\344\275\225\350\256\251Service\345\270\270\351\251\273\345\206\205\345\255\230.md"
new file mode 100644
index 00000000..66548302
--- /dev/null
+++ "b/AdavancedPart/\345\246\202\344\275\225\350\256\251Service\345\270\270\351\251\273\345\206\205\345\255\230.md"
@@ -0,0 +1,25 @@
+如何让Service常驻内存
+===
+
+我非常鄙视这种行文，一个公司应该想到如何把产品做的更完善，而不是用这些技术来损害用户的利益，来获取自己肮脏的所谓的功能。
+
+- `Service`设置成`START_STICKY`，`kill`后会被重启（等待5秒左右），重传`Intent`，保持与重启前一样
+- ​通过`startForeground`将进程设置为前台进程，做前台服务，优先级和前台应用一个级别​，除非在系统内存非常缺，否则此进程不会被`kill`
+- 双进程`Service`:让2个进程互相保护，其中一个`Service`被清理后，另外没被清理的进程可以立即重启进程
+- `QQ`黑科技:在应用退到后台后，另起一个只有1像素的页面停留在桌面上，让自己保持前台状态，保护自己不被后台清理工具杀死
+- 在已经`root`的设备下，修改相应的权限文件，将`App`伪装成系统级的应用（`Android4.0`系列的一个漏洞，已经确认可行）
+- `Android`系统中当前进程(`Process`)`fork`出来的子进程，被系统认为是两个不同的进程。当父进程被杀死的时候，子进程仍然可以存活，并不受影响。
+    鉴于目前提到的在`Android-Service`层做双守护都会失败，我们可以`fork`出`c`进程，多进程守护。死循环在那检查是否还存在，
+	具体的思路如下（`Android5.0`以下可行）
+	- 用`C`编写守护进程(即子进程)，守护进程做的事情就是循环检查目标进程是否存在，不存在则启动它。
+	- 在`NDK`环境中将1中编写的`C`代码编译打包成可执行文件(`BUILD_EXECUTABLE`)。
+	- 主进程启动时将守护进程放入私有目录下，赋予可执行权限，启动它即可。
+	
+- 联系厂商，加入白名单
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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"
new file mode 100644
index 00000000..e268531a
--- /dev/null
+++ "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"
@@ -0,0 +1,560 @@
+屏幕适配之百分比方案详解
+===
+
+`Android`设备碎片化十分严重，在开发过程中的适配工作也非常很繁琐，有关屏幕适配的介绍请看之前的文章[屏幕适配](https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%B1%8F%E5%B9%95%E9%80%82%E9%85%8D.md)。
+
+最近看到`DrawerLayout`，`support v4`中提供的类，想到对`google`提供的这些支持库，自己一点都不熟悉，想着看看`Google`提供的支持库都有什么内容。结果看着看着在最后忽然看到了`Percent Support Library`。寻思怎么还百分比呢？仔细一看介绍，我擦，真是太有用了。
+> Percent Support Library
+> The Percent package provides APIs to support adding and managing percentage based dimensions in your app.
+
+> The Percent Support library adds support for the PercentLayoutHelper.PercentLayoutParams interface and various classes, such as PercentFrameLayout and PercentRelativeLayout.
+
+> After you download the Android Support Libraries, this library is located in the <sdk>/extras/android/support/percent directory. For more information on how to set up your project, follow the instructions in Adding libraries with resources.
+
+> The Gradle build script dependency identifier for this library is as follows:
+> `com.android.support:percent:23.3.0`
+
+看到了吗？ 说提供了`PercentFrameLayout`和`PercentRelativeLayout`来支持百分比了。这样不就完美的解决了适配的问题嘛。啥也不说了，立马配置`gradle`来瞧瞧。   
+
+> Subclass of FrameLayout that supports percentage based dimensions and margins. You can specify dimension or a margin of child by using attributes with "Percent" suffix. 
+
+上代码:    
+```xml
+<android.support.percent.PercentFrameLayout
+    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">
+    <ImageView
+        android:src="@mipmap/ic_launcher"
+        app:layout_widthPercent="50%"
+        app:layout_heightPercent="50%"
+        app:layout_marginTopPercent="25%"
+        app:layout_marginLeftPercent="25%"/>
+</android.support.percent.PercentFrameLayout>
+```
+效果如下:    
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/percent_frame.png?raw=true)    
+完美.   
+
+支持的属性:    
+
+- `layout_widthPercent`
+- `layout_heightPercent`
+- `layout_marginPercent`
+- `layout_marginLeftPercent`
+- `layout_marginTopPercent`
+- `layout_marginRightPercent`
+- `layout_marginBottomPercent`
+- `layout_marginStartPercent`
+- `layout_marginEndPercent`
+- `layout_aspectRatio`
+
+> It is not necessary to specify layout_width/height if you specify layout_widthPercent. However, if you want the view to be able to take up more space than what percentage value permits, you can add layout_width/height="wrap_content". In that case if the percentage size is too small for the View's content, it will be resized using wrap_content rule.
+
+如果指定了`layout_widthPercent`就不用指定`layout_width/height`属性了。(`Studio`可能会提示错误，设置忽略就好)。然而，如果你想要该`View`能够占用比设置的百分比值更大的空间时，你可以指定`layout_widht/height=“wrap_content”`。在这种情况下，如果设置的百分比值在显示内容时太小时，将会使用`wrap_content`的值重新计算。
+
+就是这个意思:如果指定的百分比太小怕显示不开的话，也可以给它指定`wrap_content`属性，这样当显示不开的时候就会使用`wrap_content`的值。   
+如下:     
+```xml
+<android.support.percent.PercentFrameLayout
+    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">
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:src="@mipmap/ic_launcher"
+        android:text="顶顶顶顶顶大大大"
+        android:textSize="30dp"
+        android:singleLine="true"
+        app:layout_widthPercent="30%"
+        app:layout_heightPercent="5%"
+        app:layout_marginTopPercent="25%"
+        app:layout_marginLeftPercent="25%"/>
+</android.support.percent.PercentFrameLayout>
+```
+
+效果:   
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/percent_wrap.png?raw=true)    
+
+加入`wrap_content`后一点效果也没有啊，还是显示不全啊，和没加`wrap_content`一样，- -!
+
+
+你也可以通过只设置`width`或者`height`和`layout_aspectRatio`这种比例值的方式来让第另一个值自动计算。例如，如果你想要使用`16:9`的比例，你可以使用:    
+```xml
+android:layout_width="300dp"
+app:layout_aspectRatio="178%"
+```
+
+这样将会在宽固定为`300dp`的基础上以16:9(1.78:1)来计算高度。
+
+`PercentRelativeLayout`的使用都是一样的，这里就不贴了。   
+
+那它是怎么实现的呢？其实就是内部给通过属性换算，把本布局的宽高和百分比去计算每个`view`的大小和位置。但是还有为什么上面设置的`wrap_content`无效呢？是我理解错了吗？
+
+带着这两个疑问我们来看下源码:    
+```java
+public class PercentFrameLayout extends FrameLayout {
+    private final PercentLayoutHelper mHelper = new PercentLayoutHelper(this);
+
+    public PercentFrameLayout(Context context) {
+        super(context);
+    }
+
+    public PercentFrameLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public PercentFrameLayout(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    @Override
+    protected LayoutParams generateDefaultLayoutParams() {
+        return new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+    }
+
+    @Override
+    public LayoutParams generateLayoutParams(AttributeSet attrs) {
+        return new LayoutParams(getContext(), attrs);
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        mHelper.adjustChildren(widthMeasureSpec, heightMeasureSpec);
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        // 从名字上就能看出来下面就是处理如果指定百分比过小不足显示内容时，就去使用`wrap_content`的逻辑
+        if (mHelper.handleMeasuredStateTooSmall()) {
+            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        }
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+        mHelper.restoreOriginalParams();
+    }
+
+    public static class LayoutParams extends FrameLayout.LayoutParams
+            implements PercentLayoutHelper.PercentLayoutParams {
+
+        private PercentLayoutHelper.PercentLayoutInfo mPercentLayoutInfo;
+
+        public LayoutParams(Context c, AttributeSet attrs) {
+            super(c, attrs);
+            // PercentLayoutInfo中去解析自定义属性的值
+            mPercentLayoutInfo = PercentLayoutHelper.getPercentLayoutInfo(c, attrs);
+        }
+
+        public LayoutParams(int width, int height) {
+            super(width, height);
+        }
+
+        public LayoutParams(int width, int height, int gravity) {
+            super(width, height, gravity);
+        }
+
+        public LayoutParams(ViewGroup.LayoutParams source) {
+            super(source);
+        }
+
+        public LayoutParams(MarginLayoutParams source) {
+            super(source);
+        }
+
+        public LayoutParams(FrameLayout.LayoutParams source) {
+            super((MarginLayoutParams) source);
+            gravity = source.gravity;
+        }
+
+        public LayoutParams(LayoutParams source) {
+            this((FrameLayout.LayoutParams) source);
+            mPercentLayoutInfo = source.mPercentLayoutInfo;
+        }
+
+        @Override
+        public PercentLayoutHelper.PercentLayoutInfo getPercentLayoutInfo() {
+            if (mPercentLayoutInfo == null) {
+                mPercentLayoutInfo = new PercentLayoutHelper.PercentLayoutInfo();
+            }
+
+            return mPercentLayoutInfo;
+        }
+
+        @Override
+        protected void setBaseAttributes(TypedArray a, int widthAttr, int heightAttr) {
+            PercentLayoutHelper.fetchWidthAndHeight(this, a, widthAttr, heightAttr);
+        }
+    }
+}
+```
+源码不长，主要是三个部分:    
+
+- 重写`onMeasure`，根据百分比转换成对应的尺寸
+- 重写`onLayout`
+- 自定义`LayoutParams`，在`FrameLayout.LayoutParams`的基础上多实现了一个接口。包含了`PercentLayoutHelper.PercentLayoutInfo `属性，而文档中对`PercentLayoutInfo`的介绍是`Container for information about percentage dimensions and margins. It acts as an extension for LayoutParams.`
+
+
+我们也先一步步的来分析，首先看下`mHelper.adjustChildren(widthMeasureSpec, heightMeasureSpec);`:      
+```java
+/**
+ * Iterates over children and changes their width and height to one calculated from percentage
+ * values.
+ * @param widthMeasureSpec Width MeasureSpec of the parent ViewGroup.
+ * @param heightMeasureSpec Height MeasureSpec of the parent ViewGroup.
+ */
+public void adjustChildren(int widthMeasureSpec, int heightMeasureSpec) {
+    if (Log.isLoggable(TAG, Log.DEBUG)) {
+        Log.d(TAG, "adjustChildren: " + mHost + " widthMeasureSpec: "
+                + View.MeasureSpec.toString(widthMeasureSpec) + " heightMeasureSpec: "
+                + View.MeasureSpec.toString(heightMeasureSpec));
+    }
+
+    int widthHint = View.MeasureSpec.getSize(widthMeasureSpec);
+    int heightHint = View.MeasureSpec.getSize(heightMeasureSpec);
+    // mHost是由构造函数传递过来的，就是PercentFrameLayout自身。
+    for (int i = 0, N = mHost.getChildCount(); i < N; i++) {
+        View view = mHost.getChildAt(i);
+        ViewGroup.LayoutParams params = view.getLayoutParams();
+        if (Log.isLoggable(TAG, Log.DEBUG)) {
+            Log.d(TAG, "should adjust " + view + " " + params);
+        }
+        if (params instanceof PercentLayoutParams) {
+            // 通过PercentLayoutParams. getPercentLayoutInfo()方法得到PercentLayoutInfo，至于PercentLayoutInfo类在上面也说过了。
+            PercentLayoutInfo info =
+                    ((PercentLayoutParams) params).getPercentLayoutInfo();
+            if (Log.isLoggable(TAG, Log.DEBUG)) {
+                Log.d(TAG, "using " + info);
+            }
+            if (info != null) {
+                if (params instanceof ViewGroup.MarginLayoutParams) {
+                    // PercentFrameLayout.LayoutParams继承自FrameLayout.LayoutParams，而FrameLayout.LayoutParams又继承自ViewGroup.MarginLayoutParams
+                    info.fillMarginLayoutParams(view, (ViewGroup.MarginLayoutParams) params,
+                            widthHint, heightHint);
+                } else {
+                    info.fillLayoutParams(params, widthHint, heightHint);
+                }
+            }
+        }
+    }
+}
+```
+所以上面代码的意思就是通过对每个子`View`调用`getLayoutParams`方法，然后从该`LayoutParams`中获取到它的`PercentLayoutInfo`属性，然后再调用`PercentLayoutInfo.fillMarginLayoutParams()`方法。
+
+那我们继续看一下`PercentLayoutInfo.fillMarginLayoutParams()`方法的实现，该方法是根据百分比去设置尺寸和margin:    
+```java
+/**
+ * Fills {@code ViewGroup.MarginLayoutParams} dimensions and margins based on percentage
+ * values.
+ */
+public void fillMarginLayoutParams(View view, ViewGroup.MarginLayoutParams params,
+        int widthHint, int heightHint) {
+    // 根据百分比值设置View的尺寸
+    fillLayoutParams(params, widthHint, heightHint);
+
+    // 从注释中就能知道，fillLayoutParams是计算尺寸，那下面这部分就是处理margin了
+    // mPreservedParams来记录原始的margin值
+    // Preserve the original margins, so we can restore them after the measure step.
+    mPreservedParams.leftMargin = params.leftMargin;
+    mPreservedParams.topMargin = params.topMargin;
+    mPreservedParams.rightMargin = params.rightMargin;
+    mPreservedParams.bottomMargin = params.bottomMargin;
+    MarginLayoutParamsCompat.setMarginStart(mPreservedParams,
+            MarginLayoutParamsCompat.getMarginStart(params));
+    MarginLayoutParamsCompat.setMarginEnd(mPreservedParams,
+            MarginLayoutParamsCompat.getMarginEnd(params));
+
+    if (leftMarginPercent >= 0) {
+        params.leftMargin = (int) (widthHint * leftMarginPercent);
+    }
+    if (topMarginPercent >= 0) {
+        params.topMargin = (int) (heightHint * topMarginPercent);
+    }
+    if (rightMarginPercent >= 0) {
+        params.rightMargin = (int) (widthHint * rightMarginPercent);
+    }
+    if (bottomMarginPercent >= 0) {
+        params.bottomMargin = (int) (heightHint * bottomMarginPercent);
+    }
+    boolean shouldResolveLayoutDirection = false;
+    if (startMarginPercent >= 0) {
+        MarginLayoutParamsCompat.setMarginStart(params,
+                (int) (widthHint * startMarginPercent));
+        shouldResolveLayoutDirection = true;
+    }
+    if (endMarginPercent >= 0) {
+        MarginLayoutParamsCompat.setMarginEnd(params,
+                (int) (widthHint * endMarginPercent));
+        shouldResolveLayoutDirection = true;
+    }
+    if (shouldResolveLayoutDirection && (view != null)) {
+        // Force the resolve pass so that start / end margins are propagated to the
+        // matching left / right fields
+        MarginLayoutParamsCompat.resolveLayoutDirection(params,
+                ViewCompat.getLayoutDirection(view));
+    }
+    if (Log.isLoggable(TAG, Log.DEBUG)) {
+        Log.d(TAG, "after fillMarginLayoutParams: (" + params.width + ", " + params.height
+                + ")");
+    }
+}
+```
+
+再看一下`PercentLayoutInfo.fillLayoutParams()`的实现，该方法是通过百分比设置`View`的尺寸:
+
+```java
+/**
+ * Fills {@code ViewGroup.LayoutParams} dimensions based on percentage values.
+ */
+public void fillLayoutParams(ViewGroup.LayoutParams params, int widthHint,
+        int heightHint) {
+    // mPreservedParams来记录原始的宽高值
+    // Preserve the original layout params, so we can restore them after the measure step.
+    mPreservedParams.width = params.width;
+    mPreservedParams.height = params.height;
+
+    // We assume that width/height set to 0 means that value was unset. This might not
+    // necessarily be true, as the user might explicitly set it to 0. However, we use this
+    // information only for the aspect ratio. If the user set the aspect ratio attribute,
+    // it means they accept or soon discover that it will be disregarded.
+    final boolean widthNotSet =
+            (mPreservedParams.mIsWidthComputedFromAspectRatio
+                    || mPreservedParams.width == 0) && (widthPercent < 0);
+    final boolean heightNotSet =
+            (mPreservedParams.mIsHeightComputedFromAspectRatio
+                    || mPreservedParams.height == 0) && (heightPercent < 0);
+
+    // 如果指定了百分比属性，就用宽高值和百分比去算出具体的宽高
+    if (widthPercent >= 0) {
+        // 看到了吗？是根据父`View	`的宽高来乘以百分比，不是根据整个屏幕的宽高，这样可能会有问题，要是ListView这种的高度没法算了
+        params.width = (int) (widthHint * widthPercent);
+    }
+
+    if (heightPercent >= 0) {
+        params.height = (int) (heightHint * heightPercent);
+    }
+    // 如果指定了宽高的比例值，就用比例值去算出宽高，从这里能看出`aspectRatio`的优先级比百分比要高。他可以覆盖百分比之前设置的值。
+    if (aspectRatio >= 0) {
+        if (widthNotSet) {
+            params.width = (int) (params.height * aspectRatio);
+            // Keep track that we've filled the width based on the height and aspect ratio.
+            mPreservedParams.mIsWidthComputedFromAspectRatio = true;
+        }
+        if (heightNotSet) {
+            params.height = (int) (params.width / aspectRatio);
+            // Keep track that we've filled the height based on the width and aspect ratio.
+            mPreservedParams.mIsHeightComputedFromAspectRatio = true;
+        }
+    }
+
+    if (Log.isLoggable(TAG, Log.DEBUG)) {
+        Log.d(TAG, "after fillLayoutParams: (" + params.width + ", " + params.height + ")");
+    }
+}
+```    
+
+到这里`onMeasure`中通过百分比值设置宽高以及`margin`的部分就看完了，那我们接着看一下关于百分比值过小时对`wrap_content`的处理:     
+```java
+if (mHelper.handleMeasuredStateTooSmall()) {
+    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+}
+```
+
+看一下`PercentLayoutHelper.handleMeasuredStateTooSmall()`方法的实现:     
+```java
+/**
+ * Iterates over children and checks if any of them would like to get more space than it
+ * received through the percentage dimension.
+ *
+ * If you are building a layout that supports percentage dimensions you are encouraged to take
+ * advantage of this method. The developer should be able to specify that a child should be
+ * remeasured by adding normal dimension attribute with {@code wrap_content} value. For example
+ * he might specify child's attributes as {@code app:layout_widthPercent="60%p"} and
+ * {@code android:layout_width="wrap_content"}. In this case if the child receives too little
+ * space, it will be remeasured with width set to {@code WRAP_CONTENT}.
+ *
+ * @return True if the measure phase needs to be rerun because one of the children would like
+ * to receive more space.
+ */
+public boolean handleMeasuredStateTooSmall() {
+    boolean needsSecondMeasure = false;
+    for (int i = 0, N = mHost.getChildCount(); i < N; i++) {
+        View view = mHost.getChildAt(i);
+        ViewGroup.LayoutParams params = view.getLayoutParams();
+        if (Log.isLoggable(TAG, Log.DEBUG)) {
+            Log.d(TAG, "should handle measured state too small " + view + " " + params);
+        }
+        if (params instanceof PercentLayoutParams) {
+            PercentLayoutInfo info =
+                    ((PercentLayoutParams) params).getPercentLayoutInfo();
+            if (info != null) {
+                // shouldHandleMeasuredWidthTooSmall方法来进行判断
+                if (shouldHandleMeasuredWidthTooSmall(view, info)) {
+                    needsSecondMeasure = true;
+                    params.width = ViewGroup.LayoutParams.WRAP_CONTENT;
+                }
+                if (shouldHandleMeasuredHeightTooSmall(view, info)) {
+                    needsSecondMeasure = true;
+                    params.height = ViewGroup.LayoutParams.WRAP_CONTENT;
+                }
+            }
+        }
+    }
+    if (Log.isLoggable(TAG, Log.DEBUG)) {
+        Log.d(TAG, "should trigger second measure pass: " + needsSecondMeasure);
+    }
+    return needsSecondMeasure;
+}
+```
+
+那继续看一下`shouldHandleMeasuredWidthTooSmall()`方法:        
+```java
+private static boolean shouldHandleMeasuredWidthTooSmall(View view, PercentLayoutInfo info) {
+    int state = ViewCompat.getMeasuredWidthAndState(view) & ViewCompat.MEASURED_STATE_MASK;
+    return state == ViewCompat.MEASURED_STATE_TOO_SMALL && info.widthPercent >= 0 &&
+            info.mPreservedParams.width == ViewGroup.LayoutParams.WRAP_CONTENT;
+}
+```
+
+继续看`ViewCompat.getMeasuredWidthAndState()`的源码:   
+```java
+public static int getMeasuredWidthAndState(View view) {
+    return IMPL.getMeasuredWidthAndState(view);
+}
+```
+继续往下看，这个`IMPL`是什么呢？    
+```java
+static final ViewCompatImpl IMPL;
+static {
+    final int version = android.os.Build.VERSION.SDK_INT;
+    if (version >= 23) {
+        IMPL = new MarshmallowViewCompatImpl();
+    } else if (version >= 21) {
+        IMPL = new LollipopViewCompatImpl();
+    } else if (version >= 19) {
+        IMPL = new KitKatViewCompatImpl();
+    } else if (version >= 17) {
+        IMPL = new JbMr1ViewCompatImpl();
+    } else if (version >= 16) {
+        IMPL = new JBViewCompatImpl();
+    } else if (version >= 15) {
+        IMPL = new ICSMr1ViewCompatImpl();
+    } else if (version >= 14) {
+        IMPL = new ICSViewCompatImpl();
+    } else if (version >= 11) {
+        IMPL = new HCViewCompatImpl();
+    } else if (version >= 9) {
+        IMPL = new GBViewCompatImpl();
+    } else if (version >= 7) {
+        IMPL = new EclairMr1ViewCompatImpl();
+    } else {
+        IMPL = new BaseViewCompatImpl();
+    }
+}
+```
+继续看，`IMPL.getMeasuredWidthAndState()`，方法其实最终就是使用的`BaseViewCompatImpl.getMeasuredWidthAndState()`方法，接着看它的的源码:   
+```java
+@Override
+    public int getMeasuredWidthAndState(View view) {
+        return view.getMeasuredWidth();
+    }
+```
+最后就是调用了`getMeasuredWidth()`方法。  没毛病- -!
+
+
+`onMeasure`的到这里就分析完了。       
+那接着来看一下`onLayout`方法,`onLayout`方法直接调用了`PercentLayoutHelper.restoreOriginalParams`，:      
+```java
+/**
+ * Iterates over children and restores their original dimensions that were changed for
+ * percentage values. Calling this method only makes sense if you previously called
+ * {@link PercentLayoutHelper#adjustChildren(int, int)}.
+ */
+public void restoreOriginalParams() {
+    for (int i = 0, N = mHost.getChildCount(); i < N; i++) {
+        View view = mHost.getChildAt(i);
+        ViewGroup.LayoutParams params = view.getLayoutParams();
+        if (Log.isLoggable(TAG, Log.DEBUG)) {
+            Log.d(TAG, "should restore " + view + " " + params);
+        }
+        if (params instanceof PercentLayoutParams) {
+            PercentLayoutInfo info =
+                    ((PercentLayoutParams) params).getPercentLayoutInfo();
+            if (Log.isLoggable(TAG, Log.DEBUG)) {
+                Log.d(TAG, "using " + info);
+            }
+            if (info != null) {
+                if (params instanceof ViewGroup.MarginLayoutParams) {
+                    info.restoreMarginLayoutParams((ViewGroup.MarginLayoutParams) params);
+                } else {
+                    info.restoreLayoutParams(params);
+                }
+            }
+        }
+    }
+}
+```
+
+调用了`PercentLayoutInfo.restoreMarginLayoutParams()`方法，我们看下它的源码:    
+```java
+/**
+ * Restores original dimensions and margins after they were changed for percentage based
+ * values. Calling this method only makes sense if you previously called
+ * {@link PercentLayoutHelper.PercentLayoutInfo#fillMarginLayoutParams}.
+ */
+public void restoreMarginLayoutParams(ViewGroup.MarginLayoutParams params) {
+    restoreLayoutParams(params);
+    // mPreservedParams的值在之前ad
+    params.leftMargin = mPreservedParams.leftMargin;
+    params.topMargin = mPreservedParams.topMargin;
+    params.rightMargin = mPreservedParams.rightMargin;
+    params.bottomMargin = mPreservedParams.bottomMargin;
+    MarginLayoutParamsCompat.setMarginStart(params,
+            MarginLayoutParamsCompat.getMarginStart(mPreservedParams));
+    MarginLayoutParamsCompat.setMarginEnd(params,
+            MarginLayoutParamsCompat.getMarginEnd(mPreservedParams));
+}
+```
+意思是说，再他们被以百分比为基础的数据更改之后恢复成原始的尺寸和margin。  
+然后继续看一下`restoreLayoutParams()`:        
+```java
+/**
+* Restores original dimensions after they were changed for percentage based values. Calling
+* this method only makes sense if you previously called
+* {@link PercentLayoutHelper.PercentLayoutInfo#fillLayoutParams}.
+*/
+public void restoreLayoutParams(ViewGroup.LayoutParams params) {
+    if (!mPreservedParams.mIsWidthComputedFromAspectRatio) {
+        // Only restore the width if we didn't compute it based on the height and
+        // aspect ratio in the fill pass.
+        params.width = mPreservedParams.width;
+    }
+    if (!mPreservedParams.mIsHeightComputedFromAspectRatio) {
+        // Only restore the height if we didn't compute it based on the width and
+        // aspect ratio in the fill pass.
+        params.height = mPreservedParams.height;
+    }
+    
+    // Reset the tracking flags.
+    mPreservedParams.mIsWidthComputedFromAspectRatio = false;
+    mPreservedParams.mIsHeightComputedFromAspectRatio = false;
+}
+```
+
+好了到这里也分析完了`onLayout`的方法，大意就是在`onMeasure`之前先将原始的宽高和`margin`都备份一下，然后在`onMeasure`中根据百分比去设置对应的宽高和`margin`，等到设置完之后在`onLayout`方法中再去将这些值恢复到之前备份的起始数据。说实话我没看明白为什么要这样做？
+          
+通过上面的代码分析我们知道对布局影响力的优先顺序: `app:layout_aspectRatio > app:layout_heightPercent > android:layout_height`如果我们同时都设置这三个参数值的话，最终会用`app:layout_aspectRatio`的值。
+           
+遗留问题:     
+
+- 为什么在`onLayout`方法中去恢复数据，这有什么作用？
+- 看代码在处理如果指定的百分比过小但又指定`wrap_content`时，会重新根据`wrap_content`去重新计算的逻辑没有错，但是为什么我在上面测试的时候确没效果？
+- 在上面分析代码时看到`fillLayoutParams`中是根据父`View`的宽高来乘以百分比，不是根据整个屏幕的宽高，这样可能会有问题，要是ListView这种的高度没法算了。
+
+    	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Android\345\212\240\345\274\272/\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"
similarity index 75%
rename from "Android\345\212\240\345\274\272/\345\270\203\345\261\200\344\274\230\345\214\226.md"
rename to "AdavancedPart/\345\270\203\345\261\200\344\274\230\345\214\226.md"
index 1ed6eca7..68dd2232 100644
--- "a/Android\345\212\240\345\274\272/\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/Android\345\212\240\345\274\272/\346\200\247\350\203\275\344\274\230\345\214\226.md" "b/AdavancedPart/\346\200\247\350\203\275\344\274\230\345\214\226.md"
similarity index 67%
rename from "Android\345\212\240\345\274\272/\346\200\247\350\203\275\344\274\230\345\214\226.md"
rename to "AdavancedPart/\346\200\247\350\203\275\344\274\230\345\214\226.md"
index 3dcd2268..dab58d91 100644
--- "a/Android\345\212\240\345\274\272/\346\200\247\350\203\275\344\274\230\345\214\226.md"
+++ "b/AdavancedPart/\346\200\247\350\203\275\344\274\230\345\214\226.md"
@@ -1,6 +1,23 @@
-性能优化
+性能优化
 ===
 
+代码优化原则:      
+---
+
+- 时间换时间：
+	如禁用电脑的一些开机启动项，通过减少这些没必要的启动项的时间从而节省开机时间
+	如网站界面上数据的分批获取，`AJAX`技术
+- 时间换空间：
+	如拷贝文件时new一个字节数组当缓冲器，即`byte[] buffer = new byte[1024]`。
+	为什么只`new`一个1024个字节的数组呢，`new`一个更大的字节数组不是一下就把文件拷贝完了么？这么做就是为了牺牲时间节省有限的内存空间
+- 空间换时间：
+	如用`Windows`系统自带的搜索文件的功能搜索文件时会很慢，但是我们牺牲电脑硬盘空间安装一个`everything`软件来搜索文件就特别快
+- 空间换空间：
+	如虚拟内存
+	
+`Android`开发中的体现
+---
+	
 - 采用硬件加速，在清单文件中`application`节点添加`android:hardwareAccelerated=”true”`。不过这个需要在`android 3.0`才可以使用。`android4.0`这个选项是默认开启的。
 - `View`中设置缓存属性`setDrawingCache`为`true`.
 - 优化你的布局.
@@ -18,7 +35,7 @@
 - `static`的变量如果不需要修改，应该使用`static final`修饰符定义为常量
 - 使用增强`for`循环,比普通`for`循环效率高，但是也有缺点就是在遍历 集合过程中，不能对集合本身进行操作
 - 合理利用浮点数，浮点数比整型慢两倍；
-- 针对ListView的性能优化
+- 针对`ListView`的性能优化
 		
 ---
 
diff --git "a/AdavancedPart/\346\263\250\350\247\243\344\275\277\347\224\250.md" "b/AdavancedPart/\346\263\250\350\247\243\344\275\277\347\224\250.md"
new file mode 100644
index 00000000..22ebec65
--- /dev/null
+++ "b/AdavancedPart/\346\263\250\350\247\243\344\275\277\347\224\250.md"
@@ -0,0 +1,1610 @@
+注解使用
+===
+
+### 简介
+
+> Annotations, a form of metadata, provide data about a program that is not part of the program itself. Annotations have no direct effect on the operation of the code they annotate.
+
+更通俗的意思是为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且是供指定的工具或框架使用的。
+`Annontation`像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。
+
+`Annotation`其实是一种接口。通过反射来访问`annotation`信息。相关类（框架或工具中的类）根据这些信息来决定如何使用该程序元素或改变它们的行为。
+`Annotation`是不会影响程序代码的执行，无论`annotation`怎么变化，代码都始终如一地执行。
+`Java`语言解释器在工作时会忽略这些`annotation`，因此在`JVM`中这些`annotation`是“不起作用”的，只能通过配套的工具才能对这些`annontaion`类型的信息进行访问和处理。
+
+### 说明
+
+- `Annotation`的声明是通过关键字`@interface`。这个关键字会去继承`Annotation`接口。
+- `Annotation`的方法定义是独特的、受限制的。    
+   `Annotation`类型的方法必须声明为无参数、无异常的。这些方法定义了`Annotation`的成员: 方法名代表成员变量名，而方法返回值代表了成员变量的类型。而且方法的返回值类型必须是基本数据类型、`Class`类型、`String类型`、枚举类型、`Annotation`类型或者由前面类型之一作为元素的一维数组。方法的后面可以使用`default`和一个默认的数值来声明成员变量的默认值，`null`不能作为成员变量的默认值，这与我们平时的使用有很大的区别。 
+    注解如果只有一个默认属性，可直接用`value()`函数。一个属性也没有则表示该`Annotation`为`Mark Annotation`。
+    例如:
+   
+    ```java
+    public @interface UnitTest {
+         String value();
+    }
+    ```    
+    在使用时可以直接使用`@UnitTest("GCD")`，`@UnitTest("GCD"`实际上就是是 `@UnitTest(value="GCD)`的简单写法。  
+    例如:
+   
+    ```java
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface UseCase {
+        public int id();
+        public String description() default "no description";
+    }
+    ```
+
+### 作用
+
+`Annotation`一般作为一种辅助途径，应用在软件框架或者工具中。让这些工具类可以根据不同的`Annotation`注解信息来采取不同的处理过程或者改变相应程的行为。具有“让编译器进行编译检查的作用”。   
+
+具体可分为如下三类:    
+
+- 标记，用于告诉编译器一些信息
+- 编译时动态处理，如动态生成代码
+- 运行时动态处理，如得到注解信息
+
+
+### Annotation分类    
+
+
+##### 标准的`Annotaion`    
+
+从`jdk 1.5`开始，自带了三种标准的`annotation`类型：   
+
+- `Override`    
+    它是一种`marker`类型的`Annotation`，用来标注方法，说明被它标注的方法是重载了父类中的方法。如果我们使用了该注解到一个没有覆盖父类方法的方法时，编译器就会提示一个编译错误的警告。   
+
+- `Deprecated`   
+    它也是一种`marker`类型的`Annotation`。当方法或者变量使用该注解时，编译器就会提示该方法已经废弃。
+
+- `SuppressWarnings`  
+    它不是`marker`类型的`Annotation`。用户告诉编译器不要再对该类、方法或者成员变量进行警告提示。   
+
+
+##### 元`Annotation`
+
+元`Annotation`是指用来定义`Annotation`的`Annotation`。  
+
+- `@Retention`          
+    保留时间，可为`RetentionPolicy.SOURCE(源码时)`、`RetentionPolicy.CLASS(编译时)`、`RetentionPolicy.RUNTIME(运行时)`，默认为`CLASS`。如果值为`RetentionPolicy.SOURCE`那大多都是`Mark Annotation`，例如:`Override`、`Deprecated`、`Suppress Warnings`。`SOURCE`表示仅存在于源码中，在`class`文件中不会包含。`CLASS`表示会在`class`文件中存在，但是运行时无法获取。`RUNTIME`表示会在`class`文件中存在，并且在运行时可以通过反射获取。    
+
+- `@Target`           
+    用来标记可进行修饰哪些元素，例如`ElementType.TYPE`、`ElementType.METHOD`、`ElementType.CONSTRUCTOR`、`ElementType.FIELD`、`ElementType.PARAMETER`等，如果未指定则默认为可修饰所有。
+- `@Inherited`                   
+    子类是否可以继承父类中的该注解。它所标注的`Annotation`将具有继承性。               
+    例如:   
+
+    ```java
+    java.lang.annotation.Inherited
+    
+    @Inherited
+    public @interface MyAnnotation {
+    
+    }
+    ```
+    
+    ```java
+    @MyAnnotation
+    public class MySuperClass { ... }
+    ```
+    
+    ```java
+    public class MySubClass extends MySuperClass { ... }
+    ```
+
+    在这个例子中`MySubClass`类继承了`@MyAnnotation`注解，因为`MySubClass`继承了`MySuperClass`类，而`MySuperClass`类使用了`@MyAnnotation`注解。   
+
+- `@Documented`      
+    是否会保存到`javadoc`文档中。  
+
+### 自定义`Annotation` 
+
+假设现在有个开发团队在每个类的开始都要提供一些信息，例如:   
+
+```java
+public class Generation3List extends Generation2List {
+
+   // Author: John Doe
+   // Date: 3/17/2002
+   // Current revision: 6
+   // Last modified: 4/12/2004
+   // By: Jane Doe
+   // Reviewers: Alice, Bill, Cindy
+
+   // class code goes here
+
+}
+```
+
+我们可以声明一个注解来保存这些相同的元数据。如下:
+    
+```java
+@interface ClassPreamble {
+   String author();
+   String date();
+   int currentRevision() default 1;
+   String lastModified() default "N/A";
+   String lastModifiedBy() default "N/A";
+   // Note use of array
+   String[] reviewers();
+}
+```
+声明完注解之后我们就可以填写一些参数来使用它，如下:
+   
+
+```java
+@ClassPreamble (
+   author = "John Doe",
+   date = "3/17/2002",
+   currentRevision = 6,
+   lastModified = "4/12/2004",
+   lastModifiedBy = "Jane Doe",
+   // Note array notation
+   reviewers = {"Alice", "Bob", "Cindy"}
+)
+public class Generation3List extends Generation2List {
+
+// class code goes here
+
+}
+```
+
+### `Annotation`解析    
+
+当`Java`源代码被编译时，编译器的一个插件`annotation`处理器则会处理这些`annotation`。
+处理器可以产生报告信息，或者创建附加的`Java`源文件或资源。
+如果`annotation`本身被加上了`RententionPolicy`的运行时类，
+则`Java`编译器则会将`annotation`的元数据存储到`class`文件中。然后`Java`虚拟机或其他的程序可以查找这些元数据并做相应的处理。
+
+当然除了`annotation`处理器可以处理`annotation`外，我们也可以使用反射自己来处理`annotation`。`Java SE 5`有一个名为`AnnotatedElement`的接口，
+`Java`的反射对象类`Class`,`Constructor`,`Field`,`Method`以及`Package`都实现了这个接口。
+这个接口用来表示当前运行在`Java`虚拟机中的被加上了`annotation`的程序元素。
+通过这个接口可以使用反射读取`annotation`。`AnnotatedElement`接口可以访问被加上`RUNTIME`标记的`annotation`，
+相应的方法有`getAnnotation`,`getAnnotations`,`isAnnotationPresent`。
+由于`Annotation`类型被编译和存储在二进制文件中就像`class`一样，
+所以可以像查询普通的`Java`对象一样查询这些方法返回的`Annotation`。
+
+
+##### 运行时`Annotation`解析
+
+该类是指`@Retention`为`RUNTIME`的`Annotation`。      
+该类型的解析其实本质的使用反射。反射执行的效率是很低的         
+如果不是必要，应当尽量减少反射的使用，因为它会大大拖累你应用的执行效率。
+
+- 类注解
+
+    可以通过`Class`、`Method`、`Field`类来在运行时获取注解。下面是通过`Class`类获取注解的示例:    
+    
+    ```java
+    Class aClass = TheClass.class;
+    Annotation[] annotations = aClass.getAnnotations();
+    
+    for(Annotation annotation : annotations){
+        if(annotation instanceof MyAnnotation){
+            MyAnnotation myAnnotation = (MyAnnotation) annotation;
+            System.out.println("name: " + myAnnotation.name());
+            System.out.println("value: " + myAnnotation.value());
+        }
+    }
+    ```
+    也可以获取一个指定的注解类型:   
+    
+    ```java
+    Class aClass = TheClass.class;
+    Annotation annotation = aClass.getAnnotation(MyAnnotation.class);
+    
+    if(annotation instanceof MyAnnotation){
+        MyAnnotation myAnnotation = (MyAnnotation) annotation;
+        System.out.println("name: " + myAnnotation.name());
+        System.out.println("value: " + myAnnotation.value());
+    }
+    ```
+
+    `JDK`提供的主要方法有:    
+    
+    ```java
+    public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
+        ...
+    }
+    
+    public Annotation[] getAnnotations() {
+        ...
+    }
+    
+    public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
+        ...
+    }
+    ```
+
+- 方法注解
+
+    下面是一个方法使用注解的例子:   
+    
+    ```java
+    public class TheClass {
+      @MyAnnotation(name="someName",  value = "Hello World")
+      public void doSomething(){}
+    }
+    ```
+    
+    你可以通过如下方式获取方法注解:    
+    
+    ```java
+    Method method = ... //obtain method object
+    Annotation[] annotations = method.getDeclaredAnnotations();
+    
+    for(Annotation annotation : annotations){
+        if(annotation instanceof MyAnnotation){
+            MyAnnotation myAnnotation = (MyAnnotation) annotation;
+            System.out.println("name: " + myAnnotation.name());
+            System.out.println("value: " + myAnnotation.value());
+        }
+    }
+    ```
+    也可以获取一个指定的方法注解，如下:    
+    
+    ```java
+    Method method = ... // obtain method object
+    Annotation annotation = method.getAnnotation(MyAnnotation.class);
+    
+    if(annotation instanceof MyAnnotation){
+        MyAnnotation myAnnotation = (MyAnnotation) annotation;
+        System.out.println("name: " + myAnnotation.name());
+        System.out.println("value: " + myAnnotation.value());
+    }
+    ```
+
+- 参数注解
+
+    在方法的参数中声明注解，如下:    
+    
+    ```java
+    public class TheClass {
+      public static void doSomethingElse(
+            @MyAnnotation(name="aName", value="aValue") String parameter){
+      }
+    }
+    ```
+    
+    可以通过`Method`对象获取到参数的注解，如下:          
+    ```java
+    Method method = ... //obtain method object
+    Annotation[][] parameterAnnotations = method.getParameterAnnotations();
+    Class[] parameterTypes = method.getParameterTypes();
+    
+    int i=0;
+    for(Annotation[] annotations : parameterAnnotations){
+      Class parameterType = parameterTypes[i++];
+    
+      for(Annotation annotation : annotations){
+        if(annotation instanceof MyAnnotation){
+            MyAnnotation myAnnotation = (MyAnnotation) annotation;
+            System.out.println("param: " + parameterType.getName());
+            System.out.println("name : " + myAnnotation.name());
+            System.out.println("value: " + myAnnotation.value());
+        }
+      }
+    }
+    ```
+    注意，`Method.getParameterAnnotations()`方法会返回一个二维的`Annotation`数组，包含每个方法参数的一个注解数组。    
+
+- 变量注解
+
+    下面是一个变量使用注解的例子:    
+    ```java
+    public class TheClass {
+    
+      @MyAnnotation(name="someName",  value = "Hello World")
+      public String myField = null;
+    }
+    ```  
+    
+    你可以像下面这样获取变量的注解:    
+    ```java
+    Field field = ... //obtain field object
+    Annotation[] annotations = field.getDeclaredAnnotations();
+    
+    for(Annotation annotation : annotations){
+        if(annotation instanceof MyAnnotation){
+            MyAnnotation myAnnotation = (MyAnnotation) annotation;
+            System.out.println("name: " + myAnnotation.name());
+            System.out.println("value: " + myAnnotation.value());
+        }
+    }
+    ```
+    
+    当然也可以获取一个指定的变量注解，如下:    
+    ```java
+    Field field = ... // obtain method object
+    Annotation annotation = field.getAnnotation(MyAnnotation.class);
+    
+    if(annotation instanceof MyAnnotation){
+        MyAnnotation myAnnotation = (MyAnnotation) annotation;
+        System.out.println("name: " + myAnnotation.name());
+        System.out.println("value: " + myAnnotation.value());
+    }
+    ```
+
+记下来我们来举个栗子,运行时注解示例:   
+
+相信很多人都知道`Butter Knife`。它里面就是使用了注解:  
+```java
+@BindView(R.id.user) EditText username;
+@BindView(R.id.pass) EditText password;
+
+@BindString(R.string.login_error) String loginErrorMessage;
+
+@OnClick(R.id.submit) void submit() {
+    // TODO call server...
+}
+```
+
+那我们就以`onClick`事件为例模仿着他去写一下。   
+
+```java
+public class InjectorProcessor {    
+    public void process(final Object object) {        
+        Class class_=object.getClass();        
+        Method[] methods=class_.getDeclaredMethods();        
+        for (final Method method : methods) {            
+            onClick clickMethod=method.getAnnotation(onClick.class);            
+            if (clickMethod!=null) {                
+                if (object instanceof Activity) {                   
+                    for (int id : clickMethod.value()) {                        
+                        View view=((Activity) object).findViewById(id);                        
+                        view.setOnClickListener(new View.OnClickListener() {                            
+                            @Override                            
+                            public void onClick(View v) {                                
+                                try {                                    
+                                    method.invoke(object);                                
+                                } catch (IllegalAccessException e) {                                    
+                                    e.printStackTrace();                                
+                                } catch (InvocationTargetException e) {                                    
+                                    e.printStackTrace();                                
+                                }                            
+                            }                        
+                        });                    
+                    }                
+                }            
+             }        
+         }    
+    }
+}
+```
+
+使用:   
+
+```java
+public class MainActivity extends AppCompatActivity {    
+    @Override    
+    protected void onCreate(Bundle savedInstanceState) {        
+        super.onCreate(savedInstanceState);        
+        setContentView(R.layout.activity_main);        
+        InjectorProcessor processor=new InjectorProcessor();        
+        processor.process(MainActivity.this);    
+    }    
+
+    @onClick({R.id.textview})    
+    public void click() {        
+        Toast.makeText(this, "HHH", Toast.LENGTH_SHORT).show();    
+    }
+}
+```
+
+很显然大神`JakeWharton`不会这样做的，毕竟反射会影响性能。   
+我们来看一下`ButterKnife`的源码:   
+```java
+@Target(METHOD)
+@Retention(CLASS)
+@ListenerClass(
+    targetType = "android.view.View",
+    setter = "setOnClickListener",
+    type = "butterknife.internal.DebouncingOnClickListener",
+    method = @ListenerMethod(
+        name = "doClick",
+        parameters = "android.view.View"
+    )
+)
+public @interface OnClick {
+  /** View IDs to which the method will be bound. */
+  @IdRes int[] value() default { View.NO_ID };
+}
+```
+看到了吗？是编译型的注解。这样不会影响性能。
+
+
+
+一张图总结一下:   
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_annotation.jpg?raw=true)
+
+
+
+
+
+##### 编译时`Annotation`解析    
+
+在刚才介绍的运行时注解中，很多人肯定会说使用反射会影响性能，那有没有不影响性能的方式呢？当然有了，那就是编译时注解。在编译时会通过注解标示来动态生成一些类或者`xml`，而在运行时，这里注解是没有的，它会依靠动态生成的类来进行操作。所以它就和直接调用方法一样，当然不会有效率影响了。       
+
+该类型注解值是`@Retention`为`CLASS`的`Annotation`，由`APT(Annotaion Processing Tool)`自动进行解析。是在编译时注入，所以不会像反射一样影响效率问题。   
+
+根据`sun`官方的解释，`APT（annotation processing tool）`是一个命令行工具，
+它对源代码文件进行检测找出其中的`annotation`后，使用`annotation processors`来处理`annotation`。
+而`annotation processors`使用了一套反射`API`并具备对`JSR175`规范的支持。
+
+`annotation processors`处理`annotation`的基本过程如下：
+
+- `APT`运行`annotation processors`根据提供的源文件中的`annotation`生成源代码文件和其它的文件（文件具体内容由`annotation processors`的编写者决定）
+- 接着`APT`将生成的源代码文件和提供的源文件进行编译生成类文件。
+
+
+`APT`在编译时自动查找所有继承自`AbstractProcessor`的类，然后调用他们的`process`方法去处理，这样就拥有了在编译过程中执行代码的能力
+
+
+
+所以我们需要做的是:    
+
+- 自定义类继承`AbstractProcessor`
+- 重写`process`方法
+
+那我们就开始写:   
+
+```java
+public class Processor extends AbstractProcessor{
+}
+```
+但是在`Android Studio`死活提示找不到`AbstractProcessor`类，这是因为注解是`javase`中`javax`包里面的，`android.jar`默认是不包含的，所以会编译报错.
+解决方法就是新建一个`Module`，在选择类型时将该`Module`的类型选为`Java Library`。
+然后在该`Module`中创建就好了`Processor`就好了，完美解决。 
+
+
+好，那我们就开始写个编译时处理的`demo` :  
+
+- `Android Studio`中创建一个`Android`工程。
+- 新建一个`Module`，然后选择`Java Library`类型(我的名字为`annotations`)，并且让`app`依赖该`module`。
+- 在`annotations`的`module`中创建注解类:
+
+    ```java
+    package com.charon;
+    
+    import java.lang.annotation.ElementType;
+    import java.lang.annotation.Retention;
+    import java.lang.annotation.RetentionPolicy;
+    import java.lang.annotation.Target;
+    
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.CLASS)
+    public @interface AnnotationTest {
+        String value() default "";
+    }
+    ```
+- 然后在`annotations`的`module`自定义`Processor`类
+
+    ```java
+    package com.charon;
+    
+    import java.util.Set;
+    
+    import javax.annotation.processing.AbstractProcessor;
+    import javax.annotation.processing.RoundEnvironment;
+    import javax.annotation.processing.SupportedAnnotationTypes;
+    import javax.annotation.processing.SupportedSourceVersion;
+    import javax.lang.model.SourceVersion;
+    import javax.lang.model.element.Element;
+    import javax.lang.model.element.TypeElement;
+    
+    @SupportedAnnotationTypes("com.charon.AnnotationTest")
+    @SupportedSourceVersion(SourceVersion.RELEASE_7)
+    public class TestProcessor extends AbstractProcessor {
+        @Override
+        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+            System.out.println("process");
+            for (TypeElement te : annotations) {
+                for (Element element : roundEnv.getElementsAnnotatedWith(te)) {
+                    AnnotationTest annotation = element.getAnnotation(AnnotationTest.class);
+                    String value = annotation.value();
+                    System.out.println("type : " + value);
+                }
+            }
+            return true;
+        }
+    }
+    ```
+    注意:`@SupportedAnnotationTypes("com.charon.AnnotationTest")`来指定要处理的注解类。
+    `@SupportedSourceVersion(SourceVersion.RELEASE_7)`指定编译的版本。这种通过注解指定编译版本和类型的方式是从`Java 1.7`才有的。
+    对于之前的版本都是通过重写`AbstractProcessor`中的方法来指定的。   
+
+- 注册处理器   
+    我们自定义了`Processor`那如何才能让其生效呢?就是在`annotations`的`java`同级目录新建`resources/META-INF/services/javax.annotation.processing.Processor`文件
+
+    ```java
+        - java
+        - META-INF
+            - services
+                - javax.annotation.processing.Processor
+    ```
+    然后在`javax.annotation.processing.Processor`文件中指定自定义的处理器，如:      
+    
+    ```java
+    com.charon.TestProcessor
+    ```
+    如果多个话就分行写。 
+
+    然后我们`Build`一下(命令行执行`./gradlew build`)，就能看到控制台打印出来如下的信息: 
+    ```java
+    :app:compileReleaseJavaWithJavac
+    :app:compileReleaseJavaWithJavac - is not incremental (e.g. outputs have changed, no previous execution, etc.).
+    process
+    value : haha
+    process
+    ```
+
+    注意:千万不要去`logcat`中找信息，这是编译时注解。         
+    注意:一定要使用`jdk1.7`，`1.8`对注解的支持有`bug`。
+
+
+上面只是一个简单的例子，如果你想用编译时注解去做一些更高级的事情，例如自动生成一些代码，那你可能就会用到如下几个类库:   
+
+- [android-apt](https://bitbucket.org/hvisser/android-apt)
+- [Google Auto](https://github.com/google/auto)      
+- [Square javapoet](https://github.com/square/javapoet)
+
+
+这三个库分别的作用为:    
+
+- `android-apt`       
+    `Android Studio`原本是不支持注解处理器的, 但是用`android-apt`这个插件后, 我们就可以使用注解处理器了, 
+    这个插件可以自动的帮你为生成的代码创建目录, 让生成的代码编译到`APK`里面去, 而且它还可以让最终编译出来的`APK`里面不包含注解处理器本身的代码,
+    因为这部分代码只是编译的时候需要用来生成代码, 最终运行的时候是不需要的。         
+    也就是说它主要有两个目的:    
+    
+    - 允许配置只在编译时作为注解处理器的依赖，而不添加到最后的`APK`或`library`
+    - 设置源路径，使注解处理器生成的代码能被`Android Studio`正确的引用
+
+    那在什么情况下我们会需要使用它呢？     
+    当你需要引入`Processor`生成的源代码到你的代码中时。例如当你使用`Dagger 2`或`AndroidAnnotaition`.
+    该插件使得`Android Studio`可以配置生成资源的`build path`,避免`IDE`报错。
+    当使用`apt`添加添加依赖，它将不会被包含到最终的`APK`里。
+
+
+- `Auto`     
+
+    `Google Auto`的主要作用是注解`Processor`类，并对其生成`META-INF`的配置信息，
+    可以让你不用去写`META-INF`这些配置文件，只要在自定义的`Processor`上面加上`@AutoService(Processor.class)`
+
+- `javapoet`     
+    `javapoet`:`A Java API for generating .java source files.`可以更方便的生成代码，它可以帮助我们通过类调用的形式来生成代码。   
+
+
+### 自定义编译时注解
+
+在自定义注解时，一般来说可能会建三个`modules`:  
+
+- `app module`:写一些使用注解的`android`应用逻辑。
+- `api module`:定义一些可以在`app`中使用的注解。它会被`app`以及`compiler`使用。
+- `compiler module`:定义`Processor`该`module`不会被包含到应用中，它只会在构建过程中被使用。在编译的过程中它会生成一些`java`文件，而这些`java`文件会被打包进`apk`中。
+    我们可以在该`module`中使用`auto`以及`javapoet`。  
+
+
+下面开始配置`android-apt`：   
+
+- 配置到`app module`下的`build.gradle`中
+
+    ```java
+    apply plugin: 'com.android.application'
+    // apt
+    apply plugin: 'com.neenbedankt.android-apt'
+    
+    android {
+        compileSdkVersion 23
+        buildToolsVersion "23.0.3"
+    
+        defaultConfig {
+            applicationId "com.charon.annotationdemo"
+            minSdkVersion 14
+            targetSdkVersion 23
+            versionCode 1
+            versionName "1.0"
+        }
+        buildTypes {
+            release {
+                minifyEnabled false
+                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            }
+        }
+        compileOptions {
+            sourceCompatibility JavaVersion.VERSION_1_7
+            targetCompatibility JavaVersion.VERSION_1_7
+        }
+    }
+    
+    buildscript {
+        repositories {
+            jcenter()
+        }
+        dependencies {
+            // 配置apt
+            classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
+        }
+    }
+    
+    dependencies {
+        compile fileTree(dir: 'libs', include: ['*.jar'])
+        testCompile 'junit:junit:4.12'
+        compile 'com.android.support:appcompat-v7:23.4.0'
+        compile project(':api')
+        apt project(':compiler')
+    
+    }
+    ```
+
+- 接下来在`compiler module`中配置`auto`以及`javapoet`
+
+    ```java
+    apply plugin: 'java'
+    sourceCompatibility = JavaVersion.VERSION_1_7
+    targetCompatibility = JavaVersion.VERSION_1_7
+    dependencies {
+        compile project (':api')
+        compile 'com.google.auto.service:auto-service:1.0-rc2'
+        compile 'com.squareup:javapoet:1.7.0'
+    }
+    ```
+- 在`api module`中也加上如下的配置:   
+
+    ```java
+    apply plugin: 'java'
+    sourceCompatibility = JavaVersion.VERSION_1_7
+    targetCompatibility = JavaVersion.VERSION_1_7
+    ```
+
+- 接下来在`api module`中定义一个注解       
+    ```java
+    package com.charon;
+    
+    import java.lang.annotation.ElementType;
+    import java.lang.annotation.Retention;
+    import java.lang.annotation.RetentionPolicy;
+    import java.lang.annotation.Target;
+    
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.CLASS)
+    public @interface AnnotationTest {
+        String value();
+    }
+    ```
+- 然后在`compiler module`中自定义一个`Processor`       
+
+    ```java
+    package com.charon;
+    
+    import com.google.auto.service.AutoService;
+    
+    import java.util.Set;
+    
+    import javax.annotation.processing.AbstractProcessor;
+    import javax.annotation.processing.ProcessingEnvironment;
+    import javax.annotation.processing.Processor;
+    import javax.annotation.processing.RoundEnvironment;
+    import javax.lang.model.SourceVersion;
+    import javax.lang.model.element.TypeElement;
+    
+    @AutoService(Processor.class)
+    public class MyProcessor extends AbstractProcessor {
+        /**
+         * Initializes the processor with the processing environment by
+         * setting the {@code processingEnv} field to the value of the
+         * {@code processingEnv} argument.  An {@code
+         * IllegalStateException} will be thrown if this method is called
+         * more than once on the same object.
+         *
+         * @param processingEnv environment to access facilities the tool framework
+         * provides to the processor
+         * @throws IllegalStateException if this method is called more than once.
+         */
+        @Override
+        public synchronized void init(ProcessingEnvironment processingEnv) {
+            super.init(processingEnv);
+        }
+    
+        /**
+         * Processes a set of annotation types on type elements originating from the prior round 
+         * and returns whether or not these annotations are claimed by this processor. 
+         * If true is returned, the annotations are claimed and subsequent processors will 
+         * not be asked to process them; 
+         * if false is returned, the annotations are unclaimed and subsequent processors may be 
+         * asked to process them. A processor may always return the same boolean value 
+         * or may vary the result based on chosen criteria.
+         * The input set will be empty if the processor supports "*" and the root elements 
+         * have no annotations. A Processor must gracefully handle an empty set of annotations.
+         * @param annotations
+         * @param roundEnv
+         * @return
+         */
+        @Override
+        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+            System.out.println("hello processor");
+            return false;
+        }
+    
+        @Override
+        public Set<String> getSupportedAnnotationTypes() {
+            return super.getSupportedAnnotationTypes();
+        }
+    
+        @Override
+        public SourceVersion getSupportedSourceVersion() {
+            return SourceVersion.latestSupported();
+        }
+    
+    }
+    ```
+    
+    这里简单的说一下这几个主要的方法:   
+   
+    - `init()`:初始化操作的方法，`RoundEnvironment`会提供很多有用的工具类`Elements`、`Types`和`Filer`等。
+    - `process()`:这相当于每个处理器的主函数`main()`。在该方法中去扫描、评估、处理以及生成`Java`文件。 
+    - `getSupportedAnnotationTypes()`:这里你必须指定，该注解器是注册给哪个注解的。
+    - `getSupportedSourceVersion()`:用来指定你使用的`java`版本。通常这里会直接放回`SourceVersion.latestSupported()`即可。  
+
+    从`idk 1.7`开始，可以使用如下注解来代替`getSupporedAnnotationTypes()`和`getSupportedSourceVersion()`方法:    
+    ```java
+    @SupportedSourceVersion(SourceVersion.latestSupported())
+    @SupportedAnnotationTypes({
+       // 合法注解全名的集合
+     })
+    ```
+
+注解相关`API`:     
+
+- `Set<? extends Element> getElementsAnnotatedWith(Class<? extends Annotation> a)`    
+    返回使用给定注释类型注释的元素。该注释可能直接出现或者被继承。只返回注释处理的此`round`中包括的`package`元素和`type`元素、成员声明、参数或者这些元素中声明的类型参数。
+- `Element`         
+    表示一个程序元素，比如包、类或者方法。每个元素都表示一个静态的语言级构造（不表示虚拟机的运行时构造）。
+    元素应该使用`equals(Object)`方法进行比较。不保证总是使用相同的对象表示某个特定的元素。
+    要实现基于`Element`对象类的操作，可以使用`visitor`或者使用`getKind()`方法的结果。使用`instanceof`确定此建模层次结构中某一对象的有效类未必可靠，因为一个实现可以选择让单个对象实现多个`Element`子接口。
+
+- `TypeElement`
+    表示一个类或接口程序元素。提供对有关类型及其成员的信息的访问。注意，枚举类型是一种类，而注释类型是一种接口。
+    而`DeclaredType`表示一个类或接口类型，后者将成为前者的一种使用（或调用）。这种区别对于一般的类型是最明显的，对于这些类型，单个元素可以定义一系列完整的类型。
+    例如，元素`java.util.Set`对应于参数化类型`java.util.Set<String>`和`java.util.Set<Number>`（以及其他许多类型），还对应于原始类型`java.util.Set`。
+
+
+
+扯远了，那我们就以上面的目录结构和实现方式，通过一个具体的例子要详细说明，例子真的很难找，我在网上找到了一个大神写的，虽然从这个例子中并不能看出注解的强大之处，但是对于讲解来说还是非常有用的: 
+
+我们要解决的问题是我们想要实现一个披萨店，该店会提供两种披萨(`Margherita`和`Calzone`)和一种甜点(`Tiramisu`)。
+
+首先我们在`app module`中创建对应的接口和代码 ，如下:      
+
+```java
+public interface Meal {  
+  public float getPrice();
+}
+
+public class MargheritaPizza implements Meal {
+
+  @Override public float getPrice() {
+    return 6.0f;
+  }
+}
+
+public class CalzonePizza implements Meal {
+
+  @Override public float getPrice() {
+    return 8.5f;
+  }
+}
+
+public class Tiramisu implements Meal {
+
+  @Override public float getPrice() {
+    return 4.5f;
+  }
+}
+```
+如果消费者想要下单，那么它需要输入对应的物品名字:   
+```java
+public class PizzaStore {
+
+  public Meal order(String mealName) {
+
+    if (mealName == null) {
+      throw new IllegalArgumentException("Name of the meal is null!");
+    }
+
+    if ("Margherita".equals(mealName)) {
+      return new MargheritaPizza();
+    }
+
+    if ("Calzone".equals(mealName)) {
+      return new CalzonePizza();
+    }
+
+    if ("Tiramisu".equals(mealName)) {
+      return new Tiramisu();
+    }
+
+    throw new IllegalArgumentException("Unknown meal '" + mealName + "'");
+  }
+
+  public static void main(String[] args) throws IOException {
+    PizzaStore pizzaStore = new PizzaStore();
+    Meal meal = pizzaStore.order(readConsole());
+    System.out.println("Bill: $" + meal.getPrice());
+  }
+```
+这样的话在`order()`方法中，会有很多`if`语句，并且每当我们添加一种新的披萨，我们都要添加一条新的`if`语句。但是我们可以使用注解和工厂模式，我们就可以让注解来自动生成这些在工厂中的`if`语句。我们期待的代码如下:   
+```java
+public class PizzaStore {
+
+  private MealFactory factory = new MealFactory();
+
+  public Meal order(String mealName) {
+    return factory.create(mealName);
+  }
+
+  public static void main(String[] args) throws IOException {
+    PizzaStore pizzaStore = new PizzaStore();
+    Meal meal = pizzaStore.order(readConsole());
+    System.out.println("Bill: $" + meal.getPrice());
+  }
+}
+
+```
+`MealFactory`的实现应该如下:   
+```java
+public class MealFactory {
+
+  public Meal create(String id) {
+    if (id == null) {
+      throw new IllegalArgumentException("id is null!");
+    }
+    if ("Calzone".equals(id)) {
+      return new CalzonePizza();
+    }
+
+    if ("Tiramisu".equals(id)) {
+      return new Tiramisu();
+    }
+
+    if ("Margherita".equals(id)) {
+      return new MargheritaPizza();
+    }
+
+    throw new IllegalArgumentException("Unknown id = " + id);
+  }
+}
+```
+
+接下来我们要做的就是通过注解来生成`MealFactory`中的代码。
+想法是这样的：我们将使用同样的`type()`注解那些属于同一个工厂的类，并且用注解的`id()`做一个映射，例如从"Calzone"映射到"ClzonePizza"类。我们使用`@Factory`注解到我们的类中，如下：
+
+```java
+@Factory(
+    id = "Margherita",
+    type = Meal.class
+)
+public class MargheritaPizza implements Meal {
+
+  @Override public float getPrice() {
+    return 6f;
+  }
+}
+```
+```java
+@Factory(
+    id = "Calzone",
+    type = Meal.class
+)
+public class CalzonePizza implements Meal {
+
+  @Override public float getPrice() {
+    return 8.5f;
+  }
+}
+```
+```java
+@Factory(
+    id = "Tiramisu",
+    type = Meal.class
+)
+public class Tiramisu implements Meal {
+
+  @Override public float getPrice() {
+    return 4.5f;
+  }
+}
+```
+
+你可能会问你自己，我们是否可以只把`@Factory`注解应用到`Meal`接口上？答案是注解是不能继承的。一个类`class X`被注解，并不意味着它的子类`class Y extends X`会自动被注解。在我们开始写处理器的代码之前，我们先规定如下一些规则：
+
+- 只有类可以被`@Factory`注解，因为接口或者抽象类并不能用`new`操作实例化；
+- 被`@Factory`注解的类，必须至少提供一个公开的默认构造器（即没有参数的构造函数）。否者我们没法实例化一个对象。
+- 被`@Factory`注解的类必须直接或者间接的继承于`type()`指定的类型；
+- 具有相同的`type`的注解类，将被聚合在一起生成一个工厂类。这个生成的类使用`Factory`后缀，例如`type = Meal.class`，将生成`MealFactory`工厂类；
+- `id`只能是`String`类型，并且在同一个`type`组中必须唯一。
+
+那我们接着看一下在`compiler module`中的自定义的`FactoryProcessor`类:    
+```java
+@AutoService(Processor.class)
+public class FactoryProcessor extends AbstractProcessor {
+
+  private Types typeUtils;
+  private Elements elementUtils;
+  private Filer filer;
+  private Messager messager;
+  private Map<String, FactoryGroupedClasses> factoryClasses = new LinkedHashMap<String, FactoryGroupedClasses>();
+
+  @Override
+  public synchronized void init(ProcessingEnvironment processingEnv) {
+    super.init(processingEnv);
+    typeUtils = processingEnv.getTypeUtils();
+    elementUtils = processingEnv.getElementUtils();
+    filer = processingEnv.getFiler();
+    messager = processingEnv.getMessager();
+  }
+
+  @Override
+  public Set<String> getSupportedAnnotationTypes() {
+    Set<String> annotataions = new LinkedHashSet<String>();
+    // 指定支持@Factory注解
+    annotataions.add(Factory.class.getCanonicalName());
+    return annotataions;
+  }
+
+  @Override
+  public SourceVersion getSupportedSourceVersion() {
+    return SourceVersion.latestSupported();
+  }
+
+  @Override
+  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+    ...
+  }
+}
+```
+
+在`init()`方法中，我们初始化了几个变量:   
+
+- `Elements`: 处理`Element`的工具类  
+- `Types`: 处理`TypeMirror`的工具类
+- `Filer`: 用来创建你要创建的文件
+- `Messager`:提供给注解处理器一个报告错误、警告以及提示信息的途径。
+
+在注解的处理过程中会扫描所有的`java`源文件。源代码中的每一个部分都是一个特定类型的`Element`。换句话说:`Element`代表程序的元素，例如包、类或者方法等。每个`Element`代表一个构建，例如通过下面的例子我们来说明一下:   
+```java
+package com.example;    // PackageElement
+
+public class Foo {        // TypeElement
+
+    private int a;      // VariableElement
+    private Foo other;  // VariableElement
+
+    public Foo () {}    // ExecuteableElement
+
+    public void setA (  // ExecuteableElement
+                     int newA   // TypeElement
+                     ) {}
+}
+```
+所以在注解中我们必须要换一个角度来看待源代码，它只是一个结构化的文本，我们可以像`XML`中的`DOM`一样去解析它。
+例如现在有一个代表`public class Foo`类的`TypeElement`元素，你可以遍历它的子元素，如下:   
+```java
+TypeElement fooClass = ... ;  
+for (Element e : fooClass.getEnclosedElements()){ // iterate over children  
+    Element parent = e.getEnclosingElement();  // parent == fooClass
+}
+```
+正如你所见，`Element`代表的是源代码。`TypeElement`代表的是源代码中的类型元素，例如类。然而`TypeElement`并不包含类本身的信息。你可以从`TypeElement`中获取类的名字，但是你获取不到类的信息，例如它的父类。这种信息需要通过`TypeMirror`获取。你可以通过调用`elements.asType()`获取元素的`TypeMirror`。
+
+接下来我们来继续实现`process()`方法:   
+```java
+@AutoService(Processor.class)
+public class FactoryProcessor extends AbstractProcessor {
+
+    private Types typeUtils;
+    private Elements elementUtils;
+    private Filer filer;
+    private Messager messager;
+
+    @Override
+    public synchronized void init(ProcessingEnvironment processingEnv) {
+        super.init(processingEnv);
+        typeUtils = processingEnv.getTypeUtils();
+        elementUtils = processingEnv.getElementUtils();
+        filer = processingEnv.getFiler();
+        messager = processingEnv.getMessager();
+    }
+
+    @Override
+    public Set<String> getSupportedAnnotationTypes() {
+        Set<String> annotataions = new LinkedHashSet<String>();
+        annotataions.add(Factory.class.getCanonicalName());
+        return annotataions;
+    }
+
+    @Override
+    public SourceVersion getSupportedSourceVersion() {
+        return SourceVersion.latestSupported();
+    }
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+        // roundEnv.getElementsAnnotatedWith(Factory.class))返回所有被注解了@Factory的元素的列表。
+        // 你可能已经注意到，我们并没有说“所有被注解了@Factory的类的列表”，因为它真的是返回Element的列表。
+        // 请记住：Element可以是类、方法、变量等。所以，接下来，我们必须检查这些Element是否是一个类
+        for (Element annotatedElement : roundEnv.getElementsAnnotatedWith(Factory.class)) {
+            // Check if a class has been annotated with @Factory
+            if (annotatedElement.getKind() != ElementKind.CLASS) {
+                return false;
+            }
+        }
+
+        return false;
+    }
+}
+```
+
+在继续检查被注解`@Fractory`的类是否满足我们上面说的5条规则之前，我们将介绍一个让我们更方便继续处理的数据结构。有时候，一个问题或者解释器看起来如此简单，以至于程序员倾向于用一个面向过程方式来写整个处理器。但是你知道吗？一个注解处理器仍然是一个`Java`程序，所以我们需要使用面向对象编程、接口、设计模式，以及任何你将在其他普通`Java`程序中使用的技巧。
+
+我们的`FactoryProcessor`非常简单，但是我们仍然想要把一些信息存为对象。在`FactoryAnnotatedClass`中，我们保存被注解类的数据，比如合法的类的名字，以及`@Factory`注解本身的一些信息。也就是说每一个使用了`@Factory`注解的类都对应一个`FactoryAnnotatedClass`类，所以，我们保存`TypeElement`和处理过的`@Factory`注解：
+
+如下:  
+```java
+public class FactoryAnnotatedClass {
+
+  private TypeElement annotatedClassElement;
+  private String qualifiedSuperClassName;
+  private String simpleTypeName;
+  private String id;
+
+  public FactoryAnnotatedClass(TypeElement classElement) throws IllegalArgumentException {
+    this.annotatedClassElement = classElement;
+    Factory annotation = classElement.getAnnotation(Factory.class);
+    id = annotation.id();
+
+    if (StringUtils.isEmpty(id)) {
+      throw new IllegalArgumentException(
+          String.format("id() in @%s for class %s is null or empty! that's not allowed",
+              Factory.class.getSimpleName(), classElement.getQualifiedName().toString()));
+    }
+
+    // Get the full QualifiedTypeName
+    try {
+      Class<?> clazz = annotation.type();
+      // 返回底层阶级Java语言规范中定义的标准名称。
+      qualifiedSuperClassName = clazz.getCanonicalName();
+      simpleTypeName = clazz.getSimpleName();
+    } catch (MirroredTypeException mte) {
+      DeclaredType classTypeMirror = (DeclaredType) mte.getTypeMirror();
+      TypeElement classTypeElement = (TypeElement) classTypeMirror.asElement();
+      qualifiedSuperClassName = classTypeElement.getQualifiedName().toString();
+      simpleTypeName = classTypeElement.getSimpleName().toString();
+    }
+  }
+
+  /**
+   * 获取在{@link Factory#id()}中指定的id
+   * return the id
+   */
+  public String getId() {
+    return id;
+  }
+
+  /**
+   * 获取在{@link Factory#type()}指定的类型合法全名
+   *
+   * @return qualified name
+   */
+  public String getQualifiedFactoryGroupName() {
+    return qualifiedSuperClassName;
+  }
+
+
+  /**
+   * 获取在{@link Factory#type()}{@link Factory#type()}指定的类型的简单名字
+   *
+   * @return qualified name
+   */
+  public String getSimpleFactoryGroupName() {
+    return simpleTypeName;
+  }
+
+  /**
+   * 获取被@Factory注解的原始元素
+   */
+  public TypeElement getTypeElement() {
+    return annotatedClassElement;
+  }
+}
+```
+上面我们用到了`Class`,因为这里的类型是一个`java.lang.Class`。这就意味着，他是一个真正的`Class`对象。因为注解处理是在编译`Java`源代码之前。我们需要考虑如下两种情况：
+
+- 这个类已经被编译：这种情况是：如果第三方`.jar`包含已编译的被`@Factory`注解`.class`文件。在这种情况下，可以通过上面的方式在`try`代码块中直接获取。
+- 这个还没有被编译：这种情况是我们尝试编译被`@Fractory`注解的源代码。这种情况下，直接获取`Class`会抛出`MirroredTypeException`异常。幸运的是，`MirroredTypeException`包含一个`TypeMirror`，它表示我们未编译类。因为我们已经知道它必定是一个类类型（我们已经在前面检查过），我们可以直接强制转换为`DeclaredType`，然后读取`TypeElement`来获取合法的名字。
+
+
+好了，我们现在还需要一个数据结构类`FactoryGroupedClasses`，它将简单的组合所有的`FactoryAnnotatedClasses`到一起。
+```java
+public class FactoryGroupedClasses {
+
+  private String qualifiedClassName;
+
+  private Map<String, FactoryAnnotatedClass> itemsMap =
+      new LinkedHashMap<String, FactoryAnnotatedClass>();
+
+  public FactoryGroupedClasses(String qualifiedClassName) {
+    this.qualifiedClassName = qualifiedClassName;
+  }
+
+  public void add(FactoryAnnotatedClass toInsert) throws IdAlreadyUsedException {
+
+    FactoryAnnotatedClass existing = itemsMap.get(toInsert.getId());
+    if (existing != null) {
+      throw new IdAlreadyUsedException(existing);
+    }
+
+    itemsMap.put(toInsert.getId(), toInsert);
+  }
+
+  public void generateCode(Elements elementUtils, Filer filer) throws IOException {
+    ...
+  }
+}
+```
+
+正如你所见，这是一个基本的`Map<String, FactoryAnnotatedClass>`，这个映射表用来映射`@Factory.id()`到`FactoryAnnotatedClass`。我们选择`Map`这个数据类型，是因为我们要确保每个`id`是唯一的，我们可以很容易通过`map`查找实现。`generateCode()`方法将被用来生成工厂类代码（将在后面讨论）。
+
+我们继续实现`process()`方法。接下来我们想要检查被注解的类必须有只要一个公开的构造函数，不是抽象类，继承于特定的类型，以及是一个公开类：
+
+```java
+
+@AutoService(Processor.class)
+public class FactoryProcessor extends AbstractProcessor {
+
+    private Types typeUtils;
+    private Elements elementUtils;
+    private Filer filer;
+    private Messager messager;
+    private Map<String, FactoryGroupedClasses> factoryClasses =
+            new LinkedHashMap<String, FactoryGroupedClasses>();
+
+    @Override
+    public synchronized void init(ProcessingEnvironment processingEnv) {
+        super.init(processingEnv);
+        typeUtils = processingEnv.getTypeUtils();
+        elementUtils = processingEnv.getElementUtils();
+        filer = processingEnv.getFiler();
+        messager = processingEnv.getMessager();
+    }
+
+    @Override
+    public Set<String> getSupportedAnnotationTypes() {
+        Set<String> annotataions = new LinkedHashSet<String>();
+        annotataions.add(Factory.class.getCanonicalName());
+        return annotataions;
+    }
+
+    @Override
+    public SourceVersion getSupportedSourceVersion() {
+        return SourceVersion.latestSupported();
+    }
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+        // roundEnv.getElementsAnnotatedWith(Factory.class))返回所有被注解了@Factory的元素的列表。
+        // 你可能已经注意到，我们并没有说“所有被注解了@Factory的类的列表”，因为它真的是返回Element的列表。
+        // 请记住：Element可以是类、方法、变量等。所以，接下来，我们必须检查这些Element是否是一个类
+        for (Element annotatedElement : roundEnv.getElementsAnnotatedWith(Factory.class)) {
+            // Check if a class has been annotated with @Factory
+            if (annotatedElement.getKind() != ElementKind.CLASS) {
+                error(annotatedElement, "Only classes can be annotated with @%s",
+                        Factory.class.getSimpleName());
+                return true; // 退出处理
+            }
+
+
+            // 因为我们已经知道它是ElementKind.CLASS类型，所以可以直接强制转换
+            TypeElement typeElement = (TypeElement) annotatedElement;
+
+            try {
+                FactoryAnnotatedClass annotatedClass =
+                        new FactoryAnnotatedClass(typeElement); // throws IllegalArgumentException
+
+                if (!isValidClass(annotatedClass)) {
+                    return true; // 已经打印了错误信息，退出处理过程
+                }
+
+                // 一旦我们检查isValidClass()成功，我们将添加FactoryAnnotatedClass到对应的FactoryGroupedClasses中
+                FactoryGroupedClasses factoryClass =
+                        factoryClasses.get(annotatedClass.getQualifiedFactoryGroupName());
+                if (factoryClass == null) {
+                    String qualifiedGroupName = annotatedClass.getQualifiedFactoryGroupName();
+                    factoryClass = new FactoryGroupedClasses(qualifiedGroupName);
+                    factoryClasses.put(qualifiedGroupName, factoryClass);
+                }
+
+                // 如果和其他的@Factory标注的类的id相同冲突，
+                // 抛出IdAlreadyUsedException异常
+                factoryClass.add(annotatedClass);
+            } catch (IllegalArgumentException e) {
+                // @Factory.id()为空 --> 打印错误信息
+                error(typeElement, e.getMessage());
+                return true;
+            } catch (IdAlreadyUsedException e) {
+                FactoryAnnotatedClass existing = e.getExisting();
+                // 已经存在
+                error(annotatedElement,
+                        "Conflict: The class %s is annotated with @%s with id ='%s' but %s already uses the same id",
+                        typeElement.getQualifiedName().toString(), Factory.class.getSimpleName(),
+                        existing.getTypeElement().getQualifiedName().toString());
+                return true;
+            }
+        }
+
+        // 为每个工厂生成Java文件
+        try {
+            for (FactoryGroupedClasses factoryClass : factoryClasses.values()) {
+                factoryClass.generateCode(elementUtils, filer);
+            }
+        // TODO ...注意这里会遗留一个问题，我们后面再仔细说。 
+        } catch (IOException e) {
+            error(null, e.getMessage());
+        }
+
+        return true;
+    }
+
+    private void error(Element e, String msg, Object... args) {
+        messager.printMessage(
+                Diagnostic.Kind.ERROR,
+                String.format(msg, args),
+                e);
+    }
+
+
+    private boolean isValidClass(FactoryAnnotatedClass item) {
+
+        // 转换为TypeElement, 含有更多特定的方法
+        TypeElement classElement = item.getTypeElement();
+
+        if (!classElement.getModifiers().contains(Modifier.PUBLIC)) {
+            error(classElement, "The class %s is not public.",
+                    classElement.getQualifiedName().toString());
+            return false;
+        }
+
+        // 检查是否是一个抽象类
+        if (classElement.getModifiers().contains(Modifier.ABSTRACT)) {
+            error(classElement, "The class %s is abstract. You can't annotate abstract classes with @%",
+                    classElement.getQualifiedName().toString(), Factory.class.getSimpleName());
+            return false;
+        }
+
+        // 检查继承关系: 必须是@Factory.type()指定的类型子类
+        TypeElement superClassElement =
+                elementUtils.getTypeElement(item.getQualifiedFactoryGroupName());
+        if (superClassElement.getKind() == ElementKind.INTERFACE) {
+            // 检查接口是否实现了
+            if(!classElement.getInterfaces().contains(superClassElement.asType())) {
+                error(classElement, "The class %s annotated with @%s must implement the interface %s",
+                        classElement.getQualifiedName().toString(), Factory.class.getSimpleName(),
+                        item.getQualifiedFactoryGroupName());
+                return false;
+            }
+        } else {
+            // 检查子类
+            TypeElement currentClass = classElement;
+            while (true) {
+                TypeMirror superClassType = currentClass.getSuperclass();
+
+                if (superClassType.getKind() == TypeKind.NONE) {
+                    // 到达了基本类型(java.lang.Object), 所以退出
+                    error(classElement, "The class %s annotated with @%s must inherit from %s",
+                            classElement.getQualifiedName().toString(), Factory.class.getSimpleName(),
+                            item.getQualifiedFactoryGroupName());
+                    return false;
+                }
+
+                if (superClassType.toString().equals(item.getQualifiedFactoryGroupName())) {
+                    // 找到了要求的父类
+                    break;
+                }
+
+                // 在继承树上继续向上搜寻
+                currentClass = (TypeElement) typeUtils.asElement(superClassType);
+            }
+        }
+
+        // 检查是否提供了默认公开构造函数
+        for (Element enclosed : classElement.getEnclosedElements()) {
+            if (enclosed.getKind() == ElementKind.CONSTRUCTOR) {
+                ExecutableElement constructorElement = (ExecutableElement) enclosed;
+                if (constructorElement.getParameters().size() == 0 && constructorElement.getModifiers()
+                        .contains(Modifier.PUBLIC)) {
+                    // 找到了默认构造函数
+                    return true;
+                }
+            }
+        }
+
+        // 没有找到默认构造函数
+        error(classElement, "The class %s must provide an public empty default constructor",
+                classElement.getQualifiedName().toString());
+        return false;
+    }
+
+}
+```
+
+我们这里添加了`isValidClass()`方法，来检查是否我们所有的规则都被满足了：
+
+- 必须是公开类：`classElement.getModifiers().contains(Modifier.PUBLIC)`
+- 必须是非抽象类：`classElement.getModifiers().contains(Modifier.ABSTRACT)`
+- 必须是`@Factoy.type()`指定的类型的子类或者接口的实现：首先我们使用`elementUtils.getTypeElement(item.getQualifiedFactoryGroupName())`创建一个传入的`Class(@Factoy.type())`的元素。是的，你可以仅仅通过已知的合法类名来直接创建`TypeElement`（使用`TypeMirror`）。接下来我们检查它是一个接口还是一个类：`superClassElement.getKind() == ElementKind.INTERFACE`。所以我们这里有两种情况：如果是接口，就判断`classElement.getInterfaces().contains(superClassElement.asType())`；如果是类，我们就必须使用`currentClass.getSuperclass()`扫描继承层级。注意，整个检查也可以使用`typeUtils.isSubtype()`来实现。
+- 类必须有一个公开的默认构造函数：我们遍历所有的闭元素`classElement.getEnclosedElements()`，然后检查`ElementKind.CONSTRUCTOR`、`Modifier.PUBLIC`以及`constructorElement.getParameters().size() == 0`。
+
+
+上面都实现完成后下面就是在`FactoryGroupedClasses.generateCode()`方法中去生成`java`文件了。   
+写`Java`文件，和写其他普通文件没有什么两样。使用`Filer`提供的`Writer`对象，我们可以连接字符串来写我们生成的`Java`代码。但是这样是不是非常麻烦啊？还好良心企业`Square`给我们提供了`Javapoet`，我们可以用它来非常简单的去生成`java`文件。那我们接下来就使用`javapoet`来去生成代码:   
+
+```java
+public class FactoryGroupedClasses {
+
+    /**
+     * 将被添加到生成的工厂类的名字中
+     */
+    private static final String SUFFIX = "Factory";
+
+    private String qualifiedClassName;
+
+    private Map<String, FactoryAnnotatedClass> itemsMap =
+            new LinkedHashMap<String, FactoryAnnotatedClass>();
+
+    public FactoryGroupedClasses(String qualifiedClassName) {
+        this.qualifiedClassName = qualifiedClassName;
+    }
+
+    public void add(FactoryAnnotatedClass toInsert) throws ProcessingException {
+
+        FactoryAnnotatedClass existing = itemsMap.get(toInsert.getId());
+        if (existing != null) {
+
+            // Alredy existing
+            throw new ProcessingException(toInsert.getTypeElement(),
+                    "Conflict: The class %s is annotated with @%s with id ='%s' but %s already uses the same id",
+                    toInsert.getTypeElement().getQualifiedName().toString(), Factory.class.getSimpleName(),
+                    toInsert.getId(), existing.getTypeElement().getQualifiedName().toString());
+        }
+
+        itemsMap.put(toInsert.getId(), toInsert);
+    }
+
+    public void generateCode(Elements elementUtils, Filer filer) throws IOException {
+        TypeElement superClassName = elementUtils.getTypeElement(qualifiedClassName);
+        String factoryClassName = superClassName.getSimpleName() + SUFFIX;
+        String qualifiedFactoryClassName = qualifiedClassName + SUFFIX;
+        PackageElement pkg = elementUtils.getPackageOf(superClassName);
+        String packageName = pkg.isUnnamed() ? null : pkg.getQualifiedName().toString();
+
+        MethodSpec.Builder method = MethodSpec.methodBuilder("create")
+                .addModifiers(Modifier.PUBLIC)
+                .addParameter(String.class, "id")
+                .returns(TypeName.get(superClassName.asType()));
+
+        // check if id is null
+        method.beginControlFlow("if (id == null)")
+                .addStatement("throw new IllegalArgumentException($S)", "id is null!")
+                .endControlFlow();
+
+        // Generate items map
+        for (FactoryAnnotatedClass item : itemsMap.values()) {
+            method.beginControlFlow("if ($S.equals(id))", item.getId())
+                    .addStatement("return new $L()", item.getTypeElement().getQualifiedName().toString())
+                    .endControlFlow();
+        }
+
+        method.addStatement("throw new IllegalArgumentException($S + id)", "Unknown id = ");
+
+        TypeSpec typeSpec = TypeSpec.classBuilder(factoryClassName).addMethod(method.build()).build();
+
+        // Write file
+        JavaFile.builder(packageName, typeSpec).build().writeTo(filer);
+    }
+}
+```
+
+到这里，我感觉完成了，运行一下，结果发现报错了:   
+```java
+:compiler:jar UP-TO-DATE
+:app:compileDebugJavaWithJavac
+错误: Attempt to recreate a file for type com.charon.annotationdemo.inter.MealFactory
+错误: Attempt to recreate a file for type com.charon.annotationdemo.inter.MealFactory
+2 个错误
+Error:Execution failed for task ':app:compileDebugJavaWithJavac'.
+> Compilation failed; see the compiler error output for details.
+```
+
+那我们继续来解决这个问题，这个问题是由于循环引起的，我们还要处理一个重要的事情就是循环的问题:    
+
+注解处理可能会执行多次，官方文档中是这样介绍的:   
+
+> Annotation processing happens in a sequence of rounds. On each round, a processor may be asked to process a subset of the annotations found on the source and class files produced by a prior round. The inputs to the first round of processing are the initial inputs to a run of the tool; these initial inputs can be regarded as the output of a virtual zeroth round of processing.
+
+一个简单的定义：一个处理循环是调用一个注解处理器的`process()`方法。对应到我们的工厂模式的例子中：`FactoryProcessor`被初始化一次（不是每次循环都会新建处理器对象），然而，如果生成了新的源文件`process()`能够被调用多次。听起来有点奇怪不是么？原因是这样的，这些生成的文件中也可能包含`@Factory`注解，它们还将会被`FactoryProcessor`处理。
+
+例如我们的`PizzaStore`的例子中将会经过3次循环处理：
+
+| Round         | Input         | Output  |
+| ------------- |:-------------:| -----:|
+| 1             | CalzonePizza.java Tiramisu.java MargheritaPizza.java Meal.java   PizzaStore.java                  | MealFactory.java |
+| 2             | MealFactory.java      |   none |
+| 3             | none      |    none |
+
+会循环三次，但是第一次就会生成代码，所以上面会出现两次重复创建文件的错误。   
+
+解释处理循环还有另外一个原因。如果你看一下我们的`FactoryProcessor`代码你就能注意到，我们收集数据和保存它们在一个私有的域中`Map<String, FactoryGroupedClasses> factoryClasses`。在第一轮中，我们检测到了`MagheritaPizza`, `CalzonePizza`和`Tiramisu`，然后生成了`MealFactory.java`。在第二轮中把`MealFactory`作为输入。因为在`MealFactory`中没有检测到`@Factory`注解，我们预期并没有错误，然而我们得到如下的信息：
+
+```java
+:compiler:jar UP-TO-DATE
+:app:compileDebugJavaWithJavac
+错误: Attempt to recreate a file for type com.charon.annotationdemo.inter.MealFactory
+错误: Attempt to recreate a file for type com.charon.annotationdemo.inter.MealFactory
+2 个错误
+Error:Execution failed for task ':app:compileDebugJavaWithJavac'.
+> Compilation failed; see the compiler error output for details.
+```
+
+这个问题是因为我们没有清除`factoryClasses`，这意味着，在第二轮的`process()`中，任然保存着第一轮的数据，并且会尝试生成在第一轮中已经生成的文件，从而导致这个错误的出现。在我们的这个场景中，我们知道只有在第一轮中检查`@Factory`注解的类，所以我们可以简单的修复这个问题，如下：
+```java
+@Override
+public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {  
+    try {
+      for (FactoryGroupedClasses factoryClass : factoryClasses.values()) {
+        factoryClass.generateCode(elementUtils, filer);
+      }
+
+      // 清除factoryClasses
+      factoryClasses.clear();
+
+    } catch (IOException e) {
+      error(null, e.getMessage());
+    }
+    ...
+    return true;
+}
+```
+
+***我们要记住注解处理过程是需要经过多轮处理的，并且你不能重载或者重新创建已经生成的源代码。***
+
+
+
+好了，到这里就彻底完成了，运行一下，当然成功了，那生成的文件在哪里呢？ 
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/annotation_ato_create_file.png)     
+
+
+那既然能生成，我们该怎么去调用呢？很简单，像平常一样去用。
+```java
+public class MainActivity extends AppCompatActivity {
+    private View view;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+        view = findViewById(R.id.tv);
+        view.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                MealFactory factory = new MealFactory();
+                factory.create("Calzone");
+            }
+        });
+    }
+}
+```
+
+你可能会发现报错，找不到类，你可以不用管它，直接运行，你会发现一切都`OK`的。当然如果你倒错了包你就当我没说。
+
+作为`Android`开发者，当然应该很熟悉`ButterKnife`。在`ButterKnife`中使用`@InjectView`注解`View`。`ButterKnifeProcessor`生成一个`MyActivity$$ViewInjector`，但是在`ButterKnife`你不需要手动调用`new MyActivity$$ViewInjector()`来实例化一个`ButterKnife`注入的对象，而是使用`Butterknife.inject(activity)`。`ButterKnife`内部使用反射机制来实例化`MyActivity$$ViewInjector()`对象：
+
+```java
+try {  
+    Class<?> injector = Class.forName(clsName + "$$ViewInjector");
+} catch (ClassNotFoundException e) { ... }
+```
+
+但是反射机制会稍微有些慢，我们使用注解处理来生成本地代码，会不会导致很多的反射性能的问题？的确，反射机制的性能确实是一个问题。然而，它不需要手动去创建对象，确实提高了开发者的开发速度。`ButterKnife`中有一个哈希表`HashMap`来缓存实例化过的对象。所以`MyActivity$$ViewInjector`只是使用反射机制实例化一次，第二次需要`MyActivity$$ViewInjector`的时候，就直接从哈希表中获得。
+
+`FragmentArgs`非常类似于`ButterKnife`。它使用反射机制来创建对象，而不需要开发者手动来做这些。`FragmentArgs`在处理注解的时候生成一个特别的查找表类，它其实就是一种哈希表，所以整个`FragmentArgs`库只是在第一次使用的时候，执行一次反射调用，一旦整个`Class.forName()`的`Fragemnt`的参数对象被创建，后面的都是本地代码运行了。
+
+好了至此例子讲完了。   
+
+最后讲一下按照上面的三层分类:`app`,`api`,`compiler`进行分类的好处。 
+我们这么做是因为想让我们的工厂模式的例子的使用者在他们的工程中只编译注解，而包含处理器模块只是为了编译。有点晕？我们举个例子，如果我们只有一个包。如果另一个开发者想要把我们的工厂模式处理器用于他的项目中，他就必须包含`@Factory`注解和整个`FactoryProcessor`的代码（包括`FactoryAnnotatedClass`和`FactoryGroupedClasses`）到他们项目中。我非常确定的是，他并不需要在他已经编译好的项目中包含处理器相关的代码。如果你是一个`Android`的开发者，你肯定听说过`65536`个方法的限制（即在一个`.dex`文件中，只能寻址65536个方法）。如果你在`FactoryProcessor`中使用`guava`，并且把注解和处理器打包在一个包中，这样的话，`Android APK`安装包中不只是包含`FactoryProcessor`的代码，而也包含了整个`guava`的代码。`Guava`有大约20000个方法。所以分开注解和处理器是非常有意义的。
+
+
+### 使用注解提高代码的检查性    
+
+`Google`提供了`Support-Annotations library`来支持更多的注解功能。   
+可以直接在`build.gradle`中添加如下代码:    
+
+```
+dependencies {
+    compile 'com.android.support:support-annotations:23.3.0'
+}
+```
+
+`Android`提供了很多注解来支持在方法、参数和返回值上面使用，例如:    
+
+- `@Nullable`       
+    可以为`null`
+- `@NonNull`        
+    不能为`null`  
+    ```java
+    import android.support.annotation.NonNull;
+    ...
+    
+        /** Add support for inflating the <fragment> tag. */
+        @NonNull
+        @Override
+        public View onCreateView(String name, @NonNull Context context,
+          @NonNull AttributeSet attrs) {
+          ...
+          }
+    ...
+    ```
+- `@StringRes`       
+    `R.string`类型的资源。  
+    ```java
+    import android.support.annotation.StringRes;
+    ...
+        public abstract void setTitle(@StringRes int resId);
+        ...
+    
+    遇到那种你写了个`setTitle(int resId)`他确给你传`setTitle(R.drawable.xxx)`的选手，用这种方式能很好的去提示下。 
+    ```
+- `@DrawableRes`       
+    `Drawable`类型的资源。
+- `@ColorRes`     
+    `Color`类型的资源。
+- `@InterpolatorRes`        
+    `Interpolatro`类型。
+- `@AnyRes`        
+    `R.`类型。
+- `@UiThread`         
+    从`UI thread`调用。 
+- `@RequiresPermission`        
+    来验证该方法的调用者所需要有的权限。检查一个列表中的任何一个权限可以使用`anyOf`属性。想要检查多个权限时，可以使用`allOf`属性。如下:  
+    ```java
+    @RequiresPermission(Manifest.permission.SET_WALLPAPER)
+    public abstract void setWallpaper(Bitmap bitmap) throws IOException;
+    ```
+    检查多个权限:   
+    
+    ```java
+    @RequiresPermission(allOf = {
+        Manifest.permission.READ_EXTERNAL_STORAGE,
+        Manifest.permission.WRITE_EXTERNAL_STORAGE})
+    public static final void copyFile(String dest, String source) {
+        ...
+    }
+    ```
+
+
+示例`Demo`已上传到`Github`:[AnnotationDemo](https://github.com/CharonChui/AnnotationDemo)    
+
+文中例子来自`Hannes Dorfmann`大神的`ANNOTATION PROCESSING 101`，我对其重新梳理了下，来让能正常使用，并且上面的示例已经过我实际运行:   
+- [Hannes Dorfmann](http://hannesdorfmann.com/annotation-processing/annotationprocessing101)
+        
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git "a/AdavancedPart/\351\200\232\350\277\207Hardware Layer\346\217\220\351\253\230\345\212\250\347\224\273\346\200\247\350\203\275.md" "b/AdavancedPart/\351\200\232\350\277\207Hardware Layer\346\217\220\351\253\230\345\212\250\347\224\273\346\200\247\350\203\275.md"
new file mode 100644
index 00000000..46b2b118
--- /dev/null
+++ "b/AdavancedPart/\351\200\232\350\277\207Hardware Layer\346\217\220\351\253\230\345\212\250\347\224\273\346\200\247\350\203\275.md"	
@@ -0,0 +1,129 @@
+通过Hardware Layer提高动画性能
+===
+
+项目中越来越多的动画，越来越多的效果导致了应用性能越来越低。该如何提升。   
+
+### 简介 
+
+在`View`播放动画的过程中每一帧都需要被重绘。如果使用`view layers`，就不用每帧都去重绘，因为`View`渲染一旦离开屏幕缓冲区就可以被重用。
+
+而且，`hardware layers`会在`GPU`上缓存，这样就会让一些动画过程中的操作变得更快。通过`hardware layers`可以快速的渲染一些简单的转变(位移、选中、缩放、颜色渐变)。由于很多动画都是这些动作的结合，所以`hardware layers`可以显著的提高动画性能。
+
+在`View`当中提供了三种类型的`Layer type`:    
+
+- LAYER_TYPE_HARDWARE
+    > Indicates that the view has a hardware layer. A hardware layer is backed by a hardware specific texture (generally Frame Buffer Objects or FBO on OpenGL hardware) and causes the view to be rendered using Android's hardware rendering pipeline, but only if hardware acceleration is turned on for the view hierarchy. When hardware acceleration is turned off, hardware layers behave exactly as software layers.
+
+    > A hardware layer is useful to apply a specific color filter and/or blending mode and/or translucency to a view and all its children.
+
+    > A hardware layer can be used to cache a complex view tree into a texture and reduce the complexity of drawing operations. For instance, when animating a complex view tree with a translation, a hardware layer can be used to render the view tree only once.
+
+    > A hardware layer can also be used to increase the rendering quality when rotation transformations are applied on a view. It can also be used to prevent potential clipping issues when applying 3D transforms on a view.    
+    
+
+- LAYER_TYPE_SOFTWARE
+    > Indicates that the view has a software layer. A software layer is backed by a bitmap and causes the view to be rendered using Android's software rendering pipeline, even if hardware acceleration is enabled.
+
+    > Software layers have various usages:
+
+    > When the application is not using hardware acceleration, a software layer is useful to apply a specific color filter and/or blending mode and/or translucency to a view and all its children.
+
+    > When the application is using hardware acceleration, a software layer is useful to render drawing primitives not supported by the hardware accelerated pipeline. It can also be used to cache a complex view tree into a texture and reduce the complexity of drawing operations. For instance, when animating a complex view tree with a translation, a software layer can be used to render the view tree only once.
+
+    > Software layers should be avoided when the affected view tree updates often. Every update will require to re-render the software layer, which can potentially be slow (particularly when hardware acceleration is turned on since the layer will have to be uploaded into a hardware texture after every update.)
+
+- LAYER_TYPE_NONE
+    > Indicates that the view does not have a layer.
+    默认值。
+
+### 使用
+
+首先使用的前提是在清单文件中开启了硬件加速。否则将无法使用`hardware layer`。这一点在上面的文档中也有说明。
+
+`API`也是非常简单的，直接使用`View.setLayerType()`就好。使用时应该只是暂时的设置`Hardware Layer`，因为它们无法自动释放。     
+基本的使用步骤：    
+ 
+- 对每个想要在动画过程中进行缓存的`view`调用`View.setLayerType(View.LAYER_TYPE_HARDWARE, null)`方法。
+- 执行动画。
+- 在动画执行结束后调用`View.setLayerType(View.LAYER_TYPE_NONE, null)`方法来进行清除。
+
+示例:      
+```java
+mView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+
+animator.addListener(new AnimatorListenerAdapter() {  
+  @Override
+  public void onAnimationEnd(Animator animation) {
+    mView.setLayerType(View.LAYER_TYPE_NONE, null);
+  }
+});
+
+animator.start();  
+
+```
+但是如果在`4.0.x`的版本中使用上面的代码会崩溃，必须要把`setLayerType`放到`Runnable`中。如下:   
+```java
+mView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+
+animator.addListener(new AnimatorListenerAdapter() {  
+  @Override
+  public void onAnimationEnd(Animator animation) {
+    //This will work successfully
+    post(new Runnable() {
+        @Override
+        public void run () {
+            setLayerType(LAYER_TYPE_NONE, null);
+        }
+    }
+  }
+});
+
+animator.start();  
+```
+
+如果你基于`minSdkVersion 16`以上并且使用`ViewPropertyAnimator`时，你可以使用`withLayer()`方法替代如上的操作:     
+
+```java
+mView.animate().translationX(150).withLayer().start();
+```
+
+或者在`api 14`以上时使用`ViewCompat.animate().withLayer()`
+这样做，你的动画就会变得更流畅！
+    	
+
+### 注意事项  
+
+你应该知道，事情没那么简单。     
+`Hardware layers`有着惊人的提升动画性能的能力。然而，如果滥用，它的危害更大。**不要盲目的使用`layers`**
+
+- 首先，在有些情况下，`hardware layers`除了`view`渲染外还会执行更多的工作。缓存`layer`将会需要时间，因为首选第一步就需要两个过程: 先将这些`view`渲染到`GPU`的一个`layer`中然后`GPU`再渲染该`layer`到`Window`上。如果要渲染的`View`非常简单(例如一个纯色值),那么这样在初始化的时候就会增加`Hardware Layer`不必要的开销。
+
+- 其次，对所有的缓存来讲，都有一个缓存失效的可能性。任何时候如果在动画过程中调用`view.invalidate()`，那么`layer`就必须要重新渲染。经常的废弃`hardware layers`会比没有`layers`的情况下更糟糕，因为如同上面讲到的`hardware layers`在设置缓存时会有额外的开销。如果你需要经常的重新缓存`layer`，那就会有极大的损害。    
+
+    这个问题也是非常容易出现的，因为动画经常有多个移动的部分。假如现在有一个三个部分移动的动画:     
+    ```java
+    Parent ViewGroup
+    —-> Child View1 (往左移动)
+    —-> Child View2 (往右移动)
+    —-> Child View3 (往上移动)
+    ```
+    
+    如果你只在父布局`ViewGroup`上设置一个`layer`，那就将经常的缓存失效，因为`ViewGroup`会随着子`View`不断地改变。然而对每个单独的子`Views`而言，他们只是在位移。这种情况下，最好是对每个子`View上`设置`Hardware Layer`（而不是在父布局上）。
+    
+    ***再次重申，通常是对多个子`View上`适当的设置`Hardware Layer`，这样他们就不会在动画运行时失效。***
+    
+    在手机开发者选项中的*显示硬件层更新（Show hardware layers updates）*功能是追踪这个问题的开发利器。当`View`渲染`Hardware Layer`的时候闪烁绿色，它应该在动画开始的时候闪烁一次（也就是`Layer`渲染初始化的时候），然而，如果你的`View`在整个动画期间都是绿色，那就是遇到失效的问题了。
+
+- 最后，`hardware layers`使用`GPU`内存，你当然不想出现内存泄漏的问题。所以你应该在必要的时候再去使用`hardware layers`，就想播放动画时。  
+
+
+这里也没有硬性规则。`Android`渲染系统是非常复杂的。就像所有性能问题一样，测试才是关键。通过使用“显示硬件层更新”开发者选项来确定`layers`是在帮你还是害你。
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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..0e95d5fa
--- /dev/null
+++ "b/Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
@@ -0,0 +1,65 @@
+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..20afa38a
--- /dev/null
+++ "b/Algorithm/11.H\346\214\207\346\225\260.md"
@@ -0,0 +1,232 @@
+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..68b25643
--- /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..abff28d0
--- /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,128 @@
+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..8debb624
--- /dev/null
+++ "b/Algorithm/14.\345\212\240\346\262\271\347\253\231.md"
@@ -0,0 +1,143 @@
+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..b74a91ed
--- /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..0a86815c
--- /dev/null
+++ "b/Algorithm/16.\346\216\245\351\233\250\346\260\264.md"
@@ -0,0 +1,149 @@
+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/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/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/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..ffde6522
--- /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,160 @@
+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
+
+### 思路
+
+字符串大模拟，分情况讨论即可：
+
+- 如果当前行只有一个单词，特殊处理为左对齐；
+- 如果当前行为最后一行，特殊处理为左对齐；
+- 其余为一般情况，分别计算「当前行单词总长度」、「当前行空格总长度」和「往下取整后的单位空格长度」，然后依次进行拼接。当空格无法均分时，每次往靠左的间隙多添加一个空格，直到剩余的空格能够被后面的间隙所均分。
+
+```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)
+
+
+---
+- 邮箱 ：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..b8720d78
--- /dev/null
+++ "b/Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md"
@@ -0,0 +1,104 @@
+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 字符组成
+
+
+### 思路
+
+##### 方法一
+
+最简单的方法是对字符串 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  
+- Good Luck! 
+
+	
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/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/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..73f0d47d
--- /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,218 @@
+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 由小写英文字母组成
+
+### 思路
+
+##### 方法一，从头到尾遍历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;
+    }
+}
+```
+
+
+
+---
+- 邮箱 ：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! 
+
+	
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/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/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/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/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..f99c600a
--- /dev/null
+++ "b/Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md"
@@ -0,0 +1,87 @@
+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/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/57..md b/Algorithm/57..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/57..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/58..md b/Algorithm/58..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/58..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/59..md b/Algorithm/59..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/59..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：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..4f9e6d02
--- /dev/null
+++ "b/Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md"
@@ -0,0 +1,88 @@
+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/60..md b/Algorithm/60..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/60..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
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! 
+
+	
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..18fa2d74
--- /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..00e0fa54
--- /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,107 @@
+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 (i < 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..3bb87d3a
--- /dev/null
+++ "b/Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md"
@@ -0,0 +1,91 @@
+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/AndroidStudioCourse/Android Studio\344\275\240\345\217\257\350\203\275\344\270\215\347\237\245\351\201\223\347\232\204\346\223\215\344\275\234.md" "b/AndroidStudioCourse/Android Studio\344\275\240\345\217\257\350\203\275\344\270\215\347\237\245\351\201\223\347\232\204\346\223\215\344\275\234.md"
new file mode 100644
index 00000000..bf89c72d
--- /dev/null
+++ "b/AndroidStudioCourse/Android Studio\344\275\240\345\217\257\350\203\275\344\270\215\347\237\245\351\201\223\347\232\204\346\223\215\344\275\234.md"	
@@ -0,0 +1,54 @@
+Android Studio你可能不知道的操作
+===
+
+今天看在`Youtube`看视频，看到`Reto Meier`在讲解`Studio`，
+一查才知道他现在是`Studio`的开发人员。
+想起刚开始学`Android`时买的他写的书`Professional Android 4 Application Development`，
+当时很多内容没看懂。不过看了这个视频才发现大神写代码如此之快…
+
+现在天天用着大神开发的工具，没有理由不去好好学习下。
+
+工欲善其事必先利其器，一个好的开发工具可以让你事半功倍。`Android Studio`是一个非常好的开发工具，但是虽然都在用，你可能还是了解的不全面，今天就来说一下一些你可能不知道的功能。
+
+熟练使用快捷键是非常有必要的:     
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/use_shortcut.gif?raw=true)  
+
+
+- 自动导入              
+经常听到同事抱怨，`Studio`怎么没有`Eclipse`那种批量导包啊，那么多类要到，费劲了。其实不用一个个导的。
+使用`Command+Shift+A(Windows或Linux是Ctrl+Shift+A)`快速的查找设置命令。我们输入`auto import`后将`Add unambiguous imports on fly`选项开启就好了，很爽有木有？你的是不是也没开啊？              
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/auto_import.gif?raw=true)         
+你可以快速打开一些设置，例如你想在`finder`中查看该文件，直接输入`find`就好了。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/action_find.png?raw=true)        
+
+- 在自动完成代码时使用`Tab`键来替换已存在的方法和参数。           
+经常如我们想要修改一个已经存在的方法时，我们移动到对象的`.`的提示区域，如果使用`Command+Space`来补充代码选择后按`enter`的话，会把之前已经存在的代码往后移动，这样还要再去删除，很不方便。但是如果我们直接使用`Tag`键，那就会直接替换当前已经存在的方法。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/tab_tip.gif?raw=true)  
+
+- 内容选择技巧         
+使用`Control+↑或↓`能在方法间移动。使用`Shift+↑或↓`来选择至上一行或者至下一行代码的代码？那么使用`option++↑或↓(Windows或Linux是alt++↑或↓)`呢？它能选择或者取消选择和你鼠标所在位置的代码区域。同时使用`option+shift++↑或↓(Windows或Linux是alt+shift++↑或↓)可以交换选中代码块与上一行的位置。这样我们就不需要剪切和粘贴了。
+
+- 使用模板补全代码      
+你可以在代码后加用后缀的方式补充代码块，也可以用`Command+J(Windows是Ctrl+J)`来提示。      
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/command_j.gif?raw=true)        
+对于一些更多的模式，在代码自动完成时也支持生成对应的模板，例如使用`Toast`的快捷键可以很方便的生成一个新的`toast`对象，你只需要指定文字就可以了。     
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/toast_autocomp.gif?raw=true)         
+用`Command+Shift+A`然后输入`live template`然后打开对应的页面，可以看到目前已经存在的模板。当然你也可以添加新的模板。     
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/live_templete.png?raw=true)  
+
+- 在`Evaluating Expressions`中为`Object`对象指定显示内容        
+如果我们在`debug`的时候查看断点处的变量值或者`evaluating expressions`，你会发现`objects`会显示他们的`toString()`值。如果你的变量是`String`类型或者基础类型那不会有问题，但是大多数其他对象，这样没有什么意义。    
+尤其是在集合对象时，你看的是一个`CallsName:HashValue`的列表。而为了需要看清数据，我们需要知道每个对象的内容。     
+你当然可以去对每个对象类型指定索要显示的内容。在对应的对象上邮件`View as`然后创建你想要显示的内容就可以了。     
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/debug_eva.gif?raw=true)  
+
+- 结构性的搜索、替换、和检查       
+`Command+shift+A`然后输入`structural `后选择`search structurally`或者`replace structurally`，然后可以对应的结构性搜索的模板，完成之后所有符合该模板的代码都会提示`warning`。     
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/structural_search.gif?raw=true)        
+更有用的是可以使用快速修复来替换一些代码，例如一些废弃的代码或者你在`review`时发现的其他团队成员提交的一些普遍的错误。
+
+    	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/AndroidStudioCourse/AndroidStudio\344\270\255\350\277\233\350\241\214ndk\345\274\200\345\217\221.md" "b/AndroidStudioCourse/AndroidStudio\344\270\255\350\277\233\350\241\214ndk\345\274\200\345\217\221.md"
new file mode 100644
index 00000000..b57d07e6
--- /dev/null
+++ "b/AndroidStudioCourse/AndroidStudio\344\270\255\350\277\233\350\241\214ndk\345\274\200\345\217\221.md"
@@ -0,0 +1,90 @@
+AndroidStudio中进行ndk开发
+===
+
+- 创建工程，声明`native`方法。               
+	```java
+	private native void startDaemon(String serviceName, int sdkVersion);
+
+    static {
+        System.loadLibrary("daemon");
+    }
+	```
+	
+	
+- 生成`class`文件。                 
+    执行`Build-Make Project`命令，生成`class`文件。所在目录为`app_path/build/intermediates/classes/debug`
+
+
+- 执行`javah`生成`.h文件`                    
+	```
+	C:\Users\Administrator>javah -help
+	用法:
+	  javah [options] <classes>
+	其中, [options] 包括:
+	  -o <file>                输出文件 (只能使用 -d 或 -o 之一)
+	  -d <dir>                 输出目录
+	  -v  -verbose             启用详细输出
+	  -h  --help  -?           输出此消息
+	  -version                 输出版本信息
+	  -jni                     生成 JNI 样式的标头文件 (默认值)
+	  -force                   始终写入输出文件
+	  -classpath <path>        从中加载类的路径
+	  -cp <path>               从中加载类的路径
+	  -bootclasspath <path>    从中加载引导类的路径
+	```	
+	在`Studio Terminal`中进入到`src/main`目录下执行`javah`命令:       
+	`javah -d jni -classpath <SDK_android.jar>;<APP_classes> <class>`
+	
+	`F:\DaemonService\app\src\main>javah -d jni -classpath C:\develop\android-sdk-windows\platforms\android-22\android.jar;..\..\build\intermediates\classes\debug com.charonchui.daemonservice.service.DaemonService`
+	执行完成后就会在`src/main/jni`目录下生成`com_charonchui_daemonservice_service_DaemonService.h`文件。
+
+- 在`module/src/main/jni`目录下创建对应的`.c`文件。
+
+
+
+- 配置`ndk`路径，在项目右键`Moudle Setting`中设置。              
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/studio_ndk_jni.png?raw=true)    
+	
+- 在`build.gradle`中配置`ndk`选项              
+
+    ```java
+	android {
+		compileSdkVersion 23
+		buildToolsVersion "23.0.1"
+
+		defaultConfig {
+			applicationId "com.charonchui.daemonservice"
+			minSdkVersion 8
+			targetSdkVersion 23
+			versionCode 1
+			versionName "1.0"
+
+			ndk {
+				moduleName "uninstall_feedback" // 配置so名字
+				ldLibs "log"
+	//            abiFilters "armeabi", "x86"  // 默认就是全部的，加了配置才会生成选中的
+			}
+		}
+		buildTypes {
+			release {
+				minifyEnabled false
+				proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+			}
+		}
+	}
+	```
+	这里可能会出现错误:      
+	- `Error: NDK integration is deprecated in the current plugin. Consider trying the new experimental plugin. For details, see http://tools.android.com/tech-docs/new-build-system/gradle-experimental. Set "android.useDeprecatedNdk=true" in gradle.properties to continue using the current NDK integration.`
+	    解决方法就是在`gradle.properties`文件中添加`android:useDeprecatedNdk=true`就可以了。
+	- `Error:Execution failed for task ':app:compileDebugNdk'.
+		> com.android.ide.common.process.ProcessException: org.gradle.process.internal.ExecException: Process 'command 'E:\android-ndk-r10\ndk-build.cmd'' finished with non-zero exit value 2`
+		解决方法就是在`jni`目录建一个任意名字的`.c`空文件就可以了。
+	
+- 执行Build      
+	然后就可以在`app/build/intermediates/ndk/debug/obj/local`下看到所有架构的`so`了。
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/studio_ndk_build.png?raw=true)    
+	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\200\345\274\271).md" "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\200\345\274\271).md"
new file mode 100644
index 00000000..e997843c
--- /dev/null
+++ "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\200\345\274\271).md"
@@ -0,0 +1,115 @@
+AndroidStudio使用教程(第一弹)
+===
+
+`Android Studio`是一套面世不久的`IDE`（即集成开发环境），免费向谷歌及`Android`的开发人员发放。`Android Studio`以`IntelliJ IDEA`为基础,
+旨在取代`Eclipse`和`ADT`（`Android`开发者工具）为开发者提供更好的开发工具。              
+运行相应速度、智能提示、布局文件适时多屏预览等都比`Eclipse`要强，但也不能说全部都是有点现在`Studio`中无法在一个窗口管理多个`Project`，
+每个`Project`都要打开一个窗口，或者是`close`当前的后再打开别的。
+
+当但是毕竟是预览版，所以只是暂时试用了下，并没有过多接触，开发中还是使用`Eclipse`。           
+经过一年多的沉淀，如果已到0.8.4版本，最近准备在工作用正式开始使用，所以看了下官网的教程。准备开始了。
+
+- 安装                  
+    这个我就不多说了，大家都知道，官网下载安装即可。安装完成后界面和`Eclipse`有些类似，然后就新建一个`Project`，完成之后会发现一直在提示下载，
+	这是在下载`Gradle`，大约二三十M的大小，由于伟大的防火墙，所以可能需要很长时间，这里就不教大家了，对程序猿来说不是难题，大家都会科学上网。
+	
+- 区别              
+    - 此`Project`非彼`Project`, `Android Studio`的目录结构(`Project`)代表一个`Workspace`，一个`Workspace`里面可以有多个`Module`，
+	这里`Module`可以理解成`Eclipse`中的一个`Project`.
+	`Project`代表一个完整的`Android app`，而`modules`则是`app`的一个组件，并且这个组件可以单独`build,test,debug`。`modules`可以分为下面几种：      
+	    - Java library modules    
+        - Android library modules: 包含android相关代码和资源，最后生成AAR(Android ARchive)包    
+        - Android application modules       
+		
+    - 结构发生了变化，在`src`目录下有一个`main`的分组同时包含了`java`和`res`.
+	    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_1.png?raw=true)        
+	    如图：`MyApplication`就是`Project`，而`app`就是`Module`.
+	
+- 设置           
+   进入后你会发现字体或样式等不符合你的习惯。            
+   `Windows`下点击左上角`File` -> `Settings`进入设置页面(`Mac`下为 `Android Studio` -> `Preferences`)，在搜索框搜`Font`找到`Colors&Font`下的`Font`选项，
+   我们会发现无法修改右侧字体大小。这里修改必须
+   要通过新建`Theme`进行修改的，点击`Save as`输入一个名字后，就可以修改字体了。
+   	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_2.png?raw=true)
+
+	这里可能有些人会发现我的主题是黑色的，和`IO`大会演示的一样，但是安装后默认是白色的，有些刺眼。这里可以通过设置页面中修改`Theme`来改变,
+	默认是`Intellij`, 改为`Darcula`就是黑色的了.
+	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_3.png?raw=true)
+	很酷有木有.
+	
+- 运行            
+    设置好字体后，当然要走你了。             
+	运行和`Eclipse`中比较像，点击绿色的箭头。 可以通过箭头左边的下拉菜单选择不同的`Module`,快捷键是`Shift+F10`                              
+	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_4.png?raw=true)
+
+    `AndroidStudio`默认安装会启动模拟器，如果想让安装到真机上可以配置一下。在下拉菜单中选择`Edit Configurations`选择提示或者是`USB`设备。
+	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_5.png?raw=true)	
+	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6.png?raw=true)	
+	
+- 常用快捷键介绍            
+    `AndroidStudio`中可以将快捷键设置成`Eclipse`中的快捷键。具体方法为在设置页面搜索`keymap`然后选择为`Eclipse`就可以了.
+	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_7.png?raw=true)	
+	
+	强迫症的人伤不起，非想用默认的快捷键。               
+	这里我整理下下个人常用的几个快捷键。 每个人的习惯不同，大家各取所需              
+	`Ctrl+S`                   开个玩笑，这个键算是彻底废掉了， 因为`AndroidStudio`与`Eclipse`不同，他是自动保存的，所以我们再也不需要`Ctrl+S`了.   
+
+	| 功能                                                         | Windows                                     | Mac                                          |
+	| ------------------------------------------------------------ |:-------------------------------------------:| --------------------------------------------:|
+	| 代码提示                 (同`Eclipse`中`Alt+/`)               | `Ctrl+空格`                                 | `Ctrl+空格`                               |
+	| 查找文件                 (同`Eclipse`中`Ctrl+Shift+R`)        | `Ctrl+Shjft+N`                              | `双击Shift`                        |
+	| 显示当前文件的结构       (同`Eclipse`中`Ctrl+0`)                | `Ctrl+F12`                                  | `Command+F12`                          |
+	| 格式化                   (同`Eclipse`中`Ctrl+Shift+F`)       | `Ctrl+Alt+L`                                | `Command+Option+L`                          |
+	| 优化导入的包             (同`Eclipse`中`Ctrl+Shift+O`)       | `Ctrl+Alt+O`                                | `Ctrl+Option+O`                         |
+	| 查看文档                 (同`Eclipse`中`F2`)                 | `Ctrl+Q`                                    | `F1`                           |
+	| 查找使用位               (同`Eclipse`中`File Search`)        | `Alt+F7`                                    | `Option+F7`                                |
+	| 上下移动代码                                                 | `Alt+Shift+Up/Down`                         | `Option+Shift+Up/Down`                       |
+	| 剪切当前行                                                   | `Ctrl+X`                                    | `Command+x`                       |
+	| 删除当前行                                                   | `Ctrl+Y`                                    | `Command+Delete`                             |	                        
+	| 快速重写方法     override                                    | `Ctrl+O`                                    | `Ctrl+O`                                 |	                           
+	| 折叠展开代码块                                               | `Ctrl+Plus/Minus`                           | `Command+Plus/Minus`                         |	 	                                   
+	| 折叠展开全部代码块                                           | `Ctrl+Shift+Plus/Minus`                     | `Command+Shift+Plus/Minus`                   |	                                                
+	| 大小写转换                                                   | `Ctrl+Shift+U`                              | `Command+Shift+U`                            |	      		 
+	| 新建文件或生成代码(`GetSet`)                                 | `Alt+Insert`                                |      `Command+N`                                        |
+	| 快速修复(同`Eclipse`中`F1`)                                  | `Alt+Enter`                                 |       `Option+Enter`                                       |
+	| 显示方法参数                                                 | `Ctrl+P`                                    |   `Command+P`                                           |	                     
+	| 运行项目                                                     | `Shift+F10`                                 |  `Ctrl+R`                                    |				 
+	| 跳转到上次修改的地方                                         | `Ctrl+Shift+Backspace`                      |     `Command+Shift+Backspace`                                         |	                        
+	| 快捷生成结构体(加try catch等)                                | `Ctrl+Alt+T`                                |  `Command+Option+T`                        |	                                
+	| 显示最近编辑列表                                             | `Ctrl+E`                                    |  `Command+E`                                            |	                                
+	| 跳转到大括号开头或结尾                                       | `Ctrl+{或}`                                 |          .....                                    |	                          
+	| 在方法间移动                                                 | `Alt+↑或↓`                                  | `Ctrl+↑或↓`                                           |	                                            
+	| 切换已打开的文件视图                                         | `Alt+←或→`                                  |   `Ctrl+←或→`                                           |	                                               
+	| 重命名                                                       | `Shift+F6`                                  |         `Shift+F6`                                    |	                
+	| 直接进入源码                                                 | `F4`                                        |                                              |	                                                       
+	| 快速打开该类或方法(与F4虽然大部分情况下相同，但他俩不一样)   | `Ctrl+B`如在布局文件上点会直接进入布局文件  |                `Command+B`                              |
+	| 快速定位到文件错误或警告位置                                 | `F2`                                        |     `F2`                                         |	                         
+	| 在当前位置复制当前行                                         | `Ctrl+D`                                    |     `Command+D`                                         |	                             
+	| 选中两个文件或目录后进行比较(活生生一个简单的BeyondCompare)  | `Ctrl+D`                                    |      `Command+D`                                        |	                             
+	| 开关`Project`视图                                            | `Alt+1`                                     |    `Command+1`                                          |	                                
+	| 关闭当前窗口                                                 | `Ctrl+_F4`                                  |   `Command+W`                                     |	             
+	| 实现接口方法  implement                                      | `Ctrl+I`                                    | `Ctrl+I`                               |
+	| 抽象方法查看具体有哪些实现类                                 | `Ctrl+Alt+B`                                | `Command+Option+B`                       |
+	| 单行注释                                                     | `Ctrl+/`                                    | `Command+/`                       |
+	| 多行注释                                                     | `Ctrl+Shit+/`                               | `Command+Option+/`                             |	                        
+	| 复制，如果当前行没有选中内容就复制当前行                     | `Ctrl+C`                                    | `Command+C`                                  |	                           
+	| 打开该类的关系图，查看该类的继承或实现                       | `Ctrl+H`                                    | `Ctrl+H`                     |	 	                                   
+	| 提示代码缩写，如so后点击提示System.out.print等               | `Ctrl+J`                                    | `Command+J`                   |	                                                
+	| 进入父类方法的实现  UP                                       | `Ctrl+U`                                    | `Command+U`                            |	      		 
+	| 抽取某一个块代码为单独的变量或者方法                             | `Ctrl+Alt+V`                                    | `Command+Option+V`  方法是`Command+Option+M`                       |	    
+	| 选择最近所有复制过内容的列表                                 | `Ctrl+Shift+V`                              |  `Command+Shift+V`                                            |
+	| 通过卡片的方式，直接查看该方法的具体内容或者图片     | `Ctrl+Shift+I`                              |  `Option+Space`                                            |
+	| 全局搜索                                                     | `Ctrl+Shift+F`                              |  `Command+Shift+F`                                            |	                     
+    | 上一步、下一步                                                | ``                              |  `Command+[或]`                                            |	                     
+   | 高亮所有相同变量                                                | `Ctrl+Shift+F7`                              |  `Command+Shift+F7`                                            |
+  | 方法调用层级弹窗                                                | `Ctrl+Alt+H`                              |  `Control+Option+H`                                            |	
+|书签(在当前行打上书签)                                                   | `F11`                              |  `F3`                                            | 
+|展示书签                                                   | `Shift+F11`                              |  `Command+F3`                                            | 
+|整行代码上下移动                                                   | `Alt+Shift++↑或↓`                              |  `Option+Shift+↑或↓`                                         | 
+|搜索设置操作命令                                                   | `Ctrl+Shift+A`                              |  `Command+Shift+A`                                         |
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\203\345\274\271).md" "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\203\345\274\271).md"
new file mode 100644
index 00000000..579704d2
--- /dev/null
+++ "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\203\345\274\271).md"
@@ -0,0 +1,414 @@
+AndroidStudio使用教程(第七弹)
+===
+
+本文讲解一下`Gradle`的应用，大家都知道`Gradle`使用起来非常方便，那他究竟方便在哪里？　　　　　　　　　　　　　　　　　　　　　　　　　　
+
+- 很多时候我们在打印`Log`日志的时候都是需要在`Debug`版本中进行打印，而在正式版本中关闭。
+    通常我们都是用一个`Config`文件来配置，不知道大家有没有遇到过正式版中忘记关闭`Log`日志的情况。
+- 多渠道包非常让人头疼。现在国内市场这么多。一个个的打多麻烦，虽然我们会用友盟打包工具等。
+    怎么破？
+    
+
+先把项目中的`build.gradle`展现一下，然后慢慢分析。
+```xml
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 22
+    buildToolsVersion "22.0.1"
+
+    defaultConfig {
+        applicationId "com.charon.*"
+        minSdkVersion 11
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0"
+
+        multiDexEnabled true
+        // default umeng channel name
+        manifestPlaceholders = [UMENG_CHANNEL_VALUE: "umeng"]
+    }
+
+    signingConfigs {
+        debug {
+            storeFile file("debug.keystore")
+        }
+
+        release {
+            storeFile file("keystore.keystore")
+            storePassword "android"
+            keyAlias "androiddebugkey"
+            keyPassword "android"
+        }
+    }
+
+    buildTypes {
+        debug {
+            versionNameSuffix "-debug"
+            minifyEnabled false
+            zipAlignEnabled false
+            shrinkResources false
+            signingConfig signingConfigs.debug
+        }
+
+        release {
+            zipAlignEnabled true
+            // remove unused resources
+            shrinkResources true
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            signingConfig signingConfigs.release
+        }
+    }
+
+    productFlavors {
+        xiaomi {}
+        _360 {}
+        baidu {}
+        qq {}
+    }
+
+    productFlavors.all {
+            // change UMENG_CHANNEL_VALUE to the product channel name
+        flavor -> flavor.manifestPlaceholders = [UMENG_CHANNEL_VALUE: name]
+    }
+
+    lintOptions {
+        // if true, stop the gradle build if errors are found
+        abortOnError false
+
+        // set to true to turn off analysis progress reporting by lint
+        // quiet true
+        // if true, only report errors
+//        ignoreWarnings true
+        // if true, emit full/absolute paths to files with errors (true by default)
+        //absolutePaths true
+        // if true, check all issues, including those that are off by default
+//        checkAllWarnings true
+        // if true, treat all warnings as errors
+//        warningsAsErrors true
+        // turn off checking the given issue id's
+//        disable 'TypographyFractions','TypographyQuotes'
+        // turn on the given issue id's
+//        enable 'RtlHardcoded','RtlCompat', 'RtlEnabled'
+        // check *only* the given issue id's
+//        check 'NewApi', 'InlinedApi'
+        // if true, don't include source code lines in the error output
+//        noLines true
+        // if true, show all locations for an error, do not truncate lists, etc.
+//        showAll true
+        // Fallback lint configuration (default severities, etc.)
+        lintConfig file("default-lint.xml")
+        // if true, generate a text report of issues (false by default)
+//        textReport true
+        // location to write the output; can be a file or 'stdout'
+//        textOutput 'stdout'
+        // if true, generate an XML report for use by for example Jenkins
+//        xmlReport false
+        // file to write report to (if not specified, defaults to lint-results.xml)
+//        xmlOutput file("lint-report.xml")
+        // if true, generate an HTML report (with issue explanations, sourcecode, etc)
+//        htmlReport true
+        // optional path to report (default will be lint-results.html in the builddir)
+//        htmlOutput file("lint-report.html")
+
+        // set to true to have all release builds run lint on issues with severity=fatal
+        // and abort the build (controlled by abortOnError above) if fatal issues are found
+//        checkReleaseBuilds true
+        // Set the severity of the given issues to fatal (which means they will be
+        // checked during release builds (even if the lint target is not included)
+//        fatal 'NewApi', 'InlineApi'
+        // Set the severity of the given issues to error
+//        error 'Wakelock', 'TextViewEdits'
+        // Set the severity of the given issues to warning
+//        warning 'ResourceAsColor'
+        // Set the severity of the given issues to ignore (same as disabling the check)
+//        ignore 'TypographyQuotes'
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+
+    applicationVariants.all { variant ->
+        variant.outputs.each { output ->
+            def outputFile = output.outputFile
+            if (outputFile != null && outputFile.name.endsWith('.apk')) {
+                def fileName = outputFile.name.replace(".apk", "-${defaultConfig.versionName}.apk")
+                output.outputFile = new File(outputFile.parent, fileName)
+            }
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    compile project(':libraries:framework')
+    // square leakcanary
+    debugCompile 'com.squareup.leakcanary:leakcanary-android:1.3.1'
+    releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.3.1'
+}
+
+repositories {
+    mavenCentral()
+    maven{
+        url "[maven reposity path]"
+    }
+}
+
+
+```
+	            
+
+下面来详细讲几个地方:
+
+```xml
+apply plugin: 'com.android.application'
+
+android {
+    ...
+    defaultConfig {
+        // 支持方法数超过65536后的处理
+        multiDexEnabled true
+        // 这里就是上面提到的替换友盟统计中channel的值，下面这句话的意思就是默认值为umeng
+        manifestPlaceholders = [UMENG_CHANNEL_VALUE: "umeng"]
+    }
+
+	// 签名操作
+    signingConfigs {
+        debug {
+		     // debug签名文件配置
+            storeFile file("debug.keystore")
+        }
+
+        release {
+		    // 正式版签名文件配置
+            storeFile file("keystore.keystore")
+            storePassword "android"
+            keyAlias "androiddebugkey"
+            keyPassword "android"
+        }
+    }
+
+    buildTypes {
+        debug {
+		    // debug的签名处理
+            versionNameSuffix "-debug"
+            minifyEnabled false
+            zipAlignEnabled false
+            shrinkResources false
+            signingConfig signingConfigs.debug
+        }
+
+        release {
+		    // 正式版签名处理
+            zipAlignEnabled true
+            // remove unused resources
+            shrinkResources true
+			// proguard 混淆
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            signingConfig signingConfigs.release
+        }
+    }
+
+	// 多渠道打包
+    productFlavors {
+        xiaomi {}
+        _360 {}
+        baidu {}
+        qq {}
+		free {
+		    // 当然这里还可以指定 applicationId 版本等这些内容，比如我们程序有一个收费版一个付费版，他俩的包名不同，这时候就可以通过这种方式来指定。
+			applicationId = 'com.test.test'
+            versionName = '1.0'
+            versionCode = 1
+		}
+    }
+
+    productFlavors.all {
+        // 统一将manifest中的UMENG_CHANNEL_VALUE值替换为上面productFlavors中对应的渠道名
+        flavor -> flavor.manifestPlaceholders = [UMENG_CHANNEL_VALUE: name]
+    }
+
+    lintOptions {
+        // if true, stop the gradle build if errors are found
+        abortOnError false
+
+		// 下面是一些其他的选项，一般都用不到
+        // set to true to turn off analysis progress reporting by lint
+        // quiet true
+        // if true, only report errors
+//        ignoreWarnings true
+        // if true, emit full/absolute paths to files with errors (true by default)
+        //absolutePaths true
+        // if true, check all issues, including those that are off by default
+//        checkAllWarnings true
+        // if true, treat all warnings as errors
+//        warningsAsErrors true
+        // turn off checking the given issue id's
+//        disable 'TypographyFractions','TypographyQuotes'
+        // turn on the given issue id's
+//        enable 'RtlHardcoded','RtlCompat', 'RtlEnabled'
+        // check *only* the given issue id's
+//        check 'NewApi', 'InlinedApi'
+        // if true, don't include source code lines in the error output
+//        noLines true
+        // if true, show all locations for an error, do not truncate lists, etc.
+//        showAll true
+        // Fallback lint configuration (default severities, etc.)
+        lintConfig file("default-lint.xml")
+        // if true, generate a text report of issues (false by default)
+//        textReport true
+        // location to write the output; can be a file or 'stdout'
+//        textOutput 'stdout'
+        // if true, generate an XML report for use by for example Jenkins
+//        xmlReport false
+        // file to write report to (if not specified, defaults to lint-results.xml)
+//        xmlOutput file("lint-report.xml")
+        // if true, generate an HTML report (with issue explanations, sourcecode, etc)
+//        htmlReport true
+        // optional path to report (default will be lint-results.html in the builddir)
+//        htmlOutput file("lint-report.html")
+
+        // set to true to have all release builds run lint on issues with severity=fatal
+        // and abort the build (controlled by abortOnError above) if fatal issues are found
+//        checkReleaseBuilds true
+        // Set the severity of the given issues to fatal (which means they will be
+        // checked during release builds (even if the lint target is not included)
+//        fatal 'NewApi', 'InlineApi'
+        // Set the severity of the given issues to error
+//        error 'Wakelock', 'TextViewEdits'
+        // Set the severity of the given issues to warning
+//        warning 'ResourceAsColor'
+        // Set the severity of the given issues to ignore (same as disabling the check)
+//        ignore 'TypographyQuotes'
+    }
+
+	// 可以指定用具体哪个JDK版本来进行编译
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+
+	// 更改生成的apk文件名字，方便区分多渠道
+    applicationVariants.all { variant ->
+        variant.outputs.each { output ->
+            def outputFile = output.outputFile
+            if (outputFile != null && outputFile.name.endsWith('.apk')) {
+                def fileName = outputFile.name.replace(".apk", "-${defaultConfig.versionName}.apk")
+                output.outputFile = new File(outputFile.parent, fileName)
+            }
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    compile project(':libraries:framework')
+    // square leakcanary
+    debugCompile 'com.squareup.leakcanary:leakcanary-android:1.3.1'
+    releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.3.1'
+}
+
+repositories {
+    //从中央库里面获取依赖
+    mavenCentral()
+    //或者使用指定的本地maven 库
+    maven{
+        url "file://F:/githubrepo/releases"
+    }
+    //或者使用指定的远程maven库
+    maven{
+        url "远程库地址"
+    }
+}
+
+上面`build.gradle`中的配置基本就是这些，那么`manifest`中的清单文件该如何对`umeng`渠道进行修改呢？ 
+```xml
+    <application
+        android:allowBackup="true"
+        android:name=".application.RetailApplication"
+        android:icon="@mipmap/ic_launcher"
+        android:theme="@android:style/Theme.Light.NoTitleBar.Fullscreen"
+        android:label="@string/app_name">
+        <activity
+            android:name=".SplashActivity"
+            android:screenOrientation="portrait"
+            android:configChanges="keyboardHidden|orientation|screenSize"
+            android:label="@string/app_name">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+
+        <!--支持Gradle中的渠道替换-->
+        <meta-data
+            android:name="UMENG_CHANNEL"
+            android:value="${UMENG_CHANNEL_VALUE}" />
+    </application>
+```
+				
+上面讲解了如何进行多渠道打包。还剩下一个问题，就是`Log`开关的问题。这就要用到`BuildConfig.DEBUG`。 `Gradle`脚本默认有`debug`和`release`两种模式，对应的`BuildCondig.DEBUG`字段分别为`true`和`false`，而且不可更改。该字段编译后自动生成，在`app/build/source/BuildConfig/Build Varients/package name/BuildConfig`文件中。所以我们可以在`LogUtil`中这样配置。
+```java
+public class LogUtil {
+    /**
+     * If print log here.
+     */
+    private static int LOG_LEVEL = BuildConfig.DEBUG ? 6 : 1;
+
+    private static final int VERBOSE = 5;
+    private static final int DEBUG = 4;
+    private static final int INFO = 3;
+    private static final int WARN = 2;
+    private static final int ERROR = 1;
+
+    ...
+}
+```
+			
+这里再多提一句，就是如果我们不想使用`BuildConfig.DEBUG`，想额外的使用一些其他的配置该如何操作呢？
+可以在`gradle`文件中的`buildTypes`中进行添加。
+```xml
+buildTypes {
+	debug {
+		// 显示Log
+		buildConfigField "boolean", "LOG_DEBUG", "true"
+		versionNameSuffix "-debug"
+		minifyEnabled false
+		zipAlignEnabled false
+		shrinkResources false
+		signingConfig signingConfigs.debug
+	}
+
+	release {
+		// 不显示Log
+		buildConfigField "boolean", "LOG_DEBUG", "false"
+		zipAlignEnabled true
+		// remove unused resources
+		shrinkResources true
+		minifyEnabled true
+		proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+		signingConfig signingConfigs.release
+	}
+}
+```
+
+在代码中使用`BuildConfig.LOG_DEBUG`就可以了。
+
+
+更多内容请参考[Gradle Plugin User Guide](http://tools.android.com/tech-docs/new-build-system/user-guide)
+
+
+最后附上一张`Build`流程图: 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/build.png?raw=true)	
+
+	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\211\345\274\271).md" "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\211\345\274\271).md"
similarity index 97%
rename from "Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\211\345\274\271).md"
rename to "AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\211\345\274\271).md"
index ac210c1d..d1ee66ef 100644
--- "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\211\345\274\271).md"
+++ "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\211\345\274\271).md"
@@ -3,7 +3,7 @@ AndroidStudio使用教程(第三弹)
 
 熟悉了基本的使用之后，可能关心的就是版本控制了。
 
-- `SVN`
+- `SVN`               
     - 下载`Subversion command line`              
 		- 方法一                
 	        下载地址是[Subversion](http://subversion.apache.org/packages.html)里面有不同系统的版本。             
@@ -46,7 +46,7 @@ AndroidStudio使用教程(第三弹)
 	完成之后会提示是否想要把刚才检出的项目导入`AndroidStudio`中。                  
 	Why not?                         
 	以`Gradle`方式导入， 然后`next`, 然后`next`然后就没有然后了。                     
-	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_3_12.png?raw=true)	                    
+	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_3_12.png?raw=true)	                                     
 		
 ---
 
diff --git "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\214\345\274\271).md" "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\214\345\274\271).md"
similarity index 85%
rename from "Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\214\345\274\271).md"
rename to "AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\214\345\274\271).md"
index 872d119c..beb44600 100644
--- "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\214\345\274\271).md"
+++ "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\214\345\274\271).md"
@@ -6,9 +6,10 @@ AndroidStudio使用教程(第二弹)
     官方文档中说`Android Studio`可以兼容`Eclipse`的现有工程，但需要做一些操作：              
 	
     - `Eclipse`进行项目构建           
-	    首先升级`ADT`到最新版本, 好像是22之后，选择需要从`Eclipse`导出的工程，右键选择`Export`并选择`Android`下的`Generate Gradle Build Files`, 运行完成之后你会
-	发现在项目目录中多了一个`build.gradle`, 这就是`Android Studio`所识别的文件。      
-		PS：官方文档中说明如果没有`Grade build`文件，也是可以将项目导入到`Android Studio`中，它会用现有的`Ant build`文件进行配置.但为了更好地使用之后的功能和充分使用构建变量，
+	    首先升级`ADT`到最新版本, 好像是22之后，选择需要从`Eclipse`导出的工程，右键选择`Export`并选择`Android`下的`Generate Gradle Build Files`, 
+		运行完成之后你会发现在项目目录中多了一个`build.gradle`, 这就是`Android Studio`所识别的文件。      
+		PS：官方文档中说明如果没有`Grade build`文件，也是可以将项目导入到`Android Studio`中，它会用现有的`Ant build`文件进行配置.
+		但为了更好地使用之后的功能和充分使用构建变量，
 		还是强烈地建议先从`ADT`插件中生成`Gradle`文件再导入`Android Studio`.
     
 	- 导入            
@@ -43,13 +44,13 @@ AndroidStudio使用教程(第二弹)
 		
 	- 选择主题
 	
-	    想给应用设置一个主题，可以点击`Theme`图标![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_2_4.png?raw=true), 就会显示
-		出选择对话框。       
+	    想给应用设置一个主题，可以点击`Theme`图标![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_2_4.png?raw=true), 
+		就会显示出选择对话框。       
 		![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_2_5.png?raw=true)
 	
 	- 国际化
-	    对于国际化的适配选择国际化图标![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_2_6.png?raw=true),然后在弹出的列表中选择
-		需要进行国际化的国家进行适配即可。
+	    对于国际化的适配选择国际化图标![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_2_6.png?raw=true),
+		然后在弹出的列表中选择需要进行国际化的国家进行适配即可。
 
 - 常用功能
     有些人进来之后可能找不到`DDMS`了.      
diff --git "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\224\345\274\271).md" "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\224\345\274\271).md"
similarity index 92%
rename from "Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\224\345\274\271).md"
rename to "AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\224\345\274\271).md"
index 7af6c902..4901e48c 100644
--- "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\224\345\274\271).md"
+++ "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\272\224\345\274\271).md"
@@ -25,7 +25,8 @@ Add a library module
 完成之后打开该`Module`中的`build.gradle`你会看到`apply plugin: 'com.android.library'`说明这是一个`library`.    
 
 ### Add a dependency on a library module   
-上一步我们创建了`mylibrary module`, 现在我们想让`app module`依赖与`mylibrary module`, 但是构建系统还不知道，我们需要修改`app module`下的`build.gradle`文件添加`mylibrary module`就可以了。 
+上一步我们创建了`mylibrary module`, 现在我们想让`app module`依赖与`mylibrary module`, 但是构建系统还不知道，
+我们需要修改`app module`下的`build.gradle`文件添加`mylibrary module`就可以了。 
 
 ```xml
 ...
@@ -37,11 +38,11 @@ dependencies {
 
 ### Build the project in Android Studio
 `Android Studio`中`build project`点击上面导航栏中的`Build`菜单然后选择`Make Project`, 这时窗口底部的状态栏就会显示`build`的进度。       
-点击窗口右边底部的![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_5_2.png?raw=true)图标来显示`Gradle Console`.      
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_5_3.png?raw=true)
+点击窗口右边底部的![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_5_2.png)图标来显示`Gradle Console`.      
+![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_5_3.png?raw=true)
 
 在窗口右边栏点击`Gradle`窗口可以看到当前所有可用的`build tasks`, 双击里面的`task`即可执行。      
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_5_4.png?raw=true)
+![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_5_4.png?raw=true)
 
 ### Build a release version
 点击`Gradle tasks`页面， 展开`app`中的`task`然后双击`assembleRelease`即可。 
@@ -99,7 +100,7 @@ dependencies {
 `dependencies`部分是在`android`之外，该部分声明了依赖的`module`。     
 **注意：**当修改项目中得`build files`时，`Android Studio`需要进行项目同步来导入相应的`build`配置变化， 点击`Android Studio`中黄色通知部分的`Sync Now`
 来进行变化的导入。               
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_5_5.png?raw=true)     
+![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_5_5.png)     
 
 ###Declare dependencies
 ```java
diff --git "a/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\205\255\345\274\271).md" "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\205\255\345\274\271).md"
new file mode 100644
index 00000000..fc09cb7e
--- /dev/null
+++ "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\205\255\345\274\271).md"
@@ -0,0 +1,45 @@
+AndroidStudio使用教程(第六弹)
+===
+
+Debug
+---
+
+`Andorid Studio`中进行`debug`:      
+- 在`Android Studio`中打开应用程序。    
+- 点击状态栏中的`Debug`![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_6_1.png?raw=true)图标。
+- 在接下来的选择设备窗口选择相应的设备或创建虚拟机， 点击`OK`即可。     
+`Android Studio`在`debug`时会打开`Debug`工具栏， 可以点击`Debug`![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_6_2.png?raw=true)图标打开`Debug`窗口。    
+
+###设置断点 
+与`Eclipse`十分相似， 在代码左侧位置点击一下即可， 圆点的颜色变了。   
+
+###Attach the debugger to a running process 
+在`debug`时不用每次都去重启应用程序。 我们可以对正在运行的程序进行`debug`:  
+- 点击`Attach debugger to Android proccess`![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_6_3.png?raw=true)图标。  
+- 设备选择窗口选择想要`debug`的设备。 
+- 点击`Debug`![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_6_2.png?raw=true)图标打开`Debug`工具栏。    
+- 在`Debug`工具栏中有`Stop Over`, `Stop Into`等图标和快捷键，这些就不仔细说明了, 和`Eclipse`都差不多。     
+
+### View the system log
+在`Android DDMS`中和`Debug`工具栏中都可以查看系统`log`日志，
+- 在窗口底部栏点击`Android`![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_6_4.png?raw=true) 图标打开`Android DDMS`工具栏。   
+- 如果此时`Logcat`窗口中的日志是空得，点击`Restart`![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_6_5.png?raw=true)图标。 
+- 如果想要只显示当前某个进程的信息点击`Only Show Logcat from Selected Process`![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_6_6.png?raw=true). 如果当时设备窗口不可见，点击右上角的`Restore Devices View`![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_6_7.png?raw=true)图标，该图标只有设备窗口不可见时才会显示。    
+
+删除`Project`及`Module`
+---
+
+很多人都在问`AndroidStudio`中如何删除`Project`，如何删除`Module`？怎么和`Eclipse`不同啊，找不到`delete`或`remove`选项。       
+    - 删除`Project`       
+        点击左侧`File`-->`Close project`，关闭当前工程， 然后直接找到工程所在本地文件进行删除(慎重啊), 删除完之后点击最近列表中的该项目就会提示不存在，我们把他从最近项目中移除即可.![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_6_11.png?raw=true)你会发现，点击`remove`之后没效果，以后估计会解决。      
+    - 删除`Module`             
+        在该`Module`邮件选择`Open Module Settings`。            
+		![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_6_8.png?raw=true)                
+        进入设置页后选中要删除的`Module`点击左上角的删除图标`-`后点击确定。                                
+		![Image](https://github.com/CharonChui/Pictures/blob/master/AndroidStudio_6_9.png?raw=true)
+		
+        	  	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\233\233\345\274\271).md" "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\233\233\345\274\271).md"
similarity index 94%
rename from "Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\233\233\345\274\271).md"
rename to "AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\233\233\345\274\271).md"
index f299810e..23feeb94 100644
--- "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\233\233\345\274\271).md"
+++ "b/AndroidStudioCourse/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\233\233\345\274\271).md"
@@ -19,7 +19,8 @@ Gradle
 Overview
 ---
 
-`AndroidStudio build`系统是一个你可以用来`build, test, run, package your apps`的工具。 `build`系统与`Android Studio`之间是独立的，所以你可以在`Android Studio`中或者
+`AndroidStudio build`系统是一个你可以用来`build, test, run, package your apps`的工具。 `build`系统与`Android Studio`之间是独立的，
+所以你可以在`Android Studio`中或者
 `command line`中去执行。写完自己的应用程序之后，你可以用`build`系统来做以下事情：　　　　　
 - 自定义、配置和扩展`build`过程.。     
 - 用同一个工程根据不同的特性来创建多个`APK`。    
@@ -61,7 +62,8 @@ Projects and modules
 `Module`中包含应用中的源码和资源文件， `Android Studio`中的`Project`包含以下三种`Module`：     
 - 包含可复用代码的`Java library modules`. 构建系统对`Java library module`会生成一个`JAR`包。 
 - 有可复用`Android`代码和资源的`Android library modules`. 对该`library modules`构建系统会生成一个`AAR(Android ARchive)`包。
-- 有应用代码或者也可能是依赖其他`library modules`的`Android application modules`, 虽然很很多`Android`应用都只包含一个`application module`. 对于`application modules`
+- 有应用代码或者也可能是依赖其他`library modules`的`Android application modules`, 虽然很很多`Android`应用都只包含一个`application module`. 
+对于`application modules`
 构建系统会生成一个`APK`包。 
 
 `Android Studio projects`在`project`的最外城都包含一个列出所有`modules`的`Gradle build file`, 每个`module`也都包含自己的`Gradle build file`.      
@@ -76,9 +78,11 @@ Dependencies
 - `Local Dependencies`
     如果本地文件系统中有`module`所依赖的二进制包如`JAR`包， 你可以在该`module`中的构建文件中声明这些依赖关系。 
 - `Remote Dependencies`
-    当你的依赖是在远程仓库中，你不需要去下载他们然后拷贝到自己的工程中。 `Android Studio`支持远程`Maven`依赖。 `Maven`是一个流行的项目管理工具，它可以使用仓库帮助组织项目依赖。         
+    当你的依赖是在远程仓库中，你不需要去下载他们然后拷贝到自己的工程中。 `Android Studio`支持远程`Maven`依赖。 `Maven`是一个流行的项目管理工具，
+	它可以使用仓库帮助组织项目依赖。         
 	
-	许多优秀的软件类库和工具都在公共的`Maven`仓库中， 对于这些依赖只需按照远程仓库中不同元素的定义来指定他们的`Moven`位置即可。 构建系统使用的`Maven`位置格式是`group:name:version`. 例如`Google Guava`16.0.1版本类库的`Maven`坐标是
+	许多优秀的软件类库和工具都在公共的`Maven`仓库中， 对于这些依赖只需按照远程仓库中不同元素的定义来指定他们的`Moven`位置即可。 
+	构建系统使用的`Maven`位置格式是`group:name:version`. 例如`Google Guava`16.0.1版本类库的`Maven`坐标是
 	`com.google.guava:guava:16.0.1`.      
 	
 	` Maven Central Repository`现在被广泛用于分发许多类库和工具。 
@@ -95,7 +99,8 @@ dependencies {
 Build tasks
 ---
 
-`Android Studio`构建系统定义了一些列的构建任务， 高级别的任务调用一些产出必要输出的任务。 构建系统提供了`project tasks`来构建`app`和`module tasks`来独立的构建`modules`.          
+`Android Studio`构建系统定义了一些列的构建任务， 高级别的任务调用一些产出必要输出的任务。 构建系统提供了`project tasks`来构建`app`和`module tasks`
+来独立的构建`modules`.          
 
 可以通过`Andorid Studio`或者命令行看到当前可用任务的列表，并且执行里面的任务。 
 
diff --git "a/AndroidStudioCourse/AndroidStudio\346\217\220\351\253\230Build\351\200\237\345\272\246.md" "b/AndroidStudioCourse/AndroidStudio\346\217\220\351\253\230Build\351\200\237\345\272\246.md"
new file mode 100644
index 00000000..24c94c5d
--- /dev/null
+++ "b/AndroidStudioCourse/AndroidStudio\346\217\220\351\253\230Build\351\200\237\345\272\246.md"
@@ -0,0 +1,91 @@
+AndroidStudio提高Build速度
+===
+
+`Android Studio`自动发布以来，凭借其强大的功能，很快让开发者都投入到它的阵营下。但是也问题，就是`Build`速度太慢了。
+
+之前也根据网上的资料，修改了一些配置，但是一次二分多种有时候还是让人抓狂。今天索性记录一下。首先看一下[Google+](https://plus.google.com/+AndroidDevelopers/posts/ECrb9VQW9XP)关于该问题的讨论。
+
+
+- 使用`daemon`及`parallel`模式
+
+    在下面的目录中创建一个名为`gradle.properties`的文件:     
+
+    - `/home/<username>/.gradle/ (Linux)`
+    - `/Users/<username>/.gradle/ (Mac)`
+    - `C:\Users\<username>\.gradle (Windows)`
+
+    文件的内容为: 
+    ```
+    org.gradle.daemon=true
+    org.gradle.parallel=true
+    ```
+    
+    经过上面的这一步修改是对所有工程都有效果的，如果你只想对某一个工程配置的话，那就在该工程目录下的`gralde.properties`中进行配置。
+    ```
+    # Project-wide Gradle settings.
+    
+    # IDE (e.g. Android Studio) users:
+    # Gradle settings configured through the IDE *will override*
+    # any settings specified in this file.
+    
+    # For more details on how to configure your build environment visit
+    # http://www.gradle.org/docs/current/userguide/build_environment.html
+    
+    # Specifies the JVM arguments used for the daemon process.
+    # The setting is particularly useful for tweaking memory settings.
+    # Default value: -Xmx10248m -XX:MaxPermSize=256m
+    # org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+    
+    # When configured, Gradle will run in incubating parallel mode.
+    # This option should only be used with decoupled projects. More details, visit
+    # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+    # org.gradle.parallel=true
+    ```
+    打开时默认如上。我们给加添加上面的配置就好。
+    
+    当然你也可以通过`Studio`的设置中进行修改。        
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/studio_speed.png?raw=true)
+
+
+- 使用`offline`模式      
+  
+    下一步就是开始`offline`模式，因为我们经常会在`gradle`中使用一下依赖库时用`+`这样的话就能保证你的依赖库是最新的版本，但是这样在每次`build`的时候都会去检查是不是最新的版本，所以就会耗时。        
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/studio_offline.png?raw=true)
+
+    在开发过程中是不建议使用动态版本的，在`Studio`中使用动态版本的`gradle`中间中使用`ALT+ENTER`键进行修复。
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/studio_daymaic_version_tip.png?raw=true)
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/studio_dymaic_version_fix.png?raw=true)
+    详细有关为什么不要使用动态版本的介绍，请参考[Don't use dynamic versions for your dependencies](http://blog.danlew.net/2015/09/09/dont-use-dynamic-versions-for-your-dependencies/)
+
+- 增加内存使用`SSD`         
+    首先是增大内存,    `Mac`中在`Applications`中找到`Sutio`然后右键显示包内容`Contents/bin/studio.vmoptions`。
+    打开该文件后修改就可以了，我是的是:     
+    ```
+    #
+    # *DO NOT* modify this file directly. If there is a value that you would like to override,
+    # please add it to your user specific configuration file.
+    #
+    # See http://tools.android.com/tech-docs/configuration
+    #
+    -Xms1024m
+    -Xmx4096m
+    -XX:MaxPermSize=768m
+    -XX:ReservedCodeCacheSize=768m
+    -XX:+UseCompressedOops
+    ```
+    我没看见`DO NOT`的提示- -!
+    
+    - Xms 是JVN启动起始时的堆内存，堆内存是分配给对象的内容。
+    - Xmx 是能使用的最大堆内存。
+
+
+- 使用`Instant Run`   
+         
+    `Instantt Run`放在这里说可能不合适，但是用他确实能大大的减少运行时间。              
+    如果还不了解的话可以参考[Instant Run](http://tools.android.com/tech-docs/instant-run)           
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/studio_instantrun.png?raw=true)
+		
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\212\240\345\274\272/AsyncTask\350\257\246\350\247\243.md" "b/Android\345\212\240\345\274\272/AsyncTask\350\257\246\350\247\243.md"
deleted file mode 100644
index 074ca6cf..00000000
--- "a/Android\345\212\240\345\274\272/AsyncTask\350\257\246\350\247\243.md"
+++ /dev/null
@@ -1,10 +0,0 @@
-AsyncTask详解
-===
-
-很长时间没有去写总结了。太忙了。        
-先记录一下，尽快补上。。。。赶紧。
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\212\240\345\274\272/Fiddler\346\212\223\345\217\226Android\346\211\213\346\234\272\346\225\260\346\215\256\345\214\205.md" "b/Android\345\212\240\345\274\272/Fiddler\346\212\223\345\217\226Android\346\211\213\346\234\272\346\225\260\346\215\256\345\214\205.md"
deleted file mode 100644
index 7a3f3049..00000000
--- "a/Android\345\212\240\345\274\272/Fiddler\346\212\223\345\217\226Android\346\211\213\346\234\272\346\225\260\346\215\256\345\214\205.md"
+++ /dev/null
@@ -1,13 +0,0 @@
-Fiddler抓取Android手机数据包
-===
-
-`Android`开发过程中很多时候需要进行抓包操作。 今天就讲解一下使用`Fidder`进行抓取数据包。                  
-[Fiddler官网]{http://www.telerik.com/fiddler}下载安装即可。     
-1. 配置`Fiddler`     
-     
-
-    
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\212\240\345\274\272/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/Android\345\212\240\345\274\272/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 dd24fd2d..00000000
--- "a/Android\345\212\240\345\274\272/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,101 +0,0 @@
-Handler导致内存泄露分析
-===
-
-有关内存泄露请猛戳[内存泄露](https://github.com/CharonChui/AndroidNote/blob/master/Android%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86/%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F.md)
-
-```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.
-			}
-		}
-	}
-}
-```
-
-    
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\212\240\345\274\272/LayoutInflater.inflate\350\257\246\350\247\243.md" "b/Android\345\212\240\345\274\272/LayoutInflater.inflate\350\257\246\350\247\243.md"
deleted file mode 100644
index 3087a5a0..00000000
--- "a/Android\345\212\240\345\274\272/LayoutInflater.inflate\350\257\246\350\247\243.md"
+++ /dev/null
@@ -1,94 +0,0 @@
-LayoutInflater.inflate详解
-===
-
-`LayoutInflater`概述    
----
-
-从`XML`文件中实例化一个布局成对应的`View`类， 它从来不会直接使用， 而是使用`getLayoutInflater()`或者`getSystemService(String)`来获得一个对应当前`context`的标准`LayoutInflater`
-实例。 
-
-例如：　　　　
-```java
-LayoutInflater inflater = (LayoutInflater)context.getSystemService
-      (Context.LAYOUT_INFLATER_SERVICE);
-```               
-
-如果要在自己的`views`中通过`LayoutInflater.Factory`来创建`LayoutInflater`你可以用`cloneInContext(Context)`来克隆一个当前存在的`ViewFactory`然后再用`setFactory(LayoutInfalter.FActory)`
-来设置成自己的`FActory`.	              
-
-
-起因
----
-
-原来在项目中一直习惯用`inflater.inflate(R.layout.layout, null)`最近却发现会有一个黄色的警告。　十分好奇，所以决定找出原因。      
-
-我们发现`inflate`方法有两个：     
-- View inflate(int resource, ViewGroup root)
-- View inflate(int resource , ViewGroup root, boolean attachToRoot)
-第二个参数是指实例的布局所要放入的跟视图。        
-一般我们在不需要将该布局放入跟视图的时候都会把第二个参数传为`null`，这样系统就不会去进行相应的绑定操作了，不然就蹦了。 我相信很多人都会这样理解，所以都很少用到
-第二个方法， 其实这样是错误的。    
-
-原因在于`android:layout_xyz`属性会在父视图中重新计算，而你用第一个方法是说需要被添加到父视图中，只不过你不知道添加到哪一个父视图中， 所以你在`xml`中定义的`LayoutParams`
-就会被忽略(因为没有已知的父视图)。     
-
-示例
----
-
-大家肯定遇到过在`ListView`的`item`布局中设置的高度没有效果的问题。 
-```java
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="match_parent"
-    android:layout_height="100dip"
-    android:gravity="center_vertical"
-    android:orientation="horizontal">
-    <TextView
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="test" />
-</LinearLayout>
-```
-
-```java
-public View getView(int position, View convertView, ViewGroup parent) {
-    if (convertView == null) {
-        convertView = inflate(R.layout.item_lv_test, null);
-    }
-    return convertView;
-}
-```
-
-如果用上面的代码会发现设置`100dp`是无效的。     
-
-而如果换成下面的代码就可以了。
-```java
-public View getView(int position, View convertView, ViewGroup parent) {
-    if (convertView == null) {
-        convertView = inflate(R.layout.item_lv_test, null, false);
-    }
-    return convertView;
-}
-```
-这里你该会想一想为什么很多需要显示`View`的方法中都有`ViewGroup`这个参数。      
-所以有些人会说在跟布局中设置是无效的，要再嵌套一层布局。 这样是错误的，会造成布局层级增多，影响性能。 
-
-
-细节
----
-
-- `setContentView()`与`LayoutInfalter.inflate()`的区别
-    `setContentView()`一旦调用，就会立即显示`UI`. 而`LayoutInfalter.inflate()`这是把布局转换成对应的`View`对象，不会立即显示，只有需要的时候再显示出来。   
-	
-- `View.inflate()`方法与`LayoutInflater.inflate()`的区别
-    直接上源码：     
-	```java
-	public static View inflate(Context context, int resource, ViewGroup root) {
-        LayoutInflater factory = LayoutInflater.from(context);
-        return factory.inflate(resource, root);
-    }
-	```
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
diff --git "a/Android\345\212\240\345\274\272/ListView\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/Android\345\212\240\345\274\272/ListView\346\272\220\347\240\201\345\210\206\346\236\220.md"
deleted file mode 100644
index 0428838a..00000000
--- "a/Android\345\212\240\345\274\272/ListView\346\272\220\347\240\201\345\210\206\346\236\220.md"
+++ /dev/null
@@ -1,40 +0,0 @@
-ListView源码分析
-===
-
-
-一直都想写一篇文章分析下`ListView`的实现，总是忙，一直拖到现在，快到年底了，写出来希望能帮助一些面试跳槽的人。      
-当然写这篇文章也是有原因的，当时一个同事在面试的时候，被对方问答`ListView`实现原理，同事简单的答了一些，被对方刁难，    
-最后不欢而散，想想也是，一下说起来，还真只能说些简单的原理。
-
-在`Android`开发过程中`ListView`比较常用，先看一下文档中对`ListView`的说明：
-```java
-/*
- * Implementation Notes:
- *
- * Some terminology:
- *
- *     index    - index of the items that are currently visible
- *     position - index of the items in the cursor
- */
-
-
-/**
- * A view that shows items in a vertically scrolling list. The items
- * come from the {@link ListAdapter} associated with this view.
- */
-```
-
-然后再说一下`ListView`的继承关系`ListView extends AbsListView extends AdapterView<ListAdapter> extends ViewGroup extends View`
-
-
-
-
-
-
-
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\212\240\345\274\272/\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/Android\345\212\240\345\274\272/\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"
deleted file mode 100644
index feee5ad3..00000000
--- "a/Android\345\212\240\345\274\272/\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"
+++ /dev/null
@@ -1,72 +0,0 @@
-视频播放相关内容总结
-===
-
-##Surface简介
-- `Surface`就是“表面”的意思。在`SDK`的文档中，对`Surface`的描述是这样的：“`Handle onto a raw buffer that is being managed by the screen compositor`”，
-	翻译成中文就是“由屏幕显示内容合成器`(screen compositor)`所管理的原生缓冲器的句柄”，	这句话包括下面两个意思：
-    - 通过Surface（因为Surface是句柄）就可以获得原生缓冲器以及其中的内容。就像在C语言中，可以通过一个文件的句柄，就可以获得文件的内容一样；
-    - 原生缓冲器（rawbuffer）是用于保存当前窗口的像素数据的。
-- 简单的说`Surface`对应了一块屏幕缓冲区，每个`Window`对应一个`Surface`，任何`View`都是画在`Surface`上的，传统的`view`共享一块屏幕缓冲区，所有的绘制必须在`UI`线程中进行
-- 我们不能直接操作Surface实例，要通过SurfaceHolder，在SurfaceView中可以通过getHolder()方法获取到SurfaceHolder实例。
-- `Surface`是一个用来画图形的地方，但是我们知道画图都是在一个`Canvas`对象上面进行的，*`Surface`中的`Canvas`成员，是专门用于提供画图的地方，就像黑板一样，其中的原始缓冲区是用来保存数据的地方，
-	`Surface`本身的作用类似一个句柄，得到了这个句柄就可以得到其中的`Canvas`、原始缓冲区以及其他方面的内容，所以简单的说`Surface`是用来管理数据的(句柄)*。
-
-
-##SurfaceView简介      
-- 简单的说`SurfaceView`就是一个有`Surface`的`View`里面内嵌了一个专门用于绘制的`Surface`,`SurfaceView`控制这个`Surface`的格式和尺寸以及绘制位置.`SurfaceView`是一个`View`也许不够严谨，
-	然而从定义中 `public class SurfaceView extends View`显示`SurfaceView`确实是派生自`View`，但是`SurfaceView`却有着自己的`Surface`，源码：
-    ```java
-    if (mWindow == null) {  
-		mWindow = new MyWindow(this);  
-		mLayout.type = mWindowType;  
-		mLayout.gravity = Gravity.LEFT|Gravity.TOP;  
-		mSession.addWithoutInputChannel(mWindow, mWindow.mSeq, mLayout,  
-		mVisible ? VISIBLE : GONE, mContentInsets);  
-    }  
-    ```
-    很明显，每个`SurfaceView`创建的时候都会创建一个`MyWindow`，`new MyWindow(this)`中的`this`正是`SurfaceView`自身，因此将`SurfaceView`和`window`绑定在一起，而前面提到过每个`window`对应一个`Surface`，
-	所以`SurfaceView`也就内嵌了一个自己的`Surface`，可以认为`SurfaceView`是来控制`Surface`的位置和尺寸。传统`View`及其派生类的更新只能在`UI`线程，然而`UI`线程还同时处理其他交互逻辑，
-	这就无法保证`view`更新的速度和帧率了，而`SurfaceView`可以用独立的线程来进行绘制，因此可以提供更高的帧率，例如游戏，摄像头取景等场景就比较适合用`SurfaceView`来实现。
-	
-- `Surface`是纵深排序`(Z-ordered)`的，这表明它总在自己所在窗口的后面。
-- `Surfaceview`提供了一个可见区域，只有在这个可见区域内的`Surface`部分内容才可见，可见区域外的部分不可见，所以可以认为**`SurfaceView`就是展示`Surface`中数据的地方**,`Surface`就是管理数据的地方，
-	`SurfaceView`就是展示数据的地方，只有通过`SurfaceView`才能展现`Surface`中的数据。           
-	![image](https://github.com/CharonChui/Pictures/master/SurfaceView.png?raw=true)   
-- `Surface`的排版显示受到视图层级关系的影响，它的兄弟视图结点会在顶端显示。这意味者`Surface`的内容会被它的兄弟视图遮挡，这一特性可以用来放置遮盖物`(overlays)`(例如，文本和按钮等控件)。
-	注意，如果`Surface`上面有透明控件，那么它的每次变化都会引起框架重新计算它和顶层控件的透明效果，这会影响性能。surfaceview变得可见时，surface被创建；surfaceview隐藏前，surface被销毁。
-	这样能节省资源。如果你要查看 surface被创建和销毁的时机，可以重载surfaceCreated(SurfaceHolder)和 surfaceDestroyed(SurfaceHolder)。
-	**`SurfaceView`的核心在于提供了两个线程：`UI`线程和渲染线程**,两个线程通过“双缓冲”机制来达到高效的界面适时更新。
-
-##SurfaceHolder简介
-
-显示一个`Surface`的抽象接口，使你可以控制`Surface`的大小和格式以及在`Surface`上编辑像素，和监视`Surace`的改变。这个接口通常通过`SurfaceView`类实现。
-简单的说就是我们无法直接操作`Surface`只能通过`SurfaceHolder`这个接口来获取和操作`Surface`。
-SurfaceHolder`中提供了一些`lockCanvas()`：获取一个Canvas对象，并锁定之。所得到的Canvas对象，其实就是Surface中一个成员。加锁的目的其实就是为了在绘制的过程中，
-Surface中的数据不会被改变。lockCanvas是为了防止同一时刻多个线程对同一canvas写入。
-
-
-*从设计模式的角度来看,`Surface、SurfaceView、SurfaceHolder`实质上就是`MVC(Model-View-Controller)`，`Model`就是模型或者说是数据模型，更简单的可以理解成数据，在这里也就是`Surface`，
-`View`就是视图，代表用户交互界面，这里就是`SurfaceView`,`SurfaceHolder`就是`Controller.`*
-
-
-##MediaController
-
-- `MediaController`继承`FrameLayout`，通过`MediaPlayerControl`接口与`VideoView`进行结合控制，内部是通过`PopupWindow`将整个控制栏界面显示到界面上，
-	而该`PopupWindow`所显示在的位置就是通过`setAnchorView()`设置进来的`Anchor`一般可以使当前的`VideoView`或者是整个`Activity`的根布局。这里要分为小屏和全屏两种情况来进行设置。
-	如果当前的`MediaController`只是播放前下面的控制栏部分(进度条、快进、快退、暂停等)这样我们可以通过对VideoView设置点击事件，控制它的显示和隐藏。
-	如果`MediaController`为整个屏幕包括了控制栏部分、上端的信息显示部分、以及左右栏的功能部分、这时候就可以通过对`MediaController`本身设置点击事件来控制显示和隐藏。         
-	
-`Controller`可以用`PopupWindow`来实现,具体有两种方式：     
-
-    - 整个控制栏(上面的信息部分、下面的控制部分以及左右边)都在`Controller`中，`setAnchorView()`的时候就会让`Controller`中的`PopupWindow`显示出来(一直显示，但是这个`PopupWindow`是透明的)，
-		真正的显示与隐藏是控制在`PopupWindow`中的`View`部分的显示与隐藏来实现。开始的时候我是想用这种方式，当时我想的是播放就播放、控制就控制，分离开来多好，但是没想到，
-		一旦有`PopupWindow`显示出来后，Activity是接收不到任何`Touch`事件的，所有的重试界面等都要放到`Controller`中实现(手势处理等)。但是也有好处，就是不管显示还是隐藏都可以去处理手势.
-		
-	- `PopupWindow`不是全屏的，只包含下面真正的控制部分(快进、快退、暂停等,不包含上面的信息部分和左右边),而且也不是开始就显示，显示隐藏是通过控制`PopupWindow`的显示与隐藏来进行的。
-		而对于信息部分、以及左右边都是在`Activity`的布局当中，我们通过接口回调得到`PopupWindow`的显示与隐藏来控制这些布局的显示与隐藏即可。
-		这样的话我们就需要将手势等全部放到`Activity`中去处理，但是也有一个问题，就是如果`Controller`正在显示的话`Activity`是接收不到`Touch`事件的，就无法处理手势，只能是让`Controller`消失后才能处理手势。
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\200\345\274\271).md" "b/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\200\345\274\271).md"
deleted file mode 100644
index 302c87b9..00000000
--- "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\200\345\274\271).md"
+++ /dev/null
@@ -1,83 +0,0 @@
-AndroidStudio使用教程(第一弹)
-===
-
-`Android Studio`是一套面世不久的`IDE`（即集成开发环境），免费向谷歌及`Android`的开发人员发放。`Android Studio`以`IntelliJ IDEA`为基础,旨在取代`Eclipse`和`ADT`（`Android`开发者工具）为开发者提供更好的开发工具。              
-运行相应速度、智能提示、布局文件适时多屏预览等都比`Eclipse`要强，但也不能说全部都是有点现在`Studio`中无法在一个窗口管理多个`Project`，每个`Project`都要打开一个窗口，或者是`close`当前的后再打开别的。
-
-当但是毕竟是预览版，所以只是暂时试用了下，并没有过多接触，开发中还是使用`Eclipse`。           
-经过一年多的沉淀，如果已到0.8.4版本，最近准备在工作用正式开始使用，所以看了下官网的教程。准备开始了。
-
-- 安装                  
-    这个我就不多说了，大家都知道，官网下载安装即可。安装完成后界面和`Eclipse`有些类似，然后就新建一个`Project`，完成之后会发现一直在提示下载，
-	这是在下载`Gradle`，大约二三十M的大小，由于伟大的防火墙，所以可能需要很长时间，这里就不教大家了，对程序猿来说不是难题，大家都会科学上网。
-	
-- 区别              
-    - 此`Project`非彼`Project`, `Android Studio`的目录结构(`Project`)代表一个`Workspace`，一个`Workspace`里面可以有多个`Module`，这里`Module`可以理解成`Eclipse`中的一个`Project`.
-	`Project`代表一个完整的`Android app`，而`modules`则是`app`的一个组件，并且这个组件可以单独`build,test,debug`。`modules`可以分为下面几种：      
-	    - Java library modules    
-        - Android library modules: 包含android相关代码和资源，最后生成AAR(Android ARchive)包    
-        - Android application modules       
-		
-    - 结构发生了变化，在`src`目录下有一个`main`的分组同时包含了`java`和`res`.
-	    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_1.png?raw=true)        
-	    如图：`MyApplication`就是`Project`，而`app`就是`Module`.
-	
-- 设置           
-   进入后你会发现字体或样式等不符合你的习惯。            
-   `Windows`下点击左上角`File` -> `Settings`进入设置页面(`Mac`下为 `Android Studio` -> `Preferences`)，在搜索框搜`Font`找到`Colors&Font`下的`Font`选项，我们会发现无法修改右侧字体大小。这里修改必须
-   要通过新建`Theme`进行修改的，点击`Save as`输入一个名字后，就可以修改字体了。
-   	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_2.png?raw=true)
-
-	这里可能有些人会发现我的主题是黑色的，和`IO`大会演示的一样，但是安装后默认是白色的，有些刺眼。这里可以通过设置页面中修改`Theme`来改变,
-	默认是`Intellij`, 改为`Darcula`就是黑色的了.
-	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_3.png?raw=true)
-	很酷有木有.
-	
-- 运行            
-    设置好字体后，当然要走你了。             
-	运行和`Eclipse`中比较像，点击绿色的箭头。 可以通过箭头左边的下拉菜单选择不同的`Module`,快捷键是`Shift+F10`                              
-	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_4.png?raw=true)
-
-    `AndroidStudio`默认安装会启动模拟器，如果想让安装到真机上可以配置一下。在下拉菜单中选择`Edit Configurations`选择提示或者是`USB`设备。
-	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_5.png?raw=true)	
-	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6.png?raw=true)	
-	
-- 常用快捷键介绍            
-    `AndroidStudio`中可以将快捷键设置成`Eclipse`中的快捷键。具体方法为在设置页面搜索`keymap`然后选择为`Eclipse`就可以了.
-	![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_7.png?raw=true)	
-	
-	强迫症的人伤不起，非想用默认的快捷键。               
-	这里我整理下下个人常用的几个快捷键。 每个人的习惯不同，大家各取所需              
-	`Ctrl+S`                   开个玩笑，这个键算是彻底废掉了， 因为`AndroidStudio`与`Eclipse`不同，他是自动保存的，所以我们再也不需要`Ctrl+S`了.          
-	`Ctrl+空格`                代码提示                    (同`Eclipse`中`Alt+/`)         
-	`Ctrl+Shjft+N`             查找文件                    (同`Eclipse`中`Ctrl+Shift+R`)              
-	`Ctrl+F12`                 显示当前文件的结构          (同`Eclipse`中`Ctrl+0`)             
-	`Ctrl+Alt+L`               格式化                      (同`Eclipse`中`Ctrl+Shift+F`)             
-	`Ctrl+Alt+O`               优化导入的包                (同`Eclipse`中`Ctrl+Shift+O`)           
-	`Ctrl+Q`                   查看文档                    (同`Eclipse`中`F2`)              
-	`Alt+F7`                   搜寻                        (同`Eclipse`中`File Search`)           
-	`Alt+Insert`               新建文件或生成代码(`GetSet`)(同`Eclipse`中`Alt+Shift+S后的操作`)             
-	`Alt+Enter`                快速修复                    (同`Eclipse`中`F1`)           
-	`Ctrl+P`                   显示方法参数                         
-	`Shift+F10`                运行项目                               
-	`Ctrl+Shift+Backspace`     跳转到上次修改的地方           
-	`Ctrl+E`                   显示最近编辑列表             
-	`Ctrl+[或]`                跳转到大括号开头或结尾            
-	`Ctrl+Alt+T`               把代码包在一起(加try catch等)          
-	`Alt+↑或↓`                 在方法间移动            
-	`Ctrl+Shift+F7`            高亮本文件中选中的代码            
-	`Alt+←或→`                 切换已打开的文件视图               
-	`Shift+F6`                 重命名               
-	`Ctrl+B`                   快速打开该类或方法                  
-	`F2`                       快速定位到文件错误或警告位置              
-	`Ctrl+X`                   剪切当前行                
-	`Ctrl+Y`                   删除当前行             
-	`Ctrl+D`                   复制当前行                            
-	`F4`                       进入源码             
-	`Alt+1`                    开关`Project`视图      
-	`Ctrl+_F4`                 关闭当前窗口            
-	
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\203\345\274\271).md" "b/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\203\345\274\271).md"
deleted file mode 100644
index 2559e2df..00000000
--- "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\344\270\203\345\274\271).md"
+++ /dev/null
@@ -1,11 +0,0 @@
-AndroidStudio使用教程(第七弹)
-===
-
-本文讲解一下如何利用`Gradle`打多渠道包。    
-	
-	                  
-		
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\205\255\345\274\271).md" "b/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\205\255\345\274\271).md"
deleted file mode 100644
index adfa1e72..00000000
--- "a/Android\345\237\272\347\241\200/AndroidStudio\344\275\277\347\224\250\346\225\231\347\250\213(\347\254\254\345\205\255\345\274\271).md"
+++ /dev/null
@@ -1,43 +0,0 @@
-AndroidStudio使用教程(第六弹)
-===
-
-Debug
----
-
-`Andorid Studio`中进行`debug`:      
-- 在`Android Studio`中打开应用程序。    
-- 点击状态栏中的`Debug`![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_1.png?raw=true)图标。
-- 在接下来的选择设备窗口选择相应的设备或创建虚拟机， 点击`OK`即可。     
-`Android Studio`在`debug`时会打开`Debug`工具栏， 可以点击`Debug`![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_2.png?raw=true)图标打开`Debug`窗口。    
-
-###设置断点 
-与`Eclipse`十分相似， 在代码左侧位置点击一下即可， 圆点的颜色变了。   
-
-###Attach the debugger to a running process 
-在`debug`时不用每次都去重启应用程序。 我们可以对正在运行的程序进行`debug`:  
-- 点击`Attach debugger to Android proccess`![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_3.png?raw=true)图标。  
-- 设备选择窗口选择想要`debug`的设备。 
-- 点击`Debug`![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_2.png?raw=true)图标打开`Debug`工具栏。    
-- 在`Debug`工具栏中有`Stop Over`, `Stop Into`等图标和快捷键，这些就不仔细说明了, 和`Eclipse`都差不多。     
-
-### View the system log
-在`Android DDMS`中和`Debug`工具栏中都可以查看系统`log`日志，
-- 在窗口底部栏点击`Android`![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_4.png?raw=true) 图标打开`Android DDMS`工具栏。   
-- 如果此时`Logcat`窗口中的日志是空得，点击`Restart`![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_5.png?raw=true)图标。 
-- 如果想要只显示当前某个进程的信息点击`Only Show Logcat from Selected Process`![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_6.png?raw=true). 如果当时设备窗口不可见，点击右上角的`Restore Devices View`![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_7.png?raw=true)图标，该图标只有设备窗口不可见时才会显示。    
-
-删除`Project`及`Module`
----
-
-很多人都在问`AndroidStudio`中如何删除`Project`，如何删除`Module`？怎么和`Eclipse`不同啊，找不到`delete`或`remove`选项。       
-    - 删除`Project`       
-        点击左侧`File`-->`Close project`，关闭当前工程， 然后直接找到工程所在本地文件进行删除(慎重啊), 删除完之后点击最近列表中的该项目就会提示不存在，我们把他从最近项目中移除即可.![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_11.png?raw=true)你会发现，点击`remove`之后没效果，以后估计会解决。      
-    - 删除`Module`           
-        在该`Module`邮件选择`Open Module Settings`。     ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_8.png?raw=true)                
-        进入设置页后选中要删除的`Module`点击左上角的删除图标`-`.     ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_9.png?raw=true)后点击确定。                  
-        在该`Module`上邮件这次会发现已经有`Delete`按钮了。删除就可以了。    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AndroidStudio_6_10.png?raw=true)   
-	  	
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/Android\345\212\250\347\224\273.md" "b/Android\345\237\272\347\241\200/Android\345\212\250\347\224\273.md"
deleted file mode 100644
index 398f610e..00000000
--- "a/Android\345\237\272\347\241\200/Android\345\212\250\347\224\273.md"
+++ /dev/null
@@ -1,108 +0,0 @@
-Android动画
-===
-
-1. AlphaAnimation
-
-    ```java
-    RelativeLayout rl_splash = (RelativeLayout) findViewById(R.id.rl_splash);
-    //播放动画效果
-    AlphaAnimation animation = new AlphaAnimation(1.0f, 0.0f);
-    //设置Alpha动画的持续时间
-    animation.setDuration(2000);
-    //播放Alpha动画
-    rl_splash.setAnimation(animation);
-    ```
-
-2. RotateAnimation
-
-    ```java
-    //相对于自身的哪个位置旋转，这里是相对于自身的右下角
-    RotateAnimation ra = new RotateAnimation(0, 360,  //从哪旋转，旋转多少度
-            Animation.RELATIVE_TO_SELF, 1.0f, Animation.RELATIVE_TO_SELF,
-            1.0f);
-    ra.setDuration(800);
-    ra.setRepeatCount(Animation.INFINITE);
-    ra.setRepeatMode(Animation.RESTART);
-    iv_scan.startAnimation(ra);
-     ```
-3. ScaleAnimation(缩放动画)    
-     
-    ```java 
-    ScaleAnimation(float fromX, float toX, float fromY, float toY) 
-    Constructor to use when building a ScaleAnimation from code
-    ```
-
-4. TranslateAnimation(位移动画)     
-    
-    ```java
-    TranslateAnimation(int fromXType, float fromXValue, int toXType, float toXValue, int fromYType, float fromYValue, int toYType, float toYValue) 
-    Constructor to use when building a TranslateAnimation from code
-    ```
-
-5. AnimationSet (多组动画)
-    
-    ```java
-    ScaleAnimation sa = new ScaleAnimation(0.2f, 1.0f, 0.4f,1.0f);//缩放的动画效果,1.0f就代表窗体的总宽或者高
-    sa.setDuration(400);
-    TranslateAnimation ta = new TranslateAnimation(//位移动的动画效果
-              Animation.RELATIVE_TO_SELF, 0,//指定这个位置是相对于谁
-              Animation.RELATIVE_TO_SELF, 0.1f,
-              Animation.RELATIVE_TO_SELF, 0,
-              Animation.RELATIVE_TO_SELF, 0);
-    ta.setDuration(300);
-    AnimationSet set = new AnimationSet(false);//如果想播放多种动画的组合，这里就要用到了AnimationSet
-    set.addAnimation(sa);
-    set.addAnimation(ta);
-    contentView.startAnimation(set); // 播放一组动画. 
-    ```
-
-6. Frame动画    
-
-    - 在`drawable`目录下新建一个`xml`文件，内容如下:
-    
-        ```xml
-        <?xml version="1.0" encoding="utf-8"?>
-        <animation-list xmlns:android="http://schemas.android.com/apk/res/android"
-            android:oneshot="true" > //onshot是指定是否循环播放
-            <item
-                android:drawable="@drawable/desktop_rocket_launch_1"  //Frame动画的图片
-                android:duration="50"/> //播放这个图片持续的时间
-            <item
-                android:drawable="@drawable/desktop_rocket_launch_2"
-                android:duration="100"/>
-        </animation-list>
-        ```
-    - 播放Frame动画
-    
-        ```java
-        AnimationDrawable rocketAnimation;
-        public void onCreate(Bundle savedInstanceState) {
-              super.onCreate(savedInstanceState);
-              setContentView(R.layout.main);
-              ImageView rocketImage = (ImageView) findViewById(R.id.iv);
-              rocketImage.setBackgroundResource(R.drawable.animlist); //将上边建的Frame动画的xml文件通过背景资源设置给图片
-              rocketAnimation = (AnimationDrawable) rocketImage.getBackground();  //获取到图片的背景资源
-        }
-        public void start(View view) {
-              if (!rocketAnimation.isRunning()) {
-                   rocketAnimation.start();  //播放
-              }
-        }
-        ```
-        
-7. 保持动画播放完成后的状态`animation.setFillAfter(true);`   
-
-    ```java
-    Interpolator //定义了动画的变化速度，可以实现匀速、正加速、负加速、无规则变加速度
-    AccelerateDecelerateInterpolator//先加速后减速。
-    AccelerateInterpolator//逐渐加速。    
-    LinearInterpolator//平稳不变的   
-    DecelerateInterpolator//逐渐减速
-    CycleInterpolator//曲线运动特效，要传递float型的参数。     
-    animation.setInterpolator(new LinearInterpolator());//指定动画的运行效果
-    ```
-    
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213ContentProvider.md" "b/Android\345\237\272\347\241\200/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213ContentProvider.md"
deleted file mode 100644
index ca8719d6..00000000
--- "a/Android\345\237\272\347\241\200/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213ContentProvider.md"
+++ /dev/null
@@ -1,309 +0,0 @@
-Android四大组件之ContentProvider
-===
-
-ContentProvider    
----
-
-安卓应用程序默认是无法获取到其他程序的数据，这是安卓安全学的基石(沙盒原理)。但是经常我们需要给其他应用分享数据，内容提供者就是一个这种可以分享数据给其他应用的接口。
-可以简单的理解为，内容提供者就是一个可以在不同应用程序间共享数据的组件，相当于一个中间人，一个程序把数据暴露给这个中间人，另一个则通过这个中间人获取相应的数据.        
-
-下面的这张图片能更直观的显示：
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ContentProvider_1.png)    
-
-- `ContentProvider`中的`getContext`和`AndroidTestCast`中的`getContext`方法一样，都是一个模拟的上下文，必须在该类初始化之后才会调用`setContext`方法将`context`设置成自己的成员变量中记录，
-	所以对于获取`getContext`的时候只能放在方法内，不能放到成员位置，因为在成员上时是null，而在方法内调用时该类就会已经初始化完了      
-
-- `ContentProvider`中的`query()`后不能关闭数据库，因为其他的应用在调用该`query`方法时需要继续使用该返回值`Cursor`，所以不能关闭数据库，因为数据库关闭之后`Cursor`就不能用了，
-	`Cursor`中保存的数据其实是数据库的一个引用，如果数据库关了`Cursor`就不能找到里面的数据了，`Cursor.close()`只是释放·Cursor·用到的资源。说到这里就多数一句
-	`According to Dianne Hackborn (Android framework engineer) there is no need to close the database in a content provider.`以为内容提供者是因为进程启动时便加载，之后就一直存在，当进程销毁
-	释放资源时会去关闭数据库。
-	
-- 如果数据是`SQLiteDatabase`，表中必须有一个`_id`的列，用来表示每条记录的唯一性。
-
-1. 继承`ContentProvider`,并实现相应的方法。
-```java
-public class NoteProvider extends ContentProvider {
-    private static final int NOTES = 1;
-    private static final int NOTE_ID = 2;
-
-    public static final String AUTHORITY = "com.charon.demo.provider.noteprovider";
-    public static final String TABLE_NAME = "note";
-    // 定义一个名为`CONTENT_URI`必须为其指定一个唯一的字符串值，最好的方案是以类的全名称
-    public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/" + TABLE_NAME);
-
-    // 声明一个路径的检查者，参数为Uri不匹配时的返回值
-    // 虽然是中间人，但也不能谁要数据我们都给，所以要检查下，只有符合我们要求的人，我们才会给他数据。
-    private static UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
-
-    private NoteSQLiteOpenHelper mSQLiteOpenHelper;
-    private SQLiteDatabase mSQLiteDatabase;
-
-    static {
-        // 建立匹配规则，例如发现路径为ccom.charon.demo.provider.noteprovider/note/1表示要操作note表中id为1的记录
-        sUriMatcher.addURI(AUTHORITY, TABLE_NAME, NOTES);
-        sUriMatcher.addURI(AUTHORITY, TABLE_NAME + "/#", NOTE_ID);
-    }
-
-    /**
-     * Implement this to initialize your content provider on startup.
-     * This method is called for all registered content providers on the
-     * application main thread at application launch time.  It must not perform
-     * lengthy operations, or application startup will be delayed.
-     * <p/>
-     * <p>You should defer nontrivial initialization (such as opening,
-     * upgrading, and scanning databases) until the content provider is used
-     * (via {@link #query}, {@link #insert}, etc).  Deferred initialization
-     * keeps application startup fast, avoids unnecessary work if the provider
-     * turns out not to be needed, and stops database errors (such as a full
-     * disk) from halting application launch.
-     * <p/>
-     * <p>If you use SQLite, {@link android.database.sqlite.SQLiteOpenHelper}
-     * is a helpful utility class that makes it easy to manage databases,
-     * and will automatically defer opening until first use.  If you do use
-     * SQLiteOpenHelper, make sure to avoid calling
-     * {@link android.database.sqlite.SQLiteOpenHelper#getReadableDatabase} or
-     * {@link android.database.sqlite.SQLiteOpenHelper#getWritableDatabase}
-     * from this method.  (Instead, override
-     * {@link android.database.sqlite.SQLiteOpenHelper#onOpen} to initialize the
-     * database when it is first opened.)
-     *
-     * @return true if the provider was successfully loaded, false otherwise
-     */
-    @Override
-    public boolean onCreate() {
-        mSQLiteOpenHelper = new NoteSQLiteOpenHelper(getContext());
-        return true;
-    }
-
-    /**
-     * 内容提供者暴露的查询的方法.
-     */
-    @Override
-    public Cursor query(Uri uri, String[] projection, String selection,
-                        String[] selectionArgs, String sortOrder) {
-        mSQLiteDatabase = mSQLiteOpenHelper.getReadableDatabase();
-        Cursor cursor;
-        // 1.重要的事情 ,检查 uri的路径.
-        switch (sUriMatcher.match(uri)) {
-            case NOTES:
-                break;
-            case NOTE_ID:
-                String id = uri.getLastPathSegment();
-                if (TextUtils.isEmpty(selection)) {
-                    selection = selection + "_id = " + id;
-                } else {
-                    selection = selection + " and " + "_id = " + id;
-                }
-                break;
-            default:
-                throw new IllegalArgumentException("UnKnown Uri" + uri);
-                break;
-        }
-        cursor = mSQLiteDatabase.query(TABLE_NAME, projection, selection, selectionArgs, null, null, sortOrder);
-        if (cursor != null) {
-            cursor.setNotificationUri(getContext().getContentResolver(), uri);
-        }
-        return cursor;
-    }
-
-    /**
-     * Implement this to handle requests for the MIME type of the data at the
-     * given URI.  The returned MIME type should start with
-     * <code>vnd.android.cursor.item</code> for a single record,
-     * or <code>vnd.android.cursor.dir/</code> for multiple items.
-     * This method can be called from multiple threads, as described in
-     * <a href="{@docRoot}guide/topics/fundamentals/processes-and-threads.html#Threads">Processes
-     * and Threads</a>.
-     * <p/>
-     * <p>Note that there are no permissions needed for an application to
-     * access this information; if your content provider requires read and/or
-     * write permissions, or is not exported, all applications can still call
-     * this method regardless of their access permissions.  This allows them
-     * to retrieve the MIME type for a URI when dispatching intents.
-     *
-     * @param uri the URI to query.
-     * @return a MIME type string, or {@code null} if there is no type.
-     */
-    @Override
-    public String getType(Uri uri) {
-        // 注释说的很清楚了，下面是常用的格式
-        // 单个记录的IMEI类型 vnd.android.cursor.item/vnd.<yourcompanyname>.<contenttype>
-        // 多个记录的IMEI类型 vnd.android.cursor.dir/vnd.<yourcompanyname>.<contenttype>
-        switch (sUriMatcher.match(uri)) {
-            case NOTE_ID:
-                // 如果uri为 content://com.charon.demo.noteprovider/note/1
-                return "vnd.android.cursor.item/vnd.charon.note";
-            case NOTES:
-                return "vnd.android.cursor.dir/vnd.charon.note";
-            default:
-                return null;
-        }
-
-        // 这个MIME类型的作用是要匹配AndroidManifest.xml文件<activity>标签下<intent-filter>标签的子标签<data>的属性android:mimeType。
-        // 如果不一致，则会导致对应的Activity无法启动。
-    }
-
-    @Override
-    public Uri insert(Uri uri, ContentValues values) {
-        mSQLiteDatabase = mSQLiteOpenHelper.getWritableDatabase();
-        switch (sUriMatcher.match(uri)) {
-            case NOTES:
-                break;
-
-            case NOTE_ID:
-                break;
-
-            default:
-                throw new IllegalArgumentException("UnKnown Uri" + uri);
-                break;
-        }
-
-        long rowId = mSQLiteDatabase.insert(TABLE_NAME, null, values);
-        if (rowId > 0) {
-            Uri noteUri = ContentUris.withAppendedId(CONTENT_URI, rowId);
-            getContext().getContentResolver().notifyChange(noteUri, null);
-            return noteUri;
-        }
-
-        return null;
-    }
-
-    @Override
-    public int delete(Uri uri, String selection, String[] selectionArgs) {
-        mSQLiteDatabase = mSQLiteOpenHelper.getWritableDatabase();
-        switch (sUriMatcher.match(uri)) {
-            case NOTES:
-                break;
-
-            case NOTE_ID:
-                String id = uri.getLastPathSegment();
-                if (TextUtils.isEmpty(selection)) {
-                    selection = selection + "_id = " + id;
-                } else {
-                    selection = selection + " and " + "_id = " + id;
-                }
-                break;
-
-            default:
-                throw new IllegalArgumentException("UnKnown Uri" + uri);
-                break;
-        }
-        int count = mSQLiteDatabase.delete(TABLE_NAME, selection, selectionArgs);
-        getContext().getContentResolver().notifyChange(uri, null);
-        return count;
-    }
-
-    @Override
-    public int update(Uri uri, ContentValues values, String selection,
-                      String[] selectionArgs) {
-        switch (sUriMatcher.match(uri)) {
-            case NOTES:
-
-                break;
-
-            case NOTE_ID:
-
-                break;
-
-            default:
-				throw new IllegalArgumentException("UnKnown Uri" + uri);
-				break;
-        }
-
-        mSQLiteDatabase = mSQLiteOpenHelper.getWritableDatabase();
-        int update = mSQLiteDatabase.update(TABLE_NAME, values, selection, selectionArgs);
-        return update;
-    }
-```
-
-2. 在清单文件中进行注册，并且指定其authorities
-```xml
-<provider
-	android:name="com.charon.demo.provider.NoteProvider"
-	android:authorities="com.charon.demo.provider.noteprovider" >
-```
-	
-3. 使用内容提供者获取数据，使用`ContentResolver`去操作`ContentProvider`, `ContentResolver`用于管理`ContentProvider`实例，并且可实现找到指定的`ContentProvider`并获取里面的数据
-	```java
-	public void query(View view){
-		//得到内容提供者的解析器  中间人
-		ContentResolver resolver = getContentResolver();
-		Cursor cursor = resolver.query(NoteProvider.CONTENT_URI, null, null, null, null);
-		while(cursor.moveToNext()){
-			String name = cursor.getString(cursor.getColumnIndex("name"));
-			int id = cursor.getInt(cursor.getColumnIndex("id"));
-			float money = cursor.getFloat(cursor.getColumnIndex("money"));
-			System.out.println("id="+id+",name="+name+",money="+money);
-		}
-		cursor.close();
-	}
-	public void insert(View view){
-		ContentResolver resolver = getContentResolver();
-		ContentValues values = new ContentValues();
-		values.put("name", "买洗头膏");
-		values.put("money", 22.58f);
-		resolver.insert(NoteProvider.CONTENT_URI, values);
-	}
-	public void update(View view){
-		ContentResolver resolver = getContentResolver();
-		ContentValues values = new ContentValues();
-		values.put("name", "买洗头膏");
-		values.put("money", 42.58f);
-		resolver.update(NoteProvider.CONTENT_URI, values, "name=?", new String[]{"买洗头膏"});
-	}
-	public void delete(View view){
-		ContentResolver resolver = getContentResolver();
-		resolver.delete(NoteProvider.CONTENT_URI, "name=?", new String[]{"买洗头膏"});
-	}
-	```
-
-内容观察者     
----
-
-内容观察者的原理：     
-`How a content provider actually stores its data under the covers is up to its designer. But all content providers implement a common interface for querying the provider and 
-returning results — as well as for adding, altering, and deleting data.            
-It's an interface that clients use indirectly, most generally through ContentResolver objects. 
-You get a ContentResolver by calling getContentResolver() from within the implementation of an Activity or other application component: 
-You can then use the ContentResolver's methods to interact with whatever content providers you're interested in.`
-
-1. 一方使用内容观察者去观察变化
-	```java
-		protected void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-		setContentView(R.layout.activity_main);
-		ContentResolver resolver = getContentResolver();
-		resolver.registerContentObserver(NoteProvider.CONTENT_URI, true, new NoteObserver(new Handler()));
-
-	}
-
-	private class NoteObserver extends ContentObserver {
-
-		public NoteObserver(Handler handler) {
-			super(handler);
-			
-		}
-		//当观察到数据发生变化的时候  会执行onchange方法.
-		@Override
-		public void onChange(boolean selfChange) {
-			super.onChange(selfChange);
-			Log.i(TAG,"发现有新的短信产生了...");
-			//1.利用内容提供者  中间人 获取用户的短信数据.
-			ContentResolver resolver  = getContentResolver();
-			// .. 重新查询
-			cursor = ...;
-			cursor.close();
-		}
-	}
-	```
-2. 一方在发生变化的时候去发送改变的消息
-	对于一些系统的内容提供者内部都实现了该步骤，如果是自己写程序想要暴露就必须要加上该代码。     
-	
-	```java	
-	getContext().getContentResolver().notifyChange(uri, null);
-	```
-	
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213Service.md" "b/Android\345\237\272\347\241\200/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213Service.md"
deleted file mode 100644
index fcb8806c..00000000
--- "a/Android\345\237\272\347\241\200/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213Service.md"
+++ /dev/null
@@ -1,204 +0,0 @@
-Android四大组件之Service
-===
-
-服务的两种开启方式：
----
-
-1. startService();开启服务.  
-开启服务后 服务就会长期的后台运行,即使调用者退出了.服务仍然在后台继续运行.服务和调用者没有什么关系, 调用者是不可以访问服务里面的方法.
-2. bindService();绑定服务.
-服务开启后,生命周期与调用者相关联.调用者挂了,服务也会跟着挂掉.不求同时生,但求同时死.调用者和服务绑定在一起,调用者可以间接的调用到服务里面的方法.
-
-AIDL
----
-
-本地服务:服务代码在本应用中    
-远程服务:服务在另外一个应用里面(另外一个进程里面)
-aidl: android interface defination language
-IPC implementation : inter process communication
-
-服务混合调用的生命周期
----
-
-开启服务后再去绑定服务然后再去停止服务，这时服务是无法停止了.必须先解绑服务然后再停止服务，在实际开发中会经常采用这种模式，开启服务(保证服务长期后台运行) --> 绑定服务(调用服务的方法) --> 解绑服务(服务继续在后台运行) --> 停止服务(服务停止),服务只会被开启一次，如果已经开启后再去执行开启操作是没有效果的。    
-
-绑定服务调用方法的原理
----
-
-1. 定义一个接口，里面定义一个方法
-```java
-    public interface IService {
-        public void callMethodInService();//通过该类中提供一个方法，让自定 
-    义的类实现这个接口
-    }
-```
-2. 在服务中自定义一个IBinder的实现类，让这个类继承Binder(Binder是IBinder的默认适配器)，由于这个自定义类是私有的，为了其他类中能拿到该类，我们要定义一个接口，提供一个方法，让IBinder类去实现该接口，并在相应方法中调用自己要供别人调用的方法。   
-```java
-    public class TestService extends Service {
-    	@Override
-    	public IBinder onBind(Intent intent) {
-        	System.out.println("onbind");
-        	return new MyBinder();
-    	}
-        
-    	private class MyBinder extends Binder implements IService{
-        	public void callMethodInService(){
-                //实现该方法，去调用服务中的方法
-            	methodInService();
-        	}
-    	}
-        //服务中的方法
-    	public void methodInService(){
-        	Toast.makeText(this, "我是服务里面的春哥,巴拉布拉!", 0).show();
-    	}
-    }
-```
-3. 服务的调用类中将`onServiceConnected`方法中的第二个参数强转成接口
-```java
-    public class DemoActivity extends Activity {
-        private Intent intent;
-        private Myconn conn;
-        private IService iService;
-        @Override
-        public void onCreate(Bundle savedInstanceState) {
-            super.onCreate(savedInstanceState);
-            intent = new Intent(this,TestService.class);
-            setContentView(R.layout.main);
-        }
-        public void start(View view) {
-            startService(intent);
-        }
-        public void stop(View view) {
-            stopService(intent);
-        }
-        public void bind(View view) {
-            conn = new Myconn();
-            //1.绑定服务 传递一个conn对象.这个conn就是一个回调接口
-            bindService(intent, conn, Context.BIND_AUTO_CREATE);
-        }
-        public void unbind(View view) {
-            unbindService(conn);
-        }
-        //调用服务中的方法
-        public void call(View view){
-            iService.callMethodInService();
-        }
-        private class Myconn implements ServiceConnection{
-            //当服务被成功绑定的时候调用的方法.
-            @Override
-            public void onServiceConnected(ComponentName name, IBinder service) {//第二个参数就是服务中的onBind方法的返回值
-                iService = (IService) service;
-            }
-            @Override
-            public void onServiceDisconnected(ComponentName name) {
-            }
-        }
-    } 
-```
-
-远程服务aidl
----
-    
-上面介绍了绑定服务调用服务中方法的原理，对于远程服务的绑定也是这样，
-但是这个远程服务是在另外一个程序中的，在另外一个程序中定 义的这个接口，
-在另外一个程序中是拿不到的，就算是我们在自己的应用 中也定义一个一模一样
-的接口，但是由于两个程序的报名不同，这两个接口也是不一样的，为了解决这个
-问题，谷歌的工程师给提供了aidl，我们将定义的这个接口的`.java`改成 `.aidl`，
-然后将这个接口中的`权限修饰符`都**去掉**，在另一个程序中拷贝这个aidl文 
-件，然后放到同一个包名中，由于`Android`中通过包名来区分应用程序，这两个 
-`aidl`的包名一样，系统会认为两个程序中的接口是同一个，这样就能够在另一
-个程序中将参数强转成这个接口,在使用`aidl`文件拷贝到自己的工程之后会自动
-生成一个接口类，这个接口类中有 一个内部类`Stub`该类继承了`Binder`并实现了
-这个接口，所以我们在自定义 `IBinder的实现类`时只需让自定义的类继承`Stub类`
-即可.
-
-1. 远程服务中定义一个接口，改成`aidl`
-```java
-    package com.seal.test.service;
-    
-    interface IService {
-         void callMethodInService();
-    }
-```
-
-2. 远程服务中定义一个`Ibinder的实现类`，让这个实现类继承上面接口的`Stub类`，
-并在`onBind`方法中返回这个自定义类对象 
-```java
-    public class RemoteService extends Service {
-        @Override
-    	public IBinder onBind(Intent intent) {
-        	System.out.println("远程服务被绑定");
-        	return new MyBinder();
-    	}
-    	private class MyBinder extends IService.Stub{
-        	@Override
-        	public void callMethodInService() {
-            	methodInService();
-        	}
-    	}
-    	public void methodInService(){
-        	System.out.println("我是远程服务里面的方法");
-    	}
-	}
-```
-
-3. 在其他程序中想要绑定这个服务并且调用这个服务中的方法的时候首先要拷贝 
-这个`aidl`文件到自己的工程，然后再`ServiceConnection`的实现类中将这个参数使 
-用`asInterface`方法转成接口，通过这样来得到接口，从而调用接口中的方法    
-```java
-    public class CallRemoteActivity extends Activity {
-        private Intent service;
-        private IService iService;
-        @Override
-        public void onCreate(Bundle savedInstanceState) {
-            super.onCreate(savedInstanceState);
-            setContentView(R.layout.main);
-            service = new Intent();
-            service.setAction("com.itheima.xxxx");
-        }
-        public void bind(View veiw){
-            bindService(service, new MyConn(), BIND_AUTO_CREATE);
-        }
-        public void call(View view){
-            try {
-                iService.callMethodInService();
-            } catch (RemoteException e) {
-                e.printStackTrace();
-            }
-        }
-        private class MyConn implements ServiceConnection{
-            @Override
-            public void onServiceConnected(ComponentName name, IBinder service) {
-                iService = IService.Stub.asInterface(service);
-            }
-            @Override
-            public void onServiceDisconnected(ComponentName name) {
-                // TODO Auto-generated method stub
-            }
-        }
-    }
-```
-
-最后说一下`IntentService`:
-
-`IntentService`是`Service`的子类，用来处理异步请求。客户端可以通过`startService(Intent)`方法将请求的`Intent`传递请求给`IntentService`，
-`IntentService`会将该`Intent`加入到队列中，然后对每一个`Intent`开启一个`worker thread`来进行处理，执行完所有的工作之后自动停止`Service`。
-每一个请求都会在一个单独的`worker thread`中处理，不会阻塞应用程序的主线程。`IntentService` 实际上是`Looper`、`Handler`、`Service` 的集合体,他不仅有服务的功能,还有处理和循环消息的功能.
-
-- Service：
-    1. A Service is not a separate process. The Service object itself does not imply it is running in its own process; unless otherwise specified, it runs in the same process as the application it is part of.
-    2. A Service is not a thread. It is not a means itself to do work off of the main thread (to avoid Application Not Responding errors).
-所以在`Service`中进行耗时的操作时必须要新开一个线程。    
-至于为什么要使用`Service`而不是`Thread`，这个主要的区别就是生命周期不同，`Service`是Android系统的一个组件，Android系统会尽量保持`Service`的长期后台运行，
-即使内存不足杀死了该服务(很少会出现内存不足杀死服务的情况)也会在内存可用的时候去复活该服务，而`Thread`随后都会被杀死
-- IntentService
-    1. IntentService is a base class for Services that handle asynchronous requests (expressed as Intents) on demand. Clients send requests throughstartService(Intent) calls; 
-	    the service is started as needed, handles each Intent in turn using a worker thread, and stops itself when it runs out of work.    
-    2. This "work queue processor" pattern is commonly used to offload tasks from an application's main thread. The IntentService class exists to simplify this pattern and take care of the mechanics. 
-	    To use it, extend IntentService and implement onHandleIntent(Intent). IntentService will receive the Intents, launch a worker thread, and stop the service as appropriate.
-    3. All requests are handled on a single worker thread -- they may take as long as necessary (and will not block the application's main loop), but only one request will be processed at a time.
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/Android\347\274\226\347\240\201\350\247\204\350\214\203_v0.2.docx" "b/Android\345\237\272\347\241\200/Android\347\274\226\347\240\201\350\247\204\350\214\203_v0.2.docx"
deleted file mode 100644
index 6919f186..00000000
Binary files "a/Android\345\237\272\347\241\200/Android\347\274\226\347\240\201\350\247\204\350\214\203_v0.2.docx" and /dev/null differ
diff --git "a/Android\345\237\272\347\241\200/Android\351\235\242\350\257\225\347\237\245\350\257\206\347\202\271.doc" "b/Android\345\237\272\347\241\200/Android\351\235\242\350\257\225\347\237\245\350\257\206\347\202\271.doc"
deleted file mode 100644
index 73acdb6c..00000000
Binary files "a/Android\345\237\272\347\241\200/Android\351\235\242\350\257\225\347\237\245\350\257\206\347\202\271.doc" and /dev/null differ
diff --git "a/Android\345\237\272\347\241\200/Android\351\235\242\350\257\225\351\242\230\345\270\246\347\255\224\346\241\210.doc" "b/Android\345\237\272\347\241\200/Android\351\235\242\350\257\225\351\242\230\345\270\246\347\255\224\346\241\210.doc"
deleted file mode 100644
index 801e5250..00000000
Binary files "a/Android\345\237\272\347\241\200/Android\351\235\242\350\257\225\351\242\230\345\270\246\347\255\224\346\241\210.doc" and /dev/null differ
diff --git "a/Android\345\237\272\347\241\200/AsyncTask\345\210\206\346\236\220.md" "b/Android\345\237\272\347\241\200/AsyncTask\345\210\206\346\236\220.md"
deleted file mode 100644
index c8547081..00000000
--- "a/Android\345\237\272\347\241\200/AsyncTask\345\210\206\346\236\220.md"
+++ /dev/null
@@ -1,125 +0,0 @@
-AsyncTask分析
-===
-
-1. 经典版异步任务
-	```java
-	public abstract class MyAsyncTask {
-		private Handler handler = new Handler(){
-			public void handleMessage(android.os.Message msg) {
-				onPostExecute();
-			};
-		};
-		
-		/**
-		 * 后台任务执行之前 提示用户的界面操作.
-		 */
-		public abstract void onPreExecute();
-		
-		/**
-		 * 后台任务执行之后 更新界面的操作.
-		 */
-		public abstract void onPostExecute();
-		
-		/**
-		 * 在后台执行的一个耗时的操作.
-		 */
-		public abstract void doInBackground();
-		
-		
-		public void execute(){
-			//1. 耗时任务执行之前通知界面更新
-			onPreExecute();
-			new Thread(){
-				public void run() {
-					doInBackground();
-					handler.sendEmptyMessage(0);
-				};
-			}.start();
-			
-		} 
-	}
-	```
-2. 谷歌异步任务
-	```java
-		new AsyncTask<Void, Void, Void>() {
-				@Override
-				protected Void doInBackground(Void... params) {
-					blackNumberInfos = dao.findByPage(startIndex, maxNumber);
-					return null;
-				}
-				@Override
-				protected void onPreExecute() {
-					loading.setVisibility(View.VISIBLE);
-					super.onPreExecute();
-				}
-				@Override
-				protected void onPostExecute(Void result) {
-					loading.setVisibility(View.INVISIBLE);
-					if (adapter == null) {// 第一次加载数据 数据适配器还不存在
-						adapter = new CallSmsAdapter();
-						lv_callsms_safe.setAdapter(adapter);
-					} else {// 有新的数据被添加进来.
-						adapter.notifyDataSetChanged();// 通知数据适配器 数据变化了.
-					}
-					super.onPostExecute(result);
-				}
-			}.execute(); 
-
-	类的构造方法中接收三个参数，这里我们不用参数就都给它传Void，new出来AsyncTask类之后然后重写这三个方法，最后别忘了执行execute方法，其实它的内部和我们写的经典版的异步任务相同，也是里面写了一个在新的线程中去执行耗时的操作，然后用handler发送Message对象，主线程收到这个Message之后去执行onPostExecute中的内容。
-
-
-		//AsyncTask<Params, Progress, Result> ,params 异步任务执行(doBackgroud方法)需要的参数这个参数的实参可以由execute()方法的参数传入,Progess 执行的进度,result是(doBackground方法)执行后的结果 
-
-		new AsyncTask<String, Void, Boolean>() { 
-				ProgressDialog pd;
-				@Override
-				protected Boolean doInBackground(String... params) { //这里返回的就是执行的接口，这个返回的结果会传递给onPostExecute的参数
-					try {
-						String filename = params[0];//得到execute传入的参数
-						File file = new File(Environment.getExternalStorageDirectory(),filename);
-						FileOutputStream fos = new FileOutputStream(file);
-						SmsUtils.backUp(getApplicationContext(), fos, new BackUpStatusListener() {
-							public void onBackUpProcess(int process) {
-								pd.setProgress(process);
-							}
-							
-							public void beforeBackup(int max) {
-								pd.setMax(max);
-							}
-						});
-						return true;
-					} catch (Exception e) {
-						e.printStackTrace();
-						return false;
-					}    
-				}
-				@Override
-				protected void onPreExecute() {
-					pd = new ProgressDialog(AtoolsActivity.this);
-					pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
-					pd.setMessage("正在备份短信");
-					pd.show();
-					super.onPreExecute();
-				}
-				@Override
-				protected void onPostExecute(Boolean result) {
-					pd.dismiss();
-					if(result){
-						Toast.makeText(getApplicationContext(), "备份成功", 0).show();
-					}else{
-						Toast.makeText(getApplicationContext(), "备份失败", 0).show();
-					}
-					super.onPostExecute(result);
-				}
-				
-			}.execute("backup.xml"); //这里传入的参数就是doInBackgound中的参数，会传入到doInBackground中
-	 
-	ProgressDialog有个方法
-	incrementProgressBy(int num);方法，这个方法能够让进度条自动增加，如果参数为1就是进度条累加1。
-	 
-	可以给ProgressDialog添加一个监听dismiss的监听器。pd.setOnDismisListener(DismisListener listener);让其在取消显示后做什么事
-	```
-
-----
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/JNI_C\350\257\255\350\250\200\345\237\272\347\241\200.md" "b/Android\345\237\272\347\241\200/JNI_C\350\257\255\350\250\200\345\237\272\347\241\200.md"
deleted file mode 100644
index c492bcf2..00000000
--- "a/Android\345\237\272\347\241\200/JNI_C\350\257\255\350\250\200\345\237\272\347\241\200.md"
+++ /dev/null
@@ -1,458 +0,0 @@
-JNI_C语言基础
-===
-
-1.JNI(java native interface) 
-    `Java`本地开发接口，`JNI`是一个协议，这个协议用来沟通`Java`代码和外部的本地代码(`c/c++`).通过这个协议`Java`代码就可以调用外部的`c/c++`代码，外部的`c/c++`代码也可以调用java代码，
-使用JNI技术，其实就是在Java程序中，调用C语言的函数库中提供的函数，来完成一些Java语言无法完成的任务。由于Java语言和C语言结构完全不相同，因此若想让它们二者交互，则需要制定一系列的规范。
-JNI就是这组规范，此时 Java只和JNI交互，而由JNI去和C语言交互。
-JNI技术分为两部分：Java端和C语言端。且以Java端为主导。
-|-  首先，Java程序员在Java端定义一些native方法，并将这些方法以C语言头文件的方式提供给C程序员。
-|-  然后，C程序员使用C语言，来实现Java程序员提供的头文件中定义的函数。
-|-  接着，C程序员将函数打包成一个库文件，并将库文件交给Java程序员。
-|-  最后，Java程序员在Java程序中导入库文件，然后调用native方法。
-在Java程序执行的时候，若在某个类中调用了native方法，则虚拟机会通过JNI来转调用库文件中的C语言代码。提示：C代码最终是在Linux进程中执行的，而不是在虚拟机中。
- 
-2.为什么要用JNI
-|-  首先，Java语言提供的类库无法满足要求(驱动开发 wifi等),且在数学运算,实时渲染的游戏上,音视频处理等方面上与C/C++相比效率稍低。 
-|-  然后，Java语言无法直接操作硬件，C/C++代码不仅能操作硬件而且还能发挥硬件最佳性能。
-|-  接着，使用Java调用本地的C/C++代码所写的库，省去了重复开发的麻烦，并且可以利用很多开源的库提高程序效率。Opencore
-|-  接着，特殊的业务场景，java能反编译但是c不能，因此对于一些不想让别人知道的东西可以用c，加密等
- 
-3.怎么用JNI
-    1.C/C++语言 2.掌握java jni流程 3.NDK (native develop kits ) 
-  
-4.指针和指针变量的关系
-指针就是地址，地址就是指针
-地址就是内存单元的编号
-指针变量是存放地址(指针)的变量
-指针和指针变量是两个不同的概念
-但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样
-
-
-  1\ 未经过初始化的指针变量，不能够直接使用
-  2\ 指针变量的类型 不能够相互转换 
-  3\函数的变量(静态)不能够跨函数访问，失去了函数变量的访问范围(生命周期)，因为方法执行完之后会释放内存，所以方法中的变量就没有了，但是地址值还是能拿到的，因为地址值是内存中真实存在的地址位置 
-  4\指针声明的三种方式
-       int * p; //p 是变量的名字， int * 是一个类型，这个变量存放的是int类型变量的地址。
-       int* p     int * p    int *p
-
-5.*号的三种含义
-     1.乘法 3*5
-     2.定义指针变量 int * p;
-     3.指针运算符，如果p是一个已经定义好的指针变量,则*p表示以p的内容为地址的变量
- 
- 
-6.为什么要使用指针(指针的重要性）
-    直接访问硬件 (opengl 显卡绘图)   
-    快速传递数据(指针表示地址)   
-    返回一个以上的值(返回一个数组或者结构体的指针)    
-    表示复杂的数据结构(结构体)   
-    方便处理字符串   
-    指针有助于理解面向对象
-
-
-7.指针和数组的关系
-     一维数组的数组名是个指针常量，它存放的是一维数组第一个元素的地址
-C中数组的定义比较死板，中括号必须放到名字的后面
-int a[5];
-printf("%#X\n",&a[0]);
-printf("%#X\n",&a);
-
-如果p是一维数组 则p[i] 等价于 *(p+i),都是得到一维数组中的第i个元素。
- 
-在c语言中不会检查角标越界如int a[5]写a[5]不会报错
-
-8.动态分配内存Malloc
-
-采用malloc在椎内存中申请空间
-#include <malloc.h>  //不能省  malloc 是 memory(内存) allocate(分配)的缩写
-#include <stdio.h>
-
-main(){
-     //malloc() 在堆空间中动态的申请一块连续的内存空间(数组)
-     // 参数： 指定申请的内存空间的大小(字节)
-     // 返回值： 所申请空间的首地址(数组的第一个元素的地址),返回值是Void数据类型
-   
-     int* p = (int*) malloc( sizeof(int) );     //因为返回值是一个Void类型，所以要强转
-     *p = 99;
-    
-     //free()释放已经分配的内存块
-     //参数： 指定释放哪块内存空间（地址）
- 
-     free(p);
-    printf("内容是 %d\n", *p);     //上面的free只是释放内存块中的内容，但是打印这个内存块的地址还是能够打印出来的，因为这个内存块的地址是内存上的地址是真实存在的       
-     system("pause"); 
-}
-
-
-
-
-如果动态申请的内存不够用，那么可以继续申请内存
-用realloc
-/*
-  1\创建数组
-  2、赋值
-  3、打印 
-*/
-#include<stdio.h>
-#include<malloc.h>
-
-void printArr(int* arr, int len){
-     int i;
-     for( i = 0 ; i < len; i++){
-            printf("arr[ %d ]= %d\n", i, *(arr+i));
-     }
-
-}
-
-
-main(){
-       printf("请您输入所要创建的数组大小： \n");
-       int len ;
-       scanf("%d", &len);  &是取地址符
-
-       //动态数组创建
-       int* arr = (int*) malloc( sizeof(int) *  len);
-
-       printf("请您为每个元素赋值： \n");
-
-       int i;
-       for(i = 0; i < len; i++){
-             int temp;
-             scanf("%d", &temp);
-
-             *(arr + i) = temp;
-       }
-
-       //打印
-       printf("数组元素的值为： \n");
-       printArr(arr, len);
-
-       //-----------------------------------------
-
-       printf("请输入增加的元素个数： \n");
-       int count;
-       scanf("%d", &count);
-
-       //更改数组大小
-       //realloc()
-       //参数1： 指定所需修改的数组
-       //参数2： 指定修改后的数组的大小
-       //返回值：修改后数组的首地址  （VOID）
-       arr = (int*) realloc(arr, len + count);
-
-       printf("请为新增加的元素赋值： \n");
-
-       int j;
-       for(j = len; j < len + count; j++){
-             int temp;
-             scanf("%d", &temp);
-
-             *(arr + j) = temp;
-       }
-
-       //打印 
-       printf("数组元素的值为： \n");
-       printArr(arr, len + count);
-
-       system("pause");       
-}
-或者有个简单的写法
-main()
-{       
-     int* arr =(int* ) malloc(sizeof(int)*len) ; //动态申请的内存 
-     int i=0;
-     for(;i<len;i++){
-       printf("请输入第%d个数据\n",i); 
-       scanf("%d",&arr[i]);           
-     } 
-      //打印显示这个数组的元素 
-      printArr(arr,len); 
-
-        printf("请输入增加的数组的长度"); 
-        int increase;
-        scanf("%d", &increase); 
-
-        arr = realloc(arr,(len+increase)*sizeof(int));
-        i =len; 
-       for(;i<len+increase ;i++){
-       printf("请输入第%d个数据\n",i); 
-       scanf("%d",&arr[i]);           
-     } 
-
-      //打印显示这个数组的元素 
-       printf("新的数组长度为:%d\n",len+increase); 
-        printArr(arr,len+increase); 
-
-        system("pause"); 
-}
- 
-
-
-
-9.静态内存和动态内存
-静态内存是系统是程序编译执行后系统自动分配,由系统自动释放,静态内存是栈分配的.动态内存是堆分配的.
-C中静态内存会自动释放，但是对于动态内存(堆内存)在c中是没有垃圾回收的，必须要靠程序员手动的去释放，不然就会一直存在
-
-10.C中的基本数据类型
-char, int, float, double, signed, unsigned, long, short and void
-c中char 占用1个字节       java char占用2个字节
-c中long 占用4个字节       java long占用8个字节
-
-int flag = 0,1  表示java中boolean类型
-
-c中用char数组  来表示java中String类型或者指针方式来表示java中String类型
-      char* cc = "heima 15";//char* str ="hello" ;  //<--> char str[] ={'h','e','l','l','o','\0'};  //内部转化为一个字符串的数组,并且在数组的最后一个元素拼装一个\0. 
-      char cc[20] = "heima 15";
-      char cc[20] = {'h','e','i','m','a'};
-      
-
-
-11.c文件的后缀是.c
-示例代码：
-c中的打印语句中要有类似占位符，在后面的参数对占位符的内容进行声明
-#include<stdio.h>
-main() {
-printf("%d\n",sizeof(int));       //sizeof() 得到制定数据类型的长度(占用字节数)参数  接受一个数据类型 
-printf("%d\n",sizeof(char));
-system("pause");//可以执行命令行中的命令如 system("shutdown -s -t 60");如果不加pause，运行窗口会一闪而过，因为会释放内存，把dos关闭了，所以要加上pause
-} 
-
-
-12.C中的输入输出
-%d  -  int
-%ld – long int
-%c  - char
-%f -  float
-%lf – double
-%x – 十六进制输出 int 或者long int 或者short int
-%#x – 以0x开头 十六进制输出 int 或者long int 或者short int
-%o -  八进制输出
-%s – 字符串
- 
-13.   // c语言从键盘输入一个字符串
-      //scanf() 接收键盘输入的数据，参数1： 指定接收的数据的数据类型参数 2： 指定接收的数据存放的位置
-       #include<stdio.h>
-main() {
-     char c[20];
-     scanf("%s", c);
-     printf("%s", c);
-     system("pause");
-}
-
-
-14.取地址符  &(能得到一个对象的地址)
-15.C中两个数的交换
-#include<stdio.h>
-void swap(int* i, int* j) {
-     int temp = *i;
-     *i = *j;
-     *j = temp;
-}
-main() {
-       int i = 3;
-       int j = 5;
-       swap(&i, &j);
-       printf("%d",i);
-       printf("%d",j);
-       system("pause");      
-}
-
-
-16.C中的for循环
-#include <stdio.h>
-
-/**
-打印输出数组的每一个元素
-*/
-void printArr(int* arr, int len){
-     int i;
-     for(i=0;i<len;i++){
-        printf("arr[%d]=%d\n",i,*(arr+i));            
-      }
-}
-
-main()
-{    printf("请输入数组的长度");
-     int  len ;
-     scanf("%d", &len);//要用指针
-     int arr[len];
-     int i=0;
-     for(;i<len;i++){
-       printf("请输入第%d个数据\n",i);
-       scanf("%d",&arr[i]);          
-     }
-      //打印显示这个数组的元素
-      printArr(arr,len);
-      system("pause");
-}
-C中for循环不能像java那样for(int i=0, i<100; i++)C中不允许在for中进行变量的声明，必须要分开，像上面的这个代码这样
-
-17.指针的运算
-    int i = 3;  //天津 解放路 33号 
-    int j = 5;   // 北京 东北旺 9号 
-    int* p = &i;
-    int* q = &j;
-    //p-q; 单纯的指针相加减 是没有任何的意义的.
-    //指针的运算只有在连续的内存空间里面(数组)  才有意义. 
-因为指针的运算必须在数组中才有效，这就是为什么数组中能用     p[i] 等价于 *(p+i)，因为这个p是数组的名字也代表了数组中第一个元素的地址，p+i就是讲指针加几就是得到第几个元素的指针 
-
-18.函数的指针
-/**
-1.定义int (*pf)(int x, int y);
-2.赋值 pf = add;
-3.引用 pf(3,5);
-*/
-#include <stdio.h>
-int add(int x,int y){
-    return x+y;
-}
-main()
-{
-     int (*pf)(int x, int y); //定义一个函数的指针，就是讲函数的名字改了，其它的都和函数的定义一样    
-     pf = add; //将pf指向add
-   printf("result=%d\n",  pf(3,5)); //使用pf
-     
-   system("pause");
-}
-
-内存的四个部分 Stack  Heap CodeSegment DataSegment
-函数是存放到CodeSegment中的，这个函数的地址就是CodeSegment中的这个函数的地址，我们得到函数的地址如果去访问这个地址就相当于调用了这个函数
- 
-19.结构体(类似于java中的类)
-#include <stdio.h>
-struct Student
-{
-     int age;  //4
-     float score; //4
-     long id; //4
-     char sex; //1
-};
-int main(void)
-{
-     struct Student st={80,55.6f,10001,'F'};
-     printf("st.age=%d\n",st.age);
-    
-     printf("结构体的长度为%d\n",sizeof(st));//打印出来的结果是16为什么呢？ 编译器为了方便起见 做了处理，它将所有的变量的长度都统一成最大的长度
-    
-     struct Student* pst = &st;//结构体的指针
-    
-          printf("st.age=%d\n",(*pst).age);//(*pst)就是得到结构体，由于*的优先级比较低，通常要用括号括起来。
-         
-         printf("age=%d\n",pst->age);//这一行是上一行的简单写法，pst->age 在计算机内部会被转换为 (*pst).age pst->age的含义: pst所指向的结构体变量中的age这个成员
-    system("pause");
-
-}
-
-
-结构体的三种写法
-第一种
-struct Student
-{
-  int age;
-  float score;
-  char sex;
-}
-
-第二种
-struct Student2
-{
-int age;
-float score;
-char sex;
-} st2;//相当于java中直接弄了一个对象
-
-第三种 
-struct
-{
-int age;
-float score;
-char sex;
-} st3;
-
-
-
-
-20.Union联合体
-#include <stdio.h> 
-main() { 
-      struct date { int year, month, day; }today; 
-      union { long i; int k; char ii; double d; } mix; 
-
-      printf("date:%d\n",sizeof(struct date)); 
-      printf("mix:%d\n",sizeof(mix)); 
-      mix.i = 33;
-      mix.ii = 'a'; 
-      printf("i=%d\n",mix.i); //结果是96，因为联合体是一个公用的内存空间，在存ii的时候将i的值给覆盖了
-      //110100000101
-  
-      system("pause"); 
-} 
-     联合体是一个公用的内存空间，联合体长度为： 占有字节数最大的元素的长度（字节数）
-21.枚举
-enum WeekDay {
-Monday=8,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
-};//这里一定要加分号
-
-int main(void)
-{
-  enum WeekDay day = Sunday;
-  printf("%d\n",day);//打印出来是14，因为是从8开始往后逐个加1
-  system("pause");
-  return 0;
-}
-默认的情况是从0开始往后递加
-
-
-22.typedef
-定义别名
-声明自定义数据类型，配合各种原有数据类型来达到简化编程的目的的类型定义关键字。 
-typedef int haha;  //定义数据类型的别名. 
-int main(void)
-{
-  haha i = 3;这里haha就相当于int
-  printf("i=%d\n",i); 
-}
-
-每一个指针占四个字节
- 
- 
-23.多级指针
-#include <stdio.h>
-main() { 
-    int i = 88;
-    int* p = &i; 
-    int** q = &p; //指针的指针前面要加两个*
-    int*** r = &q; 
-    printf("i=%d\n",***r);  
-    system("pause"); 
-}
- 
- 
- 
-C语言常见术语：
-库函数：
-|-  为了代码重用，在C语言中提供了一些常用的、用于执行一些标准任务(如输入/出)的函数，这些函数事先被编译，并生成目标代码，然后将生成的目标代码打包成一个库文件，以供再次使用。 库文件中的函数被称为库函数，库文件被称为函数库。
-通过头文件的方式 把函数库里面所有的函数暴露 .h
-|-  在Windows中C语言库函数中的目标代码都是以.obj为后缀的，Linux中是以 .o为后缀。
-提示：单个目标代码是无法直接执行的，目标代码在运行之前需要使用连接程序将目标代码和其他库函数连接在一起后生成可执行的文件。Windows ->.exe .dll 
-Linux -> .so 动态库
-       .a 静态库
-头文件：
-|-  头文件中存放的是对某个库中所定义的函数、宏、类型、全局变量等进行声明，它类似于一份仓库清单。若用户程序中需要使用某个库中的函数，则只需要将该库所对应的头文件include到程序中即可。
-   |-  头文件中定义的是库中所有函数的函数原型。而函数的具体实现则是在库文件中。
-   |-  简单的说：头文件是给编译器用的，库文件是给连接器用的。
-|-  在连接器连接程序时，会依据用户程序中导入的头文件，将对应的库函数导入到程序中。头文件以.h为后缀名。 
-函数库：
-|-  动态库：在编译用户程序时不会将用户程序内使用的库函数连接到用户程序的目标代码中，只有在运行时，且用户程序执行到相关函数时才会调用该函数库里的相应函数，因此动态函数库所产生的可执行文件比较小。 .so 动态库
-|-  静态库：在编译用户程序时会将其内使用的库函数连接到目标代码中，程序运行时不再需要动态库。使用静态库生成可执行文件比较大。
-在Linux中：
-|-  静态库命名一般为：lib+库名+.a 。
-|-  如：libcxy.a 其中lib说明此文件是一个库文件，cxy是库的名称，.a说明是静态的。
-|-  动态库命名一般为：lib+库名+.so 。.so说明是动态的。 
-Windows 下的动态库  .dll 
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck!
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/JNI\345\237\272\347\241\200.md" "b/Android\345\237\272\347\241\200/JNI\345\237\272\347\241\200.md"
deleted file mode 100644
index 2ef664bb..00000000
--- "a/Android\345\237\272\347\241\200/JNI\345\237\272\347\241\200.md"
+++ /dev/null
@@ -1,376 +0,0 @@
-JNI基础
-===
-
-1. 将java中的字符串转换成C中字符串的工具方法
-    ```
-    char*   Jstring2CStr(JNIEnv*   env,   jstring   jstr){
-         char*   rtn   =   NULL;
-         jclass   clsstring   =   (*env)->FindClass(env,"java/lang/String");
-         jstring   strencode   =   (*env)->NewStringUTF(env,"GB2312");
-         jmethodID   mid   =   (*env)->GetMethodID(env,clsstring,   "getBytes",   "(Ljava/lang/String;)[B");
-         jbyteArray   barr=   (jbyteArray)(*env)->CallObjectMethod(env,jstr,mid,strencode); // String .getByte("GB2312");
-         jsize   alen   =   (*env)->GetArrayLength(env,barr);
-         jbyte*   ba   =   (*env)->GetByteArrayElements(env,barr,JNI_FALSE);
-         if(alen   >   0)
-         {
-          rtn   =   (char*)malloc(alen+1);         //"\0"
-          memcpy(rtn,ba,alen);
-          rtn[alen]=0;
-         }
-         (*env)->ReleaseByteArrayElements(env,barr,ba,0);  //
-         return rtn;
-    }
-    ```
-
-2. 程序被运行要经历两个步骤(1.编译 2.链接)    
-    编译就是将源文件编译成二进制代码，而链接则是将二进制代码转换成可执行的文件如.exe等头文件.(函数的声明,函数的清单文件)作用: 给编译器看的.
-    库函数: 头文件里面函数的实现.
-    作用:给连接器看的.
- 
-3. jni开发的常见错误:     
-    错误1: 忘记编写android.mk文件 unknown file: ./jni/Android.mk
-    Android NDK: Your APP_BUILD_SCRIPT points to an unknown file: ./jni/Android.mk 
-    /cygdrive/c/android-ndk-r7b/build/core/add-application.mk:133: Android NDK: Aborting...    。 停止。       
-    错误2:  ndk-build 没有任何反应.
-    忘记配置android.mk脚本     
-    错误3: $ ndk-build jni/Android.mk:4:  遗漏分隔符 。 停止。
-中文的回车或者换行
- 
-    错误4:java.lang.UnsatisfiedLinkError: hello
-忘记加载了c代码的.so库 或者 函数的签名不正确,没有找到与之对应的c代码
- 
-    错误5:07-30 java.lang.UnsatisfiedLinkError: Library Hel1o not found
-没有找到对应的c代码库
- 
-    错误6: *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
-    07-30 11:53:17.898: INFO/DEBUG(31): Build fingerprint:
-    'generic/sdk/generic/:2.2/FRF91/43546:eng/test-keys'
- 
-    c代码里面有严重的逻辑错误,产生内存的泄露.
- 
-    错误7:
-    make: *** [obj/local/armeabi/objs/Hello/Hello.o] Error 1
-    编译的时候 程序出现了问题,c语言的语法有问题
-    c语言代码编译错误的时候 先去解决第一个错误.
- 
-4. Java调用JNI的前提
-    开发所使用的电脑(windows系统, x86的CPU)
-    目标代码: android手机上运行的.( linux系统, arm的CPU)
-    所以我们要模拟手机的系统,手机的处理器         生成手机上可以运行的二进制代码这就要用到交叉编译;
-    根据运行的设备的不同，可以将cpu分为：
-    |-  arm结构 ：主要在移动手持、嵌入式设备上。
-    |-  x86结构 ： 主要在台式机、笔记本上使用。如Intel和AMD的CPU 。
-
-    交叉编译: 在一种操作系统平台或者cpu平台下 编译生成 另外一个平台(cpu)可以运行的二进制代码.(使用NDK中的ndk-build命令)
-
-工具一:  交叉编译的工具链: NDK
-NDK全称：Native Development Kit 。
-|-  NDK是一系列工具的集合，它有很多作用。
-   |-  首先，NDK可以帮助开发者快速开发C(或C++)的动态库。
-   |-  其次，NDK集成了交叉编译器。使用NDK，我们可以将要求高性能的应用逻辑使用C开发，从而提高应用程序的执行效率。
-NDK工具是提供给Linux系统用的(随着版本的升级也可以直接在Windows下使用，但是现在仍不完善有bug)，所以要在windows下使用ndk的工具,必须要提供一个工具(linux环境的模拟器)
-
-工具二:  cygwin(windows下linux系统环境的模拟器, 主要是为了能够运行ndk的工具)
-安装 devel shell
-
-linux 特点:所有的设备 硬件 都是以文件的方式定义的.
-
-工具三: cdt(c/c++ develop tools)  eclipse 的一个插件  用来让c\c++代码 语法高亮显示.
-        adt(android develop tools)
-
-
-步骤四：
-     为了不用每次使用ndk-build命令都要进入到ndk的安装目录，这里要进行Path变量的配置。
-配置cygwin的环境变量: 在cygwin安装目录,etc目录,profile的文件 32行 添加ndk工具所在的目录.
-PATH="/usr/local/bin:/usr/bin:/cygdrive/d/android-ndk-r7b:${PATH}"在这个后面加上:ndk-build的路径(注意：在linux中路径的分隔符不是分号而是冒号)，改成这样
-PATH="/usr/local/bin:/usr/bin:${PATH}:/cygdrive/d/android-ndk-r7b"         //注意这里的路径是在linux系统下的ndk路径而不是windows下的路径
-
-
-5. JNI开发步骤：
-    1.创建一个android工程
-    2.JAVA代码中写声明native 方法 public native String helloFromJNI();
-    3.用javah工具生成头文件
-    4. 创建jni目录,引入头文件,根据头文件实现c代码
-    5.编写Android.mk文件
-    6.Ndk编译生成动态库
-    7.Java代码load 动态库.调用native代码
-
-六.JNI开发之Java中调用C代码步骤
-     1.在java中定义一个要调用的C的方法(本地方法)
-     //1.定义一个native的方法
-       public native String helloFromC();
-     2..在工程中新建一个jni文件夹(然后在这个文件夹中写c代码，在C中实现java里面定义的c方法默认的时候是自己手写c的方法名，但是很麻烦这里要参考七里面提供的方式，用javah编译后，然后拷贝h的头文件到jni文件夹中，在从h文件拷贝方法的名字，然后实现该方法).
-    #include <stdio.h>
-    #include <jni.h>
-//这个方法的名字的写法固定Java_表示这个方法由Java调用,cn_itcast_ndk表示java的包名DemoActivity表示java中调用这个方法的类名helloFromC表示java中调用这个方法的方法名字
-```
-jstring Java_cn_itcast_ndk_DemoActivity_helloFromC (JNIEnv* env , jobject obj){//这两个参数是固定必不可少的
-       //return (*(*env)).NewStringUTF(env,"hello from c!");//调用NewStringUTF这个方法new出来一个java中的String类型的字符串
-       return (*env)->NewStringUTF(env,"hello from c!" );//这个写法和上面这个注释掉的一样，只是更简洁一点
-}
-```
-3.在jni文件夹中编写android.mk文件，在这个文件夹中声明要编译的c文件名以后编译后生成的文件名   
-```
-LOCAL_PATH := $(call my-dir)  //将jni所在的目录返回去到LOCAL_PATH
-#clear_vars 一个函数 初始化编译工具链的所有的变量.
-#特点:清空所有的以LOCAL_开头的变量,但是不会清空LOCAL_PATH的变量
- include $(CLEAR_VARS)  
-#指定编译后的文件的名称 符合linux系统下makefile的语法. 
-LOCAL_MODULE    := Hello
-#指定编译的源文件的名称 ,编译器非常智能
-LOCAL_SRC_FILES := Hello.c
-  #指定编译后的文件的类型. 默认编译成动态库 BUILD_SHARED_LIBRARY 扩展名.so .so代码体积很小  
-#                            静态库 BUILD_STATIC_LIBRARY 扩展名.a  .a代码体积很大
-include $(BUILD_SHARED_LIBRARY)
-```
-4.cmd进入到当前的工程的文件夹中(也可以进入到当前工程的jni目录中)，然后运行ndk-build工具就能将c文件编译成一个可执行的二进制文件. ->.so，注意用ndk-build编译之后一定要刷新，不然eclipse会缓存旧的不加载新的进来
-5.刷新工程，就能看到多出了两个文件夹
-6.在java中将要调用的c代码加载到java虚拟机中，通过静态代码块的方式
-    ```
-    public class DemoActivity extends Activity {
-       //1.定义一个native的方法
-       public native String helloFromC();
- 
-       static{
-             //5.把要调用的c代码 给加载到java虚拟机里面
-            System. loadLibrary("Hello");//注意写的是Hello不要加后缀
-        }
-    }
-    ```
-7.调用c代码
-    ```
-    public void click(View view){
-      //调用c代码
-      Toast.makeText(this, helloFromC(), 1).show();
-      
-    }
-    ```
-
-七、利用jdk的工具javah动态生成c方法名
-    在上面的调用c中的方法的时候，在c中区实现这个方法的时候的方法名字写起来很复杂，而且容易出去，在java在jdk中提供了一个工具javah，我们只要在windows的dos窗口cmd到classes目录下去执行javah 包名.类名就能够由class文件动态的生成一个c的h文件，在这个h文件中有该class文件中的native方法的名字
-     我们只要拷贝这个h文件到自己工程的jni目录中，然后在c文件中引入这个h文件，并拷贝这个h文件中的方法去实现就可以了
-    #include <stdio.h>//这个<>是引入工具的h文件
-    #include "cn_itcast_ndk2_DemoActivity.h" //对于自己工程中的h文件用""来引入或者引入#include <jni.h>也可以
-
-JNIEXPORT jstring JNICALL Java_cn_itcast_ndk2_DemoActivity_hello_1_1_1from_1_1_1c //拷贝h文件中生成的方法名
-  (JNIEnv * env, jobject obj){ 
-      return (*env)->NewStringUTF(env,"hello_from_c 2!" );
-
-}
-     然后就和上面的步骤一样了
- 
- 
-注意上面的这个javah的用法师在jdk1.6中用的，如果在jdk1.7中就不能这样用了
-对于jdk1.7在使用javah的工具的时候就不能够直接进入到classes目录下直接运行命令了，而是要将sdk中的platforms下的android版本中的android.jar这个路径加载到classPath的环境变量中(麻烦)，或者是直接进入到src目录下用javah包名.类名(简单常用)
-
-八、如何在c中向logcat中打印日志
-     如果想像logcat打印日志就要用到谷歌在ndk中提供的一个工具log.h的头文件
-     步骤：
-     1.在c文件的头上面导入文件，加入下面的这四行代码
-          #include <android/log.h> //导入log.h
-      #define LOG_TAG "clog"  //指定打印到logcat的Tag
-      #define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__) //对后面的这个打印日志的方法起一个别名是LOGD
-      #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
-    2.在android.mk中加载文件
-        LOCAL_PATH := $(call my-dir)
-   include $(CLEAR_VARS)
-
-   LOCAL_MODULE    := Hello
-   LOCAL_SRC_FILES := Hello.c
-   LOCAL_LDLIBS += -llog   //新增加这一句，作用是 #把c语言调用的log函数对应的函数库加入到编译的运行时里面 #liblog.so，如果还要加载其他的就在后面继续 -lXXX
-   include $(BUILD_SHARED_LIBRARY)
-
-     3.在c的代码中直接使用LOGD或者LOGI就能向logcat中输入打印信息
-          JNIEXPORT jint JNICALL Java_cn_itcast_ndk3_DataProvider_add
-  (JNIEnv * env, jobject obj, jint x, jint y){
-      LOGI( "x=%d",x);
-      LOGD( "y=%d",y);
-       int result = x+y;
-      LOGD( "result=%d",result);
-       return result;
-}
-
-
-
-
-
-九、如何将java的数据传递给c语言
-     就是java在方法中传值，然后c通过参数得到数据处理后返回和上面的一样
-
-
- 
-十、将c中的字符串数组转成java中的string用到jni.h中的一个方法
-     jstring     (*NewStringUTF)(JNIEnv*, const char*);
-
-
-十一、C中调用java
-c语言回调java的场景.
-1.如果有一个操作已经有方便的java实现,才用c调用java可以避免重复发明一个轮子.
-2.想在c代码里面通知界面更新ui.
- 
-C调用java的 思想类似于java中的反射，我们在c中就是通过反射的c实现来找到java中的这个方法，
-     在getMethodID的第二个参数是一个方法的签名，这里我们可以通过jdk提供的一个工具javap，来到classes目录下，然后用 javap -s 类名.方法名  来得到一个方法的签名，这样就能列出来所有方法的签名
-
-```
-/**
- * env JNIEnv* java虚拟机环境的指针.
- *
- *jobject obj ,哪个对象调用的这个native的方法 , obj就代表的是哪个对象
- */
-JNIEXPORT void JNICALL Java_cn_itcast_ndk4_DataProvider_callmethod1
-  (JNIEnv * env, jobject obj){
-       //思考 java中的反射
-       //1.找到某一个类的字节码
-       //   jclass      (*FindClass)(JNIEnv*, const char*);
-      jclass jclazz = (*env)->FindClass(env,"cn/itcast/ndk4/DataProvider" );
-       if(jclazz==0){
-            LOGI( "LOAD CLAZZ ERROR");
-      } else{
-            LOGI( "LOAD CLAZZ success" );
-      }
-       //2.找到类的字节码里面的方法.
-       // jmethodID   (*GetMethodID)(JNIEnv*, jclass, const char*, const char*);
-
-      jmethodID  methodid = (*env)->GetMethodID(env,jclazz,"helloFromJava", "()V"); //最后一个参数是方法的签名
-       if(methodid==0){
-            LOGI( "LOAD methodid ERROR" );
-      } else{
-            LOGI( "LOAD methodid success" );
-      }
-
-       //3.调用方法
-       //void        (*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...);
-      (*env)->CallVoidMethod(env,obj,methodid);
-}
-```
-
-十二、小知识
-1.Android的API提供了SystemClock类，这个类中有一个方法
-public static void sleep(long ms)，这个方法内部对Thread.sleep进行了封装对异常进行了try catch，平时用Thread.sleep还要自己进行捕捉，所以可以使用SystemColock.sleep()还简单
-2.Java中通过java虚拟机来调用c的代码，首先将c的库加载到虚拟机中，但是其实这个c代码并不是运行在java虚拟机中的，而是运行在虚拟机之外的一个单独的进程中
- 
- 
-十三、自定义一个View控件(用于表示锅炉的压力大小)
-    1.写一个类继承View(View是Android中所有能显示到界面上的东西全的父类)
-    2.重写onDraw()方法，这个方法是该控件被画到桌面上的时候调用的方法。
- 
- 
- 
- 
-十四、C++与C代码的不同
-    C++文件的后缀是cpp
-    C++与C的不同就是C++提供了模板、继承、抽象等
-```
-//将java字符串转成C++字符串的工具方法
-char*   Jstring2CStr(JNIEnv*   env,   jstring   jstr)
-{
-     char*   rtn   =   NULL;
-     jclass   clsstring   =   (env)->FindClass("java/lang/String");
-     jstring   strencode   =   (env)->NewStringUTF("GB2312");
-     jmethodID   mid   =   (env)->GetMethodID(clsstring,   "getBytes",   "(Ljava/lang/String;)[B");
-     jbyteArray   barr=   (jbyteArray)(env)->CallObjectMethod(jstr,mid,strencode); // String .getByte("GB2312");
-     jsize   alen   =   (env)->GetArrayLength(barr);
-     jbyte*   ba   =   (env)->GetByteArrayElements(barr,JNI_FALSE);
-     if(alen   >   0)
-     {
-      rtn   =   (char*)malloc(alen+1);         //"\0"
-      memcpy(rtn,ba,alen);
-      rtn[alen]=0;
-     }
-     (env)->ReleaseByteArrayElements(barr,ba,0);  //
-     return rtn;
-}
-JNIEXPORT jstring JNICALL Java_cn_itcast_cpp_DemoActivity_HelloFromC
-  (JNIEnv * env, jobject obj){
-    //C代码
-    //return (*env)->NewStringUTF(env,"haha from c"); 在C中env代表的是C中结构体的指针的指针
-    //c++代码
-    return env->NewStringUTF("haha from cpp");//在C++中env代表的是C++中结构体的指针
-}
-```
- 
-十五、对于JNI中的中文乱码问题
-    老版本的ndk r7之前 r6 r5 r5 crystal r4(编译的时候 语言集 是iso-8859-1)
-在使用老版本ndk 编译出来的so文件的时候 要手动的进行转码.先用iso8859-1解码，再用utf-8编码，在r7(包括)之后的我们只要将C文件的格式改为UTF-8就可以了
- 
-十六、文件的格式及格式转换
-    格式转换的原理：
-    1.读取一段数据到内存
-    2.分析这一段数据
-    3.修改里面的内容
-    4.写到文件里面
- 
-文件的格式：
-    文件的存储方式是二进制0101这样
-    那么怎么设别文件的类型呢？   
-    1.根据扩展名
-    2.根据文件的头信息(头信息才是一个文件的真正的格式)，有些文件我们修改了扩展名也可以打开，这是因为打开文件的程序区扫描了文件的头信息，并用头信息中的类型来打开了这个文件
- 
-十七、C中读取数据    
-```
-#include<stdio.h>
-main(){
-//用  法: FILE *fopen(char *filename, char *type); //第二个参数是打开的方式 rt就是读文件， rb就是读二进制
-   FILE*    fp = fopen("1.txt","rt");
-//用  法: int fread (void *ptr, int size, int nitems, FILE *stream); 
-                        //ptr要读的数据 放在哪一块内存空间里面.
-                        //size 一次读的数据的长度.
-                        //nitems 读多少次
-                        //stream 从哪个文件里面 读
- 
-  char* buffer = malloc(sizeof(char)*12);
- int len=   fread(buffer,sizeof(char),12,fp);
-printf("读了%d个char\n",len);
-   printf("str=%s\n",buffer);
-   fclose(fp);  //关闭掉流
- 
-  system("pause");     
-}
-```
-十八、C中写文件
-```
-#include<stdio.h>
-main(){
-//用  法: FILE *fopen(char *filename, char *type);
-   FILE*    fp = fopen("1.txt","wt");
-//用  法: int fwrite(void *ptr, int size, int nitems, FILE *stream); 
-                        //ptr要向文件写的是哪一块内存里面的数据
-                        //size 一次写的数据的长度.
-                        //nitems 写多少次
-                        //stream 写到哪个文件里面
-   char* str="hello from c";
-   int len = fwrite(str,sizeof(char),12,fp);
-   printf("写了%d个char\n",len);
-   fclose(fp);  //关闭掉流
- 
-   system("pause");     
-}
-``` 
-十九、C语言文件操作模式
-“rt” 只读打开一个文本文件，只允许读数据 
-“wt” 只写打开或建立一个文本文件，只允许写数据 
-“at” 追加打开一个文本文件，并在文件末尾写数据 
-“rb” 只读打开一个二进制文件，只允许读数据 
-“wb” 只写打开或建立一个二进制文件，只允许写数据 
-“ab” 追加打开一个二进制文件，并在文件末尾写数据 
-“rt+” 读写打开一个文本文件，允许读和写 
-“wt+” 读写打开或建立一个文本文件，允许读写 
-“at+” 读写打开一个文本文件，允许读，或在文件末追加数据 
-“rb+” 读写打开一个二进制文件，允许读和写 
-“wb+” 读写打开或建立一个二进制文件，允许读和写 
-“ab+” 读写打开一个二进制文件，允许读，或在文件末追加数据 
-
-对于文件使用方式有以下几点说明： 
-
- 文件使用方式由r,w,a,t,b，+六个字符拼成，各字符的含义是： 
-
-r(read): 读 
-w(write): 写 
-a(append): 追加 
-t(text): 文本文件，可省略不写 
-b(banary): 二进制文件 
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck!
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/Java+Android\351\235\242\350\257\225\351\242\230\345\244\247\345\205\250.doc" "b/Android\345\237\272\347\241\200/Java+Android\351\235\242\350\257\225\351\242\230\345\244\247\345\205\250.doc"
deleted file mode 100644
index 2d8e9ad3..00000000
Binary files "a/Android\345\237\272\347\241\200/Java+Android\351\235\242\350\257\225\351\242\230\345\244\247\345\205\250.doc" and /dev/null differ
diff --git "a/Android\345\237\272\347\241\200/This tag and its children can be replaced by one TextView and a compound drawable.md" "b/Android\345\237\272\347\241\200/This tag and its children can be replaced by one TextView and a compound drawable.md"
deleted file mode 100644
index eb8b7439..00000000
--- "a/Android\345\237\272\347\241\200/This tag and its children can be replaced by one TextView and a compound drawable.md"	
+++ /dev/null
@@ -1,48 +0,0 @@
-This tag and its children can be replaced by one TextView and a compound drawable
-===
-
-写项目的时候经常会遇到在`TextView`附近显示图片的问题，一般都是嵌套一层布局。
----
-```xml
-<LinearLayout
-	android:layout_width="wrap_content"
-	android:layout_height="wrap_content"
-	android:orientation="vertical" >
-
-	<ImageView
-		android:id="@+id/mediacontroller_battery"
-		android:layout_width="wrap_content"
-		android:layout_height="wrap_content"
-		android:background="@drawable/battery_100"
-		android:contentDescription="@string/iv_des" />
-
-	<TextView
-		android:id="@+id/mediacontroller_battery_level"
-		android:layout_width="wrap_content"
-		android:layout_height="wrap_content"
-		android:layout_gravity="center_horizontal"
-		android:paddingRight="12dp"
-		android:textColor="@android:color/white" />
-</LinearLayout>
-```
-
-这样写的时候会有个`warning`提示，`warning:This tag and its children can be replaced by one TextView and a compound drawable`
-意思就是这样写不合理，可以直接用`TextView`达到这种效果
-```xml
-<TextView
-	android:id="@+id/mediacontroller_battery_level"
-	android:layout_width="wrap_content"
-	android:layout_height="wrap_content"
-	android:drawableTop="@drawable/battery_100"
-	android:layout_gravity="center_horizontal"
-	android:paddingRight="12dp"
-	android:drawablePadding="0dp" // 有些时候会用到
-	android:textColor="@android:color/white" />
-```
-代码的方式： `mBatteryLevel.setCompoundDrawables(left, top, right, bottom);`
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/WebView\346\200\273\347\273\223.md" "b/Android\345\237\272\347\241\200/WebView\346\200\273\347\273\223.md"
deleted file mode 100644
index 0d2beb10..00000000
--- "a/Android\345\237\272\347\241\200/WebView\346\200\273\347\273\223.md"
+++ /dev/null
@@ -1,81 +0,0 @@
-WebView总结
-===
-     
-在`Android`中有`WebView Widget`，它内置了`WebKit`引擎，同时，`WebKit`也是`Mac OS X`的`Safari`网页浏览器的基础。`WebKit`是一个开源的浏览器引擎，`Chrome`浏览器也是基于它的。所以很多表现`WebView`和`Chrome`是一样的。          
-
-很多文章中多会说在使用`WebView`之前，要在`AndroidManifest.xml`中添加 如下权限：           
-`<uses-permission android:name="android.permission.INTERNET"></uses-permission>`        
-否则会出`Web page not available`错误。其实这是不全面的，如果我加载本地的页面是不用该权限的。
-
-- 设置WevView要显示的网页方法有很多：
-    - `mWebView.loadUrl(“http://www.google.com“);` // 网络
-    - `mWebView.loadUrl(“file:///android_asset/XX.html“);` // 本地页面,这里的格式是固定的，文件要放到`assets`目录下
-	- `mWebview.postUrl(String url, byte[] postData); // 加载页面使用`Post`方式，`postData`为参数`
-	    ```java
-		String postData = "password=password&username=username";
-		mWebview.postUrl(url, EncodingUtils.getBytes(postData, "base64"));
-		```
-    - mWebView.loadData(htmlString, "text/html", "utf-8"); // 加载Html数据
-	    ```java
-		String htmlString = "<h1>Title</h1><p>This is HTML text<br /><i>Formatted in italics</i><br />Anothor Line</p>";
-		mWebView.loadData(htmlString, "text/html", "utf-8"); // 加载Html数据
-		```
-		- `loadData()`不能加载图片内容，如果要加载图片内容或者获得更强大的Web支持请使用`loadDataWithBaseURL()`。
-		- 显示乱码
-		    `WebView`一般为了节省资源使用`UTF-8`编码，而`String`类型的数据主要是`Unicode`编码，因此在`loadData()`的时候需要设置相应编码让其将`Unicode`编码转成`UTF-8`但是有些时候设置后还是会出现乱码，这是因为还需要为`WebView`中的
-			`Text`设置编码，
-
-			```java
-			WebView mWebView = (WebView)findViewById(R.id.webview) ;
-			String content = getUnicodeContent() ;
-			mWebView.getSettings().setDefaultTextEncodingName(“UTF -8”) ;
-			mWebView.loadData(content, “text/html”, “UTF-8”) ;
-			```
-
-- 设置WebView基本信息：
-	 - 如果访问的页面中有`Javascript`，则`webview`必须设置支持`Javascript`。
-	    `webview.getSettings().setJavaScriptEnabled(true);  `
-	- 触摸焦点起作用
-	    `requestFocus() // 如果不设置的话，会出现不能弹出软键盘等问题。`
-	- 取消滚动条
-	    `this.setScrollBarStyle(SCROLLBARS_OUTSIDE_OVERLAY);`
-		
-- Back键的处理     
-    如果用`webview`点链接看了很多页以后，如果不做任何处理，点击系统`Back`键，整个浏览器会调用`finish()`而结束自身，如果希望浏览的网页回退而不是退出浏览器，需要在当前`Activity`中处理并消费掉该`Back`事件。
-
-	```java
-	 public boolean onKeyDown(int keyCoder,KeyEvent event){
-		if(webView.canGoBack() && keyCoder == KeyEvent.KEYCODE_BACK){
-			webview.goBack();   //goBack()表示返回webView的上一页面
-			return true;
-		}
-		return false;
-	 }
-	```
-	
-- WebView中Padding没有效果	       
-    `WebView`中使用`Padding`没有效果，我们在`WebView`外层包上一层布局就会有所改进，但是不能完全解决问题，正确的做法是在`WebView`的加载`css`中增加`Padding`
-	
-- WebViewClient
-    如果希望点击链接由自己处理，而不是新开`Android`的系统`browser`中响应该链接。给`WebView`添加一个事件监听对象`WebViewClient`并重写其中的一些方法： `shouldOverrideUrlLoading`对网页中超链接按钮的响应。当按下某个连接时`WebViewClient`会调用这个方法，并传递按下的url。
-	1. 接收到 Http 请求的事件 
-	
-	    `onReceivedHttpAuthRequest(WebView view, HttpAuthHandler handler, String host, String realm) `            
-	2. 打开链接前的事件
-	
-	    `public boolean shouldOverrideUrlLoading(WebView view, String url) { view.loadUrl(url); return true; } `           
-	    这个函数我们可以做很多操作，比如我们读取到某些特殊的URL，于是就可以不打开地址，取消这个操作，进行预先定义的其他操作，这对一个程序是非常必要的。
-	3. 载入页面完成的事件
-	
-	    `public void onPageFinished(WebView view, String url){ } `              
-	    页面载入完成，于是我们可以关闭`loading`条，切换程序动作。
-	4. 载入页面开始的事件
-	
-	    `public void onPageStarted(WebView view, String url, Bitmap favicon)`              
-	    这个事件就是开始载入页面调用的，通常我们可以在这设定一个loading的页面，告诉用户程序在等待网络响应。
- 
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/\345\244\232\347\272\277\347\250\213\346\226\255\347\202\271\344\270\213\350\275\275.md" "b/Android\345\237\272\347\241\200/\345\244\232\347\272\277\347\250\213\346\226\255\347\202\271\344\270\213\350\275\275.md"
deleted file mode 100644
index fcb449a1..00000000
--- "a/Android\345\237\272\347\241\200/\345\244\232\347\272\277\347\250\213\346\226\255\347\202\271\344\270\213\350\275\275.md"
+++ /dev/null
@@ -1,193 +0,0 @@
-多线程断点下载
-===
-
-1. 多线程下载
-	```java
-	public class MultiThreadDownloader {
-
-		private URL url;        // 目标地址
-		private File file;        // 本地文件
-		private long threadLen;    // 每个线程下载多少
-
-		private static final int THREAD_AMOUNT = 3;                // 线程数
-		private static final String DIR_PATH = "F:/Download";    // 下载目录
-
-		public MultiThreadDownloader(String address) throws IOException {    
-			url = new URL(address);                                                            // 记住下载地址
-			file = new File(DIR_PATH, address.substring(address.lastIndexOf("/") + 1));        // 截取地址中的文件名, 创建本地文件
-			// 创建一个临时文件路径
-		}
-
-		public void download() throws IOException {
-			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
-			conn.setConnectTimeout(3000);
-
-			long totalLen = conn.getContentLength();                    // 获取文件总长度
-			threadLen = (totalLen + THREAD_AMOUNT - 1) / THREAD_AMOUNT;    // 计算每个线程要下载的长度
-
-			// 总长度 如果能整除 线程数, 每条线程下载的长度就是 总长度 / 线程数
-			// 总长度 如果不能整除 线程数, 那么每条线程下载长度就是 总长度 / 线程数 + 1
-
-			RandomAccessFile raf = new RandomAccessFile(file, "rw");    // 在本地创建一个和服务端大小相同的文件
-			raf.setLength(totalLen);                                    // 设置文件的大小, 写入了若干个0
-			raf.close();
-
-			// 创建临时文件
-
-			for (int i = 0; i < THREAD_AMOUNT; i++)        // 按照线程数循环
-				new DownloadThread(i).start();            // 开启线程, 每个线程将会下载一部分数据到本地文件中
-		}
-
-		private class DownloadThread extends Thread {
-			private int id;     // 用来标记当前线程是下载任务中的第几个线程
-
-			public DownloadThread(int id) {
-				this.id = id;
-			}
-
-			public void run() {
-				// 从临时文件读取当前线程已完成的进度
-
-				long start = id * threadLen;                    // 起始位置
-				long end = id * threadLen + threadLen - 1;        // 结束位置
-				System.out.println("线程" + id + ": " + start + "-" + end);
-
-				try {
-					HttpURLConnection conn = (HttpURLConnection) url.openConnection();
-					conn.setConnectTimeout(3000);
-					conn.setRequestProperty("Range", "bytes=" + start + "-" + end);    // 设置当前线程下载的范围(start和end都包含)
-
-					InputStream in = conn.getInputStream();                            // 获取连接的输入流, 用来读取服务端数据
-					RandomAccessFile raf = new RandomAccessFile(file, "rw");        // 随机读写文件, 用来向本地文件写出
-					raf.seek(start);                                                // 设置保存数据的位置
-
-					byte[] buffer = new byte[1024 * 100];    // 每次拷贝100KB
-					int len;
-					while ((len = in.read(buffer)) != -1) {
-						raf.write(buffer, 0, len);            // 从服务端读取数据, 写到本地文件
-						// 存储当前下载进度到临时文件
-					}
-					raf.close();
-
-					System.out.println("线程" + id + "下载完毕");
-				} catch (IOException e) {
-					e.printStackTrace();
-				}
-			}
-		}
-
-		public static void main(String[] args) throws IOException {
-			new MultiThreadDownloader("http://192.168.1.240:8080/14.Web/android-sdk_r17-windows.zip").download();
-		}
-	}
-	```
-
-2. 断点下载
-	```java
-	public class BreakpointDownloader {
-		private static final String DIR_PATH = "F:/Download";    // 下载目录
-		private static final int THREAD_AMOUNT = 3;                // 总线程数
-
-		private URL url;            // 目标下载地址
-		private File dataFile;        // 本地文件
-		private File tempFile;        // 用来存储每个线程下载的进度的临时文件
-		private long threadLen;        // 每个线程要下载的长度
-		private long totalFinish;    // 总共完成了多少
-		private long totalLen;        // 服务端文件总长度
-		private long begin;            // 用来记录开始下载时的时间
-
-		public BreakpointDownloader(String address) throws IOException {    
-			url = new URL(address);                                                            // 记住下载地址
-			dataFile = new File(DIR_PATH, address.substring(address.lastIndexOf("/") + 1));    // 截取地址中的文件名, 创建本地文件
-			tempFile = new File(dataFile.getAbsolutePath() + ".temp");                        // 在本地文件所在文件夹中创建临时文件
-		}
-
-		public void download() throws IOException {
-			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
-			conn.setConnectTimeout(3000);
-
-			totalLen = conn.getContentLength();                                    // 获取服务端发送过来的文件长度
-			threadLen = (totalLen + THREAD_AMOUNT - 1) / THREAD_AMOUNT;            // 计算每个线程要下载的长度
-
-			if (!dataFile.exists()) {                                            // 如果本地文件不存在
-				RandomAccessFile raf = new RandomAccessFile(dataFile, "rws");    // 在本地创建文件
-				raf.setLength(totalLen);                                        // 设置文件的大小和服务端相同
-				raf.close();
-			}
-
-			if (!tempFile.exists()) {                                            // 如果临时文件不存在
-				RandomAccessFile raf = new RandomAccessFile(tempFile, "rws");    // 创建临时文件, 用来记录每个线程已下载多少
-				for (int i = 0; i < THREAD_AMOUNT; i++)                            // 按照线程数循环
-					raf.writeLong(0);                                            // 写入每个线程的开始位置(都是从0开始)
-				raf.close();
-			}
-
-			for (int i = 0; i < THREAD_AMOUNT; i++)    // 按照线程数循环
-				new DownloadThread(i).start();        // 开启线程, 每个线程将会下载一部分数据到本地文件中
-
-			begin = System.currentTimeMillis();        // 记录开始时间
-		}
-
-		private class DownloadThread extends Thread {
-			private int id;     // 用来标记当前线程是下载任务中的第几个线程
-
-			public DownloadThread(int id) {
-				this.id = id;
-			}
-
-			public void run() {
-				try {
-					RandomAccessFile tempRaf = new RandomAccessFile(tempFile, "rws");        // 用来记录下载进度的临时文件
-					tempRaf.seek(id * 8);                        // 将指针移动到当前线程的位置(每个线程写1个long值, 占8字节)
-					long threadFinish = tempRaf.readLong();        // 读取当前线程已完成了多少
-					synchronized(BreakpointDownloader.this) {    // 多个下载线程之间同步
-						totalFinish += threadFinish;            // 统计所有线程总共完成了多少
-					}
-
-					long start = id * threadLen + threadFinish;        // 计算当前线程的起始位置
-					long end = id * threadLen + threadLen - 1;        // 计算当前线程的结束位置
-					System.out.println("线程" + id + ": " + start + "-" + end);
-
-					HttpURLConnection conn = (HttpURLConnection) url.openConnection();
-					conn.setConnectTimeout(3000);
-					conn.setRequestProperty("Range", "bytes=" + start + "-" + end);        // 设置当前线程下载的范围
-
-					InputStream in = conn.getInputStream();                                // 获取连接的输入流
-					RandomAccessFile dataRaf = new RandomAccessFile(dataFile, "rws");    // 装载数据的本地文件(可以理解为输出流)
-					dataRaf.seek(start);                                                // 设置当前线程保存数据的位置
-
-					byte[] buffer = new byte[1024 * 100];            // 每次拷贝100KB
-					int len;
-					while ((len = in.read(buffer)) != -1) {
-						dataRaf.write(buffer, 0, len);                // 从服务端读取数据, 写到本地文件
-						threadFinish += len;                        // 每次写入数据之后, 统计当前线程完成了多少
-						tempRaf.seek(id * 8);                        // 将临时文件的指针指向当前线程的位置
-						tempRaf.writeLong(threadFinish);            // 将当前线程完成了多少写入到临时文件
-						synchronized(BreakpointDownloader.this) {    // 多个下载线程之间同步
-							totalFinish += len;                        // 统计所有线程总共完成了多少
-						}
-					}
-					dataRaf.close();
-					tempRaf.close();
-
-					System.out.println("线程" + id + "下载完毕");
-					if (totalFinish == totalLen) {                    // 如果已完成长度等于服务端文件长度(代表下载完成)
-						System.out.println("下载完成, 耗时: " + (System.currentTimeMillis() - begin));
-						tempFile.delete();                            // 删除临时文件
-					}
-				} catch (IOException e) {
-					e.printStackTrace();
-				}
-			}
-		}
-
-		public static void main(String[] args) throws IOException {
-			new BreakpointDownloader("http://192.168.1.240:8080/14.Web/android-sdk_r17-windows.zip").download();
-		}
-	}
-	```
-	
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\345\261\217\345\271\225\351\200\202\351\205\215.md" "b/Android\345\237\272\347\241\200/\345\261\217\345\271\225\351\200\202\351\205\215.md"
deleted file mode 100644
index 89d98f42..00000000
--- "a/Android\345\237\272\347\241\200/\345\261\217\345\271\225\351\200\202\351\205\215.md"
+++ /dev/null
@@ -1,133 +0,0 @@
-屏幕适配
-===
-
-## 基本概念
-
-Px不同设备显示效果相同。这里的“相同”是指像素数不会变，比如指定UI长度是100px，那不管分辨率是多少UI长度都是100px。也正是因为如此才造成了UI在小分辨率设备上被放大而失真，在大分辨率上被缩小。
-
-#### Screen Size（屏幕尺寸）
-一般所说的手机屏幕大小如1.6英寸、1.9英寸、2.2英寸，都是指的对角线的长度，而不是手机面积。我们可以根据勾股定理获取手机的宽和长，当然还有面积。单位为inch
-
-#### Resolution（分辨率）
-指手机屏幕垂直和水平方向上的像素个数。比如分辨率是480*320，则指设备垂直方向有480个像素点，水平方向有320个像素点。单位px * px，指的是一屏显示多少像素点。
-
-#### Dpi（dots per inch屏幕密度）
-单位dpi，指的是每inch上可以显示多少像素点即px。(每英寸中的像素数)如160dpi指手机水平或垂直方向上每英寸距离有160个像素点。假定设备分辨率为320*240，屏幕长2英寸宽1.5英寸，dpi=320/2=240/1.5=160
-
-#### Dip（Device-independent pixel，设备独立像素）
-同dp，可作长度单位，不同设备有不同的显示效果,这个和设备硬件有关，一般我们为了支持WVGA、HVGA和QVGA 推荐使用这个，不依赖像素。dip和具体像素值的对应公式是dip值 =设备密度/160* pixel值，可以看出在dpi（像素密度）为160dpi的设备上1px=1dip
-单位dp/dip，指的是自适应屏幕密度的像素，用于指定控件宽高。就所屏幕密度变大，1dp所对应的px也会变大。
-
-#### Sp（ScaledPixels放大像素）
-主要用于字体显示（best for textsize）。根据 google 的建议，TextView 的字号最好使用 sp 做单位，而且查看TextView的源码可知 Android 默认使用 sp 作为字号单位。
-
-
-我们可以用下面的思路来解释为什么用dip代替px作单位：
-设备最终会以px作为长度单位。
-如果我们直接用px作为单位会造成UI在不同分辨率设备上出现不合适的缩放。因此我们需要一种新的单位，这种单位要最终能够以合适的系数换算成px使UI表现出合适的大小。
-Dip符合这种要求吗？
-由dip和具体像素值的对应公式dip值 =设备密度/160* pixel值 可以知
-pixel值=dip值/(设备密度/160)，其中dip值是我们指定的长度大小，那么pixel值，160也是定植，也就是说UI最终的pixel值只受像素密度dip的影响，这个dip就相当于那个换算系数，这个系数的值是多少有设备商去决定。因此dip符合这种要求。
-
-　以我自己的Haier W910超级战舰(宽高比16:9)为例，上述单位的换算如下：
-　　已知数据：屏幕尺寸4.5， 分辨率1280 * 720， 屏幕密度320
-
-　　（1）16:9的4.5寸屏幕由勾股定理计算其高约为3.9寸，宽约为2.2寸
-
-　　（2）则竖向dpi为1280 / 3.9 ≈ 328， 横向dpi为720 / 2.2 ≈ 327
-
-　　（3）工业上切割液晶板时取整为320
-
-　　那么既然dip是自适应屏幕密度的，与px之间又是如何换算呢：
-
-　　120dpi(ldpi低密度屏)　　   1dp = 0.75px        (由于像素点是物理点，所以用2个像素点来显示3个dp的内容)
-
-　　160dpi(mdpi中密度屏)　　   1dp = 1px
-
-　　213dpi(tvdpi电视密度屏)　　1dp = 1.33px
-
-　　240dpi(hdpi高密度屏)　　   1dp = 1.5px
-
-　　320dpi(xhdpi极高密度屏)　  1dp = 2px
-
-　　由上述分析结果可知，控件使用dp，文字使用sp即可满足自适应的需求。
- 
-注1：分辨率限定符的匹配是向下匹配，如果没有values-land-mdpi-1024x552，比如，分辨率values-land-mdpi-1024x600的屏幕，当rom不把虚拟键计算到屏幕尺寸时，实际显示的屏幕应该是values-land-mdpi-1024x552，无法适配到values-land-mdpi-1024x600，那这样就可能适配到下一级，比如values-land-mdpi-800x480，但是现在的平板已经没有这么低的分辨率了，所以是配到无限定符的values-mdpi里，造成界面显示上的瑕疵。
-
-注2：由于分辨率限定符的匹配是向下匹配，所以如果有非主流mdpi屏幕不能精确适配到上述指定值时，values-mdpi至少可以保证app运行时不至于崩溃，同理values可以保证ldpi屏幕的平板不会因生成view而又取不到相应值而崩溃。
-
-##android为什么引进dip
-    
-The reason for dip to exist is simple enough. Take for instance the T-Mobile G1. It has a pixel resolution of 320x480 pixels. Now image another device, with the same physical screen size, but more pixels, for instance 640x480. This device would have a higher pixel density than the G1.
-
-—If you specify, in your application, a button with a width of 100 pixels, it will look at lot smaller on the 640x480 device than on the 320x480 device. Now, if you specify the width of the button to be 100 dip, the button will appear to have exactly the same size on the two devices.
-
-—The density-independent pixel is equivalent to one physical pixel on a 160 dpi screen, the baseline density assumed by the platform (as described later in this document). At run time, the platform transparently handles any scaling of the dip units needed, based on the actual density of the screen in use. The conversion of dip units to screen pixels is simple: pixels = dips * (density / 160).For example, on 240 dpi screen, 1 dip would equal 1.5 physical pixels.Using dip units to define your application's UI is highly recommended, as a way of ensuring proper display of your UI on different screens.
-
-dip是一种能自适应屏幕密度的像素，这个屏幕密度就是屏幕中一英寸里面含有的像素数，打个比方说，现在有两个4寸的手机，一个分辨率是320*480,它的屏幕密度是1，二另一个是480*800的分辨率,这样他的屏幕密度就是1.5，如果我们在320*480的手机中弄了一个160dp的横线，由于他的屏幕密度是1，所以他里面dp和px是一比一的计算。这样这条横线正好占屏幕的一半，而我们将这个横线的视图发布到480*800的手机上时，虽然也是160dp，但是由于他的屏幕密度是1.5.按照dp与px的计算公式pixel值=dip值/(设备密度/160)，可以得到将160dp要乘以1.5倍，这样得到的px就是240px，而这个手机的分辨率正好是480*800，所以看起来仍然是占屏幕的一半。注意：不论多少dp最后都是要通过转换成px来显示的手机的屏幕上的，至于这个dp的大小在屏幕上到底能占多少位置，就要看这个转换后的px与屏幕的宽度像素的比值了。
-
-另一个例子： 打个比方一个是4寸 480*800 的手机，屏幕密度为1.5.  另一个是7寸的1280*800的平板。屏幕密度也为1.  这样用160dp的横线，在480*800的手机上换算成px是160*1.5 = 240，这样横向正好占屏幕的一半，但是在1280*800的平板上，160dp换算后的px为，160*1 = 160px,而屏幕的宽是1280.这样这条横线显示在1280*800的平板上后，是160/1280 正好是八分之一。
-
-所以引入dp解决的是什么问题呢？同一个屏幕尺寸下，对于不同的分辨率，由于尺寸相同，分辨率不同，所以它的屏幕密度就会不一样，这样在同一尺寸的不同分辨率下的设备上，显示出来会看到所占的比例基本一样。如两个7寸的平板，一个是1280*800，一个是2560*1600，这样用dp后，虽然2560*1600的分辨率比那个要大一倍，但是它尺寸一样啊，所以屏幕的分辨率会是另一个的2倍，这样dp转成px后会乘以2.这样显示到这两个设备上所占的比例会一样
-
-一个是7寸1280*800的板，密度为1，一个是5寸 1024*600的板，密度为1.这样你用160dp的线，在前面是8分之一，在后面是六分之一，你就悲剧了，所以要做屏幕适配了
- 
-## 代码
-
-```java
-DisplayMetrics displayMetrics = new DisplayMetrics();
-getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
-Log.e("@@@", "density:"+displayMetrics.density);    //1
-Log.e("@@@", "densityDpi:"+displayMetrics.densityDpi);   //160
-Log.e("@@@", "widthPixels:"+displayMetrics.widthPixels);   //1024
-Log.e("@@@", "heightPixels:"+displayMetrics.heightPixels); //600
-```	 
-这个displayMetrics.densityDpi是真正的屏幕密度，可以为160dpi(mdpi标准的屏幕密度),240dpi(hdpi),320dpi(xhdpi).
-displayMetrics.density,这个不叫屏幕密度，但是在dp和px转换的时候要使用到，这个是屏幕密度的比例值，是用该设备的屏幕密度除以标准的屏幕密度得到的一个比值，如240dpi/160dpi = 1.5
- 
-## 屏幕适配文件夹命名规则
-
-- 命名不区分大小写；
-- 命名形式：资源名-属性1-属性2-属性3-属性4-属性5.....
-    资源名就是资源类型名，包括:drawable, values, layout, anim, raw, menu, color, animator, xml；
-    属性1-属性2-属性3-属性4-属性5.....就是上述的属性集内的属性，如:-en-port-hdpi；
-    注意：各属性的位置顺序必须遵守优先级从高到低排列！否则编译不过
-
-- 实例说明
-    - 把全部属性都用上的例子(各属性是按优先级先后排列出来的)                     
-        values-mcc310-en-sw320dp-w720dp-h720dp-large-long-port-car-night-ldpi-notouch-keysexposed-nokeys-navexposed-nonav-v7
-    - 上述例子属性的中文说明                     
-values-mcc310(sim卡运营商)-en(语言)-sw320dp(屏幕最小宽度)-w720dp(屏幕最佳宽度)-h720dp(屏幕最佳高度)-large(屏幕尺寸)-long(屏幕长短边模式)-port(当前屏幕横竖屏显示模式)-car(dock模式)-night(白天或夜晚)-ldpi(屏幕最佳dpi)-notouch(触摸屏模类型)-keysexposed(键盘类型)-nokey(硬按键类型)-navexposed(方向键是否可用)-nonav(方向键类型)-v7(android版本)
-
-## 手机常见分辨率
-4:3               
-VGA   640*480 (Video Graphics Array)            
-QVGA  320*240 (Quarter VGA)            
-HVGA  480*320 (Half-size VGA)      
-SVGA  800*600 (Super VGA)            
-
-5:3              
-WVGA  800*480 (Wide VGA)           
-
-16:9             
-FWVGA     854*480 (Full Wide VGA)                   
-HD        1920*1080 High Definition              
-QHD       960*540       
-720p      1280*720  标清         
-1080p     1920*1080 高清               
-
- 
-分辨率对应DPI            
-HVGA    mdpi      
-WVGA    hdpi        
-FWVGA   hdpi        
-QHD     hdpi       
-720P    xhdpi     
-1080P   xxhdpi     
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
- 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\345\272\224\347\224\250\345\256\211\350\243\205.md" "b/Android\345\237\272\347\241\200/\345\272\224\347\224\250\345\256\211\350\243\205.md"
deleted file mode 100644
index e6dc7a22..00000000
--- "a/Android\345\237\272\347\241\200/\345\272\224\347\224\250\345\256\211\350\243\205.md"
+++ /dev/null
@@ -1,51 +0,0 @@
-应用安装
-===
-
-1. 在应用程序中安装程序需要权限   
-   ` <uses-permission android:name="android.permission.INSTALL_PACKAGES" />`
-
-2. 示例代码   
-    安卓中提供了安装程序的功能，我们只要启动安装程序的Activity，并把我们的数据传入即可。
-```java
-//获取到要安装的apk文件的File对象
-File file = new File(Environment.getExternalStorageDirectory(), "test.apk");
-//创建一个意图
-Intent intent = new Intent();
-//设置意图动作
-intent.setAction(Intent.ACTION_VIEW);  //android.intent.action.VIEW
-//设置意图数据和类型
-intent.setDataAndType(Uri.fromFile(file), "application/vnd.android.package-archive");
-//启动安装程序的Activity
-startActivity(intent);
-```
-
-**Tip:**   
-- `Uri.fromFile(File file)`方法能从一个`File`对象得到它的`Uri`  
-- `Intent`有`setData(Uri uri)`和`setType(String type)`方法，但是这里如果我们分开写就会报错，原因是`setData()`方法在执行的时候会自动清空所有在此之前调用的`setType`方法所设置过的type，同样`setType`方法在执行的时候也会自动清空所有在此之前调用`setData`设置的`Data`，所以这里必须使用`setDataAndType`方法而不能分开使用`setData`和`setType`.
-- `Android`中提供了安装应用程序的功能，在`Android`系统源码中`apps/PackageInstaller`中。我们找到这个`PackageInstaller`的清单文件，然后找到`PackageInstallerActivity`来查找该`Activity`的意图：如下
-`android_source/packages/apps/PackageInstaller/AndroidManifest.xml`
-```xml
-    <activity android:name=".PackageInstallerActivity"
-            android:configChanges="orientation|keyboardHidden"
-            android:excludeFromRecents="true">
-        <intent-filter>
-            <action android:name="android.intent.action.VIEW" />
-            <action android:name="android.intent.action.INSTALL_PACKAGE" />
-            <category android:name="android.intent.category.DEFAULT" />
-            <data android:scheme="content" />
-            <data android:scheme="file" />
-            <data android:mimeType="application/vnd.android.package-archive"/>
-        </intent-filter>
-        <intent-filter>
-            <action android:name="android.intent.action.INSTALL_PACKAGE" />
-            <category android:name="android.intent.category.DEFAULT" />
-            <data android:scheme="content" />
-            <data android:scheme="file" />
-        </intent-filter>
-    </activity>
-```
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\345\274\200\345\217\221\344\270\255\345\274\202\345\270\270\347\232\204\345\244\204\347\220\206.md" "b/Android\345\237\272\347\241\200/\345\274\200\345\217\221\344\270\255\345\274\202\345\270\270\347\232\204\345\244\204\347\220\206.md"
deleted file mode 100644
index 57f8ecae..00000000
--- "a/Android\345\237\272\347\241\200/\345\274\200\345\217\221\344\270\255\345\274\202\345\270\270\347\232\204\345\244\204\347\220\206.md"
+++ /dev/null
@@ -1,55 +0,0 @@
-开发中异常的处理
-===
-
-1. 实现未捕捉异常处理器
-```java
-    public class MyExceptionHandler implements UncaughtExceptionHandler {
-        private static final String TAG = "MyExceptionHandler";
-        @Override
-        public void uncaughtException(Thread arg0, Throwable arg1) {
-            Logger.i(TAG, "发生了异常,但是被哥捕获了...");
-            try {
-            Field[] fields = Build.class.getDeclaredFields();//可以通过Build的属性来获取到手机的硬件信息，由于不同手机的硬件信息部一定有，所以要用反射得到
-            StringBuffer sb = new StringBuffer();
-            for(Field field: fields){
-                String info = field.getName()+ ":"+field.get(null)+"\n";
-                sb.append(info);
-            }
-            StringWriter sw = new StringWriter();
-            PrintWriter pw = new PrintWriter(sw);
-            arg1.printStackTrace(pw);//通过这个来得到异常信息
-            String errorlog = sw.toString();
-            
-                File file = new File(Environment.getExternalStorageDirectory(),
-                        "error.log");
-                FileOutputStream fos = new FileOutputStream(file);
-                sb.append(errorlog);
-                fos.write(sb.toString().getBytes());
-                fos.close();
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-            android.os.Process.killProcess(android.os.Process.myPid());//这个是只能杀死自己不能杀死别人，这时候系统发现程序在自己的范围之内死了，系统就会重启程序到出现错误之前的那个Activity。
-        }
-    }
-```
-
-2. 让这个处理器生效
-```java
-    /**
-     * 代表的是当前应用程序的进程.
-     */
-    public class MobliesafeApplication extends Application {
-        public BlackNumberInfo info;
-        
-        @Override
-        public void onCreate() {
-            super.onCreate();
-            Thread.currentThread().setUncaughtExceptionHandler(new MyExceptionHandler());//这样就能够让异常的处理器设置到我们的程序中
-        }
-    }
-```
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\346\225\260\346\215\256\345\255\230\345\202\250.md" "b/Android\345\237\272\347\241\200/\346\225\260\346\215\256\345\255\230\345\202\250.md"
deleted file mode 100644
index e8b548ba..00000000
--- "a/Android\345\237\272\347\241\200/\346\225\260\346\215\256\345\255\230\345\202\250.md"
+++ /dev/null
@@ -1,277 +0,0 @@
-数据存储
-===
-
-## `Android`数据存储的几种形式
-
-    1. `Internal Storage`
-        `Store private data on the device memory.`         
-        通过`mContext.getFilesDir()`来得到`data/data/包名/File`目录
-		
-    2. `External Storage`    
-        `Store public data on the shared external storage.`    
-		
-        ```java
-        TextView tv = (TextView) findViewById(R.id.tv_sdsize);
-		File path = Environment.getExternalStorageDirectory();
-		StatFs stat = new StatFs(path.getPath());
-		long blockSize = stat.getBlockSize();
-		long availableBlocks = stat.getAvailableBlocks();
-		long sizeAvailSize = blockSize * availableBlocks;
-		String str = Formatter.formatFileSize(this, sizeAvailSize);
-		tv.setText(str);
-        ```
-		
-    3. `SharedPreferences`     
-        `Store private primitive data in key-value pairs.`     
-        会在`data/data/包名/shared_prefes`里面去创建相应的`xml`文件，根节点是`Map`，其实内部就是将数据保存到`Map`集合中，然后将该集合中的数据写到`xml`文件中进行保存。
-        ```xml
-        <map>
-            <string name="password">123</string>
-            <boolean name="isLogin" value="false"/>
-        </map>
-        ```
-		
-        ```java
-		//获取系统的一个sharedpreference文件  名字叫sp
-		SharedPreferences sp = context.getSharedPreferences("sp", Context.MODE_WORLD_READABLE+Context.MODE_WORLD_WRITEABLE);
-		//创建一个编辑器 可以编辑 sp
-		Editor editor = sp.edit();
-		editor.putString("name", name);
-		editor.putString("password", password);
-		editor.putBoolean("boolean", false);
-		editor.putInt("int", 8888);
-		editor.putFloat("float",3.14159f);
-		//注意:调用 commit 提交 数据到文件.
-		editor.commit();
-		//editor.clear();
-        ```
-		
-    4. `SQLiteDatabase`    
-        `Store structured data in a private database.`     
-		`Android`平台中嵌入了一个关系型数据库`SQLite`，和其他数据库不同的是`SQLite`存储数据时不区分类型，例如一个字段声明为`Integer`类型，我们也可以将一个字符串存入，
-		一个字段声明为布尔型，我们也可以存入浮点数。除非是主键被定义为`Integer`，这时只能存储64位整数创建数据库的表时可以不指定数据类型，例如：        
-		```java
-        CREATE TABLE person(id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(20))  
-        CREATE TABLE person(id INTEGER PRIMARY KEY AUTOINCREMENT, name)
-		```
-		
-        `SQLite`支持大部分标准`SQL`语句，增删改查语句都是通用的，分页查询语句和`MySQL`相同     
-		```java
-        SELECT * FROM person LIMIT 20 OFFSET 10       
-        SELECT * FROM person LIMIT 10,20    
-        SELECT * FROM reading_history ORDER BY _id DESC LIMIT 3, 4
-        DELETE FROM test WHERE _id IN (SELECT _id FROM test ORDER BY _id DESC LIMIT 3, 20)
-		```
-		
-		`SQLite`数据库的使用
-		
-		- 继承`SQLiteOpenHelper`
-		    ```java
-			public class NoteSQLiteOpenHelper extends SQLiteOpenHelper {
-								
-				/**
-				 * name 数据库的名称 cursorfactory 游标工厂 一般设置null 默认游标工厂 version 数据库的版本
-				 * 版本号从1开始的
-				 * 
-				 * @param context
-				 */
-				public NoteSQLiteOpenHelper(Context context) {
-					super(context, "note.db", null, 1);
-				}
-
-				/**
-				 * oncreate 方法 会在数据库第一创建的时候的是被调用 适合做数据库表结构的初始化
-				 */
-				@Override
-				public void onCreate(SQLiteDatabase db) {
-					db.execSQL("create table account (id integer primary key autoincrement , name  varchar(20), money varchar(20) )");
-				}
-				
-				@Override
-				public void onUpgrade(SQLiteDatabase db, int arg1, int arg2) {
-					db.execSQL("DROP TABLE IF EXISTS " + account);
-					this.onCreate(db);
-				}
-			}
-			```
-			
-		- 获取
-			```java
-			public class NoteDao {
-				private NoteSQLiteOpenHelper helper;
-
-				public NoteDao(Context context) {
-					helper = new NoteSQLiteOpenHelper(context);
-				}
-
-				/**
-				 * 添加一条账目信息 到数据库
-				 * 
-				 * @param name
-				 *            花销的名称
-				 * @param money
-				 *            金额
-				 */
-				public void add(String name, float money) {
-					SQLiteDatabase db = helper.getWritableDatabase();
-					db.execSQL("insert into account (name,money) values (?,?)",
-							new Object[] { name, money });
-					// 记住 关闭.
-					db.close();
-				}
-
-				public void delete(int id) {
-					SQLiteDatabase db = helper.getWritableDatabase();
-					db.execSQL("delete from account where id=?", new Object[] { id });
-					db.close();
-				}
-
-				public void update(int id, float newmoney) {
-					SQLiteDatabase db = helper.getWritableDatabase();
-					db.execSQL("update account set money =? where id=?", new Object[] {
-							newmoney, id });
-					db.close();
-				}
-
-				/**
-				 * 返回数据库所有的条目
-				 * 
-				 * @return
-				 */
-				public List<NoteBean> findAll() {
-					// 得到可读的数据库
-					SQLiteDatabase db = helper.getReadableDatabase();
-					List<NoteBean> noteBeans = new ArrayList<NoteBean>();
-					// 获取到数据库查询的结果游标
-					Cursor cursor = db.rawQuery("select id,money,name from account ", null);
-					while (cursor.moveToNext()) {
-						int id = cursor.getInt(cursor.getColumnIndex("id"));
-						String name = cursor.getString(cursor.getColumnIndex("name"));
-						float money = cursor.getFloat(cursor.getColumnIndex("money"));
-						NoteBean bean = new NoteBean(id, money, name);
-						noteBeans.add(bean);
-						bean = null;
-					}
-
-					db.close();
-					return noteBeans;
-				}
-
-				/**
-				 * 模拟一个转账的操作. 使用数据库的事务
-				 * 
-				 * @throws Exception
-				 */
-				public void testTransaction() throws Exception {
-					// 得到可写的数据库
-					SQLiteDatabase db = helper.getWritableDatabase();
-					db.beginTransaction(); // 开始事务
-					try {
-						db.execSQL("update account set money = money - 5 where id=? ",
-								new String[] { "2" });
-						db.execSQL("update account set money = money + 5 where id=? ",
-								new String[] { "3" });
-						db.setTransactionSuccessful();
-					} catch (Exception e) {
-						// TODO: handle exception
-					} finally {
-						db.endTransaction();//关闭事务.
-						db.close();
-					}
-				}
-			}
-			```
-			
-			```java
-			public class NoteDao2 {
-				private NoteSQLiteOpenHelper helper;
-
-				public NoteDao2(Context context) {
-					helper = new NoteSQLiteOpenHelper(context);
-				}
-
-				/**
-				 * 添加一条账目信息 到数据库
-				 * 
-				 * @param name
-				 *            花销的名称
-				 * @param money
-				 *            金额
-				 * 
-				 * @return true 插入成功 false 失败
-				 */
-				public boolean add(String name, float money) {
-					SQLiteDatabase db = helper.getWritableDatabase();
-					ContentValues values = new ContentValues();
-					values.put("name", name);
-					values.put("money", money);
-					long rawid = db.insert("account", null, values);
-					db.close();
-					if (rawid > 0) {
-						return true;
-					} else {
-						return false;
-					}
-				}
-
-				public boolean delete(int id) {
-					SQLiteDatabase db = helper.getWritableDatabase();
-					int result = db.delete("account", "id=?", new String[] { id + "" });
-					db.close();
-					if (result > 0) {
-						return true;
-					} else {
-						return false;
-					}
-				}
-
-				public boolean update(int id, float newmoney) {
-					SQLiteDatabase db = helper.getWritableDatabase();
-					ContentValues values = new ContentValues();
-					values.put("id", id);
-					values.put("money", newmoney);
-					int result = db.update("account", values, "id=?", new String[] { id
-							+ "" });
-					db.close();
-					if (result > 0) {
-						return true;
-					} else {
-						return false;
-					}
-				}
-
-				/**
-				 * 返回数据库所有的条目
-				 * 
-				 * @return
-				 */
-				public List<NoteBean> findAll() {
-					// 得到可读的数据库
-					SQLiteDatabase db = helper.getReadableDatabase();
-					List<NoteBean> noteBeans = new ArrayList<NoteBean>();
-					Cursor cursor = db.query("account", new String[] { "id", "name",
-							"money" }, null, null, null, null, null);
-					while (cursor.moveToNext()) {
-						int id = cursor.getInt(cursor.getColumnIndex("id"));
-						String name = cursor.getString(cursor.getColumnIndex("name"));
-						float money = cursor.getFloat(cursor.getColumnIndex("money"));
-						NoteBean bean = new NoteBean(id, money, name);
-						noteBeans.add(bean);
-						bean = null;
-					}
-					db.close();
-					return noteBeans;
-				}
-			}
-			```
-    5. `Network`
-        `Store data on the web with your own network server.`
-
-## 清除缓存&清除数据    
-    清除数据会清除`/data/data/`包名中的所有文件     
-    清楚缓存会清楚`getCacheDir()`目录下的内容，也就是`/data/data/<当前应用程序包名>/cache/`
-	
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\350\265\204\346\272\220\346\226\207\344\273\266\346\213\267\350\264\235\347\232\204\344\270\211\347\247\215\346\226\271\345\274\217.md" "b/Android\345\237\272\347\241\200/\350\265\204\346\272\220\346\226\207\344\273\266\346\213\267\350\264\235\347\232\204\344\270\211\347\247\215\346\226\271\345\274\217.md"
deleted file mode 100644
index 2d8db144..00000000
--- "a/Android\345\237\272\347\241\200/\350\265\204\346\272\220\346\226\207\344\273\266\346\213\267\350\264\235\347\232\204\344\270\211\347\247\215\346\226\271\345\274\217.md"
+++ /dev/null
@@ -1,26 +0,0 @@
-资源文件拷贝的三种方式
-=====
-
-- 类加载器(类路径)  
-
-    - 用`Classloader.getResourceAsStream()`来读取类路径中的资源，然后用`FileOutputStream`写入到自己的应用中(*sdk开发的时候经常用这种方式*)。
-    - 这种方式**必须**要将数据库`address.db`放到**src**目录下，这样编译后就会直接将`address.db`生成到`bin/classes`目录中，会在类路径下，所以可以使用`Classloader`进行加载.
-    
-```java
-    InputStream is = getClassLoader().getResourceAsStream("address.db");
-    File file = new File(/data/data/包名/files/address.db);
-    FileOutputStream fos = new FileOutputStream(file);
-```
-
-- Raw目录   
-
-    将资源文件放到`res-raw`下, 然后用`getResources.openRawResource(R.raw.addresss);`(要求资源最好不超过1M,因为系统会编译`res`目录)
-
-- Assets目录   
-
-    将资源文件放到`Assets`目录中。然后用`mContext.getAssets().open("address.db");`来读取该资源(`Assets`目录中的文件不会被编译，会原封不动的打包到apk中，所以一般用来存放比较大的资源文件)
-
-----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/\351\235\242\350\257\225\347\237\245\350\257\206\347\202\271\345\207\206\345\244\207.txt" "b/Android\345\237\272\347\241\200/\351\235\242\350\257\225\347\237\245\350\257\206\347\202\271\345\207\206\345\244\207.txt"
deleted file mode 100644
index 1ebf7ecb..00000000
--- "a/Android\345\237\272\347\241\200/\351\235\242\350\257\225\347\237\245\350\257\206\347\202\271\345\207\206\345\244\207.txt"
+++ /dev/null
@@ -1,1508 +0,0 @@
-
-							����׼��
-
-һ������׼��
-1�����˼���
-	(1)�Զ���ؼ���UI��ơ����ö�����Ч
-		1)�Զ���ؼ�
-			��ΪʲôҪ�Զ���ؼ���
-				Android�����ṩ�˺ܶ�ؼ���������Щ�ؼ������������������е�Ҫ�������û���Ҫ��Խ��Խ�ߣ����Ҫ����������������
-					���˹���Ҫ��ȫ�⣬��Ҫ���û��Ƚ��űȽ����Ի������飬���ʱ�����Ҫ�����Զ���ؼ�������û����顣
-					�����û������dz��ñȽϻ��һ�����������վ������������˵����û����顣
-				Android�еĿؼ����Ǽ̳���View�࣬ͨ����дonDraw������������������Ŀؼ���
-			�����ʵ���Զ���ؼ���
-				ʵ���Զ���ؼ������ַ�ʽ��
-					��һ�Ǽ̳����пؼ���ͨ����д��ط�����ʵ�����ǵ�����
-					�ڶ��Ǽ̳�View�����ViewGroup��������������Ҫ�Ŀؼ�
-					ע��һ��������ͨ���̳����еĿؼ���ʵ���Զ���ؼ���һ�㣬�����г��ü̳����пؼ���ʵ���Զ���ؼ���
-			��ListView:
-				a��ListView��������ʲô��
-					��ʾ����
-				b��ListView�����?
-					����Ҫ��ListView����һ��������Adapter����Ҫ��ʾ�����ݽ���������Adapterȥ������
-					����ListView��getView����ÿ������һ����ʾһ����Ŀ����������һ���ɵ���Ŀ���Ƴ�����Ϊ���Ż�ListView��
-						������getView()���������þ���ĿconvertView
-					����ListView��getView������ÿִ��һ��findViewById����ʱ�����������Ӧ���ֵ���״�ṹ���ٱ�������״�ṹ�ҵ�ָ��id��
-						���ò��ֵ���״�ṹ�ܸ���ʱ��ÿ�ζ�����id��Ƚ��鷳������Ϊ���Ż����ǿ����ṩһ��ViewHolder�࣬
-						������¼�����е����пؼ������������еĿؼ�idֻ�����һ�Σ�����ʱ��ֱ����ViewHolder������ȡ
-					�����ListView��ʾ������ʱ������Ҫ���з������ػ��ҳ��ʾ����
-		3)��������
-			�ٶ����ķ��ࣺ	
-				��׿�еĶ�����Ϊ���֣�һ����֡����(Frame)��һ���ǽ��䶯��(Tweened)
-					���䶯���ַ�Ϊ���ֶ������ͣ�Alpha��Scale��Translate��Rotate
-	(2)�������ݴ��䣬��Ϥ���̡߳�Socket�����̡���ϤTCP��UDP��HTTP��Э��
-		1)�����̸�����
-			������ģ�ͣ�
-				****OSIģ��
-					Ӧ�ò�
-					��ʾ��
-					�Ự��
-					�����
-					�����
-					�������Ӳ�
-					������
-				****TCP/IPģ��
-					Ӧ�ò�
-					�����
-					���ʲ�
-					�����������
-			������ͨѶҪ��
-				IP��ַ
-				�˿ں�
-				������
-			������ͨѶǰ�᣺
-				**�ҵ��Է�IP
-				**����Ҫ���͵�ָ���˿ڡ�Ϊ�˱�ʾ��ͬ��Ӧ�ó������Ը���Щ����Ӧ�ó��������ֽ��б�ʾ�����ʾ�ͽж˿�
-				**����ͨ�Ź�����������Ϊͨ��Э�飬������֯������ͨ��Э��TCP/IP
-		1)Android����Ӧ�õĸ�����
-			Android��ȫ֧��JDK������TCP��UDP����ͨ��API������ʹ��Socket��ServerSocket����������TCP/IPЭ�������ͨ��;
-			Ҳ����ʹ��DatagramSocket/Datagrampacket����������UDPЭ�������ͨ�š�
-			ͬʱAndroid��֧��JDK�ṩ��URL��URLConnection������ͨ�ŵ�API��
-		2)TCP��UDP������
-			��UDPЭ�飺
-				����������
-				ÿ�����ݱ��Ĵ�С��������64k��
-				��Ϊ�����������ӣ������Dz��ɿ�Э��
-				����Ҫ�������ӣ��ٶȿ�
-			��TCPЭ�飺
-				���뽨�����ӣ��γɴ������ݵ�ͨ��
-				�������пɽ��д�����������
-				ͨ����������������ӣ��ǿɿ�Э��
-				���뽨�����ӣ�Ч�ʻ��Ե�
-					ע���������֣�
-					��һ�Σ������㣺��ô��
-					�ڶ��Σ���ش��ڡ�
-					�����Σ��ҷ�����Ŷ����֪�����ڡ�
-		3)Socket��
-			**Socket����Ϊ��������ṩ��һ�ֻ���
-			**ͨ�ŵ����˶���Socket
-			**����ͨ����ʵ����Socket���ͨ��
-			**����������Socket��ͨ��IO����
-			**��Socket��Ҫ���Ǽ�ס���̣�������ĵ�����
-		4)UDP(User Datagram Protocol)���û�����Э��
-			��UDP������
-				��ҪDatagramSocket��DatagramPacket������ʵ��UDPЭ�鴫������
-				UDPЭ����һ�����������ӵ�Э�顣���������ӵ�Э��ָ������ʽͨ��ǰ������Է��Ƚ������ӣ����ܶԷ�����״̬��ֱ�ӷ������ݡ�
-			��UDPЭ�鿪�����裺
-				**���Ͷˣ�
-					����DatagramSocket����
-					�ṩ���ݣ��������ݷ�װ���ֽ������У�
-					����DatagramPacket���ݰ����������ݷ�װ�����У�ͬʱָ�����ն�IP�ͽ��ն˿�
-					ͨ��Socket��������send���������ݰ����ͳ�ȥ��
-					�ر�DatagramSocket��DatagramPacket����
-				**���նˣ�
-					����DatagramSocket���񣬲�����һ���˿ڣ�
-					����һ���ֽ������һ�����ݰ���ͬʱ�������װ�����ݰ���
-					ͨ��DatagramPacket��receive�����������յ����ݴ��붨��õ����ݰ���
-					ͨ��DatagramPacke�رյķ�������ȡ�������ݰ��е���Ϣ��
-					�ر�DatagramSocket��DatagramPacket����
-			��UDP���Demo(��������)��
-				****���Ͷˣ�
-					class UDPSend
-					{
-						public static void main(String[] args) throws Exception
-						{
-							DatagramSocket ds = new DatagramSocket();
-							byte[] buf = "����UDP���Ͷ�".getBytes();
-							DatagramPacket dp = new DatagramPacket(
-								buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);
-							ds.send(dp);
-							ds.close();
-						}
-					}
-					****���ն�
-					class UDPRece
-					{
-						public static void main(String[] args) throws Exception
-						{
-							DatagramSocket ds = new DatagramSocket(10000);
-							byte[] buf = new byte[1024];
-							DatagramPacket dp = new DatagramPacket(buf,buf.length);
-							ds.receive(dp);//�����Ͷ˷��͵����ݰ����յ����ն˵����ݰ���
-							String ip = dp.getAddress().getHosyAddress();//��ȡ���Ͷ˵�ip
-							String data = new String(dp.getData(),0,dp.getLength());//��ȡ����
-							int port = dp.getPort();//��ȡ���Ͷ˵Ķ˿ں�
-							sop(ip+":"+data+":"+port);
-							ds.close();
-						}
-					}
-		ע��Э��ĸ�������ã�
-			ʲô��Э�飿
-				����ͨ�ŵ�һ�ֹ���
-			Э������ã�
-				��֤ͨ������ʵ������ͨ��
-		5)TCP/IPЭ�飺Socket��ServerSocket
-			�ٻ���TCPЭ�������ͨ�Ÿ�����
-				TCP/IPͨ��Э����һ�ֱ��뽨�����ӵĿɿ�������ͨ��Э�顣����ͨ�����˸�����һ��Socket,�Ӷ���ͨ�ŵ�����֮���γ�����������·��
-				����������·һ�����������˵ij���Ϳ��Խ���ͨ�š�
-			��TCP/IPЭ�鿪�����裺
-				**�ͻ��ˣ�
-					����Socket���񣬲�ָ��Ҫ���ӵ������Ͷ˿ڣ�
-					��ȡSocket���е������OutputStream��������д�����У�ͨ�����緢�͸�����ˣ�
-					��ȡSocket���е������InputStream����ȡ����˵ķ�����Ϣ��
-					�ر���Դ��
-				**����ˣ�
-					����ServerSocket���񣬲�����һ���˿ڣ�
-					ͨ��ServerSocket�����accept��������ȡSocket�������
-					ʹ�ÿͻ��˶���Ķ�ȡ����ȡ�ͻ��˷��͹��������ݣ�
-					ͨ���ͻ��˶����д����������Ϣ���ͻ��ˣ�
-					�ر���Դ
-			��TCP/IPЭ���һ��Demo(����Ҫ���գ�)��
-				�ͻ��ˣ�
-					class TCPClient
-					{
-						public static void main(String[] args)
-						{
-							Socket s = new Socket("192.168.1.253",10000);
-							OutputStream os = s.getOutputStream();
-							out.write("����TCP���͵�����".getBytes());
-							s.close();
-						}
-					}
-					����ˣ�
-					class TCPServer
-					{
-						public static void main(String[] args)
-						{
-							ServerSocket ss = new ServerSocket(10000);
-							Socket s = ss.accept();
-
-							String ip = s.getInetAddress().getHostAddress();
-							sop(ip);
-
-							InputStream is = s.getInputStream();
-							byte[] buf = new byte[1024];
-							int len = is.read(buf);
-							sop(new String(buf,0,len));
-							s.close();
-							ss.close();
-						}
-					}
-		6)HTTPЭ�飺
-			a��HTTP��Hyper Text Transfer Protocol����д
-			b������W3C�ƶ���ά���ġ�Ŀǰ�汾Ϊ1.0��1.1
-			c���ǿ���web�Ļ�ʯ���dz�����Ҫ
-			d��1.0�汾������״̬��Э�飬��һ������ֻ��Ӧһ��������Ӧ���˾͹رմ˴�����
-						Ҫ���ٷ��������½������ӡ������Ӷ��DZȽϺ���Դ�ġ�
-			   1.1�汾������״̬��Э�顣��������һ���������ӻ����Ϸ����������͵õ���ε���Ӧ��
-						�������ϴ�����ʱ�����ʱ�����������Զ��ϵ����ӣ�����dz�ʱ���ơ�
-			��HTTPЭ�����ɣ�
-				���󲿷֣�
-					������
-						GET / HTTP/1.1  ����������ʽGET �������Դ·����/ Э��汾�ţ�HTTP/1.1
-								����ʽ�����õ���GET��POST
-									GET��ʽ��Ĭ�Ϸ�ʽ��ֱ���������ַ��
-										�������ݳ������������С�url?username=abc&password=123
-										�ص㣺����ȫ���г������ƣ�<1k
-									POST��ʽ������ͨ������form method="post"����
-										�������ݻ�����������С�
-										�ص㣺��ȫ��û�г�������
-					������Ϣͷ��
-					�������ģ���һ������֮���ȫ��������������
-				��Ӧ���֣�
-					��Ӧ�У�
-						HTTP/1.1 200 OK    ������Э��汾��:HTTP/1.1 ��Ӧ��:200 ����:OK 
-							��Ӧ�룺(ʵ���õ���30������,��������W3C������)
-							����������Ӧ�������
-							������Ӧ�룺
-								200��һ������
-								302/307:�������Դ·�������
-								304����Դû�б��޸Ĺ�
-								404����Դ������,�Ҳ�����Դ
-								500�������������д�	
-					��Ӧ��Ϣͷ��
-					��Ӧ���ģ�
-						��һ������֮���ȫ��������Ӧ���ģ��������ʾ�ľ��������е�����
-		7)����ͨ���м�����̣߳�
-			��TCP/IPЭ�飺
-				ʵ��Ӧ���У��������Ҫ���ϵĶ�ȡ�ͻ������ݺ�д�����ݵ��ͻ���;���ͻ���Ҳ��Ҫ���ϵĶ�ȡ��������ݺ�д�����ݵ�����ˡ�
-				��ʹ�ô�ͳ��BufferedReader��readLine()������ȡ����ʱ�����ڸ÷���������ʽ�������ʵ��÷����ɹ�����֮ǰ���̱߳�������
-				�����޷�����ִ�С����ڴˣ�������Ӧ��Ϊÿ��Socket��������һ���̣߳�ÿ���̸߳�����һ���ͻ��˽���ͨ�š�
-				�ͻ���Ӧ�ð��������̣߳�һ���������������桢��Ӧ�û����������û����������д�뵽Socket��Ӧ���������
-				��һ�������ȡSocket��Ӧ�������дӷ������˷��͹��������ݣ���������Щ����������������ʾ��
-					ʹ��NIOʵ�ַ�����Socketͨ��(JDK 1.4�Ժ�ʼ)��
-						ʹ��NIO API�����÷�������ʹ��һ���������޸��߳���ͬʱ�������ӵ�����˵����пͻ��ˣ������������
-					ʹ��AIO(Asynchronous IO)ʵ�ַ�����ͨ��(JDK 1.7��ʼ):
-						ͨ��֧���첽Channel��ʵ��
-			�ڶ��߳�Ӧ�ã�
-				a�����̵߳����ã����Ч��
-				b�����̵߳�Ӧ�ã�
-					���߳����أ�
-						����URL����
-						��ȡָ��URL������ָ�����Դ�Ĵ�С(getConnectionLength())
-						�ڱ��ش����ϴ���һ����������Դ��С��ͬ�Ŀ��ļ���RandomAccessFile.setLength()
-						����ÿ���߳�Ӧ������������Դ���ĸ�����(���ĸ��ֽڿ�ʼ���ĸ��ֽڽ���)
-						���δ������������߳�������������Դ��ָ������
-							//ִ�����´�����������ͷ��ȷ��ָ���߳����صIJ���;��������ø�ͷ����ÿ���̶߳���ͷ���ص�ĩβ
-							HttpURLConnection.setRequestProperty("Range","bytes="+start+"-"+end);		
-					���̶߳ϵ��������أ�
-						��ʼ����ʱ���ж��Ƿ����µ���������
-							����ǣ���ͷ��ʼ����
-							������ǣ��ҵ��ϴ�������ɶ��٣���������
-						���ع����м�¼ÿ���̵߳����ؽ��ȣ�ͬʱ���ض��پ�д���ٵ����أ�����ÿ�����ļ���д������֮�������ݿ��и������ؽ���
-						�������֮��ɾ�����ݿ������ؼ�¼
-		8)����ͨ���е�URL��̣�
-			��URL������
-				URL(Uniform Resource Locator)�������ͳһ��Դ��λ������ָ��������Դ��ָ�롣������Դ�����Ǽ򵥵��ļ�����Ŀ¼��
-					Ҳ�����Ǹ��ӵĶ�������ã���������ݿ����������IJ�ѯ��
-			��URL��ɣ�
-				��Э�������������˿ں���Դ·����ɡ���Http://localhost:8080/BookShop/index.jsp
-			��URL��Ӧ�ã�
-				ʹ��URL����������Դ��
-				ʹ��URLConnection�ύ����
-					ͨ��URL.openConnection()����URLConnection����
-					����URLConnection����IJ�������ͨ��������
-					����GET����POST����
-				ʹ��HttpURLConnection����������Դ��
-	(3)Handler��Ϣ���ݻ��ƺ�Android�µ���Ϣ���ͻ��ƣ�
-		1)Handler��Ϣ���ݻ���:
-			��Handler������
-				Handler�ǽ���ˢ�»���
-				Handler���������AndroidӦ�ö��̼߳�ͨ�����⣬���̺߳����߳�֮��ͨ������
-				Androidϵͳ������Activity���������̷߳��ʸ�Activity����Ľ����������͵������������߳��޷���̬�ı�ý������������ֵ��
-					�����̴߳���View,���޷���ȡ����;���߳������ݣ����޷��޸�View��Handler��Ϣ���ݻ��ƾͿ��Խ���������⡣
-			��Handler�����ã�
-				a��Handler����һ���߳��У�Handler�����þ���ʵ���첽������
-				b��Handler���ڲ�ͬ�߳��У�Handler�����þ���ʵ���첽������ʵ���̼߳�ͨ�š�
-			��Handler��Looper�Ĺ�ϵ��
-				a��Handler��Ҫ���������ͺʹ�����Ϣ�����Ƿ�������Ϣ����Ϣ����ô���ݵ��أ�
-						�����Looper�������ˣ�ÿ��Handler�ڲ������װһ��Looper��������ڴ���Handler��ʱ��ָ��Looper����
-							ϵͳ�ͻ�Ĭ�Ͻ���ǰ�̵߳�Looper�󶨵�Handler�ϣ�
-						Looper������ά����һ����Ϣ���У�Hander���͵���Ϣ����洢�������Ϣ�����У�
-							Looper���ϵı��������Ϣ���У�ȡ����Ϣ������handleMessage����������
-							Looper�����ĸ��̣߳�hadleMessage�����ͻ����Ǹ��߳���ִ�С�
-				 b��Looper��������ã�
-					Looper��������̵߳���Ϣ���к���Ϣѭ��				
-					**���̵߳�Looper����
-						�������߳���ʹ��Handler��ʱ�򣬲���ָ��Looper����Ϊ�����߳̿�����ʱ�򣬾��Ѿ�������Looper.loop()������ʼ��ѯ�ˡ�
-						ͨ��Handler.getLooper()�ɻ�ȡ��ǰ���̵߳�Looper����
-						���߳̿�ͨ��Looper��������̷߳�����Ϣ
-					**���̵߳�Looper����
-						�����߳���ʹ��Handler��ʱ��ͨ������Looper��prepare���������洢Looper���󣬻��õ���Looper.loop()����������ѯ��
-						һ���߳̿��Դ���(��ȻҲ���Բ�����)һ����Ϣ���к�һ����Ϣѭ��(Looper)���ض��̵߳���Ϣֻ�ַܷ������̣߳�
-						���ܽ��п��̡߳������ͨѶ�����Ǵ����Ĺ����߳�Ĭ����û����Ϣѭ������Ϣ���еģ�������ø��߳̾�����Ϣ���к���Ϣѭ����
-						��Ҫ���߳������ȵ���Looper.prepare()��������Ϣ���У�Ȼ�����Looper.loop()������Ϣѭ����
-				ע��Android�г��˽�����������View�ڴ�����View���߳����޸ġ�
-			��Handler���ʹ�ã�
-				Handler��ʹ����Ҫ�ĸ��������ʹ�ã�
-					Handler��Looper��Message��Thread
-			��Handler��AsyncTask������
-				a����ͬ�㣺
-					AsyncTask��Handler����ͨ�����̺߳����߳�֮���ͨ�Ÿ���������
-				b����ͬ�㣺
-					Handler�Ƚ��鷳����AsyncTaskʹ������ӷ��㣬����AsyncTask���̿ɿ�;
-					���ڶ����̨����ʱ��ʹ��Handler����ṹ�����򵥣���ʹ�ö��AsyncTaskʱ���׷����쳣��
-		2)Android�µ���Ϣ���ͻ���:
-			����Ϣ���ͻ��Ƹ�����
-				�����ǿ����ͷ�����������Ӧ��ʱ�������϶���Ҫ��ȡ����˵����ݣ������Ҫ��Ϣ���ͻ�����ʵ�֡�
-			�ڻ�ȡ�������ϲ���ʱ���µ���Ϣ�����ַ�ʽ��
-				��һ���ǿͻ���ʹ��Pull(��)�ķ�ʽ���ͻ���ÿ��һ��ʱ��ȥ����˻�ȡ��Ϣ�����Ƿ��и��µ���Ϣ���оͻ�ȡ
-				�ڶ����Ƿ����ʹ��Push(��)�ķ�ʽ������˸��������ˣ��ͰѸ��µ�����Push���ͻ���
-				ע����ȻPull��Push��ʽ����ʵ�ֻ�ȡ����˸��µ����ݵĹ��ܣ������Ե�Push��ʽ��Pull����ʡ�û��������͵���
-			����Ϣ���ͽ��������
-				****��ѭPull:
-					Ӧ�ó���׶��Ե���������������Ӳ���ѯ�Ƿ�������Ϣ
-					ȱ�ݣ�Ҫ������ѯ��Ƶ�ʣ����̫�����ܵ���ijЩ��Ϣ���ӳ٣����̫�죬������������������͵��
-				****SMS Push:
-					ͨ������SMS��Ϣ���ҽ�����Ϣ�������˽����������ͼ
-					ȱ�ݣ��ɱ���ԱȽϸߣ�������ҵ���ѵĶ���Ϣ��������
-				****�־�����Push:
-					ȱ�ݣ��������ֻ���ʵ��һ���ɿ��ķ��񣬲��ҷdz������ֻ��ĵ��
-			����Ϣ���ͷ���
-				****C2DM(Cloud to Device Messaging)����:
-					C2DM��Google�ṩ����Ϣ���ͷ�����һ���򵥵ġ��������Ļ��ƣ���������������֪ͨ�ƶ�Ӧ�ó���ֱ�������������ͨ��
-					�Ա��ڴӷ�������ȡӦ�ó�����º��û����ݡ�
-					C2DM��������������Ϣ�Ŷӵ�������������Ŀ���豸�ϵ�Ӧ�ó���ַ���Щ��Ϣ��
-					C2DM��������⣺
-						C2DM������Android��2.2ϵͳ�ϣ��޷������ϵ�1.6��2.1ϵͳ
-						C2DM��Ҫ������Google�ٷ��ṩ��C2DM�����������ڹ��ڵ����绷����������񾭳������ã������Ҫ�ܺõ�ʹ�ã�
-							���ǵ�App Server����Ҳ�ڹ��⣬������²���ÿ�������߶��ܹ�ʵ�ֵ�
-				****MQTTЭ��ʵ��Android���ͣ�
-					MQTT��һ������������Ϣ����/����Э�飬����ʵ�ֻ����ֻ��ͻ��˵���Ϣ���ͷ�����������������
-					wmqtt.jar ��IBM�ṩ��MQTTЭ���ʵ��
-				****RSMBʵ�����ͣ�
-					Really Small Message Broker (RSMB) ������һ���򵥵�MQTT������ͬ����IBM�ṩ
-				****XMPPЭ��ʵ��Android���ͣ�
-					Google�ٷ���C2DM�������ײ�Ҳ�Dz���XMPPЭ����еķ�װ
-					XMPP(����չͨѶ�ͱ�ʾЭ��)�ǻ��ڿ���չ�������(XML)��Э�飬�����ڼ�ʱ��Ϣ(IM)�Լ�����̽�⡣
-					���Э��������������������û����������ϵ������κ��˷��ͼ�ʱ��Ϣ
-					androidpn��һ������XMPPЭ���java��ԴAndroid push notificationʵ��
-					ע��
-						XMPPЭ��ʵ��Android���͵�������ƾ��Ǽ򵥣����Dz���Ҫ��C2DM������������ϵͳ�汾��Ҳ���ᵣ��ijһ��Google�����������á�
-						����XMPPЭ�����ǻ����Խ�һ���Ķ�Э�������չ��ʵ�ָ�Ϊ���ƵĹ��ܡ������������������Ŀǰֻ�ܷ���������Ϣ��
-						��������������˵һ���㹻�ˣ���Ϊ���Dz���ָ��ͨ�����͵õ����е�����
-		3)���̼߳�ͨ��
-			�ٽ��̺��߳��Լ����̵߳ĸ��
-				���̣����ڽ��еij���ÿһ������ִ�ж���һ��ִ��˳�򣬸�˳����һ��ִ��·�������߽�һ�����Ƶ�Ԫ
-				�̣߳������ڲ���һ��ִ��·������һ�����Ƶ�Ԫ
-					ע�����ߵ�����
-						һ������������һ���߳�
-						������ִ�й�����ӵ�ж������ڴ浥Ԫ��������̹߳���һ���ڴ浥Ԫ
-				���̣߳�
-					һ���������ж���̣߳���Ϊ���߳�
-			�ڶ��̵߳����ƺͱ׶ˣ�
-				���ƣ�����˶ಿ��ͬʱ���е����⣬���Ч��
-				�׶ˣ��߳�̫��ᵼ��Ч�ʵĽ��ͣ���Ϊ�̵߳�ִ����������CPU�������л�
-			��ʵ�ֶ��̵߳ķ�����
-				ʵ�ֶ��߳̿���ͨ���̳�Thread���ʵ��Runnable�ӿ�
-				a���̳�Thread
-					����һ����̳�Thread��
-					��дThread���е�public void run()���������̵߳���������װ��run������
-					ֱ�Ӵ���Thread��������󣬴����߳�
-					����start()�����������߳�(�����̵߳�����run����)
-				b��ʵ��Runnable�ӿڣ�
-					����һ���࣬ʵ��Runnable�ӿڣ�
-					���ǽӿڵ�public void run()�ķ��������̵߳���������װ��run�����У�
-					����Runnable�ӿڵ��������
-					��Runnabl�ӿڵ����������Ϊ�������ݸ�Thread��Ĺ��캯��������Thread�����
-								   ��ԭ���̵߳����񶼷�װ��Runnable�ӿ���������run�����С�
-							 ����Ҫ���̶߳��󴴽�ʱ�ͱ�����ȷҪ���е����񣩡�
-					����start()�����������̡߳�
-				ע�����ַ�������
-					(1)ʵ��Runnable�ӿڱ����˵��̳еľ�����
-					(2)�̳�Thread���̴߳�������Thread�����run������
-					   ʵ��Runnable�ӿ��̴߳������ڽӿڵ������run�����У�
-					   �ڶ����߳�ʱ������ʹ��ʵ��Runnable�ӿڣ���Ϊ�������ж��̶߳�����ʹ�����ַ�ʽʵ��
-			���̵߳ļ���״̬��
-				�½���newһ��Thread������������������Ǵ���һ���̣߳���һ���̶߳��󱻴���������û�п��������ʱ��
-					  ֻ��Ϊ�̶߳��󿪱����ڴ�ռ�ͳ�ʼ�����ݡ�	        
-				�������½��Ķ������start�������Ϳ������̣߳��߳̾͵��˾���״̬��
-					  �����״̬���̶߳��󣬾���ִ���ʸ�û��CPUִ��Ȩ��
-				���У����̶߳����ȡ����CPU����Դ��
-					  �����״̬���̶߳��󣬼���ִ���ʸ�Ҳ��ִ��Ȩ��
-				���᣺���й����е��߳�����ijЩԭ��(����wait,sleep)���ͷ���ִ���ʸ��ִ��Ȩ��
-						  ��Ȼ�����ǿ��Իص�����״̬��ֻ��������ֱ�ӻص�����״̬�������Ȼص�����״̬��					  
-				���������̶߳�����õ�run()��������������ֱ�ӵ���stop()�����������̶߳����������̶߳������ڴ��б����������
-			�ݶ��̰߳�ȫ���⣺
-				a��ԭ��:
-						������Ķ�������ڲ����̵߳Ĺ�������ʱ(����Ʊ�����е�Ʊ���ǹ�����Դ)�������̵߳�����Ե���
-							һ���߳�ִ�ж������ʱ��ִ����һ���ֻ�ûִ���꣬��һ���߳����ᵽcpuִ��Ȩ�������ִ�У�
-							��ʱ�͵��¹������ݷ������󡣱�����Ʊ�����д�ӡ��Ʊ�ʹ�Ʊ�������	
-				b���������:�Զ��������������ݵ�������ͬ����һ���߳���ִ�й����������̲߳����Բ������
-			��Java�ж��߳�ͬ����
-				a��ͬ�������ã�
-					ͬ��������������̵߳İ�ȫ����ģ��ڶ��߳��У�ͬ���ܿ��ƶԹ������ݵķ��ʡ�
-					���û��ͬ������һ���߳����޸�һ����������ʱ��������һ���߳�����ʹ�û��߸���ͬһ���������ݣ��������׵��³�����ִ���Ľ��
-				b��ͬ����ǰ�᣺
-					���뱣֤�����������߳�
-					�����Ƕ���߳�ʹ��ͬһ����������������ڲ����̹߳�������
-					���뱣֤ͬ����ֻ��һ���߳�������
-				c��ͬ���ĺô��ͱ׶�
-					�ô���ͬ������˶��̵߳İ�ȫ����
-					�׶ˣ����̶߳���Ҫ�ж������Ƚ�������Դ
-				d��ͬ�������ֱ�����ʽ��
-					ͬ�������:
-						����ָ����Ҫ��ȡ�ĸ������ͬ����,ʹ��synchronized�Ĵ����ͬ����Ҫ��,���������������������
-						���ǵ���ȫ���⣬һ�㻹��ʹ��ͬһ�����������˵Ч�ʽϸߡ�
-						ע�⣺
-						**��Ȼͬ��������������ʹ�κζ��󣬵����ڽ��ж��߳�ͨ��ʹ��ͬ�������ʱ��
-						  ���뱣֤ͬ�����������Ķ���Ψһ������ᱨ����
-						**ͬ������������this��ҲҪ��֤ͬ�����������Ķ���͵���wait��notify��notifyAll�Ķ�����
-						  ͬһ������Ҳ���Ƕ���this�������Ķ���
-						��ʽ��
-						synchronized(����)
-						{
-							��ͬ���Ĵ���;
-						}
-					ͬ������
-						ͬ��������ָ����÷���ʱ��Ҫ��ȡthis�����ͬ�������ڷ�����ʹ��synchronized�ؼ��֣�
-						ʹ��this������Ϊ����Ҳ����ʹ���˵�ǰ������Ϊ��ס�˷�������������ڴ������˵Ч����Խϵ͡�
-						ע:��̬ͬ�����������Ǹ÷������ڵ�����ֽ����ļ����󣬼�����.class�ļ�
-						��ʽ��
-						���δ� synchronized ����ֵ���� ������(�����б�)
-						{
-							��ͬ���Ĵ���;
-						}
-			������
-				�����̶߳�����ͬ���������ѭ������ʱ���ͻᷢ��������
-				��ͬ��Ƕ��ͬ��������ȴ��ͬ��
-			��ΪʲôҪ�̼߳�ͨ�ţ�
-				���̲߳���ִ�е�ʱ��, �����Ҫָ���̵߳ȴ����߻��������߳�, ��ô����Ҫ�̼߳�ͨ�š�
-				���������������ߵ����⣬����һ������һ��,������ʱ����Ҫ�������ѵĽ��̵ȴ�,����һ������ɺ���Ҫ���Ѹ������ѵ��߳�,
-				ͬʱ���Լ����ڵȴ������ѵ�ʱ�������ѵ��̱߳����ѣ������������IJ�Ʒ���ֽ��ȴ��������̻߳��ѣ�
-				Ȼ��ʹ�Լ��̴߳��ڵȴ�����������ͨ�ţ��Դﵽ����һ������һ����Ŀ��
-			���̼߳���ôͨ��
-				��ͬ���������, ʹ���������wait()���������õ�ǰ�̵߳ȴ�, ֱ���������̻߳���Ϊֹ.
-				ʹ���������notify()�������Ի���һ���ȴ����̣߳�����notifyAll�������еȴ����߳�.
-				���̼߳�ͨ����sleep����ʵ�֣�˯��ʱ����Ѱ��ա�
-			��Android�������̼߳�ͨ��Ӧ�ð�����
-				a��Handler
-				b��Intent
-			ע�����̼�ͨ�Ű�����
-				���񡢹㲥�����ߡ������ṩ�ߵ�
-	(4)Android�µ�XML��JSON������
-		1)XML�Ľ��������ɣ�
-			����XML�ĸ�����
-				������XML������ʽ�����֣�DOM��SAX��Pull
-				Android SDK���Ѿ�������Pull�����������������κ�jar�ļ�����Androidϵͳ���Ƽ�ʹ��Pull����XML
-					Pull���������з�ʽ��SAX���ƣ��ṩ�����¼����ж�
-			��ΪʲôҪ����XML��
-				����XML���ǰ�XML�ļ��������ǩ�����ԡ��ı�����������װ��javabean�У�����XML�Ĺؼ���������õ�XML�ļ������Ԫ�ص����Ժ��ı�
-			�ڽ���XML�IJ��裺
-				a����ý�������XmlPullParser parser = Xml.newPullParser();
-				b�������������Լ����룬ָ�����������ĸ������������XML�ļ�
-					//ȥ��getClassLoader()���ļ���ǰ��ӡ�/�������򱨴�
-					InputStream in = PersonServiceTest.class.getClassLoader().getResourceAsStream("persons.xml");
-					parser.setInput(in, "UTF-8");
-				c��ͨ��������XmlPullParser����ij����˷���������XML�ļ�
-					XmlPullParser�¼����ͳ�����START_DOCUMENT��END_DOCUMENT ��START_TAG ��END_TAG ��TEXT
-					������
-						getEventType():��ȡ�¼�������
-						next()�����½���
-						getName()����ȡ��ǩ������
-						getAttributeValue(int index)������������ȡ��ǩ�����ԣ�������0��ʼ
-						getText()����ȡ�ı�����
-						nextText()����ȡ��һ���ı�����
-			��ΪʲôҪ����XML��
-				��javabean����д��XML�ļ�������������������XML�ļ��Ĺؼ�������ΰ�javabean�����������������XML�ļ���Ԫ�ر�ǩ��������
-			��ʹ��XmlSerializer����XML�ļ��IJ��裺
-				a����ȡ���л�����
-					XmlSerializer serializer = Xml.newSerializer();
-				b���������л������������ͱ��룬ָ�����ɵ��ĸ�����������XML�ļ�
-					FileOutputStream fos = new FileOutputStream("/mnt/sdcard/persons.xml");
-					serializer.setOutput(out,��UTF-8��);
-				c��ͨ�����л��ĸ��ַ�������������XML�ļ��ĸ���Ԫ�ر�ǩ����
-					startDocument����ʼXML�ĵ�
-					startTag����ʼ��ǩ
-					attribute�����ñ�ǩ������
-					text�����ñ�ǩ���ı�
-					endTag��������ǩ
-					endDocument������XML�ĵ�
-		2)JSON������
-			JSON�ļ����൱����һ������
-			����JSON�ļ����൱�ڱ����洢JSON�����JSONArray����ȡÿ��JSONObject�����ݣ�����װ��javabean��
-			��JSON����ȱ�㣺
-				�ŵ㣺
-					��Ϊ���ݴ����ʽ����XML���ƣ����DZ�XML��������
-					����JSON��JavaScript��ԭ����ʽ������JSON����Ҫ�����ض����ݵ��ײ���Ϣ
-				ȱ�㣺
-					�﷨�����Ͻ�
-					����ɶ��Բ�
-					��eval�������ڷ���
-	(5)JNI���ã�
-		1)JNI���
-			ʲô��JNI?
-				JNI��Java Native Interface����д����Java���ؽӿ�
-				JNI��һ��Э�飬��������ͨJava�����C/C++�����Э��,��Java��C/C++֮�������
-				ͨ��JNIЭ�飬Java���Ե����ⲿ��C/C++�еĶ���õĺ�����;�ⲿ��C/C++Ҳ���Ե���Java�з�װ�õ���ͷ���
-		2)Ϊʲô��JNI��
-			��ʵ�ʿ����е�����������C������Javaͨ��JNI�Ϳ��Ե���C�����õ��������Ӷ���չJava�����������
-			  ����Androidϵͳ��wifi-hostpot������C������Javaͨ��JNI���õ�
-			�����Ч�ʣ��ڸ�Ч�ʵ���ѧ���㡢��Ϸ��ʵʱ��Ⱦ����Ƶ��Ƶ�ı�����ϣ���C��д�ģ�Java��ͨ��JNI������C��д�õĸ�Ч�ʵĴ���
-			�۴��븴�ã�Javaʵ��2000�����Ҳ��𽥷�չ�����ģ���C������ʮ����ͳ����ˣ�C���кܶ�dz��÷dz����ĺ�����ķ�װ,
-			  ����C�й����ļ�ѹ��(7-zip ��C��д�� Ч�ʷdz���)������ʶ����������Java����Ҫ��д�ˣ�ֱ���������þͺ�
-			ע��ΪʲôC��д�Ĵ���Ч�ʸߣ�
-				C��д�Ĵ��벻��Ҫͨ��Java��������룬ϵͳֱ�Ӿ���ʶֱ�Ӿ����á�
-		3)�����JNI:
-			��C/C++������
-				ָ�룺
-					ָ����ǵ�ַ����ַ����ָ��
-				��ַ��
-					�ڴ浥Ԫ�ı��
-				ָ�������
-					��ŵ�ַ�ı���
-				ָ�����Ҫ��:
-					a����ֱ�ӷ���Ӳ��
-					b�����ٴ�������
-					c������һ�����ϵ�ֵ
-					d����ʾ���ӵ����ݽṹ
-					e�����㴦���ַ���
-					f�������������������
-			��JNI���̣�
-				a������һ��Android����
-				b����Java����������һ�����ط�������javah��������ͷ�ļ�
-				c���ڸ�Android�����д���jniĿ¼,����ͷ�ļ�,����ͷ�ļ�ʵ��c���룬�ο�NDK�����е�jni.h�ļ���
-				   ���еĽṹ��JNIEnv*�����jobject�������Ҫ����C�����еķ������봫������������
-				d����jniĿ¼�д�������дAndroid.mk�ļ�
-				e��Ndk����������ɶ�̬�⣬�������ֻ���ִ�еĶ������ļ�(.so�ļ�)
-				f��Java����load ��̬��.����native����:System.loadLibrary("Hello");//HelloΪjniĿ¼C/C++�����.c�ļ�
-			��NDK(native develop kits):
-				a��Ϊʲô��ҪNDK���ߣ�
-					�ڰ�׿�����У���Ϊ�ײ㶼��C����C������Ҫ���������ײ���ܶ�������CЧ�ʱ�java�죬��java��Ҫ����C�д��롣
-					��java����ֱ�ӵ���C�д��룬���ǵ���C����Ķ������ļ���C�������װ��C�зḻ�ĺ�����
-					Java��Ҫ����C����Ŀ�ִ�еĶ������ļ��辭�����������裺
-						���룺
-							��CԴ�������ɲ���ִ�еĶ������ļ���
-							�ö������ļ���windowsϵͳ����.obj�ļ�
-							��Linuxϵͳ����.o�ļ�
-						���ӣ�
-							������õĶ������ļ����ݵ�ǰ�IJ���ϵͳϵͳ���ӳɿ�ִ�еĶ������ļ��������ӹ����м����˱���ĺ�����
-							�ö������ļ���windowsϵͳ����.exe�ļ�
-							��linuxϵͳ����.so�ļ�
-				b��������룺
-					Google�ṩ����C��д��NDK���ߣ��ù��ߵ�ndk-build��ʵ���ڵ�����(windows����ϵͳ��x86��CPU)
-					����������ֻ�(linux����ϵͳ��arm��CPU)��ִ�еĶ������ļ����˹��̾��ǽ��������̡�
-					NDK������Ҫ������linuxϵͳ�����£���cygwin��windowsϵͳ��ģ��linuxϵͳ��һ�����ߣ��ʰ�װNDK֮ǰ�谲װcygwin������
-	(6)SQLite��MySql�����ݿ��CRUD��SharedPreferences�����ݳ־û�
-		1)SQLite:
-			��SQLite������
-				Androidƽ̨��Ƕ����һ����ϵ�����ݿ�SQLite�����������ݿⲻͬ����SQLite�洢����ʱ����������
-				SQLite���ֻ��Դ������ݿ⣬ÿһ�����ݿ����һ��XML�ļ���ÿһ��XML�ļ���һ�Ż���ű�
-			�ڴ���SQLite���ݿⲽ�裺
-				a��������̳�SQLiteOpenHelper
-					SQLiteOpenHelper�����������ݿ��һ�����ߣ������д���onCreate()���ݿ������upGrade()���ݿⷽ����
-					�ڻ�ȡ���ݿ�����ʱ����Щ�������Զ�ִ��,ʹ���ֻ��Դ���SQLite���ݿ���봴��һ��SQLiteOpenHelper���࣬
-					ʵ����onCreate(SQLiteDatabase), onUpgrade(SQLiteDatabase, int, int)������
-					������ݿⲻ�����򴴽��������������ݿ�汾�Dz������£������������������ݿ�汾��ά���䱣��һ����ѵ�״̬
-				b����ȡ���ݿ�SQLiteDatabase����
-					SQLiteOpenHelper. getWritableDatabase()����ȡд���ݿ⣬����дʱ�ɻ�ȡ�����ݿ�
-					SQLiteOpenHelper. getReadableDatabase()����ȡ�����ݿ�
-				c��ִ�����ݿ���ɾ�IJ����
-					ִ����ɾ�IJ������޷��ؽ������
-						SQLiteDatabase.execSQL(String sql,Object[] params);
-					ִ�в�ѯ����������Cursor�����
-						SQLiteDatabase.rawQuery(String sql,String[] params);
-					����ִ��CRUD������
-						SQLiteDatabase.insert();
-						SQLiteDatabase.update();
-						SQLiteDatabase.delete();
-						SQLiteDatabase.query();
-				d���ر���Դ��(��ѡ������ÿ�λ�ȡ���ݿ��ʱ�����ݿ�ײ���Զ������������ֶ��ر�)
-					SQLiteDatabase.close();
-					Cursor.close();
-		2)MySql:
-			��MySql����:
-				�ṹ����ѯ����,Structured Query Language����д
-			��JDBC��飺
-				a��JDBC��java���ݿ����ӣ�Java DataBase Connectivity����д
-				b��������Ա��װ�˲�ͬ�����ݿ������(��MySQL��Oracle)������Ҫ��װ��ͬ�����ݿ�������
-				   ������javaӦ�ó��������Ӹ����ݿⲢ�Ը����ݿ�����ݽ��в������������Կ�����Ա��˵�Ǻ��鷳��
-				   ���Ǻ�SUN���ṩ��һ�ײ������ݿ�Ĺ淶���ù淶����JDBC
-				   ��ͬ���ݿ⳧��ʵ���˸ù淶(����)��������ԱֻҪ���ոù淶����������
-				c��JDBC�淶������JDK�е�
-			��JDBC��̲��裺
-				a��ע��������
-					��ʽһ��DriverManager.registDriver(new com.mysql.jdbc.Driver())
-							ע���Driver���ڵİ���com.mysql.jdbc.*��������java.sql.*���� 
-							���ַ�ʽ������ʹ�ã�ԭ�����£�
-								****����������������ݿ���������,DriverManager��java.sql.*���е�
-									�������Orcal���ݿ⣬��øij���
-								****�ᵼ�����ݿ����������ע��2�Σ�DriverManager����һ���ص�ʱ��
-									��ע����һ��,������new com.mysql.jdbc.Driver()��ע��һ��
-									(�鿴Դ����)
-					��ʽ����Class.forName("com.mysql.jdbc.Driver");
-							�����ô˷�ʽ���η�ʽ������a�з�ʽһ���ֵ�����
-				b�����������ݿ�����ӣ�java.sql.Connection�����е������ݿ�Ľ��������������ӵĻ����Ͻ��в���
-					Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/day12","root", "xiaruri");
-					ע��url�Ĺ̶���ʽд��Ҫ��ס��"jdbc:mysql://localhost:3306/day12"
-						jdbc:����Э��  mysql:������Э��   localhost:3306:���������Ͷ˿�  day12:�������ݿ�
-						root:����MySQL�������û���    xiaruri:�û�������
-					ʵ�ʿ�������Ѵ���ȥ�������ַ�����ȡ������д�������ļ���ͨ����ȡ�����ļ���ʽ
-					����ȡ���Ĵ���ȥ���������⻻���ݿ�ʱ�ij���ֻ��������ļ�����
-				c����ȡ����SQL������
-					Statement stmt = conn.createStatement();
-				d��ִ��SQL���
-					String sql = "select id,name,password,email,birthday from users";
-				e������н�������ᱻ��װ��һ��ResultSet����
-					ResultSet rs = stmt.executeQuery(sql);
-				f�����������
-					while(rs.next()){
-					//rs.getObject(1):�����ÿ����¼����������1��ʼ������JDBC���ʱʹ��
-					System.out.println(rs.getObject("id")+"\t"+rs.getObject("name")+"\t"+
-						rs.getObject("password")+"\t"+rs.getObject("email")+
-							"\t"+rs.getObject("birthday"));
-					}
-				h���ر�ʹ�õ���Դ
-					rs.close();
-					stmt.close();
-					conn.close();
-			�ܿ�Դ������Դ��ܣ�
-				a����ֱ�ӷ���Ӳ��
-					b��DBCP
-						DBCP��Apache����������֯�µĿ�Դ���ӳ�ʵ�֣�ʹ��DBCP����ԴӦ�ó���Ӧ��ϵͳ��������������jar�ļ���	     
-							Commons-dbcp.jar�����ӳص�ʵ��
-							Commons-pool.jar�����ӳ�ʵ�ֵ�������
-						����O-R Mappingӳ�乤��
-							Hibernate     CMP JPA(Java Persistent API)
-							Ibatis(��������ΪMyBatis)
-							Commons DbUtils(ֻ�Ƕ�JDBC�򵥷�װ)
-							Spring JDBC Template
-						DbUtils��飺
-							QueryRunner
-						MyBatis��飺
-							MyBatis��ǰ������iBatis������һ�����ݳ־ò���
-							MyBatis֧����ͨSQL��ѯ���洢���̺͸߼�ӳ�������־ò���
-							�����˼������е�JDBC����Ͳ������ֹ������Լ�������ļ�����MyBatisʹ�ü򵥵�XML��ע���������ú�ԭʼӳ��
-							���ӿں�Java��POJOs(Plain Old Java Objects����ͨ��Java����)ӳ������ݿ��еļ�¼
-					c��C3P0
-		3)SharedPreferences��
-			SharedPreferences������൱��һ���ɳ־û���Map����
-			ͨ��put�����洢�־û����ݣ���Ҫcommit����Ч
-			ͨ��get��ȡ�־û�����
-	(7)ϵͳMediaPlayer���������ڡ�ͼ����Ƶ����Ƶ��ý�忪������
-		��MediaPlayer�����ղ�����Ƶ����Ƶ�ļ��Ķ���ͨ��MeidaPlayer����
-			ע����Ƶ����Ƶ��������C����д�ģ�����MediaPlayer�ڲ���ͨ��JNI����ϵͳ��C�������
-			a��MediaPlayer���������ڵļ���״̬��
-				idle����һ��MediaPlayer���󱻸ո�new�������ǵ�����reset()�����󵽴�idle״̬
-				initialized����ʼ�����״̬��ִ��setDataSource()�����󵽴�initialized״̬
-				prepared��׼�����״̬��ִ��ͬ��׼��prepare()�����첽׼��prepareAsync()�����󵽴�prepared״̬
-					      ע��prepare()������ʽ���������Բ���������Ƶ�����ж���prepareAsync()������prepareAsync()�лص�����
-				started����ʼ����״̬��ִ��start()����seekTo()�����󵽴�started״̬
-				paused����ͣ����״̬��ִ��pause()�����󵽴�paused״̬
-				stopped��ֹͣ����״̬��ִ��stop()�����󵽴�stopped״̬
-				playbackComp���������״̬��
-				end��������release()�����󵽴�end״̬
-				error�����ſ��Ʋ������ܻ�ʧ�ܣ��粻֧�ֵ���Ƶ/��Ƶ��ʽ��ȱ�ٸ���ɨ�����Ƶ/��Ƶ���ֱ���̫�ߣ�����ʱ��ԭ��
-					   һ����������MediaPlayer�������뵽Error״̬
-				MediaPlayer�����ִ�����ʽ��
-					****MediaPlayer mp = new MediaPlayer();				//���ַ��������������prepare()����prepareAsync()����start()
-					****MediaPlayer.create(Context context,int resId);	//���ַ���ϵͳneibu�Ѿ�ִ��prepare()�ˣ��ʿ�ֱ��start()
-			b��MediaPlayer�ļ����¼�
-				setOnCompletionListener(MediaPlayer.OnCompletionListener listener) 	������ý�岥�Ž���������
-				setOnBufferingUpdateListener(MediaPlayer.OnBufferingUpdateListener listener) 	������ý��Ļ��������
-				setOnErrorListener(MediaPlayer.OnErrorListener listener) 						������Ϣ������
-				setOnVideoSizeChangedListener(MediaPlayer.OnVideoSizeChangedListener listener)	��Ƶ�ߴ���� ��
-				setScreenOnWhilePlaying(boolean screenOn)										�����Ƿ�ʹ��SurfaceHolder��ʾ������
-			c��MediaPlayer������
-				****MediaPlayerͨ����Service��ϲ�����Ƶ�ļ�
-				****MediaPlayerͨ����SurfaceView��ϲ�����Ƶ�ļ�
-					����Ӧ�õ���Դ�ļ�
-					����Ӧ�õ�ԭʼ��Դ�ļ�
-					�����ⲿ�洢���ϵ���Դ�ļ�
-					����������Դ�ļ�
-			d��MediaPlayer��ȱ��
-				��Դռ�����ϸߣ��ӳ�ʱ��ϳ�
-				��֧�ֶ����Ƶͬʱ����
-			e��ʹ��SoundPool������Ч
-				SoundPoolʹ����Ч�صĸ�������������̴ٵ���Ч��SoundPool��Ҫ���ڲ����ܼ����̴ٵ���Ч��
-				SoundPool��MediaPlayer��ȵ�����������CPU��Դռ�����ͺͷ�Ӧ�ӳ��£�����SoundPool��֧����������������Ʒ�ʡ����������ű��ʵȲ���
-			f��ʹ��VideoView��MediaController������Ƶ
-				VideoView�ĸ�����
-					VideoView����������ʾ�Ͳ�����Ƶ
-					VideoView��װ��MediaPlayer��ͬʱ�̳���SurfaceView
-					VideoView���Բ���������Ƶ����Ƶ�ļ���ͨ����֧��rmvb��ʽ����Ƶ
-				ʹ��VideoView������Ƶ�IJ��裺
-					����VideoView���
-					����VideoView��setVideoPath(String path)����setVideoURI(Uri uri)����ָ����Ƶ
-					����VideoView��start()��stop()��pause()����������Ƶ�IJ���
-			g��ʹ��MediaPlayer��SurfaceView������Ƶ
-		��MediaRecorder��
-			�ֻ�һ�㶼�ṩ����˷�Ӳ������Androidϵͳ�Ϳ������ø�Ӳ����¼����Ƶ������Ƶ
-		�۶�ý�峣ʶ��
-			a��ʲô�Ƕ�ý��
-				��ý���Ǽ��������Ƶ�����Ľ�ϣ�ʵ������������ý�壻������ͼ�񣬻��������ڵ��������͵���
-			b�����õ���Ƶ��ʽ
-				AndroidϵͳĬ�ϣ�mp4��3gp	
-				���ø�ʽ��ts��3gpp��3g2��3gpp2��avi��mkv��flv��divx��f4v��rm��rmvb��rv��wmv��asf��mov��mpg��v8��ram��mpeg��
-						  swf��m2v��asx��ra��ram��ndivx��xvid��	 
-			c��������Ƶ��ʽ��
-				Androidϵͳ��mp3��ogg��
-				���ø�ʽ��wma��mid��m4a��xmf��aac��mpa��midi��ar��
-			d������ͼƬ��ʽ��PNG��GIF��BMP��jpg
-			e��android�Ķ�ý��Ӧ�ã�	
-				��Ƶ������
-				��Ƶ������
-				���
-				ͼƬ�����
-				��Ƶͨ��
-				MediaScanner����������SDcard����ʱ��ϵͳ����ɨ��ͼƬ����Ƶ����Ƶ��ý���ļ�
-			f��MediaPlayer��η�װ�����룺
-				��MediaPlayer��������һ����̬����飬�þ�̬�������ɵ�����C���Ա�д�Ľ�����롣
-			g�����ڸ�����Ƶ��վ���õĽ����ܣ�
-				�ſᡢ�Ѻ������ա�pps������Ӱ��������56�������õ�ffmpeg
-				pptv�Ѿ�ʹ��p2p����
-					��Ե㼼����peer-to-peer�� ���P2P���ֳƶԵȻ������缼������һ�������¼��������������в����ߵļ��������ʹ�����
-					�����ǰ��������ۼ��ڽ��ٵļ�̨�������ϡ�P2P����ͨ������ͨ��Ad Hoc���������ӽڵ㡣��������������ڶ�����;��
-					���ֵ������������Ѿ��õ��˹㷺��ʹ�á�P2P����Ҳ��ʹ��������VoIP��ʵʱý��ҵ�������ͨ���С�
-			h�������Ź��̳����������ƣ�
-				��ʾ�û����Ŵ���
-				���²���
-				ʹ�õ�����������			
-		����ʵ�����ܲ��ŵĿ�ܣ�
-			������
-				��ȻAndroid�Ѿ�������VideoView�����MediaPlayer����֧�ֿ�����Ƶ����������ϵͳ֧�ֵĸ�ʽ�����ܵȸ����涼ʮ������
-				�������ǿ������ÿ�Դ��ĿVLC��ffmpeg����Vitamio�����������Լ���Android���ܲ�������
-			a��VLC��ܣ�
-				VLC��һ����Դ��Ŀ������ffmpeg��ܵ��Զ��岥����������LibVLC��VLC�ĺ��IJ��֣����൱��MediaPlayer��
-				VLCһ������Ҫ�IJ��֣������Բ��Ÿ������͵�ý���ļ�����ý���ļ������ҿ��Դ���ý����������ɸ��ָ�ʽ��ý���ļ�
-				VLC��һ�ֿ�ƽ̨��ý�岥��������ý������������Ϊvideolan�Ŀͻ��ˣ�����һ�ַdz����Ķ�ý�岥������
-					�������������Ÿ��ָ���������Ƶ�ĸ�ʽ�ļ�(MPEG-1��MPEG-2��MPEG- 4��DivX��WMV��mp3��OGG��Vorbis��AC3��AAC�ȵ�)��ý��Э��
-					�����ɫ�Ĺ����ǿ��Ա����ر߹ۿ�Divxý���ļ��������Բ��Ų���ȫ��AVI�ļ�������֧�ֽ���ĸ��ġ�
-				ȱ�㣺��C/C++���룬����Java���룬����̫�Ӵ�	
-			b��ffmpeg��ܣ�
-				�ŵ㣺��������ܣ�����ά��
-				FFmpeg��һ����¼�ơ�ת������/��Ƶ������빦��Ϊһ��������Ŀ�Դ�������
-				FFMPEG����Ϊ������еķ��ع��������ˣ�������롢���롢���úͽ⸴�á�
-					��ʹ�ö�ý��Ӧ�ó��������ױ�д������һ���򵥵ģ���C��д�ģ����ٵIJ����ܹ�����
-					�������������õ��ĸ�ʽ����ȻҲ����������ָ�ʽ��
-				FFmpeg֧��MPEG��DivX��MPEG4��AC3��DV��FLV��40���ֱ��룬֧��AVI��MPEG��OGG��Matroska��ASF��90���ֽ���
-				FFmpeg��Ŀ¼����Ҫ��libavcodec��libavformat��libavutil����Ŀ¼������libavcodec���ڴ�Ÿ���encode/decodeģ��
-					libavformat���ڴ��muxer/demuxerģ�飬libavutil���ڴ���ڴ�����ȸ�����ģ��
-			c��vitamio��ܣ�
-				vitamioҲ�ǻ���ffmpeg��Դ���
-				VPlayer��vitamio��һ����Ʒ��vitamio��VPlayer��ͬһ���Ŷӿ����ģ�VPlayer�ܲ��ŵ�vitamioҲ�ܲ���
-				vitamio�ijɹ�������
-					���ڣ�VPlayer����èӰ����321Ӱ����
-					���⣺Tvltaliane��Dizi TV��
-				vitamio֧�ֵ�����Э�飺
-					m3u8
-					MMS
-		������������RTSP (RTP, SDP)
-		����������	HTTP��ʽ����(progressive streaming)
-		������������HTTP Live Streaming (M3U8), Android 2.1+
-				vitamio����ɣ�
-					vitamio.jar
-					ARMv-7-NEON.apk
-					�ĸ���������
-						ARMv-7-NEON.apk
-						VFP.apk
-						ARMv6.apk
-						ARMv5.apk
-						ע��vitamio�����ֻ�CPU�ͺŰ�װ��Ӧ�Ľ�������ֻ��װһ����������
-				vitamio�������ܵģ���Ϊ�ֻ��ϵ�Androidϵͳ�����ֻ����̸Ĺ�������vitamio��֧�����е��ֻ�������֧�ִ󲿷ֵ��ֻ���
-				���룺
-					Ӳ���룺��ϵͳ�ӿ�ʵ�ֵIJ�������
-					�����룺����ϵͳ�ӿ�ʵ�ֵIJ�������
-					ע��ϵͳ��������Ӳ���롣Ӳ������Ƶ�����������������ã�ϵͳ�������IJ��������϶��ȵ������������IJ��������á�
-			d����ý�壺
-				VLS����һ������������ר������������ĸ������⣬��Ҳ����һЩVLC��������videolan��Ϊ�������������http��rtp��rtsp������
-				��ý�������
-					��ν��ý����ָ������ʽ����ķ�ʽ��Internet���ŵ�ý���ʽ�� 
-					��ý���ֽ���ʽý�壬����ָ�̼���һ����Ƶ���ͷ������ѽ�Ŀ�������ݰ����������͵������ϡ�
-						�û�ͨ����ѹ�豸����Щ���ݽ��н�ѹ�󣬽�Ŀ�ͻ�����ǰ������ʾ������
-					��ý�������ķ�ʽ�������д�����Ƶ����Ƶ�Ͷ�ý���ļ�����ʽ��
-					��ý���ļ���ʽ��֧�ֲ�����ʽ���估���ŵ�ý���ʽ��
-					��ʽ���䷽ʽ�ǽ���Ƶ����Ƶ�ȶ�ý���ļ����������ѹ����ʽ�ֳ�һ����ѹ������
-						�ɷ��������û������������ʵʱ���͡��ڲ�����ʽ���䷽ʽ��ϵͳ�У��û����������ʽ���������ȵ������ļ�
-						ȫ��������Ϻ���ܿ������е����ݣ�����ֻ��Ҫ���������ӻ�ʮ���������ʱ�������û������������
-						��Ӧ�IJ�������ѹ������Ƶ����Ƶ����ʽý���ļ����в��ţ�ʣ��IJ��ֽ������������أ�ֱ��������ϡ�
-		�����ʵ����Ƶ�ĸ��������ţ�
-			���塢���ؿ졢�϶��졢û�й��
-	(8)JavaScript��AJAX������ͨ��JQuery���Ӧ������������첽���������ݾֲ�ˢ��
-		1)JavaScript
-			��Aptana:
-				a��������
-					Aptana��һ���dz�ǿ��ġ���Դ�ġ�רע��JavaScript��Ajax����IDE(Integrated Drive Electronics����д�������Ӽ���������)
-				b��Aptana���ܣ�
-					JavaScript��HTML��CSS���ԵĴ�����ʾ����
-					OutLiner��ͼ
-					�����﷨������ʾ
-					����JavaScript
-					֧�����е�AJAX��ܵĴ�����ʾ����
-			��JavaScript֪ʶ��
-				a�����������Window:
-					��ɣ�
-						document���ĵ�����
-							links�����Ӷ�������
-							forms��������������
-							images��ͼƬ��������
-						frame����ܶ���
-						location��λ�ö���
-						history����ʷ����
-			��DOM:
-				Document Object Mode���ĵ�����ģ��
-			��Node��
-				�ڵ��CRUD
-		2)Ajax��
-			(1)ʲô��AJAX��
-				Asynchronous JavaScript And XML�����
-				����������������ͨ�Ŷ�����ˢ�µ�ǰҳ��ļ�������AJAX������
-			(2)���������������������ַ�ʽ
-				����ͨB/Sģʽ(ͬ��)��
-					�ύ����->�ȴ�����������->������Ϸ��� ����ڼ�ͻ�����������ܸ��κ���
-				��AJAX����(�첽)��
-					�첽: ����ͨ���¼�����->��������������ʱ�������Ȼ�������������飩->�������
-			(3)ͬ�����첽�ĸ��
-				ͬ����ָ�����ͷ��������ݺ󣬵Ƚ��շ�������Ӧ�Ժ�ŷ���һ�����ݰ���ͨѶ��ʽ��                   
-				�첽��ָ�����ͷ��������ݺ󣬲��Ƚ��շ�������Ӧ�����ŷ����¸����ݰ���ͨѶ��ʽ 
-			(4)AJAX������Ӧ�ã�
-				Google��ͼ���������е���վ���ڶ�����AJAX���ֲ���ˢ�µļ�����
-			(5)����ˢ�µļ�����
-				��Flash
-				��Java Applet
-				�ۿ��
-				�����ص�iframe
-				��XMLHttpRequest
-					�ö����Ƕ�JavaScript��һ����չ����ʹ��ҳ�����������ͨ�š��Ǵ� ��AjaxӦ�õ����ѡ��ʵ����ͨ����Ajax����XMLHttpRequest����Ĵ����� 
-			(6)AJAX������ԭ����
-				��Ajax�����JavaScript����XmlHttpRequest��
-				  �ö�����Internet Explorer 5���״����룬����һ��֧���첽����ļ�����
-				  �����֮��XmlHttpRequestʹ������ʹ��JavaScript�������������󲢴�����Ӧ�����������û���
-				��AJAX�����첽�������̡�AJAX���û��������֮������һ���м�ý�飬�Ӷ����������罻�������еĴ������ȴ����������ȴ�ȱ�㡣
-			(7)AJAX�����ļ�����
-				AJAX������һ���µļ��������Ƕ��ּ����Ľ�ϣ�������Javascript��XHTML��CSS��DOM��XML��XMLHttpRequest��
-			(8)AJAX������ȱ�ݣ�
-				�������������֧�֣�ĿǰIE5.0�����ϡ�Mozilla1.0��NetScape7�����ϰ汾��֧��AJAX
-				�ڶ���ý���֧��û��FLASH��Java Applet�á�
-				���ֻ���PAD�����ܺܺõ�֧��AJAX
-				��AJAX����ҳ�����ݵ�ʱ��û��ˢ������ҳ�棬��ˣ���ҳ�ĺ��˹�����ʧЧ�ģ����������û��㲻�������ҳ���ϵ������ǾɵĻ��Ǹ��¹���	
-		3)JQuery��
-			��JQuery������ԭ��
-				Ϊ�˼�JavaScript�Ŀ���, һЩJavsScript�⵮���ˡ�
-				��ǰ���е� JavaScript ����: 
-					jQuery, MooTools, Prototype, Dojo, YUI
-			��JQuery��ʲô��
-				a��jQuery�Ǽ�prototype֮����һ�������Javascript��ܡ�����ּ�ǡ���WRITE LESS,DO MORE,д���ٵĴ���,����������顣
-				b��������������js��(ѹ����ֻ��21k)������������js���������ģ�������CSS3�������ݸ��������(IE 6.0+,FF 1.5+,Safari 2.0+,Opera 9.0+)
-				c��jQuery��һ�����ٵģ�����javaScript�⣬ʹ�û��ܸ�����ش���HTML documents��events��ʵ�ֶ���Ч�������ҷ����Ϊ��վ�ṩAJAX����
-				d��jQuery�ܹ�ʹ�û���htmlҳ���ִ����html���ݷ��룬Ҳ����˵����������html�������һ��js�����������ˣ�ֻ�趨��id����
-			��ʲô��JQuery����
-				jQuery �������ͨ��jQuery��װDOM���������Ķ���
-				��ȻjQuery�����ǰ�װDOM���������ģ�����jQuery�޷�ʹ��DOM������κη�����ͬ��DOM����Ҳ����ʹ��jQuery��ķ���.��ʹ�ûᱨ��
-	(9)AsyncTask��AsyncQueryHandler���
-		1)AsyncTask:
-			��AsyncTask������
-				AsyncTask��Android 1.5�ṩ��һ�����������첽���񹤾ߣ���һ����װ�õĺ�̨�����ࡣ
-			��AsyncTaskʹ��ԭ��
-				a��AsyncTaskʵ���������������߳��д���
-				b��execute�����������������߳���ִ��
-				c����Ҫ�ֶ��ĵ���onPreExecute��doInBackground��onPostExecute��onProgressUpdate����
-				d����ε��ý�������쳣
-			��AsyncTask��Handler����ͬ�㣺
-				a����ͬ�㣺
-					AsyncTask��Handler����ͨ�����̺߳����߳�֮���ͨ�Ÿ���������
-				b����ͬ�㣺
-					Handler�Ƚ��鷳����AsyncTaskʹ������ӷ��㣬����AsyncTask���̿ɿء�
-					���ڶ����̨����ʱ��ʹ��Handler����ṹ�����򵥣���ʹ�ö��AsyncTaskʱ���׷����쳣
-		2)AsyncQueryHandler��
-			��AsyncQueryHandler������
-				a��AsyncQueryHandler�̳���Handler
-			��AsyncQueryHandler�����ã�
-				��ContentProvider�ṩ�����ݽ�����ɾ�IJ顣
-			��AsyncQueryHandler�Ĺ������ƣ�
-				ע��AsyncQueryHandler�ڲ���ҪHandler��Looper��Message��HandlerThread��WorkerHandler��WorkerArgs���ʹ������첽����
-				a������AsyncQueryHandler����ʱ�������ϵͳ��AsyncQueryHandler���췽������AsyncQueryHandler���췽���
-				   ϵͳ��������²�����
-						����������һ��HandlerThread��ͬʱ��ʼ��Looper�����Handler����
-				b��������AsyncQueryHandler��startQuery��startInsert��startUpdate����startDelete����ʱ
-				   �ͻ�ִ����Ӧ����ɾ�IJ鷽������AsyncQueryHandler����ɾ�IJ鷽��������ͨ��Handler�����ʼ��Message����
-				   Ȼ���ٳ�ʼ��һ��WorkerArgs���󣬽����������Ϣ��װ��WorkerArgs�����У�
-				   �����ͨ��Handler�����sengMessage�������첽�������Ϣ���ͳ�ȥ
-				c��WorkerHandler�յ���Ϣ�������handleMessage�������ڸ÷�������첽����IJ������ͽ����жϣ�Ȼ��ִ����֮��Ӧ�Ĵ���
-				d�����ص�ָ�����첽����ִ����ɵĻص��������ûص�����ϵͳ�ǿ�ʵ�֣���Ҫ�û��Լ������Լ���ҵ��ȥ��д
-			��AsyncQueryHandler��ʹ��ע�����
-				������ʱ�����ANR�쳣������Ҫ�Ż���
-	(10)aidl������
-		1)ʲô��aidl��
-			aidl����Android�ӿڶ������ԣ���Android Interface Definition Language����д����Google�ṩ��һ���淶��
-		2)aidl���������ã�
-			(�����Ȳ�����������ֿ�����ʽ�ٿ�ʼ�ش��������)
-			����������ߺͷ�����ͬһ��Ӧ�ã���ʱ�����������ͨ��Զ�̰󶨷�����÷�������ķ����ͱ����ͨ��aidl������
-		3)ʹ��aidl�����IJ��裺
-			���ڷ����ж���÷���
-				���������Dz���ȥnewһ������Ҳ�Ͳ����õ�һ�������������ã��ò��������������ã�Ҳ�Ͳ���ͨ�������������������÷����еķ���
-					  ��ô����ͨ��ʲô��ʽ���ܵ��÷���ķ����أ����ǿ���ͨ��һ���м�����ʵ�ֵ��÷�������ķ���������м��˾��ǽӿڡ�
-					  ��ͨ��aidl�����ɽ�����Ӧ���еĽӿں͵�����Ӧ���еĽӿڱ��ͬһ���ӿ�
-					  �ͺñ�����Ҫ���������͵�ͨ�����ľ�����
-			�ڶ���һ���ӿڣ����ڽӿ�����������
-			��ͨ���󶨷���ķ��������ķ������÷����onBind��������ִ��onBind�����᷵��һ��IBinder�ӿڶ���
-			  ��Binder��IBinder�ӿڵ�ʵ���࣬�����ǿ����Զ���һ���ڲ���MyBinder�̳�Binderͬʱʵ�ֲ�����ж���õĽӿڣ�ʵ�ֽӿ�δʵ�ֵķ�����
-			  ��ʱMyBinder���൱��һ���м��ˣ�ͨ����������м��˵ķ������ǾͿ��Լ�ӵĵ��÷����еķ���
-			�ܽ�������Ӧ�õı���Ŀ¼���������еĽӿ��ļ���׺����Ϊaidl��ͬʱ���ӿ��е�Ȩ�����η�ȥ��(��ʱ����Ӣ���genĿ¼�������Ӧ��.java�ļ�)��
-			  ������÷����Ӧ�õı���Ŀ¼�����ӿ��ļ��ĺ�׺����Ϊaidl��ͬʱ���ӿ��е�Ȩ�����η�ȥ��(��ʱ����Ӣ���genĿ¼�������Ӧ��.java�ļ�)��
-			  �����ͱ�֤����Ӧ������ͬ����ͬ�����Ľӿ���ͬһ���ӿڣ���������ͨ�����м��˽ӿ�Զ�̵��÷�������ķ�����
-			�ݽ��������Զ�����ڲ���MyBinder��Ϊ�̳�Stub��
-			  ��Զ�̰󶨷�����÷��񷽷��Ĵ�����ServiceConnection���onServiceConnected�������ص�IBinder�ӿڣ�
-			  ͨ��Stub.asInterface(IBinder)����ǿת�������Զ�����м��˽ӿ�(ֻ��ǿתΪ�ͷ������Զ���Ľӿ����Ͳ��ܵ��÷����еķ���)
-	(11)WebService���ü�����
-		��WebService���ü��������ã�
-			���������ṩ�ķ���
-		�����ʹ��WebService:
-			a����½http://www.webxml.com.cn��վ��ȷ������Ҫ���ʵ�WebService���񣬲鿴�������ṩ��ʹ��API
-			   ��ȡ������WebService�������跢��XML�ļ��ͽ��յ�XML�ļ����˽�ʹ��˵��
-			b�������Ϸ���˷���ָ����������Ҫ��ָ����ʽ��XML�ļ�
-			c���������Ϸ���˷��ص�XML�ļ�
-		WebService�Ƿ����������ϵ�API������ͨ������XML���ã�WebService���ؽ��Ҳ��XML����
-		WebServiceû���������ƣ�ֻҪ���Է���XML���ݺͽ���XML���ݼ�	
-	(12)�������ģʽ���㷨��
-		(1)�������ģʽ��
-			ע��ʲô�����ģʽ��
-				���ij��������֮��Ч�ķ�������һ��˼�룬�ǹ��ɵ��ܽ�
-			1)�������ģʽ��
-				�ٸ��
-					��֤һ�������ڴ���ֻ��Ψһһ������
-				��ʵ�ֵ������ģʽ�IJ��裺
-					a�������캯��˽�л������캯��˽�л��ɱ����������򴴽��������
-					b���ڱ����д���һ��˽�еĸ������
-					c�������ṩһ���������ʷ�ʽ��Ϊ�˷�������������ʵ��������
-				�۵������ģʽ�����ַ�ʽ��
-					a������ʽ��
-						��һ���ؾʹ�������
-						class Student
-						{
-							private Student(){}
-							
-							private static final Student s = new Student();
-							
-							public static Student getInstance()
-							{
-								return s;
-							}
-						}
-					b������ʽ��
-						ʹ��ʱ�Ŵ����ö���
-						class Student
-						{
-							private Student(){}
-
-							private static final Student s = null;
-							
-							public static Student getInstance()
-							{
-								if(s==null) 
-								{
-									//�߳�1�ͽ����ˣ��߳�2�ͽ����ˡ�
-									s = new Student();
-								}
-								return s;
-							}
-						}
-					c������ʽ�ͱ���ʽ������
-						****����ʽ����һ���ؽ��ڴ�ʹ������˶��󣻶�����ʽ��������ؽ��ڴ��ʱ�򣬶���û�д��ڣ�Ҫʹ�øö����ʱ����new����
-						****����ʽ���ӳټ��أ��������߳�ͬʱ��������ʽʱ���п��ܳ����̰߳�ȫ����
-							Ϊ�������ʽ���̰߳�ȫ���⣬����̰߳�ȫ������Լ�ͬ���������
-							���Ǽ���ͬ��֮��ÿһ�ζ�Ҫ�Ƚ�����Ч�ʾͱ����ˣ�����ͨ��˫���ж�����߳���Ч�ʡ�
-						ע���������ö���ʽ����Ϊ����ʽ�򵥰�ȫ������ʽ���̵߳�ʱ�����׷�������
-				�ܵ������ģʽ��Ӧ�ã�
-					����Ҫ��֤ij�������ڴ������ҽ���һ��ʵ������ʱ�����õ������ģʽ������java��Runtime�ࡢClass�඼�Dz��õĵ������ģʽ
-			2)����ģʽ��
-				�����úͺô���
-					���ã�
-						�ṩ��������Ľӿ�
-					��
-						a�����ش���ϸ��
-						b����Ҫ�����¶���ʱֱ���������ļ��޸ľ��У��������
-				�ڹ���ģʽ�ķ��ࣺ
-					a���򵥹���ģʽ��
-						�����ڲ���ϵ�в�Ʒ
-					b����������ģʽ��
-						�����Թ���
-					c�����󹤳�ģʽ��
-						�ֳ�Ϊ�����䣬������Ʒ�壬�������ڲ����µIJ�Ʒ
-				�۹���ģʽ��Ӧ�ã�
-					��XML�ļ��ļ��ֽ���������DOM��SAX��PULL�ڴ���������ʱ�����õĹ���ģʽ
-				��ȱ�㣺
-					ȱ���ǵ���Ʒ�޸�ʱ��������ҲҪ����Ӧ���޸ġ�
-			3)ģ��ģʽ��
-				�ٸ��
-					����һ���������㷨�ĹǼܣ���һЩ�����ִ�н�������ȥ��ɡ�
-					�ڶ��幦��ʱ�����ܵ�һ������ȷ���ģ���һ�����Dz�ȷ���ģ�����ȷ���IJ�����ʹ�ò�ȷ���IJ��֣�
-						�ɽ���ȷ���IJ��ֱ�¶��ȥ���ɸ��������ȥ��ɡ�
-				��ģ�����ģʽ��Ӧ�ã�
-					a��Servlet�����õ�ģ�����ģʽ
-					b����Android�����е�BaseActivity������ÿ��Activity��Ҫִ��findview��setview�������¼��ʹ����¼��Ȳ�����
-					   �����ǿ��Խ���Щ��ͬ�IJ�����ȡ�����γ�һ��ģ�塣
-					c��ģ�����ģʽ��һЩ��Դ�����Ӧ�úܶ�
-			4)����ģʽ��
-				�ٶ��壺
-					Ϊ���������ṩһ�ִ����Կ��ƶ��������ķ���
-				�ڴ���ģʽ��Ӧ�ó�����
-					a����Ȩ����
-					b������ֱ�ӷ��ʶ��󣬵��ֱ�������������н���
-				�۴���ģʽ����ã�
-					������Ҫ��������裬�����æ����ֻ�����������ˣ���������Ȼ���ᳪ�裬����ͨ������������м��˿��Ե���������衣
-			5)����ģʽ��
-				�ٶ��壺
-					����ģʽ����������װ�㷨�ġ�
-					����ģʽ�������㷨���壬�ֱ��װ������������֮����Ի����滻����ģʽ���㷨�ı仯������Ӱ�쵽ʹ���㷨�Ŀͻ���
-				�ڸ�����
-					����ģʽ����Ϊ�ͻ����ֿ��������ฺ��ά�ֺͲ�ѯ��Ϊ�࣬�����㷨�ھ���IJ��������ṩ��
-					�����㷨�ͻ��������������㷨���������޸Ķ�����Ӱ�쵽�����Ϳͻ��ˡ�
-				�۲���ģʽ��Ӧ�ó�����
-					����ģʽ��������װ�㷨�ġ�
-					ֻҪ�ڲ�ͬʱ��Ӧ�ò�ͬ��ҵ����򣬾Ϳ��Կ����ò���ģʽ�������ֱ仯�Ŀ����ԡ�			
-			6)װ��ģʽ��
-				�ٸ��
-					װ��ģʽ�ԶԿͻ���͸���ķ�ʽ��չ����Ĺ��ܣ��Ǽ̳й�ϵ��һ������������ṩ�ȼ̳и��������ԡ�
-					��̬��һ���������ӹ��ܣ���Щ���ܿ����ٶ�̬�ij�����������һЩ�������ܵ�������϶������ķdz������Ĺ��ܡ�
-			7)������ģʽ�� 
-				�ٸ��
-					��һ����Ľӿ�ת���ɿͻ�ϣ��������һ���ӿڡ�������ģʽʹԭ�����ڽӿڲ����ݶ�����һ��������Щ�����һ������
-				��Ӧ�ó�����
-					������������������ͬ�������ƣ����Ǿ��в�ͬ�Ľӿ�ʱ�Ϳ��Կ���������ģʽ��
-			8)�۲���ģʽ��
-				�ٸ��
-					�۲���ģʽ������һ��һ�Զ��������ϵ���ö���۲��߶���ͬʱ����ij���������
-					������������״̬�����仯ʱ����֪ͨ���еĹ۲��ߣ�ʹ�����ܹ��Լ������Լ���
-					��������Ը��ݲ�������һ�����ʵ�ʵ�����ͻ��ˡ�
-				�ڸ���:
-					��ν֪��֪�˰�ս������
-			9)����ģʽ��
-				�ٸ��
-					�ⲿ��һ����ϵͳ��ͨ�ű���ͨ��һ��ͳһ�����������С�����ģʽ�ṩһ���߲�εĽӿڣ�ʹ����ϵͳ������ʹ�á�
-					ÿһ����ϵͳֻ��һ�������࣬���Ҵ�������ֻ��һ��ʵ����Ҳ����˵����һ������ģʽ��������ϵͳ�����ж�������ࡣ
-			10)���ԭ��
-				�ٵ�һְ��ԭ��
-					a�����
-						Ӧ�����ҽ���һ��ԭ��������ı��
-						���SRP��Single Responsibility Principle����д
-					b����һְ��ĺô���
-						��ĸ����Խ���
-						����ɶ��Ը�
-						���������
-						��������Σ�ս���
-				�������滻ԭ��
-					a�����
-						�������û���ĵط�������͸����ʹ��������Ķ���
-						ͨ�׵Ľ�����ֻҪ�����ܳ��ֵĵط���������Ϳ��Գ��֣����ҵ������໹�������κεĴ�����쳣��
-						���Ƿ������Ͳ����ˣ���������ֵĵط�������δ�ؾ�����Ӧ��
-					b�������滻ԭ���������˼��
-						���������ȫ��ʵ�ָ���ķ���
-						����������Լ��ĸ���
-						���ǻ���ʵ�ָ���ķ���ʱ����������Ա��Ŵ�
-						���ǻ���ʵ�ָ���ķ���ʱ���������Ա���С
-				����������ԭ��
-					a�����
-						Dependence Inversion Principle
-						�������ÿ���˵�����������Ƶı�ǣ����������Ա�д���򲢲���Ҫ�������дʱ���ǵĶ��������Գ����̶��������ϸ�ڱ��
-						�����������е�������ϵ����ֹ�ڳ�����߽ӿڣ��Ǿ������������ƣ���֮���ǹ��̻�������ˡ�
-				�ܽӿڸ���ԭ��(Interface Segregation Principle)��
-					a�����
-						��һ�ֶ��壺
-							�ͻ��˲�Ӧ�������������õĽӿ�
-						�ڶ��ֶ��壺
-							����������ϵӦ�ý�������С�Ľӿ���
-							ͨ�׵Ľ������ǽӿھ���ϸ����ͬʱ�ӿ��еķ����������١�
-					b���ӿڸ���������IJ���˼��
-						�ӿ�Ҫ����С
-						�ӿ�Ҫ���ھۣ�
-							���ھ۾�����߽ӿڡ��ࡢģ��Ĵ������������ٶ���Ľ���
-						���Ʒ���
-						�ӿ���������޶ȵ�
-						һ���ӿ�ֻ������һ����ģ�����ҵ���߼�
-				�ݵ����ط���(Low Of Demeter)��
-					a�����
-						Ҳ������֪ʶԭ��
-						ͨ�׵Ľ�һ������Լ���Ҫ��ϻ��ߵ��õ���Ӧ��֪�������٣������ڲ�����ô���ӡ���ô�ľ������嶼����û��ϵ��
-							����������ڲ������飬�Ҿ�֪�����ṩ����ô��public�������Ҿ͵������
-					b�������ط�����IJ���˼��
-						ֻ�����ѽ�����
-							�����ڳ�Ա������������������������е��౻��Ϊ��Ա������
-						���Ѽ�Ҳ���о���ģ�
-							�����ط����Ҫ����"С��"һ�㣬������Ҫ���⹫��̫���public�����ͷǾ�̬��public����������������
-							��ʹ��private,package-private��protected�ȷ���Ȩ��
-						���Լ��ľ����Լ���:
-							���һ���������ڱ����У�������������ϵ��Ҳ�Ա��಻��������Ӱ�죬�ͷ����ڱ�����
-						����ʹ��Serializable
-				�޿���ԭ��(Open Close Principle)��
-					a�����
-						����ʵ��Ӧ�ö���չ���ţ����޸Ĺرգ��京����˵һ������ʵ��Ӧ��ͨ����չ��ʵ�ֱ仯��������ͨ���޸����еĴ�����ʵ�ֱ仯
-						����ʵ�壺
-							��Ŀ��������Ʒ�а���һ�����߼����򻮷ֵ�ģ��
-							����ӿڻ���
-							����
-					b��ΪʲôҪ�ÿ���ԭ��
-						����ԭ�����������ԭ��
-						����ԭ��dz���Ҫ��
-							����ԭ��Բ��Ե�Ӱ��
-							����ԭ�������߸�����
-							����ԭ�������߿�ά����
-							������󿪷���Ҫ��
-					c�����ʹ�ÿ���ԭ��
-						����Լ��
-						��������ģ����Ϊ
-						�ƶ���Ŀ�³�
-						��װ�仯
-	(13)html5��PhoneGAP��ܣ�
-	
-	
-	
-	(14)�ص�������
-		�ٻص������ĸ���:
-			�ص�����������Щ�Լ�д�ģ����Dz����Լ������ã���������Ҫ��ʱ������������õĺ�����������Ϣ��Ӧ������
-			�����ɶ����ʱ�򣬲����ö���ķ���������Ϊ����������ȥ������Ҫ�ٵ��á�
-	(15)UML���ԣ�
-		��UML���ã�
-			�����˲�ͬ��ģ����֮��IJ���
-			�ṩ��һ���ͻ������� �������ܹ���ơ�����ʵ�ֺ���ά������֮�乲ͬ����������
-			����������Ŀ���ʵ���ɹ��;���
-		��UML���ࣺ
-			��̬ͼ��
-				��ͼ(��֮��Ĺ�ϵ��������������ʵ�ֺ͹���(�����ַ�Ϊ�ۺϺ����))
-				����ͼ
-				��ͼ
-			��Ϊͼ��
-				�ͼ
-				״̬ͼ
-			����ͼ��
-				����ͼ(����֮��Ĺ�ϵ����������������չ)
-			����ͼ��	
-				˳��ͼ
-				Э��ͼ
-			ʵ��ͼ��		
-				���ͼ
-				����ͼ
-		��UML�Ľ�ģ���ߣ�
-			Rose:
-			Visio:
-			Power Designer:	
-		��OO���ԭ��
-			����ԭ��
-			���ϴ���ԭ��
-			��������ԭ��
-			�ӿڷ���ԭ��
-	(16)�������
-		1)������
-			��������������������̶��Եģ��������ǿ�����ǹ��ܣ��������ǿ�����ǽ����ܷ�װ������ǿ���߱����ܵĶ���
-		2)˼���ص�ô���
-			 A:�Ƿ�������˼��ϰ�ߵ�һ��˼�룻
-			 B:�����ӵ�����򵥻��ˣ�
-			 C:������Ա��ִ���߱����ָ���ߣ�
-			 ע��
-				������Ҫ�ﵽij�ֽ����Ҫ����ij�����ܣ��Ҿ�Ѱ���ܰ��Ҵﵽ�ý���Ĺ��ܵĶ�������ö���߱��˸ù���
-				��ô���õ��ö���Ҳ�Ϳ���ʹ�øö���Ĺ��ܡ�����Ҫϴ�·��Ҿ���ϴ�»���������ôϴ�Ҳ��ܡ�		 
-		3)������
-			��װ�����ض�������Ժ�ʵ��ϸ�ڣ��������ṩ�������ʷ�ʽ
-			�̳�: ������д�����ͬ���Ժ���Ϊʱ������Щ���ݳ�ȡ������һ�����У���ô����������ٶ���
-				  ��Щ���Ժ���Ϊ��ֻҪ�̳��Ǹ��༴�ɡ�
-			��̬: һ�������ڳ���ͬ����ʱ�̴����Ķ���״̬��������߽ӿڵ�����ָ���������
-		4)���������Ƶ���Ҫ���飺
-			˭ӵ�����ݣ�˭�Ͷ����ṩ������Щ���ݵķ�����
-			�磺
-				���ںڰ��ϻ�Բ��
-					��Բ��Ҫ֪��Բ�ĵ�λ�ú�Բ�İ뾶����Բ�ĵ�λ�ú�Բ�İ뾶ֻ��Բ�Լ�����������Ի�Բ�ķ�����Բ�ķ����� 
-				�г�˾������ɲ����
-					ɲ���ķ�����˾���Ļ��dz����أ�ͬ��������ɲ���Ķ�������ôɲ��ֻ�г�������ģ���ֻ�Ƿ���ɲ�����źŸ���������ɲ���ķ����dz���
-			�������������⣺
-				����ʯͷĥ��һ��ʯ����ʯ�����Խ�������ľ�ģ�ľ�Ŀ����������ӣ�
-					ʯͷĥ��ʯ�����ĸ�����ķ����أ������ʯͷ�ڲ��ķ����Ļ�����ôʯͷĥ��ʯ����ʯͷ�Լ���û�ˣ�
-						����ʯͷĥ��ʯ������ʯͷ�ڲ��ķ�������ʯͷ���ʯ��Ӧ����һ��ʯͷ�ӹ����ķ�������ʯͷĥ��ʯ����
-					ʯ����������ľ�ģ�����ʯ��Ӧ����һ����������ľ�ĵķ���
-					ľ�Ŀ����������ӣ�����Ӧ����һ��ľ�ļӹ������üӹ�����һ������ľ��Ȼ��ӹ������ӵķ�����
-				���һ�����ӵ�һ���ƶ�����һ�ˣ�
-					���������Ӧ�����ƶ�����һ����ķ���
-					�����������Ӧ�����ṩ�¸������ĸ���ķ�������֪ͨС���ƶ��ķ���			
-	(18)Android�Ĵ������
-		1)
-		2)Service��
-			�ٷ�������ֿ�����ʽ��
-				a��startService��
-					�ص㣺
-						����һ���������ͻ��ں�̨��������
-						����Ŀ����߸�����ûʲô��ϵ
-				b��bindService��
-					�ص㣺
-						�����߹��ˣ�����Ҳ���Źҡ�������ͬ��������ͬ����
-					ע��ͨ��bindService�����ķ�������һ��Ҫ��unbindService��destroy������ᱨ�쳣��
-		3)
-		4)
-	(19)�����Ż���
-		1)�����Ż�ԭ��:
-			��ʱ�任ʱ�䣺
-				����õ��Ե�һЩ���������ͨ��������Щû��Ҫ���������ʱ��Ӷ���ʡ����ʱ��
-				����վ���������ݵķ�����ȡ��AJAX����
-			��ʱ�任�ռ䣺
-				�翽���ļ�ʱnewһ���ֽ����鵱����������byte[] buffer = new byte[1024]��
-				Ϊʲôֻnewһ��1024���ֽڵ������أ�newһ��������ֽ����鲻��һ�¾Ͱ��ļ���������ô����ô������Ϊ������ʱ���ʡ���޵��ڴ�ռ�
-			�ۿռ任ʱ�䣺
-				����Windowsϵͳ�Դ��������ļ��Ĺ��������ļ�ʱ�����������������������Ӳ�̿ռ䰲װһ��everything�����������ļ����ر��
-			�ܿؼ����ռ䣺
-				�������ڴ�
-	(20)�ֻ���λ����ͼ��
-		1)Android�ֻ���λ�����ַ�ʽ��
-			�ٻ�վ��λ��	
-				�����ֻ������͸����Ļ�վ��ͨ���ֻ��źŵ�ǿ������λ�ֻ���
-				�������ֶ�λ��ʽ�ľ�ȷ�ȸ��ֻ����վ��Զ���Լ��ֻ�������վ���ܼ��̶��й�ϵ��
-				����Ϊ20��-2000�ײ��ȡ�
-			��wifi��λ(Ҳ�����綨λ)��
-				���ֻ����������ʱ�򣬻ᶯ̬��ȡһ��ip��ַ����Ӫ�̻���ip��ʵ��λ����һ��һһ��Ӧ��ϵ������ͨ��ip��ַҲ���Զ�λ�ֻ���
-				����Google��˾�Ĺȸ��ݺᡣ
-				��Ϊ�ֻ���ȡ����ip������Ӫ�̸����ֻ�����λ�ö�̬�����ip���������ַ�ʽ�����ֻ���λ�ľ�ȷ�ȱȽϲ��ȷ��Ϊ200��+
-			��GPS���
-				�ֻ������Դ�һ���Ƚϱ��˵ķ�רҵ��A-GPSģ�飬ͨ����ѵĹⲨ�ķ�ʽ�����ǽ���ͨ�š�
-				��Ϊ��ͨ���Ⲩ�ķ�ʽ�����Ծ�Ҫ��ͷ������տ���
-				�������ϱȽ�רҵ��GPS�豸��������ź�һЩ�Ŵ�����棬�����ֻ���λҲ�ͱȽϲ������ƺ;�ȷ��
-				��ȷ�ȸ�GPSģ��ľ����йأ�ͨ��Ϊ2��-10�ס�
-		2)Google Map��
-			�ٻ�ȡGoogle Map API��Key��
-				Ϊ����Ӧ�ó����е���Google Map�������Ȼ�ȡGoogle Map API��Key��
-			�ڰ�װGoogle Map API�����
-				Android SDKĬ�ϲ���֧��Google Map��Ϊ�˵õ�֧��Google Map��SDK������ΪAndroid SDK������Ӧ�IJ����AVD��
-			�۴���֧��Google Map API�������豸��
-				ΪAndroid SDK��װGoogle Map API����󣬻���Ҫ����һ��֧��Google Map API�������豸��
-			��Google Map API��
-				a��MapView��
-					Ϊ����Androidƽ̨�ϵ���Google Map����Google Map�ṩ��һ��MapView��
-						���MapView���÷�������ͨ��ImageViewһ����ֱ���ڽ��沼���ļ��ж�������Ȼ���ڳ����п��Ƹ�������ɡ�
-				b��MapController��
-					ͨ��MapView.getController()�ɻ�ȡMapController����
-						MapController�ɶ�MapView���п��ƣ�������Ƶ�ͼ��λ��ָ��λ�û��ߵ�ͼ�Ŵ���С��
-				c��Overlay��
-					ͨ��MapView.getOverlay()�ɻ�ȡOverlay����
-						Overlay�Ǹ�����Google Map�ϵĸ���ͼƬ��Ӧ�ÿ��Կ�����Google Map������������Overlay
-				d��GeoPoint��
-					GeoPoint���ʾGoogle Map�ϵ�ָ����
-						GeoPoint���ǶԾ��Ⱥ�γ�ȵķ�װ
-			��ʹ��Google Map API��λ�IJ��裺
-				a����ȡMapView��Ӧ��MapController����
-				b�����ݾ��ȡ�γ��ֵ����GeoPoint����
-				c������MapView�ؼ���������MapController�����animateTo(GeoPoint point)������λ��ָ��λ��
-				ע�⣺
-					�ڲ����ļ�������MapViewҪͨ������.�����ķ�ʽ
-					�ڲ����ļ��ж���MapView����Ҫ����android:apiKey����ֵΪ�������뵽��Key
-			��GPS������
-				��GPS������Google Map�������ʹ�ã����Էdz�����Ŀ�����GPS����Ӧ��
-				a��ͨ��Context.getSystemService(Context.LOCATION_SERVICE)������ȡLocationManager����
-				b��ͨ��LocationManager����ÿ��һ��ʱ���ȡGPS��λ��Ϣ
-				c������LocationManager����ÿ��һ��ʱ���ȡ��GPS��λ��Ϣ��ͨ��MapView����ͼ��λ��ָ��λ��
-			�߸��ݵ�ַ��λ��
-				Google Map����ͨ�����Ⱥ�γ�������ж�λ������ͨ�û������ܼ�סij��λ�õľ��Ⱥ�γ�ȣ�
-					���Զ���ͨ�û���˵���ݵ�ַ��λ�����м�ֵ�ĵ�ͼӦ��
-					Ϊ�ˣ���Ҫ������������������
-						a����ַ������
-							���ַ�����ַת��Ϊ����γ��
-						b�������ַ������
-							�Ѿ���γ��ת��Ϊ�ַ�����ַ
-				AndroidΪ��ַ�����ṩ��Geocoder�����࣬�ù������ṩ���������������е�ַ�����ͷ����ַ����
-					a��List<Address> getFromLocation(double latitude, double longtitude, int maxResults)
-						ִ�е�ַ�������Ѿ���γ��ֵת��Ϊ�ַ�����ַ
-					b��List<Address> getFromLocationName(String locationName, int maxResults)
-						ִ�з����ַ���������ַ�����ַת��Ϊ����γ��ֵ
-		3)��������ϵͳ��
-			�����ھ��������GPS��ȡ���ľ��Ⱥ�γ�ȶ������������ǣ����ǹ���Ҳ�б������ǣ���������û�����á�
-				ͨ���������ǻ�ȡ���ľ���γ���ǹ��ʱ�׼�ľ���γ��;
-				�����ʱ�׼�ľ�γ�����й���ͼ����ʾ��λ���Dz�׼ȷ��;
-				Ϊ���ù��ʱ�׼�ľ�γ�����й���ͼ�ϻ�ȡ��׼ȷ��λ�ã���Ҫ�ѹ��ʱ�׼�ľ�γ��ת�����й��Ļ�������
-					���ܻ�ȡ��׼ȷ��λ��		
-	(21)JDK1.5�����ԣ�
-	(22)�������ƣ�
-		1)�ֻ��˵�ͨ��������
-			��WLAN(wi-fi)��	���߾�����
-				Wi-fi�����߾�������õ�һ�����߼�����wi-fi�������������ip����һ�����ݰ���UDP��  
-				���Ƿ�Χ��100������
-			���ֻ�APN(Access Point Name)�������
-				a����վ
-					���Ƿ�Χ��1-1.5����
-				b��Wap��ʽ������
-					������û�еģ����ַ�ʽ���й����еģ����е����ԡ�
-					Wap��ip�Ͷ˿ڣ�
-						ip��10.0.0.172
-						�˿ڣ�80
-					Wapͨ�Ż��ƣ�
-						�ֻ��˵�����������Դ���Ⱦ���Wap��Wap�ٽ�����ת��������Դ
-					Wap���ã�
-						���м���ṩ��ֵҵ��
-				c��Net��ʽ��
-					Netͨ�Ż��ƣ�
-						�ֻ�������������Դֱ�����ӵ���·��Դ·��������Ҫͨ���κ��м�ӿ�
-		2)�ֻ��˺ͷ�����ͨ�ŵķ�ʽ��
-			��Socket��
-				���磺�㶹��(USB��WIFI)�����칤�ߵ�
-				USB���ӣ�
-					���ֻ�ͨ��USB����PC��ʱ����ȡ�����ֻ����豸PID��VID����Ϣ��Ȼ�����ֻ�������
-						�����������û��װ�����Զ����㰲װ����������Ѱ�װ���ٰ�װ��
-						��װ���ֻ��������ͨ��Socketָ��һ���˿ڶ�ȡ�ֻ���Ϣ
-				wi-fi���ӣ�
-					PC��Ӧ�û�������������е�ipͨ��UDP����һ�����ݰ�
-				����ʵʱ�����ϸ�ʱҲ���õ�Socketͨ�ţ�
-					ͨ��Socketдһ�������ӣ�ÿ��һ��ʱ����������������ݰ���
-						������ݰ���Ϊ���������ʱ��ͨ��Ϊ30��
-					�����Ʊ���ס�������Ľ���Ӧ�õȶ���ʵʱ����������������
-			��HttpUrlConnectioon��
-				��������Ϊһ��������
-			��HttpClient��
-				HttpClient��һ����Դ���
-				���ã�
-					����ͷ��������н���������(Wap)����ʱ�ĵ��������
-						���籱�����Ϻ�������(Wap)���в���ģ����ͨ��Wap����ͨ�ţ��ڱ���������Ӧ�ã��õ��Ϻ�ȥ�û��������
-							����10�����磬���ܲųɹ�3��4�Ρ�
-		3)��д�ֻ������ӹ���֮ǰ��׼��������
-			���ж��ֻ���ǰ���������ͣ�
-				�ж���WiFi���뻹��APN����
-					�����APN��������Ҫ�����ر���������Ҫ����APN����Ϣ(��ȡ�ֻ���ǰ���ڻ״̬��APN��ip�Ͷ˿�)
-	(23)�������ԣ�
-		��monkey���ԣ�
-			Android�Դ��IJ��Թ���
-		��testing��
-			�ṩ�ܶ���Թ���
-		�۰ٶȲ������ģ�
-	(24)�����ڲ�ͬ��Ļ���ֻ��ϵ����䣻
-		1)��Ļ����ԭ��
-			�ٿ���ʱ��λ��������dip����dp��λ
-			�ڶ��岼��ʱ����������Բ��ֻ������Բ��ֻ���֡����
-			�۵���Ļ��С�������ݹ���ʱ����ScrollView�ؼ������������ļ����а���
-			�ܵ�9ͼƬ
-			����AndroidManifest.xml�ļ���<manifest>Ԫ������������Ԫ��
-				<supports-screens 
-					android:largeScreens="true"
-					android:normalScreens="true" android:anyDensity="true"
-					android:smallScreens="true">
-				</supports-screens>			
-	(25)MVC����ģʽ��
-	(26)�������Ź���
-		A.������̳�BroadcastReceiver
-		B.���嵥������<receiver>
-			<action>��nameֵΪ:android.provider.Telephony.SMS_RECEIVED
-			Ȩ��permission-->android.permission.RECEIVE_SMS
-		C.��onReceive(context,intent)�л�ȡ����
-			Bundle bundle = intent.getExtras();
-			/*
-			 * Set<String> set = bundle.keySet(); for(String str : set)
-			 * System.out.println(str); �õ�bundle�е��ֶ�--->pdus
-			 */
-			Object[] objs = (Object[]) bundle.get("pdus");//����һ��Object[]����
-			for (Object obj : objs) {
-				//ÿ��һ��obj��������һ��byte[]����
-				 SmsMessage sms = SmsMessage.createFromPdu((byte[]) obj);
-				"��������:"+sms.getMessageBody()
-				"������:"+sms.getOriginatingAddress()
-				"���������:"+sms.getServiceCenterAddress()
-					Date date = new Date(sms.getTimestampMillis());
-				"ʱ��:"+new SimpleDateFormat("yyyy��MM��dd�� HHʱmm��ss��").format(date)
-			}
-		D.���ݲ�ͬ����,���Ž��й���,��δ�ܸ���,������Ϣ��װ���ݺ��鷳,ֻ��abortBroadcast();
-1���Զ���ؼ���Ŀ
-	(1)SplashActivity:
-		1)Splash�����ã�
-			��ʵ�ʿ�����Splash������һ��չ�ֲ�Ʒ��logo��������Ʒ��֪����
-			��Splash�ĵڶ��������ǿ��Ը��ݲ�ͬ�����ں�ʱ�䣬չ�ֲ�ͬ�Ľ��棬�������˽ڰ桢�����ȣ������û�����
-				(��˳����һ���û����������ڳ��ñȽϻ��һ������κ�һ����վ�κ�һ����������˵Ҫ����û����飬
-				��������С�Ĺ�˾����UI����ʦ����Ĺ�˾����UE����ʦ)
-			��Splash�ĵ����������ǿ���������ɳ���ij�ʼ�����������ݿ�ij�ʼ�����ļ����õĿ����Ͷ�ȡ�Ȳ���
-			��Splash�����Խ��м�����硢����������������򻺴�·�������SDCard�Ƿ�����Լ���־�Ȳ�����
-		2)������
-			�ո�Splash����Ļ���˶����͵���ʱ�Ķ�������֡������
-			�ڽ���һ���ص�ʱ��������ö�����Ҫע��˴���������������ͨ���ؼ�.startAnimation�ķ�ʽ��������Ϊ��ʱ֡���������ͼƬ��Դ��û������ɣ�
-				��ͨ���ؼ�.post�ķ�ʽ������һ�����̣߳������߳���ͨ������.start�ķ�������������
-	(2)HomeActivity��
-		1)������
-			������������(android:ellipsize="marquee")��
-				a������������Ч����Ӧ�ó�����
-					�ڿռ�Ƚ����޶���Ҫչʾ��������Ϣ�Ƚ϶�ʱ���Ϳ��Կ��Dz���������Ч����չʾ
-				b������������Ч����ʵ�֣�
-					ͨ���Զ���ؼ��̳�TextView��ʵ�����ֵ�������Ч����
-					ʵ������������Ч����ǰ���Ǹÿؼ������ȡ���㣬��Ĭ����������е�TextView�ǻ�ȡ���������
-						��������Ҫ�ڼ̳�TextView���Զ���ؼ���дisFocused���������ҷ���true�������Ŀռ�Ϳ��Ի�ȡ���㣬
-						Ҳ�Ϳ����ڽ���һ���ص�ʱ��ʵ��������Ч��
-			�ڽ��沼�֣�
-				Home������ؼ���չʾͨ��GridView��ʵ�֡����ǿ�������ʾ������õ�һ���ؼ�����ListView����ʵGridView��ListView����
-					�̳���ͬһ������AbsListView���������ǵ��÷���࣬����ͨ�����ÿؼ�������������ʵ�����ݵ���ʾ
-			�۵ײ��˵�����
-				����ײ��˵������ǰǵ����ڵ��ſ��ֻ��˵�ʵ��Ч�����Ҿ������ֲ˵��Ƚ��ţ����Ծ��Լ�ʵ������
-				ʵ������Ҳ�Ƚϼ򵥣�����ͨ����Բ��ֵķ�ʽ��ʵ�֣���Ҫ�Ƕ�����ʵ�ֺ͵���¼��Ĵ�����
-				������һ����ת����������¼�����һЩ�򵥵��߼��жϺͿռ����ʾ�����ؿ���
-			�ܵ��GridViewѡ��Ķ���������
-				ͨ��overridePendingTransition��ʵ�ֽ����л�ʱ�Ķ���Ч��
-				������Ķ��������Ŷ���(Scale)�����ij��ѡ��ʱ���ɵĽ�����С����ѡ���λ�ã��µĽ����ٴӸ�ѡ���λ�÷Ŵ���Ļ��С
-	(3)ImageView��
-		1)��Ŀ��֪ʶ�������
-			���ImageViewģ����Ҫ������չʾͼƬ��һЩ�ؼ���
-			��ViewPager��
-				a��ViewPager������
-					��������������ͨ��ViewPagerʵ�ֵġ�
-					ViewPager��һ����������ǩ����android_support-v4.jar���У�ʹ�õ�ʱ����Ҫͨ������.�����ķ�ʽ���롣
-					ͨ����ViewPager����PagerAdapter����дPagerAdapter��instantiateItem������ʵ����Ҫ��ʵ��ͼƬ��destroyItem����ȥ��ͼƬ��
-					ViewPager�ؼ�������Galleryһ��һ�λ�������ͼƬ��ViewPagerһ��ֻ�ܻ���һ��ͼƬ��ΪʲôViewPagerֻ�ܻ���һ��ͼƬ�أ�
-						��ΪViewPager��ʾ��ʱ��ֻ��������ͼƬ������ǰ��ʾ��ͼƬ����ǰ��ʾͼƬ��ǰһ��ͼƬ�ͺ�һ��ͼƬ��
-				b�����ʵ��ViewPager��ͼƬ�Զ�������
-					ÿ��2���ӣ�ViewPager�ؼ������ͼƬ���Զ��л�����һ��ͼƬ�����л������һ��ͼƬʱ���л��ص�һ��ͼƬ��
-						�����ͨ����ʱ��Timer�����̳߳�ִ����ScheduledExecutorService��ʵ��ViewPger�ؼ�ͼƬ���Զ��л���
-						���ǣ�Timer����һЩbug��Timer�Ե��ȵ�֧���ǻ��ھ���ʱ�䣬���������ʱ��ģ��ɴ������ϵͳʱ�ӵĸı������е�;
-						��ScheduledThreadExecutorֻ֧�����ʱ�䡣��������Timer��ʱ��ÿ�������ִ��һ������������������
-						��ȥ�޸ĵ�ǰϵͳ��ʱ�ӣ���ʱ�ͻ�Ե�ǰ����ִ�е��������Ӱ�졣
-						����ScheduledExecutorService�ĵĻ������������������޸�ϵͳʱ���������û��Ӱ��ġ�
-						������JDK1.5�Ժ���𽥲���Timer�ˣ������ж���ScheduledExecutorService��	
-				c�����ʵ��ViewPager�����ֺ͵�����ͼƬ�Ļ����仯��
-					��ViePager�ؼ���ͼƬ�Զ��л������ֶ��л�ʱ�����е�������Ϣ�͵�״̬����֮�ı䡣
-						����ͨ����ViewPager����ͼƬ�ı��¼���������ʵ�֡�
-						��OnPageChangeListener������ViewPager��ʾ��ͼƬ�ı�ʱ�������onPageSelected���������ǿ����ڸ÷�������ʵ�֡�
-						��ʵ�ֹ�����Ҫһ����������¼��һ��ViewPager��ʾ��ͼƬ��λ��position��
-			��ScrollView��
-				a��ScrollView�ĸ�����
-					�����ĵ�ѡ������RadioGroupʵ�ֵġ���������ص�ʱ�����Ҫ��ʾ��ͼƬ����̬�Ĵ������Ӧ��Ŀ��RadioButton��
-					ͼƬ����ʾʱͨ���Զ���ؼ��̳�ViewGroup��ʵ�ֵġ�
-						ͨ����дViewGroup��onLayout�����view��ViewGroup�еIJ�����ʾ��
-							onLayout����ʵ��ViewGroup����View������С�
-							����Ҫ֪��ViewGroup����View�������ʱϵͳ���Զ����ô˷���
-						��дViewGroup��onTouchEvent()�������������¼���������ʶ����GestureDetector������
-							����ʶ������ʶ�����ĸ������ƣ���������¡����������������ٻ����ȡ�
-							ͨ����дGestureDetector��onScroll()����ʵ�ֻ��������͸�дonFling()����ʵ�ֿ��ٻ���ʱ�л�ͼƬ
-								���������ɿ���ָʱ���жϵ�ǰ����ͼƬ������Ļ���е㣬��ͨ��View.scrollBy(dx, dy)
-									����Scroller.startScroll(startX, startY, dx, dy)��������ͼƬ�ƶ�����Ļ����ʾ��
-									������invalidate()�������½���
-								���ٻ����ɿ���ָʱ���жϻ������ٶȺͼ��ٶȷ����ٽ���ǰ��ʾ��ͼƬ�л�����һ��ͼƬ
-									������invalidate()�������½���
-						����ڼ̳�ViewGroup���Զ���ؼ����ṩһ��������������ViewGroup��ʾͼƬ�ĸı䡣
-							����ʵ��ͼƬ�ı�ʱ��RadioGroup�����Ӧ��RadioButton��״̬���ѡ�С�
-			��Gallery��
-				a��Gallery������
-					ͼƬ�Ļ���+��ӰЧ��ʵ����������΢�����ˣ���Ҫ��API�Ƚ϶࣬��Ҫ�����Camera����ת����Transformation�;���Matrix
-						��ʵ��ͼƬ�ı�����ʾ����ҪBitmap������Canvas������Paint��API��ʵ�ֵ�ӰͼƬ�����ɡ�
-						������Ҫ�������߼�Ҳ��΢��һ�㡣
-					������Ҫ��ʾͼƬ�Ļ���׼���ã�
-						�Զ���ؼ��̳�Gallery��
-							�ڸü̳�Gallery���Զ���ؼ��и�дgetChildStaticTransformation�������÷�����Gallery�е�ͼƬ��ʾ״̬�����ı�ʱ�����ã�
-								�ڸ÷��������ǿ��Ը���ͼƬ��ʾ��λ�ü������ͼƬ��Galery����ʾ����תλ�ã�
-							ͬʱ�ü̳�Gallery���Զ���ؼ�Ӧ�û���һ������ͼƬ����Gallery��ʾͼƬ�����ĵ�λ�ò�ͬ����Gallery��
-								ͼƬ��ʾ�Ĵ�С���Ƕȡ����ȵ���Ϣ�ķ���
-					����׼�����ˣ�����������׼��������Ҫ��ʾ��ͼƬ��
-						�Զ����������̳�BaseAdapter��
-							�ü̳�BaseAdapter���Զ���ؼ��ṩһ�����ɵ�ӰͼƬ�ķ�����
-								�ڸ�������ӰͼƬ�ķ����У�����ԴͼƬ�͵�ӰͼƬ�ļ��������Ч��������Ч����ȥ��ͼƬ��ݵȲ���
-					���Ⱥ͵�ӰͼƬ��׼���ú󣬽������͸����������Զ������������OK��				
-			��WaterFall��
-				a��ͼƬ�ٲ���������
-					ͼƬ�ٲ�����Ҫ������ͼƬ��Դ����Ҳ��������Զ���ؼ���ʮ���׵�ԭ��֮һ��
-					��ЩͼƬ��Դ��Ϊ�Ƚϴ����Դ�����ʲ�assetsĿ¼�µġ�ΪʲôҪ������ʲ�Ŀ¼�¶����Ǵ����resĿ¼���أ�
-						��Ϊ�����res�µ�Ŀ¼�µ���Դ���ᱻ��Ը���������룬������Դ���ã�����Դ�ļ��Ƚϴ�ʱ����ͱȽ��鷳��
-						������assetsĿ¼�µ���Դ��ԭ�ⲻ���Ŀ�����.apk�ļ��С�
-	(3)Dialog��
-		1)Dialog������
-			DialogҲ��һ��Ӧ�÷dz��㷺�Ŀؼ����������е�Ӧ�ö��õ�����ؼ���
-			��Android�����У�֪ͨ�û��ķ�ʽ�����֣�һ������˾֪ͨ��һ����״̬��֪ͨ������һ�־���������õĶԻ���֪ͨ��
-				���Ի���֪ͨ�ַ�Ϊ��ѡ�Ի��򡢶�ѡ�Ի����б��Ի��򡢽��ȶԻ���ȡ�	
-			�����������ַ������ͨ��AlertDialog���ڲ���Builder��ʵ�ֵģ��Ƚϼ򵥣�ֻҪ��ѡ���ַ��һЩ�߼������͵�ַ�ռ����ʾ���ء�
-			�û���¼������ģ�µ�QQ��½ʵ�ֵġ�ͨ������ұߵ�����ͼ�굯������Ϊһ��ListView��PopupWindow��
-				�������PopupWindow��ô����Ҫ����Ϊ������Dialog�����Ե�ʣ���Ϊ����Dialog���棬����PopupWindow�ĸ߶Ⱦͱ������ˡ�
-				�������������ѵ�½����Ū��һ��Activity�����ˣ����������Ϊ����ʾһ�£�ʵ�ʿ����в���Ū��ô��ô����ô���PopupWindow��
-	(4)ProgressBar��
-		1)ProgressBar������
-			���Զ���ˮƽ��������
-				��ΪϵͳĬ�ϵĽ�����ͦ�ѿ��ģ���������Ľ��������Զ���ϵͳ��ˮƽ��������
-				ͨ���鿴Android SDK��ԴĿ¼res�µ�values�ļ����е�styles.xml�ļ������ļ�������Androidϵͳ���еĿؼ���Ԥ����ʽ��
-				�ڸ��ļ������ҵ�����ˮƽ����������ʽ�Ķ��壬���Ų鿴ϵͳprogress_horizontal.xml�ļ���
-				ֱ�ӿ���progress_horizontal.xml����������޸ģ��Ϳ���ʵ�������Զ����ˮƽ����������ʽ�ˡ�
-			�ڲ����ļ�ɨ�趯����
-				���ɨ�趯����һ����ת����������������������ٵģ��������Ч����ԭ����Ҫ���ɶ�����Ч�������ģ�
-					��Ϊ��������Ĭ�ϵIJ����������ȿ������
-				�����ȥʵ�����ٵ�Ч��Ҳ�Ƚ����ף����ǿ�����ˮƽ������ûɨ��һ����Ŀ������ת��ʮ�Ȼ�����ʮ����ʵ�����ٵ�Ч����
-			�ڲ����ļ���ɨ�裺
-				���ڲ���������ɨ�裬ʵ������Ҳ�Ƚϼ򵥡�
-				ɱ��������ԭ����
-					ɱ��������ԭ�����DZȶ��ļ��������롣
-					��ν��ɱ��������ʵ����һ���ļ��������Ϊʲô���ļ�������أ���Ϊ��������һ��Ӧ�ó���Ҳ����һ���ļ���
-					��ʲô�Dz����أ���Ҫ������ôȥ�����ˣ���νˮ���������ܸ��ۣ�һ��������
-						���һ�������������ںõķ��棬����һ����������������ڻ��ķ��棬����һ��������
-					��ν����ɨ�裬���Ǹ����ļ���������ȥ�ȶԲ������ݿ⡣
-		2)SeekBar������
-			�����ʾ�Ϳ��������Ŀؼ���ͨ���Զ���ؼ��̳�View��ʵ�ֵġ�Ҳ����������ֱ��SeekBar��ʵ�֣���ֱ��SeekBarʵ���������򵥡�
-			�ü̳�View���Զ���ؼ�ͨ����дView��onDraw�������Լ���������ͨ������ͼƬ��һ�ű�ʾ��������ɫ��Ŀ��һ�ű�ʾ�����Ļ�ɫ��Ŀ
-				onDraw�������ݵ�ǰ�����ֱ𽫱�ʾ��������ɫ���ֺͲ���ʾ�����Ļ�ɫ���ֻ�����
-			�ü̳�View���Զ���ؼ����ṩһ�������ӿں������ı������������ʵ�������ı�ʱ�ı�ؼ��Ľ���
-	(5)ListView��
-		1)ListView������
-			ListView����������ʾ���ݡ�����˵���ǿ����У�Ӧ�õ����ݴ󲿷ֶ���ͨ��ListView����ʾ��
-				���罻��Ӧ�ú��ѵ���ʾ����������Ӧ��������Ϣ����ʾ������ý����Ӧ�ö�ý���ļ�����ʾ������ͨ��ListView����ʾ��
-					��ʾ����
-			ListView�����?
-				����Ҫ��ListView����һ��������Adapter����Ҫ��ʾ�����ݽ���������Adapterȥ������
-				����ListView��getView����ÿ������һ����ʾһ����Ŀ����������һ���ɵ���Ŀ���Ƴ�����Ϊ���Ż�ListView��
-					������getView()���������þ���ĿconvertView
-				����ListView��getView������ÿִ��һ��findViewById����ʱ�����������Ӧ���ֵ���״�ṹ���ٱ�������״�ṹ�ҵ�ָ��id��
-					���ò��ֵ���״�ṹ�ܸ���ʱ��ÿ�ζ�����id��Ƚ��鷳������Ϊ���Ż����ǿ����ṩһ��ViewHolder�࣬
-					������¼�����е����пؼ������������еĿؼ�idֻ�����һ�Σ�����ʱ��ֱ����ViewHolder������ȡ
-				�����ListView��ʾ������ʱ������Ҫ���з������ػ��ҳ��ʾ����
-		2)����ˢ��:
-			�������ˢ�¿ؼ���ͨ���Զ���ؼ��̳�ListViewʵ�ֵģ�ͨ��ListView.addHeaderView������ͷ������ˢ�µ�������ӵ�ListView��
-				���������ļ���ʱ����ͨ������.�����ķ�ʽ�����Զ���ؼ���
-			����ͷ������ˢ�����������ˢ�¼�ͷ��ָ�������ˢ��������Ϣ�ĸ���ͨ�����������¼���ʵ�֣�
-				��ListView��ʾ�ĵ�һ����Ŀ��λ��Ϊ0������ָ����ĻY�᷽�����ƶ�ʱ������ˢ��������������״̬�������ˢ��״̬��
-				����ָ��������Ļ���ƶ���Y���λ�ƴ�������ˢ�������һ��ʱ������ˢ�������״̬������ˢ�±�Ϊ�ɿ�ˢ��״̬
-				���ɿ���ָʱ������ˢ�������״̬���ɿ�ˢ�±������ˢ��
-				������ˢ����ɺ�����ˢ�������״̬�ͱ��Ĭ�ϵ��������״̬
-		3)������ҳ������
-			
-2�����ܶ��ŷ����������
-	(1)��Ŀ������
-		���ܶ��ŷ�������������Ŀ��������й��ƶ���������Ŀ�����ڶ��ƻ�����һ��ϵͳ��������Ŀ��
-		��Ҫ���¸�ϵͳ��һ����װ������Ҫ��װ�й��ƶ���һЩ��Ϣ�����Ժܶ���涼��Ҫ��������
-		������ֻ�ϵͳ����Android��ԭ��ϵͳ������Phone2.5�汾�Ժ���ڶ��ŵ�һ��Ӧ�á��Ѷ���ϵͳ���½����˷�װ��
-	(2)�����ģ�飺
-		1)�Ự�б�����ʾ����
-			ʹ��Android�����ṩ���첽��ѯ���AsyncQueryHandler��ѯ�ֻ����ţ��鿴ϵͳ����Դ��TelephonyProvider
-		2)�ļ���
-			�Զ��Ž��з����������Ϊ�ռ��䡢�����䡢�ѷ��ͺͲݸ��䣬���ҶԶ��Ž��������ڷָ���ʾ��
-		3)Ⱥ�飺
-			�ṩ���û����ݶ����Զ�����������
-		4)
-		5)
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\351\235\242\350\257\225\351\242\230\346\211\223\345\215\260.doc" "b/Android\345\237\272\347\241\200/\351\235\242\350\257\225\351\242\230\346\211\223\345\215\260.doc"
deleted file mode 100644
index e54aee1c..00000000
Binary files "a/Android\345\237\272\347\241\200/\351\235\242\350\257\225\351\242\230\346\211\223\345\215\260.doc" and /dev/null differ
diff --git "a/Android\345\212\240\345\274\272/Android\345\272\224\347\224\250\345\217\221\345\270\203.md" "b/AppPublish/Android\345\272\224\347\224\250\345\217\221\345\270\203.md"
similarity index 100%
rename from "Android\345\212\240\345\274\272/Android\345\272\224\347\224\250\345\217\221\345\270\203.md"
rename to "AppPublish/Android\345\272\224\347\224\250\345\217\221\345\270\203.md"
diff --git "a/AppPublish/Zipalign\344\274\230\345\214\226.md" "b/AppPublish/Zipalign\344\274\230\345\214\226.md"
new file mode 100644
index 00000000..c69dedfa
--- /dev/null
+++ "b/AppPublish/Zipalign\344\274\230\345\214\226.md"
@@ -0,0 +1,49 @@
+Zipalign优化
+===
+
+`Zipalign`优化工具是`SDK`中自带的优化工具,在`android-sdk-windows\build-tools\23.0.1`，在我们上传`Google Pay`的时候都会遇到您上传的`Apk`没有经过`Zipalign`处理
+的失败提示，就是说如果你的`apk`没有使用`zipalign`优化，那`google play`是拒绝给你上架的，从这里能看出`zipalign`优化是多么滴重要。
+
+```
+zipalign is an archive alignment tool that provides important optimization to Android application (.apk) files. 
+The purpose is to ensure that all uncompressed data starts with a particular alignment relative to the start of the file. 
+Specifically, it causes all uncompressed data within the .apk, such as images or raw files, to be aligned on 4-byte boundaries. 
+This allows all portions to be accessed directly with mmap() even if they contain binary data with alignment restrictions. 
+The benefit is a reduction in the amount of RAM consumed when running the application.
+```
+                           
+```
+Caution: zipalign must only be performed after the .apk file has been signed with your private key. 
+If you perform zipalign before signing, then the signing procedure will undo the alignment. 
+Also, do not make alterations to the aligned package. 
+Alterations to the archive, such as renaming or deleting entries, 
+will potentially disrupt the alignment of the modified entry and all later entries. 
+And any files added to an "aligned" archive will not be aligned.
+```
+
+大意就是它提供了一个灰常重要滴功能来确保所有未压缩的数据都从文件的开始位置以指定的4字节对齐方式排列，例如图片或者
+`raw`文件。当然好处也是大大的，就是能够减少内存的资源消耗。最后他还特意提醒了你一下就是一定在对`apk`签完名之后再用`zipalign`
+优化，如果你在之前用，那无效。
+
+废多看用法:      
+
+- 首先我要检查下我的`apk`到底用没用过`zipalign`优化呢?                                   
+    `zipalign -c -v 4 test.apk`                      
+    这个4是神马呢？就是４个字节的队列方式                                          
+    命令一顿执行，然后打出来了`Verification failed`，我不想再解释了。
+	
+- 	如何使用?                                
+    `zipalign -f -v 4 test.apk zip.apk`                             
+	就是把当前的`test.apk`使用`zipalign`优化，优化完成后的是`zip.apk`
+	
+Flag:     
+
+- -f : overwrite existing outfile.zip
+- -v : verbose output
+- -c : confirm the alignment of the given file
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/AppPublish/\344\275\277\347\224\250Jenkins\345\256\236\347\216\260\350\207\252\345\212\250\345\214\226\346\211\223\345\214\205.md" "b/AppPublish/\344\275\277\347\224\250Jenkins\345\256\236\347\216\260\350\207\252\345\212\250\345\214\226\346\211\223\345\214\205.md"
new file mode 100644
index 00000000..437ac037
--- /dev/null
+++ "b/AppPublish/\344\275\277\347\224\250Jenkins\345\256\236\347\216\260\350\207\252\345\212\250\345\214\226\346\211\223\345\214\205.md"
@@ -0,0 +1,135 @@
+使用Jenkins实现自动化打包
+===
+
+[Jenkins](https://jenkins.io/)个开源的持续集成工具，不仅可以用来进行`Android`打包，也可以用来进行`iOS`打包、`NodeJs`打包、`Java`服务打包等。
+
+> The leading open source automation server, Jenkins provides hundreds of plugins to support building, deploying and automating any project.
+
+`Jenkins`是使用`Java`开发的，官方提供一个`war`包，并且自带`servlet`容器，可以独立运行也可以放在`Tomcat`中运行。当然它也提供了`mac`等客户端，可以直接下载。 
+因为一般我们都是将其部署到服务器上，所以这里就用下载`jenkins.war`放到`Tomcat`的方式来讲解。 
+
+
+安装Tomcat
+---
+
+去[Tomcat](https://tomcat.apache.org/)官网下载最新的安装包，安装完成后启动`tomcat`.
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/tomcat_org.png" width="100%" height="100%">
+
+
+安装启动都很简答，就是下载后解压，然后打开`terminal`进入解压后的目录下的`bin`目录，然后执行`startup`命令:
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/tomcat_start.png" width="100%" height="100%">
+
+可以看到上面我执行`./startup.sh`时提示权限问题了，这是因为用户没有权限导致无法运行，需要要`chmod`修改`bin`目录下`.sh`的权限。
+修改完权限后启动就可以了，看到提示启动成功后，我们可以在浏览器输入`http://localhost:8080`，如果能显示出来可爱的小喵咪，那就说明启动成功了。         
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/tomcat_startpage.png" width="100%" height="100%">
+
+有关`tomcat`更多的信息就不介绍了，一般在`javaweb`的学习过程中都会学到。    
+
+部署Jenkins到Tomcat
+---
+
+去[Jenkins官网](https://jenkins.io/)进行下载，然后选择意向版本的`.war`包
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_download_list.png" width="100%" height="100%">
+
+把下载后的`war`包放在本地`tomcat`目录下的`webapps`目录下。   
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_tomcat.png" width="100%" height="100%">
+
+然后在浏览器中访问`http://localhost:8080/jenkins/`，如果看到以下界面，代表已经成功部署了.  
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_startpage.png" width="100%" height="100%">
+
+启动完成后会提示输入一个密码，上面有路径，我们直接进去打开拷贝就可以了。  
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_secret_code.png" width="100%" height="100%">
+
+按照上面的路径，进入拷贝.
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/get_secret_code.png" width="100%" height="100%">
+
+然后会出现安装选择页面，我们选择默认的配置就可以。       
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_install.png" width="100%" height="100%">
+
+然后就会出现以下界面，我们等待安装就可以了，这个安装过程会灰常慢。 我们也可以看到他会安装`ant、gradle、git、svn、email`等插件。  
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_installing.png" width="100%" height="100%">
+
+等安装完成后会看到用户名设置界面。      
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_set_user.png" width="100%" height="100%">
+
+好了，大功告成，开始使用后的页面如下:   
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_first_page.png" width="100%" height="100%">
+
+那就开始创建一个项目的项目:   
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_demo.png" width="100%" height="100%">
+ 
+创建后就会进入到项目设置页面:   
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_setting_general.png" width="100%" height="100%">
+
+然后我们去设置源码管理，配置好分支和项目地址:     
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_source_manager.png" width="100%" height="100%">
+
+下面点击证书后面的`add`进行添加，然后选择用用户名和密码的登录方式，输入用户名和密码:   
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_username_psw.png" width="100%" height="100%">
+
+然后继续进行设置构建部分，因为`android`打包需要使用`Gradle`所以，我们选择使用`Gradle`然后进行配置`Gradle`:    
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_gradle_setting.png" width="100%" height="100%">
+
+然后设置`Gradle`版本:        
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_gradle_setting2.png" width="100%" height="100%">
+
+这里你会发现没有`Gradle`版本，这是因为我们没有去配置`Gradle`导致的，因为`android`打包需要`Gradle`和`JDK`所以我们要先去配置下他俩，
+进入到`jenkins`首页选择系统管理-全局工具配置:   
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_gradle_install.png" width="100%" height="100%">
+
+里面的`jdk`和`gradle`都可以选择在线安装，如果`jdk`使用在线安装的话需要输入`oracle`账号的的用户名和密码。
+配置弯沉恭候，再回到刚才创建的`JenkisDemo`项目的配置页面继续进行构建配置:    
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_setting_3.png" width="100%" height="100%">
+
+然后就可以选择我们刚才新添加的`gradle`版本了:   
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_gradle_version_choose.png" width="100%" height="100%">
+
+然后再`Tasks`里面输入对应的`Task`命令就可以了。
+
+在里面构建后操作中选择增加构建后操作步骤，可以选择构建完后自动发邮件等。      
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/build_over_operation.png" width="100%" height="100%">
+
+到这里就配置完了，下面直接执行项目里面的立即构建就可以自动打包了。   
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_build_start.png" width="100%" height="100%">
+
+但是报错了，我们点本次构建列表中点入，再点击控制台输出可以查看详细的错误信息，提示说需要配置`SDK`,前面只配置了`jdk`忘了配置`sdk`了       
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_failed_msg.png" width="100%" height="100%">
+
+打开系统管理-系统设置然后在全局变量-环境变量中增加`Android_home`配置:   
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_android_home.png" width="100%" height="100%">
+ 
+好了，这样就可以了。 
+
+但是我们再打包的时候不仅仅是想这样打一个简单的版本，而是想配置一下参数，来满足一些版本号，渠道等的需求。
+我们可以来到项目的设置页面，选择参数化构建过程-添加参数-选择选项参数等进行添加:   
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_demo_setting.png" width="100%" height="100%">
+
+可以配置`APP_VERSION`、`BUILD_TIME`、`PRODUCT_FLAVORS`、`BUILD_TYPE`等  
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_build_product.png" width="100%" height="100%">
+
+
+注意这里配置完成后，还要去在`gradle task`中去使用才可以(在命令后面加上配置的参数)：   
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_build_add_mingling.png" width="100%" height="100%">
+
+好了，配置完成后再返回到项目首页你就会发现之前的立即构建变成了`Build with Parameters`，点击它就可以直接构建了。  
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/jenkins_build_change_name.png" width="100%" height="100%">
+
+打包完成后可以自动放到服务器目录中，通过`tomcat`提供链接对外下载，也可以发邮件、生成二维码等。这里就不仔细介绍了。
+`jenkins`可以让我们更自由的进行配置，操作，也可以通过`shell`脚本等进行更加深度的定制，提高了开发中打包的效率。  
+
+而且`Jenkins`还提供了很多静态代码分析检查的插件，可以直接去集成使用[Static Code Analysis Plug-ins](Static Code Analysis Plug-ins)
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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..6fa7327a
--- /dev/null
+++ "b/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
@@ -0,0 +1,108 @@
+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%。代码规范，缺乏认真的代码评审。
+降低质量要求，事实上不会降低研发成本，反而会增加整体的研发成本。在研发阶段通过降低质量所“节省”的研发成本，会在软件维护阶段加倍偿还。
+
+在研发前期(需求分析和系统设计)多投入资源，相对于把资源都投入在研发后期(编码、测试等)，其收益更大。
+
+
+### 架构三要素
+
+#### 构件
+
+构件在软件领域是指可复用的模块，它可以是被封装的对象类、类树、一些功能模块、软件框架(framework)、软件架构(或体系结构Architectural)、文档、分析件、设计模式(Pattern)。但是，操作集合、过程、函数即使可以复用也不能成为一个构件。 
+
+##### 构件的属性: 
+1. 有用性(Usefulness):构件必须提供有用的功能。
+2. 可用性(Usability):构件必须易于理解和使用，可以正常运行。
+3. 质量(Quality):构件及其变形必须能正确工作，质量好坏与可用性相互补充。
+4. 适应性(Adaptability):构件应该易于通过参数化等方式再不同环境中进行配置，比较高端一点的复用性，接收外界各种入参，产生不同的结果，健壮性比较高。
+5. 可移植性(Portability):构件应能在不同的硬件运行平台和软件环境中工作，可移植性比较好，跨平台。
+
+
+#### 模式(Pattern)
+
+其实就是解决某一类问题的方法论，是生产经验和生活经验中经过抽象和升华提炼出来的核心知识体系。 模式就是一个完整的流程闭环，能够解决一些问题的通用方法(比如资本运作、玩家不同的需求等)，软件中的模式大多源于生活，是人类智慧的结晶。  
+
+#### 规划
+
+规划是系统架构中最重要的组成部分，是个人或者组织制定的比较全面长远的发展计划，是对未来整体性、长期性、基本性问题的思考和考量。设计未来整套行动的方案。很早就有规划这个概念了，例如:国家的十一五规划等。当然软件开发也和生活紧密联系，一个大型的系统也需要良好的规划，规划可以说是基石，是系统架构的前提。 
+
+
+系统架构虽然是软件系统的结构，行为，属性的高级抽象，但其根本就是在需求分析的基础行为下，制定技术框架，对需求的技术实现。 
+
+
+### 系统设计的原则和方法： 
+
+* 单一目的
+* 对外关系清晰
+* 重视资源约束
+* 根据需求做决策
+* 基于模型思考
+
+
+#### 单一职责原则
+
+
+
+#### 开放-封闭原则
+无论模块是多么的‘封闭’，都会存在一些无法对之封闭的变化。既然不可能完全封闭，设计人员必须对于他设计的模块应该对哪种变化封闭做出选择。他必须先猜测出最有可能发生的变化种类，然后构造抽象来隔离那些变化
+
+开放-封闭原则是面向对象设计的核心所在。遵循这个原则可以带来面向对象技术所声称的巨大好处，也就是可维护、可扩展、可复用、灵活性好。开发人员应该仅对程序中呈现出频繁变化的那些部分做出抽象，然而，对于应用程序中的每个部分都刻意地进行抽象同样不是一个好主意。拒绝不成熟的抽象和抽象本身一样重要
+
+
+#### 依赖倒转原则
+
+
+
+#### 迪米特法则
+迪米特法则首先强调的前提是在类的结构设计上，每一个类都应当尽量降低成员的访问权限，也就是说，一个类包装好自己的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"
new file mode 100644
index 00000000..2bcf58de
--- /dev/null
+++ "b/Architect/2.UML\347\256\200\344\273\213.md"
@@ -0,0 +1,26 @@
+2.UML简介
+
+推荐使用[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/Android\345\237\272\347\241\200/Android\345\205\245\351\227\250\344\273\213\347\273\215.md" "b/BasicKnowledge/Android\345\205\245\351\227\250\344\273\213\347\273\215.md"
similarity index 64%
rename from "Android\345\237\272\347\241\200/Android\345\205\245\351\227\250\344\273\213\347\273\215.md"
rename to "BasicKnowledge/Android\345\205\245\351\227\250\344\273\213\347\273\215.md"
index d2b16ca6..ab179d5d 100644
--- "a/Android\345\237\272\347\241\200/Android\345\205\245\351\227\250\344\273\213\347\273\215.md"
+++ "b/BasicKnowledge/Android\345\205\245\351\227\250\344\273\213\347\273\215.md"
@@ -2,16 +2,16 @@ Android入门介绍
 ===
 
 1. 3G、4G
-    - 第三代移动通信技术（3rd - Generation），速率一般在几百Kbps，较之前的2G和2.5G在数据传输速度上有很大提升。
-    - 第四代移动通信技术（4th - Generation），速度可达到100Mbps以上，几乎可以满足人们的所有传输数据的需求。
+    - 第三代移动通信技术`(3rd - Generation)`，速率一般在几百`Kbps`，较之前的`2G`和`2.5G`在数据传输速度上有很大提升。
+    - 第四代移动通信技术`(4th - Generation)`，速度可达到100`Mbps`以上，几乎可以满足人们的所有传输数据的需求。
     
-    目前主流的3G技术标准有三种：
-    - WCDMA：全球80%以上的3G网络都是采用此种制式。中国联通运营。186
-    - CDMA2000：目前日韩及北美使用较多。中国电信运营。 189
-    - TD-SCDMA：中国自主知识产权的3G通信技术。中国移动运营。 188 
+    目前主流的`3G`技术标准有三种：
+    - `WCDMA`：全球80%以上的`3G`网络都是采用此种制式。中国联通运营。186
+    - `CDMA2000`：目前日韩及北美使用较多。中国电信运营。 189
+    - `TD-SCDMA`：中国自主知识产权的3G通信技术。中国移动运营。 188 
 
-    目前主流的4G技术为LTE，但还没有被广泛应用：    
-    GSM → GPRS → EDGE → WCDMA → HSDPA → HSDPA+ → LTE
+    目前主流的`4G`技术为`LTE`，但还没有被广泛应用：    
+    `GSM` → `GPRS` → `EDGE` → `WCDMA` → `HSDPA` → `HSDPA+` → `LTE`
     
 2. Android是什么
     1. 手机设备的软件栈内存，包括
@@ -27,7 +27,7 @@ Android入门介绍
     	- 硬件驱动
 
 3. Android体系结构
-    - Applications:桌面应用、打电话应用、浏览器等应用程序
+    - Applications:桌面、电话、浏览器等应用程序
     - Applications Framework:ActivityManager、 WindowManager、ContentProvider、ResourceManager等     
     - Libraries: SQLite库、SurfaceManager、WebKit、OppenGL等。
         - Android运行时
@@ -50,7 +50,9 @@ Android入门介绍
         - intel
         - AMD
     2. ARM
-        - 摩托罗拉
+        - 联发科
+        - 高通
+        - 海思
         - 三星
 
 6. Android项目目录结构
@@ -63,7 +65,7 @@ Android入门介绍
         - anim：定义动画的XML
         - raw：原生文件
     4. assets：资源路径，不会在R文件注册
-    5. project.properties：供Eclipse使用，读取该项目使用Android版本号。早期版本名为default.properties
+    5. project.properties：供Eclipse使用，读取该项目使用Android版本号，早期版本名为default.properties
     6. AndroidManifest.xml：清单文件，在软件安装的时候被读取      
         Android中的四大组件（Activity、ContentProvider、BroadcastReceiver、Service）都需要在该文件中注册程序所需的权限也需要在此文件中声明，例如：电话、短信、互联网、访问SD卡
     7. bin：二进制文件，包括class、资源文件、dex、apk等
@@ -79,24 +81,28 @@ Android入门介绍
     7. 按照main.xml文件初始化界面
 
     简单的来说软件的安装都是两个过程
-    - 拷贝apk中得一些文件到系统的某个目录，1./data/app/目录下， 2.创建一个文件夹 /data/data/com.test.helloworld/来保存数据
-    - 在系统的注册表里面配置一些信息.  data/system/packages.xml
+    - 拷贝apk中的一些文件到系统的某个目录      
+	    1. `/data/app/`目录下   
+	    2. 创建一个文件夹 `/data/data/com.test.helloworld/`来保存数据  
+    - 在系统的packages.xml文件(类似于Windows的注册表)中里面配置应用权限等一些信息.  `/data/system/packages.xml`
     
 8. Android安全学    
-    Android安全学中的一个重要的设计点是在默认情况下应用程序没有权限执行对其它应用程序、操作系统或用户有害的操作。这些操作包括读/写用户的隐私数据（例如联系方式或e-mail），读/写其它应用程序的文件，执行网络访问，保持设备活动，等等。 所以牵扯到付费或者可能与用户隐私相关的操作都要申请权限.
+    Android安全学中的一个重要的设计点是在默认情况下应用程序没有权限执行对其它应用程序、操作系统或用户有害的操作。
+	这些操作包括读/写用户的隐私数据（例如联系人或e-mail），读/写其它应用程序的文件，执行网络访问，保持设备活动，等等。 
+	所有牵扯到付费或者可能与用户隐私相关的操作都要申请权限。
 
 9. 测试分类    
-    单元测试(Unit test) -> 功能测试( Function test) ->集成测试(Intergation test)
+    单元测试(Unit test) -> 功能测试( Function test) -> 集成测试(Intergation test)
 	
 10. Android单元测试
     - AndroidManifest.xml中进行配置,导入android的junit环境
-    - 编写测试类继承Android的测试父类,AndroidTestCase这个类( AndroidTestCase是为了去模拟一个手机的运行环境， 这个类中有一个getContext方法能获取到当前测试类的应用上下文对象，所以这个方法必须要等到测试框架初始化完成后才可以去调用)
-    - 测试的方法名要求以小写的test开头,如不以test开头只能单独点这个方法运行,整体全部运行时没有这个方法，所有的测试方法都要抛出异常，要把异常抛给测试框架不能自己去捕获。
+    - 编写测试类继承Android的测试父类,AndroidTestCase这个类( AndroidTestCase是为了去模拟一个手机的运行环境，这个类中有一个getContext方法能获取到当前测试类的应用上下文对象，所以这个方法必须要等到测试框架初始化完成后才可以去调用)
+    - 测试的方法名要求以小写的test开头,如不以test开头只能单独点这个方法运行,整体全部运行时没有这个方法，所有的测试方法都要抛出异常，要把异常抛给测试框架不能自己去捕获
  
-    注意:测试得代码也是只能在手机上跑,它是在手机上测试完之后又将信息发送到了eclipse中
+    注意:测试的代码也是只能在手机上跑,它是在手机上测试完之后又将信息发送到了eclipse中
 
 
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/BasicKnowledge/Android\345\212\250\347\224\273.md" "b/BasicKnowledge/Android\345\212\250\347\224\273.md"
new file mode 100644
index 00000000..2705a05e
--- /dev/null
+++ "b/BasicKnowledge/Android\345\212\250\347\224\273.md"
@@ -0,0 +1,386 @@
+Android动画
+===
+
+1. AlphaAnimation
+
+    ```java
+    RelativeLayout rl_splash = (RelativeLayout) findViewById(R.id.rl_splash);
+    //播放动画效果
+    AlphaAnimation animation = new AlphaAnimation(1.0f, 0.0f);
+    //设置Alpha动画的持续时间
+    animation.setDuration(2000);
+    //播放Alpha动画
+    rl_splash.setAnimation(animation);
+    ```
+
+2. RotateAnimation
+
+    ```java
+    //相对于自身的哪个位置旋转，这里是相对于自身的右下角
+    RotateAnimation ra = new RotateAnimation(0, 360,  //从哪旋转，旋转多少度
+            Animation.RELATIVE_TO_SELF, 1.0f, Animation.RELATIVE_TO_SELF,
+            1.0f);
+    ra.setDuration(800);
+    ra.setRepeatCount(Animation.INFINITE);
+    ra.setRepeatMode(Animation.RESTART);
+    iv_scan.startAnimation(ra);
+     ```
+3. ScaleAnimation(缩放动画)    
+     
+    ```java 
+    ScaleAnimation(float fromX, float toX, float fromY, float toY) 
+    Constructor to use when building a ScaleAnimation from code
+    ```
+
+4. TranslateAnimation(位移动画)     
+    
+    ```java
+    TranslateAnimation(int fromXType, float fromXValue, int toXType, float toXValue, int fromYType, float fromYValue, int toYType, float toYValue) 
+    Constructor to use when building a TranslateAnimation from code
+    ```
+
+5. AnimationSet (多组动画)
+    
+    ```java
+    ScaleAnimation sa = new ScaleAnimation(0.2f, 1.0f, 0.4f,1.0f);//缩放的动画效果,1.0f就代表窗体的总宽或者高
+    sa.setDuration(400);
+    TranslateAnimation ta = new TranslateAnimation(//位移动的动画效果
+              Animation.RELATIVE_TO_SELF, 0,//指定这个位置是相对于谁
+              Animation.RELATIVE_TO_SELF, 0.1f,
+              Animation.RELATIVE_TO_SELF, 0,
+              Animation.RELATIVE_TO_SELF, 0);
+    ta.setDuration(300);
+    AnimationSet set = new AnimationSet(false);//如果想播放多种动画的组合，这里就要用到了AnimationSet
+    set.addAnimation(sa);
+    set.addAnimation(ta);
+    contentView.startAnimation(set); // 播放一组动画. 
+    ```
+
+6. Frame动画     
+    在`SDK`中提到，不要在`onCreate`中调用`start`方法开始播放`Frame`动画，因为`AnimationDrawable`还没有完全跟`Window`相关联，如果想要界面显示时就开始播放帧动画的话，可以在`onWindowFocusChanged()`中调用`start()`。
+
+    - 在`drawable`目录下新建一个`xml`文件，内容如下:
+    
+        ```xml
+        <?xml version="1.0" encoding="utf-8"?>
+        <animation-list xmlns:android="http://schemas.android.com/apk/res/android"
+            android:oneshot="true" > //onshot是指定是否循环播放
+            <item
+                android:drawable="@drawable/desktop_rocket_launch_1"  //Frame动画的图片
+                android:duration="50"/> //播放这个图片持续的时间
+            <item
+                android:drawable="@drawable/desktop_rocket_launch_2"
+                android:duration="100"/>
+        </animation-list>
+        ```
+    - 播放Frame动画
+    
+        ```java
+        AnimationDrawable rocketAnimation;
+        public void onCreate(Bundle savedInstanceState) {
+              super.onCreate(savedInstanceState);
+              setContentView(R.layout.main);
+              ImageView rocketImage = (ImageView) findViewById(R.id.iv);
+              rocketImage.setBackgroundResource(R.drawable.animlist); //将上边建的Frame动画的xml文件通过背景资源设置给图片
+              rocketAnimation = (AnimationDrawable) rocketImage.getBackground();  //获取到图片的背景资源
+        }
+        public void start(View view) {
+              if (!rocketAnimation.isRunning()) {
+                   rocketAnimation.start();  //播放
+              }
+        }
+        ```
+        
+7. 保持动画播放完成后的状态`animation.setFillAfter(true);`   
+
+    ```java
+    Interpolator //定义了动画的变化速度，可以实现匀速、正加速、负加速、无规则变加速度
+    AccelerateDecelerateInterpolator//先加速后减速。
+    AccelerateInterpolator//逐渐加速。    
+    LinearInterpolator//平稳不变的   
+    DecelerateInterpolator//逐渐减速
+    CycleInterpolator//曲线运动特效，要传递float型的参数。     
+    animation.setInterpolator(new LinearInterpolator());//指定动画的运行效果
+    ```
+
+上面所讲的动画都是`Android 3.0`之前的动画，也就是我们最先熟悉的`Frame`动画和`Tween`动画。
+
+从`3.0`开始又引入了一个新的动画叫做`Property`动画。并且针对这三种动画的动画模式分为:
+
+- `Property Animation` : 属性动画,从`Android 3.0`开始引进，更改的是对象的实际属性，而且属性动画不止可以应用于`View`还可以应用于任何对象。
+- `View Animation` : 指之前的`Tween`动画，`alpha scale translate rotate`等。为什么叫做`View Animation`呢？因为它只能应用于`View`对象，而且只支持一部分属性，如支持缩放旋转而不支持背景颜色的变化。对于`View Animation`而言，它只改变了`View`对象绘制的位置，而没有改变`View`对象本身的属性，比如，有一个200*200大小的`Button`，你用`Tween`动画给放大到500*500但是它的有效点击区域还是200*200。
+- `Drawable Animation` : 指之前的`Frame`动画。因为它是通过一帧帧的图片来播放的。
+    
+下面我们开始仔细讲解一下`Property Animation`
+---
+
+官方文档中是这样这样介绍属性动画的:      
+
+```
+The property animation system is a robust framework that allows you to animate almost anything. You can define an animation to change any object property over time, regardless of whether it draws to the screen or not. A property animation changes a property's (a field in an object) value over a specified length of time. To animate something, you specify the object property that you want to animate, such as an object's position on the screen, how long you want to animate it for, and what values you want to animate between.
+```
+一个强大的框架。    
+
+在`Property Animation`中，可以对动画应用以下属性:   
+
+- `Duration`: 指定动画持续时间，默认时间是`300ms`      
+- `TimeInterpolation`: 一些效果，如加速、加速等。
+- `Repeat count and behavior `: 重复次数已经
+- `Animation Set`: 动画合集。用来同时或者顺序播放多个动画。
+- `Frame Refresh Delay`: 多长时间刷新一次，默认是`10ms`。
+
+### `ValueAnimator`    
+
+
+`ValueAnimator`包含`Property Animation`动画的所有核心功能，如动画时间，开始、结束属性值，相应时间属性值计算方法等。应用`Property Animation`有两个步聚：       
+
+- 计算属性值
+- 根据属性值执行相应的动作，如改变对象的某一属性。
+
+`ValuAnimiator`只完成了第一步工作，如果要完成第二步，需要实现`ValueAnimator.onUpdateListener`接口，这个接口只有一个函数`onAnimationUpdate()`，在这个函数中会传入`ValueAnimator`对象做为参数，通过这个`ValueAnimator`对象的`getAnimatedValue()`函数可以得到当前的属性值。
+
+### `ObjectAnimator`   
+
+继承自`ValueAnimator`，要指定一个对象及该对象的一个属性，当属性值计算完成时自动设置为该对象的相应属性，即完成了`Property Animation`的全部两步操作。实际应用中一般都会用`ObjectAnimator`来改变某一对象的某一属性，但用`ObjectAnimator`有一定的限制，要想使用`ObjectAnimator`，应该满足以下条件：
+
+- 对象应该有一个`setter`函数：`set<PropertyName>`（驼峰命名法）
+- 如上面的例子中，像`ofFloat`之类的工场方法，第一个参数为对象名，第二个为属性名，后面的参数为可变参数，如果`values…`参数只设置了一个值的话，那么会假定为目的值，属性值的变化范围为当前值到目的值，为了获得当前值，该对象要有相应属性的`getter`方法：`get<PropertyName>`
+- 如果有`getter`方法，其应返回值类型应与相应的`setter`方法的参数类型一致。
+- `object`的`setXxx`对属性`xxx`所做的改变必须能够通过某种方法反映出来，比如会带来`ui`的改变啥的（如果这条不满足，动画无效果）,例如我对`TextView`或者`Button`使用`width`的`ObjectAnimator`动画，就会发现无效，虽然他们都有`setWidth`和`getWidth`方法，但是`setWidth`方法的内部实现是改变`TextView`的最大宽度和最小宽度的，和`TextView`的宽度不是一个东西。所以动画就会无效。确切的说`TextView`的宽度对应的是`xml`中`android:layout_width`属性，而`TextView`还有另外一个属性:`android:width`，而`android:width` 属性对应的就是`TextView`中的`setWidth`方法。
+
+如果上述条件不满足，则不能用`ObjectAnimator`，应用`ValueAnimator`代替。
+也就是说`ObjectAnimator`内部的工作机制是通过寻找特定属性的`get`和`set`方法，然后通过方法不断地对值进行改变，从而实现动画效果的。
+
+### `AnimationSet`
+
+
+`AnimationSet`提供了一个把多个动画组合成一个组合的机制，并可设置组中动画的时序关系，如同时播放，顺序播放等。
+
+以下例子同时应用5个动画:   
+
+- Plays bounceAnim.
+- Plays squashAnim1, squashAnim2, stretchAnim1, and stretchAnim2 at the same time.
+- Plays bounceBackAnim.
+- Plays fadeAnim.
+
+```java
+AnimatorSet bouncer = new AnimatorSet();
+bouncer.play(bounceAnim).before(squashAnim1);
+bouncer.play(squashAnim1).with(squashAnim2);
+bouncer.play(squashAnim1).with(stretchAnim1);
+bouncer.play(squashAnim1).with(stretchAnim2);
+bouncer.play(bounceBackAnim).after(stretchAnim2);
+ValueAnimator fadeAnim = ObjectAnimator.ofFloat(newBall, "alpha", 1f, 0f);
+fadeAnim.setDuration(250);
+AnimatorSet animatorSet = new AnimatorSet();
+animatorSet.play(bouncer).before(fadeAnim);
+animatorSet.start();
+```
+
+### `TypeEvalutors`
+
+
+根据属性的开始、结束值与`TimeInterpolation`计算出的比例值来计算当前时间对应的属性值，`Android`提供了一下几种`evalutor`:    
+
+- `IntEvalutor`:`int`类型的属性值
+- `FloatEvaluator`:
+- `ArgbEvaluator`: 属性的值类型为十六进制颜色值；
+- `TypeEvaluator`: 一个接口，可以通过实现该接口自定义Evaluator。
+自定义`TypeEvaluator`也很简单，只需要实现一个方法，如`FloatEvalutor`的定义:     
+```java
+public class FloatEvaluator implements TypeEvaluator {
+    public Object evaluate(float fraction, Object startValue, Object endValue) {
+        float startFloat = ((Number) startValue).floatValue();
+        return startFloat + fraction * (((Number) endValue).floatValue() - startFloat);
+    }
+}
+```
+`evaluate()`方法当中传入了三个参数，第一个参数`fraction`非常重要，这个参数用于表示动画的完成度的，我们应该根据它来计算当前动画的值应该是多少，第二第三个参数分别表示动画的初始值和结束值。那么上述代码的逻辑就比较清晰了，用结束值减去初始值，算出它们之间的差值，然后乘以`fraction`这个系数，再加上初始值，那么就得到当前动画的值了。
+
+
+### `TimeInterplator`   
+Time interplator定义了属性值变化的方式，如线性均匀改变，开始慢然后逐渐快等。在Property Animation中是TimeInterplator，在View Animation中是Interplator，这两个是一样的，在3.0之前只有Interplator，3.0之后实现代码转移至了TimeInterplator。Interplator继承自TimeInterplator，内部没有任何其他代码。
+
+- AccelerateInterpolator　　　　　     加速，开始时慢中间加速
+- DecelerateInterpolator　　　 　　   减速，开始时快然后减速
+- AccelerateDecelerateInterolator　   先加速后减速，开始结束时慢，中间加速
+- AnticipateInterpolator　　　　　　  反向 ，先向相反方向改变一段再加速播放
+- AnticipateOvershootInterpolator　   反向加回弹，先向相反方向改变，再加速播放，会超出目的值然后缓慢移动至目的值
+- BounceInterpolator　　　　　　　  跳跃，快到目的值时值会跳跃，如目的值100，后面的值可能依次为85，77，70，80，90，100
+- CycleIinterpolator　　　　　　　　 循环，动画循环一定次数，值的改变为一正弦函数：Math.sin(2 * mCycles * Math.PI * input)
+- LinearInterpolator　　　　　　　　 线性，线性均匀改变
+- OvershottInterpolator　　　　　　  回弹，最后超出目的值然后缓慢改变到目的值
+- TimeInterpolator　　　　　　　　   一个接口，允许你自定义interpolator，以上几个都是实现了这个接口
+
+
+### `PropertyValuesHolder`
+
+如果要实现一个对象不同属性的动画效果，除了`Set`，我们还可以利用`PropertyValuesHolder`和`ViewPropertyAnimator`对象来实现，具体做法如下：
+```
+PropertyValuesHolder pvhX = PropertyValuesHolder.ofFloat("x", 50f);
+PropertyValuesHolder pvhY = PropertyValuesHolder.ofFloat("y", 100f);
+ObjectAnimator.ofPropertyValuesHolder(myView, pvhX, pvyY).start();
+```
+
+### `ViewPropertyAnimator`
+```
+ * <p>This class is not constructed by the caller, but rather by the View whose properties
+ * it will animate. Calls to {@link android.view.View#animate()} will return a reference
+ * to the appropriate ViewPropertyAnimator object for that View.</p>
+```
+如果需要对一个View的多个属性进行动画可以用ViewPropertyAnimator类，该类对多属性动画进行了优化，会合并一些invalidate()来减少刷新视图，该类在3.1中引入。
+
+`view.animate()`方法会返回`ViewPropertyAnimator`类。
+```java
+myView.animate().x(50f).y(100f);
+```
+的效果与上面的`PropertyValuesHolder`例子中的效果完全一致。
+但是你有没有发现我们自始至终没有调用过`start()`方法，这是因为新的接口中使用了隐式启动动画的功能，只要我们将动画定义完成之后，动画就会自动启动。并且这个机制对于组合动画也同样有效，只要我们不断地添加新的方法，那么动画就不会立刻执行，等到所有在`ViewPropertyAnimator`上设置的方法都执行完毕后，动画就会自动启动。当然如果不想使用这一默认机制的话，我们也可以显式地调用`start()`方法来启动动画。
+
+
+
+### `XML`中定义
+
+在`res/animator`中定义对应的动画`xml`       
+- <animator>  对应代码中的ValueAnimator
+- <objectAnimator>  对应代码中的ObjectAnimator
+- <set>  对应代码中的AnimatorSet 
+例如:       
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>  
+<objectAnimator   
+    xmlns:android="http://schemas.android.com/apk/res/android"   
+    android:propertyName="scaleX"  
+    android:duration="2000"  
+    android:valueFrom="1.0"  
+    android:valueTo="2.0"  
+    android:valueType="floatType" 
+    android:repeatCount="1"  
+    android:repeatMode="reverse">  
+</objectAnimator>  
+```
+这里说明一下`valueFrom`和`valueTo`:是动画开始和结束值，如果我们缩放，则它们对应的是倍数，如果我们平移则对应的就是距离了。
+
+接下来就是调用了
+```java
+scaleXAnimator = (ObjectAnimator)AnimatorInflater.loadAnimator(this, R.animator.scalex);  
+scaleXAnimator.setTarget(btnScaleX);  
+scaleXAnimator.start();
+```
+
+那如果我们要播放多个动画怎么办?  
+```xml
+<?xml version="1.0" encoding="utf-8"?>  
+<set xmlns:android="http://schemas.android.com/apk/res/android"   
+    android:ordering="together">  
+    <objectAnimator  
+        android:duration="2000"  
+        android:propertyName="scaleX"  
+        android:repeatCount="1"  
+        android:repeatMode="reverse"  
+        android:valueFrom="1.0"  
+        android:valueTo="2.0" >  
+    </objectAnimator>  
+    <objectAnimator  
+        android:duration="2000"  
+        android:propertyName="scaleY"  
+        android:repeatCount="1"  
+        android:repeatMode="reverse"  
+        android:valueFrom="1.0"  
+        android:valueTo="2.0" >  
+    </objectAnimator>  
+</set>  
+```
+```java
+animatorScaleSet = (AnimatorSet)AnimatorInflater.loadAnimator(this, R.animator.scale);  
+animatorScaleSet.setTarget(btnScale);  
+animatorScaleSet.start();
+
+```
+
+`Android L`又增加了一种动画样式，叫做`Reveal Animation`。
+首先来看一下效果:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reveal.gif?raw=true)    
+
+可以直接通过`ViewAnimationUtils.createCircularReveal()`方法来创建。
+
+```java
+/**
+ * Returns an Animator which can animate a clipping circle.
+ * <p>
+ * Any shadow cast by the View will respect the circular clip from this animator.
+ * <p>
+ * Only a single non-rectangular clip can be applied on a View at any time.
+ * Views clipped by a circular reveal animation take priority over
+ * {@link View#setClipToOutline(boolean) View Outline clipping}.
+ * <p>
+ * Note that the animation returned here is a one-shot animation. It cannot
+ * be re-used, and once started it cannot be paused or resumed. It is also
+ * an asynchronous animation that automatically runs off of the UI thread.
+ * As a result {@link AnimatorListener#onAnimationEnd(Animator)}
+ * will occur after the animation has ended, but it may be delayed depending
+ * on thread responsiveness.
+ *
+ * @param view The View will be clipped to the animating circle.
+ * @param centerX The x coordinate of the center of the animating circle, relative to
+ *                <code>view</code>.
+ * @param centerY The y coordinate of the center of the animating circle, relative to
+ *                <code>view</code>.
+ * @param startRadius The starting radius of the animating circle.
+ * @param endRadius The ending radius of the animating circle.
+ */
+public static Animator createCircularReveal(View view,
+        int centerX,  int centerY, float startRadius, float endRadius) {
+    return new RevealAnimator(view, centerX, centerY, startRadius, endRadius);
+}
+```
+
+代码如下:    
+
+```java
+void enterReveal() {
+    final View myView = findViewById(R.id.my_view);
+
+    int cx = myView.getMeasuredWidth() / 2;
+    int cy = myView.getMeasuredHeight() / 2;
+
+    int finalRadius = Math.max(myView.getWidth(), myView.getHeight()) / 2;
+
+    Animator anim =
+        ViewAnimationUtils.createCircularReveal(myView, cx, cy, 0, finalRadius);
+
+    anim.start();
+}
+
+void exitReveal() {
+    final View myView = findViewById(R.id.my_view);
+
+    int cx = myView.getMeasuredWidth() / 2;
+    int cy = myView.getMeasuredHeight() / 2;
+
+    int initialRadius = myView.getWidth() / 2;
+
+    Animator anim =
+        ViewAnimationUtils.createCircularReveal(myView, cx, cy, initialRadius, 0);
+
+    anim.addListener(new AnimatorListenerAdapter() {
+        @Override
+        public void onAnimationEnd(Animator animation) {
+            super.onAnimationEnd(animation);
+            myView.setVisibility(View.INVISIBLE);
+        }
+    });
+
+    anim.start();
+}
+
+```
+
+有关如何提高动画性能请看:[通过Hardware Layer提高动画性能](https://github.com/CharonChui/AndroidNote/blob/master/Android%E5%8A%A0%E5%BC%BA/%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)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/BasicKnowledge/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213ContentProvider.md" "b/BasicKnowledge/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213ContentProvider.md"
new file mode 100644
index 00000000..26adc9e2
--- /dev/null
+++ "b/BasicKnowledge/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213ContentProvider.md"
@@ -0,0 +1,312 @@
+Android四大组件之ContentProvider
+===
+
+ContentProvider    
+---
+
+安卓应用程序默认是无法获取到其他程序的数据，这是安卓安全学的基石(沙盒原理)。但是经常我们需要给其他应用分享数据，内容提供者就是一个这种可以分享数据给其他应用的接口。
+可以简单的理解为，内容提供者就是一个可以在不同应用程序间共享数据的组件，相当于一个中间人，一个程序把数据暴露给这个中间人，另一个则通过这个中间人获取相应的数据.        
+
+下面的这张图片能更直观的显示:     
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ContentProvider_1.png)    
+
+- `ContentProvider`中的`getContext`和`AndroidTestCast`中的`getContext`方法一样，都是一个模拟的上下文，必须在该类初始化之后才会调用`setContext`方法将`context`设置成自己的成员变量中记录，
+	所以对于获取`getContext`的时候只能放在方法内，不能放到成员位置，因为在成员上时是null，而在方法内调用时该类就会已经初始化完了      
+
+- `ContentProvider`中的`query()`后不能关闭数据库，因为其他的应用在调用该`query`方法时需要继续使用该返回值`Cursor`，所以不能关闭数据库，因为数据库关闭之后`Cursor`就不能用了，
+	`Cursor`中保存的数据其实是数据库的一个引用，如果数据库关了`Cursor`就不能找到里面的数据了，`Cursor.close()`只是释放`Cursor`用到的资源。说到这里就多数一句
+	`According to Dianne Hackborn (Android framework engineer) there is no need to close the database in a content provider.`以为内容提供者是因为进程启动时便加载，之后就一直存在，当进程销毁
+	释放资源时会去关闭数据库。
+	
+- 如果数据是`SQLiteDatabase`，表中必须有一个`_id`的列，用来表示每条记录的唯一性。
+
+1. 继承`ContentProvider`,并实现相应的方法。
+	```java
+	public class NoteProvider extends ContentProvider {
+		private static final int NOTES = 1;
+		private static final int NOTE_ID = 2;
+
+		public static final String AUTHORITY = "com.charon.demo.provider.noteprovider";
+		public static final String TABLE_NAME = "note";
+		// 定义一个名为`CONTENT_URI`必须为其指定一个唯一的字符串值，最好的方案是以类的全名称
+		public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/" + TABLE_NAME);
+
+		// 声明一个路径的检查者，参数为Uri不匹配时的返回值
+		// 虽然是中间人，但也不能谁要数据我们都给，所以要检查下，只有符合我们要求的人，我们才会给他数据。
+		private static UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+
+		private NoteSQLiteOpenHelper mSQLiteOpenHelper;
+		private SQLiteDatabase mSQLiteDatabase;
+
+		static {
+			// 建立匹配规则，例如发现路径为ccom.charon.demo.provider.noteprovider/note/1表示要操作note表中id为1的记录
+			sUriMatcher.addURI(AUTHORITY, TABLE_NAME, NOTES);
+			sUriMatcher.addURI(AUTHORITY, TABLE_NAME + "/#", NOTE_ID);
+		}
+
+		/**
+		 * Implement this to initialize your content provider on startup.
+		 * This method is called for all registered content providers on the
+		 * application main thread at application launch time.  It must not perform
+		 * lengthy operations, or application startup will be delayed.
+		 * <p/>
+		 * <p>You should defer nontrivial initialization (such as opening,
+		 * upgrading, and scanning databases) until the content provider is used
+		 * (via {@link #query}, {@link #insert}, etc).  Deferred initialization
+		 * keeps application startup fast, avoids unnecessary work if the provider
+		 * turns out not to be needed, and stops database errors (such as a full
+		 * disk) from halting application launch.
+		 * <p/>
+		 * <p>If you use SQLite, {@link android.database.sqlite.SQLiteOpenHelper}
+		 * is a helpful utility class that makes it easy to manage databases,
+		 * and will automatically defer opening until first use.  If you do use
+		 * SQLiteOpenHelper, make sure to avoid calling
+		 * {@link android.database.sqlite.SQLiteOpenHelper#getReadableDatabase} or
+		 * {@link android.database.sqlite.SQLiteOpenHelper#getWritableDatabase}
+		 * from this method.  (Instead, override
+		 * {@link android.database.sqlite.SQLiteOpenHelper#onOpen} to initialize the
+		 * database when it is first opened.)
+		 *
+		 * @return true if the provider was successfully loaded, false otherwise
+		 */
+		@Override
+		public boolean onCreate() {
+			mSQLiteOpenHelper = new NoteSQLiteOpenHelper(getContext());
+			return true;
+		}
+
+		/**
+		 * 内容提供者暴露的查询的方法.
+		 */
+		@Override
+		public Cursor query(Uri uri, String[] projection, String selection,
+							String[] selectionArgs, String sortOrder) {
+			mSQLiteDatabase = mSQLiteOpenHelper.getReadableDatabase();
+			Cursor cursor;
+			// 1.重要的事情 ,检查 uri的路径.
+			switch (sUriMatcher.match(uri)) {
+				case NOTES:
+					break;
+				case NOTE_ID:
+					String id = uri.getLastPathSegment();
+					if (TextUtils.isEmpty(selection)) {
+						selection = selection + "_id = " + id;
+					} else {
+						selection = selection + " and " + "_id = " + id;
+					}
+					break;
+				default:
+					throw new IllegalArgumentException("UnKnown Uri" + uri);
+					break;
+			}
+			cursor = mSQLiteDatabase.query(TABLE_NAME, projection, selection, selectionArgs, null, null, sortOrder);
+			if (cursor != null) {
+				cursor.setNotificationUri(getContext().getContentResolver(), uri);
+			}
+			return cursor;
+		}
+
+		/**
+		 * Implement this to handle requests for the MIME type of the data at the
+		 * given URI.  The returned MIME type should start with
+		 * <code>vnd.android.cursor.item</code> for a single record,
+		 * or <code>vnd.android.cursor.dir/</code> for multiple items.
+		 * This method can be called from multiple threads, as described in
+		 * <a href="{@docRoot}guide/topics/fundamentals/processes-and-threads.html#Threads">Processes
+		 * and Threads</a>.
+		 * <p/>
+		 * <p>Note that there are no permissions needed for an application to
+		 * access this information; if your content provider requires read and/or
+		 * write permissions, or is not exported, all applications can still call
+		 * this method regardless of their access permissions.  This allows them
+		 * to retrieve the MIME type for a URI when dispatching intents.
+		 *
+		 * @param uri the URI to query.
+		 * @return a MIME type string, or {@code null} if there is no type.
+		 */
+		@Override
+		public String getType(Uri uri) {
+			// 注释说的很清楚了，下面是常用的格式
+			// 单个记录的IMEI类型 vnd.android.cursor.item/vnd.<yourcompanyname>.<contenttype>
+			// 多个记录的IMEI类型 vnd.android.cursor.dir/vnd.<yourcompanyname>.<contenttype>
+			switch (sUriMatcher.match(uri)) {
+				case NOTE_ID:
+					// 如果uri为 content://com.charon.demo.noteprovider/note/1
+					return "vnd.android.cursor.item/vnd.charon.note";
+				case NOTES:
+					return "vnd.android.cursor.dir/vnd.charon.note";
+				default:
+					return null;
+			}
+
+			// 这个MIME类型的作用是要匹配AndroidManifest.xml文件<activity>标签下<intent-filter>标签的子标签<data>的属性android:mimeType。
+			// 如果不一致，则会导致对应的Activity无法启动。
+		}
+
+		@Override
+		public Uri insert(Uri uri, ContentValues values) {
+			mSQLiteDatabase = mSQLiteOpenHelper.getWritableDatabase();
+			switch (sUriMatcher.match(uri)) {
+				case NOTES:
+					break;
+
+				case NOTE_ID:
+					break;
+
+				default:
+					throw new IllegalArgumentException("UnKnown Uri" + uri);
+					break;
+			}
+
+			long rowId = mSQLiteDatabase.insert(TABLE_NAME, null, values);
+			if (rowId > 0) {
+				Uri noteUri = ContentUris.withAppendedId(CONTENT_URI, rowId);
+				getContext().getContentResolver().notifyChange(noteUri, null);
+				return noteUri;
+			}
+
+			return null;
+		}
+
+		@Override
+		public int delete(Uri uri, String selection, String[] selectionArgs) {
+			mSQLiteDatabase = mSQLiteOpenHelper.getWritableDatabase();
+			switch (sUriMatcher.match(uri)) {
+				case NOTES:
+					break;
+
+				case NOTE_ID:
+					String id = uri.getLastPathSegment();
+					if (TextUtils.isEmpty(selection)) {
+						selection = selection + "_id = " + id;
+					} else {
+						selection = selection + " and " + "_id = " + id;
+					}
+					break;
+
+				default:
+					throw new IllegalArgumentException("UnKnown Uri" + uri);
+					break;
+			}
+			int count = mSQLiteDatabase.delete(TABLE_NAME, selection, selectionArgs);
+			getContext().getContentResolver().notifyChange(uri, null);
+			return count;
+		}
+
+		@Override
+		public int update(Uri uri, ContentValues values, String selection,
+						  String[] selectionArgs) {
+			switch (sUriMatcher.match(uri)) {
+				case NOTES:
+
+					break;
+
+				case NOTE_ID:
+
+					break;
+
+				default:
+					throw new IllegalArgumentException("UnKnown Uri" + uri);
+					break;
+			}
+
+			mSQLiteDatabase = mSQLiteOpenHelper.getWritableDatabase();
+			int update = mSQLiteDatabase.update(TABLE_NAME, values, selection, selectionArgs);
+			return update;
+		}
+	```
+
+2. 在清单文件中进行注册，并且指定其authorities
+	```xml
+	<provider
+		android:name="com.charon.demo.provider.NoteProvider"
+		android:authorities="com.charon.demo.provider.noteprovider" >
+	```
+	
+3. 使用内容提供者获取数据，使用`ContentResolver`去操作`ContentProvider`, `ContentResolver`用于管理`ContentProvider`实例，
+	并且可实现找到指定的`ContentProvider`并获取里面的数据
+	```java
+	public void query(View view){
+		//得到内容提供者的解析器  中间人
+		ContentResolver resolver = getContentResolver();
+		Cursor cursor = resolver.query(NoteProvider.CONTENT_URI, null, null, null, null);
+		while(cursor.moveToNext()){
+			String name = cursor.getString(cursor.getColumnIndex("name"));
+			int id = cursor.getInt(cursor.getColumnIndex("id"));
+			float money = cursor.getFloat(cursor.getColumnIndex("money"));
+			System.out.println("id="+id+",name="+name+",money="+money);
+		}
+		cursor.close();
+	}
+	public void insert(View view){
+		ContentResolver resolver = getContentResolver();
+		ContentValues values = new ContentValues();
+		values.put("name", "买洗头膏");
+		values.put("money", 22.58f);
+		resolver.insert(NoteProvider.CONTENT_URI, values);
+	}
+	public void update(View view){
+		ContentResolver resolver = getContentResolver();
+		ContentValues values = new ContentValues();
+		values.put("name", "买洗头膏");
+		values.put("money", 42.58f);
+		resolver.update(NoteProvider.CONTENT_URI, values, "name=?", new String[]{"买洗头膏"});
+	}
+	public void delete(View view){
+		ContentResolver resolver = getContentResolver();
+		resolver.delete(NoteProvider.CONTENT_URI, "name=?", new String[]{"买洗头膏"});
+	}
+	```
+
+内容观察者     
+---
+
+内容观察者的原理：     
+`How a content provider actually stores its data under the covers is up to its designer. But all content providers implement a common interface for 
+querying the provider and returning results — as well as for adding, altering, and deleting data.            
+It's an interface that clients use indirectly, most generally through ContentResolver objects. 
+You get a ContentResolver by calling getContentResolver() from within the implementation of an Activity or other application component: 
+You can then use the ContentResolver's methods to interact with whatever content providers you're interested in.`
+
+1. 一方使用内容观察者去观察变化
+	```java
+		protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		setContentView(R.layout.activity_main);
+		ContentResolver resolver = getContentResolver();
+		resolver.registerContentObserver(NoteProvider.CONTENT_URI, true, new NoteObserver(new Handler()));
+
+	}
+
+	private class NoteObserver extends ContentObserver {
+
+		public NoteObserver(Handler handler) {
+			super(handler);
+			
+		}
+		//当观察到数据发生变化的时候  会执行onchange方法.
+		@Override
+		public void onChange(boolean selfChange) {
+			super.onChange(selfChange);
+			Log.i(TAG,"发现有新的短信产生了...");
+			//1.利用内容提供者  中间人 获取用户的短信数据.
+			ContentResolver resolver  = getContentResolver();
+			// .. 重新查询
+			cursor = ...;
+			cursor.close();
+		}
+	}
+	```
+	
+2. 一方在发生变化的时候去发送改变的消息
+	对于一些系统的内容提供者内部都实现了该步骤，如果是自己写程序想要暴露就必须要加上该代码。     
+	
+	```java	
+	getContext().getContentResolver().notifyChange(uri, null);
+	```
+	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/BasicKnowledge/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213Service.md" "b/BasicKnowledge/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213Service.md"
new file mode 100644
index 00000000..dcf3cb47
--- /dev/null
+++ "b/BasicKnowledge/Android\345\233\233\345\244\247\347\273\204\344\273\266\344\271\213Service.md"
@@ -0,0 +1,216 @@
+Android四大组件之Service
+===
+
+服务的两种开启方式：
+---
+
+1. `startService()`:开启服务.      
+	开启服务后 服务就会长期的后台运行,即使调用者退出了.服务仍然在后台继续运行.服务和调用者没有什么关系, 调用者是不可以访问服务里面的方法.
+2. `bindService()`:绑定服务.           
+	服务开启后,生命周期与调用者相关联.调用者挂了,服务也会跟着挂掉.不求同时生,但求同时死.调用者和服务绑定在一起,调用者可以间接的调用到服务里面的方法.
+
+AIDL
+---
+
+本地服务:服务代码在本应用中     
+远程服务:服务在另外一个应用里面(另外一个进程里面)      
+`aidl`: `android interface defination language`
+`IPC implementation` : `inter process communication`        
+
+服务混合调用的生命周期      
+---
+
+开启服务后再去绑定服务然后再去停止服务，这时服务是无法停止了.必须先解绑服务然后再停止服务，在实际开发中会经常采用这种模式，
+开启服务(保证服务长期后台运行) --> 绑定服务(调用服务的方法) --> 解绑服务(服务继续在后台运行) --> 停止服务(服务停止),服务只会被开启一次，
+如果已经开启后再去执行开启操作是没有效果的。    
+
+绑定服务调用方法的原理
+---
+
+1. 定义一个接口，里面定义一个方法
+	```java
+	public interface IService {
+		public void callMethodInService();//通过该类中提供一个方法，让自定 
+	义的类实现这个接口
+	}
+	```
+	
+2. 在服务中自定义一个IBinder的实现类，让这个类继承Binder(Binder是IBinder的默认适配器)，由于这个自定义类是私有的，为了其他类中能拿到该类，
+	我们要定义一个接口，提供一个方法，让IBinder类去实现该接口，并在相应方法中调用自己要供别人调用的方法。   
+	```java
+	public class TestService extends Service {
+		@Override
+		public IBinder onBind(Intent intent) {
+			System.out.println("onbind");
+			return new MyBinder();
+		}
+		
+		private class MyBinder extends Binder implements IService{
+			public void callMethodInService(){
+				//实现该方法，去调用服务中的方法
+				methodInService();
+			}
+		}
+		//服务中的方法
+		public void methodInService(){
+			Toast.makeText(this, "我是服务里面的春哥,巴拉布拉!", 0).show();
+		}
+	}
+	```
+	
+3. 服务的调用类中将`onServiceConnected`方法中的第二个参数强转成接口
+	```java
+	public class DemoActivity extends Activity {
+		private Intent intent;
+		private Myconn conn;
+		private IService iService;
+		@Override
+		public void onCreate(Bundle savedInstanceState) {
+			super.onCreate(savedInstanceState);
+			intent = new Intent(this,TestService.class);
+			setContentView(R.layout.main);
+		}
+		public void start(View view) {
+			startService(intent);
+		}
+		public void stop(View view) {
+			stopService(intent);
+		}
+		public void bind(View view) {
+			conn = new Myconn();
+			//1.绑定服务 传递一个conn对象.这个conn就是一个回调接口
+			bindService(intent, conn, Context.BIND_AUTO_CREATE);
+		}
+		public void unbind(View view) {
+			unbindService(conn);
+		}
+		//调用服务中的方法
+		public void call(View view){
+			iService.callMethodInService();
+		}
+		private class Myconn implements ServiceConnection{
+			//当服务被成功绑定的时候调用的方法.
+			@Override
+			public void onServiceConnected(ComponentName name, IBinder service) {//第二个参数就是服务中的onBind方法的返回值
+				iService = (IService) service;
+			}
+			@Override
+			public void onServiceDisconnected(ComponentName name) {
+			}
+		}
+	} 
+	```
+
+远程服务aidl
+---
+    
+上面介绍了绑定服务调用服务中方法的原理，对于远程服务的绑定也是这样，
+但是这个远程服务是在另外一个程序中的，在另外一个程序中定 义的这个接口，
+在另外一个程序中是拿不到的，就算是我们在自己的应用 中也定义一个一模一样
+的接口，但是由于两个程序的报名不同，这两个接口也是不一样的，为了解决这个
+问题，谷歌的工程师给提供了aidl，我们将定义的这个接口的`.java`改成 `.aidl`，
+然后将这个接口中的`权限修饰符`都**去掉**，在另一个程序中拷贝这个aidl文 
+件，然后放到同一个包名中，由于`Android`中通过包名来区分应用程序，这两个 
+`aidl`的包名一样，系统会认为两个程序中的接口是同一个，这样就能够在另一
+个程序中将参数强转成这个接口,在使用`aidl`文件拷贝到自己的工程之后会自动
+生成一个接口类，这个接口类中有 一个内部类`Stub`该类继承了`Binder`并实现了
+这个接口，所以我们在自定义 `IBinder的实现类`时只需让自定义的类继承`Stub类`
+即可.
+
+1. 远程服务中定义一个接口，改成`aidl`
+	```java
+	package com.seal.test.service;
+
+	interface IService {
+		 void callMethodInService();
+	}
+	```
+
+2. 远程服务中定义一个`Ibinder的实现类`，让这个实现类继承上面接口的`Stub类`，
+并在`onBind`方法中返回这个自定义类对象 
+	```java
+	public class RemoteService extends Service {
+		@Override
+		public IBinder onBind(Intent intent) {
+			System.out.println("远程服务被绑定");
+			return new MyBinder();
+		}
+		private class MyBinder extends IService.Stub{
+			@Override
+			public void callMethodInService() {
+				methodInService();
+			}
+		}
+		public void methodInService(){
+			System.out.println("我是远程服务里面的方法");
+		}
+	}
+	```
+
+3. 在其他程序中想要绑定这个服务并且调用这个服务中的方法的时候首先要拷贝 
+这个`aidl`文件到自己的工程，然后再`ServiceConnection`的实现类中将这个参数使 
+用`asInterface`方法转成接口，通过这样来得到接口，从而调用接口中的方法     
+	```java
+	public class CallRemoteActivity extends Activity {
+		private Intent service;
+		private IService iService;
+		@Override
+		public void onCreate(Bundle savedInstanceState) {
+			super.onCreate(savedInstanceState);
+			setContentView(R.layout.main);
+			service = new Intent();
+			service.setAction("com.itheima.xxxx");
+		}
+		public void bind(View veiw){
+			bindService(service, new MyConn(), BIND_AUTO_CREATE);
+		}
+		public void call(View view){
+			try {
+				iService.callMethodInService();
+			} catch (RemoteException e) {
+				e.printStackTrace();
+			}
+		}
+		private class MyConn implements ServiceConnection{
+			@Override
+			public void onServiceConnected(ComponentName name, IBinder service) {
+				iService = IService.Stub.asInterface(service);
+			}
+			@Override
+			public void onServiceDisconnected(ComponentName name) {
+				// TODO Auto-generated method stub
+			}
+		}
+	}
+	```
+
+最后说一下`IntentService`:
+
+`IntentService`是`Service`的子类，用来处理异步请求。客户端可以通过`startService(Intent)`方法将请求的`Intent`传递请求给`IntentService`，
+`IntentService`会将该`Intent`加入到队列中，然后对每一个`Intent`开启一个`worker thread`来进行处理，执行完所有的工作之后自动停止`Service`。
+每一个请求都会在一个单独的`worker thread`中处理，不会阻塞应用程序的主线程。`IntentService` 实际上是`Looper`、`Handler`、`Service` 的集合体,
+他不仅有服务的功能,还有处理和循环消息的功能.
+
+- Service：    
+    1. A Service is not a separate process. The Service object itself does not imply it is running in its own process; unless otherwise specified, 
+		it runs in the same process as the application it is part of.
+    2. A Service is not a thread. It is not a means itself to do work off of the main thread (to avoid Application Not Responding errors).
+所以在`Service`中进行耗时的操作时必须要新开一个线程。    
+
+至于为什么要使用`Service`而不是`Thread`，这个主要的区别就是生命周期不同，`Service`是Android系统的一个组件，Android系统会尽量保持`Service`的长期后台运行，
+即使内存不足杀死了该服务(很少会出现内存不足杀死服务的情况)也会在内存可用的时候去复活该服务，而`Thread`随后都会被杀死
+- IntentService
+    1. IntentService is a base class for Services that handle asynchronous requests (expressed as Intents) on demand. 
+		Clients send requests throughstartService(Intent) calls; 
+	    the service is started as needed, handles each Intent in turn using a worker thread, and stops itself when it runs out of work.    
+    2. This "work queue processor" pattern is commonly used to offload tasks from an application's main thread. 
+		The IntentService class exists to simplify this pattern and take care of the mechanics. 
+	    To use it, extend IntentService and implement onHandleIntent(Intent). IntentService will receive the Intents, launch a worker thread, 
+		and stop the service as appropriate.
+    3. All requests are handled on a single worker thread -- they may take as long as necessary (and will not block the application's main loop), 
+		but only one request will be processed at a time.
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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"
new file mode 100644
index 00000000..319f5ef8
--- /dev/null
+++ "b/BasicKnowledge/Android\345\237\272\347\241\200\351\235\242\350\257\225\351\242\230.md"
@@ -0,0 +1,622 @@
+Android基础面试题
+===
+
+没有删这套题，虽然都是网上找的，在刚开始找工作的时候这套题帮了我很多，那时候`Android`刚起步，很多家都是这一套面试题，我都是直接去了不看题哗哗一顿就写完了，哈哈
+现在估计没有公司会用这种笔试题了。还是留下来吧，回忆一下。
+
+1. 下列哪些语句关于内存回收的说明是正确的? (b)          
+  A、 程序员必须创建一个线程来释放内存      
+  B、 内存回收程序负责释放无用内存     
+  C、 内存回收程序允许程序员直接释放内存      
+  D、 内存回收程序可以在指定的时间释放内存对象      
+2. 下面异常是属于Runtime Exception 的是（abcd）(多选)             
+      A、ArithmeticException          
+      B、IllegalArgumentException       
+      C、NullPointerException         
+      D、BufferUnderflowException        
+3. Math.round(11.5)等于多少(). Math.round(-11.5)等于多少(c)           
+    A、11 ,-11   B、11 ,-12   C、12 ,-11   D、12 ,-12 
+4. 下列程序段的输出结果是：(b)              
+    ```java
+     void complicatedexpression_r(){
+     int x=20, y=30;
+     boolean b;
+     b=x>50&&y>60||x>50&&y<-60||x<-50&&y>60||x<-50&&y<-60;
+     System.out.println(b);
+     }
+	 ```
+     A、true  B、false  C、1  D、011.activity
+5. 对一些资源以及状态的操作保存，最好是保存在生命周期的哪个函数中进行(d)     
+   A、onPause()  B、onCreate()   C、 onResume()   D、onStart()  
+6. Intent传递数据时，下列的数据类型哪些可以被传递（abcd）(多选)            
+   A、Serializable  B、charsequence  C、Parcelable  D、Bundle
+7. android 中下列属于Intent的作用的是(c)     
+  A、实现应用程序间的数据共享      
+  B、是一段长的生命周期，没有用户界面的程序，可以保持应用在后台运行，而不会因为切换页面而消失         
+  C、可以实现界面间的切换，可以包含动作和动作数据，连接四大组件的纽带       
+  D、处理一个应用程序整体性的工作     
+8. 下列属于SAX解析xml文件的优点的是(b)          
+    A、将整个文档树在内存中，便于操作，支持删除，修改，重新排列等多种功能        
+    B、不用事先调入整个文档，占用资源少          
+    C、整个文档调入内存，浪费时间和空间           
+    D、不是长久驻留在内存，数据不是持久的，事件过后，若没有保存数据，数据就会消失           
+9. 下面的对自定style的方式正确的是(a)     
+    A、           
+	```xml
+	<resources>
+		<style name="myStyle">
+			<item name="android:layout_width">fill_parent</item>
+		</style>
+	</resources>
+	```                
+     B、              
+	 ```xml
+	<style name="myStyle">
+				<item name="android:layout_width">fill_parent</item>
+	</style>
+	```          
+     C、               
+	```xml 
+	<resources>
+		<item name="android:layout_width">fill_parent</item>
+	</resources>
+	```        
+     D、       
+	 ```xml
+	<resources>
+		<style name="android:layout_width">fill_parent</style>
+	</resources>
+	```
+10. 在android中使用Menu时可能需要重写的方法有（ac）。(多选)                
+	A、onCreateOptionsMenu()        
+	B、onCreateMenu()      
+	C、onOptionsItemSelected()    
+	D、onItemSelected()       
+11. 在SQL Server Management Studio 中运行下列T-SQL语句，其输出值（c）               
+	`SELECT @@IDENTITY`      
+	A、	可能为0.1        
+	B、	可能为3       
+	C、 不可能为-100   
+	D、	肯定为0    
+12. 在SQL Server 2005中运行如下T-SQL语句，假定SALES表中有多行数据，执行查询之后的结果是（d）。                               
+	```
+	BEGIN TRANSACTION A
+ 	Update SALES Set qty=30 WHERE qty<30
+	BEGIN TRANSACTION B
+		Update SALES Set qty=40 WHERE qty<40
+		Update SALES Set qty=50 WHERE qty<50
+		Update SALES Set qty=60 WHERE qty<60
+	COMMIT　TRANSACTION B
+	COMMIT TRANSACTION A
+	 ```              
+	A、SALES表中qty列最小值大于等于30        
+	B、SALES表中qty列最小值大于等于40       
+	C、SALES表中qty列的数据全部为50     
+	D、SALES表中qty列最小值大于等于60     
+13. 在android中使用SQLiteOpenHelper这个辅助类时，可以生成一个数据库，并可以对数据库版本进行管理的方法可以是(ab)           
+	A、getWriteableDatabase()        
+	B、getReadableDatabase()        
+	C、getDatabase()        
+	D、getAbleDatabase()        
+14.	android 关于service生命周期的onCreate()和onStart()说法正确的是(ad)(多选题)             
+	A、当第一次启动的时候先后调用onCreate()和onStart()方法         
+	B、当第一次启动的时候只会调用onCreate()方法               
+	C、如果service已经启动，将先后调用onCreate()和onStart()方法         
+	D、如果service已经启动，只会执行onStart()方法，不在执行onCreate()方法        
+15. 下面是属于GLSurFaceView特性的是(abc)(多选)         
+	A、管理一个surface，这个surface就是一块特殊的内存，能直接排版到android的视图view上。            
+	B、管理一个EGL display，它能让opengl把内容渲染到上述的surface上。           
+	C、让渲染器在独立的线程里运作，和UI线程分离。        
+	D、可以直接从内存或者DMA等硬件接口取得图像数据          
+16. 下面在AndroidManifest.xml文件中注册BroadcastReceiver方式正确的(a)            
+  	A、        
+	```xml
+	<receiver android:name="NewBroad">
+		<intent-filter>
+			<action  
+			   android:name="android.provider.action.NewBroad"/>
+			<action>
+		</intent-filter>
+	</receiver>
+	```             
+    B、       
+	```xml
+	<receiver android:name="NewBroad">
+		<intent-filter>
+			android:name="android.provider.action.NewBroad"/>
+		</intent-filter>
+	</receiver>
+	```           
+    C、         
+	 ```xml
+	<receiver android:name="NewBroad">
+		<action  
+			  android:name="android.provider.action.NewBroad"/>
+		 <action>
+	</receiver>
+	```          
+    D、               
+    ```xml
+	<intent-filter>
+		<receiver android:name="NewBroad">
+			<action> 
+			   android:name="android.provider.action.NewBroad"/>
+			<action>
+		</receiver>
+	</intent-filter>
+	```          
+17. 关于ContenValues类说法正确的是(a)        
+    A、他和Hashtable比较类似，也是负责存储一些名值对，但是他存储的名值对当中的名是String类型，而值都是基本类型        
+    B、他和Hashtable比较类似，也是负责存储一些名值对，但是他存储的名值对当中的名是任意类型，而值都是基本类型           
+    C、他和Hashtable比较类似，也是负责存储一些名值对，但是他存储的名值对当中的名，可以为空，而值都是String类型        
+    D、他和Hashtable比较类似，也是负责存储一些名值对，但是他存储的名值对当中的名是String类型，而值也是String类型    
+18. 我们都知道Hanlder是线程与Activity通信的桥梁,如果线程处理不当，你的机器就会变得越慢，那么线程销毁的方法是(a)       
+    A、onDestroy()         
+    B、onClear()      
+    C、onFinish()      
+    D、onStop()        
+19. 下面退出Activity错误的方法是(c)
+    A、finish()        
+ 	B、抛异常强制退出        
+    C、System.exit()        
+    D、onStop()      
+20. 下面属于android的动画分类的有(ab)(多项)      
+    A、Tween  B、Frame C、Draw D、Animation 
+21.	下面关于Android dvm的进程和Linux的进程,应用程序的进程说法正确的是(d)          
+    A、DVM指dalivk的虚拟机.每一个Android应用程序都在它自己的进程中运行,不一定拥有一个独立 的Dalvik虚拟机实例.而每一个DVM都是在Linux 中的一个进程,
+	所以说可以认为是同一个概念.                
+    B、DVM指dalivk的虚拟机.每一个Android应用程序都在它自己的进程中运行,不一定拥有一个独立的Dalvik虚拟机实例.而每一个DVM不一定都是在Linux 中的一个进程,
+	所以说不是一个概念.        
+    C、DVM指dalivk的虚拟机.每一个Android应用程序都在它自己的进程中运行,都拥有一个独立的Dalvik虚拟机实例.而每一个DVM不一定都是在Linux 中的一个进程,
+	所以说不是一个概念.              
+    D、DVM指dalivk的虚拟机.每一个Android应用程序都在它自己的进程中运行,都拥有一个独立的 Dalvik虚拟机实例.而每一个DVM都是在Linux 中的一个进程,
+	所以说可以认为是同一个概念.       
+22. Android项目工程下面的assets目录的作用是什么(b)      
+	A、放置应用到的图片资源。      
+	B、主要放置多媒体等数据文件          
+	C、放置字符串，颜色，数组等常量数据           
+	D、放置一些与UI相应的布局文件，都是xml文件       
+23. 关于res/raw目录说法正确的是(a)    
+	A、这里的文件是原封不动的存储到设备上不会转换为二进制的格式         
+	B、这里的文件是原封不动的存储到设备上会转换为二进制的格式         
+	C、这里的文件最终以二进制的格式存储到指定的包中       
+	D、这里的文件最终不会以二进制的格式存储到指定的包中      
+24. 下列对android NDK的理解正确的是(abcd)      
+	A、NDK是一系列工具的集合         
+	B、NDK 提供了一份稳定、功能有限的 API 头文件声明。      
+	C、使 “Java+C” 的开发方式终于转正，成为官方支持的开发方式      
+	D、NDK 将是 Android 平台支持 C 开发的开端        
+	
+25. android中常用的四个布局是framlayout，linenarlayout，relativelayout和tablelayout。
+26. android 的四大组件是activiey，service，broadcast和contentprovide。
+27. java.io包中的objectinputstream和objectoutputstream类主要用于对对象(Object)的读写。
+28. android 中service的实现方法是：startservice和bindservice。
+29. activity一般会重载7个方法用来维护其生命周期，除了onCreate(),onStart(),onDestory() 	 外还有onrestart,onresume,onpause,onstop。
+30. android的数据存储的方式sharedpreference,文件,SQlite,contentprovider,网络。
+31.	当启动一个Activity并且新的Activity执行完后需要返回到启动它的Activity来执行 的回调函数是startActivityResult()。
+32.	请使用命令行的方式创建一个名字为myAvd,sdk版本为2.2,sd卡是在d盘的根目录下,名字为scard.img， 并指定屏幕大小HVGA.____________________________________。
+33.	程序运行的结果是：_____good and gbc__________。
+	```java
+    public class Example{ 
+	　　String str=new String("good"); 
+	　　char[]ch={'a','b','c'}; 
+	　　public static void main(String args[]){ 
+	　　　　Example ex=new Example(); 
+	　　　　ex.change(ex.str,ex.ch); 
+	　　　　System.out.print(ex.str+" and "); 
+	　　　　Sytem.out.print(ex.ch); 
+	　　} 
+	　　public void change(String str,char ch[]){ 
+	　　　　str="test ok"; 
+	　　　　ch[0]='g'; 
+	　　} 
+	}
+	```
+34. 在android中，请简述jni的调用过程。(8分)         
+	1)安装和下载Cygwin，下载 Android NDK          
+	2)在ndk项目中JNI接口的设计        
+	3)使用C/C++实现本地方法      
+	4)JNI生成动态链接库.so文件           
+	5)将动态链接库复制到java工程，在java工程中调用，运行java工程即可            
+35. 简述Android应用程序结构是哪些?(7分)              
+	Android应用程序结构是：          
+	Linux Kernel(Linux内核)、Libraries(系统运行库或者是c/c++核心库)、Application          
+	Framework(开发框架包)、Applications	(核心应用程序)   
+36.	请继承SQLiteOpenHelper实现：(10分)              
+	1）.创建一个版本为1的“diaryOpenHelper.db”的数据库             
+	2）.同时创建一个 “diary” 表（包含一个_id主键并自增长，topic字符型100长度， content字符型1000长度）        
+	3）.在数据库版本变化时请删除diary表，并重新创建出diary表。          
+	```java
+	public class DBHelper  extends SQLiteOpenHelper {
+
+		public final static String DATABASENAME = "diaryOpenHelper.db";
+		public final static int DATABASEVERSION = 1;
+
+		//创建数据库
+		public DBHelper(Context context,String name,CursorFactory factory,int version)
+		{
+			super(context, name, factory, version);
+		}
+		//创建表等机构性文件
+		public void onCreate(SQLiteDatabase db)
+		{
+			String sql ="create table diary"+
+						"("+
+						"_id integer primary key autoincrement,"+
+						"topic varchar(100),"+
+						"content varchar(1000)"+
+						")";
+			db.execSQL(sql);
+		}
+		//若数据库版本有更新，则调用此方法
+		public void onUpgrade(SQLiteDatabase db,int oldVersion,int newVersion)
+		{
+			
+			String sql = "drop table if exists diary";
+			db.execSQL(sql);
+			this.onCreate(db);
+		}
+	}
+	```
+37. 页面上现有ProgressBar控件progressBar，请用书写线程以10秒的的时间完成其进度显示工作。（10分）           
+	```java
+	public class ProgressBarStu extends Activity {
+
+		private ProgressBar progressBar = null;
+		protected void onCreate(Bundle savedInstanceState) {
+			super.onCreate(savedInstanceState);
+			setContentView(R.layout.progressbar);
+			//从这到下是关键
+			progressBar = (ProgressBar)findViewById(R.id.progressBar);
+			
+			Thread thread = new Thread(new Runnable() {
+				
+				@Override
+				public void run() {
+					int progressBarMax = progressBar.getMax();
+					try {
+						while(progressBarMax!=progressBar.getProgress())
+						{
+							
+							int stepProgress = progressBarMax/10;
+							int currentprogress = progressBar.getProgress();
+							progressBar.setProgress(currentprogress+stepProgress);
+							Thread.sleep(1000);
+						}
+						
+					} catch (InterruptedException e) {
+						// TODO Auto-generated catch block
+						e.printStackTrace();
+					}
+					
+				}
+			});
+			
+			thread.start();
+			//关键结束
+		}
+	}
+	```
+38. 如何退出Activity？如何安全退出已调用多个Activity的Application？             
+	对于单一Activity的应用来说，退出很简单，直接finish()即可。         
+	当然，也可以用killProcess()和System.exit()这样的方法。          
+	但是，对于多Activity的应用来说，在打开多个Activity后，如果想在最后打开的Activity直接退出，上边的方法都是没有用的，因为上边的方法都是结束一个Activity而已。      
+	当然，网上也有人说可以。   
+	就好像有人问，在应用里如何捕获Home键，有人就会说用keyCode比较KEYCODE_HOME即可，而事实上如果不修改framework，根本不可能做到这一点一样。      
+	所以，最好还是自己亲自试一下。          
+	那么，有没有办法直接退出整个应用呢？      
+	在2.1之前，可以使用ActivityManager的restartPackage方法。        
+	它可以直接结束整个应用。在使用时需要权限android.permission.RESTART_PACKAGES。          
+	注意不要被它的名字迷惑。         
+	可是，在2.2，这个方法失效了。        
+	在2.2添加了一个新的方法，killBackgroundProcesses()，需要权限 android.permission.KILL_BACKGROUND_PROCESSES。          
+	可惜的是，它和2.2的restartPackage一样，根本起不到应有的效果。        
+	另外还有一个方法，就是系统自带的应用程序管理里，强制结束程序的方法，forceStopPackage()。         
+	它需要权限android.permission.FORCE_STOP_PACKAGES。            
+	并且需要添加android:sharedUserId="android.uid.system"属性        
+	同样可惜的是，该方法是非公开的，他只能运行在系统进程，第三方程序无法调用。          
+	因为需要在Android.mk中添加LOCAL_CERTIFICATE := platform。           
+	而Android.mk是用于在Android源码下编译程序用的。             
+	从以上可以看出，在2.2，没有办法直接结束一个应用，而只能用自己的办法间接办到。        
+	现提供几个方法，供参考：     
+	- 抛异常强制退出：      
+		该方法通过抛异常，使程序Force Close。
+		验证可以，但是，需要解决的问题是，如何使程序结束掉，而不弹出Force Close的窗口。
+	- 记录打开的Activity：
+	    每打开一个Activity，就记录下来。在需要退出时，关闭每一个Activity即可。
+	- 发送特定广播：
+		在需要结束应用时，发送一个特定的广播，每个Activity收到广播后，关闭即可。
+	- 递归退出     
+		在打开新的Activity时使用startActivityForResult，然后自己加标志，在onActivityResult中处理，递归关闭。
+	除了第一个，都是想办法把每一个Activity都结束掉，间接达到目的。       
+	但是这样做同样不完美。          
+	你会发现，如果自己的应用程序对每一个Activity都设置了nosensor，在两个Activity结束的间隙，sensor可能有效了。      
+	但至少，我们的目的达到了，而且没有影响用户使用。      
+	为了编程方便，最好定义一个Activity基类，处理这些共通问题。       
+39. 请介绍下Android中常用的五种布局。             
+	FrameLayout（框架布局），LinearLayout （线性布局），AbsoluteLayout（绝对布局），RelativeLayout（相对布局），TableLayout（表格布局）
+40. 请介绍下Android的数据存储方式。        
+	- SharedPreferences方式
+	- 文件存储方式
+	- SQLite数据库方式
+	- 内容提供器（Content provider）方式
+	- 网络存储方式
+41. 请介绍下ContentProvider是如何实现数据共享的。         
+	创建一个属于你自己的Content provider或者将你的数据添加到一个已经存在的Content provider中，前提是有相同数据类型并且有写入Content provider的权限。
+42. 如何启用Service，如何停用Service。            
+	Android中的service类似于windows中的service，service一般没有用户操作界面，它运行于系统中不容易被用户发觉，
+	可以使用它开发如监控之类的程序。
+	一。步骤
+	第一步：继承Service类
+	public class SMSService extends Service { }
+	第二步：在AndroidManifest.xml文件中的<application>节点里对服务进行配置:
+	<service android:name=".DemoService" />
+	二。Context.startService()和Context.bindService
+	服务不能自己运行，需要通过调用Context.startService()或Context.bindService()方法启动服务。这两个方法都可
+	以启动Service，但是它们的使用场合有所不同。         
+	1.使用startService()方法启用服务，调用者与服务之间没有关连，即使调用者退出了，服务仍然运行。
+	使用bindService()方法启用服务，调用者与服务绑定在了一起，调用者一旦退出，服务也就终止。           
+	2.采用Context.startService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，
+	接着调用onStart()方法。如果调用startService()方法前服务已经被创建，多次调用startService()方法并
+	不会导致多次创建服务，但会导致多次调用onStart()方法。
+	采用startService()方法启动的服务，只能调用Context.stopService()方法结束服务，服务结束时会调用
+	onDestroy()方法。 
+	 
+	3.采用Context.bindService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，
+	接着调用onBind()方法。这个时候调用者和服务绑定在一起，调用者退出了，系统就会先调用服务的onUnbind()方法，
+	。接着调用onDestroy()方法。如果调用bindService()方法前服务已经被绑定，多次调用bindService()方法并不会
+	导致多次创建服务及绑定(也就是说onCreate()和onBind()方法并不会被多次调用)。如果调用者希望与正在绑定的服务
+	解除绑定，可以调用unbindService()方法，调用该方法也会导致系统调用服务的onUnbind()-->onDestroy()方法。
+	三。Service的生命周期
+	1. Service常用生命周期回调方法如下：
+	onCreate() 该方法在服务被创建时调用，该方法只会被调用一次，无论调用多少次startService()或bindService()方法，
+	服务也只被创建一次。 onDestroy()该方法在服务被终止时调用。 
+	2. Context.startService()启动Service有关的生命周期方法
+	onStart() 只有采用Context.startService()方法启动服务时才会回调该方法。该方法在服务开始运行时被调用。
+	多次调用startService()方法尽管不会多次创建服务，但onStart() 方法会被多次调用。
+	3. Context.bindService()启动Service有关的生命周期方法
+	onBind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务绑定时被调用，
+	当调用者与服务已经绑定，多次调用Context.bindService()方法并不会导致该方法被多次调用。
+	onUnbind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务解除绑定时被调用。
+	
+	备注：
+	1. 采用startService()启动服务
+		 Intent intent = new Intent(DemoActivity.this, DemoService.class);
+		 startService(intent);
+	2. Context.bindService()启动
+		Intent intent = new Intent(DemoActivity.this, DemoService.class);
+		bindService(intent, conn, Context.BIND_AUTO_CREATE);
+	   //unbindService(conn);//解除绑定
+43. 注册广播有几种方式，这些方式有何优缺点？请谈谈Android引入广播机制的用意。            
+	Android广播机制（两种注册方法）             
+	在android下，要想接受广播信息，那么这个广播接收器就得我们自己来实现了，我们可以继承BroadcastReceiver，就可以有一个广播接受器了。
+	有个接受器还不够，我们还得重写BroadcastReceiver里面的onReceiver方法，当来广播的时候我们要干什么，这就要我们自己来实现，
+	不过我们可以搞一个信息防火墙。具体的代码：  
+	```java
+	public class SmsBroadCastReceiver extends BroadcastReceiver {   
+		@Override  
+		public void onReceive(Context context, Intent intent) {   
+			Bundle bundle = intent.getExtras();   
+			Object[] object = (Object[])bundle.get("pdus");   
+			SmsMessage sms[]=new SmsMessage[object.length];   
+			for(int i=0;i<object.length;i++) {   
+				sms[0] = SmsMessage.createFromPdu((byte[])object[i]);   
+				Toast.makeText(context, "来自"+sms[i].getDisplayOriginatingAddress()+" 的消息是："+sms[i].getDisplayMessageBody(), Toast.LENGTH_SHORT).show();   
+			}   
+			//终止广播，在这里我们可以稍微处理，根据用户输入的号码可以实现短信防火墙。   
+			abortBroadcast();   
+		}          
+	}  
+	```
+	当实现了广播接收器，还要设置广播接收器接收广播信息的类型，这里是信息：android.provider.Telephony.SMS_RECEIVED 
+	我们就可以把广播接收器注册到系统里面，可以让系统知道我们有个广播接收器。这里有两种，
+	一种是代码动态注册：     
+	```java
+	//生成广播处理   
+	smsBroadCastReceiver = new SmsBroadCastReceiver();   
+	//实例化过滤器并设置要过滤的广播   
+	IntentFilter intentFilter = new IntentFilter("android.provider.Telephony.SMS_RECEIVED"); 
+	//注册广播   
+	BroadCastReceiverActivity.this.registerReceiver(smsBroadCastReceiver, intentFilter);  
+	```
+	一种是在AndroidManifest.xml中配置广播
+	```xml
+	<?xml version="1.0" encoding="utf-8"?>  
+	<manifest xmlns:android="http://schemas.android.com/apk/res/android"  
+		  package="spl.broadCastReceiver"  
+		  android:versionCode="1"  
+		  android:versionName="1.0">  
+		<application android:icon="@drawable/icon" android:label="@string/app_name">  
+			<activity android:name=".BroadCastReceiverActivity"  
+					  android:label="@string/app_name">  
+				<intent-filter>  
+					<action android:name="android.intent.action.MAIN" />  
+					<category android:name="android.intent.category.LAUNCHER" />  
+				</intent-filter>  
+			</activity>  
+			   
+			<!--广播注册-->  
+			<receiver android:name=".SmsBroadCastReceiver">  
+				<intent-filter android:priority="20">  
+					<action android:name="android.provider.Telephony.SMS_RECEIVED"/>  
+				</intent-filter>  
+			</receiver>  
+			   
+		</application>  
+		   
+		<uses-sdk android:minSdkVersion="7" />  
+		   
+		<!-- 权限申请 -->  
+		<uses-permission android:name="android.permission.RECEIVE_SMS"></uses-permission>  
+	</manifest>   
+	```
+	两种注册类型的区别是：        
+	- 第一种不是常驻型广播，也就是说广播跟随程序的生命周期。
+    - 第二种是常驻型，也就是说当应用程序关闭后，如果有信息广播来，程序也会被系统调用自动运行。
+44. 请解释下在单线程模型中Message、Handler、Message Queue、Looper之间的关系。          
+    Handler简介：
+    一个Handler允许你发送和处理Message和Runable对象，这些对象和一个线程的MessageQueue相关联。每一个线程实例和一个单独的线程以及该线程的MessageQueue相关联。
+    当你创建一个新的Handler时，它就和创建它的线程绑定在一起了。这里，线程我们也可以理解为线程的MessageQueue。从这一点上来看，
+    Handler把Message和Runable对象传递给MessageQueue，而且在这些对象离开MessageQueue时，Handler负责执行他们。
+    Handler有两个主要的用途：（1）确定在将来的某个时间点执行一个或者一些Message和Runnable对象。（2）在其他线程（不是Handler绑定线程）中排入一些要执行的动作。
+    Scheduling Message，即（1），可以通过以下方法完成：       
+    post(Runnable):Runnable在handler绑定的线程上执行，也就是说不创建新线程。     
+    postAtTime(Runnable,long):         
+    postDelayed(Runnable,long):        
+    sendEmptyMessage(int):       
+    sendMessage(Message):      
+    sendMessageAtTime(Message,long):        
+    sendMessageDelayed(Message,long):         
+    post这个动作让你把Runnable对象排入MessageQueue,MessageQueue受到这些消息的时候执行他们，当然以一定的排序。sendMessage这个动作允许你把Message对象排成队列，
+    这些Message对象包含一些信息，Handler的hanlerMessage(Message)会处理这些Message.当然，handlerMessage(Message)必须由Handler的子类来重写。这是编程人员需要作的事。
+    当posting或者sending到一个Hanler时，你可以有三种行为：当MessageQueue准备好就处理，定义一个延迟时间，定义一个精确的时间去处理。
+    后两者允许你实现timeout,tick,和基于时间的行为。           
+    当你的应用创建一个新的进程时，主线程（也就是UI线程）自带一个MessageQueue，这个MessageQueue管理顶层的应用对象（像activities,broadcast receivers等）和
+    主线程创建的窗体。你可以创建自己的线程，并通过一个Handler和主线程进行通信。这和之前一样，通过post和sendmessage来完成，差别在于在哪一个线程中执行这么方法。
+    在恰当的时候，给定的Runnable和Message将在Handler的MessageQueue中被Scheduled。      
+    Message简介：         
+    Message类就是定义了一个信息，这个信息中包含一个描述符和任意的数据对象，这个信息被用来传递给Handler.Message对象提供额外的两个int域和一个Object域，
+    这可以让你在大多数情况下不用作分配的动作。尽管Message的构造函数是public的，但是获取Message实例的最好方法是调用Message.obtain(),
+    或者Handler.obtainMessage()方法，这些方法会从回收对象池中获取一个。            
+    MessageQueue简介：           
+    这是一个包含message列表的底层类。Looper负责分发这些message。Messages并不是直接加到一个MessageQueue中，而是通过MessageQueue.IdleHandler关联到Looper。
+    你可以通过Looper.myQueue()从当前线程中获取MessageQueue。       
+    Looper简介：                
+    Looper类被用来执行一个线程中的message循环。默认情况，没有一个消息循环关联到线程。在线程中调用prepare()创建一个Looper，然后用loop()来处理messages，直到循环终止。
+    大多数和message loop的交互是通过Handler。    
+    下面是一个典型的带有Looper的线程实现。
+    ```java
+    class LooperThread extends Thread {
+      public Handler mHandler;
+      
+      public void run() {
+    	  Looper.prepare();
+    	  
+    	  mHandler = new Handler() {
+    		  public void handleMessage(Message msg) {
+    			  // process incoming messages here
+    		  }
+    	  };
+    	  
+    	  Looper.loop();
+      }
+    }
+    ```
+45. AIDL的全称是什么？如何工作？能处理哪些类型的数据？           
+	AIDL的英文全称是Android Interface Define Language
+	当A进程要去调用B进程中的service时，并实现通信，我们通常都是通过AIDL来操作的
+	A工程：           
+	首先我们在net.blogjava.mobile.aidlservice包中创建一个RemoteService.aidl文件，在里面我们自定义一个接口，含有方法get。ADT插件会在gen目录下自动生成一个RemoteService.java文件，该类中含有一个名为RemoteService.stub的内部类，该内部类中含有aidl文件接口的get方法。
+	说明一：aidl文件的位置不固定，可以任意
+	然后定义自己的MyService类，在MyService类中自定义一个内部类去继承RemoteService.stub这个内部类，实现get方法。在onBind方法中返回这个内部类的对象，系统会自动将这个对象封装成IBinder对象，传递给他的调用者。
+	其次需要在AndroidManifest.xml文件中配置MyService类，代码如下：
+	<!-- 注册服务 -->  
+	<service android:name=".MyService"> 
+	   <intent-filter> 
+	   <!--  指定调用AIDL服务的ID  --> 
+		   <action android:name="net.blogjava.mobile.aidlservice.RemoteService" /> 
+		</intent-filter> 
+	</service>
+	为什么要指定调用AIDL服务的ID,就是要告诉外界MyService这个类能够被别的进程访问，只要别的进程知道这个ID，正是有了这个ID,B工程才能找到A工程实现通信。
+	说明：AIDL并不需要权限
+	B工程：
+	首先我们要将A工程中生成的RemoteService.java文件拷贝到B工程中，在bindService方法中绑定aidl服务
+	绑定AIDL服务就是将RemoteService的ID作为intent的action参数。
+	说明：如果我们单独将RemoteService.aidl文件放在一个包里，那个在我们将gen目录下的该包拷贝到B工程中。如果我们将RemoteService.aidl文件和我们的其他类存放在一起，那么我们在B工程中就要建立相应的包，以保证RmoteService.java文件的报名正确，我们不能修改RemoteService.java文件
+	   bindService(new Inten("net.blogjava.mobile.aidlservice.RemoteService"), serviceConnection, Context.BIND_AUTO_CREATE); 
+	ServiceConnection的onServiceConnected(ComponentName name, IBinder service)方法中的service参数就是A工程中MyService类中继承了RemoteService.stub类的内部类的对象。
+46. 请解释下Android程序运行时权限与文件系统权限的区别。           
+	运行时权限Dalvik( android授权) 
+	文件系统 linux 内核授权
+47. 系统上安装了多种浏览器，能否指定某浏览器访问指定页面？请说明原由。          
+	通过直接发送Uri把参数带过去，或者通过manifest里的intentfilter里的data属性
+48. 你如何评价Android系统？优缺点。           
+	答：Android平台手机 5大优势： 
+	- 开放性 
+		在优势方面，Android平台首先就是其开发性，开发的平台允许任何移动终端厂商加入到Android联盟中来。显著的开放性可以使其拥有更多的开发者，
+		随着用户和应用的日益丰富，一个崭新的平台也将很快走向成熟。开放性对于Android的发展而言，有利于积累人气，这里的人气包括消费者和厂商，
+		而对于消费者来讲，随大的受益正是丰富的软件资源。开放的平台也会带来更大竞争，如此一来，消费者将可以用更低的价位购得心仪的手机。
+	- 挣脱运营商的束缚 
+		在过去很长的一段时间，特别是在欧美地区，手机应用往往受到运营商制约，使用什么功能接入什么网络，几乎都受到运营商的控制。从去年iPhone 上市 ，
+		用户可以更加方便地连接网络，运营商的制约减少。随着EDGE、HSDPA这些2G至3G移动网络的逐步过渡和提升，手机随意接入网络已不是运营商口中的笑谈，
+		当你可以通过手机IM软件方便地进行即时聊天时，再回想不久前天价的彩信和图铃下载业务，是不是像噩梦一样？互联网巨头Google推动的Android终端天生就有网络特色，
+		将让用户离互联网更近。
+	- 丰富的硬件选择 
+		这一点还是与Android平台的开放性相关，由于Android的开放性，众多的厂商会推出千奇百怪，功能特色各具的多种产品。功能上的差异和特色，
+		却不会影响到数据同步、甚至软件的兼容，好比你从诺基亚 Symbian风格手机 一下改用苹果 iPhone ，同时还可将Symbian中优秀的软件带到iPhone上使用、
+		联系人等资料更是可以方便地转移，是不是非常方便呢？
+	- 不受任何限制的开发商 
+		Android平台提供给第三方开发商一个十分宽泛、自由的环境，不会受到各种条条框框的阻扰，可想而知，会有多少新颖别致的软件会诞生。但也有其两面性，血腥、暴力、情色方面的程序和游戏如可控制正是留给Android难题之一。
+	- 无缝结合的Google应用 
+		如今叱诧互联网的Google已经走过10年度历史，从搜索巨人到全面的互联网渗透，Google服务如地图、邮件、搜索等已经成为连接用户和互联网的重要纽带，
+		而Android平台手机将无缝结合这些优秀的Google服务。            
+
+	再说Android的5大不足：
+	- 安全和隐私 
+		由于手机 与互联网的紧密联系，个人隐私很难得到保守。除了上网过程中经意或不经意留下的个人足迹，Google这个巨人也时时站在你的身后，
+		洞穿一切，因此，互联网的深入将会带来新一轮的隐私危机。
+	- 首先开卖Android手机的不是最大运营商 
+		众所周知，T-Mobile在23日，于美国纽约发布 了Android首款手机G1。但是在北美市场，最大的两家运营商乃AT&T和Verizon，
+		而目前所知取得Android手机销售权的仅有 T-Mobile和Sprint，其中T-Mobile的3G网络相对于其他三家也要逊色不少，因此，用户可以买账购买G1，
+		能否体验到最佳的3G网络服务则要另当别论了！
+	- 运营商仍然能够影响到Android手机 
+		在国内市场，不少用户对购得移动定制机不满，感觉所购的手机被人涂画了广告一般。这样的情况在国外市场同样出现。
+		Android手机的另一发售运营商Sprint就将在其机型中内置其手机商店程序。
+	- 同类机型用户减少 
+		在不少手机论坛都会有针对某一型号的子论坛，对一款手机的使用心得交流，并分享软件资源。而对于Android平台手机，由于厂商丰富，
+		产品类型多样，这样使用同一款机型的用户越来越少，缺少统一机型的程序强化。举个稍显不当的例子，现在山寨机泛滥，品种各异，
+		就很少有专门针对某个型号山寨机的讨论和群组，除了哪些功能异常抢眼、颇受追捧的机型以外。
+	- 过分依赖开发商缺少标准配置 
+		在使用PC端的Windows Xp系统的时候，都会内置微软Windows Media Player这样一个浏览器程序，用户可以选择更多样的播放器，
+		如Realplay或暴风影音等。但入手开始使用默认的程序同样可以应付多样的需要。在 Android平台中，由于其开放性，软件更多依赖第三方厂商，
+		比如Android系统的SDK中就没有内置音乐 播放器，全部依赖第三方开发，缺少了产品的统一性。
+49. 什么是ANR 如何避免它?               
+　　答：ANR：Application Not Responding，五秒 
+	在Android中，活动管理器和窗口管理器这两个系统服务负责监视应用程序的响应。当出现下列情况时，Android就会显示ANR对话框了：        
+	对输入事件(如按键、触摸屏事件)的响应超过5秒     
+	意向接受器(intentReceiver)超过10秒钟仍未执行完毕 
+	Android应用程序完全运行在一个独立的线程中(例如main)。这就意味着，任何在主线程中运行的，需要消耗大量时间的操作都会引发ANR。
+	因为此时，你的应用程序已经没有机会去响应输入事件和意向广播(Intent broadcast)。          
+	因此，任何运行在主线程中的方法，都要尽可能的只做少量的工作。特别是活动生命周期中的重要方法如onCreate()和 onResume()等更应如此。
+	潜在的比较耗时的操作，如访问网络和数据库;或者是开销很大的计算，比如改变位图的大小，需要在一个单独的子线程中完成(或者是使用异步请求，如数据库操作)。
+	但这并不意味着你的主线程需要进入阻塞状态已等待子线程结束 -- 也不需要调用Therad.wait()或者Thread.sleep()方法。
+	取而代之的是，主线程为子线程提供一个句柄(Handler)，让子线程在即将结束的时候调用它(xing:可以参看Snake的例子，这种方法与以前我们所接触的有所不同)。
+	使用这种方法涉及你的应用程序，能够保证你的程序对输入保持良好的响应，从而避免因为输入事件超过5秒钟不被处理而产生的ANR。
+	这种实践需要应用到所有显示用户界面的线程，因为他们都面临着同样的超时问题。 
+50. 什么情况会导致Force Close ?如何避免?能否捕获导致其的异常?           
+	答：一般像空指针啊，可以看起logcat，然后对应到程序中 来解决错误 
+　　
+51. 如何将SQLite数据库(dictionary.db文件)与apk文件一起发布?             
+	解答：可以将dictionary.db文件复制到Eclipse Android工程中的res aw目录中。所有在res aw目录中的文件不会被压缩，这样可以直接提取该目录中的文件。
+	可以将dictionary.db文件复制到res aw目录中 
+52. 如何将打开res aw目录中的数据库文件?            
+	解答：在Android中不能直接打开res aw目录中的数据库文件，而需要在程序第一次启动时将该文件复制到手机内存或SD卡的某个目录中，然后再打开该数据库文件。复制的基本方法是使用getResources().openRawResource方法获得res aw目录中资源的 InputStream对象，然后将该InputStream对象中的数据写入其他的目录中相应文件中。
+	在Android SDK中可以使用SQLiteDatabase.openOrCreateDatabase方法来打开任意目录中的SQLite数据库文件。 
+53. Android引入广播机制的用意?            
+	- 从MVC的角度考虑(应用程序内) 
+　		其实回答这个问题的时候还可以这样问，android为什么要有那4大组件，现在的移动开发模型基本上也是照搬的web那一套MVC架构，只不过是改了点嫁妆而已。
+		android的四大组件本质上就是为了实现移动或者说嵌入式设备上的MVC架构，它们之间有时候是一种相互依存的关系，有时候又是一种补充关系，
+		引入广播机制可以方便几大组件的信息和数据交互。 
+	- 程序间互通消息(例如在自己的应用程序内监听系统来电) 
+	- 效率上(参考UDP的广播协议在局域网的方便性) 
+	- 设计模式上(反转控制的一种应用，类似监听者模式)
+54. Android dvm的进程和Linux的进程, 应用程序的进程是否为同一个概念          
+	DVM指dalivk的虚拟机。每一个Android应用程序都在它自己的进程中运行，都拥有一个独立的Dalvik虚拟机实例。而每一个DVM都是在Linux 中的一个进程，
+	所以说可以认为是同一个概念。 
+55.	说说mvc模式的原理，它在android中的运用            
+	MVC(Model_view_contraller)”模型_视图_控制器”。 MVC应用程序总是由这三个部分组成。Event(事件)导致Controller改变Model或View，或者同时改变两者。
+	只要 Controller改变了Models的数据或者属性，所有依赖的View都会自动更新。类似的，只要Contro 
+56. DDMS和TraceView的区别?           
+	DDMS是一个程序执行查看器，在里面可以看见线程和堆栈等信息，TraceView是程序性能分析器 。
+57. java中如何引用本地语言               
+	可以用JNI（java native interface  java 本地接口）接口 。
+58. 谈谈Android的IPC（进程间通信）机制                
+	IPC是内部进程通信的简称， 是共享"命名管道"的资源。Android中的IPC机制是为了让Activity和Service之间可以随时的进行交互，故在Android中该机制，
+	只适用于Activity和Service之间的通信，类似于远程方法调用，类似于C/S模式的访问。通过定义AIDL接口文件来定义IPC接口。Servier端实现IPC接口，
+	Client端调用IPC接口本地代理。
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck!
+
diff --git "a/BasicKnowledge/Android\347\274\226\347\240\201\350\247\204\350\214\203.md" "b/BasicKnowledge/Android\347\274\226\347\240\201\350\247\204\350\214\203.md"
new file mode 100644
index 00000000..d6131150
--- /dev/null
+++ "b/BasicKnowledge/Android\347\274\226\347\240\201\350\247\204\350\214\203.md"
@@ -0,0 +1,329 @@
+Android编码规范
+===
+
+介绍
+---
+
+1. 为什么需要编码规范
+	编码规范对于程序员而言尤为重要，有以下几个原因： 
+	- 一个软件的生命周期中，80%的花费在于维护 
+	- 几乎没有任何一个软件，在其整个生命周期中，均由最初的开发人员来维护
+	- 编码规范可以改善软件的可读性，可以让程序员尽快而彻底地理解新的代码
+	
+源文件规范
+---
+
+1. 文件名
+	源文件名必须和它包含的顶层类名保持一致，包括大小写，并以.java作为后缀名。
+
+2. 文件编码
+	所有源文件编码必须是`UTF-8`
+	
+	
+	
+命名
+---
+
+1. 包名
+	命名规则：一个唯一包名的前缀总是全部小写的`ASCII`字母并且是一个**顶级域名**,通常是`com,edu,gov,mil,net,org`。      
+	包名的后续部分根据不同机构各自内部的命名规范而不尽相同。这类命名规范可能以特定目录名的组成来区分部门 `(department)`,      
+	项目`(project)`,机器`(machine)`,或注册名`(login names)`.         
+	例如： `com.domain.xx`           
+	
+    包命名必须以`com.domain`开始,后面跟有项目名称（或者缩写）,再后面为模块名或层级名称。           
+		如：`com.domain.项目缩写.模块名` `com.domain.xx.bookmark`        
+		如：`com.domain.项目缩写.层级名` `com.domain.xx.activity`          
+
+2. 类和接口命名
+	命名规则：类名是个一名词，采用大小写混合的方式，每个单词的首字母大写。尽量使你的类名简洁而富于描述。使用完整单词，
+	避免缩写词(除非该缩写词被更广泛使用，像 URL，HTML)        
+	
+	接口一般要使用`able`,`ible`,`er`等后缀              
+
+	类名必须使用**驼峰规则**，即首字母必须大写，如果为词组，则每个单词的首字母也必须要大写，类名必须使用名词，或名词词组。
+	要求类名简单，不允许出现无意义的单词。
+
+3. 方法的命名
+	命名规则：方法名是一个动词，采用大小写混合的方式，第一个单词的首字母小写，其后单词的首字母大写。
+	例如： `public void run(); public String getBookName();`     
+	
+	类中常用方法的命名：              
+		- 类的获取方法（一般具有返回值）一般要求在被访问的字段名前加上`get`.     
+		    如`getFirstName()`,`getLastName()`.
+			一般来说,`get`前缀方法返回的是单个值,`find`前缀的方法返回的是列表值.
+			
+		- 类的设置方法(一般返回类型为`void`)：被访问字段名的前面加上前缀 `set`.    
+			如`setFirstName()`,`setLastName()`.
+			
+		- 类的布尔型的判断方法一般要求方法名使用单词`is`或`has`做前缀.      
+			如`isPersistent()`,`isString()`.或者使用具有逻辑意义的单词,例如`equal`或`equals`.
+			
+		- 类的普通方法一般采用完整的英文描述说明成员方法功能,第一个单词尽可能采用动词,首字母小写.     
+			如`openFile()`, `addCount()`.
+		- 构造方法应该用递增的方式写,(参数多的写在后面).
+		- `toString()`方法：一般情况下，每个类都应该定义`toString()`.
+
+4. 变量命名
+	命名规则：第一个单词的首字母小写，其后单词的首字母大写。变量名不应以下划线或美元符号开头，尽管这在语法上是允许的。变量名应简短且富于描述。
+	变量名的选用应该易于记忆，即，能够指出其用途。尽量避免单个字符的变量名，除非是一次性的临时变量。临时变量通常被取名为 `i,j,k,m,n`它们一般用于整型；
+	`c,d,e` 它们一般用于字符型。         
+	在`Android`中成员变量
+	非`public`非`static`的变量可以使用`m`开头
+	非常量的`static`变量可以使用`s`开头
+	
+
+	变量命名也必须使用**驼峰规则**，但是首字母必须小写，变量名尽可能的使用名词或名词词组。同样要求简单易懂，不允许出现无意义的单词。
+	例如：`private String mBookName; ` 
+	
+5. 常量命名
+	命名规则：类常量的声明，应该全部大写，单词间用下划线隔开。
+	例如：`private static final int MIN_WIDTH = 4;`
+	
+6. 异常命名
+	自定义异常的命名必须以`Exception`为结尾。已明确标示为一个异常。
+
+7. layout命名
+	`layout.xml`的命名必须以全部单词小写，单词间以下划线分割，并且使用名词或名词词组，即使用 模块名_功能名称_所属页面类型 来命名。
+	如：`video_controller_player_activity`     视频模块下的-控制栏-属于播放器的-Activity页
+	
+8. id命名
+	·layout`中所使用的`id`必须以全部单词小写，单词间以下划线分割，并且使用名词或名词词组，并且要求能够通过`id`直接理解当前组件要实现的功能。       
+	如：某`TextView @+id/tv_book_name_show`         
+	如：某`EditText @+id/`et_book_name_edit`          
+
+9. 资源命名
+	`layout`中所使用的所有资源(如`drawable`,`style`等),命名必须以全部单词小写，单词间以下划线分割，并且尽可能的使用名词或名词组，        
+	即使用 模块名_用途 来命名。如果为公共资源，如分割线等，则直接用用途来命名                
+	如：`menu_icon_navigate.png`      
+	如：某分割线：`line.png` 或 `separator.png`        
+
+注释
+---
+
+`Java`程序有两类注释：实现注释`(implementation comments)`和文档注释`(document comments)`。
+实现注释是使用/*...*/和//界定的注释。文档注释(被称为"doc comments")由/**...*/界定。文档注释可以通过javadoc 工具转换成HTML 文件。
+
+1. 类注释
+	每一个类都要包含如下格式的注释，以说明当前类的功能等。
+	/**
+	 * 类名
+	 * @author 作者 <br/>
+	 *	实现的主要功能。
+	 *	创建日期
+	 *	修改者，修改日期，修改内容。
+	 */
+
+2. 方法注释
+	每一个方法都要包含 如下格式的注释 包括当前方法的用途，当前方法参数的含义，当前方法返回值的内容和抛出异常的列表。
+	/**
+	 * 
+	 * 方法的一句话概述
+	 * <p>方法详述（简单方法可不必详述）</p>
+	 * @param s 说明参数含义
+	 * @return 说明返回值含义
+	 * @throws IOException 说明发生此异常的条件
+	 * @throws NullPointerException 说明发生此异常的条件
+	 */
+
+3. 类成员变量和常量注释
+	成员变量和常量需要使用`java doc`形式的注释，以说明当前变量或常量的含义
+	/**
+	 * XXXX含义
+	 */
+
+4. 其他注释
+	方法内部的注释 如果需要多行 使用/*…… */形式，如果为单行是用//……形式的注释。
+	不要再方法内部使用 java doc 形式的注释“/**……*/”
+
+代码风格
+---
+
+1. 缩进
+    除了换行符之外，ASCII空格（0x20）是唯一合法的空格字符。这意味着
+    不允许使用`Tab`进行缩进，应该使用空格进行缩进，推荐缩进为4个空格		
+	`Eclipse`中将`Tab`替换为4个空格的设置方法(很多人都习惯直接按4次空格，感觉不设置习惯了也挺好)
+		- 代码设置
+			`Window->Preferences->General->Editors->Text Editors->`勾选`Insert spaces for tabs``
+		- XML文件的Tab配置
+			`Window->Preferences->XML->XML Files->Editor>`选择右侧区域的`Indent using spaces`
+
+
+2. 空行
+	空行将逻辑相关的代码段分隔开，以提高可读性。       
+	
+ 	下列情况应该总是使用空行： 
+	- 一个源文件的两个片段之间
+ 	- 类声明和接口声明之间
+	- 两个方法之间
+	- 方法内的局部变量和方法的第一条语句之间
+	- 一个方法内的两个逻辑段之间，用以提高可读性  
+
+    通常在 变量声明区域之后要用空行分隔，常量声明区域之后要有空行分隔，方法声明之前要有空行分隔。
+
+3. 方法
+ 	- 一个方法尽量不要超过15行(可能会有难度，但是尽量不要太多，弄个方法几千行这是绝对不允许的)，如果方法太长，说明当前方法业务逻辑已经非常复杂，
+		那么就需要进行方法拆分，保证每个方法只作一件事。
+	- 不要使用`try catch`处理业务逻辑！！！！
+
+4. 参数和返回值
+    - 一个方法的参数尽可能的不要超过4个(根据情况可能也会有些难度)
+    - 如果一个方法返回的是一个错误码，请使用异常！！
+    - 尽可能不要使用`null`替代为异常
+
+5. 神秘数字
+	代码中不允许出现单独的数字，字符！如果需要使用数字或字符，则将它们按照含义封装为静态常量!(`for`语句中除外)
+	
+6. 控制语句
+	判断中如有常量，则应将常量置于判断式的右侧。如： 
+	`if (true == isAdmin())...`
+	尽量不要使用三目条件的嵌套。
+
+	在`if`、`else`、`for`、`do`和`while`语句中，即使没有语句或者只有一行，也不得省略花括号：
+	```java
+	if (true){
+		//do something......
+	}
+	```
+	不要使用下面的方式:
+	```java
+	if (true)
+		i = 0; //不要使用这种
+	```
+	
+	对于循环：
+	//将操作结构保存在临时变量里，减少方法调用次数
+	```java
+	final int count = products.getCount();
+	while(index < count){
+		// ...
+	}
+	```
+	而不是
+	```java
+	while(index < products.getCount()){
+		//每此都会执行一次getCount()方法，
+		//若此方法耗时则会影响执行效率
+		//而且可能带来同步问题，若有同步需求，请使用同步块或同步方法
+	}
+	```
+
+
+7. 访问控制
+	若没有足够理由，不要把实例或类变量声明为公有。
+	
+8. 变量赋值
+	不要使用内嵌(embedded)赋值运算符试图提高运行时的效率，这是编译器的工作。例如： 
+	 `d = (a = b + c) + r;`
+	应该写成 
+	```java
+	a = b + c; 
+	d = a + r; 
+	```
+	
+9. 圆括号的试用
+	一般而言，在含有多种运算符的表达式中使用圆括号来避免运算符优先级问题，是个好方法。
+	即使运算符的优先级对你而言可能很清楚，但对其他人未必如此。你不能假设别的程序员和你一样清楚运算符的优先级。 
+	不要这样写：
+	`if (a == b && c == d)`
+	正确的方式为： 
+	`if ((a == b) && (c == d))`
+
+10. 返回值
+	设法让你的程序结构符合目的。例如： 
+	```java
+	if (booleanExpression) { 
+		return true; 
+	} else { 
+		return false; 
+	} 
+	```
+	应该代之以如下方法： 
+	`return booleanExpression`
+
+	类似地： 
+	```java
+	if (condition) { 
+		return x; 
+	} 
+	return y; 
+	```
+	应该写做： 
+    `return (condition ? x : y);`
+
+11. 条件运算符`?`前的表达式    
+	如果一个包含二元运算符的表达式出现在三元运算符" ? : "的"?"之前，那么应该给表达式添上一对圆括号。例如：  
+	`(x >= 0) ? x : -x`
+
+12.  所有未使用的import语句应该被删除。	
+
+13. 重载（Overload）方法必须放在一起
+
+14. 非空块中花括号的使用
+	在非空代码块中使用花括号时要遵循`K&R`风格`(Kernighan and Ritchie Style)：
+	左花括号（{）前不能换行，在其后换行。
+	在右花括号（}）前要有换行。
+	
+15. 空代码块中花括号的使用	
+	如果一个代码块是空的，可以直接使用`{}`。除了`if/else-if/else`和`try/catch/finally`这样的多块语句.
+	
+16. 列宽
+	列宽必须为120字符，以下情况可以不遵守列宽限制：
+	无法限制宽度的内容，比如注释里的长`URL`
+	`package`和`import`语句
+	注释中需要被粘贴到`Shell`里去执行的命令
+
+17. 枚举
+	用逗号分割每个枚举变量，并且变量要单独在一行
+	```java
+	enum Color {
+		RED,
+		GREEN,
+		YELLOW
+	}
+	```
+	
+18. 长整形数字
+	长整型数字必须使用大写字母`L`结尾，不能使用小写字母`l`，以便和数字1进行区分。例如使用3000000000L而不是3000000000l
+  
+  
+开发格式统一
+---
+
+1. Eclipse
+    `Windows -> Preferences -> Java -> Code Style`      
+	然后选择`Import`导入相应的`Clean Up`、`Code Templates`、`Formatter`等XML文件。     
+	如果不需要Copyright信息，想要自定义的，可以不导入Code Templates。
+	
+2. IDEA 
+	`File -> Import Settings`选择下载链接中的`IDEA_Style.jar`文件，
+	可以看到两个选项，只需代码风格的，可以仅选择`Code style schemes`,
+	如果需要默认的`Copyright`信息，选择`Default Project settings`。
+
+
+代码严谨性要求
+---
+
+1. `ArrayList`通过`get`方法使用下标获取元素，如果使用的下标不在`ArrayList`大小范围内，将产生`java.lang.IndexOutOfBoundsException`的异常，导致`app`出现`Crash`。
+
+2. 方法中存在`return null`返回对象直接进行方法调用隐患, 在使用时需要先判断是否为`null`，一般尽量不要在方法中直接`return null`，最好用异常代替。
+
+3. 销毁`Dialog`前是否`isShowing`未判断隐患
+	调用`Android.app.Dialog.cancel()`方法前，如果这个`dialog`不处于`showing`状态时，会抛出`java.lang.IllegalArgumentException`的异常，导致`app`出现`Crash`。
+
+4. 使用`String.split`结果未判断长度隐患
+	在使用`String.split`得到的结果数组前，未对数组进行长度检查，取字段的时候可能发生越界而导致`Crash`。
+	```java
+	String source = "<br/>";
+	String[] infos = source.split("<br/>");
+	if(0 < infos.length){
+	   String poiName = infos[0];
+	}
+	```
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/Ant\346\211\223\345\214\205.md" "b/BasicKnowledge/Ant\346\211\223\345\214\205.md"
similarity index 59%
rename from "Android\345\237\272\347\241\200/Ant\346\211\223\345\214\205.md"
rename to "BasicKnowledge/Ant\346\211\223\345\214\205.md"
index 4c957d63..16c5733e 100644
--- "a/Android\345\237\272\347\241\200/Ant\346\211\223\345\214\205.md"
+++ "b/BasicKnowledge/Ant\346\211\223\345\214\205.md"
@@ -2,16 +2,14 @@ Ant打包
 ===
 
 使用步骤：    
-1. 对于已经存在的工程需要利用`Ant`命令更新一下：   
-    ```
-    android update project -n Test -p D:/workspace/Test -s -t 1 
-    ```
-　　-n (name) 后面跟的是这个工程的名子  
-　　-p (path)后面跟的是这个工程的目录路径                 
-　　-t (target)后面是当前共有的`SDK`版本。表明我们的*目标版本*(如果有了`project.properties`就不用再跟`target`这个参数了).    
-　　`android list target`这样就能够列出来所有的sdk版本
+1. 对于已经存在的工程需要利用`Ant`命令更新一下：    
+    `android update project -n Test -p D:/workspace/Test -s -t 1`            
+　　-n (name) 后面跟的是这个工程的名子      
+　　-p (path)后面跟的是这个工程的目录路径                          
+　　-t (target)后面是当前共有的`SDK`版本。表明我们的*目标版本*(如果有了`project.properties`就不用再跟`target`这个参数了).          
+　　`android list target`这样就能够列出来所有的sdk版本          
 
-2. 将签名文件keystore复制到工程根目录下,并且在根目录下新建`ant.properties`内容如下(配置签名文件):
+2. 将签名文件keystore复制到工程根目录下,并且在根目录下新建`ant.properties`内容如下(配置签名文件):       
     ```
 　　key.store=keystore.keystore //把签名放到根目录中   
 　　key.alias=tencent
@@ -20,17 +18,19 @@ Ant打包
     ```
 
 3. 刷新工程    
-    在`eclipse`中的`Ant`视图中右键`add build files`选择工程中的`build.xml`，选择最下面的release或者是debug，注意release是生成带签名的apk包.生成的apk在bin目录中，名字为工程名-release.apk.
+    在`eclipse`中的`Ant`视图中右键`add build files`选择工程中的`build.xml`，选择最下面的`release`或者是`debug`，
+	注意`release`是生成带签名的`apk`包.生成的apk在`bin`目录中，名字为工程名`-release.apk`.
 
-4. 常见错误：
-	有时候在用ant打包的时候会报一些错误，一般按照错误的提示进行修改即可，如文件的非法字符等。
+4. 常见错误：      
+	有时候在用`ant`打包的时候会报一些错误，一般按照错误的提示进行修改即可，如文件的非法字符等。     
 	```java
 	Error occurred during initialization of VM
 	Could not reserve enough space for object heap
 	Error: Could not create the Java Virtual Machine.
 	Error: A fatal exception has occurred. Program will exit.
 	```
-	如果发现以上错误，就是说明栈内存不足了，一种是内存设置的太小，还有一种情况就是你设置的内存大小已经超过了当前系统限制的大小。打开`D:\Java\adt-bundle-windows\sdk\build-tools\android-4.4\dx.bat`将`set defaultXmx=-Xmx1024M`改为`set defaultXmx=-Xmx512M`即可。
+	如果发现以上错误，就是说明栈内存不足了，一种是内存设置的太小，还有一种情况就是你设置的内存大小已经超过了当前系统限制的大小。
+	打开`D:\Java\adt-bundle-windows\sdk\build-tools\android-4.4\dx.bat`将`set defaultXmx=-Xmx1024M`改为`set defaultXmx=-Xmx512M`即可。
 	
 ---
 
diff --git "a/Android\345\237\272\347\241\200/Bitmap\344\274\230\345\214\226.md" "b/BasicKnowledge/Bitmap\344\274\230\345\214\226.md"
similarity index 69%
rename from "Android\345\237\272\347\241\200/Bitmap\344\274\230\345\214\226.md"
rename to "BasicKnowledge/Bitmap\344\274\230\345\214\226.md"
index 5bffef38..42b7954b 100644
--- "a/Android\345\237\272\347\241\200/Bitmap\344\274\230\345\214\226.md"
+++ "b/BasicKnowledge/Bitmap\344\274\230\345\214\226.md"
@@ -1,11 +1,15 @@
 Bitmap优化
 ===
 
-1. 一个进程的内存可以由2个部分组成：`native和dalvik`，`dalvik`就是我们平常说的`java`堆，我们创建的对象是在这里面分配的，而`bitmap`是直接在`native`上分配的。   
-一旦内存分配给`Java`后，以后这块内存即使释放后，也只能给`Java`的使用，所以如果`Java`突然占用了一个大块内存，即使很快释放了,`C`能用的内存也是16M减去`Java`最大占用的内存数。
-而`Bitmap`的生成是通过`malloc`进行内存分配的，占用的是C的内存，这个也就说明了，上述的4MBitmap无法生成的原因，因为在13M被Java用过后，剩下C能用的只有3M了。    
+1. 一个进程的内存可以由2个部分组成：`native和dalvik`
+    `dalvik`就是我们平常说的`java`堆，我们创建的对象是在这里面分配的，而`bitmap`是直接在`native`上分配的。   
+    一旦内存分配给`Java`后，以后这块内存即使释放后，也只能给`Java`使用，所以如果`Java`突然占用了一个大块内存，
+	即使很快释放了,`C`能用的内存也是16M减去`Java`最大占用的内存数。
+    而`Bitmap`的生成是通过`malloc`进行内存分配的，占用的是`C`的内存，这个也就说明了，有时候`4MBitmap`无法生成的原因，
+	因为在`13M`被`Java`用过后，剩下`C`能用的只有`3M`了。    
 
-2. 在`Android`应用里，最耗费内存的就是图片资源。而且在`Android`系统中，读取位图`Bitmap`时，分给虚拟机中的图片的堆栈大小只有8M，如果超出了，就会出现`OutOfMemory`异常。
+2. 在`Android`应用里，最耗费内存的就是图片资源。    
+    在`Android`系统中，读取位图`Bitmap`时，分给虚拟机中的图片的堆栈大小只有8M，如果超出了，就会出现`OutOfMemory`异常。
 
 3. 及时回收Bitmap的内存
     ```java
@@ -19,7 +23,8 @@ Bitmap优化
     ```
 
 4. 捕获异常     
-    在实例化`Bitmap`的代码中，一定要对`OutOfMemory`异常进行捕获。下面对初始化`Bitmap`对象过程中可能发生的`OutOfMemory`异常进行了捕获。如果发生了异常，应用不会崩溃，而是得到了一个默认的图片。
+    在实例化`Bitmap`的代码中，一定要对`OutOfMemory`异常进行捕获。下面对初始化`Bitmap`对象过程中可能发生的`OutOfMemory`异常进行了捕获。
+	如果发生了异常，应用不会崩溃，而是得到了一个默认的图片。
     ```java
     Bitmap bitmap = null;
     try {
@@ -33,14 +38,17 @@ Bitmap优化
         return defaultBitmapMap;
     }
     ```
+	
 5. 缓存通用的Bitmap对象
 
 6. 压缩图片
     如果图片像素过大可以将图片缩小，以减少载入图片过程中的内存的使用，避免异常发生。
-使用`BitmapFactory.Options.inSampleSize`就可以缩小图片。属性值`inSampleSize`表示缩略图大小为原始图片大小的几分之一。即如果这个值为2，则取出的缩略图的宽和高都是原始图片的1/2，图片的大小就为原始大小的1/4。
-如果知道图片的像素过大，就可以对其进行缩小。那么如何才知道图片过大呢?
-使用`BitmapFactory.Options`设置`inJustDecodeBounds`为`true`后，并不会真正的分配空间，即解码出来的`Bitmap`为`null`，但是可计算出原始图片的宽度和高度，即`options.outWidth`和`options.outHeight`。
-通过这两个值，就可以知道图片是否过大了。
+    使用`BitmapFactory.Options.inSampleSize`就可以缩小图片。属性值`inSampleSize`表示缩略图大小为原始图片大小的几分之一。
+	即如果这个值为2，则取出的缩略图的宽和高都是原始图片的1/2，图片的大小就为原始大小的1/4。
+    如果知道图片的像素过大，就可以对其进行缩小。那么如何才知道图片过大呢?
+    使用`BitmapFactory.Options`设置`inJustDecodeBounds`为`true`后，并不会真正的分配空间，即解码出来的`Bitmap`为`null`，
+	但是可计算出原始图片的宽度和高度，即`options.outWidth`和`options.outHeight`。
+    通过这两个值，就可以知道图片是否过大了。
     ```java
     BitmapFactory.Options opts = new BitmapFactory.Options();
     // 设置inJustDecodeBounds为true
@@ -50,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
@@ -126,4 +134,4 @@ Bitmap优化
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/Fragment\344\270\223\351\242\230.md" "b/BasicKnowledge/Fragment\344\270\223\351\242\230.md"
similarity index 66%
rename from "Android\345\237\272\347\241\200/Fragment\344\270\223\351\242\230.md"
rename to "BasicKnowledge/Fragment\344\270\223\351\242\230.md"
index a05b5af2..81ceb228 100644
--- "a/Android\345\237\272\347\241\200/Fragment\344\270\223\351\242\230.md"
+++ "b/BasicKnowledge/Fragment\344\270\223\351\242\230.md"
@@ -1,28 +1,34 @@
 Fragment专题
 ===
 
-##简介
+## 简介
 
-A Fragment is a piece of an application's user interface or behavior that can be placed in an Activity. Interaction with fragments is done through FragmentManager, 
+A Fragment is a piece of an application's user interface or behavior that can be placed in an Activity. 
+Interaction with fragments is done through FragmentManager, 
 which can be obtained via Activity.getFragmentManager() and Fragment.getFragmentManager().
 
-The Fragment class can be used many ways to achieve a wide variety of results. In its core, it represents a particular operation or interface that is running within a larger Activity. 
-A Fragment is closely tied to the Activity it is in, and can not be used apart from one. Though Fragment defines its own lifecycle, that lifecycle is dependent on its activity: if the activity is stopped, 
+The Fragment class can be used many ways to achieve a wide variety of results. 
+In its core, it represents a particular operation or interface that is running within a larger Activity. 
+A Fragment is closely tied to the Activity it is in, and can not be used apart from one. 
+Though Fragment defines its own lifecycle, that lifecycle is dependent on its activity: if the activity is stopped, 
 no fragments inside of it can be started; when the activity is destroyed, all fragments will be destroyed.
 
-All subclasses of Fragment must include a public no-argument constructor. The framework will often re-instantiate a fragment class when needed, in particular during state restore, 
-and needs to be able to find this constructor to instantiate it. If the no-argument constructor is not available, a runtime exception will occur in some cases during state restore.
+All subclasses of Fragment must include a public no-argument constructor. 
+The framework will often re-instantiate a fragment class when needed, in particular during state restore, 
+and needs to be able to find this constructor to instantiate it. 
+If the no-argument constructor is not available, a runtime exception will occur in some cases during state restore.
 
 
-##生命周期
+## 生命周期
 
-`onAttach()`(`Fragment`被绑定到`Activity`时调用) ---> `onCreate()`(`Fragment`创建) --> `onCreateView()`(创建和`Fragment`关联的`View Hierarchy`时调用) --> `onActivityCreated()`(`Activity`的`onCreate()`方法返回时调用) 
+`onAttach()`(`Fragment`被绑定到`Activity`时调用) ---> `onCreate()`(`Fragment`创建) --> 
+`onCreateView()`(创建和`Fragment`关联的`View Hierarchy`时调用) --> `onActivityCreated()`(`Activity`的`onCreate()`方法返回时调用) 
 --> `onStart()` --> `onResume()` --> `onPause()` --> `onStop()` --> `onDestroyView()`当和`Fragment`关联的`view hierarchy`正在被移除时调用. 
 --> `onDestroy()`(`Activity`的`onDestroy`执行后的回调), --> `onDetach()`(当`Fragment`从`Activity`解除关联时被调用)        
 	
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/complete_android_fragment_lifecycle.png)    
 
-##使用
+## 使用
 
 1. 布局添加
 	```xml
@@ -55,12 +61,14 @@ and needs to be able to find this constructor to instantiate it. If the no-argum
 		}
 	}
 	```
-	**每一个fragment 都需要一个唯一的标识,如果activity重启,系统可以用来恢复fragment(并且你也可以用来捕获fragment 来处理事务,例如移除它.)**
-	有3 种方法来为一个`fragment` 提供一个标识:
-		1. 为`android:id`属性提供一个唯一ID.
-		2. 为`android:tag`属性提供一个唯一字符串.
-		3. 如果以上2个你都没有提供,系统使用容器`view`的`ID`.
-		
+	**每一个fragment 都需要一个唯一的标识,如果activity重启,系统可以用来恢复fragment(并且你也可以用来捕获fragment 来处理事务,例如移除它.)**                
+
+	有3 种方法来为一个`fragment` 提供一个标识:             
+
+		1. 为`android:id`属性提供一个唯一ID.      
+		2. 为`android:tag`属性提供一个唯一字符串.       
+		3. 如果以上2个你都没有提供,系统使用容器`view`的`ID`.         
+		 
 	```java
 	public static ArticleFragment newInstance(int index) {
 		ArticleFragment f = new ArticleFragment();
@@ -109,19 +117,19 @@ and needs to be able to find this constructor to instantiate it. If the no-argum
 	}
 	```
 	
-##管理Fragment
+## 管理Fragment
 
-要在activity 中管理fragment,需要使用FragmentManager. 通过调用activity 的getFragmentManager()取得它的实例.
-可以通过FragmentManager 做一些事情, 包括:
+要在`activity`中管理`fragment`,需要使用`FragmentManager`. 通过调用`activity`的`getFragmentManager()`取得它的实例.
+可以通过`FragmentManager`做一些事情, 包括:           
     1. 使用findFragmentById() (用于在activitylayout 中提供一个UI 的fragment)或findFragmentByTag()(适用于有或没有UI 的fragment)获取activity 中存在的fragment      
     2. 将fragment 从后台堆栈中弹出, 使用popBackStack() (模拟用户按下BACK 命令).    
     3. 使用addOnBackStackChangeListener()注册一个监听后台堆栈变化的listener.   
 
 ## 处理Fragment事务
 
-每一个事务都是同时要执行的一套变化.可以在一个给定的事务中设置你想执行的所有变化,使用诸如add(), remove(),和replace().然后, 要给activity 应用事务, 必须调用commit().在调用commit()之前, 
-你可能想调用addToBackStack(),将事务添加到一个fragment 事务的backstack. 这个	
-
+每一个事务都是同时要执行的一套变化.可以在一个给定的事务中设置你想执行的所有变化,使用诸如`add()`, `remove()`,和`replace()`.
+要给`activity`应用事务, 必须调用`commit()`.在调用`commit()`之前, 
+你可能想调用`addToBackStack()`,将事务添加到一个fragment 事务的`backstack`
 将一个fragment 替换为另一个, 并在后台堆栈中保留之前的状态:
 ```java
 // Create new fragment and transaction
@@ -139,7 +147,8 @@ transaction.commit();
 	
 ## Fragment真正的onPause以及onResume
 
-`Fragment`虽然有`onResume()`和`onPause()`方法，但是这两个方法是`Activity`的方法调用时机也与`Activity`相同，和`ViewPager`搭配使用这个方法就很鸡肋了，根本不是你想要的效果，这里介绍一种方法。
+`Fragment`虽然有`onResume()`和`onPause()`方法，但是这两个方法是`Activity`的方法调用时机也与`Activity`相同，
+和`ViewPager`搭配使用这个方法就很鸡肋了，根本不是你想要的效果，这里介绍一种方法。
 ```java
 @Override
 public void setUserVisibleHint(boolean isVisibleToUser) {
@@ -152,9 +161,10 @@ public void setUserVisibleHint(boolean isVisibleToUser) {
 }
 ```
 
-通过阅读`ViewPager`和`PageAdapter`相关的代码，切换`Fragment`实际上就是通过设置`setUserVisibleHint`和`setMenuVisibility`来实现的，调用这个方法时并不会释放掉`Fragment`（即不会执行onDestoryView）。
+通过阅读`ViewPager`和`PageAdapter`相关的代码，切换`Fragment`实际上就是通过设置`setUserVisibleHint`和`setMenuVisibility`来实现的，
+调用这个方法时并不会释放掉`Fragment`（即不会执行`onDestoryView`）。
 
-##Fragment与ViewPager搭配
+## Fragment与ViewPager搭配
 `FragmentStatePagerAdapter`，会自动保存和恢复`Fragment`。
 ```java
 import android.support.v4.app.Fragment;
@@ -225,7 +235,6 @@ public class ScreenSlidePagerActivity extends FragmentActivity {
 如何给`ViewPager`切换时增加动画.
 ```java
 ViewPager mPager = (ViewPager) findViewById(R.id.pager);
-...
 mPager.setPageTransformer(true, new DepthPageTransformer ());
 ```
 
@@ -268,7 +277,61 @@ public class DepthPageTransformer implements ViewPager.PageTransformer {
 }
 ```
 
+
+## 判断首次进入`Fragment`的时机
+
+上面介绍了`Fragment`真正的`onPause`及`onResume`方法。也就是说`Fragment`和`ViewPager`一起用时，由于`ViewPager`的缓存机制，在打开一个`Fragment`时，它旁边的几个 `Fragment`其实也已经被创建了，如果我们是在`Fragment`的`onCreat()`或者`onCreateView()`里去跟服务器交互，下载界面数据，那么这时这些已经被创建的`Fragment`，就都会出现在后台下载数据的情况了。所以我们通常需要在`setUserVisibleHint()`里去判断当前`Fragment`是否可见，可见时再去下载数据，但是这样还是会出现一个问题，就是每次可见时都会重复去下载数据，即使我们在`setUserVisibleHint()`做了很多判断，实现了可见时加载并且只有第一次可见时才加载，可能还是会遇到其他问题。比如说，我下载完数据就直接需要对`ui`进行操作，将数据展示出来，但有时却报了`ui`控件`null`异常，这是因为`setUserVisibleHint()`有可能在`onCreateView()`创建`view`之前调用，而且数据加载时间很短，这就可能出现`null` 异常了，那么我们还需要再去做些判断，保证在数据下载完后`ui`控件已经创建完成。我最近就遇到了这个问题，想要在第一次进入
+某个`fragment`的时候在某个`view`上面显示一个`popunwindow`，我想到的就是在`setUserVisibleHint()`方法中去显示，但是发现有时候对应的`view`还没初始化。
+下面就是如何判断首次进入`Fragment`的时机。
+
+```
+public abstract class BaseFragment extends Fragment {
+    private View mRootView;
+    protected boolean isFirstVisible = true;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        isFirstVisible = true;
+        mRootView = null;
+    }
+
+    @Override
+    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        if (mRootView == null) {
+            mRootView = view;
+            if (getUserVisibleHint()) {
+                if (isFirstVisible) {
+                    onFragmentFirstVisible();
+                    isFirstVisible = false;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void setUserVisibleHint(boolean isVisibleToUser) {
+        super.setUserVisibleHint(isVisibleToUser);
+        if (mRootView == null) {
+            return;
+        }
+        if (isFirstVisible && isVisibleToUser) {
+            onFragmentFirstVisible();
+            isFirstVisible = false;
+        }
+    }
+
+    protected void onFragmentFirstVisible() {
+        // 首次进入改fragment的时机
+    }
+}
+
+```
+
+
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/Home\351\224\256\347\233\221\345\220\254.md" "b/BasicKnowledge/Home\351\224\256\347\233\221\345\220\254.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/Home\351\224\256\347\233\221\345\220\254.md"
rename to "BasicKnowledge/Home\351\224\256\347\233\221\345\220\254.md"
diff --git "a/Android\345\237\272\347\241\200/HttpClient\346\211\247\350\241\214Get\345\222\214Post\350\257\267\346\261\202.md" "b/BasicKnowledge/HttpClient\346\211\247\350\241\214Get\345\222\214Post\350\257\267\346\261\202.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/HttpClient\346\211\247\350\241\214Get\345\222\214Post\350\257\267\346\261\202.md"
rename to "BasicKnowledge/HttpClient\346\211\247\350\241\214Get\345\222\214Post\350\257\267\346\261\202.md"
diff --git "a/BasicKnowledge/JNI_C\350\257\255\350\250\200\345\237\272\347\241\200.md" "b/BasicKnowledge/JNI_C\350\257\255\350\250\200\345\237\272\347\241\200.md"
new file mode 100644
index 00000000..3bd5e206
--- /dev/null
+++ "b/BasicKnowledge/JNI_C\350\257\255\350\250\200\345\237\272\347\241\200.md"
@@ -0,0 +1,467 @@
+JNI_C语言基础
+===
+
+1. JNI(java native interface)    
+    `Java`本地开发接口，`JNI`是一个协议，这个协议用来沟通`Java`代码和外部的本地代码(`c/c++`).
+    通过这个协议`Java`代码就可以调用外部的`c/c++`代码，外部的`c/c++`代码也可以调用java代码，
+	使用JNI技术，其实就是在Java程序中，调用C语言的函数库中提供的函数，来完成一些Java语言无法完成的任务。由于Java语言和C语言结构完全不相同，因此若想让它们二者交互，则需要制定一系列的规范。
+	JNI就是这组规范，此时 Java只和JNI交互，而由JNI去和C语言交互。
+	
+	JNI技术分为两部分：Java端和C语言端。且以Java端为主导。    
+	- 首先，Java程序员在Java端定义一些native方法，并将这些方法以C语言头文件的方式提供给C程序员。
+	- 然后，C程序员使用C语言，来实现Java程序员提供的头文件中定义的函数。
+	- 接着，C程序员将函数打包成一个库文件，并将库文件交给Java程序员。
+	- 最后，Java程序员在Java程序中导入库文件，然后调用native方法。
+	在Java程序执行的时候，若在某个类中调用了native方法，则虚拟机会通过JNI来转调用库文件中的C语言代码。提示：C代码最终是在Linux进程中执行的，而不是在虚拟机中。
+ 
+2. 为什么要用JNI
+	- 首先，Java语言提供的类库无法满足要求(驱动开发 wifi等),且在数学运算,实时渲染的游戏上,音视频处理等方面上与C/C++相比效率稍低。 
+	- 然后，Java语言无法直接操作硬件，C/C++代码不仅能操作硬件而且还能发挥硬件最佳性能。
+	- 接着，使用Java调用本地的C/C++代码所写的库，省去了重复开发的麻烦，并且可以利用很多开源的库提高程序效率。Opencore
+	- 接着，特殊的业务场景，java能反编译但是c不能，因此对于一些不想让别人知道的东西可以用c，加密等
+ 
+3. 怎么用JNI
+    1. C/C++语言 
+	2. 掌握java jni流程 
+	3. NDK (native develop kits ) 
+  
+4. 指针和指针变量的关系
+	指针就是地址，地址就是指针          
+	地址就是内存单元的编号          
+	指针变量是存放地址(指针)的变量      
+	指针和指针变量是两个不同的概念       
+	但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样      
+
+  - 未经过初始化的指针变量，不能够直接使用
+  - 指针变量的类型 不能够相互转换 
+  - 函数的变量(静态)不能够跨函数访问，失去了函数变量的访问范围(生命周期)，因为方法执行完之后会释放内存，所以方法中的变量就没有了，
+	但是地址值还是能拿到的，因为地址值是内存中真实存在的地址位置 
+  - 指针声明的三种方式
+        int * p; //p 是变量的名字， int * 是一个类型，这个变量存放的是int类型变量的地址。
+        int* p     int * p    int *p
+
+5. *号的三种含义    
+	1. 乘法 3*5
+	2. 定义指针变量 int * p;
+    3. 指针运算符，如果p是一个已经定义好的指针变量,则*p表示以p的内容为地址的变量
+ 
+6. 为什么要使用指针(指针的重要性）
+	直接访问硬件 (opengl 显卡绘图)       
+	快速传递数据(指针表示地址)      
+	返回一个以上的值(返回一个数组或者结构体的指针)     
+	表示复杂的数据结构(结构体)    
+	方便处理字符串    
+	指针有助于理解面向对象
+
+7. 指针和数组的关系
+	一维数组的数组名是个指针常量，它存放的是一维数组第一个元素的地址    
+	C中数组的定义比较死板，中括号必须放到名字的后面    
+	int a[5];    
+	printf("%#X\n",&a[0]);    
+	printf("%#X\n",&a);    
+     
+	如果p是一维数组 则p[i] 等价于 *(p+i),都是得到一维数组中的第i个元素。    
+	在c语言中不会检查角标越界如int a[5]写a[5]不会报错   
+
+8. 动态分配内存Malloc
+	```c
+	采用malloc在椎内存中申请空间
+	#include <malloc.h>  //不能省  malloc 是 memory(内存) allocate(分配)的缩写
+	#include <stdio.h>
+
+	main(){
+		 //malloc() 在堆空间中动态的申请一块连续的内存空间(数组)
+		 // 参数： 指定申请的内存空间的大小(字节)
+		 // 返回值： 所申请空间的首地址(数组的第一个元素的地址),返回值是Void数据类型
+	   
+		 int* p = (int*) malloc( sizeof(int) );     //因为返回值是一个Void类型，所以要强转
+		 *p = 99;
+		
+		 //free()释放已经分配的内存块
+		 //参数： 指定释放哪块内存空间（地址）
+	 
+		 free(p);
+		printf("内容是 %d\n", *p);     //上面的free只是释放内存块中的内容，但是打印这个内存块的地址还是能够打印出来的，因为这个内存块的地址是内存上的地址是真实存在的       
+		 system("pause"); 
+	}
+	
+	如果动态申请的内存不够用，那么可以继续申请内存
+	用realloc
+	/*
+	  1\创建数组
+	  2、赋值
+	  3、打印 
+	*/
+	#include<stdio.h>
+	#include<malloc.h>
+
+	void printArr(int* arr, int len){
+		 int i;
+		 for( i = 0 ; i < len; i++){
+				printf("arr[ %d ]= %d\n", i, *(arr+i));
+		 }
+
+	}
+
+	main(){
+		   printf("请您输入所要创建的数组大小： \n");
+		   int len ;
+		   scanf("%d", &len);  &是取地址符
+
+		   //动态数组创建
+		   int* arr = (int*) malloc( sizeof(int) *  len);
+
+		   printf("请您为每个元素赋值： \n");
+
+		   int i;
+		   for(i = 0; i < len; i++){
+				 int temp;
+				 scanf("%d", &temp);
+
+				 *(arr + i) = temp;
+		   }
+
+		   //打印
+		   printf("数组元素的值为： \n");
+		   printArr(arr, len);
+
+		   //-----------------------------------------
+
+		   printf("请输入增加的元素个数： \n");
+		   int count;
+		   scanf("%d", &count);
+
+		   //更改数组大小
+		   //realloc()
+		   //参数1： 指定所需修改的数组
+		   //参数2： 指定修改后的数组的大小
+		   //返回值：修改后数组的首地址  （VOID）
+		   arr = (int*) realloc(arr, len + count);
+
+		   printf("请为新增加的元素赋值： \n");
+
+		   int j;
+		   for(j = len; j < len + count; j++){
+				 int temp;
+				 scanf("%d", &temp);
+
+				 *(arr + j) = temp;
+		   }
+
+		   //打印 
+		   printf("数组元素的值为： \n");
+		   printArr(arr, len + count);
+
+		   system("pause");       
+	}
+	或者有个简单的写法
+	main()
+	{       
+		 int* arr =(int* ) malloc(sizeof(int)*len) ; //动态申请的内存 
+		 int i=0;
+		 for(;i<len;i++){
+		   printf("请输入第%d个数据\n",i); 
+		   scanf("%d",&arr[i]);           
+		 } 
+		  //打印显示这个数组的元素 
+		  printArr(arr,len); 
+
+			printf("请输入增加的数组的长度"); 
+			int increase;
+			scanf("%d", &increase); 
+
+			arr = realloc(arr,(len+increase)*sizeof(int));
+			i =len; 
+		   for(;i<len+increase ;i++){
+		   printf("请输入第%d个数据\n",i); 
+		   scanf("%d",&arr[i]);           
+		 } 
+
+		  //打印显示这个数组的元素 
+		   printf("新的数组长度为:%d\n",len+increase); 
+			printArr(arr,len+increase); 
+
+			system("pause"); 
+	}
+	``` 
+
+9. 静态内存和动态内存                     
+    静态内存是系统是程序编译执行后系统自动分配,由系统自动释放,静态内存是栈分配的.动态内存是堆分配的.       
+    C中静态内存会自动释放，但是对于动态内存(堆内存)在c中是没有垃圾回收的，必须要靠程序员手动的去释放，不然就会一直存在        
+
+10. C中的基本数据类型               
+     char, int, float, double, signed, unsigned, long, short and void     
+     c中char 占用1个字节       java char占用2个字节     
+     c中long 占用4个字节       java long占用8个字节     
+
+	int flag = 0,1  表示java中boolean类型
+
+	c中用char数组  来表示java中String类型或者指针方式来表示java中String类型
+		//内部转化为一个字符串的数组,并且在数组的最后一个元素拼装一个\0. 
+		char* cc = "heima 15";//char* str ="hello" ;  //<--> char str[] ={'h','e','l','l','o','\0'};  
+		char cc[20] = "heima 15";
+		char cc[20] = {'h','e','i','m','a'};
+
+11. c文件的后缀是.c          
+	```c
+	示例代码：
+	c中的打印语句中要有类似占位符，在后面的参数对占位符的内容进行声明
+	#include<stdio.h>
+	main() {
+		printf("%d\n",sizeof(int));       //sizeof() 得到制定数据类型的长度(占用字节数)参数  接受一个数据类型 
+		printf("%d\n",sizeof(char));
+		system("pause");//可以执行命令行中的命令如 system("shutdown -s -t 60");如果不加pause，运行窗口会一闪而过，因为会释放内存，把dos关闭了，所以要加上pause
+	} 
+	```
+
+12. C中的输入输出            
+	%d  -  int     
+	%ld – long int     
+	%c  - char    
+	%f -  float     
+	%lf – double     
+	%x – 十六进制输出 int 或者long int 或者short int     
+	%#x – 以0x开头 十六进制输出 int 或者long int 或者short int     
+	%o -  八进制输出     
+	%s – 字符串      
+ 
+13. c语言从键盘输入一个字符串                   
+	```c
+    //scanf() 接收键盘输入的数据，参数1： 指定接收的数据的数据类型参数 2： 指定接收的数据存放的位置
+	#include<stdio.h>
+	main() {
+		char c[20];
+		scanf("%s", c);
+		printf("%s", c);
+		system("pause");
+	}
+	```
+
+14. 取地址符  &(能得到一个对象的地址)    
+
+15. C中两个数的交换      
+	```c
+	#include<stdio.h>
+	void swap(int* i, int* j) {
+		int temp = *i;
+		*i = *j;
+		*j = temp;
+	}
+	main() {
+		int i = 3;
+		int j = 5;
+		swap(&i, &j);
+		printf("%d",i);
+		printf("%d",j);
+		system("pause");      
+	}
+	```
+
+16. C中的for循环             
+	```c
+	#include <stdio.h>
+
+	/**
+	打印输出数组的每一个元素
+	*/
+	void printArr(int* arr, int len){
+		 int i;
+		 for(i=0;i<len;i++){
+			printf("arr[%d]=%d\n",i,*(arr+i));            
+		  }
+	}
+
+	main()
+	{    printf("请输入数组的长度");
+		 int  len ;
+		 scanf("%d", &len);//要用指针
+		 int arr[len];
+		 int i=0;
+		 for(;i<len;i++){
+		   printf("请输入第%d个数据\n",i);
+		   scanf("%d",&arr[i]);          
+		 }
+		  //打印显示这个数组的元素
+		  printArr(arr,len);
+		  system("pause");
+	}
+	C中for循环不能像java那样for(int i=0, i<100; i++)C中不允许在for中进行变量的声明，必须要分开，像上面的这个代码这样
+	```
+
+17. 指针的运算               
+    int i = 3;  //天津 解放路 33号      
+    int j = 5;   // 北京 东北旺 9号      
+    int* p = &i;      
+    int* q = &j;       
+    //p-q; 单纯的指针相加减 是没有任何的意义的.
+    //指针的运算只有在连续的内存空间里面(数组)  才有意义. 
+	因为指针的运算必须在数组中才有效，这就是为什么数组中能用     
+	p[i] 等价于 *(p+i)，因为这个p是数组的名字也代表了数组中第一个元素的地址，p+i就是讲指针加几就是得到第几个元素的指针 
+
+18. 函数的指针              
+	```c
+	/**
+	1.定义int (*pf)(int x, int y);
+	2.赋值 pf = add;
+	3.引用 pf(3,5);
+	*/
+	#include <stdio.h>
+	int add(int x,int y){
+		return x+y;
+	}
+	main()
+	{
+		 int (*pf)(int x, int y); //定义一个函数的指针，就是讲函数的名字改了，其它的都和函数的定义一样    
+		 pf = add; //将pf指向add
+	   printf("result=%d\n",  pf(3,5)); //使用pf
+		 
+	   system("pause");
+	}
+
+	内存的四个部分 Stack  Heap CodeSegment DataSegment
+	函数是存放到CodeSegment中的，这个函数的地址就是CodeSegment中的这个函数的地址，我们得到函数的地址如果去访问这个地址就相当于调用了这个函数
+	```
+    
+19. 结构体(类似于java中的类)              
+    ```c
+    #include <stdio.h>
+    struct Student
+    {
+    	 int age;  //4
+    	 float score; //4
+    	 long id; //4
+    	 char sex; //1
+    };
+    int main(void)
+    {
+    	 struct Student st={80,55.6f,10001,'F'};
+    	 printf("st.age=%d\n",st.age);
+    	
+    	 printf("结构体的长度为%d\n",sizeof(st));//打印出来的结果是16为什么呢？ 编译器为了方便起见 做了处理，它将所有的变量的长度都统一成最大的长度
+    	
+    	 struct Student* pst = &st;//结构体的指针
+    	
+    		  printf("st.age=%d\n",(*pst).age);//(*pst)就是得到结构体，由于*的优先级比较低，通常要用括号括起来。
+    		 
+    		 printf("age=%d\n",pst->age);//这一行是上一行的简单写法，pst->age 在计算机内部会被转换为 (*pst).age pst->age的含义: pst所指向的结构体变量中的age这个成员
+    	system("pause");
+    }
+    ```
+    结构体的三种写法          
+    第一种  
+    ```c
+    struct Student
+    {
+    int age;
+    float score;
+    char sex;
+    }
+    ```
+    第二种      
+    ```c
+    struct Student2
+    {
+    int age;
+    float score;
+    char sex;
+    } st2;//相当于java中直接弄了一个对象
+    ```
+    第三种       
+    ```c
+    struct
+    {
+    int age;
+    float score;
+    char sex;
+    } st3;
+    ```
+
+20. Union联合体      
+	```c
+	#include <stdio.h> 
+	main() { 
+		  struct date { int year, month, day; }today; 
+		  union { long i; int k; char ii; double d; } mix; 
+
+		  printf("date:%d\n",sizeof(struct date)); 
+		  printf("mix:%d\n",sizeof(mix)); 
+		  mix.i = 33;
+		  mix.ii = 'a'; 
+		  printf("i=%d\n",mix.i); //结果是96，因为联合体是一个公用的内存空间，在存ii的时候将i的值给覆盖了
+		  //110100000101
+	  
+		  system("pause"); 
+	} 
+	联合体是一个公用的内存空间，联合体长度为： 占有字节数最大的元素的长度（字节数）
+	```
+    
+21. 枚举         
+	```c
+	enum WeekDay {
+	Monday=8,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
+	};//这里一定要加分号
+
+	int main(void)
+	{
+	  enum WeekDay day = Sunday;
+	  printf("%d\n",day);//打印出来是14，因为是从8开始往后逐个加1
+	  system("pause");
+	  return 0;
+	}
+	默认的情况是从0开始往后递加
+	```		
+
+22. typedef           
+	定义别名          
+	声明自定义数据类型，配合各种原有数据类型来达到简化编程的目的的类型定义关键字。 
+    ```c
+	typedef int haha;  //定义数据类型的别名. 
+	int main(void)
+	{
+	  haha i = 3;这里haha就相当于int
+	  printf("i=%d\n",i); 
+	}
+    ```
+	每一个指针占四个字节
+ 
+23. 多级指针
+	```c
+	#include <stdio.h>
+	main() { 
+		int i = 88;
+		int* p = &i; 
+		int** q = &p; //指针的指针前面要加两个*
+		int*** r = &q; 
+		printf("i=%d\n",***r);  
+		system("pause"); 
+	}
+	```
+   
+C语言常见术语：      
+库函数：     
+- 为了代码重用，在C语言中提供了一些常用的、用于执行一些标准任务(如输入/出)的函数，这些函数事先被编译，并生成目标代码，然后将生成的目标代码打包成一个库文件，
+以供再次使用。 库文件中的函数被称为库函数，库文件被称为函数库。        
+通过头文件的方式 把函数库里面所有的函数暴露 .h         
+- 在Windows中C语言库函数中的目标代码都是以.obj为后缀的，Linux中是以 .o为后缀。            
+提示：单个目标代码是无法直接执行的，目标代码在运行之前需要使用连接程序将目标代码和其他库函数连接在一起后生成可执行的文件。Windows ->.exe .dll             
+Linux -> .so 动态库         
+       .a 静态库       
+头文件：          
+- 头文件中存放的是对某个库中所定义的函数、宏、类型、全局变量等进行声明，它类似于一份仓库清单。若用户程序中需要使用某个库中的函数，
+	则只需要将该库所对应的头文件include到程序中即可。          
+- 头文件中定义的是库中所有函数的函数原型。而函数的具体实现则是在库文件中。      
+- 简单的说：头文件是给编译器用的，库文件是给连接器用的。       
+- 在连接器连接程序时，会依据用户程序中导入的头文件，将对应的库函数导入到程序中。头文件以.h为后缀名。          
+函数库：         
+- 动态库：在编译用户程序时不会将用户程序内使用的库函数连接到用户程序的目标代码中，只有在运行时，且用户程序执行到相关函数时才会调用该函数库里的相应函数，因此动态函数库所产生的可执行文件比较小。 .so 动态库        
+- 静态库：在编译用户程序时会将其内使用的库函数连接到目标代码中，程序运行时不再需要动态库。使用静态库生成可执行文件比较大。   
+在Linux中：     
+- 静态库命名一般为：lib+库名+.a 。  
+- 如：libcxy.a 其中lib说明此文件是一个库文件，cxy是库的名称，.a说明是静态的。          
+- 动态库命名一般为：lib+库名+.so 。.so说明是动态的。       
+Windows 下的动态库  .dll    
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck!
\ No newline at end of file
diff --git "a/BasicKnowledge/JNI\345\237\272\347\241\200.md" "b/BasicKnowledge/JNI\345\237\272\347\241\200.md"
new file mode 100644
index 00000000..700f59a8
--- /dev/null
+++ "b/BasicKnowledge/JNI\345\237\272\347\241\200.md"
@@ -0,0 +1,410 @@
+JNI基础
+===
+
+1. 将java中的字符串转换成C中字符串的工具方法              
+    ```c
+    char*   Jstring2CStr(JNIEnv*   env,   jstring   jstr){
+         char*   rtn   =   NULL;
+         jclass   clsstring   =   (*env)->FindClass(env,"java/lang/String");
+         jstring   strencode   =   (*env)->NewStringUTF(env,"GB2312");
+         jmethodID   mid   =   (*env)->GetMethodID(env,clsstring,   "getBytes",   "(Ljava/lang/String;)[B");
+         jbyteArray   barr=   (jbyteArray)(*env)->CallObjectMethod(env,jstr,mid,strencode); // String .getByte("GB2312");
+         jsize   alen   =   (*env)->GetArrayLength(env,barr);
+         jbyte*   ba   =   (*env)->GetByteArrayElements(env,barr,JNI_FALSE);
+         if(alen   >   0)
+         {
+          rtn   =   (char*)malloc(alen+1);         //"\0"
+          memcpy(rtn,ba,alen);
+          rtn[alen]=0;
+         }
+         (*env)->ReleaseByteArrayElements(env,barr,ba,0);  //
+         return rtn;
+    }
+    ```
+
+2. 程序被运行要经历两个步骤(1.编译 2.链接)                      
+    编译就是将源文件编译成二进制代码，而链接则是将二进制代码转换成可执行的文件如.exe等头文件.(函数的声明,函数的清单文件)作用: 给编译器看的.     
+    库函数: 头文件里面函数的实现.    
+    作用:给连接器看的.    
+ 
+3. jni开发的常见错误:        
+    错误1: 忘记编写android.mk文件 unknown file: ./jni/Android.mk    
+    Android NDK: Your APP_BUILD_SCRIPT points to an unknown file: ./jni/Android.mk      
+    /cygdrive/c/android-ndk-r7b/build/core/add-application.mk:133: Android NDK: Aborting...    。 停止。          
+    
+    错误2:  ndk-build 没有任何反应.        
+    忘记配置android.mk脚本       
+	
+    错误3: $ ndk-build jni/Android.mk:4:  遗漏分隔符 。 停止。      
+中文的回车或者换行         
+
+    错误4:java.lang.UnsatisfiedLinkError: hello      
+	忘记加载了c代码的.so库 或者 函数的签名不正确,没有找到与之对应的c代码      
+ 
+    错误5:07-30 java.lang.UnsatisfiedLinkError: Library Hel1o not found      
+	没有找到对应的c代码库     
+ 
+    错误6: *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***       
+    07-30 11:53:17.898: INFO/DEBUG(31): Build fingerprint:     
+    'generic/sdk/generic/:2.2/FRF91/43546:eng/test-keys'      
+    c代码里面有严重的逻辑错误,产生内存的泄露.    
+ 
+    错误7:     
+    make: *** [obj/local/armeabi/objs/Hello/Hello.o] Error 1         
+    编译的时候 程序出现了问题,c语言的语法有问题           
+    c语言代码编译错误的时候 先去解决第一个错误. 
+ 
+4. Java调用JNI的前提        
+    开发所使用的电脑(windows系统, x86的CPU)       
+    目标代码: android手机上运行的.( linux系统, arm的CPU)           
+    所以我们要模拟手机的系统,手机的处理器，生成手机上可以运行的二进制代码这就要用到交叉编译;            
+    根据运行的设备的不同，可以将cpu分为：          
+    - arm结构 ：主要在移动手持、嵌入式设备上。      
+    - x86结构 ： 主要在台式机、笔记本上使用。如Intel和AMD的CPU 。      
+    交叉编译: 在一种操作系统平台或者cpu平台下 编译生成 另外一个平台(cpu)可以运行的二进制代码.(使用NDK中的ndk-build命令)     
+
+
+- 工具一:  交叉编译的工具链: NDK                 
+    NDK全称：Native Development Kit 。           
+    - NDK是一系列工具的集合，它有很多作用。          
+       - 首先，NDK可以帮助开发者快速开发C(或C++)的动态库。      
+       - 其次，NDK集成了交叉编译器。使用NDK，我们可以将要求高性能的应用逻辑使用C开发，从而提高应用程序的执行效率。     
+       
+    NDK工具是提供给Linux系统用的(随着版本的升级也可以直接在Windows下使用，但是现在仍不完善有bug)，
+    所以要在windows下使用ndk的工具,必须要提供一个工具(linux环境的模拟器)
+
+- 工具二:  cygwin(windows下linux系统环境的模拟器, 主要是为了能够运行ndk的工具)       
+    安装 devel shell       
+	![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jni_cygwin.png?raw=true)    
+    linux 特点:所有的设备 硬件 都是以文件的方式定义的.     
+	安装完后进入`cygwin`打印`make -v`命令如果能打印出`GNU Make ...`就说明安装木问题了。
+
+- 工具三: cdt(c/c++ develop tools)  eclipse 的一个插件  用来让c\c++代码 语法高亮显示.         
+    adt(android develop tools)          
+
+- 工具四：           
+    为了不用每次使用ndk-build命令都要进入到ndk的安装目录，这里要进行Path变量的配置。      
+    配置cygwin的环境变量: 在cygwin安装目录,etc目录,profile的文件 32行 添加ndk工具所在的目录.
+    `PATH="/usr/local/bin:/usr/bin:/cygdrive/d/android-ndk-r7b:${PATH}"`在这个后面加上:ndk-build的路径(注意：在linux中路径的分隔符不是分号而是冒号)，
+	改成这样       
+	`PATH="/usr/local/bin:/usr/bin:${PATH}:/cygdrive/d/android-ndk-r7b"`//注意这里的路径是在linux系统下的ndk路径而不是windows下的路径,/cygdrive/d/是在linux下看到的d盘。
+
+### JNI开发步骤：
+
+1. 创建一个android工程
+2. JAVA代码中写声明native 方法 public native String helloFromJNI();
+3. 用javah工具生成头文件
+4. 创建jni目录,引入头文件,根据头文件实现c代码
+5. 编写Android.mk文件
+6. Ndk编译生成动态库
+7. Java代码load 动态库.调用native代码
+
+### JNI开发之Java中调用C代码步骤
+
+1. 在java中定义一个要调用的C的方法(本地方法)            
+	//1.定义一个native的方法            
+	`public native String helloFromC();`
+
+2. 在工程中新建一个jni文件夹(然后在这个文件夹中写c代码，在C中实现java里面定义的c方法默认的时候是自己手写c的方法名，           
+	但是很麻烦这里要参考七里面提供的方式，用javah编译后，然后拷贝h的头文件到jni文件夹中，在从h文件拷贝方法的名字，然后实现该方法).  
+	```
+	C:\Users\Administrator>javah -help
+	用法:
+	  javah [options] <classes>
+	其中, [options] 包括:
+	  -o <file>                输出文件 (只能使用 -d 或 -o 之一)
+	  -d <dir>                 输出目录
+	  -v  -verbose             启用详细输出
+	  -h  --help  -?           输出此消息
+	  -version                 输出版本信息
+	  -jni                     生成 JNI 样式的标头文件 (默认值)
+	  -force                   始终写入输出文件
+	  -classpath <path>        从中加载类的路径
+	  -cp <path>               从中加载类的路径
+	  -bootclasspath <path>    从中加载引导类的路径
+	```	
+	`#include <stdio.h>`         
+	`#include <jni.h>`        
+	//这个方法的名字的写法固定Java_表示这个方法由Java调用,cn_itcast_ndk表示java的包名DemoActivity表示
+	//java中调用这个方法的类名helloFromC表示java中调用这个方法的方法名字
+	```java
+	jstring Java_cn_itcast_ndk_DemoActivity_helloFromC (JNIEnv* env , jobject obj){//这两个参数是固定必不可少的
+		   //return (*(*env)).NewStringUTF(env,"hello from c!");//调用NewStringUTF这个方法new出来一个java中的String类型的字符串
+		   return (*env)->NewStringUTF(env,"hello from c!" );//这个写法和上面这个注释掉的一样，只是更简洁一点
+	}
+	```	
+	
+3. 在jni文件夹中编写android.mk文件，在这个文件夹中声明要编译的c文件名以后编译后生成的文件名   
+	```c
+	LOCAL_PATH := $(call my-dir)  //将jni所在的目录返回去到LOCAL_PATH
+	#clear_vars 一个函数 初始化编译工具链的所有的变量.
+	#特点:清空所有的以LOCAL_开头的变量,但是不会清空LOCAL_PATH的变量
+	 include $(CLEAR_VARS)  
+	#指定编译后的文件的名称 符合linux系统下makefile的语法. 
+	LOCAL_MODULE    := Hello
+	#指定编译的源文件的名称 ,编译器非常智能
+	LOCAL_SRC_FILES := Hello.c
+	  #指定编译后的文件的类型. 默认编译成动态库 BUILD_SHARED_LIBRARY 扩展名.so .so代码体积很小  
+	#                            静态库 BUILD_STATIC_LIBRARY 扩展名.a  .a代码体积很大
+	include $(BUILD_SHARED_LIBRARY)
+	```
+4. cmd进入到当前的工程的文件夹中(也可以进入到当前工程的jni目录中)，然后运行ndk-build工具就能将c文件编译成一个可执行的二进制文件. ->.so，        
+    注意用ndk-build编译之后一定要刷新，不然eclipse会缓存旧的不加载新的进来
+	![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ndk_build.png?raw=true)    
+	
+	
+5. 刷新工程，就能看到多出了两个文件夹
+
+6. 在java中将要调用的c代码加载到java虚拟机中，通过静态代码块的方式
+	```java
+	public class DemoActivity extends Activity {
+	   //1.定义一个native的方法
+	   public native String helloFromC();
+ 
+	   static{
+			 //5.把要调用的c代码 给加载到java虚拟机里面
+			System. loadLibrary("Hello");//注意写的是Hello不要加后缀
+		}
+	}
+	```
+	
+7. 调用c代码            
+	```java
+	public void click(View view){
+	  //调用c代码
+	  Toast.makeText(this, helloFromC(), 1).show();
+	  
+	}
+	```
+
+7. 利用jdk的工具javah动态生成c方法名         
+    在上面的调用c中的方法的时候，在c中区实现这个方法的时候的方法名字写起来很复杂，而且容易出去，在java在jdk中提供了一个工具javah，
+	我们只要在windows的dos窗口cmd到classes目录下去执行javah 包名.类名就能够由class文件动态的生成一个c的h文件，在这个h文件中有该class文件中的native方法的名字       
+    我们只要拷贝这个h文件到自己工程的jni目录中，然后在c文件中引入这个h文件，并拷贝这个h文件中的方法去实现就可以了      
+    ```java
+    #include <stdio.h>//这个<>是引入工具的h文件        
+    #include "cn_itcast_ndk2_DemoActivity.h" //对于自己工程中的h文件用""来引入或者引入#include <jni.h>也可以      
+
+	JNIEXPORT jstring JNICALL Java_cn_itcast_ndk2_DemoActivity_hello_1_1_1from_1_1_1c //拷贝h文件中生成的方法名
+	  (JNIEnv * env, jobject obj){ 
+		  return (*env)->NewStringUTF(env,"hello_from_c 2!" );
+
+	}	
+    ```
+	然后就和上面的步骤一样了
+ 
+	注意上面的这个javah的用法师在jdk1.6中用的，如果在jdk1.7中就不能这样用了
+	对于jdk1.7在使用javah的工具的时候就不能够直接进入到classes目录下直接运行命令了，
+	而是要将sdk中的platforms下的android版本中的android.jar这个路径加载到classPath的环境变量中(麻烦)，或者是直接进入到src目录下用javah包名.类名(简单常用)
+
+8. 如何在c中向logcat中打印日志            
+	如果想像logcat打印日志就要用到谷歌在ndk中提供的一个工具log.h的头文件
+	步骤：
+	1. 在c文件的头上面导入文件，加入下面的这四行代码      
+        ```c
+		#include <android/log.h> //导入log.h
+		#define LOG_TAG "clog"  //指定打印到logcat的Tag
+		#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__) //对后面的这个打印日志的方法起一个别名是LOGD
+		#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+		```
+	2. 在android.mk中加载文件            
+        ```
+		LOCAL_PATH := $(call my-dir)
+		include $(CLEAR_VARS)
+
+		LOCAL_MODULE    := Hello
+		LOCAL_SRC_FILES := Hello.c
+		LOCAL_LDLIBS += -llog   //新增加这一句，作用是 #把c语言调用的log函数对应的函数库加入到编译的运行时里面 #liblog.so，如果还要加载其他的就在后面继续 -lXXX
+		include $(BUILD_SHARED_LIBRARY)
+        ```
+        
+	3. 在c的代码中直接使用LOGD或者LOGI就能向logcat中输入打印信息
+        ```c
+		JNIEXPORT jint JNICALL Java_cn_itcast_ndk3_DataProvider_add
+		(JNIEnv * env, jobject obj, jint x, jint y){
+			LOGI( "x=%d",x);
+			LOGD( "y=%d",y);
+			int result = x+y;
+			LOGD( "result=%d",result);
+			return result;
+		}
+        ```
+
+9. 如何将java的数据传递给c语言         
+    就是java在方法中传值，然后c通过参数得到数据处理后返回和上面的一样
+
+10. 将c中的字符串数组转成java中的string用到jni.h中的一个方法       
+    `jstring (*NewStringUTF)(JNIEnv*, const char*);`
+
+11. C中调用java
+	c语言回调java的场景.
+	1. 如果有一个操作已经有方便的java实现,才用c调用java可以避免重复发明一个轮子.
+	2. 想在c代码里面通知界面更新ui.     
+ 
+	C调用java的 思想类似于java中的反射，我们在c中就是通过反射的c实现来找到java中的这个方法，
+    在getMethodID的第二个参数是一个方法的签名，这里我们可以通过jdk提供的一个工具javap，来到classes目录下，
+	然后用 javap -s 类名.方法名  来得到一个方法的签名，这样就能列出来所有方法的签名
+
+	```c
+	/**
+	 * env JNIEnv* java虚拟机环境的指针.
+	 *
+	 *jobject obj ,哪个对象调用的这个native的方法 , obj就代表的是哪个对象
+	 */
+	JNIEXPORT void JNICALL Java_cn_itcast_ndk4_DataProvider_callmethod1
+	  (JNIEnv * env, jobject obj){
+		   //思考 java中的反射
+		   //1.找到某一个类的字节码
+		   //   jclass      (*FindClass)(JNIEnv*, const char*);
+		  jclass jclazz = (*env)->FindClass(env,"cn/itcast/ndk4/DataProvider" );
+		   if(jclazz==0){
+				LOGI( "LOAD CLAZZ ERROR");
+		  } else{
+				LOGI( "LOAD CLAZZ success" );
+		  }
+		   //2.找到类的字节码里面的方法.
+		   // jmethodID   (*GetMethodID)(JNIEnv*, jclass, const char*, const char*);
+
+		  jmethodID  methodid = (*env)->GetMethodID(env,jclazz,"helloFromJava", "()V"); //最后一个参数是方法的签名
+		   if(methodid==0){
+				LOGI( "LOAD methodid ERROR" );
+		  } else{
+				LOGI( "LOAD methodid success" );
+		  }
+
+		   //3.调用方法
+		   //void        (*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...);
+		  (*env)->CallVoidMethod(env,obj,methodid);
+	}
+	```
+
+12. 小知识      
+	1. Android的API提供了SystemClock类，这个类中有一个方法         
+		public static void sleep(long ms)，这个方法内部对Thread.sleep进行了封装对异常进行了try catch，平时用Thread.sleep还要自己进行捕捉，
+		所以可以使用SystemColock.sleep()还简单
+		
+	2. Java中通过java虚拟机来调用c的代码，首先将c的库加载到虚拟机中，但是其实这个c代码并不是运行在java虚拟机中的，而是运行在虚拟机之外的一个单独的进程中
+ 
+13. 自定义一个View控件(用于表示锅炉的压力大小)       
+    1. 写一个类继承View(View是Android中所有能显示到界面上的东西全的父类)
+    2. 重写onDraw()方法，这个方法是该控件被画到桌面上的时候调用的方法。
+ 
+14. C++与C代码的不同           
+    C++文件的后缀是cpp         
+    C++与C的不同就是C++提供了模板、继承、抽象等     
+	```c
+	//将java字符串转成C++字符串的工具方法
+	char*   Jstring2CStr(JNIEnv*   env,   jstring   jstr)
+	{
+		 char*   rtn   =   NULL;
+		 jclass   clsstring   =   (env)->FindClass("java/lang/String");
+		 jstring   strencode   =   (env)->NewStringUTF("GB2312");
+		 jmethodID   mid   =   (env)->GetMethodID(clsstring,   "getBytes",   "(Ljava/lang/String;)[B");
+		 jbyteArray   barr=   (jbyteArray)(env)->CallObjectMethod(jstr,mid,strencode); // String .getByte("GB2312");
+		 jsize   alen   =   (env)->GetArrayLength(barr);
+		 jbyte*   ba   =   (env)->GetByteArrayElements(barr,JNI_FALSE);
+		 if(alen   >   0)
+		 {
+		  rtn   =   (char*)malloc(alen+1);         //"\0"
+		  memcpy(rtn,ba,alen);
+		  rtn[alen]=0;
+		 }
+		 (env)->ReleaseByteArrayElements(barr,ba,0);  //
+		 return rtn;
+	}
+	JNIEXPORT jstring JNICALL Java_cn_itcast_cpp_DemoActivity_HelloFromC
+	  (JNIEnv * env, jobject obj){
+		//C代码
+		//return (*env)->NewStringUTF(env,"haha from c"); 在C中env代表的是C中结构体的指针的指针
+		//c++代码
+		return env->NewStringUTF("haha from cpp");//在C++中env代表的是C++中结构体的指针
+	}
+	```
+ 
+15. 对于JNI中的中文乱码问题        
+    老版本的ndk r7之前 r6 r5 r5 crystal r4(编译的时候 语言集 是iso-8859-1)           
+	在使用老版本ndk 编译出来的so文件的时候 要手动的进行转码.先用iso8859-1解码，再用utf-8编码，在r7(包括)之后的我们只要将C文件的格式改为UTF-8就可以了
+ 
+16. 文件的格式及格式转换
+    格式转换的原理：                
+    1. 读取一段数据到内存     
+    2. 分析这一段数据
+    3. 修改里面的内容
+    4. 写到文件里面
+ 
+	文件的格式：        
+	文件的存储方式是二进制0101这样        
+	那么怎么设别文件的类型呢？     
+	1. 根据扩展名
+	2. 根据文件的头信息(头信息才是一个文件的真正的格式)，有些文件我们修改了扩展名也可以打开，
+		这是因为打开文件的程序区扫描了文件的头信息，并用头信息中的类型来打开了这个文件
+
+17. C中读取数据    
+	```c
+	#include<stdio.h>
+	main(){
+	//用  法: FILE *fopen(char *filename, char *type); //第二个参数是打开的方式 rt就是读文件， rb就是读二进制
+	   FILE*    fp = fopen("1.txt","rt");
+	//用  法: int fread (void *ptr, int size, int nitems, FILE *stream); 
+							//ptr要读的数据 放在哪一块内存空间里面.
+							//size 一次读的数据的长度.
+							//nitems 读多少次
+							//stream 从哪个文件里面 读
+	 
+	  char* buffer = malloc(sizeof(char)*12);
+	 int len=   fread(buffer,sizeof(char),12,fp);
+	printf("读了%d个char\n",len);
+	   printf("str=%s\n",buffer);
+	   fclose(fp);  //关闭掉流
+	 
+	  system("pause");     
+	}
+	```
+	
+18. C中写文件
+	```c
+	#include<stdio.h>
+	main(){
+	//用  法: FILE *fopen(char *filename, char *type);
+	   FILE*    fp = fopen("1.txt","wt");
+	//用  法: int fwrite(void *ptr, int size, int nitems, FILE *stream); 
+							//ptr要向文件写的是哪一块内存里面的数据
+							//size 一次写的数据的长度.
+							//nitems 写多少次
+							//stream 写到哪个文件里面
+	   char* str="hello from c";
+	   int len = fwrite(str,sizeof(char),12,fp);
+	   printf("写了%d个char\n",len);
+	   fclose(fp);  //关闭掉流
+	 
+	   system("pause");     
+	}
+	``` 
+	
+19. C语言文件操作模式
+	“rt” 只读打开一个文本文件，只允许读数据       
+	“wt” 只写打开或建立一个文本文件，只允许写数据        
+	“at” 追加打开一个文本文件，并在文件末尾写数据      
+	“rb” 只读打开一个二进制文件，只允许读数据      
+	“wb” 只写打开或建立一个二进制文件，只允许写数据      
+	“ab” 追加打开一个二进制文件，并在文件末尾写数据       
+	“rt+” 读写打开一个文本文件，允许读和写        
+	“wt+” 读写打开或建立一个文本文件，允许读写        
+	“at+” 读写打开一个文本文件，允许读，或在文件末追加数据         
+	“rb+” 读写打开一个二进制文件，允许读和写           
+	“wb+” 读写打开或建立一个二进制文件，允许读和写            
+	“ab+” 读写打开一个二进制文件，允许读，或在文件末追加数据        
+
+	对于文件使用方式有以下几点说明： 
+	文件使用方式由r,w,a,t,b，+六个字符拼成，各字符的含义是： 
+
+	r(read): 读           
+	w(write): 写         
+	a(append): 追加               
+	t(text): 文本文件，可省略不写        
+	b(banary): 二进制文件        
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck!
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/ListView\344\270\223\351\242\230.md" "b/BasicKnowledge/ListView\344\270\223\351\242\230.md"
similarity index 97%
rename from "Android\345\237\272\347\241\200/ListView\344\270\223\351\242\230.md"
rename to "BasicKnowledge/ListView\344\270\223\351\242\230.md"
index eb8114e8..f8103376 100644
--- "a/Android\345\237\272\347\241\200/ListView\344\270\223\351\242\230.md"
+++ "b/BasicKnowledge/ListView\344\270\223\351\242\230.md"
@@ -1,3 +1,4 @@
+
 ListView专题
 ===
 
@@ -111,7 +112,8 @@ mAutoCircleViewPager = (ViewPager) mHeaderView.findViewById(R.id.vp_auto_circle)
 //addHeaderView要在ListView的setAdapter前添加            
 mListView.addHeaderView(mHeaderView);
 ```
-**注意**ViewPager的布局中宽高不能够使用`wrap_content`可以使用`match_parent`但是上面显示不出来也是由于match_parent的问题，如果我们将布局中的`layout_height="200dip"`,这样就能够显示出来`ViewPager`
+**注意**ViewPager的布局中宽高不能够使用`wrap_content`可以使用`match_parent`但是上面显示不出来也是由于match_parent的问题，
+如果我们将布局中的`layout_height="200dip"`,这样就能够显示出来`ViewPager`
  
 ---
 
diff --git "a/BasicKnowledge/Parcelable\345\217\212Serializable.md" "b/BasicKnowledge/Parcelable\345\217\212Serializable.md"
new file mode 100644
index 00000000..de220416
--- /dev/null
+++ "b/BasicKnowledge/Parcelable\345\217\212Serializable.md"
@@ -0,0 +1,84 @@
+Parcelable及Serializable
+===
+
+
+
+### Serializable
+
+在Java中Serializable接口是一个允许将对象转换为字节流(序列化)然后重新构造回对象(反序列化)的标记接口。   
+
+它会使用反射，并且会创建许多临时对象，导致内存使用率升高，并可能产生性能问题。  
+
+
+`Serializable`的作用是为了保存对象的属性到本地文件、数据库、网络流、`rmi`以方便数据传输，
+当然这种传输可以是程序内的也可以是两个程序间的。而`Parcelable`的设计初衷是因为`Serializable`效率过慢，
+为了在程序内不同组件间以及不同`Android`程序间(`AIDL`)高效的传输数据而设计，这些数据仅在内存中存在，`Parcelable`是通过`IBinder`通信的消息的载体。
+
+`Parcelable`的性能比`Serializable`好，在内存开销方面较小，所以在内存间数据传输时推荐使用`Parcelable`，
+如`activity`间传输数据，而`Serializable`可将数据持久化方便保存，所以在需要保存或网络传输数据时选择
+`Serializable`，因为`android`不同版本`Parcelable`可能不同，所以不推荐使用`Parcelable`进行数据持久化。
+
+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
+- serializable interface is easier to implement
+- serializable interface create a lot of temporary objects and cause quite a bit of garbage collection
+- Parcelable array can be pass via Intent in android.
+
+----
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/PopupWindow\347\273\206\350\212\202.md" "b/BasicKnowledge/PopupWindow\347\273\206\350\212\202.md"
similarity index 85%
rename from "Android\345\237\272\347\241\200/PopupWindow\347\273\206\350\212\202.md"
rename to "BasicKnowledge/PopupWindow\347\273\206\350\212\202.md"
index de67b9cc..244f786d 100644
--- "a/Android\345\237\272\347\241\200/PopupWindow\347\273\206\350\212\202.md"
+++ "b/BasicKnowledge/PopupWindow\347\273\206\350\212\202.md"
@@ -1,14 +1,15 @@
-PopupWindow细节
+PopupWindow细节
 ===
 
-##简介
+## 简介
 
 `A popup window that can be used to display an arbitrary view. The popup windows is a floating container that appears on top of the current activity.`
  
 1. 显示
 	```java
 	View contentView = View.inflate(getApplicationContext(),R.layout.popup_appmanger, null); 
-	//这里最后一个参数是指定是否能够获取焦点，如果为false那么点击弹出来之后就不消失了，但是设置为true之后点击一个条目它弹出来了，再点击别的条目的时候这个popupWindow窗口没有焦点了就自己消失了
+	//这里最后一个参数是指定是否能够获取焦点，如果为false那么点击弹出来之后就不消失了，但是设置为true之后点击一个条目它弹出来了，
+	再点击别的条目的时候这个popupWindow窗口没有焦点了就自己消失了
 	PopupWindow popwindow = new PopupWindow(contentView ,LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT,true);
 	popwindow.setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
 	int[] location = new int[2];
@@ -27,11 +28,13 @@
 	```
 
 3. 细节
-	`PopupWindow`是存在到`Activity`上的，如果`PopupWindow`在显示的时候按退出键的时候该`Activity`已经销毁，但是`PopupWindow`没有销毁，所以就报错了(`Logcat`有报错信息但是程序不会崩溃)，所以我们在`Activity`的`onDestroy`方法中要判断一下`PopupWindow`是否在显示，如果在显示就取消显示。     
-	`PopupWindow`默认是没有背景的，如果想让它播放动画就没有效果了，因为没有背景就什么也播放不了，所以我们在用这个`PopupWindow`的时候必须要给它设置一个背景，通常可以给它设置为透明色,这样再播放动画就有效果了
+	`PopupWindow`是存在到`Activity`上的，如果`PopupWindow`在显示的时候按退出键的时候该`Activity`已经销毁，但是`PopupWindow`没有销毁，
+	所以就报错了(`Logcat`有报错信息但是程序不会崩溃)，所以我们在`Activity`的`onDestroy`方法中要判断一下`PopupWindow`是否在显示，如果在显示就取消显示。      
+	`PopupWindow`默认是没有背景的，如果想让它播放动画就没有效果了，因为没有背景就什么也播放不了，所以我们在用这个`PopupWindow`的时候必须要给它设置一个背景，
+	通常可以给它设置为透明色,这样再播放动画就有效果了
 	`popwindow.setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));`
 	
-##让`PopupWindow`响应`Back`键后关闭。
+## 让`PopupWindow`响应`Back`键后关闭。
 
 - 最简单        
     在`new`的时候，使用下面的方法：          
diff --git "a/Android\345\237\272\347\241\200/SDK Manager\346\227\240\346\263\225\346\233\264\346\226\260\347\232\204\351\227\256\351\242\230.md" "b/BasicKnowledge/SDK Manager\346\227\240\346\263\225\346\233\264\346\226\260\347\232\204\351\227\256\351\242\230.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/SDK Manager\346\227\240\346\263\225\346\233\264\346\226\260\347\232\204\351\227\256\351\242\230.md"
rename to "BasicKnowledge/SDK Manager\346\227\240\346\263\225\346\233\264\346\226\260\347\232\204\351\227\256\351\242\230.md"
diff --git "a/Android\345\237\272\347\241\200/Scroller\347\256\200\344\273\213.md" "b/BasicKnowledge/Scroller\347\256\200\344\273\213.md"
similarity index 83%
rename from "Android\345\237\272\347\241\200/Scroller\347\256\200\344\273\213.md"
rename to "BasicKnowledge/Scroller\347\256\200\344\273\213.md"
index b5c22f14..bfa12941 100644
--- "a/Android\345\237\272\347\241\200/Scroller\347\256\200\344\273\213.md"
+++ "b/BasicKnowledge/Scroller\347\256\200\344\273\213.md"
@@ -1,8 +1,9 @@
 Scroller简介
 ===
 
-在`SlidingMenu`项目中为了实现控件的滑动，需要用到`Scroller`类来实现缓慢的滑动过程，至于有人说`View`类可以直接调用`scrollTo()`方法，这里`scrollTo()`方法也能实现移动，
-但是它的移动是很快一下子就移过去了，就像穿越一样，直接从现实回到了过去，而`Scroller`类能够实现过程的移动。可以理解为一步步的走。    
+在`SlidingMenu`项目中为了实现控件的滑动，需要用到`Scroller`类来实现缓慢的滑动过程，至于有人说`View`类可以直接调用`scrollTo()`方法，
+这里`scrollTo()`方法也能实现移动，但是它的移动是很快一下子就移过去了，就像穿越一样，直接从现实回到了过去，而`Scroller`类能够实现过程的移动。
+可以理解为一步步的走。    
 
 1. 查看Scroller源码
     ```java
@@ -28,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/Android\345\237\272\347\241\200/ScrollingTabs.md" b/BasicKnowledge/ScrollingTabs.md
similarity index 61%
rename from "Android\345\237\272\347\241\200/ScrollingTabs.md"
rename to BasicKnowledge/ScrollingTabs.md
index 7045ae69..f543925a 100644
--- "a/Android\345\237\272\347\241\200/ScrollingTabs.md"
+++ b/BasicKnowledge/ScrollingTabs.md
@@ -3,64 +3,67 @@ ScrollingTabs
 
 自定义ScrollingTabs结合ViewPager实现指引的效果。    
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ScrollingTabs.png?raw=true)        
-**原理:**    
+       
+**原理:**         
 由于`ScrollingTabs`即可以点击又可以实现左右滑动，首先想到的就是继承`HorizontalScrollView`来实现滑动，至于点击的实现需要通过对`View`
-设置点击。    
+设置点击。          
 通过对`ViewPager`设置`OnPageChangeListener`来监听页面变化，从而实现对`ScrollingTabs`的改变，而在每个`Tab`上设置
 点击事件，当点击的时候就去设置`ViewPager`的当前页面
 
-1.  继承HorizontalScrollView，并且添加一个水平方向的线性布局，作为Tab的父布局
-```java
-    public class ScrollingTabs extends HorizontalScrollView {
-    
-    	private LinearLayout mContainer;
-    
-    	public ScrollingTabs(Context context, AttributeSet attrs, int defStyle) {
-    		super(context, attrs, defStyle);
-    		init(context);
-    	}
-    
-    	public ScrollingTabs(Context context, AttributeSet attrs) {
-    		super(context, attrs);
-    		init(context);
-    	}
-    
-    	public ScrollingTabs(Context context) {
-    		super(context);
-    		init(context);
-    	}
-    
-    	private void init(Context context) {
-    		this.setHorizontalScrollBarEnabled(false);
-    		this.setHorizontalFadingEdgeEnabled(false);
-    
-    		mContainer = new LinearLayout(context);
-    		LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
-    				android.view.ViewGroup.LayoutParams.MATCH_PARENT,
-    				android.view.ViewGroup.LayoutParams.MATCH_PARENT);
-    		mContainer.setLayoutParams(params);
-    		mContainer.setOrientation(LinearLayout.HORIZONTAL);
-    
-    		addView(mContainer);
-    	}
-```
+1. 继承HorizontalScrollView，并且添加一个水平方向的线性布局，作为Tab的父布局
+	```java
+	public class ScrollingTabs extends HorizontalScrollView {
+
+		private LinearLayout mContainer;
+
+		public ScrollingTabs(Context context, AttributeSet attrs, int defStyle) {
+			super(context, attrs, defStyle);
+			init(context);
+		}
+
+		public ScrollingTabs(Context context, AttributeSet attrs) {
+			super(context, attrs);
+			init(context);
+		}
+
+		public ScrollingTabs(Context context) {
+			super(context);
+			init(context);
+		}
+
+		private void init(Context context) {
+			this.setHorizontalScrollBarEnabled(false);
+			this.setHorizontalFadingEdgeEnabled(false);
+
+			mContainer = new LinearLayout(context);
+			LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
+					android.view.ViewGroup.LayoutParams.MATCH_PARENT,
+					android.view.ViewGroup.LayoutParams.MATCH_PARENT);
+			mContainer.setLayoutParams(params);
+			mContainer.setOrientation(LinearLayout.HORIZONTAL);
+
+			addView(mContainer);
+		}
+	}
+	```
 
 2. 提供接口供调用者设置每个Tab的视图。
-```java
-    public interface TabAdapter {
+	```java
+	public interface TabAdapter {
 		/**
 		 * 每个Tab的视图
 		 */
 		public View getView(int position);
-    	/**
+		/**
 		 * Tab之间的分割线
 		 */
 		public View getSeparator();
 	}
-```
+	```
+	
 3. 暴露方法，初始化Tab。
-```java
-    public void setTabAdapter(TabAdapter adapter) {
+	```java
+	public void setTabAdapter(TabAdapter adapter) {
 		this.mTabAdapter = adapter;
 		initTabView();
 	}
@@ -76,9 +79,9 @@ ScrollingTabs
 	 */
 	private void initTabView() {
 		if (mViewPager != null && mTabAdapter != null) {
-            //清空父布局，保险起见
+			//清空父布局，保险起见
 			mContainer.removeAllViews();
-            //根据ViewPager的页数去设置Tab
+			//根据ViewPager的页数去设置Tab
 			for (int i = 0; i < mViewPager.getAdapter().getCount(); i++) {
 				final View tab = mTabAdapter.getView(i);
 				tab.setTag(i);
@@ -88,7 +91,7 @@ ScrollingTabs
 				// Segmentation view
 				if (mTabAdapter.getSeparator() != null
 						&& i != mViewPager.getAdapter().getCount() - 1) {
-                    //Tabs之间使用分割线
+					//Tabs之间使用分割线
 					isUseSeperator = true;
 					mContainer.addView(mTabAdapter.getSeparator());
 				}
@@ -100,11 +103,11 @@ ScrollingTabs
 					public void onClick(View v) {
 						int index = (Integer) tab.getTag();
 						if (mTabClickListener != null) {
-                            //暴露接口
+							//暴露接口
 							mTabClickListener.onClick(index);
 						} else {
 							if (mViewPager.getCurrentItem() == index) {
-                                //如果当前ViewPager已经显示到了该Tab也，就直接让其选中
+								//如果当前ViewPager已经显示到了该Tab也，就直接让其选中
 								selectTab(index);
 							} else {
 								//当前ViewPager并没有显示该Tab页，要让ViewPager去显示相应的Tab页
@@ -120,12 +123,13 @@ ScrollingTabs
 			selectTab(mViewPager.getCurrentItem());
 		}
 	}
-```
+	```
+	
 4. selectTab的实现，选中相应的Tab，并且实现滑动到屏幕中间位置
-```java
-    private void selectTab(int position) {
+	```java
+	private void selectTab(int position) {
 		if (!isUseSeperator) {
-            //没有分割线
+			//没有分割线
 			for (int i = 0; i < mContainer.getChildCount(); i++) {
 				View tab = mContainer.getChildAt(i);
 				tab.setSelected(i == position);
@@ -137,7 +141,7 @@ ScrollingTabs
 				tab.setSelected(pos == position);
 			}
 		}
-        //得到当前的Tab
+		//得到当前的Tab
 		View selectedView = null;
 		if (!isUseSeperator) {
 			selectedView = mContainer.getChildAt(position);
@@ -148,14 +152,14 @@ ScrollingTabs
 		int tabWidth = selectedView.getMeasuredWidth();
 		int tabLeft = selectedView.getLeft();
 
-        //距离左边屏幕的位置加上该Tab宽度的一半正好是该Tab中心点的位置。我们需要让该Tab的中心点移动到屏幕的中心点。
+		//距离左边屏幕的位置加上该Tab宽度的一半正好是该Tab中心点的位置。我们需要让该Tab的中心点移动到屏幕的中心点。
 		int distance = (tabLeft + tabWidth / 2) - mWindowWidth / 2;
-        //移动
+		//移动
 		smoothScrollTo(distance, this.getScrollY());
 	}
-```
+	```
 
-------------------------------------------
+---
 
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/Selector\344\275\277\347\224\250.md" "b/BasicKnowledge/Selector\344\275\277\347\224\250.md"
similarity index 94%
rename from "Android\345\237\272\347\241\200/Selector\344\275\277\347\224\250.md"
rename to "BasicKnowledge/Selector\344\275\277\347\224\250.md"
index 1efcd9f6..d088d70f 100644
--- "a/Android\345\237\272\347\241\200/Selector\344\275\277\347\224\250.md"
+++ "b/BasicKnowledge/Selector\344\275\277\347\224\250.md"
@@ -39,7 +39,7 @@ Selector使用
 		stalistDrawable.addState(new int []{focused }, getResources().getDrawable(R.drawable.pic4);  
 		//没有任何状态时显示的图片，我们给它设置我空集合  
 		stalistDrawable.addState(new int []{}, getResources().getDrawable(R.drawable.pic5);  
-		上面的“-”负号表示对应的属性值为false
+		上面的“-”负号表示对应的属性值为 false
 		当我们为某个View使用其作为背景色时，会根据状态进行背景图的转换。
     	```
     - public boolean isStateful ()     
@@ -47,8 +47,8 @@ Selector使用
         注：在StateListDrawable类中，该方法返回为true，显然状态改变后，我们的图片会跟着改变。
 
 2. GridView之Selector使用：  
-
-    GridView在点击每一个条目的时候黄色的背景,很难看，那么怎么才能让其不显示这个颜色呢?就是在GridView中将listSelector这个属性指定为透明的，这样再点击的时候就不显示黄色了，但是这样用户不知道自己点击了没有，所以要让它在点击的时候显示一个我们自定义的颜色     
+    GridView在点击每一个条目的时候黄色的背景,很难看，那么怎么才能让其不显示这个颜色呢?就是在GridView中将listSelector这个属性指定为透明的，
+	这样再点击的时候就不显示黄色了，但是这样用户不知道自己点击了没有，所以要让它在点击的时候显示一个我们自定义的颜色     
     ```xml
     <GridView
         android:listSelector="@android:color/transparent"//listSelector用于标示当前的条目被选择的时候的状态
@@ -103,4 +103,4 @@ Selector使用
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/SlidingMenu.md" b/BasicKnowledge/SlidingMenu.md
similarity index 97%
rename from "Android\345\237\272\347\241\200/SlidingMenu.md"
rename to BasicKnowledge/SlidingMenu.md
index 7148c8b6..2bdf47f8 100644
--- "a/Android\345\237\272\347\241\200/SlidingMenu.md"
+++ b/BasicKnowledge/SlidingMenu.md
@@ -10,7 +10,8 @@ SlidingMenu
 原理
 ---
 
-`SlidingMenu`无非就是一个包含三个`View`的控件，**左边View**、**中间View(默认时全屏)**、**右边View**，默认的情况下中间`View`会把两边的`View`覆盖住，在手指滑动的时候，会根据手指的滑动方向以及滑动距离去移动中间的那个`View`，从而能让两边`View`完全可见。    
+`SlidingMenu`无非就是一个包含三个`View`的控件，**左边View**、**中间View(默认时全屏)**、**右边View**，默认的情况下中间`View`会把两边的`View`覆盖住，
+在手指滑动的时候，会根据手指的滑动方向以及滑动距离去移动中间的那个`View`，从而能让两边`View`完全可见。    
 在定义该View的时候，首先会想到继承`RelativeLayout`，能简单的实现这种左、中、右三个View的布局。
 
 1. 继承RelativeLayout
@@ -41,7 +42,6 @@ SlidingMenu
 	```
 
 2. 具体的三个View需要暴露给外界调用，所以我们要提供一个setView()的方法。
-
 	```java
 	public void setView(View leftView, View rightView, View centerView,
 			int leftViewWidth, int rightViewWidth) {
@@ -207,7 +207,8 @@ SlidingMenu
 	```
 
 4. 到这里SlidingMenu的大体实现已经完成了        
-	剩下的就是对速率的计算，已经添加显示左边与显示右边的View的按钮。当左边View完全显示的时候，点击中间View可见部分时需要让中间View全屏。至于这些细节的东西就不再仔细说了，大家自己看源码吧。
+	剩下的就是对速率的计算，已经添加显示左边与显示右边的View的按钮。当左边View完全显示的时候，点击中间View可见部分时需要让中间View全屏。
+	至于这些细节的东西就不再仔细说了，大家自己看源码吧。
 
 ---
 
diff --git "a/Android\345\237\272\347\241\200/String\346\240\274\345\274\217\345\214\226.md" "b/BasicKnowledge/String\346\240\274\345\274\217\345\214\226.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/String\346\240\274\345\274\217\345\214\226.md"
rename to "BasicKnowledge/String\346\240\274\345\274\217\345\214\226.md"
diff --git "a/Android\345\237\272\347\241\200/TextView\350\267\221\351\251\254\347\201\257\346\225\210\346\236\234.md" "b/BasicKnowledge/TextView\350\267\221\351\251\254\347\201\257\346\225\210\346\236\234.md"
similarity index 99%
rename from "Android\345\237\272\347\241\200/TextView\350\267\221\351\251\254\347\201\257\346\225\210\346\236\234.md"
rename to "BasicKnowledge/TextView\350\267\221\351\251\254\347\201\257\346\225\210\346\236\234.md"
index b47295e2..046e211e 100644
--- "a/Android\345\237\272\347\241\200/TextView\350\267\221\351\251\254\347\201\257\346\225\210\346\236\234.md"
+++ "b/BasicKnowledge/TextView\350\267\221\351\251\254\347\201\257\346\225\210\346\236\234.md"
@@ -66,6 +66,6 @@ TextView实现跑马灯的效果,不用自定义View
     android:text="测试啊啊啊啊啊啊啊啊ggggggggggggggggggggggggggggg" />
 ```
 
-----
+---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
diff --git "a/BasicKnowledge/WebView\346\200\273\347\273\223.md" "b/BasicKnowledge/WebView\346\200\273\347\273\223.md"
new file mode 100644
index 00000000..e0e09f02
--- /dev/null
+++ "b/BasicKnowledge/WebView\346\200\273\347\273\223.md"
@@ -0,0 +1,132 @@
+WebView总结
+===
+     
+在`Android`中有`WebView Widget`，它内置了`WebKit`引擎，同时，`WebKit`也是`Mac OS X`的`Safari`网页浏览器的基础。`WebKit`是一个开源的浏览器引擎，
+`Chrome`浏览器也是基于它的。所以很多表现`WebView`和`Chrome`是一样的。          
+
+很多文章中多会说在使用`WebView`之前，要在`AndroidManifest.xml`中添加 如下权限：           
+`<uses-permission android:name="android.permission.INTERNET"></uses-permission>`        
+否则会出`Web page not available`错误。其实这是不全面的，如果我加载本地的页面是不用该权限的。
+
+- 设置WevView要显示的网页方法有很多：
+    - `mWebView.loadUrl(“http://www.google.com“);` // 网络
+    - `mWebView.loadUrl(“file:///android_asset/XX.html“);` // 本地页面,这里的格式是固定的，文件要放到`assets`目录下
+    - `mWebview.postUrl(String url, byte[] postData); // 加载页面使用`Post`方式，`postData`为参数`
+    ```java
+	String postData = "password=password&username=username";
+	mWebview.postUrl(url, EncodingUtils.getBytes(postData, "base64"));
+	```
+    - mWebView.loadData(htmlString, "text/html", "utf-8"); // 加载Html数据
+    ```java
+	String htmlString = "<h1>Title</h1><p>This is HTML text<br /><i>Formatted in italics</i><br />Anothor Line</p>";
+	mWebView.loadData(htmlString, "text/html", "utf-8"); // 加载Html数据
+	```
+	- `loadData()`不能加载图片内容，如果要加载图片内容或者获得更强大的Web支持请使用`loadDataWithBaseURL()`。
+	- 显示乱码    
+    `WebView`一般为了节省资源使用`UTF-8`编码，而`String`类型的数据主要是`Unicode`编码，
+	因此在`loadData()`的时候需要设置相应编码让其将`Unicode`编码转成`UTF-8`但是有些时候设置后还是会出现乱码，这是因为还需要为`WebView`中的`Text`设置编码，
+	```java
+	WebView mWebView = (WebView)findViewById(R.id.webview) ;
+	String content = getUnicodeContent() ;
+	mWebView.getSettings().setDefaultTextEncodingName(“UTF -8”) ;
+	mWebView.loadData(content, “text/html”, “UTF-8”) ;
+	```
+
+- 设置WebView基本信息：        
+
+	- 如果访问的页面中有`Javascript`，则`webview`必须设置支持`Javascript`。     
+	    `webview.getSettings().setJavaScriptEnabled(true);  `       
+	- 触摸焦点起作用      
+	    `requestFocus() // 如果不设置的话，会出现不能弹出软键盘等问题。`     
+	- 取消滚动条       
+	    `this.setScrollBarStyle(SCROLLBARS_OUTSIDE_OVERLAY);`
+		
+- Back键的处理     
+    如果用`webview`点链接看了很多页以后，如果不做任何处理，点击系统`Back`键，整个浏览器会调用`finish()`而结束自身，
+	如果希望浏览的网页回退而不是退出浏览器，需要在当前`Activity`中处理并消费掉该`Back`事件。
+	```java
+	 public boolean onKeyDown(int keyCoder,KeyEvent event){
+		if(webView.canGoBack() && keyCoder == KeyEvent.KEYCODE_BACK){
+			webview.goBack();   //goBack()表示返回webView的上一页面
+			return true;
+		}
+		return false;
+	 }
+	```
+	
+- WebView中Padding没有效果	       
+    `WebView`中使用`Padding`没有效果，我们在`WebView`外层包上一层布局就会有所改进，但是不能完全解决问题，正确的做法是在`WebView`的加载`css`中增加`Padding`
+	
+- WebViewClient        
+    如果希望点击链接由自己处理，而不是新开`Android`的系统`browser`中响应该链接。
+	给`WebView`添加一个事件监听对象`WebViewClient`并重写其中的一些方法： `shouldOverrideUrlLoading`对网页中超链接按钮的响应。
+	当按下某个连接时`WebViewClient`会调用这个方法，并传递按下的url。
+	1. 接收到 Http 请求的事件 
+	    `onReceivedHttpAuthRequest(WebView view, HttpAuthHandler handler, String host, String realm) `            
+		
+	2. 打开链接前的事件
+	    `public boolean shouldOverrideUrlLoading(WebView view, String url) { view.loadUrl(url); return true; } `           
+	    这个函数我们可以做很多操作，比如我们读取到某些特殊的URL，于是就可以不打开地址，取消这个操作，进行预先定义的其他操作，这对一个程序是非常必要的。
+		
+	3. 载入页面完成的事件
+	    `public void onPageFinished(WebView view, String url){ } `              
+	    页面载入完成，于是我们可以关闭`loading`条，切换程序动作。
+		
+	4. 载入页面开始的事件
+	    `public void onPageStarted(WebView view, String url, Bitmap favicon)`              
+	    这个事件就是开始载入页面调用的，通常我们可以在这设定一个loading的页面，告诉用户程序在等待网络响应。
+	    
+
+`WebView`与`Js`交互
+---
+
+- `Android`调用`WebView`中的`js`脚本。
+	```java
+	// 启用javascript		mWebView.getSettings().setJavaScriptEnabled(true);
+	// 加载web页面
+	mWebView.loadUrl("file:///android_asset/wst.html");
+	// 调用js
+	mWebView.loadUrl("javascript:test('" + aa+ "')"); //aa是js的函数test()的参数  
+	```
+
+- `Js`调用`Android`中的方法        
+	```java
+	public WebViewActivity extends Activity {
+	
+	    public void onCreate() {
+	        // 启用javascript	
+	        mWebView.getSettings().setJavaScriptEnabled(true);
+	        // 加载web页面
+	        mWebView.loadUrl("file:///android_asset/wst.html");
+	        // 首先要对webview绑定javascriptInterface，js脚本通过这个接口来调用java代码。javascriptInterface实际就是一个普通的java类，里面是我们本地实现的java代码， 将JavascriptInterface传递给webview，并指定别名，这样js脚本就可以通过我们给的这个别名来调用我们的方法,在这里，this是实例化的对象，wst是这个对象在js中的别名
+	        mWebView.addJavascriptInterface(this, "wst");
+	    }
+	    
+	    // js所调用的native方法的本地实现，安卓4.2及以上版本（API >= 17），在注入类中为可调用的方法添加@JavascriptInterface注解，无注解的方法不能被调用，这种方式可以防范注入漏洞
+	    @JavascriptInterface
+	    public void startFunction(final String str) {  
+	        Toast.makeText(this, str, Toast.LENGTH_SHORT).show();  
+	        runOnUiThread(new Runnable() {  
+	    
+	            @Override  
+	            public void run() {  
+	                msgView.setText(msgView.getText() + "\njs调用了java函数传递参数：" + str);  
+	    
+	            }  
+	        });  
+	    }  
+	}
+	```
+	
+	`js`中通过如下代码调用即可           
+	```html
+	<a onClick="window.wst.startFunction('hello world')" >点击调用java代码并传递参数</a>  
+	```
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/Widget(\347\252\227\345\217\243\345\260\217\351\203\250\344\273\266).md" "b/BasicKnowledge/Widget(\347\252\227\345\217\243\345\260\217\351\203\250\344\273\266).md"
similarity index 68%
rename from "Android\345\237\272\347\241\200/Widget(\347\252\227\345\217\243\345\260\217\351\203\250\344\273\266).md"
rename to "BasicKnowledge/Widget(\347\252\227\345\217\243\345\260\217\351\203\250\344\273\266).md"
index 7d8a3ec3..a43b5f8f 100644
--- "a/Android\345\237\272\347\241\200/Widget(\347\252\227\345\217\243\345\260\217\351\203\250\344\273\266).md"
+++ "b/BasicKnowledge/Widget(\347\252\227\345\217\243\345\260\217\351\203\250\344\273\266).md"
@@ -59,7 +59,9 @@ Widget简介
 		android:updatePeriodMillis="86400000" //指定更新的间隔时间，最小为半个小时，一般不用它更新，都是自己更新
 		android:previewImage="@drawable/preview"//指定小控件的图标,如果不要这个选项就是程序的图标
 		android:initialLayout="@layout/example_appwidget"//设置这个小控件的布局文件
-		android:configure="com.example.android.ExampleAppWidgetConfigure" //有些复杂的Widget在点击的时候会去开启一个Activity，这时候就是通过这个参数来配置要开启的Activity，用不着就删除这一行	android:resizeMode="horizontal|vertical">//这个是Android3.0的一个新特性，是可以让widget改变大小，在2.3时候创建出来的Widget多大就是多大，不能改变，可以把这个去掉
+		android:configure="com.example.android.ExampleAppWidgetConfigure" //有些复杂的Widget在点击的时候会去开启一个Activity，
+		// 这时候就是通过这个参数来配置要开启的Activity，用不着就删除这一行	android:resizeMode="horizontal|vertical">
+		//这个是Android3.0的一个新特性，是可以让widget改变大小，在2.3时候创建出来的Widget多大就是多大，不能改变，可以把这个去掉
 	</appwidget-provider>
 	```
 	
@@ -89,14 +91,14 @@ Widget简介
 					views.setTextViewText(
 							R.id.process_count,
 							"正在运行:"
-									+ ProcessStatusUtils												.getProcessCount(getApplicationContext())
+									+ ProcessStatusUtils.getProcessCount(getApplicationContext())
 									+ "个");
 					views.setTextViewText(
 							R.id.process_memory,
 							"可用内存:"
 									+ Formatter
 											.formatFileSize(
-													getApplicationContext(),				       ProcessStatusUtils.getAvailRAM(getApplicationContext())));
+													getApplicationContext(), ProcessStatusUtils.getAvailRAM(getApplicationContext())));
 					Intent intent = new Intent();
 					intent.setAction("com.itheima.killall");
 					//设置一个自定义的广播事件 动作  com.itheima.killall
@@ -120,37 +122,42 @@ Widget简介
 
 ## Widget的声明周期
 
-	`Widget`就是一个特殊的广播接收者
-	1. 当界面上第一个`widget`被创建的时候
-		01-14 02:17:14.348: INFO/System.out(1853): onEnabled   当`widget`第一次被创建的时候调用. 非常适合做应用程序的初始化.
-		01-14 02:17:14.348: INFO/System.out(1853): onReceive
-		01-14 02:17:14.357: INFO/System.out(1853): onUpdate     当有新的`widget`被创建的时候 更新界面的操作. 当时间片到的时候`onupdate()`调用.
-		01-14 02:17:14.357: INFO/System.out(1853): onReceive
-
-	2. 当界面上第二个`widget`被创建的时候 
-		01-14 02:18:10.148: INFO/System.out(1853): onUpdate
-		01-14 02:18:10.148: INFO/System.out(1853): onReceive
-
-	3. 再创建新的`widget`
-		01-14 02:18:10.148: INFO/System.out(1853): onUpdate
-		01-14 02:18:10.148: INFO/System.out(1853): onReceive
-
-	4. 从界面上移除一个`widget`
-		01-14 02:19:11.709: INFO/System.out(1853): onDeleted
-		01-14 02:19:11.709: INFO/System.out(1853): onReceive
-
-	5. 最后一个`widget`被移除
-		01-14 02:19:37.509: INFO/System.out(1853): onDeleted
-		01-14 02:19:37.509: INFO/System.out(1853): onReceive
-		01-14 02:19:37.509: INFO/System.out(1853): onDisabled  当`widget`从界面上全部移除的时候调用的方法. 非常适合删除临时文件停止后台服务.
-		01-14 02:19:37.509: INFO/System.out(1853): onReceive
+`Widget`就是一个特殊的广播接收者
+1. 当界面上第一个`widget`被创建的时候
+	```
+	01-14 02:17:14.348: INFO/System.out(1853): onEnabled   当`widget`第一次被创建的时候调用. 非常适合做应用程序的初始化.
+	01-14 02:17:14.348: INFO/System.out(1853): onReceive
+	01-14 02:17:14.357: INFO/System.out(1853): onUpdate     当有新的`widget`被创建的时候 更新界面的操作. 当时间片到的时候`onupdate()`调用.
+	01-14 02:17:14.357: INFO/System.out(1853): onReceive
+	```
 
-	6. `widget`就是一个特殊的广播接受者 当有新的事件产生的是 肯定会调用 `onReceive()`;
+2. 当界面上第二个`widget`被创建的时候 
+	```
+	01-14 02:18:10.148: INFO/System.out(1853): onUpdate
+	01-14 02:18:10.148: INFO/System.out(1853): onReceive
+	```
+3. 再创建新的`widget`
+	```
+	01-14 02:18:10.148: INFO/System.out(1853): onUpdate
+	01-14 02:18:10.148: INFO/System.out(1853): onReceive
+	```
+4. 从界面上移除一个`widget`
+    ```
+	01-14 02:19:11.709: INFO/System.out(1853): onDeleted
+	01-14 02:19:11.709: INFO/System.out(1853): onReceive
+    ```
+5. 最后一个`widget`被移除
+    ```
+	01-14 02:19:37.509: INFO/System.out(1853): onDeleted
+	01-14 02:19:37.509: INFO/System.out(1853): onReceive
+	01-14 02:19:37.509: INFO/System.out(1853): onDisabled  当`widget`从界面上全部移除的时候调用的方法. 非常适合删除临时文件停止后台服务.
+	01-14 02:19:37.509: INFO/System.out(1853): onReceive
+    ```
+6. `widget`就是一个特殊的广播接受者 当有新的事件产生的是 肯定会调用 `onReceive()`;
 	
-**
+
 注意: 在不同的手机上  widget的生命周期调用方法 可能有细微的不同.
 360桌面 go桌面 awt桌面 腾讯桌面 小米桌面
-**
 	
 ---
 
diff --git "a/Android\345\237\272\347\241\200/Wifi\347\212\266\346\200\201\347\233\221\345\220\254.md" "b/BasicKnowledge/Wifi\347\212\266\346\200\201\347\233\221\345\220\254.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/Wifi\347\212\266\346\200\201\347\233\221\345\220\254.md"
rename to "BasicKnowledge/Wifi\347\212\266\346\200\201\347\233\221\345\220\254.md"
diff --git "a/Android\345\237\272\347\241\200/XmlPullParser.md" b/BasicKnowledge/XmlPullParser.md
similarity index 99%
rename from "Android\345\237\272\347\241\200/XmlPullParser.md"
rename to BasicKnowledge/XmlPullParser.md
index 53f67050..69c10ee1 100644
--- "a/Android\345\237\272\347\241\200/XmlPullParser.md"
+++ b/BasicKnowledge/XmlPullParser.md
@@ -3,7 +3,6 @@ XmlPullParser
 
 ```java
 public class PersonService {
-
     /**
      * 接收一个包含XML文件的输入流, 解析出XML中的Person对象, 装入一个List返回
      * @param in    包含XML数据的输入流
@@ -76,6 +75,6 @@ public class PersonService {
 }
 ```
 
------
+---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
\ No newline at end of file
diff --git "a/BasicKnowledge/adb logcat\344\275\277\347\224\250\347\256\200\344\273\213.md" "b/BasicKnowledge/adb logcat\344\275\277\347\224\250\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..1222f1ce
--- /dev/null
+++ "b/BasicKnowledge/adb logcat\344\275\277\347\224\250\347\256\200\344\273\213.md"	
@@ -0,0 +1,120 @@
+adb logcat使用简介
+===
+
+得有半年没写日记了，今天不太忙，抽空写一个简单的入门，因为很长时间没用了，最近用起来发现已经忘了.....
+
+`android`开发过程中我们经常会用到`log`，虽然平时大多用`studio`，但是如果测试发现一个`crash`时跑过来找你时你会发现用`studio`已经有点迟了。这时候就要打开`adb logcat`.
+忘记怎么加参数了怎么办？ 默默的打开`adb logcat --help`你会发现只要你肯努力，你肯定能把所有的事情都搞垮。
+
+`adb logcat --help`
+
+
+`Usage: logcat [options] [filterspecs]`
+
+
+`options include:`
+---
+
+
+ -  `-s`              `Set default filter to silent.         
+                    Like specifying filterspec '*:s'设置默认的过滤器,我们想要输出包含"System.out"关键字的标签或信息, 就可以使用adb logcat -s System.out 命令;`   
+                       
+ - `-f <filename>`   `Log to file. Default to stdout  将日志输出到文件,注意这是手机里的文件，使用adb logcat -f /sdcard/log.txt`         
+ - `-r [<kbytes>]`  `Rotate log every kbytes. (16 if unspecified). Requires -f 按照每千字节输出日志，需要与-f一起使用`          
+ - `-n <count>`      `Sets max number of rotated logs to <count>, default 4 设置日志输出的最大数目`     
+- `-v <format>`     `Sets the log print format, where <format> is one of:         
+brief process tag thread raw time threadtime long 设置日志的输出格式, 注意只能设置一项，这里格式比较多，我们最后讲`     
+
+- `-c`              `clear (flush) the entire log and exit     清空所有的日志缓存信息`
+- `-d`              `dump the log and then exit (don't block)   将缓存的日志输出到屏幕上, 并且不会阻塞;`
+- `-t <count>`      `print only the most recent <count> lines (implies -d)  输出最近的几行日志, 输出完退出, 不阻塞;`
+  `-g`              `get the size of the log's ring buffer and exit   查看日志缓冲区信息`
+  `-b <buffer>`     `Request alternate ring buffer, 'main', 'system', 'radio' 
+                  or 'events'. Multiple -b parameters are allowed and the
+                  results are interleaved. The default is -b main -b system.加载一个日志缓冲区, 默认是 main`      
+  `-B`              `output the log in binary 以二进制形式输出日志`
+
+
+`filterspecs are a series of `
+---
+
+  `<tag>[:priority]`  过滤项格式为标签:日志等级, 默认的日志过滤项是 ` *:I `;
+```
+where <tag> is a log component tag (or * for all) and priority is:      
+
+  - V    Verbose
+  - D    Debug
+  - I    Info
+  - W    Warn
+  - E    Error
+  - F    Fatal
+  - S    Silent (supress all output)
+
+'*' means '*:d' and <tag> by itself means <tag>:v
+
+If not specified on the commandline, filterspec is set from ANDROID_LOG_TAGS.
+If no filterspec is found, filter defaults to '*:I'默认使用的是*:I级别的。
+
+If not specified with -v, format is set from ANDROID_PRINTF_LOG
+or defaults to "brief"
+```
+例如`adb logcat *:E` 是指定只显示`error`级别的`log`， `adb logcat xxx:D *:S` 是指定只显示标签为`xxx`且`debug`级别以上的`Log`。为什么要加上`*:S`呢，`*:S`用于设置所有标记的日志优先级为`S`，这样可以确保仅输出符合条件的日志。
+
+上面基本的参数都介绍完了。下面说一些常用的功能。  
+
+采用grep正则表达式过滤
+---
+
+过滤固定字符串 : 只要命令行出现的日志都可以过滤, 不管是不是标签;
+
+`adb logcat | grep -E '^[VDE]/(TAG1|TAG2)'`
+
+`adb logcat | grep Wifi`
+`adb logcat | grep -i wifi 过滤字符串忽略大小写`
+`adb logcat | grep --color=auto -i myapp #设置匹配字符串颜色。更多设置请查看 grep 帮助。`
+
+在同时输出到屏幕和文件tee
+---  
+
+想要把日志保存到文件,如果采用IO重定向,就无法输出到屏幕, 针对这个问题可以采用tee命令
+
+`adb logcat | grep -E '^[VDE]/(TAG1|TAG2)' | tee my.log`
+
+`adb logcat -v time | tee a.log`
+
+
+
+持续输出日志到文件中    
+---
+
+`>`输出 : `>` 后面跟着要输出的日志文件, 可以将`logcat`日志输出到文件中
+
+`adb logcat > test.log` //将日志保存到文件test.log
+
+`-d -f <log>` 组合命令：可以将日志保存到手机上的指定位置，对不能一直用电脑连着手机收集日志的场景非常有用。
+`adb logcat -d -f /sdcard/mylog.txt`
+
+
+
+最后说一下上面的`-v`的格式问题:  
+`-v <format>`设置日志输入格式控制输出字段，默认的是`brief`格式:   
+
+- `brief` — 显示优先级/标记和原始进程的PID (默认格式)
+- `process` — 仅显示进程PID
+- `tag` — 仅显示优先级/标记
+- `thread` — 仅显示进程：线程和优先级/标记
+- `raw` — 显示原始的日志信息，没有其他的元数据字段
+- `time` — 显示日期，调用时间，优先级/标记，PID
+- `long` —显示所有的元数据字段并且用空行分隔消息内容
+- `adb logcat -v thread`   //使用 thread 输出格式
+***注意***`-v` 选项中只能指定一种格式。
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/\344\270\213\346\213\211\345\210\267\346\226\260ListView.md" "b/BasicKnowledge/\344\270\213\346\213\211\345\210\267\346\226\260ListView.md"
similarity index 89%
rename from "Android\345\237\272\347\241\200/\344\270\213\346\213\211\345\210\267\346\226\260ListView.md"
rename to "BasicKnowledge/\344\270\213\346\213\211\345\210\267\346\226\260ListView.md"
index 7ddd8017..1ab65299 100644
--- "a/Android\345\237\272\347\241\200/\344\270\213\346\213\211\345\210\267\346\226\260ListView.md"
+++ "b/BasicKnowledge/\344\270\213\346\213\211\345\210\267\346\226\260ListView.md"
@@ -8,7 +8,9 @@ PullToRefreshListView
 拉刷新`ListView`无非就是对普通的`List View`添加一个`HeaderView`,然后通过对`ListView onTouchEvent`来获取当前下拉刷新的状态。然后去改变`HeaderView`的状态。    
 
 1. 自定义`ListView`，在构造方法中去添加`HeaderView`
-	通过`ListView.addHeaderView()`去添加`HeaderView`的时候，`HeaderView`会显示在屏幕的最初位置，我们需要它默认的时候是在屏幕的上方，这样默认时是不可见的，但是我们下拉`ListView`的时候，它就能够显示出来。这就要通过设置`HeaderView`的`padding`来实现它的隐藏。注意：View的显示最初要经过`Measure`测量宽高，我们在构造方法去添加的时候，该View可能并没有被测量，所以在获取`HeaderView`高度的时候会为0，这时候我们要手动的去测量一下`HeaderView`。
+	通过`ListView.addHeaderView()`去添加`HeaderView`的时候，`HeaderView`会显示在屏幕的最初位置，我们需要它默认的时候是在屏幕的上方，这样默认时是不可见的，
+	但是我们下拉`ListView`的时候，它就能够显示出来。这就要通过设置`HeaderView`的`padding`来实现它的隐藏。注意：View的显示最初要经过`Measure`测量宽高，
+	我们在构造方法去添加的时候，该View可能并没有被测量，所以在获取`HeaderView`高度的时候会为0，这时候我们要手动的去测量一下`HeaderView`。
 	```java
 	/**
 	* 当前状态
@@ -73,7 +75,8 @@ PullToRefreshListView
 		case MotionEvent.ACTION_MOVE:
 			//手指当前滑动的位置
 			currentPositionY = y;
-			//手指移动的距离，由于HeaderView高度固定，但是手指下拉的高度可以最大为屏幕的高度，如手指下拉屏幕高度时，HeaderView会很难看，所以我们让下拉的距离进行一个缩放。
+			//手指移动的距离，由于HeaderView高度固定，但是手指下拉的高度可以最大为屏幕的高度，如手指下拉屏幕高度时，HeaderView会很难看，
+			// 所以我们让下拉的距离进行一个缩放。
 			pullDistance = (currentPositionY - downPositionY) / RATIO;
 
 			if (mState == State.REFRESHING) {
@@ -88,7 +91,8 @@ PullToRefreshListView
 				mState = State.RELEASE_TO_REFRESH;
 				changeState();
 			} else if (mState == State.RELEASE_TO_REFRESH) {
-			//释放刷新时有三种情况，一是我继续下啦，这时候不用管，因为继续下拉还是释放刷新。二是我手指往上移动，此时HeaderView不完全可见，这时候状态要改变为下拉刷新了。三是我手指上移的很厉害，导致HeaderView完全不可见了，这是状态要改变为起始状态。
+			//释放刷新时有三种情况，一是我继续下啦，这时候不用管，因为继续下拉还是释放刷新。二是我手指往上移动，此时HeaderView不完全可见，
+			// 这时候状态要改变为下拉刷新了。三是我手指上移的很厉害，导致HeaderView完全不可见了，这是状态要改变为起始状态。
 				if (pullDistance < 0) {
 					// 如果当时状态为松手刷新，但是这时候我并没有松手，而是直接将手指往上移动，移动回手指最先的位置，这时候状态要变为起始状态。
 					mState = State.ORIGNAL;
@@ -133,7 +137,8 @@ PullToRefreshListView
 	}
 	```
 
-3. 上面的写法仍有些问题。就是我们在`onTouchEvent`中`Move`里面对移动的距离进行了判断，但是`ListView`本身就是一个可以上下滑动的组件，如果我们直接这样判断，那`ListView`本上上下滑动的功能就被我们给抹去了。
+3. 上面的写法仍有些问题。就是我们在`onTouchEvent`中`Move`里面对移动的距离进行了判断，但是`ListView`本身就是一个可以上下滑动的组件，
+	如果我们直接这样判断，那`ListView`本上上下滑动的功能就被我们给抹去了。
 	```java
 	@Override
 	public boolean onTouchEvent(MotionEvent ev) {
@@ -151,7 +156,8 @@ PullToRefreshListView
 			.....
 			break;
 	```
-	而对于`isCanPullToRefresh`的判断是通过`ListView.setOnScrollListener`去进行判断当前第一个可见条目是不是`ListView`的第一个条目，只有第一个条目在最顶端位置的时候才可以进行下拉刷新。
+	而对于`isCanPullToRefresh`的判断是通过`ListView.setOnScrollListener`去进行判断当前第一个可见条目是不是`ListView`的第一个条目，
+	只有第一个条目在最顶端位置的时候才可以进行下拉刷新。
 	```java
 	super.setOnScrollListener(new OnScrollListener() {
 
@@ -204,7 +210,8 @@ PullToRefreshListView
 LoadMoreListView
 ---
 **原理：**    
-滑动到底部自动加载更多的`ListView`，无非就是通过对其滑动过程进行监听，一旦滑动到底部的时候我们就去加载新的数据。通过对`ListView`添加`FooterView`，然后在不同的状态控制它的显示与隐藏。     
+滑动到底部自动加载更多的`ListView`，无非就是通过对其滑动过程进行监听，一旦滑动到底部的时候我们就去加载新的数据。通过对`ListView`添加`FooterView`，
+然后在不同的状态控制它的显示与隐藏。     
 
 1.  自定义ListView的子类，在构造方法中去添加FooterView.  
 	```java
diff --git "a/Android\345\237\272\347\241\200/\344\273\243\347\240\201\346\267\267\346\267\206.md" "b/BasicKnowledge/\344\273\243\347\240\201\346\267\267\346\267\206.md"
similarity index 69%
rename from "Android\345\237\272\347\241\200/\344\273\243\347\240\201\346\267\267\346\267\206.md"
rename to "BasicKnowledge/\344\273\243\347\240\201\346\267\267\346\267\206.md"
index 39fe05ff..a8771465 100644
--- "a/Android\345\237\272\347\241\200/\344\273\243\347\240\201\346\267\267\346\267\206.md"
+++ "b/BasicKnowledge/\344\273\243\347\240\201\346\267\267\346\267\206.md"
@@ -1,4 +1,4 @@
-代码混淆
+代码混淆
 ===
 
 混淆器(ProGuard)
@@ -7,7 +7,7 @@
 混淆器通过删除从未用过的代码和使用晦涩名字重命名类、字段和方法，对代码进行压缩，优化和混淆。
 
 1. 修改project.properties
-```xml
+	```xml
 	# This file is automatically generated by Android Tools.
 	# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
 	#
@@ -22,11 +22,11 @@
 
 	# Project target.
 	target=android-19
-```
+	```
     将proguard.config前面的注释去掉
 
 2. 修改proguard-project.txt
-```xml
+	```xml
 	# To enable ProGuard in your project, edit project.properties
 	# to define the proguard.config property as described in that file.
 	#
@@ -47,9 +47,10 @@
 	#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
 	#   public *;
 	#}
-```
-    如果在程序中使用了第三方的`jar`包，在混淆后导致出错，这时我们需要在proguard-project.txt中去进行相应的配置，来让其在混淆时不要混淆相应的jar包。对改配置文件中的相关配置解释如下：
-```java
+	```
+    如果在程序中使用了第三方的`jar`包，在混淆后导致出错，这时我们需要在proguard-project.txt中去进行相应的配置，
+	来让其在混淆时不要混淆相应的jar包。对改配置文件中的相关配置解释如下：
+	```java
 	-keep public class * extends android.app.Activity　　【不进行混淆类名的类，保持其原类名和包名】
 
 	-keep public abstract interface com.asqw.android.Listener{
@@ -81,26 +82,30 @@
 
 	}
 	-keep public class com.unionpay.** {*; }【对com.unionpay包下所有的类都不进行混淆，即不混淆类名，也不混淆方法名和变量名】
-```        
+	```        
 
-经过上面这两部之后反编译后就能混淆了，但是四大组件还在，为什么四大组件还在呢，因为四大组件是在清单文件中进行配置的，如果混淆后就不能根据清单文件的配置去寻找了。     
-如果对于一些自己的代码中要想提供出来让别人通过反射调用的方法时,我们不想让部分代码被混淆，或者是我们使用别人提供的第三方jar包，因为第三方的jar包一般都是已经混淆过的，我们要是再混淆就会报错了，所以我们要保证这些内容不用混淆，这里我们只需修改这个文件，然后加上后面的一句话，他就不会混淆我们给出的内容    
-```xml
--keepattributes *Annotation*          
--keep public class * extends android.app.Activity
--keep public class * extends android.app.Application
--keep public class * extends android.app.Service
--keep public class * extends android.content.BroadcastReceiver
--keep public class * extends android.content.ContentProvider
--keep public class * extends android.app.backup.BackupAgent
--keep public class * extends android.preference.Preference
--keep public class * extends android.support.v4.app.Fragment
--keep public class * extends android.app.Fragment
--keep public class com.android.vending.licensing.ILicensingService
--keep class net.youmi.android.** {
-*;
-}
-```
+	经过上面这两部之后反编译后就能混淆了，但是四大组件还在，为什么四大组件还在呢，因为四大组件是在清单文件中进行配置的，
+	如果混淆后就不能根据清单文件的配置去寻找了。     
+	如果对于一些自己的代码中要想提供出来让别人通过反射调用的方法时,我们不想让部分代码被混淆，或者是我们使用别人提供的第三方jar包，
+	因为第三方的jar包一般都是已经混淆过的，我们要是再混淆就会报错了，所以我们要保证这些内容不用混淆，这里我们只需修改这个文件，然后加上后面的一句话，
+	他就不会混淆我们给出的内容    
+	```xml
+	-keepattributes *Annotation*          
+	-keep public class * extends android.app.Activity
+	-keep public class * extends android.app.Application
+	-keep public class * extends android.app.Service
+	-keep public class * extends android.content.BroadcastReceiver
+	-keep public class * extends android.content.ContentProvider
+	-keep public class * extends android.app.backup.BackupAgent
+	-keep public class * extends android.preference.Preference
+	-keep public class * extends android.support.v4.app.Fragment
+	-keep public class * extends android.app.Fragment
+	-keep public class com.android.vending.licensing.ILicensingService
+	-keep class net.youmi.android.** {
+	*;
+	}
+	```
+	
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/Android\345\237\272\347\241\200/\344\273\273\345\212\241\347\256\241\347\220\206\345\231\250(ActivityManager).md" "b/BasicKnowledge/\344\273\273\345\212\241\347\256\241\347\220\206\345\231\250(ActivityManager).md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\344\273\273\345\212\241\347\256\241\347\220\206\345\231\250(ActivityManager).md"
rename to "BasicKnowledge/\344\273\273\345\212\241\347\256\241\347\220\206\345\231\250(ActivityManager).md"
diff --git "a/Android\345\237\272\347\241\200/\344\277\256\346\224\271\347\263\273\347\273\237\347\273\204\344\273\266\346\240\267\345\274\217.md" "b/BasicKnowledge/\344\277\256\346\224\271\347\263\273\347\273\237\347\273\204\344\273\266\346\240\267\345\274\217.md"
similarity index 95%
rename from "Android\345\237\272\347\241\200/\344\277\256\346\224\271\347\263\273\347\273\237\347\273\204\344\273\266\346\240\267\345\274\217.md"
rename to "BasicKnowledge/\344\277\256\346\224\271\347\263\273\347\273\237\347\273\204\344\273\266\346\240\267\345\274\217.md"
index 2267f5e1..b7d45510 100644
--- "a/Android\345\237\272\347\241\200/\344\277\256\346\224\271\347\263\273\347\273\237\347\273\204\344\273\266\346\240\267\345\274\217.md"
+++ "b/BasicKnowledge/\344\277\256\346\224\271\347\263\273\347\273\237\347\273\204\344\273\266\346\240\267\345\274\217.md"
@@ -4,7 +4,7 @@
 系统所有组件的样式声明都在`data-res-values-styles.xml`中，如果我们想要修改某个系统组件的样式只需要拷贝它的样式到本地后修改一下就行了。
 
 - 自定义ProgressBar样式
-	1. 去系统的styles.xml中搜寻ProgressBar的样式
+	1. 去系统的styles.xml中搜寻ProgressBar的样式                  
 		```xml
 		<style name="Widget.ProgressBar">
 			<item name="android:indeterminateOnly">true</item>
@@ -17,7 +17,7 @@
 			<item name="android:maxHeight">48dip</item>
 		</style>
 		```
-	2. 看到有一个属性引用了@android:drawable/progress_medium_white，内容如下
+	2. 看到有一个属性引用了@android:drawable/progress_medium_white，内容如下          
 		```xml
 		<animated-rotate xmlns:android="http://schemas.android.com/apk/res/android"
 			android:drawable="@drawable/spinner_white_48"
@@ -47,7 +47,6 @@
 		```
 
 - 自定义进度条
-
 	1. 系统所有的组件都在D:\android-sdk-windows\platforms\android-8\data\res\values\styles.xml
 		```xml
 		<style name="Widget.ProgressBar.Horizontal">
@@ -62,7 +61,6 @@
 		```xml
 		Layer-list代表的是一个图层的列表
 		<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
-		 
 			<item android:id="@android:id/background"> //背景,这里它是通过图形资源shape的方式定义的背景
 				<shape>
 					<corners android:radius="5dip" />
@@ -74,8 +72,7 @@
 							android:angle="270"
 					/>
 				</shape>
-			</item>
-		 
+			</item>	 
 			<item android:id="@android:id/secondaryProgress">
 				<clip>
 					<shape>
@@ -89,8 +86,7 @@
 						/>
 					</shape>
 				</clip>
-			</item>
-		 
+			</item>	 
 			<item android:id="@android:id/progress"> //进度
 				<clip>
 					<shape>
@@ -105,11 +101,9 @@
 					</shape>
 				</clip>
 			</item>
-		 
 		</layer-list>
 	```
-	 
-	3. 自定义一个样式继承系统的Widget.ProgressBar.Horizontal，然后重写android:progressDrawable属性，让其指向我们的样式
+    3. 自定义一个样式继承系统的Widget.ProgressBar.Horizontal，然后重写android:progressDrawable属性，让其指向我们的样式
 		```xml
 		<style name="MediaController_SeekBar" parent="android:Widget.SeekBar">
 			<item name="android:progressDrawable">@drawable/scrubber_progress_horizontal_holo_dark</item>
@@ -121,8 +115,7 @@
 			<item name="android:paddingLeft">16dip</item>//保证滑块显示全部，没有它滑块在首尾两端只会显示一半，左一半、右一半
 			<item name="android:paddingRight">16dip</item>//同上，控制右边的滑块能全部显示
 		</style>
-		```
-	 
+		``` 
 	4. scrubber_progress_horizontal_holo_dark.xml变成我们自己的图片
 		```xml
 		<?xml version="1.0" encoding="utf-8"?>
@@ -130,14 +123,11 @@
 			<item android:id="@android:id/background" android:drawable="@drawable/security_progress_bg">//好看的图片
 			</item>
 			<item android:id="@android:id/secondaryProgress" android:drawable="@drawable/security_progress_bg">
-				
 			</item>
 			<item android:id="@android:id/progress" android:drawable="@drawable/security_progress">//好看的图片
-				
 			</item>
 		</layer-list>
-		```
-		
+		```	
 	5. SeekBar使用自定义样式
 		```xml
 		<SeekBar
diff --git "a/Android\345\237\272\347\241\200/\345\206\205\345\255\230\346\263\204\346\274\217.md" "b/BasicKnowledge/\345\206\205\345\255\230\346\263\204\346\274\217.md"
similarity index 64%
rename from "Android\345\237\272\347\241\200/\345\206\205\345\255\230\346\263\204\346\274\217.md"
rename to "BasicKnowledge/\345\206\205\345\255\230\346\263\204\346\274\217.md"
index 666273f4..7beb88ae 100644
--- "a/Android\345\237\272\347\241\200/\345\206\205\345\255\230\346\263\204\346\274\217.md"
+++ "b/BasicKnowledge/\345\206\205\345\255\230\346\263\204\346\274\217.md"
@@ -1,20 +1,42 @@
 内存泄露
 ===
 
-`Java`和`C++`一个很大的区别就是`Java`有垃圾回收`GC(Garbage Collection)`自动管理内存的回收。但是我们在实际的项目中仍然会遇到内存泄露的问题。
-`Java`中对内存对象得访问是通过引用的方式，通过一个内存对象的引用变量来访问到对应的内存地址中的对象。
-`GC`会从代码栈的引用变量开始追踪，从而判断哪些内存是正在使用，如果无法跟踪到某一块堆内存，那么`GC`就认为这块内存不再使用了。
 
-##定义     
+## 定义     
 内存泄露是指无用对象(不再使用的对象)持续占有内存或无用对象的内存得不到及时释放，从而造成的内存空间的浪费称为内存泄露。
 
-##原因      
-长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是`java`中内存泄露的发生场景。
+## 原因      
+长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，
+这就是`java`中内存泄露的发生场景。
 
-##危害     
+## 危害     
 只有一个，那就是虚拟机占用内存过高，导致`OOM`(内存溢出)。
 对于`Android`应用来说，就是你的用户打开一个`Activity`，使用完之后关闭它，内存泄露；又打开，又关闭，又泄露；几次之后，程序占用内存超过系统限制就会出现`FC`。             
 
+
+先来说一下`Java`程序运行时的内存分配策略:        
+
+- 静态内存:存放静态数据，这块内存是在编译时就已经分配好的，在程序整个运行期间都存在。
+- 栈内存:程序执行时，局部变量的创建存储区，执行结束后将自动释放。(当时学习java时花的内存分配图，现在都生疏了- -!)
+- 堆内存:存储一些new出来的内存，也叫动态内存分配，这部分内存在不使用时将会有`Java`垃圾回收器来负责回收。    
+
+举一个典型的内存泄漏的例子:     
+```java
+Vector v = new Vector(100);
+for (int i = 1; i < 100,; i++) {
+	Object o = new Object();
+	v.add(o);
+	o = null;
+}
+```	
+在这个例子中，我们循环申请了`Object`对象，并将所申请的对象放入一个集合中，如果我们仅仅释放引用本身，那么`Vector`仍然引用
+该对象，所以这个对象对`GC`来说是不可回收的。因此，如果对象假如`Vector`后，还必须从`Vector`中删除，最简单的方法就是将
+`Vector`对象设置为`null`.
+			
+`Java`和`C++`一个很大的区别就是`Java`有垃圾回收`GC(Garbage Collection)`自动管理内存的回收。但是我们在实际的项目中仍然会遇到内存泄露的问题。
+`Java`中对内存对象得访问是通过引用的方式，通过一个内存对象的引用变量来访问到对应的内存地址中的对象。
+`GC`会从代码栈的引用变量开始追踪，从而判断哪些内存是正在使用，如果无法跟踪到某一块堆内存，那么`GC`就认为这块内存不再使用了。
+
 `Android`手机给应用分配的内存通常是8兆左右，如果处理内存处理不当很容易造成`OutOfMemoryError`
 `OutOfMemoryError`主要由以下几种情况造成： 
 
@@ -85,7 +107,7 @@
 		background.setCallback(this);
 	 }
 	```
-	有`background.setCallback(this);`方法，也就是说`Drawable`拥有`TextView`的引用，而`TextView`又拥有`Activity`*(Context类型)*的引用，
+	有`background.setCallback(this);`方法，也就是说`Drawable`拥有`TextView`的引用，而`TextView`又拥有`Activity`(Context类型)的引用，
 	因为`sBackground`为`static`的，即使`Activity`被销毁，但是`sBackground`的生命周期还没走完，所以内存仍然不会被释放。这样就会有内存泄露了。
 	对，这样想是对的，但是我们看一下`setCallback`的源码：
 	```java
@@ -93,8 +115,8 @@
         mCallback = new WeakReference<Callback>(cb);
     }
 	```
-	我们会发现里面使用了`WeakReference`，所以不会存在内存泄露了，但是官网当时提供的例子明明说有泄露，这是因为在3.0之后，修复了这个内存泄露的问题，在3.0之前`setCallback`
-	方法是没有使用`WeakReference`的，所以这种泄露的情况在3.0之前会发生，3.0之后已经被修复。
+	我们会发现里面使用了`WeakReference`，所以不会存在内存泄露了，但是官网当时提供的例子明明说有泄露，这是因为在3.0之后，
+	修复了这个内存泄露的问题，在3.0之前`setCallback`，方法是没有使用`WeakReference`的，所以这种泄露的情况在3.0之前会发生，3.0之后已经被修复。
 	
 7. 线程
     线程也是造成内存泄露的一个重要的源头。线程产生内存泄露的主要原因在于线程生命周期的不可控。我们来考虑下面一段代码。
@@ -119,6 +141,25 @@
     事实上由于我们的线程是`Activity`的内部类，所以`MyThread`中保存了`Activity`的一个引用，当`MyThread`的`run`函数没有结束时，`MyThread`是不会被销毁的，
 	因此它所引用的`Activity`也不会被销毁，因此就出现了内存泄露的问题。
 
+11. 单例造成的内存泄漏      
+  	由于单例的静态特性使得其生命周期跟应用的生命周期一样长，所以如果使用不恰当的话，很容易造成内存泄漏，比如:      
+	```java
+	public class AppManager {
+		private static AppManager instance;
+		private Context context;
+		private AppManager(Context context) {
+			this.context = context;
+		}
+		public static AppManager getInstance(Context context) {
+			if (instance != null) {
+				instance = new AppManager(context);
+			}
+			return instance;
+		}
+	}
+	```
+	这里如果传入的是`Activity`的`Context`，当该`Context`的`Activity`退出后，由于其被单例对象引用，所以会导致`Activity`无法被回收，就造成内存泄漏。
+	
 8. 尽量使用`ApplicationContext`
 	**`Context`引用的生命周期超过它本身的生命周期，也会导致`Context`泄漏**。
 	所以如果打算保存一个长时间的对象时尽量使用`Application`这种`Context`类型。
@@ -163,8 +204,50 @@
 		mHandler.removeCallbacks(mRunnable);  
 	} 
 	```
-    
-总结一下避免`Contex`t泄漏应该注意的问题： 
+10. 由上面的`Handler`可以引伸出来的匿名内部类、非静态内部类和异步现成导致的内存泄漏。      
+    下面看一个非静态内部类创建静态实例导致的内存泄漏
+	```java
+	public class MainActivity extends AppCompatActivity {
+		private static TestResource mResource = null;
+		@Override
+		protected void onCreate(Bundle savedInstanceState) {
+			super.onCreate(savedInstanceState);
+			setContentView(R.layout.activity_main);
+			if(mManager == null){
+				mManager = new TestResource();
+			}
+			//...
+		}
+		class TestResource {
+			//...
+		}
+	}
+	```
+	因为非静态内部类默认会持有外部类的引用，而该非静态内部类又创建了一个静态实例，该实例的声明周期与应用的一样长，
+	这就导致了静态实例一直会持有`Activity`的引用而造成内存泄漏。             
+	下面再看一个匿名内部类和异步现成的现象:        
+	```java
+	public class MainActivity extends Activity {
+		...
+		Runnable ref1 = new MyRunable();
+		Runnable ref2 = new Runnable() {
+			@Override
+			public void run() {
+
+			}
+		};
+		...
+	}
+	```
+	上面的例子中`ref1`对象是没问题的，但是`ref2`这个匿名类的实现对象中有外部类的引用，如果此时线程的生命周期与`Activity`的不一致时就会造成了泄漏。
+	
+10. 集合类泄漏           
+    集合类中如果只有添加元素的方法，而没有相应的删除机制，导致内存被占用。如果这个集合类是全局性的变量(比如类中的静态属性)，那么没有
+	响应的删除机制，很可能导致集合所占用的内存只增不减。
+	
+
+总结一下避免`Contex`t泄漏应该注意的问题：        
+
 - 使用`getApplicationContext()`类型。 
 - 注意对`Context`的引用不要超过它本身的生命周期。 
 - 慎重的使用`static`关键字。 
@@ -173,4 +256,4 @@
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/BasicKnowledge/\345\217\215\347\274\226\350\257\221.md" "b/BasicKnowledge/\345\217\215\347\274\226\350\257\221.md"
new file mode 100644
index 00000000..51a0aeee
--- /dev/null
+++ "b/BasicKnowledge/\345\217\215\347\274\226\350\257\221.md"
@@ -0,0 +1,88 @@
+反编译
+===
+
+- [资源文件获取Apktool](https://ibotpeaches.github.io/Apktool/install/)
+	按照官网的指示配置完成后，执行apktool命令
+
+	```
+	apktool d xxx.apk
+    // 如果提示-bash: /usr/local/bin/apktool: Permission denied
+    cd /usr/local/bin
+    sudo chmod +x apktool
+    sudo chmod +x apktool.jar
+	```
+	执行完成后会在apktool.jar的目录下升级一个文件，里面可以看到xml的信息
+    ```
+    cd /usr/loca/bin
+    open .
+    ```
+- [源码文件获取dex2jar](https://github.com/pxb1988/dex2jar)
+    将apk文件解压后获取class.dex文件，然后将dex文件拷贝到dex2jar目录中
+    ```
+	sh d2j-dex2jar.sh classes.dex 
+	d2j-dex2jar.sh: line 36: ./d2j_invoke.sh: Permission denied
+	// chmod一下
+	sudo chmod +x d2j_invoke.sh
+	sh d2j-dex2jar.sh classes.dex
+    ```
+    执行完成后会在当前目录中生成一个 classes-dex2jar.jar
+
+- [jar包源码查看工具jd-gui](https://github.com/java-decompiler/jd-gui)
+	里面有osx的版本，安装后直接打开上面用dex2jar编译出来的.jar文件就可以查看源码了
+	
+
+### 反编译后的源码修改
+
+修改代码及资源，最好的方式是修改apktool反编译后的资源级smali代码。JD-GUI查看的java代码不适宜修改，因为修改后还需要重新转换成smali，才能重新编译打包会apk。
+至于smali的修改，则要学习smali语言的语法了，smali是一种类似汇编语言的语言，具体语法可自行上网学习。
+在smali文件夹中找到与具体类对应的smali文件，然后进行修改
+可以用到[java2smali](https://plugins.jetbrains.com/plugin/7385-java2smali)将java代码转换成smali代码
+
+### 重新打包
+
+```
+B0000000134553m:bin xuchuanren$ apktool b xxxfilename 
+I: Using Apktool 2.4.0
+I: Checking whether sources has changed...
+I: Smaling smali folder into classes.dex...
+I: Checking whether resources has changed...
+I: Building resources...
+S: WARNING: Could not write to ( instead...
+S: Please be aware this is a volatile directory and frameworks could go missing, please utilize --frame-path if the default storage directory is unavailable
+I: Copying libs... (/lib)
+I: Building apk file...
+I: Copying unknown files/dir...
+I: Built apk...
+
+```
+生成的apk在该文件xxxfilename中的dist目录中
+
+### 重新签名
+
+重新签名用的是jarsigner命令
+```
+jarsigner -verbose -keystore [your_key_store_path] -signedjar [signed_apk_name] [usigned_apk_name] [your_key_store_alias] -digestalg SHA1 -sigalg MD5withRSA
+```
+
+- [your_key_store_path]：密钥所在位置的绝对路径
+- [signed_apk_name]：签名后安装包名称
+- [usigned_apk_name]：未签名的安装包名称
+- [your_key_store_alias]：密钥的别名
+
+如:  
+
+```
+jarsigner -verbose -keystore /development/key.keystore -signedjar signed_apk.apk xxx.apk charon -digestalg SHA1 -sigalg MD5withRSA
+Enter Passphrase for keystore: 
+   adding: META-INF/MANIFEST.MF
+   adding: META-INF/CHARON.SF
+   adding: META-INF/CHARON.RSA
+
+```
+执行完后会在当前目录下生成签名后的apk文件
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck!
diff --git "a/BasicKnowledge/\345\244\232\347\272\277\347\250\213\346\226\255\347\202\271\344\270\213\350\275\275.md" "b/BasicKnowledge/\345\244\232\347\272\277\347\250\213\346\226\255\347\202\271\344\270\213\350\275\275.md"
new file mode 100644
index 00000000..ed3478d1
--- /dev/null
+++ "b/BasicKnowledge/\345\244\232\347\272\277\347\250\213\346\226\255\347\202\271\344\270\213\350\275\275.md"
@@ -0,0 +1,217 @@
+多线程断点下载
+===
+
+1. 多线程下载
+	```java
+	public class MultiThreadDownloader {
+
+		private URL url;        // 目标地址
+		private File file;        // 本地文件
+		private long threadLen;    // 每个线程下载多少
+
+		private static final int THREAD_AMOUNT = 3;                // 线程数
+		private static final String DIR_PATH = "F:/Download";    // 下载目录
+
+		public MultiThreadDownloader(String address) throws IOException {    
+			// 记住下载地址
+			url = new URL(address);                                                            
+			// 截取地址中的文件名, 创建本地文件
+			file = new File(DIR_PATH, address.substring(address.lastIndexOf("/") + 1));        
+		}
+
+		public void download() throws IOException {
+			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+			conn.setConnectTimeout(3000);
+
+			// 获取文件总长度
+			long totalLen = conn.getContentLength();                    
+			// 计算每个线程要下载的长度
+			// 总长度 如果能整除 线程数, 每条线程下载的长度就是 总长度 / 线程数
+			// 总长度 如果不能整除 线程数, 那么每条线程下载长度就是 总长度 / 线程数 + 1
+			threadLen = (totalLen + THREAD_AMOUNT - 1) / THREAD_AMOUNT;    
+
+			// 在本地创建一个和服务端大小相同的文件
+			RandomAccessFile raf = new RandomAccessFile(file, "rw");    
+			// 设置文件的大小, 写入了若干个0
+			raf.setLength(totalLen);                                    
+			raf.close();
+
+			// 按照线程数循环
+			for (int i = 0; i < THREAD_AMOUNT; i++) {
+				// 开启线程, 每个线程将会下载一部分数据到本地文件中 
+				new DownloadThread(i).start();       
+			}     
+		}
+
+		private class DownloadThread extends Thread {
+			// 用来标记当前线程是下载任务中的第几个线程
+			private int id;     
+
+			public DownloadThread(int id) {
+				this.id = id;
+			}
+
+			public void run() {
+				// 从临时文件读取当前线程已完成的进度
+
+				long start = id * threadLen;     
+				long end = id * threadLen + threadLen - 1;
+				System.out.println("线程" + id + ": " + start + "-" + end);
+
+				try {
+					HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+					conn.setConnectTimeout(3000);
+					// 设置当前线程下载的范围(start和end都包含)
+					conn.setRequestProperty("Range", "bytes=" + start + "-" + end);    
+
+					InputStream in = conn.getInputStream();
+					// 随机读写文件, 用来向本地文件写出
+					RandomAccessFile raf = new RandomAccessFile(file, "rw");        
+					// 设置保存数据的位置
+					raf.seek(start);                                                
+
+					// 每次拷贝100KB
+					byte[] buffer = new byte[1024 * 100];    
+					int len;
+					while ((len = in.read(buffer)) != -1) {
+						// 从服务端读取数据, 写到本地文件
+						raf.write(buffer, 0, len);            
+					}
+					raf.close();
+
+					System.out.println("线程" + id + "下载完毕");
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}
+
+		public static void main(String[] args) throws IOException {
+			new MultiThreadDownloader("http://192.168.1.240:8080/14.Web/android-sdk_r17-windows.zip").download();
+		}
+	}
+	```
+
+2. 断点下载
+	```java
+	public class BreakpointDownloader {
+		// 下载目录
+		private static final String DIR_PATH = "F:/Download";    
+		// 总线程数
+		private static final int THREAD_AMOUNT = 3;                
+
+		// 目标下载地址
+		private URL url;            
+		// 本地文件
+		private File dataFile;        
+		// 用来存储每个线程下载的进度的临时文件
+		private File tempFile;        
+		// 每个线程要下载的长度
+		private long threadLen;      
+		// 总共完成了多少  
+		private long totalFinish;    
+		// 服务端文件总长度
+		private long totalLen;        
+		// 用来记录开始下载时的时间
+		private long begin;            
+
+		public BreakpointDownloader(String address) throws IOException {    
+			url = new URL(address);                                                            
+			dataFile = new File(DIR_PATH, address.substring(address.lastIndexOf("/") + 1));    
+			tempFile = new File(dataFile.getAbsolutePath() + ".temp");                        
+		}
+
+		public void download() throws IOException {
+			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+			conn.setConnectTimeout(3000);
+
+			totalLen = conn.getContentLength();                                    
+			threadLen = (totalLen + THREAD_AMOUNT - 1) / THREAD_AMOUNT;            
+
+			if (!dataFile.exists()) {                                            
+				RandomAccessFile raf = new RandomAccessFile(dataFile, "rws");    
+				raf.setLength(totalLen);                                        
+				raf.close();
+			}
+
+			if (!tempFile.exists()) {                                            
+				RandomAccessFile raf = new RandomAccessFile(tempFile, "rws");    
+				for (int i = 0; i < THREAD_AMOUNT; i++)                           
+					raf.writeLong(0);                                            
+				raf.close();
+			}
+
+			for (int i = 0; i < THREAD_AMOUNT; i++) { 
+				new DownloadThread(i).start();       
+			} 
+
+			// 记录开始时间
+			begin = System.currentTimeMillis();        
+		}
+
+		private class DownloadThread extends Thread {
+			// 用来标记当前线程是下载任务中的第几个线程
+			private int id;     
+
+			public DownloadThread(int id) {
+				this.id = id;
+			}
+
+			public void run() {
+				try {
+					RandomAccessFile tempRaf = new RandomAccessFile(tempFile, "rws");        
+					tempRaf.seek(id * 8);                        
+					long threadFinish = tempRaf.readLong();        
+					synchronized(BreakpointDownloader.this) {    
+						totalFinish += threadFinish;            
+					}
+
+					long start = id * threadLen + threadFinish;      
+					long end = id * threadLen + threadLen - 1;       
+					System.out.println("线程" + id + ": " + start + "-" + end);
+
+					HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+					conn.setConnectTimeout(3000);
+					conn.setRequestProperty("Range", "bytes=" + start + "-" + end);        
+
+					InputStream in = conn.getInputStream();                              
+					RandomAccessFile dataRaf = new RandomAccessFile(dataFile, "rws");    
+					dataRaf.seek(start);                                                
+
+					byte[] buffer = new byte[1024 * 100];            
+					int len;
+					while ((len = in.read(buffer)) != -1) {
+						dataRaf.write(buffer, 0, len);               
+						threadFinish += len;                        
+						tempRaf.seek(id * 8);                        
+						tempRaf.writeLong(threadFinish);           
+						synchronized(BreakpointDownloader.this) {   
+							totalFinish += len;                        
+						}
+					}
+					dataRaf.close();
+					tempRaf.close();
+
+					System.out.println("线程" + id + "下载完毕");
+					// 如果已完成长度等于服务端文件长度(代表下载完成)
+					if (totalFinish == totalLen) {                    
+						System.out.println("下载完成, 耗时: " + (System.currentTimeMillis() - begin));
+						// 删除临时文件
+						tempFile.delete();                            
+					}
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}
+
+		public static void main(String[] args) throws IOException {
+			new BreakpointDownloader("http://192.168.1.240:8080/14.Web/android-sdk_r17-windows.zip").download();
+		}
+	}
+	```
+	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\345\256\211\345\205\250\351\200\200\345\207\272\345\272\224\347\224\250\347\250\213\345\272\217.md" "b/BasicKnowledge/\345\256\211\345\205\250\351\200\200\345\207\272\345\272\224\347\224\250\347\250\213\345\272\217.md"
similarity index 95%
rename from "Android\345\237\272\347\241\200/\345\256\211\345\205\250\351\200\200\345\207\272\345\272\224\347\224\250\347\250\213\345\272\217.md"
rename to "BasicKnowledge/\345\256\211\345\205\250\351\200\200\345\207\272\345\272\224\347\224\250\347\250\213\345\272\217.md"
index ad29bd2d..10f821c1 100644
--- "a/Android\345\237\272\347\241\200/\345\256\211\345\205\250\351\200\200\345\207\272\345\272\224\347\224\250\347\250\213\345\272\217.md"
+++ "b/BasicKnowledge/\345\256\211\345\205\250\351\200\200\345\207\272\345\272\224\347\224\250\347\250\213\345\272\217.md"
@@ -1,8 +1,9 @@
-安全退出应用程序
+安全退出应用程序
 ===
 
 1. 杀死进程。    
-    这种方法是没有效果的只能杀死当前的`Activity`无法关闭程序，在1.5的时候有用，谷歌设计的时候规定程序不能自杀`android.os.Process.killProcess(android.os.Process.myPid())`.                                 
+    这种方法是没有效果的只能杀死当前的`Activity`无法关闭程序，在1.5的时候有用，谷歌设计的时候规定程序不能自杀
+	`android.os.Process.killProcess(android.os.Process.myPid())`.                                 
 2. 终止当前正在运行的Java虚拟机，导致程序终止.     
     这种方法也是没有效果的，因为`Android`用的是`dalvik`虚拟机
     `System.exit(0);`
diff --git "a/BasicKnowledge/\345\261\217\345\271\225\351\200\202\351\205\215.md" "b/BasicKnowledge/\345\261\217\345\271\225\351\200\202\351\205\215.md"
new file mode 100644
index 00000000..36dec90b
--- /dev/null
+++ "b/BasicKnowledge/\345\261\217\345\271\225\351\200\202\351\205\215.md"
@@ -0,0 +1,217 @@
+屏幕适配
+===
+
+## 基本概念
+
+`Px`不同设备显示效果相同。这里的“相同”是指像素数不会变，比如指定`UI`长度是`100px`，那不管分辨率是多少`UI`长度都是`100px`。
+也正是因为如此才造成了`UI`在小分辨率设备上被放大而失真，在大分辨率上被缩小。
+
+#### Screen Size（屏幕尺寸）
+
+一般所说的手机屏幕大小如5寸、5.5英寸，都是指的屏幕对角线的长度，而不是手机面积。我们可以根据勾股定理获取手机的宽和长，当然还有面积。单位为`inch`,1英寸=2.54厘米
+
+#### Resolution（分辨率）
+
+指手机屏幕垂直和水平方向上的像素个数。比如分辨率是`480*320`，则指设备垂直方向有480个像素点，水平方向有320个像素点。单位`px * px`，指的是一屏显示多少像素点。
+
+#### Dpi（dots per inch屏幕密度）
+
+单位`dpi`，指的是每`inch`上可以显示多少像素点即`px`。(每英寸中的像素数)如`160dpi`指手机水平或垂直方向上每英寸距离有`160`个像素点。`dpi`越高，每个像素点越小也就越清晰。
+简单地说，`dpi`越高就意味着每英寸显示的细节越多，而不是直接取决于高分辨。举个例子，
+`Galaxy Nexus`(对角线 4.65”)分辨率为：`720×1280`,`Nexus 7`(对角线 7”)分辨率为：`800×1280`.
+常见的错误观点是认为他们拥有相同的屏幕像素密度，因为它们的分辨率几乎一样。
+然而，`Galaxy Nexus` 的屏幕像素密度约为`316dpi`，`Nexus 7`的屏幕像素密度为`216dpi`，相差甚远。
+这是因为虽然它们拥有一样的分辨率，但是它们显示尺寸却不一样。
+再次说明，屏幕像素密度是分辨率和显示尺寸的比值，两个因素一起决定屏幕像素密度。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/dpi_calculate.png?raw=true)       
+例如：计算`Nexus5`的屏幕像素密度： 屏幕尺寸：`4.95inch`、分辨率：`1920×1080`，屏幕像素密度：`445`      
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/dpi_nexus5.png?raw=true)      
+  
+
+#### Dip（Device-independent pixel，设备独立像素）
+
+同`dp`，指的是自适应屏幕密度的像素，用于指定控件宽高。就所屏幕密度变大，1dp所对应的px也会变大。
+不同设备有不同的显示效果,这个和设备硬件有关，一般我们为了支持`WVGA、HVGA`和`QVGA`推荐使用这个，
+不依赖像素。
+`dip`和具体像素值的对应公式是`dip值 =设备密度/160* pixel`值，可以看出在`dpi`（像素密度）为`160dpi`的设备上`1px=1dip`,
+在`Android`中，规定以`160dpi`为基准，`1dip=1px`，如果密度是`320dpi`，则`1dip=2px`，
+以此类推。
+
+#### Sp（ScaledPixels放大像素）
+主要用于字体显示`（best for textsize）`。根据`google`的建议，`TextView`的字号最好使用`sp`做单位，
+而且查看`TextView`的源码可知`Android`默认使用`sp`作为字号单位。`Google`推荐我们使用`12sp`以上的大小，
+通常可以使用`12sp`，`14sp`，`18sp`，`22sp`，最好不要使用奇数和小数。
+
+
+我们可以用下面的部分来解释为什么用dip代替px作单位：   
+设备最终会以`px`作为长度单位。    
+如果我们直接用`px`作为单位会造成`UI`在不同分辨率设备上出现不合适的缩放。
+因此我们需要一种新的单位，这种单位要最终能够以合适的系数换算成`px`使`UI`表现出合适的大小。   
+`Dip`符合这种要求吗？    
+由`dip`和具体像素值的对应公式`dip值 =设备密度/160* pixel`值可以知
+也就是说`UI`最终的pixel值只受像素密度dip的影响，
+这个`dip`就相当于那个换算系数，这个系数的值是多少有设备商去决定。因此`dip`符合这种要求。
+
+## android为什么引进dip
+    
+> The reason for dip to exist is simple enough. Take for instance the T-Mobile G1. It has a pixel resolution of 320x480 pixels. 
+Now image another device, with the same physical screen size, but more pixels, for instance 640x480. 
+This device would have a higher pixel density than the G1.      
+
+> —If you specify, in your application, a button with a width of 100 pixels, it will look at lot smaller on the 640x480 device than on the 320x480 device. 
+Now, if you specify the width of the button to be 100 dip, the button will appear to have exactly the same size on the two devices.
+
+> —The density-independent pixel is equivalent to one physical pixel on a 160 dpi screen, the baseline density assumed by the 
+platform (as described later in this document). At run time, the platform transparently handles any scaling of the dip units needed, 
+based on the actual density of the screen in use. The conversion of dip units to screen pixels is simple: pixels = dips * (density / 160).
+For example, on 240 dpi screen, 1 dip would equal 1.5 physical pixels.Using dip units to define your application's UI is highly recommended, 
+as a way of ensuring proper display of your UI on different screens.
+
+`dip`是一种能自适应屏幕密度的像素，这个屏幕密度就是屏幕中一英寸里面含有的像素数，打个比方说，现在有两个4寸的手机，一个分辨率是`320*480`,
+它的屏幕密度是1，
+而另一个是`480*800`的分辨率,这样他的屏幕密度就是1.5，如果我们在320*480的手机中弄了一个160dp的横线，
+由于他的屏幕密度是1，所以他里面dp和px是一比一的计算。
+这样这条横线正好占屏幕的一半，而我们将这个横线的视图发布到480*800的手机上时，
+虽然也是160dp，
+但是由于他的屏幕密度是1.5.按照dp与px的计算公式pixel值=dip值/(设备密度/160)，
+可以得到将160dp要乘以1.5倍，这样得到的px就是240px，
+而这个手机的分辨率正好是480*800，所以看起来仍然是占屏幕的一半。
+注意：不论多少`dp`最后都是要通过转换成`px`来显示的手机的屏幕上的，
+至于这个`dp`的大小在屏幕上到底能占多少位置，就要看这个转换后的`px`与屏幕的宽度像素的比值了。
+
+另一个例子： 打个比方一个是4寸`480*800`的手机，屏幕密度为1.5.  另一个是7寸的`1280*800`的平板。屏幕密度也为1.  
+这样用160dp的横线，在`480*800`的手机上换算成`px`是`160*1.5 = 240`，这样横向正好占屏幕的一半，
+但是在`1280*800`的平板上，`160dp`换算后的`px`为，`160*1 = 160px`,
+而屏幕的宽是`1280`.这样这条横线显示在`1280*800`的平板上后，是`160/1280`正好是八分之一。
+
+所以引入dp解决的是什么问题呢？同一个屏幕尺寸下，对于不同的分辨率，由于尺寸相同，分辨率不同，所以它的屏幕密度就会不一样，
+这样在同一尺寸的不同分辨率下的设备上，显示出来会看到所占的比例基本一样。如两个7寸的平板，一个是`1280*800`，一个是`2560*1600`，
+这样用`dp`后，虽然`2560*1600`的分辨率比那个要大一倍，但是它尺寸一样啊，
+所以屏幕的分辨率会是另一个的2倍，这样dp转成px后会乘以2.这样显示到这两个设备上所占的比例会一样
+
+一个是`7`寸`1280*800`的手机，密度为1，一个是5寸`1024*600的`手机，密度为1.
+这样你用160dp的线，在前面是8分之一，在后面是六分之一，你就悲剧了，所以要做屏幕适配了
+ 
+## 代码
+
+```java
+DisplayMetrics displayMetrics = new DisplayMetrics();
+getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
+Log.e("@@@", "density:"+displayMetrics.density);    //1
+Log.e("@@@", "densityDpi:"+displayMetrics.densityDpi);   //160
+Log.e("@@@", "widthPixels:"+displayMetrics.widthPixels);   //1024
+Log.e("@@@", "heightPixels:"+displayMetrics.heightPixels); //600
+```     
+`displayMetrics.densityDpi`是真正的屏幕密度，可以为`160dpi`(`mdpi`标准的屏幕密度),`240dpi`(`hdpi`),
+`320dpi(xhdpi)`.
+`displayMetrics.density`,这个不叫屏幕密度，但是在`dp`和`px`转换的时候要使用到，
+这个是屏幕密度的比例值，是用该设备的屏幕密度除以标准的屏幕密度得到的一个比值，
+如`240dpi/160dpi = 1.5`
+ 
+## 屏幕适配文件夹命名规则
+
+- 命名不区分大小写；
+- 命名形式：资源名-属性1-属性2-属性3-属性4-属性5.....
+    资源名就是资源类型名，包括:drawable, values, layout, anim, raw, menu, color, animator, xml；
+    属性1-属性2-属性3-属性4-属性5.....就是上述的属性集内的属性，如:-en-port-hdpi；
+    注意：各属性的位置顺序必须遵守优先级从高到低排列！否则编译不过
+
+- 实例说明
+    - 把全部属性都用上的例子(各属性是按优先级先后排列出来的)                     
+        values-mcc310-en-sw320dp-w720dp-h720dp-large-long-port-car-night-ldpi-notouch-keysexposed-nokeys-navexposed-nonav-v7
+    - 上述例子属性的中文说明                     
+values-mcc310(sim卡运营商)-en(语言)-sw320dp(屏幕最小宽度)-w720dp(屏幕最佳宽度)-h720dp(屏幕最佳高度)-large(屏幕尺寸)-long(屏幕长短边模式)
+-port(当前屏幕横竖屏显示模式)-car(dock模式)-night(白天或夜晚)-ldpi(屏幕最佳dpi)-notouch(触摸屏模类型)-keysexposed(键盘类型)-nokey(硬按键类型)
+-navexposed(方向键是否可用)-nonav(方向键类型)-v7(android版本)
+
+## 手机常见分辨率
+4:3               
+VGA   640*480 (Video Graphics Array)            
+QVGA  320*240 (Quarter VGA)            
+HVGA  480*320 (Half-size VGA)      
+SVGA  800*600 (Super VGA)            
+
+5:3              
+WVGA  800*480 (Wide VGA)           
+
+16:9             
+FWVGA     854*480 (Full Wide VGA)                   
+HD        1920*1080 High Definition              
+QHD       960*540       
+720p      1280*720  标清         
+1080p     1920*1080 高清               
+
+
+ 
+|分辨率对应DPI |     像素密   | 通常的分辨率  | 比例大小|
+| ---------- |:----------:|:----------:|-----------:|
+|HVGA|    mdpi    | 160dpi  | 320*480 |      1|
+|WVGA |   hdpi  |   240dpi |  480*800  |     1.5|
+|720P    |xhdpi   | 320dpi  | 720*1280    |  2  |
+|1080P   |xxhdpi  | 480dpi  | 1080*1920  |   3 |
+|  xx  |    xxxhdpi | 640dpi   |          |    4 |
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/xhdpi.jpg?raw=true)    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/icon_size.jpg?raw=true)    
+
+为了解决适配的问题有时候还会使用9patch图，这里随便说一下。     
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/9patch.jpg?raw=true)
+
+- `Stretchable area`代表拉伸的部分。
+- `Padding box`代码内容所在区域。外面的就是`padding`部分。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/dpi_drawable.png?raw=true)    
+
+### Android图片选择策略
+上面说到，如果屏幕所对应的文件夹没有要找的图片怎么办。
+这是很常见的，我们开发项目时一般不会去为每一个级别的屏幕去切一套图片。
+那样做只会让`apk`很大。所以一般性的图片我们只切一两个典型密度屏幕的图片。
+但是`apk`是有可能会运行在从`ldpi`到`xxhdpi`的各种级别的手机上。
+这个时候就需要根据一定的策略去寻找图片了。
+
+`Android`系统寻找图片的步骤是这样的：
+
+- 去屏幕密度对应的目录去找。如果找到就拿来用。
+- 如果没找到，就去比这个密度高一级的目录里面去找，如果找到就拿来用。
+- 如果没找到就继续往上找。以此类推。
+- 如果到了xxhdpi目录还没有找到的话，就会去比自身屏幕密度低一级的目录去找，如果低一级的目录>=hdpi，找到了就拿来用。
+- 如果没找到， 就去mdpi目录去找， 如果找到了，就拿来用。
+- 如果没找到，就去默认的drawble目录里去找， 如果找到了就拿来用。
+- 如果没找到，再去最低的ldpi目录里去找。如果找到了，就拿来用。
+- 如果没找到， 那就是没找到了， 图片无法显示。（不过一般不会出现这种现象，因为如果每个目录都没有这个图片的话，你是编译不过的）
+
+这里有两点需要注意：
+
+- 先会去比自己密度高的目录里去找，这是因为因为系统相信，你在密度更高的目录里会放置分辨率更大的图片，这样的话这个图片会被缩小，但同时显示效果不会有损失，但是如果优先去低一级别的目录去找的话， 找到的图片就会被放大，这样的话这个图片就会被拉扯模糊了。
+e.g. 同一张图片，你在mdpi和xxhdpi目录各放了一份， 这个应用你现在运行在hdpi的手机上， 那应用会选择哪张图片呢。答案是xxhdpi目录里的。即便hdpi离mdpi更近一点！
+
+- 如果在mdpi里找不到是不会直接去ldpi里找的， 而是先去默认的drawble目录里找，这是drawble目录和drawble-mdpi是一个级别的。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/scale_drawable.png?raw=true)    
+上表几点值得注意的地方：
+
+- `rawable`目录和`drawable-mdpi`目录和`dp`到`px`的转换关系是一样的。 
+- 当你放一个`120px*180px`的图片到`drawable-hdpi`目录，如果此应用运行在一个`xhdpi`的手机上，则这个图片会被拉扯到`160px*240px`。
+- 最后一行`dp->px`， 说明了在代码或者布局文件中声明一个`dp`值， 这个值在不同屏幕密度的手机中会被乘以不同的倍数。 
+比如你在布局文件中写了一个宽和高分别为`120dp`和`180dp`的`LinearLayout`， 那么当这个应用运行在`xhdpi`的手机上时
+它的实际像素就会被转换为`240px*360px`。 如果运行在`ldpi`的手机上，就变成了`90px*135px`。 但是在这两个手机中显示的区域大小从肉眼看，是一模一样大的。
+
+UI给工程师切多大图是合适的。   
+直接基于`720*1280`的视觉稿切一版图片就可以了。 将图片只放到`xhdpi`目录中，
+这样系统会在不同密度屏幕的手机中对图片进行合理的缩放，如果想在`xxhdpi`的手机上显示的很好， 也可以基于`1080P`的屏幕设计然后放到`xxhdpi`中， 
+这样的话就兼容所有低密度屏幕的手机， 而且也不会出现图片被拉扯的现象。
+
+Note:`The mipmap-xxxhdpi qualifier is necessary only to provide a launcher icon that can appear larger than usual on an xxhdpi device. You do not need to provide xxxhdpi assets for all your app's images.`
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+ 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\345\272\224\347\224\250\345\220\216\345\217\260\345\224\244\351\206\222\345\220\216\346\225\260\346\215\256\347\232\204\345\210\267\346\226\260.md" "b/BasicKnowledge/\345\272\224\347\224\250\345\220\216\345\217\260\345\224\244\351\206\222\345\220\216\346\225\260\346\215\256\347\232\204\345\210\267\346\226\260.md"
similarity index 92%
rename from "Android\345\237\272\347\241\200/\345\272\224\347\224\250\345\220\216\345\217\260\345\224\244\351\206\222\345\220\216\346\225\260\346\215\256\347\232\204\345\210\267\346\226\260.md"
rename to "BasicKnowledge/\345\272\224\347\224\250\345\220\216\345\217\260\345\224\244\351\206\222\345\220\216\346\225\260\346\215\256\347\232\204\345\210\267\346\226\260.md"
index 64630714..7e552c79 100644
--- "a/Android\345\237\272\347\241\200/\345\272\224\347\224\250\345\220\216\345\217\260\345\224\244\351\206\222\345\220\216\346\225\260\346\215\256\347\232\204\345\210\267\346\226\260.md"
+++ "b/BasicKnowledge/\345\272\224\347\224\250\345\220\216\345\217\260\345\224\244\351\206\222\345\220\216\346\225\260\346\215\256\347\232\204\345\210\267\346\226\260.md"
@@ -21,7 +21,8 @@
     }
     ```
 
-2. 在Activity中的onStop方法中去判断当前的应用程序是否在后台运行，同时用一个成员变量去记录该Activity是否为后台，在onResume方法中去判断记录程序后台的变量是否为true，如为true就说明现在是程序从后台切换到前台了，这时候就要去刷新数据了
+2. 在Activity中的onStop方法中去判断当前的应用程序是否在后台运行，同时用一个成员变量去记录该Activity是否为后台，
+	在onResume方法中去判断记录程序后台的变量是否为true，如为true就说明现在是程序从后台切换到前台了，这时候就要去刷新数据了
     ```java
     /**
      * 用于记录当前应用程序是否在后台运行,这样只作用于一个Activity，如果想让所有的
@@ -60,6 +61,6 @@
     };
     ```
 
------
+---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
\ No newline at end of file
diff --git "a/BasicKnowledge/\345\272\224\347\224\250\345\256\211\350\243\205.md" "b/BasicKnowledge/\345\272\224\347\224\250\345\256\211\350\243\205.md"
new file mode 100644
index 00000000..824f2d5a
--- /dev/null
+++ "b/BasicKnowledge/\345\272\224\347\224\250\345\256\211\350\243\205.md"
@@ -0,0 +1,54 @@
+应用安装
+===
+
+1. 在应用程序中安装程序需要权限   
+   ` <uses-permission android:name="android.permission.INSTALL_PACKAGES" />`
+
+2. 示例代码   
+    安卓中提供了安装程序的功能，我们只要启动安装程序的Activity，并把我们的数据传入即可。
+	```java
+	//获取到要安装的apk文件的File对象
+	File file = new File(Environment.getExternalStorageDirectory(), "test.apk");
+	//创建一个意图
+	Intent intent = new Intent();
+	//设置意图动作
+	intent.setAction(Intent.ACTION_VIEW);  //android.intent.action.VIEW
+	//设置意图数据和类型
+	intent.setDataAndType(Uri.fromFile(file), "application/vnd.android.package-archive");
+	//启动安装程序的Activity
+	startActivity(intent);
+	```
+
+**Tip:**   
+- `Uri.fromFile(File file)`方法能从一个`File`对象得到它的`Uri`  
+- `Intent`有`setData(Uri uri)`和`setType(String type)`方法，但是这里如果我们分开写就会报错，
+	原因是`setData()`方法在执行的时候会自动清空所有在此之前调用的`setType`方法所设置过的type，
+	同样`setType`方法在执行的时候也会自动清空所有在此之前调用`setData`设置的`Data`，所以这里必须使用`setDataAndType`方法而不能分开使用`setData`和`setType`.
+- `Android`中提供了安装应用程序的功能，在`Android`系统源码中`apps/PackageInstaller`中。我们找到这个`PackageInstaller`的清单文件，
+	然后找到`PackageInstallerActivity`来查找该`Activity`的意图：如下
+	`android_source/packages/apps/PackageInstaller/AndroidManifest.xml`
+	```xml
+	<activity android:name=".PackageInstallerActivity"
+			android:configChanges="orientation|keyboardHidden"
+			android:excludeFromRecents="true">
+		<intent-filter>
+			<action android:name="android.intent.action.VIEW" />
+			<action android:name="android.intent.action.INSTALL_PACKAGE" />
+			<category android:name="android.intent.category.DEFAULT" />
+			<data android:scheme="content" />
+			<data android:scheme="file" />
+			<data android:mimeType="application/vnd.android.package-archive"/>
+		</intent-filter>
+		<intent-filter>
+			<action android:name="android.intent.action.INSTALL_PACKAGE" />
+			<category android:name="android.intent.category.DEFAULT" />
+			<data android:scheme="content" />
+			<data android:scheme="file" />
+		</intent-filter>
+	</activity>
+	```
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\345\274\200\345\217\221\344\270\255Log\347\232\204\347\256\241\347\220\206.md" "b/BasicKnowledge/\345\274\200\345\217\221\344\270\255Log\347\232\204\347\256\241\347\220\206.md"
similarity index 98%
rename from "Android\345\237\272\347\241\200/\345\274\200\345\217\221\344\270\255Log\347\232\204\347\256\241\347\220\206.md"
rename to "BasicKnowledge/\345\274\200\345\217\221\344\270\255Log\347\232\204\347\256\241\347\220\206.md"
index 6fa81095..2bc6ff49 100644
--- "a/Android\345\237\272\347\241\200/\345\274\200\345\217\221\344\270\255Log\347\232\204\347\256\241\347\220\206.md"
+++ "b/BasicKnowledge/\345\274\200\345\217\221\344\270\255Log\347\232\204\347\256\241\347\220\206.md"
@@ -1,7 +1,7 @@
 开发中Log的管理
 ===
 
-**LogUtil**是一个管理`Log`打印的工具类。在开发的不同阶段中通过对该类的控制来实现不同级别`Log`的打印。
+**LogUtil**是一个管理`Log`打印的工具类。在开发的不同阶段中通过对该类的控制来实现不同级别`Log`的打印。        
 ```java    
 public class LogUtil {
 	public static final int VERBOSE = 5;
diff --git "a/BasicKnowledge/\345\274\200\345\217\221\344\270\255\345\274\202\345\270\270\347\232\204\345\244\204\347\220\206.md" "b/BasicKnowledge/\345\274\200\345\217\221\344\270\255\345\274\202\345\270\270\347\232\204\345\244\204\347\220\206.md"
new file mode 100644
index 00000000..c22cd7d7
--- /dev/null
+++ "b/BasicKnowledge/\345\274\200\345\217\221\344\270\255\345\274\202\345\270\270\347\232\204\345\244\204\347\220\206.md"
@@ -0,0 +1,61 @@
+开发中异常的处理
+===
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/oom.png)
+
+1. 实现未捕捉异常处理器    
+
+```java
+public class MyExceptionHandler implements UncaughtExceptionHandler {
+	private static final String TAG = "MyExceptionHandler";
+	@Override
+	public void uncaughtException(Thread arg0, Throwable arg1) {
+		Logger.i(TAG, "发生了异常,但是被哥捕获了...");
+		try {
+		Field[] fields = Build.class.getDeclaredFields();//可以通过Build的属性来获取到手机的硬件信息，由于不同手机的硬件信息部一定有，所以要用反射得到
+		StringBuffer sb = new StringBuffer();
+		for(Field field: fields){
+			String info = field.getName()+ ":"+field.get(null)+"\n";
+			sb.append(info);
+		}
+		StringWriter sw = new StringWriter();
+		PrintWriter pw = new PrintWriter(sw);
+		arg1.printStackTrace(pw);//通过这个来得到异常信息
+		String errorlog = sw.toString();
+		
+			File file = new File(Environment.getExternalStorageDirectory(),
+					"error.log");
+			FileOutputStream fos = new FileOutputStream(file);
+			sb.append(errorlog);
+			fos.write(sb.toString().getBytes());
+			fos.close();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		android.os.Process.killProcess(android.os.Process.myPid());//这个是只能杀死自己不能杀死别人，这时候系统发现程序在自己的范围之内死了，
+		系统就会重启程序到出现错误之前的那个Activity。
+	}
+}
+```
+
+2. 让这个处理器生效   
+
+```java
+/**
+ * 代表的是当前应用程序的进程.
+ */
+public class MobliesafeApplication extends Application {
+	public BlackNumberInfo info;
+	
+	@Override
+	public void onCreate() {
+		super.onCreate();
+		Thread.currentThread().setUncaughtExceptionHandler(new MyExceptionHandler());//这样就能够让异常的处理器设置到我们的程序中
+	}
+}
+```
+	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\345\277\253\346\215\267\346\226\271\345\274\217\345\267\245\345\205\267\347\261\273.md" "b/BasicKnowledge/\345\277\253\346\215\267\346\226\271\345\274\217\345\267\245\345\205\267\347\261\273.md"
similarity index 99%
rename from "Android\345\237\272\347\241\200/\345\277\253\346\215\267\346\226\271\345\274\217\345\267\245\345\205\267\347\261\273.md"
rename to "BasicKnowledge/\345\277\253\346\215\267\346\226\271\345\274\217\345\267\245\345\205\267\347\261\273.md"
index 47f52e60..999cf5c6 100644
--- "a/Android\345\237\272\347\241\200/\345\277\253\346\215\267\346\226\271\345\274\217\345\267\245\345\205\267\347\261\273.md"
+++ "b/BasicKnowledge/\345\277\253\346\215\267\346\226\271\345\274\217\345\267\245\345\205\267\347\261\273.md"
@@ -1,5 +1,5 @@
 快捷方式工具类
-==+
+===
 
 ```java    
 /**   
diff --git "a/Android\345\237\272\347\241\200/\346\211\213\346\234\272\346\221\207\346\231\203.md" "b/BasicKnowledge/\346\211\213\346\234\272\346\221\207\346\231\203.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\346\211\213\346\234\272\346\221\207\346\231\203.md"
rename to "BasicKnowledge/\346\211\213\346\234\272\346\221\207\346\231\203.md"
diff --git "a/Android\345\237\272\347\241\200/\346\220\234\347\264\242\346\241\206.md" "b/BasicKnowledge/\346\220\234\347\264\242\346\241\206.md"
similarity index 97%
rename from "Android\345\237\272\347\241\200/\346\220\234\347\264\242\346\241\206.md"
rename to "BasicKnowledge/\346\220\234\347\264\242\346\241\206.md"
index b96f1cb9..3fb9d17b 100644
--- "a/Android\345\237\272\347\241\200/\346\220\234\347\264\242\346\241\206.md"
+++ "b/BasicKnowledge/\346\220\234\347\264\242\346\241\206.md"
@@ -1,7 +1,7 @@
 搜索框
 ===
 
-1. 在res-xml中新建一个searchable.xml
+1. 在res-xml中新建一个searchable.xml             
 	```xml
 	<?xml version="1.0" encoding="utf-8"?>
 	<searchable xmlns:android="http://schemas.android.com/apk/res/android"
@@ -12,7 +12,7 @@
 	</searchable>
 	```
  
-2. 创建一个搜索的Activity，并且在清单文件中进行配置，这个Activity就是点击搜索结果后的页面(显示搜索结果的Activity)
+2. 创建一个搜索的Activity，并且在清单文件中进行配置，这个Activity就是点击搜索结果后的页面(显示搜索结果的Activity)       
 	```xml
 	<activity android:name=".SearchableActivity" >
             <intent-filter>
diff --git "a/BasicKnowledge/\346\225\260\346\215\256\345\255\230\345\202\250.md" "b/BasicKnowledge/\346\225\260\346\215\256\345\255\230\345\202\250.md"
new file mode 100644
index 00000000..33ddcc48
--- /dev/null
+++ "b/BasicKnowledge/\346\225\260\346\215\256\345\255\230\345\202\250.md"
@@ -0,0 +1,325 @@
+数据存储
+===
+
+## `Android`数据存储的几种形式
+
+1. `Internal Storage`           
+    `Store private data on the device memory.`         
+	通过`mContext.getFilesDir()`来得到`data/data/包名/File`目录
+	
+2. `External Storage`     
+	`Store public data on the shared external storage.`    
+	```java
+	TextView tv = (TextView) findViewById(R.id.tv_sdsize);
+	File path = Environment.getExternalStorageDirectory();
+	StatFs stat = new StatFs(path.getPath());
+	long blockSize = stat.getBlockSize();
+	long availableBlocks = stat.getAvailableBlocks();
+	long sizeAvailSize = blockSize * availableBlocks;
+	String str = Formatter.formatFileSize(this, sizeAvailSize);
+	tv.setText(str);
+	```
+	
+3. `SharedPreferences`         
+	`Store private primitive data in key-value pairs.`     
+	会在`data/data/包名/shared_prefes`里面去创建相应的`xml`文件，根节点是`Map`，其实内部就是将数据保存到`Map`集合中，
+	然后将该集合中的数据写到`xml`文件中进行保存。
+	```xml
+	<map>
+		<string name="password">123</string>
+		<boolean name="isLogin" value="false"/>
+	</map>
+	```
+	
+	```java
+	//获取系统的一个sharedpreference文件  名字叫sp
+	SharedPreferences sp = context.getSharedPreferences("sp", Context.MODE_WORLD_READABLE+Context.MODE_WORLD_WRITEABLE);
+	//创建一个编辑器 可以编辑 sp
+	Editor editor = sp.edit();
+	editor.putString("name", name);
+	editor.putString("password", password);
+	editor.putBoolean("boolean", false);
+	editor.putInt("int", 8888);
+	editor.putFloat("float",3.14159f);
+	//注意:调用 commit 提交 数据到文件.
+	editor.commit();
+	//editor.clear();
+	```
+	
+4. `SQLiteDatabase`    
+	`Store structured data in a private database.`     
+	`Android`平台中嵌入了一个关系型数据库`SQLite`，和其他数据库不同的是`SQLite`存储数据时不区分类型，例如一个字段声明为`Integer`类型，
+	我们也可以将一个字符串存入，
+	一个字段声明为布尔型，我们也可以存入浮点数。除非是主键被定义为`Integer`，这时只能存储64位整数创建数据库的表时可以不指定数据类型，例如：        
+	```java
+	CREATE TABLE person(id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(20))  
+	CREATE TABLE person(id INTEGER PRIMARY KEY AUTOINCREMENT, name)
+	```
+	
+	`SQLite`支持大部分标准`SQL`语句，增删改查语句都是通用的，分页查询语句和`MySQL`相同     
+	```java
+	SELECT * FROM person LIMIT 20 OFFSET 10       
+	SELECT * FROM person LIMIT 10,20    
+	SELECT * FROM reading_history ORDER BY _id DESC LIMIT 3, 4
+	DELETE FROM test WHERE _id IN (SELECT _id FROM test ORDER BY _id DESC LIMIT 3, 20)
+	```
+	
+	`SQLite`数据库的使用
+	
+	- 继承`SQLiteOpenHelper`
+		```java
+		public class NoteSQLiteOpenHelper extends SQLiteOpenHelper {
+							
+			/**
+			 * name 数据库的名称 cursorfactory 游标工厂 一般设置null 默认游标工厂 version 数据库的版本
+			 * 版本号从1开始的
+			 * 
+			 * @param context
+			 */
+			public NoteSQLiteOpenHelper(Context context) {
+				super(context, "note.db", null, 1);
+			}
+
+			/**
+			 * oncreate 方法 会在数据库第一创建的时候的是被调用 适合做数据库表结构的初始化
+			 */
+			@Override
+			public void onCreate(SQLiteDatabase db) {
+				db.execSQL("create table account (id integer primary key autoincrement , name  varchar(20), money varchar(20) )");
+			}
+			
+			@Override
+			public void onUpgrade(SQLiteDatabase db, int arg1, int arg2) {
+				db.execSQL("DROP TABLE IF EXISTS " + account);
+				this.onCreate(db);
+			}
+		}
+		```
+		
+	- 获取
+		```java
+		public class NoteDao {
+			private NoteSQLiteOpenHelper helper;
+
+			public NoteDao(Context context) {
+				helper = new NoteSQLiteOpenHelper(context);
+			}
+
+			/**
+			 * 添加一条账目信息 到数据库
+			 * 
+			 * @param name
+			 *            花销的名称
+			 * @param money
+			 *            金额
+			 */
+			public void add(String name, float money) {
+				SQLiteDatabase db = helper.getWritableDatabase();
+				db.execSQL("insert into account (name,money) values (?,?)",
+						new Object[] { name, money });
+				// 记住 关闭.
+				db.close();
+			}
+
+			public void delete(int id) {
+				SQLiteDatabase db = helper.getWritableDatabase();
+				db.execSQL("delete from account where id=?", new Object[] { id });
+				db.close();
+			}
+
+			public void update(int id, float newmoney) {
+				SQLiteDatabase db = helper.getWritableDatabase();
+				db.execSQL("update account set money =? where id=?", new Object[] {
+						newmoney, id });
+				db.close();
+			}
+
+			/**
+			 * 返回数据库所有的条目
+			 * 
+			 * @return
+			 */
+			public List<NoteBean> findAll() {
+				// 得到可读的数据库
+				SQLiteDatabase db = helper.getReadableDatabase();
+				List<NoteBean> noteBeans = new ArrayList<NoteBean>();
+				// 获取到数据库查询的结果游标
+				Cursor cursor = db.rawQuery("select id,money,name from account ", null);
+				while (cursor.moveToNext()) {
+					int id = cursor.getInt(cursor.getColumnIndex("id"));
+					String name = cursor.getString(cursor.getColumnIndex("name"));
+					float money = cursor.getFloat(cursor.getColumnIndex("money"));
+					NoteBean bean = new NoteBean(id, money, name);
+					noteBeans.add(bean);
+					bean = null;
+				}
+
+				db.close();
+				return noteBeans;
+			}
+
+			/**
+			 * 模拟一个转账的操作. 使用数据库的事务
+			 * 
+			 * @throws Exception
+			 */
+			public void testTransaction() throws Exception {
+				// 得到可写的数据库
+				SQLiteDatabase db = helper.getWritableDatabase();
+				db.beginTransaction(); // 开始事务
+				try {
+					db.execSQL("update account set money = money - 5 where id=? ",
+							new String[] { "2" });
+					db.execSQL("update account set money = money + 5 where id=? ",
+							new String[] { "3" });
+					db.setTransactionSuccessful();
+				} catch (Exception e) {
+					// TODO: handle exception
+				} finally {
+					db.endTransaction();//关闭事务.
+					db.close();
+				}
+			}
+		}
+		```
+		
+		```java
+		public class NoteDao2 {
+			private NoteSQLiteOpenHelper helper;
+
+			public NoteDao2(Context context) {
+				helper = new NoteSQLiteOpenHelper(context);
+			}
+
+			/**
+			 * 添加一条账目信息 到数据库
+			 * 
+			 * @param name
+			 *            花销的名称
+			 * @param money
+			 *            金额
+			 * 
+			 * @return true 插入成功 false 失败
+			 */
+			public boolean add(String name, float money) {
+				SQLiteDatabase db = helper.getWritableDatabase();
+				ContentValues values = new ContentValues();
+				values.put("name", name);
+				values.put("money", money);
+				long rawid = db.insert("account", null, values);
+				db.close();
+				if (rawid > 0) {
+					return true;
+				} else {
+					return false;
+				}
+			}
+
+			public boolean delete(int id) {
+				SQLiteDatabase db = helper.getWritableDatabase();
+				int result = db.delete("account", "id=?", new String[] { id + "" });
+				db.close();
+				if (result > 0) {
+					return true;
+				} else {
+					return false;
+				}
+			}
+
+			public boolean update(int id, float newmoney) {
+				SQLiteDatabase db = helper.getWritableDatabase();
+				ContentValues values = new ContentValues();
+				values.put("id", id);
+				values.put("money", newmoney);
+				int result = db.update("account", values, "id=?", new String[] { id
+						+ "" });
+				db.close();
+				if (result > 0) {
+					return true;
+				} else {
+					return false;
+				}
+			}
+
+			/**
+			 * 返回数据库所有的条目
+			 * 
+			 * @return
+			 */
+			public List<NoteBean> findAll() {
+				// 得到可读的数据库
+				SQLiteDatabase db = helper.getReadableDatabase();
+				List<NoteBean> noteBeans = new ArrayList<NoteBean>();
+				Cursor cursor = db.query("account", new String[] { "id", "name",
+						"money" }, null, null, null, null, null);
+				while (cursor.moveToNext()) {
+					int id = cursor.getInt(cursor.getColumnIndex("id"));
+					String name = cursor.getString(cursor.getColumnIndex("name"));
+					float money = cursor.getFloat(cursor.getColumnIndex("money"));
+					NoteBean bean = new NoteBean(id, money, name);
+					noteBeans.add(bean);
+					bean = null;
+				}
+				db.close();
+				return noteBeans;
+			}
+		}
+		```
+        
+5. `Network`      
+	`Store data on the web with your own network server.`
+
+6. `/data/data/包名`下的apk在安装时提示解析失败。          
+    我们在更新或安装`apk`时一般将其放到外部存储设备中来进行安装，但是如果一个手机没有外部存储设备该怎么办呢？总不能就不给更新或者安装了。
+    可能你会觉得很简单啊，我用`mContext.getCacheDir()`或者`mContext.getFilesDir()`等获取内部路径，把`apk`放到这里面进行安装，但是你会发现安装
+    不了，提示解析失败。           
+    这是为什么呢？其实是权限的问题。安装应用的`app`是没有权限获取你应用的内部存储文件的，所以才会安装不上，那该怎么解决呢？	答案就是修改权限。
+	
+	```java
+	try {
+		InputStream is = getAssets().open(fileName);
+		File file;
+		if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
+			file = new File(Environment.getExternalStorageDirectory()
+					+ File.separator + fileName);
+		} else {
+			file = new File(mContext.getFilesDir()
+					+ File.separator + fileName);
+			String cmd = "chmod 777 " + file.getPath();
+			try {
+				Runtime.getRuntime().exec(cmd);
+			} catch (IOException e) {
+				e.printStackTrace();
+				return;
+			}
+		}
+
+		file.createNewFile();
+		FileOutputStream fos = new FileOutputStream(file);
+		byte[] temp = new byte[1024];
+		int i = 0;
+		while ((i = is.read(temp)) > 0) {
+			fos.write(temp, 0, i);
+		}
+		fos.close();
+		is.close();
+
+		Intent intent = new Intent(Intent.ACTION_VIEW);
+		intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+		intent.setDataAndType(Uri.parse("file://" + file),
+				"application/vnd.android.package-archive");
+		startActivity(intent);
+	} catch (Exception e) {
+		LogUtil.e("@@@", e.toString());
+		e.printStackTrace();
+	}
+	```
+
+7. 清除缓存&清除数据    
+	清除数据会清除`/data/data/`包名中的所有文件     
+	清楚缓存会清楚`getCacheDir()`目录下的内容，也就是`/data/data/<当前应用程序包名>/cache/`
+	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\346\226\207\344\273\266\344\270\212\344\274\240.md" "b/BasicKnowledge/\346\226\207\344\273\266\344\270\212\344\274\240.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\346\226\207\344\273\266\344\270\212\344\274\240.md"
rename to "BasicKnowledge/\346\226\207\344\273\266\344\270\212\344\274\240.md"
diff --git "a/Android\345\237\272\347\241\200/\346\235\245\347\224\265\345\217\267\347\240\201\345\275\222\345\261\236\345\234\260\346\217\220\347\244\272\346\241\206.md" "b/BasicKnowledge/\346\235\245\347\224\265\345\217\267\347\240\201\345\275\222\345\261\236\345\234\260\346\217\220\347\244\272\346\241\206.md"
similarity index 95%
rename from "Android\345\237\272\347\241\200/\346\235\245\347\224\265\345\217\267\347\240\201\345\275\222\345\261\236\345\234\260\346\217\220\347\244\272\346\241\206.md"
rename to "BasicKnowledge/\346\235\245\347\224\265\345\217\267\347\240\201\345\275\222\345\261\236\345\234\260\346\217\220\347\244\272\346\241\206.md"
index da2dc6f4..867dfa3f 100644
--- "a/Android\345\237\272\347\241\200/\346\235\245\347\224\265\345\217\267\347\240\201\345\275\222\345\261\236\345\234\260\346\217\220\347\244\272\346\241\206.md"
+++ "b/BasicKnowledge/\346\235\245\347\224\265\345\217\267\347\240\201\345\275\222\345\261\236\345\234\260\346\217\220\347\244\272\346\241\206.md"
@@ -7,7 +7,8 @@
 Toast提示只要提示的时间够长，就可以浮动到其他任何界面之上，所以我们可以模仿Toast来实现来电号码归属地的提示框         
 
 1. WindowManager      
-    The interface that apps use to talk to the window manager. Use Context.getSystemService(Context.WINDOW_SERVICE) to get one of these. Each window manager instance is bound to a particular Display.
+    The interface that apps use to talk to the window manager. Use Context.getSystemService(Context.WINDOW_SERVICE) to get one of these.
+	Each window manager instance is bound to a particular Display.
 
     1. void addView(View view,ViewGroup.LayoutParams params)    
 		将一个View视图显示到当前窗口，LayoutParams are used by views to tell their parents how they want to be laid out.
@@ -32,12 +33,13 @@ Toast提示只要提示的时间够长，就可以浮动到其他任何界面之
 	//本来还有一个FLAG_NOTUCHALBE为了让下面能触摸把这个给去掉了
 	params.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE  
 			| WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON;
-	params.format = PixelFormat.TRANSLUCENT;	//源码中这里是TYPE_TAOST但是这里为了下面要进行点击拖动事件，而Toast不能拖动，所以这里改成了TYPE_PRIORITY_PHONE,这是一个系统类型的提示框，使用这个提示框必须要申请权限,android.permission.SYSTEM_ALERT_WINDOW
+	params.format = PixelFormat.TRANSLUCENT;	//源码中这里是TYPE_TAOST但是这里为了下面要进行点击拖动事件，而Toast不能拖动，
+	所以这里改成了TYPE_PRIORITY_PHONE,这是一个系统类型的提示框，使用这个提示框必须要申请权限,android.permission.SYSTEM_ALERT_WINDOW
 	params.type = WindowManager.LayoutParams.TYPE_PRIORITY_PHONE; 
 	wm.addView(view, params); 
 	```
 
-3. WindowManager添加的显示框的简单拖动
+3. WindowManager添加的显示框的简单拖动  
     该这个View注册一个onTouchListener
     ```java
     public void showLocation(String address) {
@@ -303,7 +305,8 @@ Toast提示只要提示的时间够长，就可以浮动到其他任何界面之
 				editor.commit();
 				break;
 			}
-			//这里对于触摸事件应该是返回true为什么这里返回false呢，因为这里这一个控件同时实现了点击和触摸这两个事件，如果返回true，那么就不可能发生点击事件了，所以对于同时实现点击和触摸的控件返回值要为false
+			// 这里对于触摸事件应该是返回true为什么这里返回false呢，因为这里这一个控件同时实现了点击和触摸这两个事件，如果返回true，
+			// 那么就不可能发生点击事件了，所以对于同时实现点击和触摸的控件返回值要为false
 			return false;
 		}
 	});
diff --git "a/Android\345\237\272\347\241\200/\346\235\245\347\224\265\347\233\221\345\220\254\345\217\212\345\275\225\351\237\263.md" "b/BasicKnowledge/\346\235\245\347\224\265\347\233\221\345\220\254\345\217\212\345\275\225\351\237\263.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\346\235\245\347\224\265\347\233\221\345\220\254\345\217\212\345\275\225\351\237\263.md"
rename to "BasicKnowledge/\346\235\245\347\224\265\347\233\221\345\220\254\345\217\212\345\275\225\351\237\263.md"
diff --git "a/Android\345\237\272\347\241\200/\346\250\252\345\220\221ListView.md" "b/BasicKnowledge/\346\250\252\345\220\221ListView.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\346\250\252\345\220\221ListView.md"
rename to "BasicKnowledge/\346\250\252\345\220\221ListView.md"
diff --git "a/Android\345\237\272\347\241\200/\346\273\221\345\212\250\345\210\207\346\215\242Activity(GestureDetector).md" "b/BasicKnowledge/\346\273\221\345\212\250\345\210\207\346\215\242Activity(GestureDetector).md"
similarity index 60%
rename from "Android\345\237\272\347\241\200/\346\273\221\345\212\250\345\210\207\346\215\242Activity(GestureDetector).md"
rename to "BasicKnowledge/\346\273\221\345\212\250\345\210\207\346\215\242Activity(GestureDetector).md"
index 6891fcb8..4455bb47 100644
--- "a/Android\345\237\272\347\241\200/\346\273\221\345\212\250\345\210\207\346\215\242Activity(GestureDetector).md"
+++ "b/BasicKnowledge/\346\273\221\345\212\250\345\210\207\346\215\242Activity(GestureDetector).md"
@@ -1,58 +1,57 @@
 滑动切换Activity(GestureDetector)
 ===
 
-1. 实现手势滑动切换`Activity`      
-	1. 创建一个手势识别器(`GestureDetector`)       
-	2. 在`Activity`的`onTouchEvent`中去使用该手势识别器      
- 
-	```java
-	public abstract class SetupBaseActivity extends Activity {
-		protected SharedPreferences sp;
-		protected GestureDetector mGestureDetector;
+1. 实现手势滑动切换`Activity`        
+	- 创建一个手势识别器(`GestureDetector`)       
+	- 在`Activity`的`onTouchEvent`中去使用该手势识别器      
+		```java
+		public abstract class SetupBaseActivity extends Activity {
+			protected SharedPreferences sp;
+			protected GestureDetector mGestureDetector;
 
-		@Override
-		protected void onCreate(Bundle savedInstanceState) {
-			super.onCreate(savedInstanceState);
-			sp =getSharedPreferences("config", MODE_PRIVATE);
-			initView();
-			setupView();
-			//1.创建一个手势识别器 new 对象，并给这个手势识别器设置监听器
-			mGestureDetector = new GestureDetector(new GestureDetector.SimpleOnGestureListener(){
-				//当手指在屏幕上滑动的时候 调用的方法.
-				@Override
-				//e1代表的是手指刚开始滑动的事件，e2代表手指滑动完了的事件
-				public boolean onFling(MotionEvent e1, MotionEvent e2,float velocityX, float velocityY) {
-					if(e1.getRawX() - e2.getRawX() > 200){
-						showNext();//向右滑动，显示下一个界面
-						return true;
-					}
+			@Override
+			protected void onCreate(Bundle savedInstanceState) {
+				super.onCreate(savedInstanceState);
+				sp =getSharedPreferences("config", MODE_PRIVATE);
+				initView();
+				setupView();
+				//1.创建一个手势识别器 new 对象，并给这个手势识别器设置监听器
+				mGestureDetector = new GestureDetector(new GestureDetector.SimpleOnGestureListener(){
+					//当手指在屏幕上滑动的时候 调用的方法.
+					@Override
+					//e1代表的是手指刚开始滑动的事件，e2代表手指滑动完了的事件
+					public boolean onFling(MotionEvent e1, MotionEvent e2,float velocityX, float velocityY) {
+						if(e1.getRawX() - e2.getRawX() > 200){
+							showNext();//向右滑动，显示下一个界面
+							return true;
+						}
 
-					if(e2.getRawX() - e1.getRawX() > 200){
-						showPre();//向左滑动，显示上一个界面
-						return true;
+						if(e2.getRawX() - e1.getRawX() > 200){
+							showPre();//向左滑动，显示上一个界面
+							return true;
+						}
+						return super.onFling(e1, e2, velocityX, velocityY);
 					}
-					return super.onFling(e1, e2, velocityX, velocityY);
-				}
-			});
-		}
+				});
+			}
 
-		//2.让手势识别器生效，重写Activity的触摸事件，并且将Activity的触摸事件传入到手势识别器中
-		@Override
-		public boolean onTouchEvent(MotionEvent event) {
-			mGestureDetector.onTouchEvent(event);
-			return super.onTouchEvent(event);
+			//2.让手势识别器生效，重写Activity的触摸事件，并且将Activity的触摸事件传入到手势识别器中
+			@Override
+			public boolean onTouchEvent(MotionEvent event) {
+				mGestureDetector.onTouchEvent(event);
+				return super.onTouchEvent(event);
+			}
 		}
-	}
-	```
+		```
 
 2. 实现切换效果
 	经过上一步已经实现了滑动界面的切换，但是切换界面时的效果不好看，我们需要自定义切换的效果
 	
-	1. 在res目录下面新建一个anim文件夹在这个文件夹中新建动画效果
-		tran_next_in.xml//下一个界面进入的样式        
-		tran_next_out.xml//下一个界面进入时当前页面出去的样式         
-		tran_pre_in.xml//上一个界面进入的样式         
-		tran_pre_out.xml//上一个界面进入时当前页面出去的样式       
+	- 在res目录下面新建一个anim文件夹在这个文件夹中新建动画效果
+		tran_next_in.xml//下一个界面进入的样式         
+		tran_next_out.xml//下一个界面进入时当前页面出去的样式          
+		tran_pre_in.xml//上一个界面进入的样式          
+		tran_pre_out.xml//上一个界面进入时当前页面出去的样式        
  
 		- tran_next_in.xml里面的内容
 			```xml
@@ -106,7 +105,7 @@
 			</translate>
 			```
   
-	2. 让`Activity`在创建和销毁时使用上面自定义的动画
+	- 让`Activity`在创建和销毁时使用上面自定义的动画
 		
 		`public void overridePendingTransition(int enterAnim, int exitAnim);`
 		`Call immediately after one of the flavors of startActivity(Intent) or finish() to specify an explicit transition animation to perform next.`
diff --git "a/Android\345\237\272\347\241\200/\347\227\205\346\257\222.md" "b/BasicKnowledge/\347\227\205\346\257\222.md"
similarity index 95%
rename from "Android\345\237\272\347\241\200/\347\227\205\346\257\222.md"
rename to "BasicKnowledge/\347\227\205\346\257\222.md"
index 0074190c..eb560925 100644
--- "a/Android\345\237\272\347\241\200/\347\227\205\346\257\222.md"
+++ "b/BasicKnowledge/\347\227\205\346\257\222.md"
@@ -1,12 +1,12 @@
 病毒
 ===
 
-病毒：一个特殊计算机程序.     
-对于病毒的查杀都是基于特征码的识别.杀毒软件都需要有一个病毒信息的数据库.常用病毒数据库2000万条    
-杀毒引擎:  一套复杂高效的数据库查询算法.
-1.提取文件特征码 1秒    
-2.查询特征码是否在数据库里面 8秒     
-就是根据文件的特征码去病毒数据库中查询，如果能找到就说明这个文件是一个病毒     
+病毒：一个特殊计算机程序.      
+对于病毒的查杀都是基于特征码的识别.杀毒软件都需要有一个病毒信息的数据库.常用病毒数据库2000万条     
+杀毒引擎:  一套复杂高效的数据库查询算法.       
+1. 提取文件特征码 1秒    
+2. 查询特征码是否在数据库里面 8秒      
+就是根据文件的特征码去病毒数据库中查询，如果能找到就说明这个文件是一个病毒          
 
 病毒的查杀     
 下面以一个文件的MD5编码后的签名来判断是否是病毒
diff --git "a/Android\345\237\272\347\241\200/\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"
similarity index 92%
rename from "Android\345\237\272\347\241\200/\347\237\245\350\257\206\345\244\247\346\235\202\347\203\251.md"
rename to "BasicKnowledge/\347\237\245\350\257\206\345\244\247\346\235\202\347\203\251.md"
index 576327fe..f2fc9fa7 100644
--- "a/Android\345\237\272\347\241\200/\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"
@@ -25,8 +25,8 @@ public class TestService extends Service {
 2.*JVM*与*Dalvik*虚拟机的区别
 ---
 
-- *JVM*是基于栈的架构(内存)，编译过程为`.java`->`.class`->`.jar`    
-- *Dlvik(DVM)*是基于寄存器的架构(*CPU*里面的存储空间,*CPU*操作数据比内存要快)，编译过程为`.java`->`.class`->`.dex`->`.odex`
+- `JVM`是基于栈的架构(内存)，编译过程为`.java`->`.class`->`.jar`    
+- `Dlvik(DVM)是基于寄存器的架构(*CPU*里面的存储空间,*CPU*操作数据比内存要快)，编译过程为`.java`->`.class`->`.dex`->`.odex`
 - 一个应用，一个虚拟机实例，一个进程
  1. 每一个`Android`应用都运行在一个`Dalvik`虚拟机实例里，而每一个虚拟机实例都是一个独立的进程空间。每个进程之间可以通信（`IPC`，`Binder`机制实现）。虚拟机的线程机制，内存分配和管理，`Mutex`等等都是依赖底层操作系统而实现的。
  2. 不同的应用在不同的进程空间里运行，当一个虚拟机关闭或意外中止时不会对其它 虚拟机造成影响，可以最大程度的保护应用的安全和独立运行。
@@ -113,7 +113,8 @@ public void onClick(View v) {
 7.手机重启
 ---
 
-通过不断的`new`出来空白的`Toast`把系统弄崩溃，这样系统就会重启    
+该方法已失效，现在只会出现`ANR`无法重启                       
+通过不断的`new`出来空白的`Toast`把系统弄崩溃，这样系统就会重启。         
 ```java
 public void click(View view) {
     while (true) {
@@ -147,6 +148,13 @@ am start -a android.intent.action.VIEW -d  http://www.google.cn/
 am start -a android.intent.action.CALL -d tel:10086
 ```
 
+开启`Service`:
+```
+am startservice -n com.example.demo/.service.DemoService
+```
+
+从4.2开始`Android`加入了多用户，所以用上面的命令就不行了，要加上`user`的参数。
+
 9.启动`APK`默认`Activity`
 ---
 
@@ -208,13 +216,14 @@ adb push d:\lzd.doc /mnt/sdcard/jaj_training/fingerprint/
 12.Android 4.0横竖屏切换
 ---
 
-==`Android 2.3`以前的横竖屏切换==
+- `Android 2.3`以前的横竖屏切换
 
 在Android 2.3平台上，我们可以需要设置界面的横竖屏显示时，可以在AndroidManifest.xml中，对Activity的属性添加以下代码：
 ```java
 android:configChanges="keyboardHidden|orientation"同时在Activity中覆写onConfigurationChanged方法
 ```
-==`Android 4.0`以后的横竖屏切换==
+
+- `Android 4.0`以后的横竖屏切换
 
 当我们在4.0上像之前那样设置横竖屏时，会发现竟然没有效果，Activity依然走自己的生命周期，这是因为在API level 13以后Android做了修改了，当设备横竖屏切换时屏幕尺寸也改变了。因此，如果你想在API Level 13或者更高的环境下，像以前那样阻止设备的横竖屏切换，你需要在orientation后加上screenSize。也就说你要像这样声明：
 ```java
@@ -232,7 +241,7 @@ public void onConfigurationChanged(Configuration newConfig) {
 13.广播接收者中开启Activity
 ---
 
-如果在一个不是`Activity`的上下文中**(如服务或者广播接收者)**中去开启一个`Activity`那么就必须设置`intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);`这样才可以，不然会报错.因为Activity开启后必须要有一个`Task`栈，而在服务和广播接收者的上下文中并没有`Task`栈，所以我们必须要去指定一个新的栈。
+如果在一个不是`Activity`的上下文中(如服务或者广播接收者)中去开启一个`Activity`那么就必须设置`intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);`这样才可以，不然会报错.因为Activity开启后必须要有一个`Task`栈，而在服务和广播接收者的上下文中并没有`Task`栈，所以我们必须要去指定一个新的栈。
 ```java
 public class OutCallReceiver extends BroadcastReceiver {
     @Override
@@ -288,7 +297,8 @@ monkey -p com.charon.test -v 500
 ---
 
 1. `Handler`    
-`
+
+```
 A Handler allows you to send and process Message and Runnable objects associated with a thread's MessageQueue. Each Handler instance is associated with a single thread and that thread's message queue. 
 When you create a new Handler, it is bound to the thread / message queue of the thread that is creating it -- from that point on, 
 it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.
@@ -305,11 +315,11 @@ it will deliver messages and runnables to that message queue and execute them as
     When a process is created for your application, its main thread is dedicated to running a message queue that takes care of managing the top-level application objects (activities, broadcast receivers, etc) 
 	and any windows they create. You can create your own threads, and communicate back with the main application thread through a Handler. This is done by calling the same post or sendMessage methods as before, 
 	but from your new thread. The given Runnable or Message will then be scheduled in the Handler's message queue and processed when appropriate.
-`
+```
 
 2. `HandlerThread`
 Handy class for starting a new thread that has a looper. The looper can then be used to create handler classes. Note that start() must still be called.    
-`Handler`是一个有`Looper`的线程，这个`Looper`可以用于创建`Handler`。也是就是该`HandlerThread`内部自己维护着一个消息队列以及`Looper`，
+`HandlerThread`是一个有`Looper`的线程，这个`Looper`可以用于创建`Handler`。也是就是该`HandlerThread`内部自己维护着一个消息队列以及`Looper`，
 当我们使用以该`Looper`创建的`Handler`去执行`handler.sendMessage(Message msg)`或者`handler.post(Runnable thread)`时会将消息或者线程发送到`HandlerThread`这个线程中而不是主线程，
 消息队列也是由该线程自己执行而不会影响到主线程的执行，这样就防止了主UI线程能够及时响应用户的操作，防止了`ANR`错误。简单的说`HandlerThread`就是一个有`Looper`功能的`Thread`。
 
@@ -397,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  
diff --git "a/Android\345\237\272\347\241\200/\347\237\255\344\277\241\345\271\277\346\222\255\346\216\245\346\224\266\350\200\205.md" "b/BasicKnowledge/\347\237\255\344\277\241\345\271\277\346\222\255\346\216\245\346\224\266\350\200\205.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\347\237\255\344\277\241\345\271\277\346\222\255\346\216\245\346\224\266\350\200\205.md"
rename to "BasicKnowledge/\347\237\255\344\277\241\345\271\277\346\222\255\346\216\245\346\224\266\350\200\205.md"
diff --git "a/Android\345\237\272\347\241\200/\347\250\213\345\272\217\347\232\204\345\220\257\345\212\250\343\200\201\345\215\270\350\275\275\345\222\214\345\210\206\344\272\253.md" "b/BasicKnowledge/\347\250\213\345\272\217\347\232\204\345\220\257\345\212\250\343\200\201\345\215\270\350\275\275\345\222\214\345\210\206\344\272\253.md"
similarity index 98%
rename from "Android\345\237\272\347\241\200/\347\250\213\345\272\217\347\232\204\345\220\257\345\212\250\343\200\201\345\215\270\350\275\275\345\222\214\345\210\206\344\272\253.md"
rename to "BasicKnowledge/\347\250\213\345\272\217\347\232\204\345\220\257\345\212\250\343\200\201\345\215\270\350\275\275\345\222\214\345\210\206\344\272\253.md"
index 92c89626..02428d28 100644
--- "a/Android\345\237\272\347\241\200/\347\250\213\345\272\217\347\232\204\345\220\257\345\212\250\343\200\201\345\215\270\350\275\275\345\222\214\345\210\206\344\272\253.md"
+++ "b/BasicKnowledge/\347\250\213\345\272\217\347\232\204\345\220\257\345\212\250\343\200\201\345\215\270\350\275\275\345\222\214\345\210\206\344\272\253.md"
@@ -67,7 +67,8 @@
     } 
 	```   
 	
-	谷歌工程师在设计这个程序的时候，任何应用程序如果想使用分享的功能都可以通过实现它的Intent来实现，点击的时候可以选择不同的程序，同样也能分享到微博，邮件等程序
+	谷歌工程师在设计这个程序的时候，任何应用程序如果想使用分享的功能都可以通过实现它的Intent来实现，点击的时候可以选择不同的程序，同样也能分享到微博，
+	邮件等程序
 	
 ---
 
diff --git "a/Android\345\237\272\347\241\200/\347\253\226\347\235\200\347\232\204Seekbar.md" "b/BasicKnowledge/\347\253\226\347\235\200\347\232\204Seekbar.md"
similarity index 94%
rename from "Android\345\237\272\347\241\200/\347\253\226\347\235\200\347\232\204Seekbar.md"
rename to "BasicKnowledge/\347\253\226\347\235\200\347\232\204Seekbar.md"
index dea2adcd..58a19761 100644
--- "a/Android\345\237\272\347\241\200/\347\253\226\347\235\200\347\232\204Seekbar.md"
+++ "b/BasicKnowledge/\347\253\226\347\235\200\347\232\204Seekbar.md"
@@ -1,7 +1,8 @@
 竖着的Seekbar
 ===
 
-视频播放器页面音量控制`Seekbar`实现竖直的效果。竖直只是将`Seekbar`转了90度或-90度，我们可以把画布转一个角度，然后交给系统去画，具体的做法就是重写`ondraw()`调整画布，然后调用`super.onDraw()`。   
+视频播放器页面音量控制`Seekbar`实现竖直的效果。竖直只是将`Seekbar`转了90度或-90度，我们可以把画布转一个角度，然后交给系统去画，
+具体的做法就是重写`ondraw()`调整画布，然后调用`super.onDraw()`。   
 
 - 向上的Seekbar
 ```java
diff --git "a/Android\345\237\272\347\241\200/\350\207\252\345\256\232\344\271\211Toast.md" "b/BasicKnowledge/\350\207\252\345\256\232\344\271\211Toast.md"
similarity index 95%
rename from "Android\345\237\272\347\241\200/\350\207\252\345\256\232\344\271\211Toast.md"
rename to "BasicKnowledge/\350\207\252\345\256\232\344\271\211Toast.md"
index 6c54e70e..6ac89c34 100644
--- "a/Android\345\237\272\347\241\200/\350\207\252\345\256\232\344\271\211Toast.md"
+++ "b/BasicKnowledge/\350\207\252\345\256\232\344\271\211Toast.md"
@@ -149,7 +149,8 @@ public class ToastUtil {
 ```
 
 
-在某些Pad上面Toast显示出来后就不会自动消失，在这些Pad上`toastView.getParent()会为nul`这样就导致无法移除。可以将`cancelOldAlert()`以及`cancelCurrentAlert()`进行如下修改。
+在某些Pad上面Toast显示出来后就不会自动消失，在这些Pad上`toastView.getParent()会为nul`这样就导致无法移除。可以将`cancelOldAlert()`以及
+`cancelCurrentAlert()`进行如下修改。
 
 ```java
 private void cancelOldAlert() {
@@ -165,7 +166,8 @@ private void cancelOldAlert() {
 public void cancelCurrentAlert() {
     if (toastView != null) {
         try {
-            mWindowManager.removeView(toastView);// 去掉 oldView.getParent() != null 这个参数，然后加上try catch代码块，解决在部分Pad上oldView.getParent()不准确的问题 
+		    // 去掉 oldView.getParent() != null 这个参数，然后加上try catch代码块，解决在部分Pad上oldView.getParent()不准确的问题 
+            mWindowManager.removeView(toastView);
         } catch (Exception e) {
             e.printStackTrace();
         }
diff --git "a/Android\345\237\272\347\241\200/\350\207\252\345\256\232\344\271\211\346\216\247\344\273\266.md" "b/BasicKnowledge/\350\207\252\345\256\232\344\271\211\346\216\247\344\273\266.md"
similarity index 97%
rename from "Android\345\237\272\347\241\200/\350\207\252\345\256\232\344\271\211\346\216\247\344\273\266.md"
rename to "BasicKnowledge/\350\207\252\345\256\232\344\271\211\346\216\247\344\273\266.md"
index 93fe6b44..ddc35a13 100644
--- "a/Android\345\237\272\347\241\200/\350\207\252\345\256\232\344\271\211\346\216\247\344\273\266.md"
+++ "b/BasicKnowledge/\350\207\252\345\256\232\344\271\211\346\216\247\344\273\266.md"
@@ -8,7 +8,8 @@
 - 重写构造方法   
 可以在构造方法中附加要显示的内容如下：     
 `View.inflate(context, R.layout.ui_setting_view, this);`
-这里就是让这个填充出来的`View`显示到当前我们自定义的这个布局中`View`的构造方法共有三个，其中一个参数的构造方法，是通过代码`new`对象的时候调用，两个参数的构造方法是通过在`xml`布局文件中声明的构造     
+这里就是让这个填充出来的`View`显示到当前我们自定义的这个布局中`View`的构造方法共有三个，其中一个参数的构造方法，是通过代码`new`对象的时候调用，
+两个参数的构造方法是通过在`xml`布局文件中声明的构造     
 - 实现通过`Xml`文件配置属性
     - `values`目录下新建`attrs.xml`
     - 内容如下
@@ -39,7 +40,7 @@
 
 以系统设置页面的选中为例
 
-![image](https://github.com/CharonChui/AndroidNote/blob/master/Pic/custom_widget.jpg?raw=true)
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/custom_widget.jpg)
  
 1. 样式   
 	示例代码：`settingview.xml`
diff --git "a/Android\345\237\272\347\241\200/\350\207\252\345\256\232\344\271\211\347\212\266\346\200\201\346\240\217\351\200\232\347\237\245.md" "b/BasicKnowledge/\350\207\252\345\256\232\344\271\211\347\212\266\346\200\201\346\240\217\351\200\232\347\237\245.md"
similarity index 99%
rename from "Android\345\237\272\347\241\200/\350\207\252\345\256\232\344\271\211\347\212\266\346\200\201\346\240\217\351\200\232\347\237\245.md"
rename to "BasicKnowledge/\350\207\252\345\256\232\344\271\211\347\212\266\346\200\201\346\240\217\351\200\232\347\237\245.md"
index afb550e1..6e93737e 100644
--- "a/Android\345\237\272\347\241\200/\350\207\252\345\256\232\344\271\211\347\212\266\346\200\201\346\240\217\351\200\232\347\237\245.md"
+++ "b/BasicKnowledge/\350\207\252\345\256\232\344\271\211\347\212\266\346\200\201\346\240\217\351\200\232\347\237\245.md"
@@ -2,8 +2,8 @@
 ===
 
 状态栏通知布局
+`custom_notification.xml`        
 ```xml
-custom_notification.xml
 <?xml version="1.0" encoding="utf-8"?>
 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
diff --git "a/Android\345\237\272\347\241\200/\350\207\252\345\256\232\344\271\211\350\203\214\346\231\257.md" "b/BasicKnowledge/\350\207\252\345\256\232\344\271\211\350\203\214\346\231\257.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\350\207\252\345\256\232\344\271\211\350\203\214\346\231\257.md"
rename to "BasicKnowledge/\350\207\252\345\256\232\344\271\211\350\203\214\346\231\257.md"
diff --git "a/Android\345\237\272\347\241\200/\350\216\267\345\217\226\344\275\215\347\275\256(LocationManager).md" "b/BasicKnowledge/\350\216\267\345\217\226\344\275\215\347\275\256(LocationManager).md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\350\216\267\345\217\226\344\275\215\347\275\256(LocationManager).md"
rename to "BasicKnowledge/\350\216\267\345\217\226\344\275\215\347\275\256(LocationManager).md"
diff --git "a/Android\345\237\272\347\241\200/\350\216\267\345\217\226\345\272\224\347\224\250\347\250\213\345\272\217\347\274\223\345\255\230\345\217\212\344\270\200\351\224\256\346\270\205\347\220\206.md" "b/BasicKnowledge/\350\216\267\345\217\226\345\272\224\347\224\250\347\250\213\345\272\217\347\274\223\345\255\230\345\217\212\344\270\200\351\224\256\346\270\205\347\220\206.md"
similarity index 95%
rename from "Android\345\237\272\347\241\200/\350\216\267\345\217\226\345\272\224\347\224\250\347\250\213\345\272\217\347\274\223\345\255\230\345\217\212\344\270\200\351\224\256\346\270\205\347\220\206.md"
rename to "BasicKnowledge/\350\216\267\345\217\226\345\272\224\347\224\250\347\250\213\345\272\217\347\274\223\345\255\230\345\217\212\344\270\200\351\224\256\346\270\205\347\220\206.md"
index 2110bc7b..c73f9d22 100644
--- "a/Android\345\237\272\347\241\200/\350\216\267\345\217\226\345\272\224\347\224\250\347\250\213\345\272\217\347\274\223\345\255\230\345\217\212\344\270\200\351\224\256\346\270\205\347\220\206.md"
+++ "b/BasicKnowledge/\350\216\267\345\217\226\345\272\224\347\224\250\347\250\213\345\272\217\347\274\223\345\255\230\345\217\212\344\270\200\351\224\256\346\270\205\347\220\206.md"
@@ -3,6 +3,7 @@
 
 1. 什么是缓存呢？    
 	在手机ROM里面的缓存就是每个程序的cache文件夹
+	
 2. 获取缓存思路(参考手机设置页面)      
 	通过`PakcageManager.getPakcageSizeInfo()`能得到程序的缓存，但是这个方法被隐藏了，而系统的`Setting`页面之所以能使用是因为它们的权限高，
 	我们要想使用就必须通过反射来得到，这里`getPackageSizeInfo()`方法的第二个参数是一个远程的`aidl`文件。
@@ -54,10 +55,11 @@
         }
     }
 	```
+	
 4. 缓存清理
 	得到每个程序的缓存大小后，该怎么去清理程序的缓存呢？调用`PackageManager.deleteApplicationCacheFiles`,这个方法是隐藏的，我们通过反射来执行但是发现需要权限，
-	设置权限后还是提示需要权限，这是因为没有系统权限我们不能清理，设置页面之所以能够使用这个方法，因为是系统的`API`，所以我们只能是点击条目之后跳转到系统的设置页面，
-	让通过设置页面来删除缓存.
+	设置权限后还是提示需要权限，这是因为没有系统权限我们不能清理，设置页面之所以能够使用这个方法，因为是系统的`API`，
+	所以我们只能是点击条目之后跳转到系统的设置页面，让通过设置页面来删除缓存.
  
 5. 一键清理
 	一键自动清理使用`freeStorageAndNotify`方法，该方法能够向系统申请释放多大的内存，系统会根据你申请的大小，尽可能的去是释放可以释放的大小。
diff --git "a/Android\345\237\272\347\241\200/\350\216\267\345\217\226\346\211\213\346\234\272\344\270\255\346\211\200\346\234\211\345\256\211\350\243\205\347\232\204\347\250\213\345\272\217.md" "b/BasicKnowledge/\350\216\267\345\217\226\346\211\213\346\234\272\344\270\255\346\211\200\346\234\211\345\256\211\350\243\205\347\232\204\347\250\213\345\272\217.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\350\216\267\345\217\226\346\211\213\346\234\272\344\270\255\346\211\200\346\234\211\345\256\211\350\243\205\347\232\204\347\250\213\345\272\217.md"
rename to "BasicKnowledge/\350\216\267\345\217\226\346\211\213\346\234\272\344\270\255\346\211\200\346\234\211\345\256\211\350\243\205\347\232\204\347\250\213\345\272\217.md"
diff --git "a/Android\345\237\272\347\241\200/\350\216\267\345\217\226\346\211\213\346\234\272\345\217\212SD\345\215\241\345\217\257\347\224\250\345\255\230\345\202\250\347\251\272\351\227\264.md" "b/BasicKnowledge/\350\216\267\345\217\226\346\211\213\346\234\272\345\217\212SD\345\215\241\345\217\257\347\224\250\345\255\230\345\202\250\347\251\272\351\227\264.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\350\216\267\345\217\226\346\211\213\346\234\272\345\217\212SD\345\215\241\345\217\257\347\224\250\345\255\230\345\202\250\347\251\272\351\227\264.md"
rename to "BasicKnowledge/\350\216\267\345\217\226\346\211\213\346\234\272\345\217\212SD\345\215\241\345\217\257\347\224\250\345\255\230\345\202\250\347\251\272\351\227\264.md"
diff --git "a/Android\345\237\272\347\241\200/\350\216\267\345\217\226\350\201\224\347\263\273\344\272\272.md" "b/BasicKnowledge/\350\216\267\345\217\226\350\201\224\347\263\273\344\272\272.md"
similarity index 71%
rename from "Android\345\237\272\347\241\200/\350\216\267\345\217\226\350\201\224\347\263\273\344\272\272.md"
rename to "BasicKnowledge/\350\216\267\345\217\226\350\201\224\347\263\273\344\272\272.md"
index 72f6dd93..e136b1d9 100644
--- "a/Android\345\237\272\347\241\200/\350\216\267\345\217\226\350\201\224\347\263\273\344\272\272.md"
+++ "b/BasicKnowledge/\350\216\267\345\217\226\350\201\224\347\263\273\344\272\272.md"
@@ -8,7 +8,8 @@
 - data：和raw_contacts是多对一的关系，保存了联系人的各项数据
 - mimetypes：为数据类型
 
-先查询`raw_contacts`得到每个联系人的`id`，在使用`id`从`data`表中查询对应数据，根据`mimetype`分类数据这地方在数据库中的是一个`mimetype_id`是一个外键引用到了`mimetype`这个表中，它内部做了一个关联查询，这地方不能写`mimetype_id`，只能写`mimetype`不然会报错
+先查询`raw_contacts`得到每个联系人的`id`，在使用`id`从`data`表中查询对应数据，根据`mimetype`分类数据这地方在数据库中的是一个`mimetype_id`
+是一个外键引用到了`mimetype`这个表中，它内部做了一个关联查询，这地方不能写`mimetype_id`，只能写`mimetype`不然会报错
 
 ```java
 /**
@@ -44,9 +45,12 @@ public static List<ContactInfo> getContactInfos(Context context) {
 	return contactInfos;
 }
 ```
-要使用到这三个表，但是谷歌内部在查询这个`data`表的时候内部使用的并不是查询`data`表而是查询了`data`表的视图，这个视图中直接将`mime_Type`类型给关联好了，所以这里直接查询的就是`mimetype`这个类型就可以了，还有就是如果自己的手机中如果删除了一个联系人在查询的时候就会报错，这里因为是在手机中删除一个联系人的时候并*不是清空数据库中的数据*，而是将这个**raw_contacks中的id置为null**，所以会报错，这里就要进行判断一下查出来的id是否为null。
+要使用到这三个表，但是谷歌内部在查询这个`data`表的时候内部使用的并不是查询`data`表而是查询了`data`表的视图，
+这个视图中直接将`mime_Type`类型给关联好了，所以这里直接查询的就是`mimetype`这个类型就可以了，
+还有就是如果自己的手机中如果删除了一个联系人在查询的时候就会报错，这里因为是在手机中删除一个联系人的时候并*不是清空数据库中的数据*，
+而是将这个**raw_contacks中的id置为null**，所以会报错，这里就要进行判断一下查出来的id是否为null。
 
-------------------------------------------
+---
 
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
\ No newline at end of file
diff --git "a/Android\345\237\272\347\241\200/\350\257\273\345\217\226\347\224\250\346\210\267logcat\346\227\245\345\277\227.md" "b/BasicKnowledge/\350\257\273\345\217\226\347\224\250\346\210\267logcat\346\227\245\345\277\227.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\350\257\273\345\217\226\347\224\250\346\210\267logcat\346\227\245\345\277\227.md"
rename to "BasicKnowledge/\350\257\273\345\217\226\347\224\250\346\210\267logcat\346\227\245\345\277\227.md"
diff --git "a/BasicKnowledge/\350\265\204\346\272\220\346\226\207\344\273\266\346\213\267\350\264\235\347\232\204\344\270\211\347\247\215\346\226\271\345\274\217.md" "b/BasicKnowledge/\350\265\204\346\272\220\346\226\207\344\273\266\346\213\267\350\264\235\347\232\204\344\270\211\347\247\215\346\226\271\345\274\217.md"
new file mode 100644
index 00000000..956ff687
--- /dev/null
+++ "b/BasicKnowledge/\350\265\204\346\272\220\346\226\207\344\273\266\346\213\267\350\264\235\347\232\204\344\270\211\347\247\215\346\226\271\345\274\217.md"
@@ -0,0 +1,38 @@
+资源文件拷贝的三种方式
+===
+
+- 类加载器(类路径)  
+    - 用`Classloader.getResourceAsStream()`来读取类路径中的资源，然后用`FileOutputStream`写入到自己的应用中(*sdk开发的时候经常用这种方式*)。
+    - 这种方式**必须**要将数据库`address.db`放到**src**目录下，这样编译后就会直接将`address.db`生成到`bin/classes`目录中，会在类路径下，
+	    所以可以使用`Classloader`进行加载.  
+		
+		```java
+		InputStream is = getClassLoader().getResourceAsStream("address.db");
+		File file = new File(/data/data/包名/files/address.db);
+		FileOutputStream fos = new FileOutputStream(file);
+		```
+
+- Raw目录   
+    将资源文件放到`res-raw`下, 然后用`getResources.openRawResource(R.raw.addresss);`(要求资源最好不超过1M,因为系统会编译`res`目录)
+
+- Assets目录   
+    将资源文件放到`Assets`目录中。然后用`mContext.getAssets().open("address.db");`来读取该资源(`Assets`目录中的文件不会被编译，会原封不动的打包到apk中，
+	所以一般用来存放比较大的资源文件)
+	注意：上面这是在`Eclipse`中的使用方式，因为在`Eclipse`中`assets`目录是在`res`下，但是在`Android Studio`中如果这样使用会报`FileNotFoundException`，为什么呢？
+	文件名字没错，而且明明是在`assets`目录中的，这是因为在`Studio`中`assets`文件夹的目录层级发生了变化，直接在`module`下，与`src`目录平级了？该如何修改呢？
+	答案就是把`assets`目录移`src/main`下面就可以了？为什么呢？因为我们打开`app.impl`可以看到`<option name="ASSETS_FOLDER_RELATIVE_PATH" value="/src/main/assets" />`。
+	所以把`assets`移到`src/main/`下就可以了。
+
+那`Raw`和`Assets`两者有什么区别呢？      
+
+- 两者目录下的文件在打包后会原封不动的保存在`apk`包中，不会被编译成二进制。
+- 在读取这两个资源文件夹中的文件时会有一定的限制，即单个文件大小不能超过`1M` ，如果读取超过1M的文件会报`Data exceeds UNCOMPRESS_DATA_MAX (1314625 vs 1048576)` 的`IOException`。
+- `raw`中的文件会被映射到`R`文件中，访问的时候直接使用资源`ID`；`assets`文件夹下的文件不会被映射到`R`文件中。
+- `raw`不可以有目录结构，而`assets`则可以有目录结构，也就是`assets`目录下可以再建立文件夹。
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Android\345\237\272\347\241\200/\350\266\205\347\272\247\347\256\241\347\220\206\345\221\230(DevicePoliceManager).md" "b/BasicKnowledge/\350\266\205\347\272\247\347\256\241\347\220\206\345\221\230(DevicePoliceManager).md"
similarity index 85%
rename from "Android\345\237\272\347\241\200/\350\266\205\347\272\247\347\256\241\347\220\206\345\221\230(DevicePoliceManager).md"
rename to "BasicKnowledge/\350\266\205\347\272\247\347\256\241\347\220\206\345\221\230(DevicePoliceManager).md"
index 701d4f28..a8f8db1a 100644
--- "a/Android\345\237\272\347\241\200/\350\266\205\347\272\247\347\256\241\347\220\206\345\221\230(DevicePoliceManager).md"
+++ "b/BasicKnowledge/\350\266\205\347\272\247\347\256\241\347\220\206\345\221\230(DevicePoliceManager).md"
@@ -4,7 +4,8 @@
 DevicePolicyManager    
 ---
 
-Public interface for managing policies enforced on a device. Most clients of this class must have published a DeviceAdminReceiver that the user has currently enabled.       
+Public interface for managing policies enforced on a device. Most clients of this class must have published a DeviceAdminReceiver that the user 
+has currently enabled.       
 
 ```java
 DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Context.DEVICE_POLICY_SERVICE);
@@ -37,21 +38,21 @@ DevicePolicyManager中的方法
 	```
     
 2. 在清单文件中配置自定义的类
-	```xml
-	<receiver
-		android:name=".receiver.MyAdmin"
-		android:description="@string/admin_des"
-		android:label="防卸载"
-		android:permission="android.permission.BIND_DEVICE_ADMIN" >
-		<meta-data
-			android:name="android.app.device_admin"
-			android:resource="@xml/device_admin_sample" />
+```xml
+<receiver
+	android:name=".receiver.MyAdmin"
+	android:description="@string/admin_des"
+	android:label="防卸载"
+	android:permission="android.permission.BIND_DEVICE_ADMIN" >
+	<meta-data
+		android:name="android.app.device_admin"
+		android:resource="@xml/device_admin_sample" />
 
-		<intent-filter>
-			<action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
-		</intent-filter>
-	</receiver>
-	```
+	<intent-filter>
+		<action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
+	</intent-filter>
+</receiver>
+```
 	
 3.  完成第二步中所需的meta-data。在res下新建一个xml文件，device_admin_sample.xml
 	```xml
diff --git "a/Android\345\237\272\347\241\200/\351\224\201\345\261\217\344\273\245\345\217\212\350\247\243\351\224\201\347\233\221\345\220\254.md" "b/BasicKnowledge/\351\224\201\345\261\217\344\273\245\345\217\212\350\247\243\351\224\201\347\233\221\345\220\254.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\351\224\201\345\261\217\344\273\245\345\217\212\350\247\243\351\224\201\347\233\221\345\220\254.md"
rename to "BasicKnowledge/\351\224\201\345\261\217\344\273\245\345\217\212\350\247\243\351\224\201\347\233\221\345\220\254.md"
diff --git "a/Android\345\237\272\347\241\200/\351\233\266\346\235\203\351\231\220\344\270\212\344\274\240\346\225\260\346\215\256.md" "b/BasicKnowledge/\351\233\266\346\235\203\351\231\220\344\270\212\344\274\240\346\225\260\346\215\256.md"
similarity index 81%
rename from "Android\345\237\272\347\241\200/\351\233\266\346\235\203\351\231\220\344\270\212\344\274\240\346\225\260\346\215\256.md"
rename to "BasicKnowledge/\351\233\266\346\235\203\351\231\220\344\270\212\344\274\240\346\225\260\346\215\256.md"
index cfa38987..27beb869 100644
--- "a/Android\345\237\272\347\241\200/\351\233\266\346\235\203\351\231\220\344\270\212\344\274\240\346\225\260\346\215\256.md"
+++ "b/BasicKnowledge/\351\233\266\346\235\203\351\231\220\344\270\212\344\274\240\346\225\260\346\215\256.md"
@@ -1,7 +1,9 @@
 零权限上传数据
 ===
 
-虽然没有权限，但是也可以通过浏览器用`Get`方式来传递自己的数据，由于这样会打开浏览器，为了防止让用户看到，所以我们可以再用户锁屏之后开始传递数据，而在用户一解除锁屏我们就回到桌面，这里用`KeyguardManager`来实现，即在锁屏的时候键盘不能用，而一旦键盘能用了我们就立马回到桌面    
+虽然没有权限，但是也可以通过浏览器用`Get`方式来传递自己的数据，由于这样会打开浏览器，为了防止让用户看到，
+所以我们可以再用户锁屏之后开始传递数据，而在用户一解除锁屏我们就回到桌面，这里用`KeyguardManager`来实现，
+即在锁屏的时候键盘不能用，而一旦键盘能用了我们就立马回到桌面    
 ```java
 public void onCreate() {
 	timer = new Timer();
diff --git "a/Android\345\237\272\347\241\200/\351\237\263\351\207\217\345\217\212\345\261\217\345\271\225\344\272\256\345\272\246\350\260\203\350\212\202.md" "b/BasicKnowledge/\351\237\263\351\207\217\345\217\212\345\261\217\345\271\225\344\272\256\345\272\246\350\260\203\350\212\202.md"
similarity index 100%
rename from "Android\345\237\272\347\241\200/\351\237\263\351\207\217\345\217\212\345\261\217\345\271\225\344\272\256\345\272\246\350\260\203\350\212\202.md"
rename to "BasicKnowledge/\351\237\263\351\207\217\345\217\212\345\261\217\345\271\225\344\272\256\345\272\246\350\260\203\350\212\202.md"
diff --git "a/Android\345\237\272\347\241\200/\351\273\221\345\220\215\345\215\225\346\214\202\346\226\255\347\224\265\350\257\235\345\217\212\345\210\240\351\231\244\347\224\265\350\257\235\350\256\260\345\275\225.md" "b/BasicKnowledge/\351\273\221\345\220\215\345\215\225\346\214\202\346\226\255\347\224\265\350\257\235\345\217\212\345\210\240\351\231\244\347\224\265\350\257\235\350\256\260\345\275\225.md"
similarity index 89%
rename from "Android\345\237\272\347\241\200/\351\273\221\345\220\215\345\215\225\346\214\202\346\226\255\347\224\265\350\257\235\345\217\212\345\210\240\351\231\244\347\224\265\350\257\235\350\256\260\345\275\225.md"
rename to "BasicKnowledge/\351\273\221\345\220\215\345\215\225\346\214\202\346\226\255\347\224\265\350\257\235\345\217\212\345\210\240\351\231\244\347\224\265\350\257\235\350\256\260\345\275\225.md"
index b58378d5..b8833836 100644
--- "a/Android\345\237\272\347\241\200/\351\273\221\345\220\215\345\215\225\346\214\202\346\226\255\347\224\265\350\257\235\345\217\212\345\210\240\351\231\244\347\224\265\350\257\235\350\256\260\345\275\225.md"
+++ "b/BasicKnowledge/\351\273\221\345\220\215\345\215\225\346\214\202\346\226\255\347\224\265\350\257\235\345\217\212\345\210\240\351\231\244\347\224\265\350\257\235\350\256\260\345\275\225.md"
@@ -3,8 +3,11 @@
 
 1. 挂断电话     
 	挂断电话需要申请权限`android.permission.CALL_PHONE`
-	对于黑名单号码的来电如何挂断，由于监听来电时在`TelephonyManager`中进行监听的，在`Android1.5`之前，`TelephonyManager`中有一个`endCall()`方法能够直接挂断电话，但是后来谷歌工程师认为这样挂断电话是不安全的，所以就隐藏了这个方法。
-    挂断电话是Android中的一个远程服务，必须要拷贝系统的aidl文件，ITelephony.aidl，在自己的工程中新建一个包（com.android.internal.telephony）然后将ITelephony.aidl放到这个包中，但是发现报错了，原因是还要再考一个aidl文件NeighboringCellInfo.aidl，然后新建一个包(android.telephony)将这个aidl文件放入到这个包中。在程序中怎么使用呢?(这个ITelephony接口通常都是由TelephonyManager使用)
+	对于黑名单号码的来电如何挂断，由于监听来电时在`TelephonyManager`中进行监听的，在`Android1.5`之前，
+	`TelephonyManager`中有一个`endCall()`方法能够直接挂断电话，但是后来谷歌工程师认为这样挂断电话是不安全的，所以就隐藏了这个方法。
+    挂断电话是Android中的一个远程服务，必须要拷贝系统的aidl文件，ITelephony.aidl，在自己的工程中新建一个包(com.android.internal.telephony)
+	然后将ITelephony.aidl放到这个包中，但是发现报错了，原因是还要再考一个aidl文件NeighboringCellInfo.aidl，
+	然后新建一个包(android.telephony)将这个aidl文件放入到这个包中。在程序中怎么使用呢?(这个ITelephony接口通常都是由TelephonyManager使用)
 
     一般都是在电话来电状态监听的时候监听到了响铃状态时就挂断电话，但是仍会在来电记录中有记录
 	```java
diff --git "a/Dagger2/1.Dagger2\347\256\200\344\273\213(\344\270\200).md" "b/Dagger2/1.Dagger2\347\256\200\344\273\213(\344\270\200).md"
new file mode 100644
index 00000000..645e3ff0
--- /dev/null
+++ "b/Dagger2/1.Dagger2\347\256\200\344\273\213(\344\270\200).md"
@@ -0,0 +1,76 @@
+Dagger2简介(一)
+===
+
+[Dagger](https://github.com/google/dagger)
+
+> A fast dependency injector for Android and Java.
+
+`Dagger`是一个依赖注入(`Dependency Injection`,简称`DI`)框架，`butterknife`也是一个依赖注入框架。但是`Dagger2`比`Butterknife`更强大的多，它的主要作用，就是对象的管理，其目的是为了降低程序耦合。
+
+有关注解和`ButterKnife`的解析请看之前的文章:[注解使用](https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E6%B3%A8%E8%A7%A3%E4%BD%BF%E7%94%A8.md)及[ButterKnife源码解析](https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/butterknife%E6%BA%90%E7%A0%81%E8%AF%A6%E8%A7%A3.md)
+
+那么神马是依赖注入，其实我们一直在用:   
+
+- 通过接口注入     
+
+    ```java
+    interface Ib {
+    	void setB(B b)
+    }
+    public class A implements Ib  {
+    	B b;
+    	@override
+    	void setB(B b) {
+    		this.b = b;
+    	}
+    }
+    ```
+
+- 通过`set`方法注入    
+
+    ```java
+	public class ClassA {
+	    ClassB classB;  
+
+	    public void setClassB(ClassB b) {
+	        classB = b;
+	    }
+	}
+    ```
+
+- 通过构造方法注入     
+
+```java
+public class ClassA {
+    ClassB classB;
+    
+    public void ClassA(ClassB b) {
+        classB = b;
+    }
+}
+```
+
+- 通过注解的方式注入
+
+	```java
+	public class ClassA {
+	    //此时并不会完成注入，
+	    //还需要依赖注入框架的支持，如Dagger2
+	    @inject 
+	    ClassB classB;
+	    public ClassA() {}
+	}
+	```
+
+说了这么久，也不知道到底这货有什么用，这里举个例子，比如有个类`A`，他的构造函数需要传入`B,C`；然后代码里有10个地方实例化了`A`，那如果功能更改，`A`的构造函数改成了只有`B`，这个时候，你是不是要去这10个地方一个一个的改？如果是100个地方，你是不是要吐血？！如果采用`dagger2`，这样的需求只需要改1-2个地方。这是真的吗？听起来好像挺牛逼的样子。 
+
+
+也有人怀疑`Dagger2`利用注解是不是采用了反射，会影响性能，这个问题其实在之前的文章[ButterKnife源码解析](https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/butterknife%E6%BA%90%E7%A0%81%E8%AF%A6%E8%A7%A3.md)就已经介绍过了。`Dagger2`、`ButterKnife`这类依赖注入框架都已经采用了`apt`代码自动生成技术，其注解是停留在编译时，可以不用考虑性能的问题。
+
+
+下一篇:[2.Dagger2入门demo(二)](https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/2.Dagger2%E5%85%A5%E9%97%A8demo(%E4%BA%8C).md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Dagger2/2.Dagger2\345\205\245\351\227\250demo(\344\272\214).md" "b/Dagger2/2.Dagger2\345\205\245\351\227\250demo(\344\272\214).md"
new file mode 100644
index 00000000..cd549639
--- /dev/null
+++ "b/Dagger2/2.Dagger2\345\205\245\351\227\250demo(\344\272\214).md"
@@ -0,0 +1,272 @@
+Dagger2入门demo(二)
+===
+
+`Dagger`中使用了很多注解:   
+
+- `@Module`:`Modules`类里面的方法专门提供依赖，所以我们定义一个类，用`@Module`注解，这样`Dagger`在构造类的实例的时候，就知道从哪里去找到需要的 依赖。`modules`的一个重要特征是它们设计为分区并组合在一起（比如说，在我们的`app`中可以有多个组成在一起的`modules`)
+- `@Provide`:在`modules`中，我们定义的方法是用这个注解，以此来告诉`Dagger`我们想要构造对象并提供这些依赖。
+- `@Singleton`:当前提供的对象将是单例模式 ,一般配合`@Provides`一起出现
+- `@Component`:用于接口，这个接口被`Dagger2`用于生成用于模块注入的代码
+- `@Inject`:在需要依赖的地方使用这个注解。（你用它告诉`Dagger`这个构造方法，成员变量或者函数方法需要依赖注入。这样`Dagger`就会构造一个这个类的实例并满足他们的依赖。）
+- `@Scope`:`Scopes`可是非常的有用，`Dagger2`可以通过自定义注解限定注解作用域。
+
+
+这个东西不太好入门，这里就直接用例子上代码了。有关如何添加以来在`github`上面写的很清楚了，`android`在`build.gradle`中进行配置就好了。   
+
+这里就用[dagger官方的coffee的例子说明](https://github.com/google/dagger/tree/master/examples/simple/src/main/java/coffee)
+
+官方`demo`描述的是:一个泵压式咖啡机`(CoffeeMaker)`由两个主要零件组成，泵浦`(Pump)`和加热器`(Heater)`，咖啡机有一个功能是煮泡咖啡`(brew)`，
+当进行煮泡咖啡时，会按如下几个步骤进行:     
+
+- 打开加热器进行加热
+- 泵浦加压
+- 萃取出咖啡
+- 然后关闭加热器
+
+一杯咖啡就算制作完毕了。
+
+好了，那我们先开始写代码了(我把官方的示例代码进行了简化，方便更好的理解):
+
+定义加热器接口:   
+```java
+interface Heater {
+    void on();
+    void off();
+}
+```
+
+具体实现类:   
+```java
+class ElectricHeater implements Heater {
+ 
+    @Override
+    public void on() {
+        System.out.println("~ ~ ~ heating ~ ~ ~");
+    }
+
+    @Override
+    public void off() {
+        
+    }
+}
+```
+
+定义泵浦接口:   
+```java
+interface Pump {
+    void pump();
+}
+```
+
+具体实现类:   
+```java
+class Thermosiphon implements Pump {
+    
+    Thermosiphon() {
+   
+    }
+
+    @Override
+    public void pump() {
+        System.out.println("=> => pumping => =>");
+    }
+}
+```
+
+咖啡机功能:   
+```java
+class CoffeeMaker {
+    private final Heater heater;
+    private final Pump pump;
+
+    CoffeeMaker() {
+        heater = new ElectricHeater();
+        pump = new Thermosiphon();
+    }
+
+    public void brew() {
+        heater.on();
+        pump.pump();
+        System.out.println(" [_]P coffee! [_]P ");
+        heater.off();
+    }
+}
+```
+
+好了完成了，如果执行的话运行结果是:    
+```
+~ ~ ~ heating ~ ~ ~
+=> => pumping => =>
+ [_]P coffee! [_]P 
+```
+
+完美，上面是我们普通的开发方式，那如果我们要用`dagger`来实现该怎么弄呢?    
+
+首先这几个类是没有改动的，因为这几个类中没有牵扯到其他的类:   
+```java
+interface Pump {
+  void pump();
+}
+
+interface Heater {
+  void on();
+  void off();
+}
+
+class ElectricHeater implements Heater {
+
+  @Override 
+  public void on() {
+    System.out.println("~ ~ ~ heating ~ ~ ~");
+  }
+
+  @Override 
+  public void off() {
+    
+  }
+}
+```
+
+下面就开始使用`dagger`需要改动的部分，首先创建`module`类。`@Module`类的命名惯例是以`Module`作为类名称的结尾。而`@Module`类中的`@Provides`方法名称的命名惯例是以`provide`作为前缀。
+而这个`Module`是干什么的呢？`Module`管理所有的以来，这里你做咖啡需要以来泵浦`(Pump)`和加热器`(Heater)`，所以可以创建`Module`把他们`Pump`和`Heater`管理起来，方便
+之后获取`Pump`和`Heater`对象，所以它里面会有`provideXXX()`的函数。   
+
+
+- 第一步:增加`Module`类，使用`@Module`声明类(可以将Module理解成生产对象的工厂，里面提供了`provideXXX`这种生产对象的方法)
+
+```java
+@Module // Module注明该类是Module类
+public class CoffeeModule {
+    @Provides // Provides注明该方法是用来提供依赖对象的方法
+    Heater provideHeater() {
+        return new ElectricHeater();
+    }
+    @Provides
+    Pump providePump() {
+        return new Thermosiphon();
+    }
+}
+```
+
+- 第二步:增加接口`Component`,使用`@Component`声明(`Componet`是将`Module`中生产的对象注入到对应的需要使用该对象的类中)    
+```java
+// 这里是声明要从CoffeeModule中去找对应的依赖，从`CoffeeModule`中去通过`provideXXX`方法来获取对应的对象
+@Component(modules = CoffeeModule.class)
+// 该接口会在编译时自动生成对应的实现类，这里是DaggerCoffeeComponent
+public interface CoffeeComponent {
+    // 提供一个供目标类使用的注入方法,该方法表示要将Module中的管理类注入到哪个类中，这里当然是CoffeeMaker，因为我们要用他俩去生产咖啡
+    void inject(CoffeeMaker maker);
+}
+```
+
+注意:`@Component(modules = {AModule.class,BModule.class})`可以设置多个`Module`，而且也可以`@Component(modules = {MainModule.class}, dependencies = AppConponent.class)`
+指定依赖的`Module`和父`Component`
+
+- 第三步:`Inject`注入
+```java
+import javax.inject.Inject;
+
+class CoffeeMaker {
+    @Inject // 标记该对象是被注入的
+    Heater heater;
+    @Inject
+    Pump pump;
+
+
+    CoffeeMaker() {
+    	// DaggerCoffeeComponent这个类会在编译时产生，所以可以build一下
+        CoffeeComponent component = DaggerCoffeeComponent.create();
+        // 注入
+        component.inject(this);
+
+        // 或者使用下面的代码也是可以的
+        //        DaggerCoffeeComponent.builder()
+		//                .coffeeModule(new CoffeeModule())
+		//                .build()
+		//                .inject(this);
+    }
+
+    public void brew() {
+        heater.on();
+        pump.pump();
+        System.out.println(" [_]P coffee! [_]P ");
+        heater.off();
+    }
+}
+```
+
+到这里就完成了，执行的话，结果是一样的:    
+```
+04-20 15:16:55.083 16375-16375/com.charon.stplayer I/System.out: ~ ~ ~ heating ~ ~ ~
+04-20 15:16:55.084 16375-16375/com.charon.stplayer I/System.out: => => pumping => =>
+     [_]P coffee! [_]P 
+```
+
+到这里你肯定就迷糊了，为什么？ 本来很简单的东西，你还多搞出来几个类，弄的这么麻烦。但是麻烦吗？ 你要是有十个地方呢？ 一百个地方呢？ 以后你修改怎么改？ 一百个地方都改吗？
+
+好了，最后来个总结，高中老师讲的，要来个综上所述: 
+
+- 通过`@Module`声明一个`XXXModule`类，用于管理所有依赖，并使用`@Provides`为每个依赖提供`provideXXX()`方法    
+- 通过`@Component`声明一个`XXXComponent`接口，并且声明要从哪些`Module`中寻找依赖     
+    - 声明要去哪些`Module`中寻找依赖
+        `@Component(modules = CoffeeModule.class)`
+    - 提供一个供目标类使用的注入方法     
+        `void inject(CoffeeMaker maker);`    
+    - 为所有的依赖添加一个方法
+        这个说起来就有点多了，而且我们上面的代码中并没有进行这一步操作，这是因为方法也可以不写，但是如果要写，就按照这个格式来
+        但是当`Component`要被别的`Component`依赖时，这里就必须写这个方法，不写代表不向别的`Component`暴露此依赖，而且如果要写的话
+        这些方法返回值必须是从上面指定的依赖库`CoffeeModule.class`中取得的对象,注意：而方法名不一致也行，但是方便阅读，建议一致，因为它主要是根据返回值类型来找依赖的。
+        这里如果要写的话就是
+        ```java
+		Heater provideHeater();
+		Pump providePump();
+        ```
+- 目标类使用依赖注入,首先是使用`@Inject`声明属性变量，表示注入这个依赖，然后是调用`inject()`方法注入依赖。
+
+
+下面来个图，能够更方便的去理解:   
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/dagger2_liu.png?raw=true)    
+上图中:   
+- `Container`就是可以被注入的容器，具体对应上文例子中的`CoffeeMaker`，`Container`拥有需要被初始化的元素。需要被初始化的元素必须标上`@Inject`，只有被标上`@Inject`的元素才会被自动初始化。`@Inject`在`Dagger2`中一般标记构造方法与成员变量。
+- `Module`可以说就是依赖的原材料的制造工厂，所有需要被注入的元素的实现都是从`Module`生产的。
+- 有了可以被注入的容器`Container`，也有了提供依赖对象的`Module`。我们必须将依赖对象注入到容器中，这个过程由`Component`来执行。`Component`将`Module`中产生的依赖对象自动注入到`Container`中。
+
+好像大体明白了点....
+
+
+上面有`DaggerBaseComponent.create();`和`DaggerBaseComponent.builder().build()`两种方式有什么区别呢？ 我们看一下源码:   
+
+```java
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static BaseComponent create() {
+    return new Builder().build();
+  }
+```
+
+`Dagger2`会自动生成该接口的实现类(以`Dagger`开头，如果`@Component`注解类不是顶级类，自动生成的实现类的名字会闭包命名并用下划线分割如`DaggerFoo_Bar_BazComponent)`，可以通过该实现类的`builder()`方法获得`builder`对象，`builder`对象可以设置好依赖，最后通过`build()`方法构建实例：
+```java
+CoffeeShop coffeeShop = DaggerCoffeeShop.builder()
+    .dripCoffeeModule(new DripCoffeeModule())
+    .build();
+```
+
+如果`Modules`都是缺省构造器，`@Provides`方法都是静态的，用户不需要构建依赖实例，那么自动生成的实现类就会有`create()`方法获取新实例，就不需要处理`builder`了。
+```java
+public class CoffeeApp {
+  public static void main(String[] args) {
+    CoffeeShop coffeeShop = DaggerCoffeeShop.create();
+    coffeeShop.maker().brew();
+  }
+}
+```
+
+下一篇:[3.Dagger2入门demo扩展(三)](https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/3.Dagger2%E5%85%A5%E9%97%A8demo%E6%89%A9%E5%B1%95(%E4%B8%89).md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Dagger2/3.Dagger2\345\205\245\351\227\250demo\346\211\251\345\261\225(\344\270\211).md" "b/Dagger2/3.Dagger2\345\205\245\351\227\250demo\346\211\251\345\261\225(\344\270\211).md"
new file mode 100644
index 00000000..13a7e50a
--- /dev/null
+++ "b/Dagger2/3.Dagger2\345\205\245\351\227\250demo\346\211\251\345\261\225(\344\270\211).md"
@@ -0,0 +1,397 @@
+Dagger2入门demo扩展(三)
+===
+
+上一篇文章中讲了一个入门的例子，感觉虽然不懂内部怎么实现的，好像大体知道要怎么去用了，理解了每部分都是干什么的，既然都讲了例子了，那就继续用
+这个例子讲下如果被依赖的类的构造函数带有参数，我们该怎么去处理？
+
+现在大夏天的我们平时去吧台打咖啡都想来点清凉的，透心凉，心飞扬，那怎么办？这时候我们是不是该提供一个加冰块的功能啊？ 
+
+> 咖啡小姐姐把咖啡豆进行研磨成粉，然后放到咖啡机中，用热水和加压器去从咖啡粉中流过，这样就出来一小杯原酿咖啡了...，然后可以加点牛奶啊，加点糖啊。
+
+好了，既然要加冰块，那就加呗，但是冰块放到哪里？ 咖啡机要有一个放冰块的空间吧？而且还不能让冰块放到这里那么热不融化了吗？ 所以要有个小冰箱啊.
+```java
+public interface Ice {
+	void add();
+}
+
+public interface IceBox {
+	void addIce();
+}
+
+public class NajiIce implements  Ice{
+    public NajiIce() {
+
+    }
+    @Override
+    public void add() {
+        System.out.println("加冰了，心飞扬");
+    }
+}
+
+public class HaierIceBox implements  IceBox {
+    Ice ice;
+    public IceBox(Ice ice) {
+        this.ice = ice;
+    }
+	@Override
+    public void addIce() {
+        ice.add();
+    }
+}
+```
+
+设计完了，那按照我们平时的使用，改造一下`CoffeeMaker`类:   
+```java
+class CoffeeMaker {
+    private final Heater heater;
+    private final Pump pump;
+    private final IceBox iceBox;
+    private Ice ice;
+
+    CoffeeMaker() {
+        heater = new ElectricHeater();
+        pump = new Thermosiphon();
+        ice = new NajiIce()
+        iceBox = new HaierIceBox(ice);
+    }
+
+    public void brew() {
+        heater.on();
+        pump.pump();
+        System.out.println(" [_]P coffee! [_]P ");
+        iceBox.addIce();
+        heater.off();
+    }
+}
+```
+好了，这样就可以了,执行一下:   
+```
+04-20 17:12:01.626 20240-20240/com.charon.stplayer I/System.out: ~ ~ ~ heating ~ ~ ~
+    => => pumping => =>
+     [_]P coffee! [_]P 
+    加冰了，心飞扬
+```
+
+那通过`dagger2`怎么使用呢?我们还要按照上一篇文章的步骤来:    
+
+- 首先来到`CoffeeModule`类中，让他把`Ice`和`IceBox`管理起来，一定要记得引入`Ice`，因为`IceBox`依赖了`Ice`，这是一个依赖链条，要把这个链条上的所有依赖，都管理起来。
+
+```java
+import dagger.Module;
+import dagger.Provides;
+
+@Module
+public class CoffeeModule {
+    @Provides
+    Heater provideHeater() {
+        return new ElectricHeater();
+    }
+    @Provides
+    Pump providePump() {
+        return new Thermosiphon();
+    }
+    @Provides
+    Ice provideIce() {
+        return new NanjiIce();
+    }
+    @Provides
+    IceBox provideIceBox(Ice ice) {
+        return new HaierIceBox(ice);
+    }
+}
+```
+
+- 修改`CoffeeComponent`类，增加`Ice`和`IceBox`对应的方法:   
+```java
+@Component(modules = CoffeeModule.class)
+public interface CoffeeComponent {
+    void inject(CoffeeMaker maker);
+    
+    Heater provideHeater();
+    Pump providePump();
+    Ice provideIce();
+    IceBox provideIceBox(Ice ice);
+}
+```
+
+- 在目标类中增加注入
+```java
+class CoffeeMaker {
+    @Inject
+    Heater heater;
+    @Inject
+    Pump pump;
+    @Inject
+    IceBox iceBox;
+
+    CoffeeMaker() {
+        CoffeeComponent component = DaggerCoffeeComponent.create();
+        component.inject(this);
+    }
+
+    public void brew() {
+        heater.on();
+        pump.pump();
+        System.out.println(" [_]P coffee! [_]P ");
+        iceBox.addIce();
+        heater.off();
+    }
+}
+```
+
+好了，完成了，运行下吧，卧草,崩了!
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/dagger_param_crash_log.png?raw=true" width="100%" height="100%">
+
+写的很明白了，就是`Compnonet`中声明的方法不能带参数。
+好，我们修改一下把`provideIceBox(Ice ice)`的`ice`参数去掉:      
+```java
+@Component(modules = CoffeeModule.class)
+public interface CoffeeComponent {
+    void inject(CoffeeMaker maker);
+
+    Heater provideHeater();
+    Pump providePump();
+    Ice provideIce();
+    IceBox provideIceBox();
+}
+```
+好了，再运行一下:   
+```
+04-20 17:30:07.125 20916-20916/com.charon.stplayer I/System.out: ~ ~ ~ heating ~ ~ ~
+    => => pumping => =>
+     [_]P coffee! [_]P 
+    加冰了，心飞扬
+```
+完美
+
+总结一下:   
+如果被依赖类的构造函数带有参数，要把这个参数的类型也管理起来，而且`Component`接口中的方法不能带参数。    
+
+
+那么问题又来了，前面我们讲的例子都是依赖类只有一个构造函数，直接反射创建就好了，假如我们的依赖类有多个构造函数呢？该如何去选择根据不同的构造函数
+生成对应的对象呢？  
+
+假设我们的咖啡机里又加新功能了，只加冰虽然凉了，但是口感不够丝滑，想再加点牛奶，享受丝滑般的感受。 
+好了新建一个牛奶类:   
+```java
+public class Milk {
+    String type;
+    public Milk() {
+        type = "";
+    }
+
+    public Milk(String shuiguo) {
+        type = shuiguo;
+    }
+
+    public void addMilk() {
+        System.out.println("添加:" + type + "牛奶");
+    }
+}
+```  
+
+接下来要用到一个比较重要的东西就是限定符，用来区分哪个构造函数`new`出来的对象:   
+```java
+@Qualifier//限定符
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Type {
+    String value() default "";//默认值为""
+}
+```
+
+这里插入一句，上面我们是使用`@Qualifier`自定义了一个限定符功能，其实这种返回值相同的情况是比较常见的，`Dagger2`中已经为我们提供了类似的自定义限定符`@Named`，我们可以直接使用`@Named`,
+这里看一下它的实现:    
+```java
+@Qualifier
+@Documented
+@Retention(RUNTIME)
+public @interface Named {
+
+    /** The name. */
+    String value() default "";
+}
+```
+看到了吗？ 和我们上面定义的`Type`注解一模一样。
+
+接下来就是修改`Moudle`类，并且用上面我们创建的限定符`@Type`来区分不同的构造函数`new`出来的对象:   
+```java
+@Module
+public class CoffeeModule {
+    @Provides
+    Heater provideHeater() {
+        return new ElectricHeater();
+    }
+
+    @Provides
+    Pump providePump() {
+        return new Thermosiphon();
+    }
+
+    @Provides
+    Ice provideIce() {
+        return new NanjiIce();
+    }
+
+    @Provides
+    IceBox provideIceBox(Ice ice) {
+        return new HaierIceBox(ice);
+    }
+
+    @Provides
+    @Type("normal")
+    Milk provideNormalMilk() {
+        return new Milk();
+    }
+
+    @Provides
+    @Type("shuiguo") 
+    Milk provideShuiGuoMilk(String shuiguo) {
+        return new Milk(shuiguo);
+    }
+
+    //    由于Milk构造函数里使用了String,所以这里要管理这个String(★否则报错)
+    //    int等基本数据类型是不需要这样做的
+    @Provides
+    public String provideString() {
+        return new String();
+    }
+}
+```
+
+接下来继续修改`Component`类:  
+```java
+@Component(modules = CoffeeModule.class)
+public interface CoffeeComponent {
+    void inject(CoffeeMaker maker);
+
+    Heater provideHeater();
+    Pump providePump();
+    Ice provideIce();
+    IceBox provideIceBox();
+
+    // 添加新提价的方法，注意这里也要用@Type声明，因为是通过@Type的值来去找不同的构造函数创建对象的
+    @Type("normal")
+    Milk provideNormalMilk();
+    @Type("shuiguo")
+    Milk provideShuiGuoMilk();
+    String provideString();
+}
+```
+我们在`CoffeeMaker`里面修改对应的代码:    
+```java
+import javax.inject.Inject;
+
+class CoffeeMaker {
+    @Inject
+    Heater heater;
+    @Inject
+    Pump pump;
+    @Inject
+    IceBox iceBox;
+    @Inject
+    @Type("shuiguo") // 使用@Type来制定对应的构造函数
+    Milk shuiguoMilk;
+
+    CoffeeMaker() {
+        CoffeeComponent component = DaggerCoffeeComponent.create();
+        component.inject(this);
+    }
+
+    public void brew() {
+        heater.on();
+        pump.pump();
+        System.out.println(" [_]P coffee! [_]P ");
+        iceBox.addIce();
+        shuiguoMilk.addMilk();
+        heater.off();
+    }
+}
+```
+执行结果:   
+```java
+04-20 19:07:53.823 23151-23151/? I/System.out: ~ ~ ~ heating ~ ~ ~
+    => => pumping => =>
+     [_]P coffee! [_]P 
+    加冰了，心飞扬
+    添加:牛奶
+```
+
+虽然是可以了，但是问题又来了，我想在创建`Milk(String shuiguo)`时往里面传递参数，例如，我传递个`caomei`。这该如何操作呢？
+其实执行过程是这样的，再去`Module`中执行构造函数时候`Milk(String shuiguo)`，他会发现可以传一个参数，然后他就会在该`Module`中去找返回值是`string`的方法，
+并将该值传递给构造函数的参数中。   
+
+现在，我们重新把上面的`CoffeeModule`修改一下:    
+```java
+@Module
+public class CoffeeModule {
+    @Provides
+    Heater provideHeater() {
+        return new ElectricHeater();
+    }
+
+    @Provides
+    Pump providePump() {
+        return new Thermosiphon();
+    }
+
+    @Provides
+    Ice provideIce() {
+        return new NanjiIce();
+    }
+
+    @Provides
+    IceBox provideIceBox(Ice ice) {
+        return new HaierIceBox(ice);
+    }
+
+    @Provides
+    @Type("normal")
+    Milk provideNormalMilk() {
+        return new Milk();
+    }
+
+    @Provides
+    @Type("shuiguo")
+    Milk provideShuiGuoMilk(String shuiguo) {
+        return new Milk(shuiguo);
+    }
+
+    //    由于Milk构造函数里使用了String,所以这里要管理这个String(★否则报错)
+    //    int等基本数据类型是不需要这样做的
+    @Provides
+    public String provideString() {
+        return "caomei"; // 前面我们写的是new String()，这里改成caomei
+    }
+}
+```
+好了，执行下:    
+```
+04-20 19:28:31.944 23549-23549/? I/System.out: ~ ~ ~ heating ~ ~ ~
+    => => pumping => =>
+     [_]P coffee! [_]P 
+    加冰了，心飞扬
+    添加:caomei牛奶
+```
+
+看，参数加上去了。    
+
+
+
+
+
+下一篇:[4.Dagger2单例(四)](https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/4.Dagger2%E5%8D%95%E4%BE%8B(%E5%9B%9B).md)
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Dagger2/4.Dagger2\345\215\225\344\276\213(\345\233\233).md" "b/Dagger2/4.Dagger2\345\215\225\344\276\213(\345\233\233).md"
new file mode 100644
index 00000000..f1ac1635
--- /dev/null
+++ "b/Dagger2/4.Dagger2\345\215\225\344\276\213(\345\233\233).md"
@@ -0,0 +1,636 @@
+Dagger2单例(四)
+===
+
+我们就继续用前面的例子开始讲了，如果我使用了两个对象:  
+```java
+class CoffeeMaker {
+    @Inject
+    Heater heater;
+    @Inject
+    Heater heater2;
+
+    CoffeeMaker() {
+        CoffeeComponent component = DaggerCoffeeComponent.create();
+        component.inject(this);
+    }
+
+    public void brew() {
+        Log.e("@@@", "heater :" + heater.toString());
+        Log.e("@@@", "heater2 :" + heater2.toString());
+    }
+}
+```
+我们的执行结果是:   
+```
+heater :com.charon.stplayer.test.ElectricHeater@2fea2fd
+heater2 :com.charon.stplayer.test.ElectricHeater@8c2abf2
+```
+很显然这是两个不同的对象。 我现在想让该`Heater`是单例呢？   
+
+- 首先，在`CoffeeModule`里的`provideHeater()`方法前面添加`Singleton`
+```java
+@Module
+public class CoffeeModule {
+    @Singleton
+    @Provides
+    Heater provideHeater() {
+        return new ElectricHeater();
+    }
+
+    ....
+}    
+```
+- 然后再`CoffeeComponent`里的接口上面添加`@Singleton`注释
+```java
+@Singleton
+@Component(modules = CoffeeModule.class)
+public interface CoffeeComponent {
+    void inject(CoffeeMaker maker);
+
+    Heater provideHeater();
+    Pump providePump();
+    Ice provideIce();
+    IceBox provideIceBox();
+    @Type("normal")
+    Milk provideNormalMilk();
+    @Type("shuiguo")
+    Milk provideShuiGuoMilk();
+    String provideString();
+}
+```
+
+注意`Modle`是在方法上面添加`Singleton`，而`Component`是在接口上面添加`Singleton`。   
+好了，再执行以下:     
+```
+heater :com.charon.stplayer.test.ElectricHeater@2fea2fd
+heater2 :com.charon.stplayer.test.ElectricHeater@2fea2fd
+```
+
+看，它是同一个对象了。
+在`Dagger2`里面还有有一个注解`@Scope`也是用来实现单例的，其实它和`Singleton`差不多，`Singleton`是它的实现。用法也基本一样，只是换一个名字。   
+
+可重用的作用域绑定`(Reusable scope)`
+---
+
+如果你想控制`@Inject`构造器类被实例化或`provider`方法被调用的的次数，且不用保证某个`component`或`subcomponent`在生命周期中使用同一个实例，就可以使用`@Reusable`作用域了。`@Reusable`作用域绑定，不像其他作用域绑定一样需要关联一个`component`，它不会关联任何`component`，相反真正要用这个绑定的`component`都会缓存这个返回值或对象实例。 
+这就意味着，如果你用`@Reusable`为`component`指定`module`，且只有一个`subcomponent`会用到这个绑定，那么只有这个`subcomponent`会缓存这个绑定对象。如果两个`subcomponent`祖先没有共享一个绑定，那么每个`subcomponent`会各自缓存自己的对象。如果一个`component`的祖先已经缓存了绑定对象，那么`subcomponent`会重用这个对象。 
+由于无法保证`component`只会调用一次绑定，`@Reusable`绑定可能会返回不确定的对象，这个时候想引用同一个对象是很危险的。所以当你不关心对象会被实例化多少次使用`@Reusable`是安全的。
+```java
+@Reusable // It doesn't matter how many scoopers we use, but don't waste them.
+class CoffeeScooper {
+  @Inject CoffeeScooper() {}
+}
+
+@Module
+class CashRegisterModule {
+  @Provides
+  @Reusable // DON'T DO THIS! You do care which register you put your cash in.
+            // Use a specific scope instead.
+  static CashRegister badIdeaCashRegister() {
+    return new CashRegister();
+  }
+}
+
+@Reusable // DON'T DO THIS! You really do want a new filter each time, so this
+          // should be unscoped.
+class CoffeeFilter {
+  @Inject CoffeeFilter() {}
+}
+```
+
+
+`@Scope`
+---
+
+在`Dagger2`中，可以通过自定义`Scope`来实现局部单例:   
+```java
+@Scope
+@Retention(RetentionPolicy.RUNTIME)
+public @interface HeaterScope {
+}
+```
+
+然后在`Module`中和`Singleton`类似去使用它，来指定它的作用范围:   
+```java
+@Module
+public class CoffeeModule {
+    @HeaterScope
+    @Provides
+    Heater provideHeater() {
+        return new ElectricHeater();
+    }
+    ....
+}    
+```
+然后在`Component`中和`Singleton`类似去使用它，来指定它的作用范围:    
+```java
+@HeaterScope
+@Component(modules = CoffeeModule.class)
+public interface CoffeeComponent {
+    void inject(CoffeeMaker maker);
+
+    Heater provideHeater();
+    Pump providePump();
+    Ice provideIce();
+    IceBox provideIceBox();
+    @Type("normal")
+    Milk provideNormalMilk();
+    @Type("shuiguo")
+    Milk provideShuiGuoMilk();
+    String provideString();
+}
+```
+
+那`@Singleton`和`@Scope`有什么区别呢？ 我们看一下`@Singleton`的源码:    
+```java
+/**
+ * Identifies a type that the injector only instantiates once. Not inherited.
+ *
+ * @see javax.inject.Scope @Scope
+ */
+@Scope
+@Documented
+@Retention(RUNTIME)
+public @interface Singleton {}
+```
+
+查看源码可以发现`@Singleton`是使用注解`@Scope`修饰的, 而`@Scope`是用来声明作用域的,`Dagger2`的机制:在同一作用域下`provides`提供的依赖对象会保持单例, 脱离这一作用域, 单例作用就会失效, 可以说`@Singleton`是`@Scope`注解的一个标准, 我们还可以去自定义一些`Scope`注解来指定具体的作用域，这里就先不介绍了。 
+
+好了，到这里基本讲的差不多了，那我们就开始开发了，为了简单，我们就还是用咖啡的例子，在`Android`开发中，有两个`Activity`，我想在这两个`Activity`中都使用`Heater`对象，我们前面已经把它设置
+成单例了。但是想要在两个`Activity`中都使用，我们首先要修改一下`CoffeeComponent`的`inject`方法。   
+```java
+@Singleton
+@Component(modules = CoffeeModule.class)
+public interface CoffeeComponent {
+    void inject(MainActivity maker);
+    void inject(FirstActivity maker);
+
+    Heater provideHeater();
+    Pump providePump();
+    Ice provideIce();
+    IceBox provideIceBox();
+    @Type("normal")
+    Milk provideNormalMilk();
+    @Type("shuiguo")
+    Milk provideShuiGuoMilk();
+    String provideString();
+}
+```      
+好了接下来分别在`MainActivity`和`FirstActivity`中去使用:     
+```java
+import javax.inject.Inject;
+
+public class MainActivity extends AppCompatActivity {
+    @Inject
+    Heater heater1;
+    @Inject
+    Heater heater2;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        CoffeeComponent component = DaggerCoffeeComponent.create();
+        component.inject(this);
+        Log.e("@@@", "MainActivity heater :" + heater1.toString());
+        Log.e("@@@", "MainActivity heater2 :" + heater2.toString());
+        startActivity(new Intent(MainActivity.this, FirstActivity.class));
+        finish();
+    }
+}
+```
+`FirstActivity`:    
+```java
+public class FirstActivity extends AppCompatActivity {
+    @Inject
+    Heater heater1;
+    @Inject
+    Heater heater2;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        CoffeeComponent component = DaggerCoffeeComponent.create();
+        component.inject(this);
+
+        Log.e("@@@", "FirstActivity heater :" + heater1.toString());
+        Log.e("@@@", "FirstActivity heater2 :" + heater2.toString());
+    }
+}
+```
+
+走你 ~
+
+```
+04-21 11:57:31.514 12146-12146/com.charon.daggerdemo E/@@@: MainActivity heater :com.charon.daggerdemo.test.ElectricHeater@91bece5
+    MainActivity heater2 :com.charon.daggerdemo.test.ElectricHeater@91bece5
+04-21 11:57:31.734 12146-12146/com.charon.daggerdemo E/@@@: FirstActivity heater :com.charon.daggerdemo.test.ElectricHeater@765de0d
+    FirstActivity heater2 :com.charon.daggerdemo.test.ElectricHeater@765de0d
+```
+
+我屮艸芔茻!!!每个`Activity`中的对象确实是一样的，但是两个不同的`Activity`中是不一样的。单例个锤子啊单例。这也是单例，只不过是局部单例。
+使用`@Singeton`注解或者定制的`@Scope`的, 只在同一个`activity`或者`fragment`的一个生命周期中保持单例. 而平时我们希望一些对象能够在整个应用的生命周期中只存在一个, 也就是说实现全局意义上真正的单例该怎么做呢?       
+
+上面的`DaggerCoffeeComponent`在两个`Activity`中被各自被实例化一次, 导致产生了两个不同的对象, 所以我们需要做到让`DaggerCoffeeComponent`能够实现单例，在不同的`Activity`都是同一个对象，这样就可以保证全局单例了,`Android`中整个`App`生命周期中都只有一个`Appclication`实例,所以可以在`Application`中获得一个唯一的`Component`实例:    
+
+主要分为以下基本部分:   
+
+- 创建一个`BaseModule`，并且创建单例的`provideHeater`方法
+
+	```java
+	@Module
+	public class BaseModule {
+	    @Singleton
+	    @Provides
+	    public Heater provideHeater() {
+	        return new ElectricHeater();
+	    }
+	}
+	```
+
+- 接下来就是创建`BaseComponent`类，并且要将该接口声明单例 
+
+	```java
+	@Singleton
+	@Component(modules = BaseModule.class)
+	public interface BaseComponent {
+        // 之前我们说过Component中的provideXXX是可以不写的，但是如果你想让别的Component依赖该Component，就必须写，不写的话意味着没有向外界暴露该依赖
+	    Heater provideHeater();
+	}
+	```
+    到这里，可能就会有疑问了，你忘了写`inject`方法了。这里`BaseComponent`是不需要写`inject`方法的，因为他没有要注入的类，我们下面会有具体的`Component`类来写`inject`，方法。这是`base`就不需要了       
+    注意:`BaseComponent`中不再需要写`inject`方法, 因为这个`component`是用来让别的`component`来依赖的, 只需要告诉别的`component`他可以提供哪些类型的依赖即可, 这个例子中 我们提供一个全局`Heater`的依赖
+
+- 接下类是定义具体依赖于`BaseComponent`的子`Component`,之前我们写`Component`都是用`@Component(modules = BaseModule.class)`来指定具体要去查找类的`Module`，但是这里不一样了，
+这里该`Component`是依赖于`BaseComponent`，所以这里要使用`dependencies`关键字了。  
+
+	```java
+	@Singleton
+	@Component(dependencies = BaseComponent.class)
+	public interface HeaterComponent {
+        // 因为这里HeaterComponent依赖了BaseComponent，所以这里就有proviceHetear方法
+	    void inject(MainActivity maker);
+	    void inject(FirstActivity maker);
+	}
+	```
+
+	好了，这里我们重新`build`一次，如果没有意外的话，就会生成`DaggerHeaterComponent`类了，我们去使用它就可以了。    
+	但是，但是，出意外了.....
+	```
+	错误: This @Singleton component cannot depend on scoped components:
+    @Singleton com.charon.daggerdemo.test.BaseComponent
+	```
+	答题意思是说，使用`@Singleton`修饰的`component`不能依赖另一个局部的`component`，也就是`@Singleton com.charon.daggerdemo.test.BaseComponent`。
+	也就是说如果依赖的`component`中也使用了`@singleton`时, 被依赖的地方就不能再使用`@Singleton`了。   
+	`BaseComponent`我明明是
+	用了`@Singleton`，而这个错误信息却说是一个`scoped component`，这是什么鬼？ 这个其实前面我们也说过了,这里再看一下`@Singleton`的源码:     
+	```java
+	@Scope
+	@Documented
+	@Retention(RUNTIME)
+	public @interface Singleton {}
+	```
+
+    那这里不能用`@Singleton`该怎么处理呢？ 这里要用到自定义`@Scope`了。   
+    自定义一个`ActivityScope`:   
+    ```java
+	@Scope
+	@Retention(RetentionPolicy.RUNTIME)
+	public @interface ActivityScope {
+	}
+    ```
+
+    然后修改我们上面的`HeaterComponent`类，把之前使用的`@Singleton`修改成我们刚才自定义的`@ActivityScope`:    
+    ```java
+	@ActivityScope
+	@Component(dependencies = BaseComponent.class)
+	public interface HeaterComponent {
+	    void inject(MainActivity maker);
+	    void inject(FirstActivity maker);
+	}
+    ```
+
+    好了，再`build`一下，
+
+- 自定义`Application`
+
+```java
+public class BaseApplication extends Application {
+    private static BaseApplication mApplication;
+    private BaseComponent baseComponent;
+    public static BaseApplication getInstance() {
+        return mApplication;
+    }
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        mApplication = this;
+        // 下面这两种方式都是可以的
+//        baseComponent = DaggerBaseComponent.create();
+        baseComponent = DaggerBaseComponent.builder().baseModule(new BaseModule()).build();
+    }
+
+    public BaseComponent getBaseComponent() {
+        return baseComponent;
+    }
+}
+```    
+
+- 好了，去`MainActivity`和`FirstActivity`中修改下:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/dagger_depend_create.png?raw=true)    
+和前面一样，直接调用`DaggerHeaterComponent`你会发现没有`create`方法了，只有一个`builder`方法，这种依赖的方式，必须要使用`buildrer`来进行。   
+```java
+public class MainActivity extends AppCompatActivity {
+    @Inject
+    Heater heater1;
+    @Inject
+    Heater heater2;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        // .baseComponent就是将Application中的BAseComponent传递到子component中，而在application中一创建就调用了DaggerBaseComponent.builder().build();
+        HeaterComponent component = DaggerHeaterComponent.builder().baseComponent(
+                BaseApplication.getInstance().getBaseComponent()).build();
+        component.inject(this);
+        Log.e("@@@", "MainActivity heater :" + heater1.toString());
+        Log.e("@@@", "MainActivity heater2 :" + heater2.toString());
+        startActivity(new Intent(MainActivity.this, FirstActivity.class));
+        finish();
+    }
+}
+```
+```java
+public class FirstActivity extends AppCompatActivity {
+    @Inject
+    Heater heater1;
+    @Inject
+    Heater heater2;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        HeaterComponent component = DaggerHeaterComponent.builder().baseComponent(
+                BaseApplication.getInstance().getBaseComponent()).build();
+        component.inject(this);
+
+        Log.e("@@@", "FirstActivity heater :" + heater1.toString());
+        Log.e("@@@", "FirstActivity heater2 :" + heater2.toString());
+    }
+}
+```
+
+运行下:   
+```
+04-21 13:28:46.944 15130-15130/com.charon.daggerdemo E/@@@: MainActivity heater :com.charon.daggerdemo.test.ElectricHeater@91bece5
+    MainActivity heater2 :com.charon.daggerdemo.test.ElectricHeater@91bece5
+04-21 13:28:47.024 15130-15130/com.charon.daggerdemo E/@@@: FirstActivity heater :com.charon.daggerdemo.test.ElectricHeater@91bece5
+    FirstActivity heater2 :com.charon.daggerdemo.test.ElectricHeater@91bece5
+```
+
+看，现在是全局单例了
+
+
+上面讲到了`Component`依赖，这里仔细讲讲，在上面的例子`Activity`中:  
+
+```java
+// .baseComponent就是将Application中的BAseComponent传递到子component中，而在application中一创建就调用了DaggerBaseComponent.builder().build();
+HeaterComponent component = DaggerHeaterComponent.builder().baseComponent(
+        BaseApplication.getInstance().getBaseComponent()).build();
+component.inject(this);
+```
+
+这里因为`baseComponent`的生命周期比较特殊，需要和`Application`绑定，所以`BaseComponent`的`build`工作放到`Application`中了。如果对于普通的`component`依赖
+这里其实是两部分，假设目前我们有这种情况，已经有了一个`A`:   
+```java
+public class A {
+    public A() {
+        Log.e("@@@", "crate a");
+    }
+}
+
+@Module
+public class AModule {
+    @Provides
+    public A proviceA() {
+        return new A();
+    }
+}
+
+@Component(modules = AModule.class)
+public interface AComponent {
+    A proviceA();
+    void inject(FirstActivity activity);
+}
+
+```
+
+同样还有`B`:  
+
+```java
+public class B {
+    public B() {
+        Log.e("@@@", "crate b");
+    }
+}
+
+@Module
+public class BModule {
+    @Provides
+    public B proviceB() {
+        return new B();
+    }
+}
+
+@Component(modules = BModule.class)
+public interface BComponent {
+    B proviceB();
+    void inject(MainActivity activity);
+}
+```
+
+我们在`MainActivity`中去注入`B`:    
+```java
+public class MainActivity extends AppCompatActivity {
+    @Inject
+    B b;
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        BComponent bComponent = DaggerBComponent.create();
+        bComponent.inject(this);
+    }
+}
+```
+
+执行结果:   
+```
+04-21 18:45:38.494 18851-18851/com.charon.daggerdemo E/@@@: crate b
+```
+
+现在我想在`B`中注入`A`怎么办？我想也去用`A`，但是`A`已经有了，我不至于要重新再去写一遍:   
+```java
+@Component(modules = BModule.class, dependencies = AComponent.class) // 只需要在这里把AComponent引入，其他不用动
+public interface BComponent {
+    B proviceB();
+    void inject(MainActivity activity);
+}
+```
+
+到这里，我们的`BComponent`继承了`AComponent`，它也有了`AComponent`中的方法:   
+```java
+public class MainActivity extends AppCompatActivity {
+    @Inject
+    B b;
+    @Inject
+    A a;
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        // 注意要先build获取AComponent
+        AComponent aComponent = DaggerAComponent.builder().aModule(new AModule()).build();
+        // 要通过aComponent()方法将AComponent设置到BComponent中
+        BComponent bComponent = DaggerBComponent.builder().bModule(new BModule()).aComponent(aComponent).build();
+        bComponent.inject(this);
+    }
+}
+```
+
+执行结果:   
+```
+04-21 19:04:59.209 20445-20445/? E/@@@: crate b
+04-21 19:04:59.210 20445-20445/? E/@@@: crate a
+```
+
+
+
+可释放的引用(Releasable references)
+---
+
+如果一个绑定使用`scope`注解，这就意味着`component`对象会持有这个作用域对象的引用直到`component`自己被`GC`回收。在像`Android`这样的内存敏感环境中，如果你想在内存紧张时让`GC`回收当前未使用的作用域对象，只需要使用`@CanReleaseReferences`定义一个`scope`即可：
+```java
+@Documented
+@Retention(RUNTIME)
+@CanReleaseReferences
+@Scope
+public @interface MyScope {}
+```
+可以为`scope`注入一个`ReleasableReferenceManager`对象，在内存紧张时调用它的`releaseStrongReferences()`方法以便让`component`持有该对象的弱引用而不是强引用。
+```java
+@Inject @ForReleasableReferences(MyScope.class)
+ReleasableReferences myScopeReferences;
+
+void lowMemory() {
+  myScopeReferences.releaseStrongReferences();
+}
+```
+当内存压力减少时可以调用`restoreStrongReferences()`方法恢复缓存对象的强引用。
+```java
+void highMemory() {
+  myScopeReferences.restoreStrongReferences();
+}
+```
+
+
+如果一个`Component`的功能不能满足你的需求，你需要对它进行拓展，这里有两种方式:
+
+- 使用`@Component(dependencies=××.classs)`
+- 使用`@Subcomponent`
+
+`@SubComponent`
+---
+
+`Subcomponent`用于拓展原有`component`。同时这将产生一种副作用——子`component`同时具备两种不同生命周期的`scope`。子`Component`具备了父`Component`拥有的`Scope`，也具备了自己的`Scope`。
+
+`Subcomponent`其功能效果优点类似`component`的`dependencies`。但是使用`@Subcomponent`不需要在父`component`中显式添加子`component`需要用到的对象，只需要添加返回子`Component`的方法即可，子`Component`能自动在父`Component`中查找缺失的依赖。
+
+
+我们还是用上面`A`和`B`的例子，假设`A`是父类:   
+
+- 首先，修改`AComponent`类，在里面提供`BComponent`
+```java
+//@Singleton
+@Component(modules = AModule.class)
+public interface AComponent {
+    // 一定要在A中提供获取BComponent的方法
+    BComponent bcomponent();
+    A provideA();
+    void inject(FirstActivity activity);
+}
+```
+
+- 其次，修改`BComponent`，将其修改成`SubComponent`的方式,并且去掉前面的`dependencies`
+```java
+//@ActivityScope  // 如果有的话只能比父类的范文小
+@Subcomponent(modules = BModule.class) 
+public interface BComponent {
+    B provideB();
+    void inject(MainActivity activity);
+}
+```
+
+- 使用    
+
+```java
+public class MainActivity extends AppCompatActivity {
+    @Inject
+    B b;
+    @Inject
+    A a;
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        AComponent aComponent = DaggerAComponent.builder().aModule(new AModule()).build();
+        // 通过AComponent里面的方法去拿BComponent，然后调用inject
+        aComponent.bcomponent().inject(this);
+//        BComponent bComponent = DaggerBComponent.builder().bModule(new BModule()).aComponent(aComponent).build();
+//        bComponent.inject(this);
+    }
+}
+```
+
+对比中我们发现`dependencies`中`Component`强调的是在子类`Component`依赖于某个`Component`（子类为主角），而`Subcomponent`中强调的则是在父类`Component`中提供某个子类的`Component`（父类为主角）。
+
+但是这两种到底有什么区别呢？
+
+`Component.dependiences`方式
+---
+
+
+- 可以很清晰的看到具体的依赖关系
+- 会生成独立的`DaggerXXXXComponent`类
+- 依赖`Component`仅继承被依赖`Component`中显示提供的依赖，如果不提供，则无法使用`@Inject`注入被依赖的`Component`中的对象
+
+
+`SubComponent`方式
+---
+
+
+- 不需要在被依赖的`Component`显示提供依赖
+- 不需要使用更多的`DaggerXXXXComponent`对象来创建依赖，仅需要在被依赖`Component`中增加获取`XXXComponent`的方法
+- 但是会依赖不明确，不容易明确的看到具体的依赖关系
+- 多人开发，被依赖`Component`容易造成冲突
+- 务必在被依赖`Component`中创建`XXXComponent`的获取方法，并在被依赖`Component`的`DaggerXXXComponent`的实例化对象中调用该方法
+
+
+最后总结一下几个注解:     
+
+- `@Module`: 修饰类，用来提供依赖，里面会提供具体生成依赖类对象的方法，供使用者通过
+- `@Provides`:用于注解被`@Module`修饰的类中的方法, 当需要该类的依赖时会去找返回值为该类的方法
+- `@Component`:注解一个接口或者抽象类,为`inject`和`module`之间建立联系，可以理解为不赚差价的中间商，在编译时会产生对应的类的实例, 为依赖方和被依赖方提供桥梁,把相关的依赖注入到其中.
+- `@inject`:依赖注入类中的依赖变量声明,让`Dagger2`为其提供依赖或者用在被依赖的类的构造方法上申明, 通过标记构造函数让`Dagger2`来使用, 可以在需要这个类实例的时候来找到这个构造函数并把相关实例`new`出来
+- `@Named`:用于区分我们获取依赖的方法
+`Dagger2`寻找依赖是根据我们提供方法的返回值进行匹配的, 当我们遇到不同提供依赖的方法但是返回值类型是相同的应该怎么办呢?`Dagger2`提供了`Named`注解,用于区分相同返回值类型的不同方法.
+- `@Qualifier`:与`Named`一致,`Named`是继承`Qulifier`的,相当于`Dagger2`为我们提供的标准化的区分器,
+- `Singleton`:声明单例模式,`Dagger2`的机制是需要某个对象是回去找对应提供的实例化方法,多次寻找就会创建多个对象,当我们需要让对象保持单例模式时, 要使用`@Singleton`修饰提供依赖的方法
+- `@Scope`:查看源码可以发现`@Singleton`是使用注解`@Scope`修饰的,而`@Scope`是用来声明作用域的,`Dagger2`的机制:在同一作用域下,`provides`提供的依赖对象会保持单例,脱离这一作用域, 单例作用就会失效,可以说`@Singleton`是`@Scope`注解的一个标准,我们还可以去自定义一些`Scope`注解.
+
+
+下一篇:[Dagger2Lay和Provider(五)](https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/5.Dagger2Lay%E5%92%8CProvider(%E4%BA%94).md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Dagger2/5.Dagger2Lay\345\222\214Provider(\344\272\224).md" "b/Dagger2/5.Dagger2Lay\345\222\214Provider(\344\272\224).md"
new file mode 100644
index 00000000..434f6f76
--- /dev/null
+++ "b/Dagger2/5.Dagger2Lay\345\222\214Provider(\344\272\224).md"
@@ -0,0 +1,268 @@
+Dagger2Lay和Provider(五)
+===
+
+
+`Lazy<>(延迟加载)`和`Provider<>`(强制重新加载)
+---
+
+我们再回到之前的例子，现在我们把前面使用单例的部分都去掉，再来继续讲其他的部分。在上面的`CoffeeModule`中，把每个`provideXXX()`都添加一句`log`:   
+```java
+@Module
+public class CoffeeModule {
+    @Provides
+    Heater provideHeater() {
+        System.out.println("provide heater");
+        return new ElectricHeater();
+    }
+
+    @Provides
+    Pump providePump() {
+        System.out.println("provide pump");
+        return new Thermosiphon();
+    }
+
+    @Provides
+    Ice provideIce() {
+        System.out.println("provide ice");
+        return new NanjiIce();
+    }
+
+    @Provides
+    IceBox provideIceBox(Ice ice) {
+        System.out.println("provide ice box");
+        return new HaierIceBox(ice);
+    }
+    ...
+}
+```
+
+然后我们在`CoffeeMaker`中，只调用`Component`的`inject`方法，但是不去使用该对象:   
+```java
+class CoffeeMaker {
+    @Inject
+    Heater heater;
+    @Inject
+    Lazy<Pumb> pump; // 使用lazy
+    @Inject
+    Provider<IceBox> iceBox; // 使用provider
+    @Inject
+    @Type("shuiguo")
+    Milk shuiguoMilk;
+
+    CoffeeMaker() {
+        CoffeeComponent component = DaggerCoffeeComponent.create();
+        component.inject(this);
+    }
+
+    public void brew() {
+//        heater.on();
+//        pump.pump();
+        System.out.println(" [_]P coffee! [_]P ");
+//        iceBox.addIce();
+//        shuiguoMilk.addMilk();
+//        heater.off();
+    }
+}
+```
+
+执行结果:   
+```
+04-21 15:03:11.684 17811-17811/com.charon.stplayer I/System.out: provide heater
+04-21 15:03:11.694 17811-17811/com.charon.stplayer I/System.out:  [_]P coffee! [_]P 
+```
+可以看到普通注入只要声明就会被初始化,而使用`Provider`和`Lazy`包装的并没有进行初始化, 接下来我们分别对这些不同对象调用两次:   
+```java
+class CoffeeMaker {
+    @Inject
+    Heater heater;
+    @Inject
+    Lazy<Pump> pump;
+    @Inject
+    Provider<IceBox> iceBox;
+    @Inject
+    @Type("shuiguo")
+    Milk shuiguoMilk;
+
+    CoffeeMaker() {
+        CoffeeComponent component = DaggerCoffeeComponent.create();
+        component.inject(this);
+    }
+
+    public void brew() {
+        heater.on();
+        System.out.println(" heater on ");
+        heater.on();
+        System.out.println(" heater on ");
+        pump.get().pump();
+        System.out.println(" pump pump ");
+        pump.get().pump();
+        System.out.println(" pump pump ");
+        System.out.println(" [_]P coffee! [_]P ");
+        iceBox.get().addIce();
+        System.out.println(" iceBox addIce ");
+        iceBox.get().addIce();
+        System.out.println(" iceBox addIce ");
+        shuiguoMilk.addMilk();
+        heater.off();
+    }
+}
+```
+
+执行结果:    
+```
+provide heater   // 一共执行了一次provide heater
+~ ~ ~ heating ~ ~ ~
+ heater on 
+~ ~ ~ heating ~ ~ ~
+ heater on 
+provide pump     // 一共执行了一次provide pump
+=> => pumping => =>
+ pump pump 
+=> => pumping => =>
+ pump pump 
+ [_]P coffee! [_]P 
+provide ice         // 执行了第一次provide ice 和 provide icebox
+provide ice box
+加冰了，心飞扬
+ iceBox addIce      // 调用了第一次iceBox.addIce方法
+provide ice         // 执行了第二次provide ice 和 provide icebox
+provide ice box
+加冰了，心飞扬
+ iceBox addIce      // 调用了第二次iceBox.addIce方法
+添加:caomei牛奶
+
+```
+
+可以看到使用`Provider`包装的类,每次调用都会重新获取新的实例,而使用普通注入和使用`Lazy`包装都使用的是用一个实例。   
+
+当然，如果限定局部单例之后,无论是`Provider`还是`Lazy`,在同一个`Activity`中只会获取同一个依赖对象.
+
+
+关于`Dagger`的部分基本都讲完了，后面就是讲`Dagger`和`Android`的结合了。这里总结一下`Dagger`的依赖注入规则是:     
+
+- 1.查找`Module`中是否存在创建该类的方法。
+- 2.若存在创建类方法，查看该方法是否存在参数
+    - 2.1若存在参数，则按从步骤1开始依次初始化每个参数
+    - 2.2若不存在参数，则直接初始化该类实例，一次依赖注入到此结束
+- 3若不存在创建类方法，则查找`Inject`注解的构造函数，看构造函数是否存在参数
+    - 3.1若存在参数，则从步骤1开始依次初始化每个参数
+    - 3.2若不存在参数，则直接初始化该类实例，一次依赖注入到此结束
+
+依赖对象的注入源应该是有两个，一是Module中的@Provides方法，而是使用@Inject注解的构造函数。从前面示例中可以看出，如果使用@Scope注解类同时使用@Inject注解构造函数时，第一次创建时调用构造函数，然后将创建的实例缓存。以后再依赖注入时，不再调用构造函数创建，而是取缓存中的实例。根据Dagger的依赖注入规则，Module中的@Provides方法的优先级高于@Inject,那么使用@Scopre使用注解@Provides方法会产生什么样的效果呢？
+
+
+可选的绑定`(Optional bindings)`
+---
+
+如果你想某个绑定在`component`的某些依赖不满足的情况下也能工作，可以给`Module`添加一个`@BindsOptionalOf`方法:    
+```java
+@BindsOptionalOf abstract CoffeeCozy optionalCozy();
+```
+这就意味着`@Inject`构造器和成员和`@Provides`方法可以依赖一个`Optional<CoffeeCozy>`对象，如果`component`绑定了`CoffeeCozy`那么`Optional`就是当前的，否则`Optional`就是缺省的。你可以注入一下几种类型:   
+```java
+Optional<CoffeeCozy>
+Optional<Provider<CoffeeCozy>>
+Optional<Lazy<CoffeeCozy>>
+Optional<Provider<Lazy<CoffeeCozy>>>
+```
+
+
+
+绑定实例`(Binding Instances)`
+---
+
+如果你想在绑定`component`时注入参数，如`app`需要一个用户名参数，就可以给`component`的`builder`方法添加一个`[@BindsInstance][BindsInstance]`方法注解以使用户名字符串实例可以被注入到`component`中:     
+```java
+@Component(modules = AppModule.class)
+interface AppComponent {
+  App app();
+
+  @Component.Builder
+  interface Builder {
+    @BindsInstance Builder userName(@UserName String userName);
+    AppComponent build();
+  }
+}
+
+public static void main(String[] args) {
+  if (args.length > 1) { exit(1); }
+  App app = DaggerAppComponent
+      .builder()
+      .userName(args[0])
+      .build()
+      .app();
+  app.run();
+}
+```
+
+编译时验证`(Compile-time Validation)`
+---
+
+`Dagger2`注解处理器是严格模式的，如果所有的绑定无效或者不完整就会导致编译时错误。例如这个`module`被安装到`component`，但是忘了绑定`Executor`:   
+```java
+@Module
+class DripCoffeeModule {
+  @Provides static Heater provideHeater(Executor executor) {
+    return new CpuHeater(executor);
+  }
+}
+```
+那么当编译时，javac就会拒绝这个错误的绑定:   
+```
+[ERROR] COMPILATION ERROR :
+[ERROR] error: java.util.concurrent.Executor cannot be provided without an @Provides-annotated method.
+```
+
+只需要在当前`component`的任一`Module`中新增一个`Executor`的`@Provides`方法即可修复这个错误。
+
+
+
+
+`@Binds`与`@Provides`
+---
+
+相信大家经常会使用`@Provides`来在`Module`里面提供需要注入对象的构造, 但从来没有用过`@Binds`.
+
+如果我们需要注入一个接口的实现,我们常常会这么做:    
+```java
+@Module
+public class HomeModule {
+
+  @Provides
+  public HomePresenter providesHomePresenter(){
+    return new HomePresenterImp();
+  }
+}
+```
+其实这样的代码可以通过`@Binds`简化为:    
+```java
+@Module
+public abstract class HomeModule {
+
+  @Binds
+  public abstract HomePresenter bindHomePresenter(HomePresenterImp homePresenterImp);
+}
+```
+同时你需要将你的`Module`改为`abstract`即可,但是要注意这两个不能共存于一个`Module`,是不是很简单.
+
+
+
+
+
+
+
+
+下一篇:[Dagger2Android示例代码(六)](https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/6.Dagger2Android%E7%A4%BA%E4%BE%8B%E4%BB%A3%E7%A0%81(%E5%85%AD).md)
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Dagger2/6.Dagger2Android\347\244\272\344\276\213\344\273\243\347\240\201(\345\205\255).md" "b/Dagger2/6.Dagger2Android\347\244\272\344\276\213\344\273\243\347\240\201(\345\205\255).md"
new file mode 100644
index 00000000..eef7fcf1
--- /dev/null
+++ "b/Dagger2/6.Dagger2Android\347\244\272\344\276\213\344\273\243\347\240\201(\345\205\255).md"
@@ -0,0 +1,142 @@
+Dagger2Android示例代码
+===
+
+经过前面的几个部分，基本把`Dagger2`讲完了，都是通过简单的示例的代码。那这里我们就用开发中具体的部分来进行示例，
+这里示例主要是有两个小问题，第一个就是前面我们从例子开始讲的试试直降了`@Inject`在变量上的使用，没有将去实际的用构造函数使用`@Inject`来讲解。
+还有一个就是`Component`在使用`inject`的时候也有两种方式:`create()`和`builder.build()`，前面虽然我们把源码看了，但是没有具体去说，虽然`create`方法内部就是调用`new Builder().build()`，但是他俩还是有一点区别的。  
+
+我们平时开发中经常会用到`TabLayout`和`ViewPager`结合使用切换不同`Fragment`的地方，这里就用这个例子来:   
+```xml
+<LinearLayout 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"
+    android:orientation="vertical">
+
+    <android.support.design.widget.TabLayout
+        android:id="@+id/tab"
+        android:layout_width="match_parent"
+        android:layout_height="48dp"
+        app:tabMode="scrollable" />
+
+    <android.support.v4.view.ViewPager
+        android:id="@+id/vp"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+</LinearLayout>
+```
+
+首先将`Fragment`写好:   
+```java
+public class TitleFragment extends Fragment {
+    private static final String TITLE_KEY = "title";
+
+    public static TitleFragment getInstance(String title) {
+        TitleFragment fragment = new TitleFragment();
+        Bundle args = new Bundle();
+        args.putString(TITLE_KEY, title);
+        fragment.setArguments(args);
+        return fragment;
+    }
+
+    TextView tv;
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_main, container, false);
+        tv = view.findViewById(R.id.tv_text);
+        tv.setText(getArguments().getString(TITLE_KEY));
+        return view;
+    }
+}
+```
+
+- 声明`Module`
+
+而在`Adapter`的构造函数中需要三个参数`FragmentManager`、`List<String>`、`List<Fragment`，而`FragmentManager`通常是我们在`AppCompatActivity`中通过
+`getSupportFragmentManager()`得到的。所以首先我们要去声明`Module`方法，并且提供三个`Provide`方法:   
+
+```java
+import dagger.Module;
+import dagger.Provides;
+
+@Module
+public class MainModule {
+    AppCompatActivity appCompatActivity;
+
+    public MainModule(AppCompatActivity appCompatActivity) {
+        this.appCompatActivity = appCompatActivity;
+    }
+
+    @Provides
+    FragmentManager provideFragmentManager() {
+        return appCompatActivity.getSupportFragmentManager();
+    }
+
+    @Provides
+    List<String> providesTitles() {
+        List<String> list = new ArrayList<>();
+        for (int i = 0; i < 4; i++) {
+            list.add("Page Title : " + i);
+        }
+        return list;
+    }
+
+    @Provides
+    List<Fragment> providesFragmentList(List<String> titles) {
+        List<Fragment> fragments = new ArrayList<>();
+        for (String title : titles) {
+            fragments.add(TitleFragment.getInstance(title));
+        }
+        return fragments;
+    }
+}
+```
+
+- 声明`Component`，关联`Module`，并关联注入类
+
+```java
+@Component(modules = MainModule.class)
+public interface MainComponent {
+    void inject(MainActivity activity);
+}
+```
+
+- 注入类通过`@Inject`使用    
+
+```java
+public class MainActivity extends AppCompatActivity {
+    private ViewPager viewPager;
+    private TabLayout tabLayout;
+    @Inject
+    MainAdapter adapter;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+        tabLayout = findViewById(R.id.tab);
+        viewPager = findViewById(R.id.vp);
+        // 向下面这种Module种带有参数的就没有DaggerMainComponent.create()方法了，只能用这种builder
+        DaggerMainComponent.builder().
+                mainModule(new MainModule(this)).
+                build().
+                inject(this);
+        viewPager.setAdapter(adapter);
+        tabLayout.setupWithViewPager(viewPager);
+    }
+}
+```
+
+好了，运行下:   
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/dagger_android-demo.jpg?raw=true" width="100%" height="100%">
+
+下一篇:[Dagger2之dagger-android(七)](https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/7.Dagger2%E4%B9%8Bdagger-android(%E4%B8%83).md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Dagger2/7.Dagger2\344\271\213dagger-android(\344\270\203).md" "b/Dagger2/7.Dagger2\344\271\213dagger-android(\344\270\203).md"
new file mode 100644
index 00000000..412726f8
--- /dev/null
+++ "b/Dagger2/7.Dagger2\344\271\213dagger-android(\344\270\203).md"
@@ -0,0 +1,443 @@
+Dagger2之dagger-android(七)
+===
+
+```
+> Android Gradle
+> // Add Dagger dependencies
+> dependencies {
+>   compile 'com.google.dagger:dagger:2.x'
+>   annotationProcessor 'com.google.dagger:dagger-compiler:2.x'
+> }
+> If you're using classes in dagger.android you'll also want to include:
+
+> compile 'com.google.dagger:dagger-android:2.x'
+> compile 'com.google.dagger:dagger-android-support:2.x' // if you use the support libraries
+> annotationProcessor 'com.google.dagger:dagger-android-processor:2.x'
+```
+
+在`Dagger2`的官网上说如果你要使用`dagger.android`里面的东西，就需要添加`dagger-android`相关的依赖。那这里面都提供了些什么呢？   
+
+
+`Android`应用使用`Dagger`最主要的困难就是一些`Framework`类(如`Activity`、`Fragment`)是由操作系统实例化的，而`Dagger`更好工作的前提是它可以构建所有的注入对象。所以，你只能(不得不)在生命周期方法中进行成员变量注入，这就意味着一些类可能会写成这个样子:     
+```java
+public class FrombulationActivity extends Activity {
+  @Inject Frombulator frombulator;
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    // DO THIS FIRST. Otherwise frombulator might be null!
+    ((SomeApplicationBaseType) getContext().getApplicationContext())
+        .getApplicationComponent()
+        .newActivityComponentBuilder()
+        .activity(this)
+        .build()
+        .inject(this);
+    // ... now you can write the exciting code
+  }
+}
+```
+
+这样的确可以实现`Android`的依赖注入，但还有两个问题需要我们去面对:   
+
+- 类似的复制性的代码以后会很难维护。而且随着越来越多的开发者去复制粘贴这些代码，很少会有人知道它的作用。
+- 更重要的是，它要求注射类型`（FrombulationActivity）`知道其注射器。 即使这是通过接口而不是具体类型完成的，它打破了依赖注入的核心原则：一个类不应该知道如何实现依赖注入。
+
+
+于是`dagger.android`诞生了...`dagger.android`中的类提供了一种简洁化的实现方式。   
+
+
+注入`Activity`对象
+---
+
+- 1.在应用的`ApplicationComponent`中注入`AndroidInjectModule`，来确保可以绑定`Android`的基础组件。一般`Android`应用都会提供一个
+
+`ApplicationComponent`，其他的`Component`依赖该`ApplicationComponent`即可。    
+    ```java
+    @Module
+	public class AppModule {
+	    @Provides
+	    LogUtil provideLogUtil() {
+	        return new LogUtil();
+	    }
+	}
+	@Singleton // 必须要singleton
+	@Component(modules = AndroidInjectionModule.class, AppModule.class)
+	public interface AppComponent {
+	    void inject(AppApplication application);
+	}
+    ```
+- 2.通过`@Subcomponent`声明一个实现`AndroidInjector<YourActivity>`的接口，并且提供一个继承`AndroidInjector.Builder<YourActivity>`的`@Subcomponent.Builder`
+	```java
+	@Subcomponent(modules = AndroidInjectionModule.class)
+	public interface MainActivitySubcomponent extends AndroidInjector<MainActivity> {
+	    @Subcomponent.Builder
+	    abstract class Builder extends AndroidInjector.Builder<MainActivity> {
+	    }
+	}
+	```
+- 3.定义完上面的`Subcomponent`后，要通过`module`将该`Module`注入到`Application`的`modules`列表中
+	```java
+	@Module(subcomponents = MainActivitySubcomponent.class)
+	abstract class MainActivityModule {
+	    @Binds
+	    @IntoMap
+	    @ActivityKey(MainActivity.class)
+	    abstract AndroidInjector.Factory<? extends Activity> bindYourActivityInjectorFactory(MainActivitySubcomponent.Builder builder);
+	    @Singleton // 必须用signelton，不然报错错误: A @Module may not contain both non-static @Provides methods and abstract @Binds or @Multibinds declarations
+	    @Provides
+	    static MainActivityPresenter providePresenter() {
+	        return new MainActivityPresenter();
+	    }
+	}
+- 4.将刚才定义的`YourActivityModule.class`添加到`ApplicationComponent`中      
+	```java
+	@Singleton // 必须要singleton
+	@Component(modules = {AndroidInjectionModule.class, AppModule.class, MainActivityModule.class})
+	public interface AppComponent {
+	    void inject(AppApplication application);
+	}
+	```
+
+- 5.自定义`Application`实现`HasActivityInjector`并且通过`@Inject`注入一个`activityInjector()`方法返回的`DispathcingAndroidInJector<Activity>`实例  
+
+	```java
+	public class AppApplication extends Application implements HasActivityInjector {
+	    @Inject
+	    DispatchingAndroidInjector<Activity> dispatchingActivityInjector;
+
+	    @Override
+	    public void onCreate() {
+	        super.onCreate();
+	        DaggerAppComponent.builder().build().inject(this);
+	    }
+
+	    @Override
+	    public AndroidInjector<Activity> activityInjector() {
+	        return dispatchingActivityInjector;
+	    }
+	}
+	```	
+
+- 6.最后，在`Activity.onCreate()`方法中在`super.onCreate()`之前调用`AndroidInjection.inject(this)`
+
+	```java
+	public class MainActivity extends AppCompatActivity {
+	    @Inject
+	    LogUtil mLog;
+	    @Inject
+	    MainActivityPresenter mPresenter;
+
+	    @Override
+	    protected void onCreate(Bundle savedInstanceState) {
+	        AndroidInjection.inject(this);
+	        super.onCreate(savedInstanceState);
+	        setContentView(R.layout.activity_main);
+	        mLog.d(mPresenter.toString());
+	    }
+	}
+	```
+	执行结果:`04-23 19:46:38.443 17096-17096/? E/@@@: com.charon.daggerandroiddemo.MainActivityPresenter@e480d98`
+	
+但是它是怎么实现的呢？ 
+`AndroidInjection.inject()`会从你的`Application`中拿到一个`DispatchingAndroidInjector<Activity>`并通过`inject(Activity)`把`Activity`传了过去。这个`DispatchingAndroidInjector`会查找一个你的`Activity`类的`AndroidInjector.Factory(YourActivitySubcomponent.Builder)`，构建`AndroidInjector(YourActivitySubcomponent)`，然后把你的`Activity`传给`inject(YourActivity)`。
+
+
+注入`Fragment`实例
+---
+
+
+注入`Fragment`实例和注入`Activity`类似。同样的去声明`subcomponent`，不同的是:    
+
+- 需要将`Activity`类型参数替换成`Fragment`
+- 将`@ActivityKey`替换成`@FragmentKey`
+- 将`HasActivityInjector`替换成`HasFragmentInjector`
+- 和在`Activity.onCreate()`方法执行注入不同的`Fragment`要通过`onAttach()`方法注入。        
+- `Fragment`的`Module`的添加位置，与`Activity`定义的`Module`添加不同，其取决于`Fragment`内部所需要的其他绑定的依赖注入；
+
+
+> Unlike the modules defined for Activitys, you have a choice of where to install modules for Fragments. You can make your Fragment component a subcomponent of another Fragment component, an Activity component, or the Application component — it all depends on which other bindings your Fragment requires. After deciding on the component location, make the corresponding type implement HasFragmentInjector. For example, if your Fragment needs bindings from YourActivitySubcomponent, your code will look something like this:
+
+```java
+public class YourActivity extends Activity
+    implements HasFragmentInjector {
+  @Inject DispatchingAndroidInjector<Fragment> fragmentInjector;
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    AndroidInjection.inject(this);
+    super.onCreate(savedInstanceState);
+    // ...
+  }
+
+  @Override
+  public AndroidInjector<Fragment> fragmentInjector() {
+    return fragmentInjector;
+  }
+}
+
+public class YourFragment extends Fragment {
+  @Inject SomeDependency someDep;
+
+  @Override
+  public void onAttach(Activity activity) {
+    AndroidInjection.inject(this);
+    super.onAttach(activity);
+    // ...
+  }
+}
+
+@Subcomponent(modules = ...)
+public interface YourFragmentSubcomponent extends AndroidInjector<YourFragment> {
+  @Subcomponent.Builder
+  public abstract class Builder extends AndroidInjector.Builder<YourFragment> {}
+}
+
+@Module(subcomponents = YourFragmentSubcomponent.class)
+abstract class YourFragmentModule {
+  @Binds
+  @IntoMap
+  @FragmentKey(YourFragment.class)
+  abstract AndroidInjector.Factory<? extends Fragment>
+      bindYourFragmentInjectorFactory(YourFragmentSubcomponent.Builder builder);
+}
+
+@Subcomponent(modules = { YourFragmentModule.class, ... }
+public interface YourActivityOrYourApplicationComponent { ... }
+```
+
+
+
+
+上面主要用到了这几个类:   
+
+- `AndroidInjection`:注入`Android`核心库的基本类型的实例
+- `AndroidInjector<T>`:注入`Android`库的类型的接口,`T`为`Android`库的基本类型`T`,比如`Activity`、`Fragment`、`BroadcastReceive`等；
+- `AndroidInjector.Factory<T>`:`AndroidInjector<T>`的工厂类接口
+- `DispatchingAndroidInjector<T>`:其为`AndroidInjector<T>`接口的实现类，将`Android`核心库的的基本类型`T`的实例注入`Dagger`，该操作是由`Android`核心库的类的实例本身执行，而不是`Dagger`。
+
+卧草，好麻烦。`activity`搞一遍、`fragment`搞一遍、`service`搞一遍....
+
+
+弄到这里我已经迷糊了，在`dagger.android`这里我废了老半天劲，中间一度不想看了...
+
+- 每个`Activity`都要写一个`YourActivityModule`，并且添加到`AppComponent`中:   
+	```java
+	@Singleton // 必须要singleton
+	@Component(modules = {AndroidInjectionModule.class, AppModule.class, MainActivityModule.class})
+	public interface AppComponent {
+	    void inject(AppApplication application);
+	}
+	```
+	那么多`Activity`都添加进来，这是简洁个锤子啊
+
+- 每个`YourActivityModule`还要有一个`YourActivitySubComponent`文件，同事还需要建立多个`SubComponent`
+	```java
+	@Module(subcomponents = MainActivitySubcomponent.class)
+	abstract class MainActivityModule {
+	```
+
+官网中有这样一段话:   
+> Pro-tip: If your subcomponent and its builder have no other methods or supertypes than the ones mentioned in step #2, you can use @ContributesAndroidInjector to generate them for you. Instead of steps 2 and 3, add an abstract module method that returns your activity, annotate it with @ContributesAndroidInjector, and specify the modules you want to install into the subcomponent. If the subcomponent needs scopes, apply the scope annotations to the method as well.
+
+
+也就是如果您的`subcomponent`及其构建器没有第2步中提到的其他方法或超类型，您可以使用`@ContributesAndroidInjector`为您生成它们。我们就不需要步骤2和3，取而代之的是添加一个抽象模块方法，该方法返回您的`activity`，使用`@ContributesAndroidInjector`对其进行注解，并指定要安装到子组件中的模块。 如果子组件需要`scopes`，则也可以用`@scopes`注解到该方法。
+```java
+@ActivityScope
+@ContributesAndroidInjector(modules = { /* modules to install into the subcomponent */ })
+abstract YourActivity contributeYourActivityInjector();
+```
+
+
+我们可以封装一下:    
+
+- 提供`BaseActivity`在其`onCreate()`方法前调用`AndroidInjection.inject(this);`
+- 提供`BaseActivityComponent`
+- 然后将所有的`ActivityModule`用`AllActivityModule`统一管理
+
+
+`dagger`当然不会让你这么费劲,他们提供了更简单的实现
+
+基本`Framework`
+---
+
+
+由于`DispatchingAndroidInjector`会在运行时查找合适的`AndroidInjector`，基类需要像调用`AndroidInjection.inject()`一样实现`HasDispatchingActivityInjector/HasDispatchingFragmentInjector`，子类需要做的就是绑定一个对应的`@Subcomponent`。如果你的类层次不是很复杂的话`Dagger`会提供一些基类(如`[DaggerActivity]`和`[DaggerFragment]`)。同时`Dagger`也会提供`[DaggerApplication]`，你需要做的就是继承它并覆写`applicationInjector()`方法以返回应该注入`Application的component`。 
+
+
+还有下面的类型:
+
+- DaggerService and DaggerIntentService
+- DaggerBroadcastReceiver
+- DaggerContentProvider
+
+注意:`[DaggerBroadcastReceiver]`只适用于在`AndroidManifest.xml`文件中静态注册的`BroadcastReceiver`，如果你在代码中手动创建注册`BroadcastReceiver`，最好采用构造器注入。
+
+
+就是`dagger`提供给了`DaggerActivity`、`DaggerFragment`、`DaggerAppliation`等类，你可以直接去继承该类，实现对应的方法就可以了，不用按照上面一步一步的。
+
+
+那究竟是怎么用呢？ 
+直接上代码了:   
+
+- 首先写好`ApplicationModule`类:   
+```java
+@Module
+public class ApplicationModule {
+    @Provides
+    LogUtil provideLogUtil() {
+        return new LogUtil();
+    }
+}
+```
+
+- 定义好`MainActivityModule`:   
+```java
+@Module
+public class MainActivityModule {
+    MainPresenter provideMainPresenter() {
+        return "main activity module";
+    }
+}
+```
+
+- 把所有的`ActivityModule`都放到一个统一的管理类中(为什么必须要有这个类去统一声明对应的Module，后面讲)，这里叫`ActivityBuilder`不太合适，应该叫`ActivityBindingModule`更切合一些:   
+```java
+@Module
+public abstract class ActivityBuilder {
+    @ContributesAndroidInjector(modules = MainActivityModule.class)
+    abstract MainActivity bindMainActivity();
+    // @ContributesAndroidInjector(modules = Main2ActivityModule.class)
+    // abstract Main2Activity bindMain2Activity();
+    // ...
+    // 以后再写别的Activity只要将其对应的Module添加到这里就好了
+}
+```
+- 将`AndroidInjectionModule`、`ApplicationModule`、`ActivityBuilder`都注册到`AppComponent`中(这三是必须的)，然后提供`Builder`
+```java
+@Component(modules = {AndroidInjectionModule.class, ApplicationModule.class, ActivityBuilder.class})
+public interface AppComponent extends AndroidInjector<AppApplication> {
+    @Component.Builder // 这个是什么鬼？ 为什么要声明它，下面讲
+    interface Builder {
+
+        @BindsInstance
+        Builder application(AppApplication application);
+
+        AppComponent build();
+    }
+
+    void inject(AppApplication application);  
+}
+```
+- 自定义`Application`类继承`DaggerApplication`
+```java
+public class AppApplication extends DaggerApplication {
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+    }
+
+
+    @Override
+    protected AndroidInjector<? extends DaggerApplication> applicationInjector() {
+        AppComponent appComponent = DaggerAppComponent.builder().application(this).build();
+        return appComponent;
+    }
+}
+```
+继承后要实现`applicationInjector()`方法，也就是制定哪个是应用的`injector(the main component AppComponent)`. 
+这就是为什么要让`AppComponent`继承`AndroidInjector <DaggerApplication>`的原因。 
+
+
+- 将`Activity`继承`DaggerActivity`，并且调用方法.  
+```java
+public class MainActivity extends DaggerActivity {
+    @Inject
+    LogUtil mLog;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+    	// 看到没，这里不用写inject了
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+        mLog.d("@@@");
+    }
+}
+```
+
+好了，走你:   
+```
+04-23 21:19:29.591 21395-21395/? E/@@@: @@@
+```
+卧草，方便了没有，好像还可以啊
+
+
+别忘了上面我们还遗留了两个问题:   
+
+- 为什么要声明`ActivityBuilder`并且在里面把`Module`列出，并声明`ContributesAndroidInjector`
+- 为什么要通过`@Component.Builder`声明`Builder`接口
+
+第一个问题:  
+---
+
+> ActivityBuilder : We created this module. This is a given module to dagger. We map all our activities here. And Dagger know our activities in compile time. In our app we have Main and Detail activity. So we map both activities here.
+
+这个问题其实我们在前面讲过。 在讲`DaggerActivity`和`DaggerFragment`之前。
+
+
+第二个问题:
+---
+
+> @Component.Builder: We might want to bind some instance to Component. In this case we can create an interface with @Component.Builder annotation and add whatever method we want to add to builder. In my case I wanted to add Application to my AppComponent.
+
+> Note: If you want to create a Builder for your Component, your Builder interface has to has a build(); method which returns your Component.
+
+说白了就是讲`Application`和`AppComponent`绑定。 
+
+```java
+public class AppApplication extends DaggerApplication {
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+    }
+
+
+    @Override
+    protected AndroidInjector<? extends DaggerApplication> applicationInjector() {
+        AppComponent appComponent = DaggerAppComponent.builder().application(this).build();
+        return appComponent;
+    }
+}
+```
+
+`support`包的支持
+---
+
+像使用`Android support library`一样，`dagger.android.support`包下面也会提供相应的类。但要注意，当`support Fragment`用户需要绑定`AndroidInjector.Factory<? extends android.support.v4.app.Fragment>`时，`AppCompat`用户应该继续实现`AndroidInjector.Factory<? extends Activity>`而不是`<? extends AppCompatActivity>或<? extends FragmentActivity>`。
+
+
+何时注入
+---
+
+
+要尽可能的采用构造器注入，因为`javac`将确保被`set`之前没有字段被引用，这有利于避免空指针异常。但如果你一定要注入成员变量，最好尽早进行注入(越早越好)。也正是因为这样，`DaggerActivity`才要在`onCreate()`方法中立刻调用`AndroidInjection.inject()`再调用`super.onCreate()`。`DaggerFragment的onAttach()`也是一样，也是为了防止`Fragment`重新`attach`产生的矛盾。
+
+
+下一篇:[Dagger2与MVP(八)](https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/8.Dagger2%E4%B8%8EMVP(%E5%85%AB).md)
+
+
+- [In Dagger 2.15,Should I need to add inject line on every Activity?
+](https://stackoverflow.com/questions/49348638/in-dagger-2-15-should-i-need-to-add-inject-line-on-every-activity)
+- [感谢简书走在冷风中吧](https://www.jianshu.com/p/9f1f1e75e97c)
+- [Android_Study_OK](https://blog.csdn.net/android_study_ok/article/details/52384247)
+- [Dagger & Android](https://google.github.io/dagger//android.html)
+- [New Android Injector with Dagger 2 ](https://medium.com/@iammert/new-android-injector-with-dagger-2-part-1-8baa60152abe)
+- [MVP with Dagger 2.11](https://proandroiddev.com/mvp-with-dagger-2-11-847d52c27c5a)
+- [Kotlin with dagger-android basic setup](http://marcinchmiel.com/articles/2017-05/kotlin-with-dagger-android-basic-setup/)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Dagger2/8.Dagger2\344\270\216MVP(\345\205\253).md" "b/Dagger2/8.Dagger2\344\270\216MVP(\345\205\253).md"
new file mode 100644
index 00000000..713df3fe
--- /dev/null
+++ "b/Dagger2/8.Dagger2\344\270\216MVP(\345\205\253).md"
@@ -0,0 +1,205 @@
+Dagger2与MVP(八)
+===
+
+前面介绍了`Dagger2`的基本知识，并且通过示例代码演示了如何在`Android`开发中去使用`Dagger2`。
+`Dagger2`可以减少很多模板化的代码，更易于测试、降低耦合度，创建可复用可交换的模板。    
+
+`Dagger2`优点:   
+
+- 提供了对全局对象实例的简单访问方式      
+    声明了单例的实例都可以通过`@Inject`进行访问。比如下面的`MyTwitterApiClient`和`SharedPreferences`的实例:    
+
+    ```java
+	public class MainActivity extends Activity {
+	   @Inject MyTwitterApiClient mTwitterApiClient;
+	   @Inject SharedPreferences sharedPreferences;
+
+	   public void onCreate(Bundle savedInstance) {
+	       // assign singleton instances to fields
+	       InjectorClass.inject(this);
+	   }
+	}
+    ```
+
+- 复杂的依赖关系只需要简单的配置
+    `Dagger2`会通过依赖关系并且生成易懂易分析的代码。以前通过手写的大量模板代码中的对象引用将会由它给你创建并传递到相应对象中。
+    因此你可以更多的关注模块中构建的内容而不是模块中的对象实例的创建顺序。
+
+- 作用域实例     
+    我们不仅可以轻松的管理全局实例对象，也可以使用`Dagger2`中的`scope`定义不同的作用域。（比如根据`user session`，`activity`的生命周期）
+
+
+在之前写的一篇文章[Android开发中的MVP模式详解](https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Android%E5%BC%80%E5%8F%91%E4%B8%AD%E7%9A%84MVP%E6%A8%A1%E5%BC%8F%E8%AF%A6%E8%A7%A3.md)中，讲到了`Google`官方的[android-architecture](https://github.com/googlesamples/android-architecture),下面就从前面这篇文章的基础往下说。`android-architecture`里面有一个分支是`todo-mvp-dagger`。`MVP`和`Dagger2`搭配，开发不累。   
+
+
+我们在没使用`dagger`之前，进行`mvp`开发的时候，是不是需要创建`view`和`presenter`啊，然后让他俩分别持有对方的对象。 
+那使用`dagger`后该怎么实现呢？   
+
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/dagger_todo_mvp_list.png?raw=true" width="100%" height="100%">
+
+我们可以看到和之前的区别就是:   
+
+- 多了`di`包，这里面都是动态注入相关的类:有全局的`ApplicationModule`、`AppComponent`、`ActivityBindingModule`和自定义的`Scope`
+- 每个页面都多了一个对应的`XXXModule`
+
+- 然后`ToDoApplication`实现了`DaggerApplication`
+
+就从`ToDoApplication`开始分析吧:   
+```java
+public class ToDoApplication extends DaggerApplication {
+    @Inject
+    TasksRepository tasksRepository;
+
+    @Override
+    protected AndroidInjector<? extends DaggerApplication> applicationInjector() {
+        return DaggerAppComponent.builder().application(this).build();
+    }
+
+    /**
+     * Our Espresso tests need to be able to get an instance of the {@link TasksRepository}
+     * so that we can delete all tasks before running each test
+     */
+    @VisibleForTesting
+    public TasksRepository getTasksRepository() {
+        return tasksRepository;
+    }
+}
+```
+
+继承`DaggerApplication`并且实现`applicationInjector`方法，这是为了让`Activity`不用每个都去调用`component`的`inject`方法。 
+这里用到了`TasksRepository`和`AppComponent`，我们去看一下`AppComponent`:   
+```java
+@Singleton
+@Component(modules = {TasksRepositoryModule.class,
+        ApplicationModule.class,
+        ActivityBindingModule.class,
+        AndroidSupportInjectionModule.class})
+public interface AppComponent extends AndroidInjector<ToDoApplication> {
+	// 提供TaskRepository的注入对象
+    TasksRepository getTasksRepository();
+
+    // Gives us syntactic sugar. we can then do DaggerAppComponent.builder().application(this).build().inject(this);
+    // never having to instantiate any modules or say which module we are passing the application to.
+    // Application will just be provided into our app graph now.
+    @Component.Builder
+    interface Builder {
+
+        @BindsInstance
+        AppComponent.Builder application(Application application);
+
+        AppComponent build();
+    }
+}
+```
+
+这里面会将`TasksRepositoryModule`、`ApplicationModule`、`ActivityBindingModule`都进行绑定。   
+```java
+@Module
+public abstract class ApplicationModule {
+    //expose Application as an injectable context
+    @Binds
+    abstract Context bindContext(Application application);
+}
+
+@Module
+public abstract class ActivityBindingModule {
+	// 注意下面的这四个`Module`
+    @ActivityScoped
+    // TasksModule是给`TasksActivity`提供注入对象的
+    @ContributesAndroidInjector(modules = TasksModule.class)
+    abstract TasksActivity tasksActivity();
+
+    @ActivityScoped
+    @ContributesAndroidInjector(modules = AddEditTaskModule.class)
+    abstract AddEditTaskActivity addEditTaskActivity();
+
+    @ActivityScoped
+    @ContributesAndroidInjector(modules = StatisticsModule.class)
+    abstract StatisticsActivity statisticsActivity();
+
+    @ActivityScoped
+    @ContributesAndroidInjector(modules = TaskDetailPresenterModule.class)
+    abstract TaskDetailActivity taskDetailActivity();
+}
+```
+而`TasksRepositoryModule`是在`Mock`中:   
+```java
+/**
+ * This is used by Dagger to inject the required arguments into the {@link TasksRepository}.
+ */
+@Module
+abstract public class TasksRepositoryModule {
+
+    private static final int THREAD_COUNT = 3;
+
+    @Singleton
+    @Binds
+    @Local
+    abstract TasksDataSource provideTasksLocalDataSource(TasksLocalDataSource dataSource);
+
+    @Singleton
+    @Binds
+    @Remote
+    abstract TasksDataSource provideTasksRemoteDataSource(FakeTasksRemoteDataSource dataSource);
+
+    @Singleton
+    @Provides
+    static ToDoDatabase provideDb(Application context) {
+        return Room.databaseBuilder(context.getApplicationContext(), ToDoDatabase.class, "Tasks.db")
+                .build();
+    }
+
+    @Singleton
+    @Provides
+    static TasksDao provideTasksDao(ToDoDatabase db) {
+        return db.taskDao();
+    }
+
+    @Singleton
+    @Provides
+    static AppExecutors provideAppExecutors() {
+        return new AppExecutors(new DiskIOThreadExecutor(),
+                Executors.newFixedThreadPool(THREAD_COUNT),
+                new AppExecutors.MainThreadExecutor());
+    }
+}
+```
+这是用于`mock`测试的一个类，里面的两个方法分别表示本地数据和远程数据，最终返回的都是`TasksDataSource`。`mock`测试就是在测试过程中，对于某些不容易构造或者不容易获取的对象，用一个虚拟的对象来创建以便测试的测试方法。这里对于数据对象直接在这里进行初始化，而不是在所有的用到该数据的地方`new`一遍。这也就体现了`Dagger2`的引入对测试是一个极大的便利。
+
+
+上面看到了`ActivityBindingModule`中对每个`Activity`都声明的`Module`,接下来就看`TasksModule`:     
+```java
+/**
+ * This is a Dagger module. We use this to pass in the View dependency to the
+ * {@link TasksPresenter}.
+ */
+@Module
+public abstract class TasksModule {
+    @FragmentScoped
+    @ContributesAndroidInjector
+    abstract TasksFragment tasksFragment();
+
+    @ActivityScoped
+    @Binds abstract TasksContract.Presenter taskPresenter(TasksPresenter presenter);
+}
+
+```
+
+这里面分别提供了对应`View`的`Fragment`以及对应`Presenter`。   
+
+
+
+
+下一篇文章:[Dagger2原理分析](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)
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Dagger2/9.Dagger2\345\216\237\347\220\206\345\210\206\346\236\220(\344\271\235).md" "b/Dagger2/9.Dagger2\345\216\237\347\220\206\345\210\206\346\236\220(\344\271\235).md"
new file mode 100644
index 00000000..c8f31899
--- /dev/null
+++ "b/Dagger2/9.Dagger2\345\216\237\347\220\206\345\210\206\346\236\220(\344\271\235).md"
@@ -0,0 +1,196 @@
+Dagger2原理分析(九)
+===
+
+
+在看这篇文章前，强烈建议看一下[注解使用](https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E6%B3%A8%E8%A7%A3%E4%BD%BF%E7%94%A8.md)
+因为这篇文章只是分析`Dagger2`自动生成的代码，有关如何把注解生成代码的过程，就需要通过上面这篇文章来看了。
+
+
+写完用法之后，不看看源码，老是感觉好像还少了点什么？那这里就分析下源码。
+用一个最简单的例子来分析:  
+```java
+public class A {
+    void print() {
+        Log.i("@@@", "A");
+    }
+}
+
+@Module
+public class AModule {
+    @Provides
+    A provideA() {
+        return new A();
+    }
+}
+
+@Component(modules = AModule.class)
+public interface AComponent {
+    void inject(MainActivity activity);
+}
+
+public class MainActivity extends Activity {
+    @Inject A a;
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        DaggerAComponent.builder().build().inject(this);
+        a.print();
+    }
+}
+```
+
+首先我们看一下`dagger`自动生成的代码:
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/dagger2_generate_code.png" width="100%" height="100%">
+
+这里一共自动生成了三个类，通过名字我们很简单的能看出他们的对应关系，这里就从`Module`类开始一个个的说:   
+```java
+public final class AModule_ProvideAFactory implements Factory<A> {
+  private final AModule module;
+
+  public AModule_ProvideAFactory(AModule module) {
+    this.module = module;
+  }
+
+  @Override
+  public A get() {
+    return provideInstance(module);
+  }
+
+  public static A provideInstance(AModule module) {
+    return proxyProvideA(module);
+  }
+
+  public static AModule_ProvideAFactory create(AModule module) {
+    return new AModule_ProvideAFactory(module);
+  }
+
+  public static A proxyProvideA(AModule instance) {
+
+  	// 这里可以看到他内部其实就是调用了我们写的AModule里面的provideA()方法
+    return Preconditions.checkNotNull(
+        instance.provideA(), "Cannot return null from a non-@Nullable @Provides method");
+  }
+}
+```
+
+从前面几篇文章我们知道`Component`是`Module`和需求方的桥梁，所以我们看一下对应的`DaggerAComponent`的源码:    
+```java
+public final class DaggerAComponent implements AComponent {
+  private AModule aModule;
+
+  private DaggerAComponent(Builder builder) {
+    initialize(builder);
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static AComponent create() {
+    return new Builder().build();
+  }
+
+  @SuppressWarnings("unchecked")
+  private void initialize(final Builder builder) {
+    this.aModule = builder.aModule;
+  }
+
+  @Override
+  public void inject(MainActivity activity) {
+    injectMainActivity(activity);
+  }
+
+  private MainActivity injectMainActivity(MainActivity instance) {
+  	// 会将创建的Module对象传递到AModule_ProvideAFactory中，AModule_ProvideAFactory.proxyProvideA就是调用Module中的provideA()方法
+    MainActivity_MembersInjector.injectA(instance, AModule_ProvideAFactory.proxyProvideA(aModule));
+    return instance;
+  }
+
+  public static final class Builder {
+    private AModule aModule;
+
+    private Builder() {}
+
+    public AComponent build() {
+    	// Component里面会创建Module类
+      if (aModule == null) {
+        this.aModule = new AModule();
+      }
+      return new DaggerAComponent(this);
+    }
+
+    public Builder aModule(AModule aModule) {
+      this.aModule = Preconditions.checkNotNull(aModule);
+      return this;
+    }
+  }
+}
+```
+我们在`Activity`中都要手动的去调用`DaggerAComponent`的`inject`方法:  
+```java
+DaggerAComponent.builder().build().inject(this);
+```
+我们看一下`inject`方法的源码:  
+```java
+  @Override
+  public void inject(MainActivity activity) {
+    injectMainActivity(activity);
+  }
+
+  private MainActivity injectMainActivity(MainActivity instance) {
+    MainActivity_MembersInjector.injectA(instance, AModule_ProvideAFactory.proxyProvideA(aModule));
+    return instance;
+  }
+```
+上面`AModule_ProvideAFactory.proxyProvideA(aModule)`其实就是调用了`AModule`里面的`provideA()`方法，这里会生成一个`A`类的对象。 
+那`MainActivity_MembersInjector.injectA()`方法的源码又是什么呢？ 这里继续看一下`MainActivity_MembersInjector`类的源码:    
+```java
+public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
+  private final Provider<A> aProvider;
+
+  public MainActivity_MembersInjector(Provider<A> aProvider) {
+    this.aProvider = aProvider;
+  }
+
+  public static MembersInjector<MainActivity> create(Provider<A> aProvider) {
+    return new MainActivity_MembersInjector(aProvider);
+  }
+
+  @Override
+  public void injectMembers(MainActivity instance) {
+    injectA(instance, aProvider.get());
+  }
+
+  public static void injectA(MainActivity instance, A a) {
+    instance.a = a;
+  }
+}
+```
+它里面其实就是讲`MainActivity`对象里面的成员变量`a`复制给我们通过参数传递过来的`A`类的对象。
+
+看到这里明白了吗？ 
+```java
+public class MainActivity extends Activity {
+    @Inject A a;
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        DaggerAComponent.builder().build().inject(this);
+        a.print();
+    }
+}
+```
+所以我们在`MainActivity`中直接使用变量`a`的时候，其实`a`已经复制给了我们在`Module.provideA()`中创建的`A`类的对象。 
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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..0c6ea44b
--- /dev/null
+++ "b/Gradle&Maven/Composing builds\347\256\200\344\273\213.md"	
@@ -0,0 +1,369 @@
+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 {
+    ext.kotlin_version = "1.5.10"
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        // 因为使用的Kotlin需要需要添加Kotlin插件
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'kotlin'
+apply plugin: 'java-gradle-plugin'
+
+repositories {
+    mavenCentral()
+}
+
+compileKotlin {
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+compileTestKotlin {
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+
+gradlePlugin {
+    plugins {
+        version {
+            // 在app模块需要通过id引用这个插件
+            id = 'com.xx.xx.plugin'
+            // 实现这个插件的类的路径
+            implementationClass = 'com.xx.xx.versionplugin.Deps'
+        }
+    }
+}
+```
+
+3. 在versionPlugin/src/main/java/包名/目录下新建Deps.kt文件，添加你的依赖配置，如：
+
+```kotlin
+package com.xx.xx.versionplugin
+
+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"
+    }
+}
+```
+
+或者也可以按依赖类型用不同的类配置，例如
+
+```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 'com.android.application'
+    id 'kotlin-android'
+    id 'kotlin-kapt'
+    // 通过id来使用该plugin，这个id就是在versionPlugin文件夹下build.gradle文件内定义的id
+    id 'com.xx.xx.plugin'
+}
+```
+
+使用如下:  
+
+```groovy
+dependencies {
+    implementation CustomLibs.Glide.glide
+    kapt CustomLibs.Glide.glideCompiler
+}    
+```
+
+
+
+
+
+# 参考
+
+- [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"
new file mode 100644
index 00000000..253a8c33
--- /dev/null
+++ "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
@@ -0,0 +1,2132 @@
+Gradle专题
+===
+
+作用
+---
+
+[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发行版压缩包的下载地址。    
+
+Gradle 是一个 运行在 JVM 的通用构建工具,其核心模型是一个由 Task 组成的有向无环图(Directed Acyclic Graphs).
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/gradle_task_1.png?raw=true)
+
+
+简介
+---
+
+[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，但仔细想想我们在项目中其实没有用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：初始化阶段     
+    - 解析整个工程中所有的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完全是因为这个插件的原因。
+
+### 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的话，那么压根不会执行的。 
+```
+plugins {
+    id 'com.android.application'
+    id 'kotlin-android'
+    id 'kotlin-kapt'
+}
+```
+这就是AGP被apply的地方，也是区分一个module究竟是被打包成app还是一个library的地址。 
+
+
+
+
+
+基本的项目设置
+---
+
+一个`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`都会包含以下几个配置：   
+`Project`根目录的`build.gradle`:       
+
+```
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.5.0'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+```
+`Module`中的`build.gradle`:    
+
+```
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.3"
+    ...
+}
+```
+
+
+- `buildscript { ... }`配置了编译时的代码驱动. 这种情况下，它声明所使用的是`jCenter`仓库。还有一个声明所依赖的在`Maven`文件的路径。这里声明的包含了`Android`插件所使用的1.5.0版本的`Gradle`. 注意:这只会影响`build`中运行的代码，不是项目中。项目中需要声明它自己所需要仓库和依赖关系。
+- `apply plugin : com.android.application`，声明使用`com.androdi.application`插件。这是构建`Android`应用所需要的插件。
+- `android{...}`配置了所有`Android`构建时的参数。默认情况下，只有编译的目标版本以及编译工具的版本是需要的。
+
+重要: 这里只能使用`com.android.application`插件。如果使用`java`插件将会报错。目录结构
+
+`module/src/main`下的目录结构，因为有时候很多人把`so`放到`libs`目录就会报错:    
+
+- java/
+- res/
+- AndroidManifest.xml
+- assets/
+- aidl/  
+- jniLibs/
+- jni/  
+- rs/
+
+### 配置目录结构
+如果项目的结构不标准的时候，可能就需要去配置它。`Android`插件使用了相似的语法，但是因为它有自己的`sourceSets`，所以要在`android`代码块中进行配置。下面就是一个从`Eclipse`的老项目结构中配置主要代码并且将`androidTest`的`sourceSet`设置给`tests`目录的例子:     
+
+```
+android {
+    sourceSets {
+        main {
+            manifest.srcFile 'AndroidManifest.xml'
+            java.srcDirs = ['src']
+            resources.srcDirs = ['src']
+            aidl.srcDirs = ['src']
+            renderscript.srcDirs = ['src']
+            res.srcDirs = ['res']
+            assets.srcDirs = ['assets']
+        }
+
+        androidTest.setRoot('tests')
+    }
+}
+```
+就像有些人就是要把`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
+---
+
+对构建文件声明插件时通常或自动创建一些列的构建任务去执行。不管`Java`插件还是`Android`插件都是这样。`Android`常规的任务如下：    
+
+- `assemble`生成项目`output`目录中的内容的任务。
+- `check`执行所有的检查的任务。
+- `build`执行`assemble`和`check`的任务。
+- `clean`清理项目`output`目录的任务。
+
+在`Android`项目中至少会有两种`output`输出:一个`debug apk`和一个`release apk`。他们都有自己的主任务来分别执行构建:    
+- `assemble`
+    - `assembleDebug`
+    - `assembleRelease`  
+    
+
+提示:`Gradle`支持通过命令行执行任务首字母缩写的方式。例如:      
+在没有其他任务符合`aR`的前提下，`gradle aR`与`gradle assembleRelease`是相同的。
+
+最后，构建插件创建了为所有`build type(debug, release, test)`类型安装和卸载的任务，只要他们能被安装(需要签名)。
+
+- `installDebug`
+- `installRelease`
+- `uninstallAll`
+    - `uninstallDebug`
+    - `uninstallRelease`
+    - `uninstallDebugAndroidTest`
+    
+### 基本的`Build`定制
+
+`Android`插件提供了一些列的`DSL`来让直接从构建系统中做大部分的定制。
+
+##### `Manifest`整体部分
+`DSL`提供了很多重要的配置`manifest`文件的参数，例如:     
+
+- `minSdkVersion`
+- `targetSdkVersion`
+- `versionCode`
+- `versionName`
+- `applicationId`
+- `testApplicationId`
+- `testInstrumentationRunnder`
+
+[Android Plugin DSL Reference](http://google.github.io/android-gradle-dsl/current/)提供了一个完整的构建参数列表。
+
+把这些`manifest`属性放到`build`文件中的一个重要功能就是它可以被动态的设置。例如，可以通过读取一个文件或者其他逻辑来获取版本名称。     
+
+```
+def computeVersionName() {
+    ...
+}
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+
+
+    defaultConfig {
+        versionCode 12 
+        versionName computeVersionName()
+        minSdkVersion 16
+        targetSdkVersion 23
+    }
+}
+```
+注意:不要使用可能与现有给定冲突的方法名。例如`defaultConfig{...}`中使用`getVersionName()`方法将会自动使用`defaultConfig.getVersionName()`来带起自定义的方法。
+
+##### `Build Types`
+
+默认情况下`Android`插件会自动将应用程序设置成有一个`debug`版本和一个`release`版本。    
+这就是通过调用`BuildType`对象完成。默认情况下会创建两个实例，一个`debug`实例和一个`release`实例。`Android`插件同样允许通过其他的`Build Types`来定制其他的实例。这就是通过`buildTypes`来设置的:     
+
+```
+android {
+    buildTypes {
+        debug {
+            applicationIdSuffix ".debug"
+        }
+
+
+        jnidebug {
+            initWith(buildTypes.debug)
+            applicationIdSuffix ".jnidebug"
+            jniDebuggable true
+        }
+    }
+}
+```
+上面的代码执行了以下操作:     
+- 配置了默认`debug`的`Build Type`:     
+    - 设置了它的`applicationId`。这样`debug`模式就能与`release`模式的`apk`同时安装在同一手机上。
+- 创建了一个新的`jnidebug`的`Build Type`，并且把它设置为`debug`的拷贝。
+- 通过允许`JNI`组件的`debug`和增加一个新的包名后缀来继续定制该`Build Type`。  
+
+不管使用`initWith()`还是使用其他的代码块，创建一个新的`Build Types`都是非常简单的在`buildTypes`代码块中创建一个新的元素就可以了。
+
+##### 签名配置
+
+为应用签名需要使用如下几个部分:      
+- `A keystore`
+- `A keystore password`
+- `A key alias name`
+- `A key password`
+- `The store type`
+
+
+默认情况下有一个`debug`的配置，设置了一个`debug`的`keystore`，有一个已知的密码。`debug keystore`的位置是在`$HOME/.android/debug.keystore`，如果没有的话他会被默认创建。`Debug`的`Build Type`会默认使用该`debug`的签名设置。
+
+当然也可以通过使用`DSL`语法中的`signingconfigs`部分来创建其他的配置来进行定制:    
+
+```
+android {
+    signingConfigs {
+        debug {
+            storeFile file("debug.keystore")
+        }
+
+
+        myConfig {
+            storeFile file("other.keystore")
+            storePassword "android"
+            keyAlias "androiddebugkey"
+            keyPassword "android"
+        }
+    }
+
+
+    buildTypes {
+        foo {
+            signingConfig signingConfigs.myConfig
+        }
+    }
+}
+
+```
+上面的设置将把`debug keystore`的位置改为项目的根目录。同样也创建了一个新的签名配置，并且有一个新的`Build Type`使用它。
+
+
+
+### `Dependencies, Android Libraries and Multi-project setup`
+
+`Gradle`项目可以依赖其他的外部二进制包、或者其他的`Gradle`项目。
+
+##### 本地包
+
+想要配置依赖一个外部`jar`包，需要在`compile`的配置中添加一个`dependency`。下面的配置是添加了所有在`libs`目录的`jar`包:   
+
+```
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+}
+
+
+android {
+    ...
+}
+```
+注意:`DSL`元素中的`dependencies`是`Gradle API`中的标准元素。不属于`andorid`元素。      
+`compile`配置是用来编译主应用的。它配置的所有部分都会被打包到`apk`中。当然也有一些其他的配置:      
+
+- `compile`: `main application`
+- `androidTestCompile`:`test application`
+- `debugCompile`:`debug Build Type`
+- `release Compile`:`release Build Type`
+
+当然我们可以使用`compile`和`<buildtype>.compile`这两种配置。创建一个新的`Build Type`通常会自动基于它的名字创建一个新的配置部分。这样在像`debug`版本而`release`版本不适用的一些特别的`library`时非常有用。
+
+##### 远程仓库
+
+`Gradle`只是使用`Maven`和`Ivy`仓库。但是仓库必须要添加到列表中，并且必须声明所依赖仓库的`Maven`或者`Ivy`定义。      
+
+```
+repositories {
+     jcenter()
+}
+
+
+dependencies {
+    compile 'com.google.guava:guava:18.0'
+}
+
+
+android {
+    ...
+}
+```
+
+注意:`jcenter()`是指定仓库`URL`的快捷设置。`Gradle`支持远程和本地仓库。
+注意:`Gradle`会直接识别所有的依赖关系。这就意味着如果一个依赖库自身又依赖别的库时，他们会被一起下下来。
+
+##### 本地`AAR`库     
+
+```
+dependencies {
+	compile(name:'本地aar库的名字，不用加后缀', ext:'aar')
+}
+```
+
+
+
+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`项目。例如:      
+
+- MyProject/         
+    - app/          
+    - libraries/        
+        - lib1/           
+        - lib2/     
+        
+
+`Gradle`会通过下面的名字来引用他们：     
+`:app`       
+`:libraries:lib1`          
+`:libraries:lib2`      
+
+
+每个项目都会有一个单独的`build`文件，并且在项目的根目录还会有一个`setting.gradle`文件：    
+      
+- MyProject/         
+    - settings.gradle         
+    - app/      
+        - build.gradle       
+    + libraries/      
+        + lib1/       
+            - build.gradle      
+        + lib2/      
+           - build.gradle      
+    
+
+`setting.gradle`文件中的内容非常简单。它指定了哪个目录是`Gralde`项目:     
+```
+include ':app', ':libraries:lib1', ':libraries:lib2'
+```
+
+`：app`这个项目可能会依赖其他的`libraries`，这样可以通过如下进行声明:    
+```
+dependencies {
+     compile project(':libraries:lib1')
+}
+```
+
+### `Library`项目
+
+上面用到了`:libraries:lib1`和`:libraries:lib2`可以是`Java`项目，`:app`项目会使用他们俩的输出的`jar`包。但是如果你需要使用`android`资源等，这些`libraries`就不能是普通的`Java`项目了，他们必须是`Android Library`项目。    
+
+##### 创建一个`Library`项目      
+
+`Library`项目和普通的`Android`项目的区别比较少，由于`libraries`的构建类型与应用程序的构建不同，所有它会使用一个别的构建插件。但是他们所使用的插件内部有很多相同的代码，他们都是由`com.android.tools.build.gradle`这个`jar`包提供的。
+
+```
+buildscript {
+    repositories {
+        jcenter()
+    }
+
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.3.1'
+    }
+}
+
+
+apply plugin: 'com.android.library'
+
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+}
+```
+
+##### 普通项目与`Library`项目的区别       
+
+`Library`项目的主要输出我`.aar`包。它结合了代码(例如`jar`包或者本地`.so`文件)和资源(`manifest`,`res`,`assets`)。每个`library`也可以单独设置`Build Type`等来指定生成不同版本的`aar`。
+
+### `Lint Support`
+
+你可以通过指定对应的变量来设置`lint`的运行。可以通过添加`lintOptions`来进行配置:      
+
+```
+android {
+    lintOptions {
+        // turn off checking the given issue id's
+        disable 'TypographyFractions','TypographyQuotes'
+
+        // turn on the given issue id's
+        enable 'RtlHardcoded','RtlCompat', 'RtlEnabled'
+
+        // check *only* the given issue id's
+        check 'NewApi', 'InlinedApi'
+    }
+}
+```
+
+### `Build`变量
+
+
+构建系统的一个目标就是能对同一个应用创建多个不同的版本。    
+
+##### `Product flavors`    
+
+一个`product flavor`可以针对一个项目制定不同的构建版本。一个应用可以有多个不同的`falvors`来改变生成的应用。   
+`Product flavors`是通过`DSL`语法中的`productFlavors`来声明的:    
+
+```
+android {
+    ....
+
+
+    productFlavors {
+        flavor1 {
+            ...
+        }
+
+
+        flavor2 {
+            ...
+        }
+    }
+}
+```
+
+##### `Build Type + Product Flavor = Build Variant`
+
+像我们之前看到的，每个`Build Type`都会生成一个`apk`.`Product Flavors`也是同样的：项目的输出僵尸所有`Build Types`与`Product Flavors`的结合。每种结合方式称之为`Build Variant`。例如，如果有`debug`和`release`版本的`Build Types`，上面的例子就会生成4种`Build Variants`：    
+- `Flavor1` - `debug`
+- `Flavor1` - `release`
+- `Flavor2` - `debug`
+- `Flavor2` - `release`
+
+没有配置`flavors`的项目仍然有`Build Variants`，它只是用了一个默认的`flavor/config`，没有名字，这导致`variants`的列表和`Build Types`的列表比较相同。
+
+##### `Product Flavor`配置
+
+```
+android {
+    ...
+
+
+    defaultConfig {
+        minSdkVersion 8
+        versionCode 10
+    }
+
+
+    productFlavors {
+        flavor1 {
+            applicationId "com.example.flavor1"
+            versionCode 20
+         }
+
+
+         flavor2 {
+             applicationId "com.example.flavor2"
+             minSdkVersion 14
+         }
+    }
+}
+```
+注意`android.productFlavors.*`对象`ProductFlavor`有`android.defaultConfig`是相同的类型。这就意味着他们有相同的属性。    
+`defaultConfig`为所有的`flavors`提供了一些基本的配置，每个`flavor`都已重写他们。在上面的例子中，这些配置有:       
+
+- `flavor1`        
+    - `applicationId`: `com.example.flavor1`      
+    - `minSdkVersion`: 8       
+    - `versionCode`: 20
+- `flavor2`    
+    - `applicationId`: `com.example.flavor2`      
+    - `minSdkVersion`: 14       
+    - `versionCode`: 10       
+    
+
+通常，`Build Type`配置会覆盖其他的配置。例如，`Build Type`的`applicationIdSuffix`会添加到`Product Flavor`的`applicationId`上。
+
+
+最后，就像`Build Types`一样，`Product Flavors`也可以有他们自己的依赖关系。例如，如果有一个单独的`flavors`会使用一些广告或者支付，那这个`flavors`生成的`apk`就会使用广告的依赖，而其他的`flavors`就不需要使用。    
+```
+dependencies {
+    flavor1Compile "..."
+}
+```
+
+### `BuildConfig`      
+
+在编译阶段，`Android Studio`会生成一个叫做`BuildConfig`的类，该类包含了编译时使用的一些变量的值。你可以观看这些值来改变不同变量的行为:       
+
+```
+private void javaCode() {
+    if (BuildConfig.FLAVOR.equals("paidapp")) {
+        doIt();
+    else {
+        showOnlyInPaidAppDialog();
+    }
+}
+```
+
+下面是`BuildConfig`中包含的一些值:      
+
+- `boolean DEBUG` - `if the build is debuggable`      
+- `int VERSION_CODE` 
+- `String VERSION_NAME`
+- `String APPLICATION_ID`
+- `String BUILD_TYPE`- `Build Type`的名字，例如`release`      
+- `String FLAVOR` - `flavor`的名字，例如`flavor1`      
+
+
+### `ProGuard`配置      
+
+`Android`插件默认会使用`ProGuard`插件，并且如果`Build Type`中使用`ProGuard`的`minifyEnabled`属性开启的话，会默认创建对应的`task`。   
+
+```
+android {
+    buildTypes {
+        release {
+            minifyEnabled true
+            proguardFile getDefaultProguardFile('proguard-android.txt')
+        }
+    }
+
+    productFlavors {
+        flavor1 {
+        }
+        flavor2 {
+            proguardFile 'some-other-rules.txt'
+        }
+    }
+}
+```
+
+### `Tasks`控制     
+
+基本的`Java`项目有一系列的`tasks`一起制作输出文件。     
+`classes task`就是编译`Java`源码的任务。 我们可以在`build.gradle`中通过使用`classes`很简单的获取到它。就是`project.tasks.classes`.    
+
+在`Android`项目中，更多的编译`task`，因为他们的名字通过`Build Types`和`Product Flavors`生成。
+
+为了解决这个问题，`android`对象有两种属性:     
+- `applicationVariants` - `only for the app plugin`     
+- `libraryVariants` - `only for the library plugin`      
+- `testVariants` - `for both plugins`      
+这些都会返回一个`ApplicationVariant`, `LibraryVariant`,`TestVariant`的`DomainObjectCollection`接口的实现类对象。   
+`DomainObjectCollection`提供了直接获取或者很方便的间接获取所有对象的方法。     
+```
+android.applicationVariants.all { variant ->
+   ....
+}
+```
+
+### 设置编译语言版本
+
+可以使用`compileOptions`代码块来设置编译时使用的语言版本。默认是基于`compileSdkVersion`的值。
+```
+android {
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_6
+        targetCompatibility JavaVersion.VERSION_1_6
+    }
+}
+```
+
+### `Resource Shrinking`    
+
+`Gradle`构建系统支持资源清理：对构建的应用会自动移除无用的资源。不仅会移除项目中未使用的资源，而且还会移除项目所以来的类库中的资源。注意，资源清理只能在与代码清理结合使用(例如`ProGuad`)。这就是为什么它能移除所依赖类库的无用资源。通常，类库中的所有资源都是使用的，只有类库中无用代码被移除后这些资源才会变成没有代码引用的无用资源。    
+
+```
+android {
+    ...
+
+    buildTypes {
+        release {
+            minifyEnabled true
+            shrinkResources true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+```
+
+
+
+## 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.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使用教程(第七弹)"
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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/Gradle&Maven/kts.md b/Gradle&Maven/kts.md
new file mode 100644
index 00000000..c6a2e26c
--- /dev/null
+++ b/Gradle&Maven/kts.md
@@ -0,0 +1,136 @@
+Gradle 支持使用 Groovy DSL 或 Kotlin DSL 来编写脚本。所以在学习具体怎么写脚本时，我们肯定会考虑到底是使用 Kotlin 来写还是 Groovy 来写。
+
+不一定说你是 Kotlin Android 开发者就一定要用 Kotlin 来写 Gradle，我们得判断哪种写法更适合项目、更适合开发团队人群（学习成本）。
+
+所以下面来学习一下这两种语言的差异。
+
+1. Groovy 和 Kotlin 的差异     
+
+1.1 语言差异
+
+Groovy是一种基于 JVM 的面向对象的编程语言，它可以作为常规编程语言，但主要是作为脚本的语言（为了解决 Java 在写脚本时过于死板）。      
+
+它是一个动态语言，可以不指定变量类型。它的特性是支持闭包，闭包的本质很简单，简单的说就是定义一个匿名作用域，这个作用域内部可以封装函数和变量，外部不可以访问这个作用域内部的东西，但是可以通过调用这个作用域来完成一些任务。
+     
+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方法调用必须使用(),所以将所有方法调用改为()方式。
+
+例如:     
+
+```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"
+```
+
+完成以上几步，准备工作就完成了。
+
+
+
+
+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{} 两种类型
+————————————————
+
+                            
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/Gradle&Maven/\345\217\221\345\270\203library\345\210\260Maven\344\273\223\345\272\223.md" "b/Gradle&Maven/\345\217\221\345\270\203library\345\210\260Maven\344\273\223\345\272\223.md"
new file mode 100644
index 00000000..1a61555a
--- /dev/null
+++ "b/Gradle&Maven/\345\217\221\345\270\203library\345\210\260Maven\344\273\223\345\272\223.md"
@@ -0,0 +1,443 @@
+发布library到Maven仓库
+---
+
+在`Android Studio`中想要使用一些第三方类库的时候非常方便，只需要在`build.gradle`中加入一行代码就可以了：   
+```java
+dependencies {
+    compile 'com.google.code.gson:gson:2.3.1'
+}
+```
+刚从`Eclipse`转过来的时候感觉太方便了，也不用下`jar`包然后拷贝到`libs`目录了，重要的是以后升级起来灰常方便，改个数字就好了。
+那究竟它里面是怎么运转的呢？其实`Android Studio`是从`Maven`仓库中下载所配置的`libraray`。     
+总的来说，`Android`只有两种存放`library`的服务器就是`jCenter`和`Maven Central`:
+
+- `jCenter`                 
+    `jCenter`是由[bintray](https://bintray.com/)维护的`Maven`仓库。你可以在[这里](http://jcenter.bintray.com/)查看它所有的`library`。
+    想要在项目中使用`jCenter`必须要在项目的`build.gradle`中像如下这样进行声明：    
+
+    ```java
+    allprojects {
+		repositories {
+			jcenter()
+		}
+	}
+	```
+- `Maven Central`         
+    `Maven Central`是由[sonatype](https://issues.sonatype.org)维护的`Maven`仓库。想要在项目中使用`Maven Central`需要在项目的`build.gradle`文件中像下面这样进行声明:     
+
+    ```java
+    allprojects {
+        repositories {
+            mavenCentral()
+        }
+    }
+    ```	
+	虽然`jCenter`和`Maven Central`都是`Android`标准的`library maven`仓库，但是他俩是由不同提供者维护，并且存放到完全不同的服务器上，所以他俩之间毫无关系。     
+	除了这两个标准的服务器外，如果我们使用的`library`作者把该`library`放到自己的服务器上，我们还可以自己定义特有的`Maven`仓库服务器。例如`Twitter`的`Fabric.io`就是这种情况，它们在[https://maven.fabric.io/public](https://maven.fabric.io/public)上维护了一个自己的`Maven`仓库，如果你想使用`Fabric.io`上的`library`你必须要自己定义仓库的`url`:       
+	```java
+	repositories {
+		maven { url 'https://maven.fabric.io/public' }
+	}
+	然后才能正常使用
+	dependencies {
+		compile 'com.crashlytics.sdk.android:crashlytics:2.2.4@aar'
+	}
+	```	
+
+	上传到自建服务器需要定义仓库的`url`，所以会比上传到标准的`maven`仓库使用起来要更麻烦。
+
+	至于上传到`jCenter`还是`Maven Central`上面就要看开发者个人的爱好了，当然在这两个上面都上传是最方便的。在`Android Studio`开始的几个版本中，它将`Maven central` 作为默认仓库。新建项目之后`build.gradle`中会自动生成`Maven central`仓库的配置。
+	但是`Maven Central`最大的问题就是上传`library`非常困难，同时还会由安全方面的原因，所以后来`Android Studio`将默认仓库替换成`jCenter`。所以最近的几个版本中创建项目之后,`build.gradle`中会默认定义`jCenter`而不是`Maven Central`。     
+
+`jCenter`相对`Maven Central`来说更好的几个主要原因:    
+
+- `jCenter`通过`CDN`发送`library`，开发者会由更快的下载体验。
+- `jCenter`作为世界最大的`Java`仓库，所以它上面的`library`会更多。
+- `jCenter`上传`library`更简单，不需要像在`Maven Central`上那么复杂。
+- `jCenter`的用户界面更友好。
+- `jCenter`的`bintray`网站上可以通过一键实现将`library`上传到`Maven Central`上。
+
+所以我们后面要讲的就是如何上传`library`到`bintray`的`jCenter`中然后再一键上传到`Maven Central`上。    
+
+说之前先通过`picasso`为例认识一下几个主要的部分:      
+我们在使用`picasso`时，它会告诉我们按照如下使用： 
+```java
+compile 'com.squareup.picasso:picasso:2.5.2'
+```
+或者
+```java
+<dependency>
+  <groupId>com.squareup.picasso</groupId>
+  <artifactId>picasso</artifactId>
+  <version>2.5.2</version>
+</dependency>
+```
+
+这两种方法分别对应了`jCenter`和`Maven Central`中的使用方法.`jCenter`中`com.squareup.picasso`就是`grounId`，通常我们以开发者的报名后面紧跟`library`的名字来命名`groupId`, `picasso`是`artifactId`,`artifactId`也就是`library`真实的名称。,后面的`2.5.2`就是当前的`version`.
+
+看到这里应该清楚其实就是`Android Studio`从`Maven`服务器上去下载我们所配置的`library`然后与我们项目一起进行编译。从`Maven`仓库上下载的是该`library`的`jar`或者`aar`文件。
+
+仓库中存储的有两种文件类型的`library`：`jar`和`aar`。`jar`包大家都知道。那什么是`aar`呢？`aar`是在`jar`的基础上进行开发的，这是因为`Androd Library`需要植入一些特有的文件，例如资源文件、`assets`、`jni`、清单文件等。而这些都不是`jar`的标准，因为`aar`就是在`jar`包的基础上新增了对其他文件的封装。当然他和`jar`包一样，在本质上都是`zip`包，下面我们看一下`aar`的目录结构:     
+```java
+- /AndroidManifest.xml
+- /classes.jar
+- /res/
+- /R.txt
+- /assets/
+- /libs/*.jar
+- /jni/<abi>/*.so
+- /proguard.txt
+- /lint.jar
+```
+
+讲到这里已经清楚了`groupId`、`artifactId`以及`aar`了，那接下来我们就讲一下具体的发布流程了:          
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/public_jcenter.png?raw=true)   
+
+在Bintray上创建一个包
+---
+               
+- 登陆[bintray](https://bintray.com/)。
+- 选择`Maven`后进入。            
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/bintray.png?raw=true)
+- 添加新包。            
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/and_new_package.png?raw=true)
+- 填写包信息            
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/add_package_information.png?raw=true)
+
+    包名这里对于单词之间要用`-`分割。
+- 然后会提示已经上传。            
+ 到这里我们已经在`bintray`上创建了一个`Maven`仓库，接下来要做的就是上传`library`。
+
+在Sonatype上传件一个`Maven Central`账户。
+---
+
+- 注册Sonatype账号      
+    在[Sonatype](https://issues.sonatype.org/secure/Dashboard.jspa)上注册账号。
+    注册完登陆后需要在`JIRA`中创建一个`issue`，这样他就会允许你上传匹配`Maven Central`提供的`GROUP_ID`的`library`。    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/create_issue.png?raw=true)
+    Project: Community Support - Open Source Project Repository Hosting              
+    Issue Type: New Project          
+    Summary: 你的 library名称的概要，比如The Cheese Library。           
+    Group Id: 输入根GROUP_ID，比如， com.charonchui。一旦批准之后，每个以com.charon开始的library都允许被上传到仓库，比如com.charonchui.xxx。        
+    Project URL: 输入任意一个你想贡献的library的URL，比如， [https://github.com/CharonChui/CyberLink4Android](https://github.com/CharonChui/CyberLink4Android)。           
+    SCM URL: 版本控制的URL，比如 [https://github.com/CharonChui/CyberLink4Android.git](https://github.com/CharonChui/CyberLink4Android.git)。         
+    其他的都不用管，写完之后创建就可以了。 然后就是开始等，大约一周左右就会获准将自己的`library`分享到`Maven Central`。
+- 下面就是`Bintray`中的账户选项中填写`Sonatype`用户名。
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/add_account.png?raw=true)
+
+- 开启自动注册功能，为了能让我们通过`jcenter`上传的`libraray`自动发布到`Maven Central`中  
+    - 使用下面的命令生成一个key。如果是windows用户需要使用cygwin。否则不能执行        
+        `gpg --gen-key`
+         后面会一步步的进行提示，按照提示输入相应内容就好。
+
+         创建完成后可以使用`gpg --list-keys`命令来查看创建key的信息.
+         接下来需要将生成的key上传到keyserver上才能发挥作用。
+        ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/list_key.png?raw=true)
+	
+	    如上图所示将`key`上传到`keyserver`让它发挥作用，运行如下命令，将下面的PUBLIC_KEY_ID替换成上面2048R/后面的数字，如我的是B861C367
+	    `gpg --keyserver hkp://pool.sks-keyservers.net --send-keys PUBLIC_KEY_ID`
+		
+    - 运行以下命令        
+    ```java
+	gpg -a --export yourmail@email.com > public_key_sender.asc
+    gpg -a --export-secret-key yourmail@email.com > private_key_sender.asc
+    ```
+    运行完上面的两个命令后，会在当前目录分别生成public_key_sender.asc以及private_key_sender.ask两个文件，下面我们就打开这两个文件的内容，填写到Bintray的`Edit Profile`页面中的`GPG`注册部分。
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/GPG.png?raw=true)
+    - 开启自动注册。          
+        在`Edit Your Profile`页面找到`Repositories`后，选择`maven`后的`edit`。然后将GPG sign uploaded files using Bintray's public/private key pair.打上勾就可以了。
+        ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/maven_edit.png?raw=true)
+        ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/maven_gpg.png?raw=true)
+
+接下来就是如何将`Android Studio`中的`Library Module`进行上传
+---
+
+首先是修改项目的`build.gradle`文件。如下:    
+```java
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        // 注意gradle版本要再1.1.2以上，之前的版本存在问题。如果在工程中/gradle/wrapper/gradle-wrapper.properties重看到当前的gradle版本为2.4，下面的配置版本就要改为1.3.0
+        classpath 'com.android.tools.build:gradle:1.2.3'
+        // 下面的部分就为新添加的。
+        // 用于上传项目到bintray
+        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.2'
+        // 用于生成javaDoc和jar，如果gradle版本为2.4及以上，下面的版本就要改为1.3，具体可参考https://github.com/dcendents/android-maven-gradle-plugin
+        classpath 'com.github.dcendents:android-maven-plugin:1.2'
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        jcenter()
+    }
+}
+```
+
+修改`local.properties`文件，在里面配置`apikey`、用户名以及密码，以便`bintray`进行验证。之所以要把这些东西配置到该文件中是因为这些信息都比较敏感，不能分享到别处，包括版本控制里面。而在创建项目的时候`local.properties`已经被添加到`.gitignore`中了，所以这些数据不会被上传：   
+需要添加如下三行代码:     
+```java
+bintray.user=YOUR_BINTRAY_USERNAME  // 这里一定要用小写，不要用CharonChui不然会报错的，因为他会根据该用户名去找指定package，如果是大写他就找不到了。
+bintray.apikey=YOUR_BINTRAY_API_KEY
+bintray.gpg.password=YOUR_GPG_PASSWORD
+```
+`Api key`可以在`Binatry`官网上面的`Edit Profile`页面下的`API Key`中获取。      
+最后要做的就是修改`library module`中的`build.gradle`文件。
+下面这是最初的状态：       
+```java
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 22
+    buildToolsVersion "22.0.1"
+
+    defaultConfig {
+        minSdkVersion 8
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+}
+```
+下面就是修改之后的文件:      
+```java
+apply plugin: 'com.android.library'
+apply plugin: 'com.github.dcendents.android-maven'
+apply plugin: "com.jfrog.bintray"
+
+// This is the library version used when deploying the artifact
+version = "1.0.0"
+
+android {
+    compileSdkVersion 22
+    buildToolsVersion "22.0.1"
+
+    defaultConfig {
+        minSdkVersion 8
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+}
+
+def siteUrl = 'https://github.com/CharonChui/CyberLink4Android'      // Homepage URL of the library
+def gitUrl = 'https://github.com/CharonChui/CyberLink4Android.git'   // Git repository URL
+group = "com.charonchui.cyberlink"                      // Maven Group ID for the artifact
+
+install {
+    repositories.mavenInstaller {
+        // This generates POM.xml with proper parameters
+        pom {
+            project {
+                packaging 'aar'
+
+                // Add your description here
+                name 'cyberlink-android'
+                description = 'CyberLink for Android is a development package for UPnP™ developers on Android development.'
+                url siteUrl
+
+                // Set your license
+                licenses {
+                    license {
+                        name 'The Apache Software License, Version 2.0'
+                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                    }
+                }
+                developers {
+                    developer {
+                        id 'CharonChui'
+                        name 'Charon Chui'
+                        email 'charon.chui@gmail.com'
+                    }
+                }
+                scm {
+                    connection gitUrl
+                    developerConnection gitUrl
+                    url siteUrl
+
+                }
+            }
+        }
+    }
+}
+
+task sourcesJar(type: Jar) {
+    from android.sourceSets.main.java.srcDirs
+    classifier = 'sources'
+}
+
+task javadoc(type: Javadoc) {
+    source = android.sourceSets.main.java.srcDirs
+    classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
+}
+
+task javadocJar(type: Jar, dependsOn: javadoc) {
+    classifier = 'javadoc'
+    from javadoc.destinationDir
+}
+artifacts {
+    archives javadocJar
+    archives sourcesJar
+}
+
+Properties properties = new Properties()
+properties.load(project.rootProject.file('local.properties').newDataInputStream())
+
+// https://github.com/bintray/gradle-bintray-plugin
+bintray {
+    user = properties.getProperty("bintray.user")
+    key = properties.getProperty("bintray.apikey")
+
+    configurations = ['archives']
+    pkg {
+        repo = "maven"
+        // it is the name that appears in bintray when logged
+        name = "cyberlink-android"
+        websiteUrl = siteUrl
+        vcsUrl = gitUrl
+        licenses = ["Apache-2.0"]
+        publish = true
+        version {
+            gpg {
+                sign = true //Determines whether to GPG sign the files. The default is false
+                passphrase = properties.getProperty("bintray.gpg.password") //Optional. The passphrase for GPG signing'
+            }
+//            mavenCentralSync {
+//                sync = true //Optional (true by default). Determines whether to sync the version to Maven Central.
+//                user = properties.getProperty("bintray.oss.user") //OSS user token
+//                password = properties.getProperty("bintray.oss.password") //OSS user password
+//                close = '1' //Optional property. By default the staging repository is closed and artifacts are released to Maven Central. You can optionally turn this behaviour off (by puting 0 as value) and release the version manually.
+//            }
+        }
+    }
+}
+```
+
+到这一步就可以开始上传到`bintray`了，接下来开启`Android Studio`的`Terminal`中。
+- 检查代码的正确性，以及编译`library`文件(`aar`,`pom`等)。执行如下命令:    
+    `./gradlew install`如果提示权限不足就用`chmod 777 gradlew`改下权限就好了，windows下直接运行`gradlew install`
+    正确的话会提示`BUILD SUCCESSFUL`
+- 上传编译的文件到`bintray`，使用如下命令:     
+    `./gradlew bintrayUpload`       
+    成功的话会提示`SUCCESSFUL`      
+接下来到`bintray`上检查一下你得`package`你会在版本区域发现新上传的版本。点击进去就能发现我们上传的`library`文件。      
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/publish_version.png?raw=true)
+
+点击该版本进入后可以看到所有的文件目录。       
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/version_list.png?raw=true)
+
+到这里你的`library`就已经上传了，任何人都可以使用，但是别高兴的太早，因为现在只是上传到了你自己的私人`Maven`仓库，而不是`jCenter`上，如果别人使用你`library`，他必须要先定义仓库的`url`， 如下:     
+```java
+repositories {
+    maven {
+        url 'https://dl.bintray.com/charonchui/maven/'
+    }
+}
+...
+  
+dependencies {
+    compile 'com.charonchui.cyberlink:cyberlink-android:1.0.0'
+}
+```
+这样终究是不方便的，因为别人还要单独的去配置你仓库的`url`那么接下来就是怎么将`bintray`上我们的仓库上传到`jCenter`中呢？      
+把`library`同步到`jCenter`上非常容易。只需要访问`bintray`，然后点击`Add to jCeter`然后在新出来的页面直接点击`Send`即可。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/add_to_jcenter.png?raw=true)
+现在我们就需要等待`bintray`团队审核我们的请求，一般会在两三个小时左右，如果审核通过，会收到一封邮件通知。通过这一步之后任何开发者都可以不用配置仓库`url`直接使用了。  
+想检查一下自己的`library`是否在`jCenter`上存在，可以直接访问[http://jcenter.bintray.com](http://jcenter.bintray.com),然后根据你的`groupId`直接进入相应的目录查看即可。这里要说一下，这个链接到`jCenter`是一个只需要做一次的操作，如果以后对你的`package`做了修改，或者发布新版本等，这些改变会自动同步到`jCenter`上。同时，如果你要像删除某一个`package`，但是在`jCenter`仓库中的`library`不会被删除。它会一直存在，没法直接删除，因此如果你想要完全删除的时候，最好在移除`package`之前先在网页上把删除每个版本。
+如何通过后也可以在`bintray`上面看到，这里已经不显示`Add to jCenter`按钮了，他会直接显示出来`jCenter`.            
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/already_add_to_jcenter.png?raw=true)
+
+到这里你就可以在项目中直接使用:　　　　　
+```java
+dependencies {
+    compile 'com.charonchui.cyberlink:cyberlink-android:1.0.0'
+}
+```
+但是，我悲剧了。提示失败了，为什么呢？　
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/library_name_error.png?raw=true)　　　　　　　　　　　　　　　　　
+原因就出来`library`这个`module name`这里，因为我这里的`module`那么是`library`所以它上传之后的路径就是`library`而不是`cyberlink-android`:     
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/libray_name_error_path.png?raw=true)　　     
+所以通过这里能看出来它是使用当前`module`的名字的。我们只能通过如下方式去使用:     
+```java
+dependencies {
+    compile 'com.charonchui.cyberlink:library:1.0.0'
+}
+```
+这样就能正常使用了。 如果有些人感觉这样不好，就想要`com.charonchui.cyberlink:cyberlink-android:1.0.0`的方式，那就将`Android Studio`中`library`的名字修改为`cyberlink-android`后重新上传发布吧。
+
+
+最后一步:上传library到Maven Central      
+---
+
+并不是所有的开发者都使用`jCenter`。仍然会有一些人在使用`Maven Central`。因为此我们仍然需要将`library`上传到`Maven Central`上。要从`jCenter`中上传到`Maven Central`之前需要先完成以下两部分:      
+
+- `Bintray`上的`pacage`已经链接到`jCenter`.
+- `Maven Central`上的仓库已经认证通过.
+
+如果确认已经完成上面的授权后，上传`library`到`Maven Central`就非常简单了，只需要在`package`的详情页面点击`Maven Central`的链接。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/publish_to_maven_central.png?raw=true)
+直接进入下一个页面:         
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/send_to_maven.png?raw=true)
+然后再出来的页面输入`Maven Central`对应的用户名和密码点击`Sync`就可以了。上传到`Maven Central`的`library`是非常严格的，比如`+`号是不能在`library`版本的依赖定义中使用的。    
+完成之后，你可以在 [Maven Central Repository](https://oss.sonatype.org/content/repositories/releases/)中找到你的`library`。
+
+总结下在使用过程中遇到的错误: 
+
+- Maven gradle插件与gradle版本要对应好，如下，不要不对应。
+    ```xml
+    // Top-level build file where you can add configuration options common to all sub-projects/modules.
+    
+    buildscript {
+        repositories {
+            jcenter()
+        }
+        dependencies {
+            classpath 'com.android.tools.build:gradle:1.3.0'
+            // 用于上传项目到bintray
+            classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.2'
+            // 用于生成javaDoc和jar
+            classpath 'com.github.dcendents:android-maven-gradle-plugin:1.3'
+            // NOTE: Do not place your application dependencies here; they belong
+            // in the individual module build.gradle files
+        }
+    }
+    
+    allprojects {
+        repositories {
+            jcenter()
+        }
+    }
+    ```
+- `windows`下执行`gradlew install`编译`javadoc`时会提示`GBK`编码错误，这时候需要修改编译时的编码，具体放狗搜下，当时我改在`mac`上用了，就没解决。
+- 编译生成`javadoc`时提示很多找不到类，不能使用`<br/>`等错误，这里建议在写注释的时候一定要规范，不要使用汉字，而且不要使用`<br/>`，`<p>`等。
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\212).md" "b/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\212).md"
new file mode 100644
index 00000000..c00f9075
--- /dev/null
+++ "b/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\212).md"
@@ -0,0 +1,658 @@
+Glide简介(上)
+===
+
+![image](https://github.com/bumptech/glide/blob/master/static/glide_logo.png)
+
+
+官网:[Glide](https://github.com/bumptech/glide)[![Maven Central](https://img.shields.io/badge/version-4.1.1-brightgreen.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.bumptech.glide/glide) 
+
+`Glide`是`Google`员工的开源项目，`Google`官方`App`中已经使用，在2015年的`Google I/O`上被推荐。
+
+`Glide`的优点:   
+
+- 使用简单
+- 可配置度高，自适应程度高
+- 支持多种数据源，网络、本地、资源、`Assets`等
+- 支持`Gif`图片。
+- 支持`WebP`。
+- 加载速度快、流畅度高。
+- `Glide`的`with()`方法不光接受`Context`，还接受`Activity`和`Fragment`，这样图片加载会和`Activity/Fragment`的生命周期保持一致，比如`Pause`状态在暂停加载，在`Resume`的时候又自动重新加载。
+- 支持设置图片加载优先级。
+- 支持缩略图，可以在同一时间加载多张图片到同一个`ImageView`中，例如可以首先加载只有`ImageView`十分之一大小的缩略图，然后等再加载完整大小的图片后会再显示到该`ImageView`上。
+- 内存占用低，`Glide`默认的`Bitmap`格式是`RGB_565`，比`ARGB_8888`格式的内存开销要小一半,所以图片质量会稍微差一些，当然这些配置都是可以修改的。
+- `Glide`缓存的图片大小是根据`ImageView`尺寸来缓存的的。这种方式优点是加载显示非常快。且可以设置缓存图片的尺寸  
+- 默认使用`HttpUrlConnection`下载图片，可以配置为`OkHttp`或者`Volley`下载，也可以自定义下载方式。
+- 默认使用两个线程池来分别执行读取缓存和下载任务，且可以自定义。
+- 默认使用手机内置存储进行磁盘缓存，可以配置为外部存储，可以配置缓存大小，图片池大小。
+- 在加载同样配置的图片时，`Glide`内存占用更少，因为`Glide`是针对每个`ImageView`适配图片大小后再存储到磁盘的，这样加载进内存的是压缩过的图片，内存占用自然就比较少。这种做法有助于减少`OutOfMemoryError`的出现。
+- 高效处理`Bitmap`，使用`Bitmap Pool`来对`Bitmap`进行复用，主动调用`recycle`回收需要回收的`Bitmap`，减小系统回收压力
+
+缺点:   
+
+- 体积相对来说比较大，目前最新版的大小在`500k`左右  
+- 当我们从远程`URL`地址下载图片时，`Picasso`相比`Glide`要快很多。可能的原因是`Picasso`下载完图片后直接将整个图片加载进内存，而`Glide`还需要针对每个`ImageView`的大小来适配压缩下载到的图片，这个过程需要耗费一定的时间。（当然我们可以使用`thumbnail()`来减少压缩的时间）
+
+### 使用方法：   
+
+```java
+repositories {
+  mavenCentral()
+  maven { url 'https://maven.google.com' }
+}
+
+dependencies {
+  compile 'com.github.bumptech.glide:glide:4.1.1'
+  annotationProcessor 'com.github.bumptech.glide:compiler:4.1.1'
+}
+```
+
+`Java`代码使用:   
+
+和`Picasso`一样，`Glide`使用`fluent interface`的模式，想要加载图片，需要至少传入三个参数:    
+
+- `with(Context context)`:`Context`是很多`android api`所必要的参数，`glide`也一样。可以传递`Activity/Fragment`，而且
+它会由`Activity/Fragment`的生命周期进行绑定。  
+- `load(String imageUrl)`:图片的`URL`地址。
+- `into(ImageView targetImageView)`:需要将加载的图片显示到的对应的`ImageView`。
+
+
+```java
+// For a simple view:
+@Override public void onCreate(Bundle savedInstanceState) {
+  ...
+  ImageView imageView = (ImageView) findViewById(R.id.my_image_view);
+
+  GlideApp.with(this).load("http://goo.gl/gEgYUd").into(imageView);
+}
+
+// For a simple image list:
+@Override public View getView(int position, View recycled, ViewGroup container) {
+  final ImageView myImageView;
+  if (recycled == null) {
+    myImageView = (ImageView) inflater.inflate(R.layout.my_image_view, container, false);
+  } else {
+    myImageView = (ImageView) recycled;
+  }
+
+  String url = myUrls.get(position);
+
+  GlideApp
+    .with(myFragment)
+    .load(url)
+    .centerCrop()
+    .placeholder(R.drawable.loading_spinner)
+    .into(myImageView);
+
+  return myImageView;
+}
+```
+
+
+`Proguard`防混淆配置:   
+```java
+-keep public class * implements com.bumptech.glide.module.GlideModule
+-keep public class * extends com.bumptech.glide.AppGlideModule
+-keep public enum com.bumptech.glide.load.resource.bitmap.ImageHeaderParser$** {
+  **[] $VALUES;
+  public *;
+}
+
+# for DexGuard only
+-keepresourcexmlelements manifest/application/meta-data@value=GlideModule
+```
+
+
+### 接下来是一些常用的方法:    
+
+- 从网络加载图片    
+
+```java
+GlideApp.with(context).load(internetUrl).into(targetImageView);
+```
+
+- 从文件加载图片  
+
+```java
+File file = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),"Test.jpg");
+GlideApp.with(context).load(file).into(imageViewFile);
+```
+
+- 加载`resource`资源   
+
+```java
+int resourceId = R.mipmap.ic_launcher;
+GlideApp.with(context).load(resourceId).into(imageViewResource);
+```
+
+- 加载`URI`地址 
+
+```java
+GlideApp.with(context).load(uri).into(imageViewUri);
+```
+
+- 设置占位图      
+
+```java
+GlideApp  
+    .with(context)
+    .load(UsageExampleListViewAdapter.eatFoodyImages[0])
+    .placeholder(R.mipmap.ic_launcher) // can also be a drawable
+    .into(imageViewPlaceholder);
+```
+
+- 设置出错时的图片  
+
+```java
+GlideApp  
+    .with(context)
+    .load("http://futurestud.io/non_existing_image.png")
+    .placeholder(R.mipmap.ic_launcher) // can also be a drawable
+    .error(R.mipmap.future_studio_launcher) // will be displayed if the image cannot be loaded
+    .into(imageViewError);
+```
+
+- `fallback`占位图  
+
+上面的`error()`展位图是当资源无法获取时使用的，例如图片地址无效，但是还有另外一种情况是你传递了`null`值。比如在一个显示用户资料列表中，由于并不是
+每个人都有头像图片，所有这时可能会传递`null`值。如果想要指定一个在传递`null`值时显示的错误图片可以使用`.fallback()`.    
+```java
+String nullString = null; // could be set to null dynamically
+
+GlideApp  
+    .with(context)
+    .load( nullString )
+    .fallback( R.drawable.floorplan )
+    .into( imageViewNoFade );
+```
+
+- 结合`ListView`使用 
+
+```java
+public static String[] eatFoodyImages = {
+        "http://i.imgur.com/rFLNqWI.jpg",
+        "http://i.imgur.com/C9pBVt7.jpg",
+        "http://i.imgur.com/rT5vXE1.jpg",
+        "http://i.imgur.com/aIy5R2k.jpg",
+        "http://i.imgur.com/MoJs9pT.jpg",
+        "http://i.imgur.com/S963yEM.jpg",
+        "http://i.imgur.com/rLR2cyc.jpg",
+        "http://i.imgur.com/SEPdUIx.jpg",
+        "http://i.imgur.com/aC9OjaM.jpg",
+        "http://i.imgur.com/76Jfv9b.jpg",
+        "http://i.imgur.com/fUX7EIB.jpg",
+        "http://i.imgur.com/syELajx.jpg",
+        "http://i.imgur.com/COzBnru.jpg",
+        "http://i.imgur.com/Z3QjilA.jpg",
+};
+
+public class UsageExampleAdapter extends AppCompatActivity {  
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.activity_usage_example_adapter);
+
+        listView.setAdapter(
+            new ImageListAdapter(
+                UsageExampleAdapter.this, 
+                eatFoodyImages
+            )
+        );
+    }
+}
+
+public class ImageListAdapter extends ArrayAdapter {  
+    private Context context;
+    private LayoutInflater inflater;
+
+    private String[] imageUrls;
+
+    public ImageListAdapter(Context context, String[] imageUrls) {
+        super(context, R.layout.listview_item_image, imageUrls);
+
+        this.context = context;
+        this.imageUrls = imageUrls;
+
+        inflater = LayoutInflater.from(context);
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+        if (null == convertView) {
+            convertView = inflater.inflate(R.layout.listview_item_image, parent, false);
+        }
+
+        GlideApp
+            .with(context)
+            .load(imageUrls[position])
+            .into((ImageView) convertView);
+
+        return convertView;
+    }
+}
+```
+
+- 图片过度`Transitions`      
+
+无论你是否使用占位图，在`UI`过程中改变`ImageView`的图片都是一个很大的动作。有一个简单的方法可以使这种改变变的更平滑，更容易让人接受，那就是使用
+`crossfade`动画。   
+```java
+GlideApp  
+    .with(context)
+    .load(UsageExampleListViewAdapter.eatFoodyImages[0])
+    .placeholder(R.mipmap.ic_launcher) // can also be a drawable
+    .error(R.mipmap.future_studio_launcher) // will be displayed if the image cannot be loaded
+    .transition(DrawableTransitionOptions.withCrossFade())// withCrossFade(int duration)方法可以传入时间，默认时间是300毫秒
+    .into(imageViewCombined);
+```
+
+- 自定义过度动画
+
+上面提供了`crossfade`动画，但是有些时候我们需要自定义更多的样式。 
+`Glide`也是支持`xml`中自定义的动画文件的。    
+```java
+GlideApp  
+    .with(context)
+      .load(eatFoodyImages[0])
+      .transition(GenericTransitionOptions.with(R.anim.zoom_in))
+      .into(imageView1);
+```
+
+- 图片大小调整     
+
+理想情况下，你的服务器或者`API`能够返回所需分辨率的图片，这是在网络带宽、内存消耗和图片质量下的完美方案。
+
+跟`Picasso`比起来，`Glide`在内存上占用更优化。`Glide`在缓存和内存里自动限制图片的大小去适配`ImageView`的尺寸。`Picasso`也有同样的能力，但需要调用`fit()`方法。用`Glide`时，如果图片不需要自动适配`ImageView`，调用`override(horizontalSize, verticalSize)`，它会在将图片显示在`ImageView`之前调整图片的大小。
+
+这个设置也有利于没有明确目标，但已知尺寸的视图上。例如，如果`app`想要预先缓存在`splash`屏幕上，还没法测量出`ImageVIews`具体宽高。但是如果你已经知道图片应当为多大，使用`override`可以提供一个指定的大小的图片。
+
+```java
+GlideApp  
+    .with(context)
+    .load(UsageExampleListViewAdapter.eatFoodyImages[0])
+    .override(600, 200) // resizes the image to these dimensions (in pixel). resize does not respect aspect ratio
+    .into(imageViewResize);
+```
+
+- 缩放图片
+
+对于任何图像的任何处理，调整图像的大小可能会扭曲长宽比，丑化图片的显示。在大多数情况下，你希望防止这种事情发生。`Glide`提供了变换去处理图片显示，通过设置`centerCrop`和`fitCenter`，可以得到两个不同的效果。`CenterCrop()`会缩放图片让图片充满整个`ImageView`的边框，然后裁掉超出的部分。`ImageVIew`会被完全填充满，但是图片可能不能完全显示出。
+`fitCenter()`会缩放图片让两边都相等或小于`ImageView`的所需求的边框。图片会被完整显示，可能不能完全填充整个`ImageView`。
+```java
+GlideApp  
+    .with(context)
+    .load(UsageExampleListViewAdapter.eatFoodyImages[0])
+    .override(600, 200) // resizes the image to these dimensions (in pixel)
+    .centerCrop() // this cropping technique scales the image so that it fills the requested bounds and then crops the extra.
+    .into(imageViewResizeCenterCrop);
+
+GlideApp  
+    .with(context)
+    .load(UsageExampleListViewAdapter.eatFoodyImages[0])
+    .override(600, 200)
+    .fitCenter() 
+    .into(imageViewResizeFitCenter);    
+```
+
+- 更变图片转换 
+
+上面介绍了两种自带的图片转换方式`fitCenter`和`centerCrop`。 但有些时候我们需要自定义一些别的转换方式，自定义转换方式需要继承`BitmapTransformation`类。  
+```java
+public class BlurTransformation extends BitmapTransformation {
+
+    public BlurTransformation(Context context) {
+        super( context );
+    }
+
+    @Override
+    protected Bitmap transform(BitmapPool pool, Bitmap toTransform, int outWidth, int outHeight) {
+        return null; // todo
+    }
+
+    @Override
+    public String getId() {
+        return null; // todo
+    }
+}
+```
+接下来使用`Renderscript`来实现图片的模糊处理。    
+
+```java
+public class BlurTransformation extends BitmapTransformation {
+
+    private RenderScript rs;
+
+    public BlurTransformation(Context context) {
+        super( context );
+
+        rs = RenderScript.create( context );
+    }
+
+    @Override
+    protected Bitmap transform(BitmapPool pool, Bitmap toTransform, int outWidth, int outHeight) {
+        Bitmap blurredBitmap = toTransform.copy( Bitmap.Config.ARGB_8888, true );
+
+        // Allocate memory for Renderscript to work with
+        Allocation input = Allocation.createFromBitmap(
+            rs, 
+            blurredBitmap, 
+            Allocation.MipmapControl.MIPMAP_FULL, 
+            Allocation.USAGE_SHARED
+        );
+        Allocation output = Allocation.createTyped(rs, input.getType());
+
+        // Load up an instance of the specific script that we want to use.
+        ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
+        script.setInput(input);
+
+        // Set the blur radius
+        script.setRadius(10);
+
+        // Start the ScriptIntrinisicBlur
+        script.forEach(output);
+
+        // Copy the output to the blurred bitmap
+        output.copyTo(blurredBitmap);
+
+        toTransform.recycle();
+
+        return blurredBitmap;
+    }
+
+    @Override
+    public String getId() {
+    	// getId()方法为这个变换描述了一个独有的识别。Glide使用那个关键字作为缓存系统的一部分。防止出现异常问题，确保其唯一。
+        return "blur";
+    }
+}
+```
+传递你的类的实例作为`.transform()`的参数。不管是图片还是`gif`都可以进行变换。
+
+```java
+GlideApp  
+	.with(context)
+	.load(eatFoodyImages[0])
+	.transform(new BlurTransformation(context))
+	.into(imageView2);
+```
+
+通常，`Glide`的`fluent interface`允许方法被连接在一起，然而变换并不是这样的。确保你只调用`.transform()`一次，不然之前的设置将会被覆盖！然而，你可以通过传递多个转换对象当作参数到`.transform()`中来进行多重变换:   
+
+```java
+GlideApp  
+    .with(context)
+    .load(eatFoodyImages[0])
+    .transform(
+        new MultiTransformation(
+        new GrayscaleTransformation(context),
+        new BlurTransformation(context)))
+    .into(imageView3);
+```
+
+- 播放`gif`动画    
+
+```java
+String gifUrl = "http://i.kinja-img.com/gawker-media/image/upload/s--B7tUiM5l--/gf2r69yorbdesguga10i.gif";
+
+GlideApp  
+    .with(context)
+    .load(gifUrl)
+    .into(imageViewGif);
+```
+
+- `gif`检查     
+
+`Glide`接受`Gif`和图片作为`load()`的参数。上面代码中潜在的一个问题，如果提供的源不是`Gif`，可能是一个普通的图片。即使是一个完好的图片(非`Gif`)，`Glide`也会加载失败。`.error()`回调方法会被调用，并加载错误占位图。这样引入了一个额外的方法`.asGif()`强迫生成一个`Gif`。 
+
+```java
+GlideApp  
+    .with(context)
+    .asGif()
+    .load(gifUrl)
+    .error(R.drawable.full_cake)
+    .into(imageViewGifAsGif);
+```
+
+- 把`Gif`当作`Bitmap`播放
+
+如果你的`app`需要显示一组网络`URL`，可能包括普通的图片或者`Gif`。在一些情况下，你可能并不在意是否要播放完整的`Gif`。如果你只是想要显示`Gif`的第一帧，当`URl`指向的的确是`Gif`，你可以调用`asBitmap()`将其作为常规图片显示。
+
+```java
+GlideApp  
+    .with(context)
+    .asBitmap()
+    .load(gifUrl)
+    .into(imageViewGifAsBitmap);
+```
+
+- 显示本地视频缩略图   
+
+```java
+String filePath = "/storage/emulated/0/Pictures/example_video.mp4";
+
+GlideApp  
+    .with(context)
+    .asBitmap()
+      .load(Uri.fromFile(new File(filePath)))
+    .into(imageViewGifAsBitmap);
+```
+
+- 缓存设置   
+
+```java
+GlideApp  
+    .with(context)
+    .load(gifUrl)
+    .asGif()
+    .error(R.drawable.full_cake)
+    .diskCacheStrategy(DiskCacheStrategy.DATA)
+    .into(imageViewGif);
+```
+
+
+- 内存缓存     
+
+默认情况下，我们不用去特意的操作缓存设置，因为`Glide`默认会使用内存和硬盘缓存，但是如果在知道某一个图片会快速变化时，你可能会关闭缓存功能。 
+
+```java
+GlideApp  
+    .with(context)
+      .load(eatFoodyImages[0])
+      .skipMemoryCache(true) 
+      .into(imageView1);
+```
+上面调用了`.skipMemoryCache(true)`方法来告诉`Glide`禁用内存缓存功能。这就意味着`Glide`不会将图片缓存到内存中，但是这只是影响内存缓存，`Glide`仍然会将图片
+缓存到硬盘中来避免下一次显示该图片时重复请求。   
+
+
+- 硬盘缓存 
+
+如上面所讲到的，即使你关闭了内存缓存，所请求的图片仍然会被保存在设备的磁盘存储上。如果你有一张不段变化的图片，但是都是用的同一个`URL`，你可能需要禁止磁盘缓存了。
+你可以用`.diskCacheStrategy()`方法改变`Glide`的行为。不同于`.skipMemoryCache()`方法，它将需要从枚举型变量中选择一个，而不是一个简单的`boolean`。如果你想要禁止请求的磁盘缓存，使用枚举型变量`DiskCacheStrategy.NONE`作为参数。
+
+```java
+GlideApp  
+    .with(context)
+      .load(eatFoodyImages[1])
+      .diskCacheStrategy(DiskCacheStrategy.NONE)
+      .into(imageView2);
+```
+上面的这种方式只是会禁用硬盘缓存，`Glide`还会使用内存缓存。如果想把内存缓存和硬盘缓存都禁用，需要把上面的两个方法都设置   
+```java
+GlideApp  
+    .with(context)
+      .load(eatFoodyImages[1])
+      .diskCacheStrategy(DiskCacheStrategy.NONE)
+      .skipMemoryCache(true)
+      .into(imageView2);
+```
+
+- 自定义磁盘缓存行为
+
+如从上面提到的，`Glide`为硬盘缓存提供了多种设置方式。`Glide`的磁盘缓存是相当复杂的。例如，`Picasso`只缓存全尺寸图片。`Glide`，会缓存原始，全尺寸的图片和额外的小版本图片。例如，如果你请求一个`1000x1000`像素的图片，你的`ImageView`是`500x500`像素，`Glide`会保存两个版本的图片到缓存里。
+
+- `DiskCacheStrategy.NONE`禁用硬盘缓存功能
+- `DiskCacheStrategy.DATA`只缓存原始的全尺寸图. 例如上面例子中`1000x1000`像素的图片
+- `DiskCacheStrategy.RESOURCE`只缓存最终剪辑转换后降低分辨的图片。例如上面离职中`500x500`像素的图片
+- `DiskCacheStrategy.AUTOMATIC`基于资源只能选择缓存策略(默认的行为)
+- `DiskCacheStrategy.ALL`缓存所有分辨率对应的类型的图片
+
+- 图片请求优先级     
+
+`Glide`支持使用`.priority()`方法来设置图片请求的优先级。   
+- `Priority.LOW`
+- `Priority.NORMAL`
+- `Priority.HIGH`
+- `Priority.IMMEDIATE`
+
+```java
+private void loadImageWithHighPriority() {  
+    GlideApp
+        .with(context)
+        .load(UsageExampleListViewAdapter.eatFoodyImages[0])
+        .priority(Priority.HIGH)
+        .into(imageViewHero);
+}
+
+private void loadImagesWithLowPriority() {  
+    GlideApp
+        .with(context)
+        .load(UsageExampleListViewAdapter.eatFoodyImages[1])
+        .priority(Priority.LOW)
+        .into(imageViewLowPrioLeft);
+
+    GlideApp
+        .with(context)
+        .load(UsageExampleListViewAdapter.eatFoodyImages[2])
+        .priority(Priority.LOW)
+        .into(imageViewLowPrioRight);
+}
+```
+
+- 缩略图  
+
+缩略图不同于前面文章中提到的占位图。占位图应当是跟`app`绑定在一起的资源。缩略图是一个动态的占位图，可以从网络加载。缩略图也会被先加载，直到实际图片请求加载完毕。如果因为某些原因，缩略图获得的时间晚于原始图片，它并不会替代原始图片，而是简单地被忽略掉。
+
+`Glide`提供了两种产生缩略图的方式。第一种，是通过在加载的时候指定一个小的分辨率，产生一个缩略图。这个方法在`ListView`和详细视图的组合中非常有用。如果你已经在`ListView`中用到了`250x250`像素的图片，那么在在详细视图中会需要一个更大分辨率的图片。然而从用户的角度，我们已经看见了一个小版本的图片，为什么需要好几秒，同样的图片（高分辨率的）才能被再次加载出来呢？
+
+在这种情况下，从显示`250x250`像素版本的图片平滑过渡到详细视图里查看大图更有意义。`Glide`里的`.thumbnail()`方法让这个变为可能。这里`.thumbnal()`的参数是一个浮点乘法运算。
+
+
+```java
+String internetUrl = "http://i.imgur.com/DvpvklR.png";
+
+GlideApp  
+    .with(context)
+    .load(internetUrl)
+    .thumbnail(0.1f)
+    .into(imageView);
+```
+例如，如果你传递一个`0.1f`作为参数，`Glide`会加载原始图片大小的`10%`的图片。如果原始图片有`1000x1000`像素，缩略图的分辨率为`100x100`像素。
+
+为`.thumbnail()`传入一个浮点类型的参数，非常简单有效，但并不是总是有意义。如果缩略图的生成也需要从网络加载同样全分辨率图片后才可以，那这样加载速度并不会比不用缩略图快。
+因此`Glide`提供了另一个方法去加载和显示缩略图。第二种方式需要传递一个新的`Glide`请求作为参数。      
+
+```java
+String internetUrl = "http://i.imgur.com/DvpvklR.png";
+
+// setup Glide request without the into() method
+RequestBuilder<Drawable> thumbnailRequest = GlideApp  
+    .with(context)
+    .load(internetUrl);
+
+// pass the request as a a parameter to the thumbnail request
+GlideApp  
+    .with(context)
+      .load(UsageExampleGifAndVideos.gifUrl)
+      .thumbnail(thumbnailRequest)
+      .into(imageView);
+```
+区别在于第一个缩略图请求是完全独立于第二个原始请求的。缩略图可以来自不同资源或者图片URL，你可以在它上面应用不同的变换。
+
+
+
+- 旋转图片    
+
+`android.graphics.Matrix`提供了旋转的方法:  
+```java
+Bitmap toTransform = ... // your bitmap source
+
+Matrix matrix = new Matrix();  
+matrix.postRotate(rotateRotationAngle);
+
+Bitmap.createBitmap(toTransform, 0, 0, toTransform.getWidth(), toTransform.getHeight(), matrix, true);  
+```
+但是如果要在`Glide`中使用旋转方法，需要用`BitmapTransformation()`进行包裹:   
+```java
+public class RotateTransformation extends BitmapTransformation {
+
+    private float rotateRotationAngle = 0f;
+
+    public RotateTransformation(Context context, float rotateRotationAngle) {
+        super( context );
+
+        this.rotateRotationAngle = rotateRotationAngle;
+    }
+
+    @Override
+    protected Bitmap transform(BitmapPool pool, Bitmap toTransform, int outWidth, int outHeight) {
+        Matrix matrix = new Matrix();
+
+        matrix.postRotate(rotateRotationAngle);
+
+        return Bitmap.createBitmap(toTransform, 0, 0, toTransform.getWidth(), toTransform.getHeight(), matrix, true);
+    }
+
+    @Override
+    public String getId() {
+        return "rotate" + rotateRotationAngle;
+    }
+}
+```
+然后将上面的方法传递到`.transform()`中:  
+```java
+private void loadImageOriginal() {  
+    Glide
+        .with( context )
+        .load( eatFoodyImages[0] )
+        .into( imageView1 );
+}
+
+private void loadImageRotated() {  
+    Glide
+        .with( context )
+        .load( eatFoodyImages[0] )
+        .transform( new RotateTransformation( context, 90f ))
+        .into( imageView3 );
+}
+```
+
+
+参考
+===
+
+- [Glide — Getting Started](https://futurestud.io/tutorials/glide-getting-started)
+- [Glide — Advanced Loading](https://futurestud.io/tutorials/glide-advanced-loading)
+- [Glide — ListAdapter (ListView, GridView)](https://futurestud.io/tutorials/glide-listadapter-listview-gridview)
+- [Glide — Placeholders & Fade Animations](https://futurestud.io/tutorials/glide-placeholders-fade-animations)
+- [Glide — Image Resizing & Scaling](https://futurestud.io/tutorials/glide-image-resizing-scaling)
+- [Glide — Displaying Gifs & Video Thumbnails](https://futurestud.io/tutorials/glide-displaying-gifs-and-videos)
+- [Glide — Caching Basics](https://futurestud.io/tutorials/glide-caching-basics)
+- [Glide — Request Priorities](https://futurestud.io/tutorials/glide-request-priorities)
+- [Glide — Thumbnails](https://futurestud.io/tutorials/glide-thumbnails)
+- [Glide — Callbacks: SimpleTarget and ViewTarget for Custom View Classes](https://futurestud.io/tutorials/glide-callbacks-simpletarget-and-viewtarget-for-custom-view-classes)
+- [Glide — Exceptions: Debugging and Error Handling](https://futurestud.io/tutorials/glide-exceptions-debugging-and-error-handling)
+- [Glide — Custom Transformations](https://futurestud.io/tutorials/glide-custom-transformation)
+- [Glide — Custom Animations with animate()](https://futurestud.io/tutorials/glide-custom-animations-with-animate)
+- [Glide — Integrating Networking Stacks](https://futurestud.io/tutorials/glide-integrating-networking-stacks)
+- [Glide — Customize Glide with Modules](https://futurestud.io/tutorials/glide-customize-glide-with-modules)
+- [How to Rotate Images](https://futurestud.io/tutorials/glide-how-to-rotate-images)
+- [Glide Module Example: Customize Caching](https://futurestud.io/tutorials/glide-module-example-customize-caching)
+- [Glide Module Example: Optimizing By Loading Images In Custom Sizes](https://futurestud.io/tutorials/glide-module-example-optimizing-by-loading-images-in-custom-sizes)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- 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"
new file mode 100644
index 00000000..7c246365
--- /dev/null
+++ "b/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\213).md"
@@ -0,0 +1,477 @@
+Glide简介(下)
+===
+
+![image](https://github.com/bumptech/glide/blob/master/static/glide_logo.png)
+
+
+官网:[Glide](https://github.com/bumptech/glide)[![Maven Central](https://img.shields.io/badge/version-4.1.1-brightgreen.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.bumptech.glide/glide) 
+
+
+### `Glide`的回调:`Targets`   
+
+假设我们不想将加载的图片显示到`ImageView`上，而是只想得到对应的`Bitmap`。`Glide`提供了一种可以通过`Targets`获取`Bitmap`的方法。
+`Target`和`callback`没什么不同，都是在通过`Glide`的异步线程下载和处理后返回结果。  
+
+`Glide`提供了多个不同目的的`targets`，我们先从`BaseTarget`开始。  
+
+##### `BaseTarget`
+
+```java
+private BaseTarget target = new BaseTarget<BitmapDrawable>() {  
+  @Override
+  public void onResourceReady(BitmapDrawable bitmap, Transition<? super BitmapDrawable> transition) {
+    // do something with the bitmap
+    // for demonstration purposes, let's set it to an imageview
+    imageView1.setImageDrawable(bitmap);
+  }
+
+  @Override
+  public void getSize(SizeReadyCallback cb) {
+    cb.onSizeReady(SIZE_ORIGINAL, SIZE_ORIGINAL);
+  }
+
+  @Override
+  public void removeCallback(SizeReadyCallback cb) {}
+};
+
+private void loadImageSimpleTarget() {  
+  GlideApp
+    .with(context) // could be an issue!
+    .load(eatFoodyImages[0])
+    .into(target);
+}
+```
+需要重写`getSize`方法，并且调用`cb.onSizeReady(SIZE_ORIGINAL, SIZE_ORIGINAL);`来保证`Glide`使用最高质量的值。当然，也可以传递一个具体的值，例如
+根据`View`的大小返回。
+
+
+##### `Target`注意事项    
+
+除了刚介绍的`Target`的回调系统的一个简单版本，你要学会额外两件事。
+
+第一个是`BaseTarget`对象的定义。`Java/Android`可以允许在`.into()`内匿名定义，但这会显著增加在`Glide`处理完图片请求前`Android`垃圾回收清理匿名`target`对象的可能性。最终，会导致图片被加载了，但是回调永远不会被调用。所以，请确保将你的回调定义为一个字段对象，防止被万恶的`Android`垃圾回收给清理掉。
+
+第二个关键部分是`Glide`的`.with(context)`。这个问题实际上是`Glide`一个特性问题：当你传递了一个`context`，例如当前`app`的`activity`，当`activity`停止后，`Glide`会自动停止当前的请求。这种整合到`app`生命周期内是非常有用的，但也是很难处理的。如果你的`target`是独立于`app`的生命周期。这里的解决方案是使用`application的context`当`app`自己停止运行的时候，`Glide`会只取消掉图片的请求。请记住，再次提醒，如果你的请求需要在`activity`的生命周期以外，使用下面的代码：
+```java
+private void loadImageSimpleTargetApplicationContext() {  
+    GlideApp
+        .with(context.getApplicationContext() ) // safer!
+        .load(eatFoodyImages[1] 
+        .asBitmap()
+        .into(target2);
+}
+```
+
+##### 设置具体尺寸的`Target`    
+
+通过`Target`的另一个问题就是它没有具体的尺寸。如果在`.into()`方法的参数中传递一个`ImageView`,`Glide`会根据`ImageView`的大小来控制图片的尺寸。例如在加载一个`1000x1000`的
+图片时，但是要显示到的`ImageView`的大小是`250x250`，`Glide`会把该图片裁剪到小的尺寸来节省处理时间和内存。显示，在使用`Targets`时，这种方式并没有效果，因为根本不知道所需要的图片的大小。但是，如果你知道图片的最终所需要的尺寸时，你可以在`callback`中指定图片的尺寸来节省内存。
+
+```java
+private BaseTarget target2 = new BaseTarget<BitmapDrawable>() {  
+  @Override
+  public void onResourceReady(BitmapDrawable bitmap, Transition<? super BitmapDrawable> transition) {
+    // do something with the bitmap
+    // for demonstration purposes, let's set it to an imageview
+    imageView2.setImageDrawable(bitmap);
+  }
+
+  @Override
+  public void getSize(SizeReadyCallback cb) {
+    cb.onSizeReady(250, 250);
+  }
+
+  @Override
+  public void removeCallback(SizeReadyCallback cb) {}
+};
+
+private void loadImageSimpleTargetApplicationContext() {  
+  GlideApp
+    .with(context.getApplicationContext()) // safer!
+    .load(eatFoodyImages[1])
+    .into(target2);
+}
+```
+
+正如上面通过`cb.onSizeReady(250, 250);`来指定尺寸。    
+
+
+##### `ViewTarget`  
+
+我们不直接使用`ImageView`的原因会有很多。我们可以通过上面的方式直接获取`Bitmap`。假如现在有一个自定义`View`，`Glide`并不支持加载图片到自定义`View`中，因为它并不知道要
+将图片设置到该`View`中的哪个位置。然而，`Glide`提供了`ViewTargets`来让这种问题变的非常简单。
+下面是我们的自定义`view`:    
+
+```java
+public class FutureStudioView extends FrameLayout {  
+    ImageView iv;
+    TextView tv;
+
+    public void initialize(Context context) {
+        inflate( context, R.layout.custom_view_futurestudio, this );
+
+        iv = (ImageView) findViewById( R.id.custom_view_image );
+        tv = (TextView) findViewById( R.id.custom_view_text );
+    }
+
+    public FutureStudioView(Context context, AttributeSet attrs) {
+        super( context, attrs );
+        initialize( context );
+    }
+
+    public FutureStudioView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super( context, attrs, defStyleAttr );
+        initialize( context );
+    }
+
+    public void setImage(Drawable drawable) {
+        iv = (ImageView) findViewById( R.id.custom_view_image );
+
+        iv.setImageDrawable( drawable );
+    }
+}
+```
+因为该`View`并没有继承`ImageView`所以不能直接使用`.into()`方法。我们可以创建一个`ViewTarget`来替代`.into()`方法进行使用:   
+```java
+FutureStudioView customView = (FutureStudioView) findViewById( R.id.custom_view );
+
+viewTarget = new ViewTarget<FutureStudioView, BitmapDrawable>(customView) {  
+  @Override
+  public void onResourceReady(BitmapDrawable bitmap, Transition<? super BitmapDrawable> transition) {
+    this.view.setImage(bitmap);
+  }
+};
+
+GlideApp  
+    .with(context.getApplicationContext()) // safer!
+    .load(eatFoodyImages[2])
+    .into(viewTarget);
+```
+
+
+### 调试及`Debug`
+
+可以通过`adb`命令来开启`Glide`的调试`log` 
+`adb shell setprop log.tag.GenericRequest DEBUG`
+
+
+##### 获取异常信息   
+
+`Glide`不能直接通过`GenericRequest`类获取日志，但是我们可以获取异常信息。例如，当一个图片获取不到时，`glide`会抛出一个异常并且显示`.error()` 方法设置的错误图片。如果想明确哪里出了异常，可以通过`.listener()`方法传递一个`listener`对象进去。    
+
+首先，创建一个`listener`对象作为一个成员变量，避免被垃圾回收：
+
+```java
+private RequestListener<Bitmap> requestListener = new RequestListener<Bitmap>() {  
+  @Override
+  public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<Bitmap> target, boolean isFirstResource) {
+    // todo log exception to central service or something like that
+
+    // important to return false so the error placeholder can be placed
+    return false;
+  }
+
+  @Override
+  public boolean onResourceReady(Bitmap resource, Object model, Target<Bitmap> target, DataSource dataSource, boolean isFirstResource) {
+    // everything worked out, so probably nothing to do
+    return false;
+  }
+};
+
+GlideApp  
+    .with(context)
+    .asBitmap()
+    .load(UsageExampleListViewAdapter.eatFoodyImages[0])
+    .listener(requestListener)
+    .error(R.drawable.cupcake)
+    .into(imageViewPlaceholder);
+```
+
+
+#### 配置第三方网络库    
+
+- `OkHttp`  
+
+```java
+// image loading library Glide
+compile 'com.github.bumptech.glide:glide:4.1.1'  
+annotationProcessor 'com.github.bumptech.glide:compiler:4.1.1'
+
+// Glide's OkHttp2 Integration 
+compile 'com.github.bumptech.glide:okhttp-integration:4.1.1@aar'  
+compile 'com.squareup.okhttp:okhttp:2.7.5'  
+```
+
+- `Volley`
+
+```java
+// image loading library Glide
+compile 'com.github.bumptech.glide:glide:4.1.1'  
+annotationProcessor 'com.github.bumptech.glide:compiler:4.1.1'
+
+// Glide's Volley Integration 
+compile 'com.github.bumptech.glide:volley-integration:4.1.1@aar'  
+compile 'com.android.volley:volley:1.0.0'  
+```
+
+- `OkHttp3` 
+
+```java
+// image loading library Glide
+compile 'com.github.bumptech.glide:glide:4.1.1'  
+annotationProcessor 'com.github.bumptech.glide:compiler:4.1.1'
+
+// Glide's OkHttp3 Integration 
+compile 'com.github.bumptech.glide:okhttp3-integration:4.1.1@aar'  
+compile 'com.squareup.okhttp3:okhttp:3.8.1'  
+```
+
+#### 用`Modules`定制`Glide`
+
+
+`Glide modules`是一个全局改变`Glide`行为的抽象的方式。你需要创建`Glide`的实例，来访问`GlideBuilder`。可以通过创建一个公共的类，实现`AppGlideModule`的接口来定制`Glide`，这个接口提供了两个调整不同参数的方法，大多数情况下我们会用第一个方法`pplyOptions(Context context, GlideBuilder builder).`
+
+```java
+@GlideModule
+public class FutureStudioAppGlideModule extends AppGlideModule {  
+    @Override
+    public void applyOptions(Context context, GlideBuilder builder) {
+
+    }
+
+    @Override
+    public void registerComponents(Context context, Glide glide, Registry registry) {
+
+    }
+}
+```
+在上面的`applyOptions`方法的参数中有`GlideBuilder`对象，我们来看一下他的方法:   
+- `.setMemoryCache(MemoryCache memoryCache)`
+- `.setBitmapPool(BitmapPool bitmapPool)`
+- `.setDiskCache(DiskCache.Factory diskCacheFactory)`
+- `.setDiskCacheService(ExecutorService service)`
+- `.setResizeService(ExecutorService service)`
+- `.setDecodeFormat(DecodeFormat decodeFormat)`
+
+由于`Glide`默认使用将`bitmap`使用`RGB565`解析，下面我们就通过`GlideModule`来将图片设置为`ARGB8888`
+```java
+@GlideModule
+public class FutureStudioAppGlideModule extends AppGlideModule {  
+    @Override
+    public void applyOptions(Context context, GlideBuilder builder) {
+        builder.setDecodeFormat(DecodeFormat.PREFER_ARGB_8888);
+    }
+
+    @Override
+    public void registerComponents(Context context, Glide glide, Registry registry) {
+
+    }
+}
+```
+
+
+### 接受自签名Https证书  
+
+`Glide`内部使用标准的`HTTPUrlConnection`去下载图片。`Glide`也提供两个集成库。这三个方法优点是在安全设置上都是相当严格的。唯一的不足之处是当你从一个使用`HTTPS`，还是`self-signed`的服务器下载图片时，`Glide`并不会下载或者显示图片，因为`self-signed`认证会被认为存在安全问题。
+
+这样，你会需要去实现能够接受`self-signed`认证的网络栈。幸运地，我们已经实现并用过一个“不安全的”`OkHttpClient`。由于它提供给了一个需要集成的常规`OkHttpClient`,我们只需要拷贝并粘贴这个类:    
+```java
+public class UnsafeOkHttpClient {  
+    public static OkHttpClient getUnsafeOkHttpClient() {
+        try {
+            // Create a trust manager that does not validate certificate chains
+            final TrustManager[] trustAllCerts = new TrustManager[] {
+                    new X509TrustManager() {
+                        @Override
+                        public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
+                        }
+
+                        @Override
+                        public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
+                        }
+
+                        @Override
+                        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+                            return new java.security.cert.X509Certificate[]{};
+                        }
+                    }
+            };
+
+            // Install the all-trusting trust manager
+            final SSLContext sslContext = SSLContext.getInstance("SSL");
+            sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
+
+            // Create an ssl socket factory with our all-trusting manager
+            final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
+
+            OkHttpClient.Builder builder = new OkHttpClient.Builder();
+            builder.sslSocketFactory(sslSocketFactory, (X509TrustManager)trustAllCerts[0]);
+            builder.hostnameVerifier(new HostnameVerifier() {
+                @Override
+                public boolean verify(String hostname, SSLSession session) {
+                    return true;
+                }
+            });
+
+            OkHttpClient okHttpClient = builder.build();
+            return okHttpClient;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
+```
+该类关闭了所有`SSL`认证检查。   
+接下来我们需要将上面的方法集成到`GlideModule`中。`Glide`使用一个`ModelLoader`去链接到数据模型创建一个具体的数据类型。我们的例子中，我们需要创建一个`ModelLoader`，它连接到一个`URL`，通过`GlideUrl`类响应并转化为输入流。`Glide`需要能够创建我们的新`ModelLoader`的实例，所以我们在`.register()`方法中传入一个工厂:  
+```java
+@GlideModule
+public class UnsafeOkHttpGlideModule extends LibraryGlideModule {  
+    @Override
+    public void registerComponents(Context context, Glide glide, Registry registry) {
+        OkHttpClient client = UnsafeOkHttpClient.getUnsafeOkHttpClient();
+        registry.replace(GlideUrl.class, InputStream.class,
+                new OkHttpUrlLoader.Factory(client));
+    }
+}
+```
+
+
+### 自定义缓存
+
+`Glide`使用`MemorySizeCalculator`类来设置内存缓存的大小和`bitmap pool`。 `bitmap pool`会把图片保存到应用的栈内存中。合适的`bitmap pool`尺寸是非常必要的，因为要避免
+太大会导致内存频繁的被回收。   
+我们可以很简单的获取到`Glide`的`MemorySizeCalculator`类和默认的值:   
+```java
+MemorySizeCalculator calculator = new MemorySizeCalculator.Builder(context).build();  
+int defaultMemoryCacheSize = calculator.getMemoryCacheSize();  
+int defaultBitmapPoolSize = calculator.getBitmapPoolSize();  
+```
+
+那么如何自定义缓存大小呢？   
+```java
+@GlideModule
+public class CustomCachingGlideModule extends AppGlideModule {  
+    @Override
+    public void applyOptions(Context context, GlideBuilder builder) {
+        MemorySizeCalculator calculator = new MemorySizeCalculator.Builder(context).build();
+        int defaultMemoryCacheSize = calculator.getMemoryCacheSize();
+        int defaultBitmapPoolSize = calculator.getBitmapPoolSize();
+
+        int customMemoryCacheSize = (int) (1.2 * defaultMemoryCacheSize);
+        int customBitmapPoolSize = (int) (1.2 * defaultBitmapPoolSize);
+
+        builder.setMemoryCache(new LruResourceCache(customMemoryCacheSize));
+        builder.setBitmapPool(new LruBitmapPool(customBitmapPoolSize));
+    }
+
+    @Override
+    public void registerComponents(Context context, Glide glide, Registry registry) {
+        // nothing to do here
+    }
+}
+```
+
+- 自定义硬盘缓存    
+
+`Glide`提供了两种硬盘缓存方式`InternalCacheDiskCacheFactory`和`ExternalCacheDiskCacheFactory`。
+```java
+@GlideModule
+public class CustomCachingGlideModule extends AppGlideModule {  
+    @Override
+    public void applyOptions(Context context, GlideBuilder builder) {
+        // set disk cache size & external vs. internal
+        int cacheSize100MegaBytes = 104857600;
+
+        builder.setDiskCache(
+                new InternalCacheDiskCacheFactory(context, cacheSize100MegaBytes));
+
+        //builder.setDiskCache(
+        //        new ExternalCacheDiskCacheFactory(context, cacheSize100MegaBytes));
+    }
+
+    @Override
+    public void registerComponents(Context context, Glide glide, Registry registry) {
+        // nothing to do here
+    }
+}
+```
+
+上面的配置只是更改硬盘缓存的大小，并不会改变缓存目录，如果需要将缓存文件位置修改为指定位置，需要使用`DiskLruCacheFactory`类。 
+```java
+// or any other path
+String downloadDirectoryPath = Environment.getDownloadCacheDirectory().getPath(); 
+
+builder.setDiskCache(  
+        new DiskLruCacheFactory( downloadDirectoryPath, cacheSize100MegaBytes )
+);
+
+// In case you want to specify a cache sub folder (i.e. "glidecache"):
+//builder.setDiskCache(
+//    new DiskLruCacheFactory( downloadDirectoryPath, "glidecache", cacheSize100MegaBytes ) 
+//);
+```
+
+### 缓存总结 
+
+通过上面的设置可以发现，`Glide`一共使用了三种缓存方式:    
+
+- `Memory cache needs to implement: MemoryCache`
+- `Bitmap pool needs to implement BitmapPool`
+- `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.
+
+
+
+
+
+
+参考
+===
+
+- [Glide — Getting Started](https://futurestud.io/tutorials/glide-getting-started)
+- [Glide — Advanced Loading](https://futurestud.io/tutorials/glide-advanced-loading)
+- [Glide — ListAdapter (ListView, GridView)](https://futurestud.io/tutorials/glide-listadapter-listview-gridview)
+- [Glide — Placeholders & Fade Animations](https://futurestud.io/tutorials/glide-placeholders-fade-animations)
+- [Glide — Image Resizing & Scaling](https://futurestud.io/tutorials/glide-image-resizing-scaling)
+- [Glide — Displaying Gifs & Video Thumbnails](https://futurestud.io/tutorials/glide-displaying-gifs-and-videos)
+- [Glide — Caching Basics](https://futurestud.io/tutorials/glide-caching-basics)
+- [Glide — Request Priorities](https://futurestud.io/tutorials/glide-request-priorities)
+- [Glide — Thumbnails](https://futurestud.io/tutorials/glide-thumbnails)
+- [Glide — Callbacks: SimpleTarget and ViewTarget for Custom View Classes](https://futurestud.io/tutorials/glide-callbacks-simpletarget-and-viewtarget-for-custom-view-classes)
+- [Glide — Exceptions: Debugging and Error Handling](https://futurestud.io/tutorials/glide-exceptions-debugging-and-error-handling)
+- [Glide — Custom Transformations](https://futurestud.io/tutorials/glide-custom-transformation)
+- [Glide — Custom Animations with animate()](https://futurestud.io/tutorials/glide-custom-animations-with-animate)
+- [Glide — Integrating Networking Stacks](https://futurestud.io/tutorials/glide-integrating-networking-stacks)
+- [Glide — Customize Glide with Modules](https://futurestud.io/tutorials/glide-customize-glide-with-modules)
+- [How to Rotate Images](https://futurestud.io/tutorials/glide-how-to-rotate-images)
+- [Glide Module Example: Customize Caching](https://futurestud.io/tutorials/glide-module-example-customize-caching)
+- [Glide Module Example: Optimizing By Loading Images In Custom Sizes](https://futurestud.io/tutorials/glide-module-example-optimizing-by-loading-images-in-custom-sizes)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git "a/ImageLoaderLibrary/\345\233\276\347\211\207\345\212\240\350\275\275\345\272\223\346\257\224\350\276\203.md" "b/ImageLoaderLibrary/\345\233\276\347\211\207\345\212\240\350\275\275\345\272\223\346\257\224\350\276\203.md"
new file mode 100644
index 00000000..a3ec34f3
--- /dev/null
+++ "b/ImageLoaderLibrary/\345\233\276\347\211\207\345\212\240\350\275\275\345\272\223\346\257\224\350\276\203.md"
@@ -0,0 +1,264 @@
+图片加载库比较
+===
+
+`Android`开发过程中，图片加载基本是每个项目都必备的功能，图片加载的开源项目也比较多，从最老牌的[Android-Universal-Image-Loader](https://github.com/nostra13/Android-Universal-Image-Loader)，到后来`Google`的[Volley](https://github.com/google/volley)再到良心公司`Square`的[Picasso](https://github.com/square/picasso)以及`FaceBook`的[Fresco](https://github.com/facebook/fresco)和`Google IO`开发者大会上推荐的[Glide](https://github.com/bumptech/glide)。
+
+面对这么多的加载库我们该如何去选择？ 
+他们各有优缺点，没法绝对的来说哪个是最好的，只有根据自己的需要来选择最适合自己的，接下来我们就重点分析下这几个项目的优缺点。
+
+### `Android Universal Image Loader`
+
+最老牌的图片加载库，提供了丰富的配置，简单易用，但是从`2015.11`开始就已经停止维护了，在当前信息技术高速发展的时代，停止维护我们就只能放弃了。 
+但是不得不说，他是一个很优秀的项目。
+
+### `Glide`
+
+[![Maven Central](https://img.shields.io/badge/version-4.1.1-brightgreen.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.bumptech.glide/glide) 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/glide_rep.png?raw=true)
+
+优点:      
+
+- 支持`Gif`图片。
+- 支持`WebP`。
+- 加载速度快、流畅度高。
+- `Glide`的`with()`方法不光接受`Context`，还接受`Activity`和`Fragment`，这样图片加载会和`Activity/Fragment`的生命周期保持一致，比如`Pause`状态在暂停加载，在`Resume`的时候又自动重新加载。
+- 支持设置图片加载优先级。
+- 支持缩略图，可以在同一时间加载多张图片到同一个`ImageView`中，例如可以首先加载只有`ImageView`十分之一大小的缩略图，然后等再加载完整大小的图片后会再显示到该`ImageView`上。
+- 内存占用低，`Glide`默认的`Bitmap`格式是`RGB_565`，比`ARGB_8888`格式的内存开销要小一半,所以图片质量会稍微差一些，当然这些配置都是可以修改的。
+- `Glide`缓存的图片大小是根据`ImageView`尺寸来缓存的的。这种方式优点是加载显示非常快。且可以设置缓存图片的尺寸  
+- 默认使用`HttpUrlConnection`下载图片，可以配置为`OkHttp`或者`Volley`下载，也可以自定义下载方式。
+- 默认使用两个线程池来分别执行读取缓存和下载任务，且可以自定义。
+- 默认使用手机内置存储进行磁盘缓存，可以配置为外部存储，可以配置缓存大小，图片池大小。
+- 在加载同样配置的图片时，`Glide`内存占用更少，因为`Glide`是针对每个`ImageView`适配图片大小后再存储到磁盘的，这样加载进内存的是压缩过的图片，内存占用自然就比较少。这种做法有助于减少`OutOfMemoryError`的出现。
+- 高效处理`Bitmap`，使用`Bitmap Pool`来对`Bitmap`进行复用，主动调用`recycle`回收需要回收的`Bitmap`，减小系统回收压力
+
+
+
+默认情况下`Glide`与`Picasso`加载同样图片的内存占用比:   
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/picasso_glide_memory_compare_default.png?raw=true)
+
+配置为`ARGB_8888`的情况下`Glide`与`Picasso`加载同样图片的内存占用比:  
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/picasso_glide_memory_compare.png?raw=true)
+
+`With()`方法的比较:    
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/picasso_glide_with_method_compare.png?raw=true)
+
+
+缺点:   
+
+- 体积相对来说比较大，目前最新版的大小在`500k`左右  
+- 当我们从远程`URL`地址下载图片时，`Picasso`相比`Glide`要快很多。可能的原因是`Picasso`下载完图片后直接将整个图片加载进内存，而`Glide`还需要针对每个`ImageView`的大小来适配压缩下载到的图片，这个过程需要耗费一定的时间。（当然我们可以使用`thumbnail()`来减少压缩的时间）
+
+使用简单: 
+
+```xml
+repositories {
+  mavenCentral()
+  maven { url 'https://maven.google.com' }
+}
+
+dependencies {
+  compile 'com.github.bumptech.glide:glide:4.1.1'
+  annotationProcessor 'com.github.bumptech.glide:compiler:4.1.1'
+}
+```
+
+```java
+ImageView imageView = (ImageView) findViewById(R.id.my_image_view);
+GlideApp.with(this).load("http://goo.gl/gEgYUd").into(imageView);
+```
+
+
+### `Picasso`
+
+由良心公司`Square`开源的一款图片加载库。其实他和`Glide`很相似，所以一般会与`Glide`进行比较。           
+
+[![Maven Central](https://img.shields.io/badge/version-2.5.2-brightgreen.svg)](http://repo1.maven.org/maven2/com/squareup/picasso/picasso/2.5.2/)
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/picasso_rep.png?raw=true)
+
+优点:     
+
+- 体积更小，方法数也更少，更轻量。他的库大小及方法数基本是`Glide`的四分之一，目前为`120k`左右
+- 支持`WebP`
+- 当我们从远程`URL`地址下载图片时，`Picasso`相比`Glide`要快很多。可能的原因是`Picasso`下载完图片后直接将整个图片加载进内存，而`Glide`还需要针对每个`ImageView`的大小来适配压缩下载到的图片，这个过程需要耗费一定的时间。（当然我们可以使用`thumbnail()`来减少压缩的时间）
+
+缺点:   
+
+- `Picasso`和`Glide`在磁盘缓存策略上有很大的不同。`Picasso`缓存的是全尺寸的，而`Glide`缓存的是跟`ImageView`尺寸相同的。`Glide`的这种方式优点是加载显示非常快。而`Picasso`的方式则因为需要在显示之前重新调整大小而导致一些延迟.
+- 相对`Glide`来说更耗内存，尤其是加载大一点的图片。同样是因为上面的缓存策略不同。
+- 不支持`Gif`图片
+
+
+使用:   
+
+```java
+// Picasso
+Picasso.with(context)
+    .load("http://inthecheesefactory.com/uploads/source/glidepicasso/cover.jpg")
+    .into(ivImg);
+
+// Glide    
+Glide.with(context)
+    .load("http://inthecheesefactory.com/uploads/source/glidepicasso/cover.jpg")
+    .into(ivImg);
+```
+
+- 修改图片大小   
+
+```java
+// Picasso
+.resize(300, 200);
+
+// Glide
+.override(300, 200);
+```
+
+- 图片裁剪  
+
+```java
+// Picasso
+.centerCrop();
+
+// Glide
+.centerCrop();
+```
+
+- 设置占位图及错误图片  
+
+```java
+// Picasso
+.placeholder(R.drawable.placeholder)
+.error(R.drawable.imagenotfound)
+
+// Glide
+.placeholder(R.drawable.placeholder)
+.error(R.drawable.imagenotfound)
+```
+
+
+### `Fresco`
+
+由`Facebook`推出，自带光环。
+
+[![Maven Central](https://img.shields.io/badge/version-1.5.0-brightgreen.svg)](http://repo1.maven.org/maven2/com/facebook/fresco/fresco/1.5.0/)
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/fresco_rep.png?raw=true)
+
+
+- `Fresco`中设计有一个叫做`Image Pipeline`的模块。它负责从网络，从本地文件系统，本地资源加载图片。为了最大限度节省空间和CPU时间，它含有3级缓存设计（2级内存，1级磁盘）。
+- `Fresco`中设计有一个叫做`Drawees`模块，它会在图片加载完成前显示占位图，加载成功后自动替换为目标图片。当图片不再显示在屏幕上时，它会及时地释放内存和空间占用。
+- 如果仅用基本的图片加载功能的话，大小仅为`20k`左右
+- 解压后的图片，即`Android`中的`Bitmap`，占用大量的内存。大的内存占用势必引发更加频繁的`GC`。在`5.0`以下，`GC`将会显著地引发界面卡顿。
+在`5.0`以下系统，`Fresco`将图片放到一个特别的内存区域。当然，在图片不显示的时候，占用的内存会自动被释放。这会使得`APP`更加流畅，减少因图片内存占用而引发的`OOM`。
+`Fresco`在低端机器上表现一样出色，你再也不用因图片内存占用而思前想后。
+- 渐进式的`JPEG`图片格式已经流行数年了，渐进式图片格式先呈现大致的图片轮廓，然后随着图片下载的继续，呈现逐渐清晰的图片，这对于移动设备，尤其是慢网络有极大的利好，可带来更好的用户体验。
+`Android`本身的图片库不支持此格式，但是`Fresco`支持。使用时，和往常一样，仅仅需要提供一个图片的`URI`即可，剩下的事情，`Fresco`会处理。
+- 图片可以在任意点进行裁剪，而不是中心，即自定义居中焦点。
+- `JPEG`可以在`native`进行`resize`，避免了在缩小图片时的`OOM`风险。
+- 支持`Gif`图片。
+- 支持`WebP`。
+- 内存管理，三级缓存设计
+- 图片预览，渐进式显示效果和多图请求
+- 第一次加载和加载缓存速度都比较快
+- 下载失败之后，点击重现下载
+- 自定义占位图，自定义`overlay`, 或者进度条
+- 先显示一个低解析度的图片，等高清图下载完之后再显示高清图
+- 对于本地图，如有EXIF缩略图，在大图加载完成之前，可先显示缩略图
+- 缩放或者旋转图片
+- `Fresco`和`Glide`在内存占用上,`Fresco`更优,这是由于`Fresco`将图片放置到一块特殊的`Native`内存，这块内存的管理是由`Fresco`进行的，所以`Fresco`的体积比较庞大，会为应用增加接近`2M`的体积，这算是`Fresco`的一个缺点.
+
+缺点:   
+
+- 他也是一个非常优秀的项目，由于`Fresco`的设计需要使用`DraweeView`替代`ImageView`所以我个人来说没有选择它，
+- 由于其缓存特性，会导致应用的体积变大。
+
+使用: 
+
+- 必备功能
+
+```java
+dependencies {
+  // your app's other dependencies
+  compile 'com.facebook.fresco:fresco:1.5.0'
+}
+```
+
+- 可选功能
+
+```java
+dependencies {
+
+  // For animated GIF support
+  compile 'com.facebook.fresco:animated-gif:1.5.0'
+
+  // For WebP support, including animated WebP
+  compile 'com.facebook.fresco:animated-webp:1.5.0'
+  compile 'com.facebook.fresco:webpsupport:1.5.0'
+
+  // For WebP support, without animations
+  compile 'com.facebook.fresco:webpsupport:1.5.0'
+
+  // Provide the Android support library (you might already have this or a similar dependency)
+  compile 'com.android.support:support-core-utils:24.2.1'
+}
+```
+
+- 初始化:    
+
+```java
+[MyApplication.java]
+public class MyApplication extends Application {
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        Fresco.initialize(this);
+    }
+}
+```
+
+- 创建布局文件:   
+
+```xml
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:fresco="http://schemas.android.com/apk/res-auto"
+    android:layout_height="match_parent"
+    android:layout_width="match_parent"
+    >
+	<com.facebook.drawee.view.SimpleDraweeView
+	    android:id="@+id/my_image_view"
+	    android:layout_width="130dp"
+	    android:layout_height="130dp"
+	    fresco:placeholderImage="@drawable/my_drawable"
+	    />
+</LinearLayout>    
+```
+
+- 代码使用:   
+
+```java
+Uri uri = Uri.parse("https://raw.githubusercontent.com/facebook/fresco/master/docs/static/logo.png");
+SimpleDraweeView draweeView = (SimpleDraweeView) findViewById(R.id.my_image_view);
+draweeView.setImageURI(uri);
+```
+
+
+综上所述:对我来说`Glide`是最合适的。
+
+参考内容:   
+===
+
+- [Fresco使用指南](https://www.fresco-cn.org/)
+- [Introduction to Glide, Image Loader Library for Android, recommended by Google](https://inthecheesefactory.com/blog/get-to-know-glide-recommended-by-google/en)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git "a/JavaKnowledge/Base64\345\212\240\345\257\206.md" "b/JavaKnowledge/Base64\345\212\240\345\257\206.md"
new file mode 100644
index 00000000..1dbe14c9
--- /dev/null
+++ "b/JavaKnowledge/Base64\345\212\240\345\257\206.md"
@@ -0,0 +1,51 @@
+Base64加密
+===
+
+由来
+---
+
+为什么会有`Base64`编码呢？因为有些网络传送渠道并不支持所有的字节，例如传统的邮件只支持可见字符的传送，
+像`ASCII`码的控制字符就不能通过邮件传送。这样用途就受到了很大的限制，比如图片二进制流的每个字节不可能全部是可见字符，所以就传送不了。
+最好的方法就是在不改变传统协议的情况下，做一种扩展方案来支持二进制文件的传送。把不可打印的字符也能用可打印字符来表示，问题就解决了。
+`Base64`编码应运而生，`Base64`就是一种基于`64`个可打印字符来表示二进制数据的表示方法。
+
+原理
+---
+
+下面是`Base64`的编码表,字符选用了`A-Z、a-z、0-9、+、/`64个可打印字符。
+数值代表字符的索引，这个是标准`Base64`协议规定的，不能更改。
+64个字符用6个`bit`位就可以全部表示，一个字节有8个bit位，剩下两个`bit`就浪费掉了，这样就不得不牺牲一部分空间了。
+这里需要弄明白的就是一个`Base64`字符是8个`bit`，但是有效部分只有右边的6个`bit`，左边两个永远是0。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/base64_excel.png?raw=true)   
+
+因为`Base64`是6个`bit`那么，怎么来表示传统字符呢？那就是用４个`Base64`字符来表示3个传统字符。3*8=4*6嘛，这样就正好了。
+
+下面来看一个例子:`Man`是三个字符，一共24个`bit`，用4个`Base64`字符来凑齐24个有效位。
+红框表示的是对应的`Base64`，6个有效位转化成相应的索引值再对应`Base64`字符表，
+查出`Man`对应的`Base64`字符是`TWFU`。说到这里有个原则不知道你发现了没有，要转换成Base64的最小单位就是三个字节，
+对一个字符串来说每次都是三个字节三个字节的转换，对应的是`Base64`的四个字节。这个搞清楚了其实就差不多了。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/base64_man.png?raw=true)   
+
+
+正是因为这，所以想要转换成`Base64`最少要三个字节才可以，转换出来的`Base64`最少是4个字节，但是如果我要转换的字节不够3个怎么办？比如我想对字符`A`进行`Base64`加密。，`A`对应的第二个`Base64`的二进制位只有两个，把后边的四个补0就是了。
+所以`A`对应的`Base64`字符就是QQ。上边已经说过了，原则是`Base64`字符的最小单位是四个字符一组，那这才两个字符，后边补两个"="吧。
+其实不用"="也不耽误解码，之所以用"="，可能是考虑到多段编码后的Base64字符串拼起来也不会引起混淆。
+由此可见 Base64字符串只可能最后出现一个或两个"="，中间是不可能出现"="的。下图中字符"BC"的编码过程也是一样的。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/base64_a.png?raw=true)   
+
+总结
+---
+
+`Base64`编码是从二进制到字符的过程，像一些中文字符用不同的编码转为二进制时，产生的二进制是不一样的，
+所以最终产生的`Base64`字符也不一样。例如上网对应`utf-8`格式的`Base64`编码是`5LiK572R`,对应`GB2312`格式的`Base64`编码是`yc/N+A==`
+
+
+		
+----
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/JavaKnowledge/Git\347\256\200\344\273\213.md" "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..2d427891
--- /dev/null
+++ "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
@@ -0,0 +1,791 @@
+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)
+
+版本库
+------
+
+什么是版本库呢？版本库又名仓库，英文名`repository`，你可以简单理解成一个目录，这个目录里面的所有文件都可以被`Git`管理起来，
+每个文件的修改、删除，`Git`都能跟踪，以便任何时刻都可以追踪历史，或者在将来某个时刻可以“还原”。
+
+所以，创建一个版本库非常简单:
+
+- 创建一个空目录
+- 通过`git init`命令把这个目录变成`Git`可以管理的仓库
+    瞬间`Git`就把仓库建好了，而且告诉你是一个空的仓库`（empty Git repository）`，细心的读者可以发现当前目录下多了一个`.git`的目录，
+    这个目录是`Git`来跟踪管理版本库的，没事千万不要手动修改这个目录里面的文件，不然改乱了，就把`Git`仓库给破坏了。
+- 使用命令`git add <file>`，注意，可反复多次使用，添加多个文件；
+- 使用命令`git commit`，完成。
+
+Git的五种状态
+-------------
+
+`Git`有五种状态，你的文件可能处于其中之一:
+
+- 未修改`(origin)`
+- 已修改`(modified)`
+- 已暂存`(staged)`
+- 已提交`(committed)`
+- 已推送`(pushed)`
+
+已提交表示数据已经安全的保存在本地数据库中。
+已修改表示修改了文件，但还没保存到数据库中。
+已暂存表示对一个已修改文件的当前版本做了标记，使之包含在下次提交的快照中。
+
+`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)
+
+正常情况下，我们的工作流程就是三个步骤，分别对应上图中的三个箭头线:
+
+```shell
+git add . // 把所有文件放入暂存区
+git commit -m "comment"  // 把所有文件从暂存区提交进本地仓库
+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`文件夹中。
+工作目录会将它们解包为实际的文件以便编辑。你可以把工作目录当做**沙盒**。在你将修改提交到暂存区并记录到历史之前，可以随意更改。
+
+#### Git目录下文件的状态:
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_file_lifecycle.png?raw=true)
+你工作目录下的每一个文件都不外乎这两种状态:
+
+- 已跟踪(Tracked)    
+  已跟踪的文件是指那些被纳入了版本控制的文件，在上一次快照中有他们的记录，在工作一段时间后，它们的状态可能是未修改，已修改或
+  已放入暂存区。简而言之，已跟踪的文件就是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 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`查看当前分支下的提交记录
+
+用`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 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即可。
+
+#### 示例
+
+假设我们进入到一个新目录，其中有一个文件。 我们称其为该文件的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.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指向新的分支引用，将索引填充为该次提交的快照，
+然后将索引的内容复制到工作目录中。
+
+#### 重置的作用
+
+在以下情景中观察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 选项来一块一块地取消暂存的内容。 这样你就可以根据选择来取消暂存或恢复内容了。
+
+### `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`把当前目录所有修改的文件从`HEAD`都撤销修改。
+为什么分支的地方也是用`git checkout`这里撤销还是用它呢？他们的区别在于`--`，如果没有`--`那就是检出分支了。
+`git checkout origin/developer`  // 切换到orgin/developer分支
+
+上面介绍了两个回退操作`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`来进行撤销操作。
+
+    `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 --hard`这个命令也可以完成，这个命令可以一步到位的把你的修改完全恢复到本地仓库的未修改的状态。
+- 已提交，未推送
+    如果执行了`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 --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`撤销提交
+
+`git revert`在撤销一个提交的同时会创建一个新的提交，这是一个安全的方法，因为它不会重写提交历史。
+
+- `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 开发中通常会控制主干分支的质量，但有时还是会把错误的代码合入到远程主干。虽然可以直接回滚远程分支，但有时新的代码也已经合入，
+直接回滚后最近的提交都要重新操作。 那么有没有只移除某些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 的首字母），以防误删除文件后丢失修改的内容。
+另外一种情况是，我们想把文件从 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 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`
+- 删除`tag`
+    `git tag -d tagName`
+- 删除完`tag`后怎么推送到远程仓库，这个写法有点复杂
+    `git push origin:refs/tags/tagName`
+- 忽略文件
+    在`git`根目录下创建一个特殊的`.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`
+
+关于`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`命令。
+
+```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
+```
+现在，可以安全地切换分支并在其他地方工作。通过使用`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加上要移除的贮藏的名字来移除它。
+
+### 区间提交
+
+你想要查看 experiment 分支中还有哪些提交尚未被合并入 master 分支。 你可以使用 master..experiment 来让 Git 显示这些提交。也就是“在 experiment 分支中而不在 master 分支中的提交”。
+
+```shell
+git log master..experiment
+```
+#### 三点
+
+这个语法可以选择出被两个引用之一包含但又不被两者同时包含的提交。 再看看之前双点例子中的提交历史。 如果你想看 master 或者 experiment 中包含的但不是两者共有的提交，你可以执行：
+
+```shell
+git log master...experiment
+```
+### 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 及 filter-branch 等工具来编写故事，怎么方便后来的读者就怎么写。
+
+现在，让我们回到之前的问题上来，到底合并还是变基好？希望你能明白，这并没有一个简单的答案。 Git 是一个非常强大的工具，它允许你对
+提交历史做许多事情，但每个团队、每个项目对此的需求并不相同。 既然你已经分别学习了两者的用法，相信你能够根据实际情况作出明智的选择。
+
+总的原则是，只对尚未推送或分享给别人的本地修改执行变基操作清理历史， 从不对已推送至别处的提交执行变基操作，这样，你才能享受到两种方式带来的便利。
+
+### 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官方文档](https://git-scm.com/book/zh/v2)
+
+---
+
+- 邮箱 ：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"
new file mode 100644
index 00000000..02f9c51c
--- /dev/null
+++ "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
@@ -0,0 +1,848 @@
+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)里面放的是链表，链表中的每个节点，就是哈希表中的每个元素。
+
+![](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()方法确定键值对。
+
+扩容前后，哈希桶的长度一定会是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时，
+顺序是按照哈希桶从低到高，链表从前往后，依次遍历的。
+
+数组的特点：查询效率高，插入删除效率低。
+链表的特点：查询效率低，插入删除效率高。
+
+在HashMap底层使用数组加（链表或红黑树）的结构完美的解决了数组和链表的问题，使得查询和插入，删除的效率都很高。
+
+
+## JDK1.7
+
+HashMap在JDK1.8中发生了改变，下面的部分是基于JDK1.7的分析。HashMap主要是用数组来存储数据的，我们都知道它会对key进行哈希运算，
+哈希运算会有重复的哈希值，对于哈希值的冲突，HashMap采用链表来解决的。
+在HashMap里有这样的一句属性声明:   
+
+```java
+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
+}  
+```
+看到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数组的索引(所在的桶)。
+- 如果两个key有相同的hash值，他们会被放在table数组的同一个桶里面。
+- key的equals()方法用来确保key的唯一性。
+
+
+接下来看一下put方法:      
+
+```java
+/**
+* Associates the specified value with the specified key in this map. If the
+* map previously contained a mapping for the key, the old value is
+* replaced.
+*
+* @param key
+*            key with which the specified value is to be associated
+* @param value
+*            value to be associated with the specified key
+* @return the previous value associated with <tt>key</tt>, or <tt>null</tt>
+*         if there was no mapping for <tt>key</tt>. (A <tt>null</tt> return
+*         can also indicate that the map previously associated
+*         <tt>null</tt> with <tt>key</tt>.)
+*/
+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;
+}
+```
+再看一下get方法:
+```java
+/**
+  * Returns the value to which the specified key is mapped, or {@code null}
+  * if this map contains no mapping for the key.
+  *
+  * <p>
+  * More formally, if this map contains a mapping from a key {@code k} to a
+  * value {@code v} such that {@code (key==null ? k==null :
+  * key.equals(k))}, then this method returns {@code v}; otherwise it returns
+  * {@code null}. (There can be at most one such mapping.)
+  *
+  * </p><p>
+  * A return value of {@code null} does not <i>necessarily</i> indicate that
+  * the map contains no mapping for the key; it's also possible that the map
+  * explicitly maps the key to {@code null}. The {@link #containsKey
+  * containsKey} operation may be used to distinguish these two cases.
+  *
+  * @see #put(Object, Object)
+  */
+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;
+}
+```
+
+## JDK1.8
+
+在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)
+
+
+既然发生了变化，那这里就以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;
+        // 用于在执行过程中取消使用红黑树（拆分）箱调整大小操作的箱计数阈值，
+        // 为啥这里转成红黑树是8，而从红黑树转成链表是6？ 在hash函数设计合理的情况下，发生hash碰撞8次的几率为百万分之6，概率说话。。因为8够用了，至于为什么转回来是6，因为如果hash碰撞次数在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);
+}
+```
+
+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) 将是一个非常巧妙的设计：
+
+- 假设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)
+
+这里有一个需要注意的点就是在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了**。
+
+```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时,且只有数组长度大于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 的碰撞率可能会比较高，进而导致链表长度较长。这个时候应该优先扩容，而不是立马树化。
+
+
+## 问题
+
+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接口的一个实现类
+    
+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（旧数组的容量）。
+
+6. HashMap和HashSet的区别： 
+
+HashSet继承于AbstractSet接口，实现了Set、Cloneable、java.io.Serializable接口。HashSet不允许集合中出现重复的值。HashSet底层其实
+就是HashMap，所有对HashSet的操作其实就是对HashMap的操作。所以HashSet也不保证集合的顺序。
+
+
+参考:  
+
+- [从 JDK7 与 JDK8 对比详细分析 HashMap 的原理与优化](https://allenmistake.top/2019/05/13/hashmap/)
+- [面试必备：HashMap源码解析（JDK8）](https://blog.csdn.net/zxt0601/article/details/77413921)
+
+
+
+
+---
+- 邮箱 ：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"
new file mode 100644
index 00000000..e24c20ec
--- /dev/null
+++ "b/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md"
@@ -0,0 +1,193 @@
+HTTP与HTTPS的区别
+===
+
+## HTTP(超文本传输协议)
+
+超文本传输协议，是一个基于请求与响应，无状态的，应用层的协议，常基于TCP/IP协议传输数据，互联网上应用最为广泛的一种网络协议,所有的WWW文件都必须遵守这个标准。设计HTTP的初衷是为了提供一种发布和接收HTML页面的方法。
+
+
+
+- 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连接。
+
+
+
+缺点:    
+
+- 通信使用明文（不加密），内容可能会被窃听
+- 不验证通信方的身份，因此有可能遭遇伪装
+- 无法证明报文的完整性，所以有可能已遭篡改
+
+优点:    
+
+- 传输速度快
+
+
+
+### 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).    
+
+```
+HTTP + 加密 + 认证 + 完整性保护 = HTTPS
+```
+
+
+如何保证安全
+--- 
+
+一般来说网络安全关心三个问题:`CIA(confidentiality, integrity, availability)`.          
+那`https`在这三方面做的怎么样呢？        
+- `https`保证了`confidentiality`（你浏览的页面的内容如果被人中途看见，将会是一团乱码。不会发生比如和你用同一个无线网的人收到一个你发的数据包，打开来一看，就是你的密码啊银行卡信息啊)
+- `intergrity`(你浏览的页面就是你想浏览的，不会被黑客在中途修改，网站收到的数据包也是你最初发的那个，不会把你的数据给换掉，搞一个大新闻)
+- 最后一个`availability`几乎没有提供（虽然我个人认为会增加基础`DOS`等的难度，但是这个不值一提），不过`https`还提供了另一个`A`，`authentication`(你连接的是你连接的网站，而不是什么人在中途伪造了一个网站给你，专业上叫`Man In The Middle Attack`)。      
+那`https`具体保护了啥？简单来说，保护了你从连接到这个网站开始，到你关闭这个页面为止，你和这个网站之间收发的所有信息，就连`url`的一部分都被保护了。同时`DNS querying`这一步也被保护了，
+不会发生你输入`www.google.com`实际上跑到了另一个网站去了。
+
+
+
+#### 使用两把密钥的公开密钥加密
+
+公开密钥加密使用一对非对称的密钥。一把叫做私钥，另一把叫做公钥。私钥不能让其他任何人知道，而公钥则可以随意发布，任何人都可以获得。使用公钥加密方式，发送密文的一方使用对方的公钥进行加密处理，对方收到被加密的信息后，再使用自己的私钥进行解密。利用这种方式，不需要发送用来解密的私钥，也不必担心密钥被攻击者窃听而盗走。
+
+
+过程
+---
+
+- 服务器把自己的公钥登录至数字证书认证机构。
+- 数字证书机构把自己的私有密钥向服务器的公开密码部署数字签名并颁发公钥证书。
+- 客户端拿到服务器的公钥证书后，使用数字证书认证机构的公开密钥，向数字证书认证机构验证公钥证书上的数字签名。以确认服务器公钥的真实性。
+- 使用服务器的公开密钥对报文加密后发送。
+- 服务器用私有密钥对报文解密。
+
+
+`HTTPS`通信的步骤
+---
+
+- 客户端发送报文进行`SSL`通信。报文中包含客户端支持的`SSL`的指定版本、加密组件列表（加密算法及密钥长度等）。
+- 服务器应答，并在应答报文中包含`SSL`版本以及加密组件。服务器的加密组件内容是从接受到的客户端加密组件内筛选出来的。
+- 服务器发送报文，报文中包含公开密钥证书。
+- 服务器发送报文通知客户端，最初阶段`SSL`握手协商部分结束。
+- `SSL`第一次握手结束之后，客户端发送一个报文作为回应。报文中包含通信加密中使用的一种被称`Pre-master secret`的随机密码串。该密码串已经使用服务器的公钥加密。
+- 客户端发送报文，并提示服务器，此后的报文通信会采用`Pre-master secret`密钥加密。
+- 客户端发送`Finished`报文。该报文包含连接至今全部报文的整体校验值。这次握手协商是否能够完成成功，要以服务器是否能够正确解密该报文作为判定标准。
+- 服务器同样发送`Change Cipher Spec`报文。
+- 服务器同样发送`Finished`报文。
+- 服务器和客户端的`Finished`报文交换完毕之后，`SSL`连接就算建立完成。
+- 应用层协议通信，即发送`HTTP`响应。
+- 最后由客户端断开链接。断开链接时，发送`close_nofify`报文。
+
+
+`HTTPS`的工作原理
+---
+
+`HTTPS`在传输数据之前需要客户端（浏览器）与服务端（网站）之间进行一次握手，在握手过程中将确立双方加密传输数据的密码信息。`TLS/SSL`协议不仅仅是一套加密传输的协议，更是一件经过艺术家精心设计的艺术品，`TLS/SSL`中使用了非对称加密，对称加密以及`HASH`算法。握手过程的简单描述如下:    
+- 浏览器将自己支持的一套加密规则发送给网站。
+- 网站从中选出一组加密算法与`HASH`算法，并将自己的身份信息以证书的形式发回给浏览器。证书里面包含了网站地址，加密公钥，以及证书的颁发机构等信息。
+- 获得网站证书之后浏览器要做以下工作:      
+
+    - 验证证书的合法性（颁发证书的机构是否合法，证书中包含的网站地址是否与正在访问的地址一致等），如果证书受信任，则浏览器栏里面会显示一个小锁头，否则会给出证书不受信的提示。
+    - 如果证书受信任，或者是用户接受了不受信的证书，浏览器会生成一串随机数的密码，并用证书中提供的公钥加密。
+    - 使用约定好的HASH计算握手消息，并使用生成的随机数对消息进行加密，最后将之前生成的所有信息发送给网站。
+
+- 网站接收浏览器发来的数据之后要做以下的操作:   
+
+    - 使用自己的私钥将信息解密取出密码，使用密码解密浏览器发来的握手消息，并验证HASH是否与浏览器发来的一致。
+    - 使用密码加密一段握手消息，发送给浏览器。
+
+- 浏览器解密并计算握手消息的`HASH`，如果与服务端发来的`HASH`一致，此时握手过程结束，之后所有的通信数据将由之前浏览器生成的随机密码并利用对称加密算法进行加密。
+
+这里浏览器与网站互相发送加密的握手消息并验证，目的是为了保证双方都获得了一致的密码，并且可以正常的加密解密数据，为后续真正数据的传输做一次测试。另外，`HTTPS`一般使用的加密与`HASH`算法如下:   
+
+- 非对称加密算法:`RSA`，`DSA/DSS`
+- 对称加密算法:`AES`，`RC4`，`3DES`
+- `HASH`算法:`MD5`，`SHA1`，`SHA256`
+
+
+其中非对称加密算法用于在握手过程中加密生成的密码，对称加密算法用于对真正传输的数据进行加密，而`HASH`算法用于验证数据的完整性。由于浏览器生成的密码是整个数据加密的关键，因此在传输的时候使用了非对称加密算法对其加密。非对称加密算法会生成公钥和私钥，公钥只能用于加密数据，因此可以随意传输，而网站的私钥用于对数据进行解密，所以网站都会非常小心的保管自己的私钥，防止泄漏。
+
+`TLS`握手过程中如果有任何错误，都会使加密连接断开，从而阻止了隐私信息的传输。正是由于`HTTPS`非常的安全，攻击者无法从中找到下手的地方，于是更多的是采用了假证书的手法来欺骗客户端，从而获取明文的信息，但是这些手段都可以被识别出来，
+
+
+优点
+---
+
+尽管`HTTPS`并非绝对安全，掌握根证书的机构、掌握加密算法的组织同样可以进行中间人形式的攻击，但`HTTPS`仍是现行架构下最安全的解决方案，主要有以下几个好处:   
+
+- 使用`HTTPS`协议可认证用户和服务器，确保数据发送到正确的客户机和服务器
+- `HTTPS`协议是由`SSL+HTTP`协议构建的可进行加密传输、身份认证的网络协议，要比`http`协议安全，可防止数据在传输过程中不被窃取、改变，确保数据的完整性。
+- `HTTPS`是现行架构下最安全的解决方案，虽然不是绝对安全，但它大幅增加了中间人攻击的成本。
+- 谷歌曾在2014年8月份调整搜索引擎算法，并称比起同等`HTTP`网站，采用`HTTPS`加密的网站在搜索结果中的排名将会更高。
+
+缺点
+---
+
+虽然说HTTPS有很大的优势，但其相对来说，还是存在不足之处的:   
+
+- `HTTPS`协议握手阶段比较费时，会使页面的加载时间延长近`50%`，增加`10%`到`20%`的耗电；
+- `HTTPS`连接缓存不如`HTTP`高效，会增加数据开销和功耗，甚至已有的安全措施也会因此而受到影响；
+- `SSL`证书需要钱，功能越强大的证书费用越高，个人网站、小网站没有必要一般不会用。
+- `SSL`证书通常需要绑定`IP`，不能在同一`IP`上绑定多个域名，`IPv4`资源不可能支撑这个消耗。
+- `HTTPS`协议的加密范围也比较有限，在黑客攻击、拒绝服务攻击、服务器劫持等方面几乎起不到什么作用。最关键的，`SSL`证书的信用链体系并不安全，特别是在某些国家可以控制`CA`根证书的情况下，中间人攻击一样可行。
+
+
+
+### 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使用更简单。技术较新，不是所有浏览器都提供了支持。
+
+
+
+
+
+
+
+
+
+
+
+----
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+    
\ No newline at end of file
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"
new file mode 100644
index 00000000..6e1a10a4
--- /dev/null
+++ "b/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
@@ -0,0 +1,499 @@
+# 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)
+
+### 堆（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`来设置。
+
+
+## 如何判断对象是垃圾
+
+### 引用计数算法
+
+在`JDK1.2`之前，使用的是引用计数器算法，即当这个类被加载到内存以后，就会产生方法区，
+堆栈、程序计数器等一系列信息，当创建对象的时候，为这个对象在堆栈空间中分配对象，
+同时会产生一个引用计数器，同时引用计数器+1，当有新的引用的时候，引用计数器继续+1，
+而当其中一个引用销毁的时候，引用计数器-1，当引用计数器被减为零的时候，
+标志着这个对象已经没有引用了，可以回收了！
+这种算法在JDK1.2之前的版本被广泛使用，但是随着业务的发展，很快出现了一个问题，那就是互相引用的问题:   
+
+```java
+ObjA.obj = ObjB
+ObjB.obj - ObjA
+```
+这样的代码会产生如下引用情形`objA`指向`objB`，而`objB`又指向`objA`，这样当其他所有的引用都消失了之后，
+`objA`和`objB`还有一个相互的引用，也就是说两个对象的引用计数器各为1，
+而实际上这两个对象都已经没有额外的引用，已经是垃圾了。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/yinyongjishu.jpg)
+
+
+### 根搜索算法
+
+根搜索算法是从离散数学中的图论引入的，程序把所有的引用关系看作一张图，
+从一个节点`GC ROOT`开始，寻找对应的引用节点，找到这个节点以后，继续寻找这个节点的引用节点，
+当所有的引用节点寻找完毕之后，剩余的节点则被认为是没有被引用到的节点，即无用的节点。           
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/genshousuo.jpg)
+
+目前java中可作为GC Root的对象有:    
+
+- 虚拟机栈中引用的对象（本地变量表）
+- 方法区中静态属性引用的对象
+- 方法区中常量引用的对象
+- 本地方法栈中引用的对象（Native对象）
+
+垃圾回收算法
+---
+
+而收集后的垃圾是通过什么算法来回收的呢：   
+
+- 标记-清除算法
+- 复制算法
+- 标记整理算法
+
+那我们就继续分析下这三种算法：  
+
+### 标记-清除算法(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收集器新生代的多线程实现，注意在进行垃圾回收的时候依然会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个阶段：
+
+- Inital Mark 初始标记
+    主要是标记GC Root开始的下级（注：仅下一级）对象，这个过程会STW，但是跟GC Root直接关联的下级对象不会很多，因此这个过程其实很快。
+
+- Concurrent Mark 并发标记
+    根据上一步的结果，继续向下标识所有关联的对象，直到这条链上的最尽头。这个过程是多线程的，虽然耗时理论上会比较长，但是其它工作线程并不会阻塞，没有STW。
+
+- Remark 再标志
+    为啥还要再标记一次？因为第2步并没有阻塞其它工作线程，其它线程在标识过程中，很有可能会产生新的垃圾。
+    试想下，高铁上的垃圾清理员，从车厢一头开始吆喝“有需要扔垃圾的乘客，请把垃圾扔一下”，一边工作一边向前走，等走到车厢另一头时，刚才走过的位置上，
+    可能又有乘客产生了新的空瓶垃圾。所以，要完全把这个车厢清理干净的话，她应该喊一下：所有乘客不要再扔垃圾了（STW），然后把新产生的垃圾收走。
+    当然，因为刚才已经把收过一遍垃圾，所以这次收集新产生的垃圾，用不了多长时间（即：STW 时间不会很长）。
+
+- Concurrent Sweep
+    并行清理，这里使用多线程以“Mark Sweep- 标记清理”算法，把垃圾清掉，其它工作线程仍然能继续支行，不会造成卡顿。
+
+等等，刚才我们不是提到过“标记清理”法，会留下很多内存碎片吗？确实，但是也没办法，如果换成“Mark Compact标记 -  整理”法，把垃圾清理后，
+剩下的对象也顺便排整理，会导致这些对象的内存地址发生变化，别忘了，此时其它线程还在工作，如果引用的对象地址变了，就天下大乱了。
+
+另外，由于这一步是并行处理，并不阻塞其它线程，所以还有一个副使用，在清理的过程中，仍然可能会有新垃圾对象产生，只能等到下一轮GC，才会被清理掉。
+不过由于CMS收集器是基于标记清除算法实现的，会导致有大量的空间碎片产生，在为大对象分配内存的时候，往往会出现老年代还有很大的空间剩余，但是无法找
+到足够大的连续空间来分配当前对象，不得不提前开启一次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选项来强制指定它。
+
+虽然仍不完美，但是从这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  
+- Good Luck! 
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..34304137
--- /dev/null
+++ "b/JavaKnowledge/JVM\346\236\266\346\236\204.md"
@@ -0,0 +1,264 @@
+# 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_Architecture.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种类型的类加载器： 
+
+    - 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但具有不同的名称空间，也将其视为不同的类。不同的名称空间意味着该类已由另一个类加载器加载。
+
+    它们遵循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)
+
+- 链接
+
+    在遵循以下属性的同时，链接涉及验证和准备已加载的类或接口，其直接父类和实现的接口以及其元素类型。
+
+    - 在链接一个类或接口之前，必须将其完全加载。
+    - 在初始化类或接口之前，必须对其进行完全验证和准备（在下一步中）。
+    - 如果在链接过程中发生错误，则会将其抛出到程序中的某个位置，在该位置，程序将采取某些操作，这些操作可能直接或间接地需要链接到错误所涉及的类或接口。
+
+    链接分为以下三个阶段： 
+
+    - 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对象读取类级别的信息（类名称，父名称，方法，变量信息，静态变量等）。
+
+[具体可参考Java内存模型](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B.md)
+
+
+
+## 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垃圾回收机制](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本身创建的，以承担系统中的后台任务（系统线程）。
+
+主应用程序线程是作为调用公共静态void main（String []）的一部分而创建的主线程，而所有其他应用程序线程都是由该主线程创建的。
+应用程序线程执行诸如执行以main（）方法开头的指令，在Heap区域中创建对象（如果它在任何方法逻辑中找到新关键字）之类的任务等。
+
+主要的系统线程有： 
+
+- Compiler threads
+
+    在运行时，这些线程将字节码编译为本地代码。
+
+- GC threads
+
+    所有与GC相关的活动均由这些线程执行。
+
+- Periodic task thread
+
+    计划周期性操作执行的计时器事件（即中断）由该线程执行。
+
+- Signal dispatcher thread
+
+    该线程接收发送到JVM进程的信号，并通过调用适当的JVM方法在JVM内部对其进行处理。
+
+- 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"
new file mode 100644
index 00000000..8e75224f
--- /dev/null
+++ "b/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
@@ -0,0 +1,239 @@
+Java内存模型
+===
+
+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区总有一个是空的。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_heap_memory.png)
+
+在并发编程中，多个线程之间采取什么机制进行通信（信息交换），什么机制进行数据的同步？在Java语言中，采用的是共享内存模型来实现多线程之间的信息交换和数据同步的。
+
+## Stack Memory
+
+栈总是与线程关联在一起的，每当创建一个线程，JVM就会为该线程创建对应的线程栈，线程stack中包含有关线程调用了哪些方法以达到当前执行点的信息，也可以称之为调用栈，只要线程执行代码，调用栈就会发生改变。在这个栈中又会包含多个栈帧(Stack Frame)，栈是由一个个栈帧组成，这些栈帧是与每个方法关联起来的，每运行一个方法就创建一个栈帧，每个栈帧会含有一些局部变量表、操作栈和方法返回值等信息。
+
+局部变量表主要存放了编译器可知的各种数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或其他与此对象相关的位置）。
+
+每当一个方法执行完成时，该栈帧就会弹出栈帧的元素作为这个方法的返回值，并且清除这个栈帧，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)
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/stack_heap.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等方法来获取信息时，这些数据都来源于方法区。
+
+方法区默认最小值为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）。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)。运行时常量池是特定于实现的数据结构，它与类文件中的常量池是一一对应映射的。因此，在最初加载类型之后，该类型的所有符号引用都驻留在该类型的运行时常量池中。包括字符串常量，类和接口名称，字段名称以及类中引用的其他常量。
+
+#### String Constant Pool
+
+在Constant Pool中还有一个单独存放字符串的String Constant Pool。
+
+```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
+```
+
+### 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内存模型并没有限制执行引起使用处理器的特定寄存器或者缓存来和主内存进行交互，也没有限制即时编译器进行调整代码执行顺序这类优化措施。
+
+JMM(Java Memory Model)规定了所有的变量都存储在主内存（Main Memory）中。每个线程还有自己的工作内存（Working Memory）,线程的工作内存中保存了该线程使用到的变量的主内存的副本拷贝，线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量（volatile变量仍然有工作内存的拷贝，但是由于它特殊的操作顺序性规定，所以看起来如同直接在主内存中读写访问一般）。不同的线程之间也无法直接访问对方工作内存中的变量，线程之间值的传递都需要通过主内存来完成。
+
+由上述对JVM内存结构的描述中，我们知道了堆和方法区是线程共享的。而局部变量，方法定义参数和异常处理器参数就不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响。
+
+Java线程之间的通信由Java内存模型(JMM)控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。
+
+假设线程A与线程B之间如要通信的话，必须要经历下面2个步骤: 
+
+1. 线程A把本地内存A中更新过的共享变量刷新到主内存中去。
+2. 线程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缓存的底层细节。
+
+
+## 问题: 匿名内部类访问局部变量时，为什么这个局部变量必须用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 .
+
+---
+
+参考
+---
+- [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/JavaKnowledge/Java\345\237\272\347\241\200\351\235\242\350\257\225\351\242\230.md" "b/JavaKnowledge/Java\345\237\272\347\241\200\351\235\242\350\257\225\351\242\230.md"
new file mode 100644
index 00000000..586f63be
--- /dev/null
+++ "b/JavaKnowledge/Java\345\237\272\347\241\200\351\235\242\350\257\225\351\242\230.md"
@@ -0,0 +1,1696 @@
+Java基础面试题
+===
+
+本部分全部内容是根据张孝祥老师的Word文档整理而来。只不过是为了方便观看，把代码部分用`markdown`来展示。整理时脑海中不断回忆起张老师上课的情景，真是怀念。
+
+1. 一个`.java`源文件中是否可以包括多个类（不是内部类）？有什么限制？            
+    可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。
+2. `Java`有没有`goto`?       
+    `java`中的保留字，现在没有在`java`中使用。
+3. 说说`&`和`&&`的区别。        
+	`&`和`&&`都可以用作逻辑与的运算符，表示逻辑与`(and)`，当运算符两边的表达式的结果都为`true`时，整个运算结果才为`true`，
+    否则，只要有一方为`false`，则结果为`false`。
+	`&&`还具有短路的功能，即如果第一个表达式为`false`，则不再计算第二个表达式，例如，对于`if(str != null && !str.equals(“”))`表达式，当`str`为`null`时，
+	后面的表达式不会执行，所以不会出现`NullPointerException`如果将`&&`改为`&`，则会抛出`NullPointerException`异常。
+
+4. 在`JAVA`中如何跳出当前的多重嵌套循环？         
+	在`Java`中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的`break`语句，即可跳出外层循环。例如，
+	```java
+	ok:
+	for(int i=0;i<10;i++) {
+		for(int j=0;j<10;j++) {
+			System.out.println(“i=” + i + “,j=” + j);
+			if(j == 5) break ok;
+		}
+	} 
+	```
+	另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制，例如，要在二维数组中查找到某个数字。
+	```java
+	int arr[][] = ...;
+	boolean found = false;
+	for(int i=0;i<arr.length && !found;i++) {
+			for(int j=0;j<arr[i].length;j++) {
+				System.out.println(“i=” + i + “,j=” + j);
+				if(arr[i][j]  == 5) {
+					found = true;
+					break;
+				}
+			}
+		} 
+	}
+	```
+5. `switch`语句能否作用在`byte`上，能否作用在`long`上，能否作用在`String`上?                   
+	在`switch（expr1）`中，`expr1`只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是`int`基本类型或`Integer`包装类型，由于，
+	`byte`,`short`,`char`都可以隐含转换为`int`，所以，这些类型以及这些类型的包装类型也是可以的。显然，`long`和`String`类型都不符合`switch`的语法规定，
+	并且不能被隐式转换成`int`类型，所以，它们不能作用于`swtich`语句中。 
+6. `short s1 = 1; s1 = s1 + 1`;有什么错? `short s1 = 1; s1 += 1`;有什么错?               
+	对于`short s1 = 1; s1 = s1 + 1`; 由于`s1+1`运算时会自动提升表达式的类型，所以结果是`int`型，再赋值给`short`类型`s1`时，编译器将报告需要强制转换类型的错误。
+	对于`short s1 = 1; s1 += 1`;由于`+=`是`java`语言规定的运算符，`java`编译器会对它进行特殊处理，因此可以正确编译。 
+7. `char`型变量中能不能存贮一个中文汉字?为什么?               
+	`char`型变量是用来存储`Unicode`编码的字符的，`unicode`编码字符集中包含了汉字，所以`char`型变量中当然可以存储汉字啦。不过，
+	如果某个特殊的汉字没有被包含在`unicode`编码字符集中，那么这个`char`型变量中就不能存储这个特殊汉字。补充说明：`unicode`编码占用两个字节，
+	所以`char`类型的变量也是占用两个字节。
+	备注：后面一部分回答虽然不是在正面回答题目，但是，为了展现自己的学识和表现自己对问题理解的透彻深入，可以回答一些相关的知识，做到知无不言，言无不尽。 
+8. 用最有效率的方法算出2乘以8等於几?             
+	`2 << 3`，            
+	因为将一个数左移`n`位，就相当于乘以了`2`的`n`次方，那么，一个数乘以8只要将其左移3位即可，而位运算`cpu`直接支持的，效率最高，
+	所以2乘以8等於几的最效率的方法是`2 << 3`。
+9. 请设计一个一百亿的计算器                   
+	首先要明白这道题目的考查点是什么，一是大家首先要对计算机原理的底层细节要清楚、要知道加减法的位运算原理和知道计算机中的算术运算会发生越界的情况，
+	二是要具备一定的面向对象的设计思想。首先，计算机中用固定数量的几个字节来存储的数值，所以计算机中能够表示的数值是有一定的范围的，
+	为了便于讲解和理解，我们先以`byte` 类型的整数为例，它用1个字节进行存储，表示的最大数值范围为-128到+127。-1在内存中对应的二进制数据为11111111，
+	如果两个-1相加，不考虑Java运算时的类型提升，运算后会产生进位，二进制结果为1,11111110，由于进位后超过了byte类型的存储空间，所以进位部分被舍弃，
+	即最终的结果为11111110，也就是-2，这正好利用溢位的方式实现了负数的运算。-128在内存中对应的二进制数据为10000000，如果两个-128相加，
+	不考虑Java运算时的类型提升，运算后会产生进位，二进制结果为1,00000000，由于进位后超过了byte类型的存储空间，所以进位部分被舍弃，
+	即最终的结果为00000000，也就是0，这样的结果显然不是我们期望的，这说明计算机中的算术运算是会发生越界情况的，
+	两个数值的运算结果不能超过计算机中的该类型的数值范围。由于Java中涉及表达式运算时的类型自动提升，
+	我们无法用byte类型来做演示这种问题和现象的实验，大家可以用下面一个使用整数做实验的例子程序体验一下：        
+	```java
+	int a = Integer.MAX_VALUE;          
+	int b = Integer.MAX_VALUE;           
+	int sum = a + b;            
+	System.out.println(“a=”+a+”,b=”+b+”,sum=”+sum);             
+	```
+	先不考虑long类型，由于int的正数范围为2的31次方，表示的最大数值约等于2*1000*1000*1000，也就是20亿的大小，所以，要实现一个一百亿的计算器，
+	我们得自己设计一个类可以用于表示很大的整数，并且提供了与另外一个整数进行加减乘除的功能，大概功能如下：            
+	（）这个类内部有两个成员变量，一个表示符号，另一个用字节数组表示数值的二进制数       
+	（）有一个构造方法，把一个包含有多位数值的字符串转换到内部的符号和字节数组中          
+	（）提供加减乘除的功能    
+	```java
+	public class BigInteger {
+		int sign;
+		byte[] val;
+		public Biginteger(String val) {
+			sign = ;
+			val = ;
+		}
+		public BigInteger add(BigInteger other) {
+		}
+		public BigInteger subtract(BigInteger other) {
+		}
+		public BigInteger multiply(BigInteger other) {
+		}
+		public BigInteger divide(BigInteger other) {
+		}
+	}
+	```
+	备注：要想写出这个类的完整代码，是非常复杂的，如果有兴趣的话，可以参看jdk中自带的java.math.BigInteger类的源码。
+	面试的人也知道谁都不可能在短时间内写出这个类的完整代码的，他要的是你是否有这方面的概念和意识，他最重要的还是考查你的能力，
+	所以，你不要因为自己无法写出完整的最终结果就放弃答这道题，你要做的就是你比别人写得多，证明你比别人强，你有这方面的思想意识就可以了，
+	毕竟别人可能连题目的意思都看不懂，什么都没写，你要敢于答这道题，即使只答了一部分，那也与那些什么都不懂的人区别出来，拉开了距离，算是矮子中的高个，
+	机会当然就属于你了。另外，答案中的框架代码也很重要，体现了一些面向对象设计的功底，特别是其中的方法命名很专业，用的英文单词很精准，
+	这也是能力、经验、专业性、英语水平等多个方面的体现，会给人留下很好的印象，在编程能力和其他方面条件差不多的情况下，英语好除了可以使你获得更多机会外，
+	薪水可以高出一千元。 
+10. 使用`final`关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？           
+	使用`final`关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。例如，对于如下语句：
+	`final StringBuffer a=new StringBuffer("immutable");`         
+	执行如下语句将报告编译期错误：         
+	`a=new StringBuffer("");`         
+	但是，执行如下语句则可以通过编译：        
+	`a.append(" broken!");`              
+	有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：        
+	```java
+	public void method(final  StringBuffer  param) {       
+	} 
+	```
+	实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：
+	`param.append("a");`
+11. `==`和`equals`方法究竟有什么区别？    
+	（单独把一个东西说清楚，然后再说清楚另一个，这样，它们的区别自然就出来了，混在一起说，则很难说清楚）
+	`==`操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，
+	只能用`==`操作符。如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，
+	例如`Objet obj = new Object();`变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。
+	对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。
+	equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：            
+	`String a=new String("foo");`           
+	`String b=new String("foo");`      
+	两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，
+	所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。
+	在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = …;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，
+	这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。
+	如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：       
+	```java
+	boolean equals(Object o){
+		return this==o;
+	}
+	```
+	这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，
+	这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，
+	那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。
+12. 静态变量和实例变量的区别？ 
+	在语法定义上的区别：静态变量前要加`static`关键字，而实例变量前则不加。     
+	在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，
+	而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。
+	总之实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
+	例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个`static Var`变量，并且每创建一个实例对象，这个staticVar就会加1；但是，每创建一个实例对象，
+	就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。
+	```java
+	public class VariantTest {
+		public static int staticVar = 0; 
+		public int instanceVar = 0; 
+		public VariantTest()
+		{
+			staticVar++;
+			instanceVar++;
+			System.out.println(“staticVar=” + staticVar + ”,instanceVar=” + instanceVar);
+		}
+	}
+	```
+	备注：这个解答除了说清楚两者的区别外，最后还用一个具体的应用例子来说明两者的差异，体现了自己有很好的解说问题和设计案例的能力，思维敏捷，
+	超过一般程序员，有写作能力！
+13. 是否可以从一个static方法内部发出对非static方法的调用？                
+	不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。
+	也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？
+	这个逻辑无法成立，所以，一个static方法内部发出对非static方法的调用。
+14. Integer与int的区别                   
+	int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，
+	即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。
+	在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，结果为0，
+	所以，int不适合作为web层的表单数据的类型。在Hibernate中，如果将OID定义为Integer类型，那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的，
+	如果将OID定义为了int类型，还需要在hbm映射文件中设置其unsaved-value属性为0。另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，
+	Integer中还定义了表示整数的最大值和最小值的常量。
+15. Math.round(11.5)等於多少? Math.round(-11.5)等於多少?                  
+	Math类中提供了三个与取整有关的方法：ceil、floor、round，这些方法的作用与它们的英文名称的含义相对应，例如，ceil的英文意义是天花板，
+	该方法就表示向上取整，所以，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，该方法就表示向下取整，
+	所以，Math.floor(11.6)的结果为11,Math.floor(-11.6)的结果是-12；最难掌握的是round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，
+	即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。
+15. 下面的代码有什么不妥之处?    
+    ```java
+	if(username.equals(“zxx”){}
+	int  x = 1;
+	    return x==1?true:false;
+    ```
+	这个我就不说了吧，你能看出来的。
+16. Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?          
+	Overload是重载的意思，Override是覆盖的意思，也就是重写。     
+	重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。
+	重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，
+	这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，
+	或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。
+	如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。
+	至于Overloaded的方法是否可以改变返回值的类型这个问题，要看你倒底想问什么呢？这个题目很模糊。如果几个Overloaded的方法的参数列表不一样，
+	它们的返回者类型当然也可以不一样。但我估计你想问的问题是：如果两个方法的参数列表完全一样，是否可以让它们的返回值不同来实现重载Overload。
+	这是不行的，我们可以用反证法来说明这个问题，因为我们有时候调用一个方法时也可以不定义返回结果变量，即不要关心其返回结果，
+	例如我们调用map.remove(key)方法时，虽然remove方法有返回值，但是我们通常都不会定义接收返回结果的变量，这时候假设该类中有两个名称和参数列表完全相同的方法，
+	仅仅是返回类型不同，java就无法确定编程者倒底是想调用哪个方法了，因为它无法通过返回结果类型来判断。 
+17. 一个房子里有椅子，椅子有腿和背，房子与椅子是什么关系，椅子与腿和背是什么关系？                    
+	如果房子有多个椅子，就是聚合关系，否则是一种关联关系，当然，聚合是一种特殊的关联。椅子与腿和背时组合关系。
+	说说has a与is a的区别。        
+	答：is-a表示的是属于得关系。比如兔子属于一种动物（继承关系）。has-a表示组合，包含关系。比如兔子包含有腿，头等组件；
+18. 分层设计的好处；             
+	把各个功能按调用流程进行了模块化，模块化带来的好处就是可以随意组合，举例说明：如果要注册一个用户，
+	流程为显示界面并通过界面接收用户的输入，接着进行业务逻辑处理，在处理业务逻辑又访问数据库，如果我们将这些步骤全部按流水帐的方式放在一个方法中编写，
+	这也是可以的，但这其中的坏处就是，当界面要修改时，由于代码全在一个方法内，可能会碰坏业务逻辑和数据库访问的码，同样，当修改业务逻辑或数据库访问的代码时，
+	也会碰坏其他部分的代码。分层就是要把界面部分、业务逻辑部分、数据库访问部分的代码放在各自独立的方法或类中编写，这样就不会出现牵一发而动全身的问题了。
+	这样分层后，还可以方便切换各层，譬如原来的界面是Swing，现在要改成BS界面，如果最初是按分层设计的，这时候不需要涉及业务和数据访问的代码，
+	只需编写一条web界面就可以了。
+   下面的仅供参考，不建议照搬照套，一定要改成自己的语言，发现内心的感受：             
+	分层的好处：            
+	- 实现了软件之间的解耦；
+	- 便于进行分工
+	- 便于维护
+	- 提高软件组件的重用
+	- 便于替换某种产品，比如持久层用的是hibernate,需要更换产品用toplink，就不用该其他业务代码，直接把配置一改。
+	- 便于产品功能的扩展。
+	- 便于适用用户需求的不断变化
+19. 序列化接口的id有什么用？                 
+   对象经常要通过IO进行传送，让你写程序传递对象，你会怎么做？把对象的状态数据用某种格式写入到硬盘，Person->“zxx,male,28,30000”?Person，
+   既然大家都要这么干，并且没有个统一的干法，于是，sun公司就提出一种统一的解决方案，它会把对象变成某个格式进行输入和输出，
+   这种格式对程序员来说是透明（transparent）的，但是，我们的某个类要想能被sun的这种方案处理，必须实现Serializable接口。      
+   ObjectOutputStream.writeObject(obj);
+   Object obj = ObjectInputStream.readObject();
+   假设两年前我保存了某个类的一个对象，这两年来，我修改该类，删除了某个属性和增加了另外一个属性，两年后，我又去读取那个保存的对象，或有什么结果？
+   未知！sun的jdk就会蒙了。为此，一个解决办法就是在类中增加版本后，每一次类的属性修改，都应该把版本号升级一下，这样，在读取时，
+   比较存储对象时的版本号与当前类的版本号，如果不一致，则直接报版本号不同的错!
+20. 面向对象的特征有哪些方面                 
+	面向对象是相对于面向过程而言的，面向过程强调的是功能，面向对象强调的是将功能封装进对象强调具备功能的对象，
+	- 思想特点好处：
+		- 是符合人们思考习惯的一种思想；
+		- 将复杂的事情简单化了；
+		- 将程序员从执行者变成了指挥者；
+	 注：比如我要达到某种结果我要是用某个功能，我就寻找能帮我达到该结果的功能的对象，如果该对象具备了该功能
+	那么我拿到该对象，也就可以使用该对象的功能。如我要洗衣服我就买洗衣机，至于怎么洗我不管。		 
+
+	面向对象的编程语言有封装、继承 、多态等3个主要的特征。          
+	- 封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式        
+		封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。
+		在面向对象的编程语言中，对象是封装的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。
+		面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，
+		方法可以直接访问同一个对象中的属性。通常情况下，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，
+		只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，就很容易找出要分配到这个类上的方法了，
+		就基本上算是会面向对象的编程了。把握一个原则：把对同一事物进行操作的方法和相关的方法放在同一个类中，把方法和它操作的数据放在同一个类中。
+		例如，人要在黑板上画圆，这一共涉及三个对象：人、黑板、圆，画圆的方法要分配给哪个对象呢？由于画圆需要使用到圆心和半径，圆心和半径显然是圆的属性，
+		如果将它们在类中定义成了私有的成员变量，那么，画圆的方法必须分配给圆，它才能访问到圆心和半径这两个属性，人以后只是调用圆的画圆方法、
+		表示给圆发给消息而已，画圆这个方法不应该分配在人这个对象上，这就是面向对象的封装性，即将对象封装成一个高度自治和相对封闭的个体，
+		对象状态（属性）由这个对象自己的行为（方法）来读取和改变。一个更便于理解的例子就是，司机将火车刹住了，刹车的动作是分配给司机，
+		还是分配给火车，显然，应该分配给火车，因为司机自身是不可能有那么大的力气将一个火车给停下来的，只有火车自己才能完成这一动作，
+		火车需要调用内部的离合器和刹车片等多个器件协作才能完成刹车这个动作，司机刹车的过程只是给火车发了一个消息，通知火车要执行刹车动作而已。
+
+	- 继承: 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。   
+		在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，
+		或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。
+
+	- 多态: 一个对象在程序不同运行时刻代表的多种状态，父类或者接口的引用指向子类对象
+		多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，
+		即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
+		因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，
+		即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。
+		例如，下面代码中的UserDao是一个接口，它定义引用变量userDao指向的实例对象由daofactory.getDao()在执行的时候返回，有时候指向的是UserJdbcDao这个实现，
+		有时候指向的是UserHibernateDao这个实现，这样，不用修改源代码，就可以改变userDao指向的具体类实现，
+		从而导致userDao.insertUser()方法调用的具体代码也随之改变，即有时候调用的是UserJdbcDao的insertUser方法，
+		有时候调用的是UserHibernateDao的insertUser方法：
+		```java
+		UserDao userDao = daofactory.getDao();  
+		userDao.insertUser(user);
+		```
+		比喻：人吃饭，你看到的是左手，还是右手？
+		
+	面向对象设计的重要经验：      
+	**谁拥有数据，谁就对外提供操作这些数据的方法。**
+	如：
+	- 人在黑板上画圆：              
+		画圆需要知道圆心的位置和圆的半径，而圆心的位置和圆的半径只有圆自己最清楚，所以画圆的方法是圆的方法。            
+		
+	- 列车司机紧急刹车：          
+		刹车的方法是司机的还是车的呢？同样，具体刹车的动作、怎么刹车只有车是清楚的，人只是发个刹车的信号给车，所以刹车的方法是车的
+		
+	面向对象的面试题：           
+	- 两块石头磨成一把石刀，石刀可以将树看成木材，木材可以做出椅子：              
+		石头磨成石刀是哪个对象的方法呢？如果是石头内部的方法的话，那么石头磨成石刀，石头自己都没了，所以石头磨成石刀不是石头内部的方法，
+		故石头变成石刀应该是一个石头加工厂的方法，将石头磨成石刀。石刀将树看成木材，所以石刀应该有一个将树看成木材的方法
+		木材可以做成椅子，所以应该有一个木材加工厂，该加工厂有一个接收木材然后加工成椅子的方法。
+	- 球从一根绳子的一端移动到另一端：
+		球这个对象应该有移动到下一个点的方法
+		绳子这个对象应该有提供下个点是哪个点的方法，以通知小球移动的方向		
+			
+21. java中实现多态的机制是什么？            
+	靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，
+	也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。 
+22. abstract class和interface有什么区别? 	          
+	含有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。
+	abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，
+	那么子类也必须定义为abstract类型。接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。
+	接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
+	下面比较一下两者的语法区别：        
+	- 抽象类可以有构造方法，接口中不能有构造方法。
+	- 抽象类中可以有普通成员变量，接口中没有普通成员变量
+	- 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
+	- 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不行）,但接口中的抽象方法只能是public类型的，
+		并且默认即为public abstract类型。
+	- 抽象类中可以包含静态方法，接口中不能包含静态方法
+	- 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
+	- 一个类可以实现多个接口，但只能继承一个抽象类。	
+23. abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?           
+	abstract的method 不可以是static的，因为抽象的方法是要被子类实现的，而static与子类扯不上关系！
+	native方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现的问题，所以，它也不能是抽象的，不能与abstract混用。
+	例如，FileOutputSteam类要硬件打交道，底层的实现用的是操作系统相关的api实现，例如，在windows用c语言实现的，所以，查看jdk 的源代码，
+	可以发现FileOutputStream的open方法的定义如下：         
+	`private native void open(String name) throws FileNotFoundException;`
+	如果我们要用java调用别人写的c语言函数，我们是无法直接调用的，我们需要按照java的要求写一个c语言的函数，又我们的这个c语言函数去调用别人的c语言函数。
+	由于我们的c语言函数是按java的要求来写的，我们这个c语言函数就可以与java对接上，java那边的对接方式就是定义出与我们这个c函数相对应的方法，
+	java中对应的方法不需要写具体的代码，但需要在前面声明native。关于synchronized与abstract合用的问题，我觉得也不行，因为在我几年的学习和开发中，
+	从来没见到过这种情况，并且我觉得synchronized应该是作用在一个具体的方法上才有意义。而且，方法上的synchronized同步所使用的同步锁对象是this，
+	而抽象方法上无法确定this是什么。 
+24. 什么是内部类？Static Nested Class 和 Inner Class的不同。      
+	内部类就是在一个类的内部定义的类，内部类中不能定义静态成员（静态成员不是对象的特性，只是为了找一个容身之处，所以需要放到一个类中而已，这么一点小事，
+	你还要把它放到类内部的一个类中，过分了啊！提供内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员类似c语言的全局变量，
+	而内部类通常是用于创建内部对象用的，所以，把“全局变量”放在内部类中就是毫无意义的事情，既然是毫无意义的事情，就应该被禁止），
+	部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中，如下所示：
+	```java
+	public class Outer {
+		int out_x  = 0;
+		public void method()
+		{
+			Inner1 inner1 = new Inner1();
+			public class Inner2   //在方法体内部定义的内部类
+			{
+				public method()
+				{
+					out_x = 3;
+				}
+			}
+			Inner2 inner2 = new Inner2();
+		}
+		public class Inner1   //在方法体外面定义的内部类
+		{
+		}			
+	}
+	```
+	在方法体外面定义的内部类的访问类型可以是public,protecte,默认的，private等4种类型，这就好像类中定义的成员变量有4种访问类型一样，
+	它们决定这个内部类的定义对其他类是否可见；对于这种情况，我们也可以在外面创建内部类的实例对象，创建内部类的实例对象时，
+	一定要先创建外部类的实例对象，然后用这个外部类的实例对象去创建内部类的实例对象，代码如下：
+	```java
+	Outer outer = new Outer();
+	Outer.Inner1 inner1 = outer.new Innner1();
+	```
+	在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。
+	这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问。这种内部类必须是先定义，
+	后使用，即内部类的定义代码必须出现在使用该类之前，这与方法中的局部变量必须先定义后使用的道理也是一样的。这种内部类可以访问方法体中的局部变量，
+	但是，该局部变量前必须加final修饰符。	
+25. 内部类可以引用它的包含类的成员吗？有没有什么限制？             
+	完全可以。如果不是静态内部类，那没有什么限制！ 
+	如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，例如，下面的代码：
+    ```java
+	class Outer {
+		static int x;
+		static class Inner
+		{
+			void test()
+			{
+				syso(x);
+			}
+		}
+	}
+    ```
+	答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态内部类不能访问外部类的成员，但你一上来就顶牛，这不好，要先顺着人家，
+	让人家满意，然后再说特殊情况，让人家吃惊。
+26. Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?                  
+	可以继承其他类或实现其他接口。不仅是可以，而是必须!
+27. super.getClass()方法调用                  
+	下面程序的输出结果是多少？
+	```java
+	import java.util.Date;
+	public  class Test extends Date{
+		public static void main(String[] args) {
+			new Test().test();
+		}
+		public void test(){
+			System.out.println(super.getClass().getName());
+		}
+	}
+	```
+	很奇怪，结果是Test           
+	这属于脑筋急转弯的题目，在一个qq群有个网友正好问过这个问题，我觉得挺有趣，就研究了一下，没想到今天还被你面到了，哈哈。         
+	在test方法中，直接调用getClass().getName()方法，返回的是Test类名        
+	由于getClass()在Object类中定义成了final，子类不能覆盖该方法，所以，在       
+	test方法中调用getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用super.getClass().getName()方法，
+	所以，super.getClass().getName()方法返回的也应该是Test。如果想得到父类的名称，应该用如下代码：       
+	`getClass().getSuperClass().getName();`
+
+28. jdk中哪些类是不能继承的？              
+	不能继承的是类是那些用final关键字修饰的类。一般比较基本的类型或防止扩展类无意间破坏原来方法的实现的类型都应该是final的，
+	在jdk中System,String,StringBuffer等都是基本类型。
+29. String是最基本的数据类型吗?                
+	基本数据类型包括byte、int、char、long、float、double、boolean和short。 
+	java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类 
+
+30. String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？                    
+	没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 "Hello"，
+	然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，
+	内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。
+	通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。
+	因为 String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，
+	而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
+	同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，
+	把它设置为初始值，应当这样做：
+	```java
+	public class Demo {
+		private String s;
+		...
+		public Demo {
+		s = "Initial Value";
+		}
+		...
+	}
+	```
+	而非
+	`s = new String("Initial Value");`
+	后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。
+	也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。
+	上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，
+	无论内容是否相同。至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。
+	在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，
+	所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，
+	即 StringBuffer。
+ 
+31. String s = new String("xyz");创建了几个String Object? 二者之间有什么区别？         
+	两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。
+	New String每写一遍，就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’，
+	这句代表就不会创建”xyz”自己了，直接从缓冲区拿。
+32. String 和StringBuffer的区别               
+	JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。String类表示内容不可改变的字符串。
+	而StringBuffer类表示内容可以被修改的字符串。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。
+	另外，String实现了equals方法，new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法，
+	所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的结果为false。 
+	接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。
+	```java
+	StringBuffer sbf = new StringBuffer();  
+	for(int i=0;i<100;i++) {
+		sbf.append(i);
+	}
+	```
+	上面的代码效率很高，因为只创建了一个StringBuffer对象，而下面的代码效率很低，因为创建了101个对象。
+	```java
+	String str = new String();  
+	for(int i=0;i<100;i++) {
+		str = str + i;
+	}
+	```
+	在讲两者区别时，应把循环的次数搞成10000，然后用endTime-beginTime来比较两者执行的时间差异，最后还要讲讲StringBuilder与StringBuffer的区别。
+	String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法，所以，将StringBuffer对象存储进Java集合类中时会出现问题。
+
+33. StringBuffer与StringBuilder的区别                 
+	StringBuffer和StringBuilder类都表示内容可以被修改的字符串，StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，
+	这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用，
+	那么最好用StringBuffer。
+
+34. 如何把一段逗号分割的字符串转换成一个数组?                   
+	如果不查jdk api，我很难写出来！我可以说说我的思路：
+	- 用正则表达式，代码大概为：String [] result = orgStr.split(“,”);
+	- 用 StingTokenizer ,代码为：
+		```java
+		StringTokenizer  tokener = StringTokenizer(orgStr,”,”);
+		String [] result = new String[tokener .countTokens()];
+		Int i=0;
+		while(tokener.hasNext(){
+			result[i++]=toker.nextToken();
+		}
+		```
+35. 数组有没有length()这个方法? String有没有length()这个方法？                
+	数组没有length()这个方法，有length的属性。String有length()这个方法。
+	
+36. 下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d";                   
+	答：对于如下代码：
+	String s1 = "a";
+	String s2 = s1 + "b";
+	String s3 = "a" + "b";
+	System.out.println(s2 == "ab");
+	System.out.println(s3 == "ab");
+	第一条语句打印的结果为false，第二条语句打印的结果为true，这说明javac编译可以对字符串常量直接相加的表达式进行优化，
+	不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。
+	题目中的第一行代码被编译器在编译时优化后，相当于直接定义了一个”abcd”的字符串，所以，上面的代码应该只创建了一个String对象。写如下两行代码，
+	```java
+	String s = "a" + "b" + "c" + "d";
+	System.out.println(s == "abcd");
+	```
+	最终打印的结果应该为true。 
+
+37. try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?                   
+	也许你的答案是在return之前，但往更细地说，我的答案是在return中间执行，请看下面程序代码的运行结果： 
+	```java
+	public  class Test {
+		/**
+		 * @param args add by zxx ,Dec 9, 2008
+		 */
+		public static void main(String[] args) {
+			// TODO Auto-generated method stub
+			System.out.println(new Test().test());;
+		}
+		static int test() {
+			int x = 1;
+			try
+			{
+				return x;
+			}
+			finally
+			{
+				++x;
+			}
+		}
+	}
+	```
+	---------执行结果 ---------
+	1
+
+	运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，
+	然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。
+38. 下面的程序代码输出的结果是多少？             
+	```java
+	public class  smallT {
+		public static void  main(String args[]) {
+			smallT t  = new  smallT();
+			int  b  =  t.get();
+			System.out.println(b);
+		}
+		public int  get() {
+			try
+			{
+				return 1 ;
+			}
+			finally
+			{
+				return 2 ;
+			}
+		}
+	}
+	返回的结果是2。
+	我可以通过下面一个例子程序来帮助我解释这个答案，从下面例子的运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，
+	也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，
+	此时函数并不是马上返回，它要执行finally语句后才真正开始返回。
+	在讲解答案时可以用下面的程序来帮助分析：   
+	```java
+	public  class Test {
+		/**
+		 * @param args add by zxx ,Dec 9, 2008
+		 */
+		public static void main(String[] args) {
+			// TODO Auto-generated method stub
+			System.out.println(new Test().test());;
+		}
+		int test() {
+			try
+			{
+				return func1();
+			}
+			finally
+			{
+				return func2();
+			}
+		}
+		int func1() {
+			System.out.println("func1");
+			return 1;
+		}
+		int func2() {
+			System.out.println("func2");
+			return 2;
+		}	
+	}
+	-----------执行结果-----------------
+	func1
+	func2
+	2
+	```
+	结论：finally中的代码比return 和break语句后执行
+39. final, finally, finalize的区别。          
+	final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。 
+	内部类要访问局部变量，局部变量必须定义成final类型.       
+	finally是异常处理语句结构的一部分，表示总是执行。       
+	finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。
+	JVM不保证此方法总被调用
+
+40. 运行时异常与一般异常有何异同？             
+	异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。
+	java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。   
+41. error和exception有什么区别?              
+	error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。 
+	exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。 
+
+42. java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？           
+	java5以前，有如下两种：     
+	第一种：      
+	```java
+	new Thread(){}.start();这表示调用Thread子类对象的run方法，new Thread(){}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下：
+	new Thread(){
+		public void run(){
+		}
+	}.start();
+	```
+	第二种：         
+	```java
+	new Thread(new Runnable(){}).start();这表示调用Thread对象接受的Runnable对象的run方法，new Runnable(){}表示一个Runnable的匿名子类的实例对象,runnable的子类加上run方法后的代码如下：
+	new Thread(new Runnable(){
+			public void run(){
+			}	
+		}
+	).start();
+	```
+	从java5开始，还有如下一些线程池创建多线程的方式：    
+	```java
+	ExecutorService pool = Executors.newFixedThreadPool(3)
+	for(int i=0;i<10;i++) {
+		pool.execute(new Runable(){public void run(){}});
+	}
+	Executors.newCachedThreadPool().execute(new Runable(){public void run(){}});
+	Executors.newSingleThreadExecutor().execute(new Runable(){public void run(){}});
+	```
+
+	两种实现方法，分别是继承Thread类与实现Runnable接口 
+	用synchronized关键字修饰同步方法 
+	反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。
+	结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。
+	此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，
+	就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。
+	若标志指出线程应当恢复，则用一个notify()重新启动线程。 
+
+43. 启动一个线程是用run()还是start()?             
+	启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。 
+
+44. 简述synchronized和java.util.concurrent.locks.Lock的异同 ？              
+	主要相同点：Lock能完成synchronized所实现的所有功能                   
+	主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，
+	并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。 
+	
+45. 设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。             
+	以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。 
+	```java
+	public class ThreadTest1 
+	{ 
+	private int j; 
+	public static void main(String args[]){ 
+	   ThreadTest1 tt=new ThreadTest1(); 
+	   Inc inc=tt.new Inc(); 
+	   Dec dec=tt.new Dec(); 
+	   for(int i=0;i<2;i++){ 
+		   Thread t=new Thread(inc); 
+		   t.start(); 
+			   t=new Thread(dec); 
+		   t.start(); 
+		   } 
+	   } 
+	private synchronized void inc(){ 
+	   j++; 
+	   System.out.println(Thread.currentThread().getName()+"-inc:"+j); 
+	   } 
+	private synchronized void dec(){ 
+	   j--; 
+	   System.out.println(Thread.currentThread().getName()+"-dec:"+j); 
+	   } 
+	class Inc implements Runnable{ 
+	   public void run(){ 
+		   for(int i=0;i<100;i++){ 
+		   inc(); 
+		   } 
+	   } 
+	} 
+	class Dec implements Runnable{ 
+	   public void run(){ 
+		   for(int i=0;i<100;i++){ 
+		   dec(); 
+		   } 
+	   } 
+	} 
+	} 
+	----------随手再写的一个-------------
+	class A {
+		JManger j =new JManager();
+		main() {
+			new A().call();
+		}
+		void call {
+			for(int i=0;i<2;i++) {
+				new Thread(
+					new Runnable(){ public void run(){while(true){j.accumulate()}}}
+				).start();
+				new Thread(new Runnable(){ public void run(){while(true){j.sub()}}}).start();
+			}
+		}
+	}
+	class JManager {
+		private j = 0;	
+		public synchronized void subtract() {
+			j--
+		}
+		public synchronized void accumulate() {
+			j++;
+		}
+	}
+	```
+	
+46. 子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序。         
+	```java
+	public class ThreadTest {
+		/**
+		 * @param args
+		 */
+		public static void main(String[] args) {
+			// TODO Auto-generated method stub
+			new ThreadTest().init();
+		}
+		public void init() {
+			final Business business = new Business();
+			new Thread(
+					new Runnable() {
+						public void run() {
+							for(int i=0;i<50;i++) {
+								business.SubThread(i);
+							}						
+						}
+					}
+			).start();
+			for(int i=0;i<50;i++) {
+				business.MainThread(i);
+			}		
+		}
+		private class Business {
+			boolean bShouldSub = true;//这里相当于定义了控制该谁执行的一个信号灯
+			public synchronized void MainThread(int i) {
+				if(bShouldSub)
+					try {
+						this.wait();
+					} catch (InterruptedException e) {
+						// TODO Auto-generated catch block
+						e.printStackTrace();
+					}		
+				for(int j=0;j<5;j++) {
+					System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);
+				}
+				bShouldSub = true;
+				this.notify();
+			}	
+			public synchronized void SubThread(int i) {
+				if(!bShouldSub)
+					try {
+						this.wait();
+					} catch (InterruptedException e) {
+						// TODO Auto-generated catch block
+						e.printStackTrace();
+					}	 
+				for(int j=0;j<10;j++) {
+					System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);
+				}
+				bShouldSub = false;				
+				this.notify();			
+			}
+		}
+	}
+	备注：不可能一上来就写出上面的完整代码，最初写出来的代码如下，问题在于两个线程的代码要参照同一个变量，即这两个线程的代码要共享数据，
+	所以，把这两个线程的执行代码搬到同一个类中去:   
+	```java
+	package com.huawei.interview.lym;
+	public class ThreadTest {
+		private static boolean bShouldMain = false;
+		public static void main(String[] args) {
+			// TODO Auto-generated method stub
+			/*new Thread(){
+			public void run() {
+				for(int i=0;i<50;i++) {
+					for(int j=0;j<10;j++) {
+						System.out.println("i=" + i + ",j=" + j);
+					}
+				}				
+			}
+		}.start();*/		
+		//final String str = new String("");
+		new Thread(
+				new Runnable() {
+					public void run() {
+						for(int i=0;i<50;i++) {
+							synchronized (ThreadTest.class) {
+								if(bShouldMain) {
+									try {
+										ThreadTest.class.wait();} 
+									catch (InterruptedException e) {
+										e.printStackTrace();
+									}
+								}
+								for(int j=0;j<10;j++) {
+									System.out.println(
+											Thread.currentThread().getName() + 
+											"i=" + i + ",j=" + j);
+								}
+								bShouldMain = true;
+								ThreadTest.class.notify();
+							}							
+						}						
+					}
+				}
+		).start();
+			
+		for(int i=0;i<50;i++) {
+			synchronized (ThreadTest.class) {
+				if(!bShouldMain) {
+					try {
+						ThreadTest.class.wait();} 
+					catch (InterruptedException e) {
+						e.printStackTrace();
+					}
+				}				
+				for(int j=0;j<5;j++) {
+					System.out.println(
+							Thread.currentThread().getName() + 						
+							"i=" + i + ",j=" + j);
+				}
+				bShouldMain = false;
+				ThreadTest.class.notify();				
+			}			
+		}
+	}
+	```
+	下面使用jdk5中的并发库来实现的:   
+	```java
+	import java.util.concurrent.Executors;
+	import java.util.concurrent.ExecutorService;
+	import java.util.concurrent.locks.Lock;
+	import java.util.concurrent.locks.ReentrantLock;
+	import java.util.concurrent.locks.Condition;
+
+	public class ThreadTest {
+		private static Lock lock = new ReentrantLock();
+		private static Condition subThreadCondition = lock.newCondition();
+		private static boolean bBhouldSubThread = false;
+		public static void main(String [] args) {
+			ExecutorService threadPool = Executors.newFixedThreadPool(3);
+			threadPool.execute(new Runnable(){
+				public void run() {
+					for(int i=0;i<50;i++) {
+						lock.lock();					
+						try {					
+							if(!bBhouldSubThread)
+								subThreadCondition.await();
+							for(int j=0;j<10;j++) {
+								System.out.println(Thread.currentThread().getName() + ",j=" + j);
+							}
+							bBhouldSubThread = false;
+							subThreadCondition.signal();
+						}catch(Exception e) {						
+						}
+						finally {
+							lock.unlock();
+						}
+					}			
+				}
+				
+			});
+			threadPool.shutdown();
+			for(int i=0;i<50;i++) {
+					lock.lock();					
+					try {	
+						if(bBhouldSubThread)
+								subThreadCondition.await();								
+						for(int j=0;j<10;j++) {
+							System.out.println(Thread.currentThread().getName() + ",j=" + j);
+						}
+						bBhouldSubThread = true;
+						subThreadCondition.signal();					
+					} catch(Exception e) {						
+					}
+					finally {
+						lock.unlock();
+					}					
+			}
+		}
+	}
+	```
+
+47. ArrayList和Vector的区别             
+	这两个类都实现了List接口（List接口继承了Collection接口），他们都是有序集合，即存储在这两个集合中的元素的位置都是有顺序的，相当于一种动态的数组，
+	我们以后可以按位置索引号取出某个元素，，并且其中的数据是允许重复的，这是HashSet之类的集合的最大不同处，HashSet之类的集合不可以按索引号去检索其中的元素，
+	也不允许有重复的元素（本来题目问的与hashset没有任何关系，但为了说清楚ArrayList与Vector的功能，我们使用对比方式，更有利于说明问题）。         
+	接着才说ArrayList与Vector的区别，这主要包括两个方面：          
+	- 同步性：
+		Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程序不安全的，它的方法之间是线程不同步的。如果只有一个线程会访问到集合，
+		那最好是使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们自己再去考虑和编写线程安全的代码。
+		备注：对于Vector&ArrayList、Hashtable&HashMap，要记住线程安全的问题，记住Vector与Hashtable是旧的，是java一诞生就提供了的，它们是线程安全的，
+		ArrayList与HashMap是java2时才提供的，它们是线程不安全的。所以，我们讲课时先讲老的。
+	- 数据增长：
+		ArrayList与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就需要增加ArrayList与Vector的存储空间，每次要增加存储空间时，
+		不是只增加一个存储单元，而是增加多个存储单元，每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍，
+		而ArrayList的增长策略在文档中没有明确规定（从源代码看到的是增长为原来的1.5倍）。ArrayList与Vector都可以设置初始的空间大小，
+		Vector还可以设置增长的空间大小，而ArrayList没有提供设置增长空间的方法。
+		总结：即Vector增长原来的一倍，ArrayList增加原来的0.5倍。
+		
+48. HashMap和Hashtable的区别           
+	HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，
+	在只有一个线程访问的情况下，效率要高于Hashtable。 
+	HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。 
+	HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。 
+	Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。 
+	最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。 
+	Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。
+	就HashMap与HashTable主要从三方面来说。         
+	- 历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现 
+	- 同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的 
+	- 值：只有HashMap可以让你将空值作为一个表的条目的key或value 
+	
+49. List 和 Map 区别?             
+	一个是存储单列数据的集合，另一个是存储键和值这样的双列数据的集合，List中存储的数据是有顺序，并且允许重复；Map中存储的数据是没有顺序的，
+	其键是不能重复的，它的值是可以有重复的。
+	
+50. List, Set, Map是否继承自Collection接口?           
+	List，Set是，Map不是 
+	
+51. List、Map、Set三个接口，存取元素时，各有什么特点？                
+	这样的题属于随意发挥题：这样的题比较考水平，两个方面的水平：一是要真正明白这些内容，二是要有较强的总结和表述能力。如果你明白，
+	但表述不清楚，在别人那里则等同于不明白。
+	首先，List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口，叫Collection。Set里面不允许有重复的元素，所谓重复，
+	即不能有两个相等（注意，不是仅仅是相同）的对象 ，即假设Set集合中有了一个A对象，现在我要向Set集合再存入一个B对象，但B对象与A对象equals相等，
+	则B对象存储不进去，所以，Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，
+	当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，
+	再逐一遍历各个元素。List表示有先后顺序的集合， 注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用add(Obj e)方法时，
+	每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Obj e)方法，
+	就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，
+	其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，
+	如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。
+	Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，
+	这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Object key)返回值为key 所对应的value。另外，也可以获得所有的key的结合，
+	还可以获得所有的value的结合，还可以获得key和value组合成的Map.Entry对象的集合。
+	List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。
+	HashSet按照hashcode值的某种运算方式进行存储，而不是直接按hashCode值的大小进行存储。
+	例如，"abc" ---> 78，"def" ---> 62，"xyz" ---> 65在hashSet中的存储顺序不是62,65,78，LinkedHashSet按插入的顺序存储，
+	那被存储对象的hashcode方法还有什么作用呢？学员想想!hashset集合比较两个对象是否相等，首先看hashcode方法是否相等，然后看equals方法是否相等。
+	new 两个Student插入到HashSet中，看HashSet的size，实现hashcode和equals方法后再看size。
+	同一个对象可以在Vector中加入多次。往集合里面加元素，相当于集合里用一根绳子连接到了目标对象。往HashSet中却加不了多次的。 
+
+52. 说出ArrayList,Vector, LinkedList的存储性能和特性              
+	ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，
+	但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，
+	而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
+	LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedList可以被当作堆栈和队列来使用。
+	
+53. 去掉一个Vector集合中重复的元素             
+	```java
+	Vector newVector = new Vector();
+	For (int i=0;i<vector.size();i++) {
+		Object obj = vector.get(i);
+		if(!newVector.contains(obj)) {
+			newVector.add(obj);
+		}	
+	}
+	```
+	还有一种简单的方式，`HashSet set = new HashSet(vector);`
+	
+54. Collection 和 Collections的区别。              
+	Collection是集合类的上级接口，继承与他的接口主要有Set 和List.    
+	Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。 
+	
+55. Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?             
+	Set里的元素是不能重复的，元素重复与否是使用equals()方法进行判断的。 
+	equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。
+
+56. 两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?            
+	对。
+	如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。
+	如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode，当然，
+	我们没有理由不实现，通常都会去实现的。
+	
+57. 字节流与字符流的区别                
+	要把一片二进制数据数据逐一输出到某个设备中，或者从某个设备中逐一读取一片二进制数据，不管输入输出设备是什么，我们要用统一的方式来完成这些操作，
+	用一种抽象的方式进行描述，这个抽象描述方式起名为IO流，对应的抽象类为OutputStream和InputStream ，不同的实现类就代表不同的输入和输出设备，
+	它们都是针对字节进行操作的。在应用中，经常要完全是字符的一段文本输出去或读进来，用字节流可以吗？计算机中的一切最终都是二进制的字节形式存在。
+	对于“中国”这些字符，首先要得到其对应的字节，然后将字节写入到输出流。读取时，首先读到的是字节，可是我们要把它显示为字符，我们需要将字节转换成字符。
+	由于这样的需求很广泛，人家专门提供了字符流的包装类。底层设备永远只接受字节数据，有时候要写字符串到底层设备，需要将字符串转成字节再进行写入。
+	字符流是字节流的包装，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备，这为我们向IO设别写入或读取字符串提供了一点点方便。
+	字符向字节转换时，要注意编码的问题，因为字符串转成字节数组，
+	其实是转成该字符的某种编码的字节形式，读取也是反之的道理。
+
+58. 垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？              
+	对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。
+	通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。可以。
+	程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。 
+ 
+59. 什么时候用assert。              
+	assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，
+	它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，
+	assert将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，
+	在软件发布后，assertion检查通常是关闭的。 
+	```java
+	package com.huawei.interview;
+	public class AssertTest {
+		/**
+		 * @param args
+		 */
+		public static void main(String[] args) {
+			// TODO Auto-generated method stub
+			int i = 0;
+			for(i=0;i<5;i++)
+			{
+				System.out.println(i);
+			}
+			//假设程序不小心多了一句--i;
+			--i;
+			assert i==5;		
+		}
+	}
+	```
+
+60. 能不能自己写个类，也叫java.lang.String？                  
+	可以，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载jre.jar包中的那个java.lang.String。
+	由于在tomcat的web应用程序中，都是由webapp自己的类加载器先自己加载WEB-INF/classess目录中的类，然后才委托上级的类加载器加载，
+	如果我们在tomcat的web应用程序中写一个java.lang.String，这时候Servlet程序加载的就是我们自己写的java.lang.String，但是这么干就会出很多潜在的问题，
+	原来所有用了java.lang.String类的都将出现问题。
+	虽然java提供了endorsed技术，可以覆盖jdk中的某些类，具体做法是….。但是，能够被覆盖的类是有限制范围，反正不包括java.lang这样的包中的类。
+	（下面的例如主要是便于大家学习理解只用，不要作为答案的一部分，否则，人家怀疑是题目泄露了）例如，运行下面的程序：
+    ```java
+	package java.lang;
+	public class String {
+		/**
+		 * @param args
+		 */
+		public static void main(String[] args) {
+			// TODO Auto-generated method stub
+			System.out.println("string");
+		}
+	}
+    ```
+	报告的错误如下：
+	java.lang.NoSuchMethodError: main
+	Exception in thread "main"
+	这是因为加载了jre自带的java.lang.String，而该类中没有main方法。
+	
+算法与编程
+---
+
+1. 判断身份证：要么是15位，要么是18位，最后一位可以为字母，并写程序提出其中的年月日。                
+	答：我们可以用正则表达式来定义复杂的字符串格式，(\d{17}[0-9a-zA-Z]|\d{14}[0-9a-zA-Z])可以用来判断是否为合法的15位或18位身份证号码。
+	因为15位和18位的身份证号码都是从7位到第12位为身份证为日期类型。这样我们可以设计出更精确的正则模式，使身份证号的日期合法，
+	这样我们的正则模式可以进一步将日期部分的正则修改为[12][0-9]{3}[01][0-9][123][0-9]，当然可以更精确的设置日期。
+	在jdk的java.util.Regex包中有实现正则的类,Pattern和Matcher。以下是实现代码：
+	```java
+	import java.util.regex.Matcher;
+	import java.util.regex.Pattern;
+	public class RegexTest {
+		/**
+		 * @param args
+		 */
+		public static void main(String[] args) {
+			// 测试是否为合法的身份证号码
+			String[] strs = { "130681198712092019", "13068119871209201x",
+					"13068119871209201", "123456789012345", "12345678901234x",
+					"1234567890123" };
+			Pattern p1 = Pattern.compile("(\\d{17}[0-9a-zA-Z]|\\d{14}[0-9a-zA-Z])");
+			for (int i = 0; i < strs.length; i++) {
+				Matcher matcher = p1.matcher(strs[i]);
+				System.out.println(strs[i] + ":" + matcher.matches());
+			}
+			Pattern p2 = Pattern.compile("\\d{6}(\\d{8}).*"); // 用于提取出生日字符串
+			Pattern p3 = Pattern.compile("(\\d{4})(\\d{2})(\\d{2})");// 用于将生日字符串进行分解为年月日
+			for (int i = 0; i < strs.length; i++) {
+				Matcher matcher = p2.matcher(strs[i]);
+				boolean b = matcher.find();
+				if (b) {
+					String s = matcher.group(1);
+					Matcher matcher2 = p3.matcher(s);
+					if (matcher2.find()) {
+						System.out
+								.println("生日为" + matcher2.group(1) + "年"
+										+ matcher2.group(2) + "月"
+										+ matcher2.group(3) + "日");
+					}
+				}
+			}
+		}
+	}
+	```
+	
+2. 编写一个程序，将a.txt文件中的单词与b.txt文件中的单词交替合并到c.txt文件中，a.txt文件中的单词用回车符分隔，b.txt文件中用回车或空格进行分隔。             
+	```java
+	package cn.itcast;
+	import java.io.File;
+	import java.io.FileReader;
+	import java.io.FileWriter;
+	public class MainClass{
+    	public static void main(String[] args) throws Exception{
+    		FileManager a = new FileManager("a.txt",new char[]{'\n'});
+    		FileManager b = new FileManager("b.txt",new char[]{'\n',' '});		
+    		FileWriter c = new FileWriter("c.txt");
+    		String aWord = null;
+    		String bWord = null;
+    		while((aWord = a.nextWord()) !=null ){
+    			c.write(aWord + "\n");
+    			bWord = b.nextWord();
+    			if(bWord != null)
+    				c.write(bWord + "\n");
+    		}
+    		while((bWord = b.nextWord()) != null){
+    			c.write(bWord + "\n");
+    		}	
+    		c.close();
+    	}
+	}
+	class FileManager{
+    	String[] words = null;
+    	int pos = 0;
+    	public FileManager(String filename,char[] seperators) throws Exception{
+    		File f = new File(filename);
+    		FileReader reader = new FileReader(f);
+    		char[] buf = new char[(int)f.length()];
+    		int len = reader.read(buf);
+    		String results = new String(buf,0,len);
+    		String regex = null;
+    		if(seperators.length >1 ){
+    			regex = "" + seperators[0] + "|" + seperators[1];
+    		}else{
+    			regex = "" + seperators[0];
+    		}
+    		words = results.split(regex);
+    	}
+    	public String nextWord(){
+    		if(pos == words.length)
+    			return null;
+    		return words[pos++];
+    	}
+	}
+	```
+	
+3. 编写一个程序，将d:\java目录下的所有.java文件复制到d:\jad目录下，并将原来文件的扩展名从.java改为.jad。               
+	listFiles方法接受一个FileFilter对象，这个FileFilter对象就是过虑的策略对象，不同的人提供不同的FileFilter实现，即提供了不同的过滤策略。
+	```java
+	import java.io.File;
+	import java.io.FileInputStream;
+	import java.io.FileOutputStream;
+	import java.io.FilenameFilter;
+	import java.io.IOException;
+	import java.io.InputStream;
+	import java.io.OutputStream;
+	public class Jad2Java {
+	public static void main(String[] args) throws Exception {
+		File srcDir = new File("java");
+		if(!(srcDir.exists() && srcDir.isDirectory()))
+				throw new Exception("目录不存在");
+		File[] files = srcDir.listFiles(
+			new FilenameFilter(){
+					public boolean accept(File dir, String name) {
+						return name.endsWith(".java");
+					}
+				}
+		);
+		System.out.println(files.length);
+		File destDir = new File("jad");
+		if(!destDir.exists()) destDir.mkdir();
+		for(File f :files){
+			FileInputStream  fis = new FileInputStream(f);
+			String destFileName = f.getName().replaceAll("\\.java$", ".jad");
+			FileOutputStream fos = new FileOutputStream(new File(destDir,destFileName));
+			copy(fis,fos);
+			fis.close();
+			fos.close();
+		}
+	}
+	private static void copy(InputStream ips,OutputStream ops) throws Exception{
+		int len = 0;
+		byte[] buf = new byte[1024];
+		while((len = ips.read(buf)) != -1){
+			ops.write(buf,0,len);
+		}
+	}
+	```
+	由本题总结的思想及策略模式的解析：        
+	1.    
+	```java
+	class jad2java{
+		1. 得到某个目录下的所有的java文件集合
+			1.1 得到目录 File srcDir = new File("d:\\java");
+			1.2 得到目录下的所有java文件：File[] files = srcDir.listFiles(new MyFileFilter());
+			1.3 只想得到.java的文件： class MyFileFilter implememyts FileFilter{
+				public boolean accept(File pathname){
+					return pathname.getName().endsWith(".java")
+				}
+			}
+		2.将每个文件复制到另外一个目录，并改扩展名
+			2.1 得到目标目录，如果目标目录不存在，则创建之
+			2.2 根据源文件名得到目标文件名，注意要用正则表达式，注意.的转义。
+			2.3 根据表示目录的File和目标文件名的字符串，得到表示目标文件的File。
+				//要在硬盘中准确地创建出一个文件，需要知道文件名和文件的目录。 
+			2.4 将源文件的流拷贝成目标文件流，拷贝方法独立成为一个方法，方法的参数采用抽象流的形式。
+				//方法接受的参数类型尽量面向父类，越抽象越好，这样适应面更宽广。	
+	}
+	```
+	分析listFiles方法内部的策略模式实现原理
+	```java
+	File[] listFiles(FileFilter filter){
+		File[] files = listFiles();
+		//Arraylist acceptedFilesList = new ArrayList();
+		File[] acceptedFiles = new File[files.length];
+		int pos = 0;
+		for(File file: files){
+			boolean accepted = filter.accept(file);
+			if(accepted){
+				//acceptedFilesList.add(file);
+				acceptedFiles[pos++] = file;
+			}		
+		}
+		Arrays.copyOf(acceptedFiles,pos);
+		//return (File[])accpetedFilesList.toArray();
+	}
+	```
+	
+4. 编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串，但要保证汉字不被截取半个，如“我ABC”，4，应该截取“我AB”，             
+	输入“我ABC汉DEF”，6，应该输出“我ABC”，而不是“我ABC+汉的半个”。
+	```java
+	首先要了解中文字符有多种编码及各种编码的特征。
+    假设n为要截取的字节数。
+	public static void main(String[] args) throws Exception{
+		String str = "我a爱中华abc我爱传智def';
+		String str = "我ABC汉";
+		int num = trimGBK(str.getBytes("GBK"),5);
+		System.out.println(str.substring(0,num) );
+	}
+	public static int  trimGBK(byte[] buf,int n){
+		int num = 0;
+		boolean bChineseFirstHalf = false;
+		for(int i=0;i<n;i++) {
+			if(buf[i]<0 && !bChineseFirstHalf){
+				bChineseFirstHalf = true;
+			}else{
+				num++;
+				bChineseFirstHalf = false;				
+			}
+		}
+		return num;
+	}
+	```
+	
+5. 有一个字符串，其中包含中文字符、英文字符和数字字符，请统计和打印出各个字符的个数。                    
+	```java
+	哈哈，其实包含中文字符、英文字符、数字字符原来是出题者放的烟雾弹。
+	String content = “中国aadf的111萨bbb菲的zz萨菲”;
+	HashMap map = new HashMap();
+	for(int i=0;i<content.length;i++) {
+		char c = content.charAt(i);
+		Integer num = map.get(c);
+		if(num == null)
+			num = 1;
+		else
+			num = num + 1;
+		map.put(c,num);
+	} 
+	for(Map.EntrySet entry : map) {
+		system.out.println(entry.getkey() + “:” + entry.getValue());
+	}
+	估计是当初面试的那个学员表述不清楚，问题很可能是：
+	如果一串字符如"aaaabbc中国1512"要分别统计英文字符的数量，中文字符的数量，和数字字符的数量，假设字符中没有中文字符、英文字符、数字字符之外的其他特殊字符。
+	int engishCount;
+	int chineseCount;
+	int digitCount;
+	for(int i=0;i<str.length;i++) {
+		char ch = str.charAt(i);
+		if(ch>=’0’ && ch<=’9’) {
+			digitCount++
+		} else if((ch>=’a’ && ch<=’z’) || (ch>=’A’ && ch<=’Z’)) {
+			engishCount++;
+		} else {
+			chineseCount++;
+		}
+	}
+	System.out.println(……………);
+	```
+	
+6. 说明生活中遇到的二叉树，用java实现二叉树                 
+	这是组合设计模式。
+	我有很多个(假设10万个)数据要保存起来，以后还需要从保存的这些数据中检索是否存在某个数据，（我想说出二叉树的好处，该怎么说呢？那就是说别人的缺点），
+	假如存在数组中，那么，碰巧要找的数字位于99999那个地方，那查找的速度将很慢，因为要从第1个依次往后取，取出来后进行比较。
+	平衡二叉树（构建平衡二叉树需要先排序，我们这里就不作考虑了）可以很好地解决这个问题，但二叉树的遍历（前序，中序，后序）效率要比数组低很多，
+	代码如下：
+	```java
+	package com.huawei.interview;
+	public class Node {
+		public int value;
+		public Node left;
+		public Node right;
+		public void store(int value) {
+			if(value<this.value) {
+				if(left == null) {
+					left = new Node();
+					left.value=value;
+				} else {
+					left.store(value);
+				}
+			} else if(value>this.value) {
+				if(right == null) {
+					right = new Node();
+					right.value=value;
+				} else {
+					right.store(value);
+				}			
+			}
+		}
+		public boolean find(int value) {	
+			System.out.println("happen " + this.value);
+			if (value == this.value) {
+				return true;
+			} else if(value>this.value) {
+				if(right == null) return false;
+				return right.find(value);
+			} else {
+				if(left == null) return false;
+				return left.find(value);
+			}
+		}
+		public  void preList() {
+			System.out.print(this.value + ",");
+			if(left!=null) left.preList();
+			if(right!=null) right.preList();
+		}
+		public void middleList() {
+			if(left!=null) left.preList();
+			System.out.print(this.value + ",");
+			if(right!=null) right.preList();		
+		}
+		public void afterList() {
+			if(left!=null) left.preList();
+			if(right!=null) right.preList();
+			System.out.print(this.value + ",");		
+		}	
+		public static void main(String [] args) {
+			int [] data = new int[20];
+			for(int i=0;i<data.length;i++) {
+				data[i] = (int)(Math.random()*100) + 1;
+				System.out.print(data[i] + ",");
+			}
+			System.out.println();
+			Node root = new Node();
+			root.value = data[0];
+			for(int i=1;i<data.length;i++) {
+				root.store(data[i]);
+			}
+			root.find(data[19]);
+			root.preList();
+			System.out.println();
+			root.middleList();
+			System.out.println();		
+			root.afterList();
+		}
+	}
+	```
+	-----------------又一次临场写的代码---------------------------
+	```java
+	import java.util.Arrays;
+	import java.util.Iterator;
+	public class Node {
+		private Node left;
+		private Node right;
+		private int value;
+		//private int num;
+		public Node(int value){
+			this.value = value;
+		}
+		public void add(int value){
+			if(value > this.value) {
+				if(right != null) {
+					right.add(value);
+				} else {
+					Node node = new Node(value);				
+					right = node;
+				}
+			} else {
+				if(left != null) {
+					left.add(value);
+				} else {
+					Node node = new Node(value);				
+					left = node;
+				}			
+			}
+		}
+		public boolean find(int value){
+			if(value == this.value) {
+				return true;
+			} else if(value > this.value){ 
+				if(right == null) return false;
+				else return right.find(value);
+			}else{
+				if(left == null) return false;
+				else return left.find(value);			
+			}
+		}
+		public void display(){
+			System.out.println(value);
+			if(left != null) left.display();
+			if(right != null) right.display();
+		}
+		/*public Iterator iterator(){
+		}*/
+		public static void main(String[] args){
+			int[] values = new int[8];
+			for(int i=0;i<8;i++){
+				int num = (int)(Math.random() * 15);
+				//System.out.println(num);
+				//if(Arrays.binarySearch(values, num)<0)
+				if(!contains(values,num))
+					values[i] = num;
+				else
+					i--;
+			}
+			System.out.println(Arrays.toString(values));
+			Node root  = new Node(values[0]);
+			for(int i=1;i<values.length;i++){
+				root.add(values[i]);
+			}
+			System.out.println(root.find(13));
+			root.display();
+		}
+		public static boolean contains(int [] arr, int value){
+			int i = 0;
+			for(;i<arr.length;i++){
+				if(arr[i] == value) return true;
+			}
+			return false;
+		}
+	}
+	```
+	
+7. 从类似如下的文本文件中读取出所有的姓名，并打印出重复的姓名和重复的次数，并按重复次数排序：               
+	- 张三,28
+	- 李四,35
+	- 张三,28
+	- 王五,35
+	- 张三,28
+	- 李四,35
+	- 赵六,28
+	- 田七,35
+ 
+	程序代码如下（答题要博得用人单位的喜欢，包名用该公司，面试前就提前查好该公司的网址，如果查不到，现场问也是可以的。还要加上实现思路的注释）：
+
+	```java
+	package com.huawei.interview;
+
+	import java.io.BufferedReader;
+	import java.io.IOException;
+	import java.io.InputStream;
+	import java.io.InputStreamReader;
+	import java.util.Comparator;
+	import java.util.HashMap;
+	import java.util.Iterator;
+	import java.util.Map;
+	import java.util.TreeSet;
+
+	public class GetNameTest {
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		//InputStream ips = GetNameTest.class.getResourceAsStream("/com/huawei/interview/info.txt");
+		//用上一行注释的代码和下一行的代码都可以，因为info.txt与GetNameTest类在同一包下面，所以，可以用下面的相对路径形式
+		Map results = new HashMap();
+		InputStream ips = GetNameTest.class.getResourceAsStream("info.txt");
+		BufferedReader in = new BufferedReader(new InputStreamReader(ips));
+		String line = null;
+		try {
+			while((line=in.readLine())!=null)
+			{
+				dealLine(line,results);
+			}
+			sortResults(results);
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	static class User {
+		public  String name;
+		public Integer value;
+		public User(String name,Integer value) {
+			this.name = name;
+			this.value = value;
+		}
+		@Override
+		public boolean equals(Object obj) {
+			// TODO Auto-generated method stub		
+			//下面的代码没有执行，说明往treeset中增加数据时，不会使用到equals方法。
+			boolean result = super.equals(obj);
+			System.out.println(result);
+			return result;
+		}
+	}
+	private static void sortResults(Map results) {
+		// TODO Auto-generated method stub
+		TreeSet sortedResults = new TreeSet(
+				new Comparator(){
+					public int compare(Object o1, Object o2) {
+						// TODO Auto-generated method stub
+						User user1 = (User)o1;
+						User user2 = (User)o2;
+						/*如果compareTo返回结果0，则认为两个对象相等，新的对象不会增加到集合中去
+						 * 所以，不能直接用下面的代码，否则，那些个数相同的其他姓名就打印不出来。
+						 * */					
+						//return user1.value-user2.value;
+						//return user1.value<user2.value?-1:user1.value==user2.value?0:1;
+						if(user1.value<user2.value) {
+							return -1;
+						}else if(user1.value>user2.value) {
+							return 1;
+						}else {
+							return user1.name.compareTo(user2.name);
+						}
+					}
+				}
+		);
+		Iterator iterator = results.keySet().iterator();
+		while(iterator.hasNext()) {
+			String name = (String)iterator.next();
+			Integer value = (Integer)results.get(name);
+			if(value > 1) {				
+				sortedResults.add(new User(name,value));				
+			}
+		}
+		printResults(sortedResults);
+	}
+	private static void printResults(TreeSet sortedResults) {
+		Iterator iterator  = sortedResults.iterator();
+		while(iterator.hasNext()) {
+			User user = (User)iterator.next();
+			System.out.println(user.name + ":" + user.value);
+		}	
+	}
+	public static void dealLine(String line,Map map) {
+		if(!"".equals(line.trim())) {
+			String [] results = line.split(",");
+			if(results.length == 3) {
+				String name = results[1];
+				Integer value = (Integer)map.get(name);
+				if(value == null) value = 0;
+				map.put(name,value + 1);
+			}
+		}
+	}
+	}
+	``` 
+9. 递归算法题                          
+	一个整数，大于0，不用循环和本地变量，按照n，2n，4n，8n的顺序递增，当值大于5000时，把值按照指定顺序输出来。
+	例：n=1237
+	则输出为：      
+	1237，    
+	2474，      
+	4948，       
+	9896，      
+	9896，      
+	4948，       
+	2474，      
+	1237，            
+	提示：写程序时，先只写按递增方式的代码，写好递增的以后，再增加考虑递减部分。       
+	```java
+	public static void doubleNum(int n) {
+		System.out.println(n);
+		if(n<=5000)
+			doubleNum(n*2);
+		System.out.println(n);		
+	}
+	```
+ 
+10. 递归算法题                           
+	第1个人10，第2个比第1个人大2岁，依次递推，请用递归方式计算出第8个人多大？
+	```java
+	package cn.itcast;
+	import java.util.Date;
+	public class A1 {
+		public static void main(String [] args) {
+			System.out.println(computeAge(8));
+		}
+		public static int computeAge(int n) {
+			if(n==1) return 10;
+			return computeAge(n-1) + 2;
+		}
+	}
+	public static void toBinary(int n,StringBuffer result) {
+		if(n/2 != 0)
+			toBinary(n/2,result);
+		result.append(n%2);		
+	}
+	```
+	
+11. 排序都有哪几种方法？请列举。用JAVA实现一个快速排序。            
+	 本人只研究过冒泡排序、选择排序和快速排序，下面是快速排序的代码：
+	```java
+	public class QuickSort {
+		/**
+		* 快速排序
+		* @param strDate
+		* @param left
+		* @param right
+		*/
+		public void quickSort(String[] strDate,int left,int right){
+			String middle,tempDate;
+			int i,j;
+			i=left;
+			j=right;
+			middle=strDate[(i+j)/2];
+			do{
+				while(strDate[i].compareTo(middle)<0&& i<right)
+				i++; //找出左边比中间值大的数
+				while(strDate[j].compareTo(middle)>0&& j>left)
+				j--; //找出右边比中间值小的数
+				if(i<=j){ //将左边大的数和右边小的数进行替换 
+				tempDate=strDate[i];
+				strDate[i]=strDate[j];
+				strDate[j]=tempDate;
+				i++;
+				j--;
+				}
+			}while(i<=j); //当两者交错6时停止
+			if(i<right){
+				quickSort(strDate,i,right);//从
+			}
+			if(j>left){
+				quickSort(strDate,left,j);
+			}
+		}
+		/**
+		  * @param args
+		  */
+		public static void main(String[] args){
+			String[] strVoid=new String[]{"11","66","22","0","55","22","0","32"};
+			QuickSort sort=new QuickSort();
+			sort.quickSort(strVoid,0,strVoid.length-1);
+			for(int i=0;i<strVoid.length;i++){
+				System.out.println(strVoid[i]+" ");
+			}
+		}
+	}
+	```
+	
+12. 有数组a[n]，用java代码将数组元素顺序颠倒             
+	```java
+	import java.util.Arrays;
+	public class SwapDemo{
+		public static void main(String[] args){
+			int [] a = new int[]{
+							(int)(Math.random() * 1000),
+							(int)(Math.random() * 1000),
+							(int)(Math.random() * 1000),
+							(int)(Math.random() * 1000),						
+							(int)(Math.random() * 1000)																		
+			};	
+			System.out.println(a);
+			System.out.println(Arrays.toString(a));
+			swap(a);
+			System.out.println(Arrays.toString(a));		
+		}
+		public static void swap(int a[]){
+			int len = a.length;
+			for(int i=0;i<len/2;i++){
+				int tmp = a[i];
+				a[i] = a[len-1-i];
+				a[len-1-i] = tmp;
+			}
+		}
+	}
+	```
+	
+13. 金额转换，阿拉伯数字的金额转换成中国传统的形式如：（￥1011）－>（一千零一拾一元整）输出。            
+	```java
+	// 去零的代码：
+	return sb.reverse().toString().replaceAll("零[拾佰仟]","零").replaceAll("零+万","万").replaceAll("零+元","元").replaceAll("零+","零");
+	public class RenMingBi {
+		/**
+		 * @param args add by zxx ,Nov 29, 2008
+		 */
+		private static final char[] data = new char[]{
+				'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'
+			}; 
+		private static final char[] units = new char[]{
+			'元','拾','佰','仟','万','拾','佰','仟','亿'
+		};
+		public static void main(String[] args) {
+			// TODO Auto-generated method stub
+			System.out.println(
+					convert(135689123));
+		}
+		public static String convert(int money) {
+			StringBuffer sbf = new StringBuffer();
+			int unit = 0;
+			while(money!=0) {
+				sbf.insert(0,units[unit++]);
+				int number = money%10;
+				sbf.insert(0, data[number]);
+				money /= 10;
+			}
+			return sbf.toString();
+		}
+	}
+	```
+
+----
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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..f90b23af
--- /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,179 @@
+# 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/Java\345\237\272\347\241\200/MD5\345\212\240\345\257\206.md" "b/JavaKnowledge/MD5\345\212\240\345\257\206.md"
similarity index 87%
rename from "Java\345\237\272\347\241\200/MD5\345\212\240\345\257\206.md"
rename to "JavaKnowledge/MD5\345\212\240\345\257\206.md"
index 531f99da..62a8dd01 100644
--- "a/Java\345\237\272\347\241\200/MD5\345\212\240\345\257\206.md"
+++ "b/JavaKnowledge/MD5\345\212\240\345\257\206.md"
@@ -1,10 +1,11 @@
 MD5加密
-===
+=======
 
-`MD5`是一种不可逆的加密算法只能将原文加密，不能讲密文再还原去，原来把加密后将这个数组通过`Base64`给变成字符串，
+`MD5`是一种不可逆的加密算法只能将原文加密，不能将密文再还原回去，原来把加密后将这个数组通过`Base64`给变成字符串，
 这样是不严格的业界标准的做法是对其加密之后用每个字节`&15`然后就能得到一个`int`型的值，再将这个`int`型的值变成16进制的字符串.虽然MD5不可逆，
-但是网上出现了将常用的数字用`md5`加密之后通过数据库查询，所以`MD5`简单的情况下仍然可以查出来，一般可以对其多加密几次或者`&15`之后再和别的数运算等，这称之为*加盐*.
- 
+但是网上出现了将常用的数字用`md5`加密之后通过数据库查询，所以`MD5`简单的情况下仍然可以查出来，一般可以对其多加密几次或者`&15`之后再和别的数运算等，
+这称之为*加盐*.
+
 ```java
 public class MD5Utils {
     /**
@@ -34,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/MVC\344\270\216MVP\345\217\212MVVM.md" "b/JavaKnowledge/MVC\344\270\216MVP\345\217\212MVVM.md"
new file mode 100644
index 00000000..02a3ad83
--- /dev/null
+++ "b/JavaKnowledge/MVC\344\270\216MVP\345\217\212MVVM.md"
@@ -0,0 +1,88 @@
+MVC与MVP及MVVM
+===
+
+MVC
+---
+
+`MVC`是一种使用Model View Controller模型-视图-控制器设计创建`Web`应用程序的模式:   
+
+- `Model`（模型）表示应用程序核心（比如数据库记录列表）是应用程序中用于处理应用程序数据逻辑的部分。
+- `View`（视图）显示数据（数据库记录）是应用程序中处理数据显示的部分。
+- `Controller`（控制器）处理输入（写入数据库记录）应用程序中处理用户交互的部分。
+
+MVC 分层有助于管理复杂的应用程序，因为您可以在一个时间内专门关注一个方面。例如，您可以在不依赖业务逻辑的情况下专注于视图设计。同时也让应用程序的测试更加容易。
+MVC 分层同时也简化了分组开发。不同的开发人员可同时开发视图、控制器逻辑和业务逻辑。
+
+- 优点
+    - 耦合性低
+    - 重用性高
+    - 可维护性高
+    - 有利软件工程化管理
+    
+- 缺点
+    - 没有明确的定义
+    - 视图与控制器间的过于紧密的连接
+    - 增加系统结构和实现的复杂性
+
+![image](https://github.com/CharonChui/Pictures/blob/master/mvc_model.png?raw=true)
+
+MVP
+---
+
+`MVP`是从经典的模式`MVC`演变而来，它们的基本思想有相通的地方：`Controller/Presenter`负责逻辑的处理，`Model`提供数据，`View`负责显示。
+作为一种新的模式，`MVP`与`MVC`有着一个重大的区别：在`MVP`中`View`并不直接使用`Model`，它们之间的通信是通过`Presenter`(`MVC`中的`Controller`)来进行的，
+所有的交互都发生在`Presenter`内部，而在`MVC`中`View`会直接从`Model`中读取数据而不是通过`Controller`。
+在`MVC`里,`View`是可以直接访问`Model`的！从而，`View`里会包含`Model`信息，不可避免的还要包括一些业务逻辑。 
+在`MVC`模型里，更关注的`Model`的不变，而同时有多个对`Model`的不同显示及`View`。所以，在`MVC`模型里，`Model`不依赖于`View`，但是`View`是依赖于`Model`的。
+不仅如此，因为有一些业务逻辑在`View`里实现了，导致要更改`View`也是比较困难的，至少那些业务逻辑是无法重用的。    
+
+![image](https://github.com/CharonChui/Pictures/blob/master/is-activity-god-the-mvp-architecture-10-638.jpg?raw=true)
+
+在`MVP`里，`Presenter`完全把`Model`和`View`进行了分离，主要的程序逻辑在`Presenter`里实现。而且`Presenter`与具体的`View`是没有直接关联的，
+而是通过定义好的接口进行交互，从而使得在变更`View`时候可以保持`Presenter`的不变，即重用！ 
+在MVP里，应用程序的逻辑主要在`Presenter`来实现，其中的`View`是很薄的一层。因此就有人提出了`Presenter First`的设计模式，
+就是根据`User Story`来首先设计和开发`Presenter`。在这个过程中，`View`是很简单的，能够把信息显示清楚就可以了。
+在后面，根据需要再随便更改`View`，而对`Presenter`没有任何的影响了。 如果要实现的`UI`比较复杂，而且相关的显示逻辑还跟`Model`有关系，
+就可以在`View`和`Presenter`之间放置一个`Adapter`。由这个`Adapter`来访问`Model`和`View`，避免两者之间的关联。
+而同时，因为`Adapter`实现了`View`的接口，从而可以保证与`Presenter`之间接口的不变。这样就可以保证`View`和`Presenter`之间接口的简洁，
+又不失去`UI`的灵活性。在`MVP`模式里，`View`只应该有简单的`Set/Get`的方法，用户输入和设置界面显示的内容，除此就不应该有更多的内容，
+绝不容许直接访问`Model`这就是与`MVC`很大的不同之处。
+
+- 优点    
+    - 模型与视图完全分离，我们可以修改视图而不影响模型
+    - 可以更高效地使用模型，因为所有的交互都发生在一个地方——`Presenter`内部
+    - 我们可以将一个`Presenter`用于多个视图，而不需要改变`Presenter`的逻辑。这个特性非常的有用，因为视图的变化总是比模型的变化频繁。
+    - 如果我们把逻辑放在`Presenter`中，那么我们就可以脱离用户接口来测试这些逻辑（单元测试）
+
+- 缺点
+    由于对视图的渲染放在了`Presenter`中，所以视图和`Presenter`的交互会过于频繁。还有一点需要明白，如果`Presenter`过多地渲染了视图，
+    往往会使得它与特定的视图的联系过于紧密。一旦视图需要变更，那么`Presenter`也需要变更了。
+    比如说，原本用来呈现`Html`的`Presenter`现在也需要用于呈现Pdf了，那么视图很有可能也需要变更。
+
+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`
+- 低耦合。
+- 可重用性。
+- 独立开发。
+- 可测试。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+    
diff --git "a/Java\345\237\272\347\241\200/RMB\345\244\247\345\260\217\345\206\231\350\275\254\346\215\242.md" "b/JavaKnowledge/RMB\345\244\247\345\260\217\345\206\231\350\275\254\346\215\242.md"
similarity index 100%
rename from "Java\345\237\272\347\241\200/RMB\345\244\247\345\260\217\345\206\231\350\275\254\346\215\242.md"
rename to "JavaKnowledge/RMB\345\244\247\345\260\217\345\206\231\350\275\254\346\215\242.md"
diff --git "a/JavaKnowledge/Top-K\351\227\256\351\242\230.md" "b/JavaKnowledge/Top-K\351\227\256\351\242\230.md"
new file mode 100644
index 00000000..d716c354
--- /dev/null
+++ "b/JavaKnowledge/Top-K\351\227\256\351\242\230.md"
@@ -0,0 +1,410 @@
+Top-K问题
+===
+
+`Top-K`问题在数据分析中非常普遍的一个问题（在面试中也经常被问到），比如:    
+
+> 从1亿个数字中，找出其中最大的10000个数。    
+
+在一大堆数中求其前`k`大或前`k`小的问题，简称`Top-K`问题。而目前解决`Top-K`问题最有效的算法即是`BFPRT`算法，其又称为中位数的中位数算法，
+该算法由`Blum`、`Floyd`、`Pratt`、`Rivest`、`Tarjan`提出，最坏时间复杂度为`O(n)`。
+
+这个问题总共有几种解决方式:   
+
+- 最容易的方法就是将数据全部排序
+
+    在首次接触`TOP-K`问题时，我们的第一反应就是可以先对所有数据进行一次排序，然后取其前`k`即可，但是这么做有两个问题:    
+    - 快速排序的平均复杂度为O(nlogn)，但最坏时间复杂度为O(n^2)，不能始终保证较好的复杂度。
+    - 我们只需要前`k`大的，而对其余不需要的数也进行了排序，浪费了大量排序时间。
+
+    而且在32位的机器上，每个`float`类型占4个字节，1亿个浮点数就要占用`400MB`的存储空间，所以对于内存的要求很高，而且不能一次将全部数据
+    读入内存进行排序。
+
+- 局部淘汰法
+
+    该方法与排序方法类似，用一个容器保存前`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次这样的比较。
+
+- `Hash`法    
+
+    如果这`1`亿个数里面有很多重复的数，先通过`Hash`法，把这`1`亿个数字去重复，这样如果重复率很高的话，会减少很大的内存用量，从而缩小运算空间，
+    然后通过分治法或最小堆法查找最大的`10000`个数。    
+
+- 最小堆   
+
+    首先读入前`10000`个数来创建大小为`10000`的最小堆，建堆的时间复杂度为`O（mlogm）`（`m`为数组的大小即为`10000`），然后遍历后续的数字，
+    并于堆顶（最小）数字进行比较。如果比最小的数小，则继续读取后续数字；如果比堆顶数字大，则替换堆顶元素并重新调整堆为最小堆。整个过程直至`1`亿
+    个数全部遍历完为止。然后按照中序遍历的方式输出当前堆中的所有`10000`个数字。该算法的时间复杂度为`O（nmlogm）`，空间复杂度是10000（常数）。    
+
+
+解决`Top K`问题有两种思路:   
+
+- 最直观:小顶堆`(大顶堆 -> 最小100个数)`
+- 较高效:`Quick Select`算法.   
+
+堆排序也是一个比较好的选择，可以维护一个大小为`k`的堆，时间复杂度为`O(nlogk)`。     
+
+那是否还存在更有效的方法呢？受到[快速排序](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)的启发，
+通过修改快速排序中主元的选取方法可以降低快速排序在最坏情况下的时间复杂度（即`BFPRT`算法）.
+
+并且我们的目的只是求出前`k`，故递归的规模变小，速度也随之提高。下面来简单回顾下快速排序的过程，以升序为例:       
+
+- 选取主元（首元素，尾元素或一个随机元素）
+- 以选取的主元为分界点，把小于主元的放在左边，大于主元的放在右边
+- 分别对左边和右边进行递归，重复上述过程
+
+
+
+堆
+---
+
+
+小顶堆`(min-heap)`有个重要的性质——每个结点的值均不大于其左右孩子结点的值，则堆顶元素即为整个堆的最小值。
+`JDK`中`PriorityQueue`实现了数据结构堆，通过指定`comparator`字段来表示小顶堆或大顶堆，默认为`null`，表示自然序`(natural ordering)`。
+
+小顶堆解决`Top-K`问题的思路:小顶堆维护当前扫描到的最大100个数，其后每一次的扫描到的元素，若大于堆顶，则入堆，然后删除堆顶；
+依此往复，直至扫描完所有元素。`Java`实现第`K`大整数代码如下：
+
+```java
+public class TopK<E extends Comparable> {
+    private PriorityQueue<E> queue;
+    //堆的最大容量
+    private int maxSize; 
+
+    public TopK(int maxSize) {
+        if (maxSize <= 0) {
+            throw new IllegalStateException();
+        }
+        this.maxSize = maxSize;
+        this.queue = new PriorityQueue<>(maxSize, new Comparator<E>() {
+            @Override
+            public int compare(E o1, E o2) {
+                // 最大堆用o2 - o1，最小堆用o1 - o2
+                return (o1.compareTo(o2));
+            }
+        });
+    }
+
+    public void add(E e) {
+        if (queue.size() < maxSize) {
+            queue.add(e);
+        } else {
+            E peek = queue.peek();
+            if (e.compareTo(peek) > 0) {
+                queue.poll();
+                queue.add(e);
+            }
+        }
+    }
+
+    public List<E> sortedList() {
+        List<E> list = new ArrayList<>(queue);
+        Collections.sort(list);
+        return list;
+    }
+
+    public static void main(String[] args) {
+        int[] array = {4, 5, 1, 6, 2, 7, 3, 8};
+        TopK pq = new TopK(4);
+        for (int n : array) {
+            pq.add(n);
+        }
+        System.out.println(pq.sortedList());
+    }
+}
+```
+
+下面使用`Java`来实现     
+
+- 限定数据大小。
+- 若堆满，则插入过程中与堆顶元素比较，并做相应操作。
+- 每次删除堆顶元素后堆做一次调整，保证最小堆特性。
+
+```java
+public class Heap {
+    private int[] data;
+
+    public Heap(int[] data) {
+        this.data = data;
+        buildHeap();
+    }
+
+    public void buildHeap() {
+        for (int i = data.length / 2 - 1; i >= 0; i--) {
+            heapity(i);
+        }
+    }
+
+    public void heapity(int i) {
+        int left = getLeft(i);
+        int right = getRight(i);
+        int smallIndex = i;
+        if (left < data.length && data[left] < data[i])
+            smallIndex = left;
+        if (right < data.length && data[right] < data[smallIndex])
+            smallIndex = right;
+        if (smallIndex == i)
+            return;
+        swap(i, smallIndex);
+        heapity(smallIndex);
+    }
+
+    public int getLeft(int i) {
+        return ((i + 1) << 1) - 1;
+    }
+
+    public int getRight(int i) {
+        return (i + 1) << 1;
+    }
+
+    public void swap(int i, int j) {
+        data[i] ^= data[j];
+        data[j] ^= data[i];
+        data[i] ^= data[j];
+    }
+
+    public int getMin() {
+        return data[0];
+    }
+
+    public void setMin(int i) {
+        data[0] = i;
+        heapity(0);
+    }
+}
+
+public class TopK {        
+    private static int[] topK(int[] data,int k){  
+        int topk[]=new int[k];  
+        for (int i = 0; i < k; i++) {  
+            topk[i]=data[i];  
+        }  
+        Heap heap=new Heap(topk);  
+        for (int j = k; j < data.length; j++) {  
+            int min=heap.getMin();  
+            if(data[j]>min)  
+                heap.setMin(data[j]);  
+        }  
+        return topk;  
+    }  
+    public static void main(String[] args) {  
+          int[] data = {33,86,59,46,84,76,1236,963};    
+          int[] topk=topK(data,3);  
+          for (int i : topk) {  
+            System.out.print(i+",");  
+        }  
+    }  
+}  
+
+```
+
+
+
+
+`BFPRT`算法
+---
+
+`BFPRT`算法步骤如下:     
+
+本算法的最坏时间复杂度为`O(n)`，值得注意的是通过`BFPTR`算法将数组按第`K`小（大）的元素划分为两部分，而
+这高低两部分不一定是有序的，通常我们也不需要求出顺序，而只需要求出前`K`大的或者前`K`小的。
+
+在`BFPTR`算法中，仅仅是改变了快速排序`Partion`中的`pivot`值的选取，在快速排序中，我们始终选择第一个元
+素或者最后一个元素作为`pivot`，而在`BFPTR`算法中，每次选择五分中位数的中位数作为`pivot`，这样做的目的
+就是使得划分比较合理，从而避免了最坏情况的发生。算法步骤如下:     
+
+- 将输入数组的n个元素划分为`n/5`组，每组5个元素，且至多只有一个组由剩下的`n%5`个元素组成。
+- 寻找`n/5`个组中每一个组的中位数，首先对每组的元素进行插入排序，然后从排序过的序列中选出中位数。
+- 对于上面一步中找出的`n/5`个中位数，递归进行步骤`（1）`和`（2）`，直到只剩下一个数即为这`n/5`个元素的中位数，找到中位数后并找到对应的下标`p`。
+- 进行`Partion`划分过程，`Partion`划分中的`pivot`元素下标为`p`。
+- 进行高低区判断即可。
+
+下面为代码实现，其所求为前`K`小的数:    
+
+```java
+public class BFPRT {
+    /**
+     * 返回前K小的数
+     *
+     * @param arr
+     * @param k
+     * @return
+     */
+    public static int[] getMinKNumsByBFPRT(int[] arr, int k) {
+        if (k < 1 || k > arr.length) {
+            return arr;
+        }
+        int minKth = getMinKthByBFPRT(arr, k);
+        int[] res = new int[k];
+        int index = 0;
+        for (int i = 0; i != arr.length; i++) {
+            if (arr[i] < minKth) {
+                res[index++] = arr[i];
+            }
+        }
+        for (; index != res.length; index++) {
+            res[index] = minKth;
+        }
+        return res;
+    }
+
+    /**
+     * 返回数组中第K小的数
+     *
+     * @param arr
+     * @param K
+     * @return
+     */
+    public static int getMinKthByBFPRT(int[] arr, int K) {
+        int[] copyArr = copyArray(arr);
+        return select(copyArr, 0, copyArr.length - 1, K - 1);
+    }
+
+    public static int[] copyArray(int[] arr) {
+        int[] res = new int[arr.length];
+        for (int i = 0; i != res.length; i++) {
+            res[i] = arr[i];
+        }
+        return res;
+    }
+
+    /**
+     * 在数组上给一个 end - begin 的范围,在这个范围上,返回位于第 i 位置上的数
+     *
+     * @param arr
+     * @param begin
+     * @param end
+     * @param i
+     * @return
+     */
+    public static int select(int[] arr, int begin, int end, int i) {
+        if (begin == end) {
+            return arr[begin];
+        }
+        int pivot = medianOfMedians(arr, begin, end);
+        int[] pivotRange = partition(arr, begin, end, pivot);
+        if (i >= pivotRange[0] && i <= pivotRange[1]) {
+            return arr[i];
+        } else if (i < pivotRange[0]) {
+            return select(arr, begin, pivotRange[0] - 1, i);
+        } else if (i > pivotRange[1]) {
+            return select(arr, pivotRange[1] + 1, end, i);
+        }
+
+        return 0;
+    }
+
+    /**
+     * 求一个范围内的划分值
+     *
+     * @param arr
+     * @param begin
+     * @param end
+     * @return
+     */
+    public static int medianOfMedians(int[] arr, int begin, int end) {
+        int num = end - begin + 1;
+        int offset = num % 5 == 0 ? 0 : 1;
+        int[] mArr = new int[num / 5 + offset]; //所有中位数组成的数组
+        for (int i = 0; i < mArr.length; i++) {
+            int beginI = begin + i * 5;
+            int endI = beginI + 4;
+            mArr[i] = getMedian(arr, beginI, Math.min(endI, end));
+        }
+        return select(mArr, 0, mArr.length - 1, mArr.length / 2);
+    }
+
+    /**
+     * @param arr
+     * @param begin
+     * @param end
+     * @param pivotValue 基准值
+     * @return 返回等于区 最左边的位置 和 最右的位置
+     */
+    public static int[] partition(int[] arr, int begin, int end, int pivotValue) {
+        int small = begin - 1;
+        int big = end + 1;
+        int i = begin;
+        while (i < big) {
+            if (arr[i] < pivotValue) {
+                small++;
+                swap(arr, small, i);
+                i++;
+            } else if (arr[i] > pivotValue) {
+                big--;
+                swap(arr, i, big);
+            } else {
+                i++;
+            }
+        }
+        return new int[]{small + 1, big - 1};
+    }
+
+    /**
+     * 获取上中位数
+     * eg 9 10 11 12  取10
+     * eg 1 2 3 4 5 取3
+     *
+     * @param arr
+     * @param begin
+     * @param end
+     * @return
+     */
+    public static int getMedian(int[] arr, int begin, int end) {
+        insertionSort(arr, begin, end);
+        return arr[(end - begin) / 2 + begin];
+    }
+
+    /**
+     * 插入排序
+     *
+     * @param arr
+     * @param begin
+     * @param end
+     */
+    public static void insertionSort(int[] arr, int begin, int end) {
+        for (int i = begin + 1; i != end + 1; i++) {
+            for (int j = i; j != begin; j--) {
+                if (arr[j - 1] > arr[j]) {
+                    swap(arr, j - 1, j);
+                } else {
+                    break;
+                }
+            }
+        }
+    }
+
+    public static void swap(int[] arr, int index1, int index2) {
+        int tmp = arr[index1];
+        arr[index1] = arr[index2];
+        arr[index2] = tmp;
+    }
+
+    public static void printArray(int[] arr) {
+        System.out.print("前10小的数: ");
+        for (int i = 0; i != arr.length; i++) {
+            System.out.print(arr[i] + " ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {6, 9, 1, 3, 1, 2, 2, 5, 6, 1, 3, 5, 9, 7, 2, 5, 6, 1, 9};
+        printArray(getMinKNumsByBFPRT(arr, 10));
+        System.out.println("第10小的数: " + getMinKthByBFPRT(arr, 10));
+    }
+}
+```
+
+
+----
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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 00000000..d7f9f7f7
Binary files /dev/null and "b/JavaKnowledge/UML\347\261\273\345\233\276.pdf" differ
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"
new file mode 100644
index 00000000..3c2cffc6
--- /dev/null
+++ "b/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
@@ -0,0 +1,144 @@
+Vim使用教程
+===
+
+`Better, Stronger, Faster`
+
+首先`Vim`有两种模式: 
+
+- `Normal`            
+    该模式下不能写入，修改要在该模式进行。在`Insert`模式中可以使用`ESC`键来返回到`Normal`模式。
+- `Insert`      
+    该模式下可以进行写入。在`Normal`模式下使用按`i`键进行`Insert`模式。
+	
+下面说一下`Normal`状态下的一些命令，所有的命令都要在`Normal`状态下执行：
+
+进入`Insert`模式
+---
+
+- `i` 进入`insert`模式
+- `a(append)` 在光标后进行插入，直接进入`insert`模式
+- `o(open a line below)` 在当前行后插入一个新行，直接进入`insert`模式
+- `O` 大写的O是在光标所在的行下面插入一个新航，直接进入编译模式
+- `I` 从该行的最前面开始编辑
+- `A` 从该行的最后面开始编辑
+- `s` 删除光标后的字符，从光标当前位置插入
+- `S` 删除光标所在当前行，从行首插入
+- `cw` 替换从光标位置开始到该单词结束位置的所有字符，直接进入`Insert`模式
+
+在VIM中，有相当一部分命令可以扩展为3部分：
+
+- 开头的部分是一个数字，代表重复次数；
+- 中间的部分是命令；
+- 最后的部分，代表命令的对象。
+
+比如，命令3de中，3表示执行3次，d是删除命令，e表示从当前位置到单词的末尾。整条命令的意思就是，从当前位置向后，删除3个单词。类似的，命令3ce表示从当前位置向后，删除三个单词，然后进入编辑模式。
+
+可以看到，命令组合的前两个部分比较简单，但第三个部分也就是命令对象，技巧就比较多了。所以接下来，我就与你详细介绍下到底有哪些命令对象可以使用。
+
+其实，对命令对象并没有一个完整的分类。但我根据经验，将其总结为光标移动命令和文本对象两种。
+
+第一种是光标移动命令。比如，$命令是移动光标到本行末尾，那么d$就表示删除到本行末尾；再比如，4}表示向下移动4个由空行隔开的段落，那么d4}就是删除这4个段落。
+
+移动光标
+---
+
+- `h` 左移
+- `j` 移到下一行
+- `k` 移到上一行
+- `l` 右移
+- `gg` 移动到文章的开头
+- `G` 移动到当前文章的最后。
+
+- `$` $光标移动当前行尾
+- `0` 数字0光标移动当前行首
+
+- `e` 向右移动一个单词
+- `w` 向右移动一个单词，与e的区别是w是把光标放到下一个单词的开头，而e是把光标放到这一个单词的结尾。
+- `b` 移动到单词开始位置
+- `:59` 移动到59行
+- `#l` 移动光标到该行第#个字的位置，如`5l`
+- `ctrl+g` 列出当前光标所在行的行号等信息
+- `: #` 如输入: 15会跳到文章的第15行
+- `ctrl+b`:向上滚动一屏
+- `ctrl+f`:向下滚动一屏
+- `ctrl+u`:向上滚动半屏
+- `ctrl+d`:向下滚动半屏
+
+删除文字
+---
+
+- `x` 删除光标所在位置的一个字符
+- `#x` 删除光标所在位置后的#个字符，如`6x`就是删除后面的6个字符。
+- `X` 大写的X为删除光标所在位置前的一个字符
+- `#X` 删除光标所在位置前的#个字符
+- `dd` 删除当前行，并把删除的行存到剪贴板中
+- `#dd` 从光标所在行开始删除#行。如`5dd`就是删除5行
+- `v/ctrl+v`: 使用h、j、k、l移动选择内容，然后按d删除。其中v是非列模式，ctrl+v是列模式
+
+复制粘贴
+---
+
+- `yy` 拷贝当前行
+- `#yy` 拷贝当前所在行往下的#行文字
+- `yw` 复制当前光标所在位置到字尾处的位置
+- `#yw` 复制当前光标所在位置往后#个字
+- `y$` 拷贝光标至本行结束位置
+- `y` 拷贝选中部分，在`Normal`模式下按`v`会进入到可视化模式，这时候可以上下移动进行选中某一部分，然后按`y`就可以复制了。
+
+- `p` 在光标所在的位置向下开辟一行，粘贴
+- `P` 在光标所在的位置向上开辟一行，粘贴
+- 剪切： 按dd或者ndd删除，将删除的行保存到剪贴板中，然后按p/P就可以粘贴了。
+
+
+替换
+---
+
+- `r` 替换光标所在处的字符
+- `R` 替换光标所到之处的字符，直到按下`esc`键为止
+- `:%s/old/new/g` 用`new`替换文件中所有的`old`
+- `:%s/old/new/gc`，同上，但是每次替换需要用户确认
+- `:s/old/new/g` 光标所在行的所有old替换为new
+- `:s/old/new/` 光标所在行的第一个old替换为new
+
+撤销
+---
+
+- `u` 撤销、回退
+- `ctrl + r` 恢复刚才的撤销操作
+
+搜索
+---
+
+- `/关键字` 先按`/`键，再输入您想寻找的字符，如果第一次找的关键字不是您想要的，可以一直按`n`会往后寻找到您要的关键字为止。
+
+- `?关键字` 同上，只不过`?`是往上查找
+
+缩进缩出
+---
+
+- `>>` 当前行缩进
+- `#>>` 当前光标下n行缩进
+- `<<` 当前行缩出
+- `#<<` 当前光标下n行缩出
+
+- `: set nu` 会在文件每一行前面显示行号
+- `:wq` 保存并退出
+- `:w` 保存
+- `:q!` 退出不保存
+- `:saveas <pat>` 另存为
+- `:e filename` 打开文件
+- `:sav filename 保存为某文件名
+- ZZ: 命令模式使用大写ZZ直接保存并退出
+
+
+
+
+
+
+
+		
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/JavaKnowledge/hashCode\344\270\216equals.md" "b/JavaKnowledge/hashCode\344\270\216equals.md"
new file mode 100644
index 00000000..c73130a0
--- /dev/null
+++ "b/JavaKnowledge/hashCode\344\270\216equals.md"
@@ -0,0 +1,26 @@
+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`类中的默认实现是“将该对象的内部地址转换成一个整数返回”。           
+
+接下来有两个个关于这两个方法的重要规范:    
+- 若重写`equals(Object obj)`方法，有必要重写`hashcode()`方法，确保通过`equals(Object obj)`方法判断结果为`true`的两个对象具备相等的`hashcode()`返回值。
+    说得简单点就是:  如果两个对象相同，那么他们的hashcode应该相等。不过请注意：这个只是规范，如果你非要写一个类让`equals(Object obj)`返回`true`
+	而`hashcode()`返回两个不相等的值，编译和运行都是不会报错的。不过这样违反了`Java`规范，程序也就埋下了`BUG`。 
+- `如果equals(Object obj)`返回`false`，即两个对象“不相同”，并不要求对这两个对象调用`hashcode()`方法得到两个不相同的数。
+    说的简单点就是：“如果两个对象不相同，他们的`hashcode`可能相同”。 
+- 如果两个对象相同，那么它们的`hashCode`值一定要相同；
+- 如果两个对象的`hashCode`相同，它们并不一定相同
+上面说的对象相同指的是用`eqauls`方法比较。    
+你当然可以不按要求去做了，但你会发现，相同的对象可以出现在`Set`集合中。同时，增加新元素的效率会大大下降。
+
+---
+- 邮箱 ：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"
new file mode 100644
index 00000000..35233217
--- /dev/null
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -0,0 +1,1246 @@
+# python3入门
+
+## 变量
+
+```python
+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中，用引号括起来的都是字符串，其中的引号可以是单引号，也可以是双引号。例如:     
+```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)
+```
+
+### 自动类型转换(隐式转换)
+
+对两种不同类型的数据进行运算，较小的数据类型(整数)就会转换为较大的数据类型(浮点数)以免数据丢失，计算结果为浮点型:  
+
+```python3
+num1 = 2
+num2 = 3.0
+
+print(num1 + num2) # 5.0
+
+
+
+num1 = 9
+num2 = 1
+print(num1 / num2) #9.0
+```
+注意: 特别的，两个整形进行除法运算时结果也是浮点型。  
+
+
+
+
+
+
+
+
+
+
+
+## 注释
+
+使用井号(#)标识注释
+
+
+## 列表
+
+在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')
+```
+
+#### 使用enumerate()可以同时获取列表的下标和元素。
+
+```python
+lst = [1, 2, 3]
+
+for i, value in enumerate(lst):
+    print(i, value)
+```
+
+
+### 切片
+
+你还可以处理列表的部分元素——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")
+```
+
+### match case语句
+
+```python3
+match x:
+    case a:
+        xxxx
+    case b:
+        xxxx
+    case _:
+        xxx
+```
+在python3.10版本新增了match case的条件判断方式，match后的对象会依次与case后的内容匹配，匹配成功则执行相应的语句，否则跳过，其中_可以匹配一切。  
+
+
+### 相等判断
+```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)
+```
+
+
+## 字典(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'])
+del alien['points']
+```
+
+字典的其他写法:   
+
+```python3
+dict4 = dict(name="Bob", age=20, gender="female")
+dict5 = dict([("name", "Tom"), ("age", 22), ("gender", "male")])
+```
+
+
+### 遍历字典
+
+- 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基本一样。  
+
+## 缩进
+
+在python3中，代码块的结束不像其他一些编程语言(如c、java等)使用大括号{}来明确界定，而是通过缩进来表示。PEP8建议每级缩进都使用四个空格。
+
+
+## 函数
+
+使用关键字def来定义一个函数，定义以冒号结尾。      
+跟在def xxx:后面的所有缩进行构成了函数体。   
+
+```python
+def greet_user(username): 
+    """函数功能的注释"""
+    # 返回值
+    return 'Hello ' + username 
+
+# 调用函数    
+print(greet_user('jack')) 
+print(greet_user(username='lili'))
+```
+同样，在Python中函数也支持参数的默认值。   
+
+上面三个引号的部分是文档字符串格式，用于简要的阐述其功能的注释。     
+
+### 函数的参数传递
+
+- 不可变类型     
+    类似c++的值传递，如整数、字符串、元祖。如fun(a)，传递的只是a的值，没有影响a对象本身，比如在fun(a)内部修改a的值，只是修改了另一个复制的对象，不会影响a本身。 
+- 可变类型    
+    类似c++的引用传递，如列表、字典。如fun(la)，则是将la真正的传过去，修改后fun外部的la也会受影响  
+
+
+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')
+```
+
+
+简单来说，Python中所有的函数参数传递，统统都是基于传递对象的引用进行的。这是因为，在Python中，一切皆对象。而传对象，实质上传的是对象的内存地址，而地址即引用。
+
+
+看起来，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))
+``` 
+
+
+
+### 将函数存储在模块中
+
+函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块的独立文件中，再将模块导入到主程序中。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()，因此调用它时只需指定其名称。
+
+还可以使用星号(`*`)导入模块中的所有函数:     
+
+```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')
+```
+
+### __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()
+```
+
+
+
+## 类 
+
+在Python中，首字母大写的名称指的是类。  
+根据类来创建对象叫实例化。   
+
+dog.py
+```python
+class Dog:
+    home = "xx"    # 类属性
+
+    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都会自动运行它(__init__()方法的调用时机在实例(通过__new__()被创建之后，返回调用者之前调用，一般用于初始化一些数据))。在这个方法中形参self必不可少，还必须位于其他形参的前面。        
+
+为什么必须在方法定义中包含形参self呢？因为Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self。    
+
+每个与类相关联的方法调用都自动传入实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。         
+
+
+
+```python
+import dog
+
+dog = dog.Dog("xiaohei", 1)
+# 属性
+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__():属性访问拦截器，定义了属性被访问前的操作。  
+
+
+
+
+
+
+### 继承
+
+一个类继承另一个类时，它将自动获得另一个类的所有属性和方法。       
+
+创建子类实例时，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将父类和子类关联起来。这行代码让子类包含父类的所有属性。 
+
+
+多继承: 调用方法时先在子类中查找，若不存在则从左到右依次查找父类中是否包含方法。    
+
+#### 私有属性和方法
+
+有时为了限制属性和方法只能在类内访问，外部无法访问。或父类中某些属性和方法不希望被子类继承，可以将其私有化:    
+
+- 单下划线: 非公开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都包含它。
+类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
+每个模块也都应包含一个文档字符串，对其中的类可用于做什么进行描述。
+
+
+### 读取文件
+
+一次性读取整个文件:          
+```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。
+
+```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语句。   
+
+
+
+
+
+### 分割字符串
+
+方法split()以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中。
+
+```python
+title = "Alice in Wonderland"
+title.split()
+```
+
+['Alice','in','Wonderland']
+
+
+### pass
+
+Python有一个pass语句，可在代码块中使用它来让Python什么都不要做。    
+
+```python
+def donothing():    
+    pass    #空语句
+
+```
+
+
+pass语句如果啥事都不做，那要它有何用呢？实际上，pass可以作为一个占位符来用——视为未成熟代码的“预留地”。比如说，如果我们还没想好函数的内部实现，就可以先放一个pass，让代码先跑起来。
+
+### 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中的键。
+
+
+
+
+在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
+这种形式表示接收任意多个实际参数并将其放到一个元组中。
+2．**parameter
+这种形式表示接收任意多个类似关键字参数一样显式赋值的实际参数，并将其放到一个字典中。
+
+
+除了用等号给可变关键字参数赋值，事实上，我们还可以直接用字典给可变关键字参数赋值:     
+
+```python
+def some_kwargs(name, age, sex):
+    print(f"name: ${name}")
+
+kdic = {'name' : 'Alice', 'age' : 11, 'sex' : 'nv'}
+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
new file mode 100644
index 00000000..1c2fb339
--- /dev/null
+++ b/JavaKnowledge/shell.md
@@ -0,0 +1,101 @@
+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/
+
+
+### 切换到root用户
+
+
+`sudo su -`
+
+ - sudo : super user doing
+ - su : switch user
+ - `-` : root用户
+
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"
new file mode 100644
index 00000000..8894decc
--- /dev/null
+++ "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
@@ -0,0 +1,257 @@
+# volatile和Synchronized
+
+## 内存模型
+
+内存模型：英文名 Memory Model，它是一个老古董了。它是与计算机硬件有关的一个概念。那么，我先介绍下它和硬件到底有啥关系。
+
+计算机在执行程序的时候，每条指令都是在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缓存。多个线程访问进程中的某个共享内存，且这多个线程分别在不同的核心上执行，则每个核心都会在各自的cache中保留一份共享内存的缓存。由于多核是可以并行的，可能会出现多个线程同时写各自的缓存的情况，而各自的cache之间的数据就有可能不同。
+
+在CPU和主存之间增加缓存，在多线程场景下就可能存在**缓存一致性问题**，也就是说，在多核CPU中，每个核的自己的缓存中，关于同一个数据的缓存内容可能不一致。
+
+> 如果这家公司的命令都是串行下发的话，那么就没有任何问题。
+>
+> 如果这家公司的命令都是并行下发的话，并且这些命令都是由同一个CEO下发的，这种机制是也没有什么问题。因为他的命令执行者只有一套管理体系。
+>
+> 如果这家公司的命令都是并行下发的话，并且这些命令是由多个合伙人下发的，这就有问题了。因为每个合伙人只会把命令下达给自己直属的管理人员，而多个管理人员管理的底层员工可能是公用的。
+>
+> 比如，合伙人1要辞退员工a，合伙人2要给员工a升职，升职后的话他再被辞退需要多个合伙人开会决议。两个合伙人分别把命令下发给了自己的管理人员。合伙人1命令下达后，管理人员a在辞退了员工后，他就知道这个员工被开除了。而合伙人2的管理人员2这时候在没得到消息之前，还认为员工a是在职的，他就欣然的接收了合伙人给他的升职a的命令。
+
+### 处理器优化和指令重排
+
+上面提到在CPU和主存之间增加缓存，在多线程场景下会存在**缓存一致性问题**。除了这种情况，还有一种硬件问题也比较重要。那就是为了使处理器内部的运算单元能够尽量的被充分利用，处理器可能会对输入代码进行乱序执行处理。这就是**处理器优化**。
+
+除了现在很多流行的处理器会对代码进行优化乱序处理，很多编程语言的编译器也会有类似的优化，比如Java虚拟机的即时编译器（JIT）也会做**指令重排**。
+
+可想而知，如果任由处理器优化和编译器对指令重排的话，就可能导致各种各样的问题。
+
+> 关于员工组织调整的情况，如果允许人事部在接到多个命令后进行随意拆分乱序执行或者重排的话，那么对于这个员工以及这家公司的影响是非常大的。
+
+### 并发编程问题
+
+并发编程，为了保证数据的安全，需要满足以下三个特性：
+
+**原子性**是指在一个操作中就是cpu不可以在中途暂停然后再调度，既不被中断操作，要不执行完成，要不就不执行。
+
+**可见性**是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
+
+**有序性**即程序执行的顺序按照代码的先后顺序执行。
+
+有没有发现，**缓存一致性问题**其实就是**可见性问题**。而**处理器优化**是可以导致**原子性问题**的。**指令重排**即会导致**有序性问题**。所以，后文将不再提起硬件层面的那些概念，而是直接使用大家熟悉的原子性、可见性和有序性。
+
+前面提到的，缓存一致性问题、处理器器优化的指令重排问题是硬件的不断升级导致的。那么，有没有什么机制可以很好的解决上面的这些问题呢？
+
+最简单直接的做法就是废除处理器和处理器的优化技术、废除CPU缓存，让CPU直接和主存交互。但是，这么做虽然可以保证多线程下的并发问题。但是，这就有点因噎废食了。
+
+所以，为了保证并发编程中可以满足原子性、可见性及有序性。有一个重要的概念，那就是——内存模型。
+
+**为了保证共享内存的正确性（可见性、有序性、原子性），内存模型定义了共享内存系统中多线程程序读写操作行为的规范**。通过这些规则来规范对内存的读写操作，从而保证指令执行的正确性。它与处理器有关、与缓存有关、与并发有关、与编译器也有关。他解决了CPU多级缓存、处理器优化、指令重排等导致的内存访问问题，保证了并发场景下的一致性、原子性和有序性。
+
+内存模型解决并发问题主要采用两种方式：**限制处理器优化**和**使用内存屏障**。
+
+## Java内存模型
+
+**Java内存模型**(java Memory Model，JMM)描述了Java程序中各种变量(**线程共享变量**)的访问规则，以及在JVM中将变量**存储到内存**和从**内存中读取出变量**这样的底层细节。
+
+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指向刚分配的内存地址。这样就就不存在获取到未被初始化的对象。
+
+
+
+那为何说它禁止指令重排序呢？从硬件架构上讲，指令重排序是指处理器采用了允许将多条指令不按程序规定的顺序分开发送给各个相应的电路单元进行处理。但并不是说指令任意重排，处理器必须能正确处理指令依赖情况保障程序能得出正确的执行结果。譬如指令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锁的都对象，只不过不同形式下锁的对象不一样。**
+
+- **对于普通同步方法，锁的是当前实例对象。**
+- **对于静态同步方法，锁的是当前类的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)
+- [原子性、可见性以及有序性](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!
diff --git "a/JavaKnowledge/\345\211\221\346\214\207Offer(\344\270\212).md" "b/JavaKnowledge/\345\211\221\346\214\207Offer(\344\270\212).md"
new file mode 100644
index 00000000..9220e3c9
--- /dev/null
+++ "b/JavaKnowledge/\345\211\221\346\214\207Offer(\344\270\212).md"
@@ -0,0 +1,1250 @@
+剑指Offer(上)
+===
+
+最近面试，遇到一些笔试题，写不上来，内心是崩溃的，该好好复习下了，所以决定仔细做一遍，随便也整理下，方便大家学习。
+
+1. 我没找到第一题是什么- -!,谁知道的给补充下吧
+
+2. 实现单例模式                 
+    单例的实现分为好几种:     
+    - 饿汉式
+	- 懒汉式
+	- 枚举              
+	
+	具体实现:      
+	- 饿汉式              
+
+		```java
+		public class Singleton {
+			private Singleton() {
+			}
+
+			private static final Singleton SINGLETON = new Singleton();
+
+			public static Singleton getInstance() {
+				return SINGLETON;
+			}
+		}
+		```
+	- 懒汉式
+
+		```java
+		public class Singleton {
+			private Singleton() {
+			}
+
+			private static Singleton singleton = null;
+
+			public static Singleton getInstance() {
+				// 同步会导致效率低，这里采用双重判断的方式来提高效率
+				if (singleton == null) {
+					synchronized (Singleton.class) {
+						if (singleton == null) {
+							singleton = new Singleton();
+						}
+					}
+				}
+				return singleton;
+			}
+		}
+		```
+	- 枚举	
+
+	    ```java
+		public enum Singleton {
+			INSTANCE;
+			private Singleton() {
+
+			}
+		}		
+		```
+	
+	- 我这里写一种自我感觉是单例最完美的实现方式
+	　　
+		```java
+		public class Singleton {
+			// Private constructor prevents instantiation from other classes
+			private Singleton() { }
+
+			/**
+			* SingletonHolder is loaded on the first execution of Singleton.getInstance() 
+			* or the first access to SingletonHolder.INSTANCE, not before.
+			*/
+			private static class SingletonHolder { 
+					public static final Singleton INSTANCE = new Singleton();
+			}
+			public static Singleton getInstance() {
+					return SingletonHolder.INSTANCE;
+			}
+		}
+		```
+	
+3. 二维数组中的查找            
+    题目描述：一个二维数组，每一行从左到右递增，每一列从上到下递增．输入一个二维数组和一个整数，判断数组中是否含有整数。
+	             
+	分析:     
+	```
+	1   6   11
+	5   9   15
+	7   13   20
+	```
+	
+	假设我们要找7，那怎么找呢？                
+	我们先从第一行找，从后往前找，因为他是递增的，先是11，这里11>7所以肯定不是第三列的。这时候我们就找第二列，       
+	这个值是6,6 < 7,所以我们可以从第二列往下找，这个数可能会再第二列或者第一列。把行数加1，来到第二行第二列的9            
+	这时候一判断9 > 7，所以不可能是第二列了，这时候把列数再前移，来到第一列，刚才是第二行，所以我们取第一列第二行        
+	的数，也就是5,5 < 7，所以还要继续往后找，就是把行数加1，就来到了第三行第一列，也就是7，一判断就是他了。         
+	整体思路就是从右上角开始，逐渐前移列数或者增加行数。          
+	```java
+	public static boolean find(int[][] array, int number) {
+		if (array == null) {
+			return false;
+		}
+		
+		// 从第一行最后一列的数开始
+		int column = array[0].length - 1;
+		int row = 0;
+		while (row < array.length && column >= 0) {
+			if (array[row][column] == number) {
+				return true;
+			}
+			
+			if (array[row][column] > number) {
+				// 如果这个数比要找的数大，那肯定不是这一列了，只能是前一列
+				column--;
+			} else {
+				// 小的话，那肯定在该数的下面，就要增大行数
+				row++;
+			}
+		}
+		return false;
+	}
+	```
+	
+4. 替换空格            
+    请实现一个函数，把字符串中的每个空格替换成`%20`。              
+	思路: 很简单，就是判断每个字符是否为空着，但也要注意使用`StringBuilder`会比`StringBuffer`效率稍高。                    
+	```java
+	public String replaceBlank(String input) {
+		if (input == null) {
+			return null;
+		}	
+		StringBuilder  sb = new StringBuilder ();
+		for (int i = 0; i < input.length(); i++) {
+			if (input.charAt(i) == ' ') {
+				sb.append("%");
+				sb.append("2");
+				sb.append("0");
+			} else {
+				sb.append(String.valueOf(input.charAt(i)));
+			}
+		}
+		return new String(sb);
+	}
+	```
+	
+5. 从尾到头打印链表            
+    输入一个链表的头结点，从尾到头反过来打印出每个节点的值。            	
+	思路: 我们可以从头开始遍历，但是要让先遍历的最后打印，这就是一个吃进去、吐出来的方式，最适合的就是栈.            
+	- 遍历的方式
+	```java
+	public class ListNodeTest {
+		public static void main(String args[]) {
+			ListNode node1 = new ListNode();
+			ListNode node2 = new ListNode();
+			ListNode node3 = new ListNode();
+			node1.data = 1;
+			node2.data = 2;
+			node3.data = 3;
+			node1.next = node2;
+			node2.next = node3;
+
+			ListNodeTest.reversePrint(node1);
+		}
+
+		public static void reversePrint(ListNode headNode) {
+			Stack<ListNode> stack = new Stack<ListNode>();
+			while (headNode != null) {
+				// 遍历，然后用栈来保存
+				stack.push(headNode);
+				headNode = headNode.next;
+			}
+			while (!stack.isEmpty()) {
+				System.out.println(stack.pop().data);
+			}
+		}
+	}
+
+	class ListNode {
+		public ListNode() {
+
+		}
+
+		ListNode next;
+		int data;
+	}
+	```
+	- 递归
+	```java
+	public static void printListReverse(ListNode headNode) {
+		if (headNode != null) {
+			if (headNode.next != null) {
+				printListReverse(headNode.next);
+			}
+			System.out.println(headNode.data);
+		}
+	}
+	```
+	
+6. 重建二叉树	    
+    输入二叉树的前序遍历和中序遍历的结果，重建出该二叉树。假设前        
+    序遍历和中序遍历结果中都不包含重复的数字，例如输入的前序遍历序列        
+    {1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}重建出如图所示的二叉树。          
+		  
+	![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/binary_offer.png)	  
+	思路: 前序遍历序列中，第一个数字总是树的根节点的值。          
+	中序遍历根节点在序列的中间，左边是左子树，右边是右子树。          
+	所以我们可以根据前序遍历的第一个值去中旬遍历数组中查找，就能找出来中序的分割点是谁。           
+	这样在他左边的就都是左子树，右边是右子树。这样也就能知道左子树的个数，再用这个数量去前子树中去前几个数。          
+	就这样再递归下去排列二级左子树的根节点。          
+	```java
+	import java.util.Arrays;
+
+	public class BinaryTree {
+		public static void main(String[] args) throws Exception {
+			int[] preorder = { 1, 2, 4, 7, 3, 5, 6, 8 };
+			int[] inorder = { 4, 7, 2, 1, 5, 3, 8, 6 };
+			BinaryTreeNode root = constructCore(preorder, inorder);
+		}
+
+		public static BinaryTreeNode constructCore(int[] preorder, int[] inorder)
+				throws Exception {
+			if (preorder == null || inorder == null) {
+				return null;
+			}
+			if (preorder.length != inorder.length) {
+				throw new IllegalArgumentException("error params");
+			}
+			BinaryTreeNode root = new BinaryTreeNode();
+			for (int i = 0; i < inorder.length; i++) {
+				if (inorder[i] == preorder[0]) {
+					root.value = inorder[i];
+					// 递归让再去构建左子树的下一个根节点
+					root.leftNode = constructCore(
+							// 前序遍历从第二个开始后的i个都是左子树的
+							Arrays.copyOfRange(preorder, 1, i + 1),
+							// 中序遍历最边边这i个也是左子树
+							Arrays.copyOfRange(inorder, 0, i));
+					root.rightNode = constructCore(
+							Arrays.copyOfRange(preorder, i + 1, preorder.length),
+							Arrays.copyOfRange(inorder, i + 1, inorder.length));
+				}
+				// 就这样循环递归下去，就OK了。
+			}
+			return root;
+		}
+	}
+
+	class BinaryTreeNode {
+		public static int value;
+		public BinaryTreeNode leftNode;
+		public BinaryTreeNode rightNode;
+	}
+	```
+
+7. 用两个栈实现队列                      
+    用两个栈实现一个队列，实现队列的两个函数`appendTail`和     
+    `deleteHead`，分别完成在队列尾插入结点和在队列头部删除结点的功能。        
+	思路： 栈是啥？栈是先进后出，因为栈是一个出口啊，先进入的被压在最下面了，出要从上面开始出，也就是吃了吐出来。         
+	队列是啥？两头的，就想管道一样，先进先出。不雅的说，就是吃了拉出来。            
+	队列尾插入节点好说啊，就是在栈中往里放。         
+	那队列头部删除怎么弄？因为他在栈的最底部啊，你没法直接删他啊，不要忘了，我们是用两个栈来实现。所以自然想到
+	就是把这个栈中的数据都取出放入到第二个栈中，然后删除第二个栈的最上面的元素就可以了。         
+	```java
+	public class StackListTest<T> {
+		private Stack<T> stack1 = new Stack<T>();
+		private Stack<T> stack2 = new Stack<T>();
+
+		public void appendTail(T t) {
+			// 往栈1中存
+			stack1.push(t);
+		}
+
+		public T deleteHead() throws Exception {
+			if (stack2.isEmpty()) {
+				// 把栈1的数都放到栈2中
+				while (!stack1.isEmpty()) {
+					stack2.push(stack1.pop());
+				}
+			}
+			// 转移到栈2后，就相当于把栈1倒序了。
+			if (stack2.isEmpty()) {
+				throw new Exception("队列为空，不能删除");
+			}
+			// 直接取栈2中最上层的就可以了。
+			return stack2.pop();
+		}
+
+		public static void main(String args[]) throws Exception {
+			StackListTest<String> p7 = new StackListTest<String>();
+			p7.appendTail("1");
+			p7.appendTail("2");
+			p7.appendTail("3");
+			p7.deleteHead();
+		}
+	}
+	```
+	
+8. 	旋转数组的最小数字               
+    把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的        
+    旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如数      
+    组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为 1.        
+	
+	思路: 开始看到这道题，我感觉很简单，就是循环比较下找出最下的就完了，我感觉什么旋转数组都是面试官
+	放的烟雾弹。后来我发现我错了。旋转数组是有用的。
+	```java
+	public class FindTest {
+		public static void main(String[] args) {
+			// int[] array={1,1,1,2,0};
+			// int[] array={3,4,5,1,2};
+			int[] array = { 1, 0, 1, 1, 1 }; // 这是0，1，1，1，1的旋转
+			System.out.println(findMinNum(array));
+		}
+	
+		public static Integer findMinNum(int[] array) {
+			if (array == null) {
+				return null;
+			}
+			int leftIndex = 0;
+			int rightIndex = array.length - 1;
+			int mid = 0;
+			// 最小的数就在这中间
+			while (array[leftIndex] >= array[rightIndex]) {
+				if (rightIndex - leftIndex <= 1) {
+					// 这就是最小的了
+					mid = rightIndex;
+					break;
+				}
+				// 去中间的值，类似二分法查找
+				mid = (leftIndex + rightIndex) / 2;
+				// 前、中、后三个值都相等的情况，主要就是为了区分0，1，1，1，1这种数值相同的情况
+				if (array[leftIndex] == array[rightIndex] && array[leftIndex] == array[mid]) {
+					// 把指针在移动一下，不相等就继续变mid的值
+					if (array[leftIndex + 1] != array[rightIndex - 1]) {
+						mid = array[leftIndex + 1] < array[rightIndex - 1] ? (leftIndex + 1) : (rightIndex - 1);
+						break;
+					} else {
+						leftIndex++;
+						rightIndex--;
+					}
+				} else {
+					if (array[mid] >= array[leftIndex])
+						leftIndex = mid;
+					else {
+						if (array[mid] <= array[rightIndex])
+							rightIndex = mid;
+					}
+				}
+				return array[mid];
+			}
+			return null;
+		}
+	}
+    ```
+9. 斐波那契数列	     
+    什么是斐波那契数列呢？ 就是f(0)=0;f(1)=1;f(n)=f(n-1)+f(n-2);           
+    写一个函数，输入n，求斐波那契数列的第n项。           
+    思路:标准的一个递归。
+    ```java
+	public long fibonacci1(int n) {
+		if (n == 0) {
+			return 0;
+		}
+		
+		if (n == 1) {
+			return 1;
+		}
+		
+		return fibonacci1(n-1) + fibonacci1(n-2);
+	}
+    ```
+    貌似很合理，但其实也是有问题的，这样会导致重复计算，例如我们在算f(10)，需要先求出f(9)和f(8)，而算f(9)又要求出f(8)和f(7)，很显然重复了。显然面试官不会满意的。那该怎么做呢？ 那就是累加。 
+    ```java
+	public class Fibonacci {
+		public static long fibonacci(int n) {
+			long result = 0;
+			long preOne = 0;
+			long preTwo = 1;
+			if (n == 0) {
+				return preOne;
+			}
+			if (n == 1) {
+				return preTwo;
+			}
+			for (int i = 2; i <= n; i++) {
+				result = preOne + preTwo;
+				preOne = preTwo;
+				preTwo = result;
+			}
+			return result;
+		}
+	}
+	```
+10. 2进制中1的个数               
+    请实现一个函数,输入一个整数,输出该数二进制表示中 1 的个数。例如 把 9 表示成二进制是 1001;有 2 位是 1,因此如果输入 9,函数输出 2.      
+    思路: 把一个整数减去1，再和原整数做与运算，会把该整数最右边的一个1变成0.那么一个整数的二进制表示中有多少个1，就可以进行多少次运算。       
+    ```java
+	public int numberOf1(int n) {
+		int count = 0;
+		while (n != 0) {
+			count++;
+			n = (n - 1) & n;
+		}
+		return count;
+	}
+    ```
+    
+11. 数值的整数次方           
+    实现函数double Power(double base,int exponent),求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。        
+    思路:就是不断的累计去乘.            
+    ```java
+    public double powerWithExponent(double base, int exponent) {
+		double result = 1.0;
+		for (int i = 1; i <= exponent; i++) {
+			result = result * base;
+		}
+		return result;
+	}
+    ```
+    本来想着挺简单，其实已经写错了。因为exponent如果是0或者负数呢？         
+    思路：当指数为负数的时候，可以先对指数求绝对值，然后算出次方的结果之后再取倒数。既然有求倒数，我们很自然的就要想到有没有可能对0求倒数，如果对0求倒数怎么办？当底数base是零且指数是负数的时候，我们不做特殊的处理，就会发现对0求倒数从而导致程序运行出错。怎么告诉函数的调用者出现了这种错误？在Java中可以抛出异常来解决。
+    ```java
+    public static double power(double base, int exponent) throws Exception {
+		double result = 0.0;
+		// 如果是求0的负数次幂
+		if (equal(base, 0.0) && exponent < 0) {
+			throw new Exception("0的负数次幂没有意义");
+		}
+		if (exponent < 0) {
+			// 负数次幂，先取绝对值算出次方后再求倒数
+			result = 1.0 / powerWithExpoment(base, -exponent);
+		} else {
+			result = powerWithExpoment(base, exponent);
+		}
+		return result;
+	}
+
+	private static double powerWithExpoment(double base, int exponent) {
+		if (exponent == 0) {
+			return 1;
+		}
+		if (exponent == 1) {
+			return base;
+		}
+		double result = 1.0;
+		for (int i = 1; i <= exponent; i++) {
+			result = result * base;
+		}
+		return result;
+	}
+
+	/**
+	 * 判断两个double数据是否相等
+	 * @param num1
+	 * @param num2
+	 * @return
+	 */
+	private static boolean equal(double num1, double num2) {
+		if ((num1 - num2 > -0.0000001) && num1 - num2 < 0.0000001) {
+			return true;
+		} else {
+			return false;
+		}
+
+	}
+    ```
+12. 打印 1 到最大的 n 位数            
+    输入数字n，按顺序打印出从1最大的的n位数十进制数。比如输入3，则打印出1，2，3一直到最大的3位数即999.           
+    思路: 1位数就是`10-1`，两位数就是`10*10-1`三位数就是`10*10*10-1`              
+    
+    ```java
+    public void print1ToMaxOfNDigits(int n) {
+		int number = 1;
+		int i = 0;
+		while (i++ < n) {
+			number *= 10;
+		}
+		for (int j = 1; j < number; ++j)
+			System.out.println(j);
+	}
+    ```
+    感觉挺简单，其实已经错了。因为没有规定n的值，如果很大的话，显然会超过int型的最大值。我们很自然的想到解决这个问题需要一个大数。最常用的也是最容易的用字符串或者数组表达大数。接下来我们用数组来解决大数问题。
+    思路:每一位数都是0到9，这样弄一个数组，数组的长度就是n，每一位都是0-9，这样，循环去打印数组就可以了
+    ```java
+	public static void main(String[] args) {
+		printToMaxOfNDigits(2);
+	}
+
+	public static void printToMaxOfNDigits(int n) {
+		int[] array = new int[n];
+		if (n <= 0)
+			return;
+		printArray(array, 0);
+	}
+
+	private static void printArray(int[] array, int n) {
+		// 每一位都是0-9
+		for (int i = 0; i < 10; i++) {
+			if (n != array.length) {
+				array[n] = i;
+				// 递归弄另一位
+				printArray(array, n + 1);
+			} else {
+				boolean isFirstNo0 = false;
+				for (int j = 0; j < array.length; j++) {
+					if (array[j] != 0) {
+						System.out.print(array[j]);
+						if (!isFirstNo0) {
+							isFirstNo0 = true;
+						}
+					} else {
+						if (isFirstNo0) {
+							// 10 20 这种后位是0的
+							System.out.print(array[j]);
+						}
+					}
+				}
+				System.out.println();
+				// 打印完就return
+				return;
+			}
+		}
+	}
+	```
+
+13. 在O(1)时间删除链表节点            
+    给定单向链表的头指针和一个节点指针，定义一个函数在O(1)时间删除该节点。          
+    思路：在单向链表中删除一个节点，最常规的方法无疑是从链表的头结点开始，顺序遍历查找要删除的节点，并在链表中删除该节点。删除就是将这个要被删除的节点的前一节点设置成该要被删除节点的下一节点。- -！ 
+    ```java
+    public class DeleteListNodeTest {
+		public static void main(String[] args) {
+			ListNode head = new ListNode();
+			ListNode second = new ListNode();
+			ListNode third = new ListNode();
+			head.nextNode = second;
+			second.nextNode = third;
+			head.data = 1;
+			second.data = 2;
+			third.data = 3;
+			deleteNode(head, second);
+			System.out.println(head.nextNode.data);
+		}
+	
+		/**
+		 * 
+		 * @param head
+		 *            头结点
+		 * @param deListNode
+		 *            将被删除的节点
+		 */
+		public static void deleteNode(ListNode head, ListNode deListNode) {
+			if (deListNode == null || head == null) {
+				return;
+			}
+	
+			if (head == deListNode) {
+				// 要删除的这个节点正好是头节点
+				head = null;
+			} else if (deListNode.nextNode == null) {
+				// 要删除的这个节点正好是最后一个节点
+				ListNode pointListNode = head;
+				while (pointListNode.nextNode.nextNode != null) {
+					pointListNode = pointListNode.nextNode;
+				}
+				pointListNode.nextNode = null;
+			} else {
+				// 要删除的节点是中间的节点，直接把该节点的值和next指向下一个节点就可以。
+				deListNode.data = deListNode.nextNode.data;
+				deListNode.nextNode = deListNode.nextNode.nextNode;
+			}
+		}
+	}
+	
+	class ListNode {
+		int data;
+		ListNode nextNode;
+	}
+    ```
+14. 调整数组顺序使奇数位于偶数前面              
+    输入一个整数数组，实现一个函数来调整该函数数组中数字的顺序，使得
+所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。
+    思路: 维护两个指针，一个指向第一个元素，一个指向最后一个元素，然后通过指针的移动，来判断当前元素是奇数还是偶数，来交换位置。　　　
+	```java
+	public static void order(int[] array) {
+		if (array == null || array.length == 0) {
+			return;
+		}
+		int start = 0;
+		int end = array.length - 1;
+		while (start < end) {
+			while (start < end && !isEven(array[start])) {
+				// 如果当前位置是奇数，就下移指针
+				start++;
+			}
+			while (start < end && isEven(array[end])) {
+				// 第二个指针如果当前位置是偶数，就向前移动指针
+				end--;
+			}
+			if (start < end) {
+			    // 说明第一个指针指向的是偶数，第二个指针指向的是奇数，我们来更换他俩的位置。
+				int temp = array[start];
+				array[start] = array[end];
+				array[end] = temp;
+			}
+		}
+	}
+
+	private static boolean isEven(int n) {
+		return n % 2 == 0;
+	}
+	```
+	
+15. 链表中倒数第K个结点            
+    输入一个链表，输出该链表中倒数第`k`个结点。   
+    思路: 拿到倒数第k个节点，我们只需要知道该链表的总长度，然后我们从头开始遍历渠道第`totalLength-k`个就是了。如何拿到总长度，也简单就是遍历一遍就知道了。
+	但是这样会牵扯到两次遍历，效率比较低。那怎么处理呢？也是使用两个指针，我们要保证第一个指针走到链表最后一个位置(totalLength)的时候，第二个指针正好指向倒数第`k`个节点(
+	也就是从头开始第`totalLength-k+1个`)，那这两个指针之间差多少呢？`totalLength-(totalLength-k+1)`也就是`k-1`个位置，所以让第一个指针移动到第`k-1`个位置后，就让第二个指针
+	开始移动，这样等第一个移动到最后一个元素的时候，第二个正好指向了倒数第`k`个元素。
+	```java
+	public class ListNodeTailText {
+		public static void main(String[] args) {
+			ListNode node1 = new ListNode();
+			ListNode node2 = new ListNode();
+			ListNode node3 = new ListNode();
+			ListNode node4 = new ListNode();
+			node1.nextNode = node2;
+			node2.nextNode = node3;
+			node3.nextNode = node4;
+			node1.data = 1;
+			node2.data = 2;
+			node3.data = 3;
+			node4.data = 4;
+			ListNode resultListNode = findKToTail(node1, 3);
+			System.out.println(resultListNode.data);
+		}
+
+		public static ListNode findKToTail(ListNode head, int k) {
+			if (head == null || k == 0) {
+				return null;
+			}
+			ListNode firstIndex = head;
+			ListNode secondIndex = head;
+			for (int i = 0; i < k; ++i) {
+				if (firstIndex.nextNode != null) {
+					firstIndex = firstIndex.nextNode;
+				} else {
+					return null;
+				}
+			}
+			while (firstIndex != null) {
+				secondIndex = secondIndex.nextNode;
+				firstIndex = firstIndex.nextNode;
+			}
+			return secondIndex;
+		}
+	}
+
+	class ListNode {
+		int data;
+		ListNode nextNode;
+	}
+	```
+16. 反转链表           
+    定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的头结点。       
+	思路:反转链表问的比较多，整体的思路就是从后往前来，这个问题我也是花了很长时间才弄明白，太笨了。
+    也有两种方式：递归和普通的方式        
+
+    ```java
+    public class LinkedListDemo {
+    	public static void main(String[] args) {
+    		ListNode head = new ListNode();
+    		ListNode second = new ListNode();
+    		ListNode third = new ListNode();
+    		ListNode forth = new ListNode();
+    		head.nextNode = second;
+    		second.nextNode = third;
+    		third.nextNode = forth;
+    		head.data = 1;
+    		second.data = 2;
+    		third.data = 3;
+    		forth.data = 4;
+    		ListNode resultListNode = reverse1(head);
+    		System.out.println(resultListNode.data);
+    	}
+    
+    	/**
+    	 * 递归
+    	 * 
+    	 * @param head
+    	 * @return
+    	 */
+    	public static ListNode reverse1(ListNode head) {
+    		if (null == head || null == head.getNextNode()) {
+    			return head;
+    		}
+    		// A B C -> A C B -> C B A
+    		ListNode reversedHead = reverse1(head.getNextNode());
+    		head.getNextNode().setNextNode(head);
+    		head.setNextNode(null);
+    		return reversedHead;
+    	}
+    
+    	public static ListNode reverse2(ListNode head) {
+    		if (null == head) {
+    			return head;
+    		}
+    		// A B C
+    		ListNode pre = head;  // A
+    		ListNode cur = head.getNextNode();  // B
+    		ListNode next;
+    		while (cur != null) {
+    			// next = C
+    			next = cur.getNextNode();
+    			// B -> A
+    			cur.setNextNode(pre);
+    			// pre = B
+    			pre = cur;
+    			// cur = C
+    			cur = next;
+    			// 第一轮下来就是 A B C -> A B A 
+    			// 第二轮下来就是 C B A  pre = C cur = null
+    			// 再继续就会跳出循环
+    		}
+    	
+    		// 虽然已经是C B A 了，但是不要忘了此时A的next还是B，所以我们要将其设置为null
+    		// 将原链表的头节点的下一个节点置为null，再将反转后的头节点赋给head
+    		head.setNextNode(null);
+    		head = pre;
+    		// 到这就是返回C了。
+    		return head;
+    	}
+    }
+    
+    class ListNode {
+    	public ListNode nextNode;
+    	public int data;
+    
+    	public ListNode getNextNode() {
+    		return nextNode;
+    	}
+    
+    	public void setNextNode(ListNode nextNode) {
+    		this.nextNode = nextNode;
+    	}
+    
+    	public int getData() {
+    		return data;
+    	}
+    
+    	public void setData(int data) {
+    		this.data = data;
+    	}
+    }
+    ```
+17. 合并两个排序的链表
+    输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然是按
+    照递增排序的。	
+	思路: 合并两个链表，按照递增顺序，那就是假设第一个链表是1 3 第二个链表是2 4 6那怎么去合并呢？
+	先是比较两个链表的头结点，１和２比较，那合并后的新链表头肯定是１了，然后再拿2和3比较看谁是第二个结点，那可定是2了，到这里就确定了新链表的前两个结点，
+	就是1 2 然后再用3和4比较确定谁是第三个，这是啥？这是递归。
+	```java
+	public class MergeListTest {
+		public static void main(String[] args) {
+			ListNode head1 = new ListNode();
+			ListNode second1 = new ListNode();
+			ListNode head2 = new ListNode();
+			ListNode second2 = new ListNode();
+			ListNode third2 = new ListNode();
+			head1.nextNode = second1;
+			head2.nextNode = second2;
+			second2.nextNode = third2;
+			head1.data = 1;
+			second1.data = 3;
+			head2.data = 2;
+			second2.data = 2;
+			third2.data = 2;
+			MergeListTest test = new MergeListTest();
+			ListNode result = test.mergeList(head1, head2);
+			System.out.println(result.nextNode.nextNode.nextNode.nextNode.data);
+		}
+
+		public ListNode mergeList(ListNode head1, ListNode head2) {
+			if (head1 == null) {
+				return head2;
+			} else if (head2 == null) {
+				return head1;
+			}
+			ListNode mergeHead = null;
+			if (head1.data < head2.data) {
+				mergeHead = head1;
+				mergeHead.nextNode = mergeList(head1.nextNode, head2);
+			} else {
+				mergeHead = head2;
+				mergeHead.nextNode = mergeList(head1, head2.nextNode);
+			}
+			return mergeHead;
+		}
+	}
+
+	class ListNode {
+		public ListNode nextNode;
+		public int data;
+
+		public ListNode getNextNode() {
+			return nextNode;
+		}
+
+		public void setNextNode(ListNode nextNode) {
+			this.nextNode = nextNode;
+		}
+
+		public int getData() {
+			return data;
+		}
+
+		public void setData(int data) {
+			this.data = data;
+		}
+	}
+	```
+18. 树的子结构	               
+
+    输入两颗二叉树 A 和 B，判断 B 是不是 A 的子结构。
+	![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/findchildbinarytree.png)	  
+	思路:   想要判断B树是不是A的子树，那首先要先去在A树种遍历找到与B树根节点相同的结点，然后再从这个结点去遍历子结点
+	看字节点与B树是否一样，如果不一样就继续往下遍历结点，找与B树根节点一直的结点，如此循环。
+	以上图为例，我们先在A中找8的结点，发现A的根节点就是，然后继续看A的左子节点是8，而B的左子节点是9，锁着这
+	肯定不是了，继续往下找为8的结点，发现在A树的第二层找打了，然后再进行判断该结点下的子节点，发现为9和2，正好与B的相同
+	就是他了。
+	```java
+	public class Problem18 {
+		public static void main(String args[]) {
+			BinaryTreeNode root1 = new BinaryTreeNode();
+			BinaryTreeNode node1 = new BinaryTreeNode();
+			BinaryTreeNode node2 = new BinaryTreeNode();
+			BinaryTreeNode node3 = new BinaryTreeNode();
+			BinaryTreeNode node4 = new BinaryTreeNode();
+			BinaryTreeNode node5 = new BinaryTreeNode();
+			BinaryTreeNode node6 = new BinaryTreeNode();
+			root1.leftNode = node1;
+			root1.rightNode = node2;
+			node1.leftNode = node3;
+			node1.rightNode = node4;
+			node4.leftNode = node5;
+			node4.rightNode = node6;
+			root1.value = 8;
+			node1.value = 8;
+			node2.value = 7;
+			node3.value = 9;
+			node4.value = 2;
+			node5.value = 4;
+			node6.value = 7;
+			BinaryTreeNode root2 = new BinaryTreeNode();
+			BinaryTreeNode a = new BinaryTreeNode();
+			BinaryTreeNode b = new BinaryTreeNode();
+			root2.leftNode = a;
+			root2.rightNode = b;
+			root2.value = 8;
+			a.value = 9;
+			b.value = 2;
+			System.out.println(hasSubTree(root1, root2));
+		}
+
+		public static boolean hasSubTree(BinaryTreeNode root1, BinaryTreeNode root2) {
+			boolean result = false;
+			if (root1 != null && root2 != null) {
+				if (root1.value == root2.value) {
+					result = doesTree1HavaTree2(root1, root2);
+					if (!result) {
+						result = hasSubTree(root1.leftNode, root2);
+					}
+					if (!result) {
+						result = hasSubTree(root1.rightNode, root2);
+					}
+				}
+			}
+			return result;
+		}
+
+		private static boolean doesTree1HavaTree2(BinaryTreeNode root1,
+				BinaryTreeNode root2) {
+			if (root2 == null) {
+				return true;
+			} else if (root1 == null)
+				return false;
+			if (root1.value != root2.value) {
+				return false;
+			}
+			return doesTree1HavaTree2(root1.leftNode, root2.leftNode)
+					&& doesTree1HavaTree2(root1.rightNode, root2.rightNode);
+		}
+	}
+
+	class BinaryTreeNode {
+		int value;
+		BinaryTreeNode leftNode;
+		BinaryTreeNode rightNode;
+	}
+	```
+19. 二叉树的镜像
+    请完成一个函数，输入一个二叉树，该函数输出它的镜像。	
+    思路：什么事镜像？ 就像照镜子一样。打个比方现在的数是
+    ```
+            1                                                   1
+        2         3      左图的二叉树的镜像就是             3          2
+     4     5  6       7                              7       6  5        4
+    ```
+    就是从根节点开始，先前序遍历这棵树的每个结点,先转换它的两个子节点，然后再对这两个子节点下的子节点进行转换。
+    ```java
+    public class mirrorBinaryTreeTest {
+        public static void main(String[] args) {
+    		BinaryTreeNode root1 = new BinaryTreeNode();
+    		BinaryTreeNode node1 = new BinaryTreeNode();
+    		BinaryTreeNode node2 = new BinaryTreeNode();
+    
+    		BinaryTreeNode node3 = new BinaryTreeNode();
+    		BinaryTreeNode node4 = new BinaryTreeNode();
+    		BinaryTreeNode node5 = new BinaryTreeNode();
+    		BinaryTreeNode node6 = new BinaryTreeNode();
+    		root1.leftNode = node1;
+    		root1.rightNode = node2;
+    		node1.leftNode = node3;
+    		node1.rightNode = node4;
+    		node4.leftNode = node5;
+    		node4.rightNode = node6;
+    		root1.value = 8;
+    		node1.value = 8;
+    		node2.value = 7;
+    		node3.value = 9;
+    		node4.value = 2;
+    		node5.value = 4;
+    		node6.value = 7;
+    		BinaryTreeNode rootBinaryTreeNode = mirrorBinaryTree(root1);
+    	}
+    
+    	public static BinaryTreeNode mirrorBinaryTree(BinaryTreeNode root) {
+    		if (root == null) {
+    			return null;
+    		}
+    		if (root.leftNode == null && root.rightNode == null)
+    			return null;
+    		Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
+    		while (root != null || !stack.isEmpty()) {
+    			while (root != null) {
+    				BinaryTreeNode temp = root.leftNode;
+    				root.leftNode = root.rightNode;
+    				root.rightNode = temp;
+    				stack.push(root);
+    				root = root.leftNode;
+    			}
+    			root = stack.pop();
+    			root = root.rightNode;
+    		}
+    		return root;
+    	}
+    }
+    
+    class BinaryTreeNode {
+    	public int value;
+    	public BinaryTreeNode leftNode;
+    	public BinaryTreeNode rightNode;
+    
+    	public BinaryTreeNode() {
+    
+    	}
+    
+    	public BinaryTreeNode(int value) {
+    		this.value = value;
+    		this.leftNode = null;
+    		this.rightNode = null;
+    	}
+    }
+    ```
+20. 顺时针打印矩阵
+    输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字。
+    ```
+    1   2   3    4  
+    5   6   7    8
+    9   10  11  12
+    ```
+    思路：顺时针打印也就是4步，从左往右、从上往下、从右向左、从下往上，然后继续循环如此，
+    当然在每次循环的时候都要判断好，以免只有一行或者一列或者一个元素的情况。
+    ```java
+    public class printMatrixTest {
+        public static void main(String[] args) {
+    		int[][] arr = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } };
+    		printMatrixInCircle(arr);
+    	}
+    
+    	public static void printMatrixInCircle(int[][] array) {
+    		if (array == null) {
+    			return;
+    		}
+    		int start = 0;
+    		// 循环的次数就是维度要大于指针的2倍
+    		while (array[0].length > start * 2 && array.length > start * 2) {
+    			printOneCircle(array, start);
+    			start++;
+    		}
+    	}
+    
+    	private static void printOneCircle(int[][] array, int start) {
+    		int columns = array[0].length;
+    		int rows = array.length;
+    		int endX = columns - 1 - start;
+    		int endY = rows - 1 - start;
+    		// 从左到右打印一行
+    		for (int i = start; i <= endX; i++) {
+    			int number = array[start][i];
+    			System.out.print(number + ",");
+    		}
+    		// 从上到下打印一列
+    		if (start < endY) {
+    			for (int i = start + 1; i <= endY; i++) {
+    				int number = array[i][endX];
+    				System.out.print(number + ",");
+    			}
+    		}
+    		// 从右到左打印一行
+    		if (start < endX && start < endY) {
+    			for (int i = endX - 1; i >= start; i--) {
+    				int number = array[endY][i];
+    				System.out.print(number + ",");
+    			}
+    		}
+    		// 从下到上打印一列
+    		if (start < endY && start < endY - 1) {
+    			for (int i = endY - 1; i >= start + 1; i--) {
+    				int number = array[i][start];
+    				System.out.print(number + ",");
+    			}
+    		}
+    	}
+    }
+    ```
+21. 包含`min`函数的栈        
+    定义栈的数据结构,请在该类型中实现一个能够得到栈的最小元素的`min`函数。
+    在该栈中,调用`min`、`push`及`pop`的时间复杂度都是O(1)          
+    思路: 最先想到的就是用一个变量记录住最小的元素，但是如果这个最小的元素被取出了呢？ 
+    怎么再返回剩下所有元素中最小的一个呢？很显然用一个变量记住是不行的，我们必须要用
+    一个辅助栈来纪录这小小元素。
+    ```java
+    public class MinInStack {
+        /**
+    	 * 辅助栈，来纪录这些小的元素
+    	 */
+    	private MyStack<Integer> minStack = new MyStack<>();
+    	private MyStack<Integer> dataStack = new MyStack<>();
+    
+    	public void push(Integer item) {
+    		dataStack.push(item);
+    		if (minStack.length == 0 || item <= minStack.head.data) {
+    			minStack.push(item);
+    		} else {
+    			minStack.push(minStack.head.data);
+    		}
+    	}
+    
+    	public Integer pop() {
+    		if (dataStack.length == 0 || minStack.length == 0) {
+    			return null;
+    		}
+    		minStack.pop();
+    		return dataStack.pop();
+    	}
+    
+    	public Integer min() {
+    		if (minStack.length == 0) {
+    			return null;
+    		}
+    		return minStack.head.data;
+    	}
+    
+    	public static void main(String[] args) {
+    		MinInStack test = new MinInStack();
+    		test.push(3);
+    		test.push(2);
+    		test.push(1);
+    		System.out.println(test.pop());
+    		System.out.println(test.min());
+    	}
+    }
+    
+    /**
+     * 链表
+     */
+    class ListNode<K> {
+    	K data;
+    	ListNode<K> nextNode;
+    }
+    
+    /**
+     * 自定义栈的数据结构
+     */
+    class MyStack<K> {
+    	public ListNode<K> head;
+    	/**
+    	 * 当前栈的大小
+    	 */
+    	public int length;
+    
+    	public void push(K item) {
+    		ListNode<K> node = new ListNode<K>();
+    		node.data = item;
+    		node.nextNode = head;
+    		head = node;
+    		length++;
+    	}
+    
+    	public K pop() {
+    		if (head == null)
+    			return null;
+    		ListNode<K> temp = head;
+    		head = head.nextNode;
+    		length--;
+    		return temp.data;
+    	}
+    
+    }
+    ```
+22. 栈的压入、弹出序列         
+    题目:输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是 
+    否为该栈的弹出序列。假设压入栈的所有数字均不相等。
+    例如压栈序列为 1、2、3、4、5.序列 4、5、3、2、1 是压栈序列对应的一个
+    弹出序列,但 4、3、5、1、2 却不是。        
+    思路: 这道题我完全没看懂，看完后实在不理解是什么意思。 - -！搜了很久才弄明白。
+    什么事对应的弹出序列呢？ 就是这个入栈后所有的可能弹出的方式。比如我可以完全按照1、2、3、4、5
+    的方式去放入，然后取出就是5、4、3、2、1，也可以在1、2
+    进入的时候先把2弹出，然后再继续添加3、4、5，这样的弹出顺序就是2、5、4、3、1。
+    但是为什么4、3、5、1、2是不对的呢？ 这是因为1、2、3、4添加进入的时候，我们先弹出
+    4然后再弹出3，因为以后要弹5，所以我们必须继续添加5，这样栈内就剩下了1、2、5，然后我们再
+    往外弹出就只能是5、2、1，也就是他的顺序只能是4、3、5、2、1。        
+    那怎么判断呢？ 如果下一个弹出的数字刚好是栈顶数字，那么直接弹出。
+    如果下一个弹出的数字不在栈顶，我们把压栈序列中还没有入栈的数字压入辅助栈，
+    直到把下一个需要弹出的数字压入栈顶为止。如果所有的数字都压入栈了仍没有
+    找到下一个弹出的数字，那么该序列不可能是一个弹出序列。
+    ```java
+    public class PopOrderTest {
+        public static void main(String[] args) {
+    		int[] array1 = { 1, 2, 3, 4, 5 };
+    		int[] array2 = { 4, 3, 5, 1, 2 };
+    		System.out.println(isPopOrder(array1, array2));
+    	}
+    
+    	public static boolean isPopOrder(int[] line1, int[] line2) {
+    		if (line1 == null || line2 == null) {
+    			return false;
+    		}
+    		int index = 0;
+    		// 把line1中的元素都加入该栈
+    		Stack<Integer> stack = new Stack<Integer>();
+    		for (int i = 0; i < line2.length; i++) {
+    			if (!stack.isEmpty() && stack.peek() == line2[i]) {
+    				// 要取出的元素正好是栈顶的元素，就直接取出。
+    				stack.pop();
+    			} else {
+    				if (index == line1.length) {
+    					// line1的元素已经全部加入栈中，且要取出的元素仍然不是栈顶的元素，那就说明line1中不包含要取出的元素。直接返回false
+    					return false;
+    				} else {
+    					// 只要要取出的元素不是栈顶的，就一直往栈里面加
+    					do {
+    						stack.push(line1[index++]);
+    					} while (stack.peek() != line2[i] && index != line1.length);
+    					
+    					if (stack.peek() == line2[i]) {
+    						stack.pop();
+    					} else {
+    						return false;
+    					}
+    				}
+    			}
+    		}
+    		return true;
+    	}
+    }
+    ```
+23. 从上往下打印二叉树         
+    从上往下打印二叉树的每个结点，同一层的结点按照从左到右的顺序打印。      
+    思路: 每一次打印一个结点的时候，如果该结点有子节点，把该结点的子节点放到一个队列的尾。接下来到队列的头部取出最早进入队列的结点，重复前面打印操作，直到队列中所有的结点都被打印出为止。
+    ```java
+    public class Problem23 {
+        public static void main(String args[]) {
+    		BinaryTreeNode root1 = new BinaryTreeNode();
+    		BinaryTreeNode node1 = new BinaryTreeNode();
+    		BinaryTreeNode node2 = new BinaryTreeNode();
+    		BinaryTreeNode node3 = new BinaryTreeNode();
+    		BinaryTreeNode node4 = new BinaryTreeNode();
+    		BinaryTreeNode node5 = new BinaryTreeNode();
+    		BinaryTreeNode node6 = new BinaryTreeNode();
+    
+    		root1.leftNode = node1;
+    		root1.rightNode = node2;
+    		node1.leftNode = node3;
+    		node1.rightNode = node4;
+    		node4.leftNode = node5;
+    		node4.rightNode = node6;
+    		root1.value = 8;
+    		node1.value = 8;
+    		node2.value = 7;
+    		node3.value = 9;
+    		node4.value = 2;
+    		node5.value = 4;
+    		node6.value = 7;
+    
+    		Problem23 test = new Problem23();
+    		test.printFromTopToBottom(root1);
+    	}
+    
+    	public void printFromTopToBottom(BinaryTreeNode root) {
+    		if (root == null)
+    			return;
+    		Queue<BinaryTreeNode> queue = new LinkedList<BinaryTreeNode>();
+    		queue.add(root);
+    		while (!queue.isEmpty()) {
+    			BinaryTreeNode node = queue.poll();
+    			System.out.print(node.value);
+    			if (node.leftNode != null) {
+    				queue.add(node.leftNode);
+    			}
+    			if (node.rightNode != null) {
+    				queue.add(node.rightNode);
+    			}
+    		}
+    	}
+    }
+    
+    class BinaryTreeNode {
+    	public int value;
+    	public BinaryTreeNode leftNode;
+    	public BinaryTreeNode rightNode;
+    
+    	public BinaryTreeNode() {
+    
+    	}
+    
+    	public BinaryTreeNode(int value) {
+    		this.value = value;
+    		this.leftNode = null;
+    		this.rightNode = null;
+    	}
+    }
+    ```
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
diff --git "a/JavaKnowledge/\345\211\221\346\214\207Offer(\344\270\213).md" "b/JavaKnowledge/\345\211\221\346\214\207Offer(\344\270\213).md"
new file mode 100644
index 00000000..4df119ef
--- /dev/null
+++ "b/JavaKnowledge/\345\211\221\346\214\207Offer(\344\270\213).md"
@@ -0,0 +1,133 @@
+剑指Offer(下)
+===
+
+剑指Offer(上)一共是23道题。       
+
+24. 二叉搜索树的后序遍历序列     
+    输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历的结果。 是则返回`true`,否则返回`false`。假设输入的数组的任意两个数字都互不相同              
+    思路:  在后序遍历得到的序列中，最后一个数字是树的根节点的值。
+    数组中前面的数字可以分为两部分：第一部分是左子树结点的值，
+    它们都比根节点的值小；第二部分是右子树结点的值，他们都比根节点的值大。     
+     
+    ```
+    public class Problem24 {
+        public static void main(String[] args) {
+    		int[] array = { 5, 7, 6, 9, 11, 10, 8 };
+    		System.out.println(verfiySequence(array));
+    	}
+    
+    	public static boolean verfiySequence(int[] array) {
+    		if (array == null || array.length == 0) {
+    			return false;
+    		}
+    		int length = array.length;
+    		// 最后一个是根节点
+    		int root = array[length - 1];
+    		// 左右子树的分界点，因为左子树都是小于根节点的，右子树都是大于的。
+    		int cut = 0;
+    		for (int i = 0; i < length - 1; i++) {
+    			if (array[i] > root) {
+    				// 到了右子树的分界点
+    				cut = i + 1;
+    				break;
+    			}
+    		}
+    		if (cut == 0) {
+    			// 没有右子树，都是左子树，然后就继续判断除了上面根节点后的其他所有节点，这些都是左子树的。
+    			verfiySequence(Arrays.copyOfRange(array, 0, length - 1));
+    		} else {
+    			// 有右子树，判断从分界点开始后的所有数是不是都大于根节点。
+    			for (int j = cut; j < length - 1; j++) {
+    				if (array[j] < root) {
+    					// 有不大于根节点值的数，肯定是错误的。
+    					return false;
+    				}
+    			}
+    		}
+    		boolean left = true;
+    		if (cut > 0) {
+    			// 判断左子数里面的元素是否都对
+    			left = verfiySequence(Arrays.copyOfRange(array, 0, cut));
+    		}
+    		boolean right = true;
+    		if (cut < length - 1) {
+    			// 右子树
+    			right = verfiySequence(Arrays.copyOfRange(array, cut, length - 1));
+    		}
+    		return (right && left);
+    	}
+    }
+    ```
+25. 二叉树中和为某一值的路径        
+    输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶结点所经过的所有的结点形成一条路径。      
+    思路: 
+    
+    ```
+    public class Problem25 {
+        public static void main(String args[]) {
+    		BinaryTreeNode root1 = new BinaryTreeNode();
+    		BinaryTreeNode node1 = new BinaryTreeNode();
+    		BinaryTreeNode node2 = new BinaryTreeNode();
+    		BinaryTreeNode node3 = new BinaryTreeNode();
+    		BinaryTreeNode node4 = new BinaryTreeNode();
+    		root1.leftNode = node1;
+    		root1.rightNode = node2;
+    		node1.leftNode = node3;
+    		node1.rightNode = node4;
+    		root1.value = 10;
+    		node1.value = 5;
+    		node2.value = 12;
+    		node3.value = 4;
+    		node4.value = 7;
+    		Problem25 testFindPath = new Problem25();
+    		testFindPath.findPath(root1, 22);
+    	}
+    
+    	public void findPath(BinaryTreeNode root, int sum) {
+    		if (root == null)
+    			return;
+    		Stack<Integer> stack = new Stack<Integer>();
+    		int currentSum = 0;
+    		findPath(root, sum, stack, currentSum);
+    	}
+    
+    	private void findPath(BinaryTreeNode root, int sum, Stack<Integer> stack, int currentSum) {
+    		currentSum += root.value;
+    		stack.push(root.value);
+    		if (root.leftNode == null && root.rightNode == null) {
+    			// 到节点的尾部了
+    			if (currentSum == sum) {
+    				for (int path : stack) {
+    					System.out.print(path + " ");
+    				}
+    				System.out.println();
+    			}
+    		}
+    		if (root.leftNode != null) {
+    			findPath(root.leftNode, sum, stack, currentSum);
+    		}
+    		if (root.rightNode != null) {
+    			findPath(root.rightNode, sum, stack, currentSum);
+    		}
+    		stack.pop();
+    	}
+    }
+    
+    class BinaryTreeNode {
+    	public static int value;
+    	public BinaryTreeNode leftNode;
+    	public BinaryTreeNode rightNode;
+    }
+    ```
+
+26. 复杂链表的复制      
+    实现函数复制一个复杂链表。在复杂链表中,每个结点除了有一个 next 指针指向下一个结点外,还有一个指向链表中任意结点或 null。      
+    
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
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"
new file mode 100644
index 00000000..a010cb92
--- /dev/null
+++ "b/JavaKnowledge/\345\212\250\346\200\201\344\273\243\347\220\206.md"
@@ -0,0 +1,389 @@
+动态代理
+===
+
+有关代理模式已经动态代理和静态代理的区别请查看另一篇文章[设计模式](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F.md)             
+
+动态代理我们平时用的其实并不多，但是作为`Android`开发，你肯定知道`Retrofit`，而`Retrofit`就是基于动态代理实现。   
+
+动态代理的类和接口
+---
+
+- `Proxy`:动态代理机制的主类，提供一组静态方法为一组接口动态的生成对象和代理类。
+
+```java
+// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器
+public static InvocationHandler getInvocationHandler(Object proxy) 
+
+// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
+public static Class<?> getProxyClass(ClassLoader loader, 
+Class<?>... interfaces)
+
+// 方法 3：该方法用于判断指定类对象是否是一个动态代理类
+public static boolean isProxyClass(Class<?> cl) 
+
+// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
+public static Object newProxyInstance(ClassLoader loader,
+ Class<?>[] interfaces,InvocationHandler h)
+```
+
+
+- `InvocationHandler`:调用处理器接口，自定义invoke方法，用于实现对于真正委托类的代理访问。
+
+```java
+/**
+ 该方法负责集中处理动态代理类上的所有方法调用。
+ 第一个参数既是代理类实例，
+ 第二个参数是被调用的方法对象
+ 第三个方法是调用参数。
+ 调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行
+*/
+public Object invoke(Object proxy, Method method, Object[] args)
+    throws Throwable;
+```
+
+- `ClassLoader`:类装载器类，将类的字节码装载到`Java`虚拟机`(JVM)`中并为其定义类对象，然后该类才能被使用。
+`Proxy`类与普通类的唯一区别就是其字节码是由`JVM`在运行时动态生成的而非预存在于任何一个`.class`文件中。
+每次生成动态代理类对象时都需要指定一个类装载器对象:`newProxyInstance()`方法第一个参数。  
+
+
+动态代理机制
+---
+
+`java`动态代理创建对象的过程为如下步骤:   
+
+- 通过实现`InvocationHandler`接口创建自己的调用处理器           
+```java
+// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
+// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
+InvocationHandler handler = new InvocationHandlerImpl(..); 
+```
+
+- 通过为`Proxy`类指定`ClassLoader`对象和一组`interface`来创建动态代理类        
+```java
+// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
+Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 
+```
+- 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型          
+```java
+// 通过反射从生成的类对象获得构造函数对象
+Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });
+```
+
+- 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入
+```java
+// 通过构造函数对象创建动态代理类实例
+Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });
+```
+
+为了简化对象创建过程,`Proxy`类中的`newProxyInstance`方法封装了2~4，只需两步即可完成代理对象的创建。
+```java
+// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
+InvocationHandler handler = new InvocationHandlerImpl(..); 
+
+// 通过 Proxy 直接创建动态代理类实例
+Interface proxy = (Interface)Proxy.newProxyInstance( classLoader, 
+     new Class[] { Interface.class }, 
+     handler );
+```
+
+
+动态代理的注意点
+---
+
+- 包:代理接口是`public`，则代理类被定义在顶层包`(package为空)`，否则`(default)`，代理类被定义在该接口所在包，
+- 生成的代理类为`public final`的，不能被继承
+- 类名:格式是`$ProxyN`，`N`是逐一递增的数字，代表`Proxy`被第`N`次动态生成的代理类，要注意对于同一组接口(接口的排列顺序也相同)，不会重复创建动态代理类，而是返回一个先前已经创建并缓存了的代理类对象。提高了效率。
+- `Proxy`类是它的父类，这个规则适用于所有由`Proxy`创建的动态代理类。(也算是`java`动态代理的一处缺陷，`java`不支持多继承，所以无法实现对`class`的动态代理，只能对于`Interface`的代理)而且该类还实现了其所代理的一组接口，这就是为什么它能够被安全地类型转换到其所代理的某接口的根本原因。
+- 代理类的根类`java.lang.Object`中有三个方法也同样会被分派到调用处理器的`invoke`方法执行，它们是`hashCode`，`equals`和`toString`.    
+
+
+示例代码:      
+
+```java
+import java.lang.reflect.InvocationHandler;  
+import java.lang.reflect.Method;  
+import java.lang.reflect.Proxy;  
+
+public class HelloServiceProxy implements InvocationHandler {  
+
+
+    private Object target;    
+    /**  
+     * 绑定委托对象并返回一个【代理占位】 
+     * @param target 真实对象 
+     * @return  代理对象【占位】 
+     */    
+    public  Object bind(Object target, Class[] interfaces) {    
+        this.target = target;    
+        //取得代理对象    
+       return Proxy.newProxyInstance(target.getClass().getClassLoader(),    
+                target.getClass().getInterfaces(), this);
+    }    
+
+	@Override    
+    /** 
+     * 同过代理对象调用方法首先进入这个方法. 
+     * @param proxy --代理对象 
+     * @param method -- 方法,被调用方法. 
+     * @param args -- 方法的参数 
+     */  
+    public Object invoke(Object proxy , Method method, Object[] args) throws Throwable {    
+        System.err.println("############我是JDK动态代理################");  
+        Object result = null;    
+        //反射方法前调用  
+        System.err.println("我准备说hello。");    
+        //反射执行方法  相当于调用target.sayHelllo;  
+        result=method.invoke(target, args);  
+        //反射方法后调用.  
+        System.err.println("我说过hello了");    
+        return result;    
+    }    
+} 
+``` 
+
+其中，`bind`方法中的`newProxyInstance()`方法，就是生成一个代理对象，第一个参数是类加载器，第二个参数是真实委托对象所实现的的接口（代理对象挂在那个接口下），第三个参数`this`代表当前`HelloServiceProxy`类，换句话说是使用`HelloServiceProxy`作为对象的代理。
+
+`invoke()`方法有三个参数:第一个`proxy`是代理对象，第二个是当前调用那个方法，第三个是方法的参数。
+
+```java
+public class ProxyTest {  
+
+    public static void main(String[] args) {   
+        HelloServiceProxy proxy = new HelloServiceProxy();  
+        HelloService service = new HelloServiceImpl();  
+        //绑定代理对象。  
+        service = (HelloService) proxy.bind(service, new Class[] {HelloService.class});  
+        //这里service经过绑定，就会进入invoke方法里面了。  
+        service.sayHello("张三");  
+    }  
+}  
+```
+
+
+源码跟踪
+---
+
+- `Proxy`类 
+
+```java
+// 映射表：用于维护类装载器对象到其对应的代理类缓存
+private static Map loaderToCache = new WeakHashMap(); 
+
+// 标记：用于标记一个动态代理类正在被创建中
+private static Object pendingGenerationMarker = new Object(); 
+
+// 同步表：记录已经被创建的动态代理类类型，主要被方法 isProxyClass 进行相关的判断
+private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap()); 
+
+// 关联的调用处理器引用
+protected InvocationHandler h;
+
+public static Object newProxyInstance(ClassLoader loader, 
+            Class<?>[] interfaces, 
+            InvocationHandler h) 
+            throws IllegalArgumentException { 
+
+    // 检查 h 不为空，否则抛异常
+    if (h == null) { 
+        throw new NullPointerException(); 
+    } 
+
+    // 获得与制定类装载器和一组接口相关的代理类类型对象
+    /*
+     * Look up or generate the designated proxy class.
+     */
+        Class<?> cl = getProxyClass0(loader, interfaces); 
+
+    // 通过反射获取构造函数对象并生成代理类实例
+    /*
+     * Invoke its constructor with the designated invocation handler.
+     */
+    try {
+            final Constructor<?> cons = cl.getConstructor(constructorParams);
+            final InvocationHandler ih = h;
+            SecurityManager sm = System.getSecurityManager();
+            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
+                // create proxy instance with doPrivilege as the proxy class may
+                // implement non-public interfaces that requires a special permission
+                return AccessController.doPrivileged(new PrivilegedAction<Object>() {
+                    public Object run() {
+                        return newInstance(cons, ih);
+                    }
+                });
+            } else {
+                return newInstance(cons, ih);
+            }
+    } catch (NoSuchMethodException e) {
+        throw new InternalError(e.toString());
+    } 
+}
+
+private static Object newInstance(Constructor<?> cons, InvocationHandler h) {
+    try {
+        return cons.newInstance(new Object[] {h} );
+    } catch (IllegalAccessException e) {
+        throw new InternalError(e.toString());
+    } catch (InstantiationException e) {
+        throw new InternalError(e.toString());
+    } catch (InvocationTargetException e) {
+        Throwable t = e.getCause();
+        if (t instanceof RuntimeException) {
+            throw (RuntimeException) t;
+        } else {
+            throw new InternalError(t.toString());
+        }
+    }
+}
+```
+
+动态代理真正的关键是在`getProxyClass()`方法，该方法主要分为四个步骤:   
+
+- 对这组接口进行一定程度的安全检查 
+检查接口类对象是否对类装载器可见并且与类装载器所能识别的接口类对象是完全相同的，还会检查确保是`interface`类型而不是`class`类型。
+
+- 从`loaderToCache()`映射表中获取以类装载器对象为关键字所对应的缓存表，如果不存在就创建一个新的缓存表并更新到`loaderToCache()`。`loaderToCache()`存放键值对(接口名字列表，动态生成的代理类的类对象引用)。当代理类正在被创建时它会临时保存(接口名字列表`pendingGenerationMarker`）。标记`pendingGenerationMarke()`的作用是通知后续的同类请求（接口数组相同且组内接口排列顺序也相同）代理类正在被创建，请保持等待直至创建完成。     
+
+```java
+/*
+ * Find or create the proxy class cache for the class loader.
+ */
+Map cache;
+synchronized (loaderToCache) {
+    cache = (Map) loaderToCache.get(loader);
+    if (cache == null) {
+    cache = new HashMap();
+    loaderToCache.put(loader, cache);
+    }
+ }
+。。。。。
+do { 
+    // 以接口名字列表作为关键字获得对应 cache 值
+    Object value = cache.get(key); 
+    if (value instanceof Reference) { 
+        proxyClass = (Class) ((Reference) value).get(); 
+    } 
+    if (proxyClass != null) { 
+        // 如果已经创建，直接返回
+        return proxyClass; 
+    } else if (value == pendingGenerationMarker) { 
+        // 代理类正在被创建，保持等待
+        try { 
+            cache.wait(); 
+        } catch (InterruptedException e) { 
+        } 
+        // 等待被唤醒，继续循环并通过二次检查以确保创建完成，否则重新等待
+        continue; 
+    } else { 
+        // 标记代理类正在被创建
+        cache.put(key, pendingGenerationMarker); 
+        // break 跳出循环已进入创建过程
+        break; 
+} while (true);
+```
+
+- 动态创建代理类的`class`对象
+
+```java
+/**
+ * Choose a name for the proxy class to generate.
+ */
+long num;
+synchronized (nextUniqueNumberLock) {
+    num = nextUniqueNumber++;
+}
+String proxyName = proxyPkg + proxyClassNamePrefix + num;
+/*
+ * Verify that the class loader hasn't already
+ * defined a class with the chosen name.
+ */
+
+// 动态地生成代理类的字节码数组
+byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
+    proxyName, interfaces);
+try {
+// 动态地定义新生成的代理类
+    proxyClass = defineClass0(loader, proxyName,
+    proxyClassFile, 0, proxyClassFile.length);
+} catch (ClassFormatError e) {
+    /*
+     * A ClassFormatError here means that (barring bugs in the
+     * proxy class generation code) there was some other
+     * invalid aspect of the arguments supplied to the proxy
+     * class creation (such as virtual machine limitations
+     * exceeded).
+     */
+    throw new IllegalArgumentException(e.toString());
+}
+// 把生成的代理类的类对象记录进 proxyClasses 表
+proxyClasses.put(proxyClass, null);      
+```
+首先根据规则(接口`public`与否)，生成代理类的名称，`$ProxyN`格式，然后动态生成代理类。 
+所有的代码生成的工作都由`ProxyGenerator`所完成了，该类在`rt.jar`中，需要反编译。   
+
+```java
+public static byte[] generateProxyClass(final String name,  
+                                           Class[] interfaces) {  
+   ProxyGenerator gen = new ProxyGenerator(name, interfaces);  
+// 这里动态生成代理类的字节码，由于比较复杂就不进去看了  
+   final byte[] classFile = gen.generateClassFile();  
+
+// 如果saveGeneratedFiles的值为true，则会把所生成的代理类的字节码保存到硬盘上  
+   if (saveGeneratedFiles) {  
+       java.security.AccessController.doPrivileged(  
+       new java.security.PrivilegedAction<Void>() {  
+           public Void run() {  
+               try {  
+                   FileOutputStream file =  
+                       new FileOutputStream(dotToSlash(name) + ".class");  
+                   file.write(classFile);  
+                   file.close();  
+                   return null;  
+               } catch (IOException e) {  
+                   throw new InternalError(  
+                       "I/O exception saving generated file: " + e);  
+               }  
+           }  
+       });  
+   }  
+
+// 返回代理类的字节码  
+   return classFile;  
+}
+```
+
+- 代码生成过程进入结尾部分，根据结果更新缓存表，如果成功则将代理类的类对象引用更新进缓存表，否则清楚缓存表中对应关键值，最后唤醒所有可能的正在等待的线程。
+
+```java
+finally {
+	/*
+	 * We must clean up the "pending generation" state of the proxy
+	 * class cache entry somehow.  If a proxy class was successfully
+	 * generated, store it in the cache (with a weak reference);
+	 * otherwise, remove the reserved entry.  In all cases, notify
+	 * all waiters on reserved entries in this cache.
+	 */
+	synchronized (cache) {
+	if (proxyClass != null) {
+	    cache.put(key, new WeakReference(proxyClass));
+	} else {
+	    cache.remove(key);
+	}
+	cache.notifyAll();
+	}
+}
+return proxyClass;
+```
+
+`JDK`是动态生成代理类，并通过调用解析器，执行接口实现的方法的原理已经一目了然。动态代理加上反射，是很多框架的基础。
+比如`Spring`的`AOP`机制，自定义前置后置通知等控制策略，以及`mybatis`中的运用反射和动态代理来实现插件技术等等。
+
+
+- [Proxy源码](http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/lang/reflect/Proxy.java)
+
+
+
+	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Java\345\237\272\347\241\200/\345\215\225\344\276\213\347\232\204\346\234\200\344\275\263\345\256\236\347\216\260\346\226\271\345\274\217.md" "b/JavaKnowledge/\345\215\225\344\276\213\347\232\204\346\234\200\344\275\263\345\256\236\347\216\260\346\226\271\345\274\217.md"
similarity index 94%
rename from "Java\345\237\272\347\241\200/\345\215\225\344\276\213\347\232\204\346\234\200\344\275\263\345\256\236\347\216\260\346\226\271\345\274\217.md"
rename to "JavaKnowledge/\345\215\225\344\276\213\347\232\204\346\234\200\344\275\263\345\256\236\347\216\260\346\226\271\345\274\217.md"
index f4503900..53743211 100644
--- "a/Java\345\237\272\347\241\200/\345\215\225\344\276\213\347\232\204\346\234\200\344\275\263\345\256\236\347\216\260\346\226\271\345\274\217.md"
+++ "b/JavaKnowledge/\345\215\225\344\276\213\347\232\204\346\234\200\344\275\263\345\256\236\347\216\260\346\226\271\345\274\217.md"
@@ -1,4 +1,4 @@
-单例的最佳实现方式
+单例的最佳实现方式
 ===
 
 ```java
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"
new file mode 100644
index 00000000..8609744e
--- /dev/null
+++ "b/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
@@ -0,0 +1,596 @@
+常用命令行大全
+===
+
+
+文件目录操作命令
+---
+
+- `ls`
+
+    `ls`命令是`linux`下最常用的命令。`ls`命令就是`list`的缩写，默认情况下使用`ls`用来打印出当前目录的列表，如果`ls`指定其他目录，
+    那么就会显示指定目录里的文件及文件夹列表。 通过`ls`命令不仅可以查看`linux`文件夹包含的文件，而且可以查看文件权限(包括目录、文件夹、文件权限)，
+    查看目录信息等等。`ls`命令在日常的`linux`操作中使用得比较多了。
+    
+    命令格式:   
+    `ls [选项] [目录名]`
+    
+    命令功能:    
+    列出目标目录中所有的子目录和文件。
+    
+    常用参:     
+    
+    - `-a`:`–all`列出目录下的所有文件，包括以`.`开头的隐含文件。
+    - `-A`同`-a`，但不列出“.”(表示当前目录)和“..”(表示当前目录的父目录)。
+    - `-c` 配合 `-lt`:根据`ctime`排序及显示`ctime`(文件状态最后更改的时间)配合`-l:`显示`ctime`但根据名称排序否则:根据`ctime`排序
+    - `-l` 除了文件名之外，还将文件的权限、所有者、文件大小等信息详细列出来。
+    - `-s`，`–size`以块大小为单位列出所有文件的大小
+    - `-S`根据文件大小排序
+    - `-t` 以文件修改时间排序
+    - `-X` 根据扩展名排序
+    - `-1` 每行只列出一个文件
+    - `–help` 显示此帮助信息并离开
+    - `–version` 显示版本信息并离开
+    
+    列出`/home/yiibai`文件夹下的所有文件和目录的详细资料，命令:   
+    ```
+    ls -l -R /home/yiibai
+    ```
+    
+    列出当前目录中所有以`t`开头的目录的详细内容，可以使用如下命令:
+    ```
+    ls -l t*
+    ```
+
+- `cd`
+    
+    格式:   
+    `cd [目录名]`
+
+    切换当前目录至`dirName`
+
+    进入系统根目录`cd /`
+
+    使用`cd`命令进入当前用户主目录
+    “当前用户主目录”和“系统根目录”是两个不同的概念。进入当前用户主目录有两个方法。
+    ```
+    cd ~
+    ```
+
+- `pwd`
+
+    查看”当前工作目录“的完整路径
+
+
+ - 创建文件夹               
+
+    `mkdir test`
+
+    递归创建多个目录或一次创建多级目录:   
+    ```        
+    mkdir -p dir01/dir001
+    ```
+
+    创建权限为777的目录:   
+    ```
+    mkdir -m 777 test3
+    ```
+
+- 删除文件       
+
+    该命令的功能为删除一个目录中的一个或多个文件或目录，它也可以将某个目录及其下的所有文件及子目录均删除。
+    `rm xxx.txt`                     
+    `rm -rf file// -fr表示递归和强制，一定要小心使用 rm -fr / 那你的电脑就over了`
+    
+    - `-f`,`--force`忽略不存在的文件，从不给出提示。    
+    - `-i`,`--interactive`进行交互式删除    
+    - `-r`,`-R`,`--recursive`指示`rm`将参数中列出的全部目录和子目录均递归地删除。   
+
+- `rmdir`
+
+     该命令的功能是删除空目录，一个目录被删除之前必须是空的。删除某目录时也必须具有对父目录的写权限。由于只能删除空目录，一般都是使用rm -f
+
+- `mv`
+
+    `mv`命令是`move`的缩写，可以用来移动文件或者将文件改名`(move (rename) files)`，是`Linux`系统下常用的命令，经常用来备份文件或者目录。     
+
+    ```
+    mv [选项] 源文件或目录 目标文件或目录
+    ```
+
+    `mv`命令中第二个参数类型的不同(是目标文件还是目标目录)，`mv`命令将文件重命名或将其移至一个新的目录中。
+    当第二个参数类型是文件时，`mv`命令完成文件重命名，此时，源文件只能有一个(也可以是源目录名)，
+    它将所给的源文件或目录重命名为给定的目标文件名。当第二个参数是已存在的目录名称时，
+    源文件或目录参数可以有多个，`mv`命令将各参数指定的源文件均移至目标目录中。在跨文件系统移动文件时，
+    `mv`先拷贝，再将原有文件删除，而链至该文件的链接也将丢失。
+
+    文件改名:     
+    ```
+    mv test.log new-test.log
+    ```
+
+    移动文件:    
+    ```
+    mv test1.txt test3
+    ```
+
+- `touch`
+
+    `linux`中的`touch`命令不常用，一般用来修改文件时间戳，或者新建一个不存在的文件。
+
+    创建不存在的文件，用法如下所示:   
+    ```
+    touch log1.log log2.log
+    ```
+
+    
+- `cat`
+
+    查看文本内容:`cat xxx.txt`
+    
+    `cat`主要有三大功能:   
+
+    - 一次显示整个文件`cat filename`
+    - 从键盘创建一个文件`cat > filename`只能创建新文件,不能编辑已有文件.
+    - 将几个文件合并为一个文件`cat file1 file2 > file`
+    命令参数:     
+    
+    - `-A`,`--show-all`等价于`-vET`
+    - `-b`,`--number-nonblank`对非空输出行编号
+    - `-e`等价于`-vE`   
+    - `-E`,`--show-ends`在每行结束处显示`$`
+    - `-n`,`--number`对输出的所有行编号,由1开始对所有输出的行数编号
+    - `-s`,`--squeeze-blank`有连续两行以上的空白行，就代换为一行的空白行
+    - `-t`与`-vT`等价
+    - `-T`,`--show-tabs`将跳格字符显示为`^I`
+        
+    - 拷贝           
+        `cp -R 源文件  目标文件// -R 表示对目录进行递归操作`
+
+    
+- `cp`   
+
+    `cp`命令用来复制文件或者目录，是`Linux`系统中最常用的命令之一。
+    
+    用法:   
+    ```
+    cp [选项]... [-T] 源 目的
+    或：
+    cp [选项]... 源... 目录
+    或：
+    cp [选项]... -t 目录 源...
+    ```
+    
+    复制单个文件到目标目录，文件在目标文件中不存在,如果目标文件存在时，会询问是否覆盖:    
+    ```
+    cp log.log logs
+    ```
+
+
+- `tar`  
+
+    在维护配置服务器时，难免会要用到压缩，解压缩，打包，解包等，这时候`tar`命令就是是必不可少的一个功能强大的工具。
+    `linux`中最流行的`tar`是麻雀虽小，五脏俱全，功能强大。
+
+    首先要弄清两个概念：打包和压缩。打包是指将一大堆文件或目录变成一个总的文件；压缩则是将一个大的文件通过一些压缩算法变成一个小文件。
+
+    为什么要区分这两个概念呢？这源于`Linux`中很多压缩程序只能针对一个文件进行压缩，
+    这样当你想要压缩一大堆文件时，你得先将这一大堆文件先打成一个包(`tar`命令)，然后再用压缩程序进行压缩(`gzip, bzip2`命令)。
+
+    `linux`下最常用的打包程序就是`tar`了，使用`tar`程序打出来的包我们常称为`tar`包，`tar`包文件的命令通常都是以`.tar`结尾的。
+    生成`tar`包后，就可以用其它的程序来进行压缩。
+
+    格式:   
+    ```
+    tar[必要参数][选择参数][文件]
+    ```
+    命令功能;   
+    
+    用来压缩和解压文件。tar本身不具有压缩功能，它是调用压缩功能实现的。
+        
+    必要参数有如下：
+
+    - `-A`:新增压缩文件到已存在的压缩
+    - `-B`:设置区块大小
+    - `-c`:建立新的压缩文件
+    - `-d`:记录文件的差别
+    - `-r`:添加文件到已经压缩的文件
+    - `-u`:添加改变了和现有的文件到已经存在的压缩文件
+    - `-x`:从压缩的文件中提取文件
+    - `-t`:显示压缩文件的内容
+    - `-z`:支持gzip解压文件
+    - `-j`:支持bzip2解压文件
+    - `-k`:保留原有文件不覆盖
+    - `-m`:保留文件不被覆盖
+    
+    可选参数如下:   
+    
+    - `-b`:设置区块数目
+    - `-C`:切换到指定目录
+    - `-f`:指定压缩文件
+    - `--help`:显示帮助信息
+    - `--version`:显示版本信息
+    
+    
+- 常见解压/压缩命令
+
+    `tar`文件格式:   
+    ```
+    解包：tar xvf FileName.tar
+    打包：tar cvf FileName.tar DirName
+    (注：tar是打包，不是压缩！)
+    ```
+    
+    `.gz`文件格式:   
+    
+    ```
+    解压1：gunzip FileName.gz
+    解压2：gzip -d FileName.gz
+    压缩：gzip FileName
+    ```
+    
+    `.tar.gz`和`.tgz`:   
+    ```
+    解压：tar zxvf FileName.tar.gz
+    压缩：tar zcvf FileName.tar.gz DirName
+    ```
+    
+    `.bz2`文件格式:  
+    ```
+    解压1：bzip2 -d FileName.bz2
+    解压2：bunzip2 FileName.bz2
+    压缩： bzip2 -z FileName
+    ```
+    
+    `.tar.bz2`文件格式:   
+    ```
+    解压：tar jxvf FileName.tar.bz2
+    压缩：tar jcvf FileName.tar.bz2 DirName
+    ```
+    
+    `.bz`文件格式:    
+    ```
+    解压1：bzip2 -d FileName.bz
+    解压2：bunzip2 FileName.bz
+    压缩：未知
+    ```
+    
+    `.tar.bz`文件格式:    
+    ```
+    解压：tar jxvf FileName.tar.bz
+    压缩：未知
+    ```
+    
+    `.Z`文件格式:    
+    ```
+    解压：uncompress FileName.Z
+    压缩：compress FileName
+    ```
+    
+    `.tar.Z`文件格式:    
+    ```
+    解压：tar Zxvf FileName.tar.Z
+    压缩：tar Zcvf FileName.tar.Z DirName
+    ```
+    
+    `.zip`文件格式:   
+    ```
+    解压：unzip FileName.zip
+    压缩：zip FileName.zip DirName
+    ```
+    
+    `.rar`:   
+    ```
+    解压：rar x FileName.rar
+    压缩：rar a FileName.rar DirName
+    ```
+    
+    将文件全部打包成`tar`包:    
+    ```
+    tar -cvf log1.tar log1.log
+    tar -zcvf log2.tar.gz log2.log
+    tar -jcvf log3.tar.bz2 log3.log
+    ```
+    
+    ```
+    tar -cvf log1.tar log1.log 仅打包，不压缩！
+    tar -zcvf log2.tar.gz log2.log 打包后，以 gzip 压缩
+    tar -zcvf log.tar.bz2 log3.log 打包后，以 bzip2 压缩
+    在参数 f 之后的文件档名是自己取的，我们习惯上都用 .tar 来作为辨识。 如果加 z 参数，则以 .tar.gz 或 .tgz 来代表 gzip 压缩过的 tar 包； 如果加 j 参数，则以 .tar.bz2 来作为tar包名。
+    ```
+
+
+- `gzip`
+
+    `gzip`是在`Linux`系统中经常使用的一个对文件进行压缩和解压缩的命令，既方便又好用。
+    `gzip`不仅可以用来压缩大的、较少使用的文件以节省磁盘空间，还可以和`tar`命令一起构成`Linux`操作系统中比较流行的压缩文件格式。
+    据统计，`gzip`命令对文本文件有60%～70%的压缩率。
+
+    格式:   
+    ```
+    gzip[参数][文件或者目录]
+    ```
+    
+    功能:   
+    `gzip`是个使用广泛的压缩程序，文件经它压缩过后，其名称后面会多出`.gz`的扩展名。
+    
+    命令参数:   
+    
+    - `-a`或`--ascii`使用`ASCII`文字模式。
+    - `-c`或`--stdout`或`--to-stdout`:把压缩后的文件输出到标准输出设备，不去更动原始文件。
+    - `-d`或`--decompress`或`----uncompress`:解开压缩文件。
+    - `-f`或`--force`:强行压缩文件。不理会文件名称或硬连接是否存在以及该文件是否为符号连接。
+    - `-N`或`--name`:压缩文件时，保存原来的文件名称及时间戳记。
+    - `-r`或`--recursive`:递归处理，将指定目录下的所有文件及子目录一并处理。
+    
+    把目录下的每个文件压缩成`.gz`文件:   
+    
+    ```
+    gzip *
+    ```
+    
+    把例1中每个压缩的文件解压，并列出详细的信息:   
+    ```
+    gzip -dv *
+    ```
+
+
+文件查找
+---
+
+- `whereis`      
+
+    `whereis`命令只能用于程序名的搜索，而且只搜索二进制文件(参数`-b`)、`man`说明文件(参数`-m`)和源代码文件(参数`-s`)。
+    如果省略参数，则返回所有信息。和`find`相比，`whereis`查找的速度非常快，这是因为`linux`系统会将系统内的所有文件都记录在一个数据库文件中，
+    当使用`whereis`和下面即将介绍的locate时，会从数据库中查找数据，而不是像find命令那样，通 过遍历硬盘来查找，效率自然会很高。
+
+    格式:    
+    ```
+    whereis [-bmsu] [BMS 目录名 -f ] 文件名
+    ```
+    
+    将和xx文件相关的文件都查找出来:    
+    ```
+    whereis python
+    ```
+
+
+- `find`
+
+    `Linux`下`find`命令提供了相当多的查找条件，功能很强大。
+
+    格式:    
+    ```
+    find pathname -options [-print -exec -ok ...]
+    ```
+    
+    功能:    
+    
+    用于在文件树种查找文件，并作出相应的处理
+    
+    命令参数:   
+    
+    - `pathname`:`find`命令所查找的目录路径。例如用.来表示当前目录，用/来表示系统根目录。
+    
+    命令选项:    
+    
+    - `-name`按照文件名查找文件。
+    - `-perm`按照文件权限来查找文件。。
+    - `-mtime`:`-n +n`按照文件的更改时间来查找文件，`- n`表示文件更改时间距现在`n`天以内，+ n表示文件更改时间距现在n天以前
+    - `-type`:查找某一类型的文件，诸如：
+    
+        - `b` - 块设备文件。
+        - `d` - 目录。
+        - `c` - 字符设备文件。
+        - `p` - 管道文件。
+        - `l` - 符号链接文件。
+        - `f` - 普通文件。
+    
+    根据关键字查找:     
+    ```
+    find . -name "*.log"
+    ```
+
+
+#### 使用`-name`选项
+
+文件名选项是`find`命令最常用的选项，要么单独使用该选项，要么和其他选项一起使用。 
+可以使用某种文件名模式来匹配文件，记住要用引号将文件名模式引起来。不管当前路径是什么，
+如果想要在自己的根目录$HOME中查找文件名符合`*.log`的文件，使用~作为`pathname`参数，波浪号`~`代表了当前用户的`$HOME`目录。
+```
+find ~ -name "*.log" -print
+```
+想要在当前目录及子目录中查找所有的‘ *.log‘文件，可以用:     
+```
+find . -name "*.log" -print
+```
+想要的当前目录及子目录中查找文件名以一个大写字母开头的文件，可以用:    
+```
+find . -name "[A-Z]*" -print
+```
+想要在/etc目录中查找文件名以host开头的文件，可以用:     
+```
+find /etc -name "host*" -print
+```
+想要查找`$HOME`目录中的文件，可以用:   
+```
+find ~ -name "*" -print 或find . -print
+```
+
+权限设置
+--- 
+
+
+- `chmod`   
+
+命令格式:    
+```
+chmod [-cfvR] [—help] [—version] mode file
+```
+
+命令功能:    
+用于改变文件或目录的访问权限，用它控制文件或目录的访问权限。
+
+必要参数:    
+
+- `-c`:当发生改变时，报告处理信息
+- `-f`:错误信息不输出
+- `-R`:处理指定目录以及其子目录下的所有文件
+
+权限代号:    
+
+- `r`:读权限，用数字4表示
+- `w`:写权限，用数字2表示
+- `x`:执行权限，用数字1表示
+- `-`:删除权限，用数字0表示
+- `s`:特殊权限
+- 
+
+文字设定法:
+```
+chmod ［who］ ［+ | - | =］ ［mode］ 文件名
+```
+
+我们必须首先了解用数字表示的属性的含义：0表示没有权限，1表示可执行权限，2表示可写权限，4表示可读权限，然后将其相加。所以数字属性的格式应为3个从0到7的八进制数，其顺序是(u)(g)(o)。
+例如，如果想让某个文件的属主有“读/写”二种权限，需要把4(可读)+2(可写)＝6(读/写)。
+数字设定法的一般形式为:   
+`chmod ［mode］ 文件名`
+
+数字与字符对应关系如下:   
+
+`r=4，w=2，x=1`      
+- 若要`rwx`属性则4+2+1=7
+- 若要`rw-`属性则4+2=6；
+- 若要`r-x`属性则4+1=7。
+
+
+如:   
+```
+chmod 751 file
+```
+如果是当前root用户执行，前面需要加 sudo chmod 751 file
+
+
+性能监控和优化命令
+---
+
+- `top`
+
+    `top`命令是`Linux`下常用的性能分析工具，能够实时显示系统中各个进程的资源占用状况，类似于`Windows`的任务管理器。
+
+格式:    
+ ```
+top [参数]
+ ```
+
+- `ifconfig`
+
+许多`windows`非常熟悉`ipconfig`命令行工具，它被用来获取网络接口配置信息并对此进行修改。`Linux`系统拥有一个类似的工具，
+也就是`ifconfig`(`interfaces config`)。通常需要以`root`身份登录或使用`sudo`以便在`Linux`机器上使用`ifconfig`工具。
+
+
+格式:    
+```
+ifconfig [网络设备] [参数] 
+```
+
+- `ping`
+
+`linux`下的`ping`命令和`windows`下的`ping`执行稍有区别,`linux`下`ping`不会自动终止,需要按`ctrl+c`终止或者用参数`-c`指定要求完成的回应次数。
+
+
+    
+- 清除命令行内容          
+    `clear`
+    
+- 显示当前日期          
+    `date`
+    
+- 关机                       
+    `sudo shutdown -h now`// -h 是关闭电源 now立即关机            
+    `sudo shutdown -r now`//重启          
+    `sudo shutdown -h -time 60`// 表示60分钟后关机，注意单位是分钟      
+    
+
+
+- file命令是一个方便的小工具，能够探测文件的内部并判断文件类型：
+$ file .bashrc
+.bashrc: ASCII text
+
+
+- pkill命令可以使用程序名代替PID来终止进程，这就方便多了。除此之外，pkill命令也允许使用通配符，当系统出问题时，这是一个非常有用的工具：
+# pkill http*
+#
+该命令将“杀死”所有名称以http起始的进程，比如Apahce Web Server的httpd服务。
+警告　以root身份使用pkill命令时要格外小心。命令中的通配符很容易意外地将系统的重要进程终止。这可能会导致文件系统损坏。
+    
+
+### Shell脚本
+
+Shell的作用就是解释执行用户的命令，用户输入一条命令，Shell就解释执行一条，这种方式称为交互式，Shell还有一种执行命令的方式称为批处理，用户事先写一个Shell脚本，其中有很多条命令，让Shell一次把这些命令执行完，而不是一条一条的敲命令。
+Shell脚本和编程语言很类似，也有变量和流程控制语句，但Shell脚本是解释执行的，不需要编译，Shell程序从脚本中一行一行读取并执行这些命令，相当于一个用户把脚本中的命令一行一行敲到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关键字可以省略。
+
+###### 命令代换
+
+```shell
+DATE=`date`
+echo $DATE
+```
+由“`”反引号括起来的也是一条命令，Shell先执行该命令，然后将输出结果立刻代换到当前命令行中，也可以用$()表示: 
+```shell
+DATE = $(date)
+```
+
+
+####### 输入输出
+echo: 显示文本行或变量，或者把字符串输入到文件
+
+###### tee
+tee 命令把结果输出到标准输出，另一个副本输出到相应文件中。
+
+
+
+
+
+
+        
+----
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+    
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"
new file mode 100644
index 00000000..c656ea7f
--- /dev/null
+++ "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"
@@ -0,0 +1,87 @@
+强引用、软引用、弱引用、虚引用
+===
+
+在JDK1.2以前的版本中，当一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及状态，程序才能使用它。这就像在日常生活中，从商店购买了某样物品后，如果有用，就一直保留它，否则就把它扔到垃圾箱，由清洁工人收走。一般说来，如果物品已经被扔到垃圾箱，想再把它捡回来使用就不可能了。      
+但有时候情况并不这么简单，你可能会遇到类似鸡肋一样的物品，食之无味，弃之可惜。这种物品现在已经无用了，保留它会占空间，但是立刻扔掉它也不划算，因为也许将来还会派用场。对于这样的可有可无的物品，一种折衷的处理办法是：如果家里空间足够，就先把它保留在家里，如果家里空间不够，即使把家里所有的垃圾清除，还是无法容纳那些必不可少的生活用品，那么再扔掉这些可有可无的物品。     
+从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。
+
+***这四种级别由高到低依次为：强引用 > 软引用 > 弱引用 > 虚引用。***
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/reference_list.jpg)
+
+在java.lang.ref包中提供了三个类：SoftReference类、WeakReference类和PhantomReference类，它们分别代表软引用、弱引用和虚引用。ReferenceQueue类表示引用队列，它可以和这三种引用类联合使用，以便跟踪Java虚拟机回收所引用的对 象的活动。
+
+
+
+- 强引用(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)上班看片,那开除是肯定了(被虚拟机回收)。
+    
+    在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了***只具***有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用最常见的用途是实现规范映射(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)   
+  
+    "虚引用"顾名思义，就是形同虚设，也成为幽灵引用或幻影引用，它是最弱的一种引用关系。就只是一个标识，对象的生命周期不受期影响，这货估计就是个临时工把，遇到事情的时候想到了你，没有事情的时候，秒秒钟拿出去顶锅，开除。
+    
+    一个对象是否有虚引用的存在完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一的用处：能在对象被GC时收到系统通知，主要用于跟踪对象何时被回收，比如防止资源泄漏等。 
+    
+    虚引用必须和引用队列 (ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。 虚引用是每次垃圾回收的时候都会被回收，通过虚引用的get方法永远获取到的数据为null。
+
+![](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  
+- Good Luck! 
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"
new file mode 100644
index 00000000..fa29a7b1
--- /dev/null
+++ "b/JavaKnowledge/\346\225\260\346\215\256\345\212\240\345\257\206\345\217\212\350\247\243\345\257\206.md"
@@ -0,0 +1,65 @@
+数据加密及解密
+===
+
+加密`incode`：对明文(`plaintext`可读懂的信息)进行翻译，使用不同的算法对明文以代码形式(密码)实施加密转换成密文(`ciphertext`)。
+该过程的逆过程称为解密(`descode`)，即将该编码信息转化为明文的过程。
+
+对称加密(`Symmetric Cryptography`)
+---
+
+对称加密是最快速、最简单的一种加密方式，加密(`encryption`与解密(`decryption`)用的是同样的密钥(`secret key`),
+这种方法在密码学中叫做对称加密算法。
+对称加密有很多种算法，由于它效率很高，所以被广泛使用在很多加密协议的核心当中。
+对称加密通常使用的是相对较小的密钥，一般小于256`bit`。因为密钥越大，加密越强，但加密与解密的过程越慢。
+如果你只用1`bit`来做这个密钥，那黑客们可以先试着用0来解密，不行的话就再用1解；
+但如果你的密钥有1`MB`大，黑客们可能永远也无法破解，但加密和解密的过程要花费很长的时间。
+密钥的大小既要照顾到安全性，也要照顾到效率，是一个`trade-off`。
+
+
+
+对称加密算法介绍:  
+
+- DES
+
+    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比特中的任意一个（如果数据块及密钥长度不足时，会补齐）
+
+
+
+非对称加密(`Asymmetric Cryptography`)
+---
+
+1976年，美国学者`Dime`和`Henman`为解决信息公开传送和密钥管理问题，提出一种新的密钥交换协议，允许在不安全的媒体上的通讯双方交换信息，
+安全地达成一致的密钥，这就是“公开密钥系统”。相对于“对称加密算法”这种方法也叫做“非对称加密算法”。
+非对称加密为数据的加密与解密提供了一个非常安全的方法，它使用了一对密钥，公钥(`public key`)和私钥(`private key`)。
+私钥只能由一方安全保管，不能外泄，而公钥则可以发给任何请求它的人。非对称加密使用这对密钥中的一个进行加密，而解密则需要另一个密钥。
+比如，你向银行请求公钥，银行将公钥发给你，你使用公钥对消息加密，那么只有私钥的持有人--银行才能对你的消息解密。
+与对称加密不同的是，银行不需要将私钥通过网络发送出去，因此安全性大大提高。
+目前最常用的非对称加密算法是`RSA`算法，是`Rivest`, `Shamir`和`Adleman`于1978年发明。
+
+虽然非对称加密很安全，但是和对称加密比起来，它非常的慢，所以我们还是要用对称加密来传送消息，
+但对称加密所使用的密钥我们可以通过非对称加密的方式发送出去。
+
+
+总结
+---
+
+- 对称加密加密与解密使用的是同样的密钥，所以速度快，但由于需要将密钥在网络传输，所以安全性不高。
+- 非对称加密使用了一对密钥，公钥与私钥，所以安全性高，但加密与解密速度慢。
+- 解决的办法是将对称加密的密钥使用非对称加密的公钥进行加密，然后发送出去，接收方使用私钥进行解密得到对称加密的密钥，
+然后双方可以使用对称加密来进行沟通。
+		
+----
+- 邮箱 ：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\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..b5d71dba
--- /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,172 @@
+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]
+
+
+
+提示：
+
+只会存在一个有效答案
+ 
+
+进阶：你可以想出一个时间复杂度小于 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..03581f19
--- /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/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" "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"
new file mode 100644
index 00000000..30e2a723
--- /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/\345\205\253\347\247\215\346\216\222\345\272\217\347\256\227\346\263\225.md"
@@ -0,0 +1,585 @@
+八种排序算法
+===
+
+
+直接插入排序(Straight Insertion Sorting)
+---
+
+基本思想:在要排序的一组数中，假设前面`(n-1)[n>=2]`个数已经是排好顺序的，现在要把第`n`个数插到前面的有序数中，使得这`n`个数也是排好顺序的。如此反复循环，直到全部排好顺序。        
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/straight_insertion_sorting.png?raw=true)       
+
+总体分析:          
+
+- 用第二个数和第一个数比较大小，大的放到右边。      
+- 用第三个数分别和第二个数还有第一个数比较，并把大的放到右边。      
+- 用第四个数分别和第一个第三个第二个第一个数比较，并把大的放到右边。     
+- ...
+    
+
+所以这里肯定要用到嵌套`for`循环。 
+
+```java
+    public void insertSort(int[] arr) {
+	int len = arr.length;
+	//要插入的数
+	int insertNum;
+	//因为第一次不用，所以从1开始
+	for (int i = 1; i < len; i++) {
+		insertNum = arr[i];
+		//序列元素个数
+		int j = i - 1;
+		//从后往前循环，将大于insertNum的数向后移动
+		while (j > 0 && arr[j] > insertNum) {
+			//元素向后移动
+			arr[j + 1] = arr[j];
+			j--;
+		}
+		//找到位置，插入当前元素
+		arr[j + 1] = insertNum;
+	}
+}
+```
+
+希尔排序
+---
+
+针对直接插入排序的下效率问题，有人对次进行了改进与升级，这就是现在的希尔排序。希尔排序，也称递减增量排序算法，
+是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。        
+希尔排序是`1959`年由`D.L.Shell`提出来的，相对直接插入排序有较大的改进。希尔排序的实质就是分组插入排序，该方法又称缩小增量排序。
+
+基本思想：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，
+然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。
+因为直接插入排序在元素基本有序的情况下(接近最好情况),效率是很高的.
+因此希尔排序在时间效率上比前两种方法有较大提高。步长的选择是希尔排序的重要部分。
+只要最终步长为1任何步长序列都可以工作。
+
+
+希尔排序是基于插入排序的以下两点性质而提出改进方法的:  
+
+- 插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率
+- 但插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位    
+
+对于直接插入排序问题，数据量巨大时。
+将数的个数设为n，取奇数k=n/2，将下标差值为k的数分为一组，构成有序序列。
+再取k=k/2 ，将下标差值为k的书分为一组，构成有序序列。
+重复第二步，直到k=1执行简单插入排序。 
+
+
+算法最开始以一定的步长进行排序,然后会继续以一定步长进行排序，最终算法以步长为1进行排序。
+当步长为1时，算法变为插入排序，这就保证了数据一定会被排序。
+`Donald Shell`最初建议步长选择为\frac{n}{2}并且对步长取半直到步长达到 1。
+虽然这样取可以比\mathcal{O}(n^2)类的算法（插入排序）更好，但这样仍然有减少平均时间和最差时间的余地。
+
+```
+希尔排序示例:n=10的一个数组 58 27 32 93 65 87 58 46 9 65，步长为n/2。
+
+第一次排序 步长为 10/2 = 5
+
+   58  27  32  93  65  87  58  46  9  65 
+   1A                  1B
+       2A                  2B
+           3A                  3B
+                4A                 4B
+                    5A                5B
+
+
+首先将待排序元素序列分组，以5为步长，(1A,1B),(2A,2B),(3A,3B)等为分组标记，大写字母表示是该组的第几个元素,
+数字相同的表示在同一组，这样就分成5组，即(58,87),(27,58),(32,46),(93,9),(65,65)，
+然后分别对各分组进行直接插入排序，排序后5组为(58,87),(27,58),(32,46),(9,93),(65,65)，
+分组排序只是变得各个分组内的下表，下同。
+
+第二次排序 步长为 5/2 = 2
+
+58  27  32  9  65  87  58  46  93  65
+
+1A      1B      1C      1D      1E
+
+    2A      2B      2C      2D        2E
+
+第三次排序 步长为 2/2 = 1
+
+32  9  58  27  58  46  65  65  93  87
+
+1A  1B  1C  1D  1E  1F  1G  1H  1I  1J
+
+第四次排序 步长为 1/2 = 0 得到有序元素序列
+
+9  27  32  46  58  58  65  65  87  93
+
+```
+
+    
+```java
+    public void shellSort(int[] arr) {
+    int len = arr.length;
+    while (len != 0) {
+        len = len / 2;
+        //分组
+        for (int i = 0; i < len; i++) {
+            //元素从第二个开始
+            for (int j = i + len; j < arr.length; j += len) {
+                //k为有序序列最后一位的位数
+                int k = j - len;
+                //要插入的元素
+                int temp = arr[j];
+                //从后往前遍历
+                while (k >= 0 && temp < arr[k]) {
+                    arr[k + len] = arr[k];
+                    //向后移动len位
+                    k -= len;
+                }
+                arr[k + len] = temp;
+            }
+        }
+    }
+}
+```
+
+
+简单选择排序
+---
+
+基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
+然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。     
+
+思路:       
+
+- 第一次用第一个数字去和后面的每个数字比较，将小的放到第一个位置，这样完成这一轮之后，第一个数就是最小的数。
+- 第二次用第二个数字去和后面的每个数字比较，将晓得放到第二个位置，这样完成这一轮之后，第二个数就是最第二小的数。 
+- ...
+
+
+```java
+public void selectSort(int[] arr) {
+        int len = arr.length;
+        for (int i = 0; i < len; i++) {
+            int value = arr[i];
+            int position = i;
+            //找到最小的值和位置
+            for (int j = i + 1; j < len; j++) {
+                if (arr[j] < value) {
+                    value = arr[j];
+                    position = j;
+                }
+            }
+            //进行交换
+            arr[position] = arr[i];
+            arr[i] = value;
+        }
+    }
+```
+
+
+堆排序
+---
+
+对简单选择排序的优化。
+基本思想:堆排序是一种树形选择排序，是对直接选择排序的有效改进。
+
+堆`(heap)`，这里所说的堆是数据结构中的堆，而不是内存模型中的堆。
+
+堆数据结构是一种特殊的二叉树，在这棵树中，所有父节点都满足大于等于其子节点的堆叫大根堆，所有父节点都满足小于等于其子节点的堆叫小根堆。堆虽然是一颗树，但是通常存放在一个数组中，父节点和孩子节点的父子关系通过数组下标来确定。如下图的小根堆及存储它的数组： 
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/heap_1.png?raw=true)    
+
+堆的介绍:   
+
+- 堆是完全二叉树
+- 常常用数组实现
+- 每一个节点的关键字都大于（等于）这个节点的子节点的关键字
+
+由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。
+初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。
+然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。
+从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
+
+
+步骤:   
+
+- 将序列构建成大顶堆。
+- 将根节点与最后一个节点交换，然后断开最后一个节点。
+- 重复第一、二步，直到所有节点断开。
+
+```java
+public void heapSort(int[] arr) {
+        int len = arr.length;
+        //循环建堆
+        for (int i = 0; i < len - 1; i++) {
+            //建堆
+            buildMaxHeap(arr, len - 1 - i);
+            //交换堆顶和最后一个元素
+            swap(arr, 0, len - 1 - i);
+        }
+    }
+
+    //交换方法
+    private void swap(int[] data, int i, int j) {
+        int tmp = data[i];
+        data[i] = data[j];
+        data[j] = tmp;
+    }
+
+    //对data数组从0到lastIndex建大顶堆
+    private void buildMaxHeap(int[] data, int lastIndex) {
+        //从lastIndex处节点（最后一个节点）的父节点开始
+        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
+            //k保存正在判断的节点
+            int k = i;
+            //如果当前k节点的子节点存在
+            while (k * 2 + 1 <= lastIndex) {
+                //k节点的左子节点的索引
+                int biggerIndex = 2 * k + 1;
+                //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
+                if (biggerIndex < lastIndex) {
+                    //若果右子节点的值较大
+                    if (data[biggerIndex] < data[biggerIndex + 1]) {
+                        //biggerIndex总是记录较大子节点的索引
+                        biggerIndex++;
+                    }
+                }
+                //如果k节点的值小于其较大的子节点的值
+                if (data[k] < data[biggerIndex]) {
+                    //交换他们
+                    swap(data, k, biggerIndex);
+                    //将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
+                    k = biggerIndex;
+                } else {
+                    break;
+                }
+            }
+        }
+    }
+
+```
+
+
+冒泡排序    
+---
+
+步骤:     
+
+- 将序列中所有元素两两比较，将最大的放在最后面。
+- 将剩余序列中所有元素两两比较，将最大的放在最后面。
+- 重复第二步，直到只剩下一个数。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/bublle_sort.png?raw=true)       
+
+
+```java
+public void bubbleSort(int[] arr) {
+        int len = arr.length;
+        for (int i = 0; i < len; i++) {
+            for (int j = 0; j < len - i - 1; j++) {
+                if (arr[j] > arr[j + 1]) {
+                    int temp = arr[j];
+                    arr[j] = arr[j + 1];
+                    arr[j + 1] = temp;
+                }
+            }
+        }
+    }
+```
+
+
+快速排序
+---
+
+基本思想:找出一个元素（理论上可以随便找一个）作为基准`(pivot)`,然后对数组进行分区操作,
+使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。
+递归快速排序，将其他`n-1`个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正 确位置，排序完成。
+所以快速排序算法的核心算法是分区操作，即如何调整基准的位置以及调整返回基准的最终位置以便分治递归。
+
+### 选择基准元
+
+1. 固定基准元      
+    如果输入序列是随机的，处理时间是可以接受的。如果数组已经有序时，此时的分割就是一个非常不好的分割。因为每次划分只能使待排序序列减一，此时为最坏情况，快速排序沦为冒泡排序，时间复杂度为Θ(n^2)。而且，输入的数据是有序或部分有序的情况是相当常见的。因此，使用第一个元素作为基准元是非常糟糕的，应该立即放弃这种想法。 
+2. 随机基准元      
+    这是一种相对安全的策略。由于基准元的位置是随机的，那么产生的分割也不会总是会出现劣质的分割。在整个数组数字全相等时，仍然是最坏情况，时间复杂度是O(n^2）。实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2^n）。所以随机化快速排序可以对于绝大多数输入数据达到O（n×log(n))的期望时间复杂度。
+3. 三数取中     
+    最佳的划分是将待排序的序列分成等长的子序列，最佳的状态我们可以使用序列的中间的值，也就是第N/2个数。可是，这很难算出来，并且会明显减慢快速排序的速度。这样的中值的估计可以通过随机选取三个元素并用它们的中值作为基准元而得到。事实上，随机性并没有多大的帮助，因此一般的做法是使用左端、右端和中心位置上的三个元素的中值作为基准元。
+
+
+算法原理:单单看以上解释还是有些模糊，可以通过实例来理解它。
+下面通过一组数据来进行排序过程的解:   
+
+原数组：{3，7，2，9，1，4，6，8，10，5}
+
+花了点时间撸了下面这张快速排序示意图：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/quick_sort.png?raw=true)       
+
+
+### partition算法
+
+`partition`算法是快速排序的核心，在学习快排之前，可以先学习一下这个算法。下面先贴代码:   
+
+```java
+public int partition(int[] num, int left, int right) {
+    if (num == null || num.length <= 0 || left < 0 || right >= num.length) {
+        return 0;
+    }
+    //获取数组中间元素的下标
+    int prio = num[left + (right - left) / 2];
+    //从两端交替向中间扫描
+    while (left <= right) {
+        while (num[left] < prio)
+            left++;
+        while (num[right] > prio)
+            right--;
+        if (left <= right) {
+            //最终将基准数归位
+            swap(num, left, right);
+            left++;
+            right--;
+        }
+    }
+    return left;
+}
+```
+
+这个方法的思路是先找一个枢纽元（这个方法实现里面找的是第一个元素，具体其实大有文章不过这里先简化描述），
+再从数组的两边（具体从哪里到哪里由传进来额参数决定）生成两个指针`left`和`right`，
+每次发现左边的元素大于枢纽元则i停下来，右边的元素小于枢纽元j就停下来，并且交换这个两个数的位置。
+直到两个指针`left`，`right`相遇。再把枢纽元插入`left`的位置，也就是它应该在的位置。
+
+这么做最后的结果是让数组的`[left，right]`部分呈现出2部分，枢纽元最终位置以左都是小于等于枢纽元的，以右都是大于等于枢纽元的。而枢纽元则被插入到了一个绝对正确的位置。
+
+```java
+@Override
+protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_main);
+
+    int[] data = new int[]{26, 53, 67, 48, 57, 13, 48, 32, 60, 50};
+    quickSort(data,0,data.length-1);
+}
+
+void quickSort(int arr[], int left, int right) {
+    if (left < right) {
+        //算出枢轴值
+        int index = partition(arr, left, right);
+        //对低子表递归排序
+        quickSort(arr, left, index - 1);
+        //对高子表递归排序
+        quickSort(arr, index + 1, right);
+    }
+
+    for (int i = 0; i < arr.length; i++) {
+        Log.e("@@@", "" + arr[i]);
+    }
+}
+
+public int partition(int[] num, int left, int right) {
+    if (num == null || num.length <= 0 || left < 0 || right >= num.length) {
+        return 0;
+    }
+    int prio = num[left + (right - left) / 2];   //获取数组中间元素的下标
+    while (left <= right) {                 //从两端交替向中间扫描
+        while (num[left] < prio)
+            left++;
+        while (num[right] > prio)
+            right--;
+        if (left <= right) {
+            swap(num, left, right);        //最终将基准数归位
+            left++;
+            right--;
+        }
+    }
+    return left;
+}
+
+
+public void swap(int[] num, int left, int right) {
+    int temp = num[left];
+    num[left] = num[right];
+    num[right] = temp;
+}
+```
+
+归并排序
+---
+
+速度仅次于快速排序，内存少的时候使用，可以进行并行计算的时候使用。
+归并（`Merge`）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，
+每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/merge_sort.png?raw=true)      
+
+
+```java
+{
+    int[] data = new int[]{26, 53, 67, 48, 57, 13, 48, 32, 60, 50};
+    data = mergeSort(data, 0, data.length - 1);
+    for (int i = 0; i < data.length; i++) {
+        Log.e("@@@", "" + data[i]);
+    }
+}
+
+public static int[] mergeSort(int[] a, int low, int high) {
+    int mid = (low + high) / 2;
+    if (low < high) {
+        mergeSort(a, low, mid);
+        mergeSort(a, mid + 1, high);
+        //左右归并
+        merge(a, low, mid, high);
+    }
+    return a;
+}
+
+public static void merge(int[] a, int low, int mid, int high) {
+    int[] temp = new int[high - low + 1];
+    int i = low;
+    int j = mid + 1;
+    int k = 0;
+    // 把较小的数先移到新数组中
+    while (i <= mid && j <= high) {
+        if (a[i] < a[j]) {
+            temp[k++] = a[i++];
+        } else {
+            temp[k++] = a[j++];
+        }
+    }
+    // 把左边剩余的数移入数组
+    while (i <= mid) {
+        temp[k++] = a[i++];
+    }
+    // 把右边边剩余的数移入数组
+    while (j <= high) {
+        temp[k++] = a[j++];
+    }
+    // 把新数组中的数覆盖nums数组
+    for (int x = 0; x < temp.length; x++) {
+        a[x + low] = temp[x];
+    }
+}
+```
+
+基数排序
+---
+
+基数排序`(radix sort)`又称桶排序`(bucket sort)`，相对于常见的比较排序，基数排序是一种分配式排序，
+即通过将所有数字分配到应在的位置最后再覆盖到原数组完成排序的过程
+
+
+用于大量数，很长的数进行排序时。
+
+基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，
+依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。      
+
+我们回想一下我们小时候是怎么学习比较数字大小的？我们是先比位数，如果一个位数比另一个位数多，
+那这个数肯定更大。如果位数同样多，就按位数递减依次往下进行比较，哪个数在这一位上更大那就停止比较，
+得出这个在这个位上数更大的数字整体更大的结论。当然我们也可以从最小的位开始比较，
+这其实就对应了基数排序里的`MSD(most significant digital)和LSD(least significant digital)`两种排序方式。
+
+想清楚了这一点之后，我们就要考虑如何存储每一位排序结果的问题了，首先既然作为分配式排序，联想计数排序，
+每一位排序时存储该次排序结果的数据结构应该至少是一个长度为10的数组（对应十进制该位0-9的数字）。
+同时可能存在以下情况：原数组中所有元素在该位上的数字都相同，那一维数组就没法满足我们的需要了，
+我们需要一个`10*n`(`n`为数组长度)的二维数组来存储每次位排序结果。
+
+熟悉计数排序结果的读者可能会好奇：为什么不能像计数排序一样，在每个位置只存储出现该数字的次数，
+而不存储具体的值，这样不就可以用一维数组了？这个我们不妨先思考一下，在对基数排序分析完之后再来看这个问题。
+现在我们可以存储每次位排序的结果了，为了在下一位排序前用到这一位排序的结果，
+我们要将桶里排序的结果还原到原数组中去，然后继续对更改后的原数组执行前一步的位排序操作，如此循环，
+最后的结果就是数组内元素先按最高位排序，最高位相同的依次按下一位排序，依次递推。得到排序的结果数组。
+
+
+初始化：构造一个`10*n`的二维数组，一个长度为n的数组用于存储每次位排序时每个桶子里有多少个元素。
+循环操作：从低位开始（我们采用`LSD`的方式），将所有元素对应该位的数字存到相应的桶子里去（对应二维数组的那一列）。
+然后将所有桶子里的元素按照桶子标号从小到大取出，对于同一个桶子里的元素，先放进去的先取出，
+后放进去的后取出（保证排序稳定性）。这样原数组就按该位排序完毕了，继续下一位操作，直到最高位排序完成。
+
+下面给出一个实例帮助理解:   
+我们现有一个数组：73, 22, 93, 43, 55, 14, 28, 65, 39, 81
+下面是排序过程（二维数组里每一列对应一个桶，因为桶空间没用完，因此没有将二维数组画全）:   
+
+- 按个位排序
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/radix_sort_1.png?raw=true)      
+
+按第一位排序后数组结果:      
+81,22,73,93,43,14,55,65,28,39
+可以看到数组已经按个位排序了。
+
+- 根据个位排序结果按百位排序
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/radix_sort_2.png?raw=true)      
+
+
+取出排序结果:   
+14,22,28,39,43,55,65,73,81,93
+
+可以看到在个位排序的基础上，百位也排序完成（对于百位相同的数子，如22,28，因为个位已经排序，
+而取出时也保持了排序的稳定性，所以这两个数的位置前后是根据他们个位排序结果决定的）。
+因为原数组元素最高只有百位，原数组也完成了排序过程。
+
+我们现在来看看之前遗留的两个问题：为什么不能用一维数组，
+一定要用二维数组这样的类似桶的结构来存储中间位排序结果？其实之所以要写这个问题，
+是因为我觉得这个问题是理解基数排序的关键。基数排序本身原理很简单，
+但是实现中有两个问题需要考虑：1.怎么保留前一位的排序结果，这个问题用之前提到的排序稳定性可以解决。
+2.怎么关联该位排序结果和原数组元素，二维数组正是为了解决这个问题使用的办法。在计数排序里，
+虽然保留了所有相等的元素的相对位置，但是这些相等的元素在计数排序里实际是没有差别的，
+因此我们可以只保存数组里有多少个这样的元素即可。而基数排序里不同，有些元素虽然在某一位上相同，
+但是他们其他位上很可能不同，如果只保存该位上有多少个5或者多少个6，那关于元素其他位的信息就都丢弃了，
+这样也就没法对这些元素更高位进行排序了。
+
+```java
+private static void radixSort(int[] array,int d) {
+    int n=1;//代表位数对应的数：1,10,100...
+    int k=0;//保存每一位排序后的结果用于下一位的排序输入
+    int length=array.length;
+    int[][] bucket=new int[10][length];//排序桶用于保存每次排序后的结果，这一位上排序结果相同的数字放在同一个桶里
+    int[] order=new int[length];//用于保存每个桶里有多少个数字
+    while(n<d) {
+        for(int num:array) //将数组array里的每个数字放在相应的桶里 {
+            int digit=(num/n)%10;
+            bucket[digit][order[digit]]=num;
+            order[digit]++;
+        }
+        //将前一个循环生成的桶里的数据覆盖到原数组中用于保存这一位的排序结果
+        for(int i=0;i<length;i++) {
+            //这个桶里有数据，从上到下遍历这个桶并将数据保存到原数组中
+            if(order[i]!=0) {
+                for(int j=0;j<order[i];j++) {
+                    array[k]=bucket[i][j];
+                    k++;
+                }
+            }
+            order[i]=0;//将桶里计数器置0，用于下一次位排序
+        }
+        n*=10;
+        k=0;//将k置0，用于下一轮保存位排序结果
+    }
+}
+public static void main(String[] args) {
+    int[] A=new int[]{73,22, 93, 43, 55, 14, 28, 65, 39, 81};
+    radixSort(A, 100);
+    for(int num:A) {
+        System.out.println(num);
+    }
+}
+```
+
+
+总结:   
+
+- 直接插入排序：一般插入排序，比较是从有序序列的最后一个元素开始，如果比它大则直接插入在其后面，否则一直往前比。如果找到一个和插入元素相等的，那么就插入到这个相等元素的后面。插入排序是稳定的。
+- 希尔排序：希尔排序是按照不同步长对元素进行插入排序，一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，稳定性就会被破坏，所以希尔排序不稳定。
+- 简单选择排序：在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。光说可能有点模糊，来看个小实例：858410，第一遍扫描，第1个元素8会和4交换，那么原序列中2个8的相对前后顺序和原序列不一致了，所以选择排序不稳定。
+-堆排序：堆排序的过程是从第`n/2`开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为`n/2-1`, `n/2-2`, ...这些父节点选择元素时，有可能第`n/2`个父节点交换把后面一个元素交换过去了，而第`n/2-1`个父节点把后面一个相同的元素没有交换，所以堆排序并不稳定。
+- 冒泡排序：由前面的内容可知，冒泡排序是相邻的两个元素比较，交换也发生在这两个元素之间，如果两个元素相等，不用交换。所以冒泡排序稳定。
+- 快速排序：在中枢元素和序列中一个元素交换的时候，很有可能把前面的元素的稳定性打乱。还是看一个小实例：6 4 4 5 4 7 8  9，第一趟排序，中枢元素6和第三个4交换就会把元素4的原序列破坏，所以快速排序不稳定。
+- 归并排序：在分解的子列中，有1个或2个元素时，1个元素不会交换，2个元素如果大小相等也不会交换。在序列合并的过程中，如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，所以，归并排序也是稳定的。
+- 基数排序：是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/sort_list_compare.png?raw=true)      
+
+
+		
+---
+- 邮箱 ：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/\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"
new file mode 100644
index 00000000..1a75ec60
--- /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/\346\225\260\346\215\256\347\273\223\346\236\204.md"
@@ -0,0 +1,443 @@
+数据结构
+===
+
+结构，简单的理解就是关系，比如分子结构，就是说组成分子的原子之间的排列方式。严格点说，结构是指各个组成部分相互搭配和排列的方式。在现实世界中，
+不同数据元素之间不是独立的，而是存在特定的关系，我们将这些关系称为结构。那数据结构是什么？
+
+数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。
+
+在计算机中，数据元素并不是孤立、杂乱无序的，而是具有内在联系的数据集合。数据元素之间存在的一种或多种特定关系，也就是数据的组织形式。
+
+按照视点的不同，我们把数据结构分为逻辑结构和物理结构。
+
+数据结构（data structure）是组织和存储数据的方式，涵盖数据内容、数据之间关系和数据操作方法，它具有以下设计目标。
+
+- 空间占用尽量少，以节省计算机内存。
+- 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。
+- 提供简洁的数据表示和逻辑信息，以便算法高效运行。
+- 数据结构设计是一个充满权衡的过程。如果想在某方面取得提升，往往需要在另一方面作出妥协。
+
+下面举两个例子:   
+
+- 链表相较于数组，在数据添加和删除操作上更加便捷，但牺牲了数据访问速度。
+- 图相较于链表，提供了更丰富的逻辑信息，但需要占用更大的内存空间。
+
+
+
+#### 逻辑结构
+
+逻辑结构：是指数据对象中数据元素之间的相互关系。其实这也是我们今后最需要关注的问题。逻辑结构分为以下四种：
+
+- 集合结构
+    集合结构：集合结构中的数据元素除了同属于一个集合外，它们之间没有其他关系。各个数据元素是“平等”的，它们的共同属性是"同属于一个集合"。
+    数据结构中的集合关系就类似于数学中的集合
+- 线性结构
+    线性结构：线性结构中的数据元素之间是一对一的关系
+- 树形结构
+    树形结构：树形结构中的数据元素之间存在一种一对多的层次关系
+- 图形结构
+    图形结构：图形结构的数据元素是多对多的关系            
+
+#### 物理结构
+
+物理结构(也称为存储结构)：是指数据的逻辑结构在计算机中的存储形式。
+
+- 顺序存储结构
+    顺序存储结构：是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的
+    这种存储结构其实很简单，说白了，就是排队占位。大家都按顺序排好，每个人占一小段空间，大家谁也别插谁的队。数组就是这
+    样的顺序存储结构。当你告诉计算机，你要建立一个有9个整型数据的数组时，计算机就在内存中找了片空地，按照一个整型所占位置的大小乘以9，开辟一段
+    连续的空间，于是第一个数组数据就放在第一个位置，第二个数据放在第二个，这样依次摆放。
+- 链式存储结构
+    链式存储结构：是把数据元素存放在任意的存储单元里，这组存储单元可以是连续的，也可以是不连续的。数据元素的存储关系并不能反映其逻辑关系，因此
+    需要用一个指针存放数据元素的地址，这样通过地址就可以找到相关联数据元素的位置
+
+常见的数据结构:    
+
+- 数组`(Array)`
+- 栈`(Stack)`
+- 队列`(Queue)`
+- 链表`(LinkedList)`
+- 树`(Tree)`
+- 哈希表`(Hash)`
+- 堆`(Heap)`
+- 图`(Graph)`
+
+
+## 线性表 
+
+零个或多个数据元素的有限序列。除第一个元素外，每一个元素有且只有一个直接前驱元素，除了最后一个元素外，每一个元素有且只有一个直接后继元素。
+数据元素之间的关系是一对一的关系。
+
+- 序列
+    也就是说元素之间是有顺序的。
+- 有限
+    元素的个数是有限的。
+
+线性表的顺序存储结构，在存、读数据时，不管是哪个位置，时间复杂度都是O(1)；
+而插入或删除时，时间复杂度都是O(n)。
+这就说明，它比较适合元素个数不太变化，而更多是存取数据的应用。当然，它的优缺点还不止这些。
+
+由于线性表的顺序存储结构在插入和删除的时候需要移动大量元素，为了解决这个问题，有了线性表的链式存储结构。
+又分为单链表和多链表。
+
+### 数组`(Array)`
+
+数组是一种大小固定的数据结构，对线性表的所有操作都可以通过数组来实现。数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，
+有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。虽然数组一旦创建之后，它的大小就无法改变了，但是当数组不能再存储
+线性表中的新元素时，我们可以创建一个新的大的数组来替换当前数组。这样就可以使用数组实现动态的数据结构。
+
+```java
+int[] arr = new int[10];
+```
+
+数组是最常用的数据结构了。这里就不说了。
+
+优点:    
+
+- 可以通过下标来访问或者修改元素，比较高效
+
+缺点:    
+
+- 增删慢，插入和删除的花费开销比较大，比如当在第一个位置前插入一个元素，那么首先要把所有的元素往后移动一个位置
+- 大小固定，只能存储单一元素
+
+### 链表
+
+链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
+链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。
+每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，链表比较方便插入和删除操作。
+
+用一组地址任意的存储单元存放线性表中的数据元素。以元素(数据元素的映象)+指针(指示后继元素存储位置) = 结点。
+以“结点的序列”表示线性表,称作线性链表（单链表）。单链表是一种顺序存取的结构，为找第`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.
+
+栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫作栈顶，数据称为压栈，移除数据称为弹栈(就像子弹弹夹装弹和取弹一样)。
+对栈的基本操作有`push`(进栈)和`pop`(出栈)，前者相当于插入，后者相当于删除最后一个元素。栈有时又叫作`LIFO(Last In First Out)`表，
+即后进先出。简单暴力的理解就是吃进去吐出来
+
+优点:   
+
+- 提供了先进后出的存取方式  
+
+缺点:   
+
+- 存取其他项很慢
+
+
+### 链栈
+
+栈的顺序存储结构，我们现在来看看栈的链式存储结构，简称为链栈。
+对于链栈来说，基本不存在栈满的情况，除非内存已经没有可以使用的空间，如果真的发生，那此时的计算机操作系统已经面临死机崩溃的情况，而不是这个链栈是
+否溢出的问题。
+对比一下顺序栈与链栈，它们在时间复杂度上是一样的，均为O(1)。对于空间性能，顺序栈需要事先确定一个固定的长度，可能会存在内存空间浪费的问题，
+但它的优势是存取时定位很方便，而链栈则要求每个元素都有指针域，这同时也增加了一些内存开销，但对于栈的长度无限制。所以它们的区别和线性表中讨论的
+一样，如果栈的使用过程中元素变化不可预料，有时很小，有时非常大，那么最好是用链栈，反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。
+
+
+#### 栈的应用-递归
+
+把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数，称做递归函数。
+
+当然，写递归程序最怕的就是陷入永不结束的无穷递归中，所以，每个递归定义必须至少有一个条件，满足时递归不再进行，即不再引用自身而是返回值退出。
+
+递归（recursion）是一种算法策略，通过函数调用自身来解决问题。它主要包含两个阶段：  
+
+- 递：程序不断深入地调用自身，通常传入更小或更简化的参数，直到达到“终止条件”。
+- 归：触发“终止条件”后，程序从最深层的递归函数开始逐层返回，汇聚每一层的结果。
+
+而从实现的角度看，递归代码主要包含三个要素：   
+
+- 终止条件：用于决定什么时候由“递”转“归”。
+- 递归调用：对应“递”，函数调用自身，通常输入更小或更简化的参数。
+- 返回结果：对应“归”，将当前递归层级的结果返回至上一层。
+
+
+那么我们讲了这么多递归的内容，和栈有什么关系呢？这得从计算机系统的内部说起。前面我们已经看到递归是如何执行它的前行和退回阶段的。
+递归过程退回的顺序是它前行顺序的逆序。在退回过程中，可能要执行某些动作，包括恢复在前行过程中存储起来的某些数据。这种存储某些数据，
+并在后面又以存储的逆序恢复这些数据，以提供之后使用的需求，显然很符合栈这样的数据结构，因此，编译器使用栈实现递归就没什么好惊讶的了。
+简单的说，就是在前行阶段，对于每一层递归，函数的局部变量、参数值以及返回地址都被压入栈中。在退回阶段，位于栈顶的局部变量、参数值和返回地址被弹出，
+用于返回调用层次中执行代码的其余部分，也就是恢复了调用的状态。
+
+
+### 队列`(Queue)`
+
+队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。
+队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。
+
+队列是一种特殊的线性表，特殊之处在于它只允许在表的前端`(front)`进行删除操作，而在表的后端`(rear)`进行插入操作，和栈一样，队列是一种操作受限制
+的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。先进先出，简单暴力的理解就是吃进去拉出来   
+
+
+优点:    
+
+- 提供了先进先出的存取方式   
+
+缺点:    
+
+- 存取其他项很慢   
+
+### 链队列
+队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。
+
+
+### 串
+串（string）是由零个或多个字符组成的有限序列，又名叫字符串。
+
+
+
+### 树`(Tree)`
+
+树（Tree）是n（n≥0）个结点的有限集。n=0时称为空树。在任意一棵非空树中：    
+- 有且仅有一个特定的称为根（Root）的结点；
+- 当n＞1时，其余结点可分为m（m＞0）个互不相交的有限集T1、T2、……、Tm，其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）。
+
+
+树是由`n（n>=1）`个有限节点组成一个具有层次关系的集合。       
+它具有以下特点:每个节点有零个或多个子节点；没有父节点的节点称为根节点；每一个非根节点有且只有一个父节点；除了根节点外，每个子节点可以分为多个不相交的子树。
+
+树中结点的最大层次称为树的深度（Depth）。如果将树中结点的各子树看成从左至右是有次序的，不能互换的，则称该树为有序树，否则称为无序树。
+
+
+#### 二叉树
+
+二叉树`(binary tree)`是一棵树，每一个节点都不能有多于两个的子节点。   
+通常子树被称作“左子树”和“右子树”。二叉树常被用于实现二叉查找树和二叉堆。
+
+![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）是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。
+##### 二叉树遍历方法
+- 前序遍历
+    规则是若二叉树为空，则空操作返回，否则先访问根结点，然后前序遍历左子树，再前序遍历右子树。
+- 中序遍历
+    规则是若树为空，则空操作返回，否则从根结点开始（注意并不是先访问根结点），中序遍历根结点的左子树，然后是访问根结点，最后中序遍历右子树。
+- 后序遍历
+    规则是若树为空，则空操作返回，否则从左到右先叶子后结点的方式遍历访问左右子树，最后是访问根结点。
+- 层序遍历
+    规则是若树为空，则空操作返回，否则从树的第一层，也就是根结点开始访问，从上而下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问。
+
+
+
+#### 满二叉树和完全二叉树
+
+满二叉树:除最后一层无任何子节点外，每一层上的所有结点都有两个子结点。也可以这样理解，除叶子结点外的所有结点均有两个子结点。节点数达到最大值，所有叶子结点必须在同一层上。
+
+完全二叉树:若设二叉树的深度为`h`，除第`h`层外，其它各层`(1～(h-1))`层的结点数都达到最大个数，第h层所有的结点都连续集中在最左边，这就是完全二叉树。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/wanquan_binary_tree.jpg?raw=true)
+
+
+完全二叉树是效率很高的数据结构，堆是一种完全二叉树或者近似完全二叉树，所以效率极高，像十分常用的排序算法、Dijkstra算法、Prim算法等都要用堆才
+能优化，二叉排序树的效率也要借助平衡性来提高，而平衡性基于完全二叉树。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/man_binary_tree.png?raw=true)
+
+
+
+我们知道一颗基本的二叉排序树他们都需要满足一个基本性质：即树中的任何节点的值大于它的左子节点，且小于它的右子节点。
+
+按照这个基本性质使得树的检索效率大大提高。我们知道在生成二叉排序树的过程是非常容易失衡的，最坏的情况就是一边倒（只有右/左子树），
+这样势必会导致二叉树的检索效率大大降低`(O(n))`，所以为了维持二叉排序树的平衡，大牛们提出了各种平衡二叉树的实现算法，在平衡二叉搜索树中，
+其高度一般都良好地维持在`O(log2n)`，大大降低了操作的时间复杂度。如：`AVL`，`SBT`，伸展树，`TREAP` ，红黑树等等。
+
+
+#### 平衡二叉树       
+
+平衡二叉树必须具备如下特性：它是一棵空树或它的左右两个子树的高度差的绝对值不超过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`是树中元素的数目。
+
+对于一棵有效的红黑树而言我们必须增加如下规则，这也是红黑树最重要的5点规则:      
+
+- 每个结点都只能是红色或者黑色中的一种。 
+- 根结点是黑色的。 
+- 每个叶结点（NIL节点，空节点）是黑色的。 
+- 如果一个结点是红的，则它两个子节点都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。 
+- 从任一结点到其每个叶子的所有路径都包含相同数目的黑色结
+
+这些约束强制了红黑树的关键性质: 从根到叶子最长的可能路径不多于最短的可能路径的两倍长。结果是这棵树大致上是平衡的。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/hongheishu.jpg?raw=true)
+
+黑红树节点的`java`表示结构:   
+
+```java
+private static final boolean RED = true;
+private static final boolean BLACK = false;
+private Node root;//二叉查找树的根节点
+
+//结点数据结构
+private class Node{
+    private Key key;//键
+    private Value value;//值
+    private Node left, right;//指向子树的链接:左子树和右子树.
+    private int N;//以该节点为根的子树中的结点总数
+    boolean color;//由其父结点指向它的链接的颜色也就是结点颜色.
+
+    public Node(Key key, Value value, int N, boolean color) {
+        this.key = key;
+        this.value = value;
+        this.N = N;
+        this.color = color;
+    }
+}
+
+/**
+ * 获取整个二叉查找树的大小
+ * @return
+ */
+public int size(){
+    return size(root);
+}
+/**
+ * 获取某一个结点为根结点的二叉查找树的大小
+ * @param x
+ * @return
+ */
+private int size(Node x){
+    if(x == null){
+        return 0;
+    } else {
+        return x.N;
+    }
+}
+private boolean isRed(Node x){
+    if(x == null){
+        return false;
+    }
+    return x.color == RED;
+}
+```
+
+哈希表`(Hash)`
+---
+
+哈希表就是一种以 键-值`(key-indexed)`存储数据的结构，我们只要输入待查找的值即`key`，即可查找到其对应的值。
+
+优点:   
+
+- 如果关键字已知则存取极快
+- 插入、查找、删除的时间级为`O(1)`
+- 数据项占哈希表长的一半，或者三分之二时，哈希表的性能最好。
+
+缺点:    
+
+- 删除慢，如果不知道关键字存取慢，对存储空间使用不充分   
+- 基于数组，数组创建后难于扩展，某些哈希表被基本填满时性能下降的非常严重；
+- 没有一种简单的方法可以以任何一种顺序（如从小到大）遍历整个数据项；
+
+堆`(Heap)`
+---
+
+这里所说的堆是数据结构中的堆，而不是内存模型中的堆。堆通常是一个可以被看做一棵树，它满足下列性质:   
+
+- 堆中任意节点的值总是不大于(不小于)其子节点的值；
+- 堆是完全二叉树
+- 常常用数组实现
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/heap_1.png?raw=true)
+
+二叉堆是完全二元树或者是近似完全二元树，它分为两种：最大堆和最小堆。 
+最大堆：父结点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。
+
+优点:     
+
+- 插入、删除快，对最大数据项存取快  
+
+缺点:    
+
+- 对其他数据项存取慢   
+
+
+图`(Graph)`
+---
+
+图是一种较线性表和树更为复杂的数据结构，在线性表中，数据元素之间仅有线性关系，在树形结构中，数据元素之间有着明显的层次关系，而在图形结构中，
+节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。图的应用相当广泛，特别是近年来的迅速发展，已经渗入到诸如语言学、逻辑学、物理、
+化学、电讯工程、计算机科学以及数学的其他分支中。
+图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G（V,E），其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。
+
+
+
+优点:   
+
+- 对现实世界建模   
+
+缺点:    
+
+- 有些算法慢且复杂
+
+
+
+        
+---
+- 邮箱 ：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/\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..b33352bd
--- /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,333 @@
+算法
+===
+
+
+算法（algorithm）是在有限时间内解决特定问题的一组指令或操作步骤，它具有以下特性:   
+
+- 问题是明确的，包含清晰的输入和输出定义。
+- 具有可行性，能够在有限步骤、时间和内存空间下完成。
+- 各步骤都有确定的含义，在相同的输入和运行条件下，输出始终相同。
+
+
+算法具有五个基本特性：
+- 输入
+    算法具有零个或多个输入
+- 输出
+    算法至少有一个或多个输出
+- 有穷性
+    指算法在执行有限的步骤之后，自动结束而不会出现无限循环，并且每一个步骤在可接受的时间内完成。
+- 确定性
+    算法的每一步骤都具有确定的含义，不会出现二义性
+- 可行性
+    算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成
+
+
+在算法设计中，我们先后追求以下两个层面的目标。
+
+- 找到问题解法：算法需要在规定的输入范围内可靠地求得问题的正确解。
+- 寻求最优解法：同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。
+
+也就是说，在能够解决问题的前提下，算法效率已成为衡量算法优劣的主要评价指标，它包括以下两个维度:    
+
+- 时间效率：算法运行时间的长短。
+- 空间效率：算法占用内存空间的大小。
+
+简而言之，我们的目标是设计“既快又省”的数据结构与算法。而有效地评估算法效率至关重要，因为只有这样，我们才能将各种算法进行对比，进而指导算法设计与优化过程。
+
+
+
+
+
+### 算法时间复杂度
+
+一个算法的时间复杂度（Time Complexity）是指算法运行从开始到结束所需要的时间。这个时间就是该算法中每条语句的执行时间之和，而每条语句的执行时间是该语句执行次数（也称为频度）与执行该语句所需时间的乘积。但是，当算法转换为程序之后，一条语句执行一次所需的时间与机器的性能及编译程序生成目标代码的质量有关，是很难确定的。为此，假设执行每条语句所需的时间均为单位时间。在这一假设下，一个算法所花费的时间就等于算法中所有语句的频度之和。这样就可以脱离机器的硬、软件环境而独立地分析算法所消耗的时间。
+
+在进行算法分析时，语句总的执行次数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(1) : 操作所需的时间是常数(n个元素所需的时间与一个元素所需的时间相同)
+- O(n) : n个元素的时间是一个元素时间乘以n
+- O(n²): n个元素的时间是一个元素时间乘以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)   
+
+
+
+### 算法空间复杂度
+
+我们在写代码时，完全可以用空间来换取时间，比如说，要判断某某年是不是闰年，你可能会花一点心思写了一个算法，而且由于是一个算法，也就意味着，每次给一个年份，都是要通过计算得到是否是闰年的结果。还有另一个办法就是，事先建立一个有2050个元素的数组（年数略比现实多一点），然后把所有的年份按下标的数字对应，如果是闰年，此数组项的值就是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;
+}
+```
+
+
+数据结构与算法高度相关、紧密结合，具体表现在以下三个方面:     
+
+- 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及操作数据的方法。
+- 算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，结合算法才能解决特定问题。
+- 算法通常可以基于不同的数据结构实现，但执行效率可能相差很大，选择合适的数据结构是关键。
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/algorithm_datasturcture.jpg?raw=true)
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Java\345\237\272\347\241\200/\346\255\273\351\224\201.md" "b/JavaKnowledge/\346\255\273\351\224\201.md"
similarity index 100%
rename from "Java\345\237\272\347\241\200/\346\255\273\351\224\201.md"
rename to "JavaKnowledge/\346\255\273\351\224\201.md"
diff --git "a/Java\345\237\272\347\241\200/\347\224\237\344\272\247\350\200\205\346\266\210\350\264\271\350\200\205.md" "b/JavaKnowledge/\347\224\237\344\272\247\350\200\205\346\266\210\350\264\271\350\200\205.md"
similarity index 100%
rename from "Java\345\237\272\347\241\200/\347\224\237\344\272\247\350\200\205\346\266\210\350\264\271\350\200\205.md"
rename to "JavaKnowledge/\347\224\237\344\272\247\350\200\205\346\266\210\350\264\271\350\200\205.md"
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"
new file mode 100644
index 00000000..a638c653
--- /dev/null
+++ "b/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md"
@@ -0,0 +1,261 @@
+线程池的原理
+===
+
+所谓线程池，就是将多个线程放在一个池子里面（所谓池化技术），然后需要线程的时候不是创建一个线程，而是从线程池里面获取一个可用的线程，然后执行我们的任务。线程池的关键在于它为我们管理了多个线程，我们不需要关心如何创建线程，我们只需要关系我们的核心业务，然后需要线程来执行任务的时候从线程池中获取线程。任务执行完之后线程不会被销毁，而是会被重新放到池子里面，等待机会去执行任务。
+
+
+
+- 在什么情况下使用线程池？ 
+    - 单个任务处理的时间比较短 
+    - 将要处理的任务的数量大 
+
+    假设一个服务器完成一项任务所需时间为：`T1`创建线程时间，`T2`在线程中执行任务的时间，`T3`销毁线程时间。如果:`T1 + T3`远大于`T2`，则可以采用线程池，以提高服务器性能。
+
+
+- 一个线程池包括以下四个基本组成部分:      
+
+    - 线程池管理器（`ThreadPool`）:用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务
+    - 工作线程（`PoolWorker`）:线程池中的线程，在没有任务时处于等待状态，可以循环的执行任务
+    - 任务接口（`Task`）:每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等
+    - 任务队列（`TaskQueue`）:用于存放没有处理的任务。提供一种缓冲机制。
+
+- 使用线程池的好处:        
+    - 降低资源消耗。通过重复利用减少在创建和销毁线程上所花的时间以及系统资源的开销 
+    - 提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，
+    还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 
+    - 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
+    
+- 工作流程            
+    线程池的任务就在于负责这些线程的创建，销毁和任务处理参数传递、唤醒和等待。
+    - 创建若干线程，置入线程池
+    - 任务达到时，从线程池取空闲线程
+    - 取得了空闲线程，立即进行任务处理
+    - 否则新建一个线程，并置入线程池，并执行上一步
+    - 如果创建失败或者线程池已满，根据设计策略选择返回错误或将任务置入处理队列，等待处理
+    - 销毁线程池
+    
+- 风险           
+    虽然线程池是构建多线程应用程序的强大机制，但使用它并不是没有风险的。
+    用线程池构建的应用程序容易遭受任何其它多线程应用程序容易遭受的所有并发风险，诸如同步错误和死锁，
+    它还容易遭受特定于线程池的少数其它风险，诸如与池有关的死锁、资源不足和线程泄漏。
+    
+- 资源不足                  
+    线程池的一个优点在于：相对于其它替代调度机制而言，它们通常执行的很好。但只有恰当地调整了线程池大小时才是这样的。
+    线程消耗包括内存和其它系统资源在内的大量资源。除了`Thread`对象所需的内存之外，每个线程都需要两个可能很大的执行调用堆栈。
+    除此以外`JVM`可能会为每个`Java`线程创建一个本机线程，这些本机线程将消耗额外的系统资源。最后虽然线程之间切换的调度开销很小，
+    但如果有很多线程，环境切换也可能严重地影响程序的性能。
+    如果线程池太大，那么被那些线程消耗的资源可能严重地影响系统性能。在线程之间进行切换将会浪费时间，
+    而且使用超出比您实际需要的线程可能会引起资源匮乏问题，因为池线程正在消耗一些资源，而这些资源可能会被其它任务更有效地利用。
+    除了线程自身所使用的资源以外，服务请求时所做的工作可能需要其它资源，例如`JDBC`连接、套接字或文件。
+    这些也都是有限资源，有太多的并发请求也可能引起失效，例如不能分配`JDBC`连接。   
+    
+
+线程池的使用
+---
+
+
+`java.uitl.concurrent.ThreadPoolExecutor`类是线程池中最核心的一个类:    
+
+```java
+public class ThreadPoolExecutor extends AbstractExecutorService {
+    .....
+    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
+            BlockingQueue<Runnable> workQueue);
+ 
+    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
+            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
+ 
+    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
+            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
+ 
+    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
+        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
+    ...
+}
+```
+
+上面构造器中各参数的含义:    
+
+- `corePoolSize`:用来表示线程池中的核心线程的数量，也可以称为可闲置的线程数量。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，
+除非调用了`prestartAllCoreThreads()`或者`prestartCoreThread()`方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建`corePoolSize`个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到`corePoolSize`后，就会把到达的任务放到缓存队列当中；
+
+- `maximumPoolSize`:来表示线程池中最多能够创建的线程数量。这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
+- `keepAliveTime`:表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于`corePoolSize`时，`keepAliveTime`才会起作用，直到线程池中的线程数不大于`corePoolSize`，即当线程池中的线程数大于`corePoolSize`时，如果一个线程空闲的时间达到`keepAliveTime`，则会终止，直到线程池中的线程数不超过`corePoolSize`。但是如果调用了`allowCoreThreadTimeOut(boolean)`方法，在线程池中的线程数不大于`corePoolSize`时，`keepAliveTime`参数也会起作用，直到线程池中的线程数为0；     
+- `unit`:参数`keepAliveTime`的时间单位，有7种取值，在`TimeUnit`类中有7种静态属性:      
+
+    - `TimeUnit.DAYS`
+    - `TimeUnit.HOURS`
+    - `TimeUnit.MINUTES`
+    - `TimeUnit.SECONDS`       
+    - `TimeUnit.MILLISECONDS`  
+    - `TimeUnit.MICROSECONDS`  
+    - `TimeUnit.NANOSECONDS`
+
+- `workQueue`:一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择:     
+
+    - `ArrayBlockingQueue`:基于数组的先进先出队列，此队列创建时必须指定大小；
+    - `LinkedBlockingQueue`:基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
+    - `SynchronousQueue`:这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。
+    - `PriorityBlockingQuene`:具有优先级的无界阻塞队列
+
+- `threadFactory`:线程工厂，主要用来创建线程
+- `handler`:表示当拒绝处理任务时的策略，有以下四种取值:      
+  
+    - `ThreadPoolExecutor.AbortPolicy`:丢弃任务并抛出`RejectedExecutionException`异常     
+    - `ThreadPoolExecutor.DiscardPolicy`:也是丢弃任务，但是不抛出异常   
+    - `ThreadPoolExecutor.DiscardOldestPolicy`:丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
+    - `ThreadPoolExecutor.CallerRunsPolicy`:由调用线程处理该任务
+
+
+
+线程池状态
+---
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_poll_state.png)
+
+
+
+`ThreadPoolExecutor`中定义了一个`volatile`变量，另外定义了几个`static final`变量表示线程池的各个状态:    
+
+- `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;`此状态下，所有任务都已经执行完毕，且没有工作线程。执行terminated()方法进入终止（TERMINATED）状态。该状态表示线程池对线程进行整理优化；
+- `static final int TERMINATED = 3;`当线程池处于`SHUTDOWN`或`STOP`状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为`TERMINATED`状态。此状态下，线程池完全终止，并完成了所有资源的释放。
+
+
+`Executors`类
+---
+
+不过在`java doc`中，并不提倡我们直接使用`ThreadPoolExecutor`，而是使用`Executors`类中提供的几个静态方法来创建线程池:     
+
+- `Executors.newCachedThreadPool();`        //创建一个可缓存线程池，缓冲池容量大小为`Integer.MAX_VALUE`
+- `Executors.newSingleThreadExecutor();`   //创建容量为1的缓冲池，即线程池中每次只有一个线程工作，单线程串行执行任务，
+- `Executors.newFixedThreadPool(int);`    //创建固定容量大小的缓冲池，固定数量的线程池，没提交一个任务就是一个线程，直到达到线程池的最大数量，然后后面进入等待队列直到前面的任务完成才继续执行
+- `Executors.newScheduleThreadExecutor();`// 大小无限制的线程池，能按时间计划来执行任务，允许用户设定计划执行任务的时间。在实际的业务场景中可以使用该线程池定期的同步数据。
+
+这几个方法的具体实现:       
+
+```java
+public static ExecutorService newFixedThreadPool(int nThreads) {
+    return new ThreadPoolExecutor(nThreads, nThreads,
+                                  0L, TimeUnit.MILLISECONDS,
+                                  new LinkedBlockingQueue<Runnable>());
+}
+public static ExecutorService newSingleThreadExecutor() {
+    return new FinalizableDelegatedExecutorService
+        (new ThreadPoolExecutor(1, 1,
+                                0L, TimeUnit.MILLISECONDS,
+                                new LinkedBlockingQueue<Runnable>()));
+}
+public static ExecutorService newCachedThreadPool() {
+    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
+                                  60L, TimeUnit.SECONDS,
+                                  new SynchronousQueue<Runnable>());
+}
+
+public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
+    return new ScheduledThreadPoolExecutor(corePoolSize);
+}
+
+```
+
+从它们的具体实现来看，它们实际上也是调用了`ThreadPoolExecutor`，只不过参数都已配置好了:      
+
+- `newFixedThreadPool`创建的线程池`corePoolSize`和`maximumPoolSize`值是相等的，它使用的`LinkedBlockingQueue`；
+- `newSingleThreadExecutor`将`corePoolSize`和`maximumPoolSize`都设置为1，也使用的`LinkedBlockingQueue`；
+- `newCachedThreadPool`将`corePoolSize`设置为0，将`maximumPoolSize`设置为`Integer.MAX_VALUE`，使用的`SynchronousQueue`，也就是说来了任务就创建线程运行，当线程空闲超过`60`秒，就销毁线程。
+- `newScheduledThreadPool`:`maximumPoolSize``Integer.MAX_VALUE`使用`DelayedWorkQueue())`。
+
+实际中，如果`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。
+
+
+
+向线程池提交任务
+---
+
+有两种方式:      
+
+- `Executor.execute(Runnable command);`
+- `ExecutorService.submit(Callable<T> task);`
+
+##### `execute()`内部实现     
+
+- 首次通过`workCountof()`获知当前线程池中的线程数，如果小于`corePoolSize`, 就通过`addWorker()`创建线程并执行该任务；否则，将该任务放入阻塞队列；
+- 如果能成功将任务放入阻塞队列中,如果当前线程池是非RUNNING状态，则将该任务从阻塞队列中移除，然后执行`reject()`处理该任务；如果当前线程池处于RUNNING状态，则需要再次检查线程池（因为可能在上次检查后，有线程资源被释放），是否有空闲的线程；如果有则执行该任务；
+- 如果不能将任务放入阻塞队列中,说明阻塞队列已满；那么将通过`addWoker()`尝试创建一个新的线程去执行这个任务；如果`addWoker()`执行失败，说明线程池中线程数达到`maxPoolSize`,则执行`reject()`处理任务；
+
+
+##### `submit()`内部实现    
+
+会将提交的`Callable`任务会被封装成了一个`FutureTask`对象，`FutureTask`类实现了`Runnable`接口，这样就可以通过`Executor.execute()`提交`FutureTask`到线程池中等待被执行，最终执行的是`FutureTask`的`run`方法； 
+
+比较:     
+
+两个方法都可以向线程池提交任务，`execute()`方法的返回类型是`void`，它定义在`Executor`接口中, 而`submit()`方法可以返回持有计算结果的`Future`对象，它定义在`ExecutorService`接口中，它扩展了`Executor`接口，其它线程池类像`ThreadPoolExecutor`和`ScheduledThreadPoolExecutor`都有这些方法。 
+
+线程池的关闭
+---
+
+`ThreadPoolExecutor`提供了两个方法，用于线程池的关闭:      
+
+- `shutdown()`:不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
+- `shutdownNow()`:立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+    
diff --git "a/JavaKnowledge/\347\275\221\347\273\234\350\257\267\346\261\202\347\233\270\345\205\263\345\206\205\345\256\271\346\200\273\347\273\223.md" "b/JavaKnowledge/\347\275\221\347\273\234\350\257\267\346\261\202\347\233\270\345\205\263\345\206\205\345\256\271\346\200\273\347\273\223.md"
new file mode 100644
index 00000000..cc7e9c2c
--- /dev/null
+++ "b/JavaKnowledge/\347\275\221\347\273\234\350\257\267\346\261\202\347\233\270\345\205\263\345\206\205\345\256\271\346\200\273\347\273\223.md"
@@ -0,0 +1,216 @@
+网络请求相关内容总结
+===
+
+网络数据传输，熟悉多线程、Socket网络编程、熟悉TCP、UDP、HTTP等协议
+
+- 网络编程概述：       
+	- 网络模型：      
+		- OSI模型      
+			- 应用层      
+			- 表示层     
+			- 会话层      
+			- 传输层      
+			- 网络层       
+			- 数据连接层        
+			- 物理层       
+		- TCP/IP模型       
+			- 应用层       
+			- 传输层         
+			- 网际层      
+			- 主机至网络层           
+		![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/TCP-IP-model-vs-OSI-model.png?raw=true)       
+			
+	- 网络通讯要素      
+		- IP地址    
+		- 端口号      
+		- 传输协议   
+	- 网络通讯前提：   
+		- 找到对方IP        
+		- 数据要发送到指定端口。为了标示不同的应用程序，所以给这些网络应用程序都用数字进行标示这个表示就叫端口      
+		- 定义通信规则。这个规则称为通信协议，国际组织定义了通用协议TCP/IP       
+		
+- TCP和UDP的区别：      
+	- UDP协议：     
+		面向无连接    
+		每个数据报的大小在限制在64k内        
+		因为是面向无连接，所以是不可靠协议       
+		不需要建立连接，速度快      
+	- TCP协议：       
+		必须建立连接，形成传输数据的通道         
+		在连接中可进行大数据量传输      
+		通过三次握手完成连接，是可靠协议         
+		必须建立连接，效率会稍低        
+		
+		三次握手：        
+		- 第一次：我问你：在么? 建立连接时，客户端A发送SYN包（SYN=j）到服务器B，并进入SYN_SEND状态，等待服务器B确认。
+		- 第二次：你回答：在。服务器B收到SYN包，必须确认客户A的SYN（ACK=j+1），同时自己也发送一个SYN包（SYN=k），即SYN+ACK包，此时服务器B进入SYN_RECV状态。
+		- 第三次：我反馈：哦，我知道你在了。客户端A收到服务器B的SYN＋ACK包，向服务器B发送确认包ACK（ACK=k+1），此包发送完毕，客户端A和服务器B进入ESTABLISHED状态，完成三次握手。     
+		
+		四次挥手： 
+		- 客户端A发送一个FIN，用来关闭客户A到服务器B的数据传送。 
+        - 服务器B收到这个FIN，它发回一个ACK，确认序号为收到的序号加1。和SYN一样，一个FIN将占用一个序号。 
+        - 服务器B关闭与客户端A的连接，发送一个FIN给客户端A。 
+        - 客户端A发回ACK报文确认，并将确认序号设置为收到序号加1。 
+
+- Socket：        
+    - Socket是对TCP/IP协议的封装和应用。Socket本身并不是协议，而是一个调用接口。通过Socket，我们才能使用TCP/IP协议.在设计模式中Socket其实就是一个门面模式。
+	 他将复杂的TCP/IP协议归隐到Socket接口后面，对于使用来说，一组简单的接口就是全部，让Socket去组织符合制定协议的数据。
+	- Socket就是为网络服务提供的一种机制        
+	- 通信的两端都有Socket       
+	- 网络通信其实就是Socket间的通信      
+	- 数据在两个Socket间通过IO传输         
+	- 玩Socket主要就是记住流程，代码查文档就行             
+	
+- UDP(User Datagram Protocol)：用户数据协议            
+	- UDP概述：       
+		需要DatagramSocket与DatagramPacket对象来实现UDP协议传输数据       
+		UDP协议是一种面向无连接的协议。面向无连接的协议指的是正式通信前不必与对方先建立连接，不管对方连接状态就直接发送数据。     
+	- UDP协议开发步骤：     
+		- 发送端：         
+			- 建立DatagramSocket服务；          
+			- 提供数据，并将数据封装到字节数组中；       
+			- 创建DatagramPacket数据包，并把数据封装到包中，同时指定接收端IP和接收端口       
+			- 通过Socket服务，利用send方法将数据包发送出去；       
+			- 关闭DatagramSocket和DatagramPacket服务。        
+		- 接收端：           
+			- 建立DatagramSocket服务，并监听一个端口；         
+			- 定义一个字节数组和一个数据包，同时将数组封装进数据包；          
+			- DatagramPacket的receive方法，将接收的数据存入定义好的数据包；      
+			- 通过DatagramPacke关闭的方法，获取发送数据包中的信息；       
+			- 关闭DatagramSocket和DatagramPacket服务。       
+	- UDP协议的Demo(必须掌握)：    
+		- 发送端：     
+		
+			```java
+			class UDPSend {
+				public static void main(String[] args) throws Exception {
+					DatagramSocket ds = new DatagramSocket();
+					byte[] buf = "这是UDP发送端".getBytes();
+					DatagramPacket dp = new DatagramPacket(
+						buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);
+					ds.send(dp);
+					ds.close();
+				}
+			}
+			```
+		- 接收端        
+		
+			```java
+			class UDPRece {
+				public static void main(String[] args) throws Exception {
+					DatagramSocket ds = new DatagramSocket(10000);
+					byte[] buf = new byte[1024];
+					DatagramPacket dp = new DatagramPacket(buf,buf.length);
+					ds.receive(dp);//将发送端发送的数据包接收到接收端的数据包中
+					String ip = dp.getAddress().getHosyAddress();//获取发送端的ip
+					String data = new String(dp.getData(),0,dp.getLength());//获取数据
+					int port = dp.getPort();//获取发送端的端口号
+					sop(ip+":"+data+":"+port);
+					ds.close();
+				}
+			}
+			```
+- TCP/IP协议：Socket和ServerSocket        
+	- 基于TCP协议的网络通信概述：        
+		- TCP/IP通信协议是一种必须建立连接的可靠的网络通信协议。它在通信两端各建立一个Socket,从而在通信的两端之间形成网络虚拟链路。      
+		- 网络虚拟链路一旦建立，两端的程序就可以进行通信。    
+	- TCP/IP协议开发步骤：       
+		- 客户端：       
+			- 建立Socket服务，并指定要连接的主机和端口；      
+			- 获取Socket流中的输出流OutputStream，将数据写入流中，通过网络发送给服务端；          
+			- 获取Socket流中的输出流InputStream，获取服务端的反馈信息；         
+			- 关闭资源。          
+		- 服务端：      
+			- 建立ServerSocket服务，并监听一个端口；         
+			- 通过ServerSocket服务的accept方法，获取Socket服务对象；        
+			- 使用客户端对象的读取流获取客户端发送过来的数据；          
+			- 通过客户端对象的写入流反馈信息给客户端；         
+			- 关闭资源        
+			
+	- TCP/IP协议的一个Demo(必须要掌握！)：          
+		- 客户端：     
+		
+			```java
+			class TCPClient {
+				public static void main(String[] args) {
+					Socket s = new Socket("192.168.1.253",10000);
+					OutputStream os = s.getOutputStream();
+					out.write("这是TCP发送的数据".getBytes());
+					s.close();
+				}
+			}
+			```
+		- 服务端：
+		
+			```java
+			class TCPServer {
+				public static void main(String[] args) {
+					ServerSocket ss = new ServerSocket(10000);
+					Socket s = ss.accept();
+
+					String ip = s.getInetAddress().getHostAddress();
+					sop(ip);
+
+					InputStream is = s.getInputStream();
+					byte[] buf = new byte[1024];
+					int len = is.read(buf);
+					sop(new String(buf,0,len));
+					s.close();
+					ss.close();
+				}
+			}
+			```
+		
+- HTTP协议：
+	- HTTP是Hyper Text Transfer Protocol的缩写
+	- 是由W3C制定和维护的。目前版本为1.0和1.1
+	- 是开发web的基石，非常地重要
+	- Http虽然本身是一个协议，但是最终还是基于TCP的。
+	- 首先由客户建立一条与服务器的TCP连接，然后发送一个请求到服务器，服务器向再进行响应。一次TCP连接的建立将需要3次握手。
+	-  版本
+		- 1.0版本：是无状态的协议，即一次连接只响应一次请求，响应完了就关闭此次连接要想再访问须重新建立连接。而连接都是比较耗资源的。
+		- 1.1版本：是有状态的协议。即可以在一次网络连接基础上发出多次请求和得到多次的响应。当距离上次请求时间过长时，服务器会自动断掉连接，这就是超时机制。
+	- HTTP协议的组成：        
+		- 请求部分：         
+			- 请求行：           
+				- GET / HTTP/1.1  包含：请求方式GET 请求的资源路径：/ 协议版本号：HTTP/1.1             
+					- 请求方式。常用的有GET、POST            
+						- GET方式：默认方式。直接输入的网址。           
+							- 表单数据出现在请求行中。url?username=abc&password=123          
+							- 特点：不安全；有长度限制：<1k           
+						- POST方式：可以通过表单form method="post"设置           
+							- 表单数据会出现在正文中。           
+							- 特点：安全；没有长度限制              
+			- 请求消息头：           
+			- 请求正文：第一个空行之后的全部都是请求正文             
+		- 响应部分：            
+			- 响应行：          
+				- HTTP/1.1 200 OK    包含：协议版本号:HTTP/1.1 响应码:200 描述:OK              
+					- 响应码：(实际用到的30个左右,其他都是W3C保留的)              
+					- 描述：对响应码的描述             
+					- 常用响应码：            
+						- 200：一切正常            
+						- 302/307:请求的资源路径变更了            
+						- 304：资源没有被修改过         
+						- 404：资源不存在,找不到资源           
+						- 500：服务器程序有错	         
+			- 响应消息头：       
+			- 响应正文：           
+				- 第一个空行之后的全部都是响应正文，浏览器显示的就是正文中的内容
+
+- HTTPS
+    HTTPS（Secure Hypertext Transfer Protocol）安全超文本传输协议
+    它是一个安全通信通道，它基于HTTP开发，用于在客户计算机和服务器之间交换信息。它使用安全套接字层(SSL)进行信息交换，简单来说它是HTTP的安全版。				
+
+- HTTPS和HTTP的区别：
+    - https协议需要到证书颁发机构（Certificate Authority，简称CA）申请证书，一般免费证书很少，需要交费。
+    - http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议
+    - http和https使用的是完全不同的连接方式用的端口也不一样,前者是80,后者是443。
+    - http的连接很简单,是无状态的
+    - HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议 要比http协议安全
+	
+----
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
\ No newline at end of file
diff --git "a/Java\345\237\272\347\241\200/\350\216\267\345\217\226\344\273\212\345\220\216\345\244\232\345\260\221\345\244\251\345\220\216\347\232\204\346\227\245\346\234\237.md" "b/JavaKnowledge/\350\216\267\345\217\226\344\273\212\345\220\216\345\244\232\345\260\221\345\244\251\345\220\216\347\232\204\346\227\245\346\234\237.md"
similarity index 96%
rename from "Java\345\237\272\347\241\200/\350\216\267\345\217\226\344\273\212\345\220\216\345\244\232\345\260\221\345\244\251\345\220\216\347\232\204\346\227\245\346\234\237.md"
rename to "JavaKnowledge/\350\216\267\345\217\226\344\273\212\345\220\216\345\244\232\345\260\221\345\244\251\345\220\216\347\232\204\346\227\245\346\234\237.md"
index 17e5cc61..773bd565 100644
--- "a/Java\345\237\272\347\241\200/\350\216\267\345\217\226\344\273\212\345\220\216\345\244\232\345\260\221\345\244\251\345\220\216\347\232\204\346\227\245\346\234\237.md"
+++ "b/JavaKnowledge/\350\216\267\345\217\226\344\273\212\345\220\216\345\244\232\345\260\221\345\244\251\345\220\216\347\232\204\346\227\245\346\234\237.md"
@@ -1,5 +1,5 @@
 获取今后多少天后的日期
-===============================
+===
 
 ```java
 /**
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"
new file mode 100644
index 00000000..c0551d48
--- /dev/null
+++ "b/JavaKnowledge/\350\256\276\350\256\241\346\250\241\345\274\217.md"
@@ -0,0 +1,2034 @@
+设计模式(Design Patterns)
+===
+
+设计模式`(Design pattern)`是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他
+人理解、保证代码可靠性。 
+毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。
+项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及
+该问题的核心解决方案，这也是它能被广泛应用的原因。
+
+
+设计模式的分类
+---
+
+总体来说设计模式分为三类:     
+
+- 创建型模式:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
+- 结构型模式:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
+- 行为型模式:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
+
+
+设计模式的六大原则
+---
+
+- 开闭原则`(Open Close Principle)`             
+    开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是:
+    为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
+    当系统升级时，如果为了增强系统功能而需要进行大量的代码修改，则说明这个系统的设计是失败的，是违反开闭原则的。反之，对系统的扩展应该只需添加
+    新的软件模块，系统模式一旦确立就不再修改现有代码，这才是符合开闭原则的优雅设计。其实开闭原则在各种设计模式中都有体现，对抽象的大量运用奠定
+    了系统可复用性、可扩展性的基础，也增加了系统的稳定性。
+
+- 里氏代换原则`（Liskov Substitution Principle）`        
+    里氏代换原则面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 `LSP`是继承复用的基石，只有当衍生类
+    可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。
+    里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实
+    现抽象化的具体步骤的规范。
+
+- 依赖倒转原则`（Dependence Inversion Principle）`      
+    我们知道，面向对象中的依赖是类与类之间的一种关系，如H（高层）类要调用L（底层）类的方法，我们就说H类依赖L类。
+    依赖倒置原则指高层模块不依赖底层模块，也就是说高层模块只依赖上层抽象，而不直接依赖具体的底层实现，从而达到降低耦合的目的。如上面提到的H与L
+    的依赖关系必然会导致它们的强耦合，也许L任何细枝末节的变动都可能影响H，这是一种非常死板的设计。而依赖倒置的做法则是反其道而行，我们可以创建
+    L的上层抽象A，然后H即可通过抽象A间接地访问L，那么高层H不再依赖底层L，而只依赖上层抽象A。这样一来系统会变得更加松散，这也印证了我们在
+    “里氏替换原则”中所提到的“面向接口编程”，以达到替换底层实现的目的。
+    举个例子，公司总经理制订了下一年度的目标与计划，为了提高办公效率，总经理决定年底要上线一套全新的办公自动化软件。那么总经理作为发起方该如何
+    实施这个计划呢？直接发动基层程序员并调用他们的研发方法吗？我想世界上没有以这种方式管理公司的领导吧。公司高层一定会发动IT部门的上层抽象去
+    执行，调用IT部门经理的work方法并传入目标即可，至于这个work方法的具体实现者也许是架构师甲，也可能是程序员乙，总经理也许根本不认识他们，
+    这就达到了公司高层与底层员工实现解耦的目的。这就是将“高层依赖底层”倒置为“底层依赖高层”的好处。
+
+- 接口隔离原则`（Interface Segregation Principle）`      
+    接口隔离原则指的是对高层接口的独立、分化，客户端对类的依赖基于最小接口，而不依赖不需要的接口。简单来说，就是切勿将接口定义成全能型的，否则
+    实现类就必须神通广大，这样便丧失了子类实现的灵活性，降低了系统的向下兼容性。反之，定义接口的时候应该尽量拆分成较小的粒度，往往一个接口只对
+    应一个职能。
+
+    这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计
+    思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
+
+- 迪米特法则（最少知识原则）`（Demeter Principle）`        
+    迪米特法则也被称为最少知识原则，它提出一个模块对其他模块应该知之甚少，或者说模块之间应该彼此保持陌生，甚至意识不到对方的存在，以此最小化、
+    简单化模块间的通信，并达到松耦合的目的。反之，模块之间若存在过多的关联，那么一个很小的变动则可能会引发蝴蝶效应般的连锁反应，最终会波及大范
+    围的系统变动。我们说，缺乏良好封装性的系统模块是违反迪米特法则的，牵一发动全身的设计使系统的扩展与维护变的举步维艰。举个例子，我们买了一台
+    游戏机，主机内部集成了非常复杂的电路及电子元件，这些对外部来说完全是不可见的，就像一个黑盒子。虽然我们看不到黑盒子的内部构造与工作原理，
+    但它向外部开放了控制接口，让我们可以接上手柄对其进行访问，这便构成了一个完美的封装。
+    “门面模式”就是极好的范例。例如我们去某单位办理一项业务，来到业务大厅一脸茫然，各种填表、盖章等复杂的办理流程让人一头雾水，有可能来回折腾
+    几个小时。假若有一个提供快速通道服务的“门面”办理窗口，那么我们只需简单地把材料递交过去就可以了，“办理人“与“门面”保持最简单的通信，对于门面
+    里面发生的事情，办理人则知之甚少，更没有必要去亲力亲为。要设计出符合迪米特法则的软件，切勿跨越红线，干涉他人内务。系统模块一定要最大程度地
+    隐藏内部逻辑，大门一定要紧锁，防止陌生人随意访问，而对外只适可而止地暴露最简单的接口，让模块间的通信趋向“简单化”“傻瓜化”。
+
+
+- 合成复用原则`（Composite Reuse Principle）`          
+    原则是尽量使用合成/聚合的方式，而不是使用继承。
+
+- 单一职责原则(Single Responsibility Principle)    
+    我们知道，一套功能完备的软件系统可能是非常复杂的。既然要利用好面向对象的思想，那么对一个大系统的拆分、模块化是不可或缺的软件设计步骤。
+    面向对象以“类”来划分模块边界，再以“方法”来分隔其功能。我们可以将某业务功能划归到一个类中，也可以拆分为几个类分别实现，但是不管对其负责的业
+    务范围大小做怎样的权衡与调整，这个类的角色职责应该是单一的，或者其方法所完成的功能也应该是单一的。总之，不是自己分内之事绝不该负责，这就是
+    单一职责原则。
+    以最典型的“责任链模式”为例，其环环相扣的每个节点都“各扫门前雪”，这种清晰的职责范围划分就是单一职责原则的最佳实践。符合单一职责原则的设计
+    能使类具备“高内聚性”，让单个模块变得“简单”“易懂”，如此才能增强代码的可读性与可复用性，并提高系统的易维护性与易测试性。
+
+
+1.工厂方法模式`(Factory Method)`
+---
+
+制造业是一个国家工业经济发展的重要支柱，而工厂则是其根基所在。程序设计中的工厂类往往是对对象构造、实例化、初始化过程的封装，而工厂方法则可以升华
+为一种设计模式，它对工厂制造方法进行接口规范化，以允许子类工厂决定具体制造哪类产品的实例，最终降低系统耦合，使系统的可维护性、可扩展性等得到提升。
+工厂内部封装的生产逻辑对外部来说像一个黑盒子，外部不需要关心工厂内部细节，外部类只管调用即可。
+
+工厂方法模式分为三种:      
+
+- 普通工厂模式:就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
+
+    这里举一个发送邮件和发送短信的例子.      
+    
+    首先，创建两者的共同接口:   
+    ```java
+    public interface ISender {
+        void send();
+    }
+    ```
+    
+    然后分别创建具体的实现类:   
+    ```java
+    public class MailSender implements ISender {
+        @Override
+        public void send() {
+            System.out.println("mail sender");
+        }
+    }
+    
+    public class SmsSender implements ISender {
+        @Override
+        public void send() {
+            System.out.println("sms sender");
+        }
+    }
+    ```
+    最后是建立工厂类:    
+    ```java
+    public class SendFactory {
+        public ISender produce(String type) {
+            if ("mail".equals(type)) {
+                return new MailSender ();
+            } else if ("sms".equals(type)) {
+                return new SmsSender ();
+            } else {
+                System.out.println("请输入正确的类型!");
+                return null;
+            }
+        }
+    }
+    ```
+
+- 多个工厂方法模式:是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。         
+
+    将上面的代码进行修改，主要修改`SendFactory`就行:   
+    ```java
+    public class SendFactory {
+        public ISender produceMail(){
+            return new MailSender();
+        }
+    
+        public ISender produceSms(){
+            return new SmsSender();
+        }
+    }
+    ```
+
+- 静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
+
+    ```java
+    public class SendFactory {
+        public static ISender produceMail(){
+            return new MailSender();
+        }
+    
+        public static ISender produceSms(){
+            return new SmsSender();
+        }
+    }
+    ```
+    
+    测试类:   
+    ```java
+    ISender sender = SendFactory.produceMail();  
+    sender.Send();  
+    ```
+
+总体来说，工厂模式适合凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，
+第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。
+
+2.抽象工厂模式`(Abstract Factory)`
+---
+
+工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，
+有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
+
+抽象工厂模式是对工厂的抽象化，而不只是制造方法。我们知道，为了满足不同用户对产品的多样化需求，工厂不会只局限于生产一类产品，但是系统如果按工厂
+方法那样为每种产品都增加一个新工厂又会造成工厂泛滥。所以，为了调和这种矛盾，抽象工厂模式提供了另一种思路，将各种产品分门别类，基于此来规划各种
+工厂的制造接口，最终确立产品制造的顶级规范，使其与具体产品彻底脱钩。
+抽象工厂是建立在制造复杂产品体系需求基础之上的一种设计模式，在某种意义上，我们可以将抽象工厂模式理解为工厂方法模式的高度集群化升级版。
+针对这种情况，我们就需要进行产业规划与整合，对现有工厂进行重构。例如，我们可以基于产品品牌与系列进行生产线规划，按品牌划分A工厂与B工厂。
+具体以汽车工厂举例，A品牌汽车有轿车、越野车、跑车3个系列的产品，同样的，B品牌汽车也包括以上3个系列的产品，如此便形成了两个产品族，分别由A工厂
+和B工厂负责生产，每个工厂都有3条生产线，分别生产这3个系列的汽车。
+
+还是用上面的例子，只是在工厂类这里需要改一下，提供两个不同的工厂类，他们要实现同一个接口:    
+
+```java
+public interface IProvider {  
+    ISender produce();  
+}  
+```
+
+具体两个工厂类的实现:     
+
+```java
+public class SendMailFactory implements IProvider {     
+    @Override  
+    public ISender produce(){  
+        return new MailSender();  
+    }  
+}
+
+public class SendSmsFactory implements IProvider{  
+    @Override  
+    public ISender produce() {  
+        return new SmsSender();  
+    }  
+}  
+```
+
+测试类:    
+
+```java
+IProvider provider = new SendMailFactory();  
+ISender sender = provider.produce();  
+sender.Send();  
+```
+
+其实这个模式的好处就是，如果你现在想增加一个功能：发送即时信息，则只需做一个实现类，实现`ISender`接口，同时做一个工厂类，实现`IProvider`接口，
+就`OK`了，无需去改动现成的代码。这样做，拓展性较好！
+
+
+3.单例模式`(Singleton)`
+---
+
+单例模式能保证在一个`JVM`中，该对象只有一个实例存在。
+
+这样的模式有几个好处:      
+
+- 某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
+- 省去了`new`操作符，降低了系统内存的使用频率，减轻`GC`压力。
+- 有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。
+
+首先我们写一个简单的单例类：
+```java
+public class SingleTon {
+    private static SingleTon instance = null;
+    private SingleTon() {
+    }
+    public static SingleTon getInstance() {
+        if (instance == null) {
+            instance = new SingleTon();
+        }
+        return instance;
+    }
+
+    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
+    public Object readResolve() {
+        return instance;
+    }
+}
+```
+
+这个类可以满足基本要求，但是，像这样毫无线程安全保护的类，如果我们把它放入多线程的环境下，肯定就会出现问题了，如何解决？我们首先会想到对
+`getInstance()`方法加`synchronized`关键字，但是，`synchronized`关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用
+`getInstance()`，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。我们改成下面这个:   
+
+```java
+public class SingleTon {
+    private static SingleTon instance = null;
+
+    private SingleTon() {
+    }
+
+    public static SingleTon getInstance() {
+        if (instance == null) {
+            synchronized (instance) {
+                if (instance == null) {
+                    instance = new SingleTon();
+                }
+            }
+        }
+        return instance;
+    }
+
+
+    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
+    public Object readResolve() {
+        return instance;
+    }
+}
+```
+
+似乎解决了之前提到的问题，将`synchronized`关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在`instance`为`null`，并创建对象的时候
+才需要加锁，性能有一定的提升。         
+但是，这样的情况，还是有可能有问题的，看下面的情况：在`Java`指令中创建对象和赋值操作是分开进行的，也就是说`instance = new Singleton();`
+语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能`JVM`会为新`的Singleton`实例分配空间，然后直接赋值给`instance`成员，
+然后再去初始化这个`Singleton`实例。这样就可能出错了。     
+
+我们以`A`、`B`两个线程为例:      
+
+- `A、B`线程同时进入了第一个`if`判断
+- `A`首先进入`synchronized`块，由于`instance`为`null`，所以它执行`instance = new Singleton();`
+- 由于`JVM`内部的优化机制，`JVM`先画出了一些分配给`Singleton`实例的空白内存，并赋值给`instance`成员（注意此时`JVM`没有开始初始化这个实例），然后`A`离开了`synchronized`块。
+- `B`进入`synchronized`块，由于`instance`此时不是`null`，因此它马上离开了`synchronized`块并将结果返回给调用该方法的程序。
+- 此时`B`线程打算使用`Singleton`实例，却发现它没有被初始化，于是错误发生了。
+
+所以程序还是有可能发生错误，其实程序在运行过程是很复杂的，从这点我们就可以看出，尤其是在写多线程环境下的程序更有难度，有挑战性。我们对该程序做进一步优化:    
+
+```java
+public class SingleTon {
+
+    private SingleTon() {
+    }
+
+    private static class SingletonFactory {
+        private static SingleTon instance = new SingleTon();
+    }
+
+    public static SingleTon getInstance() {
+        return SingletonFactory.instance;
+    }
+
+    public Object readResolve() {
+        return getInstance();
+    }
+}
+```
+
+单例模式使用内部类来维护单例的实现，`JVM`内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。
+这样当我们第一次调用`getInstance()`的时候，`JVM`能够帮我们保证`instance`只被创建一次，并且会保证把赋值给`instance`的内存初始化完毕，
+这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。
+其实说它完美，也不一定，如果在构造函数中抛出异常，实例将永远得不到创建，也会出错。所以说，十分完美的东西是没有的，我们只能根据实际情况，
+选择最适合自己应用场景的实现方法。
+
+
+4.建造者模式`(Builder)`
+---
+
+
+建造者模式所构建的对象一定是庞大而复杂的，并且一定是按照既定的制造工序将组件组装起来的，例如计算机、汽车、建筑物等。我们通常将负责构建这些大型
+对象的工程师称为建造者。
+建造者模式又称为生成器模式，主要用于对复杂对象的构建、初始化，它可以将多个简单的组件对象按顺序一步步组装起来，最终构建成一个复杂的成品对象。
+与工厂系列模式不同的是，建造者模式的主要目的在于把烦琐的构建过程从不同对象中抽离出来，使其脱离并独立于产品类与工厂类，最终实现用同一套标准的制造
+工序能够产出不同的产品。
+
+工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，
+其实建造者模式就是前面抽象工厂模式和最后的`Test`测试类结合起来得到的。
+
+还是前面的例子，一个`ISender`接口，两个实现类`MailSender`和`SmsSender`。最后，建造者类如下:    
+```java
+public class SenderBuilder {
+    private List<ISender> list = new ArrayList<>();
+    public void produceMailSender(int count) {
+        for (int i = 0; i < count; i++) {
+            list.add(new MailSender());
+        }
+    }
+
+    public void produceSmsSender(int count) {
+        for (int i = 0; i < count; i++) {
+            list.add(new SmsSender());
+        }
+    }
+}
+```
+
+测试类:   
+```java
+Builder builder = new Builder();  
+builder.produceMailSender(10);  
+```
+
+建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。所以与工程模式的区别就是：工厂模式关注的是创建单个产品，而建造者模式则关注
+创建符合对象，多个部分。因此，是选择工厂模式还是建造者模式，依实际情况而定。
+
+5.原型模式`(Prototype)`
+---
+
+在制造业中通常是指大批量生产开始之前研发出的概念模型，并基于各种参数指标对其进行检验，如果达到了质量要求，即可参照这个原型进行批量生产。
+原型模式达到以原型实例创建副本实例的目的即可，并不需要知道其原始类。
+也就是说，原型模式可以用对象创建对象，而不是用类创建对象，以此达到效率的提升。
+
+构造一个对象的过程是耗时耗力的。想必大家一定有过打印和复印的经历，为了节省成本，我们通常会用打印机把电子文档打印到A4纸上（原型实例化过程），
+再用复印机把这份纸质文稿复制多份（原型拷贝过程），这样既实惠又高效。
+那么，对于第一份打印出来的原文稿，我们可以称之为“原型文件”，而对于复印过程，我们则可以称之为“原型拷贝”
+
+想必大家已经明白了类的实例化与克隆之间的区别，二者都是在造对象，但方法绝对是不同的。
+***原型模式的目的是从原型实例克隆出新的实例，对于那些有非常复杂的初始化过程的对象或者是需要耗费大量资源的情况，原型模式是更好的选择***
+
+该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。在`Java`中，复制对象是通过`clone()`实现的，先创建一个原型类:      
+
+```java
+public class Prototype implements Cloneable {
+    public Object clone() throws CloneNotSupportedException {
+        Prototype proto = (Prototype) super.clone();
+        return proto;
+    }
+}
+```
+
+很简单，一个原型类，只需要实现`Cloneable`接口，重写`clone()`方法，此处`clone()`方法可以改成任意的名称，因为`Cloneable`接口是个空接口，
+你可以任意定义实现类的方法名，如`cloneA`或者`cloneB`，因为此处的重点是`super.clone()`这句话，
+`super.clone()`调用的是`Object`的`clone()`方法，而在`Object`类中，`clone()`是`native`的。
+
+我们都知道，Java中的变量分为原始类型和引用类型，所谓浅拷贝是指只复制原始类型的值，比如横坐标x与纵坐标y这种以原始类型int定义的值，
+它们会被复制到新克隆出的对象中。
+而引用类型同样会被拷贝，但是请注意这个操作只是拷贝了地址引用（指针），也就是说副本与原型中的对象是同一个，因为两个同样的地址实际指向的内存对象是
+同一个对象。需要注意的是，克隆方法中调用父类Object的clone方法进行的是浅拷贝，所以此处的bullet并没有被真正克隆。
+
+在这儿，将结合对象的浅复制和深复制来说一下，首先需要了解对象深、浅复制的概念:    
+
+- 浅复制:将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
+- 深复制:将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。
+
+此处，写一个深浅复制的例子:   
+
+```java
+public class Prototype implements Cloneable, Serializable {
+    private static final long serialVersionUID = 1L;
+    private String string;
+    private SerializableObject obj;
+
+    /* 浅复制 */
+    public Object clone() throws CloneNotSupportedException {
+        Prototype proto = (Prototype) super.clone();
+        return proto;
+    }
+
+    /* 深复制 */
+    public Object deepClone() throws IOException, ClassNotFoundException {
+        /* 写入当前对象的二进制流 */
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        ObjectOutputStream oos = new ObjectOutputStream(bos);
+        oos.writeObject(this);
+
+        /* 读出二进制流产生的新对象 */
+        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
+        ObjectInputStream ois = new ObjectInputStream(bis);
+        return ois.readObject();
+    }
+
+    public String getString() {
+        return string;
+    }
+
+    public void setString(String string) {
+        this.string = string;
+    }
+
+    public SerializableObject getObj() {
+        return obj;
+    }
+
+    public void setObj(SerializableObject obj) {
+        this.obj = obj;
+    }
+}
+
+class SerializableObject implements Serializable {
+    private static final long serialVersionUID = 1L;
+}
+```
+
+实现深复制，需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象。
+
+从类到对象叫作“创建”，而由本体对象至副本对象则叫作“克隆”，当需要创建多个类似的复杂对象时，我们就可以考虑用原型模式。究其本质，克隆操作时Java
+虚拟机会进行内存操作，直接拷贝原型对象数据流生成新的副本对象，绝不会拖泥带水地触发一些多余的复杂操作（如类加载、实例化、初始化等），所以其效率
+远远高于“new”关键字所触发的实例化操作。看尽世间烦扰，拨开云雾见青天，有时候“简单粗暴”也是一种去繁从简、不绕弯路的解决方案。
+
+
+适配器模式`(Adapter)`
+---
+
+适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。
+适配器模式(Adapter)通常也被称为转换器，顾名思义，它一定是进行适应与匹配工作的物件。当一个对象或类的接口不能匹配用户所期待的接口时，
+适配器就充当中间转换的角色，以达到兼容用户接口的目的，同时适配器也实现了客户端与接口的解耦，提高了组件的可复用性。
+
+
+主要分为三类：     
+
+- 类的适配器模式            
+    
+    核心思想就是：有一个`Source`类，拥有一个方法，待适配，目标接口是`Targetable`，通过`Adapter`类，将`Source`的功能扩展到`Targetable`中。   
+
+    ```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!
+    ```
+
+    `Adapter`类继承`Source`类，实现`Targetable`接口,这样`Targetable`接口的实现类就具有了`Source`类的功能。
+
+- 对象的适配器模式                
+
+    基本思路和类的适配器模式相同，只是将`Adapter`类作修改，这次不继承`Source`类，而是持有`Source`类的实例，以达到解决兼容性的问题。   
+
+    只修改上面的`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();  
+        }  
+    }  
+    ```
+    输出结果和上面的一样，只是适配器的方法不同。
+
+
+- 接口的适配器模式
+
+    有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，
+    有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，
+    而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。例如`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 void method1() {
+
+        }
+        public void method2() {
+                
+        }
+        public void method3() {
+                
+        }
+        public void method4() {
+                
+        }
+        public void method5() {
+                
+        }
+        public void method6() {
+                
+        }
+    }
+
+    public class ListAdapter extends BaseAdapter {  
+        // 不用全部实现方法，只需要实现自己需要的就可以了
+        public void method4(){  
+            System.out.println("the sourceable interface's first Sub1!");  
+        }  
+    }  
+    ```
+
+
+总结一下三种适配器模式的应用场景:     
+
+- 类的适配器模式:当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。
+- 对象的适配器模式:当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个`Adapter`类，持有原类的一个实例，在`Adapter`类的方法中，调用实例的方法就行。
+- 接口的适配器模式:当不希望实现一个接口中所有的方法时，可以创建一个抽象类`Adapter`，实现所有方法，我们写别的类的时候，继承抽象类即可。
+
+
+装饰器模式`(Decorator)`
+---
+
+装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。     
+装饰器模式(Decorator)能够在运行时动态地为原始对象增加一些额外的功能，使其变得更加强大。从某种程度上讲，装饰器非常类似于“继承”，它们都是为了
+增强原始对象的功能，区别在于方式的不同，后者是在编译时(compile-time)静态地通过对原始类的继承完成，而前者则是在程序运行时(run-time)通过对原始
+对象动态地“包装”完成，是对类实例（对象）“装饰”的结果。
+
+
+`Source`类是被装饰类，`Decorator`类是一个装饰类，可以为`Source`类动态的添加一些功能，代码如下:    
+
+```java
+public interface ISourceable {  
+    public void method();  
+} 
+
+public class Source implements ISourceable {  
+    @Override  
+    public void method() {  
+        System.out.println("the original method!");  
+    }  
+} 
+public class Decorator implements ISourceable {   
+    private ISourceable source;        
+    public Decorator(ISourceable source){  
+        super();  
+        this.source = source;  
+    }  
+    @Override  
+    public void method() {  
+        System.out.println("before decorator!");  
+        source.method();  
+        System.out.println("after decorator!");  
+    }  
+}
+public class DecoratorTest {  
+   public static void main(String[] args) {  
+        ISourceable source = new Source();  
+        ISourceable obj = new Decorator(source);  
+        obj.method();  
+    }  
+}  
+
+输出:       
+before decorator!
+the original method!
+after decorator!
+```
+
+装饰器模式的应用场景:      
+
+- 需要扩展一个类的功能。
+- 动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删）
+
+缺点：产生过多相似的对象，不易排错！
+
+
+代理模式`(Proxy)`
+---
+
+代理模式(Proxy)，顾名思义，有代表打理的意思。某些情况下，当客户端不能或不适合直接访问目标业务对象时，业务对象可以通过代理把自己的业务托管起来，
+使客户端间接地通过代理进行业务访问。如此不但能方便用户使用，还能对客户端的访问进行一定的控制。简单来说，就是代理方以业务对象的名义，代理了它的业务。
+代理模式不仅能增强原业务功能，更重要的是还能对其进行业务管控。对用户来讲，隐藏于代理中的实际业务被透明化了，而暴露出来的是代理业务，以此避免客户
+端直接进行业务访问所带来的安全隐患，从而保证系统业务的可控性、安全性。
+
+代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，
+希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，
+表达我们的想法。也就是说把专业事情交给专业的人来做。    
+
+代理按照代理的创建时期，可以分为两种:     
+
+- 静态代理:由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的`.class`文件就已经存在了。   
+- 动态代理:在程序运行时运用反射机制动态创建而成。也就是说我们不需要专门针对某个接口去编写代码实现一个代理类，而是在接口运行时动态生成。    
+
+静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成，但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的
+重复代码，此时我们就可以采用动态代理，动态代理可以在程序运行期间根据需要动态的创建代理类及其实例，来完成具体的功能，主要用的是`Java`的反射机制。
+
+下面用静态代理的示例:     
+```java
+public interface ISourceable {  
+    public void method();  
+} 
+
+public class Source implements ISourceable {  
+    @Override  
+    public void method() {  
+        System.out.println("the original method!");  
+    }  
+} 
+public class Proxy implements ISourceable {  
+    private Source source;  
+    public Proxy(){  
+        super();  
+        this.source = new Source();  
+    }  
+    @Override  
+    public void method() {  
+        before();  
+        source.method();  
+        atfer();  
+    }  
+    private void atfer() {  
+        System.out.println("after proxy!");  
+    }  
+    private void before() {  
+        System.out.println("before proxy!");  
+    }  
+}  
+
+public class ProxyTest {  
+    public static void main(String[] args) {  
+        Sourceable source = new Proxy();  
+        source.method();  
+    }  
+}  
+
+输出：    
+before proxy!
+the original method!
+after proxy!
+```
+
+代理模式可以有效的将具体的实现与调用方进行解耦，通过面向接口进行编码完全将具体的实现隐藏在内部。
+代理模式的应用场景，如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：    
+
+- 修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。
+- 就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。
+
+使用代理模式，可以将功能划分的更加清晰，有助于后期维护！
+
+动态代理的优缺点:    
+- 优点:代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合）。 
+- 缺点:      
+    - 代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
+    - 代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了
+    
+即静态代理类只能为特定的接口`(Service)`服务。如想要为多个接口服务则需要建立很多个代理类。
+
+
+动态代理的思维模式与之前的一般模式是一样的，也是面向接口进行编码，创建代理类将具体类隐藏解耦，不同之处在于代理类的创建时机不同，动态代理需要在运行时因需实时创建。
+
+动态代理示例:    
+
+```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;
+    }
+}
+
+public static void main(String[] args) {
+    ISourceable source = new Source();
+    InvocationHandler h = new DynamicProxy(source);
+    ISourceable proxy = (ISourceable) Proxy.newProxyInstance(ISourceable.class.getClassLoader(), new Class[]{ISourceable.class}, h);
+    proxy.method();
+}
+```
+
+动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理`(InvocationHandler.invoke)`。这样，
+在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强
+
+代理对象就是把被代理对象包装一层，在其内部做一些额外的工作，比如用户需要上facebook,而普通网络无法直接访问，网络代理帮助用户先翻墙，
+然后再访问facebook。这就是代理的作用了。
+
+纵观静态代理与动态代理，它们都能实现相同的功能，而我们看从静态代理到动态代理的这个过程，我们会发现其实动态代理只是对类做了进一步抽象和封装，
+使其复用性和易用性得到进一步提升而这不仅仅符合了面向对象的设计理念，其中还有AOP的身影，这也提供给我们对类抽象的一种参考。关于动态代理与AOP的关系，
+个人觉得AOP是一种思想，而动态代理是一种AOP思想的实现！
+
+外观(门面)模式`(Facade)`
+---
+
+
+外观模式是为了解决类与类之家的依赖关系的，像`spring`一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个`Facade`
+类中，降低了类类之间的耦合度，该模式中没有涉及到接口。    
+它可能是最简单的结构型设计模式，它能将多个不同的子系统接口封装起来，并对外提供统一的高层接口，使复杂的子系统变得更易使用。    
+利用门面模式，我们可以把多个子系统“关”在门里面隐藏起来，成为一个整合在一起的大系统，来自外部的访问只需通过这道“门面”（接口）来进行，而不必再
+关心门面背后隐藏的子系统及其如何运转。总之，无论门面内部如何错综复杂，从门面外部看来总是一目了然，使用起来也很简单。
+
+为了更形象地理解门面模式，我们先来看一个例子。早期的相机使用起来是非常麻烦的，拍照前总是要根据场景情况进行一系列复杂的操作，如对焦、调节闪光灯、
+调光圈等，非专业人士面对这么一大堆的操作按钮根本无从下手，拍出来的照片质量也不高。随着科技的进步，出现了一种相机，叫作“傻瓜相机”，以形容其使用
+起来的方便性。用户再也不必学习那些复杂的参数调节了，只要按下快门键就可完成所有操作。
+
+
+下面以计算机启动过程为例:   
+```java
+public class CPU {  
+    public void startup(){  
+        System.out.println("cpu startup!");  
+    }  
+      
+    public void shutdown(){  
+        System.out.println("cpu shutdown!");  
+    }  
+} 
+
+public class Memory {  
+    public void startup(){  
+        System.out.println("memory startup!");  
+    }  
+      
+    public void shutdown(){  
+        System.out.println("memory shutdown!");  
+    }  
+} 
+
+public class Disk {  
+    public void startup(){  
+        System.out.println("disk startup!");  
+    }  
+      
+    public void shutdown(){  
+        System.out.println("disk shutdown!");  
+    }  
+}  
+
+public class Computer {  
+    private CPU cpu;  
+    private Memory memory;  
+    private Disk disk;  
+      
+    public Computer(){  
+        cpu = new CPU();  
+        memory = new Memory();  
+        disk = new Disk();  
+    }  
+      
+    public void startup(){  
+        System.out.println("start the computer!");  
+        cpu.startup();  
+        memory.startup();  
+        disk.startup();  
+        System.out.println("start computer finished!");  
+    }  
+      
+    public void shutdown(){  
+        System.out.println("begin to close the computer!");  
+        cpu.shutdown();  
+        memory.shutdown();  
+        disk.shutdown();  
+        System.out.println("computer closed!");  
+    }  
+}  
+
+public class User {  
+    public static void main(String[] args) {  
+        Computer computer = new Computer();  
+        computer.startup();  
+        computer.shutdown();  
+    }  
+}
+start the computer!
+cpu startup!
+memory startup!
+disk startup!
+start computer finished!
+begin to close the computer!
+cpu shutdown!
+memory shutdown!
+disk shutdown!
+computer closed!
+```
+
+如果我们没有`Computer`类，那么`CPU`、`Memory`、`Disk`他们之间将会相互持有实例，产生关系，这样会造成严重的依赖，修改一个类，可能会带来
+其他类的修改，这不是我们想要看到的，有了`Computer`类，他们之间的关系被放在了`Computer`类里，这样就起到了解耦的作用，这就是外观模式！
+
+
+桥接模式`(Bridge)`
+---
+
+桥接模式能将抽象与实现分离，使二者可以各自单独变化而不受对方约束，使用时再将它们组合起来，就像架设桥梁一样连接它们的功能，如此降低了抽象与实现
+这两个可变维度的耦合度，以保证系统的可扩展性。       
+
+桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的`JDBC`桥`DriverManager`一样，`JDBC`进行连接数据库的时候，在各个数据库
+之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是`JDBC`提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。        
+
+```java
+public interface ISourceable {  
+    public void method();  
+}
+
+public class SourceSub1 implements ISourceable {  
+    @Override  
+    public void method() {  
+        System.out.println("this is the first sub!");  
+    }  
+} 
+public class SourceSub2 implements ISourceable {  
+    @Override  
+    public void method() {  
+        System.out.println("this is the second sub!");  
+    }  
+}  
+```
+
+定义一个桥，持有`ISourceable`的实例:   
+```java
+public abstract class Bridge {  
+    private ISourceable source;  
+  
+    public void method(){  
+        source.method();  
+    }  
+      
+    public ISourceable getSource() {  
+        return source;  
+    }  
+  
+    public void setSource(ISourceable source) {  
+        this.source = source;  
+    }  
+}  
+public class MyBridge extends Bridge {  
+    public void method(){  
+        if (getSource() == null) {
+            return;
+        }
+        getSource().method();  
+    }  
+}  
+
+public class BridgeTest {  
+    public static void main(String[] args) {  
+        Bridge bridge = new MyBridge();  
+        /*调用第一个对象*/  
+        Sourceable source1 = new SourceSub1();  
+        bridge.setSource(source1);  
+        bridge.method();  
+          
+        /*调用第二个对象*/  
+        Sourceable source2 = new SourceSub2();  
+        bridge.setSource(source2);  
+        bridge.method();  
+    }  
+}  
+
+输出:    
+
+this is the first sub!
+this is the second sub!
+```
+
+这样，就通过对`Bridge`类的调用，实现了对接口`ISourceable`的实现类`SourceSub1`和`SourceSub2`的调用。
+
+
+组合模式`(Composite)`
+---
+
+组合模式是针对由多个节点对象（部分）组成的树形结构的对象（整体）而发展出的一种结构型设计模式，它能够使客户端在操作整体对象或者其下的每个节点对象
+时做出统一的响应，保证树形结构对象使用方法的一致性，使客户端不必关注对象的整体或部分，最终达到对象复杂的层次结构与客户端解耦的目的。
+
+组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便。   
+
+```java
+public class TreeNode {
+    private String name;
+    private TreeNode parent;
+    private Vector<TreeNode> children = new Vector<TreeNode>();
+
+    public TreeNode(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public TreeNode getParent() {
+        return parent;
+    }
+
+    public void setParent(TreeNode parent) {
+        this.parent = parent;
+    }
+
+    //添加子节点
+    public void add(TreeNode node) {
+        children.add(node);
+    }
+
+    //删除子节点
+    public void remove(TreeNode node) {
+        children.remove(node);
+    }
+
+    //获取子节点
+    public Enumeration<TreeNode> getChildren() {
+        return children.elements();
+    }
+}
+
+public class Tree {
+    TreeNode root;
+
+    public Tree(String name) {
+        root = new TreeNode(name);
+    }
+}
+
+测试代码: 
+public static void main(String[] args) {
+    Tree tree = new Tree("A");
+    TreeNode nodeB = new TreeNode("B");
+    TreeNode nodeC = new TreeNode("C");
+
+    nodeB.add(nodeC);
+    tree.root.add(nodeB);
+    System.out.println("build the tree finished!");
+}
+```
+使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树，数等。
+
+享元模式`(Flyweight)`
+---
+
+享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flyweight_1.jpg?raw=true)     
+
+`FlyWeightFactory`负责创建和管理享元单元，当一个客户端请求时，工厂需要检查当前对象池中是否有符合条件的对象，如果有，就返回已经存在的对象，
+如果没有，则创建一个新对象，`FlyWeight`是超类。一提到共享池，我们很容易联想到`Java`里面的`JDBC`连接池，想想每个连接的特点，
+我们不难总结出：适用于作共享的一些个对象，他们有一些共有的属性，就拿数据库连接池来说，`url`、`driverClassName`、`username`、`password`
+及`dbname`，这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理，建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据，
+在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。
+
+下面用数据库连接池的例子:   
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flyweight_2.jpg?raw=true)     
+
+```java
+public class ConnectionPool {
+    private Vector<Connection> pool;
+    /*公有属性*/
+    private String url = "jdbc:mysql://localhost:3306/test";
+    private String username = "root";
+    private String password = "root";
+    private String driverClassName = "com.mysql.jdbc.Driver";
+
+    private int poolSize = 100;
+    Connection conn;
+
+    /*构造方法，做一些初始化工作*/
+    private ConnectionPool() {
+        pool = new Vector<>(poolSize);
+        for (int i = 0; i < poolSize; i++) {
+            try {
+                Class.forName(driverClassName);
+                conn = DriverManager.getConnection(url, username, password);
+                pool.add(conn);
+            } catch (ClassNotFoundException e) {
+                e.printStackTrace();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /* 返回连接到连接池 */
+    public synchronized void release() {
+        pool.add(conn);
+    }
+
+    /* 返回连接池中的一个数据库连接 */
+    public synchronized Connection getConnection() {
+        if (pool.size() > 0) {
+            Connection conn = pool.get(0);
+            pool.remove(conn);
+            return conn;
+        } else {
+            return null;
+        }
+    }
+}
+```
+
+通过连接池的管理，实现了数据库连接的共享，不需要每一次都重新创建连接，节省了数据库重新创建的开销，提升了系统的性能！
+
+
+策略模式`(strategy)`
+---
+
+策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供
+统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数，关系图如下：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/strategy.jpg?raw=true)     
+
+图中`ICalculator`提供了同样的方法，
+`AbstractCalculator`是辅助类，提供辅助方法，接下来，依次实现下每个类:    
+
+```java
+public interface ICalculator {  
+    public int calculate(String exp);  
+} 
+public abstract class AbstractCalculator {  
+      
+    public int[] split(String exp,String opt){  
+        String array[] = exp.split(opt);  
+        int arrayInt[] = new int[2];  
+        arrayInt[0] = Integer.parseInt(array[0]);  
+        arrayInt[1] = Integer.parseInt(array[1]);  
+        return arrayInt;  
+    }  
+}  
+
+具体的实现类:   
+public class Plus extends AbstractCalculator implements ICalculator {  
+  
+    @Override  
+    public int calculate(String exp) {  
+        int arrayInt[] = split(exp,"\\+");  
+        return arrayInt[0]+arrayInt[1];  
+    }  
+}  
+public class Minus extends AbstractCalculator implements ICalculator {  
+  
+    @Override  
+    public int calculate(String exp) {  
+        int arrayInt[] = split(exp,"-");  
+        return arrayInt[0]-arrayInt[1];  
+    }  
+}  
+public class Multiply extends AbstractCalculator implements ICalculator {  
+  
+    @Override  
+    public int calculate(String exp) {  
+        int arrayInt[] = split(exp,"\\*");  
+        return arrayInt[0]*arrayInt[1];  
+    }  
+}  
+
+测试类:  
+public class StrategyTest {  
+  
+    public static void main(String[] args) {  
+        String exp = "2+8";  
+        ICalculator cal = new Plus();  
+        int result = cal.calculate(exp);  
+        System.out.println(result);  
+    }  
+} 
+输出: 
+10
+```
+策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用
+哪个算法即可
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/design_mode_celue.png?raw=true)     
+
+相信大家对上图中的计算机、USB接口还有各种设备之间的关系以及使用方法都非常熟悉了，这些模块组成的系统正是策略模式的最佳范例。策略接口就是图中的
+USB接口。
+
+我们通过对计算机USB接口的标准化，使计算机系统拥有了无限扩展外设的能力，需要什么功能只需要购买相关的USB设备。可见在策略模式中，USB接口起到了
+至关重要的解耦作用。如果没有USB接口的存在，我们就不得不将外设直接“焊接”在主机上，致使设备与主机高度耦合，系统将彻底丧失对外设的替换与扩展能力。
+
+变化是世界的常态，唯一不变的就是变化本身。拥有顺势而为、随机应变的能力才能立于不败之地。策略模式的运用能让系统的应变能力得到提升，适应随时变化
+的需求。接口的巧妙运用让一系列的策略可以脱离系统而单独存在，使系统拥有更灵活、更强大的“可插拔”扩展功能。
+
+模板方法模式`(Template Method)`
+---
+
+模板是对多种事物的结构、形式、行为的模式化总结，而模板方法模式则是对一系列类行为（方法）的模式化。我们将总结出来的行为规律固化在基类中，
+对具体的行为实现则进行抽象化并交给子类去完成，如此便实现了子类对基类模板的套用。
+
+一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，
+实现对子类的调用，先看个关系图:   
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/template.jpg?raw=true)   
+
+就是在`AbstractCalculator`类中定义一个主方法`calculate()`，`calculate()`调用`spilt()`等，`Plus`和`Minus`分别继承
+`AbstractCalculator`类，通过对`AbstractCalculator`的调用实现对子类的调用，看下面的例子:   
+
+```java
+public abstract class AbstractCalculator {  
+    /*主方法，实现对本类其它方法的调用*/  
+    public final int calculate(String exp,String opt){  
+        int array[] = split(exp,opt);  
+        return calculate(array[0],array[1]);  
+    }  
+      
+    /*被子类重写的方法*/  
+    abstract public int calculate(int num1,int num2);  
+      
+    public int[] split(String exp,String opt){  
+        String array[] = exp.split(opt);  
+        int arrayInt[] = new int[2];  
+        arrayInt[0] = Integer.parseInt(array[0]);  
+        arrayInt[1] = Integer.parseInt(array[1]);  
+        return arrayInt;  
+    }  
+}
+
+public class Plus extends AbstractCalculator {  
+  
+    @Override  
+    public int calculate(int num1,int num2) {  
+        return num1 + num2;  
+    }  
+}  
+```
+
+测试类:    
+
+```java
+public static void main(String[] args) {  
+    String exp = "8+8";  
+    AbstractCalculator cal = new Plus();  
+    int result = cal.calculate(exp, "\\+");  
+    System.out.println(result);  
+}  
+```
+
+
+观察者模式`(Observer)`
+---
+
+观察者模式(Observer)可以针对被观察对象与观察者对象之间一对多的依赖关系建立起一种行为自动触发机制，当被观察对象状态发生变化时主动对外发起广播，
+以通知所有观察者做出响应。
+
+观察者模式很好理解，类似于邮件订阅和`RSS`订阅，当我们浏览一些博客或`wiki`时，经常会看到`RSS`图标，就这的意思是，当你订阅了该文章，如果后续有
+更新，会及时通知你。简单的说就是当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
+
+在`Android`中我们常用的`Button.setOnClickListener()`其实就是用的观察者模式。大名鼎鼎的`RxJava`也是基于这种模式。  
+
+观察者:   
+```java
+public interface Observer {  
+    public void update();  
+}  
+
+public class Observer1 implements Observer {  
+    @Override  
+    public void update() {  
+        System.out.println("observer1 has received!");  
+    }  
+} 
+public class Observer2 implements Observer {  
+    @Override  
+    public void update() {  
+        System.out.println("observer2 has received!");  
+    }  
+  
+} 
+```
+被观察者:     
+```java
+public interface Subject {     
+    /*增加观察者*/  
+    public void add(Observer observer);  
+      
+    /*删除观察者*/  
+    public void del(Observer observer);  
+      
+    /*通知所有的观察者*/  
+    public void notifyObservers();  
+      
+    /*自身的操作*/  
+    public void operation();  
+}  
+
+public abstract class AbstractSubject implements Subject {    
+    private Vector<Observer> vector = new Vector<>();  
+    @Override  
+    public void add(Observer observer) {  
+        vector.add(observer);  
+    }  
+  
+    @Override  
+    public void del(Observer observer) {  
+        vector.remove(observer);  
+    }  
+  
+    @Override  
+    public void notifyObservers() {  
+        Enumeration<Observer> enumo = vector.elements();  
+        while(enumo.hasMoreElements()){  
+            enumo.nextElement().update();  
+        }  
+    }  
+}  
+
+public class MySubject extends AbstractSubject { 
+    @Override  
+    public void operation() {  
+        System.out.println("update self!");  
+        // 一旦发生了观察者所需要的动作，就需要去通知观察者们
+        notifyObservers();  
+    }  
+  
+}  
+```
+
+测试类:   
+
+```java
+public static void main(String[] args) {  
+    Subject sub = new MySubject();  
+    sub.add(new Observer1());  
+    sub.add(new Observer2());  
+      
+    sub.operation();  
+}  
+```
+
+输出:  
+
+```java
+update self!
+observer1 has received!
+observer2 has received!
+```
+
+
+迭代器模式`(Iterator)`
+---
+
+迭代，在程序中特指对某集合中各元素逐个取用的行为。迭代器模式提供了一种机制来按顺序访问集合中的各元素，而不需要知道集合内部的构造。
+换句话讲，迭代器满足了对集合迭代的需求，并向外部提供了一种统一的迭代方式，而不必暴露集合的内部数据结构。
+
+迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。
+这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。
+
+`MyCollection`中定义了集合的一些操作，`MyIterator`中定义了一系列迭代操作，且持有`Collection`实例，我们来看看实现代码:   
+
+```java
+public interface Collection {  
+    public Iterator iterator();  
+      
+    /*取得集合元素*/  
+    public Object get(int i);  
+      
+    /*取得集合大小*/  
+    public int size();  
+}
+
+public interface Iterator {  
+    //前移  
+    public Object previous();  
+      
+    //后移  
+    public Object next();  
+    public boolean hasNext();  
+      
+    //取得第一个元素  
+    public Object first();  
+}  
+```
+
+具体实现类:   
+```java
+public class MyCollection implements Collection {  
+    public String string[] = {"A","B","C","D","E"};  
+    @Override  
+    public Iterator iterator() {  
+        return new MyIterator(this);  
+    }  
+  
+    @Override  
+    public Object get(int i) {  
+        return string[i];  
+    }  
+  
+    @Override  
+    public int size() {  
+        return string.length;  
+    }  
+}  
+public class MyIterator implements Iterator {  
+    private Collection collection;  
+    private int pos = -1;  
+      
+    public MyIterator(Collection collection){  
+        this.collection = collection;  
+    }  
+      
+    @Override  
+    public Object previous() {  
+        if(pos > 0){  
+            pos--;  
+        }  
+        return collection.get(pos);  
+    }  
+  
+    @Override  
+    public Object next() {  
+        if(pos < collection.size()-1){  
+            pos++;  
+        }  
+        return collection.get(pos);  
+    }  
+  
+    @Override  
+    public boolean hasNext() {  
+        if(pos < collection.size()-1){  
+            return true;  
+        }else{  
+            return false;  
+        }  
+    }  
+  
+    @Override  
+    public Object first() {  
+        pos = 0;  
+        return collection.get(pos);  
+    }  
+}  
+```
+
+测试类:   
+```java
+public static void main(String[] args) {  
+    Collection collection = new MyCollection();  
+    Iterator it = collection.iterator();  
+      
+    while(it.hasNext()){  
+        System.out.println(it.next());  
+    }  
+} 
+```
+
+输出:  
+```
+A B C D E
+```
+
+foreach是Java5中引入的一种for的语法增强。如果我们对class文件进行反编译就会发现，对Collection接口的各种实现类来说，
+foreach本质上还是通过获取迭代器(Iterator)来遍历的。
+
+对于任何类型的集合，要防止内部机制不被暴露或破坏，以及确保用户对每个元素有足够的访问权限，迭代器模式起到了至关重要的作用。
+迭代器巧妙地利用了内部类的形式与集合类分离，迭代器依然对其内部的元素保有访问权限，如此便促成了集合的完美封装，在此基础上还提供给用户一套标准的
+迭代器接口，使各种繁杂的遍历方式得以统一。迭代器模式的应用，能在内部事务不受干涉的前提下，保持一定的对外部开放，让我们“鱼与熊掌兼得”。
+
+责任链模式`(Chain of Responsibility)`
+---
+
+责任链是由很多责任节点串联起来的一条任务链条，其中每一个责任节点都是一个业务处理环节。责任链模式允许业务请求者将责任链视为一个整体并对其发起请求，
+而不必关心链条内部具体的业务逻辑与流程走向，也就是说，请求者不必关心具体是哪个节点起了作用，总之业务最终能得到相应的处理。在软件系统中，当一个
+业务需要经历一系列业务对象去处理时，我们可以把这些业务对象串联起来成为一条业务责任链，请求者可以直接通过访问业务责任链来完成业务的处理，最终实现
+请求者与响应者的解耦。
+
+有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对
+象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。先看看关系图：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/zerenlian.jpg?raw=true)  
+
+`Abstracthandler`类提供了`get`和`set`方法，方便`MyHandler`类设置和修改引用对象，`MyHandler`类是核心，实例化后生成一系列相互持有的对象，构成一条链。
+
+```java
+public interface IHandler {  
+    public void operator();  
+}  
+
+public abstract class AbstractHandler {     
+    private IHandler handler;  
+  
+    public IHandler getHandler() {  
+        return handler;  
+    }  
+  
+    public void setHandler(IHandler handler) {  
+        this.handler = handler;  
+    }  
+}  
+
+public class MyHandler extends AbstractHandler implements IHandler {  
+    private String name;  
+  
+    public MyHandler(String name) {  
+        this.name = name;  
+    }  
+  
+    @Override  
+    public void operator() {  
+        System.out.println(name+"deal!");  
+        if(getHandler()!=null){  
+            getHandler().operator();  
+        }  
+    }  
+}  
+```
+
+测试类:    
+```java
+ public static void main(String[] args) {  
+    MyHandler h1 = new MyHandler("h1");  
+    MyHandler h2 = new MyHandler("h2");  
+    MyHandler h3 = new MyHandler("h3");  
+
+    h1.setHandler(h2);  
+    h2.setHandler(h3);  
+
+    h1.operator();  
+} 
+```
+
+输出:   
+```
+h1deal!
+h2deal!
+h3deal!
+```
+链接上的请求可以是一条链，可以是一个树，还可以是一个环，模式本身不约束这个，需要我们自己去实现，同时，在一个时刻，命令只允许由一个对象传给另一个
+对象，而不允许传给多个对象。
+
+命令模式`(Command)`
+---
+
+命令模式很好理解，举个例子，司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，
+士兵去执行。这个过程好在，三者相互解耦，任何一方都不用去依赖其他人，只需要做好自己的事儿就行，司令员要的是结果，不会去关注到底士兵是怎么实现的。
+我们看看关系图：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/command.jpg?raw=true)  
+
+`Invoker`是调用者（司令员），`Receiver`是被调用者（士兵），`MyCommand`是命令，实现了`Command`接口，持有接收对象，实现代码:    
+
+```java
+public interface Command {  
+    public void exe();  
+}  
+
+public class MyCommand implements Command {  
+    private Receiver receiver;  
+      
+    public MyCommand(Receiver receiver) {  
+        this.receiver = receiver;  
+    }  
+  
+    @Override  
+    public void exe() {  
+        receiver.action();  
+    }  
+} 
+public class Receiver {  
+    public void action(){  
+        System.out.println("command received!");  
+    }  
+}
+
+public class Invoker {  
+    private Command command;  
+      
+    public Invoker(Command command) {  
+        this.command = command;  
+    }  
+  
+    public void action(){  
+        command.exe();  
+    }  
+}  
+
+public static void main(String[] args) {  
+    Receiver receiver = new Receiver();  
+    Command cmd = new MyCommand(receiver);  
+    Invoker invoker = new Invoker(cmd);  
+    invoker.action();  
+    // 输出:command received!
+}  
+```
+
+命令模式的目的就是达到命令的发出者和执行者之间解耦，实现请求和执行分开，熟悉`Struts`的同学应该知道，`Struts`其实就是一种将请求和呈现分离的
+技术，其中必然涉及命令模式的思想！
+
+
+备忘录模式`(Memento)`
+---
+
+备忘录用来记录曾经发生过的事情，使回溯历史变得切实可行。备忘录模式则可以在不破坏元对象封装性的前提下捕获其在某些时刻的内部状态，并像历史快照一样
+将它们保留在元对象之外，以备恢复之用。
+
+主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，个人觉得叫备份模式更形象些，通俗的讲下：假设有原始类A，A中有各种属性，A可以决定需要
+备份的属性，备忘录类B是用来存储A的一些内部状态，类C呢，就是一个用来存储备忘录的，且只能存储，不能修改等操作。做个图来分析一下：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/memento.jpg?raw=true)  
+
+`Original`类是原始类，里面有需要保存的属性`value`及创建一个备忘录类，用来保存`value`值。`Memento`类是备忘录类，`Storage`类是存储备忘录
+的类，持有`Memento`类的实例，该模式很好理解。直接看源码：
+
+```java
+public class Original {  
+    private String value;  
+      
+    public String getValue() {  
+        return value;  
+    }  
+  
+    public void setValue(String value) {  
+        this.value = value;  
+    }  
+  
+    public Original(String value) {  
+        this.value = value;  
+    }  
+  
+    public Memento createMemento(){  
+        return new Memento(value);  
+    }  
+      
+    public void restoreMemento(Memento memento){  
+        this.value = memento.getValue();  
+    }  
+}  
+
+public class Memento {  
+    private String value;  
+  
+    public Memento(String value) {  
+        this.value = value;  
+    }  
+  
+    public String getValue() {  
+        return value;  
+    }  
+  
+    public void setValue(String value) {  
+        this.value = value;  
+    }  
+} 
+
+public class Storage {  
+    private Memento memento;  
+      
+    public Storage(Memento memento) {  
+        this.memento = memento;  
+    }  
+  
+    public Memento getMemento() {  
+        return memento;  
+    }  
+  
+    public void setMemento(Memento memento) {  
+        this.memento = memento;  
+    }  
+}  
+
+测试类:    
+public static void main(String[] args) {  
+    // 创建原始类  
+    Original origi = new Original("egg");  
+
+    // 创建备忘录  
+    Storage storage = new Storage(origi.createMemento());  
+
+    // 修改原始类的状态  
+    System.out.println("初始化状态为：" + origi.getValue());  
+    origi.setValue("niu");  
+    System.out.println("修改后的状态为：" + origi.getValue());  
+
+    // 回复原始类的状态  
+    origi.restoreMemento(storage.getMemento());  
+    System.out.println("恢复后的状态为：" + origi.getValue());  
+} 
+
+输出：
+
+初始化状态为：egg
+修改后的状态为：niu
+恢复后的状态为：egg 
+```
+新建原始类时，`value`被初始化为`egg`，后经过修改，将`value`的值置为`niu`，最后倒数第二行进行恢复状态，结果成功恢复了。
+其实我觉得这个模式叫“备份-恢复”模式最形象。
+
+
+状态模式`(State)`
+---
+
+状态指事物基于所处的状况、形态表现出的不同的行为特性。状态模式构架出一套完备的事物内部状态转换机制，并将内部状态包裹起来且对外部不可见，
+使其行为能随其状态的改变而改变，同时简化了事物的复杂的状态变化逻辑。
+
+核心思想就是:当对象的状态改变时，同时改变其行为，很好理解！就拿QQ来说，有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，
+而且你的好友也能看到你的状态，所以，状态模式就两点:       
+
+- 可以通过改变状态来获得不同的行为
+- 你的好友能同时看到你的变化
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/state.jpg?raw=true)  
+
+`State`类是个状态类，`Context`类可以实现切换，我们来看看代码:   
+
+```java
+public class State {  
+    private String value;  
+      
+    public String getValue() {  
+        return value;  
+    }  
+  
+    public void setValue(String value) {  
+        this.value = value;  
+    }  
+  
+    public void method1(){  
+        System.out.println("execute the first opt!");  
+    }  
+      
+    public void method2(){  
+        System.out.println("execute the second opt!");  
+    }  
+}  
+
+public class Context {  
+    private State state;  
+  
+    public Context(State state) {  
+        this.state = state;  
+    }  
+  
+    public State getState() {  
+        return state;  
+    }  
+  
+    public void setState(State state) {  
+        this.state = state;  
+    }  
+  
+    public void method() {  
+        if (state.getValue().equals("state1")) {  
+            state.method1();  
+        } else if (state.getValue().equals("state2")) {  
+            state.method2();  
+        }  
+    }  
+}  
+```
+
+测试类:    
+
+```java
+public static void main(String[] args) {      
+    State state = new State();  
+    Context context = new Context(state);  
+      
+    //设置第一种状态  
+    state.setValue("state1");  
+    context.method();  
+      
+    //设置第二种状态  
+    state.setValue("state2");  
+    context.method();  
+} 
+
+输出:   
+execute the first opt!
+execute the second opt!
+```
+
+根据这个特性，状态模式在日常开发中用的挺多的，尤其是做网站的时候，我们有时希望根据对象的某一属性，区别开他们的一些功能，比如说简单的权限控制等。
+
+
+
+访问者模式`(Visitor)`
+---
+访问者模式主要解决的是数据与算法的耦合问题，尤其是在数据结构比较稳定，而算法多变的情况下。为了不“污染”数据本身，访问者模式会将多种算法独立归类，
+并在访问数据时根据数据类型自动切换到对应的算法，实现数据的自动响应机制，并且确保算法的自由扩展。
+
+访问者模式把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式
+使的算法操作增加变的容易。若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。访问者模式的优点是增加操作很容易，
+因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。
+
+简单来说，访问者模式就是一种分离对象数据结构与行为的方法，通过这种分离，可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。
+
+示例:银行柜台提供的服务和来办业务的人。把银行的服务和业务的办理解耦了。
+缺点：如果银行要修改底层业务接口，所有继承接口的类都需要作出修改。不过java8的新特性接口默认方法可以解决这个问题，或者java8之前可以通过接口的
+适配器模式来解决这个问题。   
+
+```java
+    // 银行柜台服务，以后银行要新增业务，只需要新增一个类实现这个接口就可以了。
+    public interface Service {
+        void accept(Visitor visitor);
+    }
+
+    // 来办业务的人，里面可以加上权限控制等等
+    static class Visitor {
+        public void process(Service service) {
+            // 基本业务
+            System.out.println("基本业务");
+        }
+
+        public void process(Saving service) {
+            // 存款
+            System.out.println("存款");
+        }
+
+        public void process(Draw service) {
+            // 提款
+            System.out.println("提款");
+        }
+
+        public void process(Fund service) {
+            System.out.println("基金");
+            // 基金
+        }
+    }
+
+    static class Saving implements Service {
+        public void accept(Visitor visitor) {
+            visitor.process(this);
+        }
+    }
+
+    static class Draw implements Service {
+        public void accept(Visitor visitor) {
+            visitor.process(this);
+        }
+    }
+
+    static class Fund implements Service {
+        public void accept(Visitor visitor) {
+            visitor.process(this);
+        }
+    }
+
+    public static void main(String[] args) {
+        Service saving = new Saving();
+        Service fund = new Fund();
+        Service draw = new Draw();
+        Visitor visitor = new Visitor();
+        Visitor guweiwei = new Visitor();
+        fund.accept(guweiwei);
+        saving.accept(visitor);
+        fund.accept(visitor);
+        draw.accept(visitor);
+        // 输出：
+        // 基金
+        // 存款
+        // 基金
+        // 提款
+    }
+}
+```
+
+该模式适用场景：如果我们想为一个现有的类增加新功能，不得不考虑几个事情:      
+
+- 新功能会不会与现有功能出现兼容性问题？
+- 以后会不会再需要添加?
+- 如果类不允许修改代码怎么办？
+
+面对这些问题，最好的解决方法就是使用访问者模式，访问者模式适用于数据结构相对稳定的系统，把数据结构和算法解耦，
+
+中介者模式`(Mediator)`
+---
+
+中介是在事物之间传播信息的中间媒介。中介模式为对象构架出一个互动平台，通过减少对象间的依赖程度以达到解耦的目的。我们的生活中有各种各样的媒介，
+如婚介所、房产中介、门户网站、电子商务、交换机组网、通信基站、即时通软件等，这些都与人类的生活息息相关，离开它们我们将举步维艰。
+
+中介者模式也是用来降低类类之间的耦合的，因为如果类类之间有依赖关系的话，不利于功能的拓展和维护，因为只要修改一个对象，其它关联的对象都得进行修改。
+如果使用中介者模式，只需关心和`Mediator`类的关系，具体类类之间的关系及调度交给`Mediator`就行，这有点像`spring`容器的作用。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/mediator.jpg?raw=true)  
+
+`User`类统一接口，`User1`和`User2`分别是不同的对象，二者之间有关联，如果不采用中介者模式，则需要二者相互持有引用，这样二者的耦合度很高，为了解耦，
+引入了`Mediator`类，提供统一接口，`MyMediator`为其实现类，里面持有`User1`和`User2`的实例，用来实现对`User1`和`User2`的控制。
+
+这样`User1`和`User2`两个对象相互独立，他们只需要保持好和`Mediator`之间的关系就行，剩下的全由`MyMediator`类来维护。   
+
+```java
+public interface IMediator {  
+    public void createMediator();  
+    public void workAll();  
+}  
+
+
+public class MyMediator implements IMediator {  
+    private User user1;  
+    private User user2;  
+      
+    public User getUser1() {  
+        return user1;  
+    }  
+  
+    public User getUser2() {  
+        return user2;  
+    }  
+  
+    @Override  
+    public void createMediator() {  
+        user1 = new User1(this);  
+        user2 = new User2(this);  
+    }  
+  
+    @Override  
+    public void workAll() {  
+        user1.work();  
+        user2.work();  
+    }  
+}  
+
+
+public abstract class User {        
+    private Mediator mediator;  
+      
+    public Mediator getMediator(){  
+        return mediator;  
+    }  
+      
+    public User(Mediator mediator) {  
+        this.mediator = mediator;  
+    }  
+  
+    public abstract void work();  
+}  
+
+public class User1 extends User {  
+    public User1(Mediator mediator){  
+        super(mediator);  
+    }  
+      
+    @Override  
+    public void work() {  
+        System.out.println("user1 exe!");  
+    }  
+}  
+
+public class User2 extends User {  
+    public User2(Mediator mediator){  
+        super(mediator);  
+    }  
+      
+    @Override  
+    public void work() {  
+        System.out.println("user2 exe!");  
+    }  
+}  
+```
+
+测试类:    
+```java
+public static void main(String[] args) {  
+    Mediator mediator = new MyMediator();  
+    mediator.createMediator();  
+    mediator.workAll();  
+    // 输出:   
+    // user1 exe!
+    // 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`开发中的编译器的开发中，所以适用面比较窄。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interpreter.jpg?raw=true)
+
+`Context`类是一个上下文环境类，`Plus`和`Minus`分别是用来计算的实现，代码如下:   
+
+```java
+public interface Expression {  
+    public int interpret(Context context);  
+}  
+
+public class Plus implements Expression {  
+    @Override  
+    public int interpret(Context context) {  
+        return context.getNum1()+context.getNum2();  
+    }  
+}  
+
+public class Minus implements Expression {  
+    @Override  
+    public int interpret(Context context) {  
+        return context.getNum1()-context.getNum2();  
+    }  
+}  
+
+public class Context {  
+    private int num1;  
+    private int num2;  
+      
+    public Context(int num1, int num2) {  
+        this.num1 = num1;  
+        this.num2 = num2;  
+    }  
+      
+    public int getNum1() {  
+        return num1;  
+    }  
+    public void setNum1(int num1) {  
+        this.num1 = num1;  
+    }  
+    public int getNum2() {  
+        return num2;  
+    }  
+    public void setNum2(int num2) {  
+        this.num2 = num2;  
+    }  
+}  
+```
+
+测试类:    
+```java
+public static void main(String[] args) {  
+    // 计算9+2-8的值  
+    int result = new Minus().interpret((new Context(new Plus()  
+            .interpret(new Context(9, 2)), 8)));  
+    System.out.println(result);  
+    // 输出:3
+}  
+```
+基本就这样，解释器模式用来做各种各样的解释器，如正则表达式等的解释器等等！
+
+在面向对象的软件设计中，人们经常会遇到一些重复出现的问题。为降低软件模块的耦合性，提高软件的灵活性、兼容性、可复用性、可维护性与可扩展性，
+人们从宏观到微观对各种软件系统进行拆分、抽象、组装，确立模块间的交互关系，最终通过归纳、总结，将一些软件模式沉淀下来成为通用的解决方案，
+这就是设计模式的由来与发展。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+    
diff --git "a/Java\345\237\272\347\241\200/\345\274\240\345\255\235\347\245\245\350\200\201\345\270\210\346\225\264\347\220\206Java\345\260\261\344\270\232\351\235\242\350\257\225\351\242\230\345\244\247\345\205\250_\347\274\205\346\200\200\345\274\240\350\200\201\345\270\210.doc" "b/Java\345\237\272\347\241\200/\345\274\240\345\255\235\347\245\245\350\200\201\345\270\210\346\225\264\347\220\206Java\345\260\261\344\270\232\351\235\242\350\257\225\351\242\230\345\244\247\345\205\250_\347\274\205\346\200\200\345\274\240\350\200\201\345\270\210.doc"
deleted file mode 100644
index c96cba9e..00000000
Binary files "a/Java\345\237\272\347\241\200/\345\274\240\345\255\235\347\245\245\350\200\201\345\270\210\346\225\264\347\220\206Java\345\260\261\344\270\232\351\235\242\350\257\225\351\242\230\345\244\247\345\205\250_\347\274\205\346\200\200\345\274\240\350\200\201\345\270\210.doc" and /dev/null differ
diff --git "a/Java\345\237\272\347\241\200/\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/Java\345\237\272\347\241\200/\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"
deleted file mode 100644
index 7c1decf8..00000000
--- "a/Java\345\237\272\347\241\200/\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"
+++ /dev/null
@@ -1,23 +0,0 @@
-强引用、软引用、弱引用、虚引用
-===
-
-- 强引用(Strong Reference)
-    平时我们编程的时候例如：`Object object=new Object()`；那`object`就是一个强引用了。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空 间不足，`Java`虚拟机宁愿抛出`OutOfMemoryError`错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。
-
-- 软引用(SoftReference)
-   如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只 要垃圾回收器没有回收它，该对象就可以被程序使用。**软引用可用来实现内存敏感的高速缓存**。 软引用可以和一个引用队列`(ReferenceQueue)`联合使用，如果软引用所引用的对象被垃圾回收，`Java`虚拟机就会把这个软引用加入到与之关联的引用队列中。
-
-- 弱引用(WeakReference)
-   如果一个对象只具有弱引用，那就类似于可有可物的生活用品。弱引用与软引用的区别在于：**只具有弱引用的对象拥有更短暂的生命周期**。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。  弱引用可以和一个引用队列`(ReferenceQueue)`联合使用，如果弱引用所引用的对象被垃圾回收,`Java`虚拟机就会把这个弱引用加入到与之关联的引用队列中。 
-
-- 虚引用(PhantomReference)   
-   "虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在 任何时候都可能被垃圾回收。 虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 `(ReferenceQueue)`联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。 
-    
-	
-有关弱引用以及软引用再分析一下:
-我们都知道垃圾回收器会回收符合回收条件的对象的内存，但并不是所有的程序员都知道回收条件取决于指向该对象的引用类型。这正是`Java`中弱引用和软引用的主要区别。如果一个对象只有弱引用指向它，垃圾回收器会立即回收该对象，这是一种急切回收方式。相对的，如果有软引用指向这些对象，则只有在`JVM`需要内存时才回收这些对象。弱引用和软引用的特殊行为使得它们在某些情况下非常有用。例如：软引用可以很好的用来实现缓存，当`JVM`需要内存时，垃圾回收器就会回收这些只有被软引用指向的对象。而弱引用非常适合存储元数据，例如：存储`ClassLoader`引用。如果没有类被加载，那么也没有指向`ClassLoader`的引用。一旦上一次的强引用被去除，只有弱引用的`ClassLoader`就会被回收。
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/Java\345\237\272\347\241\200/\347\256\227\346\263\225.md" "b/Java\345\237\272\347\241\200/\347\256\227\346\263\225.md"
deleted file mode 100644
index fb3d5b09..00000000
--- "a/Java\345\237\272\347\241\200/\347\256\227\346\263\225.md"
+++ /dev/null
@@ -1,61 +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.二叉树
-4.
-数据结构分为哪两种结构?
-线性结构：线性表、栈、队列、串、?/span>
-非线性结构：树、图、
-
----
-
-- 邮箱 ：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/Jetpack/architecture/1.\347\256\200\344\273\213.md" "b/Jetpack/architecture/1.\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..3bf0bd85
--- /dev/null
+++ "b/Jetpack/architecture/1.\347\256\200\344\273\213.md"
@@ -0,0 +1,134 @@
+1.简介
+===
+
+应用开发者面临的常见问题
+---
+
+在大多数情况下，桌面应用程序在启动器快捷方式中有一个单一的入口并且作为单独的独立进程运行，与桌面应用程序不同的是`Android`应用具有更复杂的结构。一个典型的`Android`应用是由多个应用程序组件构成的，包括`activity`，`fragment`，`service`，`content provider`和`broadcast receiver`。
+这些应用程序组件中的大部分声明在`manifest.xml`文件中，用来决定如何将应用融入到用户设备的整体体验中。尽管如前所述，传统的桌面应用程序作为独立进程运行，但是正确的编写`Android`应用程序需要更加灵活，因为用户会同过设备上不同的应用程序组织成自己的方式不断切换流程和任务。
+例如，考虑下在你喜欢的社交网络应用中分享照片时会发生什么。该应用会触发一个启动相机的`intent`，从该`intent`会启动一个相机应用来处理这个请求。在此刻，用户离开社交网络应用但是用户的体验是无缝的。相机应用转而可能会触发其它的`intent`例如启动文件选择器，这可能会启动另一个应用。最终用户回到社交网络应用并且分享照片。此外，在这个过程中的任何时刻用户都有可能会被一个电话打断，并且在结束通话后再回来继续分享照片。
+在`Android`中，这种应用切换行为很常见，所以你的应用程序必须正确处理这些流程。记住，移动设备的资源是有限的，所以在任何时候，操作系统都可能会杀死一些应用为新的应用腾出空间。
+其中的重点是应用程序组件可能会被单独和无序的启动，并且可能会被用户或系统在任何时候销毁。因为应用程序组件是短暂的，并且其声明周期（什么时候被创建和销毁）不受你控制，所以不应该在应用程序组件中存储任何应用数据或状态，同时应用程序组件不应该相互依赖。
+
+通用的框架准则官方建议在架构`App`的时候遵循以下两个准则:  
+
+- 关注分离          
+
+    其中早期开发`App`最常见的做法是在`Activity`或者`Fragment`中写了大量的逻辑代码，导致`Activity`或`Fragment`中的代码很臃肿，十分不易维护。现在很多`App` 开发者都注意到了这个问题，所以前两年`MVP`结构就非常有市场，目前普及率也很高。
+
+- 模型驱动`UI`       
+
+    模型持久化的好处就是:即使系统回收了`App`的资源用户也不会丢失数据，而且在网络不稳定的情况下`App`依然可以正常地运行。从而保证了`App`的用户体验。
+
+
+面对越来越复杂的`App`需求，`Google`官方发布了`Android`框架组件库`(Android Architecture Components)`使`App`的架构更加健壮。
+
+
+[Android Architecture Components](https://developer.android.com/topic/libraries/architecture/)       
+[googlesamples/android-architecture-components](https://github.com/googlesamples/android-architecture-components)
+
+> A collection of libraries that help you design robust, testable, and maintainable apps. Start with classes for managing your UI component lifecycle and handling data persistence.
+
+
+`Android Architecture Components`,简称`AAC`意思就是一个处理`UI`的生命周期 与数据的持久化的架构
+
+- 一个全新的库集合，可帮助您设计强大，可测试和可维护的应用程序。用于管理`UI`组件生命周期和处理数据持久性。
+- 便捷管理`App`的声明周期:新的生命周期感知(`lifecycle-aware`)组件可帮助您管理`Activity`和`Fragment`的生命周期。存储配置改变，避免内存泄漏，并使用`LiveData`，`ViewModel`，`LifecycleObserver`和`LifecycleOwner`轻松将数据加载到UI中。
+- `Room`:一个`SQLite`对象映射库
+
+
+平时我们比较熟悉的的架构有`MVC`,`MVP`及`MVVM`.这些结构有各自的优缺点, 以现在比较流行的`MVP`为例, 它将不是关于界面的操作分发到`Presenter`中操作,再将结果通知给`View`接口的实现(通常是`Activity/Fragment`).
+`MVP`架构,当异步获取结果时,可能`UI`已经销毁,而`Presenter`还持有`UI`的引用,从而导致内存泄漏
+
+
+```kotlin
+fun getName() {
+    ExecutorServiceManager.getInstance().execute(Runnable {
+        try {
+            TimeUnit.SECONDS.sleep(5)
+        } catch (e: InterruptedException) {
+            e.printStackTrace()
+        }
+
+        if (iView != null) {
+            iView.setName("siyehua")
+        }
+    })
+}
+```
+
+以上代码,`iView`的具体实现是`Activity`,当`Activity`已经执行了`onDestroy()`方法,此时`Runnable`还在获取数据,就会导致内存泄漏.
+通常的做法是在给`Presenter`定义一个方法,当`Activity`销毁的时候同时移除对`iView`的引用,完整代码如下:  
+```kotlin
+class PersonPresenter(private var iView: IView?) : IPresenter {
+    fun getName() {
+        ExecutorServiceManager.getInstance().execute(Runnable {
+            try {
+                TimeUnit.SECONDS.sleep(5)
+            } catch (e: InterruptedException) {
+                e.printStackTrace()
+            }
+
+            if (iView != null) {
+                iView!!.setName("siyehua")
+            }
+        })
+    }
+
+    fun removeView() {
+        iView = null
+    }
+} 
+```
+
+在`Activity`中,代码调用如下:   
+
+```kotlin
+override fun onDestroy() {
+    //不移除 View 有可能导致内存泄漏 
+    personPresenter.removeView()
+    super.onDestroy()
+}
+```
+
+至此,即可解决`MVP`内存泄漏的问题，但是这么做不够优雅,需要手动管理`Presenter`,当然可以定义基类写入到`BaseActivity`中.
+除了有可能引发内存泄漏的风险, 数据持久化也是一个经常困扰我们的问题.通常在屏幕旋转后,`UI`的对象都会被销毁重建,这将导致原来的对象数据不得不重新创建和获取,浪费资源的同时也会影响用户的体验.
+通常的解决方法是,通过`SavedInstanceState`来存取数据,但`SavedInstanceState`存储的数据一般比较小,且数据对象还是必须重新构建.   
+
+为了将代码解耦以应对日益膨胀的代码量，工程师在应用程序中引入了“架构”的概念。使之在不影响应用程序各模块组件间通信的同时，还能够保持模块的相对独立。这样不仅有利于后期维护，也有利于代码测试。
+
+
+
+上述两个问题可以通过使用`AAC`架构解决.
+
+
+`AAC`主要提供了`Lifecycle`，`ViewModel`，`LiveData`，`Room`等功能，下面依次说明:   
+
+- `Lifecycle`:生命周期管理，把原先`Android`生命周期的中的代码抽取出来，如将原先需要在`onStart()`等生命周期中执行的代码分离到`Activity`或者`Fragment`之外。
+- `LiveData`:一个数据持有类，持有数据并且这个数据可以被观察被监听，和其他`Observer`不同的是，它是和`Lifecycle`是绑定的，在生命周期内使用有效，减少内存泄露和引用问题。
+- `ViewModel`:用于实现架构中的`ViewModel`，同时是与`Lifecycle`绑定的，使用者无需担心生命周期。可以在多个`Fragment`之间共享数据，比如旋转屏幕后`Activity`会重新`create`，这时候使用`ViewModel`还是之前的数据，不需要再次请求网络数据。
+- `Room`:谷歌推出的一个`Sqlite ORM`库，不过使用起来还不错，使用注解，极大简化数据库的操作，有点类似`Retrofit`的风格。
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/final-architecture.png" width="100%" height="100%">
+
+
+- `Activity/Fragment`      
+    `UI`层，通常是`Activity/Fragment`等，监听`ViewModel`，当`ViewModel`数据更新时刷新`UI`，监听用户事件反馈到`ViewModel`，主流的数据驱动界面。
+
+- `ViewModel`      
+    持有或保存数据，向`Repository`中获取数据，响应`UI`层的事件，执行响应的操作，响应数据变化并通知到`UI`层。
+
+- `Repository`      
+    `App`的完全的数据模型，`ViewModel`交互的对象，提供简单的数据修改和获取的接口，配合好网络层数据的更新与本地持久化数据的更新，同步等
+
+- `Data Source`      
+    包含本地的数据库等，网络`api`等，这些基本上和现有的一些`MVVM`，以及`Clean`架构的组合比较相似
+
+
+     
+- [下一篇:2.ViewBinding简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/2.ViewBinding%E7%AE%80%E4%BB%8B.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! `
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..f465ab8b
--- /dev/null
+++ "b/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md"
@@ -0,0 +1,360 @@
+# 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，但是可以保证类型安全的访问。存储类的对象（typed objects ），通过protocol buffers将对象序列化存储在本地，protocol buffers现在已经应用的非常广泛，无论是微信还是阿里等等大厂都在使用。
+
+
+
+## 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)
+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"
+}
+```
+
+**注意**：如果您需要支持大型或复杂数据集、部分更新或参照完整性，请考虑使用 [Room](https://developer.android.com/training/data-storage/room)，而不是DataStore。DataStore非常适合简单的小型数据集，不支持部分更新或参照完整性。
+
+
+
+
+
+## 使用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保留为单例。
+
+```
+// 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)
+
+```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
+
+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存储类型化的对象
+
+既生Preference DataStore何生Proto DataStore，它们之间有什么区别？
+
+- 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更快
+
+
+
+## 序列化
+
+序列化：将一个对象转换成可存储或可传输的状态，数据可能存储在本地或者在蓝牙、网络间进行传输。序列化大概分为对象序列化、数据序列化。
+
+### 对象的序列化
+
+**Java对象序列化** 将一个存储在内存中的对象转化为可传输的字节序列，便于在蓝牙、网络间进行传输或者存储在本地。把字节序列还原为存储在内存中的Java对象的过程称为**反序列化**。
+
+在Android中可以通过Serializable和Parcelable两种方式实现对象序列化。
+
+**Serializable**
+
+Serializable是Java原生序列化的方式，主要通过ObjectInputStream和ObjectOutputStream来实现对象序列化和反序列化，但是在整个过程中用到了大量的反射和临时变量，会频繁的触发GC，序列化的性能会非常差，但是实现方式非常简单，来看一下ObjectInputStream和ObjectOutputStream源码里有很多反射的地方。
+
+```
+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;
+    }
+    ......
+}
+复制代码
+```
+
+在Android中存在大量跨进程通信，由于Serializable性能差的原因，所以Android需要更加轻量且高效的对象序列化和反序列化机制，因此Parcelable出现了。
+
+**Parcelable**
+
+Parcelable的出现解决了Android中跨进程通信性能差的问题，而且Parcelable比Serializable要快很多，因为写入和读取的时候都是采用自定义序列化存储的方式，通过writeToParcel()方法和describeContents()方法来实现，不需要使用反射来推断它，因此性能得到提升，但是使用起来比Serializable要复杂很多。
+
+为了解决复杂性问题， 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这两种语法都同时在使用。
+
+对于初学者而言直接学习proto3语法就可以了，为了适应技术迭代的变化，当掌握proto3语法之后，可以顺带了解一下proto2语法以及proto3和proto2语法的区别，这样可以更好的理解其他的开源项目。
+
+为了避免混淆proto3和proto2语法，在本文仅仅分析proto3语法，当我们了解完这些基本概念之后，我们开始分析如何在项目中使用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，这会产生一定工作量
+
+
+
+
+
+
+
+最后用一张表格来对比一下 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)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- 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"
new file mode 100644
index 00000000..2d3164db
--- /dev/null
+++ "b/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md"
@@ -0,0 +1,327 @@
+# 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)
+
+
+
+
+
+
+
+- [上一篇: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)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! `
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..38c42a53
--- /dev/null
+++ "b/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
@@ -0,0 +1,509 @@
+# 12.Navigation简介
+
+单个Activity嵌套多个Fragment的UI架构模式，已经被大多数Android工程师所接受和采用。但是，对Fragment的管理一直是一件比较麻烦的事情。工程师需要通过FragmentManager和FragmentTransaction来管理Fragment之间的切换。页面的切换通常还包括对应用程序App bar的管理、Fragment间的切换动画，以及Fragment间的参数传递。纯代码的方式使用起来不是特别友好，并且Fragment和App bar在管理和使用的过程中显得很混乱。
+
+为此，Jetpack提供了一个名为Navigation的组件，旨在方便我们管理页面和App bar。
+
+
+Navigation 是一个框架，用于在 Android 应用中的“目的地”之间导航，该框架提供一致的 API，无论目的地是作为 fragment、activity 还是其他组件实现。
+
+
+
+它具有以下优势: 
+
+- 可视化的页面导航图，类似于Apple Xcode中的StoryBoard，便于我们理清页面间的关系。
+- 通过destination和action完成页面间的导航。
+- 方便添加页面切换动画。
+- 页面间类型安全的参数传递。
+- 通过NavigationUI类，对菜单、底部导航、抽屉菜单导航进行统一的管理。
+- 支持深层链接DeepLink。
+
+Navigation 组件旨在用于具有一个主 Activity 和多个 Fragment 目的地的应用。主 Activity 与导航图相关联，且包含一个负责根据需要交换目的地的 `NavHostFragment`。在具有多个 Activity 目的地的应用中，每个 Activity 均拥有其自己的导航图。
+
+
+在使用过程中，我们感受到如下的优点。
+
+- 页面跳转性能更好，在单 Activity 的架构下，都是 fragment 的切换，每次 fragment 被压栈之后，View 被销毁，相比之前 Activity 跳转，更加轻量，需要的内存更少。
+- 通过 Viewmodel 进行数据共享更便捷，不需要页面之间来回传数据。
+- 统一的 Navigation API 来更精细的控制跳转逻辑。
+
+
+
+
+## 依赖
+
+如果想要使用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)
+}
+
+```
+
+### 参考
+
+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)         
+- [下一篇:13.Jetpack MVVM简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/13.Jetpack%20MVVM%E7%AE%80%E4%BB%8B.md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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"
new file mode 100644
index 00000000..50a25fa1
--- /dev/null
+++ "b/Jetpack/architecture/13.Jetpack MVVM\347\256\200\344\273\213.md"	
@@ -0,0 +1,50 @@
+# 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)
+
+
+- [上一篇: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)
+
+
+---
+
+- 邮箱 ：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..fe29ca19
--- /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,28 @@
+# 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)
+
+
+
+- [上一篇: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"
new file mode 100644
index 00000000..4718b3f9
--- /dev/null
+++ "b/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
@@ -0,0 +1,426 @@
+# 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文件中的android节点添加如下代码: 
+```
+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)
+}
+```
+#### include
+
+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
+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
+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
+需要在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
+) : 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)
+
+## 目录
+
+- [上一篇: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  
+- Good Luck! `
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"
new file mode 100644
index 00000000..40ab61cf
--- /dev/null
+++ "b/Jetpack/architecture/3.Lifecycle\347\256\200\344\273\213.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.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)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! `
\ No newline at end of file
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"
new file mode 100644
index 00000000..5ec5a6bf
--- /dev/null
+++ "b/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
@@ -0,0 +1,354 @@
+4.ViewModel简介
+===
+
+`Android`系统提供控件，比如`Activity`和`Fragment`，这些控件都是具有生命周期方法，这些生命周期方法被系统调用。
+
+当这些控件被销毁或者被重建的时候，如果数据保存在这些对象中，那么数据就会丢失。比如在一个界面，保存了一些用户信息，当界面重新创建的时候，就需要重新去获取数据。当然了也可以使用控件自动再带的方法，在`onSaveInstanceState`方法中保存数据，在`onCreate`中重新获得数据，但这仅仅在数据量比较小的情况下。如果数据量很大，这种方法就不能适用了。
+
+另外一个问题就是，经常需要在`Activity`中加载数据，这些数据可能是异步的，因为获取数据需要花费很长的时间。那么`Activity`就需要管理这些数据调用，否则很有可能会产生内存泄露问题。最后需要做很多额外的操作，来保证程序的正常运行。
+
+同时`Activity`不仅仅只是用来加载数据的，还要加载其他资源，做其他的操作，最后`Activity`类变大，就是我们常讲的上帝类。也有不少架构是把一些操作放到单独的类中，比如`MVP`就是这样，创建相同类似于生命周期的函数做代理，这样可以减少`Activity`的代码量，但是这样就会变得很复杂，同时也难以测试。
+
+`ViewModel`是专门用于存放应用程序页面所需的数据。ViewModel将页面所需的数据从页面中剥离出来，页面只需要处理用户交互和展示数据。
+
+
+ViewModel类是一种业务逻辑或屏幕级状态容器。     
+它用于将状态公开给界面，以及封装相关的业务逻辑。    
+它的主要优点是，它可以缓存状态，并可在配置更改后持久保留相应状态。这意味着在activity之间导航时或进行配置更改后(例如旋转屏幕时)，界面将无需重新提取数据。   
+
+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。
+
+
+
+- [上一篇: 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)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! `
\ No newline at end of file
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"
new file mode 100644
index 00000000..45363359
--- /dev/null
+++ "b/Jetpack/architecture/5.LiveData\347\256\200\344\273\213.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`就可以在任意数据来源更新时收到通知。
+
+
+
+- [上一篇: 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)
+
+
+
+
+---
+
+- 邮箱 ：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..e093432c
--- /dev/null
+++ "b/Jetpack/architecture/6.DataBinding\347\256\200\344\273\213.md"
@@ -0,0 +1,24 @@
+# 6.DataBinding简介
+
+
+
+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)
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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"
new file mode 100644
index 00000000..c5d92b14
--- /dev/null
+++ "b/Jetpack/architecture/7.Room\347\256\200\344\273\213.md"
@@ -0,0 +1,517 @@
+7.Room简介
+===
+
+`Room`是一个持久化工具，和`ormlite`、`greenDao`类似，都是`ORM`工具。在开发中我们可以利用`Room`来操作`sqlite`数据库。
+
+使用原始的`SQLite`可以提供这样的功能，但是有以下两个缺点:   
+
+- 没有编译时`SQL`语句的检查。尤其是当你的数据库表发生变化时，需要手动的更新相关代码，这会花费相当多的时间并且容易出错。
+- 编写大量`SQL`语句和`Java`对象之间相互转化的代码。
+针对以上的缺点，`Google`提供了`Room`来解决这些问题。`Room`包含以下三个重要组成部分:   
+
+- `Database`:使用注解申明一个类，注解中包含若干个`Entity`类，这个`Database`类主要负责创建数据库以及获取数据对象的。
+- `Entities`:表示每个数据库的总的一个表结构，同样也是使用注解表示，类中的每个字段都对应表中的一列。
+- `DAO`:`Data Access Object`的缩写，表示从从代码中直接访问数据库，屏蔽`sql`语句。
+
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/room_architecture.png" width="100%" height="100%">
+
+其实这和传统写数据库创建访问的代码大概形式差不多的。以存储`User`信息为例，看一下下面的代码:   
+
+```java
+@Entity
+public class User {
+    @PrimaryKey
+    private int uid;
+
+    @ColumnInfo(name = "first_name")
+    private String firstName;
+
+    @ColumnInfo(name = "last_name")
+    private String lastName;
+
+    // Getters and setters are ignored for brevity, 
+    // but they're required for Room to work.
+    //Getters和setters为了简单起见就省略了，但是对Room来说是必须的
+}
+```
+
+```java
+@Dao
+public interface UserDao {
+    @Query("SELECT * FROM user")
+    List<User> getAll();
+
+    @Query("SELECT * FROM user WHERE uid IN (:userIds)")
+    List<User> loadAllByIds(int[] userIds);
+
+    @Query("SELECT * FROM user WHERE first_name LIKE :first AND "
+           + "last_name LIKE :last LIMIT 1")
+    User findByName(String first, String last);
+
+    @Insert
+    void insertAll(User... users);
+
+    @Delete
+    void delete(User user);
+}
+```
+
+```java
+@Database(entities = {User.class}, version = 1)
+public abstract class AppDatabase extends RoomDatabase {
+    public abstract UserDao userDao();
+}
+```
+
+在创建了上面三个文件后，就可以通过如下代码创建数据库了:   
+```java
+AppDatabase db = Room.databaseBuilder(getApplicationContext(),
+        AppDatabase.class, "database-name").build();
+```
+
+
+下面详细介绍提到的各个部分:  
+
+Entities
+---
+
+
+`@Entity`      
+如果上面的`User`类中包含一个字段是不希望存放到数据库中的，那么可以用`@Ignore`注解这个字段:   
+
+```java
+@Entity
+class User {
+    @PrimaryKey
+    public int id;
+
+    public String firstName;
+    public String lastName;
+
+    //不需要被存放到数据库中
+    @Ignore
+    Bitmap picture;
+}
+```
+
+`Room`持久化一个类的`field`必须要求这个`field`是可以访问的。可以把这个`field`设为`public`或者设置`setter`和`getter`。
+
+`Primary Key`主键
+---
+
+每个`Entity`都必须定义一个`field`为主键，即使是这个`Entity`只有一个`field`。如果想要`Room`生成自动的`primary key`，可以使用`@PrimaryKey`的`autoGenerate`属性。如果`Entity`的`primary key`是多个`Field`的复合`Key`，可以向下面这样设置:   
+
+```java
+@Entity(primaryKeys = {"firstName", "lastName"})
+class User {
+    public String firstName;
+    public String lastName;
+
+    @Ignore
+    Bitmap picture;
+}
+```
+在默认情况下`Room`使用类名作为数据库表的名称。如果想要设置不同的名称，可以参考下面的代码，设置表名`tableName`为`users`:    
+```java
+@Entity(tableName = "users")
+class User {
+    ...
+}
+```
+和设置`tableName`相似，`Room`默认使用`field`的名称作为表的列名。如果想要使用不同的名称，可以通过`@ColumnInfo(name = "first_name")`设置，代码如下:   
+```java
+@Entity(tableName = "users")
+class User {
+    @PrimaryKey
+    public int id;
+
+    @ColumnInfo(name = "first_name")
+    public String firstName;
+
+    @ColumnInfo(name = "last_name")
+    public String lastName;
+
+    @Ignore
+    Bitmap picture;
+}
+```
+
+索引和唯一性
+---
+
+根据访问数据库的方式，你可能想对特定的`field`建立索引来加速你的访问。下面这段代码展示了如何在`Entity`中添加索引或者复合索引:    
+```java
+@Entity(indices = {@Index("name"),
+        @Index(value = {"last_name", "address"})})
+class User {
+    @PrimaryKey
+    public int id;
+
+    public String firstName;
+    public String address;
+
+    @ColumnInfo(name = "last_name")
+    public String lastName;
+
+    @Ignore
+    Bitmap picture;
+}
+```
+
+下面的代码展示了对数据库中特定`field`设置唯一性(这个表中的`firstName`和`lastName`不能同时相同):
+```java
+@Entity(indices = {@Index(value = {"first_name", "last_name"},
+        unique = true)})
+class User {
+    @PrimaryKey
+    public int id;
+
+    @ColumnInfo(name = "first_name")
+    public String firstName;
+
+    @ColumnInfo(name = "last_name")
+    public String lastName;
+
+    @Ignore
+    Bitmap picture;
+}
+```
+
+对象之间的关系
+---
+
+`SQLite`是关系型数据库，那么就可以在两个对象之间建立联系。大多数`ORM`库允许`Entity`对象互相引用，但`Room`明确禁止了这样做。[原因](https://developer.android.com/topic/libraries/architecture/room#no-object-references)
+
+既然不允许建立直接的关系，`Room`提供以外键的方式在两个`Entity`之间建立联系。
+
+外键
+---
+
+例如，有一个`Pet`类需要和`User`类建立关系，可以通过`@ForeignKey`来达到这个目的，代码如下:    
+```java
+@Entity(foreignKeys = @ForeignKey(entity = User.class,
+                                  parentColumns = "id",
+                                  childColumns = "user_id"))
+class Pet {
+    @PrimaryKey
+    public int petId;
+
+    public String name;
+
+    @ColumnInfo(name = "user_id")
+    public int userId;
+}
+```
+
+
+外键可以允许你定义被引用的`Entity`更新时发生的行为。例如你可以定义当删除`User`时对应的`Pet`类也被删除。可以在`@ForeignKey`中添加`onDelete = CASCADE`实现。
+```
+@Insert(OnConflict = REPLACE)
+定义了REMOVE和REPLACE而不是简单的UPDATE操作。这样产生的后果会影响外键定义的约束行为，详细的信息可以参考 SQLite documentation。
+```
+
+获取关联的Entity
+---
+
+`Entity`之间可能也有一对多之间的关系。比如一个`User`有多个`Pet`，通过一次查询获取多个关联的`Pet`。
+
+```java
+public class UserAndAllPets {
+    @Embedded
+    public User user;
+    @Relation(parentColumn = "id", entityColumn = "user_id")
+    public List<Pet> pets;
+}
+
+@Dao
+public interface UserPetDao {
+    @Query("SELECT * from User")
+    public List<UserAndAllPets> loadUserAndPets();
+}
+```
+
+使用 @Relation 注解的field必须是一个List或者一个Set。通常情况下， Entity 的类型是从返回类型中推断出来的，可以通过定义 entity()来定义特定的返回类型。
+用 @Relation 注解的field必须是public或者有public的setter。这是因为加载数据是分为两步的：1. 父Entity被查询 2. 触发用 @Relation 注解的entity的查询。所以，在上面UserAndAllPets例子中，首先User所在的数据库被查询，然后触发查询Pets的查询。即Room首先出创建一个空的对象，然后设置父Entity和一个空的list。在第二次查询后，Room将会填充这个list。
+
+
+对象嵌套对象
+---
+
+有时候需要在类里面把另一个类作为`field`，这时就需要使用`@Embedded`。这样就可以像查询其他列一样查询这个`field`。
+例如，`User`类可以包含一个`field Address`，代表`User`的地址包括所在街道、城市、州和邮编。代码如下:   
+
+```java
+class Address {
+    public String street;
+    public String state;
+    public String city;
+
+    @ColumnInfo(name = "post_code")
+    public int postCode;
+}
+
+@Entity
+class User {
+    @PrimaryKey
+    public int id;
+
+    public String firstName;
+
+    @Embedded
+    public Address address;
+}
+```
+在存放`User`的表中，包含的列名如下:`id,firstName,street,state,city,post_code`。
+`Embedded`的`field`中也可以包含其他`Embedded`的`field`。
+如果多个`Embedded`的`field`是类型相同的，可以通过设置`prefix`来保证列的唯一性。
+
+
+
+Data Access Objects（DAOs）
+---
+
+`DAOs`是数据库访问的抽象层。
+`Dao`可以是一个接口也可以是一个抽象类。如果是抽象类，那么它可以接受一个`RoomDatabase`作为构造器的唯一参数。
+`Room`不允许在主线程中防伪数据库，除非在`builder`里面调用`allowMainThreadQueries()`。因为访问数据库是耗时的，可能阻塞主线程，引起`UI`卡顿。
+
+
+添加方便使用的方法:  
+
+`Insert`:使用`@Insert`注解的方法，`Room`将会生成插入的代码。
+
+```java
+@Dao
+public interface MyDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    public void insertUsers(User... users);
+
+    @Insert
+    public void insertBothUsers(User user1, User user2);
+
+    @Insert
+    public void insertUsersAndFriends(User user, List<User> friends);
+}
+```
+如果`@Insert`方法只接受一个参数，那么将返回一个`long`，对应着插入的`rowId`。如果接受多个参数，或者数组，或者集合，那么就会返回一个`long`的数组或者`list`。
+
+
+`Update`    
+```java
+@Dao
+public interface MyDao {
+    @Update
+    public void updateUsers(User... users);
+}
+```
+也可以让`update`方法返回一个`int`型的整数，代表被`update`的行号。
+
+`Delete`
+```java
+@Dao
+public interface MyDao {
+    @Delete
+    public void deleteUsers(User... users);
+}
+```
+和`update`方法一样，也可以返回一个`int`型的整数，代表被`delete`的行号。
+
+
+使用@Query注解的方法
+---
+
+`@Query`注解的方法在编译时就会被检查，如果有任何查询的问题，都会抛出编译异常，而不是等到运行以后才会发现异常。
+`Room`也会检查查询返回值的类型，如果返回类型的字段和数据路列名存在不一致，会收到警告。如果两者完全不一致，就会产生错误。
+
+#### 简单的查询
+```java
+@Dao
+public interface MyDao {
+    @Query("SELECT * FROM user")
+    public User[] loadAllUsers();
+}
+```
+
+#### 带参数查询
+下面的代码显示了如何根据年龄条件查询`User`信息:  
+```java
+@Dao
+public interface MyDao {
+    @Query("SELECT * FROM user WHERE age > :minAge")
+    public User[] loadAllUsersOlderThan(int minAge);
+}
+```
+同理，这里也会在编译时做类型检查，如果表中没有`age`这个列，那么就会抛出错误。
+也可以穿入多个参数或一个参数作为多个约束条件查询用户:   
+```java
+@Dao
+public interface MyDao {
+    @Query("SELECT * FROM user WHERE age BETWEEN :minAge AND :maxAge")
+    public User[] loadAllUsersBetweenAges(int minAge, int maxAge);
+
+    @Query("SELECT * FROM user WHERE first_name LIKE :search "
+           + "OR last_name LIKE :search")
+    public List<User> findUserWithName(String search);
+}
+```
+#### 返回列的子集
+
+有时可能只需要`Entity`的几个`field`，例如只需要获取`User`的姓名就行了。通过只获取这两列的数据不仅能够节省宝贵的资源，还能加快查询速度。
+`Room`也提供了这样的功能。   
+```java
+public class NameTuple {
+    @ColumnInfo(name="first_name")
+    public String firstName;
+
+    @ColumnInfo(name="last_name")
+    public String lastName;
+}
+```
+```java
+@Dao
+public interface MyDao {
+    @Query("SELECT first_name, last_name FROM user")
+    public List<NameTuple> loadFullName();
+}
+```
+#### 可被观察的查询
+
+通过和`LiveData`的配合使用，就可以实现当数据库内容发生变化时自动收到变化后的数据的功能。
+```java
+@Dao
+public interface MyDao {
+    @Query("SELECT first_name, last_name FROM user WHERE region IN (:regions)")
+    public LiveData<List<User>> loadUsersFromRegionsSync(List<String> regions);
+}
+```
+
+使用RxJava实现响应式查询
+---
+
+`Room`也可以返回`RxJava2`中`Publisher`和`Flowable`
+格式的数据。如果需要使用这项功能，需要在`Gradle`中添加`android.arch.persistence.room:rxjava2`。
+```java
+@Dao
+public interface MyDao {
+    @Query("SELECT * from user where id = :id LIMIT 1")
+    public Flowable<User> loadUserById(int id);
+}
+```
+
+#### 直接获取Cursor
+```java
+@Dao
+public interface MyDao {
+    @Query("SELECT * FROM user WHERE age > :minAge LIMIT 5")
+    public Cursor loadRawUsersOlderThan(int minAge);
+}
+```
+#### 查询多个表
+
+有时可能需要查询多个表来获取结果，`Room`也定义这样的功能。下面这段代码演示了如何从一个包含借阅用户信息的表和一个包含已经被借阅的书的表中获取信息:  
+```java
+@Dao
+public interface MyDao {
+    @Query("SELECT * FROM book "
+           + "INNER JOIN loan ON loan.book_id = book.id "
+           + "INNER JOIN user ON user.id = loan.user_id "
+           + "WHERE user.name LIKE :userName")
+   public List<Book> findBooksBorrowedByNameSync(String userName);
+}
+```
+也可以从查询中返回POJO类。代码如下:   
+```java
+@Dao
+public interface MyDao {
+   @Query("SELECT user.name AS userName, pet.name AS petName "
+          + "FROM user, pet "
+          + "WHERE user.id = pet.user_id")
+   public LiveData<List<UserPet>> loadUserAndPetNames();
+
+   // You can also define this class in a separate file, as long as you add the
+   // "public" access modifier.
+   static class UserPet {
+       public String userName;
+       public String petName;
+   }
+}
+```
+
+#### 使用类型转换器
+
+如果想要在数据库中存储`Date`，可以存储等价的`Unix`时间戳。通过`TypeConverter`可以很方便的做到这一点:  
+```java
+public class Converters {
+    @TypeConverter
+    public static Date fromTimestamp(Long value) {
+        return value == null ? null : new Date(value);
+    }
+
+    @TypeConverter
+    public static Long dateToTimestamp(Date date) {
+        return date == null ? null : date.getTime();
+    }
+}
+```
+这里定义了两个方法，将`Date`和`Unix`时间戳相互转换。`Room`支持存储`Long`类型的对象，这样就可以通过这种方法存储`Date`。
+接下来将`TypeConverter`添加到`AppDatabase`中，这样`Room`就能识别这种转换:   
+```java
+@Database(entities = {User.class}, version = 1)
+@TypeConverters({Converters.class})
+public abstract class AppDatabase extends RoomDatabase {
+    public abstract UserDao userDao();
+}
+```
+接下来就可以像使用基本类型一样使用自定义类型的查询，比如：
+```java
+@Database(entities = {User.class}, version = 1)
+@TypeConverters({Converters.class})
+public abstract class AppDatabase extends RoomDatabase {
+    public abstract UserDao userDao();
+}
+```
+
+```java
+@Dao
+public interface UserDao {
+    ...
+    @Query("SELECT * FROM user WHERE birthday BETWEEN :from AND :to")
+    List<User> findUsersBornBetweenDates(Date from, Date to);
+}
+```
+
+数据库迁移
+---
+
+随着业务的扩展有时候需要对数据库调整一些字段。当数据库升级时，需要保存已有的数据。
+`Room`使用`Migration`来实现数据库的迁移。每个`Migration`都指定了`startVersion`和`endVersion`。在运行的时候`Room`运行每个`Migration`的`migrate()`方法，按正确的顺序来迁移数据库到下个版本。如果没有提供足够的迁移信息，`Room`会重新创建数据库，这意味着将会失去原来保存的信息。
+```java
+Room.databaseBuilder(getApplicationContext(), MyDb.class, "database-name")
+        .addMigrations(MIGRATION_1_2, MIGRATION_2_3).build();
+
+static final Migration MIGRATION_1_2 = new Migration(1, 2) {
+    @Override
+    public void migrate(SupportSQLiteDatabase database) {
+        database.execSQL("CREATE TABLE `Fruit` (`id` INTEGER, "
+                + "`name` TEXT, PRIMARY KEY(`id`))");
+    }
+};
+
+static final Migration MIGRATION_2_3 = new Migration(2, 3) {
+    @Override
+    public void migrate(SupportSQLiteDatabase database) {
+        database.execSQL("ALTER TABLE Book "
+                + " ADD COLUMN pub_year INTEGER");
+    }
+};
+```
+
+
+- [上一篇: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)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! `
\ No newline at end of file
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"
new file mode 100644
index 00000000..e6c0f804
--- /dev/null
+++ "b/Jetpack/architecture/8.PagingLibrary\347\256\200\344\273\213.md"
@@ -0,0 +1,14 @@
+8.PagingLibrary简介
+===
+
+
+
+
+
+- [上一篇: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  
+- Good Luck! `
\ No newline at end of file
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..bd7e22b7
--- /dev/null
+++ "b/Jetpack/architecture/9.App Startup\347\256\200\344\273\213.md"	
@@ -0,0 +1,610 @@
+# 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)
+
+
+
+- [上一篇: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  
+- Good Luck! 
\ No newline at end of file
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/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"
new file mode 100644
index 00000000..ada5182a
--- /dev/null
+++ "b/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md"	
@@ -0,0 +1,118 @@
+# 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 让我们看到了曙光。
+
+
+### 精简代码
+
+编写更少的代码会影响到所有开发阶段:作为代码撰写者，需要测试和调试的代码会更少，出现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/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/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..fde025c5
--- /dev/null
+++ "b/Jetpack/ui/material/1.MaterialToolbar\347\256\200\344\273\213.md"
@@ -0,0 +1,284 @@
+# 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拉出、隐藏；
+
+
+      
+- [下一篇: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"
new file mode 100644
index 00000000..be8958c4
--- /dev/null
+++ "b/Jetpack/ui/material/2.NavigationView\347\256\200\344\273\213.md"
@@ -0,0 +1,200 @@
+# 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)
+
+
+
+
+
+
+- [上一篇: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"
new file mode 100644
index 00000000..19416b74
--- /dev/null
+++ "b/Jetpack/ui/material/3.NestedScrollView\347\256\200\344\273\213.md"
@@ -0,0 +1,994 @@
+# 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)
+
+
+
+- [上一篇: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"
new file mode 100644
index 00000000..761af93d
--- /dev/null
+++ "b/Jetpack/ui/material/4.CoordinatorLayout\347\256\200\344\273\213.md"
@@ -0,0 +1,160 @@
+# 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中的子控件，因此这个事件就理所应当能被监听到了。
+
+
+
+
+- [上一篇: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"
new file mode 100644
index 00000000..ac881419
--- /dev/null
+++ "b/Jetpack/ui/material/5.AppBarLayout\347\256\200\344\273\213.md"
@@ -0,0 +1,99 @@
+# 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"`
+
+
+
+
+- [上一篇: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"
new file mode 100644
index 00000000..4b5657bf
--- /dev/null
+++ "b/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md"
@@ -0,0 +1,240 @@
+# 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 相关的属性无效
+
+
+
+
+- [上一篇: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"
new file mode 100644
index 00000000..d495396d
--- /dev/null
+++ "b/Jetpack/ui/material/7.Snackbar\347\256\200\344\273\213.md"
@@ -0,0 +1,37 @@
+# 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。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+- [上一篇: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"
new file mode 100644
index 00000000..73d14e83
--- /dev/null
+++ "b/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md"
@@ -0,0 +1,36 @@
+# 8.TabLayout简介
+
+```
+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是可滚动的，适用于标签较多的情况下
+  
+
+- [上一篇: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
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
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/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..6bd6e2fe
--- /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,1449 @@
+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`等。    
+但是JetBrains团队设计Kotlin所要面临的第一个问题就是必须兼容他们所拥有的数百万行Java代码库，这也代表了Kotlin基于整个Java社区所承载的使命之一，
+即需要与现有的Java代码完全兼容。这个背景也决定了Kotlin的核心目标--为Java程序员提供一门更好的编程语言。
+
+很多开发者都说`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`是一种静态类型的语言。这意味着，类型将在编译时解析且从不改变
+
+
+## `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`，
+直接通过`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)
+    }
+}
+```
+
+## 变量
+
+变量可以很简单地定义成可变`var`(可读可写)和不可变`val`(只读)的变量。如果var代表了variable(变量)，那么val可看成value(值)的缩写，
+但是也有人觉得这样并不直观或准确，而是把val解释成variable+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拥有比Java更加强大的类型推导功能，这避免了静态类型语言在编码时需要书写大量类型的弊端**:   
+```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 + "");
+    }
+    ```
+
+
+
+### 变量保存了指向对象的引用
+
+![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、不可变对象及纯函数来设计程序。
+关于纯函数的概念，其实就是没有副作用的函数，具备引用透明性。
+
+简单来说，副作用就是修改了某处的某些东西，比如说：
+
+- 修改了外部变量的值
+- IO操作，如写数据到磁盘
+- UI操作，如修改了一个按钮的可操作状态
+
+来看一个实际的例子：先用var来声明一个变量a，然后在count函数内部对其进行自增操作：
+
+```kotlin
+var 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`会默认创建`set get`方法，我们也可以自定义`get set`方法:
+
+在`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`代替属性本身进行操作。按照惯例`set`参数的名称是`value`，但是如果你喜欢你可以选择一个不同的名称。
+setter通过field标识更新变量属性值。field指的是属性的支持字段，你可以将其视为对属性的底层值的引用。在getter和setter中使用field代替属性名称
+很重要，因为这样可以阻止你陷入无限循环中。
+
+```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
+```
+
+如果我们不手动写getter和setter方法，编译器会在编译代码时添加以下代码段： 
+
+```kotlin
+var myProperty: String
+    get() = field
+    set(value) {
+        field = value
+    }
+```
+
+自定义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`的属性，应该将此属性在构造器内进行初始化。
+假如想在类内声明一个`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`
+> We’ve added a new reflection API allowing you to check whether a lateinit variable has 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变量是否已经初始化。虽然语法看上去有点奇怪，但这是固定的写法。`::`前缀不能省。::是一个引用运算符，一般用于反射相关的操作中，可以引用属性或者函数。
+这里可以写成`::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 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
+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`错误   
+- lateinit在分配之前不会初始化变量，而by lazy在第一次访问时初始化它。
+- 如果在初始化之前访问，lateinit会抛出异常，而lazy则可以确保已初始化。
+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"
+}
+```
+
+- 尽量不要使用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
+    }
+```
+
+当您稍后需要在代码中初始化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"
+}
+```
+
+
+## @操作符
+
+在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`关键字
+
+当你在定义类的时候，需要想想该类所创建的对象需要什么：
+
+- 每个对象自身的特点
+
+    对象自身的特点称为属性（properties）。它们代表了对象自身的状态（数据），并且该类中的每一个对象都有自己独特的数值。
+    例如，一个狗（Dog）类可能有名字（name）、体重（weight）和品种（breed）属性。一个歌曲（Song）类可能有标题（title）和演唱者（artist）属性。
+
+- 每个对象的行为
+
+    对象的行为是它们的函数（functions）。它们决定了对象的行为，并且可能会使用对象的属性。例如，上面提到的Dog类，可能具有吠叫（bark）函数；
+    Song这个类可能会有播放（play）函数。
+
+  
+类可以包含:  
+
+- 构造函数和初始化块
+- 函数
+- 属性
+- 嵌套类和内部类
+- 对象声明
+
+
+你可以将类想象成一个对象的模板，因为它告诉编译器如何创建该特定类的对象。它还将告诉编译器每个对象应该具有哪些属性，并且从该类生成的每个对象都可以
+拥有自己独有的属性值。例如，每个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 Dog(val name: String, var weight: Int, val breed: String)
+```
+
+### 创建类的实例
+
+```kotlin
+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`中的一个类可以有一个主构造函数和一个或多个次构造函数。
+
+#### 主构造函数
+
+主构造函数是类头的一部分:它跟在类名（和可选的类型参数）后:   
+```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
+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
+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, age: 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`定义
+
+数据类通常需要重写equals()、hashCode()、toString()这几个方法。其中，equals()方法用于判断两个数据类是否相等。
+hashCode()方法作为equals()的配套方法，也需要一起重写，否则会导致HashMap、HashSet等hash相关的系统类无法正常工作。
+toString()方法用于提供更清晰的输入日志，否则一个数据类默认打印出来的就是一行内存地址。所以我们在Java中创建一个数据类时要写很多代码，
+但是在Kotlin中你只需要一行代码。
+
+数据类是一种非常强大的类:   
+
+```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)
+```
+
+数据类自动覆盖它们的equals方法以改变==操作符的行为，由此通过检查对象的每个属性值来判断是否相等。    
+例如，假设你创建了两个属性值完全相同的Artist对象，
+使用==操作符对它们进行比较将返回true，因为它们存放了相同的数据：除了提供从Any父类继承的equals方法的新实现，数据类还覆盖了hashCode和toString方法。
+
+通过数据类，会自动提供以下函数：
+
+- 所有属性的`get() set()`方法
+- `equals()`
+- `hashCode()`
+- `copy()`
+- `toString()`
+- `componentN()`
+
+如果我们使用不可修改的对象，就像我们之前讲过的，假如我们需要修改这个对象状态，必须要创建一个新的或者多个属性被修改的实例。
+这个任务是非常重复且不简洁的。
+
+举个例子,如果要修改`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版本前数据类只允许实现接口，之后的版本既可以实现接口也可以继承类，
+    更多可看[Feedback Request: Limitations on Data Classes](https://blog.jetbrains.com/kotlin/2015/09/feedback-request-limitations-on-data-classes/)
+
+与任何其他类一样，你可以向数据类添加属性和方法，只需要将它们包含在类主体中。但是有一个大问题,就是在编译器生成数据类的方法实现时，
+比如覆盖equals方法和创建copy方法，它仅包含在主构造函数中定义的属性。因此如果你在数据类主体中定义添加的属性，则它们不会被包含到任何编译器生成的方法中。
+
+### 数据类定义了componentN方法
+
+定义数据类时，编译器会自动向该类添加一组方法，你可以将其作为访问对象属性值的替代方法。它们被称为componentN方法，其中N表示被访问属性的编号（按声明排序）。
+
+多声明，也可以理解为变量映射，这就是编译器自动生成的`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()
+```
+数据类的缺点，数据类虽然使用的时候很简单，但是因为它会默认帮我们自动生成很多代码，里面的有些代码其实在某些情况下我们并不需要，例如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()方法的类如果使用数据类就会导致多生成这些代码，所以在使用数据类的时候不要去为了简单而乱用，
+也要去想想是否需要这些方法？是否需要设计成数据类。
+
+
+#### 获取类中成员函数的对象
+
+```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`，这对于没有超类型声明的类是默认超类:   
+
+```kotlin
+class Person // 从 Any 隐式继承
+```
+
+`Any`不是`java.lang.Object`。它除了`equals()`、`hashCode()`和`toString()`外没有任何成员。
+在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中所有的类默认都是不可继承的(`final`)，为什么要这样设计呢？引用`Effective Java`书中的第17条:要么为继承而设计，并提供文档说明，
+要么就禁止继承。所以我们只能继承那些明确声明`open`或者`abstract`的类:要声明一个显式的超类型，我们把类型放到类头的冒号之后:   
+
+```kotlin
+open class Person(num: Int)
+// 继承
+class SuperPerson(num: Int) : Person(num)
+```
+
+冒号后面的Person(num)会调用Person类的构造函数，以确保所有的初始化代码（例如给属性赋值）能够被执行。
+调用父类构造函数是强制性的：如果父类有主构造函数，你必须在子类头中调用它，否则代码将无法通过编译。
+请记住，即使你没有在父类中显式地添加构造函数，编译器也会在编译代码的时候自动创建一个空构造函数。
+假如我们不想为Person类添加构造函数，因此编译器在编译代码的时候创建了一个空构造函数。该构造函数通过使用Person()被调用。
+
+
+***注意： 上面在说到继承的时候`class SuperPerson(num: Int) : Person(num)`在父类后面必须加上括号，这是为了能够调用到父类的主构造函数。
+Kotlin中规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数(包括间接调用)。***
+***但是如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。 这里很特殊，在Kotlin
+中是允许类中只有次构造函数，没有主构造函数的。当一个类没有显式的定义主构造函数且定义了次构造函数时，它就是没有主构造函数的。***
+
+***如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。***
+
+***如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。***
+
+
+注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数:   
+
+```kotlin
+class MyView : View {
+    constructor(ctx: Context) : super(ctx)
+    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
+}
+```
+
+也就是MyView类的后面没有显式的定义主构造函数，同时又定义了次构造函数。所以现在MyView类是没有主构造函数的。     
+
+***那么既然没有主构造函数，继承View类的时候也就不需要再在View类后加上括号了。***
+
+其实原因就是这么简单，只是很多人在刚开始学习Kotlin的时候没能理解这对括号的意义和规则，因此总感觉继承的
+写法有时候要加上括号，有时候又不要加，搞得晕头转向的，而在你真正理解了规则之后，就会发现其实还是很好懂的。
+
+***另外，由于没有主构造函数，次构造函数只能直接调用父类的构造函数，上述代码也是将this关键字换成了super关键字，这部分就很好理解了。***
+
+
+### 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
+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`方法的属性覆盖，如果某个属性在父类中被定义为val，你可以在子类中使用var属性覆盖它。
+只需要覆盖该属性并将其声明为var即可。请注意，这只适用于这一种方式。如果尝试使用val覆盖var属性，编译器将会感到沮丧并拒绝编译你的代码。
+
+## 抽象类
+
+类和其中的某些成员可以声明为`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方法的默认实现的，Java8也开始支持了接口方法的默认实现
+    fun fly() {
+        println("I can fly")
+    }
+}
+```
+
+Kotlin提供了另外一种方式来实现这种效果:  
+
+```kotlin
+interface Flyer {
+    val height 
+        get() = 1000
+}
+```
+
+一个类实现接口时： 
+```kotlin
+class Bird() : Flyer {
+    //  ...
+}
+```
+接口的后面不用加上括号，因为它没有构造函数可以去调用。
+
+
+## 函数:通过`fun`关键字定义
+
+```kotlin
+fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    setContentView(R.layout.activity_main)
+}
+```
+如果你没有指定它的返回值，它就会返回`Unit`，`Unit`与`Java`中的`void`类似，但是`Unit`是一个类型，而void只是一个关键字。`Unit`可以省略。
+你当然也可以指定任何其它的返回类型:      
+
+```kotlin
+fun maxOf(a: Int, b: Int): Int {
+    if (a > b) {
+        return a
+    } else {
+        return b
+    }
+}
+```
+
+### `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 // 省略了{}
+```
+
+***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)
+```
+
+### 无参主函数
+
+如果你使用的是Kotlin1.2或更早的版本，若想正常运行程序，你的主函数必须写成如下形式:   
+
+```kotlin
+fun main(args: Array<String>) {
+    // ...
+}
+```
+
+从Kotlin1.3版本起，你可以忽略main函数的参数，写成如下形式:   
+
+```kotlin
+fun main() {
+    // ...
+}
+```
+
+### 可变长参数函数:使用`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
+}
+```
+
+如果你有一个现有的值数组，则可以通过在数组名前加上`*`来将这些值传递给该函数。星号`（*）`被称为扩展运算符，以下是它的一些使用示例：
+
+```kotlin
+val myArray = arrayOf(1, 2, 3, 4, 5)
+val mList = vars(*myArray)
+val mList2 = vars(0, *myArray, 6, 7)
+```
+
+
+在Kotlin中，方法调用也被定义为二元操作运算符，而这些方法往往可以转化为invoke函数。
+例如 a(i)方法的对应转换方法为 a.invoke(i)
+
+
+
+## 命名风格
+
+如果拿不准的时候，默认使用`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 {
+    // ……
+}
+```
+
+- [下一篇: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  
+- 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"
new file mode 100644
index 00000000..f2daad86
--- /dev/null
+++ "b/KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
@@ -0,0 +1,487 @@
+10.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方法，实现了解耦。 
+
+
+
+- [上一篇: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)
+
+
+
+---
+
+- 邮箱 ：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..a3f2b9c9
--- /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,1146 @@
+2.Kotlin_高阶函数&Lambda&内联函数
+===
+
+## 函数还是属性
+
+在某些情况下，不带参数的函数可与只读属性互换。 虽然语义相似，但是在某种程度上有一些风格上的约定。
+
+底层算法优先使用属性而不是函数：
+
+- 不会抛异常
+- 计算开销小（或者在首次运行时缓存）
+- 如果对象状态没有改变，那么多次调用都会返回相同结果
+
+
+## 高阶函数
+
+
+高阶函数(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
+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)?
+    // 表示传入一个类型为Int的参数，然后返回另一个类型为（Int） -> Unit的函数
+    (Int) -> ((Int) -> 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。当我们再对Book类对象的集合应用一些函数式API的时候，这会显得格外有用，比如： 
+
+```kotlin
+fun main(args: Array<String>) {
+    val bookNames = listOf (
+        Book("Thinking in java")
+        Book("Dive into Kotlin")    
+    ).map(Book::name)
+    println(bookNames)
+}
+```
+
+## 匿名函数
+
+再来思考下上面代码中的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却允许传入一小段代码。这里两次使用了“一小段代码”这种描述，那么到底多少代码才算一小段代码呢？Kotlin对此并没有进行限制，但是通常不建议在Lambda表达式中编写太长的代码，否则可能会影响代码的可读性。
+
+
+
+Lambda的语法:  
+
+- 一个Lambda表达式必须通过{}来包裹
+- 如果Lambda声明了参数部分的类型，且返回值类型支持类型推导，那么Lambda变量就可以省略函数类型声明
+- 如果Lambda变量声明了函数类型，那么Lambda的参数部分的类型就可以省略
+
+此外，如果Lambda表达式返回的不是Unit，那么默认最后一行表达式的值类型就是返回值类型，如:  
+
+```kotlin
+val foo = { x: Int -> 
+    val y = x + 1
+	y // 返回值是y           
+}
+```
+
+## Lambda表达式
+
+{参数名1: 参数类型, 参数名2: 参数类型 -> 函数体}
+
+> “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`表达式避免在抽象类或接口中编写明确的函数声明，进而也避免了类的实现部分，
+所以它是非常有用的。
+
+`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来执行它的代码你可以使用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表达式的参数列表中只有一个参数时，那么可以不声明唯一的参数名，而是可以使用it关键字来代替，因为Kotlin会隐含的声明一个名为it的参数.这叫做单个参数的隐式名称，代表了这个Lambda所接收的单个参数**    
+
+```kotlin
+val list = listOf("Apple", "Bnana", "Orange", "Pear")
+val maxLengthFruit = list.maxBy {it.length}
+```
+
+### Lambda开销
+
+```kotlin
+fun foo(int: Int) = {
+    print(int)
+}
+listOf(1, 2, 3).forEach { foo(it) } // 对一个整数列表的元素遍历调用foo
+```
+
+这里的调用等价于:  
+
+```kotlin
+listOf(1, 2, 3).forEach { item -> foo(item) }
+```
+
+假设使用以下代码将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
+@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
+public interface Function1<in P1, out R> : Function<R> {
+    /** Invokes the function with the specified argument. */
+    public operator 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表达式或匿名函数(局部函数、对象表达式等)都可以访问它的闭包。 
+
+在Kotlin中，你会发现匿名函数体、Lambda在语法上都存在“{}"，由这对花括号包裹的代码如果访问了外部环境变量则被称为一个闭包。      
+一个闭包可以被当做参数传递或直接使用，它可以简单的看成”访问外部环境变量的函数“。Lambda是Kotlin中最常见的闭包形式。
+
+与Java不一样的地方在于，Kotlin中的闭包不仅可以访问外部变量，还能够对其进行修改(我有点疑惑，Java为啥不能修改？下面说)，如下： 
+
+```kotlin
+var sum = 0
+listOf(1, 2, 3).filter { it > 0 }.forEach {
+    // 外部的变量，且可以修改
+    sum += it
+}
+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 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。
+
+
+
+## 优化Lambda开销
+
+在Kotlin中每声明一个Lambda表达式，就会在字节码中产生一个匿名类(也就是说我们一直使用的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的内联函数是具体如何操作的:   
+
+```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
+}
+```
+
+
+##### 为什么要设计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关键字来修饰该参数，从而杜绝此类问题的发生。就像这样子: 
+
+```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>()
+```
+
+
+
+
+
+
+
+
+
+- [上一篇: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)
+
+
+---
+
+- 邮箱 ：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..f4d67cad
--- /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,666 @@
+3.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
+```
+
+#### 数值类型转换背后发生了什么
+
+```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`):
+
+```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中的判等性主要有两种类型:       
+
+- 结构相等: 通过操作符==来判断两个对象的内容是否相等。
+- 引用相等: 引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。如果比较的是运行时的原始类型，比如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?.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，很明显它只限制于它的领域。
+
+### 数组
+
+你可以将数组想象成一托盘的杯子，其中每个杯子都是一个变量。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/array.jpg?raw=true)        
+
+
+
+数组用类`Array`实现，并且还有一个`size`属性及`get`和`set`方法，由于使用`[]`重载了`get`和`set`方法，所以我们可以通过下标很方便的获取或者
+设置数组对应位置的值。       
+`Kotlin`标准库提供了`arrayOf()`创建数组和`xxArrayOf`创建特定类型数组      
+
+```kotlin
+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 })
+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、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>`。
+
+可变集合，顾名思义，就是可以改变的集合。可变集合都会有一个修饰前缀“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，你可以得到它，但是你必须显式要求它，否则它不会不期而至。
+
+#### 可空类型的集合
+
+如果你有一个可空类型元素的集合，并且想要过滤非空元素，你可以使用`filterNotNull`来实现。
+
+```kotlin
+val nullableList: List<Int?> = listOf(1, 2, null, 4)
+val intList: List<Int> = nullableList.filterNotNull()
+```
+
+
+
+### 使用类型检测及自动类型转换
+
+`is`运算符检测一个表达式是否某类型的一个实例。 如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，在大多数情况下，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
+}
+```
+
+
+
+只要编译器能够保证在介于判断对象类型和被使用之间不能修改变量，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`:    
+
+```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`有三种结构化跳转表达式:    
+
+- `return`:默认从最直接包围它的函数或者匿名函数返回。
+- `break`:终止最直接包围它的循环。
+- `continue`:继续下一次最直接包围它的循环。
+
+在`Kotlin`中任何表达式都可以用标签`label`来标记。标签的格式为标识符后跟`@`符号，例如:`abc@`、`fooBar@`都是有效的标签。
+
+要为一个表达式加标签，我们只要在其前加标签即可。
+
+```kotlin
+loop@ for (i in 1..100) {
+    for (j in 1..100) {
+        if (……) break@loop
+    }
+}
+```
+
+
+- [上一篇: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)
+
+
+---
+
+- 邮箱 ：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..159e419a
--- /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,265 @@
+4.Kotlin_表达式&关键字
+===
+
+## `if`表达式
+
+在`Kotlin`中，`if`是一个表达式，即它会返回一个值，每个条件分支都隐式地返回其最后一行的表达式的结果，因此无需使用return关键字。因此就不需要三元运算符`条件 ? 然后 : 否则`，因为普通的`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 }`关键字后跟一个名称。对象表达式：在要创建一个继承自某个(或某些)类型的匿名类的对象会用到
+
+
+
+### 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)    
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
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"
new file mode 100644
index 00000000..7f4030b1
--- /dev/null
+++ "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"
@@ -0,0 +1,1074 @@
+5.Kotlin_内部类&密封类&枚举&委托
+===
+
+
+### 泛型   
+
+```kotlin
+class Data<T>(var t : T)
+interface Data<T>
+fun <T> logic(t : T){}
+```
+
+
+定义:  
+
+```kotlin
+class TypedClass<T>(parameter: T) {
+    val value: T = parameter
+}
+```
+这个类现在可以使用任何的类型初始化，并且参数也会使用定义的类型，我们可以这么做：
+```kotlin
+val t1 = TypedClass<String>("Hello World!")
+val t2 = TypedClass<Int>(25)
+```
+但是Kotlin很简单并且缩减了模版代码，所以如果编译器能够推断参数的类型，我们甚至也就不需要去指定它：
+```kotlin
+val t1 = TypedClass("Hello World!")
+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)
+```
+而经过刚才的封装之后，我们就无法进行传参了。这个问题也不难解决，只需要借助之前学习的高阶函数就可以轻松搞定。回到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的代码写起来实在是太舒服了，泛型实化和高阶函数使这种语法结构成为了可能.
+
+
+
+##### 类型擦除 
+
+```kotlin
+class Data<T>{}
+
+Log.d("test", Data<Int>().javaClass.name)
+Log.d("test", Data<String>().javaClass.name)
+
+// 输出
+com.study.jcking.weatherkotlin.exec.Data
+com.study.jcking.weatherkotlin.exec.Data
+```
+声明了一个泛型类`Data<T>`，并实现了两种不同类型的实例。但是在获取类名是，却发现得到了同样的结果
+`com.study.jcking.weatherkotlin.exec.Data`，这其实是在编译期擦除了泛型类型声明。
+
+
+
+
+
+### 嵌套类
+
+嵌套类顾名思义，就是嵌套在其他类中的类。而嵌套类外部的类一般被称为包装类或者外部类。
+```kotlin
+class Outter{
+    class Nested{
+        fun execute(){
+            Log.d("test", "Nested -> execute")
+        }
+    }
+}
+
+// 调用
+Outter.Nested().execute()
+
+//输出
+Nested -> execute
+```
+嵌套类可以直接创建实例，方式是包装类.嵌套类
+`val nested : Outter.Nested()`
+
+### 内部类   
+
+内部类和嵌套类有些类似，不同点是内部类用关键字`inner`修饰。
+
+```kotlin
+class Outter{
+    val testVal = "test"
+    inner class Inner{
+        fun execute(){
+            Log.d("test", "Inner -> execute : can read testVal=$testVal")
+        }
+    }
+}
+
+// 调用
+val outter = Outter()
+outter.Inner().execute()
+
+var v = this@Outer.testVal // 引用外部类的成员
+
+// 输出
+Inner -> execute : can read testVal=test
+```
+
+内部类不能直接创建实例，需要通过外部类调用
+```kotlin
+val outter = Outter()
+outter.Inner().execute()
+```
+
+引用外部类中对象的方式为: var 变量名 = this@外部类名
+
+在类成员中，this指代该类的当前对象。而在扩展函数或者带接受者的函数中，this表示在点左侧传递的接收者参数。   
+
+
+#### 内部类vs嵌套类
+
+在Java中，我们通过在内部类的语法上增加一个static关键词，把它变成一个嵌套类。然而，Kotlin则是相反的思路，默认是一个嵌套类，
+必须加上inner关键字才是一个内部类，也就是说可以把静态的内部类看成嵌套类。
+
+内部类和嵌套类有明显的差别，具体体现在：
+
+- 嵌套类相当于Java中的静态内部类，不能使用外部类的this。
+- 内部类必须以inner class定义，相当于Java中的私有非静态内部类，可以访问外部类的this。
+- 内部类包含着对其外部类实例的引用，在内部类中我们可以使用外部类中的属性。而在嵌套类中不包含对其外部类实例的引用，所以它无法调用其外部类的属性。
+
+
+
+#### 匿名内部类
+
+没有名字的内部类被称为匿名内部类，使用匿名内部类必须继承一个父类或实现一个接口，匿名内部类可以简化代码编写。
+
+```kotlin
+// 通过对象表达式来创建匿名内部类的对象，可以避免重写抽象类的子类和接口的实现类，这和Java中匿名内部类的是接口和抽象类的延伸一致。
+text.setOnClickListener(object : View.OnClickListener{
+    override fun onClick(p0: View?) {
+        Log.d("test", p0.string())
+    }
+})
+
+或
+mViewPager.addOnPageChangeListener(object : ViewPager.OnPageChangeListener {
+    override fun onPageScrollStateChanged(state: Int) {
+        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+    override fun onPageScrolled(position: Int, positionOffset: Float, positionOffsetPixels: Int) {
+        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+    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")
+}
+```
+
+
+
+### 枚举
+
+与Java中的enum语法大体类似，无非多了一个class关键字，表示它是一个枚举类。
+
+```kotlin
+enum class Day {
+    SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
+    THURSDAY, FRIDAY, SATURDAY
+}
+```
+不过Kotlin中的枚举类当然没有那么简单，由于它是一种类，我们可以猜测它自然应该可以拥有构造函数，以及定义额外的属性和方法。
+
+```kotlin
+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
+    }
+}
+
+```
+枚举可以通过`String`匹配名字来获取，我们也可以获取包含所有枚举的`Array`，所以我们可以遍历它。
+```kotlin
+val search: DayOfWeek = DayOfWeek.valueOf("MON")
+val iconList: Array<DayOfWeek> = DayOfWeek.values()
+```
+而且每一个枚举都有一些函数来获取它的名字、声明的位置:    
+```kotlin
+val searchName: String = Icon.SEARCH.name()
+val searchPosition: Int = Icon.SEARCH.ordinal()
+```
+
+
+
+枚举可以让你创建受限制的一组值，但在某些情况下，你需要更多的灵活性。假设你希望能在应用程序中使用两种不同的消息类型：一种用于”成功“，另一种用于”失败“，并且你希望能够将邮件限制为这两种类型。
+
+如果你用枚举类对此进行建模，代码会如下:  
+
+```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 {
+    open fun fly() = "I can fly"
+    class Eagle : Bird()
+}
+```
+
+这一点可以从它转换后的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);
+        }
+    }
+}
+
+```
+
+
+密封类用来表示受限的类继承结构: 当一个值为有限几种的类型、而不能有任何其他类型时。       
+在某种意义上，他们是枚举类的扩展:枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。
+
+虽然密封类也可以有子类，但是所有子类都必须在与密封类自身相同的文件中声明。(在`Kotlin 1.1`之前，该规则更加严格:子类必须嵌套在密封类声明的内部)。
+
+```kotlin
+sealed class Expr
+data class Const(val number: Double) : Expr()
+data class Sum(val e1: Expr, val e2: Expr) : Expr()
+object NotANumber : Expr()
+
+fun eval(expr: Expr): Double = when (expr) {
+    is Const -> expr.number
+    is Sum -> eval(expr.e1) + eval(expr.e2)
+    NotANumber -> Double.NaN
+}
+```
+
+使用密封类的关键好处在于使用`when`表达式的时候，如果能够
+验证语句覆盖了所有情况，就不需要为该语句再添加一个`else`语句了。
+
+```kotlin
+fun eval(expr: Expr): Double = when(expr) {
+    is Expr.Const -> expr.number
+    is Expr.Sum -> eval(expr.e1) + eval(expr.e2)
+    Expr.NotANumber -> Double.NaN
+    // 不再需要 `else` 子句，因为我们已经覆盖了所有的情况
+}
+```
+
+### 异常    
+
+在`Kotlin`中，所有的`Exception`都是实现了`Throwable`，含有一个`message`且未经检查。这表示我们不会强迫我们在任何地方使用`try/catch`。       
+这与`Java`中不太一样，比如在抛出`IOException`的方法，我们需要使用`try-catch`包围代码块。但是通过检查`exception`来处理显示并不是一个
+好的方法。
+
+抛出异常的方式与`Java`很类似：
+```kotlin
+throw MyException("Exception message")
+```
+
+`try`表达式也是相同的：
+```kotlin
+try{
+    // 一些代码
+} catch (e: SomeException) {
+    // 处理
+} finally {
+    // 可选的finally块
+}
+```
+在`Kotlin`中，`throw`和`try`都是表达式，这意味着它们可以被赋值给一个变量。这个在处理一些边界问题的时候确实非常有用:   
+```kotlin
+val s = when(x){
+    is Int -> "Int instance"
+    is String -> "String instance"
+    else -> throw UnsupportedOperationException("Not valid type")
+}
+```
+或者
+```kotlin
+val s = try { x as String } catch(e: ClassCastException) { null }
+```
+
+### 对象`(Object)`
+
+在Java中，static是非常重要的特性，它可以用来修饰类、方法或属性。然而static修饰的内容都属于类的，而不是某个具体对象的，
+但在定义时却与普通的变量和方法混杂在一起，显得格格不入。 
+
+在Kotlin中，你将告别static这种语法，因为它引入了全新的关键字object，可以完美的代替使用static的所有场景。
+当然除了代替static的场景之外，它还能实现更多的功能，比如单例对象及简化匿名表达式等。 
+
+声明对象就如同声明一个类，你只需要用保留字`object`替代`class`，其他都相同。只需要考虑到对象不能有构造函数，因为我们不调用任何构造函数来访问它们。      
+事实上，对象就是具有单一实现的数据类型。object声明的内容可以看成没有构造方法的类，它会在系统或者类加载时进行初始化。
+
+```kotlin
+object Resource {
+    val name = "Name"
+}
+```
+
+
+Kotlin中除了object之外还有一个companion object，也可以替代Java中的static关键字，那他俩有什么区别呢？  
+
+
+#### Companion object
+
+- 必须在一个类中定义      
+- companion object会在类第一次加载的时候就创建好，这就意味着我们可能还没使用的时候就初始化好了
+- 它等同于Java中的static     
+- 如果我们不手动指定名字的话会有一个默认的Companion的名字      
+- 在调用方法或变量的时候可以省略名字
+
+#### object
+
+- 可以被定义到任何地方      
+- 在我们第一次使用它时才会创建。      
+- 主要被用作提供单例行为       
+- 必须提供一个命名          
+- 如果在一个类中定义object，那在调用方法或者变量的时候不能省略名字  
+
+
+### 对象表达式
+
+对象也能用于创建匿名类实现。
+
+```kotlin
+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表达式更适合。
+
+#### 伴生对象
+
+先看一个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使用伴生对象来实现Java静态的效果，但不能说伴生就是静态。   
+
+现在将上面的例子改写成伴生对象的版本:   
+
+```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)
+        val commonPrize = Prize.defaultCommonPrize()
+    }
+}
+```
+
+总的来说，伴生对象是Kotlin中用来代替static关键字的一种方式，任何在Java类内部用static定义的内容都可以用Kotlin中的伴生对象来实现。
+然而，他们是类似的，一个类的伴生对象跟一个静态类一样，全局只能有一个。
+
+每个类都可以实现一个伴生对象，它是该类的所有实例共有的对象。它将类似于`Java`中的静态字段。
+```java
+class App : Application() {
+    companion object {
+         private lateinit var instance: App
+     }
+ 
+     override fun onCreate() {
+         super.onCreate()
+         instance = this
+    }
+}
+```
+
+在这例子中，创建一个继承`Application`的类，并且在`companion object`中存储它的唯一实例。     
+`lateinit`表示这个属性开始是没有值的，但是，在使用前将被赋值（否则，就会抛出异常）。     
+
+
+不过，上面companion object中的isRedpack()方法其实也并不是静态方法，companion object这个关键字实际上会在类的内部创建一个伴生类，而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()的写法来调用就可以了。
+
+
+### 单例
+
+因为一个类的伴生对象跟一个静态类一样，全局只能有一个。这让我们联想到了什么？ 没错，就是单例对象。
+
+```kotlin
+object Resource {
+    val name = "Name"
+}
+```
+
+因为对象就是具有单一实现的数据类型，所以在`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)
+
+### 委托(代理)
+
+委托，也就是委托模式，它是23中经典设计模式中的一种，又名代理模式，在委托模式中，有2个对象参与同一个请求的处理，接受请求的对象将请求委托给另一个对象来处理。
+
+委托模式中，有三个角色： 
+
+- 约束
+
+    约束是接口或抽象类，它定义了通用的业务类型，也就是需要被代理的业务
+
+- 委托对象
+
+    将约束定义的业务委托给别人
+
+- 被委托对象
+
+    具体的业务逻辑执行者
+
+
+
+##### 类委托
+
+在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。
+`kotlin`中的委托可以算是对委托模式的官方支持。    
+`Kotlin`直接支持委托模式，更加优雅，简洁。`Kotlin`通过关键字`by`实现委托。
+
+委托模式已被证明是类继承模式的一种很好的替代方案。
+
+我们经常会打游戏进行升级，但是有时候因为我们的水平不行，没法升到很高的级别，这就出现了很多的游戏代练，他们帮我们代打，这就是一个委托模式： 
+
+1. 定义约束类，定义具体需要委托的业务，这里的业务: 
+
+    ```kotlin
+    interface IGamePlayer {
+        fun upgrade()
+    }
+    ```
+
+2. 定义被委托对象，也就是游戏代练: 
+
+    ```kotlin
+    class RealGamePlayer(private val name: String): IGamePlayer {
+        override fun upgrade() {
+            println("$name up up up")
+        }
+    }
+    ```
+
+3. 定义委托对象
+
+    ```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
+    ```
+
+    
+
+##### 属性委托
+
+在软件的开发中，属性的getter和setter方法的代码有很多相同或相似的地方，虽然为每个类编写相同的代码是可行的，但这样会造成大量的代码冗余，而委托属性正是为解决这一问题而提出的。  
+
+属性委托是指一个类的某个属性值不是在类中直接定义，而是将其委托给一个代理类，从而实现对该类属性的统一管理。  
+
+在Kotlin中，有一些常见的属性类型，虽然我们可以在每次需要的时候手动实现他们，但是很麻烦，为了解决这些问题，Kotlin标准提供了委托属性。
+
+语法是`val/var <属性名>: <类型> by <表达式>`。在`by`后面的表达式是该委托，因为属性对应的`get()`和`set()`会被委托给它的`getValue()`
+和`setValue()`方法。 属性的委托不必实现任何的接口，但是需要提供一个`getValue()`函数（和`setValue()`——对于`var`属性）。
+
+```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"
+    }
+
+    operator fun setValue(ref: Any?, p: KProperty<*>, value: String) {
+        temp = value
+    }
+}
+
+fun test(){
+    val e = Example()
+    Log.d(JTAG, e.property)
+    e.property = "new"
+    Log.d(JTAG, e.property)
+}
+
+// 输出
+DelegateProperty --> property --> old
+DelegateProperty --> property --> new
+```
+
+像上面的`DelegateProperty`这样，被一个属性委托的类，我叫它被委托类，委托它的属性叫委托属性。其中:   
+
+- 如果委托属性是只读属性即`val`，则被委托类需要实现`getValue`方法
+- 如果委托属性是可变属性即`var`，则被委托类需要实现`getValue`方法和`setValue`方法
+- `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`通过属性委托的方式在Kotlin标准库中内置了很多工厂方法来实现属性委托，包括:   
+
+- 延迟属性`lazy properties`
+- 可观察属性`observable properties`
+- `map`映射
+
+##### 延迟属性
+
+延迟属性我们应该不陌生，也就是通常说的懒汉，在定义的时候不进行初始化，把初始化的工作延迟到第一次调用的时候。`kotlin`中实现延迟属性很简单，
+来看一下。
+
+lazy()是一个接收Lambda表达式作为参数并返回一个Lazy<T>实例的函数，返回的实例可以作为实现延迟属性的委托。   
+也就是说，延迟属性第一次调用get()时，将会执行传递给lazy()函数的Lambda表达式并记录执行结果，后续所有对get()的调用只会返回记录的结果。   
+
+```kotlin
+val lazyValue: String by lazy {
+    Log.d(JTAG, "Just run when first being used")
+    "value"
+}
+
+fun test(){
+    Log.d(JTAG, lazyValue)
+    Log.d(JTAG, lazyValue)
+}
+
+// 输出
+Just run when first being used
+value
+value
+```
+可以看到，只有第一次调用了`lazy`里的日志输出，说明`lazy`方法块只有第一次执行了。按照个人理解，上面的`lazy`模块可以这么翻译:    
+```kotlin
+String lazyValue;
+String getLazyValue(){
+    if(lazyValue == null){
+        Log.d(JTAG, "Just run when first being used");
+        lazyValue = "value";
+    }
+    return lazyValue;
+}
+
+void test(){
+    Log.d(JTAG, getLazyValue());
+    Log.d(JTAG, getLazyValue());
+}
+```
+
+`lazy`延迟初始化是可以接受参数的，提供了如下三个参数: 
+
+- `LazyThreadSafetyMode.SYNCHRONIZED`: 添加同步锁，使`lazy`延迟初始化线程安全
+- `LazyThreadSafetyMode.PUBLICATION`： 初始化的`lambda`表达式可以在同一时间被多次调用，但是只有第一个返回的值作为初始化的值。
+- `LazyThreadSafetyMode.NONE`：没有同步锁，多线程访问时候，初始化的值是未知的，非线程安全，一般情况下，不推荐使用这种方式，除非你能保证初始化和属性始终在同一个线程
+
+如果你指定的参数为`LazyThreadSafetyMode.SYNCHRONIZED`,则可以省略，因为`lazy`默认就是使用的`LazyThreadSafetyMode.SYNCHRONIZED`。
+
+
+
+那么学习了Kotlin的委托功能之后，我们就可以对by lazy的工作原理进行解密了，它的基本语法结构如下: 
+```kotlin
+val p by lazy { ... }
+```
+现在再来看这段代码，是不是觉得更有头绪了呢？实际上，by lazy并不是连在一起的关键字，只有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函数
+
+
+
+##### 可观察属性
+
+
+所谓可观察属性(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):
+        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")
+    }
+
+    var gender: Int by Delegates.vetoable(0) {
+        prop, old, new -> (old < new)
+    }
+}
+
+fun test(){
+    val user = User()
+    user.name = 2    // 输出 0 -> 2        
+    user.name = 1   // 输出 2 -> 1    
+
+    user.gender = 2
+    Log.d(JTAG, user.gender.string())   // 输出 2
+    user.gender = 1
+    Log.d(JTAG, user.gender.string())   // 输出 2
+}
+```
+`Delegates.observable()`接受两个参数:初始值和修改时处理程序`handler`。 每当我们给属性赋值时会调用该处理程序（在赋值后执行）。
+它有三个参数：被赋值的属性、旧值和新值。在上面的例子中，我们对`user.name`赋值，`set`变化触发了观察者，执行了`Log.d`代码段。
+
+除了`Delegates.observable()`之外，我们还把`gender`委托给了`Delegates.vetoable()`,和`observable`不同的是，`observable`是执行了
+`set`变化之后，才触发`observable`,而`vetoable`则是在`set`执行之前被触发，它返回一个`Boolean`，如果为`true`才会继续执行`set`。
+在上面的例子中，我们看到在第一次赋值`user.gender = 2`时，由于`2>0`，所以`old<new`判断成立，所以执行了`set`方法，`gender`为2,
+第二次赋值`user.gender = 1`则没有通过判断，所以`gender`依然为2。   
+
+`vetoable` 与 `observable`一样，可以观察属性值的变化，不同的是，`vetoable`可以通过`处理器函数来决定属性值是否生效`。
+
+如声明一个Int类型的属性`vetoableProp`，如果新的值比旧值大，则生效，否则不生效。
+
+
+
+
+##### map委托
+
+Map委托常常用来将Map中的key-value映射到对象的属性中，这经常出现在解析JSON或者其他动态事情的应用中。 
+
+
+```kotlin
+class User(val map: Map<String, Any?>) {
+    val name: String by map
+    val age: Int     by map
+}
+// 在这个例子中，构造函数接受一个映射参数
+val user = User(mapOf(
+    "name" to "John Doe",
+    "age"  to 25
+))
+委托属性会从这个映射中取值（通过字符串键——属性的名称）
+println(user.name) // Prints "John Doe"
+println(user.age)  // Prints 25
+这也适用于var属性，如果把只读的Map换成MutableMap的话
+class MutableUser(val map: MutableMap<String, Any?>) {
+    var name: String by map
+    var age: Int     by map
+}
+```
+
+委托在kotlin中占有举足轻重的地位，特别是属性委托，lazy延迟初始化使用非常多，还有其他一些场景，比如在我们安卓开发中，使用属性委托来封装`SharePreference`，大大简化了`SharePreference`的存储和访问。在我们软件开发中，始终提倡的是高内聚，低耦合。而委托，就是内聚，可以降低耦合。另一方面，委托的使用，也能减少很多重复的样板代码。
+
+
+
+委托模式是一种被广泛使用的设计模式，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)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
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..bd8ca990
--- /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,199 @@
+6.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的能力，更加直观，虽然背后也是通过委托对象来执行具体的方法逻辑的。
+
+
+
+
+
+
+
+
+
+
+- [上一篇: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)
+
+
+---
+
+- 邮箱 ：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..a800a8d3
--- /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,1227 @@
+7.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`中称之为`Top Level`。
+扩展函数表现得就像是属于这个类的一样，而且我们可以使用`this`关键字和调用所有`public`方法。扩展函数定义形式:
+```kotlin
+fun receiverType.functionName(params){
+    body
+}
+receiverType：表示函数的接收者，也就是函数扩展的对象
+functionName：扩展函数的名称
+params：扩展函数的参数，可以为NULL
+```
+
+```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`中将它作为普通方法来直接调用。其中`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文件中，但不允许定义在函数中。 因为扩展属性不能有初始化器，所以只能由显式提供的getter/setter定义，而且扩展属性只能被声明为val。
+
+
+##### 静态扩展
+
+`kotlin`中的静态用关键字`companion`表示，但是它不是修饰属性或方法，而是定义一个方法块，在方法块中的所有方法和属性都是静态的，
+这样就将静态部分统一包装了起来。静态部分的访问和`java`一致，直接使用类名+静态属性/方法名调用。   
+
+```kotlin
+// 定义静态部分
+class Extension {
+    companion object{
+        var name = "Extension"
+    }
+}
+
+// 通过类名+属性名直接调用
+toast("hello, ${Extension.name}")
+
+// 输出
+Toast msg : hello, Extension
+```
+
+静态的扩展和普通的扩展类似，但是在目标类要加上静态方法块的名称，所以如果我们要对一个静态部分扩展，就要先知道静态方法块的名称才行。
+
+```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
+```
+上面例子中，`companion object`一起是修饰关键字，`part`是方法块的名称。其中方法块名称`part`可以省略，如果省略的话，默认缺省名为
+`Companion`
+
+
+
+#### 标准库中的扩展函数
+
+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                                    
+        }
+    }
+}
+```
+
+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`
+
+```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函数接收两个参数：第一个参数可以是一个任意类型的对象，第二个参数是一个Lambda表达式。with函数会在Lambda表达式中提供第一个参数对象的上下文，并使用Lambda表达式中的最后一行代码作为返回值返回。
+
+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
+```
+
+### 调度方式对扩展函数的影响
+
+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()
+可以在类中，对同一运算符进行多次重载，来满足不同的需求。
+
+运算符重载实际上是函数重载，本质上是对运算符函数的调用，从运算符到对应函数的映射过程由编译器完成，或者理解成是对已有的运算符赋予他们新的含义。
+
+举例： 
+
+比如我们的+号，它的含义是两个数值相加： 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
+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`注解。
+
+
+### 泛型
+
+通配符类型参数 `? extends E`表示该方法接收E类型或者E类型的一些子类型，而不仅仅是E类型本身。
+Kotlin抛弃了通配符类型这一概念，转而引入了生产者和消费者的概念，其中，生产者表示那些只能读取数据的对象，使用表达式`out T`标记。    
+消费者表示那些只能写入数据的对象，使用表达式`in T`标记。      
+为了便于理解，可以简单的将`out T`理解为`? exnteds T`，将`in T`理解为`? super T`。 
+
+
+
+- [上一篇: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)
+
+
+---
+
+- 邮箱 ：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..2c319266
--- /dev/null
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -0,0 +1,1050 @@
+8.Kotlin_协程
+===
+
+协程并不是Kotlin提出来的概念，其他的一些编程语言，例如Go、Python等都可以在语言层面上实现协程，甚至是Java，也可以通过使用扩展库来间接的支持协程。
+
+Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它我们可以避免在异步编程中使用大量的回调，同时相比传统多线程技术，它更容易提升系统的高并发处理能力。 
+
+
+协程(coroutine)，又称微线程，是一种无优先级的子程序调度组件，由协程构建器(coroutine builder)启动。 
+
+协程本质上是一种用户态的轻量级线程
+
+## 起源
+
+线程是由操作系统来进行调度的，当操作系统切换线程的时候，会产生一定的消耗。而协程不一样，协程是包含于线程的，也就是说协程
+是工作在线程之上的，协程的切换可以由程序自己来控制，不需要操作系统进行调度。这样的话就大大降低了开销。
+
+
+
+协程就像一个轻量级的线程在幕后，启动协程就像启动一个单独的执行线程。线程在其他语言中很常见，例如Java，协程和线程可以并行运行，并互相通信。然而，不同点在于使用协程比使用线程更加高效。在性能方面，启动一个线程并使其保持运行是非常昂贵的。    
+
+处理器通常只能同时运行有限数量的线程，并且运行尽可能少的线程会更高效。     
+
+而另一方面，协程默认运行在共享的线程池中，同一个线程可以运行多个协程。由于使用的线程较少，当你想要运行异步任务时，使用协程会更加高效。
+
+**也就是说本质上Kotlin协程就是创建了一个可以复用的线程池，并且协程的delay是一个特殊的挂起函数，它不会造成线程堵塞，但是会挂起协程，并且只能在协程中使用。**    
+
+协程是语言层面的东西，线程是系统层面的东西。    
+协程就是一段代码块，既然是代码那就离不开CPU的执行，而CPU调度的基本单位是线程。    
+
+可以说，只要内存足够，一个线程中可以包含任意多个协程，但某一时刻却只能有一个协程在运行，多个协程分享该线程资源。   
+
+## 进程、线程、协程
+
+- 进程：一段程序的执行过程，资源分配和调度的基本单位，有其独立地址空间，互相之间不发生干扰      
+- 线程：轻量级进程，资源调度的最小单位，共享父进程地址空间和资源，其调度和进程一样要切换到内核态     
+- 并行：同时发生，在多核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 的协程就是一个封装在线程上面的线程框架。
+
+它有两个非常关键的亮点：
+
+- 耗时函数自动后台，从而提高性能；
+- 线程的「自动切回」
+
+所以，Kotlin 的协程在 Android 开发上的核心好处就是：消除回调地域。
+
+线程操作需要VM或OS的支持，通过CPU调度来执行生效。   
+而协程主要通过编译技术来实现，通过参入代码来生效，不需要VM或OS的额外支持。   
+
+简单来说，协程是编译器级的，而线程是操作系统级的。   
+
+协程运行在同一个线程上，没有上下文切换。 
+和线程不同，协程有多个入口点，可以在指定的位置挂起和恢复执行，而线程通常只有一个入口点，且只能返回一次。       
+其次，协程不需要多线程的锁机制，因为协程只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不需要加锁，只需要判断状态即可，因此执行效率比多线程高很多。   
+另外，使用协程后，不再需要像异步编程时那样写很多回调函数，代码结构不再支离破碎，整个代码逻辑看上去和同步代码没有什么区别，代码结构更加优雅简洁。   
+
+
+## 使用
+
+如需在 Android 项目中使用协程，请将以下依赖项添加到应用的build.gradle文件中：
+
+```groovy
+dependencies {
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9'
+}
+```
+
+## 示例
+
+在代码中，我们使用GlobalScope.launch在后台运行一个新的协程。在幕后，它创建了一个新的线程使协程在其中运行，
+
+```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中启动了一个新的协程，这意味着新协程的生命周期只受整个应用程序的生命周期限制。
+
+
+
+使用runBlocking在相同作用域内运行协程如果希望代码在相同线程、不同协程中运行，你可以使用runBlocking函数。runBlocking是一个高阶函数，它会阻塞当前线程，直到传入其中的代码运行完成。runBlocking函数定义了一个作用域，传入其中的代码继承该作用域。在本例中，我们可以使用该作用域在同一线程中运行不同的协程。
+
+
+
+delay函数暂停当前协程在这种情况下，更好的解决方案是使用协程的delay函数取而代之。该函数与Thread.sleep有相似的效果，除了它会暂停当前协程而不是当前线程。它将协程挂起指定的时长，这允许运行该线程中的其他代码。delay函数可用于以下两种情况：
+
+- 在协程中使用。
+- 在某个编译器知道将会暂停或挂起的函数中使用，在函数中调用可挂起的函数时（例如delay），该函数必须被标记为suspend。
+
+例如，以下代码将协程延迟1秒：
+
+```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 挂起
+
+基本上，协程计算可以被挂起而无需阻塞线程。线程阻塞的代价通常是昂贵的，尤其在高负载时，因为只有相对少量线程实际可用，因此阻塞其中一个会导致一些
+重要的任务被延迟。
+
+另一方面，协程挂起几乎是无代价的。不需要上下文切换或者`OS`的任何其他干预。最重要的是，挂起可以在很大程度上由用户库控制:   
+作为库的作者，我们可以决定挂起时发生什么并根据需求优化/记日志/截获。
+
+另一个区别是，协程不能在随机的指令中挂起，而只能在所谓的挂起点挂起，这会调用特别标记的函数。
+
+
+
+对于回调式的写法，如果并发场景再复杂一些，代码的嵌套可能会更多，这样的话维护起来就非常麻烦。但如果你使用了 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`的函数时，会发生挂起:    
+
+```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()
+    ……
+}
+
+```
+
+
+请注意，挂起函数`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
+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!")
+```
+
+### 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闭包中的调用也将取消停止。
+
+
+
+### RxJava与协程
+
+异步就是同时进行一个以上彼此目的不同的任务。但是对于有前后依赖关系的任务，我们就需要利用异步中的回调机制处理。而异步回调机制又会导致代码结构过分耦合，遇到多重函数回调的嵌套耦合，也就是回调地狱，会导致代码难以维护。而解决回调地狱的方案就是链式调用结构。很自然想到使用RxJava来解决回调地狱，它确实可以很方便地解决上面的问题。
+
+RxJava，准确来讲是 ReactiveX 在 Java 上的实现，是一种响应式程序框架，我们通过它提供的「Observable」的编程范式进行链式调用，可以很好地消除回调。但是RxJava中流的创建、转化与消费都需要使用到各种类和丰富的操作符，这加大了RxJava的学习成本，因为你无法保证团队里面每一个成员都能看懂它。
+
+使用协程，同样可以像 Rx 那样有效地消除回调地狱，不过无论是设计理念，还是代码风格，两者是有很大区别的，协程在写法上和普通的顺序代码类似。在串行的执行中，虽然代码确实是顺序执行的，但其实是在不同的线程上顺序执行的。因为串行的执行中，执行是阻塞式的，主线程的阻塞会导致很严重的问题，所以所有的耗时操作不能在主线程中执行，所以就需要多线程并行来执行。在并行的执行中，异步回调其实就是代码的多线程顺序执行。
+ 那能不能既按照顺序的方式编写代码，又可以让代码在不同的线程顺序执行，自动完成线程的切换工作呢？
+
+那就是Kotlin协程。
+Kotlin 的协程是一种无栈协程的实现，它的控制流转依靠对协程体本身编译生成的状态机的状态流转来实现，变量保存也是通过闭包语法来实现的。异步回调就是代码的多线程顺序执行，而Kotlin协程可以实现顺序编写异步代码，自动进行线程切换。
+
+
+
+没法比较RxJava和协程哪个好，或者谁能取代谁，因为Rx和协程的设计思想本来就不同。
+
+
+
+
+
+- [上一篇: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)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git a/KotlinCourse/9.Kotlin_androidktx.md b/KotlinCourse/9.Kotlin_androidktx.md
new file mode 100644
index 00000000..5316334e
--- /dev/null
+++ b/KotlinCourse/9.Kotlin_androidktx.md
@@ -0,0 +1,108 @@
+9.Kotlin_androidktx
+===
+
+相信每一位安卓开发人员对`findViewById()`这个方法再熟悉不过了，毫无疑问，潜在的`bug`和脏乱的代码令后续开发无从下手的。 尽管存在一系列的
+开源库能够为这个问题带来解决方案，然而对于运行时依赖的库，需要为每一个`View`注解变量字段。
+
+现在`Kotlin`安卓扩展插件能够提供与这些开源库功能相同的体验，不需要添加任何额外代码，也不影响任何运行时体验。
+另一个`Kotlin`团队研发的可以让开发更简单的插件是`Kotlin Android Extensions`。当前仅仅包括了`view`的绑定。这个插件自动创建了很多的属性
+来让我们直接访问`XML`中的`view`。这种方式不需要你在开始使用之前明确地从布局中去找到这些`views`。
+
+这些属性的名字就是来自对应`view`的`id`，所以我们取`id`的时候要十分小心，因为它们将会是我们类中非常重要的一部分。这些属性的类型也是来自
+`XML`中的，所以我们不需要去进行额外的类型转换。
+
+`Kotlin Android Extensions`的一个优点是它不需要在我们的代码中依赖其它额外的库。它仅仅由插件组层，需要时用于生成工作所需的代码，只需要依赖
+于`Kotlin`的标准库。
+
+开发者仅需要在模块的`build.gradle`文件中启用`Gradle`安卓扩展插件即可:   
+
+```
+apply plugin: 'kotlin-android-extensions'
+```
+
+我们在使用`Android Sutdio 3.0`创建`Kotlin`项目时默认已经添加了该依赖。   
+
+```kotlin
+// 使用来自主代码集的 R.layout.activity_main
+import kotlinx.android.synthetic.main.activity_main.*
+
+class MyActivity : Activity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+        textView.setText("Hello, world!")
+        // 而不是 findViewById(R.id.textView) as TextView
+    }
+}
+```
+`textView`是对`Activity`的一项扩展属性，与在`activity_main.xml`中的声明具有同样类型。
+
+这里，你肯定会想，虽然省略了R.id.几个字符，但是引入是否会造成性能问题？ 值得引入、使用 kotlin-android-extensions吗？如果我们对其反编译，就可以看到对应Java代码的实现，在第一次使用空间的时候，会在缓存集合中进行查找，有就直接使用，没有就通过findViewById进行查找，并添加到缓存的集合中。其还提供了$clearFindViewByIdCache()方法用于清除缓存，在我们想要彻底替换界面控件时可以使用。
+
+在Fragment的onDestroyView()方法中默认调用了$clearFindViewByIdCache()清除缓存，而Activity没有。
+
+所以我们并没有完全离开findViewById，只是Kotlin的扩展插件利用缓存的方式让我们开发更方便、更快捷。
+
+
+
+
+### 网络请求   
+
+
+`Kotlin`提供了一些扩展函数来执行网络请求，同时也可以使用第三方库来执行.     
+```kotlin
+public class Request(val url: String) {
+    public fun run() {
+        val forecastJsonStr = URL(url).readText()
+        Log.d(javaClass.simpleName, forecastJsonStr)
+    }
+}
+```
+
+如你所知，`HTTP`请求不被允许在主线程中执行，否则它会抛出异常。这是因为阻塞住`UI`线程是一个非常差的体验。`Android`中通用的做法是使用
+`AsyncTask`，但是这些类是非常丑陋的，并且使用它们无任何副作用地实现功能也是非常困难的。`Anko`提供了非常简单的`DSL`来处理异步任务，
+它满足大部分的需求。它提供了一个基本的`async`函数用于在其它线程执行代码，也可以选择通过调用`uiThread`的方式回到主线程。
+在子线程中执行请求如下这么简单:  
+```kotlin
+async() {
+    Request(url).run()
+    uiThread { longToast("Request performed") }
+}
+```
+`UIThread`有一个很不错的一点就是可以依赖于调用者。如果它是被一个`Activity`调用的，那么如果`activity.isFinishing()`返回`true`，
+则`uiThread`不会执行，这样就不会在`Activity`销毁的时候遇到崩溃的情况了。
+
+##### 解析`gson`
+
+`Kotlin`允许我们去定义一些行为与静态对象一样的对象。尽管这些对象可以用众所周知的模式来实现，比如容易实现的单例模式。
+我们需要一个类里面有一些静态的属性、常量或者函数，我们可以使用`companion objecvt`。这个对象被这个类的所有对象所共享，就像`Java`中的静态
+属性或者方法。
+```kotlin
+public class ForecastRequest(val zipCode: String) {
+    companion object {
+        private val APP_ID = "15646a06818f61f7b8d7823ca833e1ce"
+        private val URL = "http://api.openweathermap.org/data/2.5/" +
+                "forecast/daily?mode=json&units=metric&cnt=7"
+        private val COMPLETE_URL = "$URL&APPID=$APP_ID&q="
+    }
+    
+    fun execute(): ForecastResult {
+        val forecastJsonStr = URL(COMPLETE_URL + zipCode).readText()
+        return Gson().fromJson(forecastJsonStr, ForecastResult::class.java)
+    }
+}
+```
+
+
+
+
+- [上一篇: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)
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
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
new file mode 100644
index 00000000..0f9a7adf
--- /dev/null
+++ b/MobileAIModel/TensorFlow Lite	
@@ -0,0 +1,43 @@
+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在手机和嵌入设备上的一个轻量级框架。      
+
+主要特性:  
+
+- 通过解决以下 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 模型。在转换过程中，您可以应用量化等优化措施，以缩减模型大小和缩短延时，并最大限度降低或完全避免准确率损失。默认情况下，所有模型都不含元数据。
+
+
+
+
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中的一项常见任务。    
+
+该任务的目标是训练一个模型，为输入的文本分配标签或类别。从情感分析和意图识别，到实体提取和语言检测，文本分类在全球范围内被广泛应用
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"
new file mode 100644
index 00000000..ddfe2b25
--- /dev/null
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -0,0 +1,649 @@
+# 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来掌控。    
+那么，我们现在面临两个问题：    
+第一个问题是，操作系统到底是什么东西？    
+第二个问题是，操作系统到底操控什么事情？    
+我们先回答第一个问题。既然操作系统是掌控计算机局势的一个系统，自然很重要。但这个说法并不能帮助读者理解操作系统，也无法形成有形的概念。    
+如果我们换个说法：操作系统是介于计算机和应用软件之间的一个软件系统，则概念就具体多了。    
+从这个定义出发，我们知道操作系统的上面和下面都有别的对象存在：下面是硬件平台，上面是应用软件，现在回答第二个问题。我们知道操作系统代表的是掌控事情的系统，掌控什么事情呢？当然是计算机上或计算机里发生的一切事情。最原始的计算机并没有操作系统，而是直接由人来掌控事情，即所谓的单一控制终端、单一操作员模式。但是随着计算机复杂性的增长，人已经不能胜任直接掌控计算机了。于是我们编写出操作系统这个“软件”来掌控计算机，将人类从日益复杂的掌控任务中解脱出来。    
+这个掌控有着多层深远的意义。首先，由于计算机的功能和复杂性不断发生变化（趋向更加复杂），操作系统所掌控的事情也就越来越多，越来越复杂。同时，操作系统本身能够使用的资源也不断增多（如内存容量）。    
+这是早期驱动操作系统不断改善的根本原因。其次，既然操作系统是专门掌控计算机的，那么计算机上发生的所有事情自然需要操作系统的知晓和许可，未经操作系统同意的任何事情均视为非法的，也就是病毒和入侵攻击所试图运作的事情。作为操作系统的设计人员，我们当然要确保计算机不发生任何我们不知情或不同意的事情。但是人的能力是有限的，人的思维也是有缺陷的，我们设计出的系统自然不会十全十美，也会有缺陷，这就给了攻击者可乘之机。    
+操作系统设计人员和攻击者之间的博弈是当前驱动操作系统改善的一个重要动力。再次，掌控事情的水平有高低之分，有效率不同之分。就像手术大夫之间也有水平高低之分。为了更好地掌控事情，同时也为了更好地满足人类永不知足的各种越来越苛刻的要求，操作系统自然需要不断改善。这种改善在过去、现在和将来都会继续下去的。    
+最后，我们可以给操作系统下定义了：    
+操作系统是一个软件系统；    
+操作系统使计算机变得好用（将人类从繁琐、复杂的对机器掌控的任务中解脱）；    
+操作系统使计算机运作变得有序（操作系统掌控计算机上所有的事情）。    
+总结起来就是：操作系统是掌控计算机上所有事情的软件系统。
+
+
+作用:它可以帮我们管理计算机的各种资源，协助我们完成各种复杂繁琐的任务。
+
+### 操作系统三要素: 
+
+- 虚拟化（virtualization）    
+    操作系统将物理（physical）资源（如处理器、内存或磁盘）转换为更通用、更强大且更易于使用的虚拟形式。因此，我们有时将操作系统称为虚拟机（virtual machine）。    
+
+    当然，为了让用户可以告诉操作系统做什么，从而利用虚拟机的功能（如运行程序、分配内存或访问文件），操作系统还提供了一些接口（API），供你调用。实际上，典型的操作系统会提供几百个系统调用（system call），让应用程序调用。由于操作系统提供这些调用来运行程序、访问内存和设备，并进行其他相关操作，我们有时也会说操作系统为应用程序提供了一个标准库（standard library）。
+    
+    最后，因为虚拟化让许多程序运行（从而共享CPU），让许多程序可以同时访问自己的指令和数据（从而共享内存），让许多程序访问设备（从而共享磁盘等），所以操作系统有时被称为资源管理器（resource manager）。每个CPU、内存和磁盘都是系统的资源（resource），因此操作系统扮演的主要角色就是管理（manage）这些资源，以做到高效或公平，或者实际上考虑其他许多可能的目标。
+    
+    - 进程，它是虚拟化的CPU；
+    - 地址空间，它是虚拟化的内存。
+
+- 并发（concurrency）     
+- 持久性（persistence）    
+    操作系统实际上做了什么：它取得CPU、内存或磁盘等物理资源（resources），并对它们进行虚拟化（virtualize）。它处理与并发（concurrency）有关的麻烦且棘手的问题。它持久地（persistently）存储文件，从而使它们长期安全
+
+操作系统也是一种软件，但是操作系统是一种非常复杂的软件。操作系统提供了几种抽象模型:    
+
+- 文件：对 I/O 设备的抽象
+- 虚拟内存：对程序存储器的抽象
+- 进程：对一个正在运行程序的抽象
+- 虚拟机：对整个操作系统的抽象
+
+
+### 以现代标准而言，一个标准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 盘设备，那计算机为啥能实时识别出这些设备呢？之后会有章节讨论一下这个话题。
+
+## 操作系统的基本特征
+
+并发和共享是操作系统的两个最基本的特征，它们又互为存在条件。一方面，资源共享是以程序（进程）的并发执行为条件的，若系统部允许程序并发执行，自然不存在资源共享问题。另一方面，若系统部能对资源共享实施有效管理，也必将影响程序的并发执行，甚至根本无法并发执行。
+
+## 计算机的组成
+
+### 计算机硬件
+
+计算机的硬件由大量的IC （Integrated Circuit，集成电路）组成。每块IC上都带有许多引脚。这些引脚有的用于输入，有的用于输出。
+
+从概念上讲，计算机的结构非常简单：    
+首先布置一根总线，然后将各种硬件设备挂在总线上。所有的这些设备都有一个控制设备，外部设备都由这些控制器与CPU通信。    
+而所有设备之间的通信均需通过总线，如果对总线做一个简单的概括，可以认为总线就是数字信号的集合，而这些信号被提供给计算机上的每块电路板： 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/computer_hardware.jpg?raw=true)        
+
+
+
+计算机由处理器、存储器和输入/输出部件组成，每类部件都有一个或多个模块。这些部件以某种方式互连，以实现计算机执行程序的主要功能。因此，计算机有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。
+
+
+
+不同的处理器和硬解系统可能会采用不同的策略，但是通用系统的启动分为三个步骤: 
+
+- 开机并执行bootloader程序
+
+    开机就是给系统开始供电，此时硬件电路会产生一个确定的复位时序，保证CPU是最后一个被复位的器件。为什么CPU要最后被复位呢？ 因为，如果CPU是第一个被复位，则当CPU复位后开始运行时，其他硬件内部的寄存器状态可能还没有准备好，比如磁盘或者内存，那这样就可能出现外围硬件初始化的错误。当正确完成复位后，CPU开始执行第一条指令，该指令所在的内存地址是固定的，这由CPU的制造者指定。不同的CPU可能会从不同的地址获取指令，但这个地址必须是固定的，这个固定的地址所保存的程序往往被称为“引导程序“（Bootloader），因为其作用是装载真正的用户程序。
+
+    至于如何装载，则是一个策略问题，不同的CPU会提供不同的装载方式，比如有的是通过普通的并口存储器，有的则是通过SD卡，但是无论硬件上使用何种接口装载，装载过程必须提供以下信息，具体包括： 
+
+    - 从哪里读取用户程序？
+    - 用户程序的长度是多少？
+    - 装载完用户程序后，应该跳转到哪里，即用户程序的执行入口在哪里？
+
+    机器在上电时自动把程序计数器设置为处理器厂商设计的某个固定值，对于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等。
+
+多数基于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)
+
+
+
+![](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本身是一个Native的应用程序，与驱动、内核等均无关系。Zygote最初的名字叫“app_process”，这个名字是在Android.mk文件中指定的，但在运行过程中，app_process通过Linux下的pctrl系统调用将自己的名字换成了“Zygote”，所以我们通过ps命令看到的进程名是“Zygote”。Zygote是在Android系统中创建Java世界的盘古，它创建了第一个Java虚拟机，同时它又是女娲，它成功地繁殖了framework的核心system_server进程。
+    Zygote进程主要包含：
+    - 创建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等服务，也就是说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至少运行在一个进程上。
+- 所有的App进程都是由Zygote进程fork生成的。
+
+ 
+
+## 虚拟化
+
+### 程序运行时会发生什么？
+
+- 首先，当然得进行编程，而编程需要计算机程序设计语言作为基础。对于绝大多数编写程序的人来说，使用的编程语言称为高级程序设计语言，如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速率相当，二级缓存次之。
+
+
+CPU“取值-解码-执行”的速度叫时钟速度，单位是赫兹，赫兹是用来表示频率的单位。1赫兹代表1秒1个周期。   
+为了驱动CPU运转，称为“时钟信号”的电信号必不可少。这种电信号就好像带有一个时钟，滴答滴答地每隔一定时间就变换一次电压的高低。输出时钟信号的元件叫作“时钟发生器”。时钟发生器中带有晶振，根据其自身的频率（振动的次数）产生时钟信号。时钟信号的频率可以衡量CPU的运转速度。这里使用的是2.5MHz（兆赫兹）的时钟发生器。最大时钟频率(maximum clock speed)，也称主频，是影响处理器速度的决定性因素之一。时钟频率决定了执行一条指令所需要的时间，处理器的数据位宽也影响处理器的速度。
+
+操作系统通过虚拟化（virtualizing）CPU来提供这种假象。通过让一个进程只运行一个时间片，然后切换到其他进程，操作系统提供了存在多个虚拟CPU的假象。这就是时分共享（time sharing）CPU技术，允许用户如愿运行多个并发进程。潜在的开销就是性能损失，因为如果CPU必须共享，每个进程的运行就会慢一点。
+要实现CPU的虚拟化，要实现得好，操作系统就需要一些低级机制以及一些高级智能。我们将低级机制称为机制（mechanism）。机制是一些低级方法或协议，实现了所需的功能。例如，我们稍后将学习如何实现上下文切换（context switch），它让操作系统能够停止运行一个程序，并开始在给定的CPU上运行另一个程序。所有现代操作系统都采用了这种分时机制。
+
+CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，各部分之间通过电信号连通。
+
+- `寄存器`是中央处理器内的组成部分。它们可以用来暂存指令、数据和地址。可以将其看作是内存的一种。根据种类的不同，一个 CPU 内部会有 20 - 100个寄存器。
+- `控制器`负责把内存上的指令、数据读入寄存器，并根据指令的结果控制计算机
+- `运算器`负责运算从内存中读入寄存器的数据
+- `时钟` 负责发出 CPU 开始计时的时钟信号
+
+
+**程序是把寄存器作为对象来描述的**
+
+使用高级语言编写的程序会在编译后转化成机器语言，然后通过CPU内部的寄存器来处理。不同类型的CPU，其内部寄存器的数量，种类以及寄存器存储的数值范围都是不同的。根据功能的不同，我们可以将寄存器大致划分为八类: 
+
+- ***累加寄存器简称累加器(Accumulator Register， AC)***：是一个通用寄存器。存储执行运算的数据和运算后的数据。
+- ***标志寄存器(Flag Register)***：存储运算处理后的CPU的状态。
+- ***程序计数器(Program Counter, PC)***：记录将要取出的指令的地址。存储下一条指令所在内存的地址。
+- ***基址寄存器(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)        
+
+
+
+### 计算机执行的原理是: 取指执行
+
+处理器执行的程序是由一组保存在存储器中的指令组成的。最简单的指令处理包括两步: 处理器从存储器中一次读(取)一条指令，然后执行每条指令。程序执行是由不断重复的取指令和执行指令的过程组成的。指令执行可能涉及很多操作，具体取决于指令本身。 
+
+在典型的处理器中，程序计数器(Program Counter, PC)保存下一次要取的指令地址。除非出现其它情况，否则处理器在每次取值令后总是递增PC，以便能按顺序取下一条指令(即位于下一个存储器地址的指令)。取到的指令放在处理器的一个寄存器中，这个寄存器称为指令寄存器(Instruction Register,IR)。指令中包含确定处理器将要执行的操作的位，处理器解释指令并执行对应的操作。大体上，这些动作可分为4类:  
+
+- 处理器-存储器:数据可以从处理器传送到存储器，或从存储器传送到处理器。
+- 处理器-I/O:通过处理器和I/O模块间的数据传送，数据可以输出到外部设备，或从外部设备向处理器输入数据。
+- 数据处理:处理器可以执行很多与数据相关的算术操作或逻辑操作。
+- 控制: 某些指令可以改变执行顺序。例如，处理器从地址为149的存储单元中取出一条指令，该指令指向下一条指令应该从地址为182的存储单元中取，这样处理器就会把程序计数器置为182.因此在下一个取指阶段，将从地址182的存储单元而非150的存储单元中取指令。 
+
+
+
+## CPU 指令执行过程
+
+那么CPU是如何执行一条条的指令的呢？
+
+几乎所有的冯·诺伊曼型计算机的CPU，其工作都可以分为5个阶段：**取指令、指令译码、执行指令、访存取数、结果写回**。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/cpu_process.jpg?raw=true)        
+
+- 取指令阶段是将内存中的指令读取到CPU中寄存器的过程，程序寄存器用于存储下一条指令所在的地址
+- 指令译码阶段，在取指令完成后，立马进入指令译码阶段，在指令译码阶段，指令译码器按照预定的指令格式，对取回的指令进行拆分和解释，识别区分出不同的指令类别以及各种获取操作数的方法。
+- 执行指令阶段，译码完成后，就需要执行这一条指令了，此阶段的任务是完成指令所规定的各种操作，具体实现指令的功能。
+- 访问取数阶段，根据指令的需要，有可能需要从内存中提取数据，此阶段的任务是：根据指令地址码，得到操作数在主存中的地址，并从主存中读取该操作数用于运算。
+- 结果写回阶段，作为最后一个阶段，结果写回（Write Back，WB）阶段把执行指令阶段的运行结果数据“写回”到某种存储形式：结果数据经常被写到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.
+
+为了进一步提高计算机的效率，在流水线的基础上，人们又发明了多流水线、超标量计算和超长指令字等多指令发射机制。这些机制的发明在提升计算机效率（主要是吞吐量）的同时，也极大地增加计算机结构的复杂度，并对操作系统和编译器提出了更高的要求。下图描述的是一个超标量发射的体系结构。这个结构有两队指令读取和译码单元，以及三个执行单元。通过一个指令保持缓冲区，就可以实现多路复用（Multiplex）和反多路复用（de-Multiplex），从而提高系统每个功能单元的利用率和整个系统的吞吐量。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/cpu_process_multi.jpg?raw=true)        
+
+
+
+## 操作系统的两种CPU状态
+
+就像世界上的人并不平等一样，并不是所有的程序都是平等的。世界上有的人占有资源多，有的人占有资源少，有的人来了，别人得让出资源，有的人则专门为别人让出资源。程序也是这样的，有的程序可以访问计算机的任何资源，有的程序则只能访问少量受限资源。操作系统作为计算机的管理者，自然不能和被管理者享受一样的待遇。它应该享有更多的方便或权限。为了区分不同的程序的不同权限，人们发明了内核态和用户态的概念。
+
+- 内核态(Kernel Mode):运行操作系统程序
+
+    内核态就是拥有资源多的状态，或者说访问资源多的状态，又称为特权态。
+
+- 用户态(User Mode):运行用户程序
+
+    用户态就是非特权态，在此种状态下访问的资源将受到限制。
+
+如果一个程序运行在特权态，则该程序就可以访问计算机的任何资源，即它的资源访问不受限制。如果一个程序运行在用户态，则其资源需求将受到各种限制。很显然，内核态和用户态各有优势：
+- 运行在内核态的程序可以访问的资源多，但可靠性、安全性要求高，维护管理都较复杂；
+- 用户态程序程序访问的资源有限，但可靠性、安全性要求低，自然编写维护起来比较简单。
+一个程序到底应该运行在内核态还是用户态则取决于其对资源和效率的需求。一般来说，如果一个程序能够运行于用户态，就应该让它运行在用户态。只在迫不得已的情况下，才让程序运行于内核态。凡是牵扯到计算机本体根本运行的事情都应该在内核态下执行，只与用户数据和应用相关的东西则放在用户态执行。另外，对时序要求特别高的操作，也应该在内核态完成。
+
+
+
+#### 态势的识别
+
+那么计算机是如何知道现在正在运转的程序是内核态程序呢？而正确做出内核态或用户态的判断对系统的正确运行至关重要。显然做出这种判断需要某种标志。这个标志就是处理器的一个状态位。这个状态位是CPU状态字里面的一个字位。也就是说，所谓的用户态、内核态实际上是处理器的一种状态，而不是程序的状态。我们通过设置该状态字，可以将CPU设置为内核态、用户态或者其他的子态（有的CPU有更多种子态）。一个程序运行时，CPU是什么态，这个程序就运行在什么态。
+
+操作系统只需要这两种状态，同时这两种状态由对应的两种指令: 
+
+- 特权(privilege)指令:只能由操作系统使用、用户程序不能使用的指令
+- 非特权指令:用户程序可以使用的指令
+
+用户态 -> 内核态的唯一途径是通过陷入（trap，一种中断方式）机制（将系统调用的代码放在一个约定好的寄存器中，通过陷入将控制交给操作系统）。
+
+内核态 -> 用户态是通过设置程序状态字PSW。
+
+一旦 CPU 决定去实施中断后，程序计数器和 PSW 就会被压入到当前堆栈中并且 CPU 会切换到内核态。设备编号可以作为内存的一个引用，用来寻找该设备中断处理程序的地址。这部分内存称作`中断向量(interrupt vector)`。一旦中断处理程序（中断设备的设备驱动程序的一部分）开始后，它会移除栈中的程序计数器和 PSW 寄存器，并把它们进行保存，然后查询设备的状态。在中断处理程序全部完成后，它会返回到先前用户程序尚未执行的第一条指令。
+
+### 中断/异常
+
+为什么要引入中断与异常？
+中断的引入: 为了支持CPU和设备之间的并行操作。     
+当CPU启动设备进行输入/输出后，设备便可以独立工作，CPU转去处理与此次输入/输出不相关的事情。当设备完成输入/输出后，通过向CPU发中断报告此次输入/输出的结果，让CPU决定如何处理以后的事情。 
+异常的引入：表示CPU执行指令时本身出现的问题。    
+如算数溢出、除零、读取时的奇偶错，访问地址时的越界或执行了“陷入指令”等，这时硬件改变了CPU当前的执行流程，转到相应的错误处理程序或异常处理程序或执行系统调用。 
+
+
+#### 中断的概念
+
+所谓中断，是指CPU对系统中或系统外发生的异步事件的相应。
+
+异步事件是指无一定时序关系的随机发生的时间，如外围设备完成数据传输，实时控制设备出现异常情况等。“中断”这个名称来源于：当这些异步事件发生后，打断了CPU对当前程序的执行，而转去处理该异步事件（执行该时间的中断处理程序）。直到处理完成之后，再转回原程序的中断点继续执行。
+
+
+
+可以说操作系统是由“中断驱动”或者“时间驱动”的。中断/异常是CPU对系统发生的某个事件作出的一种反应。
+
+所有计算机都提供了允许其他模块（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)
+
+
+
+### 举个栗子
+
+- 中断
+
+    有一天我正在看书的时候，来电话了，这时候我需要执行中断，我会把当前看到的书的进度用书签标记，然后去接电话，等电话接完后，再返回从书签的位置继续读书。
+
+- 异常
+
+    同样我在读书，但是由于新买的书纸张太硬，一不小心把手划破流血了，那这个时候就是异常，我同样需要把当前看到的书的进度用书签标记，然后去用创可贴来处理伤口，等处理完后再返回书签的位置继续读书。
+
+
+
+中断的出现解决了主机和外围设备并行工作的问题，消除了因外围设备的慢速而使得主机等待的现象，提高了可靠性，为多机操作和实时处理提供了硬件基础。引起中断的那些事件称为中断事件或中断源，中断源向CPU发出的请求信号称为中断请求，而处理中断事件的那段程序称为中断处理程序。发生中断时正在执行的程序的暂停点称为中断断点，CPU暂停当前程序转而处理中断的过程称为中断响应，中断处理结束之后恢复原来程序的执行称为中断返回。
+
+### 中断系统
+
+中断系统包括量大组成部分：
+
+- 中断系统的硬件中断装置
+- 软件中断处理程序
+
+中断装置负责捕获中断源发出的中断请求，并以一定的方式响应中断源，然后将CPU的控制权移交给特定的中断处理程序。中断处理程序负责辨别中断类型，并根据请求作出相应的操作。中断装置提供了中断系统的基本框架，是中断系统的机制部分。中断处理程序是利用中断机制对处理能力的扩展和对多种处理需求的适应，属于中断系统的策略部分。
+
+
+
+### 中断处理
+
+当I/O设备完成一次I/O操作时，发生以下硬件事件:  
+
+1. 设备给处理器发送一个中断信号。
+2. 处理器在响应中断前结束当前指令的执行。
+3. 处理器对中断进行测试，确定存在未响应的中断，并给提交中断的设备发送确认信号，确认信号允许该设备取消它的中断信号。
+4. 处理器需要准备把控制权转交给中断程序。首先，需要保存从中断点恢复当前程序所需要的信息，要求的最少信息包括程序状态字（PSW）和保存在程序计数器（PC）中的下一条要执行的指令地址，它们被压入系统控制栈。
+5. 处理器把响应此中断的中断处理程序入口地址装入程序计数器。每类中断可由一个中断处理程序，具体取决于计算机系统架构和操作系统的设计。如果有多个中断程序，这一信息可能已包含在最初的中断信号中，否则处理器必须给发中断的设备发送请求，以获取含有所需信息的响应。一旦装入程序计数器，处理器就继续执行下一个指令周期，该指令周期也从取指开始。由于取指是由程序计数器的内容决定的，因此控制权被转交给中断处理程序，该程序会引起以下操作： 
+6. 在这一点，与被中断程序相关的程序计数器和PSW被保存到系统栈中，此外，还有一些其他信息被当做正在执行程序的状态的一部分。特别需要保存处理器寄存器的内容，因为中断处理程序可能会用到这些寄存器，因此所有这些值和任何其他状态信息都需要保存。
+7. 中断处理程序现在可以开始处理中断，其中包括检查与I/O操作相关的状态信息或其他引起中断的事件，还可能包括给I/O设备发送附加命令或应答。
+8. 中断处理结束后，被保存的寄存器值从栈中释放并恢复到寄存器中。
+9. 最后的操作是从栈中恢复PSW和程序计数器的值，因此下一条要执行的指令来自前面被中断的程序。
+
+
+
+与每一 I/O 类相关联的是一个称作 `中断向量(interrupt vector)` 的位置（靠近内存底部的固定区域）。它包含中断服务程序的入口地址。假设当一个磁盘中断发生时，用户进程正在运行，则中断硬件将程序计数器、程序状态字、有时还有一个或多个寄存器压入堆栈，计算机随即跳转到中断向量所指示的地址。这就是硬件所做的事情。然后软件就随即接管一切剩余的工作。
+
+当中断结束后，操作系统会调用一个 C 程序来处理中断剩下的工作。在完成剩下的工作后，会使某些进程就绪，接着调用调度程序，决定随后运行哪个进程。然后将控制权转移给一段汇编语言代码，为当前的进程装入寄存器值以及内存映射并启动该进程运行，下面显示了中断处理和调度的过程。
+
+1. 硬件压入堆栈程序计数器等
+2. 硬件从中断向量装入新的程序计数器
+3. 汇编语言过程保存寄存器的值
+4. 汇编语言过程设置新的堆栈
+5. C 中断服务器运行（典型的读和缓存写入）
+6. 调度器决定下面哪个程序先运行
+7. C 过程返回至汇编代码
+8. 汇编语言过程开始运行新的当前进程
+
+一个进程在执行过程中可能被中断数千次，但关键每次中断后，被中断的进程都返回到与中断发生前完全相同的状态。
+
+
+
+#### 中断异常机制工作原理
+
+中断/异常机制是现代计算机系统的核心机制之一。硬件和软件相互配合而使计算机系统得以充分发挥能力。
+
+硬件该做什么是？  --- 中断/异常响应
+捕获中断源发出的中断/异常请求，以一定方式响应，将处理器控制权交给特定的处理程序。 
+
+软件要做什么是？  ---中断/异常处理程序
+识别终端/异常类型并完成相应的处理
+## 存储器
+
+在任何一种计算机中，第二种主要部件都是存储器。在理想情况下，存储器应该极为迅速（快于执行一条指令，这样CPU就不会受到存储器的限制），充分大并且非常便宜。但是目前的技术无法同时满足这三个目标。
+
+- 存取时间越快，每“位”的价格越高
+- 容量越大，每“位”的价格越低
+- 容量越大，存取速度越慢
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/computer_storage_type.png?raw=true)
+
+于是出现了多级存储器组织结构:
+
+- 寄存器： 最快、最小和最贵的存储器类型由位于处理器内部的寄存器组成。它们用与CPU相同的材料制成，所以和CPU一样快。显然，访问它们是没有时延的。其典型的存储容量是，在32位CPU中为32x32位，而在64位CPU中为64x64位。在这两种情况下，其存储容量都小于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和磁盘之间。另外，与磁盘存储器不同的是，如果闪存擦除次数过多，就被磨损了。
+    
+    那闪存和固态硬盘有什么区别？固态硬盘也是将数据存储在闪存中。在存储行业中使用的最简单的类比之一是闪存就像鸡蛋，而SSD硬盘就像煎蛋卷一样。煎蛋卷主要是由鸡蛋制作的，而SSD硬盘主要由闪存制成的。
+
+
+
+
+
+## 内存
+
+通常所说的内存指的是计算机的主存储器（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的大小。
+
+高速缓冲存储器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是主要存放数据和程序的地方，所以也叫做“主存”。
+
+- 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存储器，它是一种具有静态存取功能的存储器，不需要刷新电路即能保存它内部存储的数据。不像DRAM内存那样需要刷新电路，每隔一段时间，固定要对DRAM刷新充电一次，否则内部的数据即会消失，因此SRAM具有较高的性能，但是SRAM也有它的缺点，即它的集成度较低，相同容量的DRAM内存可以设计为较小的体积，但是SRAM却需要很大的体积，这也是不能将缓存容量做得太大的重要原因。它的特点归纳如下：优点是节能、速率快、不必配合内存刷新电路、可提高整体的工作效率，缺点是集成度低、相同的容量体积较大、而且价格较高，只能少量用于关键性系统以提高效率。
+
+
+
+缓存的工作原理是当CPU要读取一个数据时，首先从CPU缓存中查找，找到就立即读取并送给CPU处理；没有找到，就从速率相对较慢的内存中读取并送给CPU处理，同时把这个数据所在的数据块调入缓存中，可以使得以后对整块数据的读取都从缓存中进行，不必再调用内存。正是这样的读取机制使CPU读取缓存的命中率非常高，一般把静态RAM缓存叫一级缓存，而把后来增加的动态RAM叫二级缓存。
+
+
+
+
+
+
+
+## 系统软件和应用软件
+
+
+
+- 系统软件是指控制和协调计算机以及外部设备，支持应用软件开发和运行的系统，是无需用户干预的各种程序的集合。主要功能是调度、监控和维护计算机系统。例如: 操作系统和一系列的基本工具(编译器、数据库管理、存储器格式化、用户身份验证、网络连接)。
+- 应用软件是和系统软件相对的，是用户可以使用的各种程序设计语言，以及用各种程序设计语言编译的应用程序的集合，分为应用软件包和用户程序。例如:互联网软件、多媒体软件、协作软件等。 
+
+
+
+## Linux系统
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/linux_archi.png)
+
+
+
+## Android系统
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_system_2.png)
+
+
+
+- 应用和框架：应用开发者最关心这一层及访问低层服务的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请求对应的锁。若无唤醒锁存在，系统就会锁定并关闭设备以节省电能。
+
+
+
+## Linux操作系统特点
+
+Linux是类Unix系统，借鉴了Unix的设计并实现相关接口，但并非Unix。Linux是由Linus Torvalds于1991年创造的开源免费系统，采用GNU GPL协议保护，下面列举Linux的一些主要特点：
+
+- Linux系统中万物皆为文件，这种抽象方便操作数据或设备，只需一套统一的系统接口open, read, write, close即可完成对文件的操作
+- Linux是单内核，支持动态加载内核模块，可在运行时根据需求动态加载和卸载部分内核代码；
+- Linux内核支持可抢占；
+- Linux内核创建进程，采用独特的fork()系统调用，创建进程较高效；
+- Linux内核并不区分进程和线程，对于内核而言，进程与线程无非是共享资源的区别，对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)
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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"
new file mode 100644
index 00000000..906d5fd8
--- /dev/null
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -0,0 +1,969 @@
+# 2.进程与线程
+
+### 为什么要引入进程的概念？
+
+我们知道I/O操作是耗时的，CPU在执行的一个程序的时候这个程序可能会有一些耗时的操作，而CPU的执行是非常快的，那如果这种情况下，CPU一直等待这个程序执行完耗时的操作再继续执行，就会导致CPU的使用率大大降低，为了提高CPU的使用率，就引入了多道程序设计，也就是说有多个程序执行，当执行到一个程序时如果遇到耗时的操作，那CPU就切换到另一个程序继续执行，等第一个程序的耗时操作执行完后再切换到第一个程序执行，这个切换过程不能只切换PC的指针，还需要记录一些其他的程序的信息，所以为了描述这种程序的信息，引入了进程的概念。
+
+
+
+事实表明，人们常常希望同时运行多个程序。比如：在使用计算机或者笔记本的时候，我们会同时运行浏览器、邮件、游戏、音乐播放器，等等。实际上，一个正常的系统可能会有上百个进程同时在运行。如果能实现这样的系统，人们就不需要考虑这个时候哪一个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的控制？控制权对于操作系统尤为重要，因为操作系统负责资源管理。如果没有控制权，一个进程可以简单地无限制运行并接管机器，或访问没有权限的信息。因此，在保持控制权的同时获得高性能，这是构建操作系统的主要挑战之一。
+
+抽象：进程概念
+操作系统为正在运行的程序提供的抽象，就是所谓的进程（process）。正如我们上面所说的，一个进程只是一个正在运行的程序。在任何时刻，我们都可以清点它在执行过程中访问或影响的系统的不同部分，从而概括一个进程。
+
+
+#### 多道程序系统与分时操作系统
+- 所谓多道程序设计指的是允许多个程序同时进入一个计算机系统的主存储器并启动进行计算的方法。也就是说，计算机内存中可以同时存放多道（两个以上相互独立的）程序，它们都处于开始和结束之间。从宏观上看是并行的，多道程序都处于运行中，并且都没有运行结束；从微观上看是串行的，各道程序轮流使用CPU，交替执行。引入多道程序设计技术的根本目的是为了提高CPU的利用率，充分发挥计算机系统部件的并行性，现代计算机系统都采用了多道程序设计技术。
+- 分时操作系统是使一台计算机同时为几个、几十个甚至几百个用户服务的一种操作系统。把计算机与许多终端用户连接起来，分时操作系统将系统处理机时间与内存空间按一定的时间间隔，轮流地切换给各终端用户的程序使用。由于时间间隔很短，每个用户的感觉就像他独占计算机一样。分时操作系统的特点是可有效增加资源的使用率。例如UNIX系统就采用剥夺式动态优先的CPU调度，有力地支持分时操作。
+- 分时操作系统是给不同用户提供程序的使用，而多道程序系统则是不同程序间的穿插运行。
+
+## 进程概念
+
+程序是指令和数据的集合。
+
+狭义定义：进程是正在运行的程序的实例（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）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。每个进程访问自己的私有虚拟地址空间（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）是该进程的一部分。
+进程的机器状态的另一部分是寄存器。许多指令明确地读取或更新寄存器，因此显然，它们对于执行该进程很重要。
+
+
+进程由三部分组成: 
+
+- 一段可执行的程序
+- 程序所需要的相关数据(变量、工作空间、缓冲区等)
+- 程序的执行上下文
+
+最后一部分是根本。执行上下文(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在各进程之间来回切换，这种快速的切换称为多道程序设计。
+
+## 多道程序设计模型
+
+采用多道程序设计可以提高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必须采用某种措施来限制各进程推进序列以保证各程序间正常协调运行。
+
+
+
+## 进程的状态(五状态进程模型)
+
+
+
+- 就绪态：进程做好了准备，只要有机会就开始执行
+- 运行态：进程正在执行
+- 堵塞/等待态：进程在某些事件发生前不能执行，如I/O操作完成
+- 新建态：刚刚创建的进程，操作系统还未把它加入可执行进程组，它通常是进程控制块已经创建但还未加载到内存中的新进程
+- 退出态：操作系统从可执行进程组中释放出的进程，要么它自身已停止，要么它因某种原因被取消
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/process_state.png)
+
+### 挂起态
+
+当内存中的所有进程都处于堵塞态时，操作系统可把其中的一个进程置为挂起态，并将它移到磁盘。此时内存所释放的空间就可被调入的另一个进程使用。操作系统执行换出操作后，将进程取到内存中的方式有两种：接纳一个新近创建的进程，或调入一个此前挂起的进程。显然，操作系统更倾向于调入一个此前挂起的进程，并为它服务，而非增加系统的总负载数。
+
+挂起进程等价于不在内存中的进程。不在内存中的进程，不论他是否在等待一个时间，都不能立即执行。
+
+### 进程由哪几部分组成？
+
+进程是程序的一次运行过程，它是由程序段、数据段和进程控制块PCB组成的一个实体，其中：
+- 程序段：对应程序的操作代码部分，用于描述进程所需要完成的功能。
+- 数据段：对应程序执行时所需要的数据部分，包括数据，堆栈和工作区。
+- 进程控制块(Process Control Block, PCB) ：描述进程的基本信息和运行状态，记录了进程运行时所需要的全部信息，它是进程存在的唯一标识，与进程一一对应。所谓的创建进程和撤销进程，都是指对PCB的操作。
+
+#### 进程控制块(PCB)
+
+又称进程描述符、进程属性，是操作系统用于管理进程的一个专门数据结构。PCB是操作系统感知进程存在的唯一标志。进程和PCB是一一对应的。
+
+进程执行的任意时刻，都可由如下元素来表征:  
+
+- 标识符:与进程相关的唯一标识符，用于标识、区分一个进程，通常有外部标识符和内部标识符两类。外部标识符通常是由字母、数字所组成的一个字符串，用户或其他进程访问该进程时使用。内部标识符是操作系统为每个进程赋予的唯一一个整数，是作为内部识别而设置的。
+- 状态:若进程正在执行，则进程处于运行态。进程状态指明进程当前的状态，作为进程调度和对换时的依据；
+- 优先级:相对于其他进程的优先顺序，说明进程使用CPU的优先级别，其中优先级高的进程将优先获得CPU。
+- 程序计数器:程序中即将执行的下一条指令的地址
+- 内存指针:包括程序代码和进程相关数据的指针，以及与其他进程共享内存块的指针
+- 上下文数据:进程执行时处理器的寄存器中的数据
+- I/O状态信息:包括显式I/O请求、分配给进程的I/O设备和被进程使用的文件列表等
+- 记账信息:包括处理器时间总和、使用的时钟数总和、时间限制、及账号等
+
+上述列表信息存放在一个进程控制块(process control block)的数据结构中，控制块由操作系统创建和管理。系统通过PCB感知进程的存在，并对其进行有效管理和控制。系统创建一个新进程时，为它建立一个PCB；当进程结束时，系统又收回其PCB，该进程也随之消亡。
+
+
+
+进程表: 所有进程的PCB集合。
+
+## 进程创建
+
+操作系统决定创建一个新进程时，会按如下步骤操作:  
+
+1. 为新进程分配一个唯一的进程标识符。此时，主进程表中会添加一个新表项，每个进程一个表项。
+2. 为进程分配空间。这包括进程映像中的所有元素。因此，操作系统必须知道私有用户地址空间(程序和数据)和用户栈需要多少空间。
+3. 初始化进程控制块。进程表示部分包括进程id和其他相关的id，如父进程id等。处理器状态信息部分的多数项目通常初始化为0，但程序计数器(置为程序入口点)和系统栈指针(定义进程栈边界)除外。进程控制信息部分根据标准的默认值和该进程请求的特性来初始化。例如，进程的状态通常初始化为就绪或就绪/挂起。
+4. 设置正确的链接。例如，若操作系统将每个调度队列都维护为一个链表，则新进程必须放在继续或就绪/挂起链表中。
+5. 创建或扩充其他数据结构。例如，操作系统可因编制账单和/或评估性能，为每个进程维护一个记账文件。
+
+
+
+## 进程切换
+
+
+
+### 进程表(Process Table)
+
+操作系统为了执行进程间的切换，会维护着一张表格，这张表就是进程表(process table)。每个进程占用一个进程表项。该表项包含了进程状态的重要信息，包括程序计数器、堆栈指针、内存分配状况、所打开文件的状态、账号和调度信息，以及其他在进程由运行态转换到就绪态或阻塞态时所必须保存的信息，从而保证该进程随后能再次启动，就像从未被中断过一样。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/process_table.png?raw=true)  
+
+上面是典型的进程表表项中的一些字段:  
+
+第一列内容与进程管理有关，第二列内容与存储管理有关，第三列内容与文件管理有关。
+
+
+
+
+
+
+
+**操作系统最底层的就是调度程序**，在它上面有许多进程。所有关于中断处理、启动进程和停止进程的具体细节都隐藏在调度程序中。事实上，调度程序只是一段非常小的程序。
+
+表面上看，进程切换很简单。在某个时刻，操作系统中断一个正在运行的进程，将另一个进程置于运行模式，并把控制权交给后者。然而，这会引发若干个问题。首先，什么事件触发了进程的切换？ 其次，必须认识到模式切换和进程切换键的区别。
+
+
+
+进程切换可在操作系统从当前正运行进程中获得控制权的任何时刻发生。首先考虑系统终端。实际上，大多数操作系统都会区分两种系统终端：一种称为终端，另一种称为陷阱。前者与当前正运行进程无关的某种外部事件相关，如完成一次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)
+
+
+
+以Linux为例，进程间的信息交换，具体内容分为：控制信息交换和数据交换，控制信息的交换为低级通信，数据的交换为高级通信。
+
+- Pipe管道通信
+
+    人们最常使用的通信手段就是对白。对白的特点就是一方发出声音，另一方接收声音。而声音的传递则通过空气（当面或无线交谈）、线缆（有线电话）进行传递。类似，进程对白就是一个进程发出某种数据信息，另外一方接收数据信息，而这些数据信息通过一片共享的存储空间进行传递。在这种方式下，一个进程向这片存储空间的一端写入信息，另一个进程从存储空间的另外一端读取信息。这看上去像什么？管道。管道所占的空间既可以是内存，也可以是磁盘。就像两人对白的媒介可以是空气，也可以是线缆一样。要创建一个管道，一个进程只需调用管道创建的系统调用即可。该系统调用所做的事情就是在某种存储介质上划出一片空间，赋给其中一个进程写的权利，另一个进程读的权利即可。
+
+    从根本上说，管道是一个线性字节数组(实为内核缓冲区)，是一种伪文件的方式，类似文件，可以使用文件读写的方式进行访问。但却不是文件。因为通过文件系统看不到管道的存在。另外，我们前面说了，管道可以设在内存里，而文件很少设在内存里。
+管道的原理：管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。
+
+    在两个进程之间，可以建立一个通道，一个进程向这个通道里写入字节流，另一个进程从这个管道中读取字节流。管道是同步的，当进程尝试从空管道读取数据时，该进程会被阻塞，直到有可用数据为止。发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信，管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。每次只有一个进程能够真正地进入管道，其他的只能等待。
+
+    
+
+    管道分为无名管道和命名管道，前者用于父子进程通信，后者用于任意进程通信。
+
+    入先出队列 FIFO 通常被称为 `命名管道(Named Pipes)`，命名管道的工作方式与常规管道非常相似，但是确实有一些明显的区别。未命名的管道没有备份文件：操作系统负责维护内存中的缓冲区，用来将字节从写入器传输到读取器。一旦写入或者输出终止的话，缓冲区将被回收，传输的数据会丢失。相比之下，命名管道具有支持文件和独特 API ，命名管道在文件系统中作为设备的专用文件存在。当所有的进程通信完成后，命名管道将保留在文件系统中以备后用。命名管道具有严格的 FIFO 行为，写入的第一个字节是读取的第一个字节，写入的第二个字节是读取的第二个字节，依此类推。
+
+   管道的局限性： 
+    - 数据自己读不能自己写
+    - 数据一旦被读走，便不在管道中存在，不可反复读取。
+    - 由于管道采用半双工通信(数据只能一个方向写，另一个方向读)方式。因此，数据只能在一个方向上流动。
+    - 只能在有公共祖先的进程间使用管道。
+
+
+创建管道: 
+```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
+#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命令在这个创建的套接字通道上进行交流了。
+
+    socket 提供端到端的双相通信。一个套接字可以与一个或多个进程关联。就像管道有命令管道和未命名管道一样，套接字也有两种模式，套接字一般用于两个进程之间的网络通信，网络套接字需要来自诸如TCP（传输控制协议）或较低级别UDP（用户数据报协议）等基础协议的支持。
+
+- Signals信号
+
+    管道和套接字虽然提供了丰富的通信语义，并且也得到了广泛应用，但它们也存在某些缺点，并且在某些时候，这两种通信机制会显得很不好用。首先，如果使用管道和套接字方式来通信，必须事先在通信的进程间建立连接（创建管道或套接字），这需要消耗系统资源。其次，通信是自愿的。即一方虽然可以随意向管道或套接字发送信息，但对方却可以选择接收的时机。即使对方对此充耳不闻，你也奈何不得。再次，由于建立连接消耗时间，一旦建立，我们就想进行尽可能多的通信。而如果通信的信息量微小，如我们只是想通知一个进程某件事情的发生，则用管道和套接字就有点“杀鸡用牛刀”的味道，效率十分低下。因此，我们需要一种不同的机制来处理如下通信需求：想迫使一方对我们的通信立即做出回应。我们不想事先建立任何连接，而是临时突然觉得需要与某个进程通信。传输的信息量微小，使用管道或套接字不划算。应付上述需求，我们使用的是信号（signal）。
+
+那么信号是什么呢？在计算机里，信号就是一个内核对象，或者说是一个内核数据结构。发送方将该数据结构的内容填好，并指明该信号的目标进程后，发出特定的软件中断。操作系统接收到特定的中断请求后，知道是有进程要发送信号，于是到特定的内核数据结构里查找信号接收方，并进行通知。接到通知的进程则对信号进行相应处理。信号非常类似我们生活当中的电报。如果你想给某人发一封电报，就拟好电文，将报文和收报人的信息都交给电报公司。电报公司则将电报发送到收报人所在地的邮局（中断），并通知收报人来取电报。发报时无需收报人事先知道，更无需进行任何协调。如果对方选择不对信号做出响应，则将被操作系统终止运行。
+
+A给B发送信号，B收到信号之前执行自己的代码，收到信号后，不管执行到程序的什么位置，都要暂停运行，去处理信号，处理完毕再继续执行。与硬件中断类似——异步模式。但信号是软件层面上实现的中断，早期常被称为“软中断”。
+
+信号的特质：由于信号是通过软件方法实现，其实现手段导致信号有很强的延时性。但对于用户来说，这个延迟时间非常短，不易察觉。
+每个进程收到的所有信号，都是由内核负责发送的，内核处理。
+```c
+int kill(pid_t pid, int sig);
+```
+
+    两个或多个进程可以通过简单的信号进行合作，可以强迫一个进程在某个位置停止，直到它接收到一个特定的信号。信号量是一个特殊的变量。用于进程间传递信息的一个整数值。
+
+    信号是 UNIX 系统最先开始使用的进程间通信机制，因为 Linux 是继承于 UNIX 的，所以 Linux 也支持信号机制，通过向一个或多个进程发送`异步事件信号`来实现，信号可以从键盘或者访问不存在的位置等地方产生；信号通过 shell 将任务发送给子进程。
+
+    你可以在 Linux 系统上输入 `kill -l` 来列出系统使用的信号。
+
+    进程可以选择忽略发送过来的信号，但是有两个是不能忽略的：`SIGSTOP` 和 `SIGKILL` 信号。SIGSTOP 信号会通知当前正在运行的进程执行关闭操作，SIGKILL 信号会通知当前进程应该被杀死。除此之外，进程可以选择它想要处理的信号，进程也可以选择阻止信号，如果不阻止，可以选择自行处理，也可以选择进行内核处理。如果选择交给内核进行处理，那么就执行默认处理。
+
+    操作系统会中断目标程序的进程来向其发送信号、在任何非原子指令中，执行都可以中断，如果进程已经注册了新号处理程序，那么就执行进程，如果没有注册，将采用默认处理的方式。
+
+   信号效率非常高，但是可携带的数据有限，只能写到一个标志位，无法携带其他数据。
+
+    不建议使用信号完成进程间通信，因为信号的优先级太高，产生信号之后会打断程序的执行。
+
+
+- 信号量
+
+    信号量（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共享内存
+
+    管道、套接字、信号、信号量，虽然满足了多种通信需要，但还是有一种需要未能满足。这就是两个进程需要共享大量数据。这就像两个人，他们互相喜欢，并想要一起生活时（共享大量数据量），打电话、握手、对白等就显得不够了，这个时候需要的是拥抱，只有将其紧紧拥抱于怀，感觉才最到位，也才能尽可能地共享。进程的拥抱就是共享内存。    
+    共享内存就是两个进程共同拥有同一片内存。对于这片内存中的任何内容，二者均可以访问。要使用共享内存进行通信，一个进程首先需要在内核中创建一片内存空间专门作为通信用，然后该进程与这片内存空间进行关联，而其他进程则将该片内存映射到自己的（虚拟）地址空间。    
+    这样，读写自己地址空间中对应共享内存的区域时，就是在和其他进程进行通信。乍一看，共享内存有点像管道，有些管道不也是一片共享内存吗？这是形似而神不似：- 首先，使用共享内存机制通信的两个进程必须在同一台物理机器上；
+- 其次，共享内存的访问方式是随机的，而不是只能从一端写，另一端读，因此其灵活性比管道和套接字大很多，能够传递的信息也复杂得多。
+
+共享内存的缺点是管理复杂，且两个进程必须在同一台物理机器上才能使用这种通信方式。共享内存的另外一个缺点是安全性脆弱。因为两个进程存在一片共享的内存，如果一个进程染有病毒，很容易就会传给另外一个进程。就像两个紧密接触的人，一个人的病毒是很容易传染另外一个人的。这里需要注意的是，使用全局变量在同一个进程的进程间实现通信不称为共享内存。
+
+    共享内存是进程通信中最快的一种方法，因为数据不需要在进程间复制，而可以直接映射到各个进程的地址空间中。在共享内存中要注意的一个问题是：当多个进程对共享内存区域进行访问时，要注意这些进程之间的同步问题。    
+例如，如果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
+
+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 (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创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。
+
+- 匿名映射
+
+    使用映射区完成文件读写操作十分方便，父子进程间通信比较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要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消息传递系统/消息队列
+
+    消息队列是一列具有头和尾的消息排列。新来的消息放在队列尾部，而读取消息则从队列头部开始，消息队列乍一看，这不是管道吗？一头读、一头写？没错。这的确看上去像管道，但它不是管道。首先，它无需固定的读写进程，任何进程都可以读写（当然是有权限的进程）。其次，它可以同时支持多个进程，多个进程可以读写消息队列。即所谓的多对多，而不是管道的点对点。另外，消息队列只在内存中实现。最后，它并不是只在UNIX和类UNIX操作系统中实现。几乎所有主流操作系统都支持消息队列。
+
+    进程与其它的进程进行通信而不必借助共享数据，通过互相发送和接收消息，建立一条通信链路。
+
+
+## 进程调度
+
+当一个计算机是多道程序设计系统时，会频繁的有很多进程或者线程来同时竞争 CPU 时间片。当两个或两个以上的进程/线程处于就绪状态时，就会发生这种情况。如果只有一个 CPU 可用，那么必须选择接下来哪个进程/线程可以运行。操作系统中有一个叫做调度程序(scheduler) 的角色存在，它就是做这件事儿的，该程序使用的算法叫做调度算法(scheduling algorithm) 。进程调度就是处理器调度(上下文切换)。
+
+### 调度级别
+
+- 高级调度
+
+    作业调度,把后备作业调入内存运行
+
+- 中级调度
+
+    在虚拟存储器中引入，在内，外存交换区进行进程对换
+
+- 低级调度
+
+    进程调度，把就绪队列里的某个进程获得CPU执行权
+
+### 调度方式
+
+- 可剥夺
+
+    当一个进程运行时，基于某种原则，剥夺已经分配给它的处理器，将之分配给其他进程，原则有：优先权原则，短进程优先原则，时间片原则。
+
+- 不可剥夺
+
+    一单处理器分配给某进程，遍让它一直运行下去，直到进程完成或者发生某种时间而阻塞，才分配给其他进程。
+
+### 调度算法
+
+- 先来先服务(first-come,first-serverd)
+
+    按照进入就绪队列的进程顺序，不加其他条件干涉。但是也存在缺陷，例如一个进程本来需要5秒就能执行完成，但是在它前面的进程确需要1个小时，它不得不等待一个小时。
+
+- 最短作业优先(Shortest Job First)
+
+    优先选出就绪队列中CPU执行时间最短的进程，例如：就绪队列有4个进程P1，P2，P3，P4，执行时间为：16,12,4,3 按照短进程优先，则周转时间(从进程提交到进程完成的时间间隔)分别为：35,19,7,3
+    平均周转时间：16，平均周转时间越小，调度性能越好。这种算法的核心是所有的程序并不都一样，而是有优先级的区分。具体来说，就是短任务的优先级比长任务的高，而我们总是安排优先级高的程序先运行。就像晚辈在公交汽车上见到长辈需要让座一样。
+
+    在所有的进程都可以运行的情况下，最短作业优先的算法才是最优的。
+
+- 最短剩余时间优先(Shortest Remaining Time Next)
+
+    使用这个算法，调度程序总是选择剩余运行时间最短的那个进程运行。
+
+- 轮转法
+  
+    一种最古老、最简单、最公平并且最广泛使用的算法就是轮询算法(round-robin)。每个进程都会被分配一个时间段，称为时间片(quantum)，在这个时间片内允许进程运行。如果时间片结束时进程还在运行的话，则抢占一个 CPU 并将其分配给另一个进程。如果进程在时间片结束前阻塞或结束，则 CPU 立即进行切换。轮询算法比较容易实现。调度程序所做的就是维护一个可运行进程的列表，当一个进程用完时间片后就被移到队列的末尾。
+    
+    - 简单轮转： 就绪进程按FIFO排队，按照一定时间间隔让处理机分配给队列中的进程，就绪队列中所有队列均可获得一个时间片的处理器运行。
+    - 多级队列： 让系统中所有进程分成若干类，每类一级。
+    
+- 优先级调度
+
+    每个进程都被赋予一个优先级，优先级高的进程优先运行。优先级调度的优点是可以赋予重要的进程以高优先级以确保重要任务能够得到CPU时间。其缺点则是低优先级的进程可能会“饥饿”。
+    
+    优先级倒挂（priority inversion）其所指的是一个低优先级任务持有一个被高优先级认为所需要的共享资源。这样高优先级任务因资源缺乏而处于受阻状态，一直到低优先级任务释放资源为止。这样实际上造成了这两个任务的优先级倒挂。如果此时有其他优先级介于二者之间的任务，并且其不需要这个共享资源，则该中级优先级的进程将获得CPU控制，从而超越这两个任务，导致高优先级进程被临界区外的低优先级进程阻塞。在某些时候，优先级倒挂并不会造成损害。高优先级任务的延迟并不会注意到。因为低优先级进程最终会释放资源。但在其他一些时候，优先级倒挂则可能引起严重后果。如果一个高优先级进程一直不能获得资源，有可能造成系统故障，或激发事先定义的纠正措施，如系统复位。例如，美国的火星探测器Mars Path-finder就是因为优先级倒挂而出现故障。
+
+
+
+## 内核栈与用户栈的区别
+
+每个进程一般会有两个栈，一个用户栈，一个内核栈，存在于内核空间。
+
+当进程在用户空间运行时，cpu堆栈指针寄存器里面的内容时用户堆栈的地址，使用的是用户栈。
+
+当进程在内核空间时，cpu堆栈指针寄存器里的内容是内核栈空间的地址，使用内核栈。
+
+内核栈是**内存**中属于操作系统空间的一块区域，主要用途为：
+
+- 保护中断现场
+- 保护操作系统子程序间相互调用的参数、返回值、返回点以及子程序函数的局部变量
+
+用户栈是用户进程空间中的一块区域，用于保存用户进程的子程序间相互作用的参数、返回值以及相关局部变量
+
+**当进程因为中断或者系统调用而陷入内核态，进程所使用的堆栈也要从用户栈转到内核栈**。进程陷入内核态后，先把用户态堆栈的地址保存在内核栈中，然后设置堆栈指针寄存器的内容为内核栈的地址，这样就完成了用户栈到内核栈的转换。**当进程从内核态恢复为用户态时，在内核态之后的最后将保存在内核栈里面的用户栈地址恢复到堆栈指针寄存器即可**。这样就实现了内核栈和用户栈的互转。
+
+注意：**每次进程从用户态陷入内核的时候得到的内核栈都是空的，所以在进程陷入内核的时候，直接把内核栈的栈顶地址给堆栈指针寄存器即可。**
+
+
+
+## Android进程结构
+
+如同传统的Linux系统一样，Android的第一个用户空间进程是init（init的PID值是0），它是所有其他进程的根。然而，Android的init启动的守护进程是不同的，这些守护进程更多的聚焦于底层细节（管理文件系统和硬件访问），而不是高层用户设施，例如调度定时任务。Android还有一层额外的进程，它们运行Dalvik的Java语言环境，负责执行系统中所有以Java实现的部分。
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_process.png?raw=true)
+
+
+
+如上图，首先是init进程，它产生了一些底层守护进程，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进程中提供服务的。
+
+### ServiceManager
+
+Android Binder的管理服务。
+
+对于Binder驱动而言，**ServiceManager是一个守护进程，更是Android系统各个服务的管理者**。Android系统中的各个服务，都是添加到ServiceManager中进行管理的，而且每个服务都对应一个服务名。当Client获取某个服务时，则通过服务名来从ServiceManager中获取相应的服务。
+
+### 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）、ActivityManagerService（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进程模型
+
+
+
+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系统启动的核心流程如下：
+
+
+
+![](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是所有上层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至少运行在一个进程上。
+
+
+
+对于IPC(Inter-Process Communication,  进程间通信)，Linux现有管道、消息队列、共享内存、套接字、信号量、信号这些IPC机制，Android额外还有Binder  IPC机制，Android OS中的Zygote进程的IPC采用的是Socket机制，在上层system server、media  server以及上层App之间更多的是采用Binder  IPC方式来完成跨进程间的通信。对于Android上层架构中，很多时候是在同一个进程的线程之间需要相互通信，例如同一个进程的主线程与工作线程之间的通信，往往采用的Handler消息机制。
+
+
+
+## 线程
+
+#### 为什么要有线程呢？ 
+
+进程是运转的程序，是为了在CPU上实现多道编程而发明的一个概念。但是进程在一个时间只能干一件事情。如果想同时干两件事，例如同时看两场电影，我们自然想到传说中的分身术，就像孙悟空那样同时变出多个真身。当然，人在现实中进行分身是办不到的。但进程却可以办到，办法就是线程。线程就是我们为了让一个进程能够同时干多件事情而发明的“分身术”。
+
+如果说，在操作系统中引入进程的目的是使多个程序并发执行以改善资源利用率及提高系统的吞吐量；那么，在操作系统中再引入线程，则是为了减少程序并发执行时所付出的时空开销，使操作系统具有更好的并发性。为了说明这一点，首先回顾进程的两个基本属性：一是进程是一个可拥有资源的独立单位；二是进程同时又是一个可以独立调度和分派的基本单位。正是由于进程具有这两个基本属性，才使之成为一个能独立运行的基本单位，从而也就构成了进程并发执行的基础。
+
+
+
+简而言之，由于进程是一个资源拥有者，因而在进程的创建、撤销和切换中，系统必须为之付出较大的时空开销。也正因如此，在系统中所设置的进程数目不宜过多，进程切换的频率也不宜过高，但这也就限制了并发程度的进一步提高。
+如何能使多个程序更好地并发执行，同时又尽量减少系统的开销，这已成为近年来设计操作系统时所追求的重要目标。有不少操作系统的学者们考虑：可否将进程的上述两个属性分开，由操作系统分开进行处理？即对作为调度和分派的基本单位，不同时作为独立分配资源的单位，以使之轻装运行。正是在这种思想的指导下，产生了线程概念。这样线程就保留了并发的优点，避免了进程切换的代价。
+
+
+
+#### 线程的定义
+
+在引入线程的操作系统中，线程是进程的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器、一组寄存器和栈），但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程；同一进程中的多个线程之间可以并发执行。    
+
+在传统的操作系统中，拥有资源的基本单位和独立调度、分派的基本单位都是进程。而在引入线程的操作系统中，则把线程作为调度和分派的基本单位，而把进程作为资源拥有的基本单位，使传统进程的两个属性分开，线程便能轻装运行，从而可显著地提高系统的并发程度。在同一进程中，线程的切换不会引起进程切换；在由一个进程中的线程切换到另一个进程中的线程时，将会引起进程切换。所以多线程技术是指把执行一个应用程序的进程划分为可以同时运行的多个线程。
+
+
+
+线程不像是进程那样具备较强的独立性。同一个进程中的所有线程都会有完全一样的地址空间，这意味着它们也共享同样的全局变量。由于每个线程都可以访问进程地址空间内每个内存地址，**「因此一个线程可以读取、写入甚至擦除另一个线程的堆栈」**。线程之间除了共享同一内存空间外，还具有如下不同的内容： 
+
+
+
+![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)  
+
+#### 线程的创建
+
+```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），保存每个线程的状态。但是，与进程相比，线程之间的上下文切换有一点主要区别：地址空间保持不变（即不需要切换当前使用的页表）。
+
+线程和进程之间的另一个主要区别在于栈。在简单的传统进程地址空间模型 [我们现在可以称之为单线程（single-threaded）进程] 中，只有一个栈，通常位于地址空间的底部，然而，在多线程的进程中，每个线程独立运行，当然可以调用各种例程来完成正在执行的任何工作。不是地址空间中只有一个栈，而是每个线程都有一个栈。假设有一个多线程的进程，它有两个线程，结果地址空间看起来不同。如下图： 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_process_memory_diff.png?raw=true)   
+
+在图中，可以看到两个栈跨越了进程的地址空间。因此，所有位于栈上的变量、参数、返回值和其他放在栈上的东西，将被放置在有时称为线程本地（thread-local）存储的地方，即相关线程的栈。你可能注意到，多个栈也破坏了地址空间布局的美感。以前，堆和栈可以互不影响地增长，直到空间耗尽。多个栈就没有这么简单了。幸运的是，通常栈不会很大（除了大量使用递归的程序）。
+
+
+#### 线程系统调用
+
+系统调用：用户在编程时可以调用的操作系统功能。
+系统调用是操作系统提供给编程人员的唯一接口。 可以使CPU状态从用户态陷入内核态。每个操作系统都提供几百种系统调用(进程控制、进程通信、文件使用、目录操作、设备管理、信息维护等).    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/linux_system_call_1.png?raw=true)
+
+进程通常会从当前的某个单线程开始，然后这个线程通过调用一个库函数（比如 `thread_create`）创建新的线程。线程创建的函数会要求指定新创建线程的名称。创建的线程通常都返回一个线程标识符，该标识符就是新线程的名字。
+
+当一个线程完成工作后，可以通过调用一个函数（比如 `thread_exit`）来退出。紧接着线程消失，状态变为终止，不能再进行调度。在某些线程的运行过程中，可以通过调用函数例如 `thread_join` ，表示一个线程可以等待另一个线程退出。这个过程阻塞调用线程直到等待特定的线程退出。在这种情况下，线程的创建和终止非常类似于进程的创建和终止。
+
+另一个常见的线程是调用 `thread_yield`，它允许线程自动放弃 CPU 从而让另一个线程运行。这样一个调用还是很重要的，因为不同于进程，线程是无法利用时钟中断强制让线程让出 CPU 的。
+
+
+
+### 线程实现
+
+线程的调度却与进程调度有稍许不同。由于线程是在进程的基础上产生的概念（进程里面的一个执行序列），其调度可以由进程负责。当然，我们也可以将线程的调度交给操作系统。而这两种不同的调度推手就形成了线程的两种实现：用户态实现和内核态实现。由进程自己管理就是用户态线程的实现，由操作系统管理就是内核态线程实现。用户态和内核态的判断以线程表所处的位置为依据：位于内核叫内核态实现，位于用户层叫用户态实现。所以线程的实现主要有三种实现方式：   
+
+- 在用户空间中实现线程；
+- 在内核空间中实现线程；
+- 在用户和内核空间中混合实现线程。
+
+下面我们分开讨论一下
+
+#### 在内核中实现线程
+
+由操作系统来管理线程有很多好处，最重要的好处是用户编程简单。因为线程的复杂性由操作系统承担，用户程序员在编程时无需管理线程的调度，即无需担心线程什么时候会执行、什么时候会挂起。另外一个重要好处是，如果一个线程执行阻塞操作，操作系统可以从容地调度另外一个线程执行。因为操作系统能够监控所有的线程。
+
+那么内核态线程实现有什么缺点呢？首先是效率较低。因为线程在内核态实现，每次线程切换都需要陷入到内核，由操作系统来进行调度。而从用户态陷入到内核态是要花时间的。另外，内核态实现占用内核稀缺的内存资源，因为操作系统需要维护线程表。操作系统所占内存空间一旦装载结束后就已经固定，无法动态改变。由于线程的数量通常大大多于进程的数量，因此随着线程数量的增加，操作系统内核空间将迅速耗尽。
+
+如果要建立进程线程，但内核空间不够了，怎么办？我们可以做的选择有：“杀死”别的进程；创建失败；让它等一下。前面说过，“杀死”别的进程是一件很不好的事情，因为将造成服务不确定性。宣称创建失败也很差。因为创建失败有可能意味着某个进程无法往前推进，这违反了我们前面说过的进程模型的时序推进要求。让创建者等一下，这要看创建的是什么进程和线程了。如果是系统进程线程，等一下可能意味着关键服务无法按时启动；如果是用户进程线程，等一下可能引起用户的强烈不满。而且，等多久谁也不知道。那在内核空间满了后，应该怎么办呢？打一个战场上的比方就清楚了。如果战场上对手太厉害了，想再调个师的军队，结果没有，怎么办？投降。也就是说，如果内核空间溢出，操作系统将停止运转。因为要创立的进程可能很重要，所以不能不创建。所以最好的结局是“死掉”。别人发现系统“死了”就会采取行动来补救。如果操作系统还要运转，却不能正确地运转，那是很危险的事情。操作系统采取的这种行动在灾难应对领域称为“无害遽止”。但上面两个缺点还不是最致命的。最致命的是内核态实现需要修改操作系统，这在线程概念提出之初是一件很难办到的事情。试想，如果你作为研究人员提出了线程概念，然后你去找一家操作系统研发商，要求其修改操作系统，加入线程的管理，结果会怎样？操作系统开发商会请你走开。有谁敢把一个还未经证明的新概念加入到对计算机影响甚大的操作系统里？除非我们先证明线程的有效性，否则很难说服他人修改操作系统。这样，就有了线程的用户态实现。
+
+现在我们考虑使用内核来实现线程的情况，此时不再需要运行时环境了。另外，每个进程中也没有线程表。相反，在内核中会有用来记录系统中所有线程的线程表。当某个线程希望创建一个新线程或撤销一个已有线程时，它会进行一个系统调用，这个系统调用通过对线程表的更新来完成线程创建或销毁工作。
+
+当某个线程希望创建一个新线程或撤销一个已有线程时，它会进行一个系统调用，这个系统调用通过对线程表的更新来完成线程创建或销毁工作。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_kernel.png?raw=true)  
+
+内核中的线程表持有每个线程的寄存器、状态和其他信息。这些信息和用户空间中的线程信息相同，但是位置却被放在了内核中而不是用户空间中。另外，内核还维护了一张进程表用来跟踪系统状态。
+
+所有能够阻塞的调用都会通过系统调用的方式来实现，当一个线程阻塞时，内核可以进行选择，是运行在同一个进程中的另一个线程（如果有就绪线程的话）还是运行一个另一个进程中的线程。由于在内核中创建或者销毁线程的开销比较大，所以某些系统会采用可循环利用的方式来回收线程。当某个线程被销毁时，就把它标志为不可运行的状态，但是其内部结构没有受到影响。稍后，在必须创建一个新线程时，就会重新启用旧线程，把它标志为可用状态。
+
+如果某个进程中的线程造成缺页故障后，内核很容易的就能检查出来是否有其他可运行的线程，如果有的话，在等待所需要的页面从磁盘读入时，就选择一个可运行的线程运行。这样做的缺点是系统调用的代价比较大，所以如果线程的操作（创建、终止）比较多，就会带来很大的开销。
+
+
+
+#### 在用户空间中实现线程
+
+把整个线程包放在用户空间中，内核对线程一无所知，它不知道线程的存在。所有的这类实现都有同样的通用结构： 
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_user.png?raw=true)  
+
+> `运行时系统(Runtime System)` 也叫做运行时环境，该运行时系统提供了程序在其中运行的环境。此环境可能会解决许多问题，包括应用程序内存的布局，程序如何访问变量，在过程之间传递参数的机制，与操作系统的接口等等。编译器根据特定的运行时系统进行假设以生成正确的代码。通常，运行时系统将负责设置和管理堆栈，并且会包含诸如垃圾收集，线程或语言内置的其他动态的功能。
+
+在用户空间管理线程时，每个进程需要有其专用的`线程表(thread table)`，用来跟踪该进程中的线程。这些表和内核中的进程表类似，不过它仅仅记录各个线程的属性，如每个线程的程序计数器、堆栈指针、寄存器和状态。该线程表由运行时系统统一管理。当一个线程转换到就绪状态或阻塞状态时，在该线程表中存放重新启动该线程的所有信息，与内核在进程表中存放的信息完全一样。
+
+
+
+在用户空间中实现线程要比在内核空间中实现线程具有这些方面的优势：考虑如果在线程完成时或者是在调用 `pthread_yield` 时，必要时会进程线程切换，然后线程的信息会被保存在运行时环境所提供的线程表中，然后，线程调度程序来选择另外一个需要运行的线程。保存线程的状态和调度程序都是`本地过程`，**所以启动他们比进行内核调用效率更高。因而不需要切换到内核，也就不需要上下文切换，也不需要对内存高速缓存进行刷新，因为线程调度非常便捷，因此效率比较高**。
+
+在用户空间实现线程还有一个优势就是**它允许每个进程有自己定制的调度算法**。例如在某些应用程序中，那些具有垃圾收集线程的应用程序（知道是谁了吧）就不用担心自己线程会不会在不合适的时候停止，这是一个优势。用户线程还具有较好的可扩展性，因为内核空间中的内核线程需要一些表空间和堆栈空间，如果内核线程数量比较大，容易造成问题。
+
+
+
+尽管在用户空间实现线程会具有一定的性能优势，但是劣势还是很明显的，你如何实现`阻塞系统调用`呢？假设在还没有任何键盘输入之前，一个线程读取键盘，让线程进行系统调用是不可能的，因为这会停止所有的线程。所以，**使用线程的一个目标是能够让线程进行阻塞调用，并且要避免被阻塞的线程影响其他线程**。
+
+与阻塞调用类似的问题是`缺页中断`问题，实际上，计算机并不会把所有的程序都一次性的放入内存中，如果某个程序发生函数调用或者跳转指令到了一条不在内存的指令上，就会发生页面故障，而操作系统将到磁盘上取回这个丢失的指令，这就称为`缺页故障`。而在对所需的指令进行读入和执行时，相关的进程就会被阻塞。如果只有一个线程引起页面故障，内核由于甚至不知道有线程存在，通常会把整个进程阻塞直到磁盘 I/O 完成为止，尽管其他的线程是可以运行的。
+
+另外一个问题是，如果一个线程开始运行，该线程所在进程中的其他线程都不能运行，除非第一个线程自愿的放弃 CPU，在一个单进程内部，没有时钟中断，所以不可能使用轮转调度的方式调度线程。除非其他线程能够以自己的意愿进入运行时环境，否则调度程序没有可以调度线程的机会。
+
+
+
+#### 在用户和内核空间中混合实现线程
+
+鉴于用户态和内核态的线程模型都存在缺陷，因此现代操作系统将二者结合起来使用。用户态的执行系统负责进程内部线程在非阻塞时的切换；内核态的操作系统负责阻塞线程的切换。即我们同时实现内核态和用户态线程管理。其中内核态线程数量较少，而用户态线程数量较多。每个内核态线程可以服务一个或多个用户态线程。换句话说，用户态线程被多路复用到内核态线程上。例如，某个进程有5个线程，我们可以将5个线程分成两组，一组3个线程，另一组2个线程。每一组线程使用一个内核线程。这样，该进程将使用两个内核线程。如果一个线程阻塞，则与其同属于一组的线程皆阻塞，但另外一组线程却可以继续执行。
+
+结合用户空间和内核空间的优点，设计人员采用了一种`内核级线程`的方式，然后将用户级线程与某些或者全部内核线程多路复用起来
+
+![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函数。这样就实现了从用户态到内核态的转换，并完成系统调用所要求的功能。
+
+
+
+### 线程同步
+
+引入线程后，也引入了一个巨大的问题，即多线程程序的执行结果有可能是不确定的。而不确定则是我们人类非常反感的东西。那么如何在保持线程这个概念的同时，消除其执行结果的不确定性呢？答案是线程的同步。
+
+线程同步的目的就是不管线程之间的执行如何穿插，其运行结果都是正确的。或者说，要保证多线程执行下结果的确定性。而在达到这个目标的同时，要保持对线程执行的限制越少越好。除此之外，线程同步的另外一个目的涉及执行效率。除了前面说过的多线程执行的结果是不确定的之外，其执行效率也是不确定的。比如，在某段时间内，线程A执行了5条指令，而线程B只执行了3条指令。线程A比线程B多执行了两条指令。但这并不是问题的关键。问题的关键是到底线程A是否比线程B执行的多，或者是多多少等，皆是不确定的。如果我们想使其变得确定，就需要进行线程同步。
+
+
+
+锁有两个基本操作：
+
+- 闭锁
+
+    闭锁就是将锁锁上，其他人进不来
+
+- 开锁
+
+    开锁就是你做的事情做完了，将锁打开，别的人可以进去了。闭锁操作有两个步骤，分别如下：
+
+    - 等待锁达到打开状态
+    - 获得锁并锁上
+
+
+
+### 死锁
+
+如果有一组线程，每个线程都在等待一个事件的发生，而这个事件只能由该组线程里面的另一线程发出，则称这组线程发生了死锁。
+
+死锁的出现需要同时满足下面四个条件
+
+> - 互斥(Mutual Exclusion)：一次只能有一个进程使用资源。如果另一个进程请求该资源，则必须延迟请求进程，直到释放该资源为止。
+> - 保持并等待(Hold and Wait)：必须存在一个进程，该进程至少持有一个资源，并且正在等待获取其他进程当前所持有的资源。
+> - 无抢占(No Preemption)：资源不能被抢占，也就是说，在进程完成其任务之后，只能由拥有它的进程自动释放资源。
+> - 循环等待(Circular Wait) ：必须存在一组 {p0，p1，..... pn} 的等待进程，使 p0 等待 p1 持有的资源，p1 等待由 p2 持有的资源， pn-1 正在等待由 pn 持有的资源，而 pn 正在等待由 p0 持有的资源。
+
+
+
+多道编程或者多线程编程除了要应对死锁之外，还有一个问题必须面对：饥饿。更准确地说是资源饥饿。资源饥饿指的是某个线程一直等不到它所需要的资源，从而无法向前推进。这就像一个人因饥饿而无法成长一样。刚听上去饥饿像是一个与死锁不同的问题。但仔细考虑，却发现它实际上是死锁的一种通例。因为处于死锁状态的所有线程均无法获得其需要的资源，所以都处于饥饿状态。死锁实际上就是饥饿。对于处于饥饿状态的线程来说，它因为无法往前推进，又有一点死锁的味道。因此，饥饿有时也称为死锁的“孪生兄弟”。不过，这里需要注意的是，饥饿和死锁还是有所不同的。处于死锁的线程必须多于1个，且处于一个死锁线程组的线程所需资源均为该组里其他线程所持有。而处于饥饿的线程可以只有1个，并且其所需要的资源可以被任何线程所占有。
+
+除此之外，饥饿还有另外一种特例：活锁。在活锁状态下，处于活锁线程组里的线程状态可以改变，但是整个活锁组的线程无法推进。活锁可以用两个人过一条很窄的小桥来比喻：为了让对方先过，两个人都想给对方让路而闪身到一边，但由于两个人都同时进行此种动作，有可能两个人都同时运动到左边，然后又同时运动到右边。这样，虽然两个人的状态一直在变化，但却都无法往前推进。由此可见，活锁是死锁的通例。
+
+从上述分析可以看出，死锁、活锁、饥饿是一个包含与被包含的关系。死锁是活锁的特例，而活锁又是饥饿的特例。在多道编程时，我们不只要应对死锁，还需要应对活锁和饥饿，而由于它们之间存在类似性，死锁应对的手段也可以在一定程度上用来应对活锁和饥饿，因为活锁和饥饿是死锁的通例，且死锁是无法完全避免的，活锁和饥饿也是不可完全避免的。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lock_hung.jpg?raw=true)        
+
+
+
+### 死锁解决方法
+
+- 鸵鸟策略：不理睬
+- 预防策略：破坏产生条件中任意一个
+- 避免策略： 精心分配资源，动态避免死锁
+- 检测与解除死锁：系统自动检测，并且解除
+
+
+
+
+
+## 进程和线程的区别
+
+进程有如下两个特点: 
+
+-  资源所有权：进程包括存放进程映像的虚拟地址空间，进程映像是程序、数据、栈和进程控制块中定义的属性集。进程总具有对资源的控制权和所有权，这些资源包括内存、I/O通道、I/O设备和文件。操作系统能提供预防进程间发生不必要资源冲突的保护功能。
+- 调度/执行：进程执行时采用一个或多程序的执行路径，不同进程的执行过程会交替执行。因此进程具有执行态和分配给其的优先级，是可被操作系统调度和分派的实体。
+
+上面这两个特点是独立的，因此操作系统能分别处理它们。为了区分这两个特点，通常将分派的单位成为线程或轻量级进程，而将拥有资源所有权的单位成为进程或任务。
+
+- 线程（thread）：可分派的工作单元。它包括处理器上下文环境（包含程序计数器和栈指针）和栈中自身的数据区域。线程顺序执行且可以中断，因此处理器可以转到另一个线程。
+- 进程（process)：一个或多个线程和相关系统资源（如包含程序和代码的存储空间、打开的文件和设备）的集合。它严格对应于一个正在执行的程序的概念。通过把一个应用程序分解成多个线程，程序员可以很大程度上控制应用程序的模块性及相关事件的时间安排。
+
+线程比进程更轻量级，所以它们比进程更容易（更快）创建，也更容易撤销。在许多系统中，创建一个线程比创建一个进程要快10~100倍。线程会共享它所在进程的地址空间和其他资源。
+
+
+
+进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。
+
+1. 简而言之,一个程序至少有一个进程,一个进程至少有一个线程。
+2. 线程的划分尺度小于进程，使得多线程程序的并发性高。
+3. 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
+4. 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
+5. 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
+
+
+
+
+
+## 一个程序的执行过程
+
+```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"。
+
+---
+
+
+
+- [上一篇: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)
+
+- [下一篇:3.内存管理](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/3.%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86.md)
+
+
+---
+
+- 邮箱 ：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..a0b3297b
--- /dev/null
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -0,0 +1,505 @@
+# 3. 内存管理
+
+
+内存管理机制负责对内存架构进行管理，使程序在内存架构的任何一个层次上的存放对于用户来说都是一样的。用户无须担心自己的程序是存储在缓存、主存、磁盘还是磁带上，反正运行、计算、输出的结果都一样。而内存管理实现这种媒介透明的手段就是虚拟内存。用我们多次讲过的“抽象”来说，虚拟内存就是操作系统提供给用户的另一个“幻象”。这个幻象构建在内存架构的顶端，给用户提供一个比物理主存空间大许多的地址空间。
+
+虚拟内存系统负责为程序提供一个巨大的、稀疏的、私有的地址空间的假象，其中保存了程序的所有指令和数据。操作系统在专门硬件的帮助下，通过每一个虚拟内存的索引，将其转换为物理地址，物理内存根据获得的物理地址去获取所需的信息。操作系统会同时对许多进程执行此操作，并且确保程序之间互相不会受到影响，也不会影响操作系统。整个方法需要大量的机制（很多底层机制）和一些关键的策略。
+
+常用概念: 
+
+- 页框：内存中固定长度的块
+- 页：固定长度的数据块，存储在二级存储器中（如磁盘）。数据页可以临时赋值到内存的页框中。
+- 段：变长数据块，存储在二级存储器中。整个段可以临时复制到内存的一个可用区域中（分段），或可以将一个段分为许多页，然后将每页单独复制到内存中（分段与分页相结合）
+
+
+
+## 内存管理的功能
+
+内存管理的主要操作是处理器把程序装入内存中执行。内存管理的功能有：    
+
+1. 内存空间的分配与回收：由操作系统完成主存储器空间的分配和管理，使程序员摆脱存储分配的麻烦，提高编程效率。
+2. 地址转换：在多道程序环境下，程序中的逻辑地址与内存中的物理地址不可能一致，因此存储管理必须提供地址变换功能，把逻辑地址转换成相应的物理地址。
+3. 内存空间的扩充：利用虚拟存储技术或自动覆盖技术，从逻辑上扩充内存。
+4. 存储保护：保证各道作业在各自的存储空间内运行，互不干扰。
+
+
+
+进程对应的内存空间中所包含的6种不同的数据区：  
+
+- 代码段(code segment):用来存放程序运行代码的一块内存空间。此空间大小在代码运行前就已经确定。内存空间一般属于只读，某些架构的代码也允许可写。
+
+- 数据段(data segment): 存储初始化的全局变量和初始化的static变量。数据段中的数据的生存期是随程序持续性(随进程持续性):进程创建就存在，进程死亡就消失。
+
+- 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等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）
+
+- 栈(stack):
+    它的申请和释放操作是编译器来隐式管理的，所以有时也称为自动（automatic）内存。
+    栈是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段中存放变量）。栈的生存期随代码块持续性，代码块运行就给你分配空间，代码块结束就自动回收空间。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的先进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存、交换临时数据的内存区。
+
+上述几种内存区域中数据段、BSS和堆通常是被连续存储的——内存位置上是连续的，而代码段和栈往往会被独立存放。有趣的是，堆和栈两个区域关系很“暧昧”，他们一个向下“长”（i386体系结构中栈向下、堆向上），一个向上“长”，相对而生。但你不必担心他们会碰头，因为他们之间间隔很大（到底大到多少，你可以从下面的例子程序计算一下），绝少有机会能碰到一起。
+
+
+##### 虚拟存储技术
+所谓虚拟存储技术是指：当进程运行时，先将其一部分装入内存，另一部分暂留在磁盘，当要执行的指令或访问的数据不在内存时，由操作系统自动完成将它们从磁盘调入内存的工作。
+虚拟地址空间即为分配给进程的虚拟内存。
+虚拟地址是在虚拟内存中指令或数据的位置，该位置可以被访问，仿佛它是内存的一部分。
+
+
+
+## 内存的演变
+
+在早些的操作系统中，并没有引入内存抽象的概念。程序直接访问和操作的都是物理内存，内存的管理也非常简单，除去操作系统所用的内存之外，全部给用户程序使用，想怎么折腾都行，只要别超出最大的容量。这种内存操作方式使得操作系统中存在多进程变得完全不可能，比如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)
+
+Stack和Heap中间有一块free space，即使没有用，也被占着，那如何才能解放这块区域呢，那就是虚拟内存。
+
+Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自互不干涉的进程地址空间。该空间是块大小为4G的线性虚拟空间，用户所看到和接触到的都是该虚拟地址，无法看到实际的物理内存地址。利用这种虚拟地址不但能起到保护操作系统的效果（用户不能直接访问物理内存），而且更重要的是，用户程序可使用比实际物理内存更大的地址空间。
+
+在讨论进程空间细节前，这里先要澄清下面几个问题：
+
+1. 4G的进程地址空间被人为的分为两个部分——用户空间与内核空间。用户空间从0到3G（0xC0000000），内核空间占据3G到4G。用户进程通常情况下只能访问用户空间的虚拟地址，不能访问内核空间虚拟地址。只有用户进程进行系统调用（代表用户进程在内核态执行）等时刻可以访问到内核空间。
+
+2. 用户空间对应进程，所以每当进程切换，用户空间就会跟着变化；而内核空间是由内核负责映射，它并不会跟着进程改变，是固定的。内核空间地址有自己对应的页表（init_mm.pgd），用户进程各自有不同的页表。
+
+3. 每个进程的用户空间都是完全独立、互不相干的。不信的话，你可以把上面的程序同时运行10次（当然为了同时运行，让它们在返回前一同睡眠100秒吧），你会看到10个进程占用的线性地址一模一样。
+
+
+
+![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWFnZXMyMDE3LmNuYmxvZ3MuY29tL2Jsb2cvMTMxMTQxMi8yMDE4MDIvMTMxMTQxMi0yMDE4MDIxNTEyMjY1NDM1OS0xNDcxMTE4NzM4LnBuZw?x-oss-process=image/format,png)
+
+
+
+### 固定分区
+
+大多数内存管理方案都假定操作系统占据内存中的某些固定部分，而内存中的其余部分则供多个用户进程使用。管理用户内存空间的最简单的方案就是对它分区，以形成若干边界固定的区域。
+
+固定分区分为两种： 
+
+- 使用大小相等的分区：此时小于等于分区大小的任何进程都可以装入任何可用的分区中。若所有分区都已满且没有进程处于就绪态或运行态，则操作系统可以换出一个进程的所有分区，并装入另一个进程，使得处理器有事可做。但是大小相等的分区有两个难点： 
+
+    - 程序可能太大而不能放到一个分区中。此时程序员必须使用覆盖技术设计程序，使得任何时候该程序只有一部分需要放到内存中。当需要的模块不在时，用户程序必须把这个模块装入程序的分区，覆盖该分区中的任何程序和数据。
+
+    - 内存的利用率非常低。任何程序，即使很小，都需要占据一个完整的分区。由于装入的数据块小于分区大小，因而导致分区内部存在空间浪费，这种现象称为内部碎片(internal fragmentation)。
+
+- 使用大小不等的分区：大小不等的分区可以缓解上面的两个问题，但是不能完全解决。
+
+虽然大小不等的分区带来了一定的灵活性，但是分区的数量在系统生成阶段已经确定，因而限制了系统中活动（未挂起）进程的数量。而且由于分区大小是在系统生成阶段事先设置的，因而小作业不能有效的利用分区空间。
+
+
+
+### 动态分区
+
+为了克服固定分区的确定，提出了动态分区。对于动态分区，分区长度和数量是可变的。程序装入内存时，系统会给它分配一块与其所需容量完全相等的内存空间。但是对于一个64MB的内存，如果装入前三个进程已经占用了很大一部分，剩下的部分对于第四个进程来说又太小，这样在内存的末尾就剩下一个“空洞”。而等第二个进程结束后腾出的足够的空间来装入第四个进程，但是由于第四个进程比第二个进程小，所有这里又形成了另一个小"空洞"。这样最终在内存中就会形成许多小空洞。随着时间的推移，内存中形成了越来越多的碎片，内存的利用率随之下降。这种现象称为外部碎片(external fragmentation)，指在所有分区外的存储空间变成了越来越多的碎片，这与前面所讲的内部碎片正好对应。 
+
+克服外部碎片的一种技术就是压缩(compaction)。操作系统不时的移动进程，使得进程占用的空间连续，并使所有空闲空间连成一片。但是压缩的困难之处在于，它是一个非常费时的过程，且会浪费处理器时间。
+
+
+
+### 伙伴系统
+
+固定分区和动态分区方案都有缺陷。固定分区方案限制了活动进程数量，且如果可用分区的大小与进程大小很不匹配，那么内存空间的利用率会非常低。动态分区的维护特别复杂，并且会引入进行压缩的额外开销。更有吸引力的一种折中方案是伙伴系统。 它是一种经典的内存分配方案，是一种特殊的“分离适配”算法。主要思想是将内存按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的内存块。
+
+
+
+### 重定位
+
+
+
+在大小相等的分区中一个进程在其声明周期中可能占据不同的分区。首次创建一个进程映像时，它被装入内存中的某个分区。以后该进程可能被换出，当它再次被换入时，可能被指定到与上一次不同的分区中。动态分区也存在同样的情况，压缩后内存中的进程也可能发生移动。因此，进程访问（指令和数据单元）的位置不是固定的。进程被换入或在内存中移动时，指令和数据单元的位置也发生变化。为了解决这个问题，需要区分几种地址类型： 
+
+- 逻辑地址（logical address）是指与当前数据在内存中的物理分配地址无关的访问地址，在执行对内存的访问之前必须把它转换为物理地址。
+- 相对地址（relative address）是逻辑地址的一个特例，他是相对于某些已知点（通常是程序的开始处）的存储单元。用户程序经过编译、汇编后形成目标代码，目标代码通常采用相对地址的形式，其首地址为0，其余地址相对于首地址而编址。
+- 物理地址（physical address）或绝对地址是数据在内存中的实际位置。
+
+系统采用运行时动态加载的方式把使用相对地址的程序加载到内存。通常情况下，被加载进程中所有内存访问都相对于程序的开始点。因此，在执行包括这类访问的指令时，需要有把相对地址转换为物理内存地址的硬件机制。这类地址转换就需要一个特殊的处理器寄存器（基址寄存器），其内容是程序在内存中的起始地址。还有一个界限寄存器指明程序的终止位置。
+
+将逻辑地址转换为物理地址的操作就叫做重定位。而把地址进行转换的功能部件就叫做内存管理单元(MMU， Memory Management Unit)。
+
+
+
+### 地址空间
+
+如果要使多个应用程序同时运行在内存中，必须要解决两个问题：`保护`和 `重定位`。第一种解决方式是用`保护密钥标记内存块`，并将执行过程的密钥与提取的每个存储字的密钥进行比较。这种方式只能解决第一种问题（破坏操作系统），但是不能解决多进程在内存中同时运行的问题。
+
+还有一种更好的方式是创造一个存储器抽象：`地址空间(the address space)`。就像进程的概念创建了一种抽象的 CPU 来运行程序，地址空间也创建了一种抽象内存供程序使用。
+
+#### 基址寄存器和变址寄存器
+
+在多道编程环境下，由于程序加载到内存的地址不是固定的（有多个地方可加载），我们必须对地址进行翻译。那么如何来翻译呢？我们看到，一个程序是加载到内存里事先划分好的某片区域，而且该程序是整个加载进去。该程序里面的虚地址只要加上其所占区域的起始地址即可获得物理地址。因此，我们的翻译过程非常简单：物理地址=虚拟地址+程序所在区域的起始地址
+
+程序所在区域的起始地址称为（程序）基址。另外，由于有多个程序在内存空间中，我们需要进行地址保护。由于每个程序占用连续的一片内存空间，因此只要其访问的地址不超出该片连续空间，则为合法访问。因此，地址保护也变得非常简单，只要访问的地址满足下列条件即为合法访问：
+
+程序所在区域的起始地址≤有效地址≤程序所在区域的起始地址+程序长度
+
+由此可见，我们只需要设置两个端值：基址和变址，即可达到地址翻译和地址保护的目的。
+这两个端值可以由两个寄存器来存放，分别称为基址寄存器和变址寄存器。在固定分区下，基址就是固定内存分区中各个区域的起始内存地址，而变址则是所加载程序的长度（记住，不是内存各个分区的上限）。
+
+这样，每次程序发出的地址需要和极限比较大小；如果大于极限，则属非法访问。在这个时候我们将陷入内核，终止进程（在个别操作系统上，也可能进入一个异常处理的过程）；否则将基址加上偏移获得物理地址，就可以合法访问这个物理地址。
+
+`动态重定位(dynamic relocation)`技术，它就是通过一种简单的方式将每个进程的地址空间映射到物理内存的不同区域。
+
+- 基址寄存器：存储数据内存的起始位置
+- 变址寄存器：存储应用程序的长度。
+
+每当进程引用内存以获取指令或读取、写入数据时，CPU 都会自动将`基址值`添加到进程生成的地址中，然后再将其发送到内存总线上。同时，它检查程序提供的地址是否大于或等于`变址寄存器` 中的值。如果程序提供的地址要超过变址寄存器的范围，那么会产生错误并中止访问。
+
+在动态重定位的过程中，只有很少的硬件参与，但获得了很好的效果。
+一个基址寄存器将虚拟地址转换为物理地址。
+一个界限寄存器确保这个地址在进程地址空间的范围内。
+它们一起提供了既简单又高效的虚拟内存机制。这种基址寄存器配合界限寄存器的硬件结构是芯片中的（每个CPU一对）。有时我们将CPU的这个负责地址转换的部分统称为内存管理单元（Memory Management Unit，MMU）。
+
+### 分页
+
+大小不等的固定分区和大小可变的分区技术在内存的使用上都是低效的，前者会产生内部碎片，后者会产生外部碎片。但是，如果内存被划分成大小固定、相等的块，切块相对比较小，每个进程也被分成同样大小的小块，那么进程中称为页的块可以分配到内存中称为页框的可用块。这样在使用分页技术时，每个进程在内存中浪费的空间，仅仅是进程最后一页的一小部分形成的内部碎片。没有任何外部碎片。
+
+分页系统的核心就是将虚拟内存空间和物理内存空间皆划分为大小相同的页面，如4KB、8KB或16KB等，并以页面作为内存空间的最小分配单位，一个程序的一个页面可以存放在任意一个物理页面里。这样，由于物理空间是页面的整数倍，并且空间分配以页面为单位，将不会再产生外部碎片。同时，由于一个虚拟页面可以存放在任何一个物理页面里，空间增长也容易解决：只需要分配额外的虚拟页面，并找到一个闲置的物理页面存放即可。在分页系统下，一个程序发出的虚拟地址由两部分组成：页面号和页内偏移值。
+
+这样操作系统需要为每个进程维护一个页表（page table）。页表给出了该进程的每页所对应页框的位置。在程序中每个逻辑地址包括一个页号和该页中的偏移量。在分页中，逻辑地址到物理地址的转换仍然由处理器硬件完成，给出逻辑地址（页号，偏移量）后，处理器使用页表产生物理地址（页框号，偏移量）。
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/page_memory_1.png?raw=true)
+
+采用分页技术的分区相当小，一个程序可以占据多个分区，并且这些分区不需要是连续的。
+
+为了使分页方案更加方便，规定页和页框的大小必须是2的幂，以便容易的表示出相对地址。
+
+
+
+#### 地址翻译
+
+从上面的分析可以看出，分页系统要能够工作的前提是：对于任何一个虚拟页面，系统知道该页面是否在物理内存中，如果在的话，其对应的物理页面是哪个；如果不在的话，则产生一个系统中断（缺页中断），并将该虚页从磁盘转到内存，然后将分配给它的物理页面号返回。也就是说，页面管理系统要能够将虚拟地址转换为物理地址。
+
+因此，分页系统的核心是页面的翻译，即从虚拟页面到物理页面的映射。而这个翻译过程由内存管理单元（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)        
+
+
+
+如果编译器只在一个虚拟空间活动，则所有的数据结构或表格均在一个虚拟空间分配，这样就必然发生不同的数据结构占据虚拟空间的不同部分的情况。这样，当一个数据结构空间需要增长时，就会碰到处于其上的其他数据结构而造成无法增长。那么如果某个数据结构无法增长，例如词法树所占空间无法增长，则编译过程将失败。
+
+当然，编译器在工作时会为每个数据结构多分配一些空间来容纳其随后的增长。而且这些空间的大小都经过经验数据测试，可以应对大多数情况下数据结构增长的需要。但是，谁也不能保障不会碰到一个很大的程序，以致某个数据结构的增长空间不够的情况。例如，如果一个程序里定义的变量奇多无比，则符号表所占的空间将大幅增加。
+
+那么怎么解决这个问题呢？记住，这里的碰撞可是在虚拟空间中的碰撞，而不是物理空间的碰撞。解决的办法自然是增加虚拟空间的容量。但是虚拟空间的大小受寻址宽度的限制而无法增长。剩下的办法就只能让一个程序使用多个虚拟空间！由于分页系统只使用一个虚拟地址空间，自然解决不了这个问题。那么要解决这个问题显然需要一种新的内存管理模式。这种新的模式就是分段管理系统。
+
+### 分段
+
+分段管理就是将一个程序按照逻辑单元分成多个程序段，每一个段使用自己单独的虚地址空间。例如，对于编译器来说，我们可以给其5个段，占用5个虚地址空间。
+
+这样，一个段占用一个虚地址空间，就不会再发生空间增长时碰撞到另一个段的问题。从而避免因空间不够而造成编译失败的情况。如果某个数据结构对空间的需求超过整个虚地址能够提供的空间，则编译仍将失败。不过出现这种可能的概率恐怕不会比太阳从西边出来的概率高出多少。
+
+一个程序占据多个虚拟地址空间，那么不同的段有可能有同样的虚拟地址空间。如果要区分一个虚拟地址所在的段，我们必须在虚拟地址前面冠以一个前缀，即该地址所在的段号。也就是说，在分段情况下，一个虚拟地址将由段号和段内偏差两个部分构成，
+
+
+
+采用分段技术，可以把用户进程地址空间按程序的自身的逻辑关系和与其相关的数据划分到几个段（fragment）中。尽管段有最大长度限制，但并不要求所有程序的所有段的长度都相等。同样内存空间也会被动态的划分为若干长度不相同的取悦，称为物理段，每个物理段由起始地址和长度确定。和分页一样，采用分段技术时的逻辑地址也是由两部分组成：段号和偏移量。 以段为单位进行分配，每段在内存中占据连续空间，但各段之间可以不相邻。
+
+由于使用大小不等的段，分段类似于动态分区。在未采用覆盖方案或使用虚存的情况下，为执行一个程序，需要把它的所有段都装入内存。与动态分区不同的是，在分段方案中，一个程序可以占据多个分区，并且这些分区不要求是连续的。分段消除了内部碎片，但是和动态分区一样，他会产生外部碎片。不过由于进程被分成多个小块，因此外部碎片也会很小。
+
+采用大小不等的段的另一个结果是，逻辑地址和物理地址间不再是简单的对应关系。类似于分页，在简单的分段方案中，每个进程都有一个段表，系统也会维护一个内存中的空闲块列表。每个段表都必须给出相应段在内存中的起始地址，还必须指明段的长度，以确保不会使用无效地址。
+
+
+
+如果说分页存储器管理方式引入的目的是提高内存的利用率，那么分段存储器管理方式的引入便是为了方便用户的使用。引入分段存储器管理方式主要是为了满足用户方便编程、分段共享和分段保护等要求。
+
+分段存储管理方式要求每个程序的地址空间按照自身的逻辑关系划分成若干段，比如主程序段、子程序段、数据段、堆栈段等，每个段都有自己的名字。为了简单，通常可用一个段号来代替段名，每个段都从0开始独立编址，段内地址连续。段的长度由相应的逻辑信息组的长度决定，因而各段的长度不等。分配内存时，为每个段分配一连续的存储空间，段间地址空间可以不连续。
+
+
+
+分页和分段的两个特点: 
+
+- 进程中的所有内存访问的都是逻辑地址，这些逻辑地址会在运行时把动态地址转换为物理地址。这意味着一个进程可被换入或换出内存，因此进程可在执行过程中的不同时刻占据内存中的不同区域。
+- 一个进程可划分为许多块（页和段），在执行过程中，这些块不需要连续的位于内存中。动态运行时地址转换和页表或段表的使用使得这一点成为可能。
+
+由于上面这两个特点的存在，那么在一个进程的执行过程中，该进程不需要所有页或段都在内存中。如果内存中保存有待取的下一条指令所在块（段或页）及待访问的下一个数据单元所在块，那么执行至少可以暂时继续下去。我们用术语“块”来表示页或段。处理器在需要访问一个不在内存中的逻辑地址时，会产生一个中断，这表明出现了内存访问故障。操作系统会把被中断的进程置于堵塞态。要继续执行这个进程，操作系统必须把包含引发访问故障的逻辑地址的进程块读入内存。为此操作系统产生一个磁盘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)
+
+#### 分段的优缺点
+
+逻辑分段的优点十分明显。首先，每个逻辑单元可单独占一个虚拟地址空间，这样使得编写程序的空间大为增长，几乎可以编写出没有尺寸限制的程序来。其次，由于段是按逻辑关系而分，共享起来就非常方便。不会出现分页系统下一个页面里面可能同时包含数据和代码而造成共享不便的问题。由于不同的逻辑段使用不同的基址与极限对，我们可以对不同的段采用不同的保护措施。最后，对于空间稀疏的程序来说，分段管理将节省大量的空间。因为空余的部分不用分配任何虚拟空间；而在分页下，空余的空间仍然需要分配虚拟页面，只不过该页面非法而已。而在上下文切换时要更换的内容很简单：段表。因为段表很小，这种切换非常容易。
+
+分段管理的缺点也十分明显。既然是分段，就存在前面基本内存管理时介绍过的缺点：外部碎片和一个段必须全部加载到内存。一般来说，一个程序的所有逻辑段是同时需要的。如果实行分段管理，则由于每个段必须全部加载到内存，这就造成了我们在基本内存管理时已经遇到过的一个问题：一个程序必须同时全部加载到内存才能执行。当然，解决这个问题可以使用重叠（overlay）。但我们已经尝过分页系统好处后再使用overlay显然有“优汰劣胜”的味道。
+
+那么我们的解决办法是什么呢？分页。但这次的分页不是前面的直接对程序进程分页，而是对程序里面的段进行分页。这就形成了所谓的段页式内存管理模式。这种段内分页是前面讲过的页式内存管理的否定之否定。
+
+### 段页式存储管理方案
+
+段页式管理就是将程序分为多个逻辑段，在每个段里面又进行分页，即将分段和分页组合起来使用。这样做的目的就是想同时获得分段和分页的好处，但又避免了单独分段或单独分页的缺陷。如果我们将每个段看做一个单独的程序，则逻辑分段就相当于同时加载多个程序。
+
+综合页式、段式方案的优点，克服两者的缺点。用户进程先按段划分，每一段再按页面划分。内存分配还是以页为单位进行分配。
+
+
+
+
+
+## 虚拟内存
+
+每个进程访问自己的私有虚拟地址空间（virtual address space）（有时称为地址空间，address space），操作系统以某种方式映射到机器的物理内存上。一个正在运行的程序中的内存引用不会影响到其他进程（或操作系统本身）的地址空间。对于正在运行的程序，它完全拥有自己的物理内存。但实际情况是，物理内存是由操作系统管理的共享资源。
+
+
+
+面对越来越大的程序,常常产生程序>内存的问题,为解决这种问题,虚拟内存的概念得到普及.
+
+虚拟内存是一种内存分配方案，是一项可以用来辅助内存分配的机制。我们知道，应用程序是按页装载进内存中的。但并不是所有的页都会装载到内存中，计算机中的硬件和软件会将数据从 RAM 临时传输到磁盘中来弥补内存的不足。如果没有虚拟内存的话，一旦你将计算机内存填满后，计算机会对你说呃，不，对不起，您无法再加载任何应用程序，请关闭另一个应用程序以加载新的应用程序。对于虚拟内存，计算机可以执行操作是查看内存中最近未使用过的区域，然后将其复制到硬盘上。虚拟内存通过复制技术实现了 妹子，你快来看哥哥能装这么多程序 的资本。复制是自动进行的，你无法感知到它的存在。
+
+要有效的使用处理器和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. 置换策略
+
+如果访问的页面不在内存中，则系统将产生缺页中断。缺页中断服务程序将负责把位于磁盘上的数据加载到物理内存来。如果物理内存还有空闲页面，那就直接使用空闲的页面。但如果物理内存已满，则需要挑选某个已经使用过的页面进行替换。那么挑选哪个页面合适呢？当内存中的所有页框都被占据，且需要读取一个新页以处理一次缺页中断时，置换策略决定置换当前内存中的哪一页。所有策略的目标都是移出最近最不能访问的页。
+
+- `最优算法`在当前页面中置换最后要访问的页面。不幸的是，没有办法来判定哪个页面是最后一个要访问的，`因此实际上该算法不能使用`。然而，它可以作为衡量其他算法的标准。
+- `NRU` 算法根据 R 位和 M 位的状态将页面氛围四类。从编号最小的类别中随机选择一个页面。NRU 算法易于实现，但是性能不是很好。存在更好的算法。
+- `FIFO` 会跟踪页面加载进入内存中的顺序，并把页面放入一个链表中。有可能删除存在时间最长但是还在使用的页面，因此这个算法也不是一个很好的选择。
+- `第二次机会`算法是对 FIFO 的一个修改，它会在删除页面之前检查这个页面是否仍在使用。如果页面正在使用，就会进行保留。这个改进大大提高了性能。
+- `时钟` 算法是第二次机会算法的另外一种实现形式，时钟算法和第二次算法的性能差不多，但是会花费更少的时间来执行算法。
+- `LRU` 算法是一个非常优秀的算法，但是没有`特殊的硬件(TLB)`很难实现。如果没有硬件，就不能使用 LRU 算法。
+- `NFU` 算法是一种近似于 LRU 的算法，它的性能不是非常好。
+- `老化` 算法是一种更接近 LRU 算法的实现，并且可以更好的实现，因此是一个很好的选择
+- 最后两种算法都使用了工作集算法。工作集算法提供了合理的性能开销，但是它的实现比较复杂。`WSClock` 是另外一种变体，它不仅能够提供良好的性能，而且可以高效地实现。
+
+总之，**「最好的算法是老化算法和WSClock算法」**。他们分别是基于 LRU 和工作集算法。他们都具有良好的性能并且能够被有效的实现。还存在其他一些好的算法，但实际上这两个可能是最重要的。
+
+##### 内存抖动
+
+在更换页面时，如果更换的页面是一个很快就会被再次访问的页面，则在此次缺页中断后很快又会发生新的缺页中断。在最坏情况下，每次新的访问都是对一个不在内存的页面进行访问，即每次内存访问都产生一次缺页中断，这样每次内存访问皆变成一次磁盘访问，而由于磁盘访问速度比内存可以慢一百万倍，因此整个系统的效率急剧下降。这种现象就称为内存抖动，或者抽打、抽筋（tras-hing）。
+
+
+
+#### 4. 驻留集管理
+
+对于分页式虚拟内存，在准备执行时，不需要也不可能把一个进程的所有页都读入内存。因此，操作系统必须决定读取多少页，即决定给特定的进程分配多大的内存空间。
+
+
+
+#### 5.清除策略
+
+与读取策略相反，清除策略用于确定何时将已修改的一页写回辅存。通常有两种选择： 
+
+- 请求式清除
+
+    只有当一页被选择用于置换时才能被写回辅存。
+
+- 预约式清除
+
+    将这些已修改的多页在需要使用他们所占据的页框之前成批写回辅存。
+
+#### 6.加载控制
+
+加载控制会影响到驻留内存中的进程数量，这称为系统并发度。加载控制策略在有效的内存管理中非常重要。如果某一时刻驻留的进程太少，那么所有进程都处于堵塞态的概率就较大，因为会有许多时间花费在交换上。另一方面，如果驻留的进程太多，平均每个进程的驻留集大小将会不够用，此时会频繁发生缺页中断，从而导致系统抖动。
+
+
+
+## 内存映射(共享内存)
+
+进程通过一个系统调用(mmap)将一个文件（或部分）映射到其虚拟地址空间的一部分，访问这个文件就像访问内存中的一个大数组，而不是对文件进行读写。
+
+在多数实现中，在映射共享的页面时不会实际读入页面的内容，而是在访问页面时，页面才会被每次一页的读入(虚拟内存的缺页处理)，磁盘文件则被当做后备存储。
+
+当进程退出或显式地解除文件映射时，所有被修改页面会写回文件。
+
+
+
+## 内存类型
+
+在运行一个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服务器或数据库管理系统，它永远不会退出），泄露内存就是很大的问题，最终会导致应用程序在内存不足时崩溃。当然，在某个程序内部泄露内存是一个更大的问题：操作系统本身。这再次向我们展示：编写内核代码的人，工作是辛苦的...
+
+### 内存耗尽杀手
+当内存严重不足的时候，页分配器在多次尝试直接页回收失败以后，就会调用内存耗尽杀手（OOM killer, OOM是“Out of Memory”的缩写），选择进程杀死，释放内存。
+
+
+## Android内存管理
+
+Android包含了标准Linux内核中内存管理设施的许多扩展，具体如下: 
+
+- ASHMem(Anonymous Shared Memory)：这个功能提供匿名共享内存，它将内存抽象为文件描述符。文件描述符可以传递给另一个进程以共享内存。
+
+- Pmen：这个功能分配虚拟内存，使的它在物理上是连续的，因此对于那些不支持虚拟内存的设备非常实用。
+
+- 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
+    - 该设置参数的存在是为了和旧版本的内核兼容
+
+    ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_process_adj.png?raw=true)
+
+    让RAM内存不足时，系统已经完成了进程的配置，使得内存溢出强制结束命令优先中止缓存(cache)类型的进程，尝试重新取得足够的所需内存，随后中止界面(home)类别、服务(service)类别，以此类推。在同一个oom_adj水平中，它将优先中止内存占用较大的进程。
+
+    Android的底层Linux未采用磁盘虚拟内存机制，程序只能使用物理内存作为最大内存，所以AmS中采用了自动杀死优先级较低进程的方法以达到释放内存的目的。
+
+
+
+
+
+
+
+
+
+---
+
+
+
+- [上一篇: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)
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：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..97635ae5
--- /dev/null
+++ "b/OperatingSystem/4.\350\260\203\345\272\246.md"
@@ -0,0 +1,92 @@
+# 4.调度
+
+
+
+在多道程序设计系统中，内存中有多个进程，每个进程要么正在处理器上运行，要么正在等待某些事件的发生，比如I/O完成。处理器调度的目的是：以满足系统目标（如响应时间、吞吐率、处理器效率）的方式，把进程分配到一个或多个处理器上执行。处理器（或处理器组）通过执行某个进程而保持忙状态，而此时其他进程处于堵塞状态。典型的调度有四种： 
+
+### 长程调度
+
+决定哪个程序可以进入系统中处理，因此它控制了系统的并发度。一旦允许进入，作业或用户程序就成为进程，并添加到供短程调度程序使用的队列中，等待调度。
+
+
+
+### 中程调度
+
+决定加入部分或全部位于内存中的进程集合。它是交换功能的一部分。典型情况下，换入（swapping-in）决定取决于管理系统并发度的需求。
+
+
+
+### 短程调度
+
+决定处理器执行哪个可运行进程。
+
+长程调度程序执行的频率相对较低，并且只是大致决定是否接受新进程和接受哪个新进程。要进行交换决定，中程调度程序需要执行的稍频繁一些。短程调度程序，也成为分派程序（dispatcher），执行的最频繁，它精确的决定下次执行哪个进程。导致当前进程堵塞或抢占当前运行进程的事发生时，调用短程调度程序。这类事件包括: 
+
+- 时钟中断
+- I/O中断
+- 操作系统调用
+- 信号（如信号量）
+
+
+
+### I/O调度
+
+决定可用I/O设备处理哪个进程挂起的I/O请求
+
+
+
+## 多处理器调度
+
+
+
+多处理器系统分为以下几类: 
+
+- 松耦合、分布式多处理器、集群：由一系列相对自治的系统组成，每个处理器都有自身的内存和I/O通道。
+- 专用处理器：I/O处理器是一个典型的例子。此时，有一个通用的主处理器，专用处理器由主处理器控制，并为主处理器提供服务。
+- 紧耦合多处理器：由一些列共享同一个内存并受操作系统完全控制的处理器组成。
+
+
+
+多处理器中的调度涉及三个相互关联的问题： 
+
+- 把进程分配到处理器
+
+    假设多处理器的结构是统一的，即没有哪个处理器在访问内核和I/O设备时具有物理上的特别优势，那么最简单的调度方法是把处理器视为一个资源池，并按照要求把进程分配到相应的处理器。但是这样就牵扯到静态还是动态的问题。如果一个进程从被激活到完成，一直被分配给同一个处理器，那么就需要为每个处理器维护一个专门的短程队列。这种方法的优点是调度的开销较小，因为相对于所有进程，关于处理器的分配只进行一次。静态分配的缺点就是一个处理器可能处于空闲状态，这时其队列为空，而另一个处理器却积压了许多工作。为了防止这种情况，需要使用一个公共队列。所有进程都进入一个全局队列，然后调度到任何一个可用的处理器中。这样，在一个进程的生命周期中，它可以在不同的时间于不同的处理器上执行。另一种分配策略是动态负载平衡，在该策略中，线程能在不同处理器所对应的队列之间转移。Linux采用的就是这种动态分配策略。
+
+    
+
+- 在单处理器上使用多道程序设计
+
+    单处理器能够在许多进程间切换，以达到较高的利用率和更好的性能。
+
+- 一个进程的实际分派
+
+    与多处理器调度相关的最后一个设计问题是选择哪个进程运行。在多道程序单处理器上，与简单的先来先服务策略相比，使用优先级或基于使用历史的高级调度算法可以提高性能。考虑多处理器时，这些复杂性可能是不必要的，甚至可能起到相反的效果，而相对比较简单的方法可能会更有效，而且开销比较低。
+
+
+
+
+
+### 线程调度
+
+在多处理器线程调度和处理器分配的各种方案中，有四个比较突出的方法：
+
+- 负载分配：进程不分配到某个特定的处理器。系统维护一个就绪线程的全局队列，每个处理器只要空闲就从队列中选择一个线程。
+- 组调度：一组相关的的线程基于一对一的原则，同时调度到一组处理器上运行。
+- 专用处理器分配：这种方法与负载分配方法正好相反，它通过把线程指定到处理器来定义隐式的调度。每个程序在其执行过程中，都分配给一组处理器，处理器的数量与程序中线程的数量相等。程序终止时，处理器返回总处理器池，以便分配给另一个程序。
+- 动态调度：在执行期间，进程中线程的数据可以改变，允许动态地改变进程中的线程数量，这就使得操作系统可以通过调整负载情况来提高利用率。
+
+
+
+---
+
+
+
+- [上一篇: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)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git a/OperatingSystem/5.IO.md b/OperatingSystem/5.IO.md
new file mode 100644
index 00000000..4ed8964e
--- /dev/null
+++ b/OperatingSystem/5.IO.md
@@ -0,0 +1,124 @@
+# 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模块发请求，且只有在整个数据块传送结束后，它才被中断。
+
+
+## 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 设备完成它的工作后，它就会产生一个中断（默认操作系统已经开启中断），它通过在总线上声明已分配的信号来实现此目的。主板上的中断控制器芯片会检测到这个信号，然后执行中断操作。
+
+​    
+
+### 磁盘高速缓存
+
+
+
+高速缓冲存储器（cache memory）通常指比内存小且比内存块的存储器，它位于内存和处理器之间。这种高速缓冲存储器利用局部性原理来减少平均存储器的存取时间。同样的原理也适用于磁盘存储器。磁盘高速缓存是内存中为磁盘扇区设置的一个缓冲区，它包含有磁盘中某些扇区的副本。出现对某一特定扇区的I/O请求时，首先会进行检测，以确定该扇区是否在磁盘的高速缓存中。若在则该请求可通过这个高速缓存来满足。若不在，则把被请求的扇区从磁盘读到磁盘高速缓存中。
+
+
+
+磁盘的高速缓存有两个问题： 
+
+- 当一个I/O请求从磁盘高速缓存中得到满足时，磁盘高速缓存中的数据必须传送到发送请求的进程。这可以通过在内存中把这一块数据从磁盘高速缓存传送到分配给该用户进程的存储空间中，或简单地使用一个共享内存，传送指向磁盘高速缓存中相应项的指针。
+- 置换策略。当一个新扇区被读入磁盘高速缓存时，必须换出一个已存在的块。因此这就需要一个页面置换算法。
+    - 最近最少使用算法(LRU，Least Recently Used)
+    - 最不常使用页面置换算法（LFU， Least Frequently Used）
+
+
+
+每个设备控制器都会有一个应用程序与之对应，设备控制器通过应用程序的接口通过中断与操作系统进行通信。设备控制器是硬件，而设备驱动程序是软件。
+
+### 内存映射 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模块发送以下信息来给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。
+
+
+
+
+
+---
+
+
+
+- [上一篇: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)
+
+
+
+
+---
+
+- 邮箱 ：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..4597c5f1
--- /dev/null
+++ "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
@@ -0,0 +1,230 @@
+# 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的能。
+
+### 文件
+
+文件是将数据存储在磁盘等存储媒介中的一种形式。文件是字节数据的集合体。程序文件中存储数据的单位是字节。文件的大小之所以用××KB、××MB等来表示，就是因为文件是以字节（B=Byte）为单位来存储的。用1字节（=8位）表示的字节数据有256种，用二进制数来表示的话，其范围就是00000000～11111111。如果文件中存储的数据是文字，那么该文件就是文本文件。如果是图形，那么该文件就是图像文件。在任何情况下，文件中的字节数据都是连续存储的。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/file_data.jpg?raw=true)        
+
+### 地址独立的实现机制：文件夹
+
+给一个文件名，操作系统是怎么知道从什么地方读取文件的内容呢？或者说，文件在磁盘上的什么位置，操作系统是如何知道的呢？这当然需要一个数据结构来记录每个文件在磁盘上的地址，这个数据结构就是文件夹。
+
+文件夹也称为目录夹（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的内容。
+
+但需要注意的是，相对路径不一定总是比绝对路径节省磁盘访问次数。如果你要访问的文件是当前这个目录的“直系后代”，则将节省磁盘访问次数；否则，即如果不是“直系后代”，你就可能多花费时间。
+
+
+
+文件拷贝程序的工作原理很简单：打开源文件和目标文件，循环往复地将源文件的内容读到一个缓冲区，然后将缓冲区的内容写到输出目标文件里。当拷贝结束后，关闭源文件和目标文件。上述程序中使用的文件系统调用包括fin.open、fout.open、fin.get等。这里需要注意的是，输入文件的打开模式为只读，而输出文件的打开模式是只有创立这个文件的人才能读写，其他人均无访问权限（输出模式0700代表的就是这个意思）。那么上述程序有一个问题，不知读者是否看出？在正确性方面没有问题，但在效率上却不太令人满意。这是因为该程序的系统调用次数太多，而系统调用需要陷入到内核。另外，每次系统调用都需要进行磁盘操作，而磁盘操作的效率远远低于内存操作的效率。解决这个问题的办法是可以将缓冲区变大，从而降低系统调用和磁盘访问的次数。但缓冲区越大，需要的内存就越大，将造成程序的可执行性下降。而且，就算缓冲区很大，文件还可以更大，还是不能从根本上解决效率低的问题。那有没有其他办法解决效率低下的问题呢？当然有，就是不使用系统调用。而是采用我们下面将要讲述的内存映射的文件访问。
+
+
+
+### 内存映射的文件访问
+
+解决读写文件效率低的中心思想就是把磁盘访问变成内存访问。实现这种访问转变的手段就是内存映射的文件访问。内存映射的文件访问原理很简单：把需要访问的文件映射到一个进程的虚拟地址内。这样，访问该虚拟地址就相当于访问文件。这样文件访问就变成内存访问。例如，假定我们将一个32KB大小的test文件映射一个进程的虚地址1024KB处。那么读写1024KB的地址就是读写test这个文件的第一个字节。而当该进程中止的时候，与文件对应的这个内存内容将被冲洗（flush）到磁盘上。
+
+这样做的好处就是磁盘访问变成了内存访问，效率自然提高。例如，还是我们前面的文件拷贝，这次不用文件系统调用来实现，而是使用内存映射的文件访问来实现。例如，我们可以将文件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.
+
+
+
+
+
+## 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设备的非易失性的存储卡。
+
+
+
+
+
+### 文件系统布局
+
+文件系统存储在`磁盘`中。大部分的磁盘能够划分出一到多个分区，叫做`磁盘分区(disk partitioning)` 或者是`磁盘分片(disk slicing)`。每个分区都有独立的文件系统，每块分区的文件系统可以不同。磁盘的 0 号分区称为 `主引导记录(Master Boot Record, MBR)`，用来`引导(boot)` 计算机。在 MBR 的结尾是`分区表(partition table)`。每个分区表给出每个分区由开始到结束的地址。
+
+当计算机开始引 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 开始。引导块可用于启动操作系统。
+
+除了从引导块开始之外，磁盘分区的布局是随着文件系统的不同而变化的。通常文件系统会包含一些属性，如下
+
+![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 后面的是根目录，它存放的是文件系统目录树的根部。最后，磁盘的其他部分存放了其他所有的目录和文件。
+
+### 文件的实现
+
+最重要的问题是记录各个文件分别用到了哪些磁盘块。不同的系统采用了不同的方法。下面我们会探讨一下这些方式。分配背后的主要思想是`有效利用文件空间`和`快速访问文件` ，主要有三种分配方案
+
+- 连续分配
+- 链表分配
+- 索引分配
+
+
+
+
+
+
+
+
+
+
+
+---
+
+
+
+- [上一篇: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)
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：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..ac818dfb
--- /dev/null
+++ "b/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md"
@@ -0,0 +1,30 @@
+# 7.嵌入式系统
+
+
+
+为完成某个特定功能而设计的，或许有附加机制或其他部分的计算机硬件和软件结合体。在许多情况下，嵌入式系统是一个更大系统或产品中的一部分，如汽车中的防抱死系统。
+
+
+
+## 嵌入式Linux
+
+嵌入式Linux是指运行在嵌入式系统中的Linux。嵌入式Linux是Linux的一个版本，是基于嵌入式设备的大小和硬件限制而定制的，它同时包括一些软件包，用于支持设备商运行的服务和应用。因此嵌入式Linux的内核比普通Linux的内核要小得多。
+
+台式机/服务器Linux与嵌入式Linux的一个关键区别是： 台式机/服务器软件通常是在运行平台上编译的，而嵌入式Linux通常在一个平台上编译，但运行于另一个平台，后者称为交叉编译。
+
+
+
+Android是基于Linux内核的一个嵌入式系统，因此我们可以认为Android是嵌入式Linux的一个例子。但是，很多嵌入式Linux开发人员不认为Android系统是嵌入式Linux的实例。他们认为，传统的嵌入式系统拥有固定的功能，而且在出厂时就已确定。Adnroid能支持各种的应用，因此要比普通平台性操作系统强大得多。而且，Android是垂直一体化的系统，包括针对Linux内核的特定修改。
+
+
+
+---
+
+- [上一篇: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)
+
+
+---
+
+- 邮箱 ：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..ebc16ef3
--- /dev/null
+++ "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
@@ -0,0 +1,133 @@
+# 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是可以在一台设备上高效执行多个副本的虚拟机。 
+
+当Java程序运行时，都是由一个虚拟机来解释Java的字节码，它将这些字节码翻译成本地CPU的指令码，然后执行。对Java程序而言，负责解释并执行的就是一个虚拟机，而对于Linux而言，这个进程只是一个普通的进程，它与一个只有一行代码的Hello World可执行程序无本质区别。所以启动一个虚拟机的方法就跟启动任何一个可执行程序的方法是相同的，那就是在命令行下输入可执行程序的名称，并在参数中指定要执行的Java类。而dalvikvm的作用就是创建一个虚拟机并执行参数中指定的Java类。
+
+
+
+### 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文件中集中到一起。
+
+
+
+### 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程序一样。
+
+## 程序是如何执行的
+
+计算机只能运行本地代码。本地（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文件中给变量及函数分配了虚拟的内存地址。在程序运行时，虚拟的内存地址会转换成实际的内存地址。链接器会在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)
+- [下一篇:Android内核](https://github.com/CharonChui/AndroidNote/tree/master/OperatingSystem/AndroidKernal)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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..a6c6a9e3
--- /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,450 @@
+# 1.Android进程间通信
+
+
+
+## Binder简介
+
+Binder，英文的意思是别针、回形针。我们经常用别针把两张纸”别“在一起，而在Android中，Binder用于完成进程间通信（IPC），即把多个进程”别“在一起。比如，普通应用程序可以调用音乐播放服务提供的播放、暂停、停止等功能。Binder工作在Linux层面，属于一个驱动，只是这个驱动不需要硬件，或者说其操作的硬件是基于一小段内存。从线程的角度来讲，Binder驱动代码运行在内核态，客户端程序调用Binder是通过系统调用完成的。
+
+
+
+## 进程间通信
+
+无论是Android系统，还是各种Linux衍生系统，各个组件、模块往往运行在各种不同的进程和线程内，这里就必然涉及进程/线程之间的通信。对于IPC(Inter-Process Communication,  进程间通信)，Linux目前有一下这些IPC机制: 
+
+- 管道(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通信方式的主要有：
+
+    - 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层之间的通信。
+
+- Handler
+
+    主要用于线程之间的通信。
+
+
+
+### 进程隔离
+
+进程隔离是操作系统为了保护进程之间不相互干扰而设计的，避免进程A写入进程B的情况发生，其实现就是使用虚拟地址空间，两个进程虚拟地址不同，这样就可以防止A进程写入数据到B进程。也就是说，操作系统的不同进程之间，数据不共享，在每个进程看来，自己都独享了整个系统空间，完全不知道其他进程的存在，因此一个进程想要与另一个进程通信，需要某种系统机制才能完成。
+
+
+
+### 用户空间/内核空间
+
+Linux Kernel是操作系统的核心，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。
+
+对于Kernel这中高安全级别的功能，显然是不允许其它应用程序随便调用或访问的，所以需要对Kernel提供一定的保护机制，这个保护机制用来告诉那些应用程序，你只可以访问某些许可的资源，不许可的资源是不能访问的，于是操作系统就把kernel和上层的应用程序抽象的隔离开，分别称之为kenel space和user space，即内核空间和用户空间。
+
+
+
+### 系统调用 内核态/用户态
+
+虽然从逻辑上抽离出用户空间和内核空间，但是不可避免的是，总有那么一些用户空间需要访问内核的资源：比如应用程序访问文件、网络这种，那么这种情况下该怎么处理？
+
+用户空间访问内核空间的唯一方式就是系统调用，通过这个统一入口，所有的资源访问都是在内核的控制下执行，以免导致用户程序对系统资源的越权访问，从而保障了系统的安全和稳定。
+
+Linux 使用两级保护机制：0 级供系统内核使用，3 级供用户程序使用。
+
+当一个任务（进程）执行系统调用而陷入内核代码中执行时，称进程处于内核运行态（内核态）。此时处理器处于特权级最高的（0级）内核代码中执行。当进程处于内核态时，执行的内核代码会使用当前进程的内核栈。每个进程都有自己的内核栈。
+
+当进程在执行用户自己的代码的时候，我们称其处于用户运行态（用户态）。此时处理器在特权级最低的（3级）用户代码中运行。
+
+
+
+### 内核模块/驱动
+
+通过系统调用，用户空间可以访问内核空间，那么如果一个用户空间想与另外一个用户空间进行通信该怎么处理？
+
+那就是让操作系统内核添加支持，传统的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等方法跟内核空间的驱动进行交互。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_qudong.png)
+
+
+
+## Android为什么要使用Binder
+
+Binder作为Android系统提供的一种IPC机制。首先一个问题就是为什么Linux已经有那么多IPC通信的机制，Android还要用Binder。
+
+**接下来正面回答这个问题，从5个角度来展开对Binder的分析：**
+
+- **从性能的角度** ：
+
+    对比与Linux的通信机制，socket是一个通用接口，导致其传输效率低、开销大。管道和消息队列因为采用存储转发的方式，所以至少需要拷贝2次数据，效率低。而共享内存虽然在传输时没有拷贝数据，但其控制机制复杂（比如跨进程通信时，需获取对方进程的pid，需要多种机制协同操作）。如果在APP级别，多拷贝一次或许没什么问题，但是如果上升到系统级别，系统内部通信频次是极高的，如果效率不够，用户体验会很差。
+
+    
+
+    具体原因如下，我们先来看看传统的 IPC 方式中，进程之间是如何实现通信的。
+
+    通常的做法是消息发送方将要发送的数据存放在内存缓存区中，通过系统调用进入内核态。然后内核程序在内核空间分配内存，开辟一块内核缓存区，调用 copy*from*user() 函数将数据从用户空间的内存缓存区拷贝到内核空间的内核缓存区中。同样的，接收方进程在接收数据时在自己的用户空间开辟一块内存缓存区，然后内核程序调用 copy*to*user() 函数将数据从内核缓存区拷贝到接收进程的内存缓存区。这样数据发送方进程和数据接收方进程就完成了一次数据传输，我们称完成了一次进程间通信。
+
+    这种传统的 IPC 通信方式有两个问题：
+
+    - 性能低下，一次数据传递需要经历：内存缓存区 --> 内核缓存区 --> 内存缓存区，需要 2 次数据拷贝；
+    - 接收数据的缓存区由数据接收进程提供，但是接收进程并不知道需要多大的空间来存放将要传递过来的数据，因此只能开辟尽可能大的内存空间或者先调用 API 接收消息头来获取消息体的大小，这两种做法不是浪费空间就是浪费时间。
+
+    
+
+    那Binder是怎么操作的呢？这就需要知道 Linux 下的另一个概念：**内存映射**。
+
+    Binder IPC 机制中涉及到的内存映射通过 mmap() 来实现，mmap()  是操作系统中一种内存映射的方法。内存映射简单的讲就是将用户空间的一块内存区域映射到内核空间。映射关系建立后，用户对这块内存区域的修改可以直接反应到内核空间；反之内核空间对这段区域的修改也能直接反应到用户空间。
+
+    内存映射能减少数据拷贝次数，实现用户空间和内核空间的高效互动。两个空间各自的修改能直接反映在映射的内存区域，从而被对方空间及时感知。也正因为如此，内存映射能够提供对进程间通信的支持。
+
+    一次完整的 Binder IPC 通信过程通常是这样：
+
+    1. 首先 Binder 驱动在内核空间创建一个数据接收缓存区；
+
+    2. 接着在内核空间开辟一块内核缓存区，建立**内核缓存区**和**内核中数据接收缓存区**之间的映射关系，以及**内核中数据接收缓存区**和**接收进程用户空间地址**的映射关系；
+
+    3. 发送方进程通过系统调用 copy*from*user() 将数据 copy 到内核中的**内核缓存区**，由于内核缓存区和接收进程的用户空间存在内存映射，因此也就相当于把数据发送到了接收进程的用户空间，这样便完成了一次进程间的通信。用户地址空间(服务端-数据接收端)和内核地址空间都映射到同一块物理地址空间。
+
+        Client(数据发送端)先从自己的用户进程空间把IPC数据通过copy_from_user()拷贝到内核空间。而Server端（数据接收端）与内核共享数据(mmap到同一块物理内存)，不再需要拷贝数据，而是通过内存地址空间的偏移量，即可获悉内存地址，整个过程只发生一次内存拷贝。
+
+- **从稳定性的角度**
+    Binder是基于C/S架构的，简单解释下C/S架构，是指客户端(Client)和服务端(Server)组成的架构，Client端有什么需求，直接发送给Server端去完成，架构清晰明朗，Server端与Client端相对独立，稳定性较好；而共享内存实现方式复杂，没有客户与服务端之别， 需要充分考虑到访问临界资源的并发同步问题，否则可能会出现死锁等问题；从这稳定性角度看，Binder架构优越于共享内存。
+
+仅仅从以上两点，各有优劣，还不足以支撑google去采用binder的IPC机制，那么更重要的原因是：
+
+- **从安全的角度**
+    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无法正常使用，而一旦授权后，应用便可以胡作非为。
+
+    针对这个问题，google在Android M做了调整，不再是安装时一并询问所有权限，而是在App运行过程中，需要哪个权限再弹框询问用户是否给相应的权限，对权限做了更细地控制，让用户有了更多的可控性，但同时也带来了另一个用户诟病的地方，那也就是权限询问的弹框的次数大幅度增多。对于Android M平台上，有些App开发者可能会写出让手机异常频繁弹框的App，企图直到用户授权为止，这对用户来说是不能忍的，用户最后吐槽的可不光是App，还有Android系统以及手机厂商，有些用户可能就跳果粉了，这还需要广大Android开发者以及手机厂商共同努力，共同打造安全与体验俱佳的Android手机。
+
+    Android中权限控制策略有SELinux等多方面手段。传统IPC只能由用户在数据包里填入UID/PID；另外，可靠的身份标记只有由IPC机制本身在内核中添加。其次传统IPC访问接入点是开放的，无法建立私有通道。从安全角度，Binder的安全性更高。
+
+- **从语言层面的角度**
+    大家多知道Linux是基于C语言(面向过程的语言)，而Android是基于Java语言(面向对象的语句)，而对于Binder恰恰也符合面向对象的思想，将进程间通信转化为通过对某个Binder对象的引用调用该对象的方法，而其独特之处在于Binder对象是一个可以跨进程引用的对象，它的实体位于一个进程中，而它的引用却遍布于系统的各个进程之中。可以从一个进程传给其它进程，让大家都能访问同一Server，就像将一个对象或引用赋值给另一个引用一样。Binder模糊了进程边界，淡化了进程间通信过程，整个系统仿佛运行于同一个面向对象的程序之中。从语言层面，Binder更适合基于面向对象语言的Android系统，对于Linux系统可能会有点“水土不服”。
+
+- **从公司战略的角度**
+
+    总所周知，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系统上层进程间通信的不二选择。
+
+
+
+### 疑问
+
+到这里又迷糊了，你上面说了这么多Binder这么好，那为啥Android里面还有地方用Socket？SystemServer和Zygote之间的通信为啥不用Binder？
+
+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线程有锁，然后子进程的主线程一直在等待其子线程（从父进程拷贝过来的子进程）的资源，但是其实父进程的子进程并没有被拷贝过来，造成死锁。
+
+所以fork不允许存在多线程。而非常巧的是Binder通讯偏偏就是多线程，所以干脆父进程（Zygote）这个时候就不使用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，进程通信自己写了个实现叫OpenBinder由一个叫Dianne Hackbod的人开发并维护后来Binder也被用到了PalmOS里
+
+3. Android创立了以后Andy从Palm带走了一大批人，其中就有Dianne。Dianne成为安卓系统总架构师。
+
+- 如果你是她，你会选择用Linux已有的进程通信手段吗？ 不会，要不当年也不会搞个新东西出来 
+
+- 重写一个新东西?也不会，binder反正是自己写的开源库
+
+- 用binder?已经被两个公司用过而且是自己写的可靠放心
+
+我是她我就用binder。
+
+你可以看到 如果当年Dianne没有加入Be或者Be没有被收购 ，又或者Dianne没有和Andy加入Android 那Android也不一定会用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驱动的交互来间接的实现跨进程通信。
+
+如果统观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
+
+    一个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队列有新的请求到来时便会唤醒，如果是由所需进程唤醒的，那么进程会让其中一个线程处理响应的请求，其他线程再次进入休眠状态。
+
+
+
+- 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 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)
+
+    可以看出无论是注册服务和获取服务的过程都需要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)
+
+    
+    
+    
+
+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 通信过程
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_communication.jpg)
+
+
+
+- 首先，一个进程使用 BINDER*SET*CONTEXT_MGR 命令通过 Binder 驱动将自己注册成为 ServiceManager；
+
+- Server通过驱动向ServiceManager中进行服务注册，表明可以对外提供服务。ServiceManager有一个全局的service列表svcinfo，用来缓存所有服务的handler和name。驱动为这个Binder创建位于内核中的实体节点以及 ServiceManager 对实体的引用，将名字以及新建的引用打包传给  ServiceManager，ServiceManger 将其填入查找表。
+
+- 客户端与服务端通信，需要拿到服务端的对象，由于进程隔离，客户端拿到的其实是服务端的代理，也可以理解为引用。客户端通过Client 通过名字，在 Binder 驱动的帮助下从ServiceManager的svcinfo中查找服务，ServiceManager返回服务的代理。
+
+- Server进程启动之后，会进入中断等待状态，等待Client的请求。
+
+- 当Client需要和Server通信时，会通过BinderProxy将我们的请求参数发送给 内核，通过共享内存的方式使用内核方法 copy_from_user() 将我们的参数先拷贝到内核空间，这时我们的客户端进入等待状态。
+
+- 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。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_all_process.jpg)
+
+
+
+## Binder的内存管理
+
+ServiceManager启动后，会通过系统调用mmap向内核空间申请128K的内存，用户进程会通过mmap向内核申请(1M-8K)的内存空间。
+
+这里用户空间mmap (1M-8K)的空间，为什么要减去8K，而不是直接用1M?
+
+Android的git commit记录：
+
+>  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.
+
+大致的意思是：kernel的“backing store”需要一个保护页，这使得1M用来分配碎片内存时变得很差，所以这里减去两页来提高效率，因为减去一页就变成了奇数。
+
+​    
+
+**系统定义**：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)
+
+用户地址空间(服务端-数据接收端)和内核地址空间都映射到同一块物理地址空间，这也是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()方法也是同理。
+
+
+
+参考: https://www.zhihu.com/question/39440766/answer/93550572
+
+[https://zhuanlan.zhihu.com/p/35519585](https://zhuanlan.zhihu.com/p/35519585)
+
+
+
+---
+
+- [上一篇:8.虚拟机](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/8.%E8%99%9A%E6%8B%9F%E6%9C%BA.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)
+
+    
+
+
+---
+
+- 邮箱 ：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..b571b6f3
--- /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,934 @@
+# 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消息队列；
+
+
+
+![handle_msg_arch](https://raw.githubusercontent.com/CharonChui/Pictures/master/handle_msg_arch.png)
+
+
+首先想一想平时我们是怎么使用的: 
+```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赋值给当前的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中。也就是说，prepare函数通过ThreadLocal机制，巧妙地把Looper和调用prepare的线程（也就是最终的处理线程）绑定在一起了。当事件源向这个Looper发送消息的时候，其实是把消息加到这个Looper的消息队列里了。那么，该消息就将由和Looper绑定的处理线程来处理。
+
+这里有点麻烦了，我们上面使用的代码中并没有调用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);
+}
+```
+
+
+
+##### postAtFrontOfQueue():将消息插入到队列头部
+
+通过调用sendMessageAtFrontOfQueue计入一个when为0的message到队列，即插入到队列的头部。可以尽量保证快速执行。
+
+
+## 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中的消息队列实际就是某个Looper的消息队列，那么，Handler如此安排的目的何在？
+在回答这个问题之前，我先来问一个问题：怎么往Looper的消息队列插入消息？如果不知道Handler，这里有一个很原始的方法可解决上面这个问题：
+- 调用Looper的myQueue，它将返回消息队列对象MessageQueue。
+- 构造一个Message，填充它的成员，尤其是target变量。
+- 调用MessageQueue的enqueueMessage，将消息插入消息队列。
+这种原始方法的确很麻烦，且极容易出错。但有了Handler后，我们的工作就变得异常简单了。Handler更像一个辅助类，帮助我们简化编程的工作。
+
+
+
+
+# Handler内存泄露
+
+
+
+有关内存泄露请猛戳[内存泄露](https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F.md)
+
+在上面分析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。    
+			- `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`声明为静态类。
+    静态类不持有外部类的对象，所以你的`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.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)
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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..bcf041f8
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
@@ -0,0 +1,125 @@
+# 3.Android Framework框架
+
+## Framework框架
+
+Framework定义了客户端组件和服务端组件功能及接口。
+
+框架中包含三个主要部分，分别是服务端、客户端和Linux驱动。
+
+
+
+### 服务端
+
+服务端主要包含两个重要类，分别是WindowManagerService(WmS)和ActivityManagerService(AmS)。
+
+WmS的作用是为所有应用程序分配窗口，并管理这些窗口。包括分配窗口的大小，调节各窗口的叠放次序，隐藏或显示窗口。
+
+AmS的作用是管理所有应用程序中的Activity。
+
+除此之外，在服务端还包括两个消息处理类: 
+
+- KeyQ类：该类为WmS的内部类，继承与KeyInputQueue类，KeyQ对象一旦创建，就立即启动一个线程，该线程会不断地读取用户的UI操作信息，比如按键、触摸屏、trackball、鼠标等，并把这些消息放到一个消息队列QueueEvent类中。
+- InputDispatcherThread类：该类的对象一旦创建，也会立即启动一个线程，该线程会不断地从QueueEvent中取出用户消息，并进行一定的过滤，过滤后，再将这些消息发送给当前活动的客户端程序中。
+
+
+
+### 客户端
+
+
+
+客户端主要包括以下重要类：   
+
+- 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进行交互。
+
+
+
+### Linux驱动
+
+Linux驱动和Framework相关的主要包含两部分： 
+
+- SurfaceFlingger（SF）驱动：每一个窗口都对应一个Surface，SF驱动的作用是把各个Surface显示在同一个屏幕上。
+- Binder驱动：Binder驱动的作用是提供进程间的消息传递。
+
+
+
+<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)。
+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类。ViewRoot类在Android2.2之后就被ViewRootImpl替换了。但是为了方便，后面还是会用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并初始化。
+
+
+
+---
+
+- [上一篇: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)
+
+
+
+
+---
+
+- 邮箱 ：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..3e88e552
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/4.ActivityManagerService\347\256\200\344\273\213.md"
@@ -0,0 +1,155 @@
+# 4.ActivityManagerService简介
+
+ActivityManagerService简称AmS，是Android内核的三大核心功能之一，另外两个是WindowManagerService和View。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所在的进程也就无效了。
+
+
+
+## startActiviy()启动流程
+
+
+
+- 调用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。
+
+
+
+---
+
+- [上一篇: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  
+- 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..3fe0e833
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/5.Android\346\266\210\346\201\257\350\216\267\345\217\226.md"
@@ -0,0 +1,69 @@
+# 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会把窗口的相关信息保存在内部的一个窗口列表类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内部定义的一个概念，主要保存了通信双发所使用的管道描述符。
+
+
+
+### 事件分发
+
+
+
+#### 按键消息派发
+
+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()向消息获取模块发送一个回执，以便其进行下一次消息派发。
+
+
+
+
+
+---
+
+- [上一篇: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  
+- 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..feeb1c49
--- /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,112 @@
+# 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类在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功能对象，然后就可以调用该对象的各种绘制函数完成对平面的绘制。
+
+
+
+### 相关类
+
+- 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等。
+
+
+
+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。
+
+
+
+无论开发者使用什么渲染 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 的热插拔）。
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- [上一篇: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)
+
+
+
+
+---
+
+- 邮箱 ：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..325c231f
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/7.View\347\273\230\345\210\266\345\216\237\347\220\206.md"
@@ -0,0 +1,1629 @@
+# 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
+ * 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)
+
+
+
+---
+
+- 邮箱 ：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..d3bb82f4
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
@@ -0,0 +1,140 @@
+# 8.WindowManagerService简介
+
+
+WmS是Android中图形用户接口的引擎，它管理着所有窗口，包括创建、删除窗口以及将某个窗口设置为焦点等。
+
+在WmS中，窗口是由两部分内容构成: 
+
+- 描述该窗口的类WindowState。
+- 该窗口在屏幕上对应的界面Surface。
+
+它的功能可以归纳为两个: 
+
+- 保持窗口的层次关系，以便SurfaceFlinger能够据此绘制屏幕
+- 把窗口信息传递给InputManager对象，以便InputDispatcher能够把输入消息派发给和屏幕上显示一致的窗口。
+
+
+
+打个比方，就像一出由N个演员参与的话剧：SurfaceFlinger是摄像机，WMS是导演，ViewRoot则是演员个体。摄像机（SurfaceFlinger）的作用是单一而规范的，它负责客观地捕获当前的画面，然后真是的呈现给观众。导演（WMS）则会考虑到话剧的舞台效果和视觉美感，如他需要根据实际情况来安排各个演员的排序站位，谁在前谁在后，都会影响到演出的”画面效果“与”剧情编排“，而各个演员的长相和表情（ViewRoot）则更多的取决于他们自身的条件与努力。正式通过这三者的”各司其职“，才能最终为观众呈现出异常美妙绝伦的”视觉盛宴“。
+
+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自然应该被销毁。
+
+
+
+---
+
+- [上一篇: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)
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- 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"
new file mode 100644
index 00000000..d26ae20e
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md"
@@ -0,0 +1,73 @@
+# 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包中的不同类型的数据文件进行边界对齐。
+
+
+
+
+
+---
+
+- [上一篇:8.WindowManagerService简介](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/8.WindowManagerService%E7%AE%80%E4%BB%8B.md)
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git a/README.md b/README.md
index 1a0c48ac..e7e3e4f7 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,729 @@ Android学习笔记
 > 青丝化雪、鬓角成霜，已是英雄迟暮，人生怎慷慨激昂？
 
 
+目录
+===  
+
+- [史上最适合Android开发者学习的Harmony OS Next语言教程](https://github.com/CharonChui/HarmonyOSNextStudyNote)
+
+- [源码解析][43] 
+    - [自定义View详解][1]
+    - [Activity界面制过程详解][2]
+    - [Activity启动过程][3]
+    - [Android Touch事件分发详解][4]
+    - [AsyncTask详解][5]
+    - [butterknife源码详解][6]
+    - [InstantRun详解][7]
+    - [ListView源码分析][8]
+    - [VideoView源码分析][9]
+    - [View绘制过程详解][10]
+    - [LeakCanary源码分析][284]
+    - [网络部分][11]
+        - [HttpURLConnection详解][12]
+        - [HttpURLConnection与HttpClient][13]
+        - [volley-retrofit-okhttp之我们该如何选择网路框架][14]
+        - [Volley源码分析][15]
+        - [Retrofit详解(上)][16]
+        - [Retrofit详解(下)][17]
+- [Dagger2][199]        
+    - [1.Dagger2简介(一).md][200]
+    - [2.Dagger2入门demo(二).md][201]    
+    - [3.Dagger2入门demo扩展(三).md][202]
+    - [4.Dagger2单例(四).md][203]
+    - [5.Dagger2Lay和Provider(五).md][204]
+    - [6.Dagger2Android示例代码(六).md][205]
+    - [7.Dagger2之dagger-android(七).md][206]            
+    - [8.Dagger2与MVP(八).md][207]    
+    - [9.Dagger2原理分析(九).md][212]
+- [音视频开发][44]
+    - [搭建nginx+rtmp服务器][18]
+    - [视频播放相关内容总结][19]
+    - [Android音视频开发][21]
+        - [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]
+        - [MediaMetadataRetriever][344]
+    - [DNS及HTTPDNS][23]
+    - [流媒体协议][224]
+        - [流媒体协议][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]
+    - [视频封装格式][225]
+        - [MP4格式详解][251]
+        - [FLV][252]
+        - [TS][253]
+        - [fMP4 vs ts][254]
+        - [fMP4格式详解][255]
+        - [视频封装格式][256]
+        - [M3U8][321]
+        - [AVI][341]
+    - [视频编码][257]
+        - [视频编码原理][331]
+        - [AV1][258]
+        - [H264][259]
+        - [H265][260]
+    - [音频编码][335]    
+        - [音频编码格式][336]
+        - [AAC][337]
+        - [PCM][338]
+        - [WAV][339]
+    - [关键帧][227]
+    - [CDN及PCDN][228]
+    - [P2P技术][229]
+        - [P2P][261]
+        - [P2P原理_NAT穿透][262]
+    - [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]
+        - [12.FBO][332]
+        - [13.LUT滤镜][346]
+        - [14.实例化][347]
+    - [弹幕][243]
+        - [Android弹幕实现][244]
+    - [FFmpeg][322]    
+        - [1.FFmpeg简介][323]
+        - [2.FFmpeg常用命令行][324]
+        - [3.FFmpeg切片][325]
+        - [4.开发环境配置][333]
+        - [5. FFmpeg核心功能][334]
+        - [6.视频播放简介][340]
+    - [OpenCV][342]
+        - [1.OpenCV简介][343]
+
+- [操作系统][263]
+    - [1.操作系统简介][264]
+    - [2.进程与线程][265]
+    - [3.内存管理][266]
+    - [4.调度][267]
+    - [5.I/O][268]
+    - [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]
+
+- [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]
+    - [图片加载库比较][27]
+    - [Coil简介][320]
+
+
+- [RxJava][46]
+    - [RxJava详解(一)][28]
+    - [RxJava详解(二)][29]
+    - [RxJava详解(三)][30]
+    - [RxJava详解之执行原理(四)][209]
+    - [RxJava详解之操作符执行原理(五)][210]
+    - [RxJava详解之线程调度原理(六)][211]
+    - [RxJava系列全家桶][31]
+
+- [开发工具][47]
+    - [目前流行的开发组合][32]
+    - [性能优化相关工具][33]
+    - [Android开发工具及类库][34]
+    - [Github个人主页绑定域名][35]
+    - [Markdown学习手册][36]
+    - [MAT内存分析][37]
+    - [调试平台Sonar][213]
+    - [Icon制作][223]
+
+- [Kotlin学习][48]
+    - [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]
+
+
+
+- [Gradle&Maven][49]
+    - [Gradle专题][39]
+    - [发布library到Maven仓库][40]
+    - [Composing builds简介][319]
+
+- [应用发布][50]
+    - [使用Jenkins实现自动化打包][198]
+    - [Android应用发布][41]
+    - [Zipalign优化][42]
+
+- [Android Studio使用教程][51]
+    - [AndroidStudio使用教程(第一弹)][55]
+    - [AndroidStudio使用教程(第二弹)][56]    
+    - [AndroidStudio使用教程(第三弹)][57]
+    - [AndroidStudio使用教程(第四弹)][58]
+    - [AndroidStudio使用教程(第五弹)][59]
+    - [AndroidStudio使用教程(第六弹)][60]
+    - [AndroidStudio使用教程(第七弹)][61]   
+    - [Android Studio你可能不知道的操作][62]
+    - [AndroidStudio提高Build速度][63]
+    - [AndroidStudio中进行ndk开发][64]
+
+- [进阶部分][52]  
+    - [布局优化][65]
+    - [屏幕适配之百分比方案详解][66]
+    - [热修复实现][67]
+    - [如何让Service常驻内存][68]
+    - [通过Hardware Layer提高动画性能][69]
+    - [性能优化][70]
+    - [注解使用][71]
+    - [Android6.0权限系统][72]
+    - [Android开发不申请权限来使用对应功能][73]
+    - [Android开发中的MVP模式详解][74]
+    - [Android启动模式详解][75]
+    - [Android卸载反馈][76]
+    - [ApplicationId vs PackageName][77]
+    - [AndroidRuntime_ART与Dalvik][78]
+    - [BroadcastReceiver安全问题][79]
+    - [Crash及ANR分析][80]
+    - [Library项目中资源id使用case时报错][81]
+    - [Mac下配置adb及Android命令][82]
+    - [RecyclerView专题][84]
+    - [ConstraintLaayout简介][194]
+    - [Android WorkManager][208]
+    - [OOM问题分析][215]
+
+- [Java基础及算法][53]
+    - [数据结构和算法][192]
+	- [八种排序算法][189]
+	- [线程池的原理][190]
+	- [设计模式][191]
+    - [动态代理][193]
+    - [常用命令行大全][85]
+    - [单例的最佳实现方式][86]
+    - [数据结构][87]
+    - [获取今后多少天后的日期][88]
+    - [剑指Offer(上)][89]
+    - [剑指Offer(下)][90]
+    - [强引用、软引用、弱引用、虚引用][91]
+    - [生产者消费者][92]
+    - [数据加密及解密][93]
+    - [死锁][94]
+    - [算法][95]
+    - [网络请求相关内容总结][96]
+    - [线程池的原理][97]
+    - [Java并发编程之原子性、可见性以及有序性][98]
+    - [Base64加密][99]
+    - [Git简介][100]
+    - [hashCode与equals][101]
+    - [HashMap实现原理分析][102]
+    - [Java基础面试题][103]
+    - [JVM垃圾回收机制][104]
+    - [MD5加密][105]
+    - [MVC与MVP及MVVM][106]
+    - [RMB大小写转换][107]
+    - [Vim使用教程][108]
+    - [volatile和Synchronized区别][109]
+    - [Http与Https的区别][195]
+    - [Top-K问题][196]
+    - [Java内存模型][285]
+    - [JVM架构][286]
+    - [python3入门][345]
+- [基础部分][54] 
+    - [安全退出应用程序][110]
+    - [病毒][111]
+    - [超级管理员(DevicePoliceManager)][112]
+    - [程序的启动、卸载和分享][113]
+    - [代码混淆][114]
+    - [读取用户logcat日志][115]
+    - [短信广播接收者][116]
+    - [多线程断点下载][117]
+    - [黑名单挂断电话及删除电话记录][118]
+    - [横向ListView][119]
+    - [滑动切换Activity(GestureDetector)][120]
+    - [获取联系人][121]
+    - [获取手机及SD卡可用存储空间][122]
+    - [获取手机中所有安装的程序][123]
+    - [获取位置(LocationManager)][124]
+    - [获取应用程序缓存及一键清理][125]
+    - [开发中异常的处理][126]
+    - [开发中Log的管理][127]
+    - [快捷方式工具类][128]
+    - [来电号码归属地提示框][129]
+    - [来电监听及录音][130]
+    - [零权限上传数据][131]
+    - [内存泄漏][132]
+    - [屏幕适配][133]
+    - [任务管理器(ActivityManager)][134]
+    - [手机摇晃][135]
+    - [竖着的Seekbar][136]
+    - [数据存储][137]
+    - [搜索框][138]
+    - [锁屏以及解锁监听][139]
+    - [文件上传][140]
+    - [下拉刷新ListView][141]
+    - [修改系统组件样式][142]
+    - [音量及屏幕亮度调节][143]
+    - [应用安装][144]
+    - [应用后台唤醒后数据的刷新][145]
+    - [知识大杂烩][146]
+    - [资源文件拷贝的三种方式][147]
+    - [自定义背景][148]
+    - [自定义控件][149]
+    - [自定义状态栏通知][150]
+    - [自定义Toast][151]
+    - [adb logcat使用简介][152]
+    - [Android编码规范][153]
+    - [Android动画][154]
+    - [Android基础面试题][155]
+    - [Android入门介绍][156]
+    - [Android四大组件之ContentProvider][157]
+    - [Android四大组件之Service][158]
+    - [Ant打包][159]
+    - [Bitmap优化][160]
+    - [Fragment专题][161]
+    - [Home键监听][162]
+    - [HttpClient执行Get和Post请求][163]
+    - [JNI_C语言基础][164]
+    - [JNI基础][165]
+    - [ListView专题][166]
+    - [Parcelable及Serializable][167]
+    - [PopupWindow细节][168]
+    - [Scroller简介][169]
+    - [ScrollingTabs][170]
+    - [SDK Manager无法更新的问题][171]
+    - [Selector使用][172]
+    - [SlidingMenu][173]
+    - [String格式化][174]
+    - [TextView跑马灯效果][175]
+    - [WebView总结][176]
+    - [Widget(窗口小部件)][177]
+    - [Wifi状态监听][178]
+    - [XmlPullParser][179]
+    - [反编译][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界面绘制过程详解"
+[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详解"
+[6]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/butterknife%E6%BA%90%E7%A0%81%E8%AF%A6%E8%A7%A3.md   "butterknife源码详解"
+[7]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/InstantRun%E8%AF%A6%E8%A7%A3.md   "InstantRun详解"
+[8]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/ListView源码分析.md   "ListView源码分析"
+[9]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/VideoView%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md   "VideoView源码分析"
+[10]: 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   "View绘制过程详解"
+[11]: https://github.com/CharonChui/AndroidNote/tree/master/SourceAnalysis/Netowork   "网络部分"
+[12]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Netowork/HttpURLConnection%E8%AF%A6%E8%A7%A3.md   "HttpURLConnection详解"
+[13]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Netowork/HttpURLConnection%E4%B8%8EHttpClient.md   "HttpURLConnection与HttpClient"
+[14]: 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之我们该如何选择网路框架"
+[15]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Netowork/Volley%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md   "Volley源码分析"
+[16]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Netowork/Retrofit%E8%AF%A6%E8%A7%A3(%E4%B8%8A).md   "Retrofit详解(上)"
+[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/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%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/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   "图片加载库比较"
+[28]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/1.RxJava%E8%AF%A6%E8%A7%A3(%E4%B8%80).md   "RxJava详解(一)"
+[29]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/2.RxJava%E8%AF%A6%E8%A7%A3(%E4%BA%8C).md   "RxJava详解(二)"
+[30]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/3.RxJava%E8%AF%A6%E8%A7%A3(%E4%B8%89).md   "RxJava详解(三)"
+[31]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/7.RxJava%E7%B3%BB%E5%88%97%E5%85%A8%E5%AE%B6%E6%A1%B6.md   "RxJava系列全家桶"
+[32]: https://github.com/CharonChui/AndroidNote/blob/master/Tools%26Library/%E7%9B%AE%E5%89%8D%E6%B5%81%E8%A1%8C%E7%9A%84%E5%BC%80%E5%8F%91%E7%BB%84%E5%90%88.md   "目前流行的开发组合"
+[33]: https://github.com/CharonChui/AndroidNote/blob/master/Tools%26Library/%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96%E7%9B%B8%E5%85%B3%E5%B7%A5%E5%85%B7.md   "性能优化相关工具"
+[34]: https://github.com/CharonChui/AndroidNote/blob/master/Tools%26Library/Android%E5%BC%80%E5%8F%91%E5%B7%A5%E5%85%B7%E5%8F%8A%E7%B1%BB%E5%BA%93.md   "Android开发工具及类库"
+[35]: https://github.com/CharonChui/AndroidNote/blob/master/Tools%26Library/Github%E4%B8%AA%E4%BA%BA%E4%B8%BB%E9%A1%B5%E7%BB%91%E5%AE%9A%E5%9F%9F%E5%90%8D.md   "Github个人主页绑定域名"
+[36]: https://github.com/CharonChui/AndroidNote/blob/master/Tools%26Library/Markdown%E5%AD%A6%E4%B9%A0%E6%89%8B%E5%86%8C.md   "Markdown学习手册"
+[37]: https://github.com/CharonChui/AndroidNote/blob/master/Tools%26Library/MAT%E5%86%85%E5%AD%98%E5%88%86%E6%9E%90.md   "MAT内存分析"
+[38]: 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学习教程(一)(未完)"
+[39]: https://github.com/CharonChui/AndroidNote/blob/master/Gradle%26Maven/Gradle%E4%B8%93%E9%A2%98.md   "Gradle专题"
+[40]: https://github.com/CharonChui/AndroidNote/blob/master/Gradle%26Maven/%E5%8F%91%E5%B8%83library%E5%88%B0Maven%E4%BB%93%E5%BA%93.md   "发布library到Maven仓库"
+[41]: https://github.com/CharonChui/AndroidNote/blob/master/AppPublish/Android%E5%BA%94%E7%94%A8%E5%8F%91%E5%B8%83.md   "Android应用发布"
+[42]: https://github.com/CharonChui/AndroidNote/blob/master/AppPublish/Zipalign%E4%BC%98%E5%8C%96.md   "Zipalign优化"
+[43]: https://github.com/CharonChui/AndroidNote/tree/master/SourceAnalysis   "源码解析"
+[44]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment   "音视频开发"
+[45]: https://github.com/CharonChui/AndroidNote/tree/master/ImageLoaderLibrary   "图片加载"
+[46]: https://github.com/CharonChui/AndroidNote/tree/master/RxJavaPart   "RxJava"
+[47]: https://github.com/CharonChui/AndroidNote/tree/master/Tools%26Library   "开发工具"
+[48]: https://github.com/CharonChui/AndroidNote/tree/master/KotlinCourse   "Kotlin学习"
+[49]: https://github.com/CharonChui/AndroidNote/tree/master/Gradle%26Maven   "Gradle&Maven"
+[50]: https://github.com/CharonChui/AndroidNote/tree/master/AppPublish   "应用发布"
+[51]: https://github.com/CharonChui/AndroidNote/tree/master/AndroidStudioCourse   "Android Studio使用教程"
+[52]: https://github.com/CharonChui/AndroidNote/tree/master/AdavancedPart   "进阶部分"
+[53]: https://github.com/CharonChui/AndroidNote/tree/master/JavaKnowledge   "Java基础及算法"
+[54]: https://github.com/CharonChui/AndroidNote/tree/master/BasicKnowledge   "基础部分"
+[55]: 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%80%E5%BC%B9).md   "AndroidStudio使用教程(第一弹)"
+[56]: 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%BA%8C%E5%BC%B9).md   "AndroidStudio使用教程(第二弹)"
+[57]: 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%89%E5%BC%B9).md   "AndroidStudio使用教程(第三弹)"
+[58]: https://github.com/CharonChui/AndroidNote/blob/master/AndroidStudioCourse/AndroidStudio%E4%BD%BF%E7%94%A8%E6%95%99%E7%A8%8B(%E7%AC%AC%E5%9B%9B%E5%BC%B9).md   "AndroidStudio使用教程(第四弹)"
+[59]: 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%BA%94%E5%BC%B9).md   "AndroidStudio使用教程(第五弹)"
+[60]: https://github.com/CharonChui/AndroidNote/blob/master/AndroidStudioCourse/AndroidStudio%E4%BD%BF%E7%94%A8%E6%95%99%E7%A8%8B(%E7%AC%AC%E5%85%AD%E5%BC%B9).md   "AndroidStudio使用教程(第六弹)"
+[61]: 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使用教程(第七弹)"
+[62]: https://github.com/CharonChui/AndroidNote/blob/master/AndroidStudioCourse/Android%20Studio%E4%BD%A0%E5%8F%AF%E8%83%BD%E4%B8%8D%E7%9F%A5%E9%81%93%E7%9A%84%E6%93%8D%E4%BD%9C.md   "Android Studio你可能不知道的操作"
+[63]: https://github.com/CharonChui/AndroidNote/blob/master/AndroidStudioCourse/AndroidStudio%E6%8F%90%E9%AB%98Build%E9%80%9F%E5%BA%A6.md   "AndroidStudio提高Build速度"
+[64]: https://github.com/CharonChui/AndroidNote/blob/master/AndroidStudioCourse/AndroidStudio%E4%B8%AD%E8%BF%9B%E8%A1%8Cndk%E5%BC%80%E5%8F%91.md   "AndroidStudio中进行ndk开发"
+[65]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E5%B8%83%E5%B1%80%E4%BC%98%E5%8C%96.md   "布局优化"
+[66]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E5%B1%8F%E5%B9%95%E9%80%82%E9%85%8D%E4%B9%8B%E7%99%BE%E5%88%86%E6%AF%94%E6%96%B9%E6%A1%88%E8%AF%A6%E8%A7%A3.md   "屏幕适配之百分比方案详解"
+[67]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E7%83%AD%E4%BF%AE%E5%A4%8D%E5%AE%9E%E7%8E%B0.md   "热修复实现"
+[68]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E5%A6%82%E4%BD%95%E8%AE%A9Service%E5%B8%B8%E9%A9%BB%E5%86%85%E5%AD%98.md   "如何让Service常驻内存"
+[69]: 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提高动画性能"
+[70]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96.md   "性能优化"
+[71]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E6%B3%A8%E8%A7%A3%E4%BD%BF%E7%94%A8.md   "注解使用"
+[72]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Android6.0%E6%9D%83%E9%99%90%E7%B3%BB%E7%BB%9F.md   "Android6.0权限系统"
+[73]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Android%E5%BC%80%E5%8F%91%E4%B8%8D%E7%94%B3%E8%AF%B7%E6%9D%83%E9%99%90%E6%9D%A5%E4%BD%BF%E7%94%A8%E5%AF%B9%E5%BA%94%E5%8A%9F%E8%83%BD.md   "Android开发不申请权限来使用对应功能"
+[74]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Android%E5%BC%80%E5%8F%91%E4%B8%AD%E7%9A%84MVP%E6%A8%A1%E5%BC%8F%E8%AF%A6%E8%A7%A3.md   "Android开发中的MVP模式详解"
+[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/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分析"
+
+[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命令"
+[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%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(下)"
+[91]: 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   "强引用、软引用、弱引用、虚引用"
+[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/%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并发编程之原子性、可见性以及有序性"
+[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"
+[102]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/HashMap%E5%AE%9E%E7%8E%B0%E5%8E%9F%E7%90%86%E5%88%86%E6%9E%90.md   "HashMap实现原理分析"
+[103]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E8%AF%95%E9%A2%98.md   "Java基础面试题"
+[104]: 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垃圾回收机制"
+[105]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/MD5%E5%8A%A0%E5%AF%86.md   "MD5加密"
+[106]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/MVC%E4%B8%8EMVP%E5%8F%8AMVVM.md   "MVC与MVP及MVVM"
+[107]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/RMB%E5%A4%A7%E5%B0%8F%E5%86%99%E8%BD%AC%E6%8D%A2.md   "RMB大小写转换"
+[108]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Vim%E4%BD%BF%E7%94%A8%E6%95%99%E7%A8%8B.md   "Vim使用教程"
+[109]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/volatile%E5%92%8CSynchronized%E5%8C%BA%E5%88%AB.md   "volatile和Synchronized区别"
+[110]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%AE%89%E5%85%A8%E9%80%80%E5%87%BA%E5%BA%94%E7%94%A8%E7%A8%8B%E5%BA%8F.md   "安全退出应用程序"
+[111]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E7%97%85%E6%AF%92.md   "病毒"
+[112]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%B6%85%E7%BA%A7%E7%AE%A1%E7%90%86%E5%91%98(DevicePoliceManager).md   "超级管理员(DevicePoliceManager)"
+[113]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E7%A8%8B%E5%BA%8F%E7%9A%84%E5%90%AF%E5%8A%A8%E3%80%81%E5%8D%B8%E8%BD%BD%E5%92%8C%E5%88%86%E4%BA%AB.md   "程序的启动、卸载和分享"
+[114]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E4%BB%A3%E7%A0%81%E6%B7%B7%E6%B7%86.md   "代码混淆"
+[115]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%AF%BB%E5%8F%96%E7%94%A8%E6%88%B7logcat%E6%97%A5%E5%BF%97.md   "读取用户logcat日志"
+[116]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E7%9F%AD%E4%BF%A1%E5%B9%BF%E6%92%AD%E6%8E%A5%E6%94%B6%E8%80%85.md   "短信广播接收者"
+[117]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%A4%9A%E7%BA%BF%E7%A8%8B%E6%96%AD%E7%82%B9%E4%B8%8B%E8%BD%BD.md   "多线程断点下载"
+[118]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E9%BB%91%E5%90%8D%E5%8D%95%E6%8C%82%E6%96%AD%E7%94%B5%E8%AF%9D%E5%8F%8A%E5%88%A0%E9%99%A4%E7%94%B5%E8%AF%9D%E8%AE%B0%E5%BD%95.md   "黑名单挂断电话及删除电话记录"
+[119]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E6%A8%AA%E5%90%91ListView.md   "横向ListView"
+[120]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E6%BB%91%E5%8A%A8%E5%88%87%E6%8D%A2Activity(GestureDetector).md   "滑动切换Activity(GestureDetector)"
+[121]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%8E%B7%E5%8F%96%E8%81%94%E7%B3%BB%E4%BA%BA.md   "获取联系人"
+[122]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%8E%B7%E5%8F%96%E6%89%8B%E6%9C%BA%E5%8F%8ASD%E5%8D%A1%E5%8F%AF%E7%94%A8%E5%AD%98%E5%82%A8%E7%A9%BA%E9%97%B4.md   "获取手机及SD卡可用存储空间"
+[123]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%8E%B7%E5%8F%96%E6%89%8B%E6%9C%BA%E4%B8%AD%E6%89%80%E6%9C%89%E5%AE%89%E8%A3%85%E7%9A%84%E7%A8%8B%E5%BA%8F.md   "获取手机中所有安装的程序"
+[124]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%8E%B7%E5%8F%96%E4%BD%8D%E7%BD%AE(LocationManager).md   "获取位置(LocationManager)"
+[125]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%8E%B7%E5%8F%96%E5%BA%94%E7%94%A8%E7%A8%8B%E5%BA%8F%E7%BC%93%E5%AD%98%E5%8F%8A%E4%B8%80%E9%94%AE%E6%B8%85%E7%90%86.md   "获取应用程序缓存及一键清理"
+[126]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%BC%80%E5%8F%91%E4%B8%AD%E5%BC%82%E5%B8%B8%E7%9A%84%E5%A4%84%E7%90%86.md   "开发中异常的处理"
+[127]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%BC%80%E5%8F%91%E4%B8%ADLog%E7%9A%84%E7%AE%A1%E7%90%86.md   "开发中Log的管理"
+[128]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%BF%AB%E6%8D%B7%E6%96%B9%E5%BC%8F%E5%B7%A5%E5%85%B7%E7%B1%BB.md   "快捷方式工具类"
+[129]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E6%9D%A5%E7%94%B5%E5%8F%B7%E7%A0%81%E5%BD%92%E5%B1%9E%E5%9C%B0%E6%8F%90%E7%A4%BA%E6%A1%86.md   "来电号码归属地提示框"
+[130]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E6%9D%A5%E7%94%B5%E7%9B%91%E5%90%AC%E5%8F%8A%E5%BD%95%E9%9F%B3.md   "来电监听及录音"
+[131]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E9%9B%B6%E6%9D%83%E9%99%90%E4%B8%8A%E4%BC%A0%E6%95%B0%E6%8D%AE.md   "零权限上传数据"
+[132]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F.md   "内存泄漏"
+[133]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%B1%8F%E5%B9%95%E9%80%82%E9%85%8D.md   "屏幕适配"
+[134]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E4%BB%BB%E5%8A%A1%E7%AE%A1%E7%90%86%E5%99%A8(ActivityManager).md   "任务管理器(ActivityManager)"
+[135]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E6%89%8B%E6%9C%BA%E6%91%87%E6%99%83.md   "手机摇晃"
+[136]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E7%AB%96%E7%9D%80%E7%9A%84Seekbar.md   "竖着的Seekbar"
+[137]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E6%95%B0%E6%8D%AE%E5%AD%98%E5%82%A8.md   "数据存储"
+[138]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E6%90%9C%E7%B4%A2%E6%A1%86.md   "搜索框"
+[139]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E9%94%81%E5%B1%8F%E4%BB%A5%E5%8F%8A%E8%A7%A3%E9%94%81%E7%9B%91%E5%90%AC.md   "锁屏以及解锁监听"
+[140]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E6%96%87%E4%BB%B6%E4%B8%8A%E4%BC%A0.md   "文件上传"
+[141]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E4%B8%8B%E6%8B%89%E5%88%B7%E6%96%B0ListView.md   "下拉刷新ListView"
+[142]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E4%BF%AE%E6%94%B9%E7%B3%BB%E7%BB%9F%E7%BB%84%E4%BB%B6%E6%A0%B7%E5%BC%8F.md   "修改系统组件样式"
+[143]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E9%9F%B3%E9%87%8F%E5%8F%8A%E5%B1%8F%E5%B9%95%E4%BA%AE%E5%BA%A6%E8%B0%83%E8%8A%82.md   "音量及屏幕亮度调节"
+[144]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%BA%94%E7%94%A8%E5%AE%89%E8%A3%85.md   "应用安装"
+[145]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%BA%94%E7%94%A8%E5%90%8E%E5%8F%B0%E5%94%A4%E9%86%92%E5%90%8E%E6%95%B0%E6%8D%AE%E7%9A%84%E5%88%B7%E6%96%B0.md   "应用后台唤醒后数据的刷新"
+[146]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E7%9F%A5%E8%AF%86%E5%A4%A7%E6%9D%82%E7%83%A9.md   "知识大杂烩"
+[147]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%B5%84%E6%BA%90%E6%96%87%E4%BB%B6%E6%8B%B7%E8%B4%9D%E7%9A%84%E4%B8%89%E7%A7%8D%E6%96%B9%E5%BC%8F.md   "资源文件拷贝的三种方式"
+[148]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%87%AA%E5%AE%9A%E4%B9%89%E8%83%8C%E6%99%AF.md   "自定义背景"
+[149]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%87%AA%E5%AE%9A%E4%B9%89%E6%8E%A7%E4%BB%B6.md   "自定义控件"
+[150]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%87%AA%E5%AE%9A%E4%B9%89%E7%8A%B6%E6%80%81%E6%A0%8F%E9%80%9A%E7%9F%A5.md   "自定义状态栏通知"
+[151]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E8%87%AA%E5%AE%9A%E4%B9%89Toast.md   "自定义Toast"
+[152]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/adb%20logcat%E4%BD%BF%E7%94%A8%E7%AE%80%E4%BB%8B.md   "adb logcat使用简介"
+[153]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Android%E7%BC%96%E7%A0%81%E8%A7%84%E8%8C%83.md   "Android编码规范"
+[154]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Android%E5%8A%A8%E7%94%BB.md   "Android动画"
+[155]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Android%E5%9F%BA%E7%A1%80%E9%9D%A2%E8%AF%95%E9%A2%98.md   "Android基础面试题"
+[156]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Android%E5%85%A5%E9%97%A8%E4%BB%8B%E7%BB%8D.md   "Android入门介绍"
+[157]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Android%E5%9B%9B%E5%A4%A7%E7%BB%84%E4%BB%B6%E4%B9%8BContentProvider.md   "Android四大组件之ContentProvider"
+[158]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Android%E5%9B%9B%E5%A4%A7%E7%BB%84%E4%BB%B6%E4%B9%8BService.md   "Android四大组件之Service"
+[159]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Ant%E6%89%93%E5%8C%85.md   "Ant打包"
+[160]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Bitmap%E4%BC%98%E5%8C%96.md   "Bitmap优化"
+[161]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Fragment%E4%B8%93%E9%A2%98.md   "Fragment专题"
+[162]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Home%E9%94%AE%E7%9B%91%E5%90%AC.md   "Home键监听"
+[163]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/HttpClient%E6%89%A7%E8%A1%8CGet%E5%92%8CPost%E8%AF%B7%E6%B1%82.md   "HttpClient执行Get和Post请求"
+[164]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/JNI_C%E8%AF%AD%E8%A8%80%E5%9F%BA%E7%A1%80.md   "JNI_C语言基础"
+[165]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/JNI%E5%9F%BA%E7%A1%80.md   "JNI基础"
+[166]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/ListView%E4%B8%93%E9%A2%98.md   "ListView专题"
+[167]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Parcelable%E5%8F%8ASerializable.md   "Parcelable及Serializable"
+[168]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/PopupWindow%E7%BB%86%E8%8A%82.md   "PopupWindow细节"
+[169]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Scroller%E7%AE%80%E4%BB%8B.md   "Scroller简介"
+[170]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/ScrollingTabs.md   "ScrollingTabs"
+[171]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/SDK%20Manager%E6%97%A0%E6%B3%95%E6%9B%B4%E6%96%B0%E7%9A%84%E9%97%AE%E9%A2%98.md   "SDK Manager无法更新的问题"
+[172]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Selector%E4%BD%BF%E7%94%A8.md   "Selector使用"
+[173]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/SlidingMenu.md   "SlidingMenu"
+[174]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/String%E6%A0%BC%E5%BC%8F%E5%8C%96.md   "String格式化"
+[175]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/TextView%E8%B7%91%E9%A9%AC%E7%81%AF%E6%95%88%E6%9E%9C.md   "TextView跑马灯效果"
+[176]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/WebView%E6%80%BB%E7%BB%93.md   "WebView总结"
+[177]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Widget(%E7%AA%97%E5%8F%A3%E5%B0%8F%E9%83%A8%E4%BB%B6).md   "Widget(窗口小部件)"
+[178]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/Wifi%E7%8A%B6%E6%80%81%E7%9B%91%E5%90%AC.md   "Wifi状态监听"
+[179]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/XmlPullParser.md   "XmlPullParser"
+
+
+[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 "设计模式"
+[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的区别"
+[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/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"
+[201]: https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/2.Dagger2%E5%85%A5%E9%97%A8demo(%E4%BA%8C).md  "2.Dagger2入门demo(二).md"
+[202]: https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/3.Dagger2%E5%85%A5%E9%97%A8demo%E6%89%A9%E5%B1%95(%E4%B8%89).md  "3.Dagger2入门demo扩展(三).md"
+[203]: https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/4.Dagger2%E5%8D%95%E4%BE%8B(%E5%9B%9B).md  "4.Dagger2单例(四).md"
+[204]: https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/5.Dagger2Lay%E5%92%8CProvider(%E4%BA%94).md  "5.Dagger2Lay和Provider(五).md"
+[205]: https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/6.Dagger2Android%E7%A4%BA%E4%BE%8B%E4%BB%A3%E7%A0%81(%E5%85%AD).md  "6.Dagger2Android示例代码(六).md"
+[206]: https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/7.Dagger2%E4%B9%8Bdagger-android(%E4%B8%83).md  "7.Dagger2之dagger-android(七).md"
+[207]: https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/8.Dagger2%E4%B8%8EMVP(%E5%85%AB).md  "8.Dagger2与MVP(八).md"
+[208]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Android%20WorkManager.md  "Android WorkManager.md"
+
+[209]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/4.RxJava%E8%AF%A6%E8%A7%A3%E4%B9%8B%E6%89%A7%E8%A1%8C%E5%8E%9F%E7%90%86(%E5%9B%9B).md  "4.RxJava详解之执行原理(四)"
+[210]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/5.RxJava%E8%AF%A6%E8%A7%A3%E4%B9%8B%E6%93%8D%E4%BD%9C%E7%AC%A6%E6%89%A7%E8%A1%8C%E5%8E%9F%E7%90%86(%E4%BA%94).md  "5.RxJava详解之操作符执行原理(五)"
+[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/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简介"
+[218]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/2.%20ExoPlayer%20MediaSource%E7%AE%80%E4%BB%8B.md "2. ExoPlayer MediaSource简介"
+[219]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/3.%20ExoPlayer%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E4%B9%8Bprepare%E6%96%B9%E6%B3%95.md "3. ExoPlayer源码分析之prepare方法"
+[220]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/4.%20ExoPlayer%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E4%B9%8Bprepare%E5%BA%8F%E5%88%97%E5%9B%BE.md "4. ExoPlayer源码分析之prepare序列图"
+[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/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/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/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简介"
+[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/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"
+[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/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"
+[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穿透"
+[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%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.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.虚拟机"
+[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简介"
+
+[ 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.简介"
+[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.播放器组件封装"
+[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/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"
+[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/14.%E5%AE%9E%E4%BE%8B%E5%8C%96.md  "14.实例化"
+
+
 Developed By
 ===
 
@@ -18,15 +741,15 @@ 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.
     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/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"
new file mode 100644
index 00000000..9e6e2c14
--- /dev/null
+++ "b/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md"
@@ -0,0 +1,792 @@
+RxJava详解(一)
+===
+
+现在`RxJava`变的越来越流行了，很多项目中都使用了它。特别是大神`JakeWharton`等的加入，以及`RxBinding、Retrofit、RxLifecycle`等众多项目的，然开发越来越方便，但是上手比较难，不过一旦你入门后你就会发现真是太棒了。
+
+
+在介绍`RxJava`之前，感觉有必要说一下什么是函数响应式编程(`FRP`)？     
+
+函数响应式编程（`FRP`）为解决现代编程问题提供了全新的视角。一旦理解它，可以极大地简化你的项目，特别是处理嵌套回调的异步事件，复杂的列表过滤和变换，或者时间相关问题，而且`RxJava`是响应式编程的一个具体实现。
+
+这里以一个真实的例子来开始讲解函数响应式编程怎么提高我们代码的可读性。我们的任务是通过查询`GitHub`的`API`， 首先获取用户列表，然后请求每个用户的详细信息。这个过程包括两个`web`服务端点:
+`https://api.github.com/users`-获取用户列表；`https://api.github.com/users/{username}`－获取特定用户的详细信息，例如`https://api.github.com/users/mutexkid`。
+
+普通情况下是这样写的:    
+```java
+//The "Nested Callbacks" Way
+public void fetchUserDetails() {
+    //first, request the users...
+    mService.requestUsers(new Callback<GithubUsersResponse>() {
+        @Override
+        public void success(final GithubUsersResponse githubUsersResponse,
+                            final Response response) {
+            Timber.i(TAG, "Request Users request completed");
+            final synchronized List<GithubUserDetail> githubUserDetails = new ArrayList<GithubUserDetail>();
+            //next, loop over each item in the response
+            for (GithubUserDetail githubUserDetail : githubUsersResponse) {
+                //request a detail object for that user
+                mService.requestUserDetails(githubUserDetail.mLogin,
+                                            new Callback<GithubUserDetail>() {
+                    @Override
+                    public void success(GithubUserDetail githubUserDetail,
+                                        Response response) {
+                        Log.i("User Detail request completed for user : " + githubUserDetail.mLogin);
+                        githubUserDetails.add(githubUserDetail);
+                        if (githubUserDetails.size() == githubUsersResponse.mGithubUsers.size()) {
+                            //we've downloaded'em all - notify all who are interested!
+                            mBus.post(new UserDetailsLoadedCompleteEvent(githubUserDetails));
+                        }
+                    }
+
+                    @Override
+                    public void failure(RetrofitError error) {
+                        Log.e(TAG, "Request User Detail Failed!!!!", error);
+                    }
+                });
+            }
+        }
+
+        @Override
+        public void failure(RetrofitError error) {
+            Log.e(TAG, "Request User Failed!!!!", error);
+        }
+    });
+}
+```
+
+尽管这不是最差的代码－至少它是异步的，因此在等待每个请求完成的时候不会阻塞－但由于代码复杂（增加更多层次的回调代码复杂度将呈指数级增长）因此远非理想的代码。
+当我们不可避免要修改代码时（在前面的`web service`调用中，我们依赖前一次的回调状态，因此它不适用于模块化或者修改要传递给下一个回调的数据）也远非容易的工作。
+我们亲切的称这种情况为“回调地狱”。
+
+而通过`RxJava`的方式:    
+```java
+public void rxFetchUserDetails() {
+    //request the users
+    mService.rxRequestUsers().concatMap(Observable::from)
+    .concatMap((GithubUser githubUser) ->
+                    //request the details for each user
+                    mService.rxRequestUserDetails(githubUser.mLogin)
+    )
+    //accumulate them as a list
+    .toList()
+    //define which threads information will be passed on
+    .subscribeOn(Schedulers.newThread())
+    .observeOn(AndroidSchedulers.mainThread())
+    //post them on an eventbus
+    .subscribe(githubUserDetails -> {
+        EventBus.getDefault().post(new UserDetailsLoadedCompleteEvent(githubUserDetails));
+    });
+}
+```
+
+如你所见，使用函数响应式编程模型我们完全摆脱了回调，并最终得到了更短小的程序。让我们从函数响应式编程的基本定义开始慢慢解释到底发生了什么，并逐渐理解上面的代码，这些代码托管在`GitHub`上面。
+
+从根本上讲，函数响应式编程是在观察者模式的基础上，增加对`Observables`发送的数据流进行操纵和变换的功能。
+
+
+
+特殊注意：
+
+（1） 若Observable.subscribeOn（）多次指定被观察者 生产事件的线程，则只有第一次指定有效，其余的指定线程无效。
+（2） 若Observable.observeOn（）多次指定观察者 接收 & 响应事件的线程，则每次指定均有效，即每指定一次，就会进行一次线程的切换。
+
+
+
+`RxJava`简介
+---
+
+在介绍`RxJava`之前先说一下`Rx`。`Rx`的全称是`Reactive Extensions`，直译过来就是响应式扩展。
+
+![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](http://reactivex.io/)
+- [RxJava](https://github.com/ReactiveX/RxJava)       
+- [RxAndroid](https://github.com/ReactiveX/RxAndroid)
+
+`RxJava`在`GitHub`上的介绍是：`a library for composing asynchronous and event-based programs by using observable sequences for the Java VM.`
+翻译过来也就是一个基于事件和程序在`Java VM`上使用可观测的序列来组成异步的库。`RxJava`的本质就是一个实现异步操作的库，它的优势就是简洁，随着程序逻辑变得越来越复杂，它依然能够保持简洁。       
+
+其实一句话总结一下`RxJava`的作用就是：异步   
+
+这里可能会有人想不就是个异步吗，至于辣么矫情么?用`AsyncTask`、`Handler`甚至自定义一个`BigAsyncTask`分分钟搞定。
+
+但是`RxJava`的好处是简洁。异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。     
+
+`Android`创造的`AsyncTask`和`Handler`其实都是为了让异步代码更加简洁。虽然`RxJava`的优势也是简洁，但它的简洁的与众不同之处在于，随着程序逻辑变得越来越复杂，它依然能够保持简洁。
+
+
+#### 扩展的观察者模式
+
+
+`RxJava`的异步实现，是通过一种扩展的观察者模式来实现的。
+
+观察者模式面向的需求是：`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()` -> 事件），就由专用的观察者模式（例如只用于监听控件点击）转变成了通用的观察者模式。如下图：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/btn_rxjava_observable.jpg?raw=true)
+
+而`RxJava`作为一个工具库，使用的就是通用形式的观察者模式。
+
+
+#### `RxJava`的观察者模式
+
+ 
+`RxJava`的基本概念：
+
+- `Observable`(可观察者，即被观察者):产生事件，例如去饭店吃饭的顾客。
+- `Observer`(观察者):接收事件，并给出响应动作，例如去饭店吃饭的厨房，会接受事件，并给出响应。
+- `subscribe()`(订阅):连接被观察者与观察者，例如去饭店吃饭的服务员。
+    `Observable`和`Observer`通过`subscribe()` 方法实现订阅关系，从而`Observable`可以在需要的时候发出事件来通知`Observer`。
+- `Event`(事件):被观察者与观察者沟通的载体，例如顾客点的菜。
+
+与传统观察者模式不同，`RxJava`的事件回调方法除了普通事件`onNext()`(相当于`onClick()`/`onEvent()`)之外，还定义了两个特殊的事件：`onCompleted()`和`onError()`:     
+但是`RxJava`与传统的观察者设计模式有一点明显不同，那就是如果一个`Observerble`没有任何的的`Subscriber`，那么这个`Observable`是不会发出任何事件的。
+
+
+- `onCompleted()`: 事件队列完结。         
+    `RxJava`不仅把每个事件单独处理，还会把它们看做一个队列。`RxJava`规定，当不会再有新的`onNext()`发出时，需要触发`onCompleted()` 方法作为标志。
+- `onError()`: 事件队列异常。
+    在事件处理过程中出异常时，`onError()`会被触发，同时队列自动终止，不允许再有事件发出。
+- 在一个正确运行的事件序列中, `onCompleted()`和`onError()`有且只有一个，并且是事件序列中的最后一个。需要注意的是`onCompleted()`和`onError()` 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。
+
+
+`RxJava`的观察者模式大致如下图：
+
+![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；
+
+
+
+#### 基本实现
+
+
+基于上面的概念， `RxJava`的基本实现主要有三点:    
+
+- 创建`Observable`         
+    `Observable`即被观察者，它决定什么时候触发事件以及触发怎样的事件。 `RxJava`使用`Observable.create()`方法来创建一个`Observable`，并为它定义事件触发规则。    
+
+- 创建`Observer`即观察者，它决定事件触发的时候将有怎样的行为。       
+    `RxJava`中的`Observer`接口的实现方式:    
+   ```java
+   Observer<String> observer = new Observer<String>() {
+       @Override
+       public void onNext(String s) {
+           Log.d(tag, "Item: " + s);
+       }
+
+       @Override
+       public void onCompleted() {
+           Log.d(tag, "Completed!");
+       }
+
+       @Override
+       public void onError(Throwable e) {
+           Log.d(tag, "Error!");
+       }
+   };
+   ```
+    除了`Observer`接口之外，`RxJava`还内置了一个实现了`Observer`的抽象类:`Subscriber`。`Subscriber`对`Observer`接口进行了一些扩展，但他们的基本使用方式是完全一样的。
+
+   ```java
+   Subscriber<String> subscriber = new Subscriber<String>() {
+       @Override
+       public void onNext(String s) {
+           Log.d(tag, "Item: " + s);
+       }
+
+       @Override
+       public void onCompleted() {
+           Log.d(tag, "Completed!");
+       }
+
+       @Override
+       public void onError(Throwable e) {
+           Log.d(tag, "Error!");
+       }
+   };
+   ```
+    不仅基本使用方式一样，实质上，在`RxJava`的`subscribe()`过程中，`Observer`也总是会先被转换成一个`Subscriber`再使用。所以如果你只想使用基本功能，选择`Observer`和 `Subscriber`是完全一样的。它们的区别对于使用者来说主要有两点：
+
+    - `onStart()`: 这是`Subscriber`增加的方法。它会在`subscribe()`刚开始而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行）， `onStart()`就不适用了，因为它总是在`subscribe()` 所发生的线程被调用，而不能指定线程。要在指定的线程来做准备工作，可以使用`doOnSubscribe()`方法，具体可以在后面的文中看到。
+    - `unsubscribe`(): 这是`Subscriber`所实现的另一个接口`Subscription`的方法，用于取消订阅。在这个方法被调用后，`Subscriber` 将不再接收事件。一般在这个方法调用前，可以使用`isUnsubscribed()`先判断一下状态。 `unsubscribe()`这个方法很重要，因为在`subscribe()`之后,`Observable`会持有 `Subscriber`的引用，这个引用如果不能及时被释放，将有内存泄露的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方（例如`onPause()、onStop()`等方法中）调用`unsubscribe()`来解除引用关系，以避免内存泄露的发生。
+    所以后续讲解时我们有时会用`Subscriber`来代替`Observer`。
+
+- 调用`subscribe()`方法(订阅)
+
+    创建了一个`Observable`和`Observer`之后，再用`subscribe()`方法将它们联结起来，整条链子就可以工作了。代码形式很简单：
+
+    ```java
+    observable.subscribe(observer);  
+    // 或者：
+    observable.subscribe(subscriber);
+    ```
+
+    > 有人可能会注意到，`subscribe()`这个方法有点怪：它看起来是`observalbe`订阅了`observer/subscriber`而不是`observer/subscriber`订阅了`observalbe`，这看起来就像『杂志订阅了读者』一样颠倒了对象关系。       
+    > 这让人读起来有点别扭，不过如果把`API`设计成`observer.subscribe(observable)/subscriber.subscribe(observable)` ，虽然更加符合思维逻辑，但对流式`API`的设计就造成影响了，比较起来明显是得不偿失的。
+
+  
+`RxJava`入门示例
+---
+
+一个`Observable`可以发出零个或者多个事件，直到结束或者出错。每发出一个事件，就会调用它的`Subscriber`的`onNext`方法，最后调用`Subscriber.onComplete()`或者`Subscriber.onError()`结束。
+
+#### `Hello World`
+
+
+```
+compile 'io.reactivex:rxandroid:1.2.1'
+// Because RxAndroid releases are few and far between, it is recommended you also
+// explicitly depend on RxJava's latest version for bug fixes and new features.
+compile 'io.reactivex:rxjava:1.2.3'
+```
+
+```java
+// 创建被观察者、数据源
+Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
+    @Override
+    public void call(Subscriber<? super String> subscriber) {
+        // 可以看到，这里传入了一个 OnSubscribe 对象作为参数。OnSubscribe 会被存储在返回的 Observable 对象中，它的作用相当于一个计划表，当 Observable      
+        //被订阅的时候，OnSubscribe 的 call() 方法会自动被调用，事件序列就会依照设定依次触发（对于上面的代码，就是观察者Subscriber 将会被调用三次 onNext() 和一次 
+        // onCompleted()）。这样，由被观察者调用了观察者的回调方法，就实现了由被观察者向观察者的事件传递，即观察者模式。
+        Log.i("@@@", "call");
+        subscriber.onNext("Hello ");
+        subscriber.onNext("World !");
+        subscriber.onCompleted();
+    }
+});
+// 创建观察者
+Subscriber<String> subscriber = new Subscriber<String>() {
+    @Override
+    public void onCompleted() {
+        Log.i("@@@", "onCompleted");
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        Log.i("@@@", "onError");
+    }
+
+    @Override
+    public void onNext(String s) {
+        Log.i("@@@", "onNext : " + s);
+    }
+};
+// 关联或者叫订阅更合适。
+observable.subscribe(subscriber);
+```
+
+一旦`subscriber`订阅了`observable`，`observable`就会调用`subscriber`对象的`onNext`和`onComplete`方法，`subscriber`就会打印出`Hello World`.        
+
+ `Observable.subscribe(Subscriber)`的内部实现是这样的（仅核心代码）：
+
+```java
+// 注意：这不是`subscribe()`的源码，而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。
+public Subscription subscribe(Subscriber subscriber) {
+   subscriber.onStart();
+   onSubscribe.call(subscriber);
+   return subscriber;
+}
+```
+
+可以看到`subscriber()`做了3件事:        
+
+- 调用`Subscriber.onStart()`。这个方法在前面已经介绍过，是一个可选的准备方法。
+- 调用`Observable`中的`onSubscribe.call(Subscriber)`。在这里，事件发送的逻辑开始运行。从这也可以看出，在`RxJava`中，`Observable` 并不是在创建的时候就立即开始发送事件，而是在它被订阅的时候，即当`subscribe()`方法执行的时候。
+- 将传入的`Subscriber`作为`Subscription`返回。这是为了方便`unsubscribe()`.
+
+整个过程中对象间的关系如下图：
+    
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_observable_list.gif?raw=true)
+
+
+`RxJava`内置了很多简化创建`Observable`对象的函数，比如`Observable.just()`就是用来创建只发出一个事件就结束的`Observable`对象，上面创建`Observable`对象的代码可以简化为一行
+
+```java
+Observable<String> observable = Observable.just("Hello ", "World !");
+```
+
+接下来看看如何简化`Subscriber`，上面的例子中，我们其实并不关心`onComplete()`和`onError`，我们只需要在`onNext`的时候做一些处理，这时候就可以使用`Action1`类。
+
+```java
+Action1<String> action1 = new Action1<String>() {
+    @Override
+    public void call(String s) {
+        Log.i("@@@", "call : " + s);
+    }
+};
+```
+
+`Observable.subscribe()`方法有一个重载版本，接受三个`Action1`类型的参数      
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_subscribe_params.png?raw=true)
+
+所以上面的代码最终可以写成这样:   
+
+```java
+Observable.just("Hello ", "World !").subscribe(new Action1<String>() {
+    @Override
+    public void call(String s) {
+        Log.i("@@@", "call : " + s);
+    }
+});
+```
+
+这里顺便多提一下`subscribe()`的多个`Action`参数：   
+```java
+Action1<String> onNextAction = new Action1<String>() {
+    // onNext()
+    @Override
+    public void call(String s) {
+        Log.d(tag, s);
+    }
+};
+Action1<Throwable> onErrorAction = new Action1<Throwable>() {
+    // onError()
+    @Override
+    public void call(Throwable throwable) {
+        // Error handling
+    }
+};
+Action0 onCompletedAction = new Action0() {
+    // onCompleted()
+    @Override
+    public void call() {
+        Log.d(tag, "completed");
+    }
+};
+
+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`)的，它们可以被用以包装不同的无返回值的方法。
+
+
+假设我们的`Observable`是第三方提供的，它提供了大量的用户数据给我们，而我们需要从用户数据中筛选部分有用的信息，那我们该怎么办呢？    
+从`Observable`中去修改肯定是不现实的？那从`Subscriber`中进行修改呢？ 这样好像是可以完成的。但是这种方式并不好，因为我们希望`Subscriber`越轻量越好，因为很有可能我们需要
+在主线程中去执行`Subscriber`。
+
+另外，根据响应式函数编程的概念，`Subscribers`更应该做的事情是`响应`，响应`Observable`发出的事件，而不是去修改。
+那该怎么办呢？ 这就要用到下面的部分要讲的操作符。  
+
+
+
+接口变化
+---
+
+`RxJava 2.x`拥有了新的特性，其依赖于4个基础接口，它们分别是:     
+- `Publisher`
+- `Subscriber`
+- `Subscription`
+- `Processor`
+其中最核心的莫过于`Publisher`和`Subscriber`。`Publisher`可以发出一系列的事件，而`Subscriber`负责和处理这些事件。
+
+其中用的比较多的自然是`Publisher`的`Flowable`，它支持背压(`backpressure`)。关于背压给个简洁的定义就是: 
+
+> 背压是指在异步场景中，被观察者发送事件速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略。
+
+简而言之，背压是流速控制的一种策略。      
+其实`RxJava 2.x`最大的改动就是对于`backpressure`的处理，为此将原来的`Observable`拆分成了新的`Observable`和`Flowable`，同时其他相关部分也同时进行了拆分。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava1vs2.png?raw=true)
+
+
+在`RxJava 2.x`中，`Observable`用于订阅`Observer`，不再支持背压（`1.x`中可以使用背压策略），而`Flowable`用于订阅`Subscriber`，是支持背压的。
+
+操作符(`Operators`)
+---
+
+`RxJava`提供了对事件序列进行变换的支持，这是它的核心功能之一.所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。       
+操作符就是为了解决对`Observable`对象的变换的问题，操作符用于在`Observable`和最终的`Subscriber`之间修改`Observable`发出的事件。`RxJava`提供了很多很有用的操作符。
+比如`map`操作符，就是用来把一个事件转换为另一个事件的。
+
+#### `map`
+
+
+`Returns an Observable that applies a specified function to each item emitted by the source Observable and emits the results of these function applications.`
+
+```java
+Observable<String> just = Observable.just("Hello ", "World !");
+Observable<String> map = just.map(new Func1<String, String>() {
+    @Override
+    public String call(String s) {
+        return s + "@@@";
+    }
+});
+map.subscribe(new Action1<String>() {
+    @Override
+    public void call(String s) {
+        Log.i("@@@", s);
+    }
+});
+```
+上面的代码打印出的结果是:   
+```
+12-12 15:51:22.184 472-472/com.charon.rxjavastudydemo I/@@@: Hello @@@
+12-12 15:51:22.184 472-472/com.charon.rxjavastudydemo I/@@@: World !@@@
+```
+
+`map()`操作符就是用于变换`Observable`对象的，`map`操作符返回一个`Observable`对象，这样就可以实现链式调用，在一个`Observable`对象上多次使用map操作符，最终将最简洁的数据传递给`Subscriber`对象。
+
+`map`操作符更有趣的一点是它不必返回Observable对象返回的类型，你可以使用`map`操作符返回一个发出新的数据类型的`Observable`对象。
+比如上面的例子中，`Subscriber`并不关心返回的字符串，而是想要字符串的`hash`值。
+
+
+```java
+Observable<String> just = Observable.just("Hello ", "World !");
+Observable<Integer> map = just.map(new Func1<String, Integer>() {
+    @Override
+    public Integer call(String s) {
+        return s.hashCode();
+    }
+});
+map.subscribe(new Action1<Integer>() {
+    @Override
+    public void call(Integer integer) {
+        Log.i("@@@", "" + integer);
+    }
+});
+```
+
+上面部分的打印结果是:    
+```
+12-12 15:54:35.515 8521-8521/com.charon.rxjavastudydemo I/@@@: -2137068114
+12-12 15:54:35.516 8521-8521/com.charon.rxjavastudydemo I/@@@: -1105126669
+```
+
+`map()`的示意图：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_map.jpg?raw=true)
+
+通过上面的部分我们可以得知:   
+
+- `Observable`和`Subscriber`可以做任何事情    
+    `Observable`可以是一个数据库查询，`Subscriber`用来显示查询结果；`Observable`可以是屏幕上的点击事件，`Subscriber`用来响应点击事件；`Observable`可以是一个网络请求，`Subscriber`用来显示请求结果。
+
+- `Observable`和`Subscriber`是独立于中间的变换过程的      
+    在`Observable`和`Subscriber`中间 可以增减任何数量的`map`。整个系统是高度可组合的，操作数据是一个很简单的过程。
+
+
+#### `flatmap`
+
+
+`Returns an Observable that emits items based on applying a function that you supply to each item emitted 
+ by the source Observable, where that function returns an Observable, and then merging those resulting 
+ Observables and emitting the results of this merger.`
+
+`flatMap()`是一个很有用但非常难理解的变换，首先假设这么一种需求：假设有一个数据结构『学生』，现在需要打印出一组学生的名字。实现方式很简单：
+
+```java
+Student[] students = ...;
+Subscriber<String> subscriber = new Subscriber<String>() {
+    @Override
+    public void onNext(String name) {
+        Log.d(tag, name);
+    }
+    ...
+};
+Observable.from(students)
+    .map(new Func1<Student, String>() {
+        @Override
+        public String call(Student student) {
+            return student.getName();
+        }
+    })
+    .subscribe(subscriber);
+```
+
+很简单。那么再假设：如果要打印出每个学生所需要修的所有课程的名称呢?(需求的区别在于，每个学生只有一个名字，但却有多个课程)首先可以这样实现：
+
+```java
+Student[] students = ...;
+Subscriber<Student> subscriber = new Subscriber<Student>() {
+    @Override
+    public void onNext(Student student) {
+        List<Course> courses = student.getCourses();
+        for (int i = 0; i < courses.size(); i++) {
+            Course course = courses.get(i);
+            Log.d(tag, course.getName());
+        }
+    }
+    ...
+};
+Observable.from(students)
+    .subscribe(subscriber);
+```
+
+依然很简单。那么如果我不想在`Subscriber`中使用`for`循环，而是希望`Subscriber`中直接传入单个的`Course`对象呢(这对于代码复用很重要),用`map()`显然是不行的，因为`map()` 是一对一的转化，而我现在的要求是一对多的转化。那怎么才能把一个`Student`转化成多个`Course`呢？
+
+这个时候，就需要用`flatMap()`了：
+```java
+Student[] students = ...;
+Subscriber<Course> subscriber = new Subscriber<Course>() {
+    @Override
+    public void onNext(Course course) {
+        Log.d(tag, course.getName());
+    }
+    ...
+};
+Observable.from(students)
+    .flatMap(new Func1<Student, Observable<Course>>() {
+        @Override
+        public Observable<Course> call(Student student) {
+            return Observable.from(student.getCourses());
+        }
+    })
+    .subscribe(subscriber);
+```
+
+`map`与`flatmap`在功能上是一致的,它也是把传入的参数转化之后返回另一个对象。区别在于`flatmap`是通过中间`Observable`来进行，而`map`是直接执行.       
+
+`flatMap()`中返回的是个 `Observable`对象，并且这个`Observable`对象并不是被直接发送到了`Subscriber`的回调方法中。 
+
+`flatMap()`的原理是这样的:  
+
+- 使用传入的事件对象创建一个`Observable`对象
+- 并不发送这个`Observable`而是将它激活，于是它开始发送事件
+- 每一个创建出来的`Observable`发送的事件，都被汇入同一个`Observable`,而这个`Observable`负责将这些事件统一交给`Subscriber` 的回调方法。
+
+这三个步骤，把事件拆成了两级，通过一组新创建的`Observable`将初始的对象『铺平』之后通过统一路径分发了下去。而这个『铺平』就是`flatMap()`所谓的`flat`。
+
+`flatMap()`就是根据你的规则，将`Observable`转换之后再发射出去，注意最后的顺序很可能是错乱的，如果要保证顺序的一致性，要使用`concatMap()`     
+由于可以在嵌套的`Observable`中添加异步代码`flatMap()`也常用于嵌套的异步操作，例如嵌套的网络请求`(Retrofit + RxJava)`
+
+`flatMap()`示意图：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_flatmap.jpg?raw=true)
+
+
+#### `throttleFirst()`
+
+
+在每次事件触发后的一定时间间隔内丢弃新的事件。常用作去抖动过滤。 
+例如按钮的点击监听器:    
+```java
+RxView.clickEvents(button); // RxBinding 代码`
+    .throttleFirst(500, TimeUnit.MILLISECONDS) // 设置防抖间隔为 500ms 
+    .subscribe(subscriber); // 妈妈再也不怕我的用户手抖点开两个重复的界面啦。
+```
+
+#### `from`
+
+
+`convert various other objects and data types into Observables`
+
+`from()`接收一个集合作为输入，然后每次输出一个元素给`subscriber`.
+
+```java
+List<String> s = Arrays.asList("Java", "Android", "Ruby", "Ios", "Swift");
+Observable.from(s).subscribe(new Action1<String>() {
+    @Override
+    public void call(String s) {
+        Log.i("@@@", s);
+    }
+});
+```
+
+#### `filter`
+
+
+返回满足过滤条件的数据。  
+
+```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
+        }
+    });
+```
+
+#### `timer`
+
+
+`Timer`会在指定时间后发射一个数字0，该操作符运行在`Computation Scheduler`。
+
+```java
+Observable.timer(3, TimeUnit.SECONDS).observeOn(AndroidSchedulers.mainThread())
+    .subscribe(new Action1<Long>() {
+        @Override
+        public void call(Long aLong) {
+            Log.i("@@@", "aLong=" + aLong); // 延时3s
+        }
+    });
+```
+
+#### `interval`
+
+
+创建一个按固定时间间隔发射整数序列的`Observable`.
+`interval`默认在`computation`调度器上执行。
+
+```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....
+        }
+    });
+```
+
+#### `Repeat`
+
+
+重复执行 
+
+
+#### `doOnNext`
+
+其实觉得`doOnNext`应该不算一个操作符，但考虑到其常用性，我们还是咬咬牙将它放在了这里。它的作用是让订阅者在接收到数据之前干点有意思的事情。假如我们在获取到数据之前想先保存一下它，无疑我们可以这样实现。
+
+#### `distinct`
+
+这个操作符非常的简单、通俗、易懂，就是简单的去重
+
+#### `take`
+
+`take`，接受一个`long`型参数`count`，代表至多接收`count`个数据。
+
+
+等等...就不继续介绍了，到时候查下文档就好了。
+
+是不是感觉没什么卵用，也稀里糊涂的，下面用一个网络请求的例子:   
+
+
+
+
+很多时候我们在使用`RxJava`的时候总是和`Retrofit`进行结合使用，而为了方便演示，这里我们就暂且采用`OkHttp3`进行演示，配合`map`，`doOnNext`，线程切换进行简单的网络请求:   
+
+- 通过`Observable.create()`方法，调用`OkHttp`网络请求；
+- 通过`map`操作符集合`gson`，将`Response`转换为`bean`类；
+- 通过`doOnNext()`方法，解析`bean`中的数据，并进行数据库存储等操作；
+- 调度线程，在子线程中进行耗时操作任务，在主线程中更新`UI`；
+- 通过`subscribe()`，根据请求成功或者失败来更新`UI`。
+```java
+Observable.create(new ObservableOnSubscribe<Response>() {
+    @Override
+    public void subscribe(@NonNull ObservableEmitter<Response> e) throws Exception {
+        Builder builder = new Builder()
+                .url(mUrl)
+                .get();
+        Request request = builder.build();
+        Call call = new OkHttpClient().newCall(request);
+        Response response = call.execute();
+        e.onNext(response);
+    }
+}).map(new Function<Response, MobileAddress>() {
+    @Override
+    public MobileAddress apply(@NonNull Response response) throws Exception {
+
+        Log.e(TAG, "map 线程:" + Thread.currentThread().getName() + "\n");
+        if (response.isSuccessful()) {
+            ResponseBody body = response.body();
+            if (body != null) {
+                Log.e(TAG, "map:转换前:" + response.body());
+                return new Gson().fromJson(body.string(), MobileAddress.class);
+            }
+        }
+        return null;
+    }
+}).observeOn(AndroidSchedulers.mainThread())
+    .doOnNext(new Consumer<MobileAddress>() {
+        @Override
+        public void accept(@NonNull MobileAddress s) throws Exception {
+            Log.e(TAG, "doOnNext 线程:" + Thread.currentThread().getName() + "\n");
+            mRxOperatorsText.append("\ndoOnNext 线程:" + Thread.currentThread().getName() + "\n");
+            Log.e(TAG, "doOnNext: 保存成功：" + s.toString() + "\n");
+            mRxOperatorsText.append("doOnNext: 保存成功：" + s.toString() + "\n");
+
+        }
+    }).subscribeOn(Schedulers.io())
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(new Consumer<MobileAddress>() {
+            @Override
+            public void accept(@NonNull MobileAddress data) throws Exception {
+                Log.e(TAG, "subscribe 线程:" + Thread.currentThread().getName() + "\n");
+                mRxOperatorsText.append("\nsubscribe 线程:" + Thread.currentThread().getName() + "\n");
+                Log.e(TAG, "成功:" + data.toString() + "\n");
+                mRxOperatorsText.append("成功:" + data.toString() + "\n");
+            }
+        }, new Consumer<Throwable>() {
+            @Override
+            public void accept(@NonNull Throwable throwable) throws Exception {
+                Log.e(TAG, "subscribe 线程:" + Thread.currentThread().getName() + "\n");
+                mRxOperatorsText.append("\nsubscribe 线程:" + Thread.currentThread().getName() + "\n");
+
+                Log.e(TAG, "失败：" + throwable.getMessage() + "\n");
+                mRxOperatorsText.append("失败：" + throwable.getMessage() + "\n");
+            }
+        });
+```
+
+
+
+更多内容请看下一篇文章[RxJava详解(二)][1]
+
+参考:   
+
+- [RxJava Wiki](https://github.com/ReactiveX/RxJava/wiki)
+- [Grokking RxJava, Part 1: The Basics](http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/)
+- [NotRxJava](https://yarikx.github.io/NotRxJava/)
+- [When Not to Use RxJava](http://tomstechnicalblog.blogspot.hk/2016/07/when-not-to-use-rxjava.html)
+- [给 Android 开发者的 RxJava 详解](http://gank.io/post/560e15be2dca930e00da1083)
+- [Google Agera 从入门到放弃](http://blog.chengyunfeng.com/?p=984)
+
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/2.RxJava%E8%AF%A6%E8%A7%A3(%E4%BA%8C).md "RxJava详解(二)"
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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"
new file mode 100644
index 00000000..55be3ce4
--- /dev/null
+++ "b/RxJavaPart/2.RxJava\350\257\246\350\247\243(\344\272\214).md"
@@ -0,0 +1,1004 @@
+RxJava详解(二)
+===
+
+
+说好的简洁呢？
+---
+
+上面这一部分，又是介绍、又是`Hello World`、又是数据变换，但是你会发现然而并没有什么卵用。说好的简洁一点也木有体现出来。    
+
+下面我们会通过一个简单的例子来进行说明。现在我们有这样一个需求:    
+
+> 有一个服务提供了一些`API`来搜索整个网络上的符合查询关键字的所有猫的图片。 每个图片包含一个可爱程度的参数(一个整数值表示其可爱程度)。 我们的任务就是下载所有猫的列表并选择最可爱的那个，把它的图片保存到本地。
+
+#### `Model`和`API`
+
+
+下面是猫的数据结构`Cat`:   
+
+```java
+public class Cat implements Comparable<Cat>{
+    Bitmap image;
+    int cuteness;
+
+    @Override
+    public int compareTo(Cat another) {
+        return Integer.compare(cuteness, another.cuteness);
+    }
+}
+```
+
+我们的`API`会调用`cat-sdk.jar`中堵塞式的接口。
+```java
+public interface Api {
+    List<Cat> queryCats(String query);
+    Uri store(Cat cat);
+}
+```
+
+看起来很清晰吧？当然了，我们继续写客户端的业务逻辑.
+```java
+public class CatsHelper {
+
+    Api api;
+
+    public Uri saveTheCutestCat(String query){
+        List<Cat> cats = api.queryCats(query);
+        Cat cutest = findCutest(cats);
+        Uri savedUri = api.store(cutest);
+        return savedUri;
+    }
+
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+通俗易懂、简单明了，非常酷的代码。主要的函数`saveTheCutestCat()`只包含了3个方法。使用这些方法然后等待方法执行完并接受返回值就可以了。
+
+非常简单、有效。接下来我们看一下这种方式的其他优点。  
+
+#### 组合
+
+
+可以看到我们的`saveTheCutestCat`由其他三个函数调用所组成的。我们通过函数来把一个大功能分割为每个容易理解的小功能。通过函数调用来组合使用这些小功能。使用和理解起来都相当简单
+
+#### 异常传递
+
+
+另外一个使用函数的好处就是方便处理异常。每个函数都可以通过抛出异常来结束运行。该异常可以在抛出异常的函数里面处理，也可以在调用该函数的外面处理，所以我们无需每次都处理每个异常，我们可以在一个地方处理所有可能抛出的异常。
+
+
+```java
+try{
+    List<Cat> cats = api.queryCats(query);
+    Cat cutest = findCutest(cats);
+    Uri savedUri = api.store(cutest);
+    return savedUri;
+} catch (Exception e) {
+    e.printStackTrace()
+    return someDefaultValue;
+}
+```
+
+这样，我们就可以处理这三个函数中所抛出的任何异常了。如果没有`try catch`语句，我们也可以把异常继续传递下去。
+
+
+向异步出发
+---
+
+但是，现实世界中我们往往没法等待。有些时候你没法只使用阻塞调用。在`Android`中你需要处理各种异步操作。
+就那`Android`的`OnClickListener`接口来说吧，如果你需要处理一个`View`的点击事件，你必须提供一个该`Listener` 的实现来处理用户的点击事件。下面来看看如何处理异步调用。
+
+
+#### 异步网络调用
+
+
+假设我们的`cats-sdk.jar`使用了异步调用的`API`来访问网络资源，
+这样我们的新`API`接口就变为这样了：
+
+```java
+public interface Api {
+    interface CatsQueryCallback {
+        void onCatListReceived(List<Cat> cats);
+        void onError(Exception e);
+    }
+
+
+    void queryCats(String query, CatsQueryCallback catsQueryCallback);
+
+    Uri store(Cat cat);
+}
+```
+这样我们查询猫的操作就变为异步的了， 通过`CatsQueryCallback`回调接口来结束查询的数据和处理异常情况。
+我们的业务逻辑也需要跟着改变一下：
+
+```java
+public class CatsHelper {
+ 
+    public interface CutestCatCallback {
+        void onCutestCatSaved(Uri uri);
+        void onQueryFailed(Exception e);
+    }
+ 
+    Api api;
+ 
+    public void saveTheCutestCat(String query, CutestCatCallback cutestCatCallback){
+        api.queryCats(query, new Api.CatsQueryCallback() {
+            @Override
+            public void onCatListReceived(List<Cat> cats) {
+                Cat cutest = findCutest(cats);
+                Uri savedUri = api.store(cutest);
+                cutestCatCallback.onCutestCatSaved(savedUri);
+            }
+ 
+            @Override
+            public void onError(Exception e) {
+                cutestCatCallback.onQueryFailed(e);
+            }
+        });
+    }
+ 
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+我们没法让`saveTheCutestCat`函数返回一个值了， 我们需要一个回调接口来异步的处理结果。
+这里我们再进一步，使用两个异步操作来实现我们的功能,例如我们需要使用异步`IO`来写文件。
+
+```java
+public interface Api {
+    interface CatsQueryCallback {
+        void onCatListReceived(List<Cat> cats);
+        void onQueryFailed(Exception e);
+    }
+ 
+    interface StoreCallback{
+        void onCatStored(Uri uri);
+        void onStoreFailed(Exception e);
+    }
+ 
+ 
+    void queryCats(String query, CatsQueryCallback catsQueryCallback);
+ 
+    void store(Cat cat, StoreCallback storeCallback);
+}
+```
+
+我们的`helper`会变成:    
+
+```java
+public class CatsHelper {
+
+    public interface CutestCatCallback {
+        void onCutestCatSaved(Uri uri);
+        void onError(Exception e);
+    }
+
+    Api api;
+
+    public void saveTheCutestCat(String query, CutestCatCallback cutestCatCallback){
+        api.queryCats(query, new Api.CatsQueryCallback() {
+            @Override
+            public void onCatListReceived(List<Cat> cats) {
+                Cat cutest = findCutest(cats);
+                api.store(cutest, new Api.StoreCallback() {
+                    @Override
+                    public void onCatStored(Uri uri) {
+                        cutestCatCallback.onCutestCatSaved(uri);
+                    }
+
+                    @Override
+                    public void onStoreFailed(Exception e) {
+                        cutestCatCallback.onError(e);
+                    }
+                });
+            }
+
+            @Override
+            public void onQueryFailed(Exception e) {
+                cutestCatCallback.onError(e);
+            }
+        });
+    }
+
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+现在我们再来看看这部分代码？还是之前那样简单暴力？现在有太多的干扰代码、匿名类，这简直是太恐怖了，但是他们的业务逻辑其实是一样的，都是查询猫的列表数据，然后找出最可爱的猫并保存它的图片。    
+
+上面说好的组合功能没有了，现在你没法像阻塞操作一样来组合调用每个功能了，异步操作中，每次你都必须通过回调接口来手工的处理结果。 
+
+上面说好的异常处理也没有了，异步代码中的异常不会自动传递，我们需要手动的去重新传递。(`onStoreFailed()`和`onQueryFailed()`就是干这事的)
+
+
+#### 结果？
+
+
+然后呢？我们可以怎么做？我们能不能使用无回调的模式？我们试着修复一下。 
+
+
+#### 奔向更好的世界     
+
+
+如果我们仔细的观察下回调接口，我们会发现它们的共性:   
+
+- 它们都有一个分发结果的方法(`onCutestCatSaved()`,`onCatListReceived()`,`onCatStored()`)
+- 它们中的绝大部分都有一个处理操作过程中异常的方法(`onError()`, `onQueryFailed()`, `onStoreFailed()`)
+
+
+所以我们可以创建一个通用的回调来取代它们。但是我们无法修改`api`的调用结构，我们只能创建一个包裹层的调用。   
+
+我们通用的回调如下:  
+
+```java
+public interface Callback<T> {
+    void onResult(T result);
+    void onError(Exception e);
+}
+```
+
+我们创建一个`ApiWrapper`类来改变我们调用的结构:   
+
+```java
+public class ApiWrapper {
+    Api api;
+
+    public void queryCats(String query, Callback<List<Cat>> catsCallback){
+        api.queryCats(query, new Api.CatsQueryCallback() {
+            @Override
+            public void onCatListReceived(List<Cat> cats) {
+                catsCallback.onResult(cats);
+            }
+
+            @Override
+            public void onQueryFailed(Exception e) {
+                catsCallback.onError(e);
+            }
+        });
+    }
+
+    public void store(Cat cat, Callback<Uri> uriCallback){
+        api.store(cat, new Api.StoreCallback() {
+            @Override
+            public void onCatStored(Uri uri) {
+                uriCallback.onResult(uri);
+            }
+
+            @Override
+            public void onStoreFailed(Exception e) {
+                uriCallback.onError(e);
+            }
+        });
+    }
+}
+```
+这样通过新的回调我们可以减少一次处理结果和异常的逻辑。    
+最终，我们的`CatsHelper`如下:    
+```java
+public class CatsHelper{
+
+    ApiWrapper apiWrapper;
+
+    public void saveTheCutestCat(String query, Callback<Uri> cutestCatCallback){
+        apiWrapper.queryCats(query, new Callback<List<Cat>>() {
+            @Override
+            public void onResult(List<Cat> cats) {
+                Cat cutest = findCutest(cats);
+                apiWrapper.store(cutest, cutestCatCallback);
+            }
+
+            @Override
+            public void onError(Exception e) {
+                cutestCatCallback.onError(e);
+            }
+        });
+    }
+
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+好了，现在比之前的代码稍微简单点了。但是我们能不能做的更好？ 当然可以！
+
+#### 保持参数和回调的分离性
+
+
+
+看看这些新的异步操作(`queryCats`,` store`和`saveTheCutestCat`)。这些函数都有同样的模式。使用一些参数来调用这些函数`(query,cat)`，同时还有一个回调接口作为参数。甚至，所有的异步操作都带有一些常规参数和一个额外的回调接口参数。如果我们把他们分离开会如何，让每个异步操作只有一些常规参数而把返回一个临时的对象来操作回调接口。
+下面来试试看看这种方式能否有效。
+如果我们返回一个临时的对象作为异步操作的回调接口处理方式，我们需要先定义这个对象。由于对象遵守通用的行为(有一个回调接口参数)，我们定义一个能用于所有操作的对象。我们称之为`AsyncJob`。
+
+
+该对象如下:   
+```java
+public abstract class AsyncJob<T> {
+    public abstract void start(Callback<T> callback);
+}
+```
+
+`start()`函数有个`Callback`回调接口参数，并开始执行该操作。
+`ApiWrapper`修改为：
+```java
+public class ApiWrapper {
+    Api api;
+ 
+    public AsyncJob<List<Cat>> queryCats(String query) {
+        return new AsyncJob<List<Cat>>() {
+            @Override
+            public void start(Callback<List<Cat>> catsCallback) {
+                api.queryCats(query, new Api.CatsQueryCallback() {
+                    @Override
+                    public void onCatListReceived(List<Cat> cats) {
+                        catsCallback.onResult(cats);
+                    }
+ 
+                    @Override
+                    public void onQueryFailed(Exception e) {
+                        catsCallback.onError(e);
+                    }
+                });
+            }
+        };
+    }
+ 
+    public AsyncJob<Uri> store(Cat cat) {
+        return new AsyncJob<Uri>() {
+            @Override
+            public void start(Callback<Uri> uriCallback) {
+                api.store(cat, new Api.StoreCallback() {
+                    @Override
+                    public void onCatStored(Uri uri) {
+                        uriCallback.onResult(uri);
+                    }
+ 
+                    @Override
+                    public void onStoreFailed(Exception e) {
+                        uriCallback.onError(e);
+                    }
+                });
+            }
+        };
+    }
+}
+```
+目前看起来还不错。现在可以使用`AsyncJob.start()`来启动每个操作了。接下来我们修改`CatsHelper`类：
+
+```java
+public class CatsHelper {
+ 
+    ApiWrapper apiWrapper;
+ 
+    public AsyncJob<Uri> saveTheCutestCat(String query) {
+        return new AsyncJob<Uri>() {
+            @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);
+                        }
+                        });
+            }
+        };
+    }
+ 
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+看起来比前面一个版本更加复杂啊，这样有啥好处啊？
+这里其实我们返回的是一个`AsyncJob`对象，该对象和客户端代码组合使用，这样在`Activity`或者`Fragment`客户端代码中就可以操作这个返回的对象了。
+代码虽然目前看起来比较复杂，下面我们就来改进一下。
+
+#### 分解
+
+
+下面是流程图:   
+```java
+         (async)                 (sync)           (async)
+query ===========> List<Cat> -------------> Cat ==========> Uri
+       queryCats              findCutest           store
+```
+
+为了让代码具有可读性，我们把这个流程分解为每个操作。同时我们再进一步假设，如果一个操作是异步的，则每个调用该异步操作的函数也是异步的。例如：如果查询猫是个异步操作，则找到最可爱的猫操作也是异步的。
+
+因此，我们可以使用`AsyncJob`来把这些操作分解为一些小的操作中。
+
+```java
+public class CatsHelper {
+ 
+    ApiWrapper apiWrapper;
+ 
+    public AsyncJob<Uri> saveTheCutestCat(String query) {
+        AsyncJob<List<Cat>> catsListAsyncJob = apiWrapper.queryCats(query);
+        AsyncJob<Cat> cutestCatAsyncJob = new AsyncJob<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);
+                    }
+                });
+            }
+        };
+ 
+        AsyncJob<Uri> storedUriAsyncJob = new AsyncJob<Uri>() {
+            @Override
+            public void start(Callback<Uri> cutestCatCallback) {
+                cutestCatAsyncJob.start(new Callback<Cat>() {
+                    @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);
+                                }
+                            });
+                    }
+ 
+                    @Override
+                    public void onError(Exception e) {
+                        cutestCatCallback.onError(e);
+                    }
+                });
+            }
+        };
+        return storedUriAsyncJob;
+    }
+ 
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+虽然代码量多了，但是看起来更加清晰了。 嵌套的回调函数没那么多层级了，异步操作的名字也更容易理解了(`catsListAsyncJob`,`cutestCatAsyncJob`, `storedUriAsyncJob`)。
+看起来还不错，但是还可以更好。
+
+#### 简单的映射
+
+
+先来看看我们创建 AsyncJob cutestCatAsyncJob 的代码：
+
+```java
+AsyncJob<Cat> cutestCatAsyncJob = new AsyncJob<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);
+            }
+        });
+    }
+};
+```
+
+这 16 行代码中，只有一行代码是我们的业务逻辑代码：
+```java
+findCutest(result)
+```
+其他的代码只是为了启动`AsyncJob`并接收结果和处理异常的干扰代码。 但是这些代码是通用的，我们可以把他们放到其他地方来让我们更加专注业务逻辑代码。
+那么如何实现呢？需要做两件事情：
+- 通过`AsyncJob`获取需要转换的结果
+- 转换的函数
+
+但是由于`Java`的限制，无法把函数作为参数，所以需要用一个接口（或者类）并在里面定义一个转换函数：
+
+```java
+public interface Func<T, R> {
+    R call(T t);
+}
+```
+灰常简单。 有两个泛型类型定义，`T`代表参数的类型；`R`代表返回值的类型。
+
+当我们把`AsyncJob`的结果转换为其他类型的时候，我们需要把一个结果值映射为另外一种类型，这个操作我们称之为`map`。 把该函数定义到`AsyncJob`类中比较方便，这样就可以通过`this`来访问`AsyncJob`对象了。
+
+```java
+public abstract class AsyncJob<T> {
+    public abstract void start(Callback<T> callback);
+ 
+    public <R> AsyncJob<R> map(Func<T, R> func){
+        final AsyncJob<T> source = this;
+        return new AsyncJob<R>() {
+            @Override
+            public void start(Callback<R> callback) {
+                source.start(new Callback<T>() {
+                    @Override
+                    public void onResult(T result) {
+                        R mapped = func.call(result);
+                        callback.onResult(mapped);
+                    }
+ 
+                    @Override
+                    public void onError(Exception e) {
+                        callback.onError(e);
+                    }
+                });
+            }
+        };
+    }
+}
+```
+
+看起来不错， 现在的`CatsHelper`如下：
+
+```java
+public class CatsHelper {
+ 
+    ApiWrapper apiWrapper;
+ 
+    public AsyncJob<Uri> saveTheCutestCat(String query) {
+        AsyncJob<List<Cat>> catsListAsyncJob = apiWrapper.queryCats(query);
+        AsyncJob<Cat> cutestCatAsyncJob = catsListAsyncJob.map(new Func<List<Cat>, Cat>() {
+            @Override
+            public Cat call(List<Cat> cats) {
+                return findCutest(cats);
+            }
+        });
+ 
+        AsyncJob<Uri> storedUriAsyncJob = new AsyncJob<Uri>() {
+            @Override
+            public void start(Callback<Uri> cutestCatCallback) {
+                cutestCatAsyncJob.start(new Callback<Cat>() {
+                    @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);
+                                    }
+                                });
+                    }
+ 
+                    @Override
+                    public void onError(Exception e) {
+                        cutestCatCallback.onError(e);
+                    }
+                });
+            }
+        };
+        return storedUriAsyncJob;
+    }
+ 
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+新创建的`AsyncJob cutestCatAsyncJob()`的代码只有6行，并且只有一层嵌套。
+
+
+#### 高级映射
+
+
+但是`AsyncJob storedUriAsyncJob()`看起来还是非常糟糕。 这里也能使用映射吗？ 下面就来试试吧！
+
+```java
+public class CatsHelper {
+ 
+    ApiWrapper apiWrapper;
+ 
+    public AsyncJob<Uri> saveTheCutestCat(String query) {
+        AsyncJob<List<Cat>> catsListAsyncJob = apiWrapper.queryCats(query);
+        AsyncJob<Cat> cutestCatAsyncJob = catsListAsyncJob.map(new Func<List<Cat>, Cat>() {
+            @Override
+            public Cat call(List<Cat> cats) {
+                return findCutest(cats);
+            }
+        });
+ 
+        AsyncJob<Uri> storedUriAsyncJob = cutestCatAsyncJob.map(new Func<Cat, Uri>() {
+            @Override
+            public Uri call(Cat cat) {
+                return apiWrapper.store(cat);
+        //      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 将会导致无法编译
+        //      Incompatible types:
+        //      Required: Uri
+        //      Found: AsyncJob<Uri>                
+            }
+        });
+        return storedUriAsyncJob;
+    }
+ 
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+哎。。。 看起来没这么简单啊，下面修复返回的类型再试一次:    
+
+```java
+public class CatsHelper {
+ 
+    ApiWrapper apiWrapper;
+ 
+    public AsyncJob<Uri> saveTheCutestCat(String query) {
+        AsyncJob<List<Cat>> catsListAsyncJob = apiWrapper.queryCats(query);
+        AsyncJob<Cat> cutestCatAsyncJob = catsListAsyncJob.map(new Func<List<Cat>, Cat>() {
+            @Override
+            public Cat call(List<Cat> cats) {
+                return findCutest(cats);
+            }
+        });
+ 
+        AsyncJob<AsyncJob<Uri>> storedUriAsyncJob = cutestCatAsyncJob.map(new Func<Cat, AsyncJob<Uri>>() {
+            @Override
+            public AsyncJob<Uri> call(Cat cat) {
+                return apiWrapper.store(cat);
+            }
+        });
+        return storedUriAsyncJob;
+        //^^^^^^^^^^^^^^^^^^^^^^^ 将会导致无法编译
+        //      Incompatible types:
+        //      Required: AsyncJob<Uri>
+        //      Found: AsyncJob<AsyncJob<Uri>>
+    }
+ 
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+这里我们只能拿到`AsyncJob<AsyncJob>` 。看来还需要更进一步。我们需要压缩一层`AsyncJob`，把两个异步操作当做一个单一的异步操作来对待。
+现在我们需要一个参数为`AsyncJob`的`map`转换操作而不是`R`。该操作类似于`map`，但是该操作会把嵌套的`AsyncJob`压缩为`flatten`一层`AsyncJob`. 我们称之为`flatMap`，实现如下：
+
+```java
+public abstract class AsyncJob<T> {
+    public abstract void start(Callback<T> callback);
+ 
+    public <R> AsyncJob<R> map(Func<T, R> func){
+        final AsyncJob<T> source = this;
+        return new AsyncJob<R>() {
+            @Override
+            public void start(Callback<R> callback) {
+                source.start(new Callback<T>() {
+                    @Override
+                    public void onResult(T result) {
+                        R mapped = func.call(result);
+                        callback.onResult(mapped);
+                    }
+ 
+                    @Override
+                    public void onError(Exception e) {
+                        callback.onError(e);
+                    }
+                });
+            }
+        };
+    }
+ 
+    public <R> AsyncJob<R> flatMap(Func<T, AsyncJob<R>> func){
+        final AsyncJob<T> source = this;
+        return new AsyncJob<R>() {
+            @Override
+            public void start(Callback<R> callback) {
+                source.start(new Callback<T>() {
+                    @Override
+                    public void onResult(T result) {
+                        AsyncJob<R> mapped = func.call(result);
+                        mapped.start(new Callback<R>() {
+                            @Override
+                            public void onResult(R result) {
+                                callback.onResult(result);
+                            }
+ 
+                            @Override
+                            public void onError(Exception e) {
+                                callback.onError(e);
+                            }
+                        });
+                    }
+ 
+                    @Override
+                    public void onError(Exception e) {
+                        callback.onError(e);
+                    }
+                });
+            }
+        };
+    }
+}
+```
+
+看起来有很多干扰代码，但是还好这些代码在客户端代码中并不会出现。 现在我们的`CatsHelper`如下：
+
+```java
+public class CatsHelper {
+ 
+    ApiWrapper apiWrapper;
+ 
+    public AsyncJob<Uri> saveTheCutestCat(String query) {
+        AsyncJob<List<Cat>> catsListAsyncJob = apiWrapper.queryCats(query);
+        AsyncJob<Cat> cutestCatAsyncJob = catsListAsyncJob.map(new Func<List<Cat>, Cat>() {
+            @Override
+            public Cat call(List<Cat> cats) {
+                return findCutest(cats);
+            }
+        });
+ 
+        AsyncJob<Uri> storedUriAsyncJob = cutestCatAsyncJob.flatMap(new Func<Cat, AsyncJob<Uri>>() {
+            @Override
+            public AsyncJob<Uri> call(Cat cat) {
+                return apiWrapper.store(cat);
+            }
+        });
+        return storedUriAsyncJob;
+    }
+ 
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+如果把匿名类修改为`Java 8`的`lambdas`表达式（逻辑是一样的，只是让代码看起来更清晰点）就很容易发现了。
+
+```java
+public class CatsHelper {
+ 
+    ApiWrapper apiWrapper;
+ 
+    public AsyncJob<Uri> saveTheCutestCat(String query) {
+        AsyncJob<List<Cat>> catsListAsyncJob = apiWrapper.queryCats(query);
+        AsyncJob<Cat> cutestCatAsyncJob = catsListAsyncJob.map(cats -> findCutest(cats));
+        AsyncJob<Uri> storedUriAsyncJob = cutestCatAsyncJob.flatMap(cat -> apiWrapper.store(cat));
+        return storedUriAsyncJob;
+    }
+ 
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+这样看起来是不是就很清晰了。 这个代码和刚刚开头的阻塞式代码是不是非常相似：
+
+```java
+public class CatsHelper {
+ 
+    Api api;
+ 
+    public Uri saveTheCutestCat(String query){
+        List<Cat> cats = api.queryCats(query);
+        Cat cutest = findCutest(cats);
+        Uri savedUri = api.store(cutest);
+        return savedUri;
+    }
+ 
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+现在他们不仅逻辑是一样的，语义上也是一样的。 太棒了！
+同时我们还可以使用组合操作，现在把两个异步操作组合一起并返还另外一个异步操作。
+异常处理也会传递到最终的回调接口中。
+下面来看看`RxJava`吧。
+你没必要把上面代码应用到您的项目中去， 这些简单的、线程不安全的代码只是 `RxJava`的一部分。
+只有一些名字上的不同：
+
+- `AsyncJob`等同于`Observable`，不仅仅可以返回一个结果，还可以返回一系列的结果，当然也可能没有结果返回。
+- `Callback`等同于`Observer`，除了`onNext(T t)`, `onError(Throwable t)`以外，还有一个`onCompleted()`函数，该函数在结束继续返回结果的时候通知`Observable`。
+- `abstract void start(Callback callback)`和`Subscription subscribe(final Observer observer)`类似，返回一个`Subscription`，如果你不再需要后面的结果了，可以取消该任务。
+
+下面是`RxJava`版本的代码:    
+
+```java
+public class ApiWrapper {
+    Api api;
+ 
+    public Observable<List<Cat>> queryCats(final String query) {
+        return Observable.create(new Observable.OnSubscribe<List<Cat>>() {
+            @Override
+            public void call(final Subscriber<? super List<Cat>> subscriber) {
+                api.queryCats(query, new Api.CatsQueryCallback() {
+                    @Override
+                    public void onCatListReceived(List<Cat> cats) {
+                        subscriber.onNext(cats);
+                    }
+ 
+                    @Override
+                    public void onQueryFailed(Exception e) {
+                        subscriber.onError(e);
+                    }
+                });
+            }
+        });
+    }
+ 
+    public Observable<Uri> store(final Cat cat) {
+        return Observable.create(new Observable.OnSubscribe<Uri>() {
+            @Override
+            public void call(final Subscriber<? super Uri> subscriber) {
+                api.store(cat, new Api.StoreCallback() {
+                    @Override
+                    public void onCatStored(Uri uri) {
+                        subscriber.onNext(uri);
+                    }
+ 
+                    @Override
+                    public void onStoreFailed(Exception e) {
+                        subscriber.onError(e);
+                    }
+                });
+            }
+        });
+    }
+}
+ 
+public class CatsHelper {
+ 
+    ApiWrapper apiWrapper;
+ 
+    public Observable<Uri> saveTheCutestCat(String query) {
+        Observable<List<Cat>> catsListObservable = apiWrapper.queryCats(query);
+        Observable<Cat> cutestCatObservable = catsListObservable.map(new Func1<List<Cat>, Cat>() {
+            @Override
+            public Cat call(List<Cat> cats) {
+                return CatsHelper.this.findCutest(cats);
+            }
+        });
+        Observable<Uri> storedUriObservable = cutestCatObservable.flatMap(new Func1<Cat, Observable<? extends Uri>>() {
+            @Override
+            public Observable<? extends Uri> call(Cat cat) {
+                return apiWrapper.store(cat);
+            }
+        });
+        return storedUriObservable;
+    }
+ 
+    private Cat findCutest(List<Cat> cats) {
+        return Collections.max(cats);
+    }
+}
+```
+
+把Observable替换为AsyncJob后他们的代码是一样的。
+
+#### 结论
+
+
+通过简单的转换操作，我们可以把异步操作抽象出来。这种抽象的结果可以像操作简单的阻塞函数一样来操作异步操作并组合异步操作。这样我们就可以摆脱层层嵌套的回调接口了，并且不用手工的去处理每次异步操作的异常。
+
+
+上面这个例子非常好，建议多看几遍，加深理解，可能把这个例子放在这里并不太好，把它放到开始讲之前可能更容易理解，但是我觉得，介绍完概念、使用方法和基本的操作符后，我们可能并不能理解操作符的原理和作用。之前看完操作符原理后迷迷糊糊的状态再来看这个例子会豁然开朗。    
+
+这里也感谢牛逼的作者[Yaroslav](https://github.com/yarikx)(也是`RxAndroid`项目的一个重要参与者)能用这么牛逼的例子，讲解的如此透彻。   
+
+
+如果嫌上面的代码麻烦，可以通过下面的例子看:   
+
+假设有这样一个需求：界面上有一个自定义的视图`imageCollectorView`，它的作用是显示多张图片，并能使用`addImage(Bitmap)` 方法来任意增加显示的图片。现在需要程序将一个给出的目录数组`File[] folders`中每个目录下的`png`图片都加载出来并显示在`imageCollectorView`中。需要注意的是，由于读取图片的这一过程较为耗时，需要放在后台执行，而图片的显示则必须在`UI`线程执行。常用的实现方式有多种，我这里贴出其中一种:        
+
+
+```java
+new Thread() {
+    @Override
+    public void run() {
+        super.run();
+        for (File folder : folders) {
+            File[] files = folder.listFiles();
+            for (File file : files) {
+                if (file.getName().endsWith(".png")) {
+                    final Bitmap bitmap = getBitmapFromFile(file);
+                    getActivity().runOnUiThread(new Runnable() {
+                        @Override
+                        public void run() {
+                            imageCollectorView.addImage(bitmap);
+                        }
+                    });
+                }
+            }
+        }
+    }
+}.start();
+```
+
+而如果使用 RxJava ，实现方式是这样的：
+
+```java
+Observable.from(folders)
+    .flatMap(new Func1<File, Observable<File>>() {
+        @Override
+        public Observable<File> call(File file) {
+            return Observable.from(file.listFiles());
+        }
+    })
+    .filter(new Func1<File, Boolean>() {
+        @Override
+        public Boolean call(File file) {
+            return file.getName().endsWith(".png");
+        }
+    })
+    .map(new Func1<File, Bitmap>() {
+        @Override
+        public Bitmap call(File file) {
+            return getBitmapFromFile(file);
+        }
+    })
+    .subscribeOn(Schedulers.io())
+    .observeOn(AndroidSchedulers.mainThread())
+    .subscribe(new Action1<Bitmap>() {
+        @Override
+        public void call(Bitmap bitmap) {
+            imageCollectorView.addImage(bitmap);
+        }
+    });
+```
+
+观察一下你会发现， `RxJava`的这个实现，是一条从上到下的链式调用，没有任何嵌套，这在逻辑的简洁性上是具有优势的。当需求变得复杂时，这种优势将更加明显（试想如果还要求只选取前`10`张图片，常规方式要怎么办？如果有更多这样那样的要求呢？再试想，在这一大堆需求实现完两个月之后需要改功能，当你翻回这里看到自己当初写下的那一片迷之缩进，你能保证自己将迅速看懂，而不是对着代码重新捋一遍思路？）。
+
+更多内容请看下一篇文章[RxJava详解(三)][1]
+
+
+参考:   
+
+- [RxJava Wiki](https://github.com/ReactiveX/RxJava/wiki)
+- [Grokking RxJava, Part 1: The Basics](http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/)
+- [NotRxJava](https://yarikx.github.io/NotRxJava/)
+- [When Not to Use RxJava](http://tomstechnicalblog.blogspot.hk/2016/07/when-not-to-use-rxjava.html)
+- [给 Android 开发者的 RxJava 详解](http://gank.io/post/560e15be2dca930e00da1083)
+- [Google Agera 从入门到放弃](http://blog.chengyunfeng.com/?p=984)
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/3.RxJava%E8%AF%A6%E8%A7%A3(%E4%B8%89).md "RxJava详解(三)"
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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"
new file mode 100644
index 00000000..4d0ac650
--- /dev/null
+++ "b/RxJavaPart/3.RxJava\350\257\246\350\247\243(\344\270\211).md"
@@ -0,0 +1,231 @@
+RxJava详解(三)
+===
+
+变换的原理`lift()`
+---
+
+这些变换虽然功能各有不同，但实质上都是针对事件序列的处理和再发送。而在`RxJava`的内部，它们是基于同一个基础的变换方法：`lift()`。
+
+首先看一下`lift()` 的内部实现（仅核心代码):      
+
+```java
+// 注意：这不是 lift() 的源码，而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。
+public <R> Observable<R> lift(Operator<? extends R, ? super T> operator) {
+    return Observable.create(new OnSubscribe<R>() {
+        @Override
+        public void call(Subscriber subscriber) {
+            Subscriber newSubscriber = operator.call(subscriber);
+            newSubscriber.onStart();
+            onSubscribe.call(newSubscriber);
+        }
+    });
+}
+```
+
+这段代码很有意思：它生成了一个新的`Observable`并返回，而且创建新`Observable`所用的参数`OnSubscribe的回调方法`call()`中的实现竟然看起来和前面讲过的`Observable.subscribe()`一样！      
+然而它们并不一样哟~不一样的地方关键就在于第二行`onSubscribe.call(subscriber)`中的`onSubscribe` 所指代的对象不同:            
+- `subscribe()`中这句话的`onSubscribe`指的是`Observable`中的`onSubscribe`对象，这个没有问题，但是`lift()`之后的情况就复杂了点。
+- 当含有`lift()`时:     
+
+    - `lift()`创建了一个`Observable`后，加上之前的原始`Observable`，已经有两个`Observable`了； 
+    - 而同样地，新`Observable`里的新`OnSubscribe`加上之前的原始`Observable`中的原始`OnSubscribe`，也就有了两个`OnSubscribe`； 
+    - 当用户调用经过`lift()`后的`Observable`的`subscribe()`的时候，使用的是`lift()`所返回的新的`Observable`，于是它所触发的`onSubscribe.call(subscriber)`，也是用的新`Observable`中的新`OnSubscribe`，即在`lift()`中生成的那个`OnSubscribe`； 
+    - 而这个新`OnSubscribe`的`call()`方法中的`onSubscribe`，就是指的原始`Observable`中的原始`OnSubscribe`，在这个`call()`方法里，新`OnSubscribe`利用`operator.call(subscriber)`生成了一个新的`Subscriber`(`Operator`就是在这里，通过自己的`call()`方法将新`Subscriber`和原始`Subscriber` 进行关联，并插入自己的『变换』代码以实现变换），然后利用这个新`Subscriber`向原始`Observable`进行订阅。 
+    这样就实现了`lift()`过程，有点像一种代理机制，通过事件拦截和处理实现事件序列的变换。
+
+精简掉细节的话，也可以这么说：在`Observable`执行了`lift(Operator)`方法之后，会返回一个新的`Observable`，这个新的`Observable`会像一个代理一样，负责接收原始的`Observable` 发出的事件，并在处理后发送给`Subscriber`。
+
+如果你更喜欢具象思维，可以看图：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_lift.gif?raw=true)
+
+举一个具体的`Operator`的实现。下面这是一个将事件中的`Integer`对象转换成`String`的例子，仅供参考：
+
+```java
+observable.lift(new Observable.Operator<String, Integer>() {
+    @Override
+    public Subscriber<? super Integer> call(final Subscriber<? super String> subscriber) {
+        // 将事件序列中的 Integer 对象转换为 String 对象
+        return new Subscriber<Integer>() {
+            @Override
+            public void onNext(Integer integer) {
+                subscriber.onNext("" + integer);
+            }
+
+            @Override
+            public void onCompleted() {
+                subscriber.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+        };
+    }
+});
+```
+> 讲述`lift()`的原理只是为了让你更好地了解`RxJava` ，从而可以更好地使用它。然而不管你是否理解了`lift()`的原理,`RxJava`都不建议开发者自定义`Operator`来直接使用`lift()`，而是建议尽量使用已有的`lift()`包装方法（如`map()、flatMap()`等）进行组合来实现需求，因为直接使用`lift()`非常容易发生一些难以发现的错误。
+
+
+线程控制`Scheduler`
+---
+
+在不指定线程的情况下，`RxJava`遵循的是线程不变的原则，即在哪个线程调用`subscribe()`方法就在哪个线程生产事件；       在哪个线程生产事件，就在哪个线程消费事件。也就是说事件的发出和消费都是在同一个线程的。观察者模式本身的目的就是『后台处理，前台回调』的异步机制，因此异步对于`RxJava`是至关重要的。而要实现异步，则需要用到`RxJava`的另一个概念：`Scheduler`。   
+
+
+#### `Scheduler`简介
+
+
+在`RxJava`中,`Scheduler`相当于线程控制器，`RxJava`通过它来指定每一段代码应该运行在什么样的线程。`RxJava`已经内置了几个`Scheduler`，它们已经适合大多数的使用场景：
+
+- `Schedulers.immediate()`: 直接在当前线程运行，相当于不指定线程。这是默认的`Scheduler`。
+- `Schedulers.newThread()`: 总是启用新线程，并在新线程执行操作。
+- `Schedulers.io()`: I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的`Scheduler`。行为模式和`newThread()`差不多，区别在于`io()` 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下`io()`比`newThread()`更有效率。不要把计算工作放在`io()`中，可以避免创建不必要的线程。
+- `Schedulers.computation()`: 计算所使用的`Scheduler`。这个计算指的是`CPU`密集型计算，即不会被`I/O`等操作限制性能的操作，例如图形的计算。这个`Scheduler` 使用的固定的线程池，大小为`CPU`核数。不要把`I/O`操作放在`computation()`中，否则`I/O`操作的等待时间会浪费`CPU`。
+- 另外，`Android`还有一个专用的`AndroidSchedulers.mainThread()`，它指定的操作将在`Android`主线程运行。
+
+
+有了这几个`Scheduler`，就可以使用`subscribeOn()`和`observeOn()`两个方法来对线程进行控制了。`subscribeOn()`指定`subscribe()`所发生的线程，即`Observable.OnSubscribe()`被激活时所处的线程或者叫做事件产生的线程。`observeOn()`指定`Subscriber`所运行在的线程或者叫做事件消费的线程。
+
+```java
+Observable.just("Hello ", "World !")
+        .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程，可以理解成数据的获取是在io线程
+        .observeOn(AndroidSchedulers.mainThread())// 指定 Subscriber 的回调发生在主线程，可以理解成数据的消费时在主线程
+        .subscribe(new Action1<String>() {
+            @Override
+            public void call(String s) {
+                Log.i("@@@", s);
+            }
+        });
+```
+
+上面这段代码中，`subscribeOn(Schedulers.io())`的指定会让创建的事件的内容`Hello `、`World !`将会在`IO`线程发出；      
+
+而由于`observeOn(AndroidScheculers.mainThread())` 的指定，因此`subscriber()`方法设置后的回调中内容的打印将发生在主线程中。     
+事实上，这种在`subscribe()`之前写上两句`subscribeOn(Scheduler.io())`和`observeOn(AndroidSchedulers.mainThread())`的使用方式非常常见，它适用于多数的***后台线程取数据，主线程显示***的程序策略。
+
+#### `Scheduler`的原理
+
+`RxJava`的`Scheduler API`很方便，也很神奇（加了一句话就把线程切换了，怎么做到的？而且subscribe()不是最外层直接调用的方法吗，它竟然也能被指定线程？）。然而Scheduler的原理需要放在后面讲，因为它的原理是以下一节《变换》的原理作为基础的。
+
+好吧这一节其实我屁也没说，只是为了让你安心，让你知道我不是忘了讲原理，而是把它放在了更合适的地方。
+
+
+能不能多切换几次线程？答案是：能。      
+
+因为`observeOn()`指定的是`Subscriber`的线程，而这个`Subscriber`并不是（严格说应该为『不一定是』，但这里不妨理解为『不是』）`subscribe()` 参数中的`Subscriber`，而是`observeOn()`执行时的当前`Observable`所对应的`Subscriber`，即它的直接下级`Subscriber`。      
+
+换句话说`observeOn()` 指定的是它之后的操作所在的线程。因此如果有多次切换线程的需求，只要在每个想要切换线程的位置调用一次`observeOn()`即可。
+
+上代码：
+
+```java
+Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
+    .subscribeOn(Schedulers.io())
+    .observeOn(Schedulers.newThread())
+    .map(mapOperator) // 新线程，由 observeOn() 指定
+    .observeOn(Schedulers.io())
+    .map(mapOperator2) // IO 线程，由 observeOn() 指定
+    .observeOn(AndroidSchedulers.mainThread) 
+    .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定
+```
+如上，通过`observeOn()`的多次调用，程序实现了线程的多次切换。
+不过，不同于`observeOn()`,`subscribeOn()`的位置放在哪里都可以，但它是只能调用一次的。
+
+其实，`subscribeOn()`和`observeOn()`的内部实现，也是用的`lift()`。
+
+具体看图（不同颜色的箭头表示不同的线程,`subscribeOn()`原理图：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_subscribeon.jpg?raw=true)
+
+`observeOn()`原理图: 
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_observeon.jpg?raw=true)
+
+从图中可以看出,`subscribeOn()`和`observeOn()`都做了线程切换的工作（图中的`schedule...`部位）。不同的是,`subscribeOn()`的线程切换发生在`OnSubscribe`中，即在它通知上一级 `OnSubscribe`时，这时事件还没有开始发送，因此`subscribeOn()`的线程控制可以从事件发出的开端就造成影响；而`observeOn()`的线程切换则发生在它内建的`Subscriber`中，即发生在它即将给下一级`Subscriber`发送事件时，因此`observeOn()`控制的是它后面的线程。
+
+最后，我用一张图来解释当多个`subscribeOn()`和`observeOn()`混合使用时，线程调度是怎么发生的（由于图中对象较多，相对于上面的图对结构做了一些简化调整）：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_observable_list.jpg?raw=true)
+
+图中共有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()`所指定的线程。
+
+示例代码:       
+
+```java
+Observable.create(onSubscribe)
+    .subscribeOn(Schedulers.io())
+    .doOnSubscribe(new Action0() {
+        @Override
+        public void call() {
+            progressBar.setVisibility(View.VISIBLE); // 需要在主线程执行
+        }
+    })
+    .subscribeOn(AndroidSchedulers.mainThread()) // 指定主线程
+    .observeOn(AndroidSchedulers.mainThread())
+    .subscribe(subscriber);
+```
+
+如上，在`doOnSubscribe()`的后面跟一个`subscribeOn()`，就能指定准备工作的线程了。
+
+#### 总结
+
+
+`RxJava`辣么好，难道他就没有缺点吗？当然有那就是使用越来越多的订阅，内存开销也会变得很大，稍不留神就会出现内存溢出的情况。我们可以用`RxJava`实现基本任何功能，但是你并不能这么做，你要明白什么时候需要用它，而什么时候没必要用它，不要一味的把功能都有`RxJava`来实现。    
+
+至于上面提到的`2.0`版本，有关它的区别请见:    
+[What's different in 2.0](https://github.com/ReactiveX/RxJava/wiki/What's-different-in-2.0)
+
+
+更多内容请看下一篇文章[RxJava详解(四)][1]
+
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/4.RxJava%E8%AF%A6%E8%A7%A3%E4%B9%8B%E6%89%A7%E8%A1%8C%E5%8E%9F%E7%90%86(%E5%9B%9B).md "RxJava详解(四)"
+
+
+Agera
+---
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/agera.png?raw=true)
+
+
+之前`Google`发布`agera`，它在`Github`上的介绍是:`Reactive Programming for Android`
+
+[agera](https://github.com/google/agera)
+
+既然是响应式编程框架，其核心思想肯定和`RxJava`也是类似的。
+`Agera`中核心也是关于事件流（数据流）的处理，可以转换数据、可以指定数据操作函数在那个线程执行。
+而`Agera`和`RxJava`不一样的地方在于，`Agera`提供了一个新的事件响应和数据请求的模型，被称之为`Push event, pull data`。也就是一个事件发生了，会通过回调来主动告诉你，你关心的事件发生了。然后你需要主动的去获取数据，根据获取到的数据做一些操作。而`RxJava`在事件发生的时候，已经带有数据了。为了支持 `Push event pull data`模型，`Agera`中有个新的概念 — `Repository`。`Repository`翻译过来也就是数据仓库,是用来提供数据的,当你收到事件的时候,通过`Repository`来获取需要的数据。 这样做的好处是，把事件分发和数据处理的逻辑给分开了，事件分发做的事情比较少，事件分发就比较高效，当你收到事件后，根据当前的状态如果发现这个时候，数据已经无效了，则你根本不用请求数据，这样数据也就不用去处理和转换了。这样可以避免无用的数据计算，而有用的数据计算也可以在你需要的时候才去计算。
+同样，在多线程环境下，使用`push event pull data`模型，可能当你收到事件通知的时候，你只能获取到最新的数据，无法去获取历史数据了。设计就是这样考虑的，因为在`Android`开发中大部分的数据都是用来更新`UI`的，这个时候你根本不需要旧的数据了，只要最新的就够了。
+
+`Agera`相对比较简单，并且是一个专业为`Android`平台打造的响应式编程框架。但是如果你熟悉了`RxJava`你会发现其用起来会有点不舒服，特别是还要主动的获取数据略感不爽（虽然提高了事件分发的效率）。 
+
+总之，现在看来`RxJava`支持的比较全面，但是会略显笨重，而`Agera`是一个专门为`Android`平台设计的响应式编程框架，比较轻巧，当然支持的并不是很全面。可以根据自己的喜好来选择.
+
+但是从个人观点来看`Agera`比起来`RxJava`还是相差几个版本。当然这是我的片面之词，有关更多信息请看[Question: what's the relation to RxJava?](https://github.com/google/agera/issues/20)
+
+
+参考:   
+
+- [RxJava Wiki](https://github.com/ReactiveX/RxJava/wiki)
+- [Grokking RxJava, Part 1: The Basics](http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/)
+- [NotRxJava](https://yarikx.github.io/NotRxJava/)
+- [When Not to Use RxJava](http://tomstechnicalblog.blogspot.hk/2016/07/when-not-to-use-rxjava.html)
+- [给 Android 开发者的 RxJava 详解](http://gank.io/post/560e15be2dca930e00da1083)
+- [Google Agera 从入门到放弃](http://blog.chengyunfeng.com/?p=984)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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"
new file mode 100644
index 00000000..913f85d2
--- /dev/null
+++ "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"
@@ -0,0 +1,504 @@
+RxJava详解之执行原理(四)
+===
+
+
+前面几篇文章介绍了`RxJava`的基本使用，也说了`RxJava`的优缺点。下面我们就从源码的角度去分析一下`RxJava`的原理，以及如何进行
+线程切换和导致内存泄漏的原因。         
+
+```java
+// 创建被观察者、数据源
+Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
+    @Override
+    public void call(Subscriber<? super String> subscriber) {
+        // 可以看到，这里传入了一个 OnSubscribe 对象作为参数。OnSubscribe 会被存储在返回的 Observable 对象中，它的作用相当于一个计划表，当 Observable
+        //被订阅的时候，OnSubscribe 的 call() 方法会自动被调用，事件序列就会依照设定依次触发（对于上面的代码，就是观察者Subscriber 将会被调用三次 onNext() 和一次
+        // onCompleted()）。这样，由被观察者调用了观察者的回调方法，就实现了由被观察者向观察者的事件传递，即观察者模式。
+        Log.i("@@@", "call");
+        subscriber.onNext("Hello ");
+        subscriber.onNext("World !");
+        subscriber.onCompleted();
+    }
+});
+// 创建观察者
+Subscriber<String> subscriber = new Subscriber<String>() {
+    @Override
+    public void onCompleted() {
+        Log.i("@@@", "onCompleted");
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        Log.i("@@@", "onError");
+    }
+
+    @Override
+    public void onNext(String s) {
+        Log.i("@@@", "onNext : " + s);
+    }
+};
+// 关联或者叫订阅更合适。
+observable.subscribe(subscriber);
+
+```
+
+
+Observable源码分析
+---
+
+
+先看一下`Observable.create()`方法:  
+
+```java
+
+public class Observable<T> {
+
+    final OnSubscribe<T> onSubscribe;
+
+    /**
+     * Creates an Observable with a Function to execute when it is subscribed to.
+     * <p>
+     * <em>Note:</em> Use {@link #create(OnSubscribe)} to create an Observable, instead of this constructor,
+     * unless you specifically have a need for inheritance.
+     *
+     * @param f
+     *            {@link OnSubscribe} to be executed when {@link #subscribe(Subscriber)} is called
+     */
+    protected Observable(OnSubscribe<T> f) {
+        this.onSubscribe = f;
+    }
+
+	public static <T> Observable<T> create(OnSubscribe<T> f) {
+		// 调用了上面的构造函数创建一个Observable对象，而RxJavaHooks.onCreate(f)是啥呢？ 源码我们下面会看，这里我们只要知道`RxjavaHooks.onCreate(f)`的返回值还是f就行了
+	    return new Observable<T>(RxJavaHooks.onCreate(f));
+	}
+	
+
+	static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
+     	// validate and proceed
+        if (subscriber == null) {
+            throw new IllegalArgumentException("subscriber can not be null");
+        }
+        // 这里会使用到Observable中的成员变量onSubscribe
+        if (observable.onSubscribe == null) {
+            throw new IllegalStateException("onSubscribe function can not be null.");
+        }
+
+        // new Subscriber so onStart it
+        subscriber.onStart();
+        // The code below is exactly the same an unsafeSubscribe but not used because it would
+        // add a significant depth to already huge call stacks.
+        try {
+            // allow the hook to intercept and/or decorate
+            // 这里会使用到Observable中的成员变量onSubscribe
+            RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
+            return RxJavaHooks.onObservableReturn(subscriber);
+        } catch (Throwable e) {
+        	。。。
+        }
+    }
+
+}
+```
+
+需要一个`OnSubscribe`参数，`OnSbuscribe`接口继承`Action1`接口的它是在`Observale.subscribe()`方法调用时会执行的操作也就是说当调用`observable.subscribe()`方法时就会执行到该参数的`call`方法:  
+```java
+/**
+ * Invoked when Observable.subscribe is called.
+ * @param <T> the output value type
+ */
+public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
+    // cover for generics insanity
+}
+
+/**
+ * A one-argument action.
+ * @param <T> the first argument type
+ */
+public interface Action1<T> extends Action {
+    void call(T t);
+}
+```
+
+而在上面`Observable.create()`方法中我们看到其实是调用了`Observable`类的构造函数，但是在参数那里传入的是`RxJavaHooks.onCreate(f)`:   
+```java
+@Experimental
+public final class RxJavaHooks {
+	static volatile Func1<Observable.OnSubscribe, Observable.OnSubscribe> onObservableCreate;
+
+    /** Initialize with the default delegation to the original RxJavaPlugins. */
+    // 哎~静态代码块
+    static {
+        init();
+    }
+
+    static void init() {
+        ...
+        initCreate()
+    }
+	static void initCreate() {
+        onObservableCreate = new Func1<Observable.OnSubscribe, Observable.OnSubscribe>() {
+            @Override
+            public Observable.OnSubscribe call(Observable.OnSubscribe f) {
+                return RxJavaPlugins.getInstance().getObservableExecutionHook().onCreate(f);
+            }
+        };
+
+        onSingleCreate = new Func1<rx.Single.OnSubscribe, rx.Single.OnSubscribe>() {
+            @Override
+            public rx.Single.OnSubscribe call(rx.Single.OnSubscribe f) {
+                return RxJavaPlugins.getInstance().getSingleExecutionHook().onCreate(f);
+            }
+        };
+
+        onCompletableCreate = new Func1<Completable.OnSubscribe, Completable.OnSubscribe>() {
+            @Override
+            public Completable.OnSubscribe call(Completable.OnSubscribe f) {
+                return RxJavaPlugins.getInstance().getCompletableExecutionHook().onCreate(f);
+            }
+        };
+    }
+
+    /**
+     * Hook to call when an Observable is created.
+     * @param <T> the value type
+     * @param onSubscribe the original OnSubscribe logic
+     * @return the original or replacement OnSubscribe instance
+     */
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public static <T> Observable.OnSubscribe<T> onCreate(Observable.OnSubscribe<T> onSubscribe) {
+    	// 这里onObservableCreate只有在调用initCreate()方法才会初始化，而initCreate()又被init()方法调用，init()在静态代码块中
+        Func1<Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableCreate;
+        if (f != null) {
+            // 所以之列返回的上面onObservableCreate创建的对OnSubscribe对象,其实这里可以简单的理解为直接返回onSubscribe参数
+            return f.call(onSubscribe);
+        }
+        return onSubscribe;
+    }
+
+    public static void clear() {
+        if (lockdown) {
+            return;
+        }
+        onError = null;
+
+        onObservableCreate = null;
+        ...
+    }
+}    
+```
+
+继续看一下`RxJavaPlugins.getInstance().getObservableExecutionHook().onCreate(f);`:  
+```java
+public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
+    return f;
+}
+```
+
+到这里我们总结一下:  
+
+`Observable.create(OnSubscribe f)`方法其实就是内部`new`了一个被观察者`Observable`对象，同时将参数中所传过来的`new`出来的`OnSubscribe`对象赋值给了该`Observable`的成员变量`onSubscribe`。
+那一定会想知道把`create(OnSubscribe f)`的参数赋值给成员变量`onSubscribe`有什么用呢？ 当然是在`Observable.subscribe()`和`unSubscribe()`中会用到啊。  
+
+
+Subscriber源码分析
+---
+
+我们在上面的例子中只是`new`了一个`Subscriber`对象并且实现了对应的方法.   
+`Subscriber`源码并不多，一共二百多行，所以....我要删除些无用的，然后都贴上来:   
+```java
+/**
+ * Provides a mechanism for receiving push-based notifications from Observables, and permits manual
+ * unsubscribing from these Observables.
+ */
+public abstract class Subscriber<T> implements Observer<T>, Subscription {
+
+    // represents requested not set yet
+    private static final long NOT_SET = Long.MIN_VALUE;
+    // Subscription that represents a group of Subscriptions that are unsubscribed together.
+    // 订阅事件集，所有发送给当前Subscriber的事件都会保存在这里
+    private final SubscriptionList subscriptions;
+    private final Subscriber<?> subscriber;
+    /**
+	 * Interface that establishes a request-channel between an Observable and a Subscriber and allows
+	 * the Subscriber to request a certain amount of items from the Observable (otherwise known as
+	 * backpressure).
+	 */
+    private Producer producer;
+
+    protected Subscriber() {
+        this(null, false);
+    }
+
+    protected Subscriber(Subscriber<?> subscriber) {
+        this(subscriber, true);
+    }
+
+    /**
+     * Construct a Subscriber by using another Subscriber for backpressure and
+     * optionally for holding the subscription list (if
+     * <code>shareSubscriptions</code> is <code>true</code> then when
+     * <code>this.add(sub)</code> is called this will in fact call
+     * <code>subscriber.add(sub)</code>).
+     * <p>
+     * To retain the chaining of subscribers when setting
+     * <code>shareSubscriptions</code> to <code>false</code>, add the created
+     * instance to {@code subscriber} via {@link #add}.
+     *
+     * @param subscriber
+     *            the other Subscriber
+     * @param shareSubscriptions
+     *            {@code true} to share the subscription list in {@code subscriber} with
+     *            this instance
+     * @since 1.0.6
+     */
+    protected Subscriber(Subscriber<?> subscriber, boolean shareSubscriptions) {
+        this.subscriber = subscriber;
+        this.subscriptions = shareSubscriptions && subscriber != null ? subscriber.subscriptions : new SubscriptionList();
+    }
+
+    /**
+     * Adds a {@link Subscription} to this Subscriber's list of subscriptions if this list is not marked as
+     * unsubscribed. If the list <em>is</em> marked as unsubscribed, {@code add} will indicate this by
+     * explicitly unsubscribing the new {@code Subscription} as well.
+     *
+     * @param s
+     *            the {@code Subscription} to add
+     */
+    public final void add(Subscription s) {
+        subscriptions.add(s);
+    }
+
+    @Override
+    public final void unsubscribe() {
+        subscriptions.unsubscribe();
+    }
+
+    /**
+     * This method is invoked when the Subscriber and Observable have been connected but the Observable has
+     * not yet begun to emit items or send notifications to the Subscriber. Override this method to add any
+     * useful initialization to your subscription, for instance to initiate backpressure.
+     */
+    public void onStart() {
+        // do nothing by default
+    } 
+}
+```
+可以看到`Subscriber`实现了`Observer`和`Subscription`接口:   
+```java
+public interface Observer<T> {
+    void onCompleted();
+    void onError(Throwable e);
+    void onNext(T t);
+}
+
+public interface Subscription {
+    void unsubscribe();
+    boolean isUnsubscribed();
+}
+```
+
+observable.subscribe(subscriber)源码分析
+---
+
+好了，关键部分出现了，我们继续看`Observable`类中的`subscribe()`方法，上面在将`Observable`源码的时候我们简单带过这部分，没有细说，这里仔细说一下:     
+```java
+public class Observable<T> {
+    final OnSubscribe<T> onSubscribe;
+    protected Observable(OnSubscribe<T> f) {
+        this.onSubscribe = f;
+    }
+    public static <T> Observable<T> create(OnSubscribe<T> f) {
+        return new Observable<T>(RxJavaHooks.onCreate(f));
+    }
+
+    public final Subscription subscribe(Subscriber<? super T> subscriber) {
+        return Observable.subscribe(subscriber, this);
+    }
+
+    static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
+     	// validate and proceed
+        if (subscriber == null) {
+            throw new IllegalArgumentException("subscriber can not be null");
+        }
+
+        if (observable.onSubscribe == null) {
+            throw new IllegalStateException("onSubscribe function can not be null.");
+            /*
+             * the subscribe function can also be overridden but generally that's not the appropriate approach
+             * so I won't mention that in the exception
+             */
+        }
+
+        // new Subscriber so onStart it
+        // 1.首先调用Subscriber.onStart()方法，上面我们知道该方法没有实现
+        subscriber.onStart();
+
+        /*
+         * See https://github.com/ReactiveX/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls
+         * to user code from within an Observer"
+         */
+        // if not already wrapped
+        // 把当前的subscriber转换成SafeSubscriber，SafeSubscriber是一个包装类，他对一些安全性做了校验，保证Subscriber中的onComplete和onError只会有一个被执行且执行一次
+        // 而且一旦他们执行了后就不会再继续执行onNext方法
+        if (!(subscriber instanceof SafeSubscriber)) {
+            // assign to `observer` so we return the protected version
+            subscriber = new SafeSubscriber<T>(subscriber);
+        }
+
+        // The code below is exactly the same an unsafeSubscribe but not used because it would
+        // add a significant depth to already huge call stacks.
+        try {
+            // allow the hook to intercept and/or decorate
+            // 这里就是核心了
+            RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
+            return RxJavaHooks.onObservableReturn(subscriber);
+
+            // 其实上面的这两句代码完全可以简写为:
+            // (observable.onSubscribe).call(subscriber);
+            // return subscriber
+
+
+
+        } catch (Throwable e) {
+            // special handling for certain Throwable/Error/Exception types
+            Exceptions.throwIfFatal(e);
+            // in case the subscriber can't listen to exceptions anymore
+            if (subscriber.isUnsubscribed()) {
+                RxJavaHooks.onError(RxJavaHooks.onObservableError(e));
+            } else {
+                // if an unhandled error occurs executing the onSubscribe we will propagate it
+                try {
+                    subscriber.onError(RxJavaHooks.onObservableError(e));
+                } catch (Throwable e2) {
+                    Exceptions.throwIfFatal(e2);
+                    // if this happens it means the onError itself failed (perhaps an invalid function implementation)
+                    // so we are unable to propagate the error correctly and will just throw
+                    RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
+                    // TODO could the hook be the cause of the error in the on error handling.
+                    RxJavaHooks.onObservableError(r);
+                    // TODO why aren't we throwing the hook's return value.
+                    throw r; // NOPMD
+                }
+            }
+            return Subscriptions.unsubscribed();
+        }
+    }
+}    
+```
+
+上面代码的核心是:   
+```java
+RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
+return RxJavaHooks.onObservableReturn(subscriber);
+```
+
+而`RxJavaHooks`这个类我们在前面讲`Observable`的时候也讲到过这个类的`onCreate()`方法。 
+
+我们分别看下他们的源码:    
+```java
+public static <T> Observable.OnSubscribe<T> onObservableStart(Observable<T> instance, Observable.OnSubscribe<T> onSubscribe) {
+	// 这一块代码是不是似曾相识？ 前面讲的RxJavaHooks。onCreate()方法是不是也是这样实现的？ 只不过那里是onObservableCreate而这里是onObservableStart，这里可以简单的理解为返回参数onSubscribe
+    Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableStart;
+    if (f != null) {
+        return f.call(instance, onSubscribe);
+    }
+    return onSubscribe;
+}
+
+/**
+ * Hook to call before the Observable.subscribe() method is about to return a Subscription.
+ * @param subscription the original subscription
+ * @return the original or alternative subscription that will be returned
+ */
+public static Subscription onObservableReturn(Subscription subscription) {
+    Func1<Subscription, Subscription> f = onObservableReturn;
+    if (f != null) {
+        return f.call(subscription);
+    }
+    return subscription;
+}
+
+static void init() {
+    onObservableStart = new Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe>() {
+        @Override
+        public Observable.OnSubscribe call(Observable t1, Observable.OnSubscribe t2) {
+            return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeStart(t1, t2);
+        }
+    };
+
+    onObservableReturn = new Func1<Subscription, Subscription>() {
+        @Override
+        public Subscription call(Subscription f) {
+            return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeReturn(f);
+        }
+    };
+}        
+```
+
+所以这里这两句核心代码是不就可以简写为:   
+```java
+(observable.onSubscribe).call(subscriber);
+return subscriber
+```
+而这里`observable.onSubscribe`变量是谁呢？ 它就是前面我们说的在`Observable.onCreate(OnSubscribe<T> f)`方法中将参数赋值给的那个变量，也就是`OnSubscribe`接口的实现类，而我们在调用`onCreate()`方法的时候都会实现`call()`方法。
+```java
+/**
+ * Invoked when Observable.subscribe is called.
+ * @param <T> the output value type
+ */
+public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
+    // cover for generics insanity
+}
+```	
+
+
+Over
+---
+
+所以到这里我们是不是就分析完了？
+```java
+// 创建被观察者、数据源
+Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
+    @Override
+    public void call(Subscriber<? super String> subscriber) {
+        subscriber.onNext("Hello ");
+        subscriber.onNext("World !");
+        subscriber.onCompleted();
+    }
+});
+Subscriber<String> subscriber = new Subscriber<String>() {
+    @Override
+    public void onCompleted() {
+        Log.i("@@@", "onCompleted");
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        Log.i("@@@", "onError");
+    }
+
+    @Override
+    public void onNext(String s) {
+        Log.i("@@@", "onNext : " + s);
+    }
+};
+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`对象。
+一旦调用`subscribe()`方法后就会触发执行`OnSubscribe.call()`。而我们上面实现的`OnSubscribe.call()`方法会调用`Subscriber`类的`onNext()`、`onComplete()`及`onError()`等方法。
+
+
+更多内容请看下一篇文章[RxJava详解(五)][1]
+
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/5.RxJava%E8%AF%A6%E8%A7%A3%E4%B9%8B%E6%93%8D%E4%BD%9C%E7%AC%A6%E6%89%A7%E8%A1%8C%E5%8E%9F%E7%90%86(%E4%BA%94).md "RxJava详解(五)"
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/RxJavaPart/5.RxJava\350\257\246\350\247\243\344\271\213\346\223\215\344\275\234\347\254\246\346\211\247\350\241\214\345\216\237\347\220\206(\344\272\224).md" "b/RxJavaPart/5.RxJava\350\257\246\350\247\243\344\271\213\346\223\215\344\275\234\347\254\246\346\211\247\350\241\214\345\216\237\347\220\206(\344\272\224).md"
new file mode 100644
index 00000000..8fd8210f
--- /dev/null
+++ "b/RxJavaPart/5.RxJava\350\257\246\350\247\243\344\271\213\346\223\215\344\275\234\347\254\246\346\211\247\350\241\214\345\216\237\347\220\206(\344\272\224).md"
@@ -0,0 +1,235 @@
+RxJava详解之操作符执行原理(五)
+===
+
+
+上一篇文章介绍了`RxJava`的执行原理。下面继续介绍一下操作符的执行原理，但是操作符太多了，这里用`map`来进行说明。 
+```java
+Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
+    @Override
+    public void call(Subscriber<? super String> subscriber) {
+        subscriber.onNext("Hello ");
+        subscriber.onNext("World !");
+        subscriber.onCompleted();
+    }
+});
+
+observable.map(new Func1<String, String>() {
+    @Override
+    public String call(String s) {
+        return "say" + s;
+    }
+});
+
+observable.subscribe(new Subscriber<String>() {
+    @Override
+    public void onCompleted() {
+
+    }
+
+    @Override
+    public void onError(Throwable e) {
+
+    }
+
+    @Override
+    public void onNext(String s) {
+        Log.i("@@@", s);
+    }
+});
+```
+
+执行结果很显然是`say Hello`和`say World !`。   
+
+我们直接进入`Observable.map()`方法的源码:     
+```java
+public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
+    return create(new OnSubscribeMap<T, R>(this, func));
+}
+
+public static <T> Observable<T> create(OnSubscribe<T> f) {
+    return new Observable<T>(RxJavaHooks.onCreate(f));
+}   
+```
+`map`的内部调用了`create()`方法，而`create()`方法的源码我们再上一个版本已经介绍了，也就是说`map`内部会创建一个新的`Observable`对象，而且用一个新的`OnSubscribeMap`对象作为参数。 
+`OnSubscribeMap()`对象的参数分别是之前通过`create()`方法创建的`Observable`对象，以及`map`中传递过来的`Func1`类的对象。接下来就直接看`OnSubscribeMap`类的源码，他实现了`OnSubscribe`接口，并重写了`call()`方法:   
+```java
+/**
+ * Applies a function of your choosing to every item emitted by an {@code Observable}, and emits the results of
+ * this transformation as a new {@code Observable}.
+ */
+public final class OnSubscribeMap<T, R> implements OnSubscribe<R> {
+    // 最初Observable.create()创建的Observable对象
+    final Observable<T> source;
+    // map方法传递过来的func1对象，它是一个转换功能
+    final Func1<? super T, ? extends R> transformer;
+
+    public OnSubscribeMap(Observable<T> source, Func1<? super T, ? extends R> transformer) {
+        this.source = source;
+        this.transformer = transformer;
+    }
+
+    @Override
+    public void call(final Subscriber<? super R> o) {
+        MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
+        // 把新创建的MapSubscriber添加到Observable.subscribe(subscribe)方法传递的参数subscriber中
+        o.add(parent);
+        // unsafeSubscribe是subscribe方法的一个安全性不高的操作，可以简单理解为subscribe方法
+        source.unsafeSubscribe(parent);
+    }
+
+    static final class MapSubscriber<T, R> extends Subscriber<T> {
+
+        final Subscriber<? super R> actual;
+
+        final Func1<? super T, ? extends R> mapper;
+
+        boolean done;
+
+        public MapSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
+            this.actual = actual;
+            this.mapper = mapper;
+        }
+
+        @Override
+        public void onNext(T t) {
+            R result;
+
+            try {
+                // 先会执行以下转换函数的call方法，然后将结果再传递给Subscribe对象调用它的onNext方法
+                result = mapper.call(t);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                onError(OnErrorThrowable.addValueAsLastCause(ex, t));
+                return;
+            }
+
+            actual.onNext(result);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            if (done) {
+                RxJavaHooks.onError(e);
+                return;
+            }
+            done = true;
+
+            actual.onError(e);
+        }
+
+
+        @Override
+        public void onCompleted() {
+            if (done) {
+                return;
+            }
+            actual.onCompleted();
+        }
+
+        @Override
+        public void setProducer(Producer p) {
+            actual.setProducer(p);
+        }
+    }
+}
+```
+
+因为在执行`observable.subscribe(subscriber)`方法会调用到`call()`方法，这里看一下`call()`方法的核心:   
+```java
+MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
+// 把新创建的MapSubscriber添加到Observable.subscribe(subscribe)方法传递的参数subscriber中
+o.add(parent);
+// unsafeSubscribe是subscribe方法的一个安全性不高的操作，可以简单理解为subscribe方法，注意这里传递的是parent，也就是先创建的MapSubscriber对象，而这里的source是谁呢？ 它是最初Observable.create创建的Observable对象
+source.unsafeSubscribe(parent);
+```
+`add()`及`unsasfeSubscribe()`方法如下:   
+```java
+private final SubscriptionList subscriptions;
+
+public final void add(Subscription s) {
+    subscriptions.add(s);
+}
+
+public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
+    try {
+        // new Subscriber so onStart it
+        subscriber.onStart();
+        // allow the hook to intercept and/or decorate
+        RxJavaHooks.onObservableStart(this, onSubscribe).call(subscriber);
+        return RxJavaHooks.onObservableReturn(subscriber);
+    } catch (Throwable e) {
+        // special handling for certain Throwable/Error/Exception types
+        Exceptions.throwIfFatal(e);
+        // if an unhandled error occurs executing the onSubscribe we will propagate it
+        try {
+            subscriber.onError(RxJavaHooks.onObservableError(e));
+        } catch (Throwable e2) {
+            Exceptions.throwIfFatal(e2);
+            // if this happens it means the onError itself failed (perhaps an invalid function implementation)
+            // so we are unable to propagate the error correctly and will just throw
+            RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
+            // TODO could the hook be the cause of the error in the on error handling.
+            RxJavaHooks.onObservableError(r);
+            // TODO why aren't we throwing the hook's return value.
+            throw r; // NOPMD
+        }
+        return Subscriptions.unsubscribed();
+    }
+}
+```
+这一块代码就很简单了，因为和前面一篇我们分析的`subscribe()`方法类似，相当于直接调用了最初`Observable.create()`创建的`Observable`对象的`call(subscriber)`方法，而这里的`subscriber`又是我们创建的`MapSubscriber`的子类，所以这里相当于调用了`MapSubscriber`类中的`onNext()`、`onComplete()`和`onError()`方法:   
+
+```java
+static final class MapSubscriber<T, R> extends Subscriber<T> {
+
+    final Subscriber<? super R> actual;
+
+    final Func1<? super T, ? extends R> mapper;
+
+    boolean done;
+
+    public MapSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
+        this.actual = actual;
+        this.mapper = mapper;
+    }
+
+    @Override
+    public void onNext(T t) {
+        R result;
+
+        try {
+            // 先会执行以下转换函数的call方法，这个就是我们把Hello修改为say Hello的部分
+            result = mapper.call(t);
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            unsubscribe();
+            onError(OnErrorThrowable.addValueAsLastCause(ex, t));
+            return;
+        }
+        // 将转换函数的call方法的执行结果交给最初的Subscriber.onNext()方法的参数来执行
+        actual.onNext(result);
+    }
+    ...
+}
+```
+乱不乱？
+
+梳理一下:
+
+- 我们把不使用`map`操作符时正常的操作创建的`Observable`和`Subscriber`分别称为1号。 
+- 而`map`又会通过`create`分辨创建一个`Observable`2号和`Subscriber`2号，当我们执行`map`的时候，会最终执行到`Subscriber`2号的`onNext()`方法中，而该方法内部会先执行一些转换操作，然后将执行完的结果作为参数传递给并调用最初的`Subscriber`1号的`onNext()`方法。懂不？ 多看两遍，这里有点绕。
+
+
+
+
+更多内容请看下一篇文章[RxJava详解(六)][1]
+
+
+[1]: 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 "RxJava详解(六)"
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/RxJavaPart/6.RxJava\350\257\246\350\247\243\344\271\213\347\272\277\347\250\213\350\260\203\345\272\246\345\216\237\347\220\206(\345\205\255).md" "b/RxJavaPart/6.RxJava\350\257\246\350\247\243\344\271\213\347\272\277\347\250\213\350\260\203\345\272\246\345\216\237\347\220\206(\345\205\255).md"
new file mode 100644
index 00000000..c3de5a36
--- /dev/null
+++ "b/RxJavaPart/6.RxJava\350\257\246\350\247\243\344\271\213\347\272\277\347\250\213\350\260\203\345\272\246\345\216\237\347\220\206(\345\205\255).md"
@@ -0,0 +1,823 @@
+RxJava详解之线程调度原理(六)
+===
+
+
+```java
+Observable.create(new Observable.OnSubscribe<String>() {
+    @Override
+    public void call(Subscriber<? super String> subscriber) {
+        subscriber.onNext("Hello");
+        subscriber.onCompleted();
+        Log.i("@@@", "call" + Thread.currentThread().getName());
+    }
+}).subscribeOn(Schedulers.io())
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(new Subscriber<String>() {
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+
+            }
+
+            @Override
+            public void onNext(String s) {
+                Log.i("@@@", "onNext : " + Thread.currentThread().getName());
+            }
+        });
+```
+执行结果:   
+```java
+07-26 17:16:49.284 7266-7309/? I/@@@: callRxIoScheduler-2
+07-26 17:16:49.368 7266-7266/? I/@@@: onNext : main
+```
+
+`subscribeOn()`是指定被观察者事件源的执行线程。
+`observeOn()`是指定观察者的处理时间的线程。
+
+
+subscribeOn源码分析:   
+```java
+public final Observable<T> subscribeOn(Scheduler scheduler) {
+    if (this instanceof ScalarSynchronousObservable) {
+        return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
+    }
+    return create(new OperatorSubscribeOn<T>(this, scheduler));
+}
+
+/**
+ * A {@code Scheduler} is an object that schedules units of work. You can find common implementations of this
+ * class in {@link Schedulers}.
+ * 线程调度器
+ */
+public abstract class Scheduler {
+    ...
+}
+```
+它内部也是通过`create()`创建一个`Observable`但是唯一不同的是`OnSubscribe`传递的是`OperatorSubscribeOn`对象:    
+```java
+/**
+ * Subscribes Observers on the specified {@code Scheduler}.
+ */
+public final class OperatorSubscribeOn<T> implements OnSubscribe<T> {
+
+    final Scheduler scheduler;
+    final Observable<T> source;
+
+    public OperatorSubscribeOn(Observable<T> source, Scheduler scheduler) {
+        this.scheduler = scheduler;
+        this.source = source;
+    }
+
+    @Override
+    public void call(final Subscriber<? super T> subscriber) {
+        final Worker inner = scheduler.createWorker();
+        subscriber.add(inner);
+
+        inner.schedule(new Action0() {
+            @Override
+            public void call() {
+                final Thread t = Thread.currentThread();
+
+                Subscriber<T> s = new Subscriber<T>(subscriber) {
+                    @Override
+                    public void onNext(T t) {
+                        subscriber.onNext(t);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        try {
+                            subscriber.onError(e);
+                        } finally {
+                            inner.unsubscribe();
+                        }
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        try {
+                            subscriber.onCompleted();
+                        } finally {
+                            inner.unsubscribe();
+                        }
+                    }
+
+                    @Override
+                    public void setProducer(final Producer p) {
+                        subscriber.setProducer(new Producer() {
+                            @Override
+                            public void request(final long n) {
+                                if (t == Thread.currentThread()) {
+                                    p.request(n);
+                                } else {
+                                    inner.schedule(new Action0() {
+                                        @Override
+                                        public void call() {
+                                            p.request(n);
+                                        }
+                                    });
+                                }
+                            }
+                        });
+                    }
+                };
+
+                source.unsafeSubscribe(s);
+            }
+        });
+    }
+}
+```
+它内部原理其实和`map`是一样一样的。我们就从`call()`方法说起，首先看一下`Subscriber`和`Worker`类:   
+
+```java
+/**
+ * A {@code Scheduler} is an object that schedules units of work. You can find common implementations of this
+ * class in {@link Schedulers}.
+ */
+public abstract class Scheduler {
+    /**
+     * Retrieves or creates a new {@link Scheduler.Worker} that represents serial execution of actions.
+     * <p>
+     * When work is completed it should be unsubscribed using {@link Scheduler.Worker#unsubscribe()}.
+     * <p>
+     * Work on a {@link Scheduler.Worker} is guaranteed to be sequential.
+     *
+     * @return a Worker representing a serial queue of actions to be executed
+     */
+    public abstract Worker createWorker();
+
+    /**
+     * Sequential Scheduler for executing actions on a single thread or event loop.
+     * <p>
+     * Unsubscribing the {@link Worker} cancels all outstanding work and allows resources cleanup.
+     */
+    public abstract static class Worker implements Subscription {
+
+        /**
+         * Schedules an Action for execution.
+         */
+        public abstract Subscription schedule(Action0 action);
+
+        /**
+         * Schedules an Action for execution at some point in the future.
+         */
+        public abstract Subscription schedule(final Action0 action, final long delayTime, final TimeUnit unit);
+    }
+}    
+```
+
+而上面的`schedulers`是通过`Schedulers.io()`创建的，这里看一下它的源码:  
+```java
+public final class Schedulers {
+
+    private final Scheduler computationScheduler;
+    private final Scheduler ioScheduler;
+    private final Scheduler newThreadScheduler;
+
+    private static final AtomicReference<Schedulers> INSTANCE = new AtomicReference<Schedulers>();
+
+    private static Schedulers getInstance() {
+        for (;;) {
+            Schedulers current = INSTANCE.get();
+            if (current != null) {
+                return current;
+            }
+            current = new Schedulers();
+            if (INSTANCE.compareAndSet(null, current)) {
+                return current;
+            } else {
+                current.shutdownInstance();
+            }
+        }
+    }
+
+    public static Scheduler io() {
+        return RxJavaHooks.onIOScheduler(getInstance().ioScheduler);
+    }
+
+    private Schedulers() {
+        @SuppressWarnings("deprecation")
+        RxJavaSchedulersHook hook = RxJavaPlugins.getInstance().getSchedulersHook();
+
+        Scheduler c = hook.getComputationScheduler();
+        if (c != null) {
+            computationScheduler = c;
+        } else {
+            computationScheduler = RxJavaSchedulersHook.createComputationScheduler();
+        }
+
+        // 下面几时创建ioScheduler的地方
+        Scheduler io = hook.getIOScheduler();
+        if (io != null) {
+            ioScheduler = io;
+        } else {
+            ioScheduler = RxJavaSchedulersHook.createIoScheduler();
+        }
+
+        Scheduler nt = hook.getNewThreadScheduler();
+        if (nt != null) {
+            newThreadScheduler = nt;
+        } else {
+            newThreadScheduler = RxJavaSchedulersHook.createNewThreadScheduler();
+        }
+    }
+    ...
+}    
+```
+继续`onIOScheduler`的源码:   
+```java
+/**
+ * 和create()方法类似，这里简单的理解为直接返回参数即可
+ * Hook to call when the Schedulers.io() is called.
+ * @param scheduler the default io scheduler
+ * @return the default of alternative scheduler
+ */
+public static Scheduler onIOScheduler(Scheduler scheduler) {
+    Func1<Scheduler, Scheduler> f = onIOScheduler;
+    if (f != null) {
+        return f.call(scheduler);
+    }
+    return scheduler;
+}
+```
+而上面`getInstance().ioScheduler`的地方最终会调用到`RxJavaSchedulersHook.createIoScheduler()`:   
+```java
+@Experimental
+public static Scheduler createIoScheduler() {
+    return createIoScheduler(new RxThreadFactory("RxIoScheduler-"));
+}
+
+public static Scheduler createIoScheduler(ThreadFactory threadFactory) {
+    if (threadFactory == null) {
+        throw new NullPointerException("threadFactory == null");
+    }
+    // 看到了吗？ 这里最终的Scheduler是CachedThreadScheduler
+    return new CachedThreadScheduler(threadFactory);
+}
+```
+
+而在`CachedThreadScheduler`类中:   
+```java
+public final class CachedThreadScheduler extends Scheduler implements SchedulerLifecycle {
+
+    @Override
+    public Worker createWorker() {
+        return new EventLoopWorker(pool.get());
+    }
+    ...
+}    
+```
+
+所以我们通过`Schedulers.io()`的源码可以发现这里的具体实现类是`CachedThreadScheduler`。而对应的`Worker`的实现类是`EventLoopWorker`:   
+```java
+   static final class EventLoopWorker extends Scheduler.Worker implements Action0 {
+        private final CompositeSubscription innerSubscription = new CompositeSubscription();
+        private final CachedWorkerPool pool;
+        private final ThreadWorker threadWorker;
+        final AtomicBoolean once;
+
+        EventLoopWorker(CachedWorkerPool pool) {
+            this.pool = pool;
+            this.once = new AtomicBoolean();
+            this.threadWorker = pool.get();
+        }
+
+        @Override
+        public void unsubscribe() {
+            if (once.compareAndSet(false, true)) {
+                // unsubscribe should be idempotent, so only do this once
+
+                // Release the worker _after_ the previous action (if any) has completed
+                threadWorker.schedule(this);
+            }
+            innerSubscription.unsubscribe();
+        }
+
+        @Override
+        public void call() {
+            pool.release(threadWorker);
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return innerSubscription.isUnsubscribed();
+        }
+
+        @Override
+        public Subscription schedule(Action0 action) {
+            return schedule(action, 0, null);
+        }
+
+        @Override
+        public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
+            if (innerSubscription.isUnsubscribed()) {
+                // don't schedule, we are unsubscribed
+                return Subscriptions.unsubscribed();
+            }
+
+            ScheduledAction s = threadWorker.scheduleActual(new Action0() {
+                @Override
+                public void call() {
+                    if (isUnsubscribed()) {
+                        return;
+                    }
+                    // 内部会调用外面传递过来的Action对象的call方法
+                    action.call();
+                }
+            }, delayTime, unit);
+            innerSubscription.add(s);
+            s.addParent(innerSubscription);
+            return s;
+        }
+```
+这里会继续执行到`threadWorker.scheduleActual`:   
+```java
+public class NewThreadWorker extends Scheduler.Worker implements Subscription {
+    private final ScheduledExecutorService executor;
+
+    public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit) {
+        Action0 decoratedAction = RxJavaHooks.onScheduledAction(action);
+        ScheduledAction run = new ScheduledAction(decoratedAction);
+        Future<?> f;
+        if (delayTime <= 0) {
+            f = executor.submit(run);
+        } else {
+            f = executor.schedule(run, delayTime, unit);
+        }
+        run.add(f);
+
+        return run;
+    }
+...
+}
+```
+
+而`ScheduledAction`的源码:   
+```java
+/**
+ * A {@code Runnable} that executes an {@code Action0} and can be cancelled. The analog is the
+ * {@code Subscriber} in respect of an {@code Observer}.
+ */
+public final class ScheduledAction extends AtomicReference<Thread> implements Runnable, Subscription {
+    /** */
+    private static final long serialVersionUID = -3962399486978279857L;
+    final SubscriptionList cancel;
+    final Action0 action;
+
+    public ScheduledAction(Action0 action) {
+        this.action = action;
+        this.cancel = new SubscriptionList();
+    }
+    ...
+}    
+```
+
+`ScheduledAction`实现了`Runnable`接口，通过线程池`executor`最终实现了线程切换。上面便是`subscribeOn(Schedulers.io())`实现线程切换的全部过程。
+
+
+observeOn源码分析
+---
+
+直接上源码:   
+```java
+public final Observable<T> observeOn(Scheduler scheduler) {
+    return observeOn(scheduler, RxRingBuffer.SIZE);
+}
+
+public final Observable<T> observeOn(Scheduler scheduler, int bufferSize) {
+    return observeOn(scheduler, false, bufferSize);
+}
+
+public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
+    if (this instanceof ScalarSynchronousObservable) {
+        return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
+    }
+    return lift(new OperatorObserveOn<T>(scheduler, delayError, bufferSize));
+}
+```
+`observeOn`内部是通过`lift`来实现的，看一下`lift`的源码:     
+```java
+public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
+    return create(new OnSubscribeLift<T, R>(onSubscribe, operator));
+}
+```  
+归根到底还是使用了`create()`，那就和之前分析的基本都差不多了，直接看`OnSubscribeLift`:  
+```java
+/**
+ * Transforms the downstream Subscriber into a Subscriber via an operator
+ * callback and calls the parent OnSubscribe.call() method with it.
+ */
+public final class OnSubscribeLift<T, R> implements OnSubscribe<R> {
+
+    final OnSubscribe<T> parent;
+
+    final Operator<? extends R, ? super T> operator;
+
+    public OnSubscribeLift(OnSubscribe<T> parent, Operator<? extends R, ? super T> operator) {
+        this.parent = parent;
+        this.operator = operator;
+    }
+
+    @Override
+    public void call(Subscriber<? super R> o) {
+        try {
+            Subscriber<? super T> st = RxJavaHooks.onObservableLift(operator).call(o);
+            try {
+                // new Subscriber created and being subscribed with so 'onStart' it
+                st.onStart();
+                parent.call(st);
+            } catch (Throwable e) {
+                // localized capture of errors rather than it skipping all operators
+                // and ending up in the try/catch of the subscribe method which then
+                // prevents onErrorResumeNext and other similar approaches to error handling
+                Exceptions.throwIfFatal(e);
+                st.onError(e);
+            }
+        } catch (Throwable e) {
+            Exceptions.throwIfFatal(e);
+            // if the lift function failed all we can do is pass the error to the final Subscriber
+            // as we don't have the operator available to us
+            o.onError(e);
+        }
+    }
+}
+```
+也实现了`OnSubscribe`，通过前面的分析我们知道一旦调用了`subscribe()`将观察者与被观察绑定后就会触发被观察者所对应的`OnSubscribe`的`call()`方法，所以这里会触发`OnSubscribeLift.call()`。在`call()`中调用了`OperatorObserveOn.call()`并返回了一个新的观察者`Subscriber st`，接着调用了前一级`Observable`对应`OnSubscriber.call(st)`。
+所以这里要看一下`OperatorObserveOn`类及它的`call()`方法:   
+```java
+public final class OperatorObserveOn<T> implements Operator<T, T> {
+    private final Scheduler scheduler;
+    private final boolean delayError;
+    private final int bufferSize;
+
+    public OperatorObserveOn(Scheduler scheduler, boolean delayError) {
+        this(scheduler, delayError, RxRingBuffer.SIZE);
+    }
+
+    public OperatorObserveOn(Scheduler scheduler, boolean delayError, int bufferSize) {
+        this.scheduler = scheduler;
+        this.delayError = delayError;
+        this.bufferSize = (bufferSize > 0) ? bufferSize : RxRingBuffer.SIZE;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super T> child) {
+        if (scheduler instanceof ImmediateScheduler) {
+            // avoid overhead, execute directly
+            return child;
+        } else if (scheduler instanceof TrampolineScheduler) {
+            // avoid overhead, execute directly
+            return child;
+        } else {
+            ObserveOnSubscriber<T> parent = new ObserveOnSubscriber<T>(scheduler, child, delayError, bufferSize);
+            parent.init();
+            return parent;
+        }
+    }
+```
+这里会走到创建`ObserveOnSubscriber`然后调用其`init()`方法:   
+```java
+static final class ObserveOnSubscriber<T> extends Subscriber<T> implements Action0 {
+    final Subscriber<? super T> child;
+    final Scheduler.Worker recursiveScheduler;
+    final boolean delayError;
+    final Queue<Object> queue;
+    /** The emission threshold that should trigger a replenishing request. */
+    final int limit;
+
+    // the status of the current stream
+    volatile boolean finished;
+
+    final AtomicLong requested = new AtomicLong();
+
+    final AtomicLong counter = new AtomicLong();
+
+    /**
+     * The single exception if not null, should be written before setting finished (release) and read after
+     * reading finished (acquire).
+     */
+    Throwable error;
+
+    /** Remembers how many elements have been emitted before the requests run out. */
+    long emitted;
+
+    // do NOT pass the Subscriber through to couple the subscription chain ... unsubscribing on the parent should
+    // not prevent anything downstream from consuming, which will happen if the Subscription is chained
+    public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> child, boolean delayError, int bufferSize) {
+        this.child = child;
+        // 通过参数传递过来的Schedule创建对应的worker
+        this.recursiveScheduler = scheduler.createWorker();
+        this.delayError = delayError;
+        int calculatedSize = (bufferSize > 0) ? bufferSize : RxRingBuffer.SIZE;
+        // this formula calculates the 75% of the bufferSize, rounded up to the next integer
+        this.limit = calculatedSize - (calculatedSize >> 2);
+        if (UnsafeAccess.isUnsafeAvailable()) {
+            queue = new SpscArrayQueue<Object>(calculatedSize);
+        } else {
+            queue = new SpscAtomicArrayQueue<Object>(calculatedSize);
+        }
+        // signal that this is an async operator capable of receiving this many
+        request(calculatedSize);
+    }
+
+    void init() {
+        // don't want this code in the constructor because `this` can escape through the
+        // setProducer call
+        Subscriber<? super T> localChild = child;
+
+        localChild.setProducer(new Producer() {
+
+            @Override
+            public void request(long n) {
+                if (n > 0L) {
+                    BackpressureUtils.getAndAddRequest(requested, n);
+                    schedule();
+                }
+            }
+
+        });
+        localChild.add(recursiveScheduler);
+        localChild.add(this);
+    }
+
+    @Override
+    public void onNext(final T t) {
+        if (isUnsubscribed() || finished) {
+            return;
+        }
+        if (!queue.offer(NotificationLite.next(t))) {
+            onError(new MissingBackpressureException());
+            return;
+        }
+        // 有该方法
+        schedule();
+    }
+
+    @Override
+    public void onCompleted() {
+        if (isUnsubscribed() || finished) {
+            return;
+        }
+        finished = true;
+        // 有该方法
+        schedule();
+    }
+
+    @Override
+    public void onError(final Throwable e) {
+        if (isUnsubscribed() || finished) {
+            RxJavaHooks.onError(e);
+            return;
+        }
+        error = e;
+        finished = true;
+        // 有该方法
+        schedule();
+    }
+
+    protected void schedule() {
+        if (counter.getAndIncrement() == 0) {
+            // 调用recursiveScheduler，而recursiveScheduler是通过参数传递过来的
+            recursiveScheduler.schedule(this);
+        }
+    }
+
+    // only execute this from schedule()
+    // 最终会执行到该方法
+    @Override
+    public void call() {
+        long missed = 1L;
+        long currentEmission = emitted;
+
+        // these are accessed in a tight loop around atomics so
+        // loading them into local variables avoids the mandatory re-reading
+        // of the constant fields
+        final Queue<Object> q = this.queue;
+        final Subscriber<? super T> localChild = this.child;
+
+        // requested and counter are not included to avoid JIT issues with register spilling
+        // and their access is is amortized because they are part of the outer loop which runs
+        // less frequently (usually after each bufferSize elements)
+
+        for (;;) {
+            long requestAmount = requested.get();
+
+            while (requestAmount != currentEmission) {
+                boolean done = finished;
+                Object v = q.poll();
+                boolean empty = v == null;
+
+                if (checkTerminated(done, empty, localChild, q)) {
+                    return;
+                }
+
+                if (empty) {
+                    break;
+                }
+                // 该方法会调用onNext方法
+                localChild.onNext(NotificationLite.<T>getValue(v));
+
+                currentEmission++;
+                if (currentEmission == limit) {
+                    requestAmount = BackpressureUtils.produced(requested, currentEmission);
+                    request(currentEmission);
+                    currentEmission = 0L;
+                }
+            }
+
+            if (requestAmount == currentEmission) {
+                if (checkTerminated(finished, q.isEmpty(), localChild, q)) {
+                    return;
+                }
+            }
+
+            emitted = currentEmission;
+            missed = counter.addAndGet(-missed);
+            if (missed == 0L) {
+                break;
+            }
+        }
+    }
+}
+```
+我们看到上面的`onNext`、`onComplete()`和`onError`方法里面都调用了`schedule()`方法，所以这个方法就是具体的切换线程的部分:   
+```java
+protected void schedule() {
+    if (counter.getAndIncrement() == 0) {
+        // 调用recursiveScheduler，而recursiveScheduler是通过参数传递过来的，该方法将所有的事件都切换到了recursiveScheduler对应的线程
+        // 这里将this传递进去了，所以最后会执行到当前的call()方法
+        recursiveScheduler.schedule(this);
+    }
+}
+```
+里面会调用`recursiveScheduler`，而该`recursiveScheduler`是通过构造函数初始化的:   
+```java
+public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> child, boolean delayError, int bufferSize) {
+    this.child = child;
+    // 通过参数传递过来的Schedule创建对应的worker
+    this.recursiveScheduler = scheduler.createWorker();
+}
+```
+而在此处我们的示例代码中用到的`Scheduler`是`AndroidSchedulers.mainThread()`:    
+```java
+public final class AndroidSchedulers {
+    private static final AtomicReference<AndroidSchedulers> INSTANCE = new AtomicReference<>();
+
+    private final Scheduler mainThreadScheduler;
+
+    private static AndroidSchedulers getInstance() {
+        for (;;) {
+            AndroidSchedulers current = INSTANCE.get();
+            if (current != null) {
+                return current;
+            }
+            current = new AndroidSchedulers();
+            if (INSTANCE.compareAndSet(null, current)) {
+                return current;
+            }
+        }
+    }
+
+    private AndroidSchedulers() {
+        RxAndroidSchedulersHook hook = RxAndroidPlugins.getInstance().getSchedulersHook();
+
+        Scheduler main = hook.getMainThreadScheduler();
+        if (main != null) {
+            mainThreadScheduler = main;
+        } else {
+            // 具体的实现类是LooperScheduler
+            mainThreadScheduler = new LooperScheduler(Looper.getMainLooper());
+        }
+    }
+
+    /** A {@link Scheduler} which executes actions on the Android UI thread. */
+    public static Scheduler mainThread() {
+        return getInstance().mainThreadScheduler;
+    }
+    ...
+}    
+```
+我们看到这里的具体的`Scheduler`的实现类是`LooperScheduler`:     
+```java
+class LooperScheduler extends Scheduler {
+    private final Handler handler;
+
+    LooperScheduler(Looper looper) {
+        handler = new Handler(looper);
+    }
+
+    LooperScheduler(Handler handler) {
+        this.handler = handler;
+    }
+
+    @Override
+    public Worker createWorker() {
+        return new HandlerWorker(handler);
+    }
+
+    static class HandlerWorker extends Worker {
+        private final Handler handler;
+        private final RxAndroidSchedulersHook hook;
+        private volatile boolean unsubscribed;
+
+        HandlerWorker(Handler handler) {
+            this.handler = handler;
+            this.hook = RxAndroidPlugins.getInstance().getSchedulersHook();
+        }
+
+        @Override
+        public void unsubscribe() {
+            unsubscribed = true;
+            handler.removeCallbacksAndMessages(this /* token */);
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return unsubscribed;
+        }
+
+        @Override
+        public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
+            if (unsubscribed) {
+                return Subscriptions.unsubscribed();
+            }
+
+            action = hook.onSchedule(action);
+
+            ScheduledAction scheduledAction = new ScheduledAction(action, handler);
+
+            Message message = Message.obtain(handler, scheduledAction);
+            message.obj = this; // Used as token for unsubscription operation.
+
+            handler.sendMessageDelayed(message, unit.toMillis(delayTime));
+
+            if (unsubscribed) {
+                handler.removeCallbacks(scheduledAction);
+                return Subscriptions.unsubscribed();
+            }
+
+            return scheduledAction;
+        }
+
+        @Override
+        public Subscription schedule(final Action0 action) {
+            return schedule(action, 0, TimeUnit.MILLISECONDS);
+        }
+    }
+
+    static final class ScheduledAction implements Runnable, Subscription {
+        private final Action0 action;
+        private final Handler handler;
+        private volatile boolean unsubscribed;
+
+        ScheduledAction(Action0 action, Handler handler) {
+            this.action = action;
+            this.handler = handler;
+        }
+
+        @Override public void run() {
+            try {
+                action.call();
+            } catch (Throwable e) {
+                // nothing to do but print a System error as this is fatal and there is nowhere else to throw this
+                IllegalStateException ie;
+                if (e instanceof OnErrorNotImplementedException) {
+                    ie = new IllegalStateException("Exception thrown on Scheduler.Worker thread. Add `onError` handling.", e);
+                } else {
+                    ie = new IllegalStateException("Fatal Exception thrown on Scheduler.Worker thread.", e);
+                }
+                RxJavaPlugins.getInstance().getErrorHandler().handleError(ie);
+                Thread thread = Thread.currentThread();
+                thread.getUncaughtExceptionHandler().uncaughtException(thread, ie);
+            }
+        }
+
+        @Override public void unsubscribe() {
+            unsubscribed = true;
+            handler.removeCallbacks(this);
+        }
+
+        @Override public boolean isUnsubscribed() {
+            return unsubscribed;
+        }
+    }
+}
+```
+他里面对应的`Worker`是`HandlerWorker`，他里面也是通过`ScheduledAction`来实现的，他实现了`Runnable`接口。通过主线程的`MainLooper`创建一个`Handler`然后去执行`ScheduledAction`中的`run()`方法。然后在`run()`方法中调用了`ObserveOnSubscriber.call()`，这便是它实现线程切换的原理。
+
+
+更多内容请看下一篇文章[RxJava详解(七)][1]
+
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/7.RxJava%E7%B3%BB%E5%88%97%E5%85%A8%E5%AE%B6%E6%A1%B6.md "RxJava全家桶"
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/RxJavaPart/7.RxJava\347\263\273\345\210\227\345\205\250\345\256\266\346\241\266.md" "b/RxJavaPart/7.RxJava\347\263\273\345\210\227\345\205\250\345\256\266\346\241\266.md"
new file mode 100644
index 00000000..bd645c2f
--- /dev/null
+++ "b/RxJavaPart/7.RxJava\347\263\273\345\210\227\345\205\250\345\256\266\346\241\266.md"
@@ -0,0 +1,67 @@
+`RxJava Android`开发全系列
+===
+
+有关`RxJava`的介绍请看[RxJava详解系列][1]
+
+要说16年`android`开发中要说那个应用最流行，那就是`RxJava`了，现在越来越多的`android`项目都会用到`RxJava`，下面就介绍一些`RxJava`必备的扩张库。 
+
+`RxAndroid`
+---
+
+[RxAndroid](https://github.com/ReactiveX/RxAndroid)
+
+> Android specific bindings for RxJava.
+
+> This module adds the minimum classes to RxJava that make writing reactive components in Android applications easy and hassle-free. More specifically, it provides a Scheduler that schedules on the main thread or any given Looper.
+
+`Android`中使用`RxJava`的必备类库，虽然里面提供的内容并不多只有`AndroidSchedulers`、`HandlerScheduler`、`LooperScheduler`，但是这些确是`Android`开发中的精髓。 
+
+`RxLifecycle`
+---
+
+[RxLifecycle](https://github.com/trello/RxLifecycle)
+
+> The utilities provided here allow for automatic completion of sequences based on Activity or Fragment lifecycle events. This capability is useful in Android, where incomplete subscriptions can cause memory leaks.
+
+`RxLifecycle`提供了一些配合`Activity`、`Fragment`生命周期使用的订阅管理的相关功能。例如使用`RxJava`执行一些耗时的操作，但是在执行过程中，用户退出了当前`Activity`，这时如果`Observable`未取消订阅就会导致内存泄漏，而`RxLifecycle`就是为了接着这些问题的。在`Activity`销毁的时候`RxLifecycle`会自动取消订阅。   
+
+`RxBinding`
+---
+
+[RxBinding](https://github.com/JakeWharton/RxBinding)
+
+> RxJava binding APIs for Android UI widgets from the platform and support libraries.
+
+`RxBinding`是把`Android`中`UI`事件转换为`RxJava`的方式，例如点击时间，每次点击后`Observable`的订阅者`Observer`都会通过`onNext()`回调得知。  
+
+`Retrofit`
+---
+
+[Retrofit](https://github.com/square/retrofit)
+
+> Type-safe HTTP client for Android and Java by Square, Inc.
+
+良心企业`Square`出品的一个基于`OkHttp`的网络请求类库，完美支持`RxJava`。 
+
+`SqlBrite`
+---
+
+[SQLBrite](https://github.com/square/sqlbrite)
+
+> A lightweight wrapper around SQLiteOpenHelper and ContentResolver which introduces reactive stream semantics to queries.
+
+良心企业`Square`出品的一个支持`RxJava`的`Sqlite`数据库的操作库。 
+
+`RxPermissions`
+
+[RxPermissions)](https://github.com/tbruyelle/RxPermissions)
+
+> This library allows the usage of RxJava with the new Android M permission model.
+
+`Android M`上动态权限申请的类库。
+
+
+[1]: https://github.com/CharonChui/AndroidNote/tree/master/RxJavaPart "RxJava详解系列"
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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/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"
new file mode 100644
index 00000000..5750685e
--- /dev/null
+++ "b/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
@@ -0,0 +1,1509 @@
+Activity启动过程
+===
+
+前两天面试了天猫的开发，被问到了`Activity`启动过程，不懂啊....
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/app%20launch%20summary.jpg)
+
+
+今天就来分析一下，我们开启`Activity`主要有两种方式:    
+
+- 通过桌面图标启动，桌面就是`Launcher`,其实他也是一个应用程序，他也是继承`Activity`。
+- 在程序内部调用`startActivity()`开启。
+
+而`Launcher`点击图标其实也是调用了`Activity`的`startActivity()`方法，所以我们就从`startActivity()`方法入手了。     
+首先看一下`Activity`类中的`startActivity()`方法:    
+```java
+@Override
+public void startActivity(Intent intent) {
+	this.startActivity(intent, null);
+}
+```
+继续看`startActivity(intent, null)`:    
+```java
+/**
+ * Launch a new activity.  You will not receive any information about when
+ * the activity exits.  This implementation overrides the base version,
+ * providing information about
+ * the activity performing the launch.  Because of this additional
+ * information, the {@link Intent#FLAG_ACTIVITY_NEW_TASK} launch flag is not
+ * required; if not specified, the new activity will be added to the
+ * task of the caller.
+ *
+ * <p>This method throws {@link android.content.ActivityNotFoundException}
+ * if there was no Activity found to run the given Intent.
+ *
+ * @param intent The intent to start.
+ * @param options Additional options for how the Activity should be started.
+ * See {@link android.content.Context#startActivity(Intent, Bundle)
+ * Context.startActivity(Intent, Bundle)} for more details.
+ *
+ * @throws android.content.ActivityNotFoundException
+ *
+ * @see {@link #startActivity(Intent)}
+ * @see #startActivityForResult
+ */
+@Override
+public void startActivity(Intent intent, @Nullable Bundle options) {
+	if (options != null) {
+		startActivityForResult(intent, -1, options);
+	} else {
+		// Note we want to go through this call for compatibility with
+		// applications that may have overridden the method.
+		startActivityForResult(intent, -1);
+	}
+}
+```
+接下来会调用`startActivityForResult()`方法(注释也很重要啊，里面也说明了singleTask启动模式时该方法不会走到回调中):     
+```java
+/**
+ * Launch an activity for which you would like a result when it finished.
+ * When this activity exits, your
+ * onActivityResult() method will be called with the given requestCode.
+ * Using a negative requestCode is the same as calling
+ * {@link #startActivity} (the activity is not launched as a sub-activity).
+ *
+ * <p>Note that this method should only be used with Intent protocols
+ * that are defined to return a result.  In other protocols (such as
+ * {@link Intent#ACTION_MAIN} or {@link Intent#ACTION_VIEW}), you may
+ * not get the result when you expect.  For example, if the activity you
+ * are launching uses the singleTask launch mode, it will not run in your
+ * task and thus you will immediately receive a cancel result.
+ *
+ * <p>As a special case, if you call startActivityForResult() with a requestCode
+ * >= 0 during the initial onCreate(Bundle savedInstanceState)/onResume() of your
+ * activity, then your window will not be displayed until a result is
+ * returned back from the started activity.  This is to avoid visible
+ * flickering when redirecting to another activity.
+ *
+ * <p>This method throws {@link android.content.ActivityNotFoundException}
+ * if there was no Activity found to run the given Intent.
+ *
+ * @param intent The intent to start.
+ * @param requestCode If >= 0, this code will be returned in
+ *                    onActivityResult() when the activity exits.
+ * @param options Additional options for how the Activity should be started.
+ * See {@link android.content.Context#startActivity(Intent, Bundle)
+ * Context.startActivity(Intent, Bundle)} for more details.
+ *
+ * @throws android.content.ActivityNotFoundException
+ *
+ * @see #startActivity
+ */
+public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
+	// mParent也是Activity类，通过名字就能看明白了。
+	if (mParent == null) {
+		// 开始了啊
+		Instrumentation.ActivityResult ar =
+			mInstrumentation.execStartActivity(
+				this, mMainThread.getApplicationThread(), mToken, this,
+				intent, requestCode, options);
+		if (ar != null) {
+			mMainThread.sendActivityResult(
+				mToken, mEmbeddedID, requestCode, ar.getResultCode(),
+				ar.getResultData());
+		}
+		if (requestCode >= 0) {
+			// If this start is requesting a result, we can avoid making
+			// the activity visible until the result is received.  Setting
+			// this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
+			// activity hidden during this time, to avoid flickering.
+			// This can only be done when a result is requested because
+			// that guarantees we will get information back when the
+			// activity is finished, no matter what happens to it.
+			mStartedActivity = true;
+		}
+
+		cancelInputsAndStartExitTransition(options);
+		// TODO Consider clearing/flushing other event sources and events for child windows.
+	} else {
+		if (options != null) {
+			mParent.startActivityFromChild(this, intent, requestCode, options);
+		} else {
+			// Note we want to go through this method for compatibility with
+			// existing applications that may have overridden it.
+			mParent.startActivityFromChild(this, intent, requestCode);
+		}
+	}
+}
+```
+里面调用了`mInstrumentation.execStartActivity`这是啥玩意，先看一下`mInstrumentation`属性，他是`Instrumentation`类，我们看下文档
+```java
+/**
+ * Base class for implementing application instrumentation code.  When running
+ * with instrumentation turned on, this class will be instantiated for you
+ * before any of the application code, allowing you to monitor all of the
+ * interaction the system has with the application.  An Instrumentation
+ * implementation is described to the system through an AndroidManifest.xml's
+ * &lt;instrumentation&gt; tag.
+ */
+public class Instrumentation {
+	...
+}
+```
+放狗查了下`Instrumentation`的意思是仪器、工具、装置的意思。我就大体翻一下:该类是实现应用程序代码的基类，当该在启动的状态下运行时，该类会在其他任何应用程序运行前进行初始化，允许你监视所有应用程序与系统的交互。一个`Instrumentation`实例会通过`Manifest`文件中的`<instrumenttation`标签描述给系统。        
+所以继续看一下`mInstrumentation.execStartActivity()`:       
+```java
+/**
+   // 下面的注释说的很明白了默认实现会更新任何活跃的对象并分发给系统的`activity manager`
+ * Execute a startActivity call made by the application.  The default 
+ * implementation takes care of updating any active {@link ActivityMonitor}
+ * objects and dispatches this call to the system activity manager; you can
+ * override this to watch for the application to start an activity, and 
+ * modify what happens when it does. 
+ *
+ * <p>This method returns an {@link ActivityResult} object, which you can 
+ * use when intercepting application calls to avoid performing the start 
+ * activity action but still return the result the application is 
+ * expecting.  To do this, override this method to catch the call to start 
+ * activity so that it returns a new ActivityResult containing the results 
+ * you would like the application to see, and don't call up to the super 
+ * class.  Note that an application is only expecting a result if 
+ * <var>requestCode</var> is &gt;= 0.
+ *
+ * <p>This method throws {@link android.content.ActivityNotFoundException}
+ * if there was no Activity found to run the given Intent.
+ *
+ * @param who The Context from which the activity is being started.
+ * @param contextThread The main thread of the Context from which the activity
+ *                      is being started.
+ * @param token Internal token identifying to the system who is starting 
+ *              the activity; may be null.
+ * @param target Which activity is performing the start (and thus receiving 
+ *               any result); may be null if this call is not being made
+ *               from an activity.
+ * @param intent The actual Intent to start.
+ * @param requestCode Identifier for this request's result; less than zero 
+ *                    if the caller is not expecting a result.
+ * @param options Addition options.
+ *
+ * @return To force the return of a particular result, return an 
+ *         ActivityResult object containing the desired data; otherwise
+ *         return null.  The default implementation always returns null.
+ *
+ * @throws android.content.ActivityNotFoundException
+ *
+ * @see Activity#startActivity(Intent)
+ * @see Activity#startActivityForResult(Intent, int)
+ * @see Activity#startActivityFromChild
+ *
+ * {@hide}
+ */
+public ActivityResult execStartActivity(
+		Context who, IBinder contextThread, IBinder token, Activity target,
+		Intent intent, int requestCode, Bundle options) {
+	IApplicationThread whoThread = (IApplicationThread) contextThread;
+	Uri referrer = target != null ? target.onProvideReferrer() : null;
+	if (referrer != null) {
+		intent.putExtra(Intent.EXTRA_REFERRER, referrer);
+	}
+	if (mActivityMonitors != null) {
+		synchronized (mSync) {
+			final int N = mActivityMonitors.size();
+			for (int i=0; i<N; i++) {
+				final ActivityMonitor am = mActivityMonitors.get(i);
+				if (am.match(who, null, intent)) {
+					am.mHits++;
+					if (am.isBlocking()) {
+						return requestCode >= 0 ? am.getResult() : null;
+					}
+					break;
+				}
+			}
+		}
+	}
+	try {
+		intent.migrateExtraStreamToClipData();
+		intent.prepareToLeaveProcess();
+		// 通过注释然后再结合代码一看我们就知道这应该就是分发到系统activity manager的过程
+		int result = ActivityManagerNative.getDefault()
+			.startActivity(whoThread, who.getBasePackageName(), intent,
+					intent.resolveTypeIfNeeded(who.getContentResolver()),
+					token, target != null ? target.mEmbeddedID : null,
+					requestCode, 0, null, options);
+		checkStartActivityResult(result, intent);
+	} catch (RemoteException e) {
+		throw new RuntimeException("Failure from system", e);
+	}
+	return null;
+}
+```
+那就直接看下`ActivityManagerNative.getDefault().startActivity()`方法，看之前我们先看看`ActivityManagerNative.getDefault()`是什么鬼:     
+```java
+/**
+ * Retrieve the system's default/global activity manager.
+ */
+static public IActivityManager getDefault() {
+	return gDefault.get();
+}
+```
+注释说的明白的就是拿到系统默认/全局的`activity manager`，通过名字也能看出来`IActivityManager`是个接口，那就继续看`IActivityManager.startActivity()`方法吧:     
+```java
+public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
+            String resolvedType, IBinder resultTo, String resultWho, int requestCode, int flags,
+            ProfilerInfo profilerInfo, Bundle options) throws RemoteException;
+```
+这里就顺便看一下`IActivityManager`接口是神马鬼：  
+```
+/**
+ * System private API for talking with the activity manager service.  This
+ * provides calls from the application back to the activity manager.
+ *
+ * {@hide}
+ */
+public interface IActivityManager extends IInterface {
+	...
+}
+```
+但是看到这里我不知道怎么继续往下分析了啊，既然是接口我们要找到实现类啊，又是通过`ActivityManagerNative.getDefault()`得到的`IActivityManager`实例，
+所以这里我们再看下`ActivityManagerNative`类。
+```java
+/** {@hide} */
+public abstract class ActivityManagerNative extends Binder implements IActivityManager {
+	...
+}
+```
+啊！ 隐藏的，连个注释也没有，我拖动了下这个类一看`5992`行，不知道从哪下手了，还能从哪下手啊，当然是从`ActivityManagerNative.getDefault()`方法啊
+```java
+public abstract class ActivityManagerNative extends Binder implements IActivityManager {
+
+	// 继承Binder接口，而且asInterFace方法，我好想明白了点什么
+    /**
+     * Cast a Binder object into an activity manager interface, generating
+     * a proxy if needed.
+     */
+    static public IActivityManager asInterface(IBinder obj) {
+        if (obj == null) {
+            return null;
+        }
+        IActivityManager in =
+            (IActivityManager)obj.queryLocalInterface(descriptor);
+        if (in != null) {
+            return in;
+        }
+		
+        return new ActivityManagerProxy(obj);
+    }
+
+    /**
+     * Retrieve the system's default/global activity manager.
+     */
+    static public IActivityManager getDefault() {
+		// 使用了getDefaule的get方法
+        return gDefault.get();
+    }
+	....
+}	
+```
+继续看：　　
+```java
+private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
+	protected IActivityManager create() {
+	    // 进程间通信了
+		IBinder b = ServiceManager.getService("activity");
+		if (false) {
+			Log.v("ActivityManager", "default service binder = " + b);
+		}
+		// 看到了吗？用到了刚才我们说的asInterface方法
+		IActivityManager am = asInterface(b);
+		if (false) {
+			Log.v("ActivityManager", "default service = " + am);
+		}
+		return am;
+	}
+};
+```
+好了，我们再看下`asInterface()`方法:　　　　
+```java
+static public IActivityManager asInterface(IBinder obj) {
+	if (obj == null) {
+		return null;
+	}
+	IActivityManager in =
+		(IActivityManager)obj.queryLocalInterface(descriptor);
+	if (in != null) {
+		return in;
+	}
+	// 在这里
+	return new ActivityManagerProxy(obj);
+}
+```
+终于找到了其实就是`ActivityManagerProxy`类，刚才我们找到`IActivityManager`接口的`startActivity()` 方法，现在终于找到了在这里使用的是`IActivityManager`接口实现类的
+`ActivityManagerProxy`类，我们来看一下该类实现的`startActivity()`方法:     
+```java
+class ActivityManagerProxy implements IActivityManager
+{
+    public ActivityManagerProxy(IBinder remote)
+    {
+        mRemote = remote;
+    }
+
+    public IBinder asBinder()
+    {
+        return mRemote;
+    }
+	public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
+			String resolvedType, IBinder resultTo, String resultWho, int requestCode,
+			int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
+		Parcel data = Parcel.obtain();
+		Parcel reply = Parcel.obtain();
+		data.writeInterfaceToken(IActivityManager.descriptor);
+		data.writeStrongBinder(caller != null ? caller.asBinder() : null);
+		data.writeString(callingPackage);
+		intent.writeToParcel(data, 0);
+		data.writeString(resolvedType);
+		data.writeStrongBinder(resultTo);
+		data.writeString(resultWho);
+		data.writeInt(requestCode);
+		data.writeInt(startFlags);
+		if (profilerInfo != null) {
+			data.writeInt(1);
+			profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
+		} else {
+			data.writeInt(0);
+		}
+		if (options != null) {
+			data.writeInt(1);
+			options.writeToParcel(data, 0);
+		} else {
+			data.writeInt(0);
+		}
+		mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
+		reply.readException();
+		int result = reply.readInt();
+		reply.recycle();
+		data.recycle();
+		return result;
+	}
+	...
+}	
+```
+再继续我就不知道走到哪里了....
+这一块其实是用了`Binder`机制，上面的`IActivityManager.getDefault()`方法返回的是`ActivityManagerService`的远程接口，所以接下来
+我们应该看一下`ActivityManagerService.startActivity()`类。(具体`Binder`机制我们后续会专门写一篇文章，这里就不说了，不然就说不完了)
+```java
+@Override
+public final int startActivity(IApplicationThread caller, String callingPackage,
+		Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
+		int startFlags, ProfilerInfo profilerInfo, Bundle options) {
+	return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
+		resultWho, requestCode, startFlags, profilerInfo, options,
+		UserHandle.getCallingUserId());
+}
+```
+继续看下`startActivityAsUser()`方法:    
+```java
+@Override
+public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
+		Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
+		int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) {
+	enforceNotIsolatedCaller("startActivity");
+	userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
+			false, ALLOW_FULL_ONLY, "startActivity", null);
+	// TODO: Switch to user app stacks here.
+	return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,
+			resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
+			profilerInfo, null, null, options, false, userId, null, null);
+}
+```
+继续看一下`mStackSupervisor.startActivityMayWait()`方法,这里`mStackSupervisor`是`ActivityStackSupervisor`类:       
+```java
+final int startActivityMayWait(IApplicationThread caller, int callingUid,
+		String callingPackage, Intent intent, String resolvedType,
+		IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
+		IBinder resultTo, String resultWho, int requestCode, int startFlags,
+		ProfilerInfo profilerInfo, WaitResult outResult, Configuration config,
+		Bundle options, boolean ignoreTargetSecurity, int userId,
+		IActivityContainer iContainer, TaskRecord inTask) {
+	// Refuse possible leaked file descriptors
+	if (intent != null && intent.hasFileDescriptors()) {
+		throw new IllegalArgumentException("File descriptors passed in Intent");
+	}
+	boolean componentSpecified = intent.getComponent() != null;
+
+	// Don't modify the client's object!
+	intent = new Intent(intent);
+
+	// 解析出要开启的Activity的信息，包名、类名、参数等。
+	// Collect information about the target of the Intent.
+	ActivityInfo aInfo =
+			resolveActivity(intent, resolvedType, startFlags, profilerInfo, userId);
+
+	ActivityContainer container = (ActivityContainer)iContainer;
+	synchronized (mService) {
+		if (container != null && container.mParentActivity != null &&
+				container.mParentActivity.state != RESUMED) {
+			// Cannot start a child activity if the parent is not resumed.
+			return ActivityManager.START_CANCELED;
+		}
+		final int realCallingPid = Binder.getCallingPid();
+		final int realCallingUid = Binder.getCallingUid();
+		int callingPid;
+		if (callingUid >= 0) {
+			callingPid = -1;
+		} else if (caller == null) {
+			callingPid = realCallingPid;
+			callingUid = realCallingUid;
+		} else {
+			callingPid = callingUid = -1;
+		}
+
+		final ActivityStack stack;
+		if (container == null || container.mStack.isOnHomeDisplay()) {
+			stack = mFocusedStack;
+		} else {
+			stack = container.mStack;
+		}
+		stack.mConfigWillChange = config != null && mService.mConfiguration.diff(config) != 0;
+		if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+				"Starting activity when config will change = " + stack.mConfigWillChange);
+
+		final long origId = Binder.clearCallingIdentity();
+
+		if (aInfo != null &&
+				(aInfo.applicationInfo.privateFlags
+						&ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {
+			// This may be a heavy-weight process!  Check to see if we already
+			// have another, different heavy-weight process running.
+			if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) {
+				if (mService.mHeavyWeightProcess != null &&
+						(mService.mHeavyWeightProcess.info.uid != aInfo.applicationInfo.uid ||
+						!mService.mHeavyWeightProcess.processName.equals(aInfo.processName))) {
+					int appCallingUid = callingUid;
+					if (caller != null) {
+						ProcessRecord callerApp = mService.getRecordForAppLocked(caller);
+						if (callerApp != null) {
+							appCallingUid = callerApp.info.uid;
+						} else {
+							Slog.w(TAG, "Unable to find app for caller " + caller
+								  + " (pid=" + callingPid + ") when starting: "
+								  + intent.toString());
+							ActivityOptions.abort(options);
+							return ActivityManager.START_PERMISSION_DENIED;
+						}
+					}
+
+					IIntentSender target = mService.getIntentSenderLocked(
+							ActivityManager.INTENT_SENDER_ACTIVITY, "android",
+							appCallingUid, userId, null, null, 0, new Intent[] { intent },
+							new String[] { resolvedType }, PendingIntent.FLAG_CANCEL_CURRENT
+							| PendingIntent.FLAG_ONE_SHOT, null);
+
+					Intent newIntent = new Intent();
+					if (requestCode >= 0) {
+						// Caller is requesting a result.
+						newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_HAS_RESULT, true);
+					}
+					newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_INTENT,
+							new IntentSender(target));
+					if (mService.mHeavyWeightProcess.activities.size() > 0) {
+						ActivityRecord hist = mService.mHeavyWeightProcess.activities.get(0);
+						newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_APP,
+								hist.packageName);
+						newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_TASK,
+								hist.task.taskId);
+					}
+					newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_NEW_APP,
+							aInfo.packageName);
+					newIntent.setFlags(intent.getFlags());
+					newIntent.setClassName("android",
+							HeavyWeightSwitcherActivity.class.getName());
+					intent = newIntent;
+					resolvedType = null;
+					caller = null;
+					callingUid = Binder.getCallingUid();
+					callingPid = Binder.getCallingPid();
+					componentSpecified = true;
+					try {
+						ResolveInfo rInfo =
+							AppGlobals.getPackageManager().resolveIntent(
+									intent, null,
+									PackageManager.MATCH_DEFAULT_ONLY
+									| ActivityManagerService.STOCK_PM_FLAGS, userId);
+						aInfo = rInfo != null ? rInfo.activityInfo : null;
+						aInfo = mService.getActivityInfoForUser(aInfo, userId);
+					} catch (RemoteException e) {
+						aInfo = null;
+					}
+				}
+			}
+		}
+		// 根据上面解析的内容去开启了。。。
+		int res = startActivityLocked(caller, intent, resolvedType, aInfo,
+				voiceSession, voiceInteractor, resultTo, resultWho,
+				requestCode, callingPid, callingUid, callingPackage,
+				realCallingPid, realCallingUid, startFlags, options, ignoreTargetSecurity,
+				componentSpecified, null, container, inTask);
+
+		Binder.restoreCallingIdentity(origId);
+
+		if (stack.mConfigWillChange) {
+			// If the caller also wants to switch to a new configuration,
+			// do so now.  This allows a clean switch, as we are waiting
+			// for the current activity to pause (so we will not destroy
+			// it), and have not yet started the next activity.
+			mService.enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION,
+					"updateConfiguration()");
+			stack.mConfigWillChange = false;
+			if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+					"Updating to new configuration after starting activity.");
+			mService.updateConfigurationLocked(config, null, false, false);
+		}
+
+		if (outResult != null) {
+			outResult.result = res;
+			if (res == ActivityManager.START_SUCCESS) {
+				mWaitingActivityLaunched.add(outResult);
+				do {
+					try {
+						mService.wait();
+					} catch (InterruptedException e) {
+					}
+				} while (!outResult.timeout && outResult.who == null);
+			} else if (res == ActivityManager.START_TASK_TO_FRONT) {
+				ActivityRecord r = stack.topRunningActivityLocked(null);
+				if (r.nowVisible && r.state == RESUMED) {
+					outResult.timeout = false;
+					outResult.who = new ComponentName(r.info.packageName, r.info.name);
+					outResult.totalTime = 0;
+					outResult.thisTime = 0;
+				} else {
+					outResult.thisTime = SystemClock.uptimeMillis();
+					mWaitingActivityVisible.add(outResult);
+					do {
+						try {
+							mService.wait();
+						} catch (InterruptedException e) {
+						}
+					} while (!outResult.timeout && outResult.who == null);
+				}
+			}
+		}
+
+		return res;
+	}
+}
+```
+那就继续看一下`startActivityLocked()`方法:        
+```java
+final int startActivityLocked(IApplicationThread caller,
+		Intent intent, String resolvedType, ActivityInfo aInfo,
+		IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
+		IBinder resultTo, String resultWho, int requestCode,
+		int callingPid, int callingUid, String callingPackage,
+		int realCallingPid, int realCallingUid, int startFlags, Bundle options,
+		boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
+		ActivityContainer container, TaskRecord inTask) {
+	int err = ActivityManager.START_SUCCESS;
+
+	ProcessRecord callerApp = null;
+	if (caller != null) {
+		// mService就是ActivityManagerService类
+		callerApp = mService.getRecordForAppLocked(caller);
+		if (callerApp != null) {
+			callingPid = callerApp.pid;
+			callingUid = callerApp.info.uid;
+		} else {
+			Slog.w(TAG, "Unable to find app for caller " + caller
+				  + " (pid=" + callingPid + ") when starting: "
+				  + intent.toString());
+			err = ActivityManager.START_PERMISSION_DENIED;
+		}
+	}
+
+	final int userId = aInfo != null ? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;
+
+	if (err == ActivityManager.START_SUCCESS) {
+		Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true, true, false)
+				+ "} from uid " + callingUid
+				+ " on display " + (container == null ? (mFocusedStack == null ?
+						Display.DEFAULT_DISPLAY : mFocusedStack.mDisplayId) :
+						(container.mActivityDisplay == null ? Display.DEFAULT_DISPLAY :
+								container.mActivityDisplay.mDisplayId)));
+	}
+
+	ActivityRecord sourceRecord = null;
+	ActivityRecord resultRecord = null;
+	if (resultTo != null) {
+		sourceRecord = isInAnyStackLocked(resultTo);
+		if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
+				"Will send result to " + resultTo + " " + sourceRecord);
+		if (sourceRecord != null) {
+			if (requestCode >= 0 && !sourceRecord.finishing) {
+				resultRecord = sourceRecord;
+			}
+		}
+	}
+
+	final int launchFlags = intent.getFlags();
+
+	if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
+		// Transfer the result target from the source activity to the new
+		// one being started, including any failures.
+		if (requestCode >= 0) {
+			ActivityOptions.abort(options);
+			return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
+		}
+		resultRecord = sourceRecord.resultTo;
+		if (resultRecord != null && !resultRecord.isInStackLocked()) {
+			resultRecord = null;
+		}
+		resultWho = sourceRecord.resultWho;
+		requestCode = sourceRecord.requestCode;
+		sourceRecord.resultTo = null;
+		if (resultRecord != null) {
+			resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode);
+		}
+		if (sourceRecord.launchedFromUid == callingUid) {
+			// The new activity is being launched from the same uid as the previous
+			// activity in the flow, and asking to forward its result back to the
+			// previous.  In this case the activity is serving as a trampoline between
+			// the two, so we also want to update its launchedFromPackage to be the
+			// same as the previous activity.  Note that this is safe, since we know
+			// these two packages come from the same uid; the caller could just as
+			// well have supplied that same package name itself.  This specifially
+			// deals with the case of an intent picker/chooser being launched in the app
+			// flow to redirect to an activity picked by the user, where we want the final
+			// activity to consider it to have been launched by the previous app activity.
+			callingPackage = sourceRecord.launchedFromPackage;
+		}
+	}
+
+	if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
+		// We couldn't find a class that can handle the given Intent.
+		// That's the end of that!
+		err = ActivityManager.START_INTENT_NOT_RESOLVED;
+	}
+
+	if (err == ActivityManager.START_SUCCESS && aInfo == null) {
+		// We couldn't find the specific class specified in the Intent.
+		// Also the end of the line.
+		err = ActivityManager.START_CLASS_NOT_FOUND;
+	}
+
+	if (err == ActivityManager.START_SUCCESS
+			&& !isCurrentProfileLocked(userId)
+			&& (aInfo.flags & FLAG_SHOW_FOR_ALL_USERS) == 0) {
+		// Trying to launch a background activity that doesn't show for all users.
+		err = ActivityManager.START_NOT_CURRENT_USER_ACTIVITY;
+	}
+
+	if (err == ActivityManager.START_SUCCESS && sourceRecord != null
+			&& sourceRecord.task.voiceSession != null) {
+		// If this activity is being launched as part of a voice session, we need
+		// to ensure that it is safe to do so.  If the upcoming activity will also
+		// be part of the voice session, we can only launch it if it has explicitly
+		// said it supports the VOICE category, or it is a part of the calling app.
+		if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0
+				&& sourceRecord.info.applicationInfo.uid != aInfo.applicationInfo.uid) {
+			try {
+				intent.addCategory(Intent.CATEGORY_VOICE);
+				if (!AppGlobals.getPackageManager().activitySupportsIntent(
+						intent.getComponent(), intent, resolvedType)) {
+					Slog.w(TAG,
+							"Activity being started in current voice task does not support voice: "
+							+ intent);
+					err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
+				}
+			} catch (RemoteException e) {
+				Slog.w(TAG, "Failure checking voice capabilities", e);
+				err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
+			}
+		}
+	}
+
+	if (err == ActivityManager.START_SUCCESS && voiceSession != null) {
+		// If the caller is starting a new voice session, just make sure the target
+		// is actually allowing it to run this way.
+		try {
+			if (!AppGlobals.getPackageManager().activitySupportsIntent(intent.getComponent(),
+					intent, resolvedType)) {
+				Slog.w(TAG,
+						"Activity being started in new voice task does not support: "
+						+ intent);
+				err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
+			}
+		} catch (RemoteException e) {
+			Slog.w(TAG, "Failure checking voice capabilities", e);
+			err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
+		}
+	}
+	// Activity栈
+	final ActivityStack resultStack = resultRecord == null ? null : resultRecord.task.stack;
+
+	if (err != ActivityManager.START_SUCCESS) {
+		if (resultRecord != null) {
+			resultStack.sendActivityResultLocked(-1,
+				resultRecord, resultWho, requestCode,
+				Activity.RESULT_CANCELED, null);
+		}
+		ActivityOptions.abort(options);
+		return err;
+	}
+
+	boolean abort = false;
+
+	final int startAnyPerm = mService.checkPermission(
+			START_ANY_ACTIVITY, callingPid, callingUid);
+
+	if (startAnyPerm != PERMISSION_GRANTED) {
+		final int componentRestriction = getComponentRestrictionForCallingPackage(
+				aInfo, callingPackage, callingPid, callingUid, ignoreTargetSecurity);
+		final int actionRestriction = getActionRestrictionForCallingPackage(
+				intent.getAction(), callingPackage, callingPid, callingUid);
+
+		if (componentRestriction == ACTIVITY_RESTRICTION_PERMISSION
+				|| actionRestriction == ACTIVITY_RESTRICTION_PERMISSION) {
+			if (resultRecord != null) {
+				resultStack.sendActivityResultLocked(-1,
+						resultRecord, resultWho, requestCode,
+						Activity.RESULT_CANCELED, null);
+			}
+			String msg;
+			if (actionRestriction == ACTIVITY_RESTRICTION_PERMISSION) {
+				msg = "Permission Denial: starting " + intent.toString()
+						+ " from " + callerApp + " (pid=" + callingPid
+						+ ", uid=" + callingUid + ")" + " with revoked permission "
+						+ ACTION_TO_RUNTIME_PERMISSION.get(intent.getAction());
+			} else if (!aInfo.exported) {
+				msg = "Permission Denial: starting " + intent.toString()
+						+ " from " + callerApp + " (pid=" + callingPid
+						+ ", uid=" + callingUid + ")"
+						+ " not exported from uid " + aInfo.applicationInfo.uid;
+			} else {
+				msg = "Permission Denial: starting " + intent.toString()
+						+ " from " + callerApp + " (pid=" + callingPid
+						+ ", uid=" + callingUid + ")"
+						+ " requires " + aInfo.permission;
+			}
+			Slog.w(TAG, msg);
+			throw new SecurityException(msg);
+		}
+
+		if (actionRestriction == ACTIVITY_RESTRICTION_APPOP) {
+			String message = "Appop Denial: starting " + intent.toString()
+					+ " from " + callerApp + " (pid=" + callingPid
+					+ ", uid=" + callingUid + ")"
+					+ " requires " + AppOpsManager.permissionToOp(
+							ACTION_TO_RUNTIME_PERMISSION.get(intent.getAction()));
+			Slog.w(TAG, message);
+			abort = true;
+		} else if (componentRestriction == ACTIVITY_RESTRICTION_APPOP) {
+			String message = "Appop Denial: starting " + intent.toString()
+					+ " from " + callerApp + " (pid=" + callingPid
+					+ ", uid=" + callingUid + ")"
+					+ " requires appop " + AppOpsManager.permissionToOp(aInfo.permission);
+			Slog.w(TAG, message);
+			abort = true;
+		}
+	}
+
+	abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
+			callingPid, resolvedType, aInfo.applicationInfo);
+
+	if (mService.mController != null) {
+		try {
+			// The Intent we give to the watcher has the extra data
+			// stripped off, since it can contain private information.
+			Intent watchIntent = intent.cloneFilter();
+			abort |= !mService.mController.activityStarting(watchIntent,
+					aInfo.applicationInfo.packageName);
+		} catch (RemoteException e) {
+			mService.mController = null;
+		}
+	}
+
+	if (abort) {
+		if (resultRecord != null) {
+			resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode,
+					Activity.RESULT_CANCELED, null);
+		}
+		// We pretend to the caller that it was really started, but
+		// they will just get a cancel result.
+		ActivityOptions.abort(options);
+		return ActivityManager.START_SUCCESS;
+	}
+	// ActivityRecord: An entry in the history stack, representing an activity.
+	ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
+			intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
+			requestCode, componentSpecified, voiceSession != null, this, container, options);
+	if (outActivity != null) {
+		outActivity[0] = r;
+	}
+
+	if (r.appTimeTracker == null && sourceRecord != null) {
+		// If the caller didn't specify an explicit time tracker, we want to continue
+		// tracking under any it has.
+		r.appTimeTracker = sourceRecord.appTimeTracker;
+	}
+
+	final ActivityStack stack = mFocusedStack;
+	if (voiceSession == null && (stack.mResumedActivity == null
+			|| stack.mResumedActivity.info.applicationInfo.uid != callingUid)) {
+		if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid,
+				realCallingPid, realCallingUid, "Activity start")) {
+			PendingActivityLaunch pal =
+					new PendingActivityLaunch(r, sourceRecord, startFlags, stack);
+			mPendingActivityLaunches.add(pal);
+			ActivityOptions.abort(options);
+			return ActivityManager.START_SWITCHES_CANCELED;
+		}
+	}
+
+	if (mService.mDidAppSwitch) {
+		// This is the second allowed switch since we stopped switches,
+		// so now just generally allow switches.  Use case: user presses
+		// home (switches disabled, switch to home, mDidAppSwitch now true);
+		// user taps a home icon (coming from home so allowed, we hit here
+		// and now allow anyone to switch again).
+		mService.mAppSwitchesAllowedTime = 0;
+	} else {
+		mService.mDidAppSwitch = true;
+	}
+
+	doPendingActivityLaunchesLocked(false);
+	// 继续调用方法
+	err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,
+			startFlags, true, options, inTask);
+
+	if (err < 0) {
+		// If someone asked to have the keyguard dismissed on the next
+		// activity start, but we are not actually doing an activity
+		// switch...  just dismiss the keyguard now, because we
+		// probably want to see whatever is behind it.
+		notifyActivityDrawnForKeyguard();
+	}
+	return err;
+}
+```
+再继续看`startActivityUncheckedLocked`方法：　　　　
+```java
+final int startActivityUncheckedLocked(final ActivityRecord r, ActivityRecord sourceRecord,
+		IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags,
+		boolean doResume, Bundle options, TaskRecord inTask) {
+	final Intent intent = r.intent;
+	final int callingUid = r.launchedFromUid;
+
+	// In some flows in to this function, we retrieve the task record and hold on to it
+	// without a lock before calling back in to here...  so the task at this point may
+	// not actually be in recents.  Check for that, and if it isn't in recents just
+	// consider it invalid.
+	if (inTask != null && !inTask.inRecents) {
+		Slog.w(TAG, "Starting activity in task not in recents: " + inTask);
+		inTask = null;
+	}
+
+	// 判断不同的启动模式
+	final boolean launchSingleTop = r.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP;
+	final boolean launchSingleInstance = r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE;
+	final boolean launchSingleTask = r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK;
+
+	.....
+
+	// We may want to try to place the new activity in to an existing task.  We always
+	// do this if the target activity is singleTask or singleInstance; we will also do
+	// this if NEW_TASK has been requested, and there is not an additional qualifier telling
+	// us to still place it in a new task: multi task, always doc mode, or being asked to
+	// launch this as a new task behind the current one.
+	if (((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&
+			(launchFlags & Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
+			|| launchSingleInstance || launchSingleTask) {
+		// If bring to front is requested, and no result is requested and we have not
+		// been given an explicit task to launch in to, and
+		// we can find a task that was started with this same
+		// component, then instead of launching bring that one to the front.
+		if (inTask == null && r.resultTo == null) {
+			// See if there is a task to bring to the front.  If this is
+			// a SINGLE_INSTANCE activity, there can be one and only one
+			// instance of it in the history, and it is always in its own
+			// unique task, so we do a special search.
+			ActivityRecord intentActivity = !launchSingleInstance ?
+					findTaskLocked(r) : findActivityLocked(intent, r.info);
+			if (intentActivity != null) {
+				// When the flags NEW_TASK and CLEAR_TASK are set, then the task gets reused
+				// but still needs to be a lock task mode violation since the task gets
+				// cleared out and the device would otherwise leave the locked task.
+				if (isLockTaskModeViolation(intentActivity.task,
+						(launchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))
+						== (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))) {
+					showLockTaskToast();
+					Slog.e(TAG, "startActivityUnchecked: Attempt to violate Lock Task Mode");
+					return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
+				}
+				if (r.task == null) {
+					r.task = intentActivity.task;
+				}
+				if (intentActivity.task.intent == null) {
+					// This task was started because of movement of
+					// the activity based on affinity...  now that we
+					// are actually launching it, we can assign the
+					// base intent.
+					intentActivity.task.setIntent(r);
+				}
+				targetStack = intentActivity.task.stack;
+				targetStack.mLastPausedActivity = null;
+				// If the target task is not in the front, then we need
+				// to bring it to the front...  except...  well, with
+				// SINGLE_TASK_LAUNCH it's not entirely clear.  We'd like
+				// to have the same behavior as if a new instance was
+				// being started, which means not bringing it to the front
+				// if the caller is not itself in the front.
+				final ActivityStack focusStack = getFocusedStack();
+				ActivityRecord curTop = (focusStack == null)
+						? null : focusStack.topRunningNonDelayedActivityLocked(notTop);
+				boolean movedToFront = false;
+				if (curTop != null && (curTop.task != intentActivity.task ||
+						curTop.task != focusStack.topTask())) {
+					r.intent.addFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
+					if (sourceRecord == null || (sourceStack.topActivity() != null &&
+							sourceStack.topActivity().task == sourceRecord.task)) {
+						// We really do want to push this one into the user's face, right now.
+						if (launchTaskBehind && sourceRecord != null) {
+							intentActivity.setTaskToAffiliateWith(sourceRecord.task);
+						}
+						movedHome = true;
+						targetStack.moveTaskToFrontLocked(intentActivity.task, noAnimation,
+								options, r.appTimeTracker, "bringingFoundTaskToFront");
+						movedToFront = true;
+						if ((launchFlags &
+								(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME))
+								== (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME)) {
+							// Caller wants to appear on home activity.
+							intentActivity.task.setTaskToReturnTo(HOME_ACTIVITY_TYPE);
+						}
+						options = null;
+					}
+				}
+				if (!movedToFront) {
+					if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Bring to front target: " + targetStack
+							+ " from " + intentActivity);
+					targetStack.moveToFront("intentActivityFound");
+				}
+
+				// If the caller has requested that the target task be
+				// reset, then do so.
+				if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
+					intentActivity = targetStack.resetTaskIfNeededLocked(intentActivity, r);
+				}
+				if ((startFlags & ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {
+					// We don't need to start a new activity, and
+					// the client said not to do anything if that
+					// is the case, so this is it!  And for paranoia, make
+					// sure we have correctly resumed the top activity.
+					if (doResume) {
+						resumeTopActivitiesLocked(targetStack, null, options);
+
+						// Make sure to notify Keyguard as well if we are not running an app
+						// transition later.
+						if (!movedToFront) {
+							notifyActivityDrawnForKeyguard();
+						}
+					} else {
+						ActivityOptions.abort(options);
+					}
+					return ActivityManager.START_RETURN_INTENT_TO_CALLER;
+				}
+				if ((launchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))
+						== (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK)) {
+					// The caller has requested to completely replace any
+					// existing task with its new activity.  Well that should
+					// not be too hard...
+					reuseTask = intentActivity.task;
+					reuseTask.performClearTaskLocked();
+					reuseTask.setIntent(r);
+				} else if ((launchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0
+						|| launchSingleInstance || launchSingleTask) {
+					// In this situation we want to remove all activities
+					// from the task up to the one being started.  In most
+					// cases this means we are resetting the task to its
+					// initial state.
+					ActivityRecord top =
+							intentActivity.task.performClearTaskLocked(r, launchFlags);
+					if (top != null) {
+						if (top.frontOfTask) {
+							// Activity aliases may mean we use different
+							// intents for the top activity, so make sure
+							// the task now has the identity of the new
+							// intent.
+							top.task.setIntent(r);
+						}
+						ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT,
+								r, top.task);
+						top.deliverNewIntentLocked(callingUid, r.intent, r.launchedFromPackage);
+					} else {
+						// A special case: we need to start the activity because it is not
+						// currently running, and the caller has asked to clear the current
+						// task to have this activity at the top.
+						addingToTask = true;
+						// Now pretend like this activity is being started by the top of its
+						// task, so it is put in the right place.
+						sourceRecord = intentActivity;
+						TaskRecord task = sourceRecord.task;
+						if (task != null && task.stack == null) {
+							// Target stack got cleared when we all activities were removed
+							// above. Go ahead and reset it.
+							targetStack = computeStackFocus(sourceRecord, false /* newTask */);
+							targetStack.addTask(
+									task, !launchTaskBehind /* toTop */, false /* moving */);
+						}
+
+					}
+				} else if (r.realActivity.equals(intentActivity.task.realActivity)) {
+					// In this case the top activity on the task is the
+					// same as the one being launched, so we take that
+					// as a request to bring the task to the foreground.
+					// If the top activity in the task is the root
+					// activity, deliver this new intent to it if it
+					// desires.
+					if (((launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0 || launchSingleTop)
+							&& intentActivity.realActivity.equals(r.realActivity)) {
+						ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r,
+								intentActivity.task);
+						if (intentActivity.frontOfTask) {
+							intentActivity.task.setIntent(r);
+						}
+						intentActivity.deliverNewIntentLocked(callingUid, r.intent,
+								r.launchedFromPackage);
+					} else if (!r.intent.filterEquals(intentActivity.task.intent)) {
+						// In this case we are launching the root activity
+						// of the task, but with a different intent.  We
+						// should start a new instance on top.
+						addingToTask = true;
+						sourceRecord = intentActivity;
+					}
+				} else if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) == 0) {
+					// In this case an activity is being launched in to an
+					// existing task, without resetting that task.  This
+					// is typically the situation of launching an activity
+					// from a notification or shortcut.  We want to place
+					// the new activity on top of the current task.
+					addingToTask = true;
+					sourceRecord = intentActivity;
+				} else if (!intentActivity.task.rootWasReset) {
+					// In this case we are launching in to an existing task
+					// that has not yet been started from its front door.
+					// The current task has been brought to the front.
+					// Ideally, we'd probably like to place this new task
+					// at the bottom of its stack, but that's a little hard
+					// to do with the current organization of the code so
+					// for now we'll just drop it.
+					intentActivity.task.setIntent(r);
+				}
+				if (!addingToTask && reuseTask == null) {
+					// We didn't do anything...  but it was needed (a.k.a., client
+					// don't use that intent!)  And for paranoia, make
+					// sure we have correctly resumed the top activity.
+					if (doResume) {
+						targetStack.resumeTopActivityLocked(null, options);
+						if (!movedToFront) {
+							// Make sure to notify Keyguard as well if we are not running an app
+							// transition later.
+							notifyActivityDrawnForKeyguard();
+						}
+					} else {
+						ActivityOptions.abort(options);
+					}
+					return ActivityManager.START_TASK_TO_FRONT;
+				}
+			}
+		}
+	}
+
+	//String uri = r.intent.toURI();
+	//Intent intent2 = new Intent(uri);
+	//Slog.i(TAG, "Given intent: " + r.intent);
+	//Slog.i(TAG, "URI is: " + uri);
+	//Slog.i(TAG, "To intent: " + intent2);
+
+	if (r.packageName != null) {
+		// If the activity being launched is the same as the one currently
+		// at the top, then we need to check if it should only be launched
+		// once.
+		ActivityStack topStack = mFocusedStack;
+		ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(notTop);
+		if (top != null && r.resultTo == null) {
+			if (top.realActivity.equals(r.realActivity) && top.userId == r.userId) {
+				if (top.app != null && top.app.thread != null) {
+					if ((launchFlags & Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0
+						|| launchSingleTop || launchSingleTask) {
+						ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, top,
+								top.task);
+						// For paranoia, make sure we have correctly
+						// resumed the top activity.
+						topStack.mLastPausedActivity = null;
+						if (doResume) {
+							resumeTopActivitiesLocked();
+						}
+						ActivityOptions.abort(options);
+						if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {
+							// We don't need to start a new activity, and
+							// the client said not to do anything if that
+							// is the case, so this is it!
+							return ActivityManager.START_RETURN_INTENT_TO_CALLER;
+						}
+						top.deliverNewIntentLocked(callingUid, r.intent, r.launchedFromPackage);
+						return ActivityManager.START_DELIVERED_TO_TOP;
+					}
+				}
+			}
+		}
+
+	} else {
+		if (r.resultTo != null && r.resultTo.task.stack != null) {
+			r.resultTo.task.stack.sendActivityResultLocked(-1, r.resultTo, r.resultWho,
+					r.requestCode, Activity.RESULT_CANCELED, null);
+		}
+		ActivityOptions.abort(options);
+		return ActivityManager.START_CLASS_NOT_FOUND;
+	}
+
+	boolean newTask = false;
+	boolean keepCurTransition = false;
+
+	TaskRecord taskToAffiliate = launchTaskBehind && sourceRecord != null ?
+			sourceRecord.task : null;
+
+	// Should this be considered a new task?
+	if (r.resultTo == null && inTask == null && !addingToTask
+			&& (launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
+		newTask = true;
+		targetStack = computeStackFocus(r, newTask);
+		targetStack.moveToFront("startingNewTask");
+
+		if (reuseTask == null) {
+			r.setTask(targetStack.createTaskRecord(getNextTaskId(),
+					newTaskInfo != null ? newTaskInfo : r.info,
+					newTaskIntent != null ? newTaskIntent : intent,
+					voiceSession, voiceInteractor, !launchTaskBehind /* toTop */),
+					taskToAffiliate);
+			if (DEBUG_TASKS) Slog.v(TAG_TASKS,
+					"Starting new activity " + r + " in new task " + r.task);
+		} else {
+			r.setTask(reuseTask, taskToAffiliate);
+		}
+		if (isLockTaskModeViolation(r.task)) {
+			Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r);
+			return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
+		}
+		if (!movedHome) {
+			if ((launchFlags &
+					(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME))
+					== (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME)) {
+				// Caller wants to appear on home activity, so before starting
+				// their own activity we will bring home to the front.
+				r.task.setTaskToReturnTo(HOME_ACTIVITY_TYPE);
+			}
+		}
+	} else if (sourceRecord != null) {
+		final TaskRecord sourceTask = sourceRecord.task;
+		if (isLockTaskModeViolation(sourceTask)) {
+			Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r);
+			return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
+		}
+		targetStack = sourceTask.stack;
+		targetStack.moveToFront("sourceStackToFront");
+		final TaskRecord topTask = targetStack.topTask();
+		if (topTask != sourceTask) {
+			targetStack.moveTaskToFrontLocked(sourceTask, noAnimation, options,
+					r.appTimeTracker, "sourceTaskToFront");
+		}
+		if (!addingToTask && (launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) {
+			// In this case, we are adding the activity to an existing
+			// task, but the caller has asked to clear that task if the
+			// activity is already running.
+			ActivityRecord top = sourceTask.performClearTaskLocked(r, launchFlags);
+			keepCurTransition = true;
+			if (top != null) {
+				ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r, top.task);
+				top.deliverNewIntentLocked(callingUid, r.intent, r.launchedFromPackage);
+				// For paranoia, make sure we have correctly
+				// resumed the top activity.
+				targetStack.mLastPausedActivity = null;
+				if (doResume) {
+					targetStack.resumeTopActivityLocked(null);
+				}
+				ActivityOptions.abort(options);
+				return ActivityManager.START_DELIVERED_TO_TOP;
+			}
+		} else if (!addingToTask &&
+				(launchFlags&Intent.FLAG_ACTIVITY_REORDER_TO_FRONT) != 0) {
+			// In this case, we are launching an activity in our own task
+			// that may already be running somewhere in the history, and
+			// we want to shuffle it to the front of the stack if so.
+			final ActivityRecord top = sourceTask.findActivityInHistoryLocked(r);
+			if (top != null) {
+				final TaskRecord task = top.task;
+				task.moveActivityToFrontLocked(top);
+				ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r, task);
+				top.updateOptionsLocked(options);
+				top.deliverNewIntentLocked(callingUid, r.intent, r.launchedFromPackage);
+				targetStack.mLastPausedActivity = null;
+				if (doResume) {
+					targetStack.resumeTopActivityLocked(null);
+				}
+				return ActivityManager.START_DELIVERED_TO_TOP;
+			}
+		}
+		// An existing activity is starting this new activity, so we want
+		// to keep the new one in the same task as the one that is starting
+		// it.
+		r.setTask(sourceTask, null);
+		if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Starting new activity " + r
+				+ " in existing task " + r.task + " from source " + sourceRecord);
+
+	} else if (inTask != null) {
+		// The caller is asking that the new activity be started in an explicit
+		// task it has provided to us.
+		if (isLockTaskModeViolation(inTask)) {
+			Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r);
+			return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
+		}
+		targetStack = inTask.stack;
+		targetStack.moveTaskToFrontLocked(inTask, noAnimation, options, r.appTimeTracker,
+				"inTaskToFront");
+
+		// Check whether we should actually launch the new activity in to the task,
+		// or just reuse the current activity on top.
+		ActivityRecord top = inTask.getTopActivity();
+		if (top != null && top.realActivity.equals(r.realActivity) && top.userId == r.userId) {
+			if ((launchFlags & Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0
+					|| launchSingleTop || launchSingleTask) {
+				ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, top, top.task);
+				if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {
+					// We don't need to start a new activity, and
+					// the client said not to do anything if that
+					// is the case, so this is it!
+					return ActivityManager.START_RETURN_INTENT_TO_CALLER;
+				}
+				top.deliverNewIntentLocked(callingUid, r.intent, r.launchedFromPackage);
+				return ActivityManager.START_DELIVERED_TO_TOP;
+			}
+		}
+
+		if (!addingToTask) {
+			// We don't actually want to have this activity added to the task, so just
+			// stop here but still tell the caller that we consumed the intent.
+			ActivityOptions.abort(options);
+			return ActivityManager.START_TASK_TO_FRONT;
+		}
+
+		r.setTask(inTask, null);
+		if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Starting new activity " + r
+				+ " in explicit task " + r.task);
+
+	} else {
+		// This not being started from an existing activity, and not part
+		// of a new task...  just put it in the top task, though these days
+		// this case should never happen.
+		targetStack = computeStackFocus(r, newTask);
+		targetStack.moveToFront("addingToTopTask");
+		ActivityRecord prev = targetStack.topActivity();
+		r.setTask(prev != null ? prev.task : targetStack.createTaskRecord(getNextTaskId(),
+						r.info, intent, null, null, true), null);
+		mWindowManager.moveTaskToTop(r.task.taskId);
+		if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Starting new activity " + r
+				+ " in new guessed " + r.task);
+	}
+
+	mService.grantUriPermissionFromIntentLocked(callingUid, r.packageName,
+			intent, r.getUriPermissionsLocked(), r.userId);
+
+	if (sourceRecord != null && sourceRecord.isRecentsActivity()) {
+		r.task.setTaskToReturnTo(RECENTS_ACTIVITY_TYPE);
+	}
+	if (newTask) {
+		EventLog.writeEvent(EventLogTags.AM_CREATE_TASK, r.userId, r.task.taskId);
+	}
+	ActivityStack.logStartActivity(EventLogTags.AM_CREATE_ACTIVITY, r, r.task);
+	targetStack.mLastPausedActivity = null;
+	
+	// 上面这部分代码很多，各种启动模式、栈的处理啊，我们就不继续看了，接着看下面的启动。
+	targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);
+	if (!launchTaskBehind) {
+		// Don't set focus on an activity that's going to the back.
+		mService.setFocusedActivityLocked(r, "startedActivity");
+	}
+	return ActivityManager.START_SUCCESS;
+}
+```
+继续看`targetStack.startActivityLocked()`方法,这里`targetStack`就是`ActivityStack`类:      
+```java
+final void startActivityLocked(ActivityRecord r, boolean newTask,
+		boolean doResume, boolean keepCurTransition, Bundle options) {
+	TaskRecord rTask = r.task;
+	final int taskId = rTask.taskId;
+	// mLaunchTaskBehind tasks get placed at the back of the task stack.
+	if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {
+		// Last activity in task had been removed or ActivityManagerService is reusing task.
+		// Insert or replace.
+		// Might not even be in.
+		insertTaskAtTop(rTask, r);
+		mWindowManager.moveTaskToTop(taskId);
+	}
+	TaskRecord task = null;
+	if (!newTask) {
+		// If starting in an existing task, find where that is...
+		boolean startIt = true;
+		for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+			task = mTaskHistory.get(taskNdx);
+			if (task.getTopActivity() == null) {
+				// All activities in task are finishing.
+				continue;
+			}
+			if (task == r.task) {
+				// Here it is!  Now, if this is not yet visible to the
+				// user, then just add it without starting; it will
+				// get started when the user navigates back to it.
+				if (!startIt) {
+					if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to task "
+							+ task, new RuntimeException("here").fillInStackTrace());
+					task.addActivityToTop(r);
+					r.putInHistory();
+					mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,
+							r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,
+							(r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0,
+							r.userId, r.info.configChanges, task.voiceSession != null,
+							r.mLaunchTaskBehind);
+					if (VALIDATE_TOKENS) {
+						validateAppTokensLocked();
+					}
+					ActivityOptions.abort(options);
+					return;
+				}
+				break;
+			} else if (task.numFullscreen > 0) {
+				startIt = false;
+			}
+		}
+	}
+
+	// Place a new activity at top of stack, so it is next to interact
+	// with the user.
+
+	// If we are not placing the new activity frontmost, we do not want
+	// to deliver the onUserLeaving callback to the actual frontmost
+	// activity
+	if (task == r.task && mTaskHistory.indexOf(task) != (mTaskHistory.size() - 1)) {
+		mStackSupervisor.mUserLeaving = false;
+		if (DEBUG_USER_LEAVING) Slog.v(TAG_USER_LEAVING,
+				"startActivity() behind front, mUserLeaving=false");
+	}
+
+	task = r.task;
+
+	// Slot the activity into the history stack and proceed
+	if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to stack to task " + task,
+			new RuntimeException("here").fillInStackTrace());
+	task.addActivityToTop(r);
+	task.setFrontOfTask();
+
+	r.putInHistory();
+	if (!isHomeStack() || numActivities() > 0) {
+		// We want to show the starting preview window if we are
+		// switching to a new task, or the next activity's process is
+		// not currently running.
+		boolean showStartingIcon = newTask;
+		ProcessRecord proc = r.app;
+		if (proc == null) {
+			proc = mService.mProcessNames.get(r.processName, r.info.applicationInfo.uid);
+		}
+		if (proc == null || proc.thread == null) {
+			showStartingIcon = true;
+		}
+		if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION,
+				"Prepare open transition: starting " + r);
+		if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) {
+			mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, keepCurTransition);
+			mNoAnimActivities.add(r);
+		} else {
+			mWindowManager.prepareAppTransition(newTask
+					? r.mLaunchTaskBehind
+							? AppTransition.TRANSIT_TASK_OPEN_BEHIND
+							: AppTransition.TRANSIT_TASK_OPEN
+					: AppTransition.TRANSIT_ACTIVITY_OPEN, keepCurTransition);
+			mNoAnimActivities.remove(r);
+		}
+		mWindowManager.addAppToken(task.mActivities.indexOf(r),
+				r.appToken, r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,
+				(r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0, r.userId,
+				r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);
+		boolean doShow = true;
+		if (newTask) {
+			// Even though this activity is starting fresh, we still need
+			// to reset it to make sure we apply affinities to move any
+			// existing activities from other tasks in to it.
+			// If the caller has requested that the target task be
+			// reset, then do so.
+			if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
+				resetTaskIfNeededLocked(r, r);
+				doShow = topRunningNonDelayedActivityLocked(null) == r;
+			}
+		} else if (options != null && new ActivityOptions(options).getAnimationType()
+				== ActivityOptions.ANIM_SCENE_TRANSITION) {
+			doShow = false;
+		}
+		if (r.mLaunchTaskBehind) {
+			// Don't do a starting window for mLaunchTaskBehind. More importantly make sure we
+			// tell WindowManager that r is visible even though it is at the back of the stack.
+			mWindowManager.setAppVisibility(r.appToken, true);
+			ensureActivitiesVisibleLocked(null, 0);
+		} else if (SHOW_APP_STARTING_PREVIEW && doShow) {
+			// Figure out if we are transitioning from another activity that is
+			// "has the same starting icon" as the next one.  This allows the
+			// window manager to keep the previous window it had previously
+			// created, if it still had one.
+			ActivityRecord prev = mResumedActivity;
+			if (prev != null) {
+				// We don't want to reuse the previous starting preview if:
+				// (1) The current activity is in a different task.
+				if (prev.task != r.task) {
+					prev = null;
+				}
+				// (2) The current activity is already displayed.
+				else if (prev.nowVisible) {
+					prev = null;
+				}
+			}
+			mWindowManager.setAppStartingWindow(
+					r.appToken, r.packageName, r.theme,
+					mService.compatibilityInfoForPackageLocked(
+							r.info.applicationInfo), r.nonLocalizedLabel,
+					r.labelRes, r.icon, r.logo, r.windowFlags,
+					prev != null ? prev.appToken : null, showStartingIcon);
+			r.mStartingWindowShown = true;
+		}
+	} else {
+		// If this is the first activity, don't do any fancy animations,
+		// because there is nothing for it to animate on top of.
+		mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,
+				r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,
+				(r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0, r.userId,
+				r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);
+		ActivityOptions.abort(options);
+		options = null;
+	}
+	if (VALIDATE_TOKENS) {
+		validateAppTokensLocked();
+	}
+
+	if (doResume) {
+		mStackSupervisor.resumeTopActivitiesLocked(this, r, options);
+	}
+}
+```
+
+ 在Android应用程序框架层中，是由ActivityManagerService组件负责为Android应用程序创建新的进程的，它本来也是运行在一个独立的进程之中，不过这个进程是在系统启动的过程中创建的。
+ ActivityManagerService组件一般会在什么情况下会为应用程序创建一个新的进程呢？当系统决定要在一个新的进程中启动一个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  
+- Good Luck! 
diff --git "a/Android\345\212\240\345\274\272/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"
similarity index 95%
rename from "Android\345\212\240\345\274\272/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"
rename to "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 f096d0c7..c686be97 100644
--- "a/Android\345\212\240\345\274\272/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"
@@ -1,4 +1,4 @@
-Activity界面绘制过程详解
+Activity界面绘制过程详解
 ===
 
 设置界面首先就是`Activity.setContentView()`方法：我们先看一下他的源码：
@@ -19,19 +19,19 @@ public void setContentView(int layoutResID) {
 ```
 `getWindow()`就是获取该页面的窗体`Window`，该类是一个抽象类，他有一个唯一的子类`PhoneWindow`.
 ```java
-    /**
-     * Retrieve the current {@link android.view.Window} for the activity.
-     * This can be used to directly access parts of the Window API that
-     * are not available through Activity/Screen.
-     *
-     * @return Window The current window, or null if the activity is not
-     *         visual.
-     */
-    public Window getWindow() {
-        return mWindow;
-    }
+/**
+ * Retrieve the current {@link android.view.Window} for the activity.
+ * This can be used to directly access parts of the Window API that
+ * are not available through Activity/Screen.
+ *
+ * @return Window The current window, or null if the activity is not
+ *         visual.
+ */
+public Window getWindow() {
+	return mWindow;
+}
 ```
-接下来，我们看一下`PhoneWindow.setContentView()`方法。(简单的理解是`PhoneWindow`把`DectorView(`FrameLayout的子类)`进行包装，将它作为窗口的根`View`)
+接下来，我们看一下`PhoneWindow.setContentView()`方法。(简单的理解是`PhoneWindow`把`DectorView`(`FrameLayout`的子类)进行包装，将它作为窗口的根`View`)
 ```java
 @Override
 public void setContentView(int layoutResID) {
@@ -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();
@@ -64,8 +64,8 @@ public void setContentView(int layoutResID) {
 }
 ```
 
-上面简单的说明了installDecor()的作用，这里我们在源码中仔细说明一下, 通过这个源码
-我们知道设置主题要在setContentView之前去调用，如用代码设置`requestWindowFeature()`设置主题时要在`setContentView()`之前设置才有用.
+上面简单的说明了`installDecor()`的作用，这里我们在源码中仔细说明一下, 通过这个源码
+我们知道设置主题要在`setContentView()`之前去调用，如用代码设置`requestWindowFeature()`设置主题时要在`setContentView()`之前设置才有用.
 ```java
 private void installDecor() {
 	if (mDecor == null) {
@@ -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/Android\345\212\240\345\274\272/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"
similarity index 87%
rename from "Android\345\212\240\345\274\272/Android Touch\344\272\213\344\273\266\345\210\206\345\217\221\350\257\246\350\247\243.md"
rename to "SourceAnalysis/Android Touch\344\272\213\344\273\266\345\210\206\345\217\221\350\257\246\350\247\243.md"
index 25a4037e..85b1e5fc 100644
--- "a/Android\345\212\240\345\274\272/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"	
@@ -1,29 +1,37 @@
-Android Touch事件分发详解
+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()`消费事件.
-
+- 事件的处理分别为`dispatchTouchEvent()`分发事件(`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,15 +107,16 @@ 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);
 }
 ```
-是调用了`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
 /**
@@ -134,18 +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
 			resetTouchState();
 			// 如果是`Down`，那么`mFirstTouchTarget`到这里肯定是`null`.因为是新一系列手势的开始。
 			// `mFirstTouchTarget`是处理第一个事件的目标。
 		}
 
-		// 检查是否拦截该事件(如果`onInterceptTouchEvent()`返回true就拦截该事件)
+	       	// 检查是否拦截该事件(如果`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
@@ -356,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) {
@@ -425,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
@@ -511,14 +525,13 @@ 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));
 	}
 
 	// 关于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) {
@@ -529,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) {
 					// 处理点击或长按事件
@@ -638,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) {
@@ -708,9 +721,9 @@ public boolean performClick() {
 讲到这里就明白了。`onTouchEvent()`中的`ACTION_UP`中会调用`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"
new file mode 100644
index 00000000..9ad20560
--- /dev/null
+++ "b/SourceAnalysis/AsyncTask\350\257\246\350\247\243.md"
@@ -0,0 +1,933 @@
+AsyncTask详解
+===
+
+`AsyncTask`简单的说其实就是`Handler`和`Thread`的结合，就像下面自己写的`MyAsyncTask`一样，这就是它的基本原理，当然它并不止这么简单。
+
+- 经典版异步任务                
+
+```java
+public abstract class MyAsyncTask {
+	private Handler handler = new Handler(){
+		public void handleMessage(android.os.Message msg) {
+			onPostExecute();
+		};
+	};
+	
+	/**
+	 * 后台任务执行之前 提示用户的界面操作.
+	 */
+	public abstract void onPreExecute();
+	
+	/**
+	 * 后台任务执行之后 更新界面的操作.
+	 */
+	public abstract void onPostExecute();
+	
+	/**
+	 * 在后台执行的一个耗时的操作.
+	 */
+	public abstract void doInBackground();
+	
+	
+	public void execute(){
+		//1. 耗时任务执行之前通知界面更新
+		onPreExecute();
+		new Thread(){
+			public void run() {
+				doInBackground();
+				handler.sendEmptyMessage(0);
+			};
+		}.start();
+		
+	} 
+}
+```
+
+-  AsyncTask                 
+
+```java
+new AsyncTask<Void, Void, Void>() {
+		@Override
+		protected Void doInBackground(Void... params) {
+			blackNumberInfos = dao.findByPage(startIndex, maxNumber);
+			return null;
+		}
+		@Override
+		protected void onPreExecute() {
+			loading.setVisibility(View.VISIBLE);
+			super.onPreExecute();
+		}
+		@Override
+		protected void onPostExecute(Void result) {
+			loading.setVisibility(View.INVISIBLE);
+			if (adapter == null) {// 第一次加载数据 数据适配器还不存在
+				adapter = new CallSmsAdapter();
+				lv_callsms_safe.setAdapter(adapter);
+			} else {// 有新的数据被添加进来.
+				adapter.notifyDataSetChanged();// 通知数据适配器 数据变化了.
+			}
+			super.onPostExecute(result);
+		}
+	}.execute(); 
+//  类的构造方法中接收三个参数，这里我们不用参数就都给它传Void，new出来AsyncTask类之后然后重写这三个方法，
+// 最后别忘了执行execute方法，其实它的内部和我们写的经典版的异步任务相同，也是里面写了一个在新的线程中去执行耗时的操作，
+// 然后用handler发送Message对象，主线程收到这个Message之后去执行onPostExecute中的内容。
+
+
+//AsyncTask<Params, Progress, Result> ,params 异步任务执行(doBackgroud方法)需要的参数这个参数的实参可以由execute()方法的参数传入,
+// Progess 执行的进度,result是(doBackground方法)执行后的结果 
+new AsyncTask<String, Void, Boolean>() { 
+		ProgressDialog pd;
+		@Override
+		protected Boolean doInBackground(String... params) { //这里返回的就是执行的接口，这个返回的结果会传递给onPostExecute的参数
+			try {
+				String filename = params[0];//得到execute传入的参数
+				File file = new File(Environment.getExternalStorageDirectory(),filename);
+				FileOutputStream fos = new FileOutputStream(file);
+				SmsUtils.backUp(getApplicationContext(), fos, new BackUpStatusListener() {
+					public void onBackUpProcess(int process) {
+						pd.setProgress(process);
+					}
+					
+					public void beforeBackup(int max) {
+						pd.setMax(max);
+					}
+				});
+				return true;
+			} catch (Exception e) {
+				e.printStackTrace();
+				return false;
+			}    
+		}
+		@Override
+		protected void onPreExecute() {
+			pd = new ProgressDialog(AtoolsActivity.this);
+			pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
+			pd.setMessage("正在备份短信");
+			pd.show();
+			super.onPreExecute();
+		}
+		@Override
+		protected void onPostExecute(Boolean result) {
+			pd.dismiss();
+			if(result){
+				Toast.makeText(getApplicationContext(), "备份成功", 0).show();
+			}else{
+				Toast.makeText(getApplicationContext(), "备份失败", 0).show();
+			}
+			super.onPostExecute(result);
+		}
+		
+	}.execute("backup.xml"); //这里传入的参数就是doInBackgound中的参数，会传入到doInBackground中
+ 
+// ProgressDialog有个方法
+// incrementProgressBy(int num);方法，这个方法能够让进度条自动增加，如果参数为1就是进度条累加1。
+ 
+// 可以给ProgressDialog添加一个监听dismiss的监听器。pd.setOnDismisListener(DismisListener listener);让其在取消显示后做什么事
+```
+
+经过上面两部分，我们会发现`AsyncTask`太好了，他帮我们封装了`Handler`和`Thread`，当然他内部肯定会有线程池的管理，所以以后我们在开发中对于耗时的操作可以都用`AsyncTask`来搞定的。其实这种做法是错误的。今天发现公司项目中的网络请求都是用`AsyncTask`来做的(刚换的工作)。这样会有严重的问题。
+
+`AsyncTask`存在的问题:
+
+- `AsyncTask`虽然有`cancel`方法，但是一旦执行了`doInBackground`方法，就算调用取消方法，也会执行完`doInBackground`方法中的内容才会停止。
+- 串行还是并行的问题。
+    在`1.6`之前，`AsyncTask`是串行执行任务的。`1.6`的时候开始采用线程池并行处理。但是从`3.0`开始为了解决`AsyncTask`的并发问题，`AsyncTask`又采用一个线程来串行执行任务。(串行啊，每个任务10秒，五个任务，最后一个就要到50秒的时候才执行完)
+- 线程池的问题。
+
+
+先从源码的角度分析下:             
+打开源码后先看下他的注释，注释把我们所关心的内容说的很明白了。`AsyncTask`并不是设计来处理耗时操作的，耗时的上限最多为几秒钟。
+
+```
+AsyncTask enables proper and easy use of the UI thread. This class allows to perform background operations and 
+ publish results on the UI thread without having to manipulate threads and/or handlers. 
+AsyncTask is designed to be a helper class around Thread and Handler and does not constitute a generic threading 
+ framework. ***AsyncTasks should ideally be used for short operations (a few seconds at the most.) If you need to keep 
+ threads running for long periods of time, it is highly recommended you use the various APIs provided by the 
+ java.util.concurrent package such as Executor, ThreadPoolExecutor and FutureTask. ***
+ 
+There are a few threading rules that must be followed for this class to work properly: 
+	- The AsyncTask class must be loaded on the UI thread. This is done automatically as of 
+	 android.os.Build.VERSION_CODES.JELLY_BEAN. 
+	- The task instance must be created on the UI thread. 
+	- execute must be invoked on the UI thread. 
+	- Do not call onPreExecute(), onPostExecute, doInBackground, onProgressUpdate manually. 
+	- The task can be executed only once (an exception will be thrown if a second execution is attempted.) Memory 
+	 observability
+	 
+    When first introduced, AsyncTasks were executed serially on a single background thread. Starting with 
+android.os.Build.VERSION_CODES.DONUT, this was changed to a pool of threads allowing multiple tasks to operate 
+in parallel. Starting with android.os.Build.VERSION_CODES.HONEYCOMB, tasks are executed on a single thread to 
+avoid common application errors caused by parallel execution. 
+If you truly want parallel execution, you can invoke executeOnExecutor(java.util.concurrent.Executor, Object[]) with 
+ THREAD_POOL_EXECUTOR.
+```
+
+拿到源码我们应该从哪里入手: 使用的时候我们都是 `new AsyncTask<>.execute()`所以我们可以先从构造方法和`execute`方法入手:
+
+```java
+/**
+ * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
+ */
+public AsyncTask() {
+        // 初始化mWorker
+	mWorker = new WorkerRunnable<Params, Result>() {
+		public Result call() throws Exception {
+			// 修改该变量值
+			mTaskInvoked.set(true);
+
+			Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+			// 熟悉的doInBackground方法，并且返回该方法的返回值。
+			//noinspection unchecked
+			return postResult(doInBackground(mParams));
+		}
+	};
+	// 初始化mFuture并且将mWorker作为参数。这个FutureTask是什么...我也不知道，放狗查了一下。FutureTask是一种可以取消的异步的计算任务实现了Runnable接口，
+	// 它可以让程序员准确地知道线程什么时候执行完成并获得到线程执行完成后返回的结果。其实就是FutureTask就是个子线程，会去执行mWorker回调中的耗时的操作
+	// 然后在执行完后执行done回调方法。
+	mFuture = new FutureTask<Result>(mWorker) {
+		@Override
+		protected void done() {
+			try {
+                                // 执行完成后的操作
+				postResultIfNotInvoked(get());
+			} catch (InterruptedException e) {
+				android.util.Log.w(LOG_TAG, e);
+			} catch (ExecutionException e) {
+				throw new RuntimeException("An error occured while executing doInBackground()",
+						e.getCause());
+			} catch (CancellationException e) {
+				postResultIfNotInvoked(null);
+			}
+		}
+	};
+}
+```
+
+`WorkerRunnable`是`Callable`接口的抽象实现类:
+
+```java
+private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
+	Params[] mParams;
+}
+```
+
+下面上`postResultIfNotInvoked()`源码:      
+```java
+private void postResultIfNotInvoked(Result result) {
+	final boolean wasTaskInvoked = mTaskInvoked.get();
+	if (!wasTaskInvoked) {
+		postResult(result);
+	}
+}
+// 通过Handler和Message将结果发布出去
+private Result postResult(Result result) {
+	@SuppressWarnings("unchecked")
+	// 调用getHandler去发送Message
+	Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
+			new AsyncTaskResult<Result>(this, result));
+	message.sendToTarget();
+	return result;
+}
+```
+
+那我们再看一下`getHandler()`方法得到的是哪个`Handler`:
+```java
+private static Handler getHandler() {
+	synchronized (AsyncTask.class) {
+		if (sHandler == null) {
+			sHandler = new InternalHandler();
+		}
+		return sHandler;
+	}
+}
+```
+那接下来再看一下`InternalHandler`的实现:
+```java
+private static class InternalHandler extends Handler {
+	public InternalHandler() {
+		super(Looper.getMainLooper());
+	}
+
+	@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
+	@Override
+	public void handleMessage(Message msg) {
+		AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
+		switch (msg.what) {
+			case MESSAGE_POST_RESULT:
+				// There is only one result
+				result.mTask.finish(result.mData[0]);
+				break;
+			case MESSAGE_POST_PROGRESS:
+				result.mTask.onProgressUpdate(result.mData);
+				break;
+		}
+	}
+}
+```
+我们看到如果判断消息类型为`MESSAGE_POST_RESULT`时，会去执行`finish()`方法，接着看一下`result.mTask.finish()`方法的源码:
+```java
+private void finish(Result result) {
+	if (isCancelled()) {
+                // 如果被取消了就执行onCancelled方法，这就是为什么虽然AsyncTask可以取消，但是doInBackground方法还是会执行完的原因。
+		onCancelled(result);
+	} else {
+	        // 没被取消就执行oPostExecute方法
+		onPostExecute(result);
+	}
+	mStatus = Status.FINISHED;
+}
+```
+
+到这里我们会发现已经分析完了`doInBackground`方法执行完后的一系列操作。那`onPreExecute`方法是在哪里?
+
+好了，接着看`execute()`方法	:
+```java
+public final AsyncTask<Params, Progress, Result> execute(Params... params) {
+	return executeOnExecutor(sDefaultExecutor, params);
+}
+```
+里面调用了`executeOnExecutor()`，我们看一下`executeOnExecutor()`方法:
+```java
+public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
+		Params... params) {
+	if (mStatus != Status.PENDING) {
+		switch (mStatus) {
+			case RUNNING:
+				throw new IllegalStateException("Cannot execute task:"
+						+ " the task is already running.");
+			case FINISHED:
+				throw new IllegalStateException("Cannot execute task:"
+						+ " the task has already been executed "
+						+ "(a task can be executed only once)");
+		}
+	}
+
+	mStatus = Status.RUNNING;
+	// 看到我们熟悉的onPreExecute()方法。
+	onPreExecute();
+        // 将参数设置给mWorker变量
+	mWorker.mParams = params;
+	// 执行了Executor的execute方法并用mFuture为参数，这个exec就是上面的sDefaultExecutor
+	exec.execute(mFuture);
+
+	return this;
+}
+```
+我们看一下`sDefaultExecutor`是什么: 
+```java
+/**
+ * An {@link Executor} that executes tasks one at a time in serial
+ * order.  This serialization is global to a particular process.
+ */
+public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
+
+private static final int MESSAGE_POST_RESULT = 0x1;
+private static final int MESSAGE_POST_PROGRESS = 0x2;
+
+private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
+```
+从上面的部分能够看出`sDefaultExecutor`是一个`SerialExecutor`对象，好了，接下来看一下`SerialExecutor`类:
+```java
+private static class SerialExecutor implements Executor {
+        // 用一个队列来管理所有的runnable。offer是把要执行的添加进来，在scheduleNext中取出来去执行。
+	final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
+	Runnable mActive;
+
+	public synchronized void execute(final Runnable r) {
+                // 终于找到了sDefaultExecutor.execute()所真正执行的部分。
+		mTasks.offer(new Runnable() {
+			public void run() {
+				try {
+	                                // 就是mFuture的run方法，他会去调用mWorker.call方法，这样就会执行doInBackground方法，执行完后会把返回值用Handler发送出去
+					r.run();
+				} finally {
+					scheduleNext();
+				}
+			}
+		});
+		if (mActive == null) {
+			scheduleNext();
+		}
+	}
+
+	protected synchronized void scheduleNext() {
+		if ((mActive = mTasks.poll()) != null) {
+                        // 去取队列中的runnable去执行，这个mActive其实就是mFuture对象。
+			THREAD_POOL_EXECUTOR.execute(mActive);
+		}
+	}
+}
+```
+
+所以从`SerialExecutor`中我们能看到这就是为什么会串行的去执行了。因为他只会取队列的第一个去执行，其他的都在队列中等待。
+
+但是这里`THREAD_POOL_EXECUTOR`是什么呢？　　　　
+```java
+/**
+ * An {@link Executor} that can be used to execute tasks in parallel.
+ */
+public static final Executor THREAD_POOL_EXECUTOR
+		= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
+				TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
+```
+静态常量，也就是所不管你用多少个`AsyncTask`都会用这同一个线程池。
+
+接着我们重点看一下`THREAD_POOL_EXECUTOR.execute(mActive)`:
+因为`mActive`就是`mFuture = new FutureTask<Result>(mWorker)`。所以在执行`execute`方法时会执行`FutureTask`的`run`方法:
+```java
+public void run() {
+	if (state != NEW ||
+		!UNSAFE.compareAndSwapObject(this, runnerOffset,
+									 null, Thread.currentThread()))
+		return;
+	try {
+		Callable<V> c = callable;
+		if (c != null && state == NEW) {
+			V result;
+			boolean ran;
+			try {
+		                // 他会去调用 Callable的call()方法，而上面传入的Callable参数是mWorker。所以这里就会调用mWorker的call方法。
+				// 通过这里就和之前我们讲的doInBackground方法联系上了.
+				result = c.call();
+				ran = true;
+			} catch (Throwable ex) {
+				result = null;
+				ran = false;
+				setException(ex);
+			}
+			if (ran)
+				set(result);
+		}
+	} finally {
+		// runner must be non-null until state is settled to
+		// prevent concurrent calls to run()
+		runner = null;
+		// state must be re-read after nulling runner to prevent
+		// leaked interrupts
+		int s = state;
+		if (s >= INTERRUPTING)
+			handlePossibleCancellationInterrupt(s);
+	}
+}
+```
+
+到这里就分析完了。
+
+下面把完整的代码粘贴上(5.1.1):
+```java
+public abstract class AsyncTask<Params, Progress, Result> {
+    private static final String LOG_TAG = "AsyncTask";
+
+    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
+    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
+    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
+    private static final int KEEP_ALIVE = 1;
+
+    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
+        private final AtomicInteger mCount = new AtomicInteger(1);
+
+        public Thread newThread(Runnable r) {
+            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
+        }
+    };
+
+    private static final BlockingQueue<Runnable> sPoolWorkQueue =
+            new LinkedBlockingQueue<Runnable>(128);
+
+    /**
+     * An {@link Executor} that can be used to execute tasks in parallel.
+     */
+    public static final Executor THREAD_POOL_EXECUTOR
+            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
+                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
+
+    /**
+     * An {@link Executor} that executes tasks one at a time in serial
+     * order.  This serialization is global to a particular process.
+     */
+    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
+
+    private static final int MESSAGE_POST_RESULT = 0x1;
+    private static final int MESSAGE_POST_PROGRESS = 0x2;
+
+    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
+    private static InternalHandler sHandler;
+
+    private final WorkerRunnable<Params, Result> mWorker;
+    private final FutureTask<Result> mFuture;
+
+    private volatile Status mStatus = Status.PENDING;
+    
+    private final AtomicBoolean mCancelled = new AtomicBoolean();
+    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
+
+    private static class SerialExecutor implements Executor {
+        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
+        Runnable mActive;
+
+        public synchronized void execute(final Runnable r) {
+            mTasks.offer(new Runnable() {
+                public void run() {
+                    try {
+                        r.run();
+                    } finally {
+                        scheduleNext();
+                    }
+                }
+            });
+            if (mActive == null) {
+                scheduleNext();
+            }
+        }
+
+        protected synchronized void scheduleNext() {
+            if ((mActive = mTasks.poll()) != null) {
+                THREAD_POOL_EXECUTOR.execute(mActive);
+            }
+        }
+    }
+
+    /**
+     * Indicates the current status of the task. Each status will be set only once
+     * during the lifetime of a task.
+     */
+    public enum Status {
+        /**
+         * Indicates that the task has not been executed yet.
+         */
+        PENDING,
+        /**
+         * Indicates that the task is running.
+         */
+        RUNNING,
+        /**
+         * Indicates that {@link AsyncTask#onPostExecute} has finished.
+         */
+        FINISHED,
+    }
+
+    private static Handler getHandler() {
+        synchronized (AsyncTask.class) {
+            if (sHandler == null) {
+                sHandler = new InternalHandler();
+            }
+            return sHandler;
+        }
+    }
+
+    /** @hide */
+    public static void setDefaultExecutor(Executor exec) {
+        sDefaultExecutor = exec;
+    }
+
+    /**
+     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
+     */
+    public AsyncTask() {
+        mWorker = new WorkerRunnable<Params, Result>() {
+            public Result call() throws Exception {
+                mTaskInvoked.set(true);
+
+                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+                //noinspection unchecked
+                return postResult(doInBackground(mParams));
+            }
+        };
+
+        mFuture = new FutureTask<Result>(mWorker) {
+            @Override
+            protected void done() {
+                try {
+                    postResultIfNotInvoked(get());
+                } catch (InterruptedException e) {
+                    android.util.Log.w(LOG_TAG, e);
+                } catch (ExecutionException e) {
+                    throw new RuntimeException("An error occured while executing doInBackground()",
+                            e.getCause());
+                } catch (CancellationException e) {
+                    postResultIfNotInvoked(null);
+                }
+            }
+        };
+    }
+
+    private void postResultIfNotInvoked(Result result) {
+        final boolean wasTaskInvoked = mTaskInvoked.get();
+        if (!wasTaskInvoked) {
+            postResult(result);
+        }
+    }
+
+    private Result postResult(Result result) {
+        @SuppressWarnings("unchecked")
+        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
+                new AsyncTaskResult<Result>(this, result));
+        message.sendToTarget();
+        return result;
+    }
+
+    /**
+     * Returns the current status of this task.
+     *
+     * @return The current status.
+     */
+    public final Status getStatus() {
+        return mStatus;
+    }
+
+    /**
+     * Override this method to perform a computation on a background thread. The
+     * specified parameters are the parameters passed to {@link #execute}
+     * by the caller of this task.
+     *
+     * This method can call {@link #publishProgress} to publish updates
+     * on the UI thread.
+     *
+     * @param params The parameters of the task.
+     *
+     * @return A result, defined by the subclass of this task.
+     *
+     * @see #onPreExecute()
+     * @see #onPostExecute
+     * @see #publishProgress
+     */
+    protected abstract Result doInBackground(Params... params);
+
+    /**
+     * Runs on the UI thread before {@link #doInBackground}.
+     *
+     * @see #onPostExecute
+     * @see #doInBackground
+     */
+    protected void onPreExecute() {
+    }
+
+    /**
+     * <p>Runs on the UI thread after {@link #doInBackground}. The
+     * specified result is the value returned by {@link #doInBackground}.</p>
+     * 
+     * <p>This method won't be invoked if the task was cancelled.</p>
+     *
+     * @param result The result of the operation computed by {@link #doInBackground}.
+     *
+     * @see #onPreExecute
+     * @see #doInBackground
+     * @see #onCancelled(Object) 
+     */
+    @SuppressWarnings({"UnusedDeclaration"})
+    protected void onPostExecute(Result result) {
+    }
+
+    /**
+     * Runs on the UI thread after {@link #publishProgress} is invoked.
+     * The specified values are the values passed to {@link #publishProgress}.
+     *
+     * @param values The values indicating progress.
+     *
+     * @see #publishProgress
+     * @see #doInBackground
+     */
+    @SuppressWarnings({"UnusedDeclaration"})
+    protected void onProgressUpdate(Progress... values) {
+    }
+
+    /**
+     * <p>Runs on the UI thread after {@link #cancel(boolean)} is invoked and
+     * {@link #doInBackground(Object[])} has finished.</p>
+     * 
+     * <p>The default implementation simply invokes {@link #onCancelled()} and
+     * ignores the result. If you write your own implementation, do not call
+     * <code>super.onCancelled(result)</code>.</p>
+     *
+     * @param result The result, if any, computed in
+     *               {@link #doInBackground(Object[])}, can be null
+     * 
+     * @see #cancel(boolean)
+     * @see #isCancelled()
+     */
+    @SuppressWarnings({"UnusedParameters"})
+    protected void onCancelled(Result result) {
+        onCancelled();
+    }    
+    
+    /**
+     * <p>Applications should preferably override {@link #onCancelled(Object)}.
+     * This method is invoked by the default implementation of
+     * {@link #onCancelled(Object)}.</p>
+     * 
+     * <p>Runs on the UI thread after {@link #cancel(boolean)} is invoked and
+     * {@link #doInBackground(Object[])} has finished.</p>
+     *
+     * @see #onCancelled(Object) 
+     * @see #cancel(boolean)
+     * @see #isCancelled()
+     */
+    protected void onCancelled() {
+    }
+
+    /**
+     * Returns <tt>true</tt> if this task was cancelled before it completed
+     * normally. If you are calling {@link #cancel(boolean)} on the task,
+     * the value returned by this method should be checked periodically from
+     * {@link #doInBackground(Object[])} to end the task as soon as possible.
+     *
+     * @return <tt>true</tt> if task was cancelled before it completed
+     *
+     * @see #cancel(boolean)
+     */
+    public final boolean isCancelled() {
+        return mCancelled.get();
+    }
+
+    /**
+     * <p>Attempts to cancel execution of this task.  This attempt will
+     * fail if the task has already completed, already been cancelled,
+     * or could not be cancelled for some other reason. If successful,
+     * and this task has not started when <tt>cancel</tt> is called,
+     * this task should never run. If the task has already started,
+     * then the <tt>mayInterruptIfRunning</tt> parameter determines
+     * whether the thread executing this task should be interrupted in
+     * an attempt to stop the task.</p>
+     * 
+     * <p>Calling this method will result in {@link #onCancelled(Object)} being
+     * invoked on the UI thread after {@link #doInBackground(Object[])}
+     * returns. Calling this method guarantees that {@link #onPostExecute(Object)}
+     * is never invoked. After invoking this method, you should check the
+     * value returned by {@link #isCancelled()} periodically from
+     * {@link #doInBackground(Object[])} to finish the task as early as
+     * possible.</p>
+     *
+     * @param mayInterruptIfRunning <tt>true</tt> if the thread executing this
+     *        task should be interrupted; otherwise, in-progress tasks are allowed
+     *        to complete.
+     *
+     * @return <tt>false</tt> if the task could not be cancelled,
+     *         typically because it has already completed normally;
+     *         <tt>true</tt> otherwise
+     *
+     * @see #isCancelled()
+     * @see #onCancelled(Object)
+     */
+    public final boolean cancel(boolean mayInterruptIfRunning) {
+        mCancelled.set(true);
+        return mFuture.cancel(mayInterruptIfRunning);
+    }
+
+    /**
+     * Waits if necessary for the computation to complete, and then
+     * retrieves its result.
+     *
+     * @return The computed result.
+     *
+     * @throws CancellationException If the computation was cancelled.
+     * @throws ExecutionException If the computation threw an exception.
+     * @throws InterruptedException If the current thread was interrupted
+     *         while waiting.
+     */
+    public final Result get() throws InterruptedException, ExecutionException {
+        return mFuture.get();
+    }
+
+    /**
+     * Waits if necessary for at most the given time for the computation
+     * to complete, and then retrieves its result.
+     *
+     * @param timeout Time to wait before cancelling the operation.
+     * @param unit The time unit for the timeout.
+     *
+     * @return The computed result.
+     *
+     * @throws CancellationException If the computation was cancelled.
+     * @throws ExecutionException If the computation threw an exception.
+     * @throws InterruptedException If the current thread was interrupted
+     *         while waiting.
+     * @throws TimeoutException If the wait timed out.
+     */
+    public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
+            ExecutionException, TimeoutException {
+        return mFuture.get(timeout, unit);
+    }
+
+    /**
+     * Executes the task with the specified parameters. The task returns
+     * itself (this) so that the caller can keep a reference to it.
+     * 
+     * <p>Note: this function schedules the task on a queue for a single background
+     * thread or pool of threads depending on the platform version.  When first
+     * introduced, AsyncTasks were executed serially on a single background thread.
+     * Starting with {@link android.os.Build.VERSION_CODES#DONUT}, this was changed
+     * to a pool of threads allowing multiple tasks to operate in parallel. Starting
+     * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, tasks are back to being
+     * executed on a single thread to avoid common application errors caused
+     * by parallel execution.  If you truly want parallel execution, you can use
+     * the {@link #executeOnExecutor} version of this method
+     * with {@link #THREAD_POOL_EXECUTOR}; however, see commentary there for warnings
+     * on its use.
+     *
+     * <p>This method must be invoked on the UI thread.
+     *
+     * @param params The parameters of the task.
+     *
+     * @return This instance of AsyncTask.
+     *
+     * @throws IllegalStateException If {@link #getStatus()} returns either
+     *         {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}.
+     *
+     * @see #executeOnExecutor(java.util.concurrent.Executor, Object[])
+     * @see #execute(Runnable)
+     */
+    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
+        return executeOnExecutor(sDefaultExecutor, params);
+		// 这里就多插一嘴了。 sDefaultExecutor在上面我们分析过了，就是一个队列来保证串行进行。从3.0开始都是这样。
+		// 那在1.6到3.0之间是怎么并行执行的呢？　按照下面的方式改就可以了
+		// return executeOnExecutor(THREAD_POOL_EXECUTOR, params);
+		// 就是将sDefaultExecutor改成THREAD_POOL_EXECUTOR， THREAD_POOL_EXECUTOR就是线程池。
+		// new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
+		// 原来的CORE_POOL_SIZE是5, KEEP_ALIVE是10, MAXIMUM_POOL_SIZE是128
+		// 也就是说可以同时执行的线程是5个，如果超过5个后，超过的部分就会放到缓存队列中，如果超过了128那就挂了
+    }
+
+    /**
+     * Executes the task with the specified parameters. The task returns
+     * itself (this) so that the caller can keep a reference to it.
+     * 
+     * <p>This method is typically used with {@link #THREAD_POOL_EXECUTOR} to
+     * allow multiple tasks to run in parallel on a pool of threads managed by
+     * AsyncTask, however you can also use your own {@link Executor} for custom
+     * behavior.
+     * 
+     * <p><em>Warning:</em> Allowing multiple tasks to run in parallel from
+     * a thread pool is generally <em>not</em> what one wants, because the order
+     * of their operation is not defined.  For example, if these tasks are used
+     * to modify any state in common (such as writing a file due to a button click),
+     * there are no guarantees on the order of the modifications.
+     * Without careful work it is possible in rare cases for the newer version
+     * of the data to be over-written by an older one, leading to obscure data
+     * loss and stability issues.  Such changes are best
+     * executed in serial; to guarantee such work is serialized regardless of
+     * platform version you can use this function with {@link #SERIAL_EXECUTOR}.
+     *
+     * <p>This method must be invoked on the UI thread.
+     *
+     * @param exec The executor to use.  {@link #THREAD_POOL_EXECUTOR} is available as a
+     *              convenient process-wide thread pool for tasks that are loosely coupled.
+     * @param params The parameters of the task.
+     *
+     * @return This instance of AsyncTask.
+     *
+     * @throws IllegalStateException If {@link #getStatus()} returns either
+     *         {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}.
+     *
+     * @see #execute(Object[])
+     */
+    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
+            Params... params) {
+        if (mStatus != Status.PENDING) {
+            switch (mStatus) {
+                case RUNNING:
+                    throw new IllegalStateException("Cannot execute task:"
+                            + " the task is already running.");
+                case FINISHED:
+                    throw new IllegalStateException("Cannot execute task:"
+                            + " the task has already been executed "
+                            + "(a task can be executed only once)");
+            }
+        }
+
+        mStatus = Status.RUNNING;
+
+        onPreExecute();
+
+        mWorker.mParams = params;
+        exec.execute(mFuture);
+
+        return this;
+    }
+
+    /**
+     * Convenience version of {@link #execute(Object...)} for use with
+     * a simple Runnable object. See {@link #execute(Object[])} for more
+     * information on the order of execution.
+     *
+     * @see #execute(Object[])
+     * @see #executeOnExecutor(java.util.concurrent.Executor, Object[])
+     */
+    public static void execute(Runnable runnable) {
+        sDefaultExecutor.execute(runnable);
+    }
+
+    /**
+     * This method can be invoked from {@link #doInBackground} to
+     * publish updates on the UI thread while the background computation is
+     * still running. Each call to this method will trigger the execution of
+     * {@link #onProgressUpdate} on the UI thread.
+     *
+     * {@link #onProgressUpdate} will not be called if the task has been
+     * canceled.
+     *
+     * @param values The progress values to update the UI with.
+     *
+     * @see #onProgressUpdate
+     * @see #doInBackground
+     */
+    protected final void publishProgress(Progress... values) {
+        if (!isCancelled()) {
+            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
+                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
+        }
+    }
+
+    private void finish(Result result) {
+        if (isCancelled()) {
+            onCancelled(result);
+        } else {
+            onPostExecute(result);
+        }
+        mStatus = Status.FINISHED;
+    }
+
+    private static class InternalHandler extends Handler {
+        public InternalHandler() {
+            super(Looper.getMainLooper());
+        }
+
+        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
+        @Override
+        public void handleMessage(Message msg) {
+            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
+            switch (msg.what) {
+                case MESSAGE_POST_RESULT:
+                    // There is only one result
+                    result.mTask.finish(result.mData[0]);
+                    break;
+                case MESSAGE_POST_PROGRESS:
+                    result.mTask.onProgressUpdate(result.mData);
+                    break;
+            }
+        }
+    }
+
+    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
+        Params[] mParams;
+    }
+
+    @SuppressWarnings({"RawUseOfParameterizedType"})
+    private static class AsyncTaskResult<Data> {
+        final AsyncTask mTask;
+        final Data[] mData;
+
+        AsyncTaskResult(AsyncTask task, Data... data) {
+            mTask = task;
+            mData = data;
+        }
+    }
+}
+
+```
+	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/SourceAnalysis/InstantRun\350\257\246\350\247\243.md" "b/SourceAnalysis/InstantRun\350\257\246\350\247\243.md"
new file mode 100644
index 00000000..a219e78f
--- /dev/null
+++ "b/SourceAnalysis/InstantRun\350\257\246\350\247\243.md"
@@ -0,0 +1,188 @@
+InstantRun详解
+===
+
+之前在写[AndroidStudio提高Build速度][1]]这篇文章的时候写到，想要快，就用`Instant Run`。最近有朋友发来邮件讨论它的原理，最近项目不忙，索性就来系统的学习下。
+
+
+`Android Studio`2.0开始引入了`Instant Run`，它主要是在`Run`和`Debug`的时候可以去减少更新应用的时间。虽然第一次`Build`的时候可能会消耗稍长的时间来完成，但是`Instant Run`可以把更新内容推送到设备上，而无需重新`build`一个新的`apk`，这样就会很快速的让我们观察到改变。
+
+`Instant Run`只支持在`build.gralde`文件中配置的`Gradle`版本是2.0.0以上并且`minSdkVersion`是15以上才可以。为了能更好的使用，请将`minSdkVrsion`设置到21以上。
+
+部署完应用后，会在`Run`![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/as-irrun.png?raw=true)(或者(Debug![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/as-irdebug.png?raw=true)))图标上面出现一个小黄色的闪电符号，这就意味着`Instant Run`已经准备就绪，在你下次点击按钮的时候可以推送更新内容。它不需要重新构建一个新的`APK`,它只推送那些新改变的地方，有些情况下`app`都不需要重启就可以直接显示新改变的下效果。
+
+
+### 配置你的应用来使用`Instant Run`
+
+`Android Stuido`中项目使用`Gralde`2.0.0及以上版本会默认使用`Instant Run`。  
+让项目更新到最新的版本:     
+
+1. 点击`Settings`中的`Preferences`按钮。
+2. 找到`Build,Execution,Deployment`中的`Instant Run`然后点击`Update Project`，如果`Update Project`部分没有显示，那说明你当前已经是最新版本了.   
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/update-project-dialog.png?raw=true)
+
+
+
+### 修复类型
+
+`Instant Run`通过热修复、暖修复或者冷修复来推送改变的代码和资源到你的设备或者模拟器上。它会根据你更改的内容来自动选择对应的修复类型。
+
+- 热修复: 更改的内容不需要重启应用甚至不需要重启当前的`activity`就可以让显示内容的改变，对于大部分通过方法内容改变的更改都可以通过这种方式来修改。
+- 暖修复: 需要重启`activity`才能让改变生效，在改变资源时会通过该方式。
+- 冷修复: 应用需要重启(不是重新安装)。对于一些方法方法结构和实现等结构性的改变需要通过该方式。    
+
+
+
+那具体更改内容和修复方式是怎么对应的呢？    
+
+- 改变现在已经存在的方法          
+    这将通过热修复来执行，这是最快的一种修复方式。你的应用会在运行的过程中，在下次调用该方法时直接使用新实现的方法。
+    热修复不需要重新初始化对象。在看到具体的更改之前，你可能会需要重启当前的`activity`或者应用。默认情况下`Android Studio`在执行热修复后会自动重启当前的`activity`。如果你不想要它自动重启`activity`你也可以在设置中禁用。
+
+- 更改或者移除已经存在的资源           
+    这将通过暖修复来执行:这也是非常快的，但是`Instant Run`在推送这些更新内容时必须要重启当前的`activity`。你的应用仍然会继续运行，但是在重启`activity`时屏幕可能会闪动-这是正常滴。
+
+- 结构性的改变例如:    
+
+    - 增删或者改变:    
+        - 一个注解
+        - 一个变量
+        - 一个静态变量
+        - 一个方法结构
+        - 一个静态方法结构
+
+    - 更改该类集成的父类      
+    - 更改接口的实现列表
+    - 更改类的静态修饰符
+    - 使用动态资源`id`重新布局
+
+    上面的这些改变都将通过冷修复(API 21以上才支持)来执行.冷修复会稍微有些慢，因为虽然不需要构建一个新的`APK`但是必须要重启整个`app`才能推送这些结构性的代码改变。对于`API` 20及以下的版本，`Android Studio`将重新部署`APK`。
+
+- 更改`manifest`文件或者更改`manifest`文件中引用的资源或者更改`Android`桌面`widget`的`UI`实现(需要Clean and Rerun)               
+    在更改清单文件或者清单文件中引用的资源时，`Android Studio`会自动的重新部署引用来实现这些内容的改变。这是因为例如应用名称、图标和`intent filters`这些东西是要在应用安装到设备时根据清单文件来决定的。
+    在更新`Android UI widget`时，你需要执行`Clean and Rerun`才能看到更改的内容，因为在使用`Instant Run`时执行`clean`会需要很长的时间，所以你在更新`UI widget`时可以禁用`Instant Run`。 
+
+
+##### 使用Rerun
+  
+如果修改了一些会影响到初始化的内容时，例如修改了应用的`onCreate()`方法，你需要重启你的应用来让这些改变生效，你可以点击`Rerun`图标。它将会停止应用运行，并且执行`clean`操作后重新部署一个新的`APK`到你的设备。   
+
+
+### 实现原理      
+
+正常情况下，我们修改了内容，想让让它生效，那就需要如下的步骤:           
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/change_run_list.png?raw=true)
+
+那`Instant Run`的目标也非常简单:         
+> 尽可能多的移除上面的步骤，来让剩下的部分尽可能更快。    
+
+这就意味着:    
+
+- 只构建和部署新更改的部分。
+- 不去重新安装应用。
+- 不去重启应用。
+- 甚至不去重启`activity`。
+
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/instant_run_list.png?raw=true)
+
+
+普通情况下在你点击`Run`或者`Debug`按钮时，会执行如下的操作:     
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/apk_progress.png?raw=true)     
+
+清单文件会被整合然后与你应用的资源重启打包成`APK`.同样的，`.java`的源代码会被编译成二进制，然后转换成`.dex`文件，他们也会被包含到`APK`中。
+
+在使用`Instant Run`的情况下，第一次点击`Run`和`Debug`时`Gradle`会执行一些额外的操作:     
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/instant_apk_progress.png?raw=true)
+`instrumentation`相关的二进制内容会被增加到`.class`文件中，并且一个新的`App Server`类会被注入到应用中。    
+同时也会增加一个新的`Application`类，来注入一些自定义的`class loader`并且能启动`App Server`。因此`minifest`文件会被修改来保证使用该新加的`Application`类(如果你已经创建了自己的`Application`类，`Instant Run`的版本将会用你定义的来进行代理扩展) 
+
+经过上面的操作`Instant Run`就开始执行了，以后如果你改变了代码部分，在重新点击`Run`或者`Debug`时，`Instant Run`将会通过热、暖、冷修复来尽可能的减少上面的构建过程。    
+
+在`Instant Run`更改内容前，`Android Studio`会你的应用版本是否支持`Instant Run`并且`App Server`是否运行在对其有用的端口(内部使用了Socket)。 这样来确定你的应用是否在前台运行，并且找到`Studio`所需要的构建`ID`.   
+
+总结一下，其实就是内部会对每个`class`文件注入`instant run`相关的代码，然后自定义一个`application`内部指定自定义的`classLoader`(也就是说不使用默认的`classLoader`了，只要用了`Instant Run`就需要使用它自定义的`classLoader`)，然后在应用程序里面开启一个服务器，`Studio`将修改的代码发送到该服务器，然后再通过自定义的`classLoader`加载代码的时候会去请求该服务器判断代码是否有更新，如果有更新就会通过委托机制加载新更新的代码然后注入到应用程序中，这样就完成了替换的操作。
+
+### 热修复过程               
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/hot_swapping.png?raw=true)
+
+`Android Studio`会监听在开发过程中哪个文件发生了改变，并且通过一个自定义的`Gralde task`来只对修改的`class`文件生成对应的`.dex`文件。    
+这些新的`.dex`文件会通过`Studio`传递发布给应用中运行的`App Server`。  
+
+因为开始时这些文件的`class`已经存在到运行中的应用中-`Gralde`需要保证更新的版本来保证他们能覆盖之前已经存在的文件。这些更新文件的转换是由`App Server`通过自定义的`class loader`来完成的。    
+
+从现在开始，每次一个方法被调用时(不管在应用中的任何地方)，被注入到最初的`class`文件中的`instrumentation`都讲去连接`App Server`来检查它们是否有更新了。 如果有更新，执行操作将被指派到新的充在的`class`文件，这样就会执行新修改的方法。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/instant_run_app_server.png?raw=true)
+
+如果你设置断点，你会发现你调用的是`override`名字的类中的方法。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/instant_debug_override.gif?raw=true)
+
+
+这种重新指定方法的方式在改变方法实现时非常有效，但是对于那种需要在`Activity`启动时加载的改变呢？   
+
+### 暖修复      
+
+暖修复会重启`Activity`。资源文件会在`Activity`启动时被加载，所以修改它们需要`activity`重新启动来进行加载。    
+
+现在，更改任何资源都会导致所有的资源都被重新打包病转移到应用中-但是以后会支持增量包的功能来让只打包和部署那些新修改的资源。
+
+> 注意，暖修复在更改`manifest`件或者`manifest`文件中引用的内容时无效，因为`manifest`文件中的内容需要在`apk`安装时读取。更改`Manifest`文件(或者它所引用的内容)需要被全部构建和部署。    
+
+
+
+非常不幸的是，重启`activity`在做一些结构性的改变时无效。对于这些改变需要使用冷修复。   
+
+### 冷修复     
+
+在部署时，你的应用和他的子项目会被分派到10个不同的部分，每个都在自己单独的`dex`文件。不同部分的类会通过包名来分配。在使用冷修复时，修改的类需要其他所有相关的`class`文件都被重新打包后才能被部署到设备上。      
+这就需要依赖`Android Runtime`能支持加载多个`.dex`文件,这是一个在`ART`中新增的功能，它只有在`Android 5.0(API 21)`以上的设备总才支持。    
+对于`API 20`一下的设备，他们仍在使用`Dalvik`虚拟机，`Android Studio`需要部署整个`APK`。      
+
+
+
+有些时候通过热修复来改变的代码，但是它会被应用首次运行时的初始化所影响，这时你就需要`restart`你的应用来让其生效(快捷键是Command + Ctrl + R)。    
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/instant_run_restart.gif?raw=true)
+
+
+### Instant Run使用技巧及提示      
+
+`Instant Run`是由`Android Studio`控制的，所以你只能通过`IDE`来`start/restart`你的`debug`实例，不要直接在设备中`start/restart`你的应用，不然的话就会发生错乱。    
+
+
+##### Instant Run限制条件    
+
+- 部署到多个设备
+
+    `Instant Run`针对设备的不同`API Level`使用不同的技术来进行热、暖、冷修复。因此，如果同时部署一个应用到多个设备时，`Studio`会暂时关闭`Instant Run`功能。 
+
+
+- Multidex
+
+    如果你的项目支持传统的`Multidex`-也就是在`build.gradle`中配置了`multiDexEnabled true`和`minSdkVersion 20`及以下-当你部署应用到`4.4`以下的设备上时，`Android Studio`将会禁用`Instant Run`。   
+
+    如果`minSdkVersion`设置为21或者更高时，`Instant Run`将自动配置来支持`multidex`，因为`Instant Run`只支持`debug`版本，有需要在发布`release`版的时候配置你的`build`变量来支持`multidex`。    
+
+- 使用第三方插件 
+    `Android Studio`在使用`Instant Run`时会暂时禁用`Java Code Coverage Library`和`ProGuard`。因为`Instant Run`只支持`debug`版本，这样也不会影响`release`版的构建。    
+
+- 只能在主进程中运行    
+    目前热修复只能在主进程中进行，如果在其他进程中热、暖修复将无法使用，只能用冷修复来替代。  
+
+
+
+参考:         
+
+- [官网](https://developer.android.com/studio/run/index.html#instant-run)
+- [Instant Run: How Does it Work?!](https://medium.com/google-developers/instant-run-how-does-it-work-294a1633367f#.8xmpk8xvc)
+    	
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/AndroidStudioCourse/AndroidStudio%E6%8F%90%E9%AB%98Build%E9%80%9F%E5%BA%A6.md "AndroidStudio提高Build速度"
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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..2d5da989
--- /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模式下有效，所以不用担心用户在正式环境下也会出现LeakCanary收集。而且是完全使用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/ListView\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/SourceAnalysis/ListView\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 00000000..c0e9cd71
--- /dev/null
+++ "b/SourceAnalysis/ListView\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,2120 @@
+ListView源码分析
+===
+
+
+一直都想写一篇文章分析下`ListView`的实现，总是忙，一直拖到现在，快到年底了，写出来希望能帮助一些面试跳槽的人。      
+当然写这篇文章也是有原因的，当时有同事在面试的时候，被对方要求当场实现一个`ListView`，同事简单的答了一些实现原理后，很显然对方不满意，经过几轮PK后，就有了不河蟹的结局。    
+不欢而散，哈哈。听说后当时我想着要把`ListView`源码仔细分析后，我自己也去面试试试，可是拖到了现在也没机会了。
+
+`GridView`与`ListView`都继承自`AbsListView`，他俩的实现也比较类似，这里就不说`GridView`了。只说一下`ListView`。
+首先看一下`ListView`的文档:     
+```java
+/*
+ * Implementation Notes:
+ *
+ * Some terminology:
+ *
+ *     index    - index of the items that are currently visible
+ *     position - index of the items in the cursor
+ */
+
+
+/**
+ * A view that shows items in a vertically scrolling list. The items
+ * come from the {@link ListAdapter} associated with this view.
+ */
+```
+
+然后再说一下`ListView`的继承关系`ListView extends AbsListView extends AdapterView<ListAdapter> extends ViewGroup extends View`。
+`ListView`与其他空间不一样，不是拖到界面上就能用，而是要通过设置适配器来添加条目。这就是`AdapterView`的主要功能。既然通过适配器来操作数据。
+这里自然想到的就是`MVC`设计模式。     
+
+- `Data`     - `M`                
+- `ListView` - `V`
+- `Adapter`  - `C`
+
+到这里我们写罗列一下我们将要分析的内容:      
+
+- `ListView`与`Adapter`间的调用。
+- `ListView`上下滑动时操作及缓存。 
+
+我们平时使用`ListView`的时候都是调用`setAdapter()`方法，所以我们这里就从该方法入手:     
+```java
+    /**
+     * Sets the data behind this ListView.
+     *
+     * The adapter passed to this method may be wrapped by a {@link WrapperListAdapter},
+     * depending on the ListView features currently in use. For instance, adding
+     * headers and/or footers will cause the adapter to be wrapped.
+     *
+     * @param adapter The ListAdapter which is responsible for maintaining the
+     *        data backing this list and for producing a view to represent an
+     *        item in that data set.
+     *
+     * @see #getAdapter() 
+     */
+    @Override
+    public void setAdapter(ListAdapter adapter) {
+        if (mAdapter != null && mDataSetObserver != null) {
+    	    // 取消之前注册过的Adapter
+            mAdapter.unregisterDataSetObserver(mDataSetObserver);
+        }
+        // 清空所有的数据
+        resetList();	
+        // The data set used to store unused views that should be reused during the next layout to avoid creating new ones.
+        // 从注释中可以很明显的看出`View`的复用是通过`RecycleBin`类来实现的。它就决定了为什么`ListView`可以显示很多数据缺不会内存溢出。
+        mRecycler.clear();
+
+        if (mHeaderViewInfos.size() > 0|| mFooterViewInfos.size() > 0) {
+            // 如果有HeaderView或者FooterView就把Adapter重新封装下,这是什么设计模式？－装饰
+			// mHeaderViewInfos和mFooterViewInfos分别是header view和foooter view装饰类FixedViewInfo的集合。
+			// 会在addHeaderView()和addFooterView()中进行添加。
+            mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, adapter);
+        } else {
+            mAdapter = adapter;
+        }
+
+        mOldSelectedPosition = INVALID_POSITION;
+        mOldSelectedRowId = INVALID_ROW_ID;
+
+        // AbsListView#setAdapter will update choice mode states.
+        super.setAdapter(adapter);
+
+        if (mAdapter != null) {
+            mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
+            mOldItemCount = mItemCount;
+            mItemCount = mAdapter.getCount();
+            checkFocus();
+
+            mDataSetObserver = new AdapterDataSetObserver();
+            mAdapter.registerDataSetObserver(mDataSetObserver); 
+            // 将viewtypecount设置给RecycleBin
+            mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());
+
+            int position;
+            // mStackFromBottom Indicates whether the list is stacked from the bottom edge or the top edge.
+            if (mStackFromBottom) {
+                position = lookForSelectablePosition(mItemCount - 1, false);
+            } else {
+                position = lookForSelectablePosition(0, true);
+            }
+            setSelectedPositionInt(position);
+            setNextSelectedPositionInt(position);
+
+            if (mItemCount == 0) {
+                // Nothing selected
+                checkSelectionChanged();
+            }
+        } else {
+            mAreAllItemsSelectable = true;
+            checkFocus();
+            // Nothing selected
+            checkSelectionChanged();
+        }
+		// 请求layout了，这个就很重要了啊...我们稍后看一下。
+        requestLayout();
+    }
+	
+	/**
+     * The list is empty. Clear everything out.
+     */
+    @Override
+    void resetList() {
+        // The parent's resetList() will remove all views from the layout so we need to
+        // cleanup the state of our footers and headers
+        clearRecycledState(mHeaderViewInfos);
+        clearRecycledState(mFooterViewInfos);
+        // The list is empty. Clear everything out.
+        super.resetList();
+
+        mLayoutMode = LAYOUT_NORMAL;
+    }
+	
+	private void clearRecycledState(ArrayList<FixedViewInfo> infos) {
+        if (infos != null) {
+            final int count = infos.size();
+
+            for (int i = 0; i < count; i++) {
+                final View child = infos.get(i).view;
+                final LayoutParams p = (LayoutParams) child.getLayoutParams();
+                if (p != null) {
+				    // 这里p就是AbsListView.LayoutParams。对于recycledHeaderFooter在注释中是这样说的. 
+					/**
+					 * When this boolean is set, the view has been added to the AbsListView
+					 * at least once. It is used to know whether headers/footers have already
+					 * been added to the list view and whether they should be treated as
+					 * recycled views or not.
+					 */
+                    p.recycledHeaderFooter = false;
+                }
+            }
+        }
+    }
+```
+
+我们看到`setAdapter()`方法中会调用`requestLayout()`方法。而`requestLayout()`方法会调用`onLayout()`方法，但是我们在`ListView`中找不到`onLayout()`方法。
+那就去他的父类`AbsListView`中找。我们接着来看一下`AbsListView.onLayout()`方法的实现。                   
+```java
+/**
+ * Subclasses should NOT override this method but
+ *  {@link #layoutChildren()} instead.
+ */
+@Override
+protected void onLayout(boolean changed, int l, int t, int r, int b) {
+	super.onLayout(changed, l, t, r, b);
+
+	mInLayout = true;
+
+	final int childCount = getChildCount();
+	if (changed) {
+		for (int i = 0; i < childCount; i++) {
+			getChildAt(i).forceLayout();
+		}
+		mRecycler.markChildrenDirty();
+	}
+
+	// 调用layoutChildren()方法。
+	layoutChildren();
+	mInLayout = false;
+
+	mOverscrollMax = (b - t) / OVERSCROLL_LIMIT_DIVISOR;
+
+	// TODO: Move somewhere sane. This doesn't belong in onLayout().
+	if (mFastScroll != null) {
+		mFastScroll.onItemCountChanged(getChildCount(), mItemCount);
+	}
+}
+```
+
+我们看一下`AbsListView.layoutChildren()`方法的实现:     
+```java
+/**
+ * Subclasses must override this method to layout their children.
+ */
+protected void layoutChildren() {
+}
+```
+
+实现是空的,文档说的很明白了，子类必须要去实现该方法，这也是应该的，因为`ListView`和`GridView`的展现是不一样的.所以我们看一下`ListView.layoutChildren()`方法的实现:      
+```java
+@Override
+protected void layoutChildren() {
+    // When set to true, calls to requestLayout() will not propagate up the parent hierarchy.
+    // This is used to layout the children during a layout pass.
+	final boolean blockLayoutRequests = mBlockLayoutRequests;
+	if (blockLayoutRequests) {
+		return;
+	}
+
+	// 开始了，置为true
+	mBlockLayoutRequests = true;
+
+	try {
+		super.layoutChildren();
+
+		invalidate();
+
+		if (mAdapter == null) {
+			resetList();
+			invokeOnItemScrollListener();
+			return;
+		}
+
+		final int childrenTop = mListPadding.top;
+		final int childrenBottom = mBottom - mTop - mListPadding.bottom;
+		final int childCount = getChildCount();
+
+		int index = 0;
+		int delta = 0;
+
+		View sel;
+		View oldSel = null;
+		View oldFirst = null;
+		View newSel = null;
+
+		// Remember stuff we will need down below
+		// mLayoutMode的注释为Controls how the next layout will happen，默认为LAYOUT_NORMAL
+		switch (mLayoutMode) {
+		case LAYOUT_SET_SELECTION:
+			index = mNextSelectedPosition - mFirstPosition;
+			if (index >= 0 && index < childCount) {
+				newSel = getChildAt(index);
+			}
+			break;
+		case LAYOUT_FORCE_TOP:
+		case LAYOUT_FORCE_BOTTOM:
+		case LAYOUT_SPECIFIC:
+		case LAYOUT_SYNC:
+			break;
+		case LAYOUT_MOVE_SELECTION:
+		default:
+			// Remember the previously selected view
+			index = mSelectedPosition - mFirstPosition;
+			if (index >= 0 && index < childCount) {
+				oldSel = getChildAt(index);
+			}
+
+			// Remember the previous first child
+			oldFirst = getChildAt(0);
+
+			if (mNextSelectedPosition >= 0) {
+				delta = mNextSelectedPosition - mSelectedPosition;
+			}
+
+			// Caution: newSel might be null
+			newSel = getChildAt(index + delta);
+		}
+
+		// mDataChanged变量标记Adapter中数据是否发生变化
+		boolean dataChanged = mDataChanged;
+		if (dataChanged) {
+			handleDataChanged();
+		}
+
+		// Handle the empty set by removing all views that are visible
+		// and calling it a day
+		if (mItemCount == 0) {
+			resetList();
+			invokeOnItemScrollListener();
+			return;
+		} else if (mItemCount != mAdapter.getCount()) {
+			throw new IllegalStateException("The content of the adapter has changed but "
+					+ "ListView did not receive a notification. Make sure the content of "
+					+ "your adapter is not modified from a background thread, but only from "
+					+ "the UI thread. Make sure your adapter calls notifyDataSetChanged() "
+					+ "when its content changes. [in ListView(" + getId() + ", " + getClass()
+					+ ") with Adapter(" + mAdapter.getClass() + ")]");
+		}
+
+		setSelectedPositionInt(mNextSelectedPosition);
+
+		AccessibilityNodeInfo accessibilityFocusLayoutRestoreNode = null;
+		View accessibilityFocusLayoutRestoreView = null;
+		int accessibilityFocusPosition = INVALID_POSITION;
+
+		// Remember which child, if any, had accessibility focus. This must
+		// occur before recycling any views, since that will clear
+		// accessibility focus.
+		final ViewRootImpl viewRootImpl = getViewRootImpl();
+		if (viewRootImpl != null) {
+			final View focusHost = viewRootImpl.getAccessibilityFocusedHost();
+			if (focusHost != null) {
+				final View focusChild = getAccessibilityFocusedChild(focusHost);
+				if (focusChild != null) {
+					if (!dataChanged || isDirectChildHeaderOrFooter(focusChild)
+							|| focusChild.hasTransientState() || mAdapterHasStableIds) {
+						// The views won't be changing, so try to maintain
+						// focus on the current host and virtual view.
+						accessibilityFocusLayoutRestoreView = focusHost;
+						accessibilityFocusLayoutRestoreNode = viewRootImpl
+								.getAccessibilityFocusedVirtualView();
+					}
+
+					// If all else fails, maintain focus at the same
+					// position.
+					accessibilityFocusPosition = getPositionForView(focusChild);
+				}
+			}
+		}
+
+		View focusLayoutRestoreDirectChild = null;
+		View focusLayoutRestoreView = null;
+
+		// Take focus back to us temporarily to avoid the eventual call to
+		// clear focus when removing the focused child below from messing
+		// things up when ViewAncestor assigns focus back to someone else.
+		final View focusedChild = getFocusedChild();
+		if (focusedChild != null) {
+			// TODO: in some cases focusedChild.getParent() == null
+
+			// We can remember the focused view to restore after re-layout
+			// if the data hasn't changed, or if the focused position is a
+			// header or footer.
+			if (!dataChanged || isDirectChildHeaderOrFooter(focusedChild)) {
+				focusLayoutRestoreDirectChild = focusedChild;
+				// Remember the specific view that had focus.
+				focusLayoutRestoreView = findFocus();
+				if (focusLayoutRestoreView != null) {
+					// Tell it we are going to mess with it.
+					focusLayoutRestoreView.onStartTemporaryDetach();
+				}
+			}
+			requestFocus();
+		}
+
+		// Pull all children into the RecycleBin.
+		// These views will be reused if possible
+		final int firstPosition = mFirstPosition;
+		final RecycleBin recycleBin = mRecycler;
+		// RecycleBin控制着整个item的复用，等最后我们再仔细分析下RecycleBin类
+		if (dataChanged) {
+		    // 如果数据发生变化，就把现在的View都添加到一个废弃的View进行缓存，RecycleBin.addScrapView()方法就是缓存一些废弃的View
+			for (int i = 0; i < childCount; i++) {
+				recycleBin.addScrapView(getChildAt(i), firstPosition+i);
+			}
+		} else {
+		    // 调用这个方法后就会根据传入的参数来将ListView中的指定元素存储到mActiveViews数组当中。
+			recycleBin.fillActiveViews(childCount, firstPosition);
+		}
+
+		// Clear out old views
+		detachAllViewsFromParent();
+		recycleBin.removeSkippedScrap();
+		// mLayoutMode默认是LAYOUT_NORMAL
+		switch (mLayoutMode) {
+		case LAYOUT_SET_SELECTION:
+			if (newSel != null) {
+				sel = fillFromSelection(newSel.getTop(), childrenTop, childrenBottom);
+			} else {
+				sel = fillFromMiddle(childrenTop, childrenBottom);
+			}
+			break;
+		case LAYOUT_SYNC:
+			sel = fillSpecific(mSyncPosition, mSpecificTop);
+			break;
+		case LAYOUT_FORCE_BOTTOM:
+			sel = fillUp(mItemCount - 1, childrenBottom);
+			adjustViewsUpOrDown();
+			break;
+		case LAYOUT_FORCE_TOP:
+			mFirstPosition = 0;
+			sel = fillFromTop(childrenTop);
+			adjustViewsUpOrDown();
+			break;
+		case LAYOUT_SPECIFIC:
+			sel = fillSpecific(reconcileSelectedPosition(), mSpecificTop);
+			break;
+		case LAYOUT_MOVE_SELECTION:
+			sel = moveSelection(oldSel, newSel, delta, childrenTop, childrenBottom);
+			break;
+		default:
+		    // 第一次调用layoutChildren方法的时候是还没有layout的，所以这时候childCount是0
+			if (childCount == 0) {
+			    // mStackFromBottom的注释Indicates whether the list is stacked from the bottom edge or the top edge.
+				if (!mStackFromBottom) {
+				    // 默认的布局方式是从上往下的。
+					final int position = lookForSelectablePosition(0, true);
+					setSelectedPositionInt(position);
+					// 调用fillFromTop方法。
+					sel = fillFromTop(childrenTop);
+				} else {
+					final int position = lookForSelectablePosition(mItemCount - 1, false);
+					setSelectedPositionInt(position);
+					sel = fillUp(mItemCount - 1, childrenBottom);
+				}
+			} else {
+			    // 如果已经有条目了就会走到这里
+				if (mSelectedPosition >= 0 && mSelectedPosition < mItemCount) {
+					sel = fillSpecific(mSelectedPosition,
+							oldSel == null ? childrenTop : oldSel.getTop());
+				} else if (mFirstPosition < mItemCount) {
+				    // 没有选中的条目
+					// TODO 一会先分析上面的fillFromTop部分，把其全部分析完后再回来分析这里。
+					sel = fillSpecific(mFirstPosition,
+							oldFirst == null ? childrenTop : oldFirst.getTop());
+				} else {
+					sel = fillSpecific(0, childrenTop);
+				}
+			}
+			break;
+		}
+
+		// Flush any cached views that did not get reused above
+		recycleBin.scrapActiveViews();
+
+		if (sel != null) {
+			// The current selected item should get focus if items are
+			// focusable.
+			if (mItemsCanFocus && hasFocus() && !sel.hasFocus()) {
+				final boolean focusWasTaken = (sel == focusLayoutRestoreDirectChild &&
+						focusLayoutRestoreView != null &&
+						focusLayoutRestoreView.requestFocus()) || sel.requestFocus();
+				if (!focusWasTaken) {
+					// Selected item didn't take focus, but we still want to
+					// make sure something else outside of the selected view
+					// has focus.
+					final View focused = getFocusedChild();
+					if (focused != null) {
+						focused.clearFocus();
+					}
+					positionSelector(INVALID_POSITION, sel);
+				} else {
+					sel.setSelected(false);
+					mSelectorRect.setEmpty();
+				}
+			} else {
+				positionSelector(INVALID_POSITION, sel);
+			}
+			mSelectedTop = sel.getTop();
+		} else {
+			final boolean inTouchMode = mTouchMode == TOUCH_MODE_TAP
+					|| mTouchMode == TOUCH_MODE_DONE_WAITING;
+			if (inTouchMode) {
+				// If the user's finger is down, select the motion position.
+				final View child = getChildAt(mMotionPosition - mFirstPosition);
+				if (child != null) {
+					positionSelector(mMotionPosition, child);
+				}
+			} else if (mSelectorPosition != INVALID_POSITION) {
+				// If we had previously positioned the selector somewhere,
+				// put it back there. It might not match up with the data,
+				// but it's transitioning out so it's not a big deal.
+				final View child = getChildAt(mSelectorPosition - mFirstPosition);
+				if (child != null) {
+					positionSelector(mSelectorPosition, child);
+				}
+			} else {
+				// Otherwise, clear selection.
+				mSelectedTop = 0;
+				mSelectorRect.setEmpty();
+			}
+
+			// Even if there is not selected position, we may need to
+			// restore focus (i.e. something focusable in touch mode).
+			if (hasFocus() && focusLayoutRestoreView != null) {
+				focusLayoutRestoreView.requestFocus();
+			}
+		}
+
+		// Attempt to restore accessibility focus, if necessary.
+		if (viewRootImpl != null) {
+			final View newAccessibilityFocusedView = viewRootImpl.getAccessibilityFocusedHost();
+			if (newAccessibilityFocusedView == null) {
+				if (accessibilityFocusLayoutRestoreView != null
+						&& accessibilityFocusLayoutRestoreView.isAttachedToWindow()) {
+					final AccessibilityNodeProvider provider =
+							accessibilityFocusLayoutRestoreView.getAccessibilityNodeProvider();
+					if (accessibilityFocusLayoutRestoreNode != null && provider != null) {
+						final int virtualViewId = AccessibilityNodeInfo.getVirtualDescendantId(
+								accessibilityFocusLayoutRestoreNode.getSourceNodeId());
+						provider.performAction(virtualViewId,
+								AccessibilityNodeInfo.ACTION_ACCESSIBILITY_FOCUS, null);
+					} else {
+						accessibilityFocusLayoutRestoreView.requestAccessibilityFocus();
+					}
+				} else if (accessibilityFocusPosition != INVALID_POSITION) {
+					// Bound the position within the visible children.
+					final int position = MathUtils.constrain(
+							accessibilityFocusPosition - mFirstPosition, 0,
+							getChildCount() - 1);
+					final View restoreView = getChildAt(position);
+					if (restoreView != null) {
+						restoreView.requestAccessibilityFocus();
+					}
+				}
+			}
+		}
+
+		// Tell focus view we are done mucking with it, if it is still in
+		// our view hierarchy.
+		if (focusLayoutRestoreView != null
+				&& focusLayoutRestoreView.getWindowToken() != null) {
+			focusLayoutRestoreView.onFinishTemporaryDetach();
+		}
+		
+		mLayoutMode = LAYOUT_NORMAL;
+		mDataChanged = false;
+		if (mPositionScrollAfterLayout != null) {
+			post(mPositionScrollAfterLayout);
+			mPositionScrollAfterLayout = null;
+		}
+		mNeedSync = false;
+		setNextSelectedPositionInt(mSelectedPosition);
+
+		updateScrollIndicators();
+
+		if (mItemCount > 0) {
+			checkSelectionChanged();
+		}
+
+		invokeOnItemScrollListener();
+	} finally {
+		if (!blockLayoutRequests) {
+			mBlockLayoutRequests = false;
+		}
+	}
+}
+```
+
+上面看到会调用`fillFromTop()`方法，我们看一下该方法的实现:       
+```java
+/**
+ * Fills the list from top to bottom, starting with mFirstPosition
+ *
+ * @param nextTop The location where the top of the first item should be
+ *        drawn
+ *
+ * @return The view that is currently selected
+ */
+private View fillFromTop(int nextTop) {
+	mFirstPosition = Math.min(mFirstPosition, mSelectedPosition);
+	mFirstPosition = Math.min(mFirstPosition, mItemCount - 1);
+	if (mFirstPosition < 0) {
+		mFirstPosition = 0;
+	}
+	// 调用fillDown()方法。
+	return fillDown(mFirstPosition, nextTop);
+}
+```
+接下来我们看一下`fillDown()`方法的实现:      
+```java
+/**
+ * Fills the list from pos down to the end of the list view.
+ *
+ * @param pos The first position to put in the list
+ *
+ * @param nextTop The location where the top of the item associated with pos
+ *        should be drawn
+ *
+ * @return The view that is currently selected, if it happens to be in the
+ *         range that we draw.
+ */
+private View fillDown(int pos, int nextTop) {
+	View selectedView = null;
+
+	int end = (mBottom - mTop);
+	if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
+		end -= mListPadding.bottom;
+	}
+	// 用一个循环一直去填充，nextTop与end的比较来判断是否超过当前屏幕了，这就是为什么ListView就算有一万条最开始载入也不卡，因为他只初始化一屏啊。
+	// 以后都是边滑动边显示啊，说到这里一会我们还要看一下手势部分的处理。pos和mItemCount的比较来判断当前是否已经把所有条目填充完
+	while (nextTop < end && pos < mItemCount) {
+		// is this the selected item?
+		boolean selected = pos == mSelectedPosition;
+		// 调用makeAndAddView方法
+		View child = makeAndAddView(pos, nextTop, true, mListPadding.left, selected);
+
+		nextTop = child.getBottom() + mDividerHeight;
+		if (selected) {
+			selectedView = child;
+		}
+		pos++;
+	}
+
+	setVisibleRangeHint(mFirstPosition, mFirstPosition + getChildCount() - 1);
+	return selectedView;
+}
+```
+
+接下来看一下`makeAndAddView()`方法，文档里面说的非常清楚了:　　　　　　
+```java
+/**
+ * Obtain the view and add it to our list of children. The view can be made
+ * fresh, converted from an unused view, or used as is if it was in the
+ * recycle bin.
+ *
+ * @param position Logical position in the list
+ * @param y Top or bottom edge of the view to add
+ * @param flow If flow is true, align top edge to y. If false, align bottom
+ *        edge to y.
+ * @param childrenLeft Left edge where children should be positioned
+ * @param selected Is this position selected?
+ * @return View that was added
+ */
+private View makeAndAddView(int position, int y, boolean flow, int childrenLeft,
+		boolean selected) {
+	View child;
+
+	if (!mDataChanged) {
+		// Try to use an existing view for this position
+		child = mRecycler.getActiveView(position);
+		if (child != null) {
+			// Found it -- we're using an existing child
+			// This just needs to be positioned
+			// 最后一个参数为true说明是复用的
+			setupChild(child, position, y, flow, childrenLeft, selected, true);
+
+			return child;
+		}
+	}
+
+	// Make a new view for this position, or convert an unused view if possible
+	// 一会我们先看一下obtainView方法，这个方法其实就是创建一个childView
+	// obtainView方法中会更改mIsScrap[0]的值，以便下面setupChild()中使用。
+	child = obtainView(position, mIsScrap);
+
+	// This needs to be positioned and measured
+	// 把childView添加到listview中，这里最后一个参数会是false
+	setupChild(child, position, y, flow, childrenLeft, selected, mIsScrap[0]);
+
+	return child;
+}
+```
+在`makeAndAddView()`方法里面就是通过`RecycleBin`来复用`View`，如果不存在可以复用的`View`时就创建一个新的。     
+那我们就先看一下`obtainView()`方法，这个方法中的注释写的非常清楚，谷歌大神写代码就是规范，不想某些牛逼哄哄的人整天咋呼敏捷开发，一个注释也不写，那能叫敏捷？。      
+```java
+/**
+ * Get a view and have it show the data associated with the specified
+ * position. This is called when we have already discovered that the view is
+ * not available for reuse in the recycle bin. The only choices left are
+ * converting an old view or making a new one.
+ *
+ * @param position The position to display
+ * @param isScrap Array of at least 1 boolean, the first entry will become true if
+ *                the returned view was taken from the scrap heap, false if otherwise.
+ *
+ * @return A view displaying the data associated with the specified position
+ */
+View obtainView(int position, boolean[] isScrap) {
+	Trace.traceBegin(Trace.TRACE_TAG_VIEW, "obtainView");
+
+	isScrap[0] = false;
+
+	// Check whether we have a transient state view. Attempt to re-bind the
+	// data and discard the view if we fail.
+	final View transientView = mRecycler.getTransientStateView(position);
+	if (transientView != null) {
+		final LayoutParams params = (LayoutParams) transientView.getLayoutParams();
+
+		// If the view type hasn't changed, attempt to re-bind the data.
+		if (params.viewType == mAdapter.getItemViewType(position)) {
+			final View updatedView = mAdapter.getView(position, transientView, this);
+
+			// If we failed to re-bind the data, scrap the obtained view.
+			if (updatedView != transientView) {
+				setItemViewLayoutParams(updatedView, position);
+				mRecycler.addScrapView(updatedView, position);
+			}
+		}
+
+		// Scrap view implies temporary detachment.
+		isScrap[0] = true;
+		return transientView;
+	}
+    // getScrapView()方法会从废弃View的缓存中去取，一旦View移除了屏幕就会被加到该废弃缓存中，所以他就是当View移除屏幕了就加到该缓存中
+	// 显示的时候再从该缓存中取，就这样进行了复用。
+	final View scrapView = mRecycler.getScrapView(position);
+	// 调用Adapter.getView()方法了。并且将scrapView作为converview的参数传入。这个方法都挺熟，就不说了。
+	final View child = mAdapter.getView(position, scrapView, this);
+	if (scrapView != null) {
+		if (child != scrapView) {
+			// Failed to re-bind the data, return scrap to the heap.
+			mRecycler.addScrapView(scrapView, position);
+		} else {
+			isScrap[0] = true;
+
+			child.dispatchFinishTemporaryDetach();
+		}
+	}
+
+	if (mCacheColorHint != 0) {
+		child.setDrawingCacheBackgroundColor(mCacheColorHint);
+	}
+
+	if (child.getImportantForAccessibility() == IMPORTANT_FOR_ACCESSIBILITY_AUTO) {
+		child.setImportantForAccessibility(IMPORTANT_FOR_ACCESSIBILITY_YES);
+	}
+	// 设置该view的layoutparams
+	setItemViewLayoutParams(child, position);
+
+	if (AccessibilityManager.getInstance(mContext).isEnabled()) {
+		if (mAccessibilityDelegate == null) {
+			mAccessibilityDelegate = new ListItemAccessibilityDelegate();
+		}
+		if (child.getAccessibilityDelegate() == null) {
+			child.setAccessibilityDelegate(mAccessibilityDelegate);
+		}
+	}
+
+	Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+
+	return child;
+}
+```
+
+到这里我们就把`obtainView()`方法都看完了，接下来我们再看一下`setupChild()`方法:     
+```java
+/**
+ * Add a view as a child and make sure it is measured (if necessary) and
+ * positioned properly.
+ *
+ * @param child The view to add
+ * @param position The position of this child
+ * @param y The y position relative to which this view will be positioned
+ * @param flowDown If true, align top edge to y. If false, align bottom
+ *        edge to y.
+ * @param childrenLeft Left edge where children should be positioned
+ * @param selected Is this position selected?
+ * @param recycled Has this view been pulled from the recycle bin? If so it
+ *        does not need to be remeasured.
+ */
+private void setupChild(View child, int position, int y, boolean flowDown, int childrenLeft,
+		boolean selected, boolean recycled) {
+	Trace.traceBegin(Trace.TRACE_TAG_VIEW, "setupListItem");
+
+	final boolean isSelected = selected && shouldShowSelector();
+	final boolean updateChildSelected = isSelected != child.isSelected();
+	final int mode = mTouchMode;
+	final boolean isPressed = mode > TOUCH_MODE_DOWN && mode < TOUCH_MODE_SCROLL &&
+			mMotionPosition == position;
+	final boolean updateChildPressed = isPressed != child.isPressed();
+	final boolean needToMeasure = !recycled || updateChildSelected || child.isLayoutRequested();
+
+	// Respect layout params that are already in the view. Otherwise make some up...
+	// noinspection unchecked
+	AbsListView.LayoutParams p = (AbsListView.LayoutParams) child.getLayoutParams();
+	if (p == null) {
+		p = (AbsListView.LayoutParams) generateDefaultLayoutParams();
+	}
+	// 这里就是Adapter中getItemViewType的调用处
+	p.viewType = mAdapter.getItemViewType(position);
+
+	if ((recycled && !p.forceAdd) || (p.recycledHeaderFooter &&
+			p.viewType == AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER)) {
+		// 复用的或者headerView及footerView等调用attachViewToParent方法，把之前detach的View重新attach到ViewGroup上
+		attachViewToParent(child, flowDown ? -1 : 0, p);
+	} else {
+		p.forceAdd = false;
+		if (p.viewType == AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
+			p.recycledHeaderFooter = true;
+		}
+		// 第一次都是通过该方法来把View添加到ViewGroup中
+		addViewInLayout(child, flowDown ? -1 : 0, p, true);
+	}
+
+	if (updateChildSelected) {
+		child.setSelected(isSelected);
+	}
+
+	if (updateChildPressed) {
+		child.setPressed(isPressed);
+	}
+
+	if (mChoiceMode != CHOICE_MODE_NONE && mCheckStates != null) {
+		if (child instanceof Checkable) {
+			((Checkable) child).setChecked(mCheckStates.get(position));
+		} else if (getContext().getApplicationInfo().targetSdkVersion
+				>= android.os.Build.VERSION_CODES.HONEYCOMB) {
+			child.setActivated(mCheckStates.get(position));
+		}
+	}
+
+	if (needToMeasure) {
+		int childWidthSpec = ViewGroup.getChildMeasureSpec(mWidthMeasureSpec,
+				mListPadding.left + mListPadding.right, p.width);
+		int lpHeight = p.height;
+		int childHeightSpec;
+		if (lpHeight > 0) {
+			childHeightSpec = MeasureSpec.makeMeasureSpec(lpHeight, MeasureSpec.EXACTLY);
+		} else {
+			childHeightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
+		}
+		child.measure(childWidthSpec, childHeightSpec);
+	} else {
+		cleanupLayoutState(child);
+	}
+
+	final int w = child.getMeasuredWidth();
+	final int h = child.getMeasuredHeight();
+	final int childTop = flowDown ? y : y - h;
+
+	if (needToMeasure) {
+		final int childRight = childrenLeft + w;
+		final int childBottom = childTop + h;
+		child.layout(childrenLeft, childTop, childRight, childBottom);
+	} else {
+		child.offsetLeftAndRight(childrenLeft - child.getLeft());
+		child.offsetTopAndBottom(childTop - child.getTop());
+	}
+
+	if (mCachingStarted && !child.isDrawingCacheEnabled()) {
+		child.setDrawingCacheEnabled(true);
+	}
+
+	if (recycled && (((AbsListView.LayoutParams)child.getLayoutParams()).scrappedFromPosition)
+			!= position) {
+		child.jumpDrawablesToCurrentState();
+	}
+
+	Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+}
+```
+通过分析我们看到核心的部分就是`attachViewToParent()`方法和`addViewInLayout()`方法，这两个方法都是父类`ViewGroup`中的方法，
+我们分别来看一下:     
+```java
+/**
+ * Attaches a view to this view group. Attaching a view assigns this group as the parent,
+ * sets the layout parameters and puts the view in the list of children so that
+ * it can be retrieved by calling {@link #getChildAt(int)}.
+ * <p>
+ * This method is intended to be lightweight and makes no assumptions about whether the
+ * parent or child should be redrawn. Proper use of this method will include also making
+ * any appropriate {@link #requestLayout()} or {@link #invalidate()} calls.
+ * For example, callers can {@link #post(Runnable) post} a {@link Runnable}
+ * which performs a {@link #requestLayout()} on the next frame, after all detach/attach
+ * calls are finished, causing layout to be run prior to redrawing the view hierarchy.
+ * <p>
+ * This method should be called only for views which were detached from their parent.
+ *
+ * @param child the child to attach
+ * @param index the index at which the child should be attached
+ * @param params the layout parameters of the child
+ *
+ * @see #removeDetachedView(View, boolean)
+ * @see #detachAllViewsFromParent()
+ * @see #detachViewFromParent(View)
+ * @see #detachViewFromParent(int)
+ */
+protected void attachViewToParent(View child, int index, LayoutParams params) {
+	child.mLayoutParams = params;
+
+	if (index < 0) {
+		index = mChildrenCount;
+	}
+	
+	// 把该view添加到数组中，就像注释所说的为了能够让`getChildAt()`方法能获取到。
+	addInArray(child, index);
+
+	child.mParent = this;
+	child.mPrivateFlags = (child.mPrivateFlags & ~PFLAG_DIRTY_MASK
+					& ~PFLAG_DRAWING_CACHE_VALID)
+			| PFLAG_DRAWN | PFLAG_INVALIDATED;
+	this.mPrivateFlags |= PFLAG_INVALIDATED;
+
+	if (child.hasFocus()) {
+		requestChildFocus(child, child.findFocus());
+	}
+}
+```
+复用的处理看完后，我们看一下新创建的childView如何被添加到ListView上，我们看一下`addViewInLayout()`方法:       
+```java
+/**
+ * Adds a view during layout. This is useful if in your onLayout() method,
+ * you need to add more views (as does the list view for example).
+ *
+ * If index is negative, it means put it at the end of the list.
+ *
+ * @param child the view to add to the group
+ * @param index the index at which the child must be added
+ * @param params the layout parameters to associate with the child
+ * @param preventRequestLayout if true, calling this method will not trigger a
+ *        layout request on child
+ * @return true if the child was added, false otherwise
+ */
+protected boolean addViewInLayout(View child, int index, LayoutParams params,
+		boolean preventRequestLayout) {
+	if (child == null) {
+		throw new IllegalArgumentException("Cannot add a null child view to a ViewGroup");
+	}
+	child.mParent = null;
+	// 这个方法最终会调用addView方法添加childView
+	addViewInner(child, index, params, preventRequestLayout);
+	child.mPrivateFlags = (child.mPrivateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;
+	return true;
+}
+```
+
+到这里已经把上面`fillFromTop()`方法的部分都分析完了。  
+不要忘了我们上面还留了一个TODO的部分，就是对于已经有数据的部分调用`fillSpecific()`方法，那我们就看一下他的实现:　　　　　
+```java
+/**
+ * Put a specific item at a specific location on the screen and then build
+ * up and down from there.
+ *
+ * @param position The reference view to use as the starting point
+ * @param top Pixel offset from the top of this view to the top of the
+ *        reference view.
+ *
+ * @return The selected view, or null if the selected view is outside the
+ *         visible area.
+ */
+private View fillSpecific(int position, int top) {
+	boolean tempIsSelected = position == mSelectedPosition;
+	View temp = makeAndAddView(position, top, true, mListPadding.left, tempIsSelected);
+	// Possibly changed again in fillUp if we add rows above this one.
+	mFirstPosition = position;
+
+	View above;
+	View below;
+
+	final int dividerHeight = mDividerHeight;
+	if (!mStackFromBottom) {
+		above = fillUp(position - 1, temp.getTop() - dividerHeight);
+		// This will correct for the top of the first view not touching the top of the list
+		adjustViewsUpOrDown();
+		below = fillDown(position + 1, temp.getBottom() + dividerHeight);
+		int childCount = getChildCount();
+		if (childCount > 0) {
+			correctTooHigh(childCount);
+		}
+	} else {
+		below = fillDown(position + 1, temp.getBottom() + dividerHeight);
+		// This will correct for the bottom of the last view not touching the bottom of the list
+		adjustViewsUpOrDown();
+		above = fillUp(position - 1, temp.getTop() - dividerHeight);
+		int childCount = getChildCount();
+		if (childCount > 0) {
+			 correctTooLow(childCount);
+		}
+	}
+
+	if (tempIsSelected) {
+		return temp;
+	} else if (above != null) {
+		return above;
+	} else {
+		return below;
+	}
+}
+```
+就像注释所说的它是让指定位置的View先加载到屏幕上，然后在加载该view往上以及往下位置的其他View，他里面会调用`fillUp()`和`fillDown()`方法，又会走上面的流程，所以这里就不分析了。
+
+好了，到这里我们就基本已经分析完了，但是感觉好像好少了点什么？　　　
+
+这里少了不是一点，是两点:      
+
+- 手势滑动过程中ListView的复用处理
+- RecycleBin中复用的具体实现
+
+
+一个个的来，先看一下手势滑动部分，这个当然是从`onTouchEvent()`方法看了，         
+手势这一块不太清楚的可以看我之前的一篇文章
+[Android Touch事件分发详解](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)
+
+
+发现`ListView`没有重写`onTouchEvent()`方法，这也好理解，因为`GridView`也有类似的滑动功能，所以去父类`AbsListView`中看.      
+我们看一下`AbsListView.onTouchEvent()`方法:　　　　　
+```java
+@Override
+public boolean onTouchEvent(MotionEvent ev) {
+	if (!isEnabled()) {
+		// A disabled view that is clickable still consumes the touch
+		// events, it just doesn't respond to them.
+		return isClickable() || isLongClickable();
+	}
+
+	if (mPositionScroller != null) {
+		mPositionScroller.stop();
+	}
+
+	if (mIsDetaching || !isAttachedToWindow()) {
+		// Something isn't right.
+		// Since we rely on being attached to get data set change notifications,
+		// don't risk doing anything where we might try to resync and find things
+		// in a bogus state.
+		return false;
+	}
+
+	startNestedScroll(SCROLL_AXIS_VERTICAL);
+
+	if (mFastScroll != null) {
+		boolean intercepted = mFastScroll.onTouchEvent(ev);
+		if (intercepted) {
+			return true;
+		}
+	}
+
+	initVelocityTrackerIfNotExists();
+	final MotionEvent vtev = MotionEvent.obtain(ev);
+
+	final int actionMasked = ev.getActionMasked();
+	if (actionMasked == MotionEvent.ACTION_DOWN) {
+		mNestedYOffset = 0;
+	}
+	vtev.offsetLocation(0, mNestedYOffset);
+	switch (actionMasked) {
+		case MotionEvent.ACTION_DOWN: {
+			onTouchDown(ev);
+			break;
+		}
+
+		case MotionEvent.ACTION_MOVE: {
+		    // 具体移动的部分就在这里了
+			onTouchMove(ev, vtev);
+			break;
+		}
+
+		case MotionEvent.ACTION_UP: {
+			onTouchUp(ev);
+			break;
+		}
+
+		case MotionEvent.ACTION_CANCEL: {
+			onTouchCancel();
+			break;
+		}
+
+		case MotionEvent.ACTION_POINTER_UP: {
+			onSecondaryPointerUp(ev);
+			final int x = mMotionX;
+			final int y = mMotionY;
+			final int motionPosition = pointToPosition(x, y);
+			if (motionPosition >= 0) {
+				// Remember where the motion event started
+				final View child = getChildAt(motionPosition - mFirstPosition);
+				mMotionViewOriginalTop = child.getTop();
+				mMotionPosition = motionPosition;
+			}
+			mLastY = y;
+			break;
+		}
+
+		case MotionEvent.ACTION_POINTER_DOWN: {
+			// New pointers take over dragging duties
+			final int index = ev.getActionIndex();
+			final int id = ev.getPointerId(index);
+			final int x = (int) ev.getX(index);
+			final int y = (int) ev.getY(index);
+			mMotionCorrection = 0;
+			mActivePointerId = id;
+			mMotionX = x;
+			mMotionY = y;
+			final int motionPosition = pointToPosition(x, y);
+			if (motionPosition >= 0) {
+				// Remember where the motion event started
+				final View child = getChildAt(motionPosition - mFirstPosition);
+				mMotionViewOriginalTop = child.getTop();
+				mMotionPosition = motionPosition;
+			}
+			mLastY = y;
+			break;
+		}
+	}
+
+	if (mVelocityTracker != null) {
+		mVelocityTracker.addMovement(vtev);
+	}
+	vtev.recycle();
+	return true;
+}
+```
+
+接着看一下`onTouchMove()`方法:      
+```java
+private void onTouchMove(MotionEvent ev, MotionEvent vtev) {
+	int pointerIndex = ev.findPointerIndex(mActivePointerId);
+	if (pointerIndex == -1) {
+		pointerIndex = 0;
+		mActivePointerId = ev.getPointerId(pointerIndex);
+	}
+
+	if (mDataChanged) {
+		// Re-sync everything if data has been changed
+		// since the scroll operation can query the adapter.
+		layoutChildren();
+	}
+
+	final int y = (int) ev.getY(pointerIndex);
+
+	switch (mTouchMode) {
+		case TOUCH_MODE_DOWN:
+		case TOUCH_MODE_TAP:
+		case TOUCH_MODE_DONE_WAITING:
+			// Check if we have moved far enough that it looks more like a
+			// scroll than a tap. If so, we'll enter scrolling mode.
+			if (startScrollIfNeeded((int) ev.getX(pointerIndex), y, vtev)) {
+				break;
+			}
+			// Otherwise, check containment within list bounds. If we're
+			// outside bounds, cancel any active presses.
+			final View motionView = getChildAt(mMotionPosition - mFirstPosition);
+			final float x = ev.getX(pointerIndex);
+			if (!pointInView(x, y, mTouchSlop)) {
+				setPressed(false);
+				if (motionView != null) {
+					motionView.setPressed(false);
+				}
+				removeCallbacks(mTouchMode == TOUCH_MODE_DOWN ?
+						mPendingCheckForTap : mPendingCheckForLongPress);
+				mTouchMode = TOUCH_MODE_DONE_WAITING;
+				updateSelectorState();
+			} else if (motionView != null) {
+				// Still within bounds, update the hotspot.
+				final float[] point = mTmpPoint;
+				point[0] = x;
+				point[1] = y;
+				transformPointToViewLocal(point, motionView);
+				motionView.drawableHotspotChanged(point[0], point[1]);
+			}
+			break;
+
+		case TOUCH_MODE_SCROLL:
+		case TOUCH_MODE_OVERSCROLL:
+			// 滑动部分的处理，传入当前位置的x,y坐标
+			scrollIfNeeded((int) ev.getX(pointerIndex), y, vtev);
+			break;
+	}
+}
+```
+
+再看一下`scrollIfNeeded()`方法的实现:　　　　
+```java
+private void scrollIfNeeded(int x, int y, MotionEvent vtev) {
+	int rawDeltaY = y - mMotionY;
+	int scrollOffsetCorrection = 0;
+	int scrollConsumedCorrection = 0;
+	if (mLastY == Integer.MIN_VALUE) {
+		rawDeltaY -= mMotionCorrection;
+	}
+	if (dispatchNestedPreScroll(0, mLastY != Integer.MIN_VALUE ? mLastY - y : -rawDeltaY,
+			mScrollConsumed, mScrollOffset)) {
+		rawDeltaY += mScrollConsumed[1];
+		scrollOffsetCorrection = -mScrollOffset[1];
+		scrollConsumedCorrection = mScrollConsumed[1];
+		if (vtev != null) {
+			vtev.offsetLocation(0, mScrollOffset[1]);
+			mNestedYOffset += mScrollOffset[1];
+		}
+	}
+	final int deltaY = rawDeltaY;
+	int incrementalDeltaY =
+			mLastY != Integer.MIN_VALUE ? y - mLastY + scrollConsumedCorrection : deltaY;
+	int lastYCorrection = 0;
+
+	if (mTouchMode == TOUCH_MODE_SCROLL) {
+		if (PROFILE_SCROLLING) {
+			if (!mScrollProfilingStarted) {
+				Debug.startMethodTracing("AbsListViewScroll");
+				mScrollProfilingStarted = true;
+			}
+		}
+
+		if (mScrollStrictSpan == null) {
+			// If it's non-null, we're already in a scroll.
+			mScrollStrictSpan = StrictMode.enterCriticalSpan("AbsListView-scroll");
+		}
+
+		if (y != mLastY) {
+			// 移动了
+			// We may be here after stopping a fling and continuing to scroll.
+			// If so, we haven't disallowed intercepting touch events yet.
+			// Make sure that we do so in case we're in a parent that can intercept.
+			if ((mGroupFlags & FLAG_DISALLOW_INTERCEPT) == 0 &&
+					Math.abs(rawDeltaY) > mTouchSlop) {
+				final ViewParent parent = getParent();
+				if (parent != null) {
+					parent.requestDisallowInterceptTouchEvent(true);
+				}
+			}
+
+			final int motionIndex;
+			if (mMotionPosition >= 0) {
+				motionIndex = mMotionPosition - mFirstPosition;
+			} else {
+				// If we don't have a motion position that we can reliably track,
+				// pick something in the middle to make a best guess at things below.
+				motionIndex = getChildCount() / 2;
+			}
+
+			int motionViewPrevTop = 0;
+			View motionView = this.getChildAt(motionIndex);
+			if (motionView != null) {
+				motionViewPrevTop = motionView.getTop();
+			}
+
+			// No need to do all this work if we're not going to move anyway
+			boolean atEdge = false;
+			if (incrementalDeltaY != 0) {
+			    // 移动的过程中不断调用
+				atEdge = trackMotionScroll(deltaY, incrementalDeltaY);
+			}
+
+			// Check to see if we have bumped into the scroll limit
+			motionView = this.getChildAt(motionIndex);
+			if (motionView != null) {
+				// Check if the top of the motion view is where it is
+				// supposed to be
+				final int motionViewRealTop = motionView.getTop();
+				if (atEdge) {
+					// Apply overscroll
+
+					int overscroll = -incrementalDeltaY -
+							(motionViewRealTop - motionViewPrevTop);
+					if (dispatchNestedScroll(0, overscroll - incrementalDeltaY, 0, overscroll,
+							mScrollOffset)) {
+						lastYCorrection -= mScrollOffset[1];
+						if (vtev != null) {
+							vtev.offsetLocation(0, mScrollOffset[1]);
+							mNestedYOffset += mScrollOffset[1];
+						}
+					} else {
+						final boolean atOverscrollEdge = overScrollBy(0, overscroll,
+								0, mScrollY, 0, 0, 0, mOverscrollDistance, true);
+
+						if (atOverscrollEdge && mVelocityTracker != null) {
+							// Don't allow overfling if we're at the edge
+							mVelocityTracker.clear();
+						}
+
+						final int overscrollMode = getOverScrollMode();
+						if (overscrollMode == OVER_SCROLL_ALWAYS ||
+								(overscrollMode == OVER_SCROLL_IF_CONTENT_SCROLLS &&
+										!contentFits())) {
+							if (!atOverscrollEdge) {
+								mDirection = 0; // Reset when entering overscroll.
+								mTouchMode = TOUCH_MODE_OVERSCROLL;
+							}
+							if (incrementalDeltaY > 0) {
+								mEdgeGlowTop.onPull((float) -overscroll / getHeight(),
+										(float) x / getWidth());
+								if (!mEdgeGlowBottom.isFinished()) {
+									mEdgeGlowBottom.onRelease();
+								}
+								invalidate(0, 0, getWidth(),
+										mEdgeGlowTop.getMaxHeight() + getPaddingTop());
+							} else if (incrementalDeltaY < 0) {
+								mEdgeGlowBottom.onPull((float) overscroll / getHeight(),
+										1.f - (float) x / getWidth());
+								if (!mEdgeGlowTop.isFinished()) {
+									mEdgeGlowTop.onRelease();
+								}
+								invalidate(0, getHeight() - getPaddingBottom() -
+										mEdgeGlowBottom.getMaxHeight(), getWidth(),
+										getHeight());
+							}
+						}
+					}
+				}
+				mMotionY = y + lastYCorrection + scrollOffsetCorrection;
+			}
+			mLastY = y + lastYCorrection + scrollOffsetCorrection;
+		}
+	} else if (mTouchMode == TOUCH_MODE_OVERSCROLL) {
+	    // 灰起了.
+		if (y != mLastY) {
+			final int oldScroll = mScrollY;
+			final int newScroll = oldScroll - incrementalDeltaY;
+			int newDirection = y > mLastY ? 1 : -1;
+
+			if (mDirection == 0) {
+				mDirection = newDirection;
+			}
+
+			int overScrollDistance = -incrementalDeltaY;
+			if ((newScroll < 0 && oldScroll >= 0) || (newScroll > 0 && oldScroll <= 0)) {
+				overScrollDistance = -oldScroll;
+				incrementalDeltaY += overScrollDistance;
+			} else {
+				incrementalDeltaY = 0;
+			}
+
+			if (overScrollDistance != 0) {
+				overScrollBy(0, overScrollDistance, 0, mScrollY, 0, 0,
+						0, mOverscrollDistance, true);
+				final int overscrollMode = getOverScrollMode();
+				if (overscrollMode == OVER_SCROLL_ALWAYS ||
+						(overscrollMode == OVER_SCROLL_IF_CONTENT_SCROLLS &&
+								!contentFits())) {
+					if (rawDeltaY > 0) {
+						mEdgeGlowTop.onPull((float) overScrollDistance / getHeight(),
+								(float) x / getWidth());
+						if (!mEdgeGlowBottom.isFinished()) {
+							mEdgeGlowBottom.onRelease();
+						}
+						invalidate(0, 0, getWidth(),
+								mEdgeGlowTop.getMaxHeight() + getPaddingTop());
+					} else if (rawDeltaY < 0) {
+						mEdgeGlowBottom.onPull((float) overScrollDistance / getHeight(),
+								1.f - (float) x / getWidth());
+						if (!mEdgeGlowTop.isFinished()) {
+							mEdgeGlowTop.onRelease();
+						}
+						invalidate(0, getHeight() - getPaddingBottom() -
+								mEdgeGlowBottom.getMaxHeight(), getWidth(),
+								getHeight());
+					}
+				}
+			}
+
+			if (incrementalDeltaY != 0) {
+				// Coming back to 'real' list scrolling
+				if (mScrollY != 0) {
+					mScrollY = 0;
+					invalidateParentIfNeeded();
+				}
+				// 继续处理着
+				trackMotionScroll(incrementalDeltaY, incrementalDeltaY);
+
+				mTouchMode = TOUCH_MODE_SCROLL;
+
+				// We did not scroll the full amount. Treat this essentially like the
+				// start of a new touch scroll
+				final int motionPosition = findClosestMotionRow(y);
+
+				mMotionCorrection = 0;
+				View motionView = getChildAt(motionPosition - mFirstPosition);
+				mMotionViewOriginalTop = motionView != null ? motionView.getTop() : 0;
+				mMotionY =  y + scrollOffsetCorrection;
+				mMotionPosition = motionPosition;
+			}
+			mLastY = y + lastYCorrection + scrollOffsetCorrection;
+			mDirection = newDirection;
+		}
+	}
+}
+```
+
+这部分代码逻辑牵扯太多，有点晕呼呼的，记着看一下`trackMotionScroll()`方法:      
+```java
+/**
+ * Track a motion scroll
+ *
+ * @param deltaY Amount to offset mMotionView. This is the accumulated delta since the motion
+ *        began. Positive numbers mean the user's finger is moving down the screen.
+ * @param incrementalDeltaY Change in deltaY from the previous event. 通过它的正负来判断是向上还是向下。
+ * @return true if we're already at the beginning/end of the list and have nothing to do.
+ */
+boolean trackMotionScroll(int deltaY, int incrementalDeltaY) {
+	final int childCount = getChildCount();
+	if (childCount == 0) {
+		return true;
+	}
+
+	final int firstTop = getChildAt(0).getTop();
+	final int lastBottom = getChildAt(childCount - 1).getBottom();
+
+	final Rect listPadding = mListPadding;
+
+	// "effective padding" In this case is the amount of padding that affects
+	// how much space should not be filled by items. If we don't clip to padding
+	// there is no effective padding.
+	int effectivePaddingTop = 0;
+	int effectivePaddingBottom = 0;
+	if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
+		effectivePaddingTop = listPadding.top;
+		effectivePaddingBottom = listPadding.bottom;
+	}
+
+	 // FIXME account for grid vertical spacing too?
+	final int spaceAbove = effectivePaddingTop - firstTop;
+	final int end = getHeight() - effectivePaddingBottom;
+	final int spaceBelow = lastBottom - end;
+
+	final int height = getHeight() - mPaddingBottom - mPaddingTop;
+	if (deltaY < 0) {
+		deltaY = Math.max(-(height - 1), deltaY);
+	} else {
+		deltaY = Math.min(height - 1, deltaY);
+	}
+
+	if (incrementalDeltaY < 0) {
+		incrementalDeltaY = Math.max(-(height - 1), incrementalDeltaY);
+	} else {
+		incrementalDeltaY = Math.min(height - 1, incrementalDeltaY);
+	}
+
+	final int firstPosition = mFirstPosition;
+
+	// Update our guesses for where the first and last views are
+	if (firstPosition == 0) {
+		mFirstPositionDistanceGuess = firstTop - listPadding.top;
+	} else {
+		mFirstPositionDistanceGuess += incrementalDeltaY;
+	}
+	if (firstPosition + childCount == mItemCount) {
+		mLastPositionDistanceGuess = lastBottom + listPadding.bottom;
+	} else {
+		mLastPositionDistanceGuess += incrementalDeltaY;
+	}
+
+	final boolean cannotScrollDown = (firstPosition == 0 &&
+			firstTop >= listPadding.top && incrementalDeltaY >= 0);
+	final boolean cannotScrollUp = (firstPosition + childCount == mItemCount &&
+			lastBottom <= getHeight() - listPadding.bottom && incrementalDeltaY <= 0);
+
+	if (cannotScrollDown || cannotScrollUp) {
+		return incrementalDeltaY != 0;
+	}
+	// 判断向上还是向下
+	final boolean down = incrementalDeltaY < 0;
+
+	final boolean inTouchMode = isInTouchMode();
+	if (inTouchMode) {
+		hideSelector();
+	}
+
+	final int headerViewsCount = getHeaderViewsCount();
+	final int footerViewsStart = mItemCount - getFooterViewsCount();
+
+	int start = 0;
+	int count = 0;
+
+	if (down) {
+		int top = -incrementalDeltaY;
+		if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
+			top += listPadding.top;
+		}
+		for (int i = 0; i < childCount; i++) {
+			final View child = getChildAt(i);
+			if (child.getBottom() >= top) {
+				break;
+			} else {
+			    // 如果这个View的底部位置已经小于top值了，说明这个view已经移除屏幕了，不可见了
+				count++;
+				int position = firstPosition + i;
+				if (position >= headerViewsCount && position < footerViewsStart) {
+					// The view will be rebound to new data, clear any
+					// system-managed transient state.
+					child.clearAccessibilityFocus();
+					// 只要该view移除屏幕就把该view添加到废弃的缓存中
+					mRecycler.addScrapView(child, position);
+				}
+			}
+		}
+	} else {
+		int bottom = getHeight() - incrementalDeltaY;
+		if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
+			bottom -= listPadding.bottom;
+		}
+		for (int i = childCount - 1; i >= 0; i--) {
+			final View child = getChildAt(i);
+			if (child.getTop() <= bottom) {
+				break;
+			} else {
+				start = i;
+				count++;
+				int position = firstPosition + i;
+				if (position >= headerViewsCount && position < footerViewsStart) {
+					// The view will be rebound to new data, clear any
+					// system-managed transient state.
+					child.clearAccessibilityFocus();
+					mRecycler.addScrapView(child, position);
+				}
+			}
+		}
+	}
+
+	mMotionViewNewTop = mMotionViewOriginalTop + deltaY;
+
+	mBlockLayoutRequests = true;
+
+	// count记录了当前已经移除屏幕的view个数
+	if (count > 0) {
+	    // 把已经移除的View从ViewGroup总detach掉
+		detachViewsFromParent(start, count);
+		mRecycler.removeSkippedScrap();
+	}
+
+	// invalidate before moving the children to avoid unnecessary invalidate
+	// calls to bubble up from the children all the way to the top
+	if (!awakenScrollBars()) {
+	   invalidate();
+	}
+
+	// 这个方法让所有的子view都按照这个参数的距离大小进行改变，这样就实现了移动也就是滑动的功能。
+	offsetChildrenTopAndBottom(incrementalDeltaY);
+
+	if (down) {
+		mFirstPosition += count;
+	}
+
+	final int absIncrementalDeltaY = Math.abs(incrementalDeltaY);
+	if (spaceAbove < absIncrementalDeltaY || spaceBelow < absIncrementalDeltaY) {
+	    // 第一个View的顶部移入了屏幕或者最后一个View的底部移入了屏幕
+		fillGap(down);
+	}
+
+	if (!inTouchMode && mSelectedPosition != INVALID_POSITION) {
+		final int childIndex = mSelectedPosition - mFirstPosition;
+		if (childIndex >= 0 && childIndex < getChildCount()) {
+			positionSelector(mSelectedPosition, getChildAt(childIndex));
+		}
+	} else if (mSelectorPosition != INVALID_POSITION) {
+		final int childIndex = mSelectorPosition - mFirstPosition;
+		if (childIndex >= 0 && childIndex < getChildCount()) {
+			positionSelector(INVALID_POSITION, getChildAt(childIndex));
+		}
+	} else {
+		mSelectorRect.setEmpty();
+	}
+
+	mBlockLayoutRequests = false;
+
+	invokeOnItemScrollListener();
+
+	return false;
+}
+```
+
+继续看一下`offsetChildrenTopAndBottom()`方法的，在`AbsListView`中没有重写该方法，具体要看其父类`ViewGroup`中的实现:       `
+```java
+/**
+ * Offset the vertical location of all children of this view by the specified number of pixels.
+ *
+ * @param offset the number of pixels to offset
+ *
+ * @hide
+ */
+public void offsetChildrenTopAndBottom(int offset) {
+	final int count = mChildrenCount;
+	final View[] children = mChildren;
+	boolean invalidate = false;
+
+	for (int i = 0; i < count; i++) {
+	    // 把所有的view都移动指定的距离
+		final View v = children[i];
+		v.mTop += offset;
+		v.mBottom += offset;
+		if (v.mRenderNode != null) {
+			invalidate = true;
+			v.mRenderNode.offsetTopAndBottom(offset);
+		}
+	}
+
+	if (invalidate) {
+		invalidateViewProperty(false, false);
+	}
+	notifySubtreeAccessibilityStateChangedIfNeeded();
+}
+```
+
+再看一下`fillGap()`方法的实现:     
+```java
+/**
+ * Fills the gap left open by a touch-scroll. During a touch scroll, children that
+ * remain on screen are shifted and the other ones are discarded. The role of this
+ * method is to fill the gap thus created by performing a partial layout in the
+ * empty space.
+ *
+ * @param down true if the scroll is going down, false if it is going up
+ */
+abstract void fillGap(boolean down);
+```
+发现在`AbsListView`中该方法是抽象的，所以我们要再`ListView`中找一下他的具体实现类:       
+```java
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    void fillGap(boolean down) {
+        final int count = getChildCount();
+        if (down) {
+            int paddingTop = 0;
+            if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
+                paddingTop = getListPaddingTop();
+            }
+            final int startOffset = count > 0 ? getChildAt(count - 1).getBottom() + mDividerHeight :
+                    paddingTop;
+            fillDown(mFirstPosition + count, startOffset);
+            correctTooHigh(getChildCount());
+        } else {
+            int paddingBottom = 0;
+            if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {
+                paddingBottom = getListPaddingBottom();
+            }
+            final int startOffset = count > 0 ? getChildAt(0).getTop() - mDividerHeight :
+                    getHeight() - paddingBottom;
+            fillUp(mFirstPosition - 1, startOffset);
+            correctTooLow(getChildCount());
+        }
+    }
+```
+可以看到他会分别根据向下滑动还是向上滑动去调用`fillDown`和`fillUp`两个方法，这两个方法之前我们都分析过了，就不再继续看了。
+
+到这里基本就把滑动部分的处理都看完了。
+还剩最后一个问题就是`RecycleBin`的实现,他是`AbsListView`中的一个内部类。
+                 
+直接上代码了，他的注释也说的非常清楚，我就把不好理解的地方简单说一下:    
+```java
+/**
+ * The RecycleBin facilitates reuse of views across layouts. The RecycleBin has two levels of
+ * storage: ActiveViews and ScrapViews. ActiveViews are those views which were onscreen at the
+ * start of a layout. By construction, they are displaying current information. At the end of
+ * layout, all views in ActiveViews are demoted to ScrapViews. ScrapViews are old views that
+ * could potentially be used by the adapter to avoid allocating views unnecessarily.
+ *
+ * @see android.widget.AbsListView#setRecyclerListener(android.widget.AbsListView.RecyclerListener)
+ * @see android.widget.AbsListView.RecyclerListener
+ */
+class RecycleBin {
+	private RecyclerListener mRecyclerListener;
+
+	/**
+	 * The position of the first view stored in mActiveViews.
+	 */
+	private int mFirstActivePosition;
+
+	/**
+	 * Views that were on screen at the start of layout. This array is populated at the start of
+	 * layout, and at the end of layout all view in mActiveViews are moved to mScrapViews.
+	 * Views in mActiveViews represent a contiguous range of Views, with position of the first
+	 * view store in mFirstActivePosition.
+	 */
+	private View[] mActiveViews = new View[0];
+
+	/**
+	 * 为什么是个数组呢？因为ListView会有多种不同的ViewType啊。
+	 * Unsorted views that can be used by the adapter as a convert view.
+	 */
+	private ArrayList<View>[] mScrapViews;
+
+	private int mViewTypeCount;
+	// mScrapViews数组中的第一个元素，方便在ViewType是1的时候使用
+	private ArrayList<View> mCurrentScrap;
+
+	private ArrayList<View> mSkippedScrap;
+
+	private SparseArray<View> mTransientStateViews;
+	private LongSparseArray<View> mTransientStateViewsById;
+
+	public void setViewTypeCount(int viewTypeCount) {
+		if (viewTypeCount < 1) {
+			throw new IllegalArgumentException("Can't have a viewTypeCount < 1");
+		}
+		// 根据ViewType的数量来创建，因为ViewType可以有多中类型，每种不同类型的View肯定要分开单独进行缓存和复用的。
+		//noinspection unchecked
+		ArrayList<View>[] scrapViews = new ArrayList[viewTypeCount];
+		for (int i = 0; i < viewTypeCount; i++) {
+			scrapViews[i] = new ArrayList<View>();
+		}
+		mViewTypeCount = viewTypeCount;
+		mCurrentScrap = scrapViews[0];
+		mScrapViews = scrapViews;
+	}
+
+	// 方法名说明了一切
+	public void markChildrenDirty() {
+		if (mViewTypeCount == 1) {
+			final ArrayList<View> scrap = mCurrentScrap;
+			final int scrapCount = scrap.size();
+			for (int i = 0; i < scrapCount; i++) {
+				scrap.get(i).forceLayout();
+			}
+		} else {
+			final int typeCount = mViewTypeCount;
+			for (int i = 0; i < typeCount; i++) {
+				final ArrayList<View> scrap = mScrapViews[i];
+				final int scrapCount = scrap.size();
+				for (int j = 0; j < scrapCount; j++) {
+					scrap.get(j).forceLayout();
+				}
+			}
+		}
+		if (mTransientStateViews != null) {
+			final int count = mTransientStateViews.size();
+			for (int i = 0; i < count; i++) {
+				mTransientStateViews.valueAt(i).forceLayout();
+			}
+		}
+		if (mTransientStateViewsById != null) {
+			final int count = mTransientStateViewsById.size();
+			for (int i = 0; i < count; i++) {
+				mTransientStateViewsById.valueAt(i).forceLayout();
+			}
+		}
+	}
+
+	public boolean shouldRecycleViewType(int viewType) {
+		return viewType >= 0;
+	}
+
+	/**
+	 * Clears the scrap heap.
+	 */
+	void clear() {
+		if (mViewTypeCount == 1) {
+			final ArrayList<View> scrap = mCurrentScrap;
+			clearScrap(scrap);
+		} else {
+			final int typeCount = mViewTypeCount;
+			for (int i = 0; i < typeCount; i++) {
+				final ArrayList<View> scrap = mScrapViews[i];
+				clearScrap(scrap);
+			}
+		}
+
+		clearTransientStateViews();
+	}
+
+	/**
+	 * Fill ActiveViews with all of the children of the AbsListView.
+	 * 将View存储到mActiveViews数组中
+	 * @param childCount The minimum number of views mActiveViews should hold
+	 * @param firstActivePosition The position of the first view that will be stored in
+	 *        mActiveViews
+	 */
+	void fillActiveViews(int childCount, int firstActivePosition) {
+		if (mActiveViews.length < childCount) {
+			mActiveViews = new View[childCount];
+		}
+		mFirstActivePosition = firstActivePosition;
+
+		//noinspection MismatchedReadAndWriteOfArray
+		final View[] activeViews = mActiveViews;
+		for (int i = 0; i < childCount; i++) {
+			View child = getChildAt(i);
+			AbsListView.LayoutParams lp = (AbsListView.LayoutParams) child.getLayoutParams();
+			// Don't put header or footer views into the scrap heap
+			if (lp != null && lp.viewType != ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
+				// Note:  We do place AdapterView.ITEM_VIEW_TYPE_IGNORE in active views.
+				//        However, we will NOT place them into scrap views.
+				activeViews[i] = child;
+				// Remember the position so that setupChild() doesn't reset state.
+				lp.scrappedFromPosition = firstActivePosition + i;
+			}
+		}
+	}
+
+	/**
+	 * Get the view corresponding to the specified position. The view will be removed from
+	 * mActiveViews if it is found.注释说了获取完之后就会从mActiveViews中移除，这是很好理解的
+	 * 因为获取了就是说这个View已经显示到当前的ListView中了，肯定不能再复用他了。
+	 *
+	 * @param position The position to look up in mActiveViews
+	 * @return The view if it is found, null otherwise
+	 */
+	View getActiveView(int position) {
+		int index = position - mFirstActivePosition;
+		final View[] activeViews = mActiveViews;
+		if (index >=0 && index < activeViews.length) {
+			final View match = activeViews[index];
+			activeViews[index] = null;
+			return match;
+		}
+		return null;
+	}
+
+	View getTransientStateView(int position) {
+		if (mAdapter != null && mAdapterHasStableIds && mTransientStateViewsById != null) {
+			long id = mAdapter.getItemId(position);
+			View result = mTransientStateViewsById.get(id);
+			mTransientStateViewsById.remove(id);
+			return result;
+		}
+		if (mTransientStateViews != null) {
+			final int index = mTransientStateViews.indexOfKey(position);
+			if (index >= 0) {
+				View result = mTransientStateViews.valueAt(index);
+				mTransientStateViews.removeAt(index);
+				return result;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Dumps and fully detaches any currently saved views with transient
+	 * state.
+	 */
+	void clearTransientStateViews() {
+		final SparseArray<View> viewsByPos = mTransientStateViews;
+		if (viewsByPos != null) {
+			final int N = viewsByPos.size();
+			for (int i = 0; i < N; i++) {
+				removeDetachedView(viewsByPos.valueAt(i), false);
+			}
+			viewsByPos.clear();
+		}
+
+		final LongSparseArray<View> viewsById = mTransientStateViewsById;
+		if (viewsById != null) {
+			final int N = viewsById.size();
+			for (int i = 0; i < N; i++) {
+				removeDetachedView(viewsById.valueAt(i), false);
+			}
+			viewsById.clear();
+		}
+	}
+
+	/**
+	 * 从废弃View的缓存中获取，只要移动出屏幕之后就都会被加到废弃View的缓存中 
+	 * @return A view from the ScrapViews collection. These are unordered.
+	 */
+	View getScrapView(int position) {
+		if (mViewTypeCount == 1) {
+			return retrieveFromScrap(mCurrentScrap, position);
+		} else {
+			final int whichScrap = mAdapter.getItemViewType(position);
+			if (whichScrap >= 0 && whichScrap < mScrapViews.length) {
+				return retrieveFromScrap(mScrapViews[whichScrap], position);
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Puts a view into the list of scrap views.
+	 * <p>
+	 * If the list data hasn't changed or the adapter has stable IDs, views
+	 * with transient state will be preserved for later retrieval.
+	 *
+	 * @param scrap The view to add
+	 * @param position The view's position within its parent
+	 */
+	void addScrapView(View scrap, int position) {
+		final AbsListView.LayoutParams lp = (AbsListView.LayoutParams) scrap.getLayoutParams();
+		if (lp == null) {
+			return;
+		}
+
+		lp.scrappedFromPosition = position;
+
+		// Remove but don't scrap header or footer views, or views that
+		// should otherwise not be recycled.
+		final int viewType = lp.viewType;
+		if (!shouldRecycleViewType(viewType)) {
+			return;
+		}
+
+		scrap.dispatchStartTemporaryDetach();
+
+		// The the accessibility state of the view may change while temporary
+		// detached and we do not allow detached views to fire accessibility
+		// events. So we are announcing that the subtree changed giving a chance
+		// to clients holding on to a view in this subtree to refresh it.
+		notifyViewAccessibilityStateChangedIfNeeded(
+				AccessibilityEvent.CONTENT_CHANGE_TYPE_SUBTREE);
+		
+		// 对一些瞬态View的处理
+		// Don't scrap views that have transient state.
+		final boolean scrapHasTransientState = scrap.hasTransientState();
+		if (scrapHasTransientState) {
+			if (mAdapter != null && mAdapterHasStableIds) {
+				// If the adapter has stable IDs, we can reuse the view for
+				// the same data.
+				if (mTransientStateViewsById == null) {
+					mTransientStateViewsById = new LongSparseArray<View>();
+				}
+				mTransientStateViewsById.put(lp.itemId, scrap);
+			} else if (!mDataChanged) {
+				// If the data hasn't changed, we can reuse the views at
+				// their old positions.
+				if (mTransientStateViews == null) {
+					mTransientStateViews = new SparseArray<View>();
+				}
+				mTransientStateViews.put(position, scrap);
+			} else {
+				// Otherwise, we'll have to remove the view and start over.
+				if (mSkippedScrap == null) {
+					mSkippedScrap = new ArrayList<View>();
+				}
+				mSkippedScrap.add(scrap);
+			}
+		} else {
+			if (mViewTypeCount == 1) {
+				mCurrentScrap.add(scrap);
+			} else {
+				mScrapViews[viewType].add(scrap);
+			}
+
+			if (mRecyclerListener != null) {
+				mRecyclerListener.onMovedToScrapHeap(scrap);
+			}
+		}
+	}
+
+	/**
+	 * Finish the removal of any views that skipped the scrap heap.
+	 */
+	void removeSkippedScrap() {
+		if (mSkippedScrap == null) {
+			return;
+		}
+		final int count = mSkippedScrap.size();
+		for (int i = 0; i < count; i++) {
+			removeDetachedView(mSkippedScrap.get(i), false);
+		}
+		mSkippedScrap.clear();
+	}
+
+	/**
+	 * Move all views remaining in mActiveViews to mScrapViews.
+	 */
+	void scrapActiveViews() {
+		final View[] activeViews = mActiveViews;
+		final boolean hasListener = mRecyclerListener != null;
+		final boolean multipleScraps = mViewTypeCount > 1;
+
+		ArrayList<View> scrapViews = mCurrentScrap;
+		final int count = activeViews.length;
+		for (int i = count - 1; i >= 0; i--) {
+			final View victim = activeViews[i];
+			if (victim != null) {
+				final AbsListView.LayoutParams lp
+						= (AbsListView.LayoutParams) victim.getLayoutParams();
+				final int whichScrap = lp.viewType;
+
+				activeViews[i] = null;
+
+				if (victim.hasTransientState()) {
+					// Store views with transient state for later use.
+					victim.dispatchStartTemporaryDetach();
+
+					if (mAdapter != null && mAdapterHasStableIds) {
+						if (mTransientStateViewsById == null) {
+							mTransientStateViewsById = new LongSparseArray<View>();
+						}
+						long id = mAdapter.getItemId(mFirstActivePosition + i);
+						mTransientStateViewsById.put(id, victim);
+					} else if (!mDataChanged) {
+						if (mTransientStateViews == null) {
+							mTransientStateViews = new SparseArray<View>();
+						}
+						mTransientStateViews.put(mFirstActivePosition + i, victim);
+					} else if (whichScrap != ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
+						// The data has changed, we can't keep this view.
+						removeDetachedView(victim, false);
+					}
+				} else if (!shouldRecycleViewType(whichScrap)) {
+					// Discard non-recyclable views except headers/footers.
+					if (whichScrap != ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
+						removeDetachedView(victim, false);
+					}
+				} else {
+					// Store everything else on the appropriate scrap heap.
+					if (multipleScraps) {
+						scrapViews = mScrapViews[whichScrap];
+					}
+
+					victim.dispatchStartTemporaryDetach();
+					lp.scrappedFromPosition = mFirstActivePosition + i;
+					scrapViews.add(victim);
+
+					if (hasListener) {
+						mRecyclerListener.onMovedToScrapHeap(victim);
+					}
+				}
+			}
+		}
+
+		pruneScrapViews();
+	}
+
+	/**
+	 * Makes sure that the size of mScrapViews does not exceed the size of
+	 * mActiveViews, which can happen if an adapter does not recycle its
+	 * views. Removes cached transient state views that no longer have
+	 * transient state.
+	 */
+	private void pruneScrapViews() {
+		final int maxViews = mActiveViews.length;
+		final int viewTypeCount = mViewTypeCount;
+		final ArrayList<View>[] scrapViews = mScrapViews;
+		for (int i = 0; i < viewTypeCount; ++i) {
+			final ArrayList<View> scrapPile = scrapViews[i];
+			int size = scrapPile.size();
+			final int extras = size - maxViews;
+			size--;
+			for (int j = 0; j < extras; j++) {
+				removeDetachedView(scrapPile.remove(size--), false);
+			}
+		}
+
+		final SparseArray<View> transViewsByPos = mTransientStateViews;
+		if (transViewsByPos != null) {
+			for (int i = 0; i < transViewsByPos.size(); i++) {
+				final View v = transViewsByPos.valueAt(i);
+				if (!v.hasTransientState()) {
+					removeDetachedView(v, false);
+					transViewsByPos.removeAt(i);
+					i--;
+				}
+			}
+		}
+
+		final LongSparseArray<View> transViewsById = mTransientStateViewsById;
+		if (transViewsById != null) {
+			for (int i = 0; i < transViewsById.size(); i++) {
+				final View v = transViewsById.valueAt(i);
+				if (!v.hasTransientState()) {
+					removeDetachedView(v, false);
+					transViewsById.removeAt(i);
+					i--;
+				}
+			}
+		}
+	}
+
+	/**
+	 * Puts all views in the scrap heap into the supplied list.
+	 */
+	void reclaimScrapViews(List<View> views) {
+		if (mViewTypeCount == 1) {
+			views.addAll(mCurrentScrap);
+		} else {
+			final int viewTypeCount = mViewTypeCount;
+			final ArrayList<View>[] scrapViews = mScrapViews;
+			for (int i = 0; i < viewTypeCount; ++i) {
+				final ArrayList<View> scrapPile = scrapViews[i];
+				views.addAll(scrapPile);
+			}
+		}
+	}
+
+	/**
+	 * Updates the cache color hint of all known views.
+	 *
+	 * @param color The new cache color hint.
+	 */
+	void setCacheColorHint(int color) {
+		if (mViewTypeCount == 1) {
+			final ArrayList<View> scrap = mCurrentScrap;
+			final int scrapCount = scrap.size();
+			for (int i = 0; i < scrapCount; i++) {
+				scrap.get(i).setDrawingCacheBackgroundColor(color);
+			}
+		} else {
+			final int typeCount = mViewTypeCount;
+			for (int i = 0; i < typeCount; i++) {
+				final ArrayList<View> scrap = mScrapViews[i];
+				final int scrapCount = scrap.size();
+				for (int j = 0; j < scrapCount; j++) {
+					scrap.get(j).setDrawingCacheBackgroundColor(color);
+				}
+			}
+		}
+		// Just in case this is called during a layout pass
+		final View[] activeViews = mActiveViews;
+		final int count = activeViews.length;
+		for (int i = 0; i < count; ++i) {
+			final View victim = activeViews[i];
+			if (victim != null) {
+				victim.setDrawingCacheBackgroundColor(color);
+			}
+		}
+	}
+
+	private View retrieveFromScrap(ArrayList<View> scrapViews, int position) {
+		final int size = scrapViews.size();
+		if (size > 0) {
+			// See if we still have a view for this position or ID.
+			for (int i = 0; i < size; i++) {
+				final View view = scrapViews.get(i);
+				final AbsListView.LayoutParams params =
+						(AbsListView.LayoutParams) view.getLayoutParams();
+
+				if (mAdapterHasStableIds) {
+					final long id = mAdapter.getItemId(position);
+					if (id == params.itemId) {
+						return scrapViews.remove(i);
+					}
+				} else if (params.scrappedFromPosition == position) {
+					final View scrap = scrapViews.remove(i);
+					clearAccessibilityFromScrap(scrap);
+					return scrap;
+				}
+			}
+			final View scrap = scrapViews.remove(size - 1);
+			clearAccessibilityFromScrap(scrap);
+			return scrap;
+		} else {
+			return null;
+		}
+	}
+
+	private void clearScrap(final ArrayList<View> scrap) {
+		final int scrapCount = scrap.size();
+		for (int j = 0; j < scrapCount; j++) {
+			removeDetachedView(scrap.remove(scrapCount - 1 - j), false);
+		}
+	}
+
+	private void clearAccessibilityFromScrap(View view) {
+		view.clearAccessibilityFocus();
+		view.setAccessibilityDelegate(null);
+	}
+
+	private void removeDetachedView(View child, boolean animate) {
+		child.setAccessibilityDelegate(null);
+		AbsListView.this.removeDetachedView(child, animate);
+	}
+}
+```
+
+到此为止。
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Android\345\212\240\345\274\272/HttpURLConnection\344\270\216HttpClient.md" "b/SourceAnalysis/Netowork/HttpURLConnection\344\270\216HttpClient.md"
similarity index 54%
rename from "Android\345\212\240\345\274\272/HttpURLConnection\344\270\216HttpClient.md"
rename to "SourceAnalysis/Netowork/HttpURLConnection\344\270\216HttpClient.md"
index dcdff9fc..aa8688af 100644
--- "a/Android\345\212\240\345\274\272/HttpURLConnection\344\270\216HttpClient.md"
+++ "b/SourceAnalysis/Netowork/HttpURLConnection\344\270\216HttpClient.md"
@@ -1,4 +1,4 @@
-HttpURLConnection与HttpClient
+HttpURLConnection与HttpClient
 ===
 
 - `Java`的`HttpURLConnection`     
@@ -6,8 +6,8 @@
 - `Apache`的`HttpClient`       
     请求默认不带`Gzip`压缩。
 	
-一般对于`API`请求返回的数据大多是`Json`类的字符串，`Gzip`压缩可以使数据大小大幅降低。`Retrofit`及`Volley`框架默认在`Android Gingerbread(API 9)`及以上都是用`HttpURLConnection`，
-9以下用`HttpClient`。       
+一般对于`API`请求返回的数据大多是`Json`类的字符串，`Gzip`压缩可以使数据大小大幅降低。
+`Retrofit`及`Volley`框架默认在`Android Gingerbread(API 9)`及以上都是用`HttpURLConnection`，9以下用`HttpClient`。       
 
 ---
 
diff --git "a/SourceAnalysis/Netowork/HttpURLConnection\350\257\246\350\247\243.md" "b/SourceAnalysis/Netowork/HttpURLConnection\350\257\246\350\247\243.md"
new file mode 100644
index 00000000..2c1e28bf
--- /dev/null
+++ "b/SourceAnalysis/Netowork/HttpURLConnection\350\257\246\350\247\243.md"
@@ -0,0 +1,1621 @@
+Android HttpURLConnection源码分析
+---
+
+之前写过HttpURLConnection与HttpClient的区别及选择。后来又分析了Volley的源码。
+最近又遇到了问题，想在Volley中针对HttpURLConnection添加连接池的功能，开始有点懵了，不知道HttpURLConnection要怎么加连接池，
+虽然感觉这是没必要的，但是心底确拿不出依据。所以研究下HttpURLConnection的源码进行分析。
+
+
+在使用的时候都是通过URL.openConnection()来获取`HttpURLConnection`对象，然后调用其`connect`方法进行链接，所以先从`URL.penConnection()`入手:    
+```java
+/**
+ * Returns a new connection to the resource referred to by this URL.
+ *
+ * @throws IOException if an error occurs while opening the connection.
+ */
+public URLConnection openConnection() throws IOException {
+    return streamHandler.openConnection(this);
+}
+```
+
+接下来就要看一下`streamHandler`究竟是何方神圣？我们搜一下他的赋值，是在`setupStreamHandler`方法中进行的：    
+```java
+/**
+ * Sets the receiver's stream handler to one which is appropriate for its
+ * protocol.
+ *
+ * <p>Note that this will overwrite any existing stream handler with the new
+ * one. Senders must check if the streamHandler is null before calling the
+ * method if they do not want this behavior (a speed optimization).
+ *
+ * @throws MalformedURLException if no reasonable handler is available.
+ */
+void setupStreamHandler() {
+    // Check for a cached (previously looked up) handler for
+    // the requested protocol.
+    streamHandler = streamHandlers.get(protocol);
+    if (streamHandler != null) {
+        return;
+    }
+
+    // If there is a stream handler factory, then attempt to
+    // use it to create the handler.
+    if (streamHandlerFactory != null) {
+        streamHandler = streamHandlerFactory.createURLStreamHandler(protocol);
+        if (streamHandler != null) {
+            streamHandlers.put(protocol, streamHandler);
+            return;
+        }
+    }
+
+    // Check if there is a list of packages which can provide handlers.
+    // If so, then walk this list looking for an applicable one.
+    String packageList = System.getProperty("java.protocol.handler.pkgs");
+    ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
+    if (packageList != null && contextClassLoader != null) {
+        for (String packageName : packageList.split("\\|")) {
+            String className = packageName + "." + protocol + ".Handler";
+            try {
+                Class<?> c = contextClassLoader.loadClass(className);
+                streamHandler = (URLStreamHandler) c.newInstance();
+                if (streamHandler != null) {
+                    streamHandlers.put(protocol, streamHandler);
+                }
+                return;
+            } catch (IllegalAccessException ignored) {
+            } catch (InstantiationException ignored) {
+            } catch (ClassNotFoundException ignored) {
+            }
+        }
+    }
+
+    // Fall back to a built-in stream handler if the user didn't supply one
+    if (protocol.equals("file")) {
+        streamHandler = new FileHandler();
+    } else if (protocol.equals("ftp")) {
+        streamHandler = new FtpHandler();
+    } else if (protocol.equals("http")) {
+        // 判断一下如果是HTTP协议，就会创建HtppHandler。看到这里明白了，原来使用的是okhttp.
+        try {
+            String name = "com.android.okhttp.HttpHandler";
+            streamHandler = (URLStreamHandler) Class.forName(name).newInstance();
+        } catch (Exception e) {
+            throw new AssertionError(e);
+        }
+    } else if (protocol.equals("https")) {
+        try {
+            String name = "com.android.okhttp.HttpsHandler";
+            streamHandler = (URLStreamHandler) Class.forName(name).newInstance();
+        } catch (Exception e) {
+         throw new AssertionError(e);
+        }
+    } else if (protocol.equals("jar")) {
+        streamHandler = new JarHandler();
+    }
+    if (streamHandler != null) {
+        streamHandlers.put(protocol, streamHandler);
+    }
+}
+```
+这里我们就以`HTTP`协议为例说一下所以找到`okhttp HttpHandler.openConnection()`方法:     
+```java    
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You 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.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package com.squareup.okhttp;
+import java.io.IOException;
+import java.net.Proxy;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+public final class HttpHandler extends URLStreamHandler {
+    @Override protected URLConnection openConnection(URL url) throws IOException {
+        // 调用了OKHttpClient()的方法
+        return new OkHttpClient().open(url);
+    }
+    @Override protected URLConnection openConnection(URL url, Proxy proxy) throws IOException {
+        if (url == null || proxy == null) {
+            throw new IllegalArgumentException("url == null || proxy == null");
+        }
+        return new OkHttpClient().setProxy(proxy).open(url);
+    }
+    @Override protected int getDefaultPort() {
+        return 80;
+    }
+}
+```
+
+接下来就悲剧了，因为我找不到OkHttpClient()类中有`open`方法。               
+仔细查看了文档后发现在`OKHttp`1.6.0的时候该方法就已经已经过时了。    
+```java
+@Deprecated
+public HttpURLConnection open(URL url)
+Deprecated. moved to OkUrlFactory.open.
+```
+
+那我们怎么往下分析呢？很显然`Android sdk`中使用的`OkHttp`不是最新版。所以我们可以使用`1.5.0`版本的`OKHttp`接着分析。
+在项目`build.gradle`中进行配置 compile 'com.squareup.okhttp:okhttp:1.5.0' 然后开始愉快的查看源码。    
+
+```java
+package com.squareup.okhttp;
+
+import com.squareup.okhttp.internal.Util;
+import com.squareup.okhttp.internal.http.HttpAuthenticator;
+import com.squareup.okhttp.internal.http.HttpURLConnectionImpl;
+import com.squareup.okhttp.internal.http.HttpsURLConnectionImpl;
+import com.squareup.okhttp.internal.http.ResponseCacheAdapter;
+import com.squareup.okhttp.internal.okio.ByteString;
+import com.squareup.okhttp.internal.tls.OkHostnameVerifier;
+import java.io.IOException;
+import java.net.CookieHandler;
+import java.net.HttpURLConnection;
+import java.net.Proxy;
+import java.net.ProxySelector;
+import java.net.ResponseCache;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+import java.net.URLStreamHandlerFactory;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+
+/** Configures and creates HTTP connections. */
+public final class OkHttpClient implements URLStreamHandlerFactory, Cloneable {
+
+  private final RouteDatabase routeDatabase;
+  private Proxy proxy;
+  private List<Protocol> protocols;
+  private ProxySelector proxySelector;
+  private CookieHandler cookieHandler;
+  private OkResponseCache responseCache;
+  private SSLSocketFactory sslSocketFactory;
+  private HostnameVerifier hostnameVerifier;
+  private OkAuthenticator authenticator;
+  private ConnectionPool connectionPool;
+  private boolean followProtocolRedirects = true;
+  private int connectTimeout;
+  private int readTimeout;
+
+  public OkHttpClient() {
+    routeDatabase = new RouteDatabase();
+  }
+
+  /**
+   * Sets the default connect timeout for new connections. A value of 0 means no timeout.
+   *
+   * @see URLConnection#setConnectTimeout(int)
+   */
+  public void setConnectTimeout(long timeout, TimeUnit unit) {
+    if (timeout < 0) {
+      throw new IllegalArgumentException("timeout < 0");
+    }
+    if (unit == null) {
+      throw new IllegalArgumentException("unit == null");
+    }
+    long millis = unit.toMillis(timeout);
+    if (millis > Integer.MAX_VALUE) {
+      throw new IllegalArgumentException("Timeout too large.");
+    }
+    connectTimeout = (int) millis;
+  }
+
+  /** Default connect timeout (in milliseconds). */
+  public int getConnectTimeout() {
+    return connectTimeout;
+  }
+
+  /**
+   * Sets the default read timeout for new connections. A value of 0 means no timeout.
+   *
+   * @see URLConnection#setReadTimeout(int)
+   */
+  public void setReadTimeout(long timeout, TimeUnit unit) {
+    if (timeout < 0) {
+      throw new IllegalArgumentException("timeout < 0");
+    }
+    if (unit == null) {
+      throw new IllegalArgumentException("unit == null");
+    }
+    long millis = unit.toMillis(timeout);
+    if (millis > Integer.MAX_VALUE) {
+      throw new IllegalArgumentException("Timeout too large.");
+    }
+    readTimeout = (int) millis;
+  }
+
+  /** Default read timeout (in milliseconds). */
+  public int getReadTimeout() {
+    return readTimeout;
+  }
+
+  /**
+   * Sets the HTTP proxy that will be used by connections created by this
+   * client. This takes precedence over {@link #setProxySelector}, which is
+   * only honored when this proxy is null (which it is by default). To disable
+   * proxy use completely, call {@code setProxy(Proxy.NO_PROXY)}.
+   */
+  public OkHttpClient setProxy(Proxy proxy) {
+    this.proxy = proxy;
+    return this;
+  }
+
+  public Proxy getProxy() {
+    return proxy;
+  }
+
+  /**
+   * Sets the proxy selection policy to be used if no {@link #setProxy proxy}
+   * is specified explicitly. The proxy selector may return multiple proxies;
+   * in that case they will be tried in sequence until a successful connection
+   * is established.
+   *
+   * <p>If unset, the {@link ProxySelector#getDefault() system-wide default}
+   * proxy selector will be used.
+   */
+  public OkHttpClient setProxySelector(ProxySelector proxySelector) {
+    this.proxySelector = proxySelector;
+    return this;
+  }
+
+  public ProxySelector getProxySelector() {
+    return proxySelector;
+  }
+
+  /**
+   * Sets the cookie handler to be used to read outgoing cookies and write
+   * incoming cookies.
+   *
+   * <p>If unset, the {@link CookieHandler#getDefault() system-wide default}
+   * cookie handler will be used.
+   */
+  public OkHttpClient setCookieHandler(CookieHandler cookieHandler) {
+    this.cookieHandler = cookieHandler;
+    return this;
+  }
+
+  public CookieHandler getCookieHandler() {
+    return cookieHandler;
+  }
+
+  /**
+   * Sets the response cache to be used to read and write cached responses.
+   */
+  public OkHttpClient setResponseCache(ResponseCache responseCache) {
+    return setOkResponseCache(toOkResponseCache(responseCache));
+  }
+
+  public ResponseCache getResponseCache() {
+    return responseCache instanceof ResponseCacheAdapter
+        ? ((ResponseCacheAdapter) responseCache).getDelegate()
+        : null;
+  }
+
+  public OkHttpClient setOkResponseCache(OkResponseCache responseCache) {
+    this.responseCache = responseCache;
+    return this;
+  }
+
+  public OkResponseCache getOkResponseCache() {
+    return responseCache;
+  }
+
+  /**
+   * Sets the socket factory used to secure HTTPS connections.
+   *
+   * <p>If unset, a lazily created SSL socket factory will be used.
+   */
+  public OkHttpClient setSslSocketFactory(SSLSocketFactory sslSocketFactory) {
+    this.sslSocketFactory = sslSocketFactory;
+    return this;
+  }
+
+  public SSLSocketFactory getSslSocketFactory() {
+    return sslSocketFactory;
+  }
+
+  /**
+   * Sets the verifier used to confirm that response certificates apply to
+   * requested hostnames for HTTPS connections.
+   *
+   * <p>If unset, the
+   * {@link javax.net.ssl.HttpsURLConnection#getDefaultHostnameVerifier()
+   * system-wide default} hostname verifier will be used.
+   */
+  public OkHttpClient setHostnameVerifier(HostnameVerifier hostnameVerifier) {
+    this.hostnameVerifier = hostnameVerifier;
+    return this;
+  }
+
+  public HostnameVerifier getHostnameVerifier() {
+    return hostnameVerifier;
+  }
+
+  /**
+   * Sets the authenticator used to respond to challenges from the remote web
+   * server or proxy server.
+   *
+   * <p>If unset, the {@link java.net.Authenticator#setDefault system-wide default}
+   * authenticator will be used.
+   */
+  public OkHttpClient setAuthenticator(OkAuthenticator authenticator) {
+    this.authenticator = authenticator;
+    return this;
+  }
+
+  public OkAuthenticator getAuthenticator() {
+    return authenticator;
+  }
+
+  /**
+   * Sets the connection pool used to recycle HTTP and HTTPS connections.
+   *
+   * <p>If unset, the {@link ConnectionPool#getDefault() system-wide
+   * default} connection pool will be used.
+   */
+  public OkHttpClient setConnectionPool(ConnectionPool connectionPool) {
+    this.connectionPool = connectionPool;
+    return this;
+  }
+
+  public ConnectionPool getConnectionPool() {
+    return connectionPool;
+  }
+
+  /**
+   * Configure this client to follow redirects from HTTPS to HTTP and from HTTP
+   * to HTTPS.
+   *
+   * <p>If unset, protocol redirects will be followed. This is different than
+   * the built-in {@code HttpURLConnection}'s default.
+   */
+  public OkHttpClient setFollowProtocolRedirects(boolean followProtocolRedirects) {
+    this.followProtocolRedirects = followProtocolRedirects;
+    return this;
+  }
+
+  public boolean getFollowProtocolRedirects() {
+    return followProtocolRedirects;
+  }
+
+  public RouteDatabase getRoutesDatabase() {
+    return routeDatabase;
+  }
+
+  /**
+   * @deprecated OkHttp 1.5 enforces an enumeration of {@link Protocol protocols}
+   * that can be selected. Please switch to {@link #setProtocols(java.util.List)}.
+   */
+  @Deprecated
+  public OkHttpClient setTransports(List<String> transports) {
+    List<Protocol> protocols = new ArrayList<Protocol>(transports.size());
+    for (int i = 0, size = transports.size(); i < size; i++) {
+      try {
+        Protocol protocol = Util.getProtocol(ByteString.encodeUtf8(transports.get(i)));
+        protocols.add(protocol);
+      } catch (IOException e) {
+        throw new IllegalArgumentException(e);
+      }
+    }
+    return setProtocols(protocols);
+  }
+
+  /**
+   * Configure the protocols used by this client to communicate with remote
+   * servers. By default this client will prefer the most efficient transport
+   * available, falling back to more ubiquitous protocols. Applications should
+   * only call this method to avoid specific compatibility problems, such as web
+   * servers that behave incorrectly when SPDY is enabled.
+   *
+   * <p>The following protocols are currently supported:
+   * <ul>
+   *   <li><a href="http://www.w3.org/Protocols/rfc2616/rfc2616.html">http/1.1</a>
+   *   <li><a href="http://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1">spdy/3.1</a>
+   *   <li><a href="http://tools.ietf.org/html/draft-ietf-httpbis-http2-09">HTTP-draft-09/2.0</a>
+   * </ul>
+   *
+   * <p><strong>This is an evolving set.</strong> Future releases may drop
+   * support for transitional protocols (like spdy/3.1), in favor of their
+   * successors (spdy/4 or http/2.0). The http/1.1 transport will never be
+   * dropped.
+   *
+   * <p>If multiple protocols are specified, <a
+   * href="https://technotes.googlecode.com/git/nextprotoneg.html">NPN</a> will
+   * be used to negotiate a transport. Future releases may use another mechanism
+   * (such as <a href="http://tools.ietf.org/html/draft-friedl-tls-applayerprotoneg-02">ALPN</a>)
+   * to negotiate a transport.
+   *
+   * @param protocols the protocols to use, in order of preference. The list
+   *     must contain "http/1.1". It must not contain null.
+   */
+  public OkHttpClient setProtocols(List<Protocol> protocols) {
+    protocols = Util.immutableList(protocols);
+    if (!protocols.contains(Protocol.HTTP_11)) {
+      throw new IllegalArgumentException("protocols doesn't contain http/1.1: " + protocols);
+    }
+    if (protocols.contains(null)) {
+      throw new IllegalArgumentException("protocols must not contain null");
+    }
+    this.protocols = Util.immutableList(protocols);
+    return this;
+  }
+
+  /**
+   * @deprecated OkHttp 1.5 enforces an enumeration of {@link Protocol
+   *     protocols} that can be selected. Please switch to {@link
+   *     #getProtocols()}.
+   */
+  @Deprecated
+  public List<String> getTransports() {
+    List<String> transports = new ArrayList<String>(protocols.size());
+    for (int i = 0, size = protocols.size(); i < size; i++) {
+      transports.add(protocols.get(i).name.utf8());
+    }
+    return transports;
+  }
+
+  public List<Protocol> getProtocols() {
+    return protocols;
+  }
+
+  public HttpURLConnection open(URL url) {
+    return open(url, proxy);
+  }
+
+  HttpURLConnection open(URL url, Proxy proxy) {
+    String protocol = url.getProtocol();
+    // 将该对象clone后设置一些其他的属性返回，里面会设置一个默认的连接池。
+    OkHttpClient copy = copyWithDefaults();
+    copy.proxy = proxy;
+    // 返回了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);
+  }
+
+  /**
+   * Returns a shallow copy of this OkHttpClient that uses the system-wide
+   * default for each field that hasn't been explicitly configured.
+   */
+  OkHttpClient copyWithDefaults() {
+    OkHttpClient result = clone();
+    if (result.proxySelector == null) {
+      result.proxySelector = ProxySelector.getDefault();
+    }
+    if (result.cookieHandler == null) {
+      result.cookieHandler = CookieHandler.getDefault();
+    }
+    if (result.responseCache == null) {
+      result.responseCache = toOkResponseCache(ResponseCache.getDefault());
+    }
+    if (result.sslSocketFactory == null) {
+      result.sslSocketFactory = getDefaultSSLSocketFactory();
+    }
+    if (result.hostnameVerifier == null) {
+      result.hostnameVerifier = OkHostnameVerifier.INSTANCE;
+    }
+    if (result.authenticator == null) {
+      result.authenticator = HttpAuthenticator.SYSTEM_DEFAULT;
+    }
+    if (result.connectionPool == null) {
+	  // 会给OkHttpClient设置一个默认的连接池
+      result.connectionPool = ConnectionPool.getDefault();
+    }
+    if (result.protocols == null) {
+      result.protocols = Util.HTTP2_SPDY3_AND_HTTP;
+    }
+    return result;
+  }
+
+  /**
+   * Java and Android programs default to using a single global SSL context,
+   * accessible to HTTP clients as {@link SSLSocketFactory#getDefault()}. If we
+   * used the shared SSL context, when OkHttp enables NPN for its SPDY-related
+   * stuff, it would also enable NPN for other usages, which might crash them
+   * because NPN is enabled when it isn't expected to be.
+   * <p>
+   * This code avoids that by defaulting to an OkHttp created SSL context. The
+   * significant drawback of this approach is that apps that customize the
+   * global SSL context will lose these customizations.
+   */
+  private synchronized SSLSocketFactory getDefaultSSLSocketFactory() {
+    if (sslSocketFactory == null) {
+      try {
+        SSLContext sslContext = SSLContext.getInstance("TLS");
+        sslContext.init(null, null, null);
+        sslSocketFactory = sslContext.getSocketFactory();
+      } catch (GeneralSecurityException e) {
+        throw new AssertionError(); // The system has no TLS. Just give up.
+      }
+    }
+    return sslSocketFactory;
+  }
+
+  /** Returns a shallow copy of this OkHttpClient. */
+  @Override public OkHttpClient clone() {
+    try {
+      return (OkHttpClient) super.clone();
+    } catch (CloneNotSupportedException e) {
+      throw new AssertionError();
+    }
+  }
+
+  private OkResponseCache toOkResponseCache(ResponseCache responseCache) {
+    return responseCache == null || responseCache instanceof OkResponseCache
+        ? (OkResponseCache) responseCache
+        : new ResponseCacheAdapter(responseCache);
+  }
+
+  /**
+   * Creates a URLStreamHandler as a {@link URL#setURLStreamHandlerFactory}.
+   *
+   * <p>This code configures OkHttp to handle all HTTP and HTTPS connections
+   * created with {@link URL#openConnection()}: <pre>   {@code
+   *
+   *   OkHttpClient okHttpClient = new OkHttpClient();
+   *   URL.setURLStreamHandlerFactory(okHttpClient);
+   * }</pre>
+   */
+  public URLStreamHandler createURLStreamHandler(final String protocol) {
+    if (!protocol.equals("http") && !protocol.equals("https")) return null;
+
+    return new URLStreamHandler() {
+      @Override protected URLConnection openConnection(URL url) {
+        return open(url);
+      }
+
+      @Override protected URLConnection openConnection(URL url, Proxy proxy) {
+        return open(url, proxy);
+      }
+
+      @Override protected int getDefaultPort() {
+        if (protocol.equals("http")) return 80;
+        if (protocol.equals("https")) return 443;
+        throw new AssertionError();
+      }
+    };
+  }
+}
+```
+接着看一下`HttpURLConnectionImpl`类,它是`HttpURLConnection`的子类：     
+```java
+public class HttpURLConnectionImpl extends HttpURLConnection {
+    .....
+}
+```
+到这里`new URL(url).openConnection()`方法已经分析完了，其实就是返回了一个HtppURLConnectionImpl对象。    
+
+我们在使用`HttpURLConnection`都是这样使用：    
+```java
+String url = "http://www.baidu.com"
+URL url = new URL(url);
+HttpURLConnection connection = (HttpURLConnection)url.openConnection();
+// 设置一些请求头等参数
+...
+connection.connect();
+// 然后调用一些其他的获取结果或者状态的方法。
+...
+connection.getResponseCode();
+connection.getOuoputStream();
+connection.getInputStream();
+....
+```
+
+上面分析了`new URL().openConnection()`那我们这里就接着分析第二步了，就是调用`connect()`方法的处理:      
+这里看一下`HttpURLConnectionImpl.connect()`方法：   
+```java
+@Override public final void connect() throws IOException {
+initHttpEngine();
+boolean success;
+do {
+  success = execute(false);
+} while (!success);
+}
+```
+
+接着看一下`initHttpEngine()`方法的实现:            
+```java
+private void initHttpEngine() throws IOException {
+    if (httpEngineFailure != null) {
+      throw httpEngineFailure;
+    } else if (httpEngine != null) {
+      return;
+    }
+
+    connected = true;
+    try {
+      if (doOutput) {
+        if (method.equals("GET")) {
+          // they are requesting a stream to write to. This implies a POST method
+          method = "POST";
+        } else if (!HttpMethod.hasRequestBody(method)) {
+          // If the request method is neither POST nor PUT nor PATCH, then you're not writing
+          throw new ProtocolException(method + " does not support writing");
+        }
+      }
+
+      // 将newHttpEngine方法的返回值赋值给HttpEngine的成员变量。
+      httpEngine = newHttpEngine(method, null, null);
+    } catch (IOException e) {
+      httpEngineFailure = e;
+      throw e;
+    }
+  }
+
+  private HttpEngine newHttpEngine(String method, Connection connection,
+      RetryableSink requestBody) {
+    Request.Builder builder = new Request.Builder()
+        .url(getURL())
+        .method(method, null /* No body; that's passed separately. */);
+    Headers headers = requestHeaders.build();
+    for (int i = 0; i < headers.size(); i++) {
+      builder.addHeader(headers.name(i), headers.value(i));
+    }
+
+    boolean bufferRequestBody;
+    if (fixedContentLength != -1) {
+      bufferRequestBody = false;
+      builder.header("Content-Length", Long.toString(fixedContentLength));
+    } else if (chunkLength > 0) {
+      bufferRequestBody = false;
+      builder.header("Transfer-Encoding", "chunked");
+    } else {
+      bufferRequestBody = true;
+    }
+
+    Request request = builder.build();
+
+    // If we're currently not using caches, make sure the engine's client doesn't have one.
+    OkHttpClient engineClient = client;
+    if (engineClient.getOkResponseCache() != null && !getUseCaches()) {
+      engineClient = client.clone().setOkResponseCache(null);
+    }
+	// 将之前通过构造函数传递进来的OkHttpClient对象clone一份后再传递给HttpEngine
+    return new HttpEngine(engineClient, request, bufferRequestBody, connection, null, requestBody);
+  }
+
+```
+
+到这里我们知道他会创建一个`HttpEngine`类，我们先不管它，接着看一下`execute()`方法的内部实现： 
+```java
+/**
+* Sends a request and optionally reads a response. Returns true if the
+* request was successfully executed, and false if the request can be
+* retried. Throws an exception if the request failed permanently.
+*/
+private boolean execute(boolean readResponse) throws IOException {
+try {
+  // 调用了HttpEngine的sendRequest方法。
+  httpEngine.sendRequest();
+  route = httpEngine.getRoute();
+  handshake = httpEngine.getConnection() != null
+      ? httpEngine.getConnection().getHandshake()
+      : null;
+  // 读取结果，我们先不分析这里，等把sendRequest部分全部分析完成后再回来分析readResponse()部分。
+  if (readResponse) {
+    httpEngine.readResponse();
+  }
+
+  return true;
+} catch (IOException e) {
+  HttpEngine retryEngine = httpEngine.recover(e);
+  if (retryEngine != null) {
+    httpEngine = retryEngine;
+    return false;
+  }
+
+  // Give up; recovery is not possible.
+  httpEngineFailure = e;
+  throw e;
+}
+}
+```
+到这里，可以大胆的猜测一下了`HttpEngine`应该就是实际在`Socket`链接上进行数据收发的类。 当然这只是猜测，接着看一下它的实现:      
+```java
+/**
+ * Handles a single HTTP request/response pair. Each HTTP engine follows this
+ * lifecycle:
+ * <ol>
+ * <li>It is created.
+ * <li>The HTTP request message is sent with sendRequest(). Once the request
+ * is sent it is an error to modify the request headers. After
+ * sendRequest() has been called the request body can be written to if
+ * it exists.
+ * <li>The HTTP response message is read with readResponse(). After the
+ * response has been read the response headers and body can be read.
+ * All responses have a response body input stream, though in some
+ * instances this stream is empty.
+ * </ol>
+ *
+ * <p>The request and response may be served by the HTTP response cache, by the
+ * network, or by both in the event of a conditional GET.
+ */
+```
+文档验证了我们的想法。因为它内部实现代码比较多，所以就不全部贴了，按照重要的一步步分析，既然上面调用了`sendRequest()`方法，这里就从他入手：　　　   
+```java
+/**
+* Figures out what the response source will be, and opens a socket to that
+* source if necessary. Prepares the request headers and gets ready to start
+* writing the request body if it exists.
+*/
+public final void sendRequest() throws IOException {
+	if (responseSource != null) return; // Already sent.
+	if (transport != null) throw new IllegalStateException();
+
+	// 设置一些请求头，正式这个方法内部默认设置了`Keep-Alive`的值，也就是在Android Level 9之前因为Bug，我们需要关闭它的具体处理位置。   
+	prepareRawRequestHeaders();
+	// 处理cache
+	OkResponseCache responseCache = client.getOkResponseCache();
+
+	Response cacheResponse = responseCache != null
+		? responseCache.get(request)
+		: null;
+	long now = System.currentTimeMillis();
+	CacheStrategy cacheStrategy = new CacheStrategy.Factory(now, request, cacheResponse).get();
+	responseSource = cacheStrategy.source;
+	request = cacheStrategy.request;
+
+	if (responseCache != null) {
+	  // 记录下当前的请求是来自网络请求还是来时缓存中的数据。
+	  responseCache.trackResponse(responseSource);
+	}
+
+	if (responseSource != ResponseSource.NETWORK) {
+	  validatingResponse = cacheStrategy.response;
+	}
+
+	if (cacheResponse != null && !responseSource.usesCache()) {
+	  closeQuietly(cacheResponse.body()); // We don't need this cached response. Close it.
+	}
+
+	if (responseSource.requiresConnection()) {
+	  // Open a connection unless we inherited one from a redirect.
+	  if (connection == null) {
+		// 调用connect方法，内部会重新创建一个connection，连接到服务器、重定向或者通过代理。
+		connect();
+	  }
+	  // 通过Connection创建一个HttpTransport类。这个和后面的connection类一起看， Transport接口提供了一个用户写Request头和数据的输出流。
+	  transport = (Transport) connection.newTransport(this);
+
+	  // Create a request body if we don't have one already. We'll already have
+	  // one if we're retrying a failed POST.
+	  if (hasRequestBody() && requestBodyOut == null) {
+		// 通过transport创建一个请求体的输出流，requestBodyOut是Sink接口的实现类，其实就是将请求头和请求体发送给服务器。这部分跟下去内容比较多，就不往下跟了。
+	　　　　// 到这里就已经完成了与服务器的连接功能，并且把请求内容发送给服务器。请求部分就执行完了，可以回去了，还知道开头是哪吗？哈哈。接下来的就是从服务器接口读取返回数据了。  
+		requestBodyOut = transport.createRequestBody(request);
+	  }
+
+	} else {
+	  // We're using a cached response. Recycle a connection we may have inherited from a redirect.
+	  if (connection != null) {
+		// 回收connection，这里就看到了连接池，这个client就是构造函数中传递进来的OKHttpClient
+		client.getConnectionPool().recycle(connection);
+		connection = null;
+	  }
+
+	  // No need for the network! Promote the cached response immediately.
+	  this.response = validatingResponse;
+	  if (validatingResponse.body() != null) {
+		initContentStream(validatingResponse.body().source());
+	  }
+	}
+}
+
+```
+
+接着看一下`connect()`方法：     
+```java
+/** Connect to the origin server either directly or via a proxy. */
+private void connect() throws IOException {
+	if (connection != null) throw new IllegalStateException();
+
+	if (routeSelector == null) {
+	  String uriHost = request.url().getHost();
+	  if (uriHost == null || uriHost.length() == 0) {
+		throw new UnknownHostException(request.url().toString());
+	  }
+	  SSLSocketFactory sslSocketFactory = null;
+	  HostnameVerifier hostnameVerifier = null;
+	  if (request.isHttps()) {
+		sslSocketFactory = client.getSslSocketFactory();
+		hostnameVerifier = client.getHostnameVerifier();
+	  }
+	  Address address = new Address(uriHost, getEffectivePort(request.url()), sslSocketFactory,
+		  hostnameVerifier, client.getAuthenticator(), client.getProxy(), client.getProtocols());
+	  // RoteSeclector类介绍. Selects routes to connect to an origin server. Each connection requires a
+	  // choice of proxy server, IP address, and TLS mode. Connections may also be
+	  // recycled.注意他把OkHttpClient中的connection pool传递进来了。
+	  routeSelector = new RouteSelector(address, request.uri(), client.getProxySelector(),
+		  client.getConnectionPool(), Dns.DEFAULT, client.getRoutesDatabase());
+	}
+
+	// roteSeclecrot.next()方法的注释Returns the next route address to attempt.这一步非常重要。
+	connection = routeSelector.next(request.method());
+
+	if (!connection.isConnected()) {
+	  // connection 进行连接了啊。他里面会用Socket开始连了。。后面我们再细看。简单的说Connection管理了Socket，后面我们要重点看这个类。
+	  connection.connect(client.getConnectTimeout(), client.getReadTimeout(), getTunnelConfig());
+	  if (connection.isSpdy()) client.getConnectionPool().share(connection);
+	  client.getRoutesDatabase().connected(connection.getRoute());
+	} else if (!connection.isSpdy()) {
+	  connection.updateReadTimeout(client.getReadTimeout());
+	}
+
+	route = connection.getRoute();
+}
+```
+接下来我们要先看一下routeSelector.next()方法如何返回connection对象，然后在看Connection.connect()方法：    
+```java
+/**
+* Returns the next route address to attempt.
+*
+* @throws NoSuchElementException if there are no more routes to attempt.
+*/
+public Connection next(String method) throws IOException {
+        // 使用连接池获取Connection的地方。pool就是OkHttpClient中的连接池。
+	// Always prefer pooled connections over new connections.
+	for (Connection pooled; (pooled = pool.get(address)) != null; ) {
+	  // 匹配get方法，或者判断是否可读，http1.x是通过判断socket是否关闭来判断是否可读的。
+	  if (method.equals("GET") || pooled.isReadable()) return pooled;
+	  // 不满足重用，就关闭。
+	  pooled.close();
+	}
+
+	// Compute the next route to attempt.
+	if (!hasNextTlsMode()) {
+	  if (!hasNextInetSocketAddress()) {
+		if (!hasNextProxy()) {
+		  if (!hasNextPostponed()) {
+			throw new NoSuchElementException();
+		  }
+		  return new Connection(pool, nextPostponed());
+		}
+		lastProxy = nextProxy();
+		resetNextInetSocketAddress(lastProxy);
+	  }
+	  lastInetSocketAddress = nextInetSocketAddress();
+	  resetNextTlsMode();
+	}
+
+	boolean modernTls = nextTlsMode() == TLS_MODE_MODERN;
+	Route route = new Route(address, lastProxy, lastInetSocketAddress, modernTls);
+	if (routeDatabase.shouldPostpone(route)) {
+	  postponedRoutes.add(route);
+	  // We will only recurse in order to skip previously failed routes. They will be
+	  // tried last.
+	  return next(method);
+	}
+        // 没有的话也会去创建，并把OkHttpClient中的连接池传递进去。
+	return new Connection(pool, route);
+}
+```
+
+再看一下`Connection`类的实现以及其`connect()`方法:   
+```java
+public final class Connection implements Closeable {
+  private final ConnectionPool pool;
+  private final Route route;
+
+  private Socket socket;
+  private InputStream in;
+  private OutputStream out;
+  private BufferedSource source;
+  private BufferedSink sink;
+  private boolean connected = false;
+  private HttpConnection httpConnection;
+  private SpdyConnection spdyConnection;
+  private int httpMinorVersion = 1; // Assume HTTP/1.1
+  private long idleStartTimeNs;
+  private Handshake handshake;
+  private int recycleCount;
+  // 传递进来的连接池。
+  public Connection(ConnectionPool pool, Route route) {
+    this.pool = pool;
+    this.route = route;
+  }
+
+  public void connect(int connectTimeout, int readTimeout, TunnelRequest tunnelRequest)
+      throws IOException {
+    if (connected) throw new IllegalStateException("already connected");
+
+    socket = (route.proxy.type() != Proxy.Type.HTTP) ? new Socket(route.proxy) : new Socket();
+    // 连socket了，内部调用了socket.connect()方法。Connects this socket to the given remote host address and port specified
+    // by the SocketAddress {@code remoteAddr} with the specified timeout. The
+    // connecting method will block until the connection is established or an
+    // error occurred.
+    Platform.get().connectSocket(socket, route.inetSocketAddress, connectTimeout);
+    socket.setSoTimeout(readTimeout);
+    in = socket.getInputStream();
+    out = socket.getOutputStream();
+
+    if (route.address.sslSocketFactory != null) {
+      // 完成TLS握手和验证
+      upgradeToTls(tunnelRequest);
+    } else {
+      initSourceAndSink();
+      // 创建HttpConnection.A socket connection that can be used to send HTTP/1.1 messages. 
+      // 这个HttpConnection有什么用呢？就是下面的newTransport方法中会用。而且还要把连接池传递进去？
+      httpConnection = new HttpConnection(pool, this, source, sink);
+    }
+	// 这样就已经连接上了
+    connected = true;
+  }
+
+  // 该方法决定了使用的协议是SPDY还是HTTP
+  /** Returns the transport appropriate for this connection. */
+  public Object newTransport(HttpEngine httpEngine) throws IOException {
+    return (spdyConnection != null)
+        ? new SpdyTransport(httpEngine, spdyConnection)
+        : new HttpTransport(httpEngine, httpConnection);
+  }
+}
+```
+
+到这里就已经把发送请求到服务器的部分全部分析完了，就想上面所说的我们应该回去了，回去分析发送完请求后的部分。
+我们这个分析是在`HttpURLConnectionImpl.execute()`方法中的`HttpEngine.sendRequest()`方法开始一直分析下来的，
+所以我们还是要回到`HttpURLConnectionImpl.execute()`方法中. 
+```java
+private boolean execute(boolean readResponse) throws IOException {
+try {
+  // 上面已经把sendRequest部分全部分析完了，该方法会与服务器通过Socket建立连接并把请求部分发送给服务器。
+  httpEngine.sendRequest();
+  route = httpEngine.getRoute();
+  handshake = httpEngine.getConnection() != null
+      ? httpEngine.getConnection().getHandshake()
+      : null;
+  if (readResponse) {
+    // 发送完请求之后该干什么呢？ 当然是读取返回数据了。。。 没错就是它。但是不要忘了在connect()方法传递过来的时候这个值是false。
+    // 所以这一步在这里是不执行的，但是我们也分析下，方便以后理解。那这个值什么时候是true呢？就是在getResponse()方法中。
+    httpEngine.readResponse();
+  }
+
+  return true;
+} catch (IOException e) {
+  HttpEngine retryEngine = httpEngine.recover(e);
+  if (retryEngine != null) {
+    httpEngine = retryEngine;
+    return false;
+  }
+
+  // Give up; recovery is not possible.
+  httpEngineFailure = e;
+  throw e;
+}
+}
+```
+接着看`HttpEngine.readResponse()`方法吧。注释说的非常明白。   
+```java
+/**
+* Flushes the remaining request header and body, parses the HTTP response
+* headers and starts reading the HTTP response body if it exists.
+*/
+public final void readResponse() throws IOException {
+if (response != null) return;
+if (responseSource == null) throw new IllegalStateException("call sendRequest() first!");
+if (!responseSource.requiresConnection()) return;
+
+// Flush the request body if there's data outstanding.
+if (bufferedRequestBody != null && bufferedRequestBody.buffer().size() > 0) {
+  bufferedRequestBody.flush();
+}
+
+if (sentRequestMillis == -1) {
+  if (OkHeaders.contentLength(request) == -1 && requestBodyOut instanceof RetryableSink) {
+    // We might not learn the Content-Length until the request body has been buffered.
+    long contentLength = ((RetryableSink) requestBodyOut).contentLength();
+    request = request.newBuilder()
+        .header("Content-Length", Long.toString(contentLength))
+        .build();
+  }
+  transport.writeRequestHeaders(request);
+}
+
+if (requestBodyOut != null) {
+  if (bufferedRequestBody != null) {
+    // This also closes the wrapped requestBodyOut.
+    bufferedRequestBody.close();
+  } else {
+    requestBodyOut.close();
+  }
+  if (requestBodyOut instanceof RetryableSink) {
+    transport.writeRequestBody((RetryableSink) requestBodyOut);
+  }
+}
+
+transport.flushRequest();
+
+response = transport.readResponseHeaders()
+    .request(request)
+    .handshake(connection.getHandshake())
+    .header(OkHeaders.SENT_MILLIS, Long.toString(sentRequestMillis))
+    .header(OkHeaders.RECEIVED_MILLIS, Long.toString(System.currentTimeMillis()))
+    .setResponseSource(responseSource)
+    .build();
+connection.setHttpMinorVersion(response.httpMinorVersion());
+receiveHeaders(response.headers());
+
+if (responseSource == ResponseSource.CONDITIONAL_CACHE) {
+  // 检查缓存是否可用，如果可用就用当前缓存的response。并且释放该连接。
+  if (validatingResponse.validate(response)) {
+    transport.emptyTransferStream();
+    releaseConnection();
+    response = combine(validatingResponse, response);
+
+    // Update the cache after combining headers but before stripping the
+    // Content-Encoding header (as performed by initContentStream()).
+    OkResponseCache responseCache = client.getOkResponseCache();
+    responseCache.trackConditionalCacheHit();
+    responseCache.update(validatingResponse, cacheableResponse());
+
+    if (validatingResponse.body() != null) {
+      initContentStream(validatingResponse.body().source());
+    }
+    return;
+  } else {
+    closeQuietly(validatingResponse.body());
+  }
+}
+
+if (!hasResponseBody()) {
+  // Don't call initContentStream() when the response doesn't have any content.
+  responseTransferSource = transport.getTransferStream(cacheRequest);
+  responseBody = responseTransferSource;
+  return;
+}
+
+// 设置cacheRequest的值
+maybeCache();
+// 设置返回数据了，transport这里也就是HttpTransport。他的getTransferStream返回的是一个Source接口的实现类。也就是返回的数据。
+initContentStream(transport.getTransferStream(cacheRequest));
+}
+```
+先看一下maybeCache()方法：    
+```java
+private void maybeCache() throws IOException {
+OkResponseCache responseCache = client.getOkResponseCache();
+if (responseCache == null) return;
+
+// Should we cache this response for this request?
+if (!CacheStrategy.isCacheable(response, request)) {
+  responseCache.maybeRemove(request);
+  return;
+}
+
+// Offer this request to the cache.
+cacheRequest = responseCache.put(cacheableResponse());
+}
+```
+再看一下`initContentStream()`方法：    
+```java
+/**
+* Initialize the response content stream from the response transfer source.
+* These two sources are the same unless we're doing transparent gzip, in
+* which case the content source is decompressed.
+*
+* <p>Whenever we do transparent gzip we also strip the corresponding headers.
+* We strip the Content-Encoding header to prevent the application from
+* attempting to double decompress. We strip the Content-Length header because
+* it is the length of the compressed content, but the application is only
+* interested in the length of the uncompressed content.
+*
+* <p>This method should only be used for non-empty response bodies. Response
+* codes like "304 Not Modified" can include "Content-Encoding: gzip" without
+* a response body and we will crash if we attempt to decompress the zero-byte
+* source.
+*/
+private void initContentStream(Source transferSource) throws IOException {
+responseTransferSource = transferSource;
+if (transparentGzip && "gzip".equalsIgnoreCase(response.header("Content-Encoding"))) { 
+  // 没有结果时response为null，有结果了就会给他赋值。
+  response = response.newBuilder()
+      .removeHeader("Content-Encoding")
+      .removeHeader("Content-Length")
+      .build();
+  responseBody = new GzipSource(transferSource);
+} else {
+  responseBody = transferSource;
+}
+}
+```
+到这里又执行完了，responseBody已经被赋值了，他是一个Source接口的实现类。也就是说到这里，这次网络请求就完成了，也收到了服务器返回的数据。
+
+
+也就是说到这里我们已经分析了:  
+
+```java
+HttpURLConnection connection = (HttpURLConnection)new URL(url).openConnection();
+connection.connect();
+```
+接下来就是分析`connection.getResponseCode()`以及`connection.getOutputStream()`这两个方法了。       
+先看一下`getResponseCode()`方法：　　　　
+```java
+@Override public final int getResponseCode() throws IOException {
+// 看到了吗？这里就是刚才我们说的execute()方法的参数什么时候会为true的地方。
+return getResponse().getResponse().code();
+}
+```
+那我们接着看一下`getResponse()`方法，其实就是直接读取响应头的响应值：　　　　　　
+```java
+/**
+* Aggressively tries to get the final HTTP response, potentially making
+* many HTTP requests in the process in order to cope with redirects and
+* authentication.
+*/
+private HttpEngine getResponse() throws IOException {
+initHttpEngine();
+
+// 如果已经有返回数据了就直接返回
+if (httpEngine.hasResponse()) {
+  return httpEngine;
+}
+
+while (true) {
+  // 参数为true了。
+  if (!execute(true)) {
+    continue;
+  }
+
+  Retry retry = processResponseHeaders();
+  if (retry == Retry.NONE) {
+    httpEngine.releaseConnection();
+    return httpEngine;
+  }
+
+  // The first request was insufficient. Prepare for another...
+  String retryMethod = method;
+  Sink requestBody = httpEngine.getRequestBody();
+
+  // Although RFC 2616 10.3.2 specifies that a HTTP_MOVED_PERM
+  // redirect should keep the same method, Chrome, Firefox and the
+  // RI all issue GETs when following any redirect.
+  int responseCode = httpEngine.getResponse().code();
+  if (responseCode == HTTP_MULT_CHOICE
+      || responseCode == HTTP_MOVED_PERM
+      || responseCode == HTTP_MOVED_TEMP
+      || responseCode == HTTP_SEE_OTHER) {
+    retryMethod = "GET";
+    requestHeaders.removeAll("Content-Length");
+    requestBody = null;
+  }
+
+  if (requestBody != null && !(requestBody instanceof RetryableSink)) {
+    throw new HttpRetryException("Cannot retry streamed HTTP body", responseCode);
+  }
+
+  if (retry == Retry.DIFFERENT_CONNECTION) {
+    httpEngine.releaseConnection();
+  }
+
+  Connection connection = httpEngine.close();
+  httpEngine = newHttpEngine(retryMethod, connection, (RetryableSink) requestBody);
+}
+}
+```
+接着看一下`getOutputStream()`的源码：     
+```java
+@Override public final OutputStream getOutputStream() throws IOException {
+// 看到了吗？他内部会先去调用connect()方法
+connect();
+
+// 这里可能有人会有说，getOutputStream和request body有什么关系，应该是response body才对啊。
+// 不要弄混了啊，getOutputStream是要把post请求的数据输入给请求。
+BufferedSink sink = httpEngine.getBufferedRequestBody();
+if (sink == null) {
+  throw new ProtocolException("method does not support a request body: " + method);
+} else if (httpEngine.hasResponse()) {
+  throw new ProtocolException("cannot write request body after response has been read");
+}
+
+return sink.outputStream();
+}
+```
+顺便再看一下`getInputStream()`方法：     　
+```java
+@Override public final InputStream getInputStream() throws IOException {
+if (!doInput) {
+  throw new ProtocolException("This protocol does not support input");
+}
+// 它也会直接调用getResponse()方法，这个比较好理解。
+HttpEngine response = getResponse();
+
+// if the requested file does not exist, throw an exception formerly the
+// Error page from the server was returned if the requested file was
+// text/html this has changed to return FileNotFoundException for all
+// file types
+if (getResponseCode() >= HTTP_BAD_REQUEST) {
+  throw new FileNotFoundException(url.toString());
+}
+
+InputStream result = response.getResponseBodyBytes();
+if (result == null) {
+  throw new ProtocolException("No response body exists; responseCode=" + getResponseCode());
+}
+return result;
+}
+```
+再顺便看一下`HttpURLConnection.disconnect()`方法，因为这个方法可能很多人不清楚该不该调用他,不过注释说的很明白了：     
+```java
+/**
+ * Releases this connection so that its resources may be either reused or
+ * closed.
+ *
+ * <p>Unlike other Java implementations, this will not necessarily close
+ * socket connections that can be reused. You can disable all connection
+ * reuse by setting the {@code http.keepAlive} system property to {@code
+ * false} before issuing any HTTP requests.
+ */
+@Override public final void disconnect() {
+// Calling disconnect() before a connection exists should have no effect.
+if (httpEngine != null) {
+  // 调用HttpEngine.close()方法
+  httpEngine.close();
+}
+}
+```
+看一下HttpEngine.close()方法:     
+```java
+/**
+* Release any resources held by this engine. If a connection is still held by
+* this engine, it is returned.
+*/
+public final Connection close() {
+if (bufferedRequestBody != null) {
+  // This also closes the wrapped requestBodyOut.
+  closeQuietly(bufferedRequestBody);
+} else if (requestBodyOut != null) {
+  closeQuietly(requestBodyOut);
+}
+
+// If this engine never achieved a response body, its connection cannot be reused.
+if (responseBody == null) {
+  closeQuietly(connection);
+  connection = null;
+  return null;
+}
+
+// Close the response body. This will recycle the connection if it is eligible.
+closeQuietly(responseBody);
+
+// Clear the buffer held by the response body input stream adapter.
+closeQuietly(responseBodyBytes);
+
+// HttpTransport.canReuseConnection()用于判断该Connection是否可复用
+// Close the connection if it cannot be reused.
+if (transport != null && !transport.canReuseConnection()) {
+  closeQuietly(connection);
+  connection = null;
+  return null;
+}
+
+Connection result = connection;
+connection = null;
+return result;
+}
+```
+继续看一下closeQuietly(connection)方法：     
+```java
+/**
+* Closes {@code closeable}, ignoring any checked exceptions. Does nothing
+* if {@code closeable} is null.
+*/
+public static void closeQuietly(Closeable closeable) {
+if (closeable != null) {
+  try {
+    // 这里也就是Connection的close()方法
+    closeable.close();
+  } catch (RuntimeException rethrown) {
+    throw rethrown;
+  } catch (Exception ignored) {
+  }
+}
+}
+```
+
+再接着看一下Connection.close()方法：    
+```java
+@Override public void close() throws IOException {
+// 直接调用了socket.close()方法。这些socket也关了。
+socket.close();
+}
+```
+再看Socket.close()方法：    
+```java
+package com.squareup.okhttp;
+
+/**
+ * Closes the socket. It is not possible to reconnect or rebind to this
+ * socket thereafter which means a new socket instance has to be created.
+ *
+ * @throws IOException
+ *             if an error occurs while closing the socket.
+ */
+public synchronized void close() throws IOException {
+    isClosed = true;
+    isConnected = false;
+    // RI compatibility: the RI returns the any address (but the original local port) after
+    // close.
+    localAddress = Inet4Address.ANY;
+    impl.close();
+}
+```
+
+
+到这里就都看完了，最后我们再看一下上面用到的连接池，也就是`ConnectionPool`类:  因为在上面的分析中，我们发现此类贯穿了很多类。
+它为`OkHttpClient`中的对象，后贯穿到`HttpEngine`、`Connection`、`HttpConnection`等。所以要分析下。
+```java
+/**
+ * Manages reuse of HTTP and SPDY connections for reduced network latency. HTTP
+ * requests that share the same {@link com.squareup.okhttp.Address} may share a
+ * {@link com.squareup.okhttp.Connection}. This class implements the policy of
+ * which connections to keep open for future use.
+ *
+ * <p>The {@link #getDefault() system-wide default} uses system properties for
+ * tuning parameters:
+ * <ul>
+ *     <li>{@code http.keepAlive} true if HTTP and SPDY connections should be
+ *         pooled at all. Default is true.
+ *     <li>{@code http.maxConnections} maximum number of idle connections to
+ *         each to keep in the pool. Default is 5.
+ *     <li>{@code http.keepAliveDuration} Time in milliseconds to keep the
+ *         connection alive in the pool before closing it. Default is 5 minutes.
+ *         This property isn't used by {@code HttpURLConnection}.
+ * </ul>
+ *
+ * <p>The default instance <i>doesn't</i> adjust its configuration as system
+ * properties are changed. This assumes that the applications that set these
+ * parameters do so before making HTTP connections, and that this class is
+ * initialized lazily.
+ */
+public class ConnectionPool {
+  private static final int MAX_CONNECTIONS_TO_CLEANUP = 2;
+  private static final long DEFAULT_KEEP_ALIVE_DURATION_MS = 5 * 60 * 1000; // 5 min
+
+  // 这个就是getDefault方法所返回的默认连接池。
+  private static final ConnectionPool systemDefault;
+
+  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;
+    if (keepAlive != null && !Boolean.parseBoolean(keepAlive)) {
+      systemDefault = new ConnectionPool(0, keepAliveDurationMs);
+    } else if (maxIdleConnections != null) {
+      systemDefault = new ConnectionPool(Integer.parseInt(maxIdleConnections), keepAliveDurationMs);
+    } else {
+      systemDefault = new ConnectionPool(5, keepAliveDurationMs);
+    }
+  }
+
+  /** The maximum number of idle connections for each address. */
+  private final int maxIdleConnections;
+  private final long keepAliveDurationNs;
+
+  private final LinkedList<Connection> connections = new LinkedList<Connection>();
+
+  // 连接的有效性检测是所有连接池都面临的一个通用问题，大部分HTTP服务器为了控制资源开销，并不会永久的维护一个长连接，而是一段时间就会关闭该连接。
+  // 放回连接池的连接，如果在服务器端已经关闭，客户端是无法检测到这个状态变化而及时的关闭Socket的。这就造成了线程从连接池中获取的连接不一定是有效的。
+  // 这个问题的一个解决方法就是在每次请求之前检查该连接是否已经存在了过长时间，可能已过期。但是这个方法会使得每次请求都增加额外的开销。
+  // 所以通过下面的任务来执行清理过期的连接。
+  /** We use a single background thread to cleanup expired connections. */
+  private final ExecutorService executorService = new ThreadPoolExecutor(0, 1,
+      60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(),
+      Util.threadFactory("OkHttp ConnectionPool", true));
+  private final Runnable connectionsCleanupRunnable = new Runnable() {
+    @Override public void run() {
+      List<Connection> expiredConnections = new ArrayList<Connection>(MAX_CONNECTIONS_TO_CLEANUP);
+      int idleConnectionCount = 0;
+      synchronized (ConnectionPool.this) {
+        for (ListIterator<Connection> i = connections.listIterator(connections.size());
+            i.hasPrevious(); ) {
+          Connection connection = i.previous();
+          if (!connection.isAlive() || connection.isExpired(keepAliveDurationNs)) {
+            i.remove();
+            expiredConnections.add(connection);
+            if (expiredConnections.size() == MAX_CONNECTIONS_TO_CLEANUP) break;
+          } else if (connection.isIdle()) {
+            idleConnectionCount++;
+          }
+        }
+
+        for (ListIterator<Connection> i = connections.listIterator(connections.size());
+            i.hasPrevious() && idleConnectionCount > maxIdleConnections; ) {
+          Connection connection = i.previous();
+          if (connection.isIdle()) {
+            expiredConnections.add(connection);
+            i.remove();
+            --idleConnectionCount;
+          }
+        }
+      }
+      for (Connection expiredConnection : expiredConnections) {
+        Util.closeQuietly(expiredConnection);
+      }
+    }
+  };
+
+  public ConnectionPool(int maxIdleConnections, long keepAliveDurationMs) {
+    this.maxIdleConnections = maxIdleConnections;
+    this.keepAliveDurationNs = keepAliveDurationMs * 1000 * 1000;
+  }
+
+  /**
+   * Returns a snapshot of the connections in this pool, ordered from newest to
+   * oldest. Waits for the cleanup callable to run if it is currently scheduled.
+   */
+  List<Connection> getConnections() {
+    waitForCleanupCallableToRun();
+    synchronized (this) {
+      return new ArrayList<Connection>(connections);
+    }
+  }
+
+  /**
+   * Blocks until the executor service has processed all currently enqueued
+   * jobs.
+   */
+  private void waitForCleanupCallableToRun() {
+    try {
+      executorService.submit(new Runnable() {
+        @Override public void run() {
+        }
+      }).get();
+    } catch (Exception e) {
+      throw new AssertionError();
+    }
+  }
+
+  public static ConnectionPool getDefault() {
+    return systemDefault;
+  }
+
+  /** Returns total number of connections in the pool. */
+  public synchronized int getConnectionCount() {
+    return connections.size();
+  }
+
+  /** Returns total number of spdy connections in the pool. */
+  public synchronized int getSpdyConnectionCount() {
+    int total = 0;
+    for (Connection connection : connections) {
+      if (connection.isSpdy()) total++;
+    }
+    return total;
+  }
+
+  /** Returns total number of http connections in the pool. */
+  public synchronized int getHttpConnectionCount() {
+    int total = 0;
+    for (Connection connection : connections) {
+      if (!connection.isSpdy()) total++;
+    }
+    return total;
+  }
+
+  /** Returns a recycled connection to {@code address}, or null if no such connection exists. */
+  public synchronized Connection get(Address address) {
+    Connection foundConnection = null;
+    for (ListIterator<Connection> i = connections.listIterator(connections.size());
+        i.hasPrevious(); ) {
+      Connection connection = i.previous();
+      if (!connection.getRoute().getAddress().equals(address)
+          || !connection.isAlive()
+          || System.nanoTime() - connection.getIdleStartTimeNs() >= keepAliveDurationNs) {
+        continue;
+      }
+      i.remove();
+      if (!connection.isSpdy()) {
+	    // 不是spdy连接
+        try {
+          // Platforml类对当前Android平台做了适配。
+          Platform.get().tagSocket(connection.getSocket());
+        } catch (SocketException e) {
+          Util.closeQuietly(connection);
+          // When unable to tag, skip recycling and close
+          Platform.get().logW("Unable to tagSocket(): " + e);
+          continue;
+        }
+      }
+      // 找到可复用的Connection
+      foundConnection = connection;
+      break;
+    }
+
+    // 针对spdy连接，添加到连接池中
+    if (foundConnection != null && foundConnection.isSpdy()) {
+      connections.addFirst(foundConnection); // Add it back after iteration.
+    }
+
+    executorService.execute(connectionsCleanupRunnable);
+    return foundConnection;
+  }
+
+  /**
+   * Gives {@code connection} to the pool. The pool may store the connection,
+   * or close it, as its policy describes.
+   *
+   * <p>It is an error to use {@code connection} after calling this method.
+   */
+  public void recycle(Connection connection) {
+    if (connection.isSpdy()) {
+      return;
+    }
+
+    if (!connection.isAlive()) {
+      Util.closeQuietly(connection);
+      return;
+    }
+
+    try {
+      Platform.get().untagSocket(connection.getSocket());
+    } catch (SocketException e) {
+      // When unable to remove tagging, skip recycling and close.
+      Platform.get().logW("Unable to untagSocket(): " + e);
+      Util.closeQuietly(connection);
+      return;
+    }
+
+    synchronized (this) {
+      connections.addFirst(connection);
+      connection.incrementRecycleCount();
+      connection.resetIdleStartTime();
+    }
+
+    executorService.execute(connectionsCleanupRunnable);
+  }
+
+  /**
+   * Shares the SPDY connection with the pool. Callers to this method may
+   * continue to use {@code connection}.
+   */
+  public void share(Connection connection) {
+    if (!connection.isSpdy()) throw new IllegalArgumentException();
+    executorService.execute(connectionsCleanupRunnable);
+    if (connection.isAlive()) {
+      synchronized (this) {
+        connections.addFirst(connection);
+      }
+    }
+  }
+
+  /** Close and remove all connections in the pool. */
+  public void evictAll() {
+    List<Connection> connections;
+    synchronized (this) {
+      connections = new ArrayList<Connection>(this.connections);
+      this.connections.clear();
+    }
+
+    for (int i = 0, size = connections.size(); i < size; i++) {
+      Util.closeQuietly(connections.get(i));
+    }
+  }
+}
+
+```
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
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"
new file mode 100644
index 00000000..29bdf7c6
--- /dev/null
+++ "b/SourceAnalysis/Netowork/Retrofit\350\257\246\350\247\243(\344\270\212).md"
@@ -0,0 +1,386 @@
+
+Retrofit详解(上)
+===
+
+之前写过一篇文章[volley-retrofit-okhttp之我们该如何选择网路框架][1]来分析`Volley`与`Retrofit`之间的区别。之前一直用`Volley`比较多。但是随着`Rx`系列的走红，目前越来越多的项目使用`RxJava+Retrofit`这一黄金组合。而且`Retrofit`使用注解的方式比较方便以及`2.x`版本的提示让`Retrofit`更加完善，今天简单的来学习记录下。
+
+- 有关更多`Volley`的知识请查看[Volley源码分析][2]    
+- 有关注解更多的知识请查看[注解使用][3]
+- 有关更多`RxJava`的介绍请查看[Rx详解系列][4]
+
+简介
+---
+
+[Retrofit](http://square.github.io/retrofit/)
+
+> A type-safe HTTP client for Android and Java
+
+`type-safe`是什么鬼？    
+类型安全代码指访问被授权可以访问的内存位置。例如，类型安全代码不能从其他对象的私有字段读取值。它只从定义完善的允许方式访问类型才能读取。
+
+使用
+---
+
+`Gradle`中集成:   
+
+```java
+compile 'com.squareup.retrofit2:retrofit:2.1.0'
+```  
+`Retrofit 2`底层默认使用自家兄弟`OKHttp`作为网络层,并且在它上面进行构建。所以不需要在想`1.x`版本那样在
+项目中显式的定义`OkHttp`依赖。所以`Retrofit`与`OkHttp`的关系是后者专注与网络请求的高效优化，而前者专注于接口的封装和调用管理等。    
+
+![image](https://github.com/CharonChui/Pictures/blob/master/retrofit_okhttp_relation.jpg?raw=true)
+
+当然你还需要在清单文件中添加网络请求的权限:   
+
+```
+<uses-permission android:name="android.permission.INTERNET"/>
+```
+
+我们就以`Github`获取个人仓库的`api`来进行举例测试:   
+```java
+https://api.github.com/users/{user}/repos
+```
+
+- `Retrofit`会将你的`api`封装成`Java`接口   
+  ```java
+  public interface GitHubService {
+    @GET("users/{user}/repos")
+    Call<List<Repo>> listRepos(@Path("user") String user);
+  }
+  ```
+
+- `Retrofit`类会生成一个`GitHubService`接口的实现类:  
+
+  ```java
+  Retrofit retrofit = new Retrofit.Builder()
+      .baseUrl("https://api.github.com/")
+      .build();
+  
+  GitHubService service = retrofit.create(GitHubService.class);
+  ```
+
+- 从创建的`GithubService`类返回的每个`Call`对象调用后都可以创建一个同步或异步的网络请求:   
+
+  ```java
+  Call<List<Repo>> repos = service.listRepos("CharonChui");
+  ```
+
+- 上面返回的`Call`其实并不是真正的数据结果，它更像一条指令，你需要执行它:   
+
+  ```java
+  // 同步调用
+  List<Repo> data = repos.execute(); 
+   
+  // 异步调用
+  repos.enqueue(new Callback<List<Repo>>() {
+    @Override
+    public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
+        List<Repo> data = response.body();
+        Log.i("@@@", "data size : " + (data == null ? "null" : data.size() + ""));
+    }
+  
+    @Override
+    public void onFailure(Call<List<Repo>> call, Throwable t) {
+  
+    }
+  });
+  ```
+
+  那如何取消请求呢？ 
+
+  ```java
+  repos.cancel();
+  ```
+
+上面这一部分代码，你要是拷贝运行后是运行不了的。
+当然了，因为木有`Repo`对象。但是添加`Repo`对象也是运行不了的。会报错。 
+
+```java
+Process: com.charon.retrofitdemo, PID: 7229
+java.lang.RuntimeException: Unable to start activity ComponentInfo{com.charon.retrofitdemo/com.charon.retrofitdemo.MainActivity}: java.lang.IllegalArgumentException: Unable to create converter for java.util.List<com.charon.retrofitdemo.Repo>
+   for method GitHubService.listRepos
+   at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2281)
+   at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2331)
+   at android.app.ActivityThread.handleRelaunchActivity(ActivityThread.java:3974)
+   at android.app.ActivityThread.access$1100(ActivityThread.java:143)
+   at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1250)
+   at android.os.Handler.dispatchMessage(Handler.java:102)
+   at android.os.Looper.loop(Looper.java:136)
+   at android.app.ActivityThread.main(ActivityThread.java:5291)
+   at java.lang.reflect.Method.invokeNative(Native Method)
+   at java.lang.reflect.Method.invoke(Method.java:515)
+   at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:849)
+   at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:665)
+   at dalvik.system.NativeStart.main(Native Method)
+Caused by: java.lang.IllegalArgumentException: Unable to create converter for java.util.List<com.charon.retrofitdemo.Repo>
+   for method GitHubService.listRepos
+   at retrofit2.ServiceMethod$Builder.methodError(ServiceMethod.java:720)
+   at retrofit2.ServiceMethod$Builder.createResponseConverter(ServiceMethod.java:706)
+   at retrofit2.ServiceMethod$Builder.build(ServiceMethod.java:167)
+   at retrofit2.Retrofit.loadServiceMethod(Retrofit.java:166)
+   at retrofit2.Retrofit$1.invoke(Retrofit.java:145)
+   at $Proxy0.listRepos(Native Method)
+   at com.charon.retrofitdemo.MainActivity$override.onCreate(MainActivity.java:29)
+   at com.charon.retrofitdemo.MainActivity$override.access$dispatch(MainActivity.java)
+   at com.charon.retrofitdemo.MainActivity.onCreate(MainActivity.java:0)
+   at android.app.Activity.performCreate(Activity.java:5304)
+   at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1090)
+   at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2245)
+    ... 12 more
+Caused by: java.lang.IllegalArgumentException: Could not locate ResponseBody converter for java.util.List<com.charon.retrofitdemo.Repo>.
+ Tried:
+```
+
+这是什么鬼?难道官方给的示例代码有问题？ 从`log`上面我们能看出来是返回的数据结构不匹配导致的，返回的是`ResponseBody`的转换器无法转换为`List<Repo>`。    
+
+
+`Retrofit`是一个将`API`接口转换成回调对象的类，默认情况下`Retrofit`会根据平台提供一些默认的配置，但是它是支持配置的。   
+
+Converters(解析数据)
+---
+
+默认情况下，`Retrofit`只能将`HTTP`响应体反序列化为`OkHttp`的`ResponseBody`类型。并且通过`@Body`也只能接受`RequestBody`类型。    
+
+可以通过添加转换器来支持其他类型。它提供了6中类似的序列化类库来方便进行使用:    
+
+- Gson: com.squareup.retrofit2:converter-gson
+- Jackson: com.squareup.retrofit2:converter-jackson
+- Moshi: com.squareup.retrofit2:converter-moshi
+- Protobuf: com.squareup.retrofit2:converter-protobuf
+- Wire: com.squareup.retrofit2:converter-wire
+- Simple XML: com.squareup.retrofit2:converter-simplexml
+- Scalars (primitives, boxed, and String): com.squareup.retrofit2:converter-scalars
+
+
+我们这里通过`Gson`为例，讲解一下如何使用，首先需要在`gradle`文件中配置对应的支持模块。 
+
+```java
+compile 'com.squareup.retrofit2:retrofit:2.1.0'
+compile 'com.squareup.retrofit2:converter-gson:2.1.0'
+```
+
+下面是一个通过使用`GsonConverterFactory`类来指定`GitHubService`接口使用`Gson`来解析结果的配置。 
+
+```java
+Retrofit retrofit = new Retrofit.Builder()
+    .baseUrl("https://api.github.com")
+    .addConverterFactory(GsonConverterFactory.create())
+    .build();
+
+GitHubService service = retrofit.create(GitHubService.class);
+```
+
+经过这些改造，就可以了，贴一下完整的代码:  
+```java
+public interface GitHubService {
+    @GET("users/{user}/repos")
+    Call<List<Repo>> listRepos(@Path("user") String user);
+}
+
+public class MainActivity extends AppCompatActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+        
+        Retrofit retrofit = new Retrofit.Builder()
+                .baseUrl("https://api.github.com/")
+                .addConverterFactory(GsonConverterFactory.create())
+                .build();
+
+        GitHubService service = retrofit.create(GitHubService.class);
+
+        Call<List<Repo>> call= service.listRepos("CharonChui");
+
+        call.enqueue(new Callback<List<Repo>>() {
+            @Override
+            public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
+                List<Repo> body = response.body();
+                Log.i("@@@", "call " + body.size());
+            }
+
+            @Override
+            public void onFailure(Call<List<Repo>> call, Throwable t) {
+
+            }
+        });
+    }
+}
+```
+
+运行上面的代码,`log`会打印出`12-14 14:43:38.900 21509-21509/com.charon.retrofitdemo I/@@@: call 26`
+
+
+到这里，我们入门的`Hello World`就完成了。 
+
+`Retrofit`支持的协议包括`GET/POST/PUT/DELETE/HEAD/PATCH`，当然你也可以直接用`HTTP` 来自定义请求。这些协议均以注解的形式进行配置，比如我们已经见过`GET`的用法.
+
+我们发现在`Retrofit`创建的时候需要传入一个`baseUrl(https://api.github.com/)`，在`GitHubService`中会通过注解设置`@GET("users/{user}/repos")`，请求的完整`Url`就是通过`baseUrl`与注解的`value`也就是`path`路径结合起来组成。虽然提供了多种规则，但是统一使用下面这一种是最好的。 
+```java
+通过注解的value指定的是相对路径，baseUrl是目录形式：
+path = "users/CharonChui/repos"，baseUrl = "https://api.github.com/"
+Url = "https://api.github.com/users/CharonChui/repos"
+```
+
+上面介绍的例子中使用的是`@Path`。 
+
+`@Query`及`@QueryMap`
+---
+
+假设我们有一个分页查询的功能:   
+```java
+GET("/list")
+Call<ResponseBody> list(@Query("page") int page);
+```
+
+这就相当于`https://api.github.com/list?page=1`这种。`Query`其实就是`Url`中`?`后面的`k-v`。而`QueryMap`就是多个查询条件。     
+
+
+`@Field`及`@FieldMap`
+---
+
+用`Post`的场景相对比较多，绝大多数的服务端接口要做加密、校验等。所以使用`Post`提交表单的场景就会很多。
+
+```java
+@FormUrlEncoded
+@POST("user/edit")
+Call<User> updateUser(@Field("first_name") String first, @Field("last_name") String last);
+```
+
+当然`FieldMap`就是多个的版本了。  
+
+`@Part`及`@PartMap`
+---
+
+上传文件时使用。
+```java
+public interface FileUploadService {  
+@Multipart
+@PUT("user/photo")
+Call<User> updateUser(@Part("photo") RequestBody photo, @Part("description") RequestBody description);
+}
+```
+
+`@Headers`
+---
+
+可以通过`@Headers`来设置静态的请求头
+
+```java
+@Headers({
+    "Accept: application/vnd.github.v3.full+json",
+    "User-Agent: Retrofit-Sample-App"
+})
+@GET("users/{username}")
+Call<User> getUser(@Path("username") String username);
+```
+
+请求头信息可以通过`@Header`注解来动态更新
+
+```java
+@GET("user")
+Call<User> getUser(@Header("Authorization") String authorization)
+```
+如果传的值是`null`，该请求头将会被忽略，否则将会使用该值得`toString`。 
+
+
+`RxJava`+`Retrofit`
+---
+
+`Retrofit`如何与`RxJava`结合使用呢？ 
+
+- 添加依赖
+
+  ```java
+  compile 'com.squareup.retrofit2:retrofit:2.1.0'
+  compile 'com.squareup.retrofit2:converter-gson:2.1.0'// 支持gson
+  compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'// 支持rxjava
+  
+  // rxjava part
+  compile 'io.reactivex:rxandroid:1.2.1'
+  compile 'io.reactivex:rxjava:1.2.3'
+  ```
+
+- 修改`Retrofit`的配置，让其支持`RxJava`   
+
+  ```java
+  Retrofit retrofit = new Retrofit.Builder()
+      .baseUrl("https://api.github.com/")
+      .addConverterFactory(GsonConverterFactory.create())
+      .addCallAdapterFactory(RxJavaCallAdapterFactory.create()) // 支持RxJava
+      .build();
+  ```
+
+- 修改`GitHubService`，将返回值改为`Observable`，而不是`Call`。     
+
+  ```java
+  public interface GitHubService {
+      @GET("users/{user}/repos")
+      Observable<List<Repo>> listRepos(@Path("user") String user);
+  }
+  ```
+
+- 执行部分
+
+  ```java
+  GitHubService service = retrofit.create(GitHubService.class);
+  
+  service.listRepos("CharonChui")
+      .subscribeOn(Schedulers.newThread())
+      .observeOn(AndroidSchedulers.mainThread())
+      .subscribe(new Subscriber<List<Repo>>() {
+          @Override
+          public void onCompleted() {
+              Log.i("@@@", "onCompleted");
+          }
+  
+          @Override
+          public void onError(Throwable e) {
+              Log.i("@@@", "onError : " + e.toString());
+          }
+  
+          @Override
+          public void onNext(List<Repo> repos) {
+              Log.i("@@@", "onNext : " + repos.size());
+              Toast.makeText(MainActivity.this, "size : " + repos.size(), Toast.LENGTH_SHORT).show();
+          }
+      });
+  ```
+  
+
+  `RxJava`+`Retrofit`形式的时候，`Retrofit`把请求封装进`Observable`在请求结束后调用 `onNext()`或在请求失败后调用`onError()`。
+
+
+`Proguard`配置
+---
+
+如果项目中使用了`Proguard`，你需要添加如下配置:   
+```java
+# Platform calls Class.forName on types which do not exist on Android to determine platform.
+-dontnote retrofit2.Platform
+# Platform used when running on RoboVM on iOS. Will not be used at runtime.
+-dontnote retrofit2.Platform$IOS$MainThreadExecutor
+# Platform used when running on Java 8 VMs. Will not be used at runtime.
+-dontwarn retrofit2.Platform$Java8
+# Retain generic type information for use by reflection by converters and adapters.
+-keepattributes Signature
+# Retain declared checked exceptions for use by a Proxy instance.
+-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 "注解使用"
+[4]: https://github.com/CharonChui/AndroidNote/tree/master/RxJavaPart "Rx详解系列"
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- 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"
new file mode 100644
index 00000000..a745ab21
--- /dev/null
+++ "b/SourceAnalysis/Netowork/Retrofit\350\257\246\350\247\243(\344\270\213).md"
@@ -0,0 +1,672 @@
+Retrofit详解(下)
+===
+
+
+上一篇文章介绍了`Retrofit`的基本使用，接下来我们通过从源码的角度分析一下`Retrofit`的实现。    
+
+首先看一下它的基本使用方法:    
+
+```java
+// 1
+Retrofit retrofit = new Retrofit.Builder()
+        .baseUrl("https://api.github.com/")
+        .addConverterFactory(GsonConverterFactory.create())
+        .build();
+// 2
+GitHubService gitHubService = retrofit.create(GitHubService.class);
+
+// 3
+Call<List<Repo>> call = gitHubService.listRepos("CharonChui");
+
+// 4
+call.enqueue(new Callback<List<Repo>>() {
+    @Override
+    public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
+        List<Repo> data = response.body();
+        Log.i("@@@", "data size : " + (data == null ? "null" : data.size() + ""));
+    }
+
+    @Override
+    public void onFailure(Call<List<Repo>> call, Throwable t) {
+
+    }
+});
+```
+
+我把上面主要分为4个部分，接下来逐一分析:    
+
+1. 创建`Retrofit`并进行配置。
+---
+
+```java
+Retrofit retrofit = new Retrofit.Builder()
+  .baseUrl("https://api.github.com/")
+  .addConverterFactory(GsonConverterFactory.create())
+  .build();
+```
+
+简单的一句话，却埋藏了很多。     
+
+这是典型的建造者模式、外观模式      
+
+就像平时我们写的下载模块，作为一个公共的模块，我们可以对外提供一个`DownloadManager`供外界使用，而对于里面的实现我们完全可以闭门造车。    
+
+具体`baseUrl()`、`addConverterFactory()`方法里面的具体实现就不去看了，比较简单。当然这里也用到了工厂设计模式。
+
+2. 创建对应的服务类
+---
+
+```java
+GitHubService gitHubService = retrofit.create(GitHubService.class);
+```
+
+这一部分是如何实现的呢？我们看一下`retrofit.create()`方法的实现:    
+
+```java
+public <T> T create(final Class<T> service) {
+    Utils.validateServiceInterface(service);
+    if (validateEagerly) {
+      eagerlyValidateMethods(service);
+    }
+    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
+        new InvocationHandler() {
+          // 这里的Platform主要是为了检测当前的运行平台，是java还是android，会根据当前的平台来返回默认的CallAdapter
+          private final Platform platform = Platform.get();
+
+          @Override public Object invoke(Object proxy, Method method, Object... args)
+              throws Throwable {
+            // If the method is a method from Object then defer to normal invocation.
+            if (method.getDeclaringClass() == Object.class) {
+              // 代理调用
+              return method.invoke(this, args);
+            }
+            if (platform.isDefaultMethod(method)) {
+              return platform.invokeDefaultMethod(method, service, proxy, args);
+            }
+            // 1，根据动态代理的方法去生成ServiceMethod这里动态代理的方法就是listRepos方法
+            ServiceMethod serviceMethod = loadServiceMethod(method);
+            // 2，根据ServiceMethod和参数去生成OkHttpCall，这里args是CharonChui
+            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
+            // 3, serviceMethod去进行处理并返回Call对象，拿到这个Call对象才能去执行网络请求。
+            return serviceMethod.callAdapter.adapt(okHttpCall);
+          }
+        });
+  }
+```
+
+看到`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高新技术系列中的动态代理](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86.md)
+
+这里就不仔细介绍动态代理了，上面的代码中又分为三部分:    
+
+- `loadServiceMethod()`
+- `new OkHttpCall()`
+- `serviceMethod.callAdapter.adapt()`
+
+我们这里分别来进行分析。    
+
+- `loadServiceMethod()`
+	实现如下:   
+	
+	```java
+	ServiceMethod loadServiceMethod(Method method) {
+	    ServiceMethod result;
+	    synchronized (serviceMethodCache) {
+	      // ServiceMethod包含了请求的所有相关数据，以及获取请求的request和把请求结果转换成java对象，所以相比较而言较重，用缓存来提高效率。
+	      result = serviceMethodCache.get(method);
+	      if (result == null) {
+	        // build
+	        result = new ServiceMethod.Builder(this, method).build();
+	        serviceMethodCache.put(method, result);
+	      }
+	    }
+	    return result;
+	  }
+	```
+	
+	会通过缓存的方式来获取一个`ServiceMethod`类。通过缓存来保证同一个`API`的同一个方法只会创建一次。 
+	有关`ServiceMethod`类的文档介绍是:     
+	```java
+	Adapts an invocation of an interface method into an HTTP call.
+	```
+	大体翻译一下就是将一个请求接口的方法转换到`Http Call`中调用。    
+	
+	而上面第一次使用的时候会通过`new ServiceMethod.Builder(this, method).build()`创建，那我们看一下它的实现:    
+	
+	```java
+	public ServiceMethod build() {
+	       // 创建CallAdapter用来代理Call
+	      callAdapter = createCallAdapter();
+	      responseType = callAdapter.responseType();
+	      if (responseType == Response.class || responseType == okhttp3.Response.class) {
+	        throw methodError("'"
+	            + Utils.getRawType(responseType).getName()
+	            + "' is not a valid response body type. Did you mean ResponseBody?");
+	      }
+	      // responseConverter用来解析结果将json等返回结果解析成java对象
+	      responseConverter = createResponseConverter();
+	
+	      for (Annotation annotation : methodAnnotations) {
+	        parseMethodAnnotation(annotation);
+	      }
+	
+	      if (httpMethod == null) {
+	        throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
+	      }
+	
+	      if (!hasBody) {
+	        if (isMultipart) {
+	          throw methodError(
+	              "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
+	        }
+	        if (isFormEncoded) {
+	          throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
+	              + "request body (e.g., @POST).");
+	        }
+	      }
+	
+	      int parameterCount = parameterAnnotationsArray.length;
+	      parameterHandlers = new ParameterHandler<?>[parameterCount];
+	      for (int p = 0; p < parameterCount; p++) {
+	        Type parameterType = parameterTypes[p];
+	        if (Utils.hasUnresolvableType(parameterType)) {
+	          throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
+	              parameterType);
+	        }
+         	//  解析对应method的注解，这里是listRepos方法的注解。
+	        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
+	        if (parameterAnnotations == null) {
+	          throw parameterError(p, "No Retrofit annotation found.");
+	        }
+	        // 通过注解和参数类型，解析并赋值到parameterHandlers中
+	        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
+	      }
+	
+	      if (relativeUrl == null && !gotUrl) {
+	        throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
+	      }
+	      if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
+	        throw methodError("Non-body HTTP method cannot contain @Body.");
+	      }
+	      if (isFormEncoded && !gotField) {
+	        throw methodError("Form-encoded method must contain at least one @Field.");
+	      }
+	      if (isMultipart && !gotPart) {
+	        throw methodError("Multipart method must contain at least one @Part.");
+	      }
+	      // 创建`ServiceMethod()`对象
+	      return new ServiceMethod<>(this);
+	    }
+	```
+	总起来说，就是创建`CallAdapter`、`responseConverter`、解析注解、设置参数，然后创建`ServiceMethod`对象。   
+	
+	而`ServiceMethod`的构造函数如下:    
+	```java
+	ServiceMethod(Builder<T> builder) {
+	    this.callFactory = builder.retrofit.callFactory();
+	    this.callAdapter = builder.callAdapter;
+	    this.baseUrl = builder.retrofit.baseUrl();
+	    this.responseConverter = builder.responseConverter;
+	    this.httpMethod = builder.httpMethod;
+	    this.relativeUrl = builder.relativeUrl;
+	    this.headers = builder.headers;
+	    this.contentType = builder.contentType;
+	    this.hasBody = builder.hasBody;
+	    this.isFormEncoded = builder.isFormEncoded;
+	    this.isMultipart = builder.isMultipart;
+	    this.parameterHandlers = builder.parameterHandlers;
+	  }
+	```
+	
+	看到吗？ 这一部分我们应该都稍微有点印象，因为在上一篇文章介绍使用方法的时候，基本会用到这里。 
+
+至于这里的`CallAdapter`、`ResponseConverter`、`Headers`、`ParamterHandlers`等这里就不分析了，最后我们再简单介绍下。
+
+- 创建`OkHttpCall`
+
+	接下来会创建`OkHttpCall`，而`OkHttpCall`是`Call`的子类，那`Call`是什么鬼？ 它是具体的网络请求类。
+	
+	文档中对`Call`类的介绍如下:    
+	```java
+	/**
+	 * An invocation of a Retrofit method that sends a request to a webserver and returns a response.
+	 * Each call yields its own HTTP request and response pair. Use {@link #clone} to make multiple
+	 * calls with the same parameters to the same webserver; this may be used to implement polling or
+	 * to retry a failed call.
+	 *
+	 * <p>Calls may be executed synchronously with {@link #execute}, or asynchronously with {@link
+	 * #enqueue}. In either case the call can be canceled at any time with {@link #cancel}. A call that
+	 * is busy writing its request or reading its response may receive a {@link IOException}; this is
+	 * working as designed.
+	 *
+	 * @param <T> Successful response body type.
+	 */
+	public interface Call<T> extends Cloneable {
+		// 这里我特地把这句话放上，Call集成了Cloneable接口。
+		// 每一个 call 对象实例只能被用一次，所以说 request 和 response 都是一一对应的。你其实可以通过 Clone 方法来创建一个一模一样的实例，这个开销是很小的。比如说：你可以在每次决定发请求前 clone 一个之前的实例。
+		....
+	}
+	```
+	
+	`Retrofit`底层默认使用`OkHttp`，所以当然要创建`OkHttpCall`了。    
+	
+	- `serviceMethod.callAdapter.adapt(okHttpCall)`
+	
+	这个`CallApdater`是什么鬼？   
+	
+	```java
+	/**
+	 * Adapts a {@link Call} into the type of {@code T}. Instances are created by {@linkplain Factory a
+	 * factory} which is {@linkplain Retrofit.Builder#addCallAdapterFactory(Factory) installed} into
+	 * the {@link Retrofit} instance.
+	 */
+	```
+	
+	可以很简单的看出来这是一个结果类型转换的类。就是`Call`的适配器，作用就是创建/转换`Call`对象，把`Call`转换成预期的格式。`CallAdatper`创建是通过`CallAdapter.factory`工厂类进行的。`DefaultCallAdapter`为`Retrofit2`自带默认`Call`转换器，用来生成`OKHTTP`的`call`请求调用。
+
+	
+	而它里面的`adapt()`方法的作用呢？ 
+	
+	```java
+	/**
+	   * Returns an instance of {@code T} which delegates to {@code call}.
+	   * <p>
+	   * For example, given an instance for a hypothetical utility, {@code Async}, this instance would
+	   * return a new {@code Async<R>} which invoked {@code call} when run.
+	   * <pre><code>
+	   * &#64;Override
+	   * public &lt;R&gt; Async&lt;R&gt; adapt(final Call&lt;R&gt; call) {
+	   *   return Async.create(new Callable&lt;Response&lt;R&gt;&gt;() {
+	   *     &#64;Override
+	   *     public Response&lt;R&gt; call() throws Exception {
+	   *       return call.execute();
+	   *     }
+	   *   });
+	   * }
+	   * </code></pre>
+	   */
+	  <R> T adapt(Call<R> call);
+	```
+	
+	所以分析到这里我们基本明白了`retrofit.create()`方法的作用，就是将请求接口的服务类转换成`Call`，然后将`Call`的结果转换成实体类。
+	
+3. 调用方法，得到`Call`对象
+---
+
+```java
+Call<List<Repo>> call = gitHubService.listRepos("CharonChui");
+```
+
+这个就不分析了，就是在`ServiceMethod`中返回的`Call`。
+ 
+4. 调用`Call.enqueue()`
+---
+
+在上面分析了，这个`Call`其实是`OkHttpCall`，那我们来看一下`OkHttpCall.enqueue()`方法的实现:     
+
+```java
+@Override public void enqueue(final Callback<T> callback) {
+    if (callback == null) throw new NullPointerException("callback == null");
+
+    okhttp3.Call call;
+    Throwable failure;
+
+    synchronized (this) {
+      if (executed) throw new IllegalStateException("Already executed.");
+      executed = true;
+
+      call = rawCall;
+      failure = creationFailure;
+      if (call == null && failure == null) {
+        try {
+          // 调用createRawCall()方法创建Call
+          call = rawCall = createRawCall();
+        } catch (Throwable t) {
+          failure = creationFailure = t;
+        }
+      }
+    }
+
+    if (failure != null) {
+      callback.onFailure(this, failure);
+      return;
+    }
+
+    if (canceled) {
+      call.cancel();
+    }
+    // 把请求任务加入到okhttp的请求队列中，执行网络请求，注意这里的Call是okhttp3.Call
+    call.enqueue(new okhttp3.Callback() {
+      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
+          throws IOException {
+        Response<T> response;
+        try {
+          // 解析结果，该方法内部会将OkHttp中Request的执行结果转换成对应的Java对象。
+          response = parseResponse(rawResponse);
+        } catch (Throwable e) {
+          callFailure(e);
+          return;
+        }
+        callSuccess(response);
+      }
+
+      @Override public void onFailure(okhttp3.Call call, IOException e) {
+        try {
+          callback.onFailure(OkHttpCall.this, e);
+        } catch (Throwable t) {
+          t.printStackTrace();
+        }
+      }
+
+      private void callFailure(Throwable e) {
+        try {
+          callback.onFailure(OkHttpCall.this, e);
+        } catch (Throwable t) {
+          t.printStackTrace();
+        }
+      }
+
+      private void callSuccess(Response<T> response) {
+        try {
+          callback.onResponse(OkHttpCall.this, response);
+        } catch (Throwable t) {
+          t.printStackTrace();
+        }
+      }
+    });
+  }
+```
+
+上面的部分也主要分为三部分:    
+
+- 创建Call
+- 执行网络请求
+- 解析结果 
+
+#### 第一部分：创建`Call`
+
+我们分别进行分析，首先是`createRawCall()`方法的实现:    
+```java
+private okhttp3.Call createRawCall() throws IOException {
+  // ServiceMethod.toRequest()方法的作用是将ServiceMethod中的网络请求相关的数据转换成一个OkHttp的网络请求所需要的Request对象。因为之前分析过所有Retrofit解析的网络请求相关的数据都是在ServiceMethod中
+  Request request = serviceMethod.toRequest(args);
+  // 调用Factory.newCall方法
+  okhttp3.Call call = serviceMethod.callFactory.newCall(request);
+  if (call == null) {
+    throw new NullPointerException("Call.Factory returned null.");
+  }
+  return call;
+}
+```
+
+然后看一下`Factory.newCall()`方法:  
+```java
+interface Factory {
+    Call newCall(Request request);
+  }
+```
+
+它的实现类是`OkHttpClient`类中的`newCall()`方法，并且创建`RealCall`对象:    
+```java
+@Override public Call newCall(Request request) {
+    return new RealCall(this, request);
+  }
+```
+
+#### 第二部分：执行网络请求
+
+这一部分是在`call.enqueue()`方法中执行的，上面我们分析了创建的`Call`最终是`RealCall`类，所以这里直接到看`RealCall.enqueue()`方法:    
+
+```java
+@Override public void enqueue(Callback responseCallback) {
+    enqueue(responseCallback, false);
+  }
+
+  void enqueue(Callback responseCallback, boolean forWebSocket) {
+    synchronized (this) {
+      if (executed) throw new IllegalStateException("Already Executed");
+      executed = true;
+    }
+
+    // 调用OkHttpClient中的Dispatcher中的enqueue方法
+    client.dispatcher().enqueue(new AsyncCall(responseCallback, forWebSocket));
+  }
+```
+
+我们接着看`client.dispatcher().enqueue()`方法:
+
+```java
+synchronized void enqueue(AsyncCall call) {
+    // maxRequests的个数是64;
+    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
+      runningAsyncCalls.add(call);
+      // 线程池执行
+      executorService().execute(call);
+    } else {
+      readyAsyncCalls.add(call);
+    }
+  }
+```   
+
+而这个参数`AsyncCall`是什么鬼？ 它是`RealCall`的内部类，它里面的`execute()`方法是如何实现的？ 只要找到该方法的实现就算是完成了。     
+
+首先看一下`AsyncCall`的声明和构造:    
+```java
+final class AsyncCall extends NamedRunnable {
+    private final Callback responseCallback;
+    private final boolean forWebSocket;
+
+    private AsyncCall(Callback responseCallback, boolean forWebSocket) {
+      super("OkHttp %s", redactedUrl().toString());
+      this.responseCallback = responseCallback;
+      this.forWebSocket = forWebSocket;
+    }
+    ...
+  }
+```
+
+`NamedRunnable`是`Runnable`的实现类。我们看一下它的`execute()`方法:   
+```java
+@Override protected void execute() {
+      boolean signalledCallback = false;
+      try {
+        // 获取请求结果
+        Response response = getResponseWithInterceptorChain(forWebSocket);
+        if (canceled) {
+          signalledCallback = true;
+          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
+        } else {
+          signalledCallback = true;
+          // 将响应结果设置给之前构造函数传递回来的回调
+          responseCallback.onResponse(RealCall.this, response);
+        }
+      } catch (IOException e) {
+        if (signalledCallback) {
+          // Do not signal the callback twice!
+          Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
+        } else {
+          responseCallback.onFailure(RealCall.this, e);
+        }
+      } finally {
+        client.dispatcher().finished(this);
+      }
+    }
+```
+
+接着看一下`RealCall.getResponseWithInterceptorChain()`:    
+
+```java
+private Response getResponseWithInterceptorChain(boolean forWebSocket) throws IOException {
+    Interceptor.Chain chain = new ApplicationInterceptorChain(0, originalRequest, forWebSocket);
+    return chain.proceed(originalRequest);
+  }
+
+  class ApplicationInterceptorChain implements Interceptor.Chain {
+    private final int index;
+    private final Request request;
+    private final boolean forWebSocket;
+
+    ApplicationInterceptorChain(int index, Request request, boolean forWebSocket) {
+      this.index = index;
+      this.request = request;
+      this.forWebSocket = forWebSocket;
+    }
+
+    @Override public Connection connection() {
+      return null;
+    }
+
+    @Override public Request request() {
+      return request;
+    }
+
+    @Override public Response proceed(Request request) throws IOException {
+      // If there's another interceptor in the chain, call that.
+      if (index < client.interceptors().size()) {
+        Interceptor.Chain chain = new ApplicationInterceptorChain(index + 1, request, forWebSocket);
+        Interceptor interceptor = client.interceptors().get(index);
+        Response interceptedResponse = interceptor.intercept(chain);
+
+        if (interceptedResponse == null) {
+          throw new NullPointerException("application interceptor " + interceptor
+              + " returned null");
+        }
+
+        return interceptedResponse;
+      }
+
+      // No more interceptors. Do HTTP.
+      return getResponse(request, forWebSocket);
+    }
+  }
+```
+
+又会调用`getResponse()`方法：    
+```java
+/**
+   * Performs the request and returns the response. May return null if this call was canceled.
+   */
+  Response getResponse(Request request, boolean forWebSocket) throws IOException {
+    // Copy body metadata to the appropriate request headers.
+    RequestBody body = request.body();
+    if (body != null) {
+      Request.Builder requestBuilder = request.newBuilder();
+
+      MediaType contentType = body.contentType();
+      if (contentType != null) {
+        requestBuilder.header("Content-Type", contentType.toString());
+      }
+
+      long contentLength = body.contentLength();
+      if (contentLength != -1) {
+        requestBuilder.header("Content-Length", Long.toString(contentLength));
+        requestBuilder.removeHeader("Transfer-Encoding");
+      } else {
+        requestBuilder.header("Transfer-Encoding", "chunked");
+        requestBuilder.removeHeader("Content-Length");
+      }
+
+      request = requestBuilder.build();
+    }
+
+    // Create the initial HTTP engine. Retries and redirects need new engine for each attempt.
+    engine = new HttpEngine(client, request, false, false, forWebSocket, null, null, null);
+
+    int followUpCount = 0;
+    while (true) {
+      if (canceled) {
+        engine.releaseStreamAllocation();
+        throw new IOException("Canceled");
+      }
+
+      boolean releaseConnection = true;
+      try {
+        engine.sendRequest();
+        engine.readResponse();
+        releaseConnection = false;
+      } catch (RequestException e) {
+        // The attempt to interpret the request failed. Give up.
+        throw e.getCause();
+      } catch (RouteException e) {
+        // The attempt to connect via a route failed. The request will not have been sent.
+        HttpEngine retryEngine = engine.recover(e.getLastConnectException(), true, null);
+        if (retryEngine != null) {
+          releaseConnection = false;
+          engine = retryEngine;
+          continue;
+        }
+        // Give up; recovery is not possible.
+        throw e.getLastConnectException();
+      } catch (IOException e) {
+        // An attempt to communicate with a server failed. The request may have been sent.
+        HttpEngine retryEngine = engine.recover(e, false, null);
+        if (retryEngine != null) {
+          releaseConnection = false;
+          engine = retryEngine;
+          continue;
+        }
+
+        // Give up; recovery is not possible.
+        throw e;
+      } finally {
+        // We're throwing an unchecked exception. Release any resources.
+        if (releaseConnection) {
+          StreamAllocation streamAllocation = engine.close();
+          streamAllocation.release();
+        }
+      }
+
+      Response response = engine.getResponse();
+      Request followUp = engine.followUpRequest();
+
+      if (followUp == null) {
+        if (!forWebSocket) {
+          engine.releaseStreamAllocation();
+        }
+        return response;
+      }
+
+      StreamAllocation streamAllocation = engine.close();
+
+      if (++followUpCount > MAX_FOLLOW_UPS) {
+        streamAllocation.release();
+        throw new ProtocolException("Too many follow-up requests: " + followUpCount);
+      }
+
+      if (!engine.sameConnection(followUp.url())) {
+        streamAllocation.release();
+        streamAllocation = null;
+      } else if (streamAllocation.stream() != null) {
+        throw new IllegalStateException("Closing the body of " + response
+            + " didn't close its backing stream. Bad interceptor?");
+      }
+
+      request = followUp;
+      engine = new HttpEngine(client, request, false, false, forWebSocket, streamAllocation, null,
+          response);
+    }
+  }
+```
+
+完了没有？ 完了....
+
+
+上面只是简单的分析了下大体的调用流程和主要的类，但是好像并没有什么乱用，因为没有具体的去分析里面各部分的实现，如果都分析下来内容太多了。这里就不仔细看了，大体总结一下。    
+
+通过上面的分析，最终的网络请求是在`OkHttp`的`Call`中去执行，也就是说`Retrofit`其实是将一个`Java`接口通过注解等方式来解析参数等然后转换成一个请求交给`OkHttp`去执行，然后将执行结果进行解析转换暴露给上层调用者。 
+而这一切是如何实现的呢？ 
+`Retrofit`非常巧妙的用注解来描述一个`HTTP`请求，将一个`HTTP`请求抽象成一个`Java`接口，然后用了`动态代理`的方式，动态的将这个接口的注解转换成一个`HTTP`请求，然后再将这个`Http`请求交给`OkHttp`执行。
+
+动态代理用的太妙，而它的过程中也使用了大量的工厂模式，这里就不分析了。
+
+
+参考:   
+- [simple-http-retrofit-2](https://realm.io/news/droidcon-jake-wharton-simple-http-retrofit-2)
+- [Retrofit API](http://square.github.io/retrofit/2.x/retrofit/)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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"
new file mode 100644
index 00000000..8b6ca304
--- /dev/null
+++ "b/SourceAnalysis/Netowork/Volley\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,1149 @@
+Volley源码分析
+---
+
+- Volley简介    
+
+    [volley官方地址](https://android.googlesource.com/platform/frameworks/volley)                                                   
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/volley.png?raw=true)                   
+
+    在`Google I/0 2013`中发布了`Volley`.`Volley`是`Android`平台上的网络通信库，能使网络通信更快，更简单，更健壮。
+
+    这是`Volley`名称的由来:`a burst or emission of many things or a large amount at once`.`Volley`特别适合数据量不大但是通信频繁的场景。   
+
+    `Github`上面已经有大神做了镜像，使用`Gradle`更方便。[Volley On Github](https://github.com/mcxiaoke/android-volley)            
+
+- Volley使用                   
+    `Volley`的使用非常方便。
+    - 首先就是要构建一个`RequestQueue`的请求队列，它可以缓存所有`Http`请求，内部处理的非常完善，通常我们整个应用只需要一个`RequestQueue`对象即可。
+    - 创建`StringRequest`对象，并且传入相应的请求地址以及添加请求成功和失败的回调方法。这一步的意思就是创建一个新的网络请求。
+    - 将刚才新创建的`StringRequest`对象加入到`RequestQueue`队列中。这样就相当于会去执行该请求。等到执行成功后就可以在`StringRequest`中设置的回调方法里面获取到相应的结果。      
+    总结一下，其实挺像我们浏览器的操作，第一步打开浏览器，第二步输入`URL`地址第三步按回车去执行。    
+
+    ```java
+    public class HttpUtil {
+        private static HttpUtil instance;
+        private RequestQueue mQueue;
+    
+        private HttpUtil(Context context) {
+            mQueue = Volley.newRequestQueue(context);
+        }
+    
+        public static synchronized HttpUtil getInstance(Context context) {
+            if (instance == null) {
+                instance = new HttpUtil(context.getApplicationContext());
+            }
+            return instance;
+        }
+    
+        public Request sendGetRequest(String url, final HttpListener listener) {
+            StringRequest stringRequest = new StringRequest(url, new Response.Listener<String>() {
+                @Override
+                public void onResponse(String response) {
+                    if (listener != null) {
+                        listener.onResponse(response);
+                    }
+                }
+            }, new Response.ErrorListener() {
+                @Override
+                public void onErrorResponse(VolleyError error) {
+                    if (listener != null) {
+                        listener.onErrorResponse(error);
+                    }
+                }
+            });
+            mQueue.add(stringRequest);
+            return stringRequest;
+        }
+    
+        public Request sendPostRequest(String url, final Map<String, String> map, final HttpListener listener) {
+            final StringRequest stringRequest = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {
+                @Override
+                public void onResponse(String response) {
+                    if (listener != null) {
+                        listener.onResponse(response);
+                    }
+    
+                }
+            }, new Response.ErrorListener() {
+                @Override
+                public void onErrorResponse(VolleyError error) {
+                    if (listener != null) {
+                        listener.onErrorResponse(error);
+                    }
+                }
+            }) {
+                @Override
+                protected Map<String, String> getParams() throws AuthFailureError {
+                    return map;
+                }
+            };
+            mQueue.add(stringRequest);
+            return stringRequest;
+        }
+    
+        /**
+         * Response listener of HttpUtil.
+         */
+        public interface HttpListener {
+    
+            void onResponse(String response);
+    
+            void onErrorResponse(VolleyError error);
+        }
+    }
+    ```
+
+到这里我们就简单的介绍了它的使用，当然还有一些其他的`Request`对象例如`JsonRequest`等，他们的使用方法都是一样的，这里就不再说明了。当然`Volley`里面还提供了对图片的处理，例如`NetworkImageView`空间和`ImageRequest`等，因为这里图片用到的不太多，所以暂时不去分析了。
+
+
+接下来我们就从源码的角度去分析一下：      
+这里我们都知道使用的时候最新要初始化一个`RequestQueue`所以，我们首先看一下`Volley.newRequestQueue`方法。
+```java
+
+public class Volley {
+
+    /** Default on-disk cache directory. */
+    private static final String DEFAULT_CACHE_DIR = "volley";
+
+    /**
+     * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
+     * You may set a maximum size of the disk cache in bytes.
+     *
+     * @param context A {@link Context} to use for creating the cache dir.
+     * @param stack An {@link HttpStack} to use for the network, or null for default.
+     * @param maxDiskCacheBytes the maximum size of the disk cache, in bytes. Use -1 for default size.
+     * @return A started {@link RequestQueue} instance.
+     */
+    public static RequestQueue newRequestQueue(Context context, HttpStack stack, int maxDiskCacheBytes) {
+        File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);
+
+        String userAgent = "volley/0";
+        try {
+            String packageName = context.getPackageName();
+            PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
+            // 使用包名和versionCode作为userAgent
+            userAgent = packageName + "/" + info.versionCode;
+        } catch (NameNotFoundException e) {
+        }
+
+        if (stack == null) {
+            if (Build.VERSION.SDK_INT >= 9) {
+                // 在9及以上Volleys使用HttpURLConnection，9一下使用HttpClient。这里是有原因的，因为在9之前HttpURLConnection有Bug。
+                // 那HttpClient那么好为什么不一直使用它，要在9及以后使用HttpURLConnection呢？这里也是有原因的。从9开始HttpURLConnection
+                // 将自动添加`Accept-Encoding:gzip`头字段到`request`请求中，并做相应处理，一般我们请求都是字符串，所以压缩可以使数据大小大幅降低。
+                // 但是这也会带来问题的，之前开发中就遇到过。因为启用了压缩，所以`Content-Lenght`字段返回的是压缩后的大小。使用`getContentLength()`
+                // 方法去分配解压缩后数据大小是错误的。应该从response中读取字节直到`InputStream.read()`返回-1为止。当时我们在开发下载时就遇到过这个
+                // 问题，在下载视频时没有问题，但是在下载小说的时候就会发现`content-length`返回值不对。
+                // 总结一下就是在9之前HttpClient的bug更少，而HttpURLConnection存在严重的Bug。但是从9开始HttpURLConnection更小巧，API更简单，压缩以及
+                // response cache的使用减少了网络流量，提高了网络速度，也就更省电，所以更适合在Android中使用
+                stack = new HurlStack();
+            } else {
+                // Prior to Gingerbread, HttpUrlConnection was unreliable.
+                // See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
+                stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
+            }
+        }
+        // 创建BasicNetwork对象，下面会介绍BasicNetwork(HttpStack)方法的内部实现
+        Network network = new BasicNetwork(stack);
+        
+        RequestQueue queue;
+        if (maxDiskCacheBytes <= -1)
+        {
+                // 如果不指定大小的话，默认大小为5M
+            // No maximum size specified
+        	queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
+        }
+        else
+        {
+        	// Disk cache size specified
+        	queue = new RequestQueue(new DiskBasedCache(cacheDir, maxDiskCacheBytes), network);
+        }
+
+        queue.start();
+
+        return queue;
+    }
+    
+    /**
+     * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
+     * You may set a maximum size of the disk cache in bytes.
+     *
+     * @param context A {@link Context} to use for creating the cache dir.
+     * @param maxDiskCacheBytes the maximum size of the disk cache, in bytes. Use -1 for default size.
+     * @return A started {@link RequestQueue} instance.
+     */
+    public static RequestQueue newRequestQueue(Context context, int maxDiskCacheBytes) {
+        return newRequestQueue(context, null, maxDiskCacheBytes);
+    }
+    
+    /**
+     * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
+     *
+     * @param context A {@link Context} to use for creating the cache dir.
+     * @param stack An {@link HttpStack} to use for the network, or null for default.
+     * @return A started {@link RequestQueue} instance.
+     */
+    public static RequestQueue newRequestQueue(Context context, HttpStack stack)
+    {
+    	return newRequestQueue(context, stack, -1);
+    }
+    
+    /**
+     * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
+     *
+     * @param context A {@link Context} to use for creating the cache dir.
+     * @return A started {@link RequestQueue} instance.
+     */
+    public static RequestQueue newRequestQueue(Context context) {
+        return newRequestQueue(context, null);
+    }
+
+}
+
+```
+
+接着来看一下上面提到的new BasicNetwork(HttpStack)方法的实现,可以看到他内部的缓存大小是4k
+```java
+private static int DEFAULT_POOL_SIZE = 4096;
+
+protected final HttpStack mHttpStack;
+
+protected final ByteArrayPool mPool;
+
+/**
+ * @param httpStack HTTP stack to be used
+ */
+public BasicNetwork(HttpStack httpStack) {
+    // If a pool isn't passed in, then build a small default pool that will give us a lot of
+    // benefit and not use too much memory.
+    this(httpStack, new ByteArrayPool(DEFAULT_POOL_SIZE));
+}
+
+/**
+ * @param httpStack HTTP stack to be used
+ * @param pool a buffer pool that improves GC performance in copy operations
+ */
+public BasicNetwork(HttpStack httpStack, ByteArrayPool pool) {
+    mHttpStack = httpStack;
+    mPool = pool;
+}
+```
+
+接着我们还要分析一下`RequestQueue`的构造方法以及`start()`方法:      
+```java
+/**
+ * A request dispatch queue with a thread pool of dispatchers.
+ *
+ * Calling {@link #add(Request)} will enqueue the given Request for dispatch,
+ * resolving from either cache or network on a worker thread, and then delivering
+ * a parsed response on the main thread.
+ *//**
+ * A request dispatch queue with a thread pool of dispatchers.
+ *
+ * Calling {@link #add(Request)} will enqueue the given Request for dispatch,
+ * resolving from either cache or network on a worker thread, and then delivering
+ * a parsed response on the main thread.
+ */
+public class RequestQueue {
+
+    /** Used for generating monotonically-increasing sequence numbers for requests. */
+    private AtomicInteger mSequenceGenerator = new AtomicInteger();
+
+    /**
+     * Staging area for requests that already have a duplicate request in flight.
+     *
+     * <ul>
+     *     <li>containsKey(cacheKey) indicates that there is a request in flight for the given cache
+     *          key.</li>
+     *     <li>get(cacheKey) returns waiting requests for the given cache key. The in flight request
+     *          is <em>not</em> contained in that list. Is null if no requests are staged.</li>
+     * </ul>
+     */
+    private final Map<String, Queue<Request<?>>> mWaitingRequests =
+            new HashMap<String, Queue<Request<?>>>();
+
+    /**
+     * The set of all requests currently being processed by this RequestQueue. A Request
+     * will be in this set if it is waiting in any queue or currently being processed by
+     * any dispatcher.
+     */
+    private final Set<Request<?>> mCurrentRequests = new HashSet<Request<?>>();
+
+    // 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<?>>();
+
+    /** Number of network request dispatcher threads to start. */
+    private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4;
+
+    /** Cache interface for retrieving and storing responses. */
+    private final Cache mCache;
+
+    /** Network interface for performing requests. */
+    private final Network mNetwork;
+
+    /** Response delivery mechanism. */
+    private final ResponseDelivery mDelivery;
+
+    /** The network dispatchers. */
+    private NetworkDispatcher[] mDispatchers;
+
+    /** The cache dispatcher. */
+    private CacheDispatcher mCacheDispatcher;
+
+    /**
+     * Creates the worker pool. Processing will not begin until {@link #start()} is called.
+     *
+     * @param cache A Cache to use for persisting responses to disk
+     * @param network A Network interface for performing HTTP requests
+     * @param threadPoolSize Number of network dispatcher threads to create
+     * @param delivery A ResponseDelivery interface for posting responses and errors
+     */
+    public RequestQueue(Cache cache, Network network, int threadPoolSize,
+            ResponseDelivery delivery) {
+        mCache = cache;
+        mNetwork = network;
+        mDispatchers = new NetworkDispatcher[threadPoolSize];
+        mDelivery = delivery;
+    }
+
+    /**
+     * Creates the worker pool. Processing will not begin until {@link #start()} is called.
+     *
+     * @param cache A Cache to use for persisting responses to disk
+     * @param network A Network interface for performing HTTP requests
+     * @param threadPoolSize Number of network dispatcher threads to create
+     */
+    public RequestQueue(Cache cache, Network network, int threadPoolSize) {
+        this(cache, network, threadPoolSize,
+                new ExecutorDelivery(new Handler(Looper.getMainLooper())));
+    }
+
+    /**
+     * Creates the worker pool. Processing will not begin until {@link #start()} is called.
+     *
+     * @param cache A Cache to use for persisting responses to disk
+     * @param network A Network interface for performing HTTP requests
+     */
+    public RequestQueue(Cache cache, Network network) {
+        // 默认大小为4
+        this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);
+    }
+
+    /**
+     * Starts the dispatchers in this queue.
+     */
+    public void start() {
+        stop();  // Make sure any currently running dispatchers are stopped.
+        // Create the cache dispatcher and start it.
+        // 初始化RequestQueue之后就会调用start方法，内部会开启CacheDispatcher,也是Thread的子类，后面再看里面具体的run方法
+        mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
+        mCacheDispatcher.start();
+
+        // Create network dispatchers (and corresponding threads) up to the pool size.
+        for (int i = 0; i < mDispatchers.length; i++) {
+            // 创建4个(默认是4个)NetworkDispatcher一直去执行, NetworkDispatcher是Thread的子类，他会不断的去从mNetworkQueue中取出Requet并用
+            // 并用mNetwork去执行，执行完成后再使用mDelivery去分发相应的结果
+            NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
+                    mCache, mDelivery);
+            mDispatchers[i] = networkDispatcher;
+            networkDispatcher.start();
+        }
+        // 就好像一个工厂一启动，里面就分配了5个搬运工，一个负责搬运cache里面的的请求，4个负责搬运network中的。启动后他们就开始待命
+        // 一旦有活来了，就开始去取出活开始干。
+
+    }
+
+    /**
+     * Stops the cache and network dispatchers.
+     */
+    public void stop() {
+        if (mCacheDispatcher != null) {
+            mCacheDispatcher.quit();
+        }
+        for (int i = 0; i < mDispatchers.length; i++) {
+            if (mDispatchers[i] != null) {
+                mDispatchers[i].quit();
+            }
+        }
+    }
+
+    /**
+     * Gets a sequence number.
+     */
+    public int getSequenceNumber() {
+        return mSequenceGenerator.incrementAndGet();
+    }
+
+    /**
+     * Gets the {@link Cache} instance being used.
+     */
+    public Cache getCache() {
+        return mCache;
+    }
+
+    /**
+     * A simple predicate or filter interface for Requests, for use by
+     * {@link RequestQueue#cancelAll(RequestFilter)}.
+     */
+    public interface RequestFilter {
+        public boolean apply(Request<?> request);
+    }
+
+    /**
+     * Cancels all requests in this queue for which the given filter applies.
+     * @param filter The filtering function to use
+     */
+    public void cancelAll(RequestFilter filter) {
+        synchronized (mCurrentRequests) {
+            for (Request<?> request : mCurrentRequests) {
+                if (filter.apply(request)) {
+                    request.cancel();
+                }
+            }
+        }
+    }
+
+    /**
+     * Cancels all requests in this queue with the given tag. Tag must be non-null
+     * and equality is by identity.
+     */
+    public void cancelAll(final Object tag) {
+        if (tag == null) {
+            throw new IllegalArgumentException("Cannot cancelAll with a null tag");
+        }
+        cancelAll(new RequestFilter() {
+            @Override
+            public boolean apply(Request<?> request) {
+                return request.getTag() == tag;
+            }
+        });
+    }
+
+    /**
+     * Adds a Request to the dispatch queue.
+     * @param request The request to service
+     * @return The passed-in request
+     */
+    public <T> Request<T> add(Request<T> request) {
+        // Tag the request as belonging to this queue and add it to the set of current requests.
+        request.setRequestQueue(this);
+        synchronized (mCurrentRequests) {
+            // 添加到mCurrentRequests中，在执行完后的finish方法中会去移除该请求。
+            mCurrentRequests.add(request);
+        }
+
+        // Process requests in the order they are added.
+        request.setSequence(getSequenceNumber());
+        request.addMarker("add-to-queue");
+
+        // 判断一下该请求能否进行缓存，如果不能缓存就直接添加到网络请求的队列中。这个能不能缓存是怎么判断的？其实就是根据Request中的一个变量来判断。
+　　　　// 默认情况下所有的请求都是可以缓存的，可以通过Request.setShouldCache(false)方法，来将其设置为不可缓存状态。
+        // If the request is uncacheable, skip the cache queue and go straight to the network.
+        if (!request.shouldCache()) {
+            mNetworkQueue.add(request);
+            return request;
+        }
+
+        // Insert request into stage if there's already a request with the same cache key in flight.
+        synchronized (mWaitingRequests) {
+            String cacheKey = request.getCacheKey();
+            if (mWaitingRequests.containsKey(cacheKey)) {
+                // There is already a request in flight. Queue up.
+                Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
+                if (stagedRequests == null) {
+                    stagedRequests = new LinkedList<Request<?>>();
+                }
+                stagedRequests.add(request);
+                mWaitingRequests.put(cacheKey, stagedRequests);
+                if (VolleyLog.DEBUG) {
+                    VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);
+                }
+            } else {
+                // 如果能缓存，并且缓存线程中没有的时候就讲该请求添加到缓存队列中
+                // Insert 'null' queue for this cacheKey, indicating there is now a request in
+                // flight.
+                mWaitingRequests.put(cacheKey, null);
+                mCacheQueue.add(request);
+            }
+            return request;
+        }
+    }
+
+    /**
+     * Called from {@link Request#finish(String)}, indicating that processing of the given request
+     * has finished.
+     *
+     * <p>Releases waiting requests for <code>request.getCacheKey()</code> if
+     *      <code>request.shouldCache()</code>.</p>
+     */
+    void finish(Request<?> request) {
+        // Remove from the set of requests currently being processed.
+        synchronized (mCurrentRequests) {
+            mCurrentRequests.remove(request);
+        }
+
+        if (request.shouldCache()) {
+            synchronized (mWaitingRequests) {
+                String cacheKey = request.getCacheKey();
+                Queue<Request<?>> waitingRequests = mWaitingRequests.remove(cacheKey);
+                if (waitingRequests != null) {
+                    if (VolleyLog.DEBUG) {
+                        VolleyLog.v("Releasing %d waiting requests for cacheKey=%s.",
+                                waitingRequests.size(), cacheKey);
+                    }
+                    // Process all queued up requests. They won't be considered as in flight, but
+                    // that's not a problem as the cache has been primed by 'request'.
+                    mCacheQueue.addAll(waitingRequests);
+                }
+            }
+        }
+    }
+}
+```
+
+看到这里基本都能看的差不多了。官方文档中有句话说的很好，这里用他来总结一下`A RequestQueue needs two things to do its job: a network to perform transport of the requests, and a cache to handle caching. `
+顺便再上一张图:       
+ 
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/volley-request.png?raw=true)                   
+
+总结完之后我们接着进行分析。因为默认情况下请求都是可缓存的，所以都会被添加到mCacheQueue中。添加该队列之后，就会被开始`start`方法所制定的cache搬运工去执行，所以我们要看一下CacheDispatcher的实现。
+```java
+/**
+ * Provides a thread for performing cache triage on a queue of requests.
+ *
+ * Requests added to the specified cache queue are resolved from cache.
+ * Any deliverable response is posted back to the caller via a
+ * {@link ResponseDelivery}.  Cache misses and responses that require
+ * refresh are enqueued on the specified network queue for processing
+ * by a {@link NetworkDispatcher}.
+ */
+public class CacheDispatcher extends Thread {
+
+    private static final boolean DEBUG = VolleyLog.DEBUG;
+
+    /** The queue of requests coming in for triage. */
+    private final BlockingQueue<Request<?>> mCacheQueue;
+
+    /** The queue of requests going out to the network. */
+    private final BlockingQueue<Request<?>> mNetworkQueue;
+
+    /** The cache to read from. */
+    private final Cache mCache;
+
+    /** For posting responses. */
+    private final ResponseDelivery mDelivery;
+
+    /** Used for telling us to die. */
+    private volatile boolean mQuit = false;
+
+    /**
+     * Creates a new cache triage dispatcher thread.  You must call {@link #start()}
+     * in order to begin processing.
+     *
+     * @param cacheQueue Queue of incoming requests for triage
+     * @param networkQueue Queue to post requests that require network to
+     * @param cache Cache interface to use for resolution
+     * @param delivery Delivery interface to use for posting responses
+     */
+    public CacheDispatcher(
+            BlockingQueue<Request<?>> cacheQueue, BlockingQueue<Request<?>> networkQueue,
+            Cache cache, ResponseDelivery delivery) {
+        // 将CacheQueue以及networkQueue等传递进来。
+        mCacheQueue = cacheQueue;
+        mNetworkQueue = networkQueue;
+        mCache = cache;
+        mDelivery = delivery;
+    }
+
+    /**
+     * Forces this dispatcher to quit immediately.  If any requests are still in
+     * the queue, they are not guaranteed to be processed.
+     */
+    public void quit() {
+        mQuit = true;
+        interrupt();
+    }
+
+    @Override
+    public void run() {
+        if (DEBUG) VolleyLog.v("start new dispatcher");
+        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+
+        // Make a blocking call to initialize the cache.
+    /**
+     * Performs any potentially long-running actions needed to initialize the cache;
+     * will be called from a worker thread.
+     */
+        mCache.initialize();
+
+        while (true) {
+            try {
+                // 从缓存队列中取出第一个请求
+                // Get a request from the cache triage queue, blocking until
+                // at least one is available.
+                final Request<?> request = mCacheQueue.take();
+                request.addMarker("cache-queue-take");
+
+                // If the request has been canceled, don't bother dispatching it.
+                if (request.isCanceled()) {
+                    request.finish("cache-discard-canceled");
+                    continue;
+                }
+
+                // Attempt to retrieve this item from cache.
+                Cache.Entry entry = mCache.get(request.getCacheKey());
+                if (entry == null) {
+                    // 如果缓存中找不到该请求，就把该请求添加到网络请求队列中。
+                    request.addMarker("cache-miss");
+                    // Cache miss; send off to the network dispatcher.
+                    mNetworkQueue.put(request);
+                    continue;
+                }
+                // 如果缓存中找到了该请求，接下来就判断该缓存是否过期。
+                // If it is completely expired, just send it to the network.
+                if (entry.isExpired()) {
+                    // 过期了也重新添加到网络请求中
+                    request.addMarker("cache-hit-expired");
+                    request.setCacheEntry(entry);
+                    mNetworkQueue.put(request);
+                    continue;
+                }
+                // 没有过期，就不用再请求了，直接从缓存中取出数据返回即可。
+                // We have a cache hit; parse its data for delivery back to the request.
+                request.addMarker("cache-hit");
+                // 这里的意思就是对数据进行解析，后面再看Request.parseNetworkResponse方法。
+                Response<?> response = request.parseNetworkResponse(
+                        new NetworkResponse(entry.data, entry.responseHeaders));
+                request.addMarker("cache-hit-parsed");
+		// 判断缓存数据是否需要刷新，以便使用mDelivery分发结果或者添加到网络请求队列中
+                if (!entry.refreshNeeded()) {
+                    // Completely unexpired cache hit. Just deliver the response.
+                    mDelivery.postResponse(request, response);
+                } else {
+                    // Soft-expired cache hit. We can deliver the cached response,
+                    // but we need to also send the request to the network for
+                    // refreshing.
+                    request.addMarker("cache-hit-refresh-needed");
+                    request.setCacheEntry(entry);
+
+                    // Mark the response as intermediate.
+                    response.intermediate = true;
+
+                    // Post the intermediate response back to the user and have
+                    // the delivery then forward the request along to the network.
+                    mDelivery.postResponse(request, response, new Runnable() {
+                        @Override
+                        public void run() {
+                            try {
+                                mNetworkQueue.put(request);
+                            } catch (InterruptedException e) {
+                                // Not much we can do about this.
+                            }
+                        }
+                    });
+                }
+
+            } catch (InterruptedException e) {
+                // We may have been interrupted because it was time to quit.
+                if (mQuit) {
+                    return;
+                }
+                continue;
+            }
+        }
+    }
+}
+
+```
+
+而对于网络请求队列中的任务该如何执行，这里就要看`NetworkDispatcher`的具体实现:        
+
+```java
+/**
+ * Provides a thread for performing network dispatch from a queue of requests.
+ *
+ * Requests added to the specified queue are processed from the network via a
+ * specified {@link Network} interface. Responses are committed to cache, if
+ * eligible, using a specified {@link Cache} interface. Valid responses and
+ * errors are posted back to the caller via a {@link ResponseDelivery}.
+ */
+public class NetworkDispatcher extends Thread {
+    /** The queue of requests to service. */
+    private final BlockingQueue<Request<?>> mQueue;
+    /** The network interface for processing requests. */
+    private final Network mNetwork;
+    /** The cache to write to. */
+    private final Cache mCache;
+    /** For posting responses and errors. */
+    private final ResponseDelivery mDelivery;
+    /** Used for telling us to die. */
+    private volatile boolean mQuit = false;
+
+    /**
+     * Creates a new network dispatcher thread.  You must call {@link #start()}
+     * in order to begin processing.
+     *
+     * @param queue Queue of incoming requests for triage
+     * @param network Network interface to use for performing requests
+     * @param cache Cache interface to use for writing responses to cache
+     * @param delivery Delivery interface to use for posting responses
+     */
+    public NetworkDispatcher(BlockingQueue<Request<?>> queue,
+            Network network, Cache cache,
+            ResponseDelivery delivery) {
+        mQueue = queue;
+        mNetwork = network;
+        mCache = cache;
+        mDelivery = delivery;
+    }
+
+    /**
+     * Forces this dispatcher to quit immediately.  If any requests are still in
+     * the queue, they are not guaranteed to be processed.
+     */
+    public void quit() {
+        mQuit = true;
+        interrupt();
+    }
+
+    @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+    private void addTrafficStatsTag(Request<?> request) {
+        // Tag the request (if API >= 14)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
+            TrafficStats.setThreadStatsTag(request.getTrafficStatsTag());
+        }
+    }
+
+    @Override
+    public void run() {
+        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+        while (true) {
+            long startTimeMs = SystemClock.elapsedRealtime();
+            Request<?> request;
+            try {
+                // Take a request from the queue.
+                request = mQueue.take();
+            } catch (InterruptedException e) {
+                // We may have been interrupted because it was time to quit.
+                if (mQuit) {
+                    return;
+                }
+                continue;
+            }
+
+            try {
+                request.addMarker("network-queue-take");
+
+                // If the request was cancelled already, do not perform the
+                // network request.
+                if (request.isCanceled()) {
+                    request.finish("network-discard-cancelled");
+                    continue;
+                }
+
+                addTrafficStatsTag(request);
+                // mNetwork会去执行对应的request请求，后面再看里面的具体实现
+                // Perform the network request.
+                NetworkResponse networkResponse = mNetwork.performRequest(request);
+                request.addMarker("network-http-complete");
+
+                // If the server returned 304 AND we delivered a response already,
+                // we're done -- don't deliver a second identical response.
+                if (networkResponse.notModified && request.hasHadResponseDelivered()) {
+                    request.finish("not-modified");
+                    continue;
+                }
+                // 将网络请求返回的NetworkResponse交给request.parseNetworkResponse进行处理
+                // Parse the response here on the worker thread.
+                Response<?> response = request.parseNetworkResponse(networkResponse);
+                request.addMarker("network-parse-complete");
+
+                // Write to cache if applicable.
+                // TODO: Only update cache metadata instead of entire record for 304s.
+                if (request.shouldCache() && response.cacheEntry != null) {
+                    mCache.put(request.getCacheKey(), response.cacheEntry);
+                    request.addMarker("network-cache-written");
+                }
+
+                // Post the response back.
+                request.markDelivered();
+                // mDelivery进行分发
+                mDelivery.postResponse(request, response);
+            } catch (VolleyError volleyError) {
+                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
+                parseAndDeliverNetworkError(request, volleyError);
+            } catch (Exception e) {
+                VolleyLog.e(e, "Unhandled exception %s", e.toString());
+                VolleyError volleyError = new VolleyError(e);
+                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
+                mDelivery.postError(request, volleyError);
+            }
+        }
+    }
+
+    private void parseAndDeliverNetworkError(Request<?> request, VolleyError error) {
+        error = request.parseNetworkError(error);
+        mDelivery.postError(request, error);
+    }
+}
+```
+上面会执行到`mNetwork.performRequest`方法，而`Network`是一个接口，具体的实现要看`BaseNetwork`中的实现：      
+```java
+    @Override
+    public NetworkResponse performRequest(Request<?> request) throws VolleyError {
+        long requestStart = SystemClock.elapsedRealtime();
+        while (true) {
+            HttpResponse httpResponse = null;
+            byte[] responseContents = null;
+            Map<String, String> responseHeaders = Collections.emptyMap();
+            try {
+                // Gather headers.
+                Map<String, String> headers = new HashMap<String, String>();
+                addCacheHeaders(headers, request.getCacheEntry());
+                // 调用mHttpStack.performRequest方法，这里就是newRequestQueue中创建的部分，9及以上为HurlStack，9以下为HttpClientStach,具体就是真正执行网络请求的部分了。
+                httpResponse = mHttpStack.performRequest(request, headers);
+                StatusLine statusLine = httpResponse.getStatusLine();
+                int statusCode = statusLine.getStatusCode();
+
+                responseHeaders = convertHeaders(httpResponse.getAllHeaders());
+                // Handle cache validation.
+                if (statusCode == HttpStatus.SC_NOT_MODIFIED) {
+
+                    Entry entry = request.getCacheEntry();
+                    if (entry == null) {
+                        return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, null,
+                                responseHeaders, true,
+                                SystemClock.elapsedRealtime() - requestStart);
+                    }
+
+                    // A HTTP 304 response does not have all header fields. We
+                    // have to use the header fields from the cache entry plus
+                    // the new ones from the response.
+                    // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5
+                    entry.responseHeaders.putAll(responseHeaders);
+                    return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, entry.data,
+                            entry.responseHeaders, true,
+                            SystemClock.elapsedRealtime() - requestStart);
+                }
+                
+                // Handle moved resources
+                if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {
+                	String newUrl = responseHeaders.get("Location");
+                	request.setRedirectUrl(newUrl);
+                }
+
+                // Some responses such as 204s do not have content.  We must check.
+                if (httpResponse.getEntity() != null) {
+                  responseContents = entityToBytes(httpResponse.getEntity());
+                } else {
+                  // Add 0 byte response as a way of honestly representing a
+                  // no-content request.
+                  responseContents = new byte[0];
+                }
+
+                // if the request is slow, log it.
+                long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
+                logSlowRequests(requestLifetime, request, responseContents, statusLine);
+
+                if (statusCode < 200 || statusCode > 299) {
+                    throw new IOException();
+                }
+                return new NetworkResponse(statusCode, responseContents, responseHeaders, false,
+                        SystemClock.elapsedRealtime() - requestStart);
+            } catch (SocketTimeoutException e) {
+                attemptRetryOnException("socket", request, new TimeoutError());
+            } catch (ConnectTimeoutException e) {
+                attemptRetryOnException("connection", request, new TimeoutError());
+            } catch (MalformedURLException e) {
+                throw new RuntimeException("Bad URL " + request.getUrl(), e);
+            } catch (IOException e) {
+                int statusCode = 0;
+                NetworkResponse networkResponse = null;
+                if (httpResponse != null) {
+                    statusCode = httpResponse.getStatusLine().getStatusCode();
+                } else {
+                    throw new NoConnectionError(e);
+                }
+                if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || 
+                		statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {
+                	VolleyLog.e("Request at %s has been redirected to %s", request.getOriginUrl(), request.getUrl());
+                } else {
+                	VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());
+                }
+                if (responseContents != null) {
+                    networkResponse = new NetworkResponse(statusCode, responseContents,
+                            responseHeaders, false, SystemClock.elapsedRealtime() - requestStart);
+                    if (statusCode == HttpStatus.SC_UNAUTHORIZED ||
+                            statusCode == HttpStatus.SC_FORBIDDEN) {
+                        attemptRetryOnException("auth",
+                                request, new AuthFailureError(networkResponse));
+                    } else if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || 
+                    			statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {
+                        attemptRetryOnException("redirect",
+                                request, new AuthFailureError(networkResponse));
+                    } else {
+                        // TODO: Only throw ServerError for 5xx status codes.
+                        throw new ServerError(networkResponse);
+                    }
+                } else {
+                    throw new NetworkError(networkResponse);
+                }
+            }
+        }
+    }
+```
+上面调用了mHttpStack.performRequest的方法，这里就以9及以上的HurlStack类来看下源码：   
+```java
+@Override
+public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
+		throws IOException, AuthFailureError {
+	String url = request.getUrl();
+	HashMap<String, String> map = new HashMap<String, String>();
+	map.putAll(request.getHeaders());
+	map.putAll(additionalHeaders);
+	if (mUrlRewriter != null) {
+		String rewritten = mUrlRewriter.rewriteUrl(url);
+		if (rewritten == null) {
+			throw new IOException("URL blocked by rewriter: " + url);
+		}
+		url = rewritten;
+	}
+	URL parsedUrl = new URL(url);
+	HttpURLConnection connection = openConnection(parsedUrl, request);
+	for (String headerName : map.keySet()) {
+		connection.addRequestProperty(headerName, map.get(headerName));
+	}
+	setConnectionParametersForRequest(connection, request);
+	// Initialize HttpResponse with data from the HttpURLConnection.
+	ProtocolVersion protocolVersion = new ProtocolVersion("HTTP", 1, 1);
+	int responseCode = connection.getResponseCode();
+	if (responseCode == -1) {
+		// -1 is returned by getResponseCode() if the response code could not be retrieved.
+		// Signal to the caller that something was wrong with the connection.
+		throw new IOException("Could not retrieve response code from HttpUrlConnection.");
+	}
+	StatusLine responseStatus = new BasicStatusLine(protocolVersion,
+			connection.getResponseCode(), connection.getResponseMessage());
+	BasicHttpResponse response = new BasicHttpResponse(responseStatus);
+	response.setEntity(entityFromConnection(connection));
+	for (Entry<String, List<String>> header : connection.getHeaderFields().entrySet()) {
+		if (header.getKey() != null) {
+			Header h = new BasicHeader(header.getKey(), header.getValue().get(0));
+			response.addHeader(h);
+		}
+	}
+	return response;
+}
+```
+
+接下来还要看一下`mDelivery.postResponse(request, response);`这里的,mDelivery就是`new ExecutorDelivery(new Handler(Looper.getMainLooper()))`
+```java
+/**
+ * Delivers responses and errors.
+ */
+public class ExecutorDelivery implements ResponseDelivery {
+    /** Used for posting responses, typically to the main thread. */
+    private final Executor mResponsePoster;
+
+    /**
+     * Creates a new response delivery interface.
+     * @param handler {@link Handler} to post responses on
+     */
+    public ExecutorDelivery(final Handler handler) {
+        // Make an Executor that just wraps the handler.
+        mResponsePoster = new Executor() {
+            @Override
+            public void execute(Runnable command) {
+                handler.post(command);
+            }
+        };
+    }
+
+    /**
+     * Creates a new response delivery interface, mockable version
+     * for testing.
+     * @param executor For running delivery tasks
+     */
+    public ExecutorDelivery(Executor executor) {
+        mResponsePoster = executor;
+    }
+
+    @Override
+    public void postResponse(Request<?> request, Response<?> response) {
+        postResponse(request, response, null);
+    }
+
+    @Override
+    public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
+        request.markDelivered();
+        request.addMarker("post-response");
+        // 内部会调用execute方法
+        mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
+    }
+
+    @Override
+    public void postError(Request<?> request, VolleyError error) {
+        request.addMarker("post-error");
+        Response<?> response = Response.error(error);
+        mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, null));
+    }
+
+    /**
+     * A Runnable used for delivering network responses to a listener on the
+     * main thread.
+     */
+    @SuppressWarnings("rawtypes")
+    private class ResponseDeliveryRunnable implements Runnable {
+        private final Request mRequest;
+        private final Response mResponse;
+        private final Runnable mRunnable;
+
+        public ResponseDeliveryRunnable(Request request, Response response, Runnable runnable) {
+            mRequest = request;
+            mResponse = response;
+            mRunnable = runnable;
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void run() {
+            // 这里就是重点部分了
+            // If this request has canceled, finish it and don't deliver.
+            if (mRequest.isCanceled()) {
+                mRequest.finish("canceled-at-delivery");
+                return;
+            }
+            // 调用mRequest的deliverResponse或者deliverError进行分发
+            // Deliver a normal response or error, depending.
+            if (mResponse.isSuccess()) {
+                mRequest.deliverResponse(mResponse.result);
+            } else {
+                mRequest.deliverError(mResponse.error);
+            }
+
+            // If this is an intermediate response, add a marker, otherwise we're done
+            // and the request can be finished.
+            if (mResponse.intermediate) {
+                mRequest.addMarker("intermediate-response");
+            } else {
+                // 执行finish方法
+                mRequest.finish("done");
+            }
+
+            // If we have been provided a post-delivery runnable, run it.
+            if (mRunnable != null) {
+                mRunnable.run();
+            }
+       }
+    }
+}
+
+```
+这里再看一下mRequest的deliverResponse方法。     
+Request接口中没有实现该方法，具体我们以StringRequest为例看一下： 
+```java
+/**
+ * A canned request for retrieving the response body at a given URL as a String.
+ */
+public class StringRequest extends Request<String> {
+    private final Listener<String> mListener;
+
+    /**
+     * Creates a new request with the given method.
+     *
+     * @param method the request {@link Method} to use
+     * @param url URL to fetch the string at
+     * @param listener Listener to receive the String response
+     * @param errorListener Error listener, or null to ignore errors
+     */
+    public StringRequest(int method, String url, Listener<String> listener,
+            ErrorListener errorListener) {
+        super(method, url, errorListener);
+        mListener = listener;
+    }
+
+    /**
+     * Creates a new GET request.
+     *
+     * @param url URL to fetch the string at
+     * @param listener Listener to receive the String response
+     * @param errorListener Error listener, or null to ignore errors
+     */
+    public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) {
+        this(Method.GET, url, listener, errorListener);
+    }
+
+    @Override
+    protected void deliverResponse(String response) {
+        // 回调
+        mListener.onResponse(response);
+    }
+
+    @Override
+    protected Response<String> parseNetworkResponse(NetworkResponse response) {
+        String parsed;
+        try {
+            parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
+        } catch (UnsupportedEncodingException e) {
+            parsed = new String(response.data);
+        }
+        return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
+    }
+}
+
+```
+
+
+接着看一下mRequest.finish方法的实现:    
+```java
+/**
+ * Notifies the request queue that this request has finished (successfully or with error).
+ *
+ * <p>Also dumps all events from this request's event log; for debugging.</p>
+ */
+void finish(final String tag) {
+    if (mRequestQueue != null) {
+        // 内部调用了mRequestQueue的finish方法，也就是把请求从请求队列中移除。
+        mRequestQueue.finish(this);
+    }
+    if (MarkerLog.ENABLED) {
+        final long threadId = Thread.currentThread().getId();
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            // If we finish marking off of the main thread, we need to
+            // actually do it on the main thread to ensure correct ordering.
+            Handler mainThread = new Handler(Looper.getMainLooper());
+            mainThread.post(new Runnable() {
+                @Override
+                public void run() {
+                    mEventLog.add(tag, threadId);
+                    mEventLog.finish(this.toString());
+                }
+            });
+            return;
+        }
+
+        mEventLog.add(tag, threadId);
+        mEventLog.finish(this.toString());
+    } else {
+        long requestTime = SystemClock.elapsedRealtime() - mRequestBirthTime;
+        if (requestTime >= SLOW_REQUEST_THRESHOLD_MS) {
+            VolleyLog.d("%d ms: %s", requestTime, this.toString());
+        }
+    }
+}
+```
+
+到这里就全部分析完了。
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/SourceAnalysis/Netowork/volley-retrofit-okhttp\344\271\213\346\210\221\344\273\254\350\257\245\345\246\202\344\275\225\351\200\211\346\213\251\347\275\221\350\267\257\346\241\206\346\236\266.md" "b/SourceAnalysis/Netowork/volley-retrofit-okhttp\344\271\213\346\210\221\344\273\254\350\257\245\345\246\202\344\275\225\351\200\211\346\213\251\347\275\221\350\267\257\346\241\206\346\236\266.md"
new file mode 100644
index 00000000..199266cd
--- /dev/null
+++ "b/SourceAnalysis/Netowork/volley-retrofit-okhttp\344\271\213\346\210\221\344\273\254\350\257\245\345\246\202\344\275\225\351\200\211\346\213\251\347\275\221\350\267\257\346\241\206\346\236\266.md"
@@ -0,0 +1,52 @@
+volley-retrofit-okhttp之我们该如何选择网路框架
+===
+
+说起`Volley`、`Retrofit`、`OkHttp`相信基本没有人不知道。当然这里把`OkHttp`放进来可能有些不恰当。
+因为`OkHttp`的官方介绍是`An HTTP+HTTP/2 client for Android and Java applications`。
+也就是说`OkHttp`是基于`http`协议封装的一套请求客户端。它是真正的网络请求部分，
+与`HttpClient`、`HttpUrlConnection`是一样的，
+但是显然它的效率非常高(说到这里顺便提一嘴，从`Android 4.4`开始`HttpUrlConnection`内部默认使用的也是`OkHttp`，
+具体请参考之前的文章[HttpUrlConnection详解][1]
+而`Volley`、`Retrofit`是控制请求的队列、切换、解析、缓存等逻辑。所以`Volley`和`Retrofit`都可以结合`OkHttp`来使用。 
+
+
+在`Android`开发中有很多网络请求框架，但是比较过来比较过去，最后最倾向的就是这两个:    
+
+- `Volley`:`Google`发布的网络请求框架，专门为移动设备定制，小而美。     
+- `Retrofit`:良心企业    `Square`由大神`JakeWharton`主导的开源项目,是基于`OkHttp`封装的一套`Resetful`网络请求框架。`Type-safe HTTP client for Android and Java by Square, Inc.`
+
+
+有关`Volley`的介绍请看之前发布的文章[Volley源码分析][2]
+
+
+这里就不分别介绍他俩了，直接说各自的优缺点:    
+
+- `Retrofit`使用起来更简单。而`Volley`配置起来会稍微麻烦，因为`Volley`可以使用`HttpClient`、`HttpUrlConnection`、`OkHttp`我们需要根据自己的需求去配置。而`Retrofit`只能结合`OkHttp`使用。   
+
+- `Retrofit`依赖于`OkHttp`，从而会导致它的包大小会比`Volley`的大。 
+
+- `Volley`有很好的内存缓存管理，它在解析之前会将整个相应部分都加载到内存中，所以它对于小的网络请求非常合适，但是不支持`post`大数据，所以不适合上传文件。而`Retrofit`使用的是硬盘缓存，所以相比起从缓存这块来讲`Retrofit`可能会更慢一些。   
+
+- `Retrofit`依赖于`OkHttp`，而`OkHttp`自身会避免同时两次请求同一个请求。所以`Retrofit`同样会和`Volley`一样去避免重复的请求，只不过它是在网络层来处理的。 
+
+- `Volley`在网络请求部分默认依赖于`Apache HttpClient`。而`Apache HttpClient`从`API 23`开始已经在`Android`中被移除并废弃了。这就是为什么很多开发者会认为`Volley`已经过时了，因为`Volley`并没有迁移到新的未废弃的代码。    
+
+- 默认情况下`Volley`会在`DefaultRetryPolicy`中会将读取和连接的超时时间设置为`2.5s`，并且对每次请求失败或者超时都有一次自动重试。 所以对于一些服务器响应可能会超过`2s`的请求，开发者需要格外的小心下。`Retrofit`的默认超时时间是`10s`，而且它对失败或者超时的操作不会自动重试。      
+- 很多开发者都会说`Retrofit`会比`Volley`更快。因为有人专门去测试过，其实这里是不严谨的。因为`Volley`可以结合使用`HttpUrlConnection`、`HttpClient`、`OkHttp`等来使用，而`Retrofit`是用`OkHttp`一起，所以如果你让`Volley`结合`OkHttp`之后再来测试你就会发现总体来说其实他们不相上下。    
+
+
+- `Volley`实现了很完善的`Activity`声明周期管理。
+
+虽然`Volley`之前也有一些问题，但是它们也都被各个大神修复。
+
+
+所以综合起来说使用`Volley+OKHttp`的组合是非常不错的，既可以保证速度又可以满足对缓存、重试等的处理。但是如果你是`RxJava`的使用者那你可能会更偏向于使用`Retrofit`，因为`Retrofit`可以无缝结合`RxJava`使用。目前主流的一套框架就是`Retrofit + OkHttp + RxJava + Dagger2 `，但是对使用者的要求也相对要高些。
+
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Netowork/HttpURLConnection%E8%AF%A6%E8%A7%A3.md "HttpUrlConnection详解"
+[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源码分析"
+		
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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/Android\345\212\240\345\274\272/VideoView\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/SourceAnalysis/VideoView\346\272\220\347\240\201\345\210\206\346\236\220.md"
similarity index 99%
rename from "Android\345\212\240\345\274\272/VideoView\346\272\220\347\240\201\345\210\206\346\236\220.md"
rename to "SourceAnalysis/VideoView\346\272\220\347\240\201\345\210\206\346\236\220.md"
index e1a45349..bece3204 100644
--- "a/Android\345\212\240\345\274\272/VideoView\346\272\220\347\240\201\345\210\206\346\236\220.md"
+++ "b/SourceAnalysis/VideoView\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -1,4 +1,4 @@
-VideoView源码分析
+VideoView源码分析
 ===
 
 VideoView
diff --git "a/Android\345\212\240\345\274\272/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"
similarity index 95%
rename from "Android\345\212\240\345\274\272/View\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md"
rename to "SourceAnalysis/View\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md"
index 133df6c9..1bb19a51 100644
--- "a/Android\345\212\240\345\274\272/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"
@@ -1,8 +1,9 @@
-View绘制过程详解
+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,7 +1611,11 @@ 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  
-- Good Luck! 
\ No newline at end of file
+- 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"
new file mode 100644
index 00000000..dfe613b2
--- /dev/null
+++ "b/SourceAnalysis/butterknife\346\272\220\347\240\201\350\257\246\350\247\243.md"
@@ -0,0 +1,592 @@
+butterknife源码详解
+===
+
+作为`Android`开发者，大家肯定都知道大名鼎鼎的[butterknife](https://github.com/JakeWharton/butterknife)。它大大的提高了开发效率，虽然在很早之前就开始使用它了，但是只知道是通过注解的方式实现的，却一直没有仔细的学习下大牛的代码。最近在学习运行时注解，决定今天来系统的分析下`butterknife`的实现原理。    
+
+如果你之前不了解`Annotation`，那强烈建议你先看[注解使用][1]
+
+废多看图:  
+
+![image](https://github.com/CharonChui/Pictures/blob/master/butterknife_sample.png?raw=true)
+
+从图中可以很直观的看出它的`module`结构，以及使用示例代码。
+
+它的目录和我们在[注解使用][1]这篇文章中介绍的一样，大体也是分为三个部分:   
+
+- app : butterknife
+- api : butterknife-annotations
+- compiler : butterknife-compiler
+
+通过示例代码我们大体能预料到对应的功能实现:    
+
+- `@BindView(R2.id.hello) Button hello;`    
+    `BindView`注解的作用就是通过`value`指定的值然后去调用`findViewById()`来找到对应的控件，然后将该控件赋值给使用该注解的变量。 
+
+- `@OnClick(R2.id.hello) void sayHello() {...}`    		
+    `OnClick`注解也是通过指定的`id`来找到对应控件后，然后对其设置`onClickListener`并调用使用该注解的方法。   
+
+- 最后不要忘了`ButterKnife.bind(this);`该方法也是后面我们要分析的突破点。 
+
+当然`Butterknife`的功能是非常强大的，我们在这里只是用这两个简单的例子来进行分析说明。    
+
+那我们就来查看`BindView`和`Onclik`注解的源码:   
+```java
+@Retention(CLASS) @Target(FIELD)
+public @interface BindView {
+  /** View ID to which the field will be bound. */
+  @IdRes int value();
+}
+```
+作用在变量上的编译时注解。对该注解的值`value()`使用`android.support.annotation`中的`IdRes`注解，来表明该值只能是资源类型的`id`。  
+
+```java
+@Target(METHOD)
+@Retention(CLASS)
+@ListenerClass(
+    targetType = "android.view.View",
+    setter = "setOnClickListener",
+    type = "butterknife.internal.DebouncingOnClickListener",
+    method = @ListenerMethod(
+        name = "doClick",
+        parameters = "android.view.View"
+    )
+)
+public @interface OnClick {
+  /** View IDs to which the method will be bound. */
+  @IdRes int[] value() default { View.NO_ID };
+}
+```
+作用到方法上的编译时注解。我们发现该注解还使用了`ListenerClass`注解，当然从上面的声明中可以很容易看出它的作用。   
+那我们就继续简单的看一下`ListenerClass`注解的实现:   
+
+```java
+@Retention(RUNTIME) @Target(ANNOTATION_TYPE)
+public @interface ListenerClass {
+  String targetType();
+
+  /** Name of the setter method on the {@linkplain #targetType() target type} for the listener. */
+  String setter();
+
+  /**
+   * Name of the method on the {@linkplain #targetType() target type} to remove the listener. If
+   * empty {@link #setter()} will be used by default.
+   */
+  String remover() default "";
+
+  /** Fully-qualified class name of the listener type. */
+  String type();
+
+  /** Enum which declares the listener callback methods. Mutually exclusive to {@link #method()}. */
+  Class<? extends Enum<?>> callbacks() default NONE.class;
+
+  /**
+   * Method data for single-method listener callbacks. Mutually exclusive with {@link #callbacks()}
+   * and an error to specify more than one value.
+   */
+  ListenerMethod[] method() default { };
+
+  /** Default value for {@link #callbacks()}. */
+  enum NONE { }
+}
+```
+作用到注解类型的运行时注解。 
+
+
+有了之前[注解使用](https://github.com/CharonChui/AndroidNote/blob/master/Android%E5%8A%A0%E5%BC%BA/%E6%B3%A8%E8%A7%A3%E4%BD%BF%E7%94%A8.md)这篇文章的基础，我们知道对于编译时注解肯定是要通过自定义`AbstractProcessor`来解析的，所以接下来我们要去`butterknife-compiler module`中找一下对应的类。通过名字我们就能很简单的找到:  
+```java
+package butterknife.compiler;
+
+@AutoService(Processor.class)
+public final class ButterKnifeProcessor extends AbstractProcessor {
+   ...
+}
+```
+通过`AutoService`注解我们很容易看出来`Butterknife`也使用了`Google Auto`。当然它肯定也都用了`javaopet`和`android-apt`，这里我们就不去分析了。 
+其他的一些方法我们就不继续看了，我们接下来看一下具体的核心处理方法，也就是`ButterKnifeProcessor.process()`方法:        
+```java
+@Override public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
+    // 查找、解析出所有的注解
+    Map<TypeElement, BindingClass> targetClassMap = findAndParseTargets(env);
+    // 将注解后要生成的相关代码信息保存到BindingClass类中
+    for (Map.Entry<TypeElement, BindingClass> entry : targetClassMap.entrySet()) {
+      TypeElement typeElement = entry.getKey();
+      BindingClass bindingClass = entry.getValue();
+      // 输出生成的类
+      for (JavaFile javaFile : bindingClass.brewJava()) {
+        try {
+          javaFile.writeTo(filer);
+        } catch (IOException e) {
+          error(typeElement, "Unable to write view binder for type %s: %s", typeElement,
+              e.getMessage());
+        }
+      }
+    }
+
+    return true;
+  }
+```
+
+从`process()`方法来看，我们需要主要分析两个部分:   
+
+- `findAndParseTargets()`：查找、解析所有的注解
+- `bindingClass.brewJava()`：生成代码
+
+##### 第一步:`findAndParseTargets()`  
+
+先查看`findAndParseTargets()`方法的实现,里面解析的类型比较多，我们就以`BindView`为例进行说明:   
+```java
+private Map<TypeElement, BindingClass> findAndParseTargets(RoundEnvironment env) {
+    Map<TypeElement, BindingClass> targetClassMap = new LinkedHashMap<>();
+    Set<TypeElement> erasedTargetNames = new LinkedHashSet<>();
+
+    scanForRClasses(env);
+
+    // Process each @BindArray element.
+    for (Element element : env.getElementsAnnotatedWith(BindArray.class)) {
+      if (!SuperficialValidation.validateElement(element)) continue;
+      try {
+        parseResourceArray(element, targetClassMap, erasedTargetNames);
+      } catch (Exception e) {
+        logParsingError(element, BindArray.class, e);
+      }
+    }
+
+    // Process each @BindBitmap element.
+    for (Element element : env.getElementsAnnotatedWith(BindBitmap.class)) {
+      if (!SuperficialValidation.validateElement(element)) continue;
+      try {
+        parseResourceBitmap(element, targetClassMap, erasedTargetNames);
+      } catch (Exception e) {
+        logParsingError(element, BindBitmap.class, e);
+      }
+    }
+
+    // Process each @BindBool element.
+    for (Element element : env.getElementsAnnotatedWith(BindBool.class)) {
+      if (!SuperficialValidation.validateElement(element)) continue;
+      try {
+        parseResourceBool(element, targetClassMap, erasedTargetNames);
+      } catch (Exception e) {
+        logParsingError(element, BindBool.class, e);
+      }
+    }
+
+    // Process each @BindColor element.
+    for (Element element : env.getElementsAnnotatedWith(BindColor.class)) {
+      if (!SuperficialValidation.validateElement(element)) continue;
+      try {
+        parseResourceColor(element, targetClassMap, erasedTargetNames);
+      } catch (Exception e) {
+        logParsingError(element, BindColor.class, e);
+      }
+    }
+
+    // Process each @BindDimen element.
+    for (Element element : env.getElementsAnnotatedWith(BindDimen.class)) {
+      if (!SuperficialValidation.validateElement(element)) continue;
+      try {
+        parseResourceDimen(element, targetClassMap, erasedTargetNames);
+      } catch (Exception e) {
+        logParsingError(element, BindDimen.class, e);
+      }
+    }
+
+    // Process each @BindDrawable element.
+    for (Element element : env.getElementsAnnotatedWith(BindDrawable.class)) {
+      if (!SuperficialValidation.validateElement(element)) continue;
+      try {
+        parseResourceDrawable(element, targetClassMap, erasedTargetNames);
+      } catch (Exception e) {
+        logParsingError(element, BindDrawable.class, e);
+      }
+    }
+
+    // Process each @BindInt element.
+    for (Element element : env.getElementsAnnotatedWith(BindInt.class)) {
+      if (!SuperficialValidation.validateElement(element)) continue;
+      try {
+        parseResourceInt(element, targetClassMap, erasedTargetNames);
+      } catch (Exception e) {
+        logParsingError(element, BindInt.class, e);
+      }
+    }
+
+    // Process each @BindString element.
+    for (Element element : env.getElementsAnnotatedWith(BindString.class)) {
+      if (!SuperficialValidation.validateElement(element)) continue;
+      try {
+        parseResourceString(element, targetClassMap, erasedTargetNames);
+      } catch (Exception e) {
+        logParsingError(element, BindString.class, e);
+      }
+    }
+
+    // Process each @BindView element.
+    for (Element element : env.getElementsAnnotatedWith(BindView.class)) {
+      // 检查一下合法性
+      if (!SuperficialValidation.validateElement(element)) continue;
+      try {
+        // 进行解析 
+        parseBindView(element, targetClassMap, erasedTargetNames);
+      } catch (Exception e) {
+        logParsingError(element, BindView.class, e);
+      }
+    }
+
+    // Process each @BindViews element.
+    for (Element element : env.getElementsAnnotatedWith(BindViews.class)) {
+      if (!SuperficialValidation.validateElement(element)) continue;
+      try {
+        parseBindViews(element, targetClassMap, erasedTargetNames);
+      } catch (Exception e) {
+        logParsingError(element, BindViews.class, e);
+      }
+    }
+
+    // Process each annotation that corresponds to a listener.
+    for (Class<? extends Annotation> listener : LISTENERS) {
+      findAndParseListener(env, listener, targetClassMap, erasedTargetNames);
+    }
+
+    // Try to find a parent binder for each.
+    for (Map.Entry<TypeElement, BindingClass> entry : targetClassMap.entrySet()) {
+      TypeElement parentType = findParentType(entry.getKey(), erasedTargetNames);
+      if (parentType != null) {
+        BindingClass bindingClass = entry.getValue();
+        BindingClass parentBindingClass = targetClassMap.get(parentType);
+        bindingClass.setParent(parentBindingClass);
+      }
+    }
+
+    return targetClassMap;
+  }
+```
+
+继续看一下`parseBindView()`方法:   
+```java
+private void parseBindView(Element element, Map<TypeElement, BindingClass> targetClassMap,
+      Set<TypeElement> erasedTargetNames) {
+    TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();
+
+    // Start by verifying common generated code restrictions.
+    boolean hasError = isInaccessibleViaGeneratedCode(BindView.class, "fields", element)
+        || isBindingInWrongPackage(BindView.class, element);
+
+    // Verify that the target type extends from View.
+    TypeMirror elementType = element.asType();
+    if (elementType.getKind() == TypeKind.TYPEVAR) {
+      TypeVariable typeVariable = (TypeVariable) elementType;
+      elementType = typeVariable.getUpperBound();
+    }
+    // 必须是View类型或者接口
+    if (!isSubtypeOfType(elementType, VIEW_TYPE) && !isInterface(elementType)) {
+      error(element, "@%s fields must extend from View or be an interface. (%s.%s)",
+          BindView.class.getSimpleName(), enclosingElement.getQualifiedName(),
+          element.getSimpleName());
+      hasError = true;
+    }
+
+    if (hasError) {
+      return;
+    }
+    // 通过注解的value拿到id
+    // Assemble information on the field.
+    int id = element.getAnnotation(BindView.class).value();
+
+    BindingClass bindingClass = targetClassMap.get(enclosingElement);
+    if (bindingClass != null) {
+      // 之前已经绑定过该id
+      ViewBindings viewBindings = bindingClass.getViewBinding(getId(id));
+      if (viewBindings != null && viewBindings.getFieldBinding() != null) {
+        FieldViewBinding existingBinding = viewBindings.getFieldBinding();
+        error(element, "Attempt to use @%s for an already bound ID %d on '%s'. (%s.%s)",
+            BindView.class.getSimpleName(), id, existingBinding.getName(),
+            enclosingElement.getQualifiedName(), element.getSimpleName());
+        return;
+      }
+    } else {
+      // 没有绑定过该id的话就去生成代码
+      bindingClass = getOrCreateTargetClass(targetClassMap, enclosingElement);
+    }
+
+    String name = element.getSimpleName().toString();
+    TypeName type = TypeName.get(elementType);
+    boolean required = isFieldRequired(element);
+
+    FieldViewBinding binding = new FieldViewBinding(name, type, required);
+    // 用BindingClass添加代码
+    bindingClass.addField(getId(id), binding);
+
+    // Add the type-erased version to the valid binding targets set.
+    erasedTargetNames.add(enclosingElement);
+  }
+```
+终于进入生成代码的阶段了，继续看一下`getOrCreateTargetClass()`的实现:     
+```java
+private BindingClass getOrCreateTargetClass(Map<TypeElement, BindingClass> targetClassMap,
+      TypeElement enclosingElement) {
+    BindingClass bindingClass = targetClassMap.get(enclosingElement);
+    if (bindingClass == null) {
+      TypeName targetType = TypeName.get(enclosingElement.asType());
+      if (targetType instanceof ParameterizedTypeName) {
+        targetType = ((ParameterizedTypeName) targetType).rawType;
+      }
+      // 得到包名、类名
+      String packageName = getPackageName(enclosingElement);
+      String className = getClassName(enclosingElement, packageName);
+      // 用包名、类名和_ViewBinder等拼接成要生成的类的全名，这里会有两个类:$$_ViewBinder和$$_ViewBinding
+      ClassName binderClassName = ClassName.get(packageName, className + "_ViewBinder");
+      ClassName unbinderClassName = ClassName.get(packageName, className + "_ViewBinding");
+
+      boolean isFinal = enclosingElement.getModifiers().contains(Modifier.FINAL);
+      // 将要生成的类名,$$_ViewBinder和$$_ViewBinding封装给BindingClass类
+      bindingClass = new BindingClass(targetType, binderClassName, unbinderClassName, isFinal);
+      targetClassMap.put(enclosingElement, bindingClass);
+    }
+    return bindingClass;
+  }
+```
+继续看一下`BindingClass.addField()`:    
+```java
+void addField(Id id, FieldViewBinding binding) {
+    getOrCreateViewBindings(id).setFieldBinding(binding);
+  }
+```
+继续看`getOrCreateViewBindings()`以及`setFieldBinding()`方法:    
+```java
+private ViewBindings getOrCreateViewBindings(Id id) {
+    ViewBindings viewId = viewIdMap.get(id);
+    if (viewId == null) {
+      viewId = new ViewBindings(id);
+      viewIdMap.put(id, viewId);
+    }
+    return viewId;
+  }
+```
+然后看`ViewBindings.setFieldBinding()`方法:    
+```java
+public void setFieldBinding(FieldViewBinding fieldBinding) {
+    if (this.fieldBinding != null) {
+      throw new AssertionError();
+    }
+    this.fieldBinding = fieldBinding;
+  }
+```
+看到这里就把`findAndParseTargets()`方法分析完了。大体总结一下就是把一些变量、参数等初始化到了`BindingClass`类中。
+也就是说上面`process()`方法中的第一步已经分析完了，下面我们来继续看第二部分.
+
+##### 第二步:`bindingClass.brewJava()`  
+
+继续查看`BindingClass.brewJava()`方法的实现:    
+```java
+Collection<JavaFile> brewJava() {
+    TypeSpec.Builder result = TypeSpec.classBuilder(binderClassName)
+        .addModifiers(PUBLIC, FINAL)
+        .addSuperinterface(ParameterizedTypeName.get(VIEW_BINDER, targetTypeName));
+
+    result.addMethod(createBindMethod(targetTypeName));
+
+    List<JavaFile> files = new ArrayList<>();
+    if (isGeneratingUnbinder()) {
+      // 生成$$_ViewBinding类
+      files.add(JavaFile.builder(unbinderClassName.packageName(), createUnbinderClass())
+          .addFileComment("Generated code from Butter Knife. Do not modify!")
+          .build()
+      );
+    } else if (!isFinal) {
+      result.addMethod(createBindToTargetMethod());
+    }
+    // 生成$$_ViewBinder类
+    files.add(JavaFile.builder(binderClassName.packageName(), result.build())
+        .addFileComment("Generated code from Butter Knife. Do not modify!")
+        .build());
+
+    return files;
+  }
+```
+看到这里感觉不用再继续分析了，该方法就是使用`javaopet`来生成对应`$$_ViewBinder.java`类。 
+
+到这里我们已经知道在编译的过程中会去生成一个对应的`$$_ViewBinder.java`文件，该类实现了`ViewBinder`接口。它内部会去生成对应`findViewByid()`以及`setOnClickListener()`等方法的代码，它生成了该类后如何去调用呢？我们也没有发现`new $$_ViewBinder`的方法。不要忘了上面我们看到的`ButterKnife.bind(this);`。接下来我们看一下`ButterKnife.bind(this);`方法的实现:    
+
+```java
+/**
+   * BindView annotated fields and methods in the specified {@link Activity}. The current content
+   * view is used as the view root.
+   *
+   * @param target Target activity for view binding.
+   */
+  @NonNull @UiThread
+  public static Unbinder bind(@NonNull Activity target) {
+    return getViewBinder(target).bind(Finder.ACTIVITY, target, target);
+  }
+
+  /**
+   * BindView annotated fields and methods in the specified {@link View}. The view and its children
+   * are used as the view root.
+   *
+   * @param target Target view for view binding.
+   */
+  @NonNull @UiThread
+  public static Unbinder bind(@NonNull View target) {
+    return getViewBinder(target).bind(Finder.VIEW, target, target);
+  }
+```
+调用了`getViewBinder()`的`bind()`方法，继续看`getViewBinder()`方法:   
+```java
+static final Map<Class<?>, ViewBinder<Object>> BINDERS = new LinkedHashMap<>();
+...
+
+@NonNull @CheckResult @UiThread
+  static ViewBinder<Object> getViewBinder(@NonNull Object target) {
+    Class<?> targetClass = target.getClass();
+    if (debug) Log.d(TAG, "Looking up view binder for " + targetClass.getName());
+    return findViewBinderForClass(targetClass);
+  }
+
+  @NonNull @CheckResult @UiThread
+  private static ViewBinder<Object> findViewBinderForClass(Class<?> cls) {
+     // BINDERS是一个Map集合。也就是说它内部使用Map缓存了一下，先去内存中取
+     ViewBinder<Object> viewBinder = BINDERS.get(cls);
+    if (viewBinder != null) {
+      if (debug) Log.d(TAG, "HIT: Cached in view binder map.");
+      return viewBinder;
+    }
+    // 内存中没有缓存该类
+    String clsName = cls.getName();
+    // 通过类名判断下是不是系统的组件
+    if (clsName.startsWith("android.") || clsName.startsWith("java.")) {
+      if (debug) Log.d(TAG, "MISS: Reached framework class. Abandoning search.");
+      return NOP_VIEW_BINDER;
+    }
+    //noinspection TryWithIdenticalCatches Resolves to API 19+ only type.
+    try {
+      // 通过反射获取到对应通过编译时注解生成的$_ViewBinder类的实例
+      Class<?> viewBindingClass = Class.forName(clsName + "_ViewBinder");
+      //noinspection unchecked
+      viewBinder = (ViewBinder<Object>) viewBindingClass.newInstance();
+      if (debug) Log.d(TAG, "HIT: Loaded view binder class.");
+    } catch (ClassNotFoundException e) {
+      if (debug) Log.d(TAG, "Not found. Trying superclass " + cls.getSuperclass().getName());
+      viewBinder = findViewBinderForClass(cls.getSuperclass());
+    } catch (InstantiationException e) {
+      throw new RuntimeException("Unable to create view binder for " + clsName, e);
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException("Unable to create view binder for " + clsName, e);
+    }
+    // 通过反射来操作毕竟会影响性能，所以这里通过Map缓存的方式来进行优化
+    BINDERS.put(cls, viewBinder);
+    return viewBinder;
+  }
+
+```
+
+到这里就彻底分析完了`ButterKnife.bind(this);`的实现，它其实就相当于`new`了一个`$_ViewBinder`类的实例。当然这样用起来是非常方便的，毕竟我们手动的去`new`类多不合理，虽然他里面用到了反射会影响一点点性能，但是他通过内存缓存的方式优化了，我感觉这种方式是利大于弊的。   
+
+那`$_ViewBinder`类里面都是什么内容呢？ 我们去看一下该类的代码，但是它生成的代码在哪里呢？
+![image](https://github.com/CharonChui/Pictures/blob/master/butterknife_apt_genierate_code.png?raw=true)
+
+
+开始看一下`SimpleActivity_ViewBinder.bind()`方法:      
+```java
+public final class SimpleActivity_ViewBinder implements ViewBinder<SimpleActivity> {
+  @Override
+  public Unbinder bind(Finder finder, SimpleActivity target, Object source) {
+    return new SimpleActivity_ViewBinding<>(target, finder, source);
+  }
+}
+```
+
+接着看`SimpleActivity_ViewBinding`类:   
+```java
+public class SimpleActivity_ViewBinding<T extends SimpleActivity> implements Unbinder {
+  protected T target;
+
+  private View view2130968578;
+
+  private View view2130968579;
+
+  public SimpleActivity_ViewBinding(final T target, Finder finder, Object source) {
+    this.target = target;
+
+    View view;
+    target.title = finder.findRequiredViewAsType(source, R.id.title, "field 'title'", TextView.class);
+    target.subtitle = finder.findRequiredViewAsType(source, R.id.subtitle, "field 'subtitle'", TextView.class);
+    view = finder.findRequiredView(source, R.id.hello, "field 'hello', method 'sayHello', and method 'sayGetOffMe'");
+    target.hello = finder.castView(view, R.id.hello, "field 'hello'", Button.class);
+    view2130968578 = view;
+    view.setOnClickListener(new DebouncingOnClickListener() {
+      @Override
+      public void doClick(View p0) {
+        target.sayHello();
+      }
+    });
+    view.setOnLongClickListener(new View.OnLongClickListener() {
+      @Override
+      public boolean onLongClick(View p0) {
+        return target.sayGetOffMe();
+      }
+    });
+    view = finder.findRequiredView(source, R.id.list_of_things, "field 'listOfThings' and method 'onItemClick'");
+    target.listOfThings = finder.castView(view, R.id.list_of_things, "field 'listOfThings'", ListView.class);
+    view2130968579 = view;
+    ((AdapterView<?>) view).setOnItemClickListener(new AdapterView.OnItemClickListener() {
+      @Override
+      public void onItemClick(AdapterView<?> p0, View p1, int p2, long p3) {
+        target.onItemClick(p2);
+      }
+    });
+    target.footer = finder.findRequiredViewAsType(source, R.id.footer, "field 'footer'", TextView.class);
+    target.headerViews = Utils.listOf(
+        finder.findRequiredView(source, R.id.title, "field 'headerViews'"), 
+        finder.findRequiredView(source, R.id.subtitle, "field 'headerViews'"), 
+        finder.findRequiredView(source, R.id.hello, "field 'headerViews'"));
+  }
+
+  @Override
+  public void unbind() {
+    T target = this.target;
+    if (target == null) throw new IllegalStateException("Bindings already cleared.");
+
+    target.title = null;
+    target.subtitle = null;
+    target.hello = null;
+    target.listOfThings = null;
+    target.footer = null;
+    target.headerViews = null;
+
+    view2130968578.setOnClickListener(null);
+    view2130968578.setOnLongClickListener(null);
+    view2130968578 = null;
+    ((AdapterView<?>) view2130968579).setOnItemClickListener(null);
+    view2130968579 = null;
+
+    this.target = null;
+  }
+}
+```
+可以看到他内部会通过`findViewByid()`等来找到对应的`View`，然后将其赋值给`target.xxxx`，所以这样就相当于把所有的控件以及事件都给初始化了，以后就可以直接使用了，通过这里也可以看到我们在使用注解的时候不要把控件或者方法声明为`private`的。   
+
+
+
+总结一下:      
+
+- `ButterKnifeProcessor`会生成`$$_ViewBinder`类并实现了`ViewBinder`接口。
+- `$$_ViewBinder`类中包含了所有对应的代码，会通过注解去解析到`id`等，然后通过`findViewById()`等方法找到对应的控件，并且复制给调用该方法的来中的变量。这样就等同于我们直接
+   使用`View v = findViewByid(R.id.xx)`来进行初始化控件。  
+- 上面虽然生成了`$$_ViewBinder`类，但是如何去调用呢？ 就是在调用`ButterKnife.bind(this)`时执行，该方法会通过反射去实例化对应的`$$_ViewBinder`类，并且调用该类的`bind()`方法。 
+
+-  `Butterknife`除了在`Butterknife.bind()`方法中使用反射之外，其他注解的处理都是通过编译时注解使用，所以不会影响效率。    
+- 使用`Butterknife`是不要将变量声明为`private`类型，因为`$$_ViewBinder`类中会去直接调用变量赋值，如果声明为`private`将无法赋值。   
+    ```java
+    @BindView(R2.id.title) TextView title;
+    ```
+
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E6%B3%A8%E8%A7%A3%E4%BD%BF%E7%94%A8.md "注解使用"
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- 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"
new file mode 100644
index 00000000..35eba6a8
--- /dev/null
+++ "b/SourceAnalysis/\350\207\252\345\256\232\344\271\211View\350\257\246\350\247\243.md"
@@ -0,0 +1,526 @@
+自定义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`
+
+```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 overridden 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) {
+        setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
+                getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
+    }
+```
+
+注释说的非常清楚。但是我还是要强调一下这两个参数:`widthMeasureSpec`和`heightMeasureSpec`这两个int类型的参数，看名字应该知道是跟宽和高有关系，但它们其实不是宽和高，而是由宽、高和各自方向上对应的模式来合成的一个值：其中，在int类型的32位二进制位中，31-30这两位表示模式，0~29这三十位表示宽和高的实际值.其中模式一共有三种，被定义在Android中的View类的一个内部类中：View.MeasureSpec：
+
+```java
+android.view
+public static class View.MeasureSpec
+extends Object
+A MeasureSpec encapsulates the layout requirements passed from parent to child. Each MeasureSpec represents a requirement for either the width or the height. A MeasureSpec is comprised of a size and a mode. There are three possible modes:
+UNSPECIFIED
+The parent has not imposed any constraint on the child. It can be whatever size it wants.
+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.
+AT_MOST
+The child can be as large as it wants up to the specified size.
+MeasureSpecs are implemented as ints to reduce object allocation. This class is provided to pack and unpack the <size, mode> tuple into the int.
+```
+
+- MeasureSpec.UNSPECIFIED The parent has not imposed any constraint on the child. It can be whatever size it wants. 这种情况比较少，一般用不到。标示父控件没有给子View任何显示- - - -对应的二进制表示: 00
+- 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’. - - - - 对应的二进制表示:01
+- MeasureSpec.AT_MOST The child can be as large as it wants up to the specified size.理解成WRAP_CONTENT,这是的值是父View可以允许的最大的值，只要不超过这个值都可以。- - - - 对应的二进制表示:10
+
+
+那具体`MeasureSpec`是怎么把宽和高的实际值以及模式组合起来变成一个int类型的值呢？ 这部分是在`MeasureSpce.makeMeasureSpec()`方法中处理的:    
+```java
+public static int makeMeasureSpec(int size, int mode) {
+            if (sUseBrokenMakeMeasureSpec) {
+                return size + mode;
+            } else {
+                return (size & ~MODE_MASK) | (mode & MODE_MASK);
+            }
+        }
+```
+那我们如何从MeasureSpec值中提取模式和大小呢？该方法内部是采用位移计算.
+```java
+/**
+ * Extracts the mode from the supplied measure specification.
+ *
+ * @param measureSpec the measure specification to extract the mode from
+ * @return {@link android.view.View.MeasureSpec#UNSPECIFIED},
+ *         {@link android.view.View.MeasureSpec#AT_MOST} or
+ *         {@link android.view.View.MeasureSpec#EXACTLY}
+ */
+public static int getMode(int measureSpec) {
+    return (measureSpec & MODE_MASK);
+}
+
+/**
+ * Extracts the size from the supplied measure specification.
+ *
+ * @param measureSpec the measure specification to extract the size from
+ * @return the size in pixels defined in the supplied measure specification
+ */
+public static int getSize(int measureSpec) {
+    return (measureSpec & ~MODE_MASK);
+}
+```
+
+
+### `onLayout`
+
+为了能合理的去绘制定义`View`,你需要指定它的大小。复杂的自定义`View`通常需要根据屏幕的样式和大小来进行复杂的布局计算。你不应该假设你的屏幕上的`View`的大小。即使只有一个应用使用你的自定义`View`，也需要处理不同的屏幕尺寸、屏幕密度和横屏以及竖屏下的多种比率等。
+
+虽然`View`有很多处理测量的方法，但他们中的大部分都不需要被重写。如果你的`View`不需要特别的控制它的大小，你只需要重写一个方法:`onSizeChanged()`。
+
+`onSizeChanged()`方法会在你的`View`第一次指定大小后调用，在因某些原因改变大小后会再次调用。在上面`PieChart`的例子中，`onSizeChanged()`方法就是它需要重新计算表格样式和大小以及其他元素的地方。
+下面就是`PieChart.onSizeChanged()`方法的内容:      
+
+```java
+// Account for padding
+float xpad = (float)(getPaddingLeft() + getPaddingRight());
+float ypad = (float)(getPaddingTop() + getPaddingBottom());
+
+// Account for the label
+if (mShowText) xpad += mTextWidth;
+
+float ww = (float)w - xpad;
+float hh = (float)h - ypad;
+
+// Figure out how big we can make the pie.
+float diameter = Math.min(ww, hh);
+```
+
+
+### `onDraw`
+
+自定义`View`最重要的就是展现样式。
+
+##### 重写`onDraw()`方法
+
+绘制自定义`View`最重要的步骤就是重写`onDraw()`方法。`onDraw()`方法的参数是`Canvas`对象。可以用它来绘制自身。`Canvas`类定义了绘制文字、线、位图和很多其他图形的方法。你可以在`onDraw()`方法中使用这些方法来指定`UI`.
+
+在使用任何绘制方法之前，你都必须要创建一个`Paint`对象。  
+
+##### 创建绘制的对象
+
+`android.graphics`框架将绘制分为两步:     
+
+- 绘制什么，由`Canvas`处理。
+- 怎么去绘制，由`Paint`处理。
+
+
+##### `Canvas`
+
+> The Canvas class holds the "draw" calls. To draw something, you need 4 basic components: A Bitmap to hold the pixels,  
+ a Canvas to host the draw calls (writing into the bitmap), a drawing primitive (e.g. Rect, Path, text, Bitmap),   
+and a paint (to describe the colors and styles for the drawing).  
+
+
+- `Canvas()`:创建一个空的画布，可以使用`setBitmap()`方法来设置绘制的具体画布； 
+- `Canvas(Bitmap bitmap)`:以`bitmap`对象创建一个画布，则将内容都绘制在`bitmap`上，`bitmap`不得为`null`; 
+- `canvas.drawRect(RectF,Paint)`方法用于画矩形，第一个参数为图形显示区域，第二个参数为画笔，设置好图形显示区域`Rect`和画笔`Paint`后，即可画图； 
+- `canvas.drawRoundRect(RectF, float, float, Paint)`方法用于画圆角矩形，第一个参数为图形显示区域，第二个参数和第三个参数分别是水平圆角半径和垂直圆角半径。 
+- `canvas.drawLine(startX, startY, stopX, stopY, paint)`：前四个参数的类型均为`float`，最后一个参数类型为`Paint`。表示用画笔`paint`从点`（startX,startY）`到点`（stopX,stopY）`画一条直线； 
+- `canvas.drawLines (float[] pts, Paint paint)``pts`:是点的集合，大家下面可以看到，这里不是形成连接线，而是每两个点形成一条直线，`pts`的组织方式为`｛x1,y1,x2,y2,x3,y3,……｝`，例如`float []pts={10,10,100,100,200,200,400,400};`就是有四个点：（10，10）、（100，100），（200，200），（400，400）），两两连成一条直线；
+- `canvas.drawArc(oval, startAngle, sweepAngle, useCenter, paint)`：第一个参数`oval`为`RectF`类型，即圆弧显示区域，`startAngle`和`sweepAngle`均为`float`类型，分别表示圆弧起始角度和圆弧度数,3点钟方向为0度，`useCenter`设置是否显示圆心，`boolean`类型，`paint`为画笔； 
+- `canvas.drawCircle(float,float, float, Paint)`方法用于画圆，前两个参数代表圆心坐标，第三个参数为圆半径，第四个参数是画笔； 
+- `canvas.drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint)` 位图，参数一就是我们常规的`Bitmap`对象，参数二是源区域(这里是`bitmap`)，参数三是目标区域(应该在`canvas`的位置和大小)，参数四是`Paint`画刷对象，因为用到了缩放和拉伸的可能，当原始`Rect`不等于目标`Rect`时性能将会有大幅损失。
+- `canvas.drawText(String text, float x, floaty, Paint paint)`渲染文本，`Canvas`类除了上
+面的还可以描绘文字，参数一是`String`类型的文本，参数二`x`轴，参数三`y`轴，参数四是`Paint`对象。
+- `canvas.drawPath (Path path, Paint paint)`，根据`Path`去画.
+    ```java
+    Path path = new Path();  
+    path.moveTo(10, 10); //设定起始点  
+    path.lineTo(10, 100);//第一条直线的终点，也是第二条直线的起点  
+    path.lineTo(300, 100);//画第二条直线  
+    path.lineTo(500, 100);//第三条直线  
+    path.close();//闭环  
+    canvas.drawPath(path, paint);  
+    ```
+
+##### `Paint`
+
+- `setARGB(int a, int r, int g, int b)` 设置`Paint`对象颜色，参数一为`alpha`透明值
+- `setAlpha(int a)` 设置`alpha`不透明度，范围为0~255
+- `setAntiAlias(boolean aa)`是否抗锯齿
+- `setColor(int color)`设置颜色
+- `setTextScaleX(float scaleX)`设置文本缩放倍数，1.0f为原始
+- `setTextSize(float textSize)`设置字体大小
+- `setUnderlineText(String underlineText)`设置下划线
+
+
+
+例如，`Canvas`提供了一个画一条线的方法，而`Paint`提供了指定这条线的颜色的方法。`Canvas`提供了绘制长方形的方法，而`Paint`提供了是用颜色填充整个长方形还是空着的方法。简单的说，`Canvas`指定了你想在屏幕上绘制的形状，而`Paint`指定了你要绘制的形状的颜色、样式、字体和样式等等。   
+
+所以，在你`draw`任何东西之前，你都需要创建一个或者多个`Paint`对象。下面的`PieChart`例子就是在构造函数中调用的`init`方法:     
+
+```java
+private void init() {
+   mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+   mTextPaint.setColor(mTextColor);
+   if (mTextHeight == 0) {
+       mTextHeight = mTextPaint.getTextSize();
+   } else {
+       mTextPaint.setTextSize(mTextHeight);
+   }
+
+   mPiePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+   mPiePaint.setStyle(Paint.Style.FILL);
+   mPiePaint.setTextSize(mTextHeight);
+
+   mShadowPaint = new Paint(0);
+   mShadowPaint.setColor(0xff101010);
+   mShadowPaint.setMaskFilter(new BlurMaskFilter(8, BlurMaskFilter.Blur.NORMAL));
+
+   ...
+```
+
+下面是`PieChart`完整的`onDraw()`方法:      
+```java
+protected void onDraw(Canvas canvas) {
+   super.onDraw(canvas);
+
+   // Draw the shadow
+   canvas.drawOval(
+           mShadowBounds,
+           mShadowPaint
+   );
+
+   // Draw the label text
+   canvas.drawText(mData.get(mCurrentItem).mLabel, mTextX, mTextY, mTextPaint);
+
+   // Draw the pie slices
+   for (int i = 0; i < mData.size(); ++i) {
+       Item it = mData.get(i);
+       mPiePaint.setShader(it.mShader);
+       canvas.drawArc(mBounds,
+               360 - it.mEndAngle,
+               it.mEndAngle - it.mStartAngle,
+               true, mPiePaint);
+   }
+
+   // Draw the pointer
+   canvas.drawLine(mTextX, mPointerY, mPointerX, mPointerY, mTextPaint);
+   canvas.drawCircle(mPointerX, mPointerY, mPointerSize, mTextPaint);
+}
+```
+
+
+下面是一张`View`绘制过程中框架调用的一些标准方法概要图:      
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/custom_view_methods.png?raw=true)
+
+下面来几个例子:    
+
+自定义开关:      
+
+```java
+public class ToogleView extends View {
+    private int mSlideMarginLeft = 0;
+    private Bitmap backgroundBitmap;
+    private Bitmap slideButton;
+
+
+    public ToogleView(Context context) {
+        super(context);
+        init(context);
+    }
+
+    public ToogleView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context);
+    }
+
+    public ToogleView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init(context);
+    }
+
+    private void init(Context context) {
+        backgroundBitmap = BitmapFactory.decodeResource(getResources(),
+                R.drawable.toogle_bg);
+        slideButton = BitmapFactory.decodeResource(getResources(),
+                R.drawable.toogle_slide);
+        this.setOnClickListener(new OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                if (mSlideMarginLeft == 0) {
+                    mSlideMarginLeft = backgroundBitmap.getWidth() - slideButton.getWidth();
+                } else {
+                    mSlideMarginLeft = 0;
+                }
+                invalidate();
+            }
+        });
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        Paint paint = new Paint();
+        paint.setAntiAlias(true);
+        // 先画背景图
+        canvas.drawBitmap(backgroundBitmap, 0, 0, paint);
+        // 再画滑块，用mSlideMarginLeft来控制滑块距离左边的距离。
+        canvas.drawBitmap(slideButton, mSlideMarginLeft, 0, paint);
+    }
+```
+
+```xml
+<LinearLayout android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    xmlns:android="http://schemas.android.com/apk/res/android" >
+
+<com.charon.recyclerviewdemo.ToogleView
+        android:paddingLeft="50dp"
+        android:background="@android:color/holo_green_light"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+    </LinearLayout>
+```
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/toogle_1.png?raw=true)
+很明显显示的不对，因为高设置为`warp_content`了，但是界面显示的确实整个屏幕，而且`paddingLeft`也没生效，那该怎么做呢？ 当然是重写`onMeasure()` 方法:   
+```java
+public class ToogleView extends View {
+    private int mSlideMarginLeft = 0;
+    private Bitmap backgroundBitmap;
+    private Bitmap slideButton;
+
+
+    public ToogleView(Context context) {
+        super(context);
+        init(context);
+    }
+
+    public ToogleView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context);
+    }
+
+    public ToogleView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init(context);
+    }
+
+    private void init(Context context) {
+        backgroundBitmap = BitmapFactory.decodeResource(getResources(),
+                R.drawable.toogle_bg);
+        slideButton = BitmapFactory.decodeResource(getResources(),
+                R.drawable.toogle_slide);
+        this.setOnClickListener(new OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                if (mSlideMarginLeft == 0) {
+                    mSlideMarginLeft = backgroundBitmap.getWidth() - slideButton.getWidth();
+                } else {
+                    mSlideMarginLeft = 0;
+                }
+                invalidate();
+            }
+        });
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        int measureWidth = MeasureSpec.getSize(widthMeasureSpec);
+        int measureWidthMode = MeasureSpec.getMode(widthMeasureSpec);
+
+        int measureHeight = MeasureSpec.getSize(heightMeasureSpec);
+        int measureHeightMode = MeasureSpec.getMode(heightMeasureSpec);
+        int width;
+        int height;
+        if (MeasureSpec.EXACTLY == measureWidthMode) {
+            width = measureWidth;
+        } else {
+            width = backgroundBitmap.getWidth();
+        }
+
+        if (MeasureSpec.EXACTLY == measureHeightMode) {
+            height = measureHeight;
+        } else {
+            height = backgroundBitmap.getHeight();
+        }
+
+        setMeasuredDimension(width, height);
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        Paint paint = new Paint();
+        paint.setAntiAlias(true);
+        canvas.drawBitmap(backgroundBitmap, getPaddingLeft(), 0, paint);
+        canvas.drawBitmap(slideButton, mSlideMarginLeft + getPaddingLeft(), 0, paint);
+    }
+
+}
+
+```
+这样就可以了。简单的说明一下，就是如果当前的模式是`EXACTLY`那就把父`View`传递进来的宽高设置进来，如果是`AT_MOST`或者`UNSPECIFIED`的话就使用背景图片的宽高。
+
+
+最后再来一个自定义`ViewGroup`的例子:       
+
+之前的引导页面都是通过类似`ViewPager`这种方法左右滑动，现在想让他上下滑动，该怎么弄呢？    
+```java
+public class VerticalLayout extends ViewGroup {
+    public VerticalLayout(Context context) {
+        super(context);
+    }
+    public VerticalLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public VerticalLayout(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        
+    }
+}
+```
+继承`ViewGroup`必须要重写`onLayout`方法。其实这也很好理解，因为每个`ViewGroup`的排列方式不一样，所以让子类来自己实现是最好的。      
+当然子类重写`onLayout`之外，也要重写`onMeasure`。
+代码如下，滑动手势处理的部分就不贴了。     
+```java
+	@Override
+	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+		int measureSpec = MeasureSpec.makeMeasureSpec(mScreenHeight
+				* getChildCount(), MeasureSpec.getMode(heightMeasureSpec));
+		super.onMeasure(widthMeasureSpec, measureSpec);
+		measureChildren(widthMeasureSpec, heightMeasureSpec);
+	}
+
+	@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++) {
+				View child = getChildAt(i);
+				if (child.getVisibility() != View.GONE) {
+					child.layout(l, i * mScreenHeight, r, (i + 1)
+							* mScreenHeight);
+				}
+			}
+		}
+	}
+```
+
+上面介绍了通过继承`View`以及`ViewGroup`的方式来自定义`View`，平时开发过程中有时不需要继承他俩，我们直接继承功能接近
+的类进行扩展就好，例如:我想自定义一个`Meterial Design`样式的`EditText`。那我们该怎么实现呢？ 当然是继承`EditText`了，它比`EditText`多了一条底下的线，那我们给它`draw`上就可以了。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/meterial_edittext.png?raw=true)
+
+```java
+public class MetrailEditText extends EditText {
+    private NinePatchDrawable mDrawable;
+
+    public MetrailEditText(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    public MetrailEditText(Context context) {
+        super(context);
+        init();
+    }
+
+    private void init() {
+        setBackgroundResource(0);
+        mDrawable = (NinePatchDrawable) getResources().getDrawable(R.drawable.edittext_meterial_bg_activated);
+    }
+
+    @Override
+    protected void onDraw(final Canvas canvas) {
+        super.onDraw(canvas);
+        mDrawable.setBounds(-getCompoundPaddingLeft(), 0, getWidth() + getCompoundPaddingRight(), getHeight());
+        mDrawable.draw(canvas);
+    }
+}
+```
+
+看到这里你可能会糊涂，这哪行啊？ 我们的`edittext_meterial_bg_activated`可不是普通的图，当然是`9 patch`图了。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/meterial_edittext_line.png?raw=true)
+
+当然你可以在`onDraw()`的时候加一个自定义线的颜色`mDrawable.setColorFilter(mLineColor, PorterDuff.Mode.SRC_ATOP);`等。
+
+
+
+参考部分:   	
+- http://blog.csdn.net/cyp331203/article/details/40736027
+
+	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! I
diff --git "a/Tools&Library/Android\345\274\200\345\217\221\345\267\245\345\205\267\345\217\212\347\261\273\345\272\223.md" "b/Tools&Library/Android\345\274\200\345\217\221\345\267\245\345\205\267\345\217\212\347\261\273\345\272\223.md"
new file mode 100644
index 00000000..9806157a
--- /dev/null
+++ "b/Tools&Library/Android\345\274\200\345\217\221\345\267\245\345\205\267\345\217\212\347\261\273\345\272\223.md"
@@ -0,0 +1,86 @@
+Android开发工具及类库
+===
+
+在项目开发过程中，总有一些必要的工具和类库。下面就简单介绍下我常用的一些(还在用`Eclipse`的请无视)。      
+
+1. [volley](https://android.googlesource.com/platform/frameworks/volley)                                                   
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/volley.png?raw=true)                   
+在`Google I/0 2013`中发布了`Volley`.`Volley`是`Android`平台上的网络通信库，能使网络通信更快，更简单，更健壮。
+这是`Volley`名称的由来:`a burst or emission of many things or a large amount at once`.`Volley`特别适合数据量不大但是通信频繁的场景。   
+`Github`上面已经有大神做了镜像，使用更方便有木有。[Volley On Github](https://github.com/mcxiaoke/android-volley)                     
+
+2. [Gson](https://code.google.com/p/google-gson/)                    
+`Json`转换神器。
+
+3. [GsonFormat](https://github.com/zzz40500/GsonFormat)               
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/GsonFormat.gif?raw=true)                 
+既然用了`Gson`怎么能少了该神器呢？
+
+4. [android-butterknife-zelezny](https://github.com/avast/android-butterknife-zelezny)         
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/zelezny_animated.gif?raw=true)      
+使用[butterknife](https://github.com/JakeWharton/butterknife)制作的`Android Studio/IDEA`插件。非常方便有木有。
+
+5. [android-selector-chapek](https://github.com/inmite/android-selector-chapek)       
+`selector`写起来是不是很麻烦？以后让`UI`规范化命名，然后就没有然后了。                
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/select_folder.png?raw=true)            
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/select_option.png?raw=true)         
+接下来你就会在`drawable`目录发现对应的`selector`文件。           
+        
+6. [leakcanary](https://github.com/square/leakcanary)		  
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/screenshot.png?raw=true)       
+内存泄漏你怕不怕？         
+		
+7. [fresco](https://github.com/facebook/fresco)		      
+怎么能少了对图片的处理呢？`Fracebook`出品。更快、更强、更方便。       
+
+8. [android-resource-remover](https://github.com/KeepSafe/android-resource-remover)                    
+    开发过程中可能会经常遇到需求的变更，时间长了，项目中的无用资源就会越来越多。 虽然在`Gradle`中支持相应的配置来去除无用资源: 
+
+	```xml                               
+	buildTypes {
+        debug {
+            minifyEnabled false
+            zipAlignEnabled false
+            shrinkResources false
+        }
+
+        release {
+            zipAlignEnabled true
+            // remove unused resources
+            shrinkResources true
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            signingConfig signingConfigs.release
+        }
+    }
+	```
+    
+    但是这只是在打包的时候不会打进去无用的资源，但是这些资源还是会在工程中。
+    那我们怎么能快速的移除掉这些无用资源呢？答案也很简单，就是使用`lint`检查出无用的资源后用工具删除，这个工具就是`android-resource-remover`。 
+    因为它是一个`python`脚本，所以如果不懂`python`的话使用起来会比较麻烦，下面就介绍一下具体的使用方法:            
+    - 下载并安装`Python 2.x`版本
+        去[Python](https://www.python.org/)下载后即可，这里要下载2.x版本，因为3.x版本对语法做了很多改动，可能会不兼容，下载完成后安装就可。安装完成后将安装路径加入到`Path`中。如`D:\Python;`。
+    - 安装`android-resource-remover`     
+	    在命令行输入下面的命令`pip install android-resource-remover`。 这里有些电脑可能会提示错误，是因为没有安装`pip`导致的，具体可以看[pip](https://pip.pypa.io/en/latest/installing.html)找到安装的方法。上面介绍了要下载`get-pip.py`后执行`python get-pip.py`就能安装了。
+	- 将`D:\Python\Scripts`添加到`Path`中。
+    - 将`lint`命令添加到`Path`中，`D:\android-sdk-windows\tools`.
+    - 在`Studio`右侧的`Gradle`窗口中执行`lint`任务。 这样就会在`app/build/outputs`下生成`lint-results.xml`文件。下一步清理的时候需要使用`lint-results.xml`文件。               
+	    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lint.png?raw=true)	
+	- 进入到`Android Studio`中的具体项目中执行`./gradlew clean`后再执行`./gradlew lint && android-resource-remover --xml app/build/outputs/lint-results.xml`
+
+9. [stetho](https://github.com/facebook/stetho)
+    `facebook`出品。快速查看布局、数据库、网络请求。实在不能再方便了。   
+10. [RxJava](https://github.com/ReactiveX/RxJava)
+    用了后你会爱上它。
+11. [Retrofilt](https://github.com/square/retrofit)
+    `Square`出品。大神`JakeWharton`主导出品的网络请求框架。内部结合`OkHttp`。结合`RxJava`使用非常方便。   
+12. [android-architecture](https://github.com/googlesamples/android-architecture)
+    放到这里可能不太合适，因为它并不是工具和类库，而是`Google`官方发布的`Android`架构示例。非常值得参考。  
+13. [AndroidWiFiADB](https://github.com/pedrovgs/AndroidWiFiADB)
+    还在为数据线不够用而烦恼嘛?
+    
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Android\345\212\240\345\274\272/Github\344\270\252\344\272\272\344\270\273\351\241\265\347\273\221\345\256\232\345\237\237\345\220\215.md" "b/Tools&Library/Github\344\270\252\344\272\272\344\270\273\351\241\265\347\273\221\345\256\232\345\237\237\345\220\215.md"
similarity index 97%
rename from "Android\345\212\240\345\274\272/Github\344\270\252\344\272\272\344\270\273\351\241\265\347\273\221\345\256\232\345\237\237\345\220\215.md"
rename to "Tools&Library/Github\344\270\252\344\272\272\344\270\273\351\241\265\347\273\221\345\256\232\345\237\237\345\220\215.md"
index f582878d..19f43825 100644
--- "a/Android\345\212\240\345\274\272/Github\344\270\252\344\272\272\344\270\273\351\241\265\347\273\221\345\256\232\345\237\237\345\220\215.md"
+++ "b/Tools&Library/Github\344\270\252\344\272\272\344\270\273\351\241\265\347\273\221\345\256\232\345\237\237\345\220\215.md"
@@ -1,4 +1,4 @@
-Github个人主页绑定域名
+Github个人主页绑定域名
 ===
 
 `Github`虽然很好，可毕竟是免费的，还是有不少限制的。写到这里，特意去看了下`Github`对免费用户究竟有什么限制。发现除了300M的空间限制（还是所谓软限制），没有其他限制。所以用它来作为博客平台，真是再理想不过了。
diff --git "a/Tools&Library/Icon\345\210\266\344\275\234.md" "b/Tools&Library/Icon\345\210\266\344\275\234.md"
new file mode 100644
index 00000000..6012caef
--- /dev/null
+++ "b/Tools&Library/Icon\345\210\266\344\275\234.md"
@@ -0,0 +1,16 @@
+Icon制作
+---
+
+
+子日:工欲善其事必先利其器
+
+[logoko在线制作](https://www.logoko.com.cn)
+
+[图标工厂，一键生成各种分辨率图片](http://icon.wuruihong.com/)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+-
+Good Luck! 
diff --git "a/Android\345\212\240\345\274\272/MAT\345\206\205\345\255\230\345\210\206\346\236\220.md" "b/Tools&Library/MAT\345\206\205\345\255\230\345\210\206\346\236\220.md"
similarity index 75%
rename from "Android\345\212\240\345\274\272/MAT\345\206\205\345\255\230\345\210\206\346\236\220.md"
rename to "Tools&Library/MAT\345\206\205\345\255\230\345\210\206\346\236\220.md"
index d2bcd5f0..c575f19a 100644
--- "a/Android\345\212\240\345\274\272/MAT\345\206\205\345\255\230\345\210\206\346\236\220.md"
+++ "b/Tools&Library/MAT\345\206\205\345\255\230\345\210\206\346\236\220.md"
@@ -1,10 +1,9 @@
-MAT内存分析
+MAT内存分析
 ===
 
 `Eclipse Memory Analyzer（MAT）`是著名的跨平台集成开发环境`Eclipse Galileo`版本的33个组成项目中之一，它是一个功能丰富的`JAVA` 堆转储文件分析工具，可以帮助你发现内存漏洞和减少内存消耗。
 
-[内存泄露介绍]{https://raw.githubusercontent.com/CharonChui/AndroidNote/blob/master/Android%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86/%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F.md}
-
+[内存泄露介绍][1]
 [MAT(Memory Analyzer)官网]{http://www.eclipse.org/mat/}    
 - 安装：
     - 单机版，解压后直接使用
@@ -18,6 +17,11 @@
 		看一下上图中`data object`这一栏中的`Total Size`的大小是保持稳定还是有明显的变大趋势，如果有明显的变大趋势就说明这个页面存在内存泄露的问题，需要进行具体分析。
 		
 		
+很长时间之前学习的，一直想记录出来，总是忙，到现在才开始整理，但是现在已经很少用`MAT`了，因为它太费劲了。
+自从良心企业发布了`leakCanary`后，都已经转投到大神门下。
+
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F.md "内存泄露介绍"		
  
 ---
 
diff --git "a/Android\345\212\240\345\274\272/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"
similarity index 92%
rename from "Android\345\212\240\345\274\272/Markdown\345\255\246\344\271\240\346\211\213\345\206\214.md"
rename to "Tools&Library/Markdown\345\255\246\344\271\240\346\211\213\345\206\214.md"
index 8df1f5a3..1fc3e4f8 100644
--- "a/Android\345\212\240\345\274\272/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"
new file mode 100644
index 00000000..0770d1bb
--- /dev/null
+++ "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"
@@ -0,0 +1,339 @@
+性能优化相关工具
+有关性能优化的文章请参考性能优化和布局优化
+
+DDMS(百宝箱)
+查看进程的内存使用
+DDMS可以让你查看到一个进程使用的堆内存。
+
+在Device了表选择你想查看的进程。
+点击Update Heap按钮来开启查看进程堆内存信息。
+在Heap页面，点击Cause GC来执行垃圾回收。
+在列表中点击一个对象类型来查看它所分配的内存大小。
+追踪对象的内存分配情况
+在Device了表选择你想查看的进程。
+在Allocation Tracker页面，点击Start Tracking按钮来开始追踪。
+点击Get Allocations来查看从你点击Start Tracking之后分配内存的对象列表。 你可以再次点击Get Allocations来添加新分配内存的对象列表。
+停止追踪或者清除数据可以点击Stop Tracking按钮。
+在列表中单独点击一行来查看详细的信息。
+使用文件系统
+DDMS提供了一个文件浏览器来供你查看、拷贝、删除文件。
+
+在Device页面，选中你想要查看的设备。
+从设备中拷贝文件，用文件浏览器选择文件后点击Pull file按钮。
+拷贝文件到设备中，点击Push file按钮。
+检查线程信息
+Thread页面可以显示指定进程中当前正在运行的线程。
+
+在Device页面，选择想要查看的进程。
+点击Update Threads按钮。
+在Thread页面，你可以查看对应的线程信息。
+启动方法分析
+方法分析可以追踪一个方法的特定信息，例如调用数量，执行时间、耗时等。如果想要更精确的控制想要收集的数据，可以使用startMethodTracing()和stopMethodTracing()方法。
+
+在你开始使用方法分析之前请知晓如下限制:
+
+在Android 2.1及以前的设备必须有SD卡，并且你的应用必须有写入SD卡的权限。
+在Android 2.2及以后的设备中不需要SD卡，trace log文件会直接被导入到开发机上。
+开启方法分析:
+
+在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包含了一个网络使用情况的页面来支持跟踪应用的网络请求。
+
+如图:
+
+image。
+
+通过检测数据交互的频繁性以及在每次连接中数据的传递量，你可以知道应用中具体可以做的更好更高效的地方。 想要更好的查看引起数据交互的地方，可以使用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。
+
+下面以命令行的方式为例，这里只讲解一下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。
+
+看不懂！！！
+
+分析Trace
+用浏览器打开上面生成的mynewtrace.html。 下面为了能明显的说明，我就用官网提供的例子来说明了。
+
+查看Frames
+从打开的文件中我们能看到每个应用都有一行frame的圆圈来标示渲染的帧，通常都是绿色的。黄色或者红的圆圈标示超过了我们对保障60fps所需的16毫秒绘制时间。。 可以在文件上面按w键来放大文件以便能更好的观看查找。
+
+***提示:***在文件上面按?键可以查看对应的快捷键。
+
+image。
+
+在Android 5.0以上的设备上，显示工作呗分为UI Thread和Render Thread。在之前的版本，所有工作都是在UI Thread进行的。 点击某个单独的frame图标来查看它们所需的时间。
+
+观看Alerts
+Systracv会自动分析trace过程的时间，并且通过alerts提示该展现问题，以及建议如何处理。
+
+image
+
+如上图所示，在你点击一个比较慢的frame时，下面就会显示一个alert。在这种情况下，它直说可能是ListView服用以及重复渲染的问题。 如果你发现UI Thread做了太多的工作，你可以使用TraceView进行代码分析，来找到具体哪些操作导致了消耗时间。
+
+如下，你也可以通过点击窗口右边的Alerts来查看当前所有的alert。这样会直接展开Alert窗口。
+
+image
+
+下面我们以另外一个例子来分析一下它的Frame：
+
+我们点击某一红色frame来查看这一阵的一些相关警告:
+image 可以看到这里说耗时32毫秒，这已经远远超过了16毫秒的绘制时间。 我们可以通过Description来查看描述内容。
+下面是另外一个渲染过慢的例子:
+
+image 从上图，我们发现了Scheduling delay的警告，加起来能看到总的绘制时间大约是19毫秒。
+Scheduling delay的意思是调度延迟，也就是说一个县城在处理这部分操作时，在很长时间内没有被分配到CPU上面进行运算，这样就导致了很长时间内没有完成操作。 我们选择这一帧中最长的一块，来观察下:
+image
+
+我们在上图看到了Wall duration，他代表着这一块开始到结束的总耗时。而在CPU Duration这里显示了CPU在处理该部分消耗的时间。 很明显，真个区域用了18毫秒，但是CPU实际处理只用了4毫秒，也就是说剩下的14毫秒就可能有问题了。
+image
+
+可以看到，4个线程都比较忙。
+
+选择其中一个线程来查看是哪个应用在使用它，这里看到了一个包名为com.udinic.keepbusyapp的应用。也就是说由于另外一个应用占用了CPU,，导致了我们的应用未能获取到足够的CPU资源。
+
+追踪代码
+在Android 4.3以上你可以使用Trace类来在代码中添加(很熟悉有木有，在看源码的时候经常看到)。这样能查看到此时你的应用线程都做了哪些操作。 下面的代码展示了如何使用Trace类来追踪两个代码块部分:
+
+public void ProcessPeople() {
+    Trace.beginSection("ProcessPeople");
+    try {
+        Trace.beginSection("Processing Jane");
+        try {
+            // code for Jane task...
+        } finally {
+            Trace.endSection(); // ends "Processing Jane"
+        }
+
+        Trace.beginSection("Processing John");
+        try {
+            // code for John task...
+        } finally {
+            Trace.endSection(); // ends "Processing John"
+        }
+    } finally {
+        Trace.endSection(); // ends "ProcessPeople"
+    }
+}
+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.
+
+创建Trace文件
+想要使用Traceview你需要创建一个包含你想分析部分的trace信息的log文件。 有两种方式来生成trace logs：
+
+在你测试的类中添加startMethodTracing()和stopMethodTracing()的代码，来指定开始和结束获取trace信息。这种方式是非常精确的，因为你可以在代码中指定开始和结束的位置。
+
+使用DDMS中的方法来生成。这种方式就不太精确。虽然这种方式不能精确的指定起始和结束位置，但是如果在你无法修改源代码或者不需要精确时间的时候是非常有用的。
+
+在开始生成trace log信息时，你需要知道如下的限制条件:
+
+如果你在测试代码中使用，你的应用必须要用WRITE_EXTERNAL_STORAGE的权限。
+
+如果你使用DDMS生成:
+
+Android 2.1之前必须有SD卡，并且你的应用也要有写入SD卡的权限。
+Android 2.2之后不需要SD卡，trace log文件会直接生成到你的开发机上。
+在测试代码中调用startMethodTracing()方法的时候，你可以指定系统生成trace文件的名字。结束的时候调用stopMethodTracing()方法。这些方法开始和结束时贯穿整个虚拟中的。例如你可以在你activity的onCreate()方法中调用startMethodTracing()方法，然后在activity的onDestroy()方法中调用stopMethodTracing()方法。
+
+    // start tracing to "/sdcard/calc.trace"
+    Debug.startMethodTracing("calc");
+    // ...
+    // stop tracing
+    Debug.stopMethodTracing();
+在调用startMethodTracing()方法的时候，系统创建一个名为<trace-base-name>.trace的文件。它包含方法的二进制trace数据和一个线程与方法名的对应集合。
+然后系统就开始生成trace数据，直到调用stopMethodTracing()方法。如果在你调用stopMethodTracing()方法之前系统已经达到了最大的缓冲大小，系统就会停止trace并且在控制台发出一个通知。
+
+拷贝Trace文件到电脑上
+在模拟器或者机器上生成<trace-base-name>.trace文件后，你需要拷贝他们到你的电脑上，你可以使用adb pull命令来拷贝：
+adb pull /sdcard/calc.trace /tmp
+
+在Traceview中查看trace文件
+运行Traceview并且查看trace文件:
+
+打开Android Device Monitor。
+在Android Device Monitor的状态栏中点击DDMS并且选择一个进程。
+点击Start Method Profiling图标开始查看。
+在查看完后点击Stop Method Profiling图标来显示traceview。
+大体的样子如下:
+
+image
+
+Traceview Layout
+如果你有一个trace log文件(通过添加tracing代码或者用DDMS生成)，你可以把该文件加载到Traceview中，这将会把log数据显示为两部分:
+
+timeline panel-展示了每个线程和方法的起始和结束
+profile panel-提供了一个方法中的执行内容的简述
+Timeline Panel
+每个线程都会以时间从左往右递增的方式在单独的一行中显示它的执行情况，
+
+image
+
+Profile Panel
+显示了一个方法所消耗的时间的概要情况。在表格中会同时显示inclusive和exclusive的时间。Exclusive的时间是该方法所消耗的时间。InClusive的时间是该方法消耗的时间加上任何调的方法所消耗的时间。我们简单的将调用的方法叫做parents，被调用的方法叫做children。如果一个方法被调用，它会显示对应的parents和children。parents会显示一个紫色的背景，children会显示一个黄色的背景。最后一列显示了该方法所调用的总数的调用数。在下面的图中我们能看到一共有14个地方调用了LoadListener.nativeFinished() .
+
+image
+
+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()方法中并不能看到这个线程做了什么，因为这段逻辑不在getView()方法之中。于是我找到了Thread.run()方法，就是在线程被创建出来时候所运行的方法。而跟随这个方法一路向下，我找到了问题的元凶。
+
+image
+
+我发现了BgService.doWork()方法的每次调用花费了将近14毫秒，并且有四十个这东西！而且getView()中还有可能调用多次这个方法，这就解释了为什么getView()方法执行时间如此之长。这个方法让CPU长时间的保持在了繁忙状态。而看看Exclusive CPU time，我们可以看到他占据了80%的CPU时间！此外，根据Exclusive CPU time排序，可以帮我们更好的定位那些耗时很长的方法，而他们很有可能就是造成性能问题的罪魁祸首。
+
+关注这些耗时方法，例如getView()，View#onDraw()等方法，可以很好的帮助我们寻找为什么应用运行缓慢的原因。但有些时候，还会有一些其他的东西来占用宝贵的CPU资源，而这些资源如果被运用在UI的绘制上，也许我们的应用会更加流畅。Garbage Collector垃圾回收机制会不时的运行，回收那些没用的对象，通常来讲这不会影响我们在前台运行的程序。但如果GC被运行的过于频繁，他同样可以影响我们应用的执行效率。而我们该如何知道回收的是否过于频繁了呢…
+
+Monitors
+在Android Studio中下方的Android Monitor中可以看到Monitors工具栏，它能不断的去检测内存、网络、CPU的消耗情况。
+
+image
+
+我们可以直接点击Dump Java Heap或者Call GC等按钮，以便更好的去观察内存的使用情况。点击后会生成一个.hprof的文件。生成后直接使用Studio打开.hprof文件即可。
+
+说到这里插一嘴,有关Java垃圾回收机制请参考
+
+image 在左边能看到所有堆内存中的实例。后面会显示他所占用的内存大小。
+
+对于内存泄漏的分析可以使用MAT或者LeakCanary来进行。这里就不仔细说了。
+
+不同虚拟机的内存管理
+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会显示一些垃圾回收相关的信息。
+
+GPU使用情况
+上面也显示了GPU的使用情况，这里要说一句，如果想要显示它，必须要在手机的开发者中心中开启GPU显示配置文件选项，将其设置为显示与adb shell dumpsys gfxinfo。然后再点击Studio中的按钮重新开始就可以看到了。 每一条线意味着一帧被绘制出来了。而线的颜色又代表不同的阶段：
+
+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会变得过多过于沉重，从而导致在这一阶段过长的耗时。
+
+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
+布局分析工具，非常常用。
+
+在Android Device Monitor中打开Hierarchy Viewer即可。
+
+连接你的手机或者模拟器。 出于安全性考虑，Hierarchy Viewer只能连接开发者版的系统的手机。
+运行程序，并且让界面显示出来。
+启动hierarchy view工具，接着就能看到左边栏显示出了对应的设备，展开后可以看到一些组件的名称。这个页面包含了应用的界面以及系统的界面。选择你的应用中想要查看的界面直接双击就可以了。
+image 如果你的界面显示的不是这个样子，少一些东西的话，你可以使用Window>Reset Perspective来重置样式。
+
+但是我并打不开。
+如果你的手机是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.
+好了，我们直接打开自己的页面进行查看布局吧(有点慢)。
+它是介个样子滴 ：
+image
+
+我们可以看到所有结构，点击对一个的节点，能直接看到该界面的UI效果，并展示该布局包含多少个View，以及该布局measure,draw,layout所消耗的时间。选中Show Extras选项可以看到在右下角看到界面效果。
+
+选中要查看的节点后点击Profile Node选项，可以看到如下界面:
+
+image
+
+可以看到每个布局都出现了三个点。有不同的颜色,从左到右这三个点分别表示:
+
+左边的点代表Draw阶段。
+中间的点代表了Layout阶段。
+右边的点代表了Execute阶段。
+这三个点有分别对应了pipeline中的不同阶段，如下图:
+image
+
+不同的颜色代表不同的性能:
+
+绿色代表渲染的非常快，至少是其他View的一半。
+黄色代表View渲染比最后那一半的View快。
+红色代表View渲染是几乎是在最慢的那部分中间。
+Hierarchy Viewer测量的是相对的表现能力，所以总会有一个红色的节点，它并不意味者该View一定是绘制的太慢。
+
+过度绘制
+在开发者选项中将调试GPU过度绘制设置为显示过度绘制区域，就能看到程序的绘制情况。
+过度绘制往往发生在我们需要在一个东西上面绘制另外一个东西，例如在一个红色的背景上画一个黄色的按钮。那么GPU就需要先画出红色背景，再在他上面绘制黄色按钮，此时过度绘制就是不可避免的了。如果我们有太多层需要绘制，那么则会过度的占用GPU导致我们每帧消耗的时间超过16毫秒。 这些过度绘制可能发生在我们给Activity或Fragment设置了全屏的背景，同时又给ListView以及ListView的条目设置了背景色。而通过只设置一次背景色即可解决这样的问题。
+
+注意：默认的主题会为你指定一个默认的全屏背景色，如果你的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的源码后，我发现了在滑动的时候会自动为左右两页启动一个硬件层，并且在滑动结束后移除掉。
+
+在两页间滑动的时候创建硬件层也是可以理解的，但对我来说小有不幸。通常来讲加入硬件层是为了让ViewPager的滑动更加流畅，毕竟它们相对复杂。
+
+是的，但是再使用硬件layers的时候还是有几点要牢记在心：
+
+回收 – 硬件层会占用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!
\ No newline at end of file
diff --git "a/Tools&Library/\347\233\256\345\211\215\346\265\201\350\241\214\347\232\204\345\274\200\345\217\221\347\273\204\345\220\210.md" "b/Tools&Library/\347\233\256\345\211\215\346\265\201\350\241\214\347\232\204\345\274\200\345\217\221\347\273\204\345\220\210.md"
new file mode 100644
index 00000000..a753091f
--- /dev/null
+++ "b/Tools&Library/\347\233\256\345\211\215\346\265\201\350\241\214\347\232\204\345\274\200\345\217\221\347\273\204\345\220\210.md"
@@ -0,0 +1,14 @@
+目前流行的开发组合
+===
+
+
+目前主流的一套框架就是`Retrofit + RxJava + RxBinding + Dagger2`
+
+架构上面目前是`MVP`居多。
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Tools&Library/\350\260\203\350\257\225\345\271\263\345\217\260Flipper.md" "b/Tools&Library/\350\260\203\350\257\225\345\271\263\345\217\260Flipper.md"
new file mode 100644
index 00000000..92e411a1
--- /dev/null
+++ "b/Tools&Library/\350\260\203\350\257\225\345\271\263\345\217\260Flipper.md"
@@ -0,0 +1,189 @@
+调试平台Flipper
+
+===
+
+子日:工欲善其事必先利其器
+
+[Flipper](https://fbflipper.com/docs)是之前`Facebook`的一个内部调试工具，旨在帮助开发人员以交互式和可扩展的方式检查和理解`iOS`及`Android`应用程序的结构和行为。
+
+根据`Facebook`工程师`EmilSjölander`的说法，`Flipper`基于[Stetho](http://facebook.github.io/stetho/)的经验基础而构建，`Stetho`是一个`Android`调试桥，允许开发人员使用`Chrome DevTools`调试他们的应用程序。
+
+`Facebook`推荐开发者使用`Flipper`来替代`Stetho`，除非是还没有从`Stetho`移植到`Flipper`的一些功能，例如基于`Dumper`的命令行工具。
+
+
+前段时间`facebook`将`Flipper`开源了。最开始的时候是叫做`Sonar`后来改成`Flipper`了。
+
+
+这里就以`android`应用为例简单介绍一下它的使用。 
+`Flipper`包括两部分:  
+
+- 桌面应用
+- `Flipper SDK`:移动应用程序需要集成`Flipper SDK`，`Flipper SDK`负责与基于`Electron`的桌面应用程序通信，以显示调试数据。
+
+在扩展性方面，`Flipper`提供了一个插件`API`，开发人员可以使用这组`API`创建自己的插件来可视化和调试应用程序数据。`Flipper`初始版本包含许多即用型插件，例如:
+
+- `Logs`:用于检查应用程序的系统日志，默认集成的，不用手动添加。
+- `Layout Inspector`:用于检查`iOS`和`Android`应用程序的布局。
+- `Network Inspector`:用于检查网络流量。
+- `SharedPreferece`:用于查看`sharedpreference`文件的。
+
+这些只是`Flipper`提供的一些基本的功能。根据`Sjölander`的说法，`Facebook`工程师还开发了插件来监控`GraphQL`请求、跟踪性能标记等。
+
+
+下面介绍一下如何使用：   
+
+### 首先，去官网下载桌面应用，下载完后是这个样子的。
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/sonar_desktop.png?raw=true" width="100%" height="100%">
+
+我们可以看到左边只有`log`的部分。
+
+
+### 接下来在`app`中嵌入`flipper`的`sdk`
+
+- 首先需要保证已声明如下权限:   
+```xml
+<uses-permission android:name="android.permission.INTERNET" />
+<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+```
+
+- 然后在`build.gradle`文件中添加依赖
+
+```java
+repositories {
+  jcenter()
+}
+
+dependencies {
+  debugImplementation 'com.facebook.flipper:flipper:0.6.18'
+}
+```
+
+- 自定义一个`Application`，并在`onCreate()`方法中初始化`flipper`
+
+```java
+public class MyApplication extends Application {
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        SoLoader.init(this, false);
+
+        if (BuildConfig.DEBUG && SonarUtils.shouldEnableSonar(this)) {
+            final SonarClient client = AndroidSonarClient.getInstance(this);
+            client.addPlugin(new NetworkSonarPlugin());
+            client.addPlugin(new SharedPreferencesSonarPlugin(this));
+            client.start();
+        }
+    }
+}
+```
+
+上面我们添加了两个`plugin`，我们执行看一下:   
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/sonar_add_plugin.png?raw=true" width="100%" height="100%">
+
+看到了吗？左边现在有`log`、`network`和`sharedpreference`三个部分了。 但是这三个是远远不够的啊，我还想查看布局。 
+
+这里需要注意一下，如果使用了`okhttp`,可以使用拦截器系统自动`hook`到现在的堆栈。
+
+```java
+import com.facebook.sonar.plugins.network.SonarOkhttpInterceptor;
+
+new OkHttpClient.Builder()
+    .addNetworkInterceptor(new SonarOkhttpInterceptor(networkSonarPlugin))
+    .build();
+```
+
+- 增加对查看布局的支持
+
+```java
+public class MyApplication extends Application {
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        SoLoader.init(this, false);
+
+        if (BuildConfig.DEBUG && SonarUtils.shouldEnableSonar(this)) {
+            final SonarClient client = AndroidSonarClient.getInstance(this);
+            client.addPlugin(new NetworkSonarPlugin());
+            client.addPlugin(new SharedPreferencesSonarPlugin(this));
+            // 增加布局plugin
+            final DescriptorMapping descriptorMapping = DescriptorMapping.withDefaults();
+            client.addPlugin(new InspectorSonarPlugin(this, descriptorMapping));
+            client.start();
+        }
+    }
+}
+```
+
+执行一下:  
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/sonar_add_plugun_layout.png?raw=true" width="100%" height="100%">
+
+
+- 沙箱插件
+
+这个我没搞懂到底是干什么用的，也没用过。
+
+> The Sandbox plugin is useful for developers that had to test changes of their apps by pointing them to some Sandbox environment. Through this plugin and a few lines of code in the client, the app can get a callback and get the value that the user has input through Sonar. At this point, the developer can plugin its logic to save this setting in its app.
+
+```java
+import com.facebook.sonar.plugins.SandboxSonarPlugin;
+import com.facebook.sonar.plugins.SandboxSonarPluginStrategy;
+
+final SandboxSonarPluginStrategy strategy = getStrategy(); // Your strategy goes here
+client.addPlugin(new SandboxSonarPlugin(strategy));
+```
+ 
+在上面的代码中，我们都是直接通过`addPlugin()`方法去添加的，我们看一下系统提供的`Plugin`。 
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/sonar_plugin_list.png?raw=true" width="100%" height="100%">
+
+其实我们也可以自定义`Plugin`，自定义一个类实现`SonarPlugin`接口，然后去发送或者接受数据，一般也用不到，这里就不说了:
+```java
+public class MySonarPlugin implements SonarPlugin {
+  private SonarConnection mConnection;
+
+  @Override
+  public String getId() {
+    return "MySonarPlugin";
+  }
+
+    @Override
+    public void onConnect(SonarConnection connection) throws Exception {
+        mConnection = connection;
+        // Using the SonarConnection object you can register a receiver of a desktop method call and respond with data.
+        connection.receive("getData", new SonarReceiver() {
+            @Override
+            public void onReceive(SonarObject params, SonarResponder responder) throws Exception {
+                responder.success(
+                        new SonarObject.Builder()
+                                .put("data", MyData.get())
+                                .build());
+            }
+        });
+
+        // You don't have to wait for the desktop to request data though, you can also push data directly to the desktop.
+        connection.send("MyMessage",
+                new SonarObject.Builder()
+                        .put("message", "Hello")
+                        .build());
+
+
+
+    }
+
+  @Override
+  public void onDisconnect() throws Exception {
+    mConnection = null;
+  }
+}
+```
+
+
+
+---
+
+- 邮箱 ：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"
new file mode 100644
index 00000000..664e9d8e
--- /dev/null
+++ "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"
@@ -0,0 +1,425 @@
+音视频基础知识
+===
+
+
+基本概念
+---
+
+- 图像
+    图像是人类视觉的基础，是自然景物的客观反映，是人类认识世界和人类本身发展的重要源泉。“图”是物体反射或透射光的分布，“像”是人的视觉系统所接收的图在人脑中所形成的印象或认识。图像是客观对象的一种相似性的、生动性的描述或写真，是人类社会活动中最常用的信息载体，或者说图像是客观对象的一种表示，它包含了被描述对象的有关信息。广义上，图像就是所有具有视觉效果的画面，包括纸介质的、底片或照片上的、电视上的、投影仪或计算机屏幕上的画面。在计算机领域，与图像相关的概念非常多，包括像素、PPI、图像位深度等。
+
+    图像本质上是由很多“带有颜色的点”组成的，而这些点，就是“像素”。像素的英文叫Pixel，缩写为PX。这个单词是由图像(Picture)和元素(Element)这两个单词所组成的。
+
+    像素是图像显示的基本单位，分辨率是指一张图片的宽度和高度的乘积，单位是像素。通常说一张图片的大小，例如1920×1080像素，是指宽度为1920像素，高度为1080像素。它们的乘积是1920×1080=2 073 600，也就是说这张图片是两百万像素的。1920×1080，也被称为这幅图片的分辨率
+
+- 媒体
+
+    是表示，传输，存储信息的载体，常人们见到的文字、声音、图像、图形等都是表示信息的媒体。
+
+- 多媒体
+
+    是声音、动画、文字、图像和录像等各种媒体的组合，以图文并茂，生动活泼的动态形式表现出来，给人以很强的视觉冲击力，留下深刻印象.
+
+- 多媒体技术
+
+    是将文字、声音、图形、静态图像、动态图像与计算集成在一起的技术。它要解决的问题是计算机进一步帮助人类按最自然的和最习惯的方式接受和处理信息。
+
+- 流媒体
+
+    流媒体是指采用流式传输的方式在`Internet`播放的连续时基媒体格式，实际指的是一种新的媒体传送方式，而不是一种新的媒体格式（在网络上传输音/视频等多媒体信息现在主要有下载和流式传输两种方式）流式传输分两种方法：实时流式传输方式(`Realtime Streaming`)和顺序流式传输方式(`Progressive Streaming`)。
+
+- 多媒体文件
+
+    既包括视频又包括音频，甚至还带有脚本的一个集合，也可以叫容器。
+
+- 媒体编码
+
+    是文件当中的视频和音频所采用的压缩算法。也就是说一个`avi`的文件，当中的视频编码有可能是`A`，也可能是`B`，而其音频编码有可能是`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，表示采用动态比特率编码方式，达到播放质量与体积兼得的效果。 使用VBR编码时，系统将自动为内容的简单部分分配较少的比特，从而留出足量的比特用于生成高质量的复杂部分。这意味着复杂性恒定的内容（例如新闻播音）不会受益于VBR编码。
+
+    对混合内容使用VBR编码时，在文件大小相同的条件下，VBR编码的输出结果要比CBR编码的输出结果质量好得很多。在某些情况下，与CBR编码文件质量相同的VBR编码文件，其大小可能只有前者的一半。
+  
+- 静态比特率(CBR: Constant Bit Rate)
+    固定比特率，指文件从头到尾都是一种位速率。在流式播放方案中使用CBR编码最为有效。使用CBR编码时，比特率在流的进行过程中基本保持恒定并且接近目标比特率，始终处于由缓冲区大小确定的时间窗内。
+
+    CBR编码的缺点在于编码内容的质量不稳定。因为内容的某些片段要比其他片段更难压缩，所以CBR流的某些部分质量就比其他部分差。此外，CBR编码会导致相邻流的质量不同。通常在较低比特率下，质量的变化会更加明显。
+    
+  
+- 帧率(Frame Rate)
+  
+
+帧/秒(`frames per second`)的缩写帧率即每秒显示帧数，帧率表示图形处理器处理场时每秒钟能够更新的次数。高的帧率可以得到更流畅、更逼真的动画。一般来说`30fps`就是可以接受的，但是将性能提升至`60fps`则可以明显提升交互感和逼真感，但是一般来说超过`75fps`一般就不容易察觉到有明显的流畅度提升了。如果帧率超过屏幕刷新率只会浪费图形处理的能力，因为监视器不能以这么快的速度更新，这样超过新率的帧率就浪费掉了。
+  ![image](https://github.com/CharonChui/Pictures/blob/master/fps.gif?raw=true)
+
+- 关键帧
+
+    相当于二维动画中的原画，指角色或者物体运动或变化中的关键动作所处的那一帧，它包含了图像的所有信息，后来帧仅包含了改变了的信息。如果你没有足够的关键帧，你的影片品质可能比较差，因为所有的帧从别的帧处产生。对于一般的用途，一个比较好的原则是每5秒设一个关键键。但如果时那种实时传输的流文件，那么要考虑传输网络的可靠度，所以要1到2秒增加一个关键帧。
+
+- 刷新率
+
+    刷新率是指屏幕每秒画面被刷新的次数，刷新率分为垂直刷新率和水平刷新率，一般提到的刷新率通常是指垂直刷新率。垂直刷新率表示屏幕上图像每秒重绘多少次，也就是每秒屏幕刷新的次数，以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的最佳分辨率，也叫最大分辨率，在该分辨率下，液晶显示器才能显现最佳影像。
+
+每个像素有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，主要用于标识读入内存中的比特流在什么时候开始送入解码器中进行解码。
+
+- PTS
+
+    Presentation Time Stamp，主要用于度量解码后的视频帧什么时候被显示出来。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/gop_dts_pts.jpg)
+
+
+音视频压缩编码标准
+---
+
+为什么要有编码? 
+以一个分辨率1920×1280，帧率30的视频为例：
+共：1920×1280=2,073,600（Pixels 像素），每个像素点是24bit；
+也就是：每幅图片2073600×24=49766400 bit，8 bit（位）=1 byte（字节）；
+所以：49766400bit=6220800byte≈6.22MB。
+
+这是一幅1920×1280图片的原始大小，再乘以帧率30。
+也就是说：每秒视频的大小是186.6MB，每分钟大约是11GB，一部90分钟的电影，
+约是1000GB。。。
+
+编码的终极目的，说白了，就是为了压缩。各种五花八门的视频编码方式，都是为了让视频变得体积更小，有利于存储和传输。
+
+
+多媒体编辑码方式就是指通过特定的压缩技术，将某个视频格式的文件转换成另一种视频格式文件的方式，现在主要的编码方式有:    
+
+- `MPEG`系列:由国际标准组织机构(`ISO`)下属的运动图象专家组(`MPEG`)开发。视频编码方面主要是`Mpeg1`、`Mpeg2`、`Mpeg4`、`Mpeg4 AVC`。音频编码方面主要是`MPEG Audio Layer 1/2`、`MPEG Audio Layer 3`、`MPEG-2 AAC`、`MPEG-4 AAC`等等:   
+
+    - `MPEG-1`第二部分，主要使用在`VCD`上，有些在线视频也使用这种格式。该编解码器的质量大致上和原有的`VHS`录像带相当。
+    - `MPEG-2`第二部分，等同于`H.262`，使用在`DVD`、`SVCD`和大多数数字视频广播系统和有线分布系统中。
+    - `MPEG-4`第二部分，可以使用在网络传输、广播和媒体存储上。比起`MPEG-2`第二部分和第一版的`H.263`，它的压缩性能有所提高。
+    - `MPEG-4`第十部分，等同于`H.264`，是这两个编码组织合作诞生的标准。
+
+
+- `H.26X`系列：由国际电传视讯联盟远程通信标准化组织(`ITU-T`)主导，包括`H.261`、`H.262`、`H.263`、`H.264`、`H.265`。
+    - `H.261`主要用于老的视频会议和视频电话系统。是第一个使用的数字视频压缩标准。实质上说，之后的所有的标准视频编解码器都是基于它设计的。
+    - `H.262`等同于`MPEG-2`第二部分，使用在`DVD`、`SVCD`和大多数数字视频广播系统和有线分布系统中。
+    - `H.263`主要用于视频会议、视频电话和网络视频相关产品。在对逐行扫描的视频源进行压缩的方面，`H.263` 比它之前的视频编码标准在性能上有了较大的提升。尤其是在低码率端，它可以在保证一定质量的前提下大大的节约码率。
+    - `H.264`等同于`MPEG-4`第十部分，也被称为高级视频编码(`Advanced Video Coding`，简称 `AVC`)，是一种视频压缩标准，一种被广泛使用的高精度视频的录制、压缩和发布格式。该标准引入了一系列新的能够大大提高压缩性能的技术，并能够同时在高码率端和低码率端大大超越以前的诸标准。
+    - `H.265`被称为高效率视频编码(`High Efficiency Video Coding`，简称`HEVC`)是一种视频压缩标准，是`H.264`的继任者。`HEVC` 被认为不仅提升图像质量，同时也能达到`H.264`两倍的压缩率（等同于同样画面质量下比特率减少了50%），可支持`4K` 分辨率甚至到超高画质电视，最高分辨率可达到`8192×4320`(`8K`分辨率)，这是目前发展的趋势。
+
+
+- 微软`Windows Media`系列:视频编码有`Mpeg-4 v1/v2/v3`、`Windows Media Video 7/8/9/10`；音频编码有`Windows Media audeo v1/v2/7/8/9`。    
+- `Real Media`系列:视频编码有`RealVideo G2`、`RealVideo 8/9/10`；音频编码有`RealAudio cook/sipro`、`RealAudio AAC/AACPlus`等。  
+- `QuickTime`系列:视频编码有`Sorenson Video 3`、`Apple MPEG-4`、`Apple H.264`；音频编码有`QDesign Music 2`、`Apple MPEG-4 AAC`。   
+- 其它如：`Ogg`、`On2-vpx`、`flash vidio`，以及`M-JPEG`视频压缩方式。    
+
+
+简单的总结一下上面的两条就是，视频编码标准有两大系统:  
+
+- MPEG:MPEG标准由MPEG制定，MPEG-1 | MPEG-2 | MPEG-3 | MPEG-4 | MPEG-7 | MPEG-21
+- ITU-T:ITU-T标准由VCEG制定，H.261 | H.262 | H.263 | H.263v2 | H.264
+
+
+
+#### 音频编解码方式
+
+视频中除了画面通常还有声音，所以这就涉及到音频编解码。在视频中经常使用的音频编码方式有: 
+
+- `AAC`:(`Advanced Audio Coding`)，是由`Fraunhofer IIS`、`杜比实验室`、`AT&T`、`Sony`等公司共同开发，在1997年推出的基于`MPEG-2` 的音频编码技术。2000年，`MPEG-4`标准出现后，`AAC`重新集成了其特性，加入了`SBR`技术和`PS`技术，为了区别于传统的`MPEG-2 AAC`又称为`MPEG-4 AAC`。
+- `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就是要把声音从模拟转换成数字信号的一种技术，它的原理简单地说就是利用一个固定的频率对模拟信号进行采样，采样后的信号在波形上看就像一串连续的幅值不一的脉冲，把这些脉冲的幅值按一定的精度进行量化，这些量化后的数值被连续地输出、传输、处理或记录到存储介质中，所有这些组成了数字音频的产生过程。
+
+
+PCM的采集步骤分为： 
+模拟信号 -> 采样 -> 量化 -> 编码  -> 数字信号
+---
+
+
+
+
+视频格式(封装格式/容器)
+---
+
+把编码后的音视频数据以一定格式封装到一个容器。
+
+目前我们经常见的视频格式无非就是两大类： 
+
+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）。
+
+
+一些音视频的参数含义
+---
+
+ 数码音频系统是通过将声波波形转换成一连串的二进制数据来再现原始声音的，实现这个步骤使用的设备是模/数转换器（A/D），它以每秒上万次的速率对声波进行采样，每一次采样都记录下了原始模拟声波在某一时刻的状态，称之为样本。
+
+将一串的样本连接起来，就可以描述一段声波了，把每一秒钟所采样的数目称为采样频率或采率，单位为HZ（赫兹）。采样频率越高所能描述的声波频率就越高。采样率决定声音频率的范围（相当于音调），可以用数字波形表示。要正确理解音频采样可以分为采样的位数和采样的频率。
+
+采样的位数：采样位数可以理解为采集卡处理声音的解析度。这个数值越大，解析度就越高，录制和回放的声音就越真实。我们首先要知道：电脑中的声音文件是用数字0和1来表示的。所以在电脑上录音的本质就是把模拟声音信号转换成数字信号。
+
+反之，在播放时则是把数字信号还原成模拟声音信号输出。采集卡的位是指采集卡在采集和播放声音文件时所使用数字声音信号的二进制位数。采集卡的位客观地反映了数字声音信号对输入声音信号描述的准确程度。
+
+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的采样频率人耳已无法辨别出来了，所以在电脑上没有多少使用价值。
+
+
+
+***声道***：目前人们所使用的各种声场技术规范非常多，但最常见的几乎都来自三家公司，他们是`Dolby`（杜比）、`HTX`和`DTS`。
+
+声卡所支持的声道数是衡量声卡档次的重要指标之一，从单声道到最新的环绕立体声，下面一一详细介绍：
+
+- 单声道：单声道是比较原始的声音复制形式，早期的声卡采用的比较普遍。当通过两个扬声器回放单声道信息的时候，我们可以明显感觉到声音是从两个音箱中间传递到我们耳朵里的。
+这种缺乏位置感的录制方式用现在的眼光看自然是很落后的，但在声卡刚刚起步时，已经是非常先进的技术了。
+- 立体声：单声道缺乏对声音的位置定位，而立体声技术则彻底改变了这一状况。声音在录制过程中被分配到两个独立的声道，从而达到了很好的声音定位效果。
+这种技术在音乐欣赏中显得尤为有用，听众可以清晰地分辨出各种乐器来自的方向，从而使音乐更富想象力，更加接近于临场感受。立体声技术广泛运用于自`Sound Blaster Pro`以后的大量声卡，成为了影响深远的一个音频标准。时至今日，立体声依然是许多产品遵循的技术标准。
+- 准立体声：准立体声声卡的基本概念就是：在录制声音的时候采用单声道，而放音有时是立体声，有时是单声道。采用这种技术的声卡也曾在市面上流行过一段时间，但现在已经销声匿迹了。
+- 四声道环绕：人们的欲望是无止境的，立体声虽然满足了人们对左右声道位置感体验的要求，但是随着技术的进一步发展，大家逐渐发现双声道已经越来越不能满足我们的需求。
+由于`PCI`声卡的出现带来了许多新的技术，其中发展最为神速的当数三维音效。三维音效的主旨是为人们带来一个虚拟的声音环境，通过特殊的HRTF技术营造一个趋于真实的声场，
+从而获得更好的游戏听觉效果和声场定位。而要达到好的效果，仅仅依靠两个音箱是远远不够的，所以立体声技术在三维音效面前就显得捉襟见肘了，但四声道环绕音频技术则很好的解决了这一问题。
+四声道环绕规定了4个发音点：前左、前右，后左、后右，听众则被包围在这中间。同时还建议增加一个低音音箱，以加强对低频信号的回放处理(这也就是如今4.1声道音箱系统广泛流行的原因)。
+就整体效果而言，四声道系统可以为听众带来来自多个不同方向的声音环绕，可以获得身临各种不同环境的听觉感受，给用户以全新的体验。如今四声道技术已经广泛融入于各类中高档声卡的设计中，
+成为未来发展的主流趋势。
+- 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表示红色通道与亮度的差值(为什么只有蓝色红色，没有绿色，这是因为红蓝绿加起来为1，所以1减去他俩就是绿)
+UV的作用是描述影像色彩及饱和度，它们用于指定像素的颜色。
+U和V不是基础信号，他俩都是被正交调制的。早期的电视都是黑白的，即只有亮度值(Y)，有了彩色电视之后，加入了UV两种色度，形成现在的YUV。
+人眼对亮度敏感，对色度不敏感，因此减少部分UV的数据量，人眼也无法感知出来，这样就可以通过压缩UV的分辨率，在不影响观感的前提下，减少视频的体积。
+
+YUV和RGB视频信号相比，最大的优点在于只需要占用极少的带宽，YUV只需要占用RGB一般的带宽。
+
+YUV 色彩编码模型，其设计初衷为了解决彩色电视机与黑白电视的兼容问题，利用了人类眼睛的生理特性（对亮度敏感，对色度不敏感），允许降低色度的带宽，降低了传输带宽。
+
+在计算机系统中应用尤为广泛，利用 YUV 色彩编码模型可以降低图片数据的内存占用，YUV只需要占用RGB一般的带宽，从而提高数据处理效率。
+
+另外，YUV 编码模型的图像数据一般不能直接用于显示，还需要将其转换为 RGB（RGBA） 编码模型，才能够正常显示图像。
+
+
+
+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
+---
+
+最近开发中遇到了一个问题，就是平时我们都是按照视频的宽高来显示缩放的，也就是分辨率，但是最近确发现了有一个视频会发生变形的情况，而在VLC上面确实正常的，后来追查发现是因为这个视频的PAR并不是1:1，而为什么会出现这种情况呢？ 这事因为视频的制式按照设备可以分为计算机制式和电视制式。而电视制式又可以分为PAL和NTSC。电视制式的PAR通常不为1:1，而计算机制式的PAR为1:1。
+
+
+- PAR(Pixel Aspect Ratio):像素横纵比。表示每个像素的宽度与长度的比值，大多数情况为1:1，就是一个正方形像素，否则为长方形像素。
+- 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格式的数据。
+
+[常见流媒体协议](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)
+
+##### 硬件加速
+
+
+中央处理器(Central Processing Unit，CPU)，包括算术逻辑部件(Arithmetic Logic Unit，ALU)和高速缓冲存储器(Cache)及实现它们之间联系的数据(Data)、控制及状态的总线(Bus)。GPU即图形处理器(Graphics Processing Unit)，专为执行复杂的数学和几何计算而设计的，拥有二维或三维图形加速功能。GPU相比于CPU具有更强大的二维、三维图形计算能力，可以让CPU从图形处理的任务中解放出来，执行其他更多的系统任务，这样可以大大提高计算机的整体性能。硬件加速(Hardware Acceleration)就是利用硬件模块来替代软件算法以充分利用硬件所固有的快速特性，硬件加速通常比软件算法的效率要高。例如将与二维、三维图形计算相关的工作交给GPU处理，从而释放CPU的压力，是属于硬件加速的一种。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+相关知识: 
+
+- [封装格式](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! 
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/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
diff --git "a/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" "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"
new file mode 100644
index 00000000..648a79f3
--- /dev/null
+++ "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"	
@@ -0,0 +1,454 @@
+Android WebRTC简介
+===
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/webrtc-logo.png?raw=true)
+              
+
+WebRTC简介
+---
+
+[WebRTC](https://webrtc.org/)
+
+
+`WebRTC`名称源自网页实时通信(Web Real-Time Communication`)的缩写，是一个支持网页浏览器进行实时语音对话或视频对话的技术，是谷歌2010年以6820万美元收购`Global IP Solutions`公司而获得的一项技术。`Google`于2011年6月3日开源的即时通讯项目，旨在使其成为客户端视频通话的标准。其实在`Google`将`WebRTC`开源之前，微软和苹果各自的通讯产品已占用很大市场份额（如`Skype`），`Google`也是为了快速扩大市场，所以将他给开源。在行业内得到了广泛的支持和应用，成为下一代视频通话的标准。更多介绍可以去官网上看。
+
+`WebRTC`被誉为是`web`长期开源开发的一个新启元，是近年来`Web`开发的最重要创新。`WebRTC`允许`Web`开发者在其`web`应用中添加视频聊天或者点对点数据传输，不需要复杂的代码或者昂贵的配置。目前支持`Chrome`、`Firefox`和`Opera`，后续会支持更多的浏览器，它有能力达到数十亿的设备。
+
+然而，`WebRTC`一直被误解为仅适合于浏览器。事实上，`WebRTC`最重要的一个特征是允许本地和`web`应用间的互操作，很少有人使用到这个特性。
+
+
+本文主要以开源项目[AndroidRTC](https://github.com/pchab/AndroidRTC)为例。
+下载后通过`Android Studio`打开，打开的时候可能会报错，说找不到`org.json:json:20090211`，这时只要将`AndroidRTC/webrtc-client/build.gradle`中的
+```
+dependencies {
+    compile ('com.github.nkzawa:socket.io-client:0.4.1')
+    compile 'io.pristine:libjingle:8871@aar'
+}
+```
+修改成
+```
+dependencies {
+    compile ('com.github.nkzawa:socket.io-client:0.4.1'){ // //webSocket相关
+        exclude group: 'org.json', module: 'json' // 这句话是我新加的，不然会提示org.json:json:20090211找不到
+    }
+
+    compile 'io.pristine:libjingle:8871@aar' // //webRTC官方aar包
+}
+```
+就可以了。 
+
+
+运行一下你会发现进去会黑屏，这是因为需要依赖`node.js`服务。
+
+`WebRTC Live Streaming`: 
+
+- `Node.js server`
+- `Desktop client`
+- `Android client`
+
+如果电脑上没有安装`nodejs`需要先安装`nodejs`，因为需要依赖`node.js`所以我们要先安装`node.js`。去[nodejs官网](https://nodejs.org/en/#download)下载安装。
+
+然后是要本地下载[ProjectRTC](https://github.com/pchab/ProjectRTC)项目:    
+- `git clone https://github.com/pchab/ProjectRTC.git`
+- `cd ProjectRTC/`
+- `npm install`
+- `npm start`
+服务默认会运行在3000端口，你可以在浏览器中打开`localhost:3000`。  
+
+![image](https://github.com/CharonChui/Pictures/blob/master/webrtc_web_1.png?raw=true)
+
+如图就表示运行成功了。
+
+接下来我们进行打开`android`客户端，你会发现，还是黑屏。
+这是因为我们需要在项目中的`strings.xml`中将配置修改成本地电脑在局域网下的`ip`地址和运行`Node`服务端的端口。如下:   
+```xml
+<resources>
+    <string name="app_name">AndroidRTC</string>
+    <string name="host">172.16.55.27</string>
+    <string name="port">3000</string>
+    <string name="action_settings">Options</string>
+</resources>
+```
+好了，现在再运行`android`项目，然后打开浏览器输入`localhost:3000`，在浏览器页面点击`start`，你就可以看到电脑摄像头获取的画面，如下图: 
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/webrtc_web_start.png?raw=true)
+
+
+然后点击左边的`call`，就会去申请连手机端，接下来你就可以在浏览器和手机端看到画面了，如下图:
+
+![image](https://github.com/CharonChui/Pictures/blob/master/webrtc_web_call.png?raw=true)
+
+手机端的画面:   
+
+![image](https://github.com/CharonChui/Pictures/blob/master/webrtc_android.jpg?raw=true)
+
+既然连通了，下面就仔细分析一下代码:   
+代码文件比较少，主要是三个类:  
+
+![image](https://github.com/CharonChui/Pictures/blob/master/webrtc_demo_file.png?raw=true)
+
+其中在`WebRtcClient`中实现的逻辑最为核心，我们就从他入手。  
+
+`Android`相关的`API`有`VideoCapturerAndroid`,`VideoRenderer`,`MediaStream`,`PeerConnection`,
+和`PeerConnectionFactory`。下面我们将逐一讲解。
+
+在开始之前，需要创建`PeerConnectionFactory`，这是`Android`上使用`WebRTC`最核心的`API`。
+
+### `PeerConnectionFactory`
+
+`Android WebRTC`最核心的类。理解这个类并了解它如何创建其他任何事情是深入了解`Android`中`WebRTC`的关键。
+它和我们期望的方式还是有所不同的，所以我们开始深入挖掘它。
+
+我们先到`WebRtcClient`文件中找到`PeerConnectionFactory`初始化的地方:   
+
+![image](https://github.com/CharonChui/Pictures/blob/master/webrtc_factory_code.png?raw=true)
+
+`initializeAndroidGlobals`的参数分别是:   
+- `context`:应用上下文
+- `initializeAudio`:是否初始化音频的布尔值。
+- `initializeVideo`:是否初始化视频的布尔值。跳过这两个就允许跳过请求`API`的相关权限，例如数据通道应用。
+- `videoCodecHwAcceleration`:是否允许硬件加速的布尔值。
+- `renderEGLContext`:用来提供支持硬件视频解码，可以在视频解码线程中创建共享`EGL`上下文。
+可以为空——在本文例子中硬件视频解码将产生`yuv420`帧而非`texture`帧。
+- `initializeAndroidGlobals`也是返回布尔值，`true`表示一切OK，`false`表示有失败。
+
+
+有了`peerConnectionFactory`实例，就可以从用户设备获取视频和音频，最终将其渲染到屏幕上。在`Android`中，我们需要了解`VideoCapturerAndroid`，`VideoSource`，`VideoTrack`和`VideoRenderer`。     
+先从`VideoCapturerAndroid`开始:     
+
+#### `VideoCapturerAndroid`
+
+`VideoCapturerAndroid`其实是一系列`Camera API`的封装，为访问摄像头设备的流信息提供了方便。它允许获取多个摄像头设备信息，包括前置摄像头，或者后置摄像头。
+
+在`WebRtcClient`类中的代码为:     
+```java
+private void setCamera(){
+    localMS = factory.createLocalMediaStream("ARDAMS");
+    if(pcParams.videoCallEnabled){
+        MediaConstraints videoConstraints = new MediaConstraints();
+        videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("maxHeight", Integer.toString(pcParams.videoHeight)));
+        videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("maxWidth", Integer.toString(pcParams.videoWidth)));
+        videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("maxFrameRate", Integer.toString(pcParams.videoFps)));
+        videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("minFrameRate", Integer.toString(pcParams.videoFps)));
+
+        videoSource = factory.createVideoSource(getVideoCapturer(), videoConstraints);
+        localMS.addTrack(factory.createVideoTrack("ARDAMSv0", videoSource));
+    }
+
+    AudioSource audioSource = factory.createAudioSource(new MediaConstraints());
+    localMS.addTrack(factory.createAudioTrack("ARDAMSa0", audioSource));
+
+    mListener.onLocalStream(localMS);
+}
+
+private VideoCapturer getVideoCapturer() {
+	// 获取前置摄像头的名称
+    String frontCameraDeviceName = VideoCapturerAndroid.getNameOfFrontFacingDevice();
+    // 创建前置摄像头对象
+    return VideoCapturerAndroid.create(frontCameraDeviceName);
+}
+```
+
+有了包含摄像流信息的`VideoCapturerAndroid`实例，就可以创建从本地设备获取到的包含视频流信息的`MediaStream`，从而发送给另一端。但做这些之前，我们首先研究下如何将自己的视频显示到应用上面。
+
+
+#### `VideoSource/VideoTrack`
+
+从`VideoCapturer`实例中获取一些有用信息，或者要达到最终目标————为连接端获取合适的媒体流，或者仅仅是将它渲染给用户，我们需要了解`VideoSource`和`VideoTrack`类。
+
+`VideoSource`允许方法开启、停止设备捕获视频。这在为了延长电池寿命而禁止视频捕获的情况下比较有用。
+`VideoTrack`是简单的添加`VideoSource`到`MediaStream`对象的一个封装。
+
+我们通过代码看看它们是如何一起工作的。`capturer`是`VideoCapturer`的实例，`videoConstraints`是`MediaConstraints`的实例。
+代码还是在上面贴出的`setCamera()`方法中:    
+
+```java
+private void setCamera(){
+    localMS = factory.createLocalMediaStream("ARDAMS");
+    if(pcParams.videoCallEnabled){
+        MediaConstraints videoConstraints = new MediaConstraints();
+        ......
+        // 创建VideoSource
+        videoSource = factory.createVideoSource(getVideoCapturer(), videoConstraints);
+        // 创建VideoTrack
+        localMS.addTrack(factory.createVideoTrack("ARDAMSv0", videoSource));
+    }
+    // 创建AudioSource
+    AudioSource audioSource = factory.createAudioSource(new MediaConstraints());
+    // 创建AudioSource
+    localMS.addTrack(factory.createAudioTrack("ARDAMSa0", audioSource));
+
+    mListener.onLocalStream(localMS);
+}
+```
+
+#### `AudioSource/AudioTrack`
+
+`AudioSource`和`AudioTrack`与`VideoSource`和`VideoTrack`相似，只是不需要`AudioCapturer`来获取麦克风，
+代码同上。   
+
+#### `VideoRenderer`
+
+进入`VideoRenderer`，`WebRTC`库允许通过`VideoRenderer.Callbacks`实现自己的渲染。另外，
+它提供了一种非常好的默认方式`VideoRendererGui`。简而言之，`VideoRendererGui`是一个`GLSurfaceView`，使用它可以绘制自己的视频流。我们通过代码看一下它是如何工作的，以及如何添加`renderer`到`VideoTrack`。
+因为他是渲染的类，所以代码就不是在`WebRtcClient`里面了，在`RtcActivity`中，我们看下代码:    
+
+```java
+// Local preview screen position before call is connected.
+private static final int LOCAL_X_CONNECTING = 0;
+private static final int LOCAL_Y_CONNECTING = 0;
+private static final int LOCAL_WIDTH_CONNECTING = 100;
+private static final int LOCAL_HEIGHT_CONNECTING = 100;
+// Local preview screen position after call is connected.
+private static final int LOCAL_X_CONNECTED = 72;
+private static final int LOCAL_Y_CONNECTED = 72;
+private static final int LOCAL_WIDTH_CONNECTED = 25;
+private static final int LOCAL_HEIGHT_CONNECTED = 25;
+// Remote video screen position
+private static final int REMOTE_X = 0;
+private static final int REMOTE_Y = 0;
+private static final int REMOTE_WIDTH = 100;
+private static final int REMOTE_HEIGHT = 100;
+
+private VideoRendererGui.ScalingType scalingType = VideoRendererGui.ScalingType.SCALE_ASPECT_FILL;
+private GLSurfaceView vsv;
+private VideoRenderer.Callbacks localRender;
+private VideoRenderer.Callbacks remoteRender;
+private WebRtcClient client;
+private String mSocketAddress;
+private String callerId;
+
+@Override
+public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    requestWindowFeature(Window.FEATURE_NO_TITLE);
+    getWindow().addFlags(
+            LayoutParams.FLAG_FULLSCREEN
+                    | LayoutParams.FLAG_KEEP_SCREEN_ON
+                    | LayoutParams.FLAG_DISMISS_KEYGUARD
+                    | LayoutParams.FLAG_SHOW_WHEN_LOCKED
+                    | LayoutParams.FLAG_TURN_SCREEN_ON);
+    setContentView(R.layout.main);
+    mSocketAddress = "http://" + getResources().getString(R.string.host);
+    mSocketAddress += (":" + getResources().getString(R.string.port) + "/");
+
+    // 获取GLSurfaceView 
+    vsv = (GLSurfaceView) findViewById(R.id.glview_call);
+    vsv.setPreserveEGLContextOnPause(true);
+    vsv.setKeepScreenOn(true);
+    // 设置给VideoRendererGui
+    VideoRendererGui.setView(vsv, new Runnable() {
+        @Override
+        public void run() {
+            init();
+        }
+    });
+
+    // 创建本地和远程的Render
+    // local and remote render
+    remoteRender = VideoRendererGui.create(
+            REMOTE_X, REMOTE_Y,
+            REMOTE_WIDTH, REMOTE_HEIGHT, scalingType, false);
+    localRender = VideoRendererGui.create(
+            LOCAL_X_CONNECTING, LOCAL_Y_CONNECTING,
+            LOCAL_WIDTH_CONNECTING, LOCAL_HEIGHT_CONNECTING, scalingType, true);
+
+    final Intent intent = getIntent();
+    final String action = intent.getAction();
+
+    if (Intent.ACTION_VIEW.equals(action)) {
+        final List<String> segments = intent.getData().getPathSegments();
+        callerId = segments.get(0);
+    }
+}
+
+......
+
+
+public void onLocalStream(MediaStream localStream) {
+	// 将Render添加到VideoTrack中
+    localStream.videoTracks.get(0).addRenderer(new VideoRenderer(localRender));
+    VideoRendererGui.update(localRender,
+            LOCAL_X_CONNECTING, LOCAL_Y_CONNECTING,
+            LOCAL_WIDTH_CONNECTING, LOCAL_HEIGHT_CONNECTING,
+            scalingType);
+}
+
+@Override
+public void onAddRemoteStream(MediaStream remoteStream, int endPoint) {
+    remoteStream.videoTracks.get(0).addRenderer(new VideoRenderer(remoteRender));
+    VideoRendererGui.update(remoteRender,
+            REMOTE_X, REMOTE_Y,
+            REMOTE_WIDTH, REMOTE_HEIGHT, scalingType);
+    VideoRendererGui.update(localRender,
+            LOCAL_X_CONNECTED, LOCAL_Y_CONNECTED,
+            LOCAL_WIDTH_CONNECTED, LOCAL_HEIGHT_CONNECTED,
+            scalingType);
+}
+
+@Override
+public void onRemoveRemoteStream(int endPoint) {
+    VideoRendererGui.update(localRender,
+            LOCAL_X_CONNECTING, LOCAL_Y_CONNECTING,
+            LOCAL_WIDTH_CONNECTING, LOCAL_HEIGHT_CONNECTING,
+            scalingType);
+}
+
+```
+
+#### `MediaConstraints`
+
+`MediaConstraints`是支持不同约束的`WebRTC`库方式的类，可以加载到`MediaStream`中的音频和视频轨道。对于大多数需要`MediaConstraints`的方法，一个简单的`MediaConstraints`实例就可以做到。
+
+```java
+private MediaConstraints pcConstraints = new MediaConstraints();
+......
+pcConstraints.mandatory.add(new MediaConstraints.KeyValuePair("OfferToReceiveAudio", "true"));
+pcConstraints.mandatory.add(new MediaConstraints.KeyValuePair("OfferToReceiveVideo", "true"));
+pcConstraints.optional.add(new MediaConstraints.KeyValuePair("DtlsSrtpKeyAgreement", "true"));
+
+......
+this.pc = factory.createPeerConnection(iceServers, pcConstraints, this);
+```
+
+#### `MediaStream`
+
+
+本地看见自己后接下来就要想办法让对方看见自己。我们需要自己创建`MediaStream`。
+接下来我们就研究如何添加本地的`VideoTrack`和`AudioTrack`来创建一个合适的`MediaStream`。
+代码还是在前面分析的`setCamera()`方法中:   
+```java
+private MediaStream localMS;
+
+private void setCamera(){
+	// 创建MediaStream
+	localMS = factory.createLocalMediaStream("ARDAMS");
+	if(pcParams.videoCallEnabled){
+	    MediaConstraints videoConstraints = new MediaConstraints();
+	    videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("maxHeight", Integer.toString(pcParams.videoHeight)));
+	    videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("maxWidth", Integer.toString(pcParams.videoWidth)));
+	    videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("maxFrameRate", Integer.toString(pcParams.videoFps)));
+	    videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("minFrameRate", Integer.toString(pcParams.videoFps)));
+
+	    videoSource = factory.createVideoSource(getVideoCapturer(), videoConstraints);
+	    // 添加VideoTrack
+	    localMS.addTrack(factory.createVideoTrack("ARDAMSv0", videoSource));
+	}
+
+	AudioSource audioSource = factory.createAudioSource(new MediaConstraints());
+	// 添加AudioTrack
+	localMS.addTrack(factory.createAudioTrack("ARDAMSa0", audioSource));
+
+	mListener.onLocalStream(localMS);
+}
+```
+
+我们现在有了包含视频流和音频流的`MediaStream`实例，而且在屏幕上显示了我们的预览画面。下面要做的就该把这些信息传送给对方了。
+这篇文章不会介绍如何建立自己的信号流，我们直接介绍对应的`API`方法，以及它们如何与`web`关联的。 `AppRTC`使用`autobahn`使得`WebSocket`连接到信号端。
+
+
+#### `PeerConnection`
+
+现在我们有了自己的`MediaStream`，就可以开始连接远端了。创建`PeerConnection`很简单，只需要`PeerConnectionFactory`的协助即可。    
+
+
+```java
+private PeerConnection pc;
+private PeerConnectionFactory factory;
+private LinkedList<PeerConnection.IceServer> iceServers = new LinkedList<>();
+
+
+iceServers.add(new PeerConnection.IceServer("stun:23.21.150.121"));
+iceServers.add(new PeerConnection.IceServer("stun:stun.l.google.com:19302"));
+
+this.pc = factory.createPeerConnection(iceServers, pcConstraints, this);
+```
+
+参数的作用如下：
+
+`iceServers`:连接到外部设备或者网络时需要用到这个参数。在这里添加STUN 和 TURN 服务器就允许进行连接，即使在网络条件很差的条件下。
+`constraints`:前面介绍的`MediaConstraints`的实例，应该包含`offerToRecieveAudio`和`offerToRecieveVideo`。
+`observer`:`PeerConnection.Observer`实例。
+
+`PeerConnection`和`web`上的对应`API`很相似，包含了`addStream`、`addIceCandidate`、`createOffer`、`createAnswer`、`getLocalDescription`、`setRemoteDescription`和其他类似方法。为了了解如何协调所有工作在两点之间建立起通讯通道，我们先看下下面的几个类:  
+
+
+#### `addStream`
+
+这个是用来将`MediaStream`添加到`PeerConnection`中的,如同它的命名一样。如果你想要对方看到你的视频、听到你的声音，就需要用到这个方法。
+
+#### `addIceCandidate`
+
+一旦内部`IceFramework`发现有`candidates`允许其他方连接你时，就会创建`IceCandidates`。当通过`PeerConnectionObserver.onIceCandidate`传递数据到对方时，需要通过任何一个你选择的信号通道获取到对方的`IceCandidates`。使用`addIceCandidate`添加它们到`PeerConnection`，以便`PeerConnection`可以通过已有信息试图连接对方。
+
+#### `createOffer/createAnswer`
+
+这两个方法用于原始通话的建立。在`WebRTC`中，已经有了`caller`和`callee`的概念，一个是呼叫，一个是应答。`createOffer`是`caller`使用的，它需要一个`sdpObserver`，它允许获取和传输会话描述协议`Session Description Protocol (SDP)`给对方，还需要一个`MediaConstraint`。一旦对方得到了这个请求，它将创建一个应答并将其传输给`caller`。`SDP`是用来给对方描述期望格式的数据（如`video`、`formats`、`codecs`、`encryption`、`resolution`、 `size`等）。一旦`caller`收到这个应答信息，双方就相互建立的通信需求达成了一致，如视频、音频、解码器等。
+
+#### `setLocalDescription/setRemoteDescription`
+
+这个是用来设置`createOffer`和`createAnswer`产生的`SDP`数据的，包含从远端获取到的数据。它允许内部`PeerConnection`配置链接以便一旦开始传输音频和视频就可以开始真正工作。
+
+#### `PeerConnection.Observer`
+
+这个接口提供了一种监测`PeerConnection`事件的方法，例如收到`MediaStream`时，或者发现`iceCandidates`时，或者需要重新建立通讯时。这个接口必须被实现，以便你可以有效处理收到的事件，例如当对方变为可见时，向他们发送信号`iceCandidates`。
+
+
+`WebRTC打开了人与人之间的通讯，对开发者免费，对终端用户免费。 它不仅仅提供了视频聊天，还有其他应用，比如健康服务、低延迟文件传输、种子下载、甚至游戏应用。
+想要看到一个真正的`WebRTC`应用实例，请下载[appear.in](https://play.google.com/store/apps/details?id=appear.in.app&referrer=utm_source=tech.appear.in&utm_medium=blog&utm_campaign=android-launch-may15)。它在浏览器和本地应用间运行的相当完美，在同一个房间内最多可以8个人免费使用。不需要安装和注册。
+
+
+最后总结一下: 
+
+直播用的主流协议:  
+
+- `RTMP`: (`Real Time Messaging Protocol`)实时消息传送协议是`Adobe Systems`公司为`Flash`播放器和服务器之间音频、视频和数据传输 开发的开放协议。目前直播的主流平台95%都是基于该协议做的。      
+
+    - 优点：成熟，稳定，效果好等等
+    - 缺点：有延迟，达不到实时互动等等
+
+- `WebRTC`: 名称源自网页实时通信（`Web Real-Time Communication`）的缩写，是一个支持网页浏览器进行实时语音对话或视频对话的技术，是谷歌2010年以6820万美元收购`Global IP Solutions`公司而获得的一项技术。2011年5月开放了工程的源代码，在行业内得到了广泛的支持和应用，成为下一代视频通话的标准。      
+
+    - 优点：实时互动，开发难度小等等
+    - 缺点：太实时，如果网络不好，视频质量会严重下降，体验不好；考研服务器等等
+
+
+
+那既然`WebRTC`这么好，那直接用来做直播不就好了。结果往往并没有想象中的那么完美。
+
+`WebRTC`整体的技术并不适合做直播。`WebRTC`设计的初衷只是为了在两个浏览器/`native app`之间解决直接连接发送`media streaming/data`数据的，也就是所谓的`peer to peer`的通信，大多数的情况下不需要依赖于服务器的中转，因此一般在通信的逻辑上是一对一。而我们现在的直播服务大部分的情况下是一对多的通信，一个主播可能会有成千上万个接收端，这种方式用传统的`P2P`来实现是不可能的，所以目前直播的方案基本上都是会有直播服务器来做中央管理，主播的数据首先发送给直播服务器，直播服务器为了能够支持非常多用户的同事观看，还要通过边缘节点`CDN`的方式来做地域加速，所有的接收端都不会直接连接主播，而是从服务器上接收数据。
+
+`WebRtc`只适合小范围（8人以内）音视频会议，不适合做直播：
+1. 视频部分：vpx的编码器太弱，专利原因不能用264，做的好的都要自己改264/265代码才行。
+2. 音频部分：音频只适合人声编码，对音乐和其他非人声的效果很糟糕。
+3. 网络部分：对国内各种奇葩网络适应性太低，网络糟糕点或者人多点就卡。
+4. 信号处理：同时用过`GIPS`和`WebRTC`进行对比，可以肯定目前开源的代码是`GIPS`阉割过的。
+5. 使用规模：10人以内使用，超过10人就挂了，
+
+现在的直播服务器请使用`nginx rtmp-module`架设，架设好了用`ffmpeg`命令行来测试播摄像头。主播客户端请使用`rtmp`进行推流给`rtmp-module`，粉丝请使用`rtmp/flv+http stream`进行观看，`PC-web`端的粉丝请使用`Flash NetStream`来观看，移动`web`端的粉丝请使用`hls/m3u8`来观看。如果你试验成功要上线了，出现压力了，那么把`nginx`分层（接入层+交换层），稍微改两行代码，如果资金不足以全国部署服务器，那么把`nginx-rtmp-module`换为`cdn`的标准直播服务，也可以直接调过`nginx`，一开始就用`cdn`的直播服务，比如网宿（斗鱼的直播服务提供商）。这是正道，别走弯路了。
+
+那既然`WebRTC`不适合做直播，还写这么多干啥，`WebRTC`内部包含的技术模块是非常适合解决直播过程中存在的各种问题的，而且应该在大多数直播技术框架中都已经得到了部分应用，例如音视频数据的收发、音频处理回音消除降噪等。所以综上，可以使用`WebRTC`内部的技术模块来解决直播过程中存在的技术问题，但是不适合直接用`WebRTC`来实现直播的整体框架。
+
+
+参考: 
+
+- [Introduction to WebRTC on Android](https://tech.appear.in/2015/05/25/Introduction-to-WebRTC-on-Android/)   
+- [Android WebRTC 编译](https://webrtc.org/native-code/android/)
+- [Android WebRTC开源项目](https://github.com/pchab/AndroidRTC)
+- [ProjectRTC](https://github.com/pchab/ProjectRTC)
+- [Getting Started with WebRTC](https://www.html5rocks.com/en/tutorials/webrtc/basics/)
+- [WebRTC Github](https://github.com/webrtc)
+- [WebRTC GoogleSource](https://chromium.googlesource.com/external/webrtc)
+- [Android WebRTC](https://webrtc.org/native-code/android/)
+- [Samples](https://github.com/webrtc/samples/)
+- [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/Media_Streams_API)
+- [WebRTC适合做直播吗？](https://www.zhihu.com/question/25497090)
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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"
new file mode 100644
index 00000000..ff862a6c
--- /dev/null
+++ "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"
@@ -0,0 +1,27 @@
+AudioTrack简介
+---
+
+Android系统提供了三种播放音频文件的方式:  
+
+- SoundPoll:适合播放短促且对反应速度要求比较高的情况(如游戏音效、按键声等)
+- 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进行混音，然后才传递给硬件播放。 
+
+
+AudioTrack播放声音时不能直接把WAV文件传递给AudioTrack进行播放，必须传递buffer，通过write函数把需要播放的缓冲区buffer传递给AudioTrack，然后才能播放。
+
+
+上面一直说PCM，那PCM究竟是啥?
+
+简单的说，PCM是一种数据编码格式，CD唱片上刻录的就是直接用PCM格式编码的数据文件，WAV是一种声音文件格式，WAV里面包含的声音数据可以是采用PCM格式编码的声音数据，也可以是采用其他格式编码的声音数据，但是目前一般采用PCM编码的声音数据两者之间的区别就是:PCM是一个通信上的概念，脉冲编码调制。WAV是媒体概念，体现的是封装。WAV文件可以封装PCM编码信息，也可以封装其他编码格式，例如MP3等。
+
+
+
+AudioTrack类可以完成Android平台上音频数据的输出任务。AudioTrack有两种数据加载模式:   
+
+- MODE_STREAM:通过write一次次把音频数据写到AudioTrack中。和平时通过write系统调用往文件中写数据类似，但是这种工作方式每次都需要把数据从用户提供的Buffer中拷贝到AudioTrack中的Buffer，这样会在一定程度上引入延迟，为了解决这个问题，AudioTrack引入了第二种方式。 
+- MODE_STATIC:这种模式下，在play之前只需要把所有数据通过一次write调用传递到AudioTrack中的内部缓冲区，后续就不必再传递数据。这种模式适用于铃声这种内存占用小，延时要求高的文件，但是它也有一个缺点，就是一次write的数据不能太多，否则系统无法分配足够的内存来存储全部数据。
+
+
+
+
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
diff --git "a/Android\345\237\272\347\241\200/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 99%
rename from "Android\345\237\272\347\241\200/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"
index 7c555536..cbf52924 100644
--- "a/Android\345\237\272\347\241\200/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"
@@ -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也是比较像的。
@@ -92,7 +92,7 @@ DLNA架构分为如下图7个层次：
 
 3. Device Discovery&Control 设备发现和控制。 
 	这一层是DLNA的基础协议框架。**DLNA用UPnP协议来实现设备的发现和控制**。下面重点看一下UPnP。    
-	`UPnP`，英文是`Universal Plug and play`，翻译过来就是通用即插即用。UPnP最开始Apple和Microsoft在搞，后来Apple不做了(这里多一嘴，为什么Apple不做了，因为Apple现在出了个)，Microsoft还在继续做，Intel也加进来做，Sony，Moto等等也有加入。UPnP有个网站http://www.upnp.org/，我们发现DLNA的网页和UPnP的网页很像，颜色也差不多，就可以知道他们关系很好了。DNLA主要是在推UPnP。  
+	`UPnP`，英文是`Universal Plug and play`，翻译过来就是通用即插即用。UPnP最开始Apple和Microsoft在搞，后来Apple不做了(这里多一嘴，为什么Apple不做了，因为Apple现在出了个)，Microsoft还在继续做，Intel也加进来做，Sony，Moto等等也有加入。UPnP有个网站[http://www.upnp.org/](http://www.upnp.org/)，我们发现DLNA的网页和UPnP的网页很像，颜色也差不多，就可以知道他们关系很好了。DNLA主要是在推UPnP。  
 
 	微软官方网站对UPnP的解释：通用即插即用 (UPnP) 是一种用于 PC 机和智能设备（或仪器）的常见对等网络连接的体系结构，尤其是在家庭中。UPnP 以 Internet 标准和技术（例如 TCP/IP、HTTP 和 XML）为基础，使这样的设备彼此可自动连接和协同工作，从而使网络（尤其是家庭网络）对更多的人成为可能。
     举个例子。我们在自己的PC（win7）里面打开网络服务的UPnP选项，然后再家庭网络中共享一个装着视频的文件夹，然后买一台SmartTV回来打开就可以找到这台PC的共享文件夹，然后就直接在电视上选文件播放了。
@@ -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/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"
new file mode 100644
index 00000000..204676f3
--- /dev/null
+++ "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,37 @@
+# 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一起使用。 
+
+
+MediaCodec可以处理原始的音视频数据，包括编码(将原始数据转换为压缩格式)和解码(将压缩格式转换为原始数据)。    
+
+
+
+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只能用于读取已经完成的音视频文件，无法用于实时处理音视频数据流。
+
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"
new file mode 100644
index 00000000..23739606
--- /dev/null
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md"
@@ -0,0 +1,162 @@
+SurfaceView与TextureView
+===
+
+
+Android系统中图形系统是相当复杂的，包括WindowManager、SurfaceFlinger、OpenGL等。     
+
+其中SurfaceFlinger(表面合成器或表面渲染器)作为负责绘制应用UI的核心。
+
+但是不论使用什么渲染API，所有的东西最终都渲染到Surface上，Android平台所创建的Window都由Surface所支持，所有可见的Surface渲染到显示设备都是通过SurfaceFlinger来完成。    
+
+
+
+
+
+### `Surface`简介
+
+- `Surface`就是“表面”的意思，可以简单理解为内存中的一段绘图缓冲区。
+
+    在`SDK`的文档中，对`Surface`的描述是这样的：“`Handle onto a raw buffer that is being managed by the screen compositor`”，
+    翻译成中文就是“由屏幕显示内容合成器`(screen compositor)`所管理的原生缓冲器的句柄”，   这句话包括下面两个意思:     
+
+    - 通过`Surface`（因为`Surface`是句柄）就可以获得原生缓冲器以及其中的内容。就像在`C`语言中，可以通过一个文件的句柄，就可以获得文件的内容一样；
+    - 原生缓冲器（`rawbuffer`）是用于保存当前窗口的像素数据的。
+
+- 简单的说`Surface`对应了一块屏幕缓冲区，每个`Window`对应一个`Surface`，任何`View`都是画在`Surface`上的，传统的`view`共享一块屏幕缓冲区，所有的绘制必须在`UI`线程中进行
+- 我们不能直接操作`Surface`实例，要通过`SurfaceHolder`，在`SurfaceView`中可以通过`getHolder()`方法获取到`SurfaceHolder`实例。
+- `Surface`是一个用来画图形的地方，但是我们知道画图都是在一个`Canvas`对象上面进行的，*`Surface`中的`Canvas`成员，是专门用于提供画图的地方，就像黑板一样，其中的原始缓冲区是用来保存数据的地方，
+    `Surface`本身的作用类似一个句柄，得到了这个句柄就可以得到其中的`Canvas`、原始缓冲区以及其他方面的内容，所以简单的说`Surface`是用来管理数据的(句柄)*。
+    
+
+Surface是一个绘制目标，可以被系统的SurfaceFlinger直接合成显示在屏幕上。    
+
+### `SurfaceView`简介      
+
+- 简单的说`SurfaceView`就是一个有`Surface`的`View`里面内嵌了一个专门用于绘制的`Surface`,`SurfaceView`控制这个`Surface`的格式和尺寸以及绘制位置。
+
+SurfaceView就是在Window上挖一个洞，它就是显示在这个洞里，其他的View是显示在Window上，所以View可以显式在 SurfaceView之上，你也可以添加一些层在SurfaceView之上。
+
+```java
+if (mWindow == null) {  ß
+    mWindow = new MyWindow(this);  
+    mLayout.type = mWindowType;  
+    mLayout.gravity = Gravity.LEFT|Gravity.TOP;  
+    mSession.addWithoutInputChannel(mWindow, mWindow.mSeq, mLayout,  
+    mVisible ? VISIBLE : GONE, mContentInsets);  
+}  
+```
+很明显，每个`SurfaceView`创建的时候都会创建一个`MyWindow`，`new MyWindow(this)`中的`this`正是`SurfaceView`自身，因此将`SurfaceView`和`window`绑定在一起，而前面提到过每个`window`对应一个`Surface`，
+所以`SurfaceView`也就内嵌了一个自己的`Surface`，可以认为`SurfaceView`是来控制`Surface`的位置和尺寸。传统`View`及其派生类的更新只能在`UI`线程，然而`UI`线程还同时处理其他交互逻辑，
+这就无法保证`view`更新的速度和帧率了，而`SurfaceView`可以用独立的线程来进行绘制，因此可以提供更高的帧率，例如游戏，摄像头取景等场景就比较适合用`SurfaceView`来实现。
+
+- `Surface`是纵深排序`(Z-ordered)`的，这表明它总在自己所在窗口的后面。
+- `Surfaceview`提供了一个可见区域，只有在这个可见区域内的`Surface`部分内容才可见，可见区域外的部分不可见，所以可以认为**`SurfaceView`就是展示`Surface`中数据的地方**,`Surface`就是管理数据的地方，
+    `SurfaceView`就是展示数据的地方，只有通过`SurfaceView`才能展现`Surface`中的数据。           
+    ![image](https://github.com/CharonChui/Pictures/blob/master/SurfaceView.png?raw=true)   
+
+
+- `Surface`的排版显示受到视图层级关系的影响，它的兄弟视图结点会在顶端显示。这意味者`Surface`的内容会被它的兄弟视图遮挡，这一特性可以用来放置遮盖物`(overlays)`(例如，文本和按钮等控件)。
+    注意，如果`Surface`上面有透明控件，那么它的每次变化都会引起框架重新计算它和顶层控件的透明效果，这会影响性能。`surfaceview`变得可见时，`surface`被创建；`surfaceview`隐藏前，`surface`被销毁。
+    这样能节省资源。如果你要查看`surface`被创建和销毁的时机，可以重载`surfaceCreated(SurfaceHolder)`和`surfaceDestroyed(SurfaceHolder)`。
+    **`SurfaceView`的核心在于提供了两个线程：`UI`线程和渲染线程**,两个线程通过“双缓冲”机制来达到高效的界面适时更新。而这个双缓冲可以理解为，SurfaceView在更新视图时用到了两张Canvas，一张frontCanvas和一张backCanvas。每次实际显示的是frontCanvas，backCanvas存储的是上一次更改前的视图，当使用lockCanvas（）获取画布时，得到的实际上是backCanvas而不是正在显示的frontCanvas，之后你在获取到的backCanvas上绘制新视图，再unlockCanvasAndPost（canvas）此视图，那么上传的这张canvas将替换原来的frontCanvas作为新的frontCanvas，原来的frontCanvas将切换到后台作为backCanvas。例如，如果你已经先后两次绘制了视图A和B，那么你再调用lockCanvas（）获取视图，获得的将是A而不是正在显示的B，之后你将重绘的C视图上传，那么C将取代B作为新的frontCanvas显示在SurfaceView上，原来的B则转换为backCanvas。()
+    不用画布，直接在窗口上进行绘图叫做无缓冲绘图。用了一个画布，将所有内容都先画到画布上，在整体绘制到窗口上，就该叫做单缓冲绘图，那个画布就是一个缓冲区。用了两个画布，一个进行临时的绘图，一个进行最终的绘图，这样就叫做双缓冲。)
+
+
+SurfaceView的优缺点:     
+
+一般的Activity包含的多个View会组成View hierachy的树形结构，只有最顶层的DectorView才是对WMS可见的，这个DecorView在WMS中有一个对应的WindowState，再SurfaceFlinger中有对应的Layer，而SurfaceView正因为它有自己的Surface，有自己的Window，它在WMS中有对应的WindowState，在SurfaceFlinger中有Layer。虽然在App端它仍在View hierachy中，但在Server端(WMS和SurfaceFlinger)中，它与宿主窗口是分离的。这样的好处是对这个Surface的渲染可以放到单独的线程中去做，渲染时可以有自己的GL context。因为它不会影响主线程对时间的响应。所以它的优点就是可以在独立的线程中绘制，不影响主线程，而且使用双缓冲机制，播放视频时画面更顺畅。但是这也有缺点，因为这个Surface不在View hierachy中，它的显示也不受View的属性控制，所以不能进行平移、缩放等动画，它也不能放在其它ViewGroup中，SurfaceView不能嵌套使用，而且不能使用某些View的特性，例如View.setAlpha()。
+
+
+***从Android7.0开始，SurfaceView的窗口位置与其他View渲染同步更新。 这意味着在屏幕上平移和缩放SurfaceView不会导致渲染失真。***
+
+
+### `SurfaceHolder`简介
+
+显示一个`Surface`的抽象接口，使你可以控制`Surface`的大小和格式以及在`Surface`上编辑像素，和监视`Surace`的改变。这个接口通常通过`SurfaceView`类实现。
+简单的说就是我们无法直接操作`Surface`只能通过`SurfaceHolder`这个接口来获取和操作`Surface`。
+`SurfaceHolder`中提供了一些`lockCanvas()`:获取一个`Canvas`对象，并锁定之。所得到的`Canvas`对象，其实就是`Surface`中一个成员。加锁的目的其实就是为了在绘制的过程中，
+`Surface`中的数据不会被改变。`lockCanvas`是为了防止同一时刻多个线程对同一`canvas`写入。
+
+
+*从设计模式的角度来看,`Surface、SurfaceView、SurfaceHolder`实质上就是`MVC(Model-View-Controller)`，`Model`就是模型或者说是数据模型，更简单的可以理解成数据，在这里也就是`Surface`，
+`View`就是视图，代表用户交互界面，这里就是`SurfaceView`,`SurfaceHolder`就是`Controller.`*
+
+
+## TextureView
+
+因为上面所说的SurfaceView不在主窗口中，它没法做动画没法使用一些View的特性方法，所以在Android 4.0中引入了TextureView，它是一个结合了View和SurfaceTexture的View对象。它不会在WMS中单独创建窗口，而是作为View hierachy中的一个普通view，因此它可以和其他普通View一样进行平移、旋转等动画。但是TextureView必须在硬件加速的窗口中，它显示的内容流数据可以来自App进程或者远程进程。    
+
+TextureView重载了draw()方法，其中主要SurfaceTexture中收到的图像数据作为纹理更新到对应的HardwareLayer中。
+
+SurfaceTexture.OnFrameAvailableListener用于通知TextureView内容流有新图像到来。SurfaceTextureListener接口用于让TextureView的使用者知道SurfaceTexture已准备好，这样就可以把SurfaceTexture交给相应的内容源。Surface为BufferQueue的Producer接口实现类，使生产者可以通过它的软件或硬件渲染接口为SurfaceTexture内部的BufferQueue提供graphic buffer。
+
+SurfaceTexture可以用作非直接输出的内容流，这样就提供二次处理的机会。与SurfaceView直接输出相比，这样会有若干帧的延迟。同时，由于它本身管理BufferQueue，因此内存消耗也会稍微大一些。
+TextureView是一个可以把内容流作为外部纹理输出在上面的View, 它本身需要是一个硬件加速层。
+
+### SurfaceTexture
+
+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上做绘制，可以是用户提供的线程，而不是系统的主线程或是渲染线程。
+
+
+与 SurfaceView 相比，TextureView 具有更出色的 Alpha 版和旋转处理能力，但在视频上以分层方式合成界面元素时，SurfaceView 具有性能方面的优势。当客户端使用 SurfaceView 呈现内容时，SurfaceView 会为客户端提供单独的合成层。如果设备支持，SurfaceFlinger 会将单独的层合成为硬件叠加层。当客户端使用 TextureView 呈现内容时，界面工具包会使用 GPU 将 TextureView 的内容合成到 View 层次结构中。对内容进行的更新可能会导致其他 View 元素重绘，例如，如果其他 View 位于 TextureView 上方。View 呈现完成后，SurfaceFlinger 会合成应用界面层和所有其他层，以便每个可见像素合成两次。
+
+***注意：受 DRM 保护的视频只能在叠加平面上呈现。支持受保护内容的视频播放器必须使用 SurfaceView 进行实现。***
+
+| 项目        |  SurfaceView   |  TextureView  |
+| --------   | -----:  | :----:  |
+| 内存      |  低   |   高     |
+| 耗电        |   低   |   高   |
+| 绘制        |    及时    |  1-3帧延迟  |
+| 动画和截图        |    不支持    |  支持  |
+
+
+
+- 在android 7.0上系统surfaceview的性能比TextureView更有优势，支持对象的内容位置和包含的应用内容同步更新，平移、缩放不会产生黑边。 - 在7.0以下系统如果使用场景有动画效果，可以选择性使用TextureView
+- 由于失效(invalidation)和缓冲的特性，TextureView增加了额外1~3帧的延迟显示画面更新
+- TextureView总是使用GL合成，而SurfaceView可以使用硬件overlay后端，可以占用更少的内存
+- TextureView的内部缓冲队列导致比SurfaceView使用更多的内存
+- SurfaceView： 内部自己持有surface，surface 创建、销毁、大小改变时系统来处理的，通过surfaceHolder 的callback回调通知。当画布创建好时，可以将surface绑定到MediaPlayer中。SurfaceView如果为用户可见的时候，创建SurfaceView的SurfaceHolder用于显示视频流解析的帧图片，如果发现SurfaceView变为用户不可见的时候，则立即销毁SurfaceView的SurfaceHolder，以达到节约系统资源的目的
+
+
+
+
+​    
+---
+
+- 邮箱 ：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/\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"
new file mode 100644
index 00000000..a77a4510
--- /dev/null
+++ "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"
@@ -0,0 +1,155 @@
+播放器性能优化
+===
+
+播放器相关问题:   
+- 业务耦合
+- 成功率低
+- 不支持边下边播，缓冲时间长
+- 成本优化
+- 问题定位难
+
+
+
+### 成本优化
+
+#### 预下载控制
+
+- 不限速
+- 非高峰时段，预下载N秒
+- 高峰时段，预下载M秒
+- 高峰期动态码率
+
+#### H265
+
+- 压缩率提升 30%
+- 相比H264,编码复杂度提升4倍，更消耗系统资源
+- 编码时间更长
+
+通过软解可以支持，但是CPU会占用较高，而且发热和耗电。
+对解码能力进行评估，来通过机型打分控制是否使用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 毫秒，这是非常可观的提升。最后测试下来，也是此优化项对于缓存命中率的提升是最为明显的。
+
+- 多播放器
+
+    空间换时间。双播放器方案原理比较简单，就是在当前视频起播之后，预准备下一个视频的播放器，两个播放器循环使用。下一个视频的播放器一旦准备好，加上视频流已加载到本地，则起播非常快，几乎是视频直出的效果。但由于播放器准备更耗时，用户滑到下一个视频时，并不能百分百保证此视频的播放器已准备好。
+
+### 预取策略
+
+1. 修改AndroidVideoCache进行预加载
+2. 线程池并发缓存并控制视频缓存优先级（线程池线程数为3，先加入的先缓存），一次预加载8个视频，item创建时开始预加载，item销毁时，取消预加载
+3. 等待下页第一个视频预加载完成，才会进入下一页视频，保证滑到的视频都是可以立马观看的。（一页视频为8个）
+4. 当前视频开始播放之后才会进行预加载
+5. 区分快滑慢滑两种模式，快滑时取消当前所有预加载，慢滑不取消，因为快滑大概率滑到一个未预加载的视频，慢滑大概率滑到一个已经预加载的视频，保证滑到视频尽快播放。
+6. 当视频播放后，根据滑动方向，会将取消的预加载进行恢复，正向滑动就恢复当前之后之后的预加载任务，反选滑动就恢复当前视频之前的预加载任务。
+7. 限制网速，当时视频还没播放的时候，会限制预下载的网速（慢滑不会取消预加载），通过让下载线程sleep来限制网速。
+8. ijkplayer起播参数配置。
+9. 视频压缩和处理（让视频参数都位于视频首部）。
+
+
+
+#### MOOV后置
+
+很多手机为了偷懒，录制完视频后才知道视频信息，所以把moov放到末尾。对于moov放到视频最后的情况下，就要多一次seek，当从头开始解析的时候如果发现未找到moov信息，需要将其seek到尾部再去寻找，这样会导致起播慢。 
+
+针对这种情况可以采用后台做转码修复，客户端增加监控打点。
+
+解析完MOOV后需要下载多少数据才可以起播呢？ 
+
+- Android 6.0及以下 : 5秒视频数据
+- Android 7.0及以上 : 一个GOP
+- FFmpeg Based Player : 关键帧
+
+播放端识别首个关键帧即启动播放，或者通过减小GOP间隔来提高加载速度；也是可以达到的。
+
+#### Http DNS
+
+有关DNS相关可参考[DNS及HTTPDNS](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/DNS%E5%8F%8AHTTPDNS.md)     
+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)指标连接则更可以直观地反应出成效。
+不断优化表现直接与收入关联的主要原因是，收入统计通常计出多门且较为滞后，可采用的替代指标包括注册用户数、活跃用户数、视频观察市场、观看次数、播放占比、付费率、留存率、分享率、满意度等。
+
+
+### 监控
+
+监控上报，肯定是不可缺少的，这是一个成熟的项目必备的要素。
+
+1. 问题定位，老板跟用户反馈说我这个视频播不了，要有一套成熟的问题定位的方式；
+    传统的捞Log方式大家都有，但是这种方式效率太低，需要等用户上线之后才能捞到Log，Log捞到之后还得花时间去分析。我们做法的是在关键问题上做一些插装，把每一类错误和每一个具体的子错误都能定义出来，这样一看错误码就知道播放错误是由什么原因导致的。还可以把每次播放视频的链路所有关键流水上报到统计系统里来，每一次播放都是一组流水，每一条流水里面就包含了例如首次缓冲发生的Seek，或下载的链接是多少，下载的时间是多少，有了这些流水之后，用户反馈播放失败，我首先可以用流水看发生了什么错误？错误在哪一步？每一步信息是什么？几秒钟就可以定位到问题。
+
+有了这个数据上报之后，还可以做一些报表。比如说可以做错误码的报表，有了报表之后就可以跟进哪个错误是在TOP的，负责人是谁，原因是什么，都可以看到。
+
+我们也有自己实时的曲线，可以看到各项数据的情况。在告警方面，基于成功率和失败率的统计，进行实时告警。
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Android\345\212\240\345\274\272/\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 63%
rename from "Android\345\212\240\345\274\272/\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"
index bbeff659..94721c34 100644
--- "a/Android\345\212\240\345\274\272/\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/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/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/CDN\345\217\212PCDN.md" "b/VideoDevelopment/CDN\345\217\212PCDN.md"
new file mode 100644
index 00000000..bc9d8c36
--- /dev/null
+++ "b/VideoDevelopment/CDN\345\217\212PCDN.md"
@@ -0,0 +1,291 @@
+CDN及PCDN
+===
+
+![image](https://github.com/CharonChui/Pictures/blob/master/cdn.png?raw=true)
+
+## CDN
+
+CDN(Content Delivery Network或Content Ddistribute Network):内容分发网络也称为内容传送网络。
+是指一种透过互联网互相连接的电脑网络系统，利用最靠近每位用户的服务器，更快、更可靠地将音乐、图片、影片、
+应用程序及其他文件发送给用户，来提供高性能、可扩展性及低成本的网络内容传递给用户。
+这个概念始于1996年，是美国麻省理工学院的一个研究小组为改善互联网的服务质量而提出的。
+为了能在传统IP网上发布丰富的宽带媒体内容，他们提出在现有互联网基础上建立一个内容分发平台专门为网站提供
+服务，并于1999年成立了专门的CDN服务公司，为Yahoo提供专业服务。由于CDN是为加快网络访问速度而被优化的
+网络覆盖层，因此被形象地称为“网络加速器”。    
+
+
+- 举个栗子:  
+
+大学的时候宿舍里面有一个同学A翻墙去东京看一个比较热的电影，日本人访问那个网站的时候，速度就会很快。
+但是我在中国，当我去访问网站的时候速度就会很慢。这是由于地域的限制，中间隔了很多很多的网络，
+导致我访问很慢。所有同学A想要把这个电影下载下来再看。结果宿舍内的其他同学BCD发现这个电影挺好看，
+他也想看这个电影，如果同学BCD直接去该网站上下载这个电影，那速度肯定是奇慢无比。
+但是如果同学A先把这个电影缓存下来，然后同学BCD可以直接通过内网来从同学A缓存的电影进行下载，
+这样既不占用访问外网的带宽，也对目标网站的服务器压力小了很多，同时也大大的提高了速度。      
+
+这种把一个视频从比较远的服务器中，缓存下来，放到离用户比较近的地方，让他们可以就近获取，
+更快速，这就是CDN,那个缓存视频的同学A就是一个CDN节点。
+
+还有一个现实中的例子，我感觉是对CDN原理的最佳应用:      
+打个比方我想买一个手表，我先去淘宝上找了一个第三方的卖家，看了下价格，问了一下从哪发货啊，
+是什么快递啊，他告诉我从深圳发货。到你那三天，因为他这个发货地点一般就是一个。
+而我在京东上面的话，京东在全国各地都有仓库，他会根据你的位置,在全国范围内找离你最近、
+送达最快的仓库，京东的这种仓储系统，就是类似CDN的作用。    
+
+
+### 组成
+
+CDN网络中包含的功能实体包括以下部分:    
+- 内容缓存:CDN网络节点，位于用户接入点，是面向最终用户的内容提供设备，可缓存静态Web内容和流媒
+体内容，实现内容的边缘传播和存储，以便用户的就近访问。它借助于建立索引、缓存、流分裂、组播（Multicast）等技术，将内容发布或投递到距离用户最近的远程服务点（POP）处。
+内容分发包含从内容源到CDN边缘的Cache的过程。从实现上，有两种主流的内容分发技术：PUSH和PULL。
+PUSH是一种主动分发的技术。通常，PUSH由内容管理系统发起，将内容从源或者中心媒体资源库分发到各边缘的Cache节点。分发的协议可以采用Http/ftp等。通过PUSH分发的内容一般是比较热点的内容，
+这些内容通过PUSH方式预分发到边缘Cache，可以实现有针对的内容提供。
+对于PUSH分发需要考虑的主要问题是分发策略，即在什么时候分发什么内容。一般来说，
+内容分发可以由CP（内容提供商）或者CDN内容管理员人工确定，也可以通过智能的方式决定，
+即所谓的智能分发，它根据用户访问的统计信息，以及预定义的内容分发的规则，确定内容分发的过程。PULL是一种被动的分发技术，PULL分发通常由用户请求驱动。当用户请求的内容在本地的边缘 Cache上不存在（未命中）时，Cache启动PULL方法从内容源或者其他CDN节点实时获取内容。在PULL方式下，内容的分发是按需的。
+- 内容交换机:处于用户接入集中点，可以均衡单点多个内容缓存设备的负载，并对内容进行缓存负载平衡及访问控制。
+- 内容路由器:负责将用户的请求调度到适当的设备上。它是整体性的网络负载均衡技术，通过内容路由器中的重定向（DNS）机制，在多个远程POP上均衡用户的请求，
+以使用户请求得到最近内容源的响应。CDN负载均衡系统实现CDN的内容路由功能。它的作用是将用户的请求导向
+整个CDN网络中的最佳节点。最佳节点的选定可以根据多种策略，例如距离最近、节点负载最轻等。
+负载均衡系统是整个CDN的核心，负载均衡的准确性和效率直接决定了整个CDN的效率和性能。
+通常负载均衡可以分为两个层次:全局负载均衡（GSLB）和本地负载均衡（SLB）。全局负载均衡主要的目的是在整
+个网络范围内将用户的请求定向到最近的节点（或者区域）。因此，就近性判断是全局负载均衡的主要功能。
+本地负载均衡一般局限于一定的区域范围内，其目标是在特定的区域范围内寻找一台最适合的节点提供服务，
+因此，CDN节点的健康性、负载情况、支持的媒体格式等运行状态是本地负载均衡进行决策的主要依据。
+- 内容管理系统:负责整个CDN的管理，它通过内部和外部监控系统，获取网络部件的状况信息，测量内容发布的
+端到端性能（如包丢失、延时、平均带宽、启动时间、帧速率等），保证网络处于最佳的运行状态。内容管理在
+广义上涵盖了从内容的发布、注入、分发、调整、传递等一系列过程。在这里，内容管理重点强调内容进人Cache
+点后的内容管理，称其为本地内容管理。本地内容管理主要针对一个CDN节点（有多个CDN Cache设备和一个
+SLB设备构成）进行。本地内容管理的主要目标是提高内容服务的效率，提高本地节点的存储利用率。
+通过本地内容管理，可以在CDN节点实现基于内容感知的调度，通过内容感知的调度，可以避免将用户重定向到没有
+该内容的 Cache设备上，从而提高负载均衡的效率。通过本地内容管理还可以有效实现在CDN节点内容的存储共享，
+提高存储空间的利用率。
+
+
+### 功能
+
+
+使用CDN的第一个也是最重要的原因：加速网站的访问。   
+
+对于TCP传输而言，TCP的速度会受到延迟时间与数据包漏失率影响。为了改善这些负面因素，
+内容分发网络通常会指派较近、较顺畅的服务器节点将数据传输给用户。虽然距离并不是绝对因素，
+但这么做可以尽可能提高性能，用户将会觉得比较顺畅。这使得一些比较高带宽的应用（传输高清影片）更容易推动。
+
+归纳起来，CDN具有以下主要功能:         
+1. 实现跨运营商、跨地域的全网覆盖    
+互联不互通、区域ISP地域局限、出口带宽受限制等种种因素都造成了网站的区域性无法访问。
+CDN加速可以覆盖全球的线路，通过和运营商合作，部署IDC资源，在全国骨干节点上，合理部署CDN边缘
+分发存储节点，充分利用带宽资源，平衡源站流量，这样可以节省骨干网带宽，减少带宽需求量并能
+解决由于用户访问量大造成的服务器过载问题。    
+2. 保障网站安全      
+CDN的负载均衡和分布式存储技术，可以加强网站的可靠性，相当无无形中给你的网站添加了一把保护伞，
+应对绝大部分的互联网攻击事件。防攻击系统也能避免网站遭到恶意攻击。    
+3. 为了异地备援       
+当某个服务器发生意外故障时，系统将会调用其他临近的健康服务器节点进行服务，进而提供接近100%的可靠性，
+这就让你的网站可以做到永不宕机。    
+4. 为了节约成本投入     
+使用CDN加速可以实现网站的全国铺设，你根本不用考虑购买服务器与后续的托管运维，服务器之间镜像同步，
+也不用为了管理维护技术人员而烦恼，节省了人力、精力和财力。
+
+### 特点
+
+- 本地Cache加速：提高了企业站点（尤其含有大量图片和静态页面站点）的访问速度，
+并大大提高以上性质站点的稳定性。 
+- 镜像服务：消除了不同运营商之间互联的瓶颈造成的影响，实现了跨运营商的网络加速，保证不同网络中的用户
+都能得到良好的访问质量。
+- 远程加速：远程访问用户根据DNS负载均衡技术智能自动选择Cache服务器，选择最快的Cache服务器，
+加快远程访问的速度。
+- 带宽优化：自动生成服务器的远程Mirror（镜像）cache服务器，远程用户访问时从cache服务器上读取数据，
+减少远程访问的带宽、分担网络流量、减轻原站点WEB服务器负载等功能。
+- 集群抗攻击：广泛分布的CDN节点加上节点之间的智能冗余机制，可以有效地预防黑客入侵以及降低各
+种D.D.o.S攻击对网站的影响，同时保证较好的服务质量。
+
+### 原理 
+
+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节点，主要的流程如下:     
+
+1. 当用户点击网站页面上的内容URL，经过本地DNS系统解析，DNS系统会最终将域名的解析权交给CNAME指向的CDN专用DNS服务器。
+2. CDN的DNS服务器将CDN的全局负载均衡设备IP地址返回用户。
+3. 用户向CDN的全局负载均衡设备发起内容URL访问请求。
+4. CDN全局负载均衡设备根据用户IP地址，以及用户请求的内容URL，选择一台用户所属区域的区域负载均衡设备，告诉用户向这台设备发起请求。
+5. 区域负载均衡设备会为用户选择一台合适的缓存服务器提供服务，选择的依据包括：根据用户IP地址，
+判断哪一台服务器距用户最近；根据用户所请求的URL中携带的内容名称，判断哪一台服务器上有用户所需内容；查询各个服务器当前的负载情况，判断哪一台服务器尚有服务能力。基于以上这些条件的综合分析之后，
+区域负载均衡设备会向全局负载均衡设备返回一台缓存服务器的IP地址。
+6. 全局负载均衡设备把服务器的IP地址返回给用户。
+7. 用户向缓存服务器发起请求，缓存服务器响应用户请求，将用户所需内容传送到用户终端。如果这台缓存服务器上并没有用户想要的内容，而区域均衡设备依然将它分配给了用户，那么这台服务器就要向它的上一级缓存服务器请求内容，直至追溯到网站的源服务器将内容拉到本地。
+
+### 网站接入CDN
+
+使用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
+
+PCDN:(P2P技术和CDN的融合创新)，下面是[阿里云PCDN](https://help.aliyun.com/product/54287.html)
+的介绍:P2P内容分发网络（英文名：P2P CDN，简称PCDN）是以P2P技术为基础，通过挖掘利用电信边缘网络
+海量碎片化闲置资源而构建的低成本高品质内容分发网络服务。客户通过集成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缓存节点，
+提供服务并赚取积分，而积分可兑换现金红包、特定商品或服务。     
+
+P2P技术则是打破了传统的Client/Server模式，是一种基于对等节点非中心化服务的平台方案。
+P2P技术发展迅猛，迅速改变了整个互联网传统秩序。“去中性化”符合WEB2.0技术潮流。特别在流媒体领域，
+由于采用Peer之间对等计算的模式，大大提高了资源共享的利用率，能在较低的成本下，充分利用空闲时间分
+发数据，避免拥塞，提供具备高实时性，和容错性能的流服务。为流媒体服务开辟了一条崭新的道路。   
+
+
+
+
+
+### 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):点对点通信或称为对等联网。每个用户既下载数据，又作为服务器存储数据
+并供其他用户下载。他的本质，是一种硬盘的共享，是把每个人电脑上的一部分硬盘，拿出来与其他人共享。
+
+然而目前单纯的P2P应用亦存在它的问题，P2P业务的盛行会带来网络流量风暴；新闻监管缺失，
+内容版权管理真空，盗版盛行；可能导致恶性病毒；给电信运营商以及产业链造成损害。此外，层出不穷的p2P
+产品采用的拓扑结构、算法模型不尽相同，缺乏标准体系，应用模式也不清晰。这些问题都阻碍了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技术。通过这种模式，
+可以在不增加成本的同时有效提升CDN服务能力，更有效避免了P2P应用的诸多弊端，是在当前运营商
+网络状况下最理想的媒体业务承载平台方案。
+
+PCDN的主要优势:      
+
+- 流服务能力的提高     
+P2P传输的内容与原CDN的内容有所不同，在核心节点根据P2P协议对内容（包括文件和流）做切片处理，
+P2P用户将根据这些规则来完成P2P共享。P2P在边缘层的引入大大降低了边缘服务器的压力，
+提高了文件传输和流媒体传输的效率。P2P技术充分利用了用户的闲置上行带宽，这样运营商可以通过更少
+的边缘服务器，提供更多的业务量为更多的用户服务，以较低成本代价应对迅猛增长的客户规模带来的挑战。
+- 可管理的P2P＋CDN网络      
+为了避免骨干网上的流量对冲，通过集中的分布式架构，将P2P的流量严格限制在同一边缘节点的区域内。
+这样就继承了P2P和CDN的优点，同时摒弃双方的缺点，避免电信骨干网上的流量无序性和风暴，
+增强了网络的可管理性和服务高的可靠性。通过客户端，可以实现对用户的监控，流量的监管。
+- 客户体验的改善     
+一方面，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  
+- Good Luck! 
diff --git "a/VideoDevelopment/DNS\345\217\212HTTPDNS.md" "b/VideoDevelopment/DNS\345\217\212HTTPDNS.md"
new file mode 100644
index 00000000..0a0323b1
--- /dev/null
+++ "b/VideoDevelopment/DNS\345\217\212HTTPDNS.md"
@@ -0,0 +1,257 @@
+DNS及HTTPDNS
+===
+
+![image](https://github.com/CharonChui/Pictures/blob/master/dns_generic.png?raw=true)
+
+### DNS简介
+
+DNS（Domain Name System):域名系统,是互联网的一项服务。它作为将域名和IP地址相互映射的一个分布式数据库，能够使人更方便地访问互联网。DNS使用TCP和UDP端口53。当前，对于每一级域名长度的限制是63个字符，域名总长度则不能超过253个字符。它的作用是根据域名查出IP地址，它是HTTP协议的前提，只有将域名正确的解析成IP地址后，后面的HTTP流程才能进行，所以一般做网络优化会首选优化DNS。
+
+根据域名查询IP，可以使用dig和host命令，例如下面查询百度的IP，我们直接浏览器访问220.181.38.148也是可以放到baidu的
+```
+dig baidu.com
+// 查询参数和统计
+; <<>> DiG 9.10.6 <<>> baidu.com
+;; global options: +cmd
+;; Got answer:
+;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 50292
+;; flags: qr aa rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 5, ADDITIONAL: 6
+// 查询内容
+;; OPT PSEUDOSECTION:
+; EDNS: version: 0, flags:; udp: 4096
+;; QUESTION SECTION:
+;baidu.com.         IN  A // 域名baidu.com的A记录，A是Address，注意com后面多了一个点
+// DNS服务器的答复,有两个IP，600表示600s内不用重新查询
+;; ANSWER SECTION:
+baidu.com.      600 IN  A   220.181.38.148
+baidu.com.      600 IN  A   39.156.69.79
+// baidu.com的NS记录(Name Server)，即哪些服务器负责管理baidu.com的DNS记录
+;; AUTHORITY SECTION:
+baidu.com.      86400   IN  NS  ns3.baidu.com.
+baidu.com.      86400   IN  NS  dns.baidu.com.
+baidu.com.      86400   IN  NS  ns7.baidu.com.
+baidu.com.      86400   IN  NS  ns2.baidu.com.
+baidu.com.      86400   IN  NS  ns4.baidu.com.
+// 上一段返回的域名服务器的IP地址
+;; ADDITIONAL SECTION:
+dns.baidu.com.      86400   IN  A   202.108.22.220
+ns2.baidu.com.      86400   IN  A   220.181.33.31
+ns3.baidu.com.      86400   IN  A   112.80.248.64
+ns4.baidu.com.      86400   IN  A   14.215.178.80
+ns7.baidu.com.      86400   IN  A   180.76.76.92
+// DNS服务器的一些传输信息，本机的DNS服务器是172.22.1.253，查询端口是53(DNS服务器默认端口)
+;; Query time: 16 msec
+;; SERVER: 172.22.1.253#53(172.22.1.253)
+;; WHEN: Wed Dec 18 17:25:52 CST 2019
+;; MSG SIZE  rcvd: 240
+```
+host命令是dig的简版:     
+```
+host baidu.com
+baidu.com has address 220.181.38.148
+baidu.com has address 39.156.69.79
+baidu.com mail is handled by 20 jpmx.baidu.com.
+baidu.com mail is handled by 20 mx50.baidu.com.
+baidu.com mail is handled by 10 mx.maillb.baidu.com.
+baidu.com mail is handled by 15 mx.n.shifen.com.
+baidu.com mail is handled by 20 mx1.baidu.com.
+```
+
+
+
+从上面dig命令执行的结果来看，域名baidu.com显示为baidu.com.这里为啥会多一个.。其实baidu.com
+的真正域名时baidu.com.root。简写为baidu.com.。因为，根域名.root对于所有域名都是一样的，所以平时是省略的。
+根域名的下一级，叫做"顶级域名"（top-level domain，缩写为TLD），比如.com、.net；再下一级叫做"次级域名"（second-level domain，缩写为SLD），比如www.example.com里面的.example，这一级域名是用户可以注册的；再下一级是主机名（host），比如www.example.com里面的www，又称为"三级域名"，这是用户在自己的域里面为服务器分配的名称，是用户可以任意分配的。
+
+DNS服务器根据域名的层级，进行分级查询。需要明确的是，每一级域名都有自己的NS记录，NS记录指向该级域名的域名服务器。这些服务器知道下一级域名的各种记录。所谓"分级查询"，就是从根域名开始，依次查询每一级域名的NS记录，直到查到最终的IP地址，过程大致如下:   
+1. 从"根域名服务器"查到"顶级域名服务器"的NS记录和A记录（IP地址）
+2. 从"顶级域名服务器"查到"次级域名服务器"的NS记录和A记录（IP地址）
+3. 从"次级域名服务器"查出"主机名"的IP地址
+
+![image](https://github.com/CharonChui/Pictures/blob/master/dns_1.png?raw=true)
+
+仔细看上面的过程，你可能发现了，没有提到DNS服务器怎么知道"根域名服务器"的IP地址。这是因为"根域名服务器"的NS记录和IP地址一般是不会变化的，所以内置在DNS服务器里面。目前，世界上一共有十三组根域名服务器，从A.ROOT-SERVERS.NET一直到M.ROOT-SERVERS.NET。
+
+
+#### DNS服务器的分类
+
+##### 根域名服务器
+
+全球13台顶级DNS服务器，存储了所有后缀的域名服务器IP地址，根据域名后缀查询出对应所属的域名服务器IP。
+
+##### 域名服务器 
+
+存储了所有域名的注册信息及NS服务器地址，根据域名注册信息上记录的NS地址找到提供域名解析服务的DNS解析服务器（权威DNS）所在IP.
+
+##### 权威解析服务器
+
+存储了提供解析服务的所有域名解析记录，可直接查询出访问域名所添加的解析记录值.
+DNS权威服务器保存着域名空间中部分区域的数据。如果DNS服务器负责管辖一个或多个区域时，称此DNS服务器为这些区域的权威服务器。
+权威DNS即最终决定域名解析结果的服务器，开发者可以在权威DNS上配置、变更、删除具体域名的对应解析结果信息。阿里云云解析（ https://wanwang.aliyun.com/domain/dns ）即权威DNS服务提供商。
+
+##### 递归服务器
+
+递归DNS(或运营商DNS)又称为Local DNS，它没有域名解析结果的决定权，但代理了用户向权威DNS获取域名解析结果的过程。根据用户的解析访问请求，向上级DNS解析服务器发起查询请求，再将最终查询出的域名解析记录指向地址告知请求设备。根据用户的解析访问请求，向上级DNS解析服务器发起查询请求，再将最终查询出的域名解析记录指向地址告知请求设备。      
+
+递归DNS上有缓存模块，当目标域名存在缓存解析结果并且TTL未过期时（每个域名都有TTL时间，即有效生存时间，若域名解析结果缓存的时间超过TTL，需要重新向权威DNS获取解析结果），递归DNS会返回缓存结果，否则，递归DNS会一级一级地查询各个层级域名的权威DNS直至获取最终完整域名的解析结果。
+
+- 公共DNS
+
+公共DNS是递归DNS的一种特例，它是一种全网开放的递归DNS服务，而传统的递归DNS信息一般由运营商分发给用户。一个比较典型的公共DNS即Google的8.8.8.8，我们可以通过在操作系统配置文件中配置公共DNS来代替Local DNS完成域名解析流程。
+
+在实际的使用过程中，我们通常不需要手工指定自己的Local DNS地址。运营商会通过DHCP协议在系统网络初始化阶段将Local DNS地址分配给我们的计算机。当我们需要使用公共DNS服务时，我们就必须手工指定这些服务的地址。以Linux为例，我们可以通过在'/etc/resolv.conf'中添加Local DNS地址项来改变本机Local DNS的地址。
+
+
+### DNS解析过程
+
+![image](https://github.com/CharonChui/Pictures/blob/master/dns_progress.png?raw=true)
+
+
+1. 在浏览器中输入www.qq.com域名，操作系统会先检查自己本地的hosts文件是否有这个网址映射关系，如果有，就先调用这个IP地址映射，完成域名解析。 
+
+2. 如果hosts里没有这个域名的映射，则查找本地DNS解析器缓存，是否有这个网址映射关系，如果有，直接返回，完成域名解析。 
+
+3. 如果hosts与本地DNS解析器缓存都没有相应的网址映射关系，首先会找TCP/ip参数中设置的首选DNS服务器，在此我们叫它本地DNS服务器，此服务器收到查询时，如果要查询的域名，包含在本地配置区域资源中，则返回解析结果给客户机，完成域名解析，此解析具有权威性。 
+
+4. 如果要查询的域名，不由本地DNS服务器区域解析，但该服务器已缓存了此网址映射关系，则调用这个IP地址映射，完成域名解析，此解析不具有权威性。 
+
+5. 如果本地DNS服务器本地区域文件与缓存解析都失效，则根据本地DNS服务器的设置（是否设置转发器）进行查询，如果未用转发模式，本地DNS就把请求发至13台根DNS，根DNS服务器收到请求后会判断这个域名(.com)是谁来授权管理，并会返回一个负责该顶级域名服务器的一个IP。本地DNS服务器收到IP信息后，将会联系负责.com域的这台服务器。这台负责.com域的服务器收到请求后，如果自己无法解析，它就会找一个管理.com域的下一级DNS服务器地址(qq.com)给本地DNS服务器。当本地DNS服务器收到这个地址后，就会找qq.com域服务器，重复上面的动作，进行查询，直至找到www.qq.com主机。 
+
+6. 如果用的是转发模式，此DNS服务器就会把请求转发至上一级DNS服务器，由上一级服务器进行解析，上一级服务器如果不能解析，或找根DNS或把转请求转至上上级，以此循环。不管是本地DNS服务器用是是转发，还是根提示，最后都是把结果返回给本地DNS服务器，由此DNS服务器再返回给客户机。
+
+
+#### 解析顺序
+
+1. 浏览器缓存     
+当用户通过浏览器访问某域名时，浏览器首先会在自己的缓存中查找是否有该域名对应的IP地址（若曾经访问过该域名且没有清空缓存便存在）    
+2. 系统缓存     
+当浏览器缓存中无域名对应IP则会自动检查用户计算机系统Hosts文件DNS缓存是否有该域名对应IP；    
+3. 路由器缓存     
+当浏览器及系统缓存中均无域名对应IP则进入路由器缓存中检查，以上三步均为客服端的DNS缓存；     
+4. ISP（互联网服务提供商）DNS缓存     
+当在用户客服端查找不到域名对应IP地址，则将进入ISP DNS缓存中进行查询。比如你用的是电信的网络，则会进入电信的DNS缓存服务器中进行查找；    
+5. 根域名服务器     
+当以上均未完成，则进入根服务器进行查询。全球仅有13台根域名服务器，1个主根域名服务器，其余12为辅根域名服务器。根域名收到请求后会查看区域文件记录，若无则将其管辖范围内顶级域名（如.com）服务器IP告诉本地DNS服务器；
+6. 顶级域名服务器    
+顶级域名服务器收到请求后查看区域文件记录，若无则将其管辖范围内主域名服务器的IP地址告诉本地DNS服务器；      
+7. 主域名服务器     
+主域名服务器接受到请求后查询自己的缓存，如果没有则进入下一级域名服务器进行查找，并重复该步骤直至找到正确纪录；     
+8. 保存结果至缓存      
+本地域名服务器把返回的结果保存到缓存，以备下一次使用，同时将该结果反馈给客户端，客户端通过这个IP地址与web服务器建立链接。
+
+
+
+
+### DNS的记录类型 
+
+域名与IP之间的对应关系，称为"记录"（record）。根据使用场景，"记录"可以分成不同的类型（type），前面已经看到了有A记录和NS记录。
+
+常见的DNS记录类型如下。
+- A：地址记录（Address），返回域名指向的IP地址。
+- NS：域名服务器记录（Name Server），返回保存下一级域名信息的服务器地址。该记录只能设置为域名，不能设置为IP地址。
+- MX：邮件记录（Mail eXchange），返回接收电子邮件的服务器地址。
+- CNAME：规范名称记录（Canonical Name），返回另一个域名，即当前查询的域名是另一个域名的跳转。
+- PTR：逆向查询记录（Pointer Record），只用于从IP地址查询域名。
+
+一般来说，为了服务的安全可靠，至少应该有两条NS记录，而A记录和MX记录也可以有多条，这样就提供了服务的冗余性，防止出现单点失败。
+
+CNAME记录主要用于域名的内部跳转，为服务器配置提供灵活性，用户感知不到。
+
+
+### DNS存在的问题 
+
+- 不稳定:DNS劫持或者故障，导致服务不可用
+- 不准确: LocalDNS的调度并不一定是就近原则，某些小运营商没有DNS服务器，直接调用其他运营商的DNS服务器，最终直接跨网传输。例如:用户侧是移动运营商，调度到了电信的IP，造成访问慢，甚至访问受限等问题
+- 不及时:运营商可能会修改DNS的TTL(Time-To-Live，DNS缓存时间)，导致DNS的修改，延迟生效。
+
+#### 域名劫持
+
+域名劫持一直是困扰许多开发者的问题之一，其表现即域名A应该返回的DNS解析结果IP1被恶意替换为了IP2，导致A的访问失败或访问了一个不安全的站点。下面我们一起看看几种常见的域名劫持的场景。
+
+- 一种可能的域名劫持方式即黑客侵入了宽带路由器并对终端用户的Local DNS进行篡改，指向黑客自己伪造的Local DNS，进而通过控制Local DNS的逻辑返回错误的IP信息进行域名劫持。另一方面，由于DNS解析主要是基于UDP协议，除了上述攻击行为外，攻击者还可以监听终端用户的域名解析请求，并在Local DNS返回正确结果之前将伪造的DNS解析响应传递给终端用户，进而控制终端用户的域名访问行为。
+
+- 另一种我们最常碰到的域名劫持现象是缓存污染。我们知道在接收到域名解析请求时，Local DNS首先会查找缓存，如果缓存命中就会直接返回缓存结果，不再进行递归DNS查询。这时候如果Local DNS针对部分域名的缓存进行更改，比如将缓存结果指向第三方的广告页，就会导致用户的访问请求被引导到这些广告页地址上。对比第一种攻击，这类缓存污染往往能带来更明显的群体伤害，比如某个省份某个运营商的用户群可能因为该地区Local DNS的缓存污染而导致访问服务异常。这类缓存污染行为往往是间歇性、局部性发生的，没有明显的规律，导致开发者很难对其进行量化、评估、预防。
+
+#### 调度不精准
+
+除了域名劫持问题，基于传统Local DNS的域名解析还会带来域名调度精准性的问题。对于类似CDN域名访问这类需要按地域、运营商进行智能解析调度的场景，精准调度的诉求是十分强烈的。
+
+关于调度不精准的原因，我们主要可以从两个方面来探究一下。第一个常见的问题即解析转发。
+
+部分Local DNS供应商为了降低运营成本，会将请求到自己节点的域名解析请求转发给其他供应商的Local DNS节点，假如用户请求解析一个CDN域名cdn.aliyun.com，用户分配到的Local DNS A为了节省成本，把该次请求转发给了另一运营商的Local DNS B，权威DNS在进行域名解析时会根据Local DNS的IP信息进行智能调度，即权威DNS会根据Local DNS B的IP78.29.29.1进行调度，分配与78.29.29.1相同运营商并且地理位置最近的CDN节点78.29.29.2，然而这个CDN节点对于终端135.35.35.1而言并不是最优的CDN节点，他们分属不同的运营商，并且地理位置上可能相隔很远。这类解析转发行为会严重影响域名解析的精准性并对用户业务访问延迟带来影响。
+
+![image](https://github.com/CharonChui/Pictures/blob/master/local_dns_map.png?raw=true)
+
+如上图所示，部分运营商Local DNS的布点受成本因素制约分布并不均匀，比如在东部地区部署比较密集，但在西部地区部署比较稀疏。这时候当一位西藏的用户准备访问CDN节点时，我们预期他应该会被调度到西藏的CDN节点A上以实现就近接入和访问加速。但由于Local DNS的资源有限，西部地区的终端用户被统一调度到青海的Local DNS B上，这时候权威DNS根据Local DNS B的IP进行CDN域名的智能解析，并将青海的CDN节点B返回给西藏用户，导致用户的网络访问延迟上升。另一种我们实际发现的情况是Local DNS的分配甚至并非遵循就近原则，比如有实际案例显示西藏的用户甚至被分配了北京的Local DNS节点C，导致西藏的用户在进行CDN资源访问时被调度到了北京的CDN节点C上，类似的由于调度精度的缺失带来的访问体验的影响是非常严重的。
+
+#### 解析生效滞后
+
+部分业务场景下开发者对域名解析结果变更的生效时间非常敏感（这部分变更操作是开发者在权威DNS上完成的），比如当业务服务器受到攻击时，我们需要最快速地将业务IP切换到另一组集群上，这样的诉求在传统域名解析体系下是无法完成的。
+
+Local DNS的部署是由各个地区的各个运营商独立部署的，因此各个Local DNS的服务质量参差不齐。在对域名解析缓存的处理上，各个独立节点的实现策略也有区别，比如部分节点为了节省开支忽略了域名解析结果的TTL时间限制，导致用户在权威DNS变更的解析结果全网生效的周期非常漫长（我们已知的最长生效时间甚至高达48小时）。这类延迟生效可能直接导致用户业务访问的异常。
+
+DNS首次查询或缓存过期后的查询，需要递归遍历多个DNS服务器以获取最终的解析结果，这增加了网络请求的前置延时时间。特别是在移动互联网场景下，移动网络质量参差不齐，弱网环境的RTT时间可能高达数百毫秒，对于一次普通的业务请求而言，上述延时是非常沉重的负担。另一方面，弱网环境下的解析超时、解析失败等现象屡见不鲜，如何合理优化DNS解析对于整体网络访问质量的提升至关重要。
+
+
+通过上面的介绍，可以知道传统域名解析面临的诸多问题与挑战本质根源在于Local DNS的服务质量不可控，如果有一个更安全、稳定、高效的递归DNS服务帮助我们代理了域名解析的过程，上述问题看起来就可以彻底地得到解决。HTTPDNS在这样的背景下应运而生。
+
+### HTTPDNS
+
+HTTPDNS使用HTTP协议进行域名解析，代替现有基于UDP的DNS协议，域名解析请求直接发送到HTTPDNS服务端，从而绕过运营商的Local DNS，有效的防止了域名劫持，提高域名解析的效率，如下图所示。
+
+![image](https://github.com/CharonChui/Pictures/blob/master/http_dns.png?raw=true)
+
+HTTPDNS代替了传统的LocalDNS完成递归解析的功能，基于HTTP协议的设计可以适用于几乎所有的网络环境，同时保留了鉴权、HTTPS等更高安全性的扩展能力，避免恶意攻击劫持行为。另一方面，商业化的HTTPDNS服务，如[阿里云](https://www.aliyun.com/product/httpdns)缓存管理有严格的SLA保障，避免了类似Local DNS的缓存污染的问题。
+
+HTTPDNS的原理非常简单，主要有两步:    
+
+- 客户端直接访问HttpDNS接口，获取业务在域名配置管理系统上配置的访问延迟最优的IP。（基于容灾考虑，还是保留次选使用运营商LocalDNS解析域名的方式）
+- 客户端向获取到的IP后就向直接往此IP发送业务协议请求。以Http请求为例，通过在header中指定host字段，向HTTPDNS返回的IP发送标准的Http请求即可。
+
+#### 精准调度
+传统域名解析的调度精准性问题，本质根源在于Local DNS的部署和分配机制上。由于碎片化的管理方式，这些环节的服务质量同样很难得到保障。HTTPDNS在递归解析实现上优化了与权威DNS的交互，通过[edns-client-subnet协议](https://datatracker.ietf.org/doc/rfc7871)将终端用户的IP信息直接交付给权威DNS，这样权威DNS就可以忽略Local DNS IP信息，根据终端用户的IP信息进行精准调度，避免Local DNS的坐标干扰（当然上述精准调度方案的前提是权威DNS需要支持edns-client-subnet，可喜的是当前主流的权威DNS服务都已支持该协议）。精准调度的流程示例如下。
+
+#### 实时生效
+在域名解析生效周期方面，HTTPDNS也有着传统域名解析体系所无法具备的能力。前文中我们提到由于各个地区的Local DNS是独立维护的，服务质量参差不齐，缓存实现不一，因此导致的解析变更全网生效滞后的问题，在商业化的HTTPDNS服务上就不会存在（HTTPDNS严格遵循DNS TTL限制进行缓存更新）。另一方面，即便我们假设Local DNS严格遵循域名TTL时间进行缓存管理（这里我们假设开发者配置的域名TTL时间为5min），当开发者业务受到攻击并需要快速进行切换时，Local DNS也会遵循域名TTL，在持续5min的时间段内返回旧IP信息，这5min的业务影响对于中大型企业而言是一个不小的损失（对于电商类的大型企业，5min的访问异常可能意味着几百万的交易额下跌）。以阿里云HTTPDNS服务为例，HTTPDNS在快速生效方面有专有的方案，配合阿里云的权威DNS服务云解析，用户在权威DNS变更的解析结果将快速同步给HTTPDNS，覆盖原有的缓存记录，帮助用户实现秒级的域名解析切换。
+
+在DNS解析延迟方面，由于HTTPDNS基于HTTP协议，而HTTP基于TCP协议，对比传统的UDP传输多了一些冗余的握手环节，因此从原理上而言网络请求方面的开销并没有降低。但在实际使用过程中，我们可以通过端上的策略来实现一个零延迟DNS解析的方案。
+
+#### 预解析
+绝大多数的APP在应用初始化阶段都有一个启动期，我们可以在这个启动期针对业务的热点域名在后台发起异步的HTTPDNS解析请求。这部分预解析结果在后续的业务请求中可以直接使用，进而消除首次业务请求的DNS解析开销，提升APP首页的加载速度。
+
+在客户端实际使用HTTPDNS的过程中，有一个大家需要关注的点。标准的Web服务器（以Nginx为例）一般会将HTTP请求头中的Host头的值作为请求的域名信息进行处理（取决于服务端的配置，但一般情况都如此）。比如当我们通过标准的网络库访问www.aliyun.com/index.html这个地址时，发出的网络请求一般是这样的：
+```
+GET /index.html HTTP/1.1
+Host: www.aliyun.com
+User-Agent: curl/7.43.0
+Accept: */*
+```
+使用HTTPDNS后，我们需要将HTTP请求URL中的Host域（注意这里的Host域指的是URL中的Host字段，而非HTTP请求头中的Host头）替换为HTTPDNS解析获得的IP，这时由于标准的网络库会将URL中的Host域赋值给HTTP请求头中的Host头，发出的网络请求如下：
+```
+GET /index.html HTTP/1.1
+Host: 140.205.63.8
+User-Agent: curl/7.43.0
+Accept: */*
+```
+
+
+#### 智能缓存
+
+通过预解析获取的IP有一定的TTL有效时间，我们需要合理地缓存下来进行管理。操作系统本身的DNS缓存粒度比较粗，在客户端我们可以应用更细粒度的缓存管理来提升解析效率。比如在不同的网络运营商环境下，对CDN域名的解析结果会发生变化，当我们使用电信WIFI时，DNS解析会返回就近的电信CDN节点IP，当我们使用联通3G时，DNS解析会返回就近的联通CDN节点IP，针对不同运营商的解析结果缓存可以确保我们在网络切换时能够快速地进行网络请求，减免DNS解析带来的额外开销。甚至更激进的，我们可以做本地的持久化缓存，当下一次APP启动时直接读取缓存用于网络访问，以提升首屏加载的速度。
+
+#### 懒加载
+
+懒加载策略的实施可以让我们真正实现DNS的零延迟解析。所谓懒加载策略，核心的实现思路如下：业务层的域名解析请求只和缓存进行交互，不实际发生网络解析请求。如果缓存中存在记录，不论过期与否，直接返回业务层缓存中的记录；
+如果缓存中的记录已过期，后台发起异步网络请求进行HTTPDNS解析。 
+
+这里提两条大厂公开的数据，对腾讯的产品，在接入HTTPDNS后，用户平均延迟下降超过 10%，访问失败率下降超过五分之一。而百度App的Feed业务，Android劫持率由0.25%降低到0.05%。
+
+
+参考:   
+- [移动互联网时代，如何优化你的网络 —— 域名解析篇](https://yq.aliyun.com/articles/58967?spm=a2c4e.11155435.0.0.30967fbdKgs205)
+
+    
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/VideoDevelopment/Danmaku/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"
new file mode 100644
index 00000000..6a0ef80d
--- /dev/null
+++ "b/VideoDevelopment/Danmaku/Android\345\274\271\345\271\225\345\256\236\347\216\260.md"
@@ -0,0 +1,95 @@
+弹幕
+
+---
+
+
+
+[OpenDanmaku](https://github.com/linsea/OpenDanmaku)
+
+[bilibili Android开源弹幕引擎.烈焰弹幕使](https://github.com/Bilibili/DanmakuFlameMaster)
+
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/danmaku.gif?raw=true)
+
+### 弹幕目前使用场景
+
+
+
+1. 直播:通过直播间im可以实时的去显示用户新发的弹幕
+2. 短视频:目前没有im，可以通过单独的接口来请求弹幕，实时性有缺陷
+
+
+
+### 播放器上弹幕实现原理
+
+   布局上分为: 最下层的播放器视图、中间层的弹幕视图层、最上层的操作视图层。
+
+- 自定义View显示弹幕:VideoView上面盖上一层全透明的DanmakuView，该DanmakuView去不断的渲染显示弹幕。可能会有卡顿。
+
+- SurfaceView显示弹幕:内存及耗电量低、绘制及时，但是不支持动画和截图。    
+
+  打个比方可以是两个SurfaceView，下面的一个SurfaceView显示视频画面，上面的一层透明SurfaceView用于绘制弹幕。          
+
+- TextureView显示弹幕: 内存和耗电稍高、绘制会有1-3帧的延迟、但是支持动画和截图。   
+
+  一般的Activity包含的多个View会组成View hierachy的树形结构，只有最顶层的DectorView才是对WMS可见的，这个DecorView在WMS中有一个对应的WindowState，再SurfaceFlinger中有对应的Layer，而SurfaceView正因为它有自己的Surface，有自己的Window，它在WMS中有对应的WindowState，在SurfaceFlinger中有Layer。虽然在App端它仍在View hierachy中，但在Server端(WMS和SurfaceFlinger)中，它与宿主窗口是分离的。这样的好处是对这个Surface的渲染可以放到单独的线程中去做，渲染时可以有自己的GL context。因为它不会影响主线程对时间的响应。所以它的优点就是可以在独立的线程中绘制，不影响主线程，而且使用双缓冲机制，播放视频时画面更顺畅。但是这也有缺点，因为这个Surface不在View hierachy中，它的显示也不受View的属性控制，所以不能进行平移、缩放等动画，它也不能放在其它ViewGroup中，SurfaceView不能嵌套使用，而且不能使用某些View的特性，例如View.setAlpha()。
+
+  ***从Android7.0开始，SurfaceView的窗口位置与其他View渲染同步更新。 这意味着在屏幕上平移和缩放SurfaceView不会导致渲染失真。***
+
+
+
+### 需要考虑的问题
+
+
+
+1. 弹幕的大小及位置是否可以用户随意调整
+
+2. 弹幕内移动的item出现的角度是否可按类型不同控制
+
+3. 弹幕能否支持图文以及标签
+
+4. 弹幕内移动的item出现的位置是否可随机
+
+5. 弹幕有没有交互功能，例如点击弹幕中的头像进入用户页面
+
+6. 弹幕过于密集集中是的展示策略(是否舍弃)
+
+7. 小屏和全屏切换后的展示策略(展示内容的空间大小不同)
+
+8. 性能的影响
+
+9. 弹幕太多挡住视频中的人物画面
+
+   B站移动端的视频能够明显的看到人物边缘的锯齿.        
+
+   ![](https://github.com/CharonChui/Pictures/blob/master/bilibili_danmaku.jpeg?raw=true)
+
+   对观看还是有一定的体验影响，感觉可以从上面第四条的角度去出发，对于密集的弹幕做一个展示策略，例如短时间内大量的重复或者相近的弹幕可以舍弃(只有发弹幕的本人可以看到)或者是合并。
+
+   - 抠图:任务在弹幕渲染的层级之上渲染。
+   - 视频预处理:服务端做离线的视频人脸监测，生成蒙层，，弹幕遇到人脸的位置就消失，除了人脸就显示。
+
+### 实现思考
+
+
+
+#### 自定义View
+
+
+
+#### 自定义SurfaceView
+
+
+
+#### 自定义TextureView
+
+#### OpenGL实现
+
+
+
+
+
+
+
+
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"
new file mode 100644
index 00000000..09afc156
--- /dev/null
+++ "b/VideoDevelopment/ExoPlayer/1. ExoPlayer\347\256\200\344\273\213.md"	
@@ -0,0 +1,232 @@
+1.ExoPlayer简介
+---    
+
+[ExoPlayer](https://github.com/google/ExoPlayer)是google开源的应用级媒体播放器项目。
+
+
+与内置的MediaPlayer相比，ExoPlayer的优点主要有: 
+
+- 支持通过Http(DASH)和SmoothStreaming进行动态自适应流，这两种都不受MediaPlayer的支持。它还支持其他格式的数据资源，比如MP4、M4A、FMP4、MKV、MP3、Ogg、WAV、FLV等
+- 支持高级的HLS个性，比如正确处理#EXT-X-DISCONTINUITY标签
+- 无缝连接，合并和循环播放多媒体的能力
+- 和应用一起更新播放器(ExoPlayer)，因为ExoPlayer是一个集成到应用APK的库，可以随着应用的更新把ExoPlayer更新到一个更新的版本。
+- 在不同的Android版本和设备上很少会有不同的表现。
+- 能够自定义和扩展播放器，以适应各种不同的需求
+- 各个组件都可以自定义，还可以接入ffmpeg组件
+
+缺点就是，在音频播放时ExoPlayer会比MediaPlayer消耗更多的电量。
+
+集成
+---
+
+在app的module中的`build.gradle`文件添加如下依赖(这种方式是添加全部的依赖):  
+`implementation 'com.google.android.exoplayer:exoplayer:2.X.X'`
+
+如果不需要依赖全部的类库，也可以只选择添加你需要的类库，例如下面的方式是只需要播放DASH内容的app，就是只添加Core、DASH和UI库:  
+```
+implementation 'com.google.android.exoplayer:exoplayer-core:2.X.X'
+implementation 'com.google.android.exoplayer:exoplayer-dash:2.X.X'
+implementation 'com.google.android.exoplayer:exoplayer-ui:2.X.X'
+```
+
+下面列出了所有的依赖库:   
+
+- `exoplayer-core`:核心功能库(基础库、必要)
+- `exoplayer-dash`:支持DASH
+- `exoplayer-hls`:支持HLS
+- `exoplayer-smoothstreaming`:支持SmoothStreaming
+- `exoplayer-ui`:使用ExoPlayer所需的UI部分和资源
+
+上面讲到了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)上查看。
+
+如果依赖完后仍然不行，你需要将build.gradle文件中的android节点打开Java 8的支持:  
+```
+compileOptions {
+    targetCompatibility = 1.8
+}
+```
+
+
+ExoPlayer库的核心是ExoPlayer接口，ExoPlayer公开了传统的高级媒体播放器功能，例如缓冲、播放、暂停、seek等。在具体实现方面，该开源库对播放器的媒体类型、存储方式、位置、渲染方式等进行了最少的实现，旨在让开发者自定义各种特性。ExoPlayer的实现不是直接实现加载和呈现媒体，而是将这项工作委托给各种组件。主要有:  
+
+- TrackSelector:轨道提取器，从MediaSource中提取各个轨道的二进制数据，交给Renderer渲染，创建播放器时传入。
+- Renderer:对多媒体中的各个轨道(音轨、视频轨、字母轨等)数据进行渲染，渲染就是"播放"，把二进制文件渲染成声音、画面，创建播放器时传入。
+- MediaSource:定义多媒体数据源，这个类的功能就是从Uri中读取多媒体文件的二进制数据。MediaSource在播放开始时通过ExoPlayer.prepare()注入。
+- LoadControl:对MediaSource进行控制，比如什么时候开始缓冲、缓冲多少等。
+
+它们之间的关系是:   
+
+渲染器(Render)  ---刷数据--->提取器(Extraor) ----读取数据---> 加载控制器(LoadControl) ----控制数据加载方式---> 媒体源(MediaSource)
+
+
+
+
+该库提供了这些组件的默认实现，既能满足大部分需求，也可通过自定义来实现特殊的需求。例如可以通过自定义LoadControl来更改播放器的缓冲策略，或自定义Renderer来渲染Android本身不支持的编解码器。
+
+[支持的格式](https://exoplayer.dev/supported-formats.html)
+
+
+### 创建播放器
+
+为了满足不同的需求，ExoPlayer提供了一个工厂类ExoPlayerFactory，通过该工厂类来创建一个ExoPlayer实例，大多数情况下直接使用`ExoPlayerFactory.newSimpleInstance(context)`方法即可:  
+
+```
+public static SimpleExoPlayer newSimpleInstance(Context context) {
+    return newSimpleInstance(context, new DefaultTrackSelector());
+}
+```
+它返回的SimpleExoPlayer是一个实现ExoPlayer接口并添加了一些额外的高级播放器功能。
+
+### 把播放器实例附着到一个View上
+
+ExoPlayer库提供了一个PlayerView(A high level view for Player media playbacks. It displays video, subtitles and album art during playback, and displays playback controls using a PlayerControlView.)类，他封装了PlayerControlView和渲染视频的一个默认的SurfaceView以及字幕等功能。可以通过xml中surface_type来指定视频播放的Surface类型，除了值spherical_view（这是球形视频播放一个特殊的值）时，允许值是surface_view，texture_view和none。如果视图仅用于音频播放，则应使用none以避免必须创建Surface，因为这样做可能耗费资源。
+
+如果视图是用于常规视频播放那么surface_view或texture_view 应该使用。对于视频播放，相比TextureView，SurfaceView有许多好处:   
+
+- 显着降低了许多设备的功耗。
+- 更准确的帧定时，使视频播放更流畅。
+- 播放受DRM保护的内容时支持安全输出。
+因此，相比较于TextureView，SurfaceView应尽可能优先考虑。 TextureView只有在SurfaceView不符合您需求的情况下才能使用。一个示例是在Android N之前需要平滑动画或滚动视频表面，如下所述。对于这种情况，最好 TextureView 只在SDK_INT小于24（Android N）时使用， 否则，使用SurfaceView。
+
+SurfaceView在Android N之前，渲染未与视图动画正确同步。在早期版本SurfaceView中，当放入滚动容器或受到动画影响时，这可能会导致不必要的效果 。这些效果包括视图的内容看起来略微落后于它应该显示的位置，并且视图在受到动画时变黑。为了在Android N之前实现流畅的动画或视频滚动，因此必须使用TextureView而不是SurfaceView。
+
+xml声明:   
+```
+<com.google.android.exoplayer2.ui.PlayerView
+    android:id="@+id/mPlayerView"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" />
+```
+
+```kotlin
+private lateinit var mPlayer: SimpleExoPlayer
+private fun initView(context: Context) {
+    val view = View.inflate(context, R.layout.video_view, this)
+    mPlayer = ExoPlayerFactory.newSimpleInstance(context)
+    // 通过PlayerView.setPlayer方法来将ExoPlayer绑定到View上
+    mPlayerView.player = mPlayer
+}
+```
+
+### 开始播放   
+
+ExoPlayer中将每一种媒体资源都封装成MediaSource，如果想要播放一种媒体资源，首先需要为他创建对应的MediaSource对象，然后把这个对象传递给ExoPlayer.prepared方法。ExoPlayer提供了多种MediaSource的实现类，例如播放[DASH](https://exoplayer.dev/dash.html)的DashMediaSource，[SmoothStreaming](https://exoplayer.dev/smoothstreaming.html)的SsMediaSource,[HLS](https://exoplayer.dev/hls.html)的HlsMediaSource，以及[顺序流媒体文件](https://exoplayer.dev/progressive.html)的ProgressiveMediaSource(插一嘴，流式传输分两种方法：实时流式传输方式(Realtime Streaming)和顺序流式传输方式(Progressive Streaming)。)。
+
+
+
+
+```
+    fun playSingleMp4Video(url: String) {
+        val uri = Uri.parse(url)
+        val mediaSource = buildMediaSource(uri)
+        // setPlayWhenReady()方法可以设置prepared完成后是否自动播放，如果已经准备好了该方法可实现开始和暂停播放的功能
+        mPlayer.playWhenReady = true
+        // setShuffleModeEnabled控制播放列表 setPlaybackParameters控制亮度和音量
+
+        // 设置监听
+        mPlayer.addListener(mPlayerEventListener)
+        mPlayer.addVideoListener(mPlayerVideoListener)
+        // 移除监听
+        // mPlayer.removeListener(mPlayerEventListener)
+        mPlayer.prepare(mediaSource, false, false)
+    }
+
+    private fun buildMediaSource(uri: Uri): MediaSource {
+        val dataSourceFactory = DefaultDataSourceFactory(context, Util.getUserAgent(context, "you application name"))
+        return ProgressiveMediaSource.Factory(dataSourceFactory)
+            .createMediaSource(uri)
+    }
+
+        private var mPlayerEventListener = object : EventListener {
+        override fun onPlayerStateChanged(playWhenReady: Boolean, playbackState: Int) {
+            when (playbackState) {
+                Player.STATE_IDLE -> {
+                    // 出事状态、播放器停止或播放失败时的状态
+                }
+                Player.STATE_BUFFERING -> {
+                    // 开始加载数据，无法立即从当前位置进行播放
+                }
+                Player.STATE_READY -> {
+                    // ready状态，可以直接从当前位置播放
+                }
+                Player.STATE_ENDED -> {
+                    // 播放完成
+                }
+            }
+        }
+
+        override fun onPlayerError(error: ExoPlaybackException?) {
+            // error.getSourceException()可以获取更多信息
+            when(error?.type) {
+                ExoPlaybackException.TYPE_SOURCE -> {
+                    // 加载资源时出错
+                }
+
+                ExoPlaybackException.TYPE_RENDERER -> {
+                    // 渲染时出错
+                }
+
+                ExoPlaybackException.TYPE_UNEXPECTED -> {
+                    // 意外
+                }
+
+                ExoPlaybackException.TYPE_OUT_OF_MEMORY -> {
+                    // OOM
+                }
+
+                ExoPlaybackException.TYPE_REMOTE -> {
+                    // 远程错误
+                }
+            }
+        }
+    }
+
+    private var mPlayerVideoListener = object : VideoListener {
+        override fun onVideoSizeChanged(
+            width: Int,
+            height: Int,
+            unappliedRotationDegrees: Int,
+            pixelWidthHeightRatio: Float
+        ) {
+
+        }
+
+        override fun onRenderedFirstFrame() {
+
+        }
+
+        override fun onSurfaceSizeChanged(width: Int, height: Int) {
+
+        }
+    }
+```
+
+
+### 资源释放
+
+```
+if (mPlayer != null) {
+    mPlayer.removeListener(mPlayerEventListener)
+    mPlayer.removeVideoListener(mPlayerVideoListener)
+    mPlayer.release()
+}
+```
+
+
+
+[下一篇: 2. ExoPlayer MediaSource简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/2.%20ExoPlayer%20MediaSource%E7%AE%80%E4%BB%8B.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/ExoPlayer/2. ExoPlayer MediaSource\347\256\200\344\273\213.md" "b/VideoDevelopment/ExoPlayer/2. ExoPlayer MediaSource\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..1a307e2f
--- /dev/null
+++ "b/VideoDevelopment/ExoPlayer/2. ExoPlayer MediaSource\347\256\200\344\273\213.md"	
@@ -0,0 +1,126 @@
+2.ExoPlayer MediaSource简介     
+---
+
+在ExoPlayer里每一种媒体资源都是被MediaSource来代表的。
+```
+/**
+ * Defines and provides media to be played by an {@link com.google.android.exoplayer2.ExoPlayer}. A
+ * MediaSource has two main responsibilities:
+ *
+ * <ul>
+ *   <li>To provide the player with a {@link Timeline} defining the structure of its media, and to
+ *       provide a new timeline whenever the structure of the media changes. The MediaSource
+ *       provides these timelines by calling {@link SourceInfoRefreshListener#onSourceInfoRefreshed}
+ *       on the {@link SourceInfoRefreshListener}s passed to {@link
+ *       #prepareSource(SourceInfoRefreshListener, TransferListener)}.
+ *   <li>To provide {@link MediaPeriod} instances for the periods in its timeline. MediaPeriods are
+ *       obtained by calling {@link #createPeriod(MediaPeriodId, Allocator, long)}, and provide a
+ *       way for the player to load and read the media.
+ * </ul>
+ *
+ * All methods are called on the player's internal playback thread, as described in the {@link
+ * com.google.android.exoplayer2.ExoPlayer} Javadoc. They should not be called directly from
+ * application code. Instances can be re-used, but only for one {@link
+ * com.google.android.exoplayer2.ExoPlayer} instance simultaneously.
+ */
+public interface MediaSource {
+    ....
+}
+
+```
+
+
+ExoPlayer中MediaSource接口有很多实现类:   
+
+- ProgressiveMediaSource: 常规资源
+- SsMediaSource: SmoothStreaming资源
+- HlsMediaSource: HLS资源
+- DashMediaSource: DASH资源
+- LoopingMediaSource:循环播放
+- MergingMediaSource:合并
+- ClippingMediaSource:裁剪
+- ConcatenatingMediaSource:列表
+
+
+
+### ConcatenatingMediaSource
+
+连接资源的转换是无缝的。这种连接不要求是相同格式的资源（例如可以把包含480P H264视频文件和包含720P VP9的视频文件很好地连接在一起）。它们甚至可以是不同的类型（比如可以将一个视频和一个纯音频流很好地连接在一起）。并且在一个连接里一个类型的MediaSource可以被多次使用。
+
+在一个ConcatenatingMediaSource里可以通过添加，删除和移动MediaSource动态地修改播放列表。同样在播放视频之前或者是正在播放的过程中可以通过调用相应的ConcatenatingMediaSource方法动态修改播放列表。播放器会正确地自动处理这些动态修改。例如正在播放的MediaSource被移动了，播放不会中断并且播放完成后会自动播放它后面的一个MediaSource资源。如果正在播放的MediaSource被删除了，播放器会自动移动到第一个存在的后继者去播放，如果没有后继者的话，播放器将会转到结束的状态。
+
+```
+val mediaSource = buildMediaSource(uri)
+val mediaSource2 = buildMediaSource(uri)
+
+val concatenatingMediaSource = ConcatenatingMediaSource(mediaSource, mediaSource2)
+mPlayer.prepare(concatenatingMediaSource)
+
+private fun buildMediaSource(uri: Uri): MediaSource {
+    val dataSourceFactory = DefaultDataSourceFactory(context, Util.getUserAgent(context, "you application name"))
+    return ProgressiveMediaSource.Factory(dataSourceFactory)
+        .createMediaSource(uri)
+}
+```
+
+
+### ClippingMediaSource
+
+剪辑视频
+
+```
+// 从5s到10s
+val clippingMediaSource = ClippingMediaSource(mediaSource, 5000, 10000)
+mPlayer.prepare(clippingMediaSource)
+```
+
+
+### LoopingMediaSource
+
+循环播放，如果想要一直循环，可以使用ExoPlayer.setRepeatMode.
+
+```
+// 循环5次
+val loopingMediaSource = LoopingMediaSource(mediaSource, 5)
+mPlayer.prepare(loopingMediaSource)
+```
+
+
+
+### MergingMediaSource
+
+如果一个视频文件和一个单独的字母文件，可以使用MergingMediaSource合并成一个资源播放
+
+### 高级组合
+
+假如有两个视频A和B，下面的例子展示了怎么一起使用LoopingMediaSource和ConcatenatingMediaSource来播放A、A、B序列。
+
+```
+val mediaSource = buildMediaSource(uri)
+val mediaSource2 = buildMediaSource(uri)
+
+val loopingMediaSource = LoopingMediaSource(mediaSource, 2)
+val concatenatingMediaSource = ConcatenatingMediaSource(loopingMediaSource, mediaSource2)
+mPlayer.prepare(concatenatingMediaSource)
+```
+
+
+
+ExoPlayer提供下载媒体以进行离线播放的功能。这里就不细说了。
+
+
+
+[上一篇: 1. ExoPlayer简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/1.%20ExoPlayer%E7%AE%80%E4%BB%8B.md)        
+[下一篇: 3. ExoPlayer源码分析之prepare方法](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/3.%20ExoPlayer%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E4%B9%8Bprepare%E6%96%B9%E6%B3%95.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/ExoPlayer/3. ExoPlayer\346\272\220\347\240\201\345\210\206\346\236\220\344\271\213prepare\346\226\271\346\263\225.md" "b/VideoDevelopment/ExoPlayer/3. ExoPlayer\346\272\220\347\240\201\345\210\206\346\236\220\344\271\213prepare\346\226\271\346\263\225.md"
new file mode 100644
index 00000000..54185eca
--- /dev/null
+++ "b/VideoDevelopment/ExoPlayer/3. ExoPlayer\346\272\220\347\240\201\345\210\206\346\236\220\344\271\213prepare\346\226\271\346\263\225.md"	
@@ -0,0 +1,1092 @@
+3.ExoPlayer源码分析之prepare方法   
+---
+
+上面两篇文章说了ExoPlayer简单的使用，都是些API，没什么用，查查文档就可以了。我们要去学习ExoPlayer整体是怎么设计的。以下基于2.10.6版本.     
+
+### 找入口
+
+分析的时候首先要找到一个切入点，上一篇文章中写了怎么去创建使用，我们再看一遍代码，如下:    
+```
+View.inflate(context, R.layout.video_view, this)
+mPlayer = ExoPlayerFactory.newSimpleInstance(context)
+mPlayerView.player = mPlayer
+
+val uri = Uri.parse(url)
+val mediaSource = buildMediaSource(uri) //  ProgressiveMediaSource
+mPlayer.prepare(mediaSource)
+```
+
+从上面的代码看出来其实主要就是三步:   
+1. 通过ExoPlayerFactory创建ExoPlayer实例对象，当然这里创建的是SimpleExoPlayer()    
+2. 将视频url封装成MediaSource类    
+3. 调用ExoPlayer.prepare()方法，并将MediaSource类对象作为参数传入。    
+
+我们下面分析就只看上面的1和3部分，因为2最终也是通过3方法的参数传入的。   
+
+
+### 类图
+先看一下`ExoPlayer`接口的实现:   
+
+```
+/**
+ * An extensible media player that plays MediaSources. Instances can be obtained from ExoPlayerFactory.
+ */
+public interface ExoPlayer extends Player {
+    void retry();
+    void prepare(MediaSource mediaSource);
+    PlayerMessage createMessage(PlayerMessage.Target target);
+}
+```
+
+它实现了Player接口:  
+```
+public interface Player {
+    interface AudioComponent
+    interface VideoComponent
+    interface TextComponent
+    interface MetadataComponent
+    interface MetadataComponent
+    interface EventListener
+    int STATE_IDLE = 1;
+    int STATE_BUFFERING = 2;
+    int STATE_READY = 3;
+    int STATE_ENDED = 4;
+    AudioComponent getAudioComponent();
+    VideoComponent getVideoComponent();
+    TextComponent getTextComponent();
+     MetadataComponent getMetadataComponent();
+     Looper getApplicationLooper();
+     void addListener(EventListener listener);
+     int getPlaybackState();
+     boolean isPlaying();
+     void setPlayWhenReady(boolean playWhenReady);
+     void setRepeatMode();
+     void setShuffleModeEnabled(boolean shuffleModeEnabled);
+     void seekTo(long positionMs);
+     void stop();
+     void release();
+     long getCurrentPosition();
+     long getCurrentPosition();
+}
+```
+
+Player接口有一个默认的实现类BasePlayer:     
+
+```
+/** Abstract base {@link Player} which implements common implementation independent methods. */
+public abstract class BasePlayer implements Player {
+
+}
+```
+
+
+### ExoPlayer创建部分
+
+获取ExoPlayer对象的实例是通过ExoPlayerFactory来实现的，这里面提供了一些静态的方法:  
+```
+public static SimpleExoPlayer newSimpleInstance(Context context) {
+    return newSimpleInstance(context, new DefaultTrackSelector());
+}
+
+public static SimpleExoPlayer newSimpleInstance(Context context, TrackSelector trackSelector) {
+    return newSimpleInstance(context, new DefaultRenderersFactory(context), trackSelector);
+}
+
+public static SimpleExoPlayer newSimpleInstance(
+  Context context, RenderersFactory renderersFactory, TrackSelector trackSelector) {
+    return newSimpleInstance(context, renderersFactory, trackSelector, new DefaultLoadControl());
+}
+
+public static ExoPlayer newInstance(
+  Context context, Renderer[] renderers, TrackSelector trackSelector) {
+    return newInstance(context, renderers, trackSelector, new DefaultLoadControl());
+}
+```
+
+通过这个工厂类可以获取SimpleExoPlayer或者ExoPlayer接口的实例。我们上面是通过该工厂类的ExoPlayerFactory.newSimpleInstance(context)来获取的SimpleExoPlayer。而newSimpleInstance()方法的实现如下:   
+```
+public static SimpleExoPlayer newSimpleInstance(
+      Context context,
+      RenderersFactory renderersFactory,
+      TrackSelector trackSelector,
+      LoadControl loadControl,
+      @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager,
+      BandwidthMeter bandwidthMeter,
+      AnalyticsCollector.Factory analyticsCollectorFactory,
+      Looper looper) {
+    return new SimpleExoPlayer(
+        context,
+        renderersFactory,
+        trackSelector,
+        loadControl,
+        drmSessionManager,
+        bandwidthMeter,
+        analyticsCollectorFactory,
+        looper);
+}
+```
+可以看到它最后调用了new SimpleExoPlayer，并且传入了一些参数，这些参数主要有:   
+
+- TrackSelector:轨道提取器，The component of an ExoPlayer responsible for selecting tracks to be consumed by each of the player's Renderers. The DefaultTrackSelector implementation should be suitable for most use cases.从MediaSource中提取各个轨道的二进制数据，交给Renderer渲染，它有个selectTracks()方法，会返回TrackSelection数组，TrackSelection就是对轨道进行解析的，因为一个文件有多个轨道:音频轨、视频轨、文字轨等，所以也需要多个TrackSelection。
+- Renderer:对多媒体中的各个轨道(音轨、视频轨、字母轨等)数据进行渲染，渲染就是"播放"，把二进制文件渲染成声音、画面，创建播放器时传入。
+RenderersFactory的作用就是创建Renderers，每个资源可能有音频、视频等多个轨道，每个Render对应一个轨道，Renderer对应的有VideoRender、AudioRender、TextRenderer、MetadataRenderers等等
+- LoadControl:对MediaSource进行控制，比如什么时候开始缓冲、缓冲多少等 主要是记录一些位置。
+- MediaSource:定义多媒体数据源，这个类的功能就是从Uri中读取多媒体文件的二进制数据。MediaSource在播放开始时通过ExoPlayer.prepare()注入，它有一个主要的方法就是createPeriod()，用来创建Period对象，这个对象里面会真正的做资源处理。
+- Looper:为了ExoPlayer中消息的处理
+- BandwidthMeter:监控当前的带宽情况
+
+它们之间的关系是:   
+
+渲染器(Render)  ---刷数据--->提取器(Extraor) ----读取数据---> 加载控制器(LoadControl) ----控制数据加载方式---> 媒体源(MediaSource)
+
+扯远了，继续看SimpleExoPlayer的构造函数:     
+```
+public class SimpleExoPlayer extends BasePlayer
+    implements ExoPlayer,
+        Player.AudioComponent,
+        Player.VideoComponent,
+        Player.TextComponent,
+        Player.MetadataComponent {
+    private final ExoPlayerImpl player;
+    private final Handler eventHandler;
+
+    protected SimpleExoPlayer(
+          Context context,
+          RenderersFactory renderersFactory,
+          TrackSelector trackSelector, // 轨道提取器
+          LoadControl loadControl, // 加载控制器
+          @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager,  // drm session管理 刚才传的是null
+          BandwidthMeter bandwidthMeter, // 带宽监测
+          AnalyticsCollector.Factory analyticsCollectorFactory, // 用于分析
+          Clock clock, // 传的是SystemClick，可以获取系统时间，为了创建HandlerWrapper
+          Looper looper) {
+        this.bandwidthMeter = bandwidthMeter;
+        componentListener = new ComponentListener();
+        videoListeners = new CopyOnWriteArraySet<>();
+        audioListeners = new CopyOnWriteArraySet<>();
+        textOutputs = new CopyOnWriteArraySet<>();
+        metadataOutputs = new CopyOnWriteArraySet<>();
+        videoDebugListeners = new CopyOnWriteArraySet<>();
+        audioDebugListeners = new CopyOnWriteArraySet<>();
+        eventHandler = new Handler(looper);
+        // 获取Render来进行渲染
+        renderers =
+            renderersFactory.createRenderers(
+                eventHandler,
+                componentListener,
+                componentListener,
+                componentListener,
+                componentListener,
+                drmSessionManager);
+
+        // Set initial values.
+        audioVolume = 1;
+        audioSessionId = C.AUDIO_SESSION_ID_UNSET;
+        audioAttributes = AudioAttributes.DEFAULT;
+        videoScalingMode = C.VIDEO_SCALING_MODE_DEFAULT;
+        currentCues = Collections.emptyList();
+
+        // 创建ExoPlayerImp的实例，并将render trackselector loadControl bandwidthmeter looper等传入
+        // Build the player and associated objects.
+        player =
+            new ExoPlayerImpl(renderers, trackSelector, loadControl, bandwidthMeter, clock, looper);
+        analyticsCollector = analyticsCollectorFactory.createAnalyticsCollector(player, clock);
+        addListener(analyticsCollector);
+        addListener(componentListener);
+        videoDebugListeners.add(analyticsCollector);
+        videoListeners.add(analyticsCollector);
+        audioDebugListeners.add(analyticsCollector);
+        audioListeners.add(analyticsCollector);
+        addMetadataOutput(analyticsCollector);
+        bandwidthMeter.addEventListener(eventHandler, analyticsCollector);
+        if (drmSessionManager instanceof DefaultDrmSessionManager) {
+          ((DefaultDrmSessionManager) drmSessionManager).addListener(eventHandler, analyticsCollector);
+        }
+        audioFocusManager = new AudioFocusManager(context, componentListener);
+    }
+}
+```
+
+该方法里面调用了new ExoPlayerImpl()，继续看一下ExoPlayerImpl的构造函数: 
+```
+final class ExoPlayerImpl extends BasePlayer implements ExoPlayer {
+    public ExoPlayerImpl(
+      Renderer[] renderers,
+      TrackSelector trackSelector,
+      LoadControl loadControl,
+      BandwidthMeter bandwidthMeter,
+      Clock clock,
+      Looper looper) {
+    Log.i(TAG, "Init " + Integer.toHexString(System.identityHashCode(this)) + " ["
+        + ExoPlayerLibraryInfo.VERSION_SLASHY + "] [" + Util.DEVICE_DEBUG_INFO + "]");
+    Assertions.checkState(renderers.length > 0);
+    this.renderers = Assertions.checkNotNull(renderers);
+    this.trackSelector = Assertions.checkNotNull(trackSelector);
+    this.playWhenReady = false;
+    this.repeatMode = Player.REPEAT_MODE_OFF;
+    this.shuffleModeEnabled = false;
+    this.listeners = new CopyOnWriteArrayList<>();
+    emptyTrackSelectorResult =
+        new TrackSelectorResult(
+            new RendererConfiguration[renderers.length],
+            new TrackSelection[renderers.length],
+            null);
+    // 媒体资源的片段，TimeLine和Period都是媒体资源片段状态相关的        
+    period = new Timeline.Period();
+    // 播放器相关参数，default是默认的1倍速
+    playbackParameters = PlaybackParameters.DEFAULT;
+    // seek的参数
+    seekParameters = SeekParameters.DEFAULT;
+    playbackSuppressionReason = PLAYBACK_SUPPRESSION_REASON_NONE;
+    // 通过传递进来的looper创建eventHandler，并将message交给ExoPlayerImpl.this.handleEvent方法
+    eventHandler =
+        new Handler(looper) {
+          @Override
+          public void handleMessage(Message msg) {
+            ExoPlayerImpl.this.handleEvent(msg);
+          }
+        };
+    // 创建一个空的播放对象信息，直到开播的时候再赋值
+    playbackInfo = PlaybackInfo.createDummy(/* startPositionUs= */ 0, emptyTrackSelectorResult);
+    pendingListenerNotifications = new ArrayDeque<>();
+    // 创建ExoPlayerImplInternal对象internalPlayer
+    internalPlayer =
+        new ExoPlayerImplInternal(
+            renderers,
+            trackSelector,
+            emptyTrackSelectorResult,
+            loadControl,
+            bandwidthMeter,
+            playWhenReady,
+            repeatMode,
+            shuffleModeEnabled,
+            eventHandler,
+            clock);
+    // 创建internalPlayer使用的handler        
+    internalPlayerHandler = new Handler(internalPlayer.getPlaybackLooper());
+    }
+
+}
+```
+
+里面又创建了ExoPlayerImplInternal，并把那些参数全部传递到这里面了:   
+
+```
+public ExoPlayerImplInternal(
+      Renderer[] renderers,
+      TrackSelector trackSelector,
+      TrackSelectorResult emptyTrackSelectorResult,
+      LoadControl loadControl,
+      BandwidthMeter bandwidthMeter,
+      boolean playWhenReady,
+      @Player.RepeatMode int repeatMode,
+      boolean shuffleModeEnabled,
+      Handler eventHandler,
+      Clock clock) {
+    this.renderers = renderers;
+    this.trackSelector = trackSelector;
+    this.emptyTrackSelectorResult = emptyTrackSelectorResult;
+    this.loadControl = loadControl;
+    this.bandwidthMeter = bandwidthMeter;
+    this.playWhenReady = playWhenReady;
+    this.repeatMode = repeatMode;
+    this.shuffleModeEnabled = shuffleModeEnabled;
+    this.eventHandler = eventHandler;
+    this.clock = clock;
+    this.queue = new MediaPeriodQueue();
+
+    backBufferDurationUs = loadControl.getBackBufferDurationUs();
+    retainBackBufferFromKeyframe = loadControl.retainBackBufferFromKeyframe();
+
+    seekParameters = SeekParameters.DEFAULT;
+    playbackInfo =
+        PlaybackInfo.createDummy(/* startPositionUs= */ C.TIME_UNSET, emptyTrackSelectorResult);
+    playbackInfoUpdate = new PlaybackInfoUpdate();
+    rendererCapabilities = new RendererCapabilities[renderers.length];
+    for (int i = 0; i < renderers.length; i++) {
+      renderers[i].setIndex(i);
+      rendererCapabilities[i] = renderers[i].getCapabilities();
+    }
+    mediaClock = new DefaultMediaClock(this, clock);
+    pendingMessages = new ArrayList<>();
+    enabledRenderers = new Renderer[0];
+    // Timeline、Window、Period后面的文章会单独讲一下
+    window = new Timeline.Window();
+    period = new Timeline.Period();
+    // 初始化trackSelector
+    trackSelector.init(/* listener= */ this, bandwidthMeter);
+
+    // Note: The documentation for Process.THREAD_PRIORITY_AUDIO that states "Applications can
+    // not normally change to this priority" is incorrect.
+    internalPlaybackThread = new HandlerThread("ExoPlayerImplInternal:Handler",
+        Process.THREAD_PRIORITY_AUDIO);
+    // 启动一个线程，准备接受任务    
+    internalPlaybackThread.start();
+    // 这个地方比较关键clock.createHandler的意思是使用特定的looper和特定callback来处理消息
+    // 而这里传的callback是this，所以通过该handler发送的消息都会传递到ExoPlayerImplInternal类的handleMessage方法
+    // clock是一个可以获取系统时间的类,又通过clock创建了一个ExoPlayerImplInternal使用的handler
+    handler = clock.createHandler(internalPlaybackThread.getLooper(), this);
+  }
+```
+
+看到这里应该明白了其实ExoPlayerImplInternal才是最终实现的核心类。     
+到这里我们上面mPlayer = ExoPlayerFactory.newSimpleInstance(context)的部分已经看完了，剩下的就是mPlayer.prepare(concatenatingMediaSource). 
+
+### ExoPlayer.prepare()部分
+
+我们找到SimpleExoPlayer.prepare()方法:    
+```
+  @Override
+  public void prepare(MediaSource mediaSource) {
+    prepare(mediaSource, /* resetPosition= */ true, /* resetState= */ true);
+  }
+
+  @Override
+  public void prepare(MediaSource mediaSource, boolean resetPosition, boolean resetState) {
+    verifyApplicationThread();
+    if (this.mediaSource != null) {
+      this.mediaSource.removeEventListener(analyticsCollector);
+      analyticsCollector.resetForNewMediaSource();
+    }
+    this.mediaSource = mediaSource;
+    mediaSource.addEventListener(eventHandler, analyticsCollector);
+    @AudioFocusManager.PlayerCommand
+    int playerCommand = audioFocusManager.handlePrepare(getPlayWhenReady());
+    // 更新当前是否是准备完成后自动开始播放
+    updatePlayWhenReady(getPlayWhenReady(), playerCommand);
+    // player是ExoPlayerImpl对象
+    player.prepare(mediaSource, resetPosition, resetState);
+  }
+```
+所以要继续看ExoPlayerImpl.prepare()方法:   
+```
+  @Override
+  public void prepare(MediaSource mediaSource, boolean resetPosition, boolean resetState) {
+    playbackError = null;
+    this.mediaSource = mediaSource;
+    PlaybackInfo playbackInfo =
+        getResetPlaybackInfo(
+            resetPosition, resetState, /* playbackState= */ Player.STATE_BUFFERING);
+    // Trigger internal prepare first before updating the playback info and notifying external
+    // listeners to ensure that new operations issued in the listener notifications reach the
+    // player after this prepare. The internal player can't change the playback info immediately
+    // because it uses a callback.
+    hasPendingPrepare = true;
+    pendingOperationAcks++;
+    // 调用了ExoPlayerImplInternal的prepare方法
+    internalPlayer.prepare(mediaSource, resetPosition, resetState);
+    updatePlaybackInfo(
+        playbackInfo,
+        /* positionDiscontinuity= */ false,
+        /* ignored */ DISCONTINUITY_REASON_INTERNAL,
+        TIMELINE_CHANGE_REASON_RESET,
+        /* seekProcessed= */ false);
+  }
+```
+所以要继续再看ExoPlayerImplInternal的prepare方法:   
+```
+  public void prepare(MediaSource mediaSource, boolean resetPosition, boolean resetState) {
+    // 调用handler.sendMessage，上面在handler初始化的时候说过，该handler发送的消息会走到该类的handleMessage方法。
+    handler
+        .obtainMessage(MSG_PREPARE, resetPosition ? 1 : 0, resetState ? 1 : 0, mediaSource)
+        .sendToTarget();
+  }
+```
+所以接下来要继续看一下ExoPlayerImplInternal.handleMessage()方法，这个方法比较多，我们这里只要看MSG_PREPARE部分:    
+```
+  public boolean handleMessage(Message msg) {
+    try {
+      switch (msg.what) {
+        case MSG_PREPARE:
+        // 通过msg取出MediaSource对象并作为参数调用prepareInternal()方法
+          prepareInternal(
+              (MediaSource) msg.obj,
+              /* resetPosition= */ msg.arg1 != 0,
+              /* resetState= */ msg.arg2 != 0);
+          break;
+        case MSG_SET_PLAY_WHEN_READY:
+          setPlayWhenReadyInternal(msg.arg1 != 0);
+          break;
+        case MSG_SET_REPEAT_MODE:
+          setRepeatModeInternal(msg.arg1);
+          break;
+        case MSG_SET_SHUFFLE_ENABLED:
+          setShuffleModeEnabledInternal(msg.arg1 != 0);
+          break;
+        case MSG_DO_SOME_WORK:
+          doSomeWork();
+          break;
+        ..........
+  }
+```
+
+里面调用了prepareInternal()方法:   
+```
+private void prepareInternal(MediaSource mediaSource, boolean resetPosition, boolean resetState) {
+    pendingPrepareCount++;
+    // 这个方法是做一些资源的释放初始化等操作，移除MSG_DO_SOME_WORK消息，然后重置Render，把之前的MediaSource释放等
+    resetInternal(
+        /* resetRenderers= */ false, /* releaseMediaSource= */ true, resetPosition, resetState);
+    // onPrepared方法内部只是reset了
+    loadControl.onPrepared();
+    this.mediaSource = mediaSource;
+    // 更新当前的状态到buffering
+    setState(Player.STATE_BUFFERING);
+    // 开始资源准备，并且添加对应的监听, 具体MediaSource里面怎么去实现的prepareSource，等我们讲完doSomeWork后再说
+    mediaSource.prepareSource(/* listener= */ this, bandwidthMeter.getTransferListener());
+    // 又发送了MSG_DO_SOME_WORK
+    handler.sendEmptyMessage(MSG_DO_SOME_WORK);
+}
+```
+这里又是两部分:   
+- mediaSource.prepareSource()方法，这里面是关于MediaSource作用的部分
+- 发送MSG_DO_SOME_WORK的消息
+
+
+#### MediaSource.prepareSource()
+在看之前有必要先看一下MediaSource接口:   
+```
+Defines and provides media to be played by an ExoPlayer. A MediaSource has two main responsibilities:
+To provide the player with a Timeline defining the structure of its media, and to provide a new timeline whenever the structure of the media changes. The MediaSource provides these timelines by calling MediaSource.SourceInfoRefreshListener.onSourceInfoRefreshed on the MediaSource.SourceInfoRefreshListeners passed to prepareSource(MediaSource.SourceInfoRefreshListener, TransferListener).
+To provide MediaPeriod instances for the periods in its timeline. MediaPeriods are obtained by calling createPeriod(MediaSource.MediaPeriodId, Allocator, long), and provide a way for the player to load and read the media.
+```
+大体的意思就是一个MediaSource要有两个重要的职责:    
+- 将一个定义媒体结构的Timeline对象提供给player，并且在媒体变化的时候去提供一个新的Timeline对象
+- 对Timeline中的媒体片段提供MediaPeriod对象，player通过MediaPeriod中提供的方式来读取媒体数据
+
+继续看一下mediaSource.prepareSource()方法，它的实现是在BaseMediaSource类中的:     
+```
+public final void prepareSource(
+      SourceInfoRefreshListener listener,
+      @Nullable TransferListener mediaTransferListener) {
+    Looper looper = Looper.myLooper();
+    Assertions.checkArgument(this.looper == null || this.looper == looper);
+    sourceInfoListeners.add(listener);
+    if (this.looper == null) {
+      this.looper = looper;
+      // 开始的时候会调用该方法
+      prepareSourceInternal(mediaTransferListener);
+    } else if (timeline != null) {
+      listener.onSourceInfoRefreshed(/* source= */ this, timeline, manifest);
+    }
+}
+```
+继续看prepareSourceInternal()方法，该方法是子类去实现的，这里我们用普通视频格式的ProgressiveMediaSource类来看:   
+```
+public void prepareSourceInternal(@Nullable TransferListener mediaTransferListener) {
+    transferListener = mediaTransferListener;
+    notifySourceInfoRefreshed(timelineDurationUs, timelineIsSeekable);
+}
+
+private void notifySourceInfoRefreshed(long durationUs, boolean isSeekable) {
+    timelineDurationUs = durationUs;
+    timelineIsSeekable = isSeekable;
+    // TODO: Make timeline dynamic until its duration is known. This is non-trivial. See b/69703223.
+    refreshSourceInfo(
+        new SinglePeriodTimeline(
+            timelineDurationUs, timelineIsSeekable, /* isDynamic= */ false, tag),
+        /* manifest= */ null);
+}
+
+protected final void refreshSourceInfo(Timeline timeline, @Nullable Object manifest) {
+    this.timeline = timeline;
+    this.manifest = manifest;
+    for (SourceInfoRefreshListener listener : sourceInfoListeners) {
+      listener.onSourceInfoRefreshed(/* source= */ this, timeline, manifest);
+    }
+ }
+```
+而这里的listener是谁呢？ 是ExoPlayerImplInternal，继续看ExoPlayerImplInternal.onSourceInfoRefreshed()方法:  
+```
+public void onSourceInfoRefreshed(MediaSource source, Timeline timeline, Object manifest) {
+    handler.obtainMessage(MSG_REFRESH_SOURCE_INFO,
+        new MediaSourceRefreshInfo(source, timeline, manifest)).sendToTarget();
+  }
+```
+
+接着就是发送MSG_REFRESH_SOURCE_INFO消息，然后我们到handleMessage()中看一下:   
+```
+  public boolean handleMessage(Message msg) {
+    try {
+      switch (msg.what) {
+        case MSG_PREPARE:
+          prepareInternal(
+              (MediaSource) msg.obj,
+              /* resetPosition= */ msg.arg1 != 0,
+              /* resetState= */ msg.arg2 != 0);
+          break;
+          case MSG_REFRESH_SOURCE_INFO:
+          handleSourceInfoRefreshed((MediaSourceRefreshInfo) msg.obj);
+          break;
+          ....
+      }
+  }
+}
+```
+Message发送过来的是MediaSourceRefreshInfo对象，然后将其作为参数传递给handleSourceInfoRefreshed()方法，里面逻辑太多了，大体都是一些更新播放信息和状态的操作。
+
+
+#### MSG_DO_SOME_WORK消息
+handleMessage方法中在收到MSG_DO_SOME_WORK后调用了doSomeWork()方法，我们看一下他里面的实现:    
+```
+private void doSomeWork() throws ExoPlaybackException, IOException {
+    // 获取系统时间
+    long operationStartTimeMs = clock.uptimeMillis();
+    // 通过MediaPeriodQueue更新媒体文件的片段，里面会去prepare下一个片段
+    updatePeriods();
+    if (!queue.hasPlayingPeriod()) {
+      // We're still waiting for the first period to be prepared.
+      maybeThrowPeriodPrepareError();
+      scheduleNextWork(operationStartTimeMs, PREPARING_SOURCE_INTERVAL_MS);
+      return;
+    }
+    // 获取当前播放器的媒体片段
+    MediaPeriodHolder playingPeriodHolder = queue.getPlayingPeriod();
+
+    TraceUtil.beginSection("doSomeWork");
+    // 更新播放位置
+    updatePlaybackPositions();
+    long rendererPositionElapsedRealtimeUs = SystemClock.elapsedRealtime() * 1000;
+
+    playingPeriodHolder.mediaPeriod.discardBuffer(playbackInfo.positionUs - backBufferDurationUs,
+        retainBackBufferFromKeyframe);
+
+    boolean renderersEnded = true;
+    boolean renderersReadyOrEnded = true;
+    // renderers会比较多，有音频、视频、文本，Renderer接口有好几个实现类
+    for (Renderer renderer : enabledRenderers) {
+      // TODO: Each renderer should return the maximum delay before which it wishes to be called
+      // again. The minimum of these values should then be used as the delay before the next
+      // invocation of this method.
+      // 开始让Renderer进入准备状态
+      renderer.render(rendererPositionUs, rendererPositionElapsedRealtimeUs);
+      renderersEnded = renderersEnded && renderer.isEnded();
+      // Determine whether the renderer is ready (or ended). We override to assume the renderer is
+      // ready if it needs the next sample stream. This is necessary to avoid getting stuck if
+      // tracks in the current period have uneven durations. See:
+      // https://github.com/google/ExoPlayer/issues/1874
+      boolean rendererReadyOrEnded = renderer.isReady() || renderer.isEnded()
+          || rendererWaitingForNextStream(renderer);
+      if (!rendererReadyOrEnded) {
+        renderer.maybeThrowStreamError();
+      }
+      renderersReadyOrEnded = renderersReadyOrEnded && rendererReadyOrEnded;
+    }
+    if (!renderersReadyOrEnded) {
+      maybeThrowPeriodPrepareError();
+    }
+
+    long playingPeriodDurationUs = playingPeriodHolder.info.durationUs;
+    if (renderersEnded
+        && (playingPeriodDurationUs == C.TIME_UNSET
+            || playingPeriodDurationUs <= playbackInfo.positionUs)
+        && playingPeriodHolder.info.isFinal) {
+      setState(Player.STATE_ENDED);
+      stopRenderers();
+    } else if (playbackInfo.playbackState == Player.STATE_BUFFERING
+        && shouldTransitionToReadyState(renderersReadyOrEnded)) {
+      setState(Player.STATE_READY);
+      // prepare的时候会走到这里，如果prepared完成需要自动播放并且所有Renderer目前都已经是准备好的状态那就会开始渲染的功能
+      if (playWhenReady) {
+        startRenderers();
+      }
+    } else if (playbackInfo.playbackState == Player.STATE_READY
+        && !(enabledRenderers.length == 0 ? isTimelineReady() : renderersReadyOrEnded)) {
+      rebuffering = playWhenReady;
+      setState(Player.STATE_BUFFERING);
+      stopRenderers();
+    }
+
+    if (playbackInfo.playbackState == Player.STATE_BUFFERING) {
+      for (Renderer renderer : enabledRenderers) {
+        renderer.maybeThrowStreamError();
+      }
+    }
+
+    if ((playWhenReady && playbackInfo.playbackState == Player.STATE_READY)
+        || playbackInfo.playbackState == Player.STATE_BUFFERING) {
+      // 发送下一个MSG_DO_SOME_WORK的消息，这样来达到循环
+      scheduleNextWork(operationStartTimeMs, RENDERING_INTERVAL_MS);
+    } else if (enabledRenderers.length != 0 && playbackInfo.playbackState != Player.STATE_ENDED) {
+      scheduleNextWork(operationStartTimeMs, IDLE_INTERVAL_MS);
+    } else {
+      handler.removeMessages(MSG_DO_SOME_WORK);
+    }
+
+    TraceUtil.endSection();
+}
+```
+
+可以看出，doSomeWork()方法会不断的去绘制，然后每次绘制完一部分就会继续循环调用该方法去绘制下一个媒体片段。上面可以看到核心功能在updatePeriods()方法，通过循环来不断的去加载下一个媒体片段，来达到播放的功能，所以接下来看一下该方法:   
+```
+  private void updatePeriods() throws ExoPlaybackException, IOException {
+    if (mediaSource == null) {
+      // The player has no media source yet.
+      return;
+    }
+    if (pendingPrepareCount > 0) {
+      // We're waiting to get information about periods.
+      mediaSource.maybeThrowSourceInfoRefreshError();
+      return;
+    }
+
+    // Update the loading period if required.
+    // 下面会看该方法的实现，这个方法就是去尝试加载下一个媒体片段
+    maybeUpdateLoadingPeriod();
+
+    MediaPeriodHolder loadingPeriodHolder = queue.getLoadingPeriod();
+    if (loadingPeriodHolder == null || loadingPeriodHolder.isFullyBuffered()) {
+      setIsLoading(false);
+    } else if (!playbackInfo.isLoading) {
+      maybeContinueLoading();
+    }
+
+    if (!queue.hasPlayingPeriod()) {
+      // We're waiting for the first period to be prepared.
+      return;
+    }
+
+    // Advance the playing period if necessary.
+    MediaPeriodHolder playingPeriodHolder = queue.getPlayingPeriod();
+    MediaPeriodHolder readingPeriodHolder = queue.getReadingPeriod();
+    boolean advancedPlayingPeriod = false;
+    // 如果prepare完成后需要开始播放的话
+    while (playWhenReady
+        && playingPeriodHolder != readingPeriodHolder
+        && rendererPositionUs >= playingPeriodHolder.getNext().getStartPositionRendererTime()) {
+      // All enabled renderers' streams have been read to the end, and the playback position reached
+      // the end of the playing period, so advance playback to the next period.
+      if (advancedPlayingPeriod) {
+        // If we advance more than one period at a time, notify listeners after each update.
+        maybeNotifyPlaybackInfoChanged();
+      }
+      int discontinuityReason =
+          playingPeriodHolder.info.isLastInTimelinePeriod
+              ? Player.DISCONTINUITY_REASON_PERIOD_TRANSITION
+              : Player.DISCONTINUITY_REASON_AD_INSERTION;
+      MediaPeriodHolder oldPlayingPeriodHolder = playingPeriodHolder;
+      // advancePlayingPeriod()方法内部会去设置queue中要播放的playingPeroidHolder
+      // 这里对于MediaPeriodQueue有必要说一下，它里面有三个MediaPeriodHolder对象，分别是
+      // playingMediaPeriodHolder、readingMediaPeriodHolder、loadingMediaPeriodHolder
+      playingPeriodHolder = queue.advancePlayingPeriod();
+      // 调用enableRenderers()方法，然后开始渲染
+      updatePlayingPeriodRenderers(oldPlayingPeriodHolder);
+      playbackInfo =
+          playbackInfo.copyWithNewPosition(
+              playingPeriodHolder.info.id,
+              playingPeriodHolder.info.startPositionUs,
+              playingPeriodHolder.info.contentPositionUs,
+              getTotalBufferedDurationUs());
+      playbackInfoUpdate.setPositionDiscontinuity(discontinuityReason);
+      updatePlaybackPositions();
+      advancedPlayingPeriod = true;
+    }
+    ........
+  }
+```
+
+maybeUpdateLoadingPeriod()是用来检测是否加载下一个媒体片段的:   
+```
+private void maybeUpdateLoadingPeriod() throws IOException {
+    // 如果现在有一个正在loading的片段，会重新去评估
+    queue.reevaluateBuffer(rendererPositionUs);
+    // 检查是否需要加载下一个媒体片段
+    if (queue.shouldLoadNextMediaPeriod()) {
+      // 获取下一个媒体片段信息
+      MediaPeriodInfo info = queue.getNextMediaPeriodInfo(rendererPositionUs, playbackInfo);
+      if (info == null) {
+        maybeThrowSourceInfoRefreshError();
+      } else {
+        // 1. 调用了MediaPeriodQueue.enqueueNextMediaPeriod()方法
+        MediaPeriod mediaPeriod =
+            queue.enqueueNextMediaPeriod(
+                rendererCapabilities,
+                trackSelector,
+                loadControl.getAllocator(),
+                mediaSource,
+                info);
+        // 2. 调用下一个媒体片段的prepare方法。MediaPeriod接口有很多实现类，例如DASH、HLS等
+        // 所以每个不同类型的资源，它的prepare方法都是不一样的        
+        mediaPeriod.prepare(this, info.startPositionUs);
+        setIsLoading(true);
+        // 更新状态
+        handleLoadingMediaPeriodChanged(/* loadingTrackSelectionChanged= */ false);
+      }
+    }
+  }
+```
+
+上面又分了两部分:  
+- 获取MediaPeriod
+- 调用MediaPeriod.prepare方法
+
+
+#### 先看获取MediaPeriod的部分
+
+MediaPeriodQueue.enqueueNextMediaPeriod方法的实现如下: 
+```
+  public MediaPeriod enqueueNextMediaPeriod(
+      RendererCapabilities[] rendererCapabilities,
+      TrackSelector trackSelector,
+      Allocator allocator,
+      MediaSource mediaSource,
+      MediaPeriodInfo info) {
+    long rendererPositionOffsetUs =
+        loading == null
+            ? (info.id.isAd() && info.contentPositionUs != C.TIME_UNSET
+                ? info.contentPositionUs
+                : 0)
+            : (loading.getRendererOffset() + loading.info.durationUs - info.startPositionUs);
+
+    // 创建MediaPeriodHolder    
+    MediaPeriodHolder newPeriodHolder =
+        new MediaPeriodHolder(
+            rendererCapabilities,
+            rendererPositionOffsetUs,
+            trackSelector,
+            allocator,
+            mediaSource,
+            info);
+    if (loading != null) {
+      Assertions.checkState(hasPlayingPeriod());
+      loading.setNext(newPeriodHolder);
+    }
+    oldFrontPeriodUid = null;
+    loading = newPeriodHolder;
+    length++;
+    return newPeriodHolder.mediaPeriod;
+  }
+```
+而MediaPeriodHolder的构造函数是:   
+```
+  public MediaPeriodHolder(
+      RendererCapabilities[] rendererCapabilities,
+      long rendererPositionOffsetUs,
+      TrackSelector trackSelector,
+      Allocator allocator,
+      MediaSource mediaSource,
+      MediaPeriodInfo info) {
+    this.rendererCapabilities = rendererCapabilities;
+    this.rendererPositionOffsetUs = rendererPositionOffsetUs;
+    this.trackSelector = trackSelector;
+    this.mediaSource = mediaSource;
+    this.uid = info.id.periodUid;
+    this.info = info;
+    sampleStreams = new SampleStream[rendererCapabilities.length];
+    mayRetainStreamFlags = new boolean[rendererCapabilities.length];
+    mediaPeriod =
+        createMediaPeriod(
+            info.id, mediaSource, allocator, info.startPositionUs, info.endPositionUs);
+  }
+```
+接着是createMediaPeriod():  
+```
+  /** Returns a media period corresponding to the given {@code id}. */
+  private static MediaPeriod createMediaPeriod(
+      MediaPeriodId id,
+      MediaSource mediaSource,
+      Allocator allocator,
+      long startPositionUs,
+      long endPositionUs) {
+    MediaPeriod mediaPeriod = mediaSource.createPeriod(id, allocator, startPositionUs);
+    if (endPositionUs != C.TIME_UNSET && endPositionUs != C.TIME_END_OF_SOURCE) {
+      mediaPeriod =
+          new ClippingMediaPeriod(
+              mediaPeriod, /* enableInitialDiscontinuity= */ true, /* startUs= */ 0, endPositionUs);
+    }
+    return mediaPeriod;
+  }
+```
+然后就是MediaSource.createPeriod()方法，我们用ProgressiveMediaPeriod来看:  
+```
+  public MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator, long startPositionUs) {
+    DataSource dataSource = dataSourceFactory.createDataSource();
+    if (transferListener != null) {
+      dataSource.addTransferListener(transferListener);
+    }
+    return new ProgressiveMediaPeriod(
+        uri,
+        dataSource,
+        extractorsFactory.createExtractors(),
+        loadableLoadErrorHandlingPolicy,
+        createEventDispatcher(id),
+        this,
+        allocator,
+        customCacheKey,
+        continueLoadingCheckIntervalBytes);
+  }
+```
+
+#### 再看MediaPeriod.prepare部分 
+这里还是用普通视频的ProgressiveMediaPeriod来看: 
+```
+  public void prepare(Callback callback, long positionUs) {
+    this.callback = callback;
+    loadCondition.open();
+    // 又调用了startLoading()
+    startLoading();
+  }
+```
+
+接着看startLoading()方法:   
+```
+  private void startLoading() {
+    // 注意这个loadable，里面有uri和DataSource
+    ExtractingLoadable loadable =
+        new ExtractingLoadable(
+            uri, dataSource, extractorHolder, /* extractorOutput= */ this, loadCondition);
+    if (prepared) {
+      SeekMap seekMap = getPreparedState().seekMap;
+      Assertions.checkState(isPendingReset());
+      if (durationUs != C.TIME_UNSET && pendingResetPositionUs > durationUs) {
+        loadingFinished = true;
+        pendingResetPositionUs = C.TIME_UNSET;
+        return;
+      }
+      loadable.setLoadPosition(
+          seekMap.getSeekPoints(pendingResetPositionUs).first.position, pendingResetPositionUs);
+      pendingResetPositionUs = C.TIME_UNSET;
+    }
+    extractedSamplesCountAtStartOfLoad = getExtractedSamplesCount();
+    // loader是构造函数里面创建的一个加载线程
+    long elapsedRealtimeMs =
+        loader.startLoading(
+            loadable, this, loadErrorHandlingPolicy.getMinimumLoadableRetryCount(dataType));
+    eventDispatcher.loadStarted(
+        loadable.dataSpec,
+        C.DATA_TYPE_MEDIA,
+        C.TRACK_TYPE_UNKNOWN,
+        /* trackFormat= */ null,
+        C.SELECTION_REASON_UNKNOWN,
+        /* trackSelectionData= */ null,
+        /* mediaStartTimeUs= */ loadable.seekTimeUs,
+        durationUs,
+        elapsedRealtimeMs);
+  }
+```
+接着看一下Loader类的startLoading()方法:   
+```
+  public <T extends Loadable> long startLoading(
+      T loadable, Callback<T> callback, int defaultMinRetryCount) {
+    Looper looper = Looper.myLooper();
+    Assertions.checkState(looper != null);
+    fatalError = null;
+    long startTimeMs = SystemClock.elapsedRealtime();
+    new LoadTask<>(looper, loadable, callback, defaultMinRetryCount, startTimeMs).start(0);
+    return startTimeMs;
+  }
+```
+里面启动了LoadTask，LoadTask是一个Runnable的实现类,我们就直接看它的run方法:  
+
+```
+private final class LoadTask<T extends Loadable> extends Handler implements Runnable {
+    public void run() {
+      try {
+        executorThread = Thread.currentThread();
+        if (!canceled) {
+          TraceUtil.beginSection("load:" + loadable.getClass().getSimpleName());
+          try {
+            // 最终调用的是这个，而loadable是啥？他是上面创建的ExtractingLoadable
+            loadable.load();
+          } finally {
+            TraceUtil.endSection();
+          }
+        }
+        if (!released) {
+          sendEmptyMessage(MSG_END_OF_SOURCE);
+        }
+      } catch (IOException e) {
+        if (!released) {
+          obtainMessage(MSG_IO_EXCEPTION, e).sendToTarget();
+        }
+      } catch (InterruptedException e) {
+        // The load was canceled.
+        Assertions.checkState(canceled);
+        if (!released) {
+          sendEmptyMessage(MSG_END_OF_SOURCE);
+        }
+      } catch (Exception e) {
+        // This should never happen, but handle it anyway.
+        Log.e(TAG, "Unexpected exception loading stream", e);
+        if (!released) {
+          obtainMessage(MSG_IO_EXCEPTION, new UnexpectedLoaderException(e)).sendToTarget();
+        }
+      } catch (OutOfMemoryError e) {
+        // This can occur if a stream is malformed in a way that causes an extractor to think it
+        // needs to allocate a large amount of memory. We don't want the process to die in this
+        // case, but we do want the playback to fail.
+        Log.e(TAG, "OutOfMemory error loading stream", e);
+        if (!released) {
+          obtainMessage(MSG_IO_EXCEPTION, new UnexpectedLoaderException(e)).sendToTarget();
+        }
+      } catch (Error e) {
+        // We'd hope that the platform would kill the process if an Error is thrown here, but the
+        // executor may catch the error (b/20616433). Throw it here, but also pass and throw it from
+        // the handler thread so that the process dies even if the executor behaves in this way.
+        Log.e(TAG, "Unexpected error loading stream", e);
+        if (!released) {
+          obtainMessage(MSG_FATAL_ERROR, e).sendToTarget();
+        }
+        throw e;
+      }
+    }
+
+}
+```
+
+要想看ExtractingLoadable.load()方法，需要先看一下ExtractingLoadable类，以及他的构造函数:
+```
+/** Loads the media stream and extracts sample data from it. */
+final class ExtractingLoadable implements Loadable, IcyDataSource.Listener {
+    // DataSource是从流中读取数据的部分
+    public ExtractingLoadable(
+        Uri uri,
+        DataSource dataSource,
+        ExtractorHolder extractorHolder,
+        ExtractorOutput extractorOutput,
+        ConditionVariable loadCondition) {
+      this.uri = uri;
+      this.dataSource = new StatsDataSource(dataSource);
+      this.extractorHolder = extractorHolder;
+      this.extractorOutput = extractorOutput;
+      this.loadCondition = loadCondition;
+      this.positionHolder = new PositionHolder();
+      this.pendingExtractorSeek = true;
+      this.length = C.LENGTH_UNSET;
+      dataSpec = buildDataSpec(/* position= */ 0);
+    }
+
+    public void load() throws IOException, InterruptedException {
+      int result = Extractor.RESULT_CONTINUE;
+      while (result == Extractor.RESULT_CONTINUE && !loadCanceled) {
+        ExtractorInput input = null;
+        try {
+          long position = positionHolder.position;
+          // DataSpec是表示数据区域的对象，buildDataSpec会通过Uri和position来确定具体的数据区间
+          dataSpec = buildDataSpec(position);
+          // 获取数据的长度
+          length = dataSource.open(dataSpec);
+          if (length != C.LENGTH_UNSET) {
+            length += position;
+          }
+          Uri uri = Assertions.checkNotNull(dataSource.getUri());
+          icyHeaders = IcyHeaders.parse(dataSource.getResponseHeaders());
+          DataSource extractorDataSource = dataSource;
+          if (icyHeaders != null && icyHeaders.metadataInterval != C.LENGTH_UNSET) {
+            extractorDataSource = new IcyDataSource(dataSource, icyHeaders.metadataInterval, this);
+            icyTrackOutput = icyTrack();
+            icyTrackOutput.format(ICY_FORMAT);
+          }
+          input = new DefaultExtractorInput(extractorDataSource, position, length);
+          // Extractor是从视频容器中获取数据的，selectExtractor方法内部会去选择对应的Extractor
+          // 如果是MP4的话，这里就会返回Mp4Extractor对象
+          Extractor extractor = extractorHolder. (input, extractorOutput, uri);
+
+          // MP3 live streams commonly have seekable metadata, despite being unseekable.
+          if (icyHeaders != null && extractor instanceof Mp3Extractor) {
+            ((Mp3Extractor) extractor).disableSeeking();
+          }
+
+          if (pendingExtractorSeek) {
+            extractor.seek(position, seekTimeUs);
+            pendingExtractorSeek = false;
+          }
+          while (result == Extractor.RESULT_CONTINUE && !loadCanceled) {
+            loadCondition.block();
+            // extractor不断从input流中取读取数据，如果是mp4extractor的话
+            // 里面会先执行readAtomHeader，然后atomheader解析完毕后去执行processMoovAtom
+            // 等moovatom执行完后就会通过message回调onPrepared方法
+            result = extractor.read(input, positionHolder);
+            if (input.getPosition() > position + continueLoadingCheckIntervalBytes) {
+              position = input.getPosition();
+              loadCondition.close();
+              // 执行完成后会执行到onContinueLoadingRequestedRunnable中
+              handler.post(onContinueLoadingRequestedRunnable);
+            }
+          }
+        } finally {
+          if (result == Extractor.RESULT_SEEK) {
+            result = Extractor.RESULT_CONTINUE;
+          } else if (input != null) {
+            positionHolder.position = input.getPosition();
+          }
+          Util.closeQuietly(dataSource);
+        }
+      }
+    }
+}
+```
+我们看到数据加载完成后会执行到onContinueLoadingRequestedRunnable中:  
+而该Runnable的实现: 
+```
+onContinueLoadingRequestedRunnable =
+    () -> {
+      if (!released) {
+        Assertions.checkNotNull(callback)
+            .onContinueLoadingRequested(ProgressiveMediaPeriod.this);
+      }
+    };
+```
+会调用到onContinueLoadingRequested，该实现类就是ExoPlayerImplInternal类:  
+```
+  @Override
+  public void onContinueLoadingRequested(MediaPeriod source) {
+    handler.obtainMessage(MSG_SOURCE_CONTINUE_LOADING_REQUESTED, source).sendToTarget();
+  }
+```
+又是发消息，我们继续看下handleMessage方法里面的MSG_SOURCE_CONTINUE_LOADING_REQUESTED，收到该message会执行以下方法: 
+```
+private void handleContinueLoadingRequested(MediaPeriod mediaPeriod) {
+    if (!queue.isLoading(mediaPeriod)) {
+      // Stale event.
+      return;
+    }
+    queue.reevaluateBuffer(rendererPositionUs);
+    // 尝试去加载下一个MediaPeriod
+    maybeContinueLoading();
+}
+
+  private void maybeContinueLoading() {
+    MediaPeriodHolder loadingPeriodHolder = queue.getLoadingPeriod();
+    long nextLoadPositionUs = loadingPeriodHolder.getNextLoadPositionUs();
+    if (nextLoadPositionUs == C.TIME_END_OF_SOURCE) {
+      setIsLoading(false);
+      return;
+    }
+    long bufferedDurationUs =
+        getTotalBufferedDurationUs(/* bufferedPositionInLoadingPeriodUs= */ nextLoadPositionUs);
+    boolean continueLoading =
+        loadControl.shouldContinueLoading(
+            bufferedDurationUs, mediaClock.getPlaybackParameters().speed);
+    setIsLoading(continueLoading);
+    if (continueLoading) {
+      loadingPeriodHolder.continueLoading(rendererPositionUs);
+    }
+  }
+```
+到这里基本讲完了doSomeWork()部分。  
+
+
+总结一下:   
+1. SimpleExoPlayer.prepare()里面调用ExoPlayerImpl.prepare()然后再调用ExoPlayerImplInternal.prepare()然后ExoPlayerImplInternal里面通过handler发送MSG_PREPARE，收到message后会执行prepareInternal()方法，这里面先是调用MediaSouorce.prepare去做一些初始化操作，然后再发送MSG_DO_SOME_WORK，收到改消息后执行doSomeWork()(这个方法执行完后会发消息，再循环执行doSomeWork()方法)，这里面再调用updatePeriods()方法。     
+2. 这个updatePeroid()方法呢灰常重要，里面又是三步: 第一个步骤是去加载MediaPeroid，然后调用MediaPeriod.prepare()方法，这里面又调用ExtractingLoadable去加载数据，里面会用DataSource和Extractor去解析数据(解析mp4文件的moov数据后执行onPrepared回调)。 第二步是在playWhenReady后，会执行queue.advancePlayingPeriod()，这里面会去设置要播放的playingMediaPeriodHolder。第三部是执行updatePlayingPeriodRenderers()方法，这里面会取playingMediaPeriodHolder然后调用enableRenderers()方法，该方法里面循环遍历renderers数组，对每个都调用renderer.start()。
+
+下一篇文章会通过序列图的方式来描述一下这部分的调用逻辑。
+
+
+
+[上一篇: 2. ExoPlayer MediaSource简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/2.%20ExoPlayer%20MediaSource%E7%AE%80%E4%BB%8B.md)     
+[下一篇: 4. ExoPlayer源码分析之prepare序列图](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/4.%20ExoPlayer%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E4%B9%8Bprepare%E5%BA%8F%E5%88%97%E5%9B%BE.md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/ExoPlayer/4. ExoPlayer\346\272\220\347\240\201\345\210\206\346\236\220\344\271\213prepare\345\272\217\345\210\227\345\233\276.md" "b/VideoDevelopment/ExoPlayer/4. ExoPlayer\346\272\220\347\240\201\345\210\206\346\236\220\344\271\213prepare\345\272\217\345\210\227\345\233\276.md"
new file mode 100644
index 00000000..61d0babf
--- /dev/null
+++ "b/VideoDevelopment/ExoPlayer/4. ExoPlayer\346\272\220\347\240\201\345\210\206\346\236\220\344\271\213prepare\345\272\217\345\210\227\345\233\276.md"	
@@ -0,0 +1,51 @@
+4.ExoPlayer源码分析之prepare序列图    
+---    
+
+
+上面源码分析完了后，发现一脸懵逼，只是简单的知道了怎么调用的，都是啥，但是并不知道每个类具体是干啥的，以及他们之间的关联关系
+
+
+```sequence
+SimpleExoPlayer->ExoPlayerImpl: player.prepare(mediaSource)
+ExoPlayerImpl->ExoPlayerImplInternal: internalPlayer.prepare(mediaSource)
+ExoPlayerImplInternal->ExoPlayerImplInternal: MSG_PREPARE
+ExoPlayerImplInternal->ExoPlayerImplInternal: prepareInternal
+ExoPlayerImplInternal->MediaSource: mediaSource.prepareSource()
+ExoPlayerImplInternal->ExoPlayerImplInternal: DO_SOME_WORK
+ExoPlayerImplInternal->MediaPeriodQueue: doSomeWork()
+ExoPlayerImplInternal->Renderer: renderer.render()
+MediaPeriodQueue->MediaPeriodHolder: queue.getPlayingPeriod()
+MediaPeriodHolder->MediaPeriod: createMediaPeriod()
+ExoPlayerImplInternal->MediaPeriod: doSomeWork(updatePeriods())
+MediaPeriod->ExtractingLoadable: prepare()
+ExtractingLoadable->DataSource: load()
+ExtractingLoadable->Extracotr(Mp4Extractor): load()
+Extracotr(Mp4Extractor)->Extracotr(Mp4Extractor): readAtomHeader() processAtomEnded()processMoovAtom
+Extracotr(Mp4Extractor)->ProgressiveMediaPeriod: endTracks()
+ProgressiveMediaPeriod->ExoPlayerImplInternal: onPrepared(MediaPeriod source)
+ExoPlayerImplInternal->ExoPlayerImplInternal: handlePeriodPrepared
+ExoPlayerImplInternal->Renderer: enableRenderer
+Renderer->Renderer: if (isPlaying) {renderer.start()}
+```
+
+
+
+<img src="https://github.com/CharonChui/Pictures/blob/master/ExoPlayer_prepare.png?raw=true" width="150%" height="150%">
+
+
+
+
+[上一篇: 3. ExoPlayer源码分析之prepare方法](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/3.%20ExoPlayer%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E4%B9%8Bprepare%E6%96%B9%E6%B3%95.md)       
+[下一篇: 5. ExoPlayer源码分析之PlayerView](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)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/ExoPlayer/5. ExoPlayer\346\272\220\347\240\201\345\210\206\346\236\220\344\271\213PlayerView.md" "b/VideoDevelopment/ExoPlayer/5. ExoPlayer\346\272\220\347\240\201\345\210\206\346\236\220\344\271\213PlayerView.md"
new file mode 100644
index 00000000..f9b839f7
--- /dev/null
+++ "b/VideoDevelopment/ExoPlayer/5. ExoPlayer\346\272\220\347\240\201\345\210\206\346\236\220\344\271\213PlayerView.md"	
@@ -0,0 +1,344 @@
+5.ExoPlayer源码分析之PlayerView
+---
+
+前面两篇文章大体看了一下ExoPlayer.prepare()部分，接下来，我们要看一下UI部分的封装，PlayerView:   
+
+xml声明:   
+```
+<com.google.android.exoplayer2.ui.PlayerView
+    android:id="@+id/mPlayerView"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" />
+```
+
+```kotlin
+private lateinit var mPlayer: SimpleExoPlayer
+private fun initView(context: Context) {
+    val view = View.inflate(context, R.layout.video_view, this)
+    mPlayer = ExoPlayerFactory.newSimpleInstance(context)
+    // 通过PlayerView.setPlayer方法来将ExoPlayer绑定到View上
+    mPlayerView.player = mPlayer
+}
+```
+
+```
+public class PlayerView extends FrameLayout implements AdsLoader.AdViewProvider {
+    // 构造函数
+    public PlayerView(Context context, AttributeSet attrs, int defStyleAttr) {
+    super(context, attrs, defStyleAttr);
+
+    LayoutInflater.from(context).inflate(playerLayoutId, this);
+    componentListener = new ComponentListener();
+    setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
+
+    // Content frame.
+    contentFrame = findViewById(R.id.exo_content_frame);
+    if (contentFrame != null) {
+      setResizeModeRaw(contentFrame, resizeMode);
+    }
+
+    // Shutter view.
+    shutterView = findViewById(R.id.exo_shutter);
+    if (shutterView != null && shutterColorSet) {
+      shutterView.setBackgroundColor(shutterColor);
+    }
+
+    // 看对应的SurfaceView的类型，创建SurfaceView或TextureView
+    if (contentFrame != null && surfaceType != SURFACE_TYPE_NONE) {
+      ViewGroup.LayoutParams params =
+          new ViewGroup.LayoutParams(
+              ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
+      switch (surfaceType) {
+        case SURFACE_TYPE_TEXTURE_VIEW:
+          surfaceView = new TextureView(context);
+          break;
+        case SURFACE_TYPE_MONO360_VIEW:
+          SphericalSurfaceView sphericalSurfaceView = new SphericalSurfaceView(context);
+          sphericalSurfaceView.setSingleTapListener(componentListener);
+          surfaceView = sphericalSurfaceView;
+          break;
+        default:
+          surfaceView = new SurfaceView(context);
+          break;
+      }
+      surfaceView.setLayoutParams(params);
+      contentFrame.addView(surfaceView, 0);
+    } else {
+      surfaceView = null;
+    }
+
+    // Ad overlay frame layout.
+    adOverlayFrameLayout = findViewById(R.id.exo_ad_overlay);
+
+    // Overlay frame layout.
+    overlayFrameLayout = findViewById(R.id.exo_overlay);
+
+    // Artwork view.
+    artworkView = findViewById(R.id.exo_artwork);
+    this.useArtwork = useArtwork && artworkView != null;
+    if (defaultArtworkId != 0) {
+      defaultArtwork = ContextCompat.getDrawable(getContext(), defaultArtworkId);
+    }
+
+    // Subtitle view.
+    subtitleView = findViewById(R.id.exo_subtitles);
+    if (subtitleView != null) {
+      subtitleView.setUserDefaultStyle();
+      subtitleView.setUserDefaultTextSize();
+    }
+
+    // Buffering view.
+    bufferingView = findViewById(R.id.exo_buffering);
+    if (bufferingView != null) {
+      bufferingView.setVisibility(View.GONE);
+    }
+    this.showBuffering = showBuffering;
+
+    // Error message view.
+    errorMessageView = findViewById(R.id.exo_error_message);
+    if (errorMessageView != null) {
+      errorMessageView.setVisibility(View.GONE);
+    }
+
+    // Playback control view.
+    PlayerControlView customController = findViewById(R.id.exo_controller);
+    View controllerPlaceholder = findViewById(R.id.exo_controller_placeholder);
+    if (customController != null) {
+      this.controller = customController;
+    } else if (controllerPlaceholder != null) {
+      // Propagate attrs as playbackAttrs so that PlayerControlView's custom attributes are
+      // transferred, but standard attributes (e.g. background) are not.
+      this.controller = new PlayerControlView(context, null, 0, attrs);
+      controller.setId(R.id.exo_controller);
+      controller.setLayoutParams(controllerPlaceholder.getLayoutParams());
+      ViewGroup parent = ((ViewGroup) controllerPlaceholder.getParent());
+      int controllerIndex = parent.indexOfChild(controllerPlaceholder);
+      parent.removeView(controllerPlaceholder);
+      parent.addView(controller, controllerIndex);
+    } else {
+      this.controller = null;
+    }
+    this.controllerShowTimeoutMs = controller != null ? controllerShowTimeoutMs : 0;
+    this.controllerHideOnTouch = controllerHideOnTouch;
+    this.controllerAutoShow = controllerAutoShow;
+    this.controllerHideDuringAds = controllerHideDuringAds;
+    this.useController = useController && controller != null;
+    hideController();
+  }
+
+
+  public void setPlayer(@Nullable Player player) {
+    if (this.player == player) {
+      return;
+    }
+    if (this.player != null) {
+      this.player.removeListener(componentListener);
+      Player.TextComponent oldTextComponent = this.player.getTextComponent();
+      if (oldTextComponent != null) {
+        oldTextComponent.removeTextOutput(componentListener);
+      }
+    }
+    this.player = player;
+    // 把Player设置给PlayerControlView
+    if (useController) {
+      controller.setPlayer(player);
+    }
+    if (subtitleView != null) {
+      subtitleView.setCues(null);
+    }
+    updateBuffering();
+    updateErrorMessage();
+    updateForCurrentTrackSelections(/* isNewPlayer= */ true);
+    if (player != null) {
+        // 注意下这里
+      Player.VideoComponent newVideoComponent = player.getVideoComponent();
+      if (newVideoComponent != null) {
+        if (surfaceView instanceof TextureView) {
+          newVideoComponent.setVideoTextureView((TextureView) surfaceView);
+        } else if (surfaceView instanceof SphericalSurfaceView) {
+          ((SphericalSurfaceView) surfaceView).setVideoComponent(newVideoComponent);
+        } else if (surfaceView instanceof SurfaceView) {
+          newVideoComponent.setVideoSurfaceView((SurfaceView) surfaceView);
+        }
+        newVideoComponent.addVideoListener(componentListener);
+      }
+      Player.TextComponent newTextComponent = player.getTextComponent();
+      if (newTextComponent != null) {
+        newTextComponent.addTextOutput(componentListener);
+      }
+      player.addListener(componentListener);
+      maybeShowController(false);
+    } else {
+      hideController();
+    }
+  }
+}
+```
+
+构造函数里面只是创建了SurfaceView，然后添加了一些其他的View，例如PlayerControlView。
+
+看到这里有个问题,PlayerView里面会去创建SurfaceView，那它是怎么传递到ExoPlayerl里面的? 
+
+```
+     // 注意下这里
+      Player.VideoComponent newVideoComponent = player.getVideoComponent();
+      if (newVideoComponent != null) {
+        if (surfaceView instanceof TextureView) {
+          newVideoComponent.setVideoTextureView((TextureView) surfaceView);
+        } else if (surfaceView instanceof SphericalSurfaceView) {
+          ((SphericalSurfaceView) surfaceView).setVideoComponent(newVideoComponent);
+        } else if (surfaceView instanceof SurfaceView) {
+          newVideoComponent.setVideoSurfaceView((SurfaceView) surfaceView);
+        }
+        newVideoComponent.addVideoListener(componentListener);
+      }
+```
+
+newVideoComponent.setVideoTextureView里面会调用SimpleExoPlayer中的setVideoSurfaceView:  
+```
+ @Override
+  public void setVideoSurfaceView(SurfaceView surfaceView) {
+    setVideoSurfaceHolder(surfaceView == null ? null : surfaceView.getHolder());
+  }
+
+  @Override
+  public void setVideoSurfaceHolder(SurfaceHolder surfaceHolder) {
+    verifyApplicationThread();
+    removeSurfaceCallbacks();
+    this.surfaceHolder = surfaceHolder;
+    if (surfaceHolder == null) {
+      setVideoSurfaceInternal(null, false);
+      maybeNotifySurfaceSizeChanged(/* width= */ 0, /* height= */ 0);
+    } else {
+      surfaceHolder.addCallback(componentListener);
+      Surface surface = surfaceHolder.getSurface();
+      if (surface != null && surface.isValid()) {
+        setVideoSurfaceInternal(surface, /* ownsSurface= */ false);
+        Rect surfaceSize = surfaceHolder.getSurfaceFrame();
+        maybeNotifySurfaceSizeChanged(surfaceSize.width(), surfaceSize.height());
+      } else {
+        setVideoSurfaceInternal(/* surface= */ null, /* ownsSurface= */ false);
+        maybeNotifySurfaceSizeChanged(/* width= */ 0, /* height= */ 0);
+      }
+    }
+  }
+```
+然后会调用setVideoSurfaceInternal:   
+```
+  private void setVideoSurfaceInternal(@Nullable Surface surface, boolean ownsSurface) {
+    // Note: We don't turn this method into a no-op if the surface is being replaced with itself
+    // so as to ensure onRenderedFirstFrame callbacks are still called in this case.
+    List<PlayerMessage> messages = new ArrayList<>();
+    // 遍历所有renderer，如果是视频类型
+    for (Renderer renderer : renderers) {
+      if (renderer.getTrackType() == C.TRACK_TYPE_VIDEO) {
+        messages.add(
+            // 发送msg给MediaCodecVideoRenderer
+            player.createMessage(renderer).setType(C.MSG_SET_SURFACE).setPayload(surface).send());
+      }
+    }
+    // 如果之前有surface，把之前的释放掉
+    if (this.surface != null && this.surface != surface) {
+      // We're replacing a surface. Block to ensure that it's not accessed after the method returns.
+      try {
+        for (PlayerMessage message : messages) {
+          message.blockUntilDelivered();
+        }
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+      }
+      // If we created the previous surface, we are responsible for releasing it.
+      if (this.ownsSurface) {
+        this.surface.release();
+      }
+    }
+    this.surface = surface;
+    this.ownsSurface = ownsSurface;
+  }
+```
+
+接下来继续看一下MediaCodecVideoRenderer里面处理Message的部分: 
+```
+ @Override
+  public void handleMessage(int messageType, @Nullable Object message) throws ExoPlaybackException {
+    if (messageType == C.MSG_SET_SURFACE) {
+      // 直接调用setSurface()方法
+      setSurface((Surface) message);
+    } else if (messageType == C.MSG_SET_SCALING_MODE) {
+      scalingMode = (Integer) message;
+      MediaCodec codec = getCodec();
+      if (codec != null) {
+        codec.setVideoScalingMode(scalingMode);
+      }
+    } else if (messageType == C.MSG_SET_VIDEO_FRAME_METADATA_LISTENER) {
+      frameMetadataListener = (VideoFrameMetadataListener) message;
+    } else {
+      super.handleMessage(messageType, message);
+    }
+  }
+```
+接着看一下setSurface()方法:    
+```
+private void setSurface(Surface surface) throws ExoPlaybackException {
+    if (surface == null) {
+      // Use a dummy surface if possible.
+      if (dummySurface != null) {
+        surface = dummySurface;
+      } else {
+        MediaCodecInfo codecInfo = getCodecInfo();
+        if (codecInfo != null && shouldUseDummySurface(codecInfo)) {
+          dummySurface = DummySurface.newInstanceV17(context, codecInfo.secure);
+          surface = dummySurface;
+        }
+      }
+    }
+    // We only need to update the codec if the surface has changed.
+    if (this.surface != surface) {
+      this.surface = surface;
+      @State int state = getState();
+      MediaCodec codec = getCodec();
+      if (codec != null) {
+        if (Util.SDK_INT >= 23 && surface != null && !codecNeedsSetOutputSurfaceWorkaround) {
+          setOutputSurfaceV23(codec, surface);
+        } else {
+          releaseCodec();
+          maybeInitCodec();
+        }
+      }
+      if (surface != null && surface != dummySurface) {
+        // If we know the video size, report it again immediately.
+        maybeRenotifyVideoSizeChanged();
+        // We haven't rendered to the new surface yet.
+        clearRenderedFirstFrame();
+        if (state == STATE_STARTED) {
+          setJoiningDeadlineMs();
+        }
+      } else {
+        // The surface has been removed.
+        clearReportedVideoSize();
+        clearRenderedFirstFrame();
+      }
+    } else if (surface != null && surface != dummySurface) {
+      // The surface is set and unchanged. If we know the video size and/or have already rendered to
+      // the surface, report these again immediately.
+      maybeRenotifyVideoSizeChanged();
+      maybeRenotifyRenderedFirstFrame();
+    }
+  }
+```
+
+
+[上一篇: 4. ExoPlayer源码分析之prepare序列图](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/4.%20ExoPlayer%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E4%B9%8Bprepare%E5%BA%8F%E5%88%97%E5%9B%BE.md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- 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"
new file mode 100644
index 00000000..72414061
--- /dev/null
+++ "b/VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md"
@@ -0,0 +1,60 @@
+1.FFmpeg简介
+===
+
+[FFmpeg](https://ffmpeg.org/)是一个开源免费跨平台的视频和音频流方案，属于自由软件，采用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。
+
+
+
+主要的工具集：
+
+- ffmpeg：一个命令行工具，可用于格式转换、解码、编码等；
+- ffsever：一个 HTTP 、RTSP的实时广播流媒体服务器；
+- ffplay：是一个简单的播放器，使用ffmpeg 库解析和解码，通过SDL显示；
+- 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  
+- 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"
new file mode 100644
index 00000000..a00c00c4
--- /dev/null
+++ "b/VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
@@ -0,0 +1,530 @@
+2.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 不处理音频
+
+
+9. 压缩转码mp4文件
+```
+ffmpeg -i input.avi -s 640x480 output.avi
+
+ffmpeg -i input.avi -s vga output.avi
+```
+10. 将文件当做直播送至live
+```
+ffmpeg -re -i localFile.mp4 -c copy -f flv rtmp://server/live/streamName
+```
+11. 将直播媒体保存至本地文件
+```
+ffmpeg -i rtmp://server/live/streamName -c copy dump.flv
+```
+12. 将其中一个直播流，视频改用h264压缩，音频不变，送至另外一个直播服务流
+
+```
+ffmpeg -i rtmp://server/live/originalStream -c:a copy -c:v libx264 -vpre slow -f flv rtmp://server/live/h264Stream
+```
+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
+```
+14. 将其中一个直播流，视频不变，音频改用faac压缩，送至另外一个直播服务流
+```
+ffmpeg -i rtmp://server/live/originalStream -acodec libfaac -ar 44100 -ab 48k -vcodec copy -f flv rtmp://server/live/h264_AAC_Stream
+```
+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
+```
+
+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
+```
+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〃
+```
+
+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。
+
+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
+```
+
+21. ffmpeg从视频中生成gif图片：
+```
+ffmpeg -i capx.mp4 -t 10 -s 320x240 -pix_fmt rgb24 jidu1.gif
+```
+
+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置于文件头部。
+
+24. 设置视频帧率
+滤镜fps可以设置输入视频的帧率。当输入视频的帧率与设置帧率不一致时，ffmpeg将通过丢帧或复制当前帧的方式确保输出视频帧率的稳定性。滤镜fps支持的参数如下。◎ fps：指定输出视频的帧率，默认为25。◎ start_time：指定起始时间戳。◎ round：时间戳近似方法。◎ eof_action：末尾帧的处理方法。通过以下命令可以将输入视频的帧率设置为30。
+```
+ffmpeg -i input.mp4 -vf fps=fps=30 -y output.mp4
+```
+
+
+
+
+### ffplay
+
+ffplay是以FFmpeg框架为基础，外加渲染音视频的库libSDL构建的媒体文件播放器。ffplay不仅仅是播放器，同时也是测试ffmpeg的codec引擎、format引擎以及filter引擎的工具。并且还可以进行媒体参数分析，可以通过ffplay --help进行查看。 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_ffplay.png?raw=true)
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_ffplay1.png?raw=true)
+
+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播放音频文件，播放的时候其将会把解码后的音频数据以音频波形的形式显示出来，命令行执行后的效果如图2-8所示，命令如下：
+`ffplay -showmode 1 output.mp3`
+
+
+##### 音画同步
+
+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 --help来查看详细的帮助信息。
+
+命令格式: 
+`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 /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]
+```
+这个文件的格式有可能是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 /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 /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)
+
+
+
+##### 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
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/VideoDevelopment/FFmpeg/3.FFmpeg\345\210\207\347\211\207.md" "b/VideoDevelopment/FFmpeg/3.FFmpeg\345\210\207\347\211\207.md"
new file mode 100644
index 00000000..d03ed441
--- /dev/null
+++ "b/VideoDevelopment/FFmpeg/3.FFmpeg\345\210\207\347\211\207.md"
@@ -0,0 +1,12 @@
+3.FFmpeg切片
+===
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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..0cfbb91a
--- /dev/null
+++ "b/VideoDevelopment/FFmpeg/5.FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"
@@ -0,0 +1,204 @@
+## 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 文件）。需要注意的是，本程序并不进行视音频的编码和解码工作。
+而是直接将视音频压缩码流从一种封装格式文件中获取出来然后打包成另外一种封装格式
+的文件。
+
+### 读取视频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]
+```
+
+
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/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/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..f9dd0282
--- /dev/null
+++ "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
@@ -0,0 +1,201 @@
+1.OpenCV简介
+===
+
+[OpenCV官网](https://opencv.org/)
+
+
+### OpenCV4简介
+
+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
+
+Mat是一个基本图像容器，也是一个类，数据由两个部分组成:   
+- 矩阵头(包含矩阵尺寸、存储方法、存储地址等信息)
+- 一个指向存储所有像素值的矩阵的指针
+
+API：
+- imread(..url...)：加载本地图像
+	默认的BGR 彩色图像加载方式，此外支持灰度图像和任意格式。注意：在OpenCV中颜色值写法是BGR，而不是RGB。
+    imread() 函数默认加载图像文件，加载进来的是3 通道彩色图像，色彩空间是RGB 色彩空间。
+    通道顺序是：BGR （蓝色、绿色、红色）。
+    通道分离函数：split()
+    通道合并函数：merge()
+- imshow("namexx", ...url...)：显示图像
+- getStructuringElement(...)：获取腐蚀的内核矩阵
+- erode(...)：腐蚀(源图像、目的图像、内核矩阵）
+- blur(...) ：模糊
+- cvtColor(...)：颜色转换
+- Canny(...)：提取边缘
+- waitKey(int delay = 0)：等待按键
+- 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 两个函数实现数据完全复制
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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/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..ec827301
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -0,0 +1,777 @@
+## 1.OpenGL简介
+
+OpenGL(Open Graphics Library开放图形库)是用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程**接口**。
+
+
+然而，**OpenGL本身并不是一个API，它仅仅是一个由Khronos组织制定并维护的规范(Specification)**。
+
+**OpenGL规范严格规定了每个函数该如何执行，以及它们的输出值。至于内部具体每个函数是如何实现(Implement)的，将由编写OpenGL库的人自行决定。**
+
+[OpenGL官网](https://www.opengl.org/)
+
+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，当然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渲染。        
+
+CPU和GPU因为涉及之初需求就不一样，所以它们的组成不同，在计算机中的分工也不同。    
+GPU有更多的ALU(算术逻辑单元，能实现多组算术运算和逻辑运算的组合逻辑电路)，而CPU有Control单元和Cache单元，普通的业务代码因为逻辑复杂，数据类型复杂、跳转复杂、依赖性高等，就更适合CPU来做。    
+
+而GPU不擅长处理这些复杂的逻辑，它更擅长处理单一的运算，大量的算术逻辑单元可以保证做到真正的高并发，所以大量的计算任务是适合它的工作，就比如GLSL代码。    
+
+简单说就是CPU更像管理者，负责调度和控制，也进行小量的计算，而GPU则是单纯的打工人，负责大量的计算工作。      
+
+
+
+
+目前为止最高效的方法就是有效的使用图形处理单元(GPU)，图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点运算，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
+
+
+- 图片处理:比如图片色调转换、美颜等。
+- 摄像头预览效果处理。比如美颜相机、恶搞相机等。
+- 视频处理。视频播放的时候增加一些滤镜效果。
+- 3D游戏。比如神庙逃亡、都市赛车等。
+
+
+
+图像数据无非是一个个的像素点，对图像数据的处理无非是对每个像素点进行计算后重新赋值，一般来说对每个像素点的计算都比较独立，计算也相对简单。CPU虽然计算能力强大，但是并行处理能力有限，对一张720P的图片，一共包含720*1280=921600个像素，要进行这么多次运算，CPU也要望洋兴叹了。GPU与CPU相比最大的优势就是并行处理能力，一般移动端的GPU也要包含数千个处理单元，这些处理单元虽然计算能力比不上CPU，但是却可以同时处理几千个像素点。像素点数据的计算相对简单，而且可以同时处理几千个像素点，图像数据用GPU来做计算就非常适合了。而怎么使用GPU呢？这就要介绍到目前使用最广泛的2D、3D矢量图形沉浸API：OpenGL了。
+
+
+
+### 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 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. 
+
+- OpenGL自身是一个巨大的状态机: 描述该如何操作的所有变量的大集合
+- OpenGL的状态通常被称为上下文(Context)
+- 状态设置函数(State-changing Function): 该类函数将会改变上下文	
+- 状态应用的函数(State-using Function): 该类函数会根据当前OpenGL的状态执行一些操作。    
+
+![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提供的设置窗口颜色位数的某个方法
+    ....
+}
+```
+
+
+但是，这样也有问题:        
+
+- 当前状态只有一份，如果每次显示不同的效果，都重新配置会很麻烦。 
+- 这时候我们就需要一些小助理(对象)，来帮忙记录某些状态信息，以便复用。  
+
+如果我们有10种子集，那就需要10个小助理(对象)，而当前状态(Context，只有一份)可以通过装配这些对象来完成。 
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_zhuli.jpg?raw=true)
+
+
+通常把OpenGL上下文比作一个大的结构体，包含很多子集。
+
+在OpenGL中一个对象是指一些选项的集合，它代表OpenGL状态的一个子集。     
+比如，我们可以用一个对象来代表绘制窗口的设置，之后我们就可以设置它的大小等。      
+
+```C
+// OpenGL的状态
+struct OpenGL_Context {
+    ....
+    object *object_Window_Target;  // 设置窗口大小、颜色位数等的对象
+    ....
+}
+```
+
+
+
+```c++
+// 创建对象    
+unsigned int objectId = 0;
+glGenObject(1, &objectId);
+
+// 绑定对象至上下文
+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，大多译为管线，实际上指的是一堆原始图形数据途经一个输送管道，期间经过各种变化处理最终出现在屏幕的过程）管理的。        
+
+图形渲染管线可以被划分为两个主要部分:       
+
+- 第一部分把你的3D坐标转换为2D坐标
+- 第二部分是把2D坐标转变为实际的有颜色的像素
+
+图形渲染管线接收一组3D坐标，然后把它们转变为你屏幕上的有色2D像素输出。          
+
+图形渲染管线可以被划分为几个阶段，每个阶段将会把前一个阶段的输出作为输入。      
+所有这些阶段都是高度专门化的（它们都有一个特定的函数），并且很容易并行执行。          
+正是由于它们具有并行执行的特性，当今大多数显卡都有成千上万的小处理核心，它们在GPU上为每一个（渲染管线）阶段运行各自的小程序，从而在图形渲染管线中快速处理你的数据。这些小程序叫做**着色器(Shader)**。
+
+简单来说，渲染管线就是一个顶点在呈现为像素之前经过的全部过程。
+
+- OpenGL 1.x系列采用的是固定功能管线。
+- OpenGL ES 2.0开始采用了可编程图形管线。
+- OpenGL ES 3.0兼容了2.0，并丰富了更多功能。
+
+OpenGL渲染管线的流程为: 
+>> 顶点数据 -> 顶点着色器 -> 图元装配 -> 几何着色器 -> 光栅化 -> 片段着色器 -> 逐片段处理 -> 帧缓冲   
+
+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)
+
+下面，你会看到一个图形渲染管线的每个阶段的抽象展示。    
+要注意蓝色部分代表的是我们可以注入自定义的着色器的部分:
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_progress.jpg)
+
+首先，我们以数组的形式传递3个3D坐标作为图形渲染管线的输入，用来表示一个三角形，这个数组叫做顶点数据(Vertex Data)；      
+顶点数据是一系列顶点的集合。     
+一个顶点(Vertex)是一个3D坐标的数据的集合。      
+而顶点数据是用顶点属性(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的新特性。
+
+
+
+### 依赖库
+
+OpenGL实际上并不是把图像直接绘制到计算机屏幕上，而是将之渲染到一个帧缓冲区。    
+然后由计算机来负责把帧缓冲区中的内容绘制到屏幕上的一个窗口中。有不少库都可以支持这一部分工作:     
+
+- 使用操作系统提供的窗口管理功能，比如Microsoft Windows API。但这通常不实用，因为需要很多底层的编码工作。   
+- FreeGLUT、GLOW、GLFW等库
+
+
+简要来说，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上运行的小程序。     
+从名称可以看出，可通过处理它们来处理顶点。        
+此程序使用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));
+```
+从调用glBindBuffer()这一刻起，我们使用的任何(在GL_ARRAY_BUFFER目标上的)缓冲调用都会用来配置当前绑定的缓冲(VBO)。      
+然后我们可以调用glBufferData()函数，它会把之前定义的顶点数据复制到缓冲的内存中(小助理把对应的数据单独记录下来了)。   
+     
+
+
+绑定对象的过程有点类似设置铁路的道岔开关。     
+一旦设置了开关，从这条线路通过的所有列车都会驶向对应的轨道。    
+如果我们将开关设置到另一个状态，那么所有之后经过的列车都会驶向另一条轨道。OpenGL的对象也是如此。     
+
+总体上来说，在两种情况下我们需要绑定一个对象:   
+- 创建对象并初始化它所对应的数据是。   
+- 每次我们准备使用这个对象，而它并不是当前绑定的对象时。   
+
+
+
+ 
+```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把数据发送到显卡相对较慢，所以只要可能我们都尝试尽量一次性发送尽可能多的数据。** 
+
+当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这个是非常快的过程。
+
+整体总结为:     
+
+- 它会在GPU上创建内存，用于存储我们的顶点数据
+    - 通过顶点缓冲对象(Vertex Buffer Objects, VBO)来管理数据，顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。
+    - OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型(每一个缓冲类型类似于前面说的子集，每个VBO是一个小助理)。
+
+- 配置OpenGL如何解释这些内存            
+
+
+通过顶点数组对象(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)
+
+    
+
+OpenGLES2.0编程中，用于绘制的顶点数组数据首先保存在CPU内存，在调用glDrawArrays或者glDrawElements等进行绘制时，需要将顶点数组数据从CPU内存拷贝到显存。
+
+但是很多时候我们没必要每次绘制的时候都去进行内存拷贝，如果可以在显存中缓存这些数据，就可以在很大程度上降低内存拷贝带来的开销。
+
+OpenGLES3.0 VBO和EBO的出现就是为了解决这个问题。VBO和EBO的作用是在显存中提前开辟好一块内存，用于缓存顶点数据或者图元索引数据，从而避免每次绘制时的CPU与GPU之间的内存拷贝，可以提升渲染性能，降低内存带宽和功耗。
+
+把数据发送给OpenGL管线还要更加复杂一点，有两种方式:    
+
+- 通过顶点属性的缓冲区。
+- 直接发送给统一变量。
+
+理解这两种方式的机制非常重要，因为这样我们才能为每个要发送的项目选取合适的方式。  
+
+
+### 缓冲区和顶点属性    
+
+想要绘制一个对象，它的顶点数据需要发送给顶点着色器。       
+通常会把顶点数据在放入一个缓冲区，并把这个缓冲区和着色器中声明的顶点属性相关联。         
+要完成这件事，有好几个步骤需要做，有些步骤只需要做一次，而对于动画场景，一些步骤则需要每帧做一次。只做一次的步骤如下，它们一般包含在init()中:      
+
+- 创建缓冲区。
+- 将顶点数据复制到缓冲区。    
+    - 每帧都要做的步骤如下，它们一般包含在display()中。
+- 启用包含顶点数据的缓冲区。
+- 将这个缓冲区和一个顶点属性相关联。
+- 启用这个顶点属性。
+- 使用glDrawArrays()绘制对象。      
+
+所有缓冲区通常都在程序开始的时候统一创建，可以在init()中，或者在被init()调用的函数中。       
+
+在OpenGL中，缓冲区被包含在顶点缓冲对象(Vertex Buffer Object, VBO)中，VBO在OpenGL应用程序中被声明和实例化。      
+
+一个场景可能需要很多VBO，所以我们常常会在init()中生成并填充若干个VBO，以备程序需要时直接使用。
+
+
+### 图元装配(Primitive Assembly)
+
+顶点组合成图元的过程叫做图元装配，这里的图元就是指点、线、三角。           
+图元装配阶段将顶点着色器输出的所有顶点作为输入(如果是GL_POINTS，那么就是一个顶点),并将所有的点装配成指定的图元的形状。           
+也就是说图元装配是将顶点着色器中设置的顶点数据装配成指定图元的形状。           
+
+OpenGL中最基础且唯一的多边形就是三角形，所有更复杂的图形都是由三角形组成的。复杂的图形都可以拆分成多个三角形。比如OpenGL提供给开发者的绘制方法glDrawArrays，这个方法的第一个参数就是指定绘制方式，可选值有:  
+
+- GL_POINTS:以点的形式绘制
+- GL_LINES:以线的形式绘制
+- GL_TRIANGLE_STRIP:以三角形的形式绘制，所有二维图像的渲染都会使用这种方式。
+
+该过程还有两个重要操作，裁剪和淘汰:      
+
+- 裁剪是指对于不在视椎体(屏幕上可见的3D区域)内的图元进行裁剪。
+- 淘汰是指根据图元面向前方或后方选择抛弃它们(如事物内部的点)。
+   
+### 几何着色器(Geometry Shader)     
+
+图元装配阶段的输出会传递给几何着色器(Geometry Shader)。        
+
+几何着色器把图元形式的一系列顶点的集合作为输入，它可以通过产生新顶点构造出新的图元来生成其他形状。例如它生成了另一个三角形。
+
+几何着色器的输出会被传入光栅化阶段(Rasterization Stage)，这里它会把图元映射为最终屏幕上相应的像素，生成供片段着色器(Fragment Shader)使用的片段(Fragment)。          
+
+在片段着色器运行之前会执行裁切(Clipping)。裁切会丢弃超出你的视图以外的所有像素，用来提升执行效率。
+
+### 光栅化阶段(Rasterization Stage)
+
+这里会把图元映射为最终屏幕上相应的像素，生成供片段着色器(fragment shader)使用的片段。       
+在图元装配后传递过来的图元数据中，这些图元信息只是顶点而已。         
+顶点处都还没有像素点，直线段端点之间是空的、多边形的边和内部也是空的，光栅化的任务就是构造这些。将图片转化为片段(fragment)的过程叫做光栅化。        
+
+这个阶段会将图元数据分解成更小的单元并对应于帧缓冲区的各个像素，这些单元成为片元，一个片元可能包含窗口颜色、纹理坐标等属性。
+
+光栅化其实是一种将几何图元变成二维图像的过程。在这里，虚拟3D世界中的物体投影到平面上，并生成一系列的片段。    
+
+### 片段着色器或片元着色器(Fragment Shader)
+
+
+显示设备屏幕都是离散化的(由一个一个的像素组成)，因此还需要将投影的结果离散化。    
+将其分解为一个个离散化的小单元，这些小单元一版称为片元。    
+
+其实每个片元都对应于帧缓冲中的一个像素，之所以不直接称为像素是因为3D空间中的物体是可以相互遮挡的。而一个3D场景最终显示到屏幕上虽然是一个整体，但每个3D物体的每个图元是独立处理的。这就可能出现这样的情况，系统先处理的是位于离观察点较远的图元，其光栅化成为了一组图元，暂时送入帧缓冲的对应位置。    
+
+但后面继续处理离观察点较近的图元时也光栅化出了一组片元，两组片元中有对应到帧缓冲中同一个位置的，这时距离近的片元将覆盖距离远的片元(如何覆盖的检测是在深度检测阶段完成的)。      
+
+因此，某片元就不一定能成为最终屏幕上的像素，称为像素就不准确了，可以将其理解为候选像素。    
+
+使用颜色或纹理(texture)渲染图形表面的OpenGLES代码。
+
+
+我们3D世界中的点、三角形、颜色等全都需要展现在一个2D显示器上。      
+这个2D屏幕由栅格(即矩形像素阵列)组成。当3D物体栅格化后，OpenGL会将物体中的图元(通常是三角形)转化为片段。    
+片段拥有关于像素的信息。栅格化过程确定了为了显示由3个顶点确定的三角形需要绘制的所有像素的位置。片段着色器用于为栅格化的像素指定颜色。    
+
+主要目的是计算一个像素的最终颜色。      
+所有片段着色器的目的都是给为要展示的像素赋予颜色。              
+
+光栅化操作构造了像素点(图元(点或三角形)转换成了像素的集合)，这个阶段就是处理这些像素点，根据自己的业务，例如高亮、饱和度调节、高斯模糊等来变化这个片元的颜色。      
+为组成点、直线和三角形的每个片元生成最终颜色/纹理，针对每个片元都会执行一次，一个片元是一个小的、单一颜色的长方形区域，类似于计算机屏幕上的一个像素。        
+一旦最终颜色生成，OpenGL就会把它们写到一块称为帧缓冲区的内存块中，然后Android就会把这个帧缓冲区显示到屏幕上。
+
+通常在这里对片段进行处理(纹理采样、颜色汇总等)，将每个片段的颜色等属性计算出来并送给后续阶段。
+
+可以看到，图形渲染管线非常复杂，它包含很多可配置的部分。然而，对于大多数场合，我们只需要配置顶点和片段着色器就行了。几何着色器是可选的，通常使用它默认的着色器就行了。
+
+**在现代OpenGL中，我们必须定义至少一个顶点着色器和一个片段着色器（因为GPU中没有默认的顶点/片段着色器）。**  
+
+
+光栅化后产生了多少个片元，就会插值计算出多少套in变量。同时，渲染管线就会调用多少次片元着色器。可以看出，一般情况下对一个3D物体的渲染中，片元着色器执行的次数会大大超过顶点着色器。
+
+因此，GPU硬件中配置的片元着色器硬件数量往往多于顶点着色器硬件数量，通过这些硬件单元的并行执行，提高渲染速度。
+
+整个处理过程又分为以下几个部分:     
+
+- 逐片段操作
+    具体的细分步骤又分为:  
+    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_fragment_opera.jpg)
+
+  - 像素归属测试
+
+    判断当前像素是否归OpenGL所有，即OpenGLES帧缓冲区窗口的部分是否被另一个窗口所遮蔽，被遮挡像素不属于OpenGL上下文。
+
+  - 裁剪测试
+
+    判断当前像素是否位于裁剪矩形范围内，如果位于裁剪区域外则被抛弃。
+
+  - 模板测试
+
+    模板测试主要将绘制区域限定在一定范围内，一般用在湖面倒影、镜像等场合。
+
+  - 深度测试
+
+    深度测试是将输入片元的深度与帧缓冲区中对应片元的深度进行比较，确定片段是否应该被拒绝。
+
+  - 混合
+
+    将新生成的片段和保存在缓冲区的片段进行混合。
+
+  - 抖动
+
+    用于最小化，因为使用有限精度在帧缓冲区中保存颜色值而产生的伪像，使用少量颜色模拟更宽的颜色范围。
+
+### 帧缓冲区
+
+像素(pixel)是显示器上最小的可见单元。计算机系统将所有的像素保存到帧缓存(framebuffer)当中，后者是由图形硬件设备管理的一块独立内存区域，可以直接映射到最终的显示设备上。     
+
+
+OpenGL实际上并不是把图像直接绘制到计算机屏幕上，而是将之渲染到一个帧缓冲区，然后由计算机来负责把帧缓冲区中的内容绘制到屏幕上的一个窗口中。            
+
+OpenGL管线的最终渲染目的地被称为帧缓存(framebuffer也被记做FBO)
+
+### 着色器语言
+
+GLSL(OpenGL Shading Language)是OpenGL着色语言。
+
+在图形卡的GPU上执行，代替了固定的渲染管线的一部分，是渲染管线中不同层次具有可编程性，例如：视图转换、投影转换等。GLSL的着色器代码分为两个部分: 
+
+  - 顶点着色器(Vertex Shader)
+  - 片段着色器(Fragment Shader)
+
+通常在CPU上编译、链接成二进制数据，然后将它拷贝到GPU上运行，在GPU上运行起来的就是渲染、合成的命令。它的编译是通过OpenGL API操作的。     
+
+### 坐标系
+
+OpenGL ES是一个3D的世界，由x、y、z坐标组成顶点坐标。采用虚拟的右手坐标。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_xy.png)
+
+OpenGL采用的是右手坐标，选取屏幕中心为原点，从原点到屏幕边缘默认长度为1，也就是默认情况下，从原点到x左边的1和到y左边的1的位置在屏幕上显示的并不相同。
+
+### 形状面和缠绕
+
+在OpenGL的世界里，我们只能画点、线、三角形，图元装配中说到所有复杂的图形都是由三角形组成。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_ex_xy_1.jpg)
+
+三角形的点按顺序定义，使得它们以逆时针方向绘制。绘制这些坐标的顺序定义了形状的缠绕方向。默认情况下，在OpenGL中，逆时针绘制的面是正面。
+
+### 程式(Program)
+
+一个OpenGL对象，包含了你所希望用来绘制图形所要用到的着色器，最后顶点着色器和片元着色器都要放入到程式中，然后才可以使用，简单的说就是将两个着色器变为一个程序对象。
+
+
+如果想要绘制图像，需要至少一个顶点着色器来定义一个图形顶点，以及一个片元着色器为该图形上色。这些着色器必须被编译然后再添加到一个OpenGL Program中，并利用这个Program来绘制形状。
+
+glUseProgram()用于将含有两个已编译着色器的程序载入OpenGL管线阶段(在GPU上)。   
+注意，glUseProgram()并没有运行着色器，它只是将着色器加载进硬件。   
+
+### 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提供基本的不透明类型--EGLDisplay，该类型封装了所有系统相关性，用于和原生窗口系统接口。任何使用EGL的应用程序必须执行的第一个操作就是创建和初始化与本地EGL显示的连接。
+
+EGL是OpenGL和本地窗口系统（Native Window System）之间的通信接口，它的主要作用：
+
+- 与设备的原生窗口系统通信；
+- 查询绘图表面的可用类型和配置；
+- 创建绘图表面；
+- 在OpenGL ES 和其他图形渲染API之间同步渲染；
+- 管理纹理贴图等渲染资源。
+OpenGL ES 的平台无关性正是借助 EGL 实现的，EGL 屏蔽了不同平台的差异。
+
+![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并显示出来。   
+
+补充说明： 
+应用程序使用单缓冲绘图时可能会存在图像闪烁的问题。这是因为生成的图像不是一下子被绘制出来的，而是按照从左到右，由上到下逐像素的绘制而成的。最终图像不是在瞬间显示给用户，而是通过一步一步生成的，这会导致渲染的结果很不真实。为了规避这些问题，就应用了双缓冲渲染模式，前缓冲保存着最终输出的图像，它会在屏幕上显示；    
+而所有的渲染指令都会在后缓冲上绘制。当所有的渲染指令执行完毕后，我们交换前缓冲和后缓冲，这样图像就立即呈现出来，刚才提到的不真实感就消除了。
+
+
+要在Android平台实现OpenGL渲染，需要完成一系列的EGL操作，主要为下面几步(后面分析GLSurfaceView源码的时候也是这样来实现的):   
+
+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渲染相关的操作都必须放在该线程中执行并且指定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)中的纹理。     
+创建Pbuffer和创建EGL窗口非常相似，只有少数微小的不同。为了创建Pbuffer，需要和窗口一样找到EGLConfig，并作一处修改：我们需要扩增EGL_SURFACE_TYPE的值，使其包含EGL_PBUFFER_BIT。
+
+
+
+#### OpenGL纹理
+
+纹理(Texture)是一个2D图片(也有1D和3D纹理)，他可以用来添加物体的细节，你可以想象纹理是一张绘有砖块的纸，无缝折叠贴合到你的3D房子上，这样你的房子看起来就有砖墙的外表了。
+
+
+#### 视频数据流
+
+视频从视频文件到屏幕显示出来，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中取出图形数据，显示到屏幕上
+
+
+### 参考
+
+---
+
+- [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)
+
+
+
+
+--- 
+
+- [下一篇: 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"
new file mode 100644
index 00000000..0eb4f1b9
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -0,0 +1,347 @@
+## 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传给相机，相机预览数据就会输出到这个纹理上了。
+3. 使用GLSurfaceView.Render将该纹理渲染到GLSurfaceView的窗口上。
+4. 使用SurfaceTexture的setOnFrameAvailableListener方法给SurfaceTexture添加一个数据帧可用的监听器，在监听器中调用GLSurfaceView的requestRender方法渲染该帧数据，这样相机每次输出一帧数据就可以渲染一次，在GLSurfaceView窗口中就可以看到相机的预览数据了。
+
+- 顶点着色器
+
+  ```glsl
+  #version 300 es
+  in vec4 vPosition;
+  in vec2 vCoordPosition;
+  out vec2 aCoordPosition;
+  
+  void main() {
+      gl_Position = vPosition;
+      aCoordPosition = vCoordPosition;
+  }
+  ```
+  
+- 片段着色器
+
+  这里需要注意一下，就是做相机预览和视频播放的话，纹理的类型需要使用samplerExternalOES，而不是之前渲染图片的sampler2D。这是因为相机和视频的数据是YUV的，而OpenGL ES是RGB的，samplerExternalOES内部会进行处理。#extension用于启用和设置扩展的行为。格式为#extension all : behavior。behavior的可选值有: require、enable、warn、disable。
+
+  ```glsl
+  #version 300 es
+  #extension GL_OES_EGL_image_external_essl3 : require
+  precision mediump float;
+  in vec2 aCoordPosition;
+  uniform samplerExternalOES uSamplerTexture;
+  out vec4 vFragColor;
+  void main() {
+      vFragColor = texture(uSamplerTexture, aCoordPosition);
+  }
+  ```
+
+
+
+### GLSurfaceView+MediaPlayer播放视频
+
+```java
+public class VideoPlayerActivity extends Activity {
+    private GLSurfaceView mGLSurfaceView;
+    private Surface mSurface;
+    private MediaPlayer mMediaPlayer;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_video_player);
+        mGLSurfaceView = findViewById(R.id.mGLSurfaceView);
+        mGLSurfaceView.setEGLContextClientVersion(3);
+        VideoPlayerRender videoPlayerRender = new VideoPlayerRender(mGLSurfaceView);
+        videoPlayerRender.setIVideoTextureRenderListener(new VideoPlayerRender.IVideoTextureRenderListener() {
+            @Override
+            public void onCreate(SurfaceTexture surfaceTexture) {
+                mSurface = new Surface(surfaceTexture);
+                startPlay();
+            }
+        });
+        mGLSurfaceView.setRenderer(videoPlayerRender);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        if (mSurface != null && mSurface.isValid()) {
+            startPlay();
+        }
+        if (mGLSurfaceView != null) {
+            mGLSurfaceView.onResume();
+        }
+    }
+
+    private void startPlay() {
+        if (mMediaPlayer != null && mSurface != null && mSurface.isValid()) {
+            mMediaPlayer.setSurface(mSurface);
+            mMediaPlayer.start();
+            return;
+        }
+        mMediaPlayer = new MediaPlayer();
+        try {
+            mMediaPlayer = MediaPlayer.create(this, R.raw.beauty);
+            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);
+            mSurface.release();
+            mMediaPlayer.setScreenOnWhilePlaying(true);
+            mMediaPlayer.setLooping(true);
+            mMediaPlayer.prepareAsync();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @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();
+            mMediaPlayer = null;
+        }
+    }
+}
+```
+
+视频是能播起来了，但是变形了
+
+### 修复变形
+
+我们要根据视频的宽高和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" width="40%" height="40%" />
+
+
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_video_player_2.jpeg" width="40%" height="40%" />
+
+
+
+---
+- [上一篇: 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"
new file mode 100644
index 00000000..ac2ff34d
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -0,0 +1,443 @@
+## 11.OpenGL ES滤镜
+
+给图像添加滤镜本质就是图片处理，也就是对图片的像素进行计算，简单来说，图像处理的方法可以分为三类:
+
+- 点算:当前像素的处理只和自身的像素值有关，和其他像素无关，比如灰度处理。
+- 领域算:当前像素的处理需要和相邻的一定范围内的像素有关，比如高斯模糊。
+- 全局算:在全局上对所有像素进行统一变换，比如几何变换。
+
+### 灰色滤镜
+
+和前一篇文章基本一样，只是修改一下片段着色器的代码，原理就是在片段着色器中去处理颜色，让RGB三个通道的颜色取均值:
+
+```glsl
+#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;
+}
+
+```
+
+
+
+### 反色滤镜
+
+RGB三个通道的颜色取反，而alpha通道不变。
+
+### 灰色滤镜
+
+让RGB三个通道的颜色取均值
+
+### 位移滤镜
+
+纹理默认传入的读取范围是(0,0)到(1,1)内的颜色值。如果对读取的位置进行调整修改，那么就可以做出各种各样的效果，例如缩放动画就是让读取的范围改成(-1,-1)到(2,2)。
+
+### 看完了疯了是不是，要做个滤镜效果，各种计算我实在弄不明白
+
+最简单的方法就是通过LUT方法，通过设计师提供的LUT文件来实现预定的滤镜效果。基本思路如下：
+
+- 准备LUT文件
+- 加载LUT文件到OpenGL纹理
+- 将纹理传递给片段着色器
+- 根据LUT，在片段着色器中对图像的颜色值进行映射，得到滤镜后的颜色进行输出
+
+
+
+### 离屏渲染
+
+之前已经将相机的预览数据输出到OpenGL的纹理上，渲染的时候OpenGL直接将纹理渲染到屏幕上。但是如果想要对纹理进行进一步的处理，就不能直接渲染到屏幕上，而是需要先渲染到屏幕外的缓冲区(FrameBuffer)处理完后再渲染到屏幕。渲染到缓冲区的操作就是离屏渲染。主要步骤如下:
+
+- 准备离屏渲染所需要的FrameBuffer和纹理对象。
+- 切换渲染目标(屏幕->缓冲区)
+- 执行渲染
+- 重置渲染目标(缓冲区 -> 屏幕)
+
+
+
+## 视频播放滤镜实现
+
+首先需要在GLSurfaceView.Renderer的实现类中提供一个setFilter()的方法，然后在onDrawFrame()的时候再去调用这个Filter的onDraw()方法，所以滤镜的编写主要是靠基类。
+
+- 先抽取BaseFilter类，封装好每个滤镜的着色器及onDraw等方法。
+- 不同的滤镜都继承该BaseFilter类，然后实现有区别的部分。其实每个不同滤镜的区别就是着色器的不同。
+- 在Renderder接口的实现类中去创建不同的Filter类，然后在onDrawFrame方法中去调用该filter.onDraw方法。
+
+滤镜的不同大部分只需要修改片元着色器就可以了。
+
+### 滤镜的基类
+
+- onCreate()：创建
+- onSizeChange()：滤镜尺寸改变
+- onDraw()：绘制每一帧
+- 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);
+    }
+```
+
+#### 常用概念整理
+- 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)
+
+- [下一篇: 12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/VideoDevelopment/OpenGL/12.FBO.md b/VideoDevelopment/OpenGL/12.FBO.md
new file mode 100644
index 00000000..dcbb6993
--- /dev/null
+++ b/VideoDevelopment/OpenGL/12.FBO.md
@@ -0,0 +1,228 @@
+## 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通过绘制到窗口系统提供的帧缓冲区，然后将帧缓冲区的对应区域复制到纹理来实现渲染到纹理，但是此方法只有在纹理尺寸小于或等于帧缓冲区尺寸才有效。       
+
+另一种方式是通过使用连接到纹理的pbuffer来实现渲染到纹理，但是与上下文和窗口系统提供的可绘制表面切换开销也很大。因此，引入了帧缓冲区对象FBO来解决这个问题。
+
+Android OpenGL ES开发中，一般使用GLSurfaceView将绘制结果显示到屏幕上，然而在实际应用中，也有许多场景不需要渲染到屏幕上，如利用GPU在后台完成一些图像转换、缩放等耗时操作，这个时候利用FBO可以方便实现类似需求。
+
+使用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)
+
+- [下一篇: 13.LUT滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
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..d02b6e97
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
@@ -0,0 +1,261 @@
+# 13.LUT滤镜
+
+
+LUT全称Look Up Table，也称为颜色查找表。       
+
+它代表的是一种映射关系，通过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)
+
+由于颜色值的范围是（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中的红色平面发生移动，其中对应的绿色和蓝色分量也会发生改变，也就是说，一个颜色通道改变可以影响其他的颜色通道。      
+
+理论上3D LUT可以在立体色彩空间中描述所有颜色调整行为，所以它可以处理任何显示的非线性属性，从简单的gamma值、颜色范围和追踪错误，到修正高级的非线性属性、颜色串扰（去耦）、色相、饱和度、亮度等，3D LUT都可以胜任。
+
+
+常见的3D LUT滤镜文件与.cube或者.3dl都是把3D坐标二维化后的数据表现，如下图
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/3d_lut.jpg)
+
+
+我们看到的这些方格子里面的蓝色是固定的，然后每个格子横坐标是红色，纵坐标是绿色，最左上角的格子因为蓝色全无，所以红色和绿色就很明显，而最右下角的那个格子，蓝色色值达到最大，因此整体看上去就非常的蓝(从左上角的格子到右下角的格子，一共是8行8列，正好是64个格子)。
+
+
+### 为什么是64x64
+
+对于RGB颜色，每种颜色可以有256(0 ~ 255)种取值，而每个颜色占用3个字节，因此一个3D LUT如果全量表示的话，大小为`256*256*256*3`个字节，即48M内存空间。      
+
+如果我们有一个大小为`256*256*256*3`的3D LUT文件，那么颜色映射将非常简单，只要根据RGB的像素值按照用蓝色找到对应的格子，然后用红色和绿色找到对应格子的横列就可以找到映射的颜色值。
+
+但是通常情况下，我们不会这么干，因为一张图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/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)
+
+
+- LUT图在横竖方向上被分成了8 X 8一共64个小方格，每一个小方格内的B（Blue）分量为一个定值，64 个小方格一共表示了B分量的64种取值。
+
+- 对于每一个小方格，横竖方向又各自分为64个小格:以左上角为原点，横向小格的 R（Red）分量依次增加，纵向小格的 G（Green）分量依次增加
+
+
+**在使用上面这张LUT表的时候首选需要找对B分量对应的小格子，然后在找到的小格子上再计算出R分量和G分量的映射结果即可得到完整的RGB映射结果。**
+
+
+
+下面我们就以一个`64*64*64`的3D LUT为例，来说明一下3D LUT如何查找和使用的（用glsl来实现）:     
+
+- 整张图从左到右和从上到下为蓝色的渐变，每个小格子从左到右为红色渐变，从上到下为绿色渐变
+- 肉眼可见的有8*8个方格，假设整个图的范围我们定义为0.0~1.0 ，也就是说每个格子所表示的范围是1./8. = 0.125
+- 我们首先通过蓝色来查找我们在哪个方格，由于涉及到插值，因此通过蓝色进行查找的时候，可能不会那么幸运一定映射到整数的格子上面，因此我们需要通过向下取整和向上进位两种方式来获取蓝色所对应的方格，然后通过蓝色的颜色值来mix这两种的颜色值，从而获取最终的颜色值。   
+
+
+### 映射示例
+
+
+#### 1.1 寻找B值的两个格子
+
+B值对应的是0 ~ 63，共64个格子，在计算时，并不一定会是一个整数，对应到某一个格子，大概率会是一个小数，为了能够更精确的进行映射，需要使用两个格子，然后根据小数(因子)进行插值计算，从而能够更精确。    
+
+##### 蓝色值用来定位两个相邻的小格子
+
+- 首先是对原图进行像素采样
+
+```glsl
+vec4 textureColor = texture(s_texture, v_texCoord);
+```
+
+textureColor.b是一个0 - 1之间的浮点数，乘以63用来确定B分量所在的格子.       
+因为会出现浮点误差，所以才需要取两个B分量，也就是下一步的取与B分量值最接近的2个小方格的坐标，最后根据小数点进行插值运算。
+
+
+- 第一个小格子:         
+
+```python
+vec4 color = texture(s_texture, v_texCoord);
+float blueColor = color.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分量的值确定小方格内目标映射的RGB组合的坐标，然后归一化，转化为纹理坐标。
+
+每个B格子代表的纹理坐标长度是 1/8 = 0.125
+63 * textureColor.r是将当前实际像素的r值映射到0 ~ 63，再除以512是转化为纹理坐标中实际的点，LUT图的分辨率为`512*512`
+
+红色值和绿色值用来确定相对于整个LUT的纹理坐标:   
+
+```glsl
+
+vec2 texPos1;
+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) * 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)的具体坐标。  
+- `(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
+
+这个就很好理解了，因为上面算出来的结果都是小方格的左上角坐标，加上小方格横纵的一半坐标就是将该点移动到了小方格中心。   
+
+
+
+
+    
+
+##### 通过纹理坐标获取两个新的颜色   
+
+```glsl
+vec4 newColor1 = texture(textureLUT, texPos1);
+vec4 newColor2 = texture(textureLUT, texPos2);
+```
+
+##### 然后根据蓝色值小数部分作为权重做线性混合，获取最终的颜色输出
+
+
+```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);
+```
+
+片元着色器代码:     
+
+```glsl
+#version 300 es
+precision mediump float;
+
+in vec2 v_texCoord;
+out vec4 outColor;
+uniform sampler2D s_texture;
+uniform sampler2D textureLUT;
+
+//查找表滤镜
+vec4 lookupTable(vec4 color){
+    float blueColor = color.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) * 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) * 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));
+    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)
+
+---
+
+- 邮箱 ：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"
new file mode 100644
index 00000000..e04ca224
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md"
@@ -0,0 +1,75 @@
+## 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)，是渲染的片段在深度缓冲区中相互对应的像素条目上“斗争”的结果。
+
+
+![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剔除背向三角形，必须手动启用它。
+
+
+
+
+--- 
+[上一篇: 13.LUT滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
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轴分布。   
+
+
+
+
+
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..723b4dae
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md"
@@ -0,0 +1,74 @@
+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减少掉帧次数。
+
+
+
+
+### 混合
+
+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/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..0647b7ea
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
@@ -0,0 +1,241 @@
+## 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)。    
+
+### 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方法才会去渲染
+- requestRender:请求渲染，请求异步线程进行渲染，调用后不会立即进行渲染。渲染会回调到Renderer接口的onDrawFrame()方法
+- queueEvent:插入一个Runnable任务到后台渲染线程上执行。相应的，渲染线程中可以通过Activity的runOnUIThread的方法来传递事件给主线程去执行
+
+#### GLSurfaceView.Renderer(可控制该视图中绘制的图形)
+
+此接口定义了在GLSurfaceView中绘制图形所需的方法。您必须将此接口的一个实现作为单独的类提供，并使用GLSurfaceView.setRenderer()将其附加到您的GLSurfaceView实例。         
+
+GLSurfaceView.Renderer接口要求您实现以下方法:     
+- onSurfaceCreated():系统会在创建GLSurface时调用一次此方法。使用此方法可执行仅需发生一次的操作，例如设置OpenGL环境参数或初始化OpenGL图形对象。          
+在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：
+
+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))
+
+### GLSurfaceView类
+```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的版本： 
+
+```xml
+<uses-feature android:glEsVersion="0x00030000" android:required="true" />
+```
+
+
+
+```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);
+        // 设置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。
+上面glClearColor函数是一个状态设置函数，而glClear函数则是一个状态使用的函数，它使用了当前的状态来获取应该清除为的颜色    
+
+Render接口重写的三个方法中调用了GLES31的API方法:   
+
+- glClearColor()：设置清空屏幕用的颜色，参数为RGBA。
+- glClear()：清空屏幕，当调用glClear函数清除颜色缓冲之后，整个颜色缓冲都会被填充为glClearColor里所设置的颜色。glClear函数来清空屏幕的颜色缓冲时会接受一个缓冲位(Buffer Bit)来指定要清空的缓冲，可能的缓冲位有GL_COLOR_BUFFER_BIT、GL_DEPTH_BUFFER_BIT和GL_STENCIL_BUFFER_BIT，由于这里我们只关心颜色值，所以我们只清空颜色缓冲。
+- 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()在同一线程上出现。
+
+
+--- 
+
+- [上一篇: 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/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/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..4453dcc7
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
@@ -0,0 +1,713 @@
+## 3.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线程和调用线程。所以对一些变量必须要进行同步。
+
+
+
+---
+
+- [上一篇: 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"
new file mode 100644
index 00000000..63981545
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
@@ -0,0 +1,1999 @@
+## 4.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;
+}
+```
+
+
+
+
+
+---
+- [上一篇: 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"
new file mode 100644
index 00000000..be6c7acb
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -0,0 +1,1217 @@
+## 5.OpenGL ES绘制三角形
+
+
+OpenGL ES的绘制需要有以下步骤:   
+
+### 1. 顶点输入
+
+  开始绘制图形之前，我们必须先给OpenGL输入一些顶点数据。    
+  OpenGL是一个3D图形库，所以我们在OpenGL中所指定的所有坐标都是3D坐标(xyz)。OpenGL并不是简单地把所有的3D坐标变换成屏幕上的2D像素。    
+  OpenGL仅当3D坐标在3个轴(xyz)上都为-1.0到1.0的范围内才去处理它。    
+  所有在这个范围内的坐标叫做标准化设备坐标(Normalized Device Coordinates)，此范围内的坐标最终显示在屏幕上（在这个范围以外的坐标则不会显示）。
+
+由于我们希望渲染一个三角形，我们一共要指定三个顶点，每个顶点都有一个3D位置。我们会将它们以标准化设备坐标的形式（OpenGL的可见区域）定义为一个float数组。
+
+```java
+float vertices[] = {
+    -0.5f, -0.5f, 0.0f,
+     0.5f, -0.5f, 0.0f,
+     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如何解释这些内存，并且指定其如何发送给显卡。**      
+
+顶点着色器接着会处理我们在内存中指定数量的顶点。
+
+我们通过顶点缓冲对象(Vertex Buffer Objects, VBO)管理这个内存，它会在GPU内存（通常被称为显存）中储存大量顶点。    
+使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。   
+从CPU把数据发送到显卡相对较慢，所以只要可能我们都要尝试尽量一次性发送尽可能多的数据。当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这是个非常快的过程。
+
+顶点缓冲对象是我们在OpenGL教程中第一个出现的OpenGL对象。就像OpenGL中的其它对象一样，这个缓冲有一个独一无二的ID，所以我们可以使用glGenBuffers函数和一个缓冲ID生成一个VBO对象。
+
+
+### 2.顶点着色器
+
+  着色器都是使用GLSL语言来写的，而GLSL不同版本之间会有差异。
+
+  ```glsl
+  #version 300 es
+  layout (location = 0) in vec3 position;
+  
+  void main()
+  {
+      gl_Position = vec4(position.x, position.y, position.z, 1.0);
+  }
+  ```
+
+  每个着色器都起始于一个版本声明，这里声明的是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)。        
+    `layout(location = 0);`用于指定着色器中的变量 position 与 OpenGL程序中顶点数组中数据的关联关系，这里表示该位置数据的位置索引为0。以确保在着色器中能正常的接收输入的数据。 
+    你后面会看到为什么我们会需要这个位置值。
+    
+
+layout限定符是从OpenGL ES 3.0开始出现的，其主要用于设置变量的存储索引（即引用）值.    
+
+##### 向量(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变量中输出一个位置。这个变量定义传递给管线下一个阶段的位置。
+
+### 3.编译着色器
+
+  写完顶点着色器后，为了能让OpenGL使用它，我们必须在运行时动态编译它。
+
+### 4.片段着色器
+
+  片段着色器全是关于计算你的像素最后的颜色输出。颜色使用RGBA。
+
+  ```glsl
+  #version 300 es
+  out vec4 color;
+  void main() {
+      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窗口显示。
+
+### 5.着色器程序(Shader Program Object)
+
+着色器程序对象(Shader Program Object)是多个着色器合并之后并最终链接完成的版本。    
+如果要使用刚才编译的着色器我们必须把它们链接(Link)为一个着色器程序对象，然后在渲染对象的时候激活这个着色器程序。    
+已激活着色器程序的着色器将在我们发送渲染调用的时候被使用。    
+
+当链接着色器至一个程序的时候，它会把每个着色器的输出链接到下个着色器的输入。            
+当输出和输入不匹配的时候，你会得到一个连接错误。我们需要把之前编译的着色器附加到程序队形上，然后使用glLinkProgram链接他们:
+
+```java
+final int shaderProgramId = GLES30.glCreateProgram(); 
+GLES30.glAttachShader(shaderProgramId, vertexShaderId);
+GLES30.glAttachShader(shaderProgramId, fragmentShaderId);
+GLES30.glLinkProgram(shaderProgramId);
+```
+
+链接完后需要使用glUseProgram方法，用刚创建的程序对象的id作为参数，以激活这个程序对象。         
+调用glUserProgram方法后，所有后续的渲染将用连接到这个程序对象的顶点和片段着色器进行。           
+
+对了，在把着色器对象链接到程序对象以后，记得删除着色器对象，我们不再需要它们了：
+
+```java
+GLES30.glDeleteShader(vertexShaderId);
+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)。
+- 数据中第一个值在缓冲开始的位置。
+
+有了这些信息我们就可以使用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声明的
+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`。
+  - 第二个参数指定顶点属性的大小。顶点属性是一个`vec3`，它由3个值组成，所以大小是3。
+  - 第三个参数指定数据的类型，这里是GL_FLOAT(GLSL中`vec*`都是由浮点数值组成的)。
+  - 下个参数定义我们是否希望数据被标准化(Normalize)。如果我们设置为GL_TRUE，所有数据都会被映射到0（对于有符号型signed数据是-1）到1之间。我们把它设置为GL_FALSE。
+  - 第五个参数叫做步长(Stride)，它告诉我们在连续的顶点属性组之间的间隔。由于下个组位置数据在3个`GLfloat`之后，我们把步长设置为`3 * sizeof(GLfloat)`也就是3*4。
+      要注意的是由于我们知道这个数组是紧密排列的（在两个顶点属性之间没有空隙）我们也可以设置为0来让OpenGL决定具体步长是多少（只有当数值是紧密排列时才可用）。
+      一旦我们有更多的顶点属性，我们就必须更小心地定义每个顶点属性之间的间隔，我们在后面会看到更多的例子(译注: 这个参数的意思简单说就是从这个属性第二次出现的地方到整个数组0位置之间有多少字节)。
+  - 最后一个参数的类型是数据。
+
+每个顶点属性从一个VBO管理的内存中获得它的数据，而具体是从哪个VBO（程序中可以有多个VBO）获取则是通过在调用glVertexAttribPointer时绑定到GL_ARRAY_BUFFER的VBO决定的。       
+由于在调用glVertexAttribPointer之前绑定的是先前定义的VBO对象，顶点属性现在会链接到它的顶点数据。
+
+现在我们已经定义了OpenGL该如何解释顶点数据，接着应该使用glEnableVertexAttribArray，以顶点属性位置值作为参数，启用顶点属性；      
+**顶点属性默认是禁用的。**    
+
+自此，所有东西都已经设置好了：我们使用一个顶点缓冲对象将顶点数据初始化至缓冲区中，建立了一个顶点和一个片段着色器，并告诉了OpenGL如何把顶点数据链接到顶点着色器的顶点属性上。    
+在OpenGL中绘制一个物体，代码会像是这样：
+
+```java
+// 0. 复制顶点数组到缓冲中供OpenGL使用,使用glGenBuffers函数和一个缓冲ID生成一个VBO对象
+IntBuffer vbo = IntBuffer.allocate(1);
+GLES30.glGenBuffers(1, vbo);
+// 使用glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上
+GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, vbo.get(0));
+// glBufferData是一个专门用来把用户定义的数据复制到当前绑定缓冲的函数
+// 它的第一个参数是目标缓冲类型。 第二个参数是指定传输数据的大小(以字节为单位),用一个简单的sizeof计算出顶点数据的大小就行
+// 第三个参数是我们希望发送的实际数据
+// 第四个参数指定了我们希望显卡如何管理这些数据，有三种形式: GL_STATIC_DRAW(数据不会或几乎不会改变)， GL_DYNAMIC_DRAW(数据会被改变很多)， GL_STREAM_DRAW(数据每次绘制时都会改变)
+GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, POSITION_VERTEX.size * Float.BYTES,
+                    vertexBuffer, GLES30.GL_STATIC_DRAW);
+// 1. 设置顶点属性指针
+GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 3 * Float.BYTES, vertexBuffer);
+GLES30.glEnableVertexAttribArray(0);
+// 2. 当我们渲染一个物体时要使用着色器程序
+GLES30.glUseProgram(shaderProgram);
+// 3. 绘制物体
+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很类似：
+
+```java
+IntBuffer arrays = IntBuffer.allocate(1);
+GLES30.glGenVertexArrays(1, arrays);
+```
+要想使用VAO，要做的只是使用glBindVertexArray绑定VAO(glBindVertexArrays()命令的目的是将指定的VAO标记为活跃，这样生成的缓冲区就会和这个VAO相关联)。从绑定之后起，我们应该绑定和配置对应的VBO和属性指针，之后解绑VAO供之后使用。    
+当我们打算绘制一个物体的时候，我们只要在绘制物体前简单地把VAO绑定到希望使用的设定上就行了。这段代码应该看起来像这样：
+
+VAO小助理偷偷帮我们记录一切：   
+
+```java
+// ..:: 初始化代码（只运行一次 (除非你的物体频繁改变)） :: ..
+// 1. 绑定VAO
+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. 设置顶点属性指针
+GLES30.glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * Float.BYTES, vertexBuffer);
+GLES30.glEnableVertexAttribArray(0);
+
+[...]
+
+// ..:: 绘制代码（渲染循环中） :: ..
+// 4. 绘制物体
+GLES30.glUseProgram(shaderProgram);
+// 解绑数据：GLES30.glBindVertexArray(0)
+GLES30.glBindVertexArray(0);
+someOpenGLFunctionThatDrawsOurTriangle();
+```
+
+就这么多了！前面做的一切都是等待这一刻，一个储存了我们顶点属性配置和应使用的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的函数调用。   
+
+
+
+下面需要实现GLSurfaceView.Render接口，实现要绘制的部分:   
+
+- 用EGL创建屏幕上的渲染表面(GLSurfaceView内部实现)
+- 写顶点着色器和片段着色器文件。
+- 加载编译顶点着色器和片段着色器。
+- 确定需要绘制图形的坐标和颜色数据。
+- 创建program对象，连接顶点和片断着色器，将坐标数据、颜色数据传到OpenGL ES程序中。
+- 设置视图窗口(viewport)。
+- 使颜色缓冲区的内容显示到EGL窗口上。
+
+
+
+### GLSL配置
+
+编写着色器需要用到GLSL，但是在Studio中默认是不支持关键字高亮和智能提示的，所以需要先安装插件。   
+
+Preferences -> Plugins -> 搜GLSL Support安装就可以了。
+
+
+
+### 编写着色器
+
+安装完GLSL插件后，就可以开始了。一般将GLSL文件放到raw或assets目录，我们这里在raw目录上右键New，然后选择GLSL Shader创建就可以了，创建后默认会生成一个main()函数。
+
+- 顶点着色器(triangle_vertex_shader.glsl)
+
+关键字in意思是输入(input)，表示这个顶点属性将会从缓冲区(C++或Java代码中的VBO、VAO等)中接收数值。
+顶点属性还可以改为被声明为out，这意味着它们会将值发送到管线中的下一个阶段。    
+
+layout(location=0)称为layout修饰符。也就是我们把顶点属性和特定缓冲区关联起来的方法，这意味着这个顶点属性的识别号是0.
+
+
+```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。
+
+- 片段着色器(triangle_fragment_shader.glsl)
+
+  ```glsl
+  // 声明着色器的版本
+  #version 300 es
+  // 声明着色器中浮点变量的默认精度
+  precision mediump float;
+  // 声明一个输入名为vColor的4分向量，来自上面的顶点着色器
+  in vec4 vColor;
+  // 声明一个4分向量的输出变量fragColor
+  out vec4 fragColor;
+  void main() {
+      // 将输入的颜色值数据拷贝到fragColor变量中，输出到颜色缓冲区
+      fragColor = vColor;
+  }
+  ```
+precision是精度限定符，它可以使着色器创作者指定着色器变量的计算精度。变量可以声明为低、中或高精度。        
+这些限定符用于提示编译器允许在较低的范围和精度上执行变量的计算。    
+在较低的精度上，有些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变量指定精度。
+
+
+```java
+public class TriangleActivity extends Activity {
+    private GLSurfaceView mGlSurfaceView;
+    private TriangleRender mTriangleRender;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        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);
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        mGlSurfaceView.onPause();
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        mGlSurfaceView.onResume();
+    }
+}
+```
+
+TriangleRender的实现如下:  
+
+```java
+public class TriangleRender implements GLSurfaceView.Renderer {
+    //三个顶点
+    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 TriangleRender() {
+        /****************2.为顶点位置及颜色申请本地内存 start************/
+        //将顶点数据拷贝映射到native内存中，以便OpenGL能够访问
+        //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
+        vertexBuffer = ByteBuffer.allocateDirect(triangleCoords.length * Float.BYTES) // 直接分配native内存
+                .order(ByteOrder.nativeOrder()) // 和本地平台保持一致的字节序
+                .asFloatBuffer(); // 将底层字节映射到FloatBuffer实例，方便使用
+        vertexBuffer.put(triangleCoords); // 将顶点数据拷贝到native内存中
+        // 将数组数据put进buffer之后，指针并不是在首位，所以一定要position到0，至关重要！否则会有很多奇妙的错误！将缓冲区的指针移动到头部，保证数据是从最开始处读取
+        vertexBuffer.position(0);
+
+        //顶点颜色相关
+        colorBuffer = ByteBuffer.allocateDirect(color.length * Float.BYTES)
+                .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.triangle_vertex_shader);
+        int vertexShaderId = compileVertexShader(vertexShaderStr);
+        //编译片段着色程序
+        String fragmentShaderStr = readResource(MyApplication.getInstance(), R.raw.triangle_fragment_shader);
+        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);
+        // 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 * Float.BYTES, vertexBuffer);
+        //启用顶点变量，这个0也是vPosition在着色器变量中的位置，和上面一样，在着色器文件中的location=0声明的
+        // 也就是说由于vPosition在着色器中的位置被指定为0，因此可以简单的通过glVertexAttribPointer()函数调用中的第一个参数和在glEnableVertexAttribArray()函数调用中使用0来引用此变量
+        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： 本地数据缓存（这里我们的是顶点的位置和颜色数据）。
+         */
+        // 1是aColor在属性的位置，4是因为我们声明的颜色是4位，r、g、b、a。
+        GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 4 * Float.BYTES, 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);
+            // 删除
+            GLES30.glDeleteShader(vertexShaderId);
+            GLES30.glDeleteShader(fragmentShaderId);
+            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();
+    }
+}
+```
+
+
+调用glCreateShader将根据传入的type参数创建一个新的顶点或片段着色器。返回值是指向新着色器对象的句柄。当完成链接着色器对象时，可以用glDeleteShader删除。             
+注意，如果一个着色器连接到一个程序对象，那么调用glDeleteShader不会立即删除着色器，而是将着色器编标记为删除，在着色器不再连接到任何程序对象时，它的内存将被释放。
+
+效果如下:   
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_tri.jpg" width="20%" height="20%" />
+
+
+
+我们设置的是数据来看，应该是等腰三角形，但是实际效果并不是，这是因为OpenGL假设屏幕采用均匀的方形坐标系，所以在把标准坐标系下的坐标绘制到非方形的屏幕上时，就会出现拉伸。
+如果想让绘制一个等腰三角形该怎么做呢？ 
+
+### 变成等腰三角形的原理
+
+打个比方现在屏幕的宽高比是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)，而是用在所谓透视划分上。
+
+
+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个有序数组成的数组。       
+
+所以矩阵中的每一个行可以看做一个行向量，每一列也可以看成一个列向量，所以说向量是矩阵的一部分。         
+
+在三维图形学中，一般使用的是4阶矩阵。在DirectX中使用的是行向量，如[xyzw]，所以与矩阵相乘时，向量在前矩阵在后。         
+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的矩阵。这是因为我们决定使用齐次坐标系。 否则，各变换矩阵可能会有不同的纬度并且无法想乘。    
+
+
+
+### 相机
+
+这里的相机指的是观察外界的视角并不是我们生活中的相机。这里的相机是指我们从照相机或者摄像机的角度来观察这个世界。 相机对应于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);
+            //删除
+            GLES30.glDeleteShader(vertexShaderId);
+            GLES30.glDeleteShader(fragmentShaderId);
+            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(@NonNull Context context, @RawRes int resourceId) {
+        StringBuilder builder = new StringBuilder();
+        try {
+            InputStream inputStream = context.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();
+    }
+}
+```
+
+
+
+- 修改顶点着色器，增加矩阵变换(修改iso_triangle_vertex_shader.glsl)，片段着色器不用修改
+
+```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实现类中定义矩阵变量
+
+- 把变换矩阵设置给顶点渲染器
+
+其他所有代码都和上面的一样，只是在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
+public class IsoTriangleRender implements GLTextureView.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 IsoTriangleRender() {
+        //顶点位置相关
+        //分配本地内存空间,每个浮点型占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 = ResReadUtils.readResource(MyApplication.getInstance(), R.raw.iso_triangle_vertex_shader);
+        int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
+        //编译片段着色程序
+        String fragmentShaderStr = ResReadUtils.readResource(MyApplication.getInstance(), R.raw.iso_triangle_fragment_shader);
+        int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
+        //连接程序
+        mProgram = ShaderUtils.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 boolean 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);
+        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)
+
+---
+
+- 邮箱 ：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"
new file mode 100644
index 00000000..ff975060
--- /dev/null
+++ "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"	
@@ -0,0 +1,544 @@
+## 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)
+
+
+OpenGL ES中仅允许采用三角形来搭建物体。其实这从构造能力上来说并没有区别，因为任何多边形都可以拆分为多个三角形。OpenGL ES中之所以仅支持三角形而不支持任意多边形是出于性能的考虑，就目前移动嵌入式设备的硬件性能情况来看，这是必然的选择了。
+
+
+### 顶点法和索引法
+
+- 顶点法
+
+  上一篇文章中写的绘制点、线、三角形都是使用GLES30.glDrawArrays()来绘制，它是顶点法。根据传入的顶点顺序进行绘制。顶点复用情况少，可读性低。
+
+- 索引法
+
+  根据索引序列，在顶点序列中找到对应的顶点，并根据绘制的方式，组成相应的图元绘制，用的是GLES30.glDrawElements()，称为索引法。       
+ 相对于顶点法在复杂图形的绘制中无法避免大量顶点重复的情况，索引法可以减少很多重复顶点占用的空间，所以复杂的图形下推荐使用索引法。顶点复用情况多，可读性高。
+
+之前说过OpenGL ES提供的的图元单位是三角形，想要绘制其他多边形，就要利用三角形来拼成。 矩形是两个三角形，而圆形则是由很多个三角形组成，个数越多，圆越圆。
+
+
+### 元素缓冲对象(EBO)
+在渲染顶点这一话题上我们还有最后一个需要讨论的东西——元素缓冲对象(Element Buffer Object，EBO)，也叫索引缓冲对象(Index Buffer Object，IBO)。       
+
+要解释元素缓冲对象的工作方式最好还是举个例子：假设我们不再绘制一个三角形而是绘制一个矩形。       
+我们可以绘制两个三角形来组成一个矩形（OpenGL主要处理三角形）。这会生成下面的顶点的集合：
+
+```java
+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)正是我们问题的解决方案。首先，我们先要定义（不重复的）顶点，和绘制出矩形所需的索引：
+
+```java
+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   // 左上角
+};
+
+int indices[] = {
+    // 注意索引从0开始! 
+    // 此例的索引(0,1,2,3)就是顶点数组vertices的下标，
+    // 这样可以由下标代表顶点组合成矩形
+
+    0, 1, 3, // 第一个三角形
+    1, 2, 3  // 第二个三角形
+};
+```
+
+你可以看到，当使用索引的时候，我们只定义了4个顶点，而不是6个。下一步我们需要创建元素缓冲对象:     
+
+```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。          
+注意：我们传递了GL_ELEMENT_ARRAY_BUFFER当作缓冲目标。最后一件要做的事是用glDrawElements来替换glDrawArrays函数，表示我们要从索引缓冲区渲染三角形。         
+使用glDrawElements时，我们会使用当前绑定的索引缓冲对象中的索引进行绘制：
+
+```java
+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。
+
+![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配置了。**           
+**OpenGL中会解绑VBO和VAO但是不能解绑EBO)**
+
+到这里我有点懵了，VAO有什么用？ 
+
+简单说就是VBO用于存储顶点数据，而VAO用于封装顶点数组的状态，包括顶点属性指针和VBO的绑定状态。这两者的结合使用可以使OpenGL中管理和切换多个顶点数据配置变得更加方便和高效。 
+
+
+### 绘制矩形
+
+
+
+- 顶点着色器与上一个三角形的一样
+
+- 片段着色器与上一个三角形的一样
+
+- Render的实现如下
+
+  顶点法:   
+  
+  ```java
+  public class SquareRender extends BaseGLSurfaceViewRenderer {
+      //顶点位置缓存
+      private final FloatBuffer vertexBuffer;
+      //顶点颜色缓存
+      private final FloatBuffer colorBuffer;
+      //位置
+      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
+      };
+  
+      public SquareRender() {
+          vertexBuffer = BufferUtil.getFloatBuffer(POINT_DATA);
+          colorBuffer = BufferUtil.getFloatBuffer(COLOR_DATA);
+      }
+  
+      @Override
+      public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+          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) {
+          glViewport(0, 0, width, height);
+          orthoM("u_Matrix", width, height);
+      }
+  
+      @Override
+      public void onDrawFrame(GL10 gl) {
+          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 HexagonRender extends BaseGLSurfaceViewRenderer {
+      //顶点位置缓存
+      private final FloatBuffer vertexBuffer;
+      //顶点颜色缓存
+      private final FloatBuffer colorBuffer;
+      // 顶点索引缓存
+      private final ShortBuffer indexBuffer;
+      //位置
+      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,
+              0f, -1.0f,
+              0f, 1.0f
+      };
+  
+      /**
+       * 数组绘制的索引:当前是绘制三角形，所以是3个元素构成一个绘制顺序
+       */
+      private static final short[] INDEX_DATA = {
+              0, 1, 2,
+              0, 2, 3,
+              0, 4, 1,
+              3, 2, 5
+      };
+  
+      /**
+       * 颜色占用的向量个数
+       */
+      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 HexagonRender() {
+          vertexBuffer = BufferUtil.getFloatBuffer(POINT_DATA);
+          colorBuffer = BufferUtil.getFloatBuffer(COLOR_DATA);
+          indexBuffer = BufferUtil.getShortBuffer(INDEX_DATA);
+      }
+  
+      @Override
+      public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+          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) {
+          glViewport(0, 0, width, height);
+          orthoM("u_Matrix", width, height);
+      }
+  
+      @Override
+      public void onDrawFrame(GL10 gl) {
+          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);
+      }
+  }
+  ```
+  
+  
+
+### 绘制圆形
+
+其他也都和上面的一样，只有Render不同，如下:  
+
+```java
+public class CircleRender extends BaseGLSurfaceViewRenderer {
+    //顶点位置缓存
+    private final FloatBuffer vertexBuffer;
+    //顶点颜色缓存
+    private final FloatBuffer colorBuffer;
+    //位置
+    private int aPositionLocation;
+    //颜色
+    private int aColorLocation;
+
+    /**
+     * 坐标占用的向量个数
+     */
+    private static final int POSITION_COMPONENT_COUNT = 3;
+    private float circlePosition[];
+    /**
+     * 颜色占用的向量个数
+     */
+    private static final int COLOR_COMPONENT_COUNT = 4;
+    private float color[];
+
+    public CircleRender() {
+        createPositions(1, 60);
+        vertexBuffer = BufferUtil.getFloatBuffer(circlePosition);
+        colorBuffer = BufferUtil.getFloatBuffer(color);
+    }
+
+    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);
+        }
+
+        circlePosition = 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) {
+        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) {
+        glViewport(0, 0, width, height);
+        orthoM("u_Matrix", width, height);
+    }
+
+    @Override
+    public void onDrawFrame(GL10 gl) {
+        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);
+    }
+}
+```
+
+
+### 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)
+
+---
+
+- 邮箱 ：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"
new file mode 100644
index 00000000..12bb9706
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -0,0 +1,652 @@
+## 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函数。       
+每个着色器的入口点都是main函数，在这个函数中我们处理所有的输入变量，并将结果输出到输出变量中。
+
+和其他编程语言一样，GLSL有数据类型可以来指定变量的种类。      
+GLSL中包含C等其它语言大部分的默认基础数据类型：int、float、double、uint和bool。       
+GLSL也有两种容器类型，它们会在这个教程中使用很多，分别是向量(Vector)和矩阵(Matrix)。
+
+
+### 顶点着色器:
+
+```glsl
+#version 300 es
+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); // 把输出变量设置为暗红色
+}
+```
+
+```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%" />
+
+顶点着色器的输入包括:
+
+- 顶点着色器输入(或者属性):用顶点数组提供的每个顶点的数据。
+- 统一变量(uniform):顶点或片段着色器使用的不变的数据。
+- 采样器:代表顶点着色器使用纹理的特殊统一变量类型。
+- 着色器程序:描述顶点上执行操作的顶点着色器的程序源代码或可执行文件。
+
+这里需要重点讲一下上面的版本:   
+
+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()方法替换。
+
+- 可直接使用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被废弃
+
+    当使用samplerExternalOES是，如果在\#extension GL_OES_EGL_image_external : require会报错，需要变成#extension GL_OES_EGL_image_external_essl3 : require
+
+- `#version 300 es`这种声明版本的语句，必须放到第一行，并且shader中不能有Tab键，只能用空格替换。
+
+虽然着色器是各自独立的小程序，但是它们都是一个整体的一部分，出于这样的原因，我们希望每个着色器都有输入和输出，这样才能进行数据交流和传递。       
+GLSL定义了in和out关键字专门来实现这个目的。     
+**每个着色器使用这两个关键字设定输入和输出，只要一个输出变量与下一个着色器阶段的输入匹配，它就会传递下去。**     
+但在顶点和片段着色器中会有点不同。
+
+
+
+
+
+#### in、out
+
+顶点着色器应该接收的是一种特殊形式的输入，否则就会效率低下。      
+顶点着色器的输入特殊在，它从顶点数据中直接接收输入。       
+为了定义顶点数据该如何管理，我们使用location这一元数据指定输入变量，这样我们才可以在CPU上配置顶点属性。       
+我们已经在前面的教程看过这个了，layout (location = 0)。顶点着色器需要为它的输入提供一个额外的layout标识，这样我们才能把它链接到顶点数据。
+
+你也可以忽略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链接了。        
+由于我们在顶点着色器中将颜色设置为深红色，最终的片段也是深红色的。
+
+
+
+
+顶点着色器中用in限定符修饰的变量其值实质是由宿主程序（本书中为Java、C++）批量传入渲染管线的，管线进行基本处理后再传递给顶点着色器。       数据中有多少个顶点，管线就调用多少次顶点着色器，每次将一个顶点的各种属性数据传递给顶点着色器中对应的in变量。因此，顶点着色器每次执行将完成对一个顶点各项属性数据的处理。
+
+
+顶点着色器每顶点执行一次，而片元着色器每片元执行一次，片元着色器的执行次数明显大于顶点着色器的执行次数。因此在开发中，应尽量减少片元着色器的运算量，可以将一些复杂运算尽量放在顶点着色器中执行。
+
+
+####  精度限定符
+
+精度限定符使着色器创作者可以指定着色器变量的计算精度。变量可以声明为低、中或者高精度。这些限定符用于提示编译器允许在较低的范围和精度上执行变量计算。在较低的精度上，有些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会一直保存它们的数据，直到它们被重置或更新。    
+
+
+CPU在处理并行线程的时候，每个线程负责给完整图像的一部分配置颜色。    
+尽管每个线程和其他线程之间不能有数据交换，但我们能从CPU给每个线程输入数据。    
+因为显卡的架构，所有线程的输入值必须统一(uniform)，而且必须设为只读。      
+
+也就是说，每条线程接收相同的数据，并且是不可改变的数据。这些输入值叫做uniform(统一值). 
+
+按业界传统应该在uniform值的名字前加u_，这样一看便知是uniform。    
+
+Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。 
+
+你可以把uniform想象成连通CPU和GPU的许多的小桥梁。        
+
+首先，uniform是全局的(Global)。         
+全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的，而且它可以被着色器程序的任意着色器在任意阶段访问。       
+
+第二，无论你把uniform值设置成什么，uniform会一直保存它们的数据，直到它们被重置或更新。
+
+统一变量通常保存在硬件中，这个区域被称作“常量存储”，是硬件中为存储常量值而分配的特殊空间。    
+
+因为常量存储的大小一般是固定的，所以程序中可以使用的统一变量数量受到限制。          
+这种限制可以通过读取内建变量gl_MaxVertexUniformVectors和gl_MaxFragmentUniformVectors的值来确定。
+但是对于在编译时已知值的变量应该是常量，而不是统一变量，这样可以提高效率。     
+
+
+我们可以在一个着色器中添加uniform关键字至类型和变量名前来声明一个GLSL的uniform。从此处开始我们就可以在着色器中使用新声明的uniform了。我们来看看这次是否能通过uniform设置三角形的颜色：     
+
+```glsl
+#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的索引/位置值后，我们就可以更新它的值了。这次我们不去给像素传递单独一个颜色，而是让它随着时间改变颜色：
+
+```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的。         
+
+因为OpenGL在其核心是一个C库，所以它不支持类型重载，在函数参数不同的时候就要为其定义新的函数；glUniform是一个典型例子。这个函数有一个特定的后缀，标识设定的uniform的类型。可能的后缀有：
+
+- f : 函数需要一个float作为它的值
+- i : 函数需要一个int作为它的值
+- ui: 函数需要一个unsigned int作为它的值
+- 3f: 函数需要3个float作为它的值
+- fv: 函数需要一个float向量/数组作为它的值
+
+每当你打算配置一个OpenGL的选项时就可以简单地根据这些规则选择适合你的数据类型的重载函数。在我们的例子里，我们希望分别设定uniform的4个float值，所以我们通过glUniform4f传递我们的数据(注意，我们也可以使用fv版本)。       
+
+现在你知道如何设置uniform变量的值了，我们可以使用它们来渲染了。如果我们打算让颜色慢慢变化，我们就要在游戏循环的每一次迭代中（所以他会逐帧改变）更新这个uniform，否则三角形就不会改变颜色。        
+
+
+顶点着色器中的乘法将矩阵变换应用于顶点，将其转换为相机空间（请注意从右到左的计算顺序）。这些值被放入内置的OpenGL输出变量gl_Position中，然后继续通过管线，并由光栅着色器进行插值。
+插值后的像素位置（称为片段）被发送到片段着色器(fragment shader)。回想一下，片段着色器的主要目的是设置输出像素的颜色。与顶点着色器的方式类似，片段着色器逐个处理像素，并对每个像素单独调用。
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_progress_11.png?raw=true)
+
+
+
+
+### GLSL的特点
+
+OpenGLES的着色器语言GLSL是一种高级的图形化编程语言，其源自应用广泛的C语言。与传统的C语言不同的是，它提供了更加丰富的针对于图像处理的原生类型，诸如向量、矩阵之类。GLSL主要包含以下特性：       
+
+- 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
+
+### 基本数据类型
+
+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表示分量。
+
+我们大部分时候使用vecn，因为float足够满足大多数要求了。
+
+```glsl
+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表示。         
+我们可以把矩阵看做是一个二维数组，也可以用二维数组下表的方式取里面具体位置的值。      
+现在我们已经讨论了向量的全部内容，是时候看看矩阵了！简单来说矩阵就是一个矩形的数字、符号或表达式数组。矩阵中每一项叫做矩阵的元素(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)，先算列，再算行）
+
+矩阵的构造方法则更加灵活，有以下规则:      
+
+- 如果对矩阵构造器只提供了一个标量参数，该值会作为矩阵的对角线上的值。例如 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); // 第三列
+```
+
+
+三维图形学中我们只用到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
+```
+
+
+
+
+- 采样器
+
+  采样器是着色语言中不同于C语言的一种特殊的基本数据类型，采样器是专门用来对纹理进行采样工作的，在GLSL中一般来说，一个采样器变量表示一副或者一套纹理贴图。所谓的纹理贴图可以理解为我们看到的物体上的皮肤。
+
+- 结构体
+
+  和C语言中的结构体相同，用struct来定义结构体。
+
+- 数组
+
+  数组也与C相同
+
+- 空类型
+
+  void
+
+###  变量修饰符 
+
+- none：(默认的可省略)本地变量，可读可写，函数的输入参数既是这种类型
+- const：常量
+- in：输入变量，一般用于各个顶点各不相同的量。如顶点颜色、坐标等。用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器。(GLSL 100 es版本中是attribute)
+- uniform：统一变量。统一变量存储应用程序通过OpenGL ES API传入着色器的只读值。在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器。如果统一变量在顶点着色器和片段着色器中均有声明，则声明的类型必须相同，且两个着色器中的值也需要相同。
+- out：输出变量，易变量，用于修饰从顶点着色器向片元着色器传递的变量。一般是在光栅化图元的过程中计算生成，记录在每个片段中(而不是从顶点着色器直接传递给片元着色器),(GLSL 100 es版本中是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基本一样
+
+### 函数
+
+定义函数的方式也与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:当前片元颜色(GLSL 200 es版本的内置属性，在GLSL 300 es中已经没有了，需要自己用out关键字定义)
+  - gl_FragData:vec4类型的数据。设置当前片元的颜色，供渲染管线的后继过程使用。(GLSL 200 es版本的内置属性，在GLSL 300 es中已经没有了，需要自己用out关键字定义)
+
+### 内置函数
+
+#### 常用函数
+
+- 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所有分量执行逻辑非运算
+
+
+### 更多
+
+在前面的教程中，我们了解了如何填充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
+
+out vec3 ourColor; // 向片段着色器输出一个颜色
+
+void main()
+{
+    gl_Position = vec4(aPos, 1.0);
+    ourColor = aColor; // 将ourColor设置为我们从顶点数据那里得到的输入颜色
+}
+```
+由于我们不再使用uniform来传递片段的颜色了，现在使用ourColor输出变量，我们必须再修改一下片段着色器：     
+
+```glsl
+#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函数更新顶点格式：     
+
+```java
+// 位置属性
+GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 6 * Float.BYTES, 0);
+GLES30.glEnableVertexAttribArray(0);
+// 颜色属性
+GLES30.glVertexAttribPointer(1, 3, GLES30.GL_FLOAT, false, 6 * Float.BYTES, 3* Float.BYTES);
+// 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字节。    
+
+
+### 着色器示例
+
+```
+顶点着色器如下：
+#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)
+
+---
+
+- 邮箱 ：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"
new file mode 100644
index 00000000..4bc0353a
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -0,0 +1,524 @@
+## 8.GLES类及Matrix类
+
+
+
+GLES作为我们与着色器连接的工具类提供了丰富的api。了解一些常用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(句柄、指针)
+
+```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);
+// 顶点位置数据传入着色器
+GLES30.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, 20, mRectBuffer);
+// 顶点颜色数据传入着色器中
+GLES30.glVertexAttribPointer(maColorHandle, 4, GLES20.GL_FLOAT, false, 4*4, mColorBuffer);
+// 顶点坐标传递到顶点着色器
+GLES30.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, 20, mRectBuffer);
+```
+
+### 定义顶点属性数组
+
+
+```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);
+```
+
+### 启用或禁用顶点属性数组
+
+调用GLES30.glEnableVertexAttribArray和GLES30.glDisableVertexAttribArray传入参数index。            
+
+如果启用，那么当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就是专门设计出来帮助我们简化矩阵和向量运算操作的，里面所有的实现原理都是线性代数中的运算。
+
+我们知道OpenGl中实现图形的操作大量使用了矩阵，在OpenGL中使用的向量为列向量，我们通过利用矩阵与列向量（颜色、坐标都可看做列向量）相乘，得到一个新的列向量。    
+利用这点，我们构建一个的矩阵，与图形所有的顶点坐标坐标相乘，得到新的顶点坐标集合，当这个矩阵构造恰当的话，新得到的顶点坐标集合形成的图形相对原图形就会出现平移、旋转、缩放或拉伸、抑或扭曲的效果。    
+Matrix是专门为处理4*4矩阵和4元素向量设计的，其中的方法都是static的，不需要初始化Matrix实例。
+
+
+
+OpenGL ES中使用的是列向量。列向量和矩阵相乘实现变换时，只能在列向量前面乘以矩阵。    
+而行向量则反之，否则乘法没有意义。   
+
+- multiplyMM
+
+  两个4x4矩阵相乘，并将结果存储到第三个4x4矩阵中。
+
+  ```java
+  public static native void multiplyMM(float[] result, int resultOffset,
+              float[] lhs, int lhsOffset, float[] rhs, int rhsOffset);
+  ```
+
+- multiplyMV
+
+  将一个4x4矩阵和一个四元素向量相乘，得到一个新的四元素向量
+
+  ```java
+  public static native void multiplyMV(float[] resultVec,int resultVecOffset,
+  			 float[] lhsMat, int lhsMatOffset,
+              float[] rhsVec, int rhsVecOffset);
+  ```
+
+- transposeM
+
+  获取逆矩阵
+
+
+
+平移、旋转、缩放等基本变换都是通过将表示点坐标的向量与特定的变换矩阵相乘完成的，进行基于矩阵的变换时，三维空间中点的位置需要表示成齐次坐标形式。   
+
+所谓齐次坐标形式也就是在x、y、z 3个坐标值后面增加第四个量w，未变换时w值一般为1。
+
+所谓齐次坐标表示就是用N+1维坐标表示N维坐标。     
+
+齐次坐标是为了兼容点的平移操作，使得我们可以用同一个公式对点和方向做运算。  y
+采用齐次坐标是由于很多在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中变换的实现机制可以理解为首先通过矩阵对坐标系进行变换，然后根据传入渲染管线的原始顶点坐标在最终变换结果坐标系中的位置来绘制。   
+
+
+
+
+
+### 相机
+
+顶点着色器可赋予程序员一次操作一个顶点（“按顶点”处理）的能力，片段着色器（稍后会看到）可赋予程序员一次操作一个像素（“按片段”处理）的能力，几何着色器可赋予程序员一次操作一个图元（“按图元”处理）的能力。
+
+到目前为止，我们所接触的变换矩阵全都可以在3D空间中操作。但是，我们最终需要将3D空间或它的一部分展示在2D显示器上。       
+
+为了达成这个目标，我们需要找到一个有利点。       
+正如我们在现实世界通过眼睛从一点观察一样，我们也必须找到一点并确立观察方向作为我们观察虚拟世界的窗口。这个点叫作视图或视觉空间，或“合成相机”（简称相机）。
+
+
+
+观察3D世界需要:    
+
+- 将相机放入世界的某个位置；
+- 调整相机的角度，通常需要一套它自己的直角坐标轴u、v、n（由向量U，V，N构成）；
+- 定义一个视体(view volume)；将视体内的对象投影到投影平面(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相机，我们需要将它移动到适合的位置和方向。我们需要先找出在世界中的物体与我们期望的相机位置的相对位置。      
+给定世界空间中的点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空间中有的平行线用透视法画出来就不再平行。我们可以通过使用变换矩阵将平行线变为恰当的不平行线来实现这个效果，这个矩阵叫作透视矩阵或者透视变换。           
+
+在正射投影中，平行线仍然是平行的，即不使用透视，如下图所示。正射与透视相反，在视体中的物体不因其与相机的距离而改变，可以直接投影。正射投影是一种平行投影，其中所有的投影过程都沿与投影平面垂直的方向进行。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_zheng.jpg?raw=true)
+
+我们最后要学习的变换矩阵是LookAt矩阵。当你想要把相机放在某处并看向一个特定的位置时，就需要用到它了，LookAt矩阵的元素如下图所示。        
+当然，用我们已经学到的方法也可以实现LookAt变换，但是这个操作非常频繁，因此为它专门构建一个矩阵通常比较有用。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_lookat.jpg?raw=true)
+
+- invertM
+
+  计算正交投影和透视投影
+
+
+
+### 正交投影
+
+- 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
+
+  计算透视投影矩阵
+
+- perspectiveM
+
+  根据视场角度、纵横比和Z裁剪平面定义投影矩阵
+
+- length
+
+  计算向量长度
+
+- setIdentityM(float[] sm, int smOffset)
+
+  用来创建一个单位矩阵。其中第一个参数是创建出来的单位矩阵存储的地方，是一个float类型的一维数组。第二个参数是存储的数据位置的偏移量，也就是说从哪里开始存储。生成的结果先按照列优先存储的，也就是说先存放第一列的数据，再存放第二列的数据，以此类推。前面理论部分已经提到，所有变换都是基于单位矩阵的基础上进行的，所以第一步创建单位矩阵是必须的。
+
+- scaleM(float[] m, int mOffset,
+            float x, float y, float z)
+
+    用来进行图像的缩放，第一个参数是需要变换的矩阵；第三、四、五个参数分别对应x,y,z 方向的缩放比例，当x方向缩放为0.5时，相当于向x方向缩放为原来的0.5倍，其他类似。
+
+- translateM(
+            float[] m, int mOffset,
+            float x, float y, float z)
+
+    用来进行图像的位移，第一个参数是需要变换的矩阵；第二个参数是偏移量；第三、四、五个参数分别对应x,y,z 方向的位移量。其以图像自身x，y，z方向为单位，也就是说当x方向位移量为0.5时，相当于向右移动0.5个身位，其他类似。
+
+- rotateM(float[] m, int mOffset,
+            float a, float x, float y, float 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渲染管线的需要。   
+
+  
+
+
+
+### 旋转
+
+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)  
+- [下一篇: 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"
new file mode 100644
index 00000000..e6a24893
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -0,0 +1,731 @@
+## 9.OpenGL ES纹理
+
+
+
+### 纹理
+
+
+现实生活中，纹理（Texture）最通常的作用是装饰 3D 物体，它就像贴纸一样贴在物体表面，丰富了物体的表面和细节。
+ 
+在 OpenGLES 开发中，纹理除了用于装饰物体表面，还可以用来作为存储数据的容器。
+
+那么在 OpenGLES 中，***纹理实际上是一个可以被采样的复杂数据集合，是 GPU 的图像数据结构，纹理分为 2D 纹理、 立方图纹理和 3D 纹理。***
+
+***2D 纹理是 OpenGLES 中最常用和最常见的纹理形式，是一个图像数据的二维数组。纹理中的一个单独数据元素称为纹素或纹理像素。***
+
+立方图纹理是一个由 6 个单独的 2D 纹理面组成的纹理。立方图纹理像素的读取通过使用一个三维坐标（s,t,r）作为纹理坐标。
+
+3D 纹理可以看作 2D 纹理作为切面的一个数组，类似于立方图纹理，使用三维坐标对其进行访问。
+
+
+
+使用纹理坐标来获取纹理颜色就称为采样(sampling)。
+
+
+### 基本原理
+
+启用纹理映射功能后，如果想把一副纹理应用到相应的几何图元，就必须告知渲染系统如何进行纹理的映射。     
+
+告知的方式就是为图元中的顶点指定恰当的纹理坐标，纹理坐标用浮点数来表示，范围一般从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:句柄，纹理的直接引用
+- 纹理单元:纹理的操作容器，有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对应的数据进行操作。
+
+OpenGL要操作一个纹理，那么是将纹理ID装进纹理单元这个容器里，然后再通过操作纹理单元的方式去实现的。      
+
+这样的话，我们可以加载出很多很多个纹理ID(但要注意爆内存问题)，但只有16个纹理单元，在Fragment Shader里最多同时能操作16个单元。
+
+  
+
+纹理贴图是在栅格化的模型表面上覆盖图像的技术。它是为渲染场景添加真实感的最基本和最重要的方法之一。
+纹理贴图非常重要，因此硬件也为它提供了支持，使得它具备实现实时的照片级真实感的超高性能。纹理单元是专为纹理设计的硬件组件，现代显卡通常带有数个纹理单元。
+为了在OpenGL/GLSL中有效地完成纹理贴图，需要协调好以下几个不同的数据集和机制：
+·用于保存纹理图像的纹理对象（在本章中我们仅考虑2D图像）；
+·特殊的统一采样器变量，以便顶点着色器访问纹理；
+·用于保存纹理坐标的缓冲区；
+·用于将纹理坐标传递给管线的顶点属性；
+·显卡上的纹理单元。
+
+
+
+### 纹理与渐变色的区别
+
+渐变色:光栅化过程中计算出颜色值，然后在使用片段着色器的时候可以直接赋值。
+
+纹理:光栅化过程中，计算出当前片段在纹理上的坐标位置，然后在片段着色器中根据这个纹理上的坐标，去纹理中取出相应的颜色值。
+
+### 纹理坐标
+
+OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)内，两个维度分别为S、T，所以一般称为ST纹理坐标。     
+有些时候也叫UV坐标。      
+纹理左边的方向性和Android上的视图坐标系一致，都是顶点在左上角，范围为0到1之间。
+
+
+纹理上的每个顶点与定点坐标上的顶点一一对应。如下图，左边是顶点坐标，右边是纹理坐标，只要两个坐标的ABCD定义顺序一致，就可以正常地映射出对应的图形。顶点坐标内光栅化后的每个片段，都会在纹理坐标内取得对应的颜色值。
+
+![](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度的纹理贴图。           
+所以调整纹理坐标和顶点坐标的对应关系可以实现纹理图简单的旋转。
+
+
+
+
+纹理坐标是对纹理图像（通常是2D图像）中的像素的引用。纹理图像中的像素被称为纹元(texel)，以便将它们与在屏幕上呈现的像素区分开。纹理坐标用于将3D模型上的点映射到纹理中的位置。除了将它定位在3D空间中的坐标(x,y,z)之外，模型表面上的每个点还具有纹理坐标(s,t)，用来指定纹理图像中的哪个纹元为它提供颜色。这样，物体的表面被按照纹理图像“涂画”。纹理在对象表面上的朝向由分配给对象顶点的纹理坐标确定。
+要使用纹理贴图，必须为要添加纹理的对象中的每个顶点提供纹理坐标。OpenGL将使用这些纹理坐标，查找存储在纹理图像中的引用的纹元的颜色，来确定模型中每个栅格化像素的颜色。为了确保渲染模型中的每个像素都使用纹理图像中的适当纹元进行绘制，纹理坐标也需要被放入顶点属性中，以便由光栅着色器进行插值。
+
+
+
+
+
+### 文件读取
+
+OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加载原始数据，也就是bitmap。        
+我们在内置图片到工程中，应该将图片放到drawable-nodpi中，避免读取时被压缩，通过BitmapFactory解码读取图片时，要设置为非缩放的方式，即options.isScaled=false。
+
+### 纹理过滤
+
+纹理坐标不依赖于分辨率，它可以是任意浮点值，所以OpenGL需要知道怎样将纹理像素映射到纹理坐标。      
+
+当你有一个很大的物体但是纹理的分辨率很低的时候这就变得很重要了。
+
+
+当我们通过光栅化将图形处理成一个个小片段的时候，再将纹理采样，渲染到指定位置上时，通常会遇到纹理元素和小片段并非一一对应。      
+这时候，会出现纹理的压缩或者放大。那么在这两种情况下，就会有不同的处理方案，这就是纹理过滤了。
+
+
+纹理过滤有很多选项，这里只说最重要的两项: GL_NEAREST和GL_LINEAR。   
+
+- GL_NEAREST: 临近过滤，是OpenGL默认的纹理过滤方式，会选择中心点最接近纹理坐标的那个像素。      
+
+- GL_LINEAR: 线性过滤，会基于纹理坐标附近的纹理像素，计算出一个插值，近似出这些纹理像素之间的颜色。一个纹理像素的中心距离纹理坐标越近，那么这个纹理像素的颜色对最终的样本颜色的贡献越大。     
+
+
+
+如果在一个很大的物体上应用一张低分辨率的纹理会发生什么呢(纹理被放大了，每个纹理像素都能看到)？
+
+GL_NEAREST产生了颗粒状的图案，我们能够清晰看到组成纹理的像素。    
+而GL_LINEAR能够产生更平滑的图案，很难看出单个的纹理像素。GL_LINEAR可以产生更真实的输出。      
+
+
+### 纹理对象和纹理的加载
+
+纹理应用的第一步是创建一个纹理对象。纹理对象是一个容器对象，保存渲染所需的纹理数据，例如图像数据、过滤模式和包装模式。         
+在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。
+
+```java
+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线程中调用
+     */
+    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) {
+            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) {
+            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对象上解绑，现在OpenGL已经完成了纹理的加载，不需要再绑定此纹理了，后面使用此纹理时通过纹理对象的ID即可
+        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`；
+
+  ```glsl
+  #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;
+  }
+  ```
+
+  
+
+- 片段着色器
+
+片段着色器也应该能访问纹理对象，但是我们怎样能把纹理对象传给片段着色器呢？         
+GLSL有一个供纹理对象使用的内建数据类型，叫做采样器(Sampler)，它以纹理类型作为后缀，比如sampler1D、sampler3D，或在我们的例子中的sampler2D。       
+我们可以简单声明一个uniform sampler2D把一个纹理添加到片段着色器中，稍后我们会把纹理赋值给这个uniform。
+
+我们使用GLSL内建的texture函数来采样纹理的颜色，它第一个参数是纹理采样器，第二个参数是对应的纹理坐标。           
+texture函数会使用之前设置的纹理参数对相应的颜色值进行采样。这个片段着色器的输出就是纹理的（插值）纹理坐标上的(过滤后的)颜色。
+
+
+之前直接输出顶点着色器来的颜色，现在变为经过纹理处理最终成为输出颜色。
+
+```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);
+}
+```
+
+
+为了最大限度地提高性能，我们希望在硬件中执行纹理处理。这意味着片段着色器需要一种访问我们在C++/OpenGL应用程序中创建的纹理对象的方法。它的实现机制是通过一个叫作统一采样器变量的特殊GLSL工具。这是一个变量，用于指示显卡上的纹理单元，从加载的纹理对象中提取或“采样”纹元。
+要实际执行纹理处理，我们需要修改片段着色器输出颜色的方式。以前，我们的片段着色器要么输出一个固定的颜色常量，要么从顶点属性获取颜色，而这次我们需要使用从顶点着色器（通过光栅着色器）接收的插值纹理坐标来对纹理对象进行采样。调用texture()函数如下：
+```
+in vec2 tc;            // 纹理坐标
+...
+color = texture(samp, tc);
+```
+  
+
+- render实现类
+
+区别就是把前面绘制矩形时的color部分换成了纹理，其他都是一样的。
+
+纹理的绘制:  
+
+```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);
+```
+
+
+
+#### 为什么要激活纹理单元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，它是默认激活的，纹理单元的主要目的就是给着色器多一个使用的纹理。         
+通过纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们在使用的时候激活纹理。
+
+
+OpenGL至少保证有16个纹理单元供你使用，也就是说你可以激活从GL_TEXTURE0到GL_TEXTURE15。         
+它们都是按顺序定义的，所以我们也可以通过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;
+      private final FloatBuffer textureBuffer;
+  
+      private int textureId;
+      private int aPositionLocation;
+      private int aTextureLocation;
+      private int uSamplerTextureLocation;
+  
+      /**
+       * 坐标占用的向量个数
+       */
+      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;
+      // 纹理坐标(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 TextureRender() {
+          vertextBuffer = BufferUtil.getFloatBuffer(POINT_DATA);
+          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();
+          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) {
+          glViewport(0, 0, width, height);
+          orthoM("u_Matrix", width, height);
+      }
+  
+      @Override
+      public void onDrawFrame(GL10 gl) {
+          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);
+      }
+  }
+```
+
+
+
+### 多纹理绘制 
+
+
+- 单纹理单元，多次绘制
+
+多次调用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);
+    }
+```
+  
+  
+  
+- 多纹理单元，单次绘制
+
+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;
+    }
+}
+```
+相关功能介绍: 
+- 窗口，Window：主窗口，用于界面显示
+- 渲染，Render：GPU，硬件加速
+- 纹理，texture：存储描述信息
+- 画布，surface：内存中的一块地址，存储像素数据
+
+
+
+- 几何着色器
+
+几何着色器阶段位于曲面细分着色器和栅格化之间，位于用于图元处理的管线内。
+顶点着色器允许一次操作一个顶点，而片段着色器一次可以操作一个片段（实际上是一个像素），但几何着色器却可以一次操作一个图元。
+
+
+
+
+#### 纹理色彩通道灵活组合
+
+纹理色彩通道的灵活组合。通过其可以对输入的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)  
+
+- [下一篇: 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/P2P\346\212\200\346\234\257/P2P.md" "b/VideoDevelopment/P2P\346\212\200\346\234\257/P2P.md"
new file mode 100644
index 00000000..850e36f6
--- /dev/null
+++ "b/VideoDevelopment/P2P\346\212\200\346\234\257/P2P.md"
@@ -0,0 +1,185 @@
+P2P
+===
+
+![image](https://github.com/CharonChui/Pictures/blob/master/p2p.jpg?raw=true)
+
+## P2P简介
+P2P(Peer to Peer):点对点通信或称为对等联网。每个用户既下载数据，又作为服务器存储数据
+并供其他用户下载。他的本质，是一种硬盘的共享，是把每个人电脑上的一部分硬盘，拿出来与其他人共享。
+
+1999年互联网界非常著名的一个创业者，他的名字叫Shawn Fanning。他创立了一个叫
+Napster的mp3音乐分享网站，他通过将每个人电脑上的mp3汇集成一张目录，当有人想下载mp3时，
+那么Napster就会找到那些有这个mp3的电脑，同时去从这些电脑中下载一个个小小的碎片，然后在你的电脑上
+拼成这个mp3。所以Napster本身并不拥有MP3，他只是帮助那些拥有mp3的人互相分享，我们把这个
+叫做点对点的分享。
+
+P2P可以是一种通信模式、一种逻辑网络模型、一种技术、甚至一种理念。在P2P网络中，
+所有通信节点的地位都是对等的，每个节点都扮演着客户机和服务器双重角色，节点之间通过直接通信实现
+文件信息、处理器运算能力、存储空间等资源的共享。P2P网络具有分散性、可扩展性、健壮性等特点，
+这使得P2P技术在信息共享、即时通讯、协同工作、分布式计算、网络存储等领域都有广阔的应用。
+
+传统的CS模型:    
+![image](https://github.com/CharonChui/Pictures/blob/master/cs.jpg?raw=true)    
+p2p模型:   
+![image](https://github.com/CharonChui/Pictures/blob/master/p2p_model.jpg?raw=true)
+
+
+## 迅雷
+
+说到P2P我的第一印象就是迅雷。    
+
+迅雷就是做P2P下载的，它的逻辑是把电影文件，放到每个不同的电脑上，然后彼此分享，这个模式极
+大地节省了资源。它将整个文件虚拟等份拆分→制作bt种子，记录等分文件信息及追踪信息→用户获取种子→
+下载工具解析文件信息并追踪拥有分块文件的用户地址→发起连接→同时从多个用户计算机直接下载分块
+文件（无需再上传至服务器）
+
+迅雷将P2P技术优势发扬光大，并加以改进推出P2SP（存储资源至迅雷自己的服务器，P2P下载的同时还解析HTTP的下载链接）；
+当年大型网络游戏在国内的井喷式发展吸引了大量玩家，而安装文件动辄几个GB，还不到100kb/s的HTTP下
+载速度实在无法满足用户需求。迅雷为用户提供高速稳定的下载体验，快速占领下载工具市场；2004年，迅雷超越
+传统HTTP/FTP下载工具龙头——网际快车，成为市场第一。其实网际快车和比特彗星的没落也与网络游戏有关，
+创始人由于沉迷于魔兽世界，停更软件长达一年。
+
+2006年用户数量破亿，迅雷积累大量P2P用户，用户越多资源越多，下载速度越快，由此迅雷在下载工具市场的地位
+变得无法撼动。
+
+
+### P2P的弊端
+
+- 版权问题    
+P2P传输是用户间直接共享，不向版权方支付任何费用。版权方起诉下载用户不现实，转而起诉P2P下载工具。
+2011年-2014年一季度，迅雷涉及版权的诉讼达366起。版权及诉讼问题影响公司自身发展。虽然迅雷只输了3起官司
+，赔偿5.6万人民币，但确实为用户盗版提供了帮助。迅雷曾经因版权问题受到美国电影协会质疑而影响IPO进程。
+
+- 监管与安全      
+数据传输完全不需要中心服务器使得P2P传输缺乏监管，色情暴力、敏感政治等无法从正规渠道获取的非法内容，
+却可以通过私下分享种子文件传播。无法确定下载内容是否包含病毒程序。
+
+- 传输速度    
+上行带宽影响下行带宽：P2P用户需要作为服务器为其他用户提供下载服务。用户打开迅雷即便自身
+不下载任何数据也会影响网速，因此迅雷一度被称为“吸血迅雷”，在大学寝室开迅雷的童鞋也常常被室友揪出来批斗。
+因为整个互联网的基础设施是非对称型的，下行特别快，上行会窄一点。P2P场景虽然把上行带宽用起来了，
+但是最终对社会的成本是比较高的。P2P虽然用户节点多，但数据传输较为无序，算法有优化空间。
+随着互联网信息量暴增，尤其是视频格式从avi/rmvb发展到mkv，用户对视屏分辨率的要求越来越高，
+一部蓝光高清电影有可能达到十几GB，即便P2P传输也压力山大。
+
+#### P2P的弊端加上互联网变革使迅雷面临困境
+
+- 丧失资源优势，用户流失    
+    - 盗版资源：    
+    迅雷为融资及业务发展解决了版权的问题，包括字幕组在内的盗版资源转战虚拟网盘
+    （以前都是要迅雷种子/磁链，现在流行百度云盘）
+    - 色情暴力：     
+    2014年扫黄打黑办公室开展净网行动，典型事件是快播CEO王欣的入狱，时至今日涉及色情、暴利、政治
+    敏感的资源很难再从迅雷获取。
+
+### 迅雷的突破
+
+完美契合迅雷的技术优势与互联网趋势，成为最佳的转型方向。
+
+点播业务峰值是相对均衡的，它已经通过各家CDN在功能、性能、稳定性以及响应度各种努力，把它做到了一秒
+的延时、秒开、高质量、低卡顿。但直播业务的峰值时不时出现巨量增长，且往往并发非常高，也就两个小时。
+这会带来高额的带宽成本。在此基础上若引入P2P结合CDN，可降低整体产品的使用成本。    
+传统的P2P架构已经老化，就是早期的迅雷以及在快播做的P2SP架构。其最大的场景，是PC上的分布式网络。
+而现在机顶盒、路由器、手机等所有设备都已经自动化，以前PC的这套网络已经落后，亟待革新。
+传统P2P的最大特点就是高分享率、但低可用性。比如说原来在快播做的数据分享率可以做到99%，
+但质量是无法保障的。而CDN+P2P是把CDN的高可用性、可管理、可运维去和P2P的加速性、可靠性以及突发
+处理能力做一个有机结合，在网络层面提高系统的可扩展性，降低成本，降低跨域、跨流量的问题。    
+
+2015年6月，迅雷全资子公司网心科技推出星域CDN，正式布局P2PCDN业务。P2PCDN与传统CDN或云CDN模式
+的区别在于，服务器不再由厂商自建而是P2P用户自己提供或购买设备，带宽从P2P用户端低价收购。
+
+### P2PCDN的优势
+
+CDN成本大幅降低（服务器成本，带宽采购成本），服务器规模理论上无限多且容易扩展（多卖一台设备就多一个P2P服务器）。
+从官方透露的信息来看，星域CDN业务受到视频直播领域客户的广泛认可。爱奇艺、快手都是星域CDN的客户，采购量有所增加。
+星域CDN也与小米、熊猫、陌陌、bilibili和触手等用户保持密切合作。
+
+但在成本方面：迅雷节省的成本越多，用户可得收益越少。对迅雷而言，CDN服务利润=给客户提供的
+带宽售价-从用户收来的带宽成本-自身服务器的架设成本。对用户而言，分享带宽的动机=迅雷收集闲置带宽所
+给予的收益-硬件购置与损耗成本-电费成本-网络成本（注：一般用户的网络实际上是成本略低的家用网络，
+若将其用于商业用途，或违反与电信商签署的宽带协议）。
+
+需要注意的是，一旦参与迅雷CDN计划的用户减少，迅雷CDN市场占有率也会降低。所以，
+给予用户足够的动机显得至关重要。
+
+### 用户刺激
+
+为了刺激用户的分享热情，迅雷开启了一系列的计划。其中最有名的是玩客云   
+1. 迅雷水晶    
+将用户PC直接作为服务器，用户贡献上行带宽，所得奖励为迅雷水晶，迅雷水晶可兑换人民币。问题：
+硬件损耗大，耗电量高，影响网速。
+
+2. 赚钱宝+IDC专属项目    
+2014年腾讯云计算总裁陈磊加入迅雷任CTO，合作迅雷云计算业务。2015年4月推出二代P2PCDN计划：赚钱宝。
+赚钱宝是独立的硬件设备，由玩家购买作为服务器。玩家贡献上行带宽，所得奖励为迅雷水晶，10000水晶=1人民币。
+IDC专属针对的是闲置机房/个人网管。解决了上一代的问题：赚钱宝较PC功率小，耗电量低；
+作为独立硬件贡献闲置带宽，网速影响小。
+
+3. 玩客云     
+玩客云与赚钱宝的运作模式类似，用户购买玩客云设备，贡献带宽与储存，按照一定规则获取玩客币。
+唯一的不同之处就在于赚钱宝给人民币，玩客云给玩客币。
+
+
+扯远了，这里回来继续说P2P。 
+
+## P2P的原理
+
+常见流媒体直播协议都属于C/S型，即所有客户端通过指定协议，从服务端获取直播数据。当客户端数量达到
+一定规模后，服务端将承受巨大的I/O和带宽压力。若服务器无法及时处理客户请求，客户端卡播率急剧上升，
+从而影响用户观看体验。
+
+直播P2P技术，简单来说，就是客户端之间使用一定协议，交换和共享直播数据，通过减少对服务器的数据请求，
+来降低服务端的I/O带宽等方面压力，从而削减服务器带宽成本，降低客户端卡播率。
+
+鉴于通用性与效率，一般很少从底层开始设计一套全新的流媒体直播P2P协议。惯用做法是基于通用协议，
+实现客户端的P2P网络。对基于HTTP的流媒体协议，如HLS，MPEG-DASH等，重写客户端数据下载逻辑即可；
+对非HTTP的流媒体协议实现P2P，如RTMP，RTSP，需要一套切片服务器，切片服务器负责持续地将数据流切成
+一个个数据片段（类似HLS的TS文件），客户端在P2P网络基础上进行数据片段的下载和交换共享。
+
+设计直播P2P协议，通常关注两个要素：客户端延迟，P2P分享率。客户端延迟是指客户端播放到的最新数据时间
+戳与服务器最新产生的数据时间戳的差值，P2P分享率是指客户端从P2P网络获取的数据量与客户端完整观
+看所需的数据量的比值。
+
+
+## NAT
+
+
+二十世纪90年代初，网络专家们意识到，IPv4地址很快就要耗光了。于是，人们开始考虑IPv4的替代方案，同时采取一系列的措施来减缓IPv4地址的消耗。正是在这样一个背景之下，本期的主角闪亮登场，它就是网络地址转换——NAT。
+
+NAT是一项神奇的技术，说它神奇在于它的出现几乎使IPv4起死回生。在IPv4已经被认为行将结束历史使命之后近20年时间里，人们几乎忘了IPv4的地址空间即将耗尽这样一个事实——在新技术日新月异的时代，20年可算一段漫长的历史。更不用说，在NAT产生以后，网络终端的数量呈加速上升趋势，对IP地址的需求剧烈增加。此足见NAT技术之成功，影响之深远。
+
+说它神奇，更因为NAT给IP网络模型带来了深远影响，其身影遍布网络每个角落。根据一份最近的研究报告，70%的P2P用户位于NAT网关以内。因为P2P主要运行在终端用户的个人电脑之上，这个数字意味着大多数PC通过NAT网关连接到Internet。如果加上2G和3G方式联网的智能手机等移动终端，在NAT网关之后的用户远远超过这个比例。
+
+然而当我们求本溯源时却发现一个很奇怪的事实：NAT这一意义重大的技术，竟然没有公认的发明者。NAT第一个版本的RFC作者，只是整理归纳了已被广泛采用的技术。
+
+
+NAT名字很准确，网络地址转换，就是替换IP报文头部的地址信息。NAT通常部署在一个组织的网络出口位置，通过将内部网络IP地址替换为出口的IP地址提供公网可达性和上层协议的连接能力。那么，什么是内部网络IP地址？
+
+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网关的存在对通信双方是保持透明的；
+- NAT网关为了实现双向翻译的功能，需要维护一张关联表，把会话的信息保存下来。
+
+NAT最典型的应用场景就如同图2描述的，一个组织网络，在出口位置部署NAT网关，所有对公网的访问表现为一台主机。这就是所谓的一对多模型。这种方式下，出口设备只占用一个由Internet服务提供商分配的公网IP地址。面对私网内部数量庞大的主机，如果NAT只进行IP地址的简单替换，就会产生一个问题：当有多个内部主机去访问同一个服务器时，从返回的信息不足以区分响应应该转发到哪个内部主机。此时，需要NAT设备根据传输层信息或其他上层协议去区分不同的会话，并且可能要对上层协议的标识进行转换，比如TCP或UDP端口号。这样NAT网关就可以将不同的内部连接访问映射到同一公网IP的不同传输层端口，通过这种方式实现公网IP的复用和解复用。这种方式也被称为端口转换PAT、NAPT或IP伪装，但更多时候直接被称为NAT，因为它是最典型的一种应用模式。
+
+
+更多P2P技术的原理可见:   
+
+- [P2P技术详解(一)：NAT详解——详细原理、P2P简介](http://www.52im.net/thread-50-1-1.html)
+- [P2P技术详解(二)：P2P中的NAT穿越(打洞)方案详解](http://www.52im.net/thread-542-1-1.html)
+- [P2P技术详解(三)：P2P中的NAT穿越(打洞)方案详解(进阶分析篇)](http://www.52im.net/thread-2872-1-1.html)
+- [P2P技术详解(四)：P2P技术之STUN、TURN、ICE详解](http://www.52im.net/thread-557-1-1.html)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
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..b8ffe932
--- /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,86 @@
+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原理
+内网主机向外网主机发送的网络包，在经过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处理报文的几个关键特点：**
+
+
+
+- 1）网络被分为私网和公网两个部分，NAT网关设置在私网到公网的路由出口位置，双向流量必须都要经过NAT网关；
+- 2）网络访问只能先由私网侧发起，公网无法主动访问私网主机；
+- 3）NAT网关在两个访问方向上完成两次地址的转换或翻译，出方向做源信息替换，入方向做目的信息替换；
+- 4）NAT网关的存在对通信双方是保持透明的；
+- 5）NAT网关为了实现双向翻译的功能，需要维护一张关联表，把会话的信息保存下来。
+
+
+
+ 简单的背景了解过后，下面介绍下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用户，这样就把他俩形成了一个私有的通路，这个操作就是打洞。 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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/\345\205\263\351\224\256\345\270\247.md" "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
new file mode 100644
index 00000000..878ca9db
--- /dev/null
+++ "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
@@ -0,0 +1,85 @@
+关键帧
+===
+
+
+
+### 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
+
+这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 帧就无法解码。
+
+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通常用于视频流中断或丢失时，重新恢复视频流的一种方式。
+
+总之，I帧是视频序列中的一种关键帧，它能够独立解码，而IDR是一种特殊的I帧，具有重新初始化解码器的特殊作用。
+
+一个序列(GOP)的第一个图像叫做IDR图像(立即刷新图像)，IDR图像都是I帧图像。H.264引入IDR图像是为了解码的重新同步，当解码器解码到IDR图像时，立即将参考帧队列清空，将已解码的数据全部输出或抛弃，重新查找下一个参考集，开始解码一个新的序列。这样，如果前一个序列出现重大错误，在这里可以获得重新同步的机会。IDR图像之后的图像永远不会使用IDR之前的图像数据来解码。一个序列就是一段内容差异不太大的图像编码后生成的一串数据流。当运动变化比较少时，一个序列可以很长，因为运动变化少就代表图像画面的内容变动很小，所以就可以是一个I帧，然后一直是P帧、B帧。当运动变化多时，一个序列可能会比较短，比如只包含一个I帧和几个P帧、B帧。
+
+     那么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 参数进行更新。
+     对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)
+
+### 数据压缩比
+
+数据压缩比大约为: 
+
+I帧 : P帧 : B帧 = 7 ：20 : 50
+
+P帧和B帧极大的节省了数据量，节省出来的空间可以用来多保存一些I帧，以实现在相同码率下，提供更好的画质。    
+
+### PTS和DTS
+
+【为什么会有PTS和DTS的概念】
+
+通过上面的描述可以看出：P帧需要参考前面的I帧或P帧才可以生成一张完整的图片，而B帧则需要参考前面I帧或P帧及其后面的一个P帧才可以生成一张完整的图片。这样就带来了一个问题：在视频流中，先到来的 B 帧无法立即解码，需要等待它依赖的后面的 I、P 帧先解码完成，这样一来播放时间与解码时间不一致了，顺序打乱了，那这些帧该如何播放呢？这时就引入了另外两个概念：DTS 和 PTS。在没有B帧的情况下，DTS和PTS的输出顺序是一样的。因为B 帧打乱了解码和显示的顺序，所以一旦存在B帧，PTS与DTS势必就会 不同。
+
+【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  帧来预测，因而编解码和帧的显示顺序有所不同
+
+
+
+
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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"
new file mode 100644
index 00000000..ba93a123
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md"
@@ -0,0 +1,119 @@
+# JPEG
+
+[JPEG](https://www.w3.org/Graphics/JPEG/itu-t81.pdf)
+JPEG（Joint Photographic Experts Group)，全称为联合图像专家小组，是国际标准化组织（ISO）制定的静态图像压缩标准，文件扩展名为.jpg或.jpeg，适用于连续色调静止图像处理。
+
+
+
+JPEG只描述一副图像如何转换成一组数据流，而不论这些字节存储在何种介质上。     
+
+由独立JPEG组创立的另一个进阶标准，JFIF（JPEG File Interchange Format，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..3732f554
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md"
@@ -0,0 +1,243 @@
+# 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 用于“你想说什么”。​
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文本而且支持扩展性，可用于编辑元数据、版权等。   
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\346\220\255\345\273\272nginx+rtmp\346\234\215\345\212\241\345\231\250.md" "b/VideoDevelopment/\346\220\255\345\273\272nginx+rtmp\346\234\215\345\212\241\345\231\250.md"
new file mode 100644
index 00000000..7b54f1cd
--- /dev/null
+++ "b/VideoDevelopment/\346\220\255\345\273\272nginx+rtmp\346\234\215\345\212\241\345\231\250.md"
@@ -0,0 +1,61 @@
+搭建nginx+rtmp服务器
+===
+
+为了更好的进行直播功能的开发，我们需要本地搭建`nginx+rtmp`服务器，下面就是介绍如何在`Mac`上的搭建步骤:  
+
+1. 安装`Homebrew`(有关`Homebrew`的介绍请参考[Homebrew介绍](http://www.cnblogs.com/lzrabbit/p/4032515.html)
+
+    打开终端, 查看是否已经安装了`Homebrew`, 直接终端输入命令`man brew`
+    如果`Mac`已经安装了, 会显示一些命令的帮助信息. 此时输入`Q`退出即可, 直接进入第二步. 反之, 如果没有安装,执行命令 
+    `ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"` 
+    如果安装后, 想要卸载 
+    `ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/uninstall)"`
+
+2. 安装`nginx`
+
+    - 先执行命令`brew tap homebrew/nginx`来`clone nginx`项目到本地
+    - 通过命令`brew install nginx-full --with-rtmp-module`执行安装
+
+    此时, `nginx`和`rtmp`模块就安装好了,输入命令`nginx`然后在浏览器里打开`http://localhost:8080`，如果出现欢迎界面就说明大功告成了。
+
+3. 配置`nginx`和`ramp`
+
+    首先通过命令`brew info nginx-full`查看安装目录， 然后找到`nginx.conf`文件所在位置, 例如`/usr/local/etc/nginx/nginx.conf`。 
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/nginx_path.png?raw=true)
+
+    打开`nginx.confg`文件后在文件的最后一行空白处添加如下代码。
+    
+    ```java
+    rtmp {
+        server {
+            listen 1935;
+            application rtmplive {
+                live on;
+                record off;
+            }
+        }
+    }
+    ```
+    然后通过命令`[path] -s reload`重启`nginx`，我的是`/usr/local/opt/nginx-full/bin/nginx -s reload`。
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/nginx_reload.png?raw=true)
+
+4. 安装`ffmpeg`
+
+    执行命令`brew install ffmpeg`安装`ffmpeg`。  
+
+5. 安装`VLC`播放器
+
+    [VLC](http://www.videolan.org/)下载安装，可用于播放测试`rtmp`协议的流媒体。
+
+6. `Over`.
+
+
+
+参考:  
+
+- [https://github.com/arut/nginx-rtmp-module/wiki](https://github.com/arut/nginx-rtmp-module/wiki)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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..e96493fa
--- /dev/null
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
@@ -0,0 +1,216 @@
+# 简介
+
+除了前面讲的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传输协议的流媒体传输技术。它诞生的目的是为了统一标准，因此是兼容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。
+
+![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)
+
+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)
+
+```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、视频分辨率、码率等。   
+DASH会通过media presentation description (MPD)将视频内容切片成一个很短的文件片段，每个切片都有多个不同的码率，DASH Client可以根据网络的情况选择一个码率进行播放，支持在不同码率之间无缝切换。
+DASH中的重要概念
+
+### Period
+
+标注了视频的时长信息，也可以看做是更新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将被单独描述
+
+### Representation
+
+包含不同的码率、编码方式、帧率信息等。每个Adaptationset包含了一个或者多个Representations,一个Representation包含一个或者多个media streams，每个media stream对应一个media content component。为了适应不同的网络带宽，实际播放的时候，视频会在一个AdaptationSet中的不同Representaiton 之间切换码率，可能会从一个Representation切换到另外一个Representation，会依次请求该Representaiton下不同Segment序列。
+
+### Segments
+
+每一个具体的片段。（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）
+
+- 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。
+   
+   
+   
+   `*_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
+
+  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即可。
+
+码率自适应切换算法
+
+- 基于带宽的码率自适应切换算法
+- 基于缓存的码率自适应切换算法
+
+![image-20200406165443536](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_change_compare.png)
+
+此基于时间缓存的码率自适应算法对网络带宽变化反应敏感，能够有效的提高平均码率，但同时码率切换次数过大，尤其是在网络状况波动很大的情况下，这势必会造成用户体验的下降。
+
+- MSS拥有最高的平均码率和较少的切换次数
+
+- HLS的切换次数最少，但是以最低的平均码率作为代价
+
+- HDS不能保证流程的播放
+
+- DASH有足够的竞争力，也具有巨大的提升空间。
+
+
+
+## 为什么使用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支持缩略型描述以支持快速启动。
+
+    
+
+
+
+
+
+### HLS vs DASH
+
+
+
+- 在标准HTTP服务器上的用法： HLS和DASH均可在常规HTTP服务器（例如Nginx，Apache等）上使用。
+- 多个音频通道: 特别是对于多语言内容，重要的是能够在各个语言的不同音频通道之间进行切换。 DASH和HLS都可以做到这一点。
+- 字幕和标题: 为了给视频添加字幕，通常创建一个单独的文件，例如，文件可以具有WebVTT格式。然后从清单（即.m3u8或.mpd文件）中引用该文件。
+- 插入广告: 通常，可以在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。
+
+
+
+### 测试流
+
+- 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
+
+
+
+参考:  
+
+- [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)
+
+
+
+
+
+在线测试播放器: 
+
+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"
new file mode 100644
index 00000000..852cfb03
--- /dev/null
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
@@ -0,0 +1,240 @@
+# HLS协议
+
+[HLS(HTTP Live Streaming)协议](https://developer.apple.com/library/archive/documentation/NetworkingInternet/Conceptual/StreamingMediaGuide/Introduction/Introduction.html)：2009年由苹果公司实现的基于HTTP的流媒体传输协议，可实现流媒体的直播和点播。它的工作原理是把整个流分成一个个小的基于HTTP的文件来下载，每次只下载一些。
+
+HLS协议规定:  
+
+- 视频的封装格式是ts(WWDC2016年发布也支持了fMP4)
+- 视频的编码格式为H264、H265、VP9(17年支持H265、VP9)，音频编码格式为MP3、AAC或者AC-3
+- 除了TS视频文件本身，还定义了用来控制播放的m3u8文件(文本文件)
+
+HLS协议由三部分组成:  
+
+- HTTP:传输协议
+- 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端口)，不会遇到被防火墙屏蔽的情况。
+
+
+
+## 使用
+
+- [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 。即服务器、分发组件和客户端。
+
+下面是 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/视频流)的任一片段开始都是可以独立解码的。
+
+
+
+在开始一个流媒体会话时，客户端会下载一个包含元数据的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  切片会相应的被删除，流停止，影片不会立即停止，影片播放会滞后于拉流一段时间
+
+
+
+
+- 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/adaptive_bitratestreaming_HLS.jpg" 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
+```
+
+
+
+#### 直播流 
+
+```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 的优势
+
+- 客户端支持简单, 只需要支持 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 不稳定和出现错误的风险.通常 HLS 直播延时会达到 20-30s，而高延时对于需要实时互动体验的直播来说是不可接受的。Apple在WWDC2019发布了新的解决方案，可以将延迟从8秒降低到1至2秒。
+- 对于点播服务来说, 由于 TS 切片通常较小, 海量碎片在文件分发, 一致性缓存, 存储等方面都有较大挑战.
+- HLS 基于短连接 HTTP，HTTP 是基于 TCP 的，这就意味着 HLS 需要不断地与服务器建立连接，TCP 每次建立连接时的三次握手、慢启动过程、断开连接时的四次挥手都会产生消耗。
+
+
+
+## TS相比MP4的劣势
+
+TS文件虽然适于优先电视领域的应用，但在带宽使用上与DASH所使用的扩展格式MP4相比有巨大的劣势。首先TS包按188字节分割过于细小，其包头虽然仅占4字节，累积起来仍嫌浪费。其次，重复插入的PSI包对持续的视频播放而言颇显肿余（虽然HLS协议的后期版本通过EXT-X-MAP标签支持独立的仅含PSI包的TS文件，但将引入兼容问题）。更重要的是，由于TS包的字节数限制，当视频或音频包不足字节数时，需要加上许多无用的填充字节。据不同来源统计，三项合计，TS文件平均要浪费4%~13%的带宽，设计较好的封装格式，在寸带宽寸金的互联网世界中，意味着节约千万甚至上亿美元。
+
+
+
+
+
+
+
+#### 测试地址:
+
+- 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
+
+
+
+#### 参考:
+
+- [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"
new file mode 100644
index 00000000..9cbdf178
--- /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,84 @@
+HTTP FLV
+===
+
+在说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”。
+
+HttpFlv 就是 http+flv ，将音视频数据封装成FLV格式，然后通过 HTTP 协议传输给客户端。
+
+当下的直播平台中大部分的主线路使用的都是HTTP-FLV协议，备线路多为RTMP。小编随便在Safari中打开几个直播平台房间，一抓包就不难发现使用HTTP-FLV协议的身影：熊猫、斗鱼、虎牙、B站。
+
+
+
+HTTP-FLV
+
+我们这里说的HTTP-FLV，主要是说的是HTTP-FLV流，而不是基于HTTP的FLV视频文件点播，也不是能够随意SEEK的HTTP FLV伪流。
+
+FLV渐进式下载：通过HTTP协议将FLV下载到播放器中播放，无法直接拉到中间去播放。
+
+HTTP FLV伪流：支持SEEK，可从未下载的部分开始播放。
+
+HTTP-FLV流：拥有和流式协议RTMP一样的特征，长连接，流式数据。
+
+#### 4 优点：
+
+- 服务器兼容性好：基于 HTTP 协议。
+- 低延迟：直接传输 FLV 流，而且基于 HTTP 长链接。
+
+#### 5 缺点：
+
+- 播放端兼容性不好：需要 Flash 支持，不支持多音视频流，不便于 Seek。
+
+▣  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! 
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..425d5974
--- /dev/null
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md"
@@ -0,0 +1,131 @@
+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的整体流程为:  
+
+视频采集器 -> 支持RTMP的视频编码器 -> 网络传输  -> 流媒体服务器 -> 网络 -> 客户端
+
+
+
+#### 2 握手流程：
+
+以下为简单握手的流程
+
+[![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 支持。
+
+
+
+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\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/\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）。
+
+
+
+
+
+
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..507a0aad
--- /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,105 @@
+FLV
+===
+
+在网络的直播与点播场景中，FLV也是一种常见的格式，FLV是Adobe发布的一种可以作为直播也可以作为点播的封装格式，其封装格式非常简单，均以FLVTAG的形式存在，并且每一个TAG都是独立存在的.
+
+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)
+
+
+tag又可以分成三类:
+- Audio Tag：音频流
+- Video Tag：视频流
+- Script Tag：脚本流，又称Metadata Tag
+
+每个tag又由tag header和tag data组成。一般一个flv文件由一个头部信息，一个script Tag，以及若干个video Tag和audio Tag组成。
+
+
+#### FLV整体结构图：
+
+![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 body结构分析
+
+FLV body由若干个tag 组成。每一个tag第一部分是tag header，tag header长度为11bytes，但是每个tag header前面有4bytes记录着上一个tag的长度。
+
+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。
+
+##### 音频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)   
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_video_tag2.png?raw=true)   
+
+
+##### 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)   
+
+- 第一个AMF包：
+    第1个字节表示AMF包类型，一般总是0x02，表示字符串。第2-3个字节为UI16类型值，标识字符串的长度，一般总是 0x000A（“onMetaData”长度）。后面字节为具体的字符串，一般  为“onMetaData”（6F,6E,4D,65,74,61,44,61,74,61）。
+    所以第一个AMF包总共占13字节。
+
+- 第二个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等常见元素，但并不确认适用于所有元素。常见的数组元素如下表所示。
+
+    ![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`
+
+[FLV分析工具: FlV Analyzer](http://flv-viewer.softwar.io/)
+
+参考: 
+
+- [flv/video_file_format_spec_v10](https://www.adobe.com/content/dam/acom/en/devnet/flv/video_file_format_spec_v10.pdf)
+
+
+
+---
+
+- 邮箱 ：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/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"
new file mode 100644
index 00000000..8f7769d9
--- /dev/null
+++ "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"
@@ -0,0 +1,158 @@
+MP4格式详解
+===
+
+MP4是一套用于音频、视频信息的压缩编码标准，由国际标准化组织（ISO）和国际电工委员会（IEC）下属的“动态图像专家组”（Moving Picture Experts Group，即MPEG）制定。MP4 实际代表的含义是MPEG-4 Part 14。它只是MPEG标准中的14部分。它主要参考ISO/IEC标准来制定的。MP4主要作用是可以实现快进快放，边下载边播放的效果。MPEG-4格式的主要用途在于网上流、光盘、语音发送（视频电话），以及电视广播，是一种常见的多媒体封装格式。
+
+MP4的格式稍微比FLV复杂一些，它是通过嵌的方式来实现整个数据的携带。换句话说，它的每一段内容，都可以变成一个对象，如果需要播放的话，只要得到相应的对象即可。
+
+
+MP4视频文件封装格式是基于QuickTime容器格式定义的，因此参考QuickTime的格式定义对理解MP4文件格式很有帮助。MP4文件格式是一个十分开放的容器，几乎可以用来描述所有的媒体结构，MP4文件中的媒体描述与媒体数据是分开的，并且媒体数据的组织也很自由，不一定要按照时间顺序排列，甚至媒体数据可以直接引用其他文件。同时，MP4也支持流媒体。MP4目前被广泛用于封装h.264视频和AAC音频，是高清视频的代表。
+
+**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的基本结构是:  
+```
+[4bytes atom size] [4bytes atom type] [8bytes largesize, if size ==1] [contents of the atom, if any]
+```
+
+这四部分分别是:   
+- 4bytes atom size:表示整个Atom所占用的大小，包含Header部分，如果Atom很大，超过了unit32的最大值(例如存放具体视频数据的mdata)，size就会被设置为1，并用接下来的LARGESIZE来存放数据大小
+- 4bytes atom type:表示这个Atom的类型，主要有ftyp、moov、mdat等
+- 8bytes largesize, if size ==1: 使用8bytes unit64来存储该Atom的大小
+- contents of the atom, if any: 实际的数据
+
+### MP4文件的Atom结构
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/mp4_info.png?raw=true)
+
+这里在mac上使用[MediaParser](https://github.com/ksvc/MediaParser)来查看一个mp4文件的结构(Windows上可以使用Mp4Info): 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/mediaparser_mp4.png?raw=true)
+
+
+Mp4文件需要有ftyp、moov、mdat，它们都是顶级的Atom文件，不能被其他Atom包含。
+- ftyp：指示该MP4文件应用的相关信息，必须在第一个，而且只有一个，并且只能被包含在文件层，而不能被其他box包含。
+- moov：该box包含了文件媒体的metadata信息，“moov”是一个container box，具体内容信息由子box诠释。
+- mdat：实际媒体数据，我们最终解码播放的音视频数据都在这里面。
+moov和mdat这两个Atom顺序不固定，一般来说都是moov在前。
+
+
+### MP4重要box
+
+#### ftyp(File Type Box)
+
+声明该文件为MP4文件的相关信息，必须在第一个，而且只有一个
+
+#### moov(movie box)
+
+moov在mp4文件中也是有且只有一个，moov中会包含1个mvhd和若干个trak。其中mvhd为header box，一般作为moov的第一个子box出现。
+
+##### mvhd(movie header box)
+
+mvhd定义了整个movie的特性，通常包含媒体无关的信息，例如播放时长、创建时间等，具体的类型有:   
+
+- box size
+- box type
+- version:box版本，0或1，一般为0
+- flags
+- creation time
+- modification time
+- time scale
+- duration
+- rate:推荐播放速率
+- volume
+- reserved
+- matrix
+- pre-defined
+- next track id
+
+##### trak(Track Box)
+
+
+- track表示一些sample的集合，对于媒体数据来说，track表示一个视频或音频序列。
+- hint track:一类特殊的track，并不包含媒体数据，而是包含了一些将其他数据track打包成流媒体的指示信息。
+- sample:对于非hint track来说，video sample即为一帧视频或者一组连续视频帧，audio sample即为一段连续的压缩音频，他们统称为sample。对于hint track来说，sample定义一个或多个流媒体包的格式。
+- chunk:一个track的几个sample组成的单元。
+
+
+一个mp4文件可以包含一个或多个tracks，它们之间相互独立，各自有各自的时间和空间信息。每个track box都有与之关联的media box。trak box 要求必须有一个trak header box(tkhd)和一个media box(mdia)。
+
+- tkhd(track header box)这里面有一个字段，track_ID，用于唯一的表示当前track。另一个字段，duration，用于记录当前track的播放长度。
+- mdia(track media box)包含用于声明当前track信息的所有对象，它定义了track媒体类型以及sample数据，来描述sample信息，一般mdia包含一个mdhd(media header box),一个hdlr(handler reference box)和一个minf(media information box)。
+
+
+#### mdat(media data 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文件，还有可能存在视频文件基本下载完成后才能播放的问题。
+
+
+### 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 码流。
+
+
+
+
+
+
+---
+
+- 邮箱 ：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/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..e2b7e467
--- /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,139 @@
+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格式的特点就是要求从视频流的任一片段开始都是可以独立解码的。
+
+我们可以看出，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交给解码器，获得压缩前的原始音视频数据。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：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..1cb7d9c6
--- /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,65 @@
+# 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信息是复用在一起的。 
+元数据的分离允许我们在streaming中先读取各个流的元数据，知道他们的媒体内容的属性（比如不同的视频质量、不同的语言等），从而可以更好地在不同的media data之间做自适应切换。 
+当然，在更实际的应用场景中，比如在dash协议中会直接把这些元数据信息写在mpd中，player可以只读一个mpd就知道各个媒体数据的属性
+
+### 各个Track独立存储
+
+在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)文件可以更加简洁。   
+针对不同语言的音频，都只需要存一个大文件就够了。 
+相对地，在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作为同步点，这都使得无缝码流切换更简单。 
+
+### 与DRM的集成
+
+所谓DRM即数字版权管理，说白了就是对流进行加密，这东西在国内用的不多，但是在国外可是每一个内容提供商必须要有的东西。和编码标准一样，业界也存在很多DRM方案，为了避免每采用一个新的加密方案就要重新编一个码流，MPEG推出了通用加密（CENC）标准（23001-7 - Common Encryption）。使用这一标准的码流，就可以将一个码流应用于各种不同的DRM方案。在DASH  spec中，也定义了Content Protection字段来对应这种加密方案。 
+
+CENC使用的就是fMP4格式，这是利用了fMP4中音视频可以不复用同时还能提供独立于media data存储的metadata的特点。TS流就享受不了这样的好处了。TODO:介绍TS应用DRM的方法。
+
+
+
+
+
+## 主要说了以下几点:
+
+- .ts文件不提供关于时长等信息，你无法在ts文件里去实现音视频的seek操作
+- .mp4不同于ts，是提供了时长等信息，可以执行seek到指定位置
+- .ts文件一般用于m3u8中, 或者提供了流媒体基础信息的前提下使用
+- .mp4文件可以在不下载完全媒体文件的前提下进行seek操作;因为其头部记录moov信息(moov box 中包含编码、分辨率、码率、帧率、时长、音频采样率等等媒体信息)
+
+
+
+---
+
+- 邮箱 ：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/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..5b7b47c3
--- /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,67 @@
+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 中，它是一个流式的封装格式
+
+
+
+
+
+![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）
+
+    和普通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的相关元信息。
+
+一个‘moof’和一个‘mdat’组成Fragmented MP4文件的一个fragment，这个fragment包含一个video track或audio track，并且包含足够的metadata以保证这部分数据可以单独解码。Fragmented MP4 中的 moov box 只存储文件级别的媒体信息，因此 moov box 的体积比传统的 MP4 中的 moov box 体积要小很多。
+
+
+
+![fmp4_parser](https://raw.githubusercontent.com/CharonChui/Pictures/master/fmp4_parser.png?raw=true)
+
+
+
+### FMP4与普通MP4 BOX的区别
+
+#### 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
+
+moof 主要是用来存放 FMP4 的相关内容。它本身没啥太多的内容。
+
+
+
+---
+
+- 邮箱 ：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..f60f3b09
--- /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,122 @@
+视频封装格式
+===
+
+一个完整的视频文件，包括音频、视频和基础元信息，我们常见的视频文件如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 |
+
+
+## 音频编码格式
+
+#### 音频编码格式有如下:
+
+- AAC : Advanced Audio Coding
+- AMR
+- PCM
+- ogg(ogg vorbis音频)
+- AC3(DVD 专用音频编码)
+- DTS(DVD 专用音频编码)
+- APE(monkey’s 音频)
+- AU(sun 格式)
+- WMA
+- MP3 
+    
+
+## 视频编码格式
+
+视频编码标准有两大系统：
+
+- “国际电联（ITU-T）”，它制定的标准有H.261、H.263、H.263+、H.264等，
+- “国际标准化组织（ISO）”它制定的标准有MPEG-1、MPEG-2、MPEG-4等。
+
+#### 常见编码格式有：
+
+- Xvid(MPEG4)
+
+- H265(High Efficiency Video Coding,简称 HEVC)
+
+- H264 
+
+- H263
+
+- MPEG1，MPEG2
+
+- AC-1
+
+- RM，RMVB
+
+    
+
+目前最常见的视频编码方式的大致性能排序基本是：
+
+ 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
+- FLV
+
+
+
+为什么把flv叫做流式文件格式？ 和mp4，avi不是一样都是音视频的容器吗？ 有什么区别？
+
+通常说的流式文件是可以边传边解的，开始不需要整个文件。特点是有文件头信息（这个不是必需的）和中间打包了，可以直接解析分包，而且文件可以任意大小，而不需要通过索引分包。FLV，MPEG，RMVB等都可以直接依次分包解析，而MP4，AVI一定要依赖索引表才行，而且开始就要固定位置好，如果索引表在尾部，还没办法解析。
+
+流媒体文件是指多媒体文件边下载可以边观看的文件。而传统的视频文件需下载完成才能观看，而流媒体主要是下载一部分文件到缓存区，然后再从缓存区里面拿数据~而能作为这种流媒体文件的只有经过特殊编码的格式才适合，而flv、rmvb、mov、asf等格式文件才属于流媒体格式文件
+
+对于相同的音视频内容，使用三种不同的封装格式，则文件体积从大到小依次为：  TS -> MP4 -> FLV
+
+ FLV和MP4封装格式的文件大小基本相等。
+
+
+
+
+
+参考: 
+
+- [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! 
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"
new file mode 100644
index 00000000..5b7375cd
--- /dev/null
+++ "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"
@@ -0,0 +1,130 @@
+视频播放相关内容总结
+===
+
+多媒体常识：
+---
+
+- 什么是多媒体             
+
+    多媒体是计算机和视频技术的结合，实际上它是两个媒体:声音和图像
+	
+- 常用的视频格式
+
+	`Android`系统默认:`mp4`、`3gp`	           
+	常用格式:`ts、3gpp、3g2、3gpp2、avi、mkv、flv、divx、f4v、rm、rmvb、rv、wmv、asf、mov、mpg、v8、ram、mpeg、
+	swf、m2v、asx、ra、ram、ndivx、xvid`等	 
+			  
+- 常用音频格式：
+
+	`Android`系统:`mp3、ogg`           
+	常用格式:`wma、mid、m4a、xmf、aac、mpa、midi、ar`等
+	
+- 常用图片格式:`PNG、GIF、BMP、jpg`
+
+- 国内各个视频网站采用的解码框架:  
+
+	- 优酷、搜狐、奇艺、`pps`、暴风影音土豆、56网都是用的`ffmpeg`.       
+	- `pptv`已经使用`p2p`技术       
+		点对点技术（`peer-to-peer`， 简称`P2P`）又称对等互联网络技术，是一种网络新技术，依赖网络中参与者的计算能力和带宽，
+		而不是把依赖都聚集在较少的几台服务器上。`P2P`网络通常用于通过`Ad Hoc`连接来连接节点。这类网络可以用于多种用途，
+		各种档案分享软件已经得到了广泛的使用。`P2P`技术也被使用在类似`VoIP`等实时媒体业务的数据通信中。
+                      
+目前常用的开发框架:   
+
+- `VLC`框架:     
+	`VLC`是一个开源项目，基于`ffmpeg`框架的自定义播放器。其中`LibVLC`是`VLC`的核心部分，就相当于`MediaPlayer`类           
+	`VLC`一个最主要的部分，它可以播放各种类型的媒体文件和流媒体文件，并且可以创造媒体流并保存成各种格式的媒体文件      
+	`VLC`是一种跨平台的媒体播放器和流媒体服务器，最初为`videolan`的客户端，它是一种非常简便的多媒体播放器，
+	它可以用来播放各种各样的音视频的格式文件(`MPEG-1、MPEG-2、MPEG- 4、DivX、WMV、mp3、OGG、Vorbis、AC3、AAC`等等)流媒体协议
+	最具特色的功能是可以边下载边观看`Divx`媒体文件，并可以播放不完全的`AVI`文件。并且支持界面的更改。          
+	缺点:有`C/C++`代码，还有`Java`代码，代码太庞大	         
+	
+- `ffmpeg`框架:      
+	优点:轻量级框架，易于维护         
+	`FFmpeg`是一个集录制、转换、音/视频编码解码功能为一体的完整的开源解决方案         
+	`FFmpeg`几乎为你把所有的繁重工作都做了，比如解码、编码、复用和解复用。     
+	这使得多媒体应用程序变得容易编写。它是一个简单的，用`C`编写的，快速的并且能够解码几乎所有你能用到的格式，当然也包括编码多种格式。          
+	`FFmpeg`支持`MPEG、DivX、MPEG4、AC3、DV、FLV`等40多种编码，支持`AVI、MPEG、OGG、Matroska、AS`F等90多种解码          
+	`FFmpeg`主目录下主要有`libavcodec、libavformat`和`libavutil`等子目录。其中`libavcodec`用于存放各个`encode/decode`模块
+	`libavformat`用于存放`muxer/demuxer`模块，`libavutil`用于存放内存操作等辅助性模块
+	
+- `vitamio`框架:      
+	`vitamio`也是基于`ffmpeg`开源框架          
+	`VPlayer`是`vitamio`的一个产品，`vitamio`和`VPlayer`是同一个团队开发的，`VPlayer`能播放的`vitamio`也能播放         
+	
+	
+## `Surface`简介
+
+- `Surface`就是“表面”的意思。在`SDK`的文档中，对`Surface`的描述是这样的：“`Handle onto a raw buffer that is being managed by the screen compositor`”，
+	翻译成中文就是“由屏幕显示内容合成器`(screen compositor)`所管理的原生缓冲器的句柄”，	这句话包括下面两个意思:     
+
+    - 通过`Surface`（因为`Surface`是句柄）就可以获得原生缓冲器以及其中的内容。就像在`C`语言中，可以通过一个文件的句柄，就可以获得文件的内容一样；
+    - 原生缓冲器（`rawbuffer`）是用于保存当前窗口的像素数据的。
+
+- 简单的说`Surface`对应了一块屏幕缓冲区，每个`Window`对应一个`Surface`，任何`View`都是画在`Surface`上的，传统的`view`共享一块屏幕缓冲区，所有的绘制必须在`UI`线程中进行
+- 我们不能直接操作`Surface`实例，要通过`SurfaceHolder`，在`SurfaceView`中可以通过`getHolder()`方法获取到`SurfaceHolder`实例。
+- `Surface`是一个用来画图形的地方，但是我们知道画图都是在一个`Canvas`对象上面进行的，*`Surface`中的`Canvas`成员，是专门用于提供画图的地方，就像黑板一样，其中的原始缓冲区是用来保存数据的地方，
+	`Surface`本身的作用类似一个句柄，得到了这个句柄就可以得到其中的`Canvas`、原始缓冲区以及其他方面的内容，所以简单的说`Surface`是用来管理数据的(句柄)*。
+	
+## `SurfaceView`简介      
+
+- 简单的说`SurfaceView`就是一个有`Surface`的`View`里面内嵌了一个专门用于绘制的`Surface`,`SurfaceView`控制这个`Surface`的格式和尺寸以及绘制位置.`SurfaceView`是一个`View`也许不够严谨，
+	然而从定义中 `public class SurfaceView extends View`显示`SurfaceView`确实是派生自`View`，但是`SurfaceView`却有着自己的`Surface`，源码：
+    ```java
+    if (mWindow == null) {  ß
+		mWindow = new MyWindow(this);  
+		mLayout.type = mWindowType;  
+		mLayout.gravity = Gravity.LEFT|Gravity.TOP;  
+		mSession.addWithoutInputChannel(mWindow, mWindow.mSeq, mLayout,  
+		mVisible ? VISIBLE : GONE, mContentInsets);  
+    }  
+    ```
+    很明显，每个`SurfaceView`创建的时候都会创建一个`MyWindow`，`new MyWindow(this)`中的`this`正是`SurfaceView`自身，因此将`SurfaceView`和`window`绑定在一起，而前面提到过每个`window`对应一个`Surface`，
+	所以`SurfaceView`也就内嵌了一个自己的`Surface`，可以认为`SurfaceView`是来控制`Surface`的位置和尺寸。传统`View`及其派生类的更新只能在`UI`线程，然而`UI`线程还同时处理其他交互逻辑，
+	这就无法保证`view`更新的速度和帧率了，而`SurfaceView`可以用独立的线程来进行绘制，因此可以提供更高的帧率，例如游戏，摄像头取景等场景就比较适合用`SurfaceView`来实现。
+	
+- `Surface`是纵深排序`(Z-ordered)`的，这表明它总在自己所在窗口的后面。
+- `Surfaceview`提供了一个可见区域，只有在这个可见区域内的`Surface`部分内容才可见，可见区域外的部分不可见，所以可以认为**`SurfaceView`就是展示`Surface`中数据的地方**,`Surface`就是管理数据的地方，
+	`SurfaceView`就是展示数据的地方，只有通过`SurfaceView`才能展现`Surface`中的数据。           
+	
+	![image](https://github.com/CharonChui/Pictures/blob/master/SurfaceView.png?raw=true)   
+
+
+- `Surface`的排版显示受到视图层级关系的影响，它的兄弟视图结点会在顶端显示。这意味者`Surface`的内容会被它的兄弟视图遮挡，这一特性可以用来放置遮盖物`(overlays)`(例如，文本和按钮等控件)。
+	注意，如果`Surface`上面有透明控件，那么它的每次变化都会引起框架重新计算它和顶层控件的透明效果，这会影响性能。`surfaceview`变得可见时，`surface`被创建；`surfaceview`隐藏前，`surface`被销毁。
+	这样能节省资源。如果你要查看`surface`被创建和销毁的时机，可以重载`surfaceCreated(SurfaceHolder)`和`surfaceDestroyed(SurfaceHolder)`。
+	**`SurfaceView`的核心在于提供了两个线程：`UI`线程和渲染线程**,两个线程通过“双缓冲”机制来达到高效的界面适时更新。
+
+## `SurfaceHolder`简介
+
+显示一个`Surface`的抽象接口，使你可以控制`Surface`的大小和格式以及在`Surface`上编辑像素，和监视`Surface`的改变。这个接口通常通过`SurfaceView`类实现。
+简单的说就是我们无法直接操作`Surface`只能通过`SurfaceHolder`这个接口来获取和操作`Surface`。
+`SurfaceHolder`中提供了一些`lockCanvas()`:获取一个`Canvas`对象，并锁定之。所得到的`Canvas`对象，其实就是`Surface`中一个成员。加锁的目的其实就是为了在绘制的过程中，
+`Surface`中的数据不会被改变。`lockCanvas`是为了防止同一时刻多个线程对同一`canvas`写入。
+
+
+*从设计模式的角度来看,`Surface、SurfaceView、SurfaceHolder`实质上就是`MVC(Model-View-Controller)`，`Model`就是模型或者说是数据模型，更简单的可以理解成数据，在这里也就是`Surface`，
+`View`就是视图，代表用户交互界面，这里就是`SurfaceView`,`SurfaceHolder`就是`Controller.`*
+
+
+## MediaController
+
+- `MediaController`继承`FrameLayout`，通过`MediaPlayerControl`接口与`VideoView`进行结合控制，内部是通过`PopupWindow`将整个控制栏界面显示到界面上，
+	而该`PopupWindow`所显示在的位置就是通过`setAnchorView()`设置进来的`Anchor`一般可以使当前的`VideoView`或者是整个`Activity`的根布局。这里要分为小屏和全屏两种情况来进行设置。
+	如果当前的`MediaController`只是播放前下面的控制栏部分(进度条、快进、快退、暂停等)这样我们可以通过对VideoView设置点击事件，控制它的显示和隐藏。
+	如果`MediaController`为整个屏幕包括了控制栏部分、上端的信息显示部分、以及左右栏的功能部分、这时候就可以通过对`MediaController`本身设置点击事件来控制显示和隐藏。         
+	
+`Controller`可以用`PopupWindow`来实现,具体有两种方式:     
+
+- 整个控制栏(上面的信息部分、下面的控制部分以及左右边)都在`Controller`中，`setAnchorView()`的时候就会让`Controller`中的`PopupWindow`显示出来(一直显示，但是这个`PopupWindow`是透明的)，
+	真正的显示与隐藏是控制在`PopupWindow`中的`View`部分的显示与隐藏来实现。开始的时候我是想用这种方式，当时我想的是播放就播放、控制就控制，分离开来多好，但是没想到，
+	一旦有`PopupWindow`显示出来后，Activity是接收不到任何`Touch`事件的，所有的重试界面等都要放到`Controller`中实现(手势处理等)。但是也有好处，就是不管显示还是隐藏都可以去处理手势.
+		
+- `PopupWindow`不是全屏的，只包含下面真正的控制部分(快进、快退、暂停等,不包含上面的信息部分和左右边),而且也不是开始就显示，显示隐藏是通过控制`PopupWindow`的显示与隐藏来进行的。
+	而对于信息部分、以及左右边都是在`Activity`的布局当中，我们通过接口回调得到`PopupWindow`的显示与隐藏来控制这些布局的显示与隐藏即可。
+	这样的话我们就需要将手势等全部放到`Activity`中去处理，但是也有一个问题，就是如果`Controller`正在显示的话`Activity`是接收不到`Touch`事件的，就无法处理手势，只能是让`Controller`消失后才能处理手势。
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
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..39fb1ead
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/AV1.md"
@@ -0,0 +1,15 @@
+AV1
+===
+
+
+
+
+
+TODO 
+
+
+
+---
+
+- 邮箱 ：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..66c7f6b6
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H264.md"
@@ -0,0 +1,198 @@
+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  不但有助于节省庞大开支，还可以提高资源的使用效率，同时令达到商业质量的实时视频服务拥有更多的潜在客户。
+
+
+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
+
+
+
+
+
+---
+
+- 邮箱 ：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..418dae10
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H265.md"
@@ -0,0 +1,13 @@
+H265
+===
+
+
+
+TODO 
+
+
+
+---
+
+- 邮箱 ：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/\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..e55d26c6
--- /dev/null
+++ "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/AAC.md"
@@ -0,0 +1,57 @@
+## 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 采用优化的算法达到了更高的解码效率，解码时只需较少的处理能力。
+
+
+
+原始的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 格式的音频流。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AAC_ADIF_ADTS_1.jpg?raw=true)
+
+
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/)
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..a0d2f54b
--- /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,62 @@
+## 音频编码格式
+
+多媒体要想发声，就得加个喇叭，但是喇叭是靠模拟信号驱动的，所以在喇叭之前需要增加一个数字信号转模拟信号的“解码器”，
+将数字信号转换为模拟信号。      
+
+其次还需要增加一个信号放大器，将微弱的电流放大成足以驱动喇叭磁铁产生足够磁力从而震动纸盆的足够强的电流。
+
+原始的PCM音频数据也是非常大的数据量，因此也需要对其进行压缩编码。
+和视频编码一样，音频也有许多的编码格式，如：WAV、MP3、WMA、APE、FLAC等等，音乐发烧友应该对这些格式非常熟悉，特别是后两种无损压缩格式。
+
+音频压缩的本质： 消除冗余数据。
+
+人耳能察觉到的声音信号频率范围为20Hz ~ 20KHz，在这个频率范围以外的音频信号属于冗余信号。
+- 去除人耳听觉频率范围临界附近的值
+- 大声音附近如果有小的声音可以去除
+- 时域屏蔽效应
+- 高声附近50ms内如果声音比较小可以去掉
+- 无损压缩
+
+
+
+### 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码率下表现优异，且多用于视频中的音频编码。
+使用场景：128Kbps码率下的音频编码，多用于视频中音频轨的编码。
+
+### 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的压缩速率是动态的，压缩时只压缩可被压缩的部分，不能被压缩的部分还是会被保留下来。