diff --git a/Java-Interview/.travis.yml b/Java-Interview/.travis.yml
new file mode 100644
index 0000000..9396aad
--- /dev/null
+++ b/Java-Interview/.travis.yml
@@ -0,0 +1,9 @@
+language: java
+
+install: mvn install -DskipTests=true -Dmaven.javadoc.skip=true
+script: mvn -DskipTests=true clean install
+
+
+branches:
+  only:
+    - master
\ No newline at end of file
diff --git a/Java-Interview/LICENSE b/Java-Interview/LICENSE
new file mode 100644
index 0000000..f74ee34
--- /dev/null
+++ b/Java-Interview/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 crossoverJie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Java-Interview/MD/ArrayList.md b/Java-Interview/MD/ArrayList.md
new file mode 100644
index 0000000..8601cd1
--- /dev/null
+++ b/Java-Interview/MD/ArrayList.md
@@ -0,0 +1,151 @@
+# ArrayList/Vector 的底层分析
+
+## ArrayList
+
+`ArrayList` 实现于 `List`、`RandomAccess` 接口。可以插入空数据，也支持随机访问。
+
+`ArrayList `相当于动态数据，其中最重要的两个属性分别是:
+`elementData` 数组，以及 `size` 大小。
+在调用 `add()` 方法的时候：
+```java
+    public boolean add(E e) {
+        ensureCapacityInternal(size + 1);  // Increments modCount!!
+        elementData[size++] = e;
+        return true;
+    }
+```
+
+- 首先进行扩容校验。
+- 将插入的值放到尾部，并将 size + 1 。
+
+如果是调用 `add(index,e)` 在指定位置添加的话：
+```java
+    public void add(int index, E element) {
+        rangeCheckForAdd(index);
+
+        ensureCapacityInternal(size + 1);  // Increments modCount!!
+        //复制，向后移动
+        System.arraycopy(elementData, index, elementData, index + 1,
+                         size - index);
+        elementData[index] = element;
+        size++;
+    }
+```
+
+
+- 也是首先扩容校验。
+- 接着对数据进行复制，目的是把 index 位置空出来放本次插入的数据，并将后面的数据向后移动一个位置。
+
+其实扩容最终调用的代码:
+```java
+    private void grow(int minCapacity) {
+        // overflow-conscious code
+        int oldCapacity = elementData.length;
+        int newCapacity = oldCapacity + (oldCapacity >> 1);
+        if (newCapacity - minCapacity < 0)
+            newCapacity = minCapacity;
+        if (newCapacity - MAX_ARRAY_SIZE > 0)
+            newCapacity = hugeCapacity(minCapacity);
+        // minCapacity is usually close to size, so this is a win:
+        elementData = Arrays.copyOf(elementData, newCapacity);
+    }
+```
+
+也是一个数组复制的过程。
+
+由此可见 `ArrayList` 的主要消耗是数组扩容以及在指定位置添加数据，在日常使用时最好是指定大小，尽量减少扩容。更要减少在指定位置插入数据的操作。
+
+### 序列化
+
+由于 ArrayList 是基于动态数组实现的，所以并不是所有的空间都被使用。因此使用了 `transient` 修饰，可以防止被自动序列化。
+
+```java
+transient Object[] elementData;
+```
+
+因此 ArrayList 自定义了序列化与反序列化：
+
+```java
+    private void writeObject(java.io.ObjectOutputStream s)
+        throws java.io.IOException{
+        // Write out element count, and any hidden stuff
+        int expectedModCount = modCount;
+        s.defaultWriteObject();
+
+        // Write out size as capacity for behavioural compatibility with clone()
+        s.writeInt(size);
+
+        // Write out all elements in the proper order.
+        //只序列化了被使用的数据
+        for (int i=0; i<size; i++) {
+            s.writeObject(elementData[i]);
+        }
+
+        if (modCount != expectedModCount) {
+            throw new ConcurrentModificationException();
+        }
+    }
+
+    private void readObject(java.io.ObjectInputStream s)
+        throws java.io.IOException, ClassNotFoundException {
+        elementData = EMPTY_ELEMENTDATA;
+
+        // Read in size, and any hidden stuff
+        s.defaultReadObject();
+
+        // Read in capacity
+        s.readInt(); // ignored
+
+        if (size > 0) {
+            // be like clone(), allocate array based upon size not capacity
+            ensureCapacityInternal(size);
+
+            Object[] a = elementData;
+            // Read in all elements in the proper order.
+            for (int i=0; i<size; i++) {
+                a[i] = s.readObject();
+            }
+        }
+    }
+```
+
+> 当对象中自定义了 writeObject 和 readObject 方法时，JVM 会调用这两个自定义方法来实现序列化与反序列化。
+
+
+从实现中可以看出 ArrayList 只序列化了被使用的数据。
+
+
+## Vector
+
+`Voctor` 也是实现于 `List` 接口，底层数据结构和 `ArrayList` 类似,也是一个动态数组存放数据。不过是在 `add()` 方法的时候使用 `synchronize` 进行同步写数据，但是开销较大，所以 `Vector` 是一个同步容器并不是一个并发容器。
+
+以下是 `add()` 方法：
+```java
+    public synchronized boolean add(E e) {
+        modCount++;
+        ensureCapacityHelper(elementCount + 1);
+        elementData[elementCount++] = e;
+        return true;
+    }
+```
+
+以及指定位置插入数据:
+```java
+    public void add(int index, E element) {
+        insertElementAt(element, index);
+    }
+    public synchronized void insertElementAt(E obj, int index) {
+        modCount++;
+        if (index > elementCount) {
+            throw new ArrayIndexOutOfBoundsException(index
+                                                     + " > " + elementCount);
+        }
+        ensureCapacityHelper(elementCount + 1);
+        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
+        elementData[index] = obj;
+        elementCount++;
+    }
+```
+
+
+
diff --git a/Java-Interview/MD/Cache-design.md b/Java-Interview/MD/Cache-design.md
new file mode 100644
index 0000000..1dea519
--- /dev/null
+++ b/Java-Interview/MD/Cache-design.md
@@ -0,0 +1,45 @@
+# 分布式缓存设计
+
+目前常见的缓存方案都是分层缓存，通常可以分为以下几层：
+
+- `NG` 本地缓存，命中的话直接返回。
+- `NG` 没有命中时则需要查询分布式缓存，如 `Redis` 。
+- 如果分布式缓存没有命中则需要回源到 `Tomcat` 在本地堆进行查询，命中之后异步写回 `Redis` 。
+- 以上都没有命中那就只有从 `DB` 或者是数据源进行查询，并写回到 Redis 中。
+
+
+## 缓存更新的原子性
+
+在写回 Redis 的时候如果是 `Tomcat` 集群，多个进程同时写那很有可能出现脏数据，这时就会出现更新原子性的问题。
+
+可以有以下解决方案:
+- 可以将多个 Tomcat 中的数据写入到 MQ 队列中，由消费者进行单线程更新缓存。
+- 利用[分布式锁](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Java-lock.md#%E5%9F%BA%E4%BA%8E%E6%95%B0%E6%8D%AE%E5%BA%93)，只有获取到锁进程才能写数据。
+
+## 如何写缓存
+
+写缓存时也要注意，通常来说分为以下几步：
+
+- 开启事物。
+- 写入 DB 。
+- 提交事物。
+- 写入缓存。
+
+这里可能会存在数据库写入成功但是缓存写入失败的情况，但是也不建议将写入缓存加入到事务中。
+因为写缓存的时候可能会因为网络原因耗时较长，这样会阻塞数据库事务。
+如果对一致性要求不高并且数据量也不大的情况下，可以单独起一个服务来做 DB 和缓存之间的数据同步操作。
+
+更新缓存时也建议做增量更新。
+
+## 负载策略
+
+缓存负载策略一般有以下两种：
+- 轮询机制。
+- 一致哈希算法。
+
+轮询的优点是负载到各个服务器的请求是均匀的，但是如果进行扩容则缓存命中率会下降。
+
+一致哈希的优点是相同的请求会负载到同一台服务器上，命中率不会随着扩容而降低，但是当大流量过来时有可能把服务器拖垮。
+
+所以建议两种方案都采用：
+首先采用一致哈希算法，当流量达到一定的阈值的时候则切换为轮询，这样既能保证缓存命中率，也能提高系统的可用性。
\ No newline at end of file
diff --git a/Java-Interview/MD/ClassLoad.md b/Java-Interview/MD/ClassLoad.md
new file mode 100644
index 0000000..e2e7969
--- /dev/null
+++ b/Java-Interview/MD/ClassLoad.md
@@ -0,0 +1,17 @@
+# 类加载机制
+
+## 双亲委派模型
+
+模型如下图：
+
+![](https://ws3.sinaimg.cn/large/006tNc79ly1fmjwua3iv4j30ic0f0mxq.jpg)
+
+双亲委派模型中除了启动类加载器之外其余都需要有自己的父类加载器
+
+当一个类收到了类加载请求时: 自己不会首先加载，而是委派给父加载器进行加载，每个层次的加载器都是这样。
+
+所以最终每个加载请求都会经过启动类加载器。只有当父类加载返回不能加载时子加载器才会进行加载。
+
+双亲委派的好处 : 由于每个类加载都会经过最顶层的启动类加载器，比如 `java.lang.Object`这样的类在各个类加载器下都是同一个类(只有当两个类是由同一个类加载器加载的才有意义，这两个类才相等。)
+
+如果没有双亲委派模型，由各个类加载器自行加载的话。当用户自己编写了一个 `java.lang.Object`类，那样系统中就会出现多个 `Object`，这样 Java 程序中最基本的行为都无法保证，程序会变的非常混乱。
\ No newline at end of file
diff --git a/Java-Interview/MD/ConcurrentHashMap.md b/Java-Interview/MD/ConcurrentHashMap.md
new file mode 100644
index 0000000..773ac14
--- /dev/null
+++ b/Java-Interview/MD/ConcurrentHashMap.md
@@ -0,0 +1,96 @@
+**更多 HashMap 与 ConcurrentHashMap 相关请查看[这里](https://crossoverjie.top/2018/07/23/java-senior/ConcurrentHashMap/)。**
+
+# ConcurrentHashMap 实现原理
+
+由于 `HashMap` 是一个线程不安全的容器，主要体现在容量大于`总量*负载因子`发生扩容时会出现环形链表从而导致死循环。
+
+因此需要支持线程安全的并发容器 `ConcurrentHashMap` 。
+
+## JDK1.7 实现
+
+### 数据结构
+![](https://ws2.sinaimg.cn/large/006tNc79ly1fn2f5pgxinj30dw0730t7.jpg)
+
+如图所示，是由 `Segment` 数组、`HashEntry` 数组组成，和 `HashMap` 一样，仍然是数组加链表组成。
+
+`ConcurrentHashMap` 采用了分段锁技术，其中 `Segment` 继承于 `ReentrantLock`。不会像 `HashTable` 那样不管是 `put` 还是 `get` 操作都需要做同步处理，理论上 ConcurrentHashMap 支持 `CurrencyLevel` (Segment 数组数量)的线程并发。每当一个线程占用锁访问一个 `Segment` 时，不会影响到其他的 `Segment`。
+
+### get 方法
+`ConcurrentHashMap` 的 `get` 方法是非常高效的，因为整个过程都不需要加锁。
+
+只需要将 `Key` 通过 `Hash` 之后定位到具体的 `Segment` ，再通过一次 `Hash` 定位到具体的元素上。由于 `HashEntry` 中的 `value` 属性是用 `volatile` 关键词修饰的，保证了内存可见性，所以每次获取时都是最新值([volatile 相关知识点](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Threadcore.md#%E5%8F%AF%E8%A7%81%E6%80%A7))。
+
+### put 方法
+
+内部 `HashEntry` 类 ：
+
+```java
+    static final class HashEntry<K,V> {
+        final int hash;
+        final K key;
+        volatile V value;
+        volatile HashEntry<K,V> next;
+
+        HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
+            this.hash = hash;
+            this.key = key;
+            this.value = value;
+            this.next = next;
+        }
+    }
+```
+
+虽然 HashEntry 中的 value 是用 `volatile` 关键词修饰的，但是并不能保证并发的原子性，所以 put 操作时仍然需要加锁处理。
+
+首先也是通过 Key 的 Hash 定位到具体的 Segment，在 put 之前会进行一次扩容校验。这里比 HashMap 要好的一点是：HashMap 是插入元素之后再看是否需要扩容，有可能扩容之后后续就没有插入就浪费了本次扩容(扩容非常消耗性能)。
+
+而 ConcurrentHashMap 不一样，它是先将数据插入之后再检查是否需要扩容，之后再做插入。
+
+### size 方法
+
+每个 `Segment` 都有一个 `volatile` 修饰的全局变量 `count` ,求整个 `ConcurrentHashMap` 的 `size` 时很明显就是将所有的 `count` 累加即可。但是 `volatile` 修饰的变量却不能保证多线程的原子性，所有直接累加很容易出现并发问题。
+
+但如果每次调用 `size` 方法将其余的修改操作加锁效率也很低。所以做法是先尝试两次将 `count` 累加，如果容器的 `count` 发生了变化再加锁来统计 `size`。
+
+至于 `ConcurrentHashMap` 是如何知道在统计时大小发生了变化呢，每个 `Segment` 都有一个 `modCount` 变量，每当进行一次 `put remove` 等操作，`modCount` 将会 +1。只要 `modCount` 发生了变化就认为容器的大小也在发生变化。
+
+
+
+## JDK1.8 实现
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fthpv4odbsj30lp0drmxr.jpg)
+
+1.8 中的 ConcurrentHashMap 数据结构和实现与 1.7 还是有着明显的差异。
+
+其中抛弃了原有的 Segment 分段锁，而采用了 `CAS + synchronized` 来保证并发安全性。
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fthq78e5gqj30nr09mmz9.jpg)
+
+也将 1.7 中存放数据的 HashEntry 改为 Node，但作用都是相同的。
+
+其中的 `val next` 都用了 volatile 修饰，保证了可见性。
+
+### put 方法
+
+重点来看看 put 函数：
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fthrz8jlo8j30oc0rbte3.jpg)
+
+- 根据 key 计算出 hashcode 。
+- 判断是否需要进行初始化。
+- `f` 即为当前 key 定位出的 Node，如果为空表示当前位置可以写入数据，利用 CAS 尝试写入，失败则自旋保证成功。
+- 如果当前位置的 `hashcode == MOVED == -1`,则需要进行扩容。
+- 如果都不满足，则利用 synchronized 锁写入数据。
+- 如果数量大于 `TREEIFY_THRESHOLD` 则要转换为红黑树。
+
+### get 方法
+
+![](https://ws1.sinaimg.cn/large/006tNc79gy1fthsnp2f35j30o409hwg7.jpg)
+
+- 根据计算出来的 hashcode 寻址，如果就在桶上那么直接返回值。
+- 如果是红黑树那就按照树的方式获取值。
+- 就不满足那就按照链表的方式遍历获取值。
+
+## 总结
+
+1.8 在 1.7 的数据结构上做了大的改动，采用红黑树之后可以保证查询效率（`O(logn)`），甚至取消了 ReentrantLock 改为了 synchronized，这样可以看出在新版的 JDK 中对 synchronized 优化是很到位的。
diff --git a/Java-Interview/MD/Consistent-Hash.md b/Java-Interview/MD/Consistent-Hash.md
new file mode 100644
index 0000000..4c778cf
--- /dev/null
+++ b/Java-Interview/MD/Consistent-Hash.md
@@ -0,0 +1,62 @@
+# 一致 Hash 算法
+
+当我们在做数据库分库分表或者是分布式缓存时，不可避免的都会遇到一个问题:
+
+如何将数据均匀的分散到各个节点中，并且尽量的在加减节点时能使受影响的数据最少。
+
+## Hash 取模
+随机放置就不说了，会带来很多问题。通常最容易想到的方案就是 `hash 取模`了。
+
+可以将传入的 Key 按照 `index = hash(key) % N` 这样来计算出需要存放的节点。其中 hash 函数是一个将字符串转换为正整数的哈希映射方法，N 就是节点的数量。
+
+这样可以满足数据的均匀分配，但是这个算法的容错性和扩展性都较差。
+
+比如增加或删除了一个节点时，所有的 Key 都需要重新计算，显然这样成本较高，为此需要一个算法满足分布均匀同时也要有良好的容错性和拓展性。
+
+## 一致 Hash 算法
+
+一致 Hash 算法是将所有的哈希值构成了一个环，其范围在 `0 ~ 2^32-1`。如下图：
+
+![](https://ws1.sinaimg.cn/large/006tNc79gy1fn8kbmd4ncj30ad08y3yn.jpg)
+
+之后将各个节点散列到这个环上，可以用节点的 IP、hostname 这样的唯一性字段作为 Key 进行 `hash(key)`，散列之后如下：
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fn8kf72uwuj30a40a70t5.jpg)
+
+之后需要将数据定位到对应的节点上，使用同样的 `hash 函数` 将 Key 也映射到这个环上。
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fn8kj9kd4oj30ax0aomxq.jpg)
+
+这样按照顺时针方向就可以把 k1 定位到 `N1节点`，k2 定位到 `N3节点`，k3 定位到 `N2节点`。
+
+### 容错性
+这时假设 N1 宕机了：
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fn8kl9pp06j30a409waaj.jpg)
+
+依然根据顺时针方向，k2 和 k3 保持不变，只有 k1 被重新映射到了 N3。这样就很好的保证了容错性，当一个节点宕机时只会影响到少少部分的数据。
+
+### 拓展性
+
+当新增一个节点时:
+
+![](https://ws1.sinaimg.cn/large/006tNc79gy1fn8kp1fc9xj30ca0abt9c.jpg)
+
+在 N2 和 N3 之间新增了一个节点 N4 ，这时会发现受印象的数据只有 k3，其余数据也是保持不变，所以这样也很好的保证了拓展性。
+
+## 虚拟节点
+到目前为止该算法依然也有点问题:
+
+当节点较少时会出现数据分布不均匀的情况：
+
+![](https://ws2.sinaimg.cn/large/006tNc79gy1fn8krttekbj30c10a5dg5.jpg)
+
+这样会导致大部分数据都在 N1 节点，只有少量的数据在 N2 节点。
+
+为了解决这个问题，一致哈希算法引入了虚拟节点。将每一个节点都进行多次 hash，生成多个节点放置在环上称为虚拟节点:
+
+![](https://ws2.sinaimg.cn/large/006tNc79gy1fn8ktzuswkj30ae0abdgb.jpg)
+
+计算时可以在 IP 后加上编号来生成哈希值。
+
+这样只需要在原有的基础上多一步由虚拟节点映射到实际节点的步骤即可让少量节点也能满足均匀性。
\ No newline at end of file
diff --git a/Java-Interview/MD/DB-split.md b/Java-Interview/MD/DB-split.md
new file mode 100644
index 0000000..038cc7e
--- /dev/null
+++ b/Java-Interview/MD/DB-split.md
@@ -0,0 +1,35 @@
+# 数据库水平垂直拆分
+
+当数据库量非常大的时候，DB 已经成为系统瓶颈时就可以考虑进行水平垂直拆分了。
+
+## 水平拆分
+
+一般水平拆分是根据表中的某一字段(通常是主键 ID )取模处理，将一张表的数据拆分到多个表中。这样每张表的表结构是相同的但是数据不同。
+
+不但可以通过 ID 取模分表还可以通过时间分表，比如每月生成一张表。
+按照范围分表也是可行的:一张表只存储 `0~1000W`的数据，超过只就进行分表，这样分表的优点是扩展灵活，但是存在热点数据。
+
+按照取模分表拆分之后我们的查询、修改、删除也都是取模。比如新增一条数据的时候往往需要一张临时表来生成 ID,然后根据生成的 ID 取模计算出需要写入的是哪张表(也可以使用[分布式 ID 生成器](https://github.com/crossoverJie/Java-Interview/blob/master/MD/ID-generator.md)来生成 ID)。
+
+分表之后不能避免的就是查询要比以前复杂，通常不建议 `join` ，一般的做法是做两次查询。
+
+## 垂直拆分
+
+当一张表的字段过多时则可以考虑垂直拆分。
+通常是将一张表的字段才分为主表以及扩展表，使用频次较高的字段在一张表，其余的在一张表。
+
+这里的多表查询也不建议使用 `join` ，依然建议使用两次查询。
+
+## 拆分之后带来的问题
+
+拆分之后由一张表变为了多张表，一个库变为了多个库。最突出的一个问题就是事务如何保证。
+
+### 两段提交
+
+### 最终一致性
+
+如果业务对强一致性要求不是那么高那么最终一致性则是一种比较好的方案。
+
+通常的做法就是补偿，比如 一个业务是 A 调用 B，两个执行成功才算最终成功，当 A 成功之后，B 执行失败如何来通知 A 呢。
+
+比较常见的做法是 失败时 B 通过 MQ 将消息告诉 A，A 再来进行回滚。这种的前提是 A 的回滚操作得是幂等的，不然 B 重复发消息就会出现问题。
\ No newline at end of file
diff --git a/Java-Interview/MD/GarbageCollection.md b/Java-Interview/MD/GarbageCollection.md
new file mode 100644
index 0000000..a233f8a
--- /dev/null
+++ b/Java-Interview/MD/GarbageCollection.md
@@ -0,0 +1,72 @@
+# 垃圾回收
+
+> 垃圾回收主要思考三件事情:
+
+- 哪种内存需要回收？
+- 什么时候回收？
+- 怎么回收？
+
+## 对象是否存活
+
+### 引用计数法
+
+这是一种非常简单易理解的回收算法。每当有一个地方引用一个对象的时候则在引用计数器上 +1，当失效的时候就 -1，无论什么时候计数器为 0 的时候则认为该对象死亡可以回收了。
+
+这种算法虽然简单高效，但是却无法解决**循环引用**的问题，因此 Java 虚拟机并没有采用这种算法。
+
+### 可达性分析算法
+主流的语言其实都是采用可达性分析算法:
+
+可达性算法是通过一个称为 `GC Roots` 的对象向下搜索，整个搜索路径就称为引用链，当一个对象到 `GC Roots` 没有任何引用链 `JVM` 就认为该对象是可以被回收的。
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fmwqi5mv1jj30e407kmxm.jpg)
+
+如图:Object1、2、3、4 都是存活的对象，而 Object5、6、7都是可回收对象。
+
+可以用作 `GC-Roots` 的对象有:
+
+- 方法区中静态变量所引用的对象。
+- 虚拟机栈中所引用的对象。
+
+## 垃圾回收算法
+
+### 标记-清除算法
+
+标记清除算法分为两个步骤，标记和清除。
+首先将需要回收的对象标记起来，然后统一清除。但是存在两个主要的问题:
+- 标记和清除的效率都不高。
+- 清除之后容易出现不连续内存，当需要分配一个较大内存时就不得不需要进行一次垃圾回收。
+
+标记清除过程如下:
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fmz99ai1n3j30fj08qdgc.jpg)
+
+### 复制算法
+
+复制算法是将内存划分为两块大小相等的区域，每次使用时都只用其中一块区域，当发生垃圾回收时会将存活的对象全部复制到未使用的区域，然后对之前的区域进行全部回收。
+
+这样简单高效，而且还不存在标记清除算法中的内存碎片问题，但就是有点浪费内存。
+
+> 在新生代会使用该算法。
+
+新生代中分为一个 `Eden` 区和两个 `Survivor` 区。通常两个区域的比例是 `8:1:1` ，使用时会用到 `Eden` 区和其中一个 `Survivor` 区。当发生回收时则会将还存活的对象从 `Eden` ，`Survivor` 区拷贝到另一个 `Survivor` 区，当该区域内存也不足时则会使用分配担保利用老年代来存放内存。
+
+复制算法过程：
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fmzavlf4enj30fj08qt9b.jpg)
+
+
+### 标记整理算法
+
+复制算法如果在存活对象较多时效率明显会降低，特别是在老年代中并没有多余的内存区域可以提供内存担保。
+
+所以老年代中使用的时候`分配整理算法`，它的原理和`分配清除算法`类似，只是最后一步的清除改为了将存活对象全部移动到一端，然后再将边界之外的内存全部回收。
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fmzbq55pfdj30fe08s3yx.jpg)
+
+### 分代回收算法
+现代多数的商用 `JVM` 的垃圾收集器都是采用的分代回收算法，和之前所提到的算法并没有新的内容。
+
+只是将 Java 堆分为了新生代和老年代。由于新生代中存活对象较少，所以采用**复制算法**，简单高效。
+
+而老年代中对象较多，并且没有可以担保的内存区域，所以一般采用**标记清除或者是标记整理算法**。
diff --git a/Java-Interview/MD/HashMap.md b/Java-Interview/MD/HashMap.md
new file mode 100644
index 0000000..e6cbd7c
--- /dev/null
+++ b/Java-Interview/MD/HashMap.md
@@ -0,0 +1,77 @@
+**更多 HashMap 与 ConcurrentHashMap 相关请查看[这里](https://crossoverjie.top/2018/07/23/java-senior/ConcurrentHashMap/)。**
+
+# HashMap 底层分析
+
+> 以下基于 JDK1.7 分析。
+
+![](https://ws2.sinaimg.cn/large/006tNc79gy1fn84b0ftj4j30eb0560sv.jpg)
+
+如图所示，HashMap 底层是基于数组和链表实现的。其中有两个重要的参数：
+
+- 容量
+- 负载因子
+
+容量的默认大小是 16，负载因子是 0.75，当 `HashMap` 的 `size > 16*0.75` 时就会发生扩容(容量和负载因子都可以自由调整)。
+
+## put 方法
+首先会将传入的 Key 做 `hash` 运算计算出 hashcode,然后根据数组长度取模计算出在数组中的 index 下标。
+
+由于在计算中位运算比取模运算效率高的多，所以 HashMap 规定数组的长度为 `2^n` 。这样用 `2^n - 1` 做位运算与取模效果一致，并且效率还要高出许多。
+
+由于数组的长度有限，所以难免会出现不同的 Key 通过运算得到的 index 相同，这种情况可以利用链表来解决，HashMap 会在 `table[index]`处形成链表，采用头插法将数据插入到链表中。
+
+## get 方法
+
+get 和 put 类似，也是将传入的 Key 计算出 index ，如果该位置上是一个链表就需要遍历整个链表，通过 `key.equals(k)` 来找到对应的元素。
+
+## 遍历方式
+
+
+```java
+ Iterator<Map.Entry<String, Integer>> entryIterator = map.entrySet().iterator();
+        while (entryIterator.hasNext()) {
+            Map.Entry<String, Integer> next = entryIterator.next();
+            System.out.println("key=" + next.getKey() + " value=" + next.getValue());
+        }
+```
+
+```java
+Iterator<String> iterator = map.keySet().iterator();
+        while (iterator.hasNext()){
+            String key = iterator.next();
+            System.out.println("key=" + key + " value=" + map.get(key));
+
+        }
+```
+
+```java
+map.forEach((key,value)->{
+    System.out.println("key=" + key + " value=" + value);
+});
+```
+
+**强烈建议**使用第一种 EntrySet 进行遍历。
+
+第一种可以把 key value 同时取出，第二种还得需要通过 key 取一次 value，效率较低, 第三种需要 `JDK1.8` 以上，通过外层遍历 table，内层遍历链表或红黑树。 
+
+
+## notice
+
+在并发环境下使用 `HashMap` 容易出现死循环。
+
+并发场景发生扩容，调用 `resize()` 方法里的 `rehash()` 时，容易出现环形链表。这样当获取一个不存在的 `key` 时，计算出的 `index` 正好是环形链表的下标时就会出现死循环。
+
+![](https://ws2.sinaimg.cn/large/006tNc79gy1fn85u0a0d9j30n20ii0tp.jpg)
+
+> 所以 HashMap 只能在单线程中使用，并且尽量的预设容量，尽可能的减少扩容。
+
+在 `JDK1.8` 中对 `HashMap` 进行了优化：
+当 `hash` 碰撞之后写入链表的长度超过了阈值(默认为8)，链表将会转换为**红黑树**。
+
+假设 `hash` 冲突非常严重，一个数组后面接了很长的链表，此时重新的时间复杂度就是 `O(n)` 。
+
+如果是红黑树，时间复杂度就是 `O(logn)` 。
+
+大大提高了查询效率。
+
+多线程场景下推荐使用 [ConcurrentHashMap](https://github.com/crossoverJie/Java-Interview/blob/master/MD/ConcurrentHashMap.md)。
diff --git a/Java-Interview/MD/ID-generator.md b/Java-Interview/MD/ID-generator.md
new file mode 100644
index 0000000..04a71d9
--- /dev/null
+++ b/Java-Interview/MD/ID-generator.md
@@ -0,0 +1,39 @@
+# 分布式 ID 生成器
+
+一个唯一 ID 在一个分布式系统中是非常重要的一个业务属性，其中包括一些如订单 ID，消息 ID ，会话 ID，他们都有一些共有的特性：
+
+- 全局唯一。
+- 趋势递增。
+
+全局唯一很好理解，目的就是唯一标识某个次请求，某个业务。
+
+通常有以下几种方案：
+
+## 基于数据库
+可以利用 `MySQL` 中的自增属性 `auto_increment` 来生成全局唯一 ID，也能保证趋势递增。
+但这种方式太依赖 DB，如果数据库挂了那就非常容易出问题。
+
+### 水平扩展改进
+但也有改进空间，可以将数据库水平拆分，如果拆为了两个库 A 库和 B 库。
+A 库的递增方式可以是 `0 ,2 ,4 ,6`。B 库则是 `1 ,3 ,5 ,7`。这样的方式可以提高系统可用性，并且 ID 也是趋势递增的。
+
+但也有如下一下问题：
+
+- 想要扩容增加性能变的困难，之前已经定义好了 A B 库递增的步数，新加的数据库不好加入进来，水平扩展困难。
+- 也是强依赖与数据库，并且如果其中一台挂掉了那就不是绝对递增了。
+
+## 本地 UUID 生成
+还可以采用 `UUID` 的方式生成唯一 ID，由于是在本地生成没有了网络之类的消耗，所有效率非常高。
+
+但也有以下几个问题：
+- 生成的 ID 是无序性的，不能做到趋势递增。
+- 由于是字符串并且不是递增，所以不太适合用作主键。
+
+## 采用本地时间
+这种做法非常简单，可以利用本地的毫秒数加上一些业务 ID 来生成唯一ID，这样可以做到趋势递增，并且是在本地生成效率也很高。
+
+但有一个致命的缺点:当并发量足够高的时候**唯一性**就不能保证了。
+
+## Twitter 雪花算法
+
+可以基于 `Twitter` 的 `Snowflake` 算法来实现。它主要是一种划分命名空间的算法，将生成的 ID 按照机器、时间等来进行标志。
\ No newline at end of file
diff --git a/Java-Interview/MD/Java-lock.md b/Java-Interview/MD/Java-lock.md
new file mode 100644
index 0000000..b9132ac
--- /dev/null
+++ b/Java-Interview/MD/Java-lock.md
@@ -0,0 +1,39 @@
+# 对锁的一些认知 有哪些锁
+
+## 同一进程
+
+### [重入锁](https://github.com/crossoverJie/Java-Interview/blob/master/MD/ReentrantLock.md)
+使用 `ReentrantLock` 获取锁的时候会会判断当前线程是否为获取锁的线程，如果是则将同步的状态 +1 ,释放锁的时候则将状态 -1。只有将同步状态的次数置为 0 的时候才会最终释放锁。
+
+### 读写锁
+使用 `ReentrantReadWriteLock` ,同时维护一对锁：读锁和写锁。当写线程访问时则其他所有锁都将阻塞，读线程访问时则不会。通过读写锁的分离可以很大程度的提高并发量和吞吐量。
+
+
+## 不同进程
+
+分布式锁：
+
+### 基于数据库
+可以创建一张表，将其中的某个字段设置为`唯一索引`，当多个请求过来的时候只有新建记录成功的请求才算获取到锁，当使用完毕删除这条记录的时候即释放锁。
+
+存在的问题:
+- 数据库单点问题，挂了怎么办？
+- 不是重入锁，同一进程无法在释放锁之前再次获得锁，因为数据库中已经存在了一条记录了。
+- 锁是非阻塞的，一旦 `insert` 失败则会立即返回，并不会进入阻塞队列只能下一次再次获取。
+- 锁没有失效时间，如果那个进程解锁失败那就没有请求可以再次获取锁了。
+
+解决方案:
+- 数据库切换为主从，不存在单点。
+- 在表中加入一个同步状态字段，每次获取锁的是加 1 ，释放锁的时候`-1`，当状态为 0 的时候就删除这条记录，即释放锁。
+- 非阻塞的情况可以用 `while` 循环来实现，循环的时候记录时间，达到 X 秒记为超时，`break`。
+- 可以开启一个定时任务每隔一段时间扫描找出多少 X 秒都没有被删除的记录，主动删除这条记录。
+
+### 基于 Redis
+
+使用 `setNX(key) setEX(timeout)` 命令，只有在该 `key` 不存在的时候创建和这个 `key`，就相当于获取了锁。由于有超时时间，所以过了规定时间会自动删除，这样也可以避免死锁。
+
+可以参考：
+
+[基于 Redis 的分布式锁](http://crossoverjie.top/2018/03/29/distributed-lock/distributed-lock-redis/)
+
+### 基于 ZK
diff --git a/Java-Interview/MD/Limiting.md b/Java-Interview/MD/Limiting.md
new file mode 100644
index 0000000..2b76019
--- /dev/null
+++ b/Java-Interview/MD/Limiting.md
@@ -0,0 +1,58 @@
+# 限流算法
+
+限流是解决高并发大流量的一种方案，至少是可以保证应用的可用性。
+
+通常有以下两种限流方案：
+
+- 漏桶算法
+- 令牌桶算法
+
+## 漏桶算法
+
+![漏桶算法，来自网络.png](https://i.loli.net/2017/08/11/598c905caa8cb.png)
+
+漏桶算法非常简单，就是将流量放入桶中并按照一定的速率流出。如果流量过大时候并不会提高流出效率，而溢出的流量也只能是抛弃掉了。
+
+这种算法很简单，但也非常粗暴，无法应对突发的大流量。
+这时可以考虑令牌桶算法。
+
+## 令牌桶算法
+![令牌桶算法-来自网络.gif](https://i.loli.net/2017/08/11/598c91f2a33af.gif)
+
+令牌桶算法是按照恒定的速率向桶中放入令牌，每当请求经过时则消耗一个或多个令牌。当桶中的令牌为 0 时，请求则会被阻塞。
+
+> note：
+令牌桶算法支持先消费后付款，比如一个请求可以获取多个甚至全部的令牌，但是需要后面的请求付费。也就是说后面的请求需要等到桶中的令牌补齐之后才能继续获取。
+
+实例:
+```java
+    @Override
+    public BaseResponse<UserResVO> getUserByFeignBatch(@RequestBody UserReqVO userReqVO) {
+        //调用远程服务
+        OrderNoReqVO vo = new OrderNoReqVO() ;
+        vo.setReqNo(userReqVO.getReqNo());
+
+        RateLimiter limiter = RateLimiter.create(2.0) ;
+        //批量调用
+        for (int i = 0 ;i< 10 ; i++){
+            double acquire = limiter.acquire();
+            logger.debug("获取令牌成功!,消耗=" + acquire);
+            BaseResponse<OrderNoResVO> orderNo = orderServiceClient.getOrderNo(vo);
+            logger.debug("远程返回:"+JSON.toJSONString(orderNo));
+        }
+
+        UserRes userRes = new UserRes() ;
+        userRes.setUserId(123);
+        userRes.setUserName("张三");
+
+        userRes.setReqNo(userReqVO.getReqNo());
+        userRes.setCode(StatusEnum.SUCCESS.getCode());
+        userRes.setMessage("成功");
+
+        return userRes ;
+    }
+```
+
+
+1. [单 JVM 限流](http://crossoverjie.top/2017/08/11/sbc4/)
+2. [分布式限流](http://crossoverjie.top/2018/04/28/sbc/sbc7-Distributed-Limit/)
diff --git a/Java-Interview/MD/LinkedList.md b/Java-Interview/MD/LinkedList.md
new file mode 100644
index 0000000..1e0a4f6
--- /dev/null
+++ b/Java-Interview/MD/LinkedList.md
@@ -0,0 +1,67 @@
+# LinkedList 底层分析
+
+![](https://ws4.sinaimg.cn/large/006tKfTcly1fqzb66c00gj30p7056q38.jpg)
+
+如图所示 `LinkedList` 底层是基于双向链表实现的，也是实现了 `List` 接口，所以也拥有 List 的一些特点(JDK1.7/8 之后取消了循环，修改为双向链表)。
+
+## 新增方法
+
+```java
+    public boolean add(E e) {
+        linkLast(e);
+        return true;
+    }
+     /**
+     * Links e as last element.
+     */
+    void linkLast(E e) {
+        final Node<E> l = last;
+        final Node<E> newNode = new Node<>(l, e, null);
+        last = newNode;
+        if (l == null)
+            first = newNode;
+        else
+            l.next = newNode;
+        size++;
+        modCount++;
+    }
+```
+
+可见每次插入都是移动指针，和 ArrayList 的拷贝数组来说效率要高上不少。
+
+## 查询方法
+
+```java
+    public E get(int index) {
+        checkElementIndex(index);
+        return node(index).item;
+    }
+    
+    Node<E> node(int index) {
+        // assert isElementIndex(index);
+
+        if (index < (size >> 1)) {
+            Node<E> x = first;
+            for (int i = 0; i < index; i++)
+                x = x.next;
+            return x;
+        } else {
+            Node<E> x = last;
+            for (int i = size - 1; i > index; i--)
+                x = x.prev;
+            return x;
+        }
+    }
+```
+
+由此可以看出是使用二分查找来看 `index` 离 size 中间距离来判断是从头结点正序查还是从尾节点倒序查。
+
+- `node()`会以`O(n/2)`的性能去获取一个结点
+    - 如果索引值大于链表大小的一半，那么将从尾结点开始遍历
+
+这样的效率是非常低的，特别是当 index 越接近 size 的中间值时。
+
+总结：
+
+- LinkedList 插入，删除都是移动指针效率很高。
+- 查找需要进行遍历查询，效率较低。
diff --git a/Java-Interview/MD/MemoryAllocation.md b/Java-Interview/MD/MemoryAllocation.md
new file mode 100644
index 0000000..3b50803
--- /dev/null
+++ b/Java-Interview/MD/MemoryAllocation.md
@@ -0,0 +1,38 @@
+# Java 运行时的内存划分
+
+![](https://ws1.sinaimg.cn/large/006tNc79ly1fmk5v19cmvj30g20anq3y.jpg)
+
+## 程序计数器
+
+记录当前线程所执行的字节码行号，用于获取下一条执行的字节码。
+
+当多线程运行时，每个线程切换后需要知道上一次所运行的状态、位置。由此也可以看出程序计数器是每个线程**私有**的。
+
+
+## 虚拟机栈
+虚拟机栈由一个一个的栈帧组成，栈帧是在每一个方法调用时产生的。
+
+每一个栈帧由`局部变量区`、`操作数栈`等组成。每创建一个栈帧压栈，当一个方法执行完毕之后则出栈。
+
+> - 如果出现方法递归调用出现死循环的话就会造成栈帧过多，最终会抛出 `StackOverflowError`。
+> - 若线程执行过程中栈帧大小超出虚拟机栈限制，则会抛出 `StackOverFlowError`。
+> - 若虚拟机栈允许动态扩展，但在尝试扩展时内存不足，或者在为一个新线程初始化新的虚拟机栈时申请不到足够的内存，则会抛出
+ `OutOfMemoryError`。
+ 
+**这块内存区域也是线程私有的。**
+
+## Java 堆
+`Java` 堆是整个虚拟机所管理的最大内存区域，所有的对象创建都是在这个区域进行内存分配。
+
+这块区域也是垃圾回收器重点管理的区域，由于大多数垃圾回收器都采用`分代回收算法`，所有堆内存也分为 `新生代`、`老年代`，可以方便垃圾的准确回收。
+
+**这块内存属于线程共享区域。**
+
+## 方法区
+
+方法区主要用于存放已经被虚拟机加载的类信息，如`常量，静态变量`。
+这块区域也被称为`永久代`。
+
+### 运行时常量池
+
+运行时常量池是方法区的一部分，其中存放了一些符号引用。当 new 一个对象时，会检查这个区域是否有这个符号的引用。
diff --git a/Java-Interview/MD/MySQL-Index.md b/Java-Interview/MD/MySQL-Index.md
new file mode 100644
index 0000000..fad0342
--- /dev/null
+++ b/Java-Interview/MD/MySQL-Index.md
@@ -0,0 +1,26 @@
+# MySQL 索引原理
+
+现在互联网应用中对数据库的使用多数都是读较多，比例可以达到 `10:1`。并且数据库在做查询时 `IO` 消耗较大，所以如果能把一次查询的 `IO` 次数控制在常量级那对数据库的性能提升将是非常明显的，因此基于 `B+ Tree` 的索引结构出现了。
+
+
+## B+ Tree 的数据结构
+
+![](https://ws2.sinaimg.cn/large/006tKfTcgy1fn10d6j9sij30hc08cab3.jpg)
+
+如图所示是 `B+ Tree` 的数据结构。是由一个一个的磁盘块组成的树形结构，每个磁盘块由数据项和指针组成。
+
+> 所有的数据都是存放在叶子节点，非叶子节点不存放数据。
+
+## 查找过程
+
+以磁盘块1为例，指针 P1 表示小于17的磁盘块，P2 表示在 `17~35` 之间的磁盘块，P3 则表示大于35的磁盘块。
+
+比如要查找数据项99，首先将磁盘块1 load 到内存中，发生 1 次 `IO`。接着通过二分查找发现 99 大于 35，所以找到了 P3 指针。通过P3 指针发生第二次 IO 将磁盘块4加载到内存。再通过二分查找发现大于87，通过 P3 指针发生了第三次 IO 将磁盘块11 加载到内存。最后再通过一次二分查找找到了数据项99。
+
+由此可见，如果一个几百万的数据查询只需要进行三次 IO 即可找到数据，那么整个效率将是非常高的。
+
+观察树的结构，发现查询需要经历几次 IO 是由树的高度来决定的，而树的高度又由磁盘块，数据项的大小决定的。
+
+磁盘块越大，数据项越小那么数的高度就越低。这也就是为什么索引字段要尽可能小的原因。
+
+> 索引使用的一些[原则](https://github.com/crossoverJie/Java-Interview/blob/master/MD/SQL-optimization.md)。
diff --git a/Java-Interview/MD/OOM-analysis.md b/Java-Interview/MD/OOM-analysis.md
new file mode 100644
index 0000000..0ecd407
--- /dev/null
+++ b/Java-Interview/MD/OOM-analysis.md
@@ -0,0 +1,90 @@
+# OOM 分析
+
+## Java 堆内存溢出
+
+在 Java 堆中只要不断的创建对象，并且 `GC-Roots` 到对象之间存在引用链，这样 `JVM` 就不会回收对象。
+
+只要将`-Xms(最小堆)`,`-Xmx(最大堆)` 设置为一样禁止自动扩展堆内存。
+
+
+当使用一个 `while(true)` 循环来不断创建对象就会发生 `OutOfMemory`，还可以使用 `-XX:+HeapDumpOutofMemoryErorr` 当发生 OOM 时会自动 dump 堆栈到文件中。
+
+伪代码:
+
+```java
+    public static void main(String[] args) {
+        List<String> list = new ArrayList<>(10) ;
+        while (true){
+            list.add("1") ;
+        }
+    }
+```
+
+当出现 OOM 时可以通过工具来分析 `GC-Roots` [引用链](https://github.com/crossoverJie/Java-Interview/blob/master/MD/GarbageCollection.md#%E5%8F%AF%E8%BE%BE%E6%80%A7%E5%88%86%E6%9E%90%E7%AE%97%E6%B3%95) ，查看对象和 `GC-Roots` 是如何进行关联的，是否存在对象的生命周期过长，或者是这些对象确实改存在的，那就要考虑将堆内存调大了。
+
+```
+Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
+	at java.util.Arrays.copyOf(Arrays.java:3210)
+	at java.util.Arrays.copyOf(Arrays.java:3181)
+	at java.util.ArrayList.grow(ArrayList.java:261)
+	at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:235)
+	at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:227)
+	at java.util.ArrayList.add(ArrayList.java:458)
+	at com.crossoverjie.oom.HeapOOM.main(HeapOOM.java:18)
+	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
+	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
+	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
+	at java.lang.reflect.Method.invoke(Method.java:498)
+	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
+
+Process finished with exit code 1
+
+```
+`java.lang.OutOfMemoryError: Java heap space`表示堆内存溢出。
+
+
+## MetaSpace (元数据) 内存溢出
+
+> `JDK8` 中将永久代移除，使用 `MetaSpace` 来保存类加载之后的类信息，字符串常量池也被移动到 Java 堆。
+
+`PermSize` 和 `MaxPermSize` 已经不能使用了，在 JDK8 中配置这两个参数将会发出警告。
+
+
+JDK 8 中将类信息移到到了本地堆内存(Native Heap)中，将原有的永久代移动到了本地堆中成为 `MetaSpace` ,如果不指定该区域的大小，JVM 将会动态的调整。
+
+可以使用 `-XX:MaxMetaspaceSize=10M` 来限制最大元数据。这样当不停的创建类时将会占满该区域并出现 `OOM`。
+
+```java
+    public static void main(String[] args) {
+        while (true){
+            Enhancer  enhancer = new Enhancer() ;
+            enhancer.setSuperclass(HeapOOM.class);
+            enhancer.setUseCache(false) ;
+            enhancer.setCallback(new MethodInterceptor() {
+                @Override
+                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
+                    return methodProxy.invoke(o,objects) ;
+                }
+            });
+            enhancer.create() ;
+
+        }
+    }
+```
+使用 `cglib` 不停的创建新类，最终会抛出:
+```
+Caused by: java.lang.reflect.InvocationTargetException
+	at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)
+	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
+	at java.lang.reflect.Method.invoke(Method.java:498)
+	at net.sf.cglib.core.ReflectUtils.defineClass(ReflectUtils.java:459)
+	at net.sf.cglib.core.AbstractClassGenerator.generate(AbstractClassGenerator.java:336)
+	... 11 more
+Caused by: java.lang.OutOfMemoryError: Metaspace
+	at java.lang.ClassLoader.defineClass1(Native Method)
+	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
+	... 16 more
+```
+
+注意：这里的 OOM 伴随的是 `java.lang.OutOfMemoryError: Metaspace` 也就是元数据溢出。
+
diff --git a/Java-Interview/MD/ReentrantLock.md b/Java-Interview/MD/ReentrantLock.md
new file mode 100644
index 0000000..22ec2b0
--- /dev/null
+++ b/Java-Interview/MD/ReentrantLock.md
@@ -0,0 +1,299 @@
+# ReentrantLock 实现原理 
+
+使用 `synchronize` 来做同步处理时，锁的获取和释放都是隐式的，实现的原理是通过编译后加上不同的机器指令来实现。
+
+而 `ReentrantLock` 就是一个普通的类，它是基于 `AQS(AbstractQueuedSynchronizer)`来实现的。
+
+是一个**重入锁**：一个线程获得了锁之后仍然可以**反复**的加锁，不会出现自己阻塞自己的情况。
+
+> `AQS` 是 `Java` 并发包里实现锁、同步的一个重要的基础框架。
+
+
+## 锁类型
+
+ReentrantLock 分为**公平锁**和**非公平锁**，可以通过构造方法来指定具体类型：
+
+```java
+    //默认非公平锁
+    public ReentrantLock() {
+        sync = new NonfairSync();
+    }
+    
+    //公平锁
+    public ReentrantLock(boolean fair) {
+        sync = fair ? new FairSync() : new NonfairSync();
+    }
+```
+
+默认一般使用**非公平锁**，它的效率和吞吐量都比公平锁高的多(后面会分析具体原因)。
+
+## 获取锁
+
+通常的使用方式如下:
+
+```java
+    private ReentrantLock lock = new ReentrantLock();
+    public void run() {
+        lock.lock();
+        try {
+            //do bussiness
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            lock.unlock();
+        }
+    }
+```
+
+### 公平锁获取锁
+首先看下获取锁的过程：
+
+```java
+    public void lock() {
+        sync.lock();
+    }
+```
+
+可以看到是使用 `sync`的方法，而这个方法是一个抽象方法，具体是由其子类(`FairSync`)来实现的，以下是公平锁的实现:
+
+```java
+        final void lock() {
+            acquire(1);
+        }
+        
+        //AbstractQueuedSynchronizer 中的 acquire()
+        public final void acquire(int arg) {
+        if (!tryAcquire(arg) &&
+            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
+            selfInterrupt();
+    	}
+```
+
+第一步是尝试获取锁(`tryAcquire(arg)`),这个也是由其子类实现：
+
+```java
+        protected final boolean tryAcquire(int acquires) {
+            final Thread current = Thread.currentThread();
+            int c = getState();
+            if (c == 0) {
+                if (!hasQueuedPredecessors() &&
+                    compareAndSetState(0, acquires)) {
+                    setExclusiveOwnerThread(current);
+                    return true;
+                }
+            }
+            else if (current == getExclusiveOwnerThread()) {
+                int nextc = c + acquires;
+                if (nextc < 0)
+                    throw new Error("Maximum lock count exceeded");
+                setState(nextc);
+                return true;
+            }
+            return false;
+        }
+    }
+```
+
+首先会判断 `AQS` 中的 `state` 是否等于 0，0 表示目前没有其他线程获得锁，当前线程就可以尝试获取锁。
+
+**注意**:尝试之前会利用 `hasQueuedPredecessors()` 方法来判断 AQS 的队列中中是否有其他线程，如果有则不会尝试获取锁(**这是公平锁特有的情况**)。
+
+如果队列中没有线程就利用 CAS 来将 AQS 中的 state 修改为1，也就是获取锁，获取成功则将当前线程置为获得锁的独占线程(`setExclusiveOwnerThread(current)`)。
+
+如果 `state` 大于 0 时，说明锁已经被获取了，则需要判断获取锁的线程是否为当前线程(`ReentrantLock` 支持重入)，是则需要将 `state + 1`，并将值更新。
+
+
+#### 写入队列
+如果 `tryAcquire(arg)` 获取锁失败，则需要用 `addWaiter(Node.EXCLUSIVE)` 将当前线程写入队列中。
+
+写入之前需要将当前线程包装为一个 `Node` 对象(`addWaiter(Node.EXCLUSIVE)`)。
+
+> AQS 中的队列是由 Node 节点组成的双向链表实现的。
+
+
+包装代码:
+
+```java
+    private Node addWaiter(Node mode) {
+        Node node = new Node(Thread.currentThread(), mode);
+        // Try the fast path of enq; backup to full enq on failure
+        Node pred = tail;
+        if (pred != null) {
+            node.prev = pred;
+            if (compareAndSetTail(pred, node)) {
+                pred.next = node;
+                return node;
+            }
+        }
+        enq(node);
+        return node;
+    }
+
+```
+
+首先判断队列是否为空，不为空时则将封装好的 `Node` 利用 `CAS` 写入队尾，如果出现并发写入失败就需要调用 `enq(node);` 来写入了。
+
+```java
+    private Node enq(final Node node) {
+        for (;;) {
+            Node t = tail;
+            if (t == null) { // Must initialize
+                if (compareAndSetHead(new Node()))
+                    tail = head;
+            } else {
+                node.prev = t;
+                if (compareAndSetTail(t, node)) {
+                    t.next = node;
+                    return t;
+                }
+            }
+        }
+    }
+```
+
+这个处理逻辑就相当于`自旋`加上 `CAS` 保证一定能写入队列。
+
+#### 挂起等待线程
+
+写入队列之后需要将当前线程挂起(利用`acquireQueued(addWaiter(Node.EXCLUSIVE), arg)`)：
+
+```java
+    final boolean acquireQueued(final Node node, int arg) {
+        boolean failed = true;
+        try {
+            boolean interrupted = false;
+            for (;;) {
+                final Node p = node.predecessor();
+                if (p == head && tryAcquire(arg)) {
+                    setHead(node);
+                    p.next = null; // help GC
+                    failed = false;
+                    return interrupted;
+                }
+                if (shouldParkAfterFailedAcquire(p, node) &&
+                    parkAndCheckInterrupt())
+                    interrupted = true;
+            }
+        } finally {
+            if (failed)
+                cancelAcquire(node);
+        }
+    }
+```
+
+首先会根据 `node.predecessor()` 获取到上一个节点是否为头节点，如果是则尝试获取一次锁，获取成功就万事大吉了。
+
+如果不是头节点，或者获取锁失败，则会根据上一个节点的 `waitStatus` 状态来处理(`shouldParkAfterFailedAcquire(p, node)`)。
+
+`waitStatus` 用于记录当前节点的状态，如节点取消、节点等待等。
+
+`shouldParkAfterFailedAcquire(p, node)` 返回当前线程是否需要挂起，如果需要则调用 `parkAndCheckInterrupt()`：
+
+```java
+    private final boolean parkAndCheckInterrupt() {
+        LockSupport.park(this);
+        return Thread.interrupted();
+    }
+```
+
+他是利用 `LockSupport` 的 `part` 方法来挂起当前线程的，直到被唤醒。
+
+
+### 非公平锁获取锁
+公平锁与非公平锁的差异主要在获取锁：
+
+公平锁就相当于买票，后来的人需要排到队尾依次买票，**不能插队**。
+
+而非公平锁则没有这些规则，是**抢占模式**，每来一个人不会去管队列如何，直接尝试获取锁。
+
+非公平锁:
+```java
+        final void lock() {
+            //直接尝试获取锁
+            if (compareAndSetState(0, 1))
+                setExclusiveOwnerThread(Thread.currentThread());
+            else
+                acquire(1);
+        }
+```
+
+公平锁:
+```java
+        final void lock() {
+            acquire(1);
+        }
+```
+
+还要一个重要的区别是在尝试获取锁时`tryAcquire(arg)`，非公平锁是不需要判断队列中是否还有其他线程，也是直接尝试获取锁：
+
+```java
+        final boolean nonfairTryAcquire(int acquires) {
+            final Thread current = Thread.currentThread();
+            int c = getState();
+            if (c == 0) {
+                //没有 !hasQueuedPredecessors() 判断
+                if (compareAndSetState(0, acquires)) {
+                    setExclusiveOwnerThread(current);
+                    return true;
+                }
+            }
+            else if (current == getExclusiveOwnerThread()) {
+                int nextc = c + acquires;
+                if (nextc < 0) // overflow
+                    throw new Error("Maximum lock count exceeded");
+                setState(nextc);
+                return true;
+            }
+            return false;
+        }
+```
+
+## 释放锁
+
+公平锁和非公平锁的释放流程都是一样的：
+
+```java
+    public void unlock() {
+        sync.release(1);
+    }
+    
+    public final boolean release(int arg) {
+        if (tryRelease(arg)) {
+            Node h = head;
+            if (h != null && h.waitStatus != 0)
+            	   //唤醒被挂起的线程
+                unparkSuccessor(h);
+            return true;
+        }
+        return false;
+    }
+    
+    //尝试释放锁
+    protected final boolean tryRelease(int releases) {
+        int c = getState() - releases;
+        if (Thread.currentThread() != getExclusiveOwnerThread())
+            throw new IllegalMonitorStateException();
+        boolean free = false;
+        if (c == 0) {
+            free = true;
+            setExclusiveOwnerThread(null);
+        }
+        setState(c);
+        return free;
+    }        
+```
+
+首先会判断当前线程是否为获得锁的线程，由于是重入锁所以需要将 `state` 减到 0 才认为完全释放锁。
+
+释放之后需要调用 `unparkSuccessor(h)` 来唤醒被挂起的线程。
+
+
+## 总结
+
+由于公平锁需要关心队列的情况，得按照队列里的先后顺序来获取锁(会造成大量的线程上下文切换)，而非公平锁则没有这个限制。
+
+所以也就能解释非公平锁的效率会被公平锁更高。
+
+
+
+
diff --git a/Java-Interview/MD/SQL-optimization.md b/Java-Interview/MD/SQL-optimization.md
new file mode 100644
index 0000000..847bd8d
--- /dev/null
+++ b/Java-Interview/MD/SQL-optimization.md
@@ -0,0 +1,86 @@
+# SQL 优化
+
+### 负向查询不能使用索引
+
+```sql
+select name from user where id not in (1,3,4);
+```
+应该修改为:
+
+```
+select name from user where id in (2,5,6);
+```
+
+### 前导模糊查询不能使用索引
+如:
+
+```sql
+select name from user where name like '%zhangsan'
+```
+
+非前导则可以:
+```sql
+select name from user where name like 'zhangsan%'
+```
+建议可以考虑使用 `Lucene` 等全文索引工具来代替频繁的模糊查询。
+
+### 数据区分不明显的不建议创建索引
+
+如 user 表中的性别字段，可以明显区分的才建议创建索引，如身份证等字段。
+
+### 字段的默认值不要为 null
+这样会带来和预期不一致的查询结果。
+
+### 在字段上进行计算不能命中索引
+
+```sql
+select name from user where FROM_UNIXTIME(create_time) < CURDATE();
+```
+
+应该修改为:
+
+```sql
+select name from user where create_time < FROM_UNIXTIME(CURDATE());
+```
+
+### 最左前缀问题
+
+如果给 user 表中的 username pwd 字段创建了复合索引那么使用以下SQL 都是可以命中索引:
+
+```sql
+select username from user where username='zhangsan' and pwd ='axsedf1sd'
+
+select username from user where pwd ='axsedf1sd' and username='zhangsan'
+
+select username from user where username='zhangsan'
+```
+
+但是使用
+
+```sql
+select username from user where pwd ='axsedf1sd'
+```
+是不能命中索引的。
+
+### 如果明确知道只有一条记录返回
+
+```sql
+select name from user where username='zhangsan' limit 1
+```
+可以提高效率，可以让数据库停止游标移动。
+
+### 不要让数据库帮我们做强制类型转换
+
+```sql
+select name from user where telno=18722222222
+```
+这样虽然可以查出数据，但是会导致全表扫描。
+
+需要修改为
+```
+select name from user where telno='18722222222'
+```
+
+### 如果需要进行 join 的字段两表的字段类型要相同
+
+不然也不会命中索引。
\ No newline at end of file
diff --git a/Java-Interview/MD/Spike.md b/Java-Interview/MD/Spike.md
new file mode 100644
index 0000000..b35114e
--- /dev/null
+++ b/Java-Interview/MD/Spike.md
@@ -0,0 +1,30 @@
+# 设计一个秒杀系统
+
+主要做到以下两点:
+
+- 尽量将请求过滤在上游。
+- 尽可能的利用缓存(大多数场景下都是**查多于写**)。
+
+常用的系统分层结构:
+
+![](https://ws4.sinaimg.cn/large/006tNc79ly1fmjw06nz2zj306f0fejrh.jpg)
+
+针对于浏览器端，可以使用 JS 进行请求过滤，比如五秒钟之类只能点一次抢购按钮，五秒钟只能允许请求一次后端服务。(APP 同理)
+
+这样其实就可以过滤掉大部分普通用户。
+
+但是防不住直接抓包循环调用。这种情况可以最简单的处理:在`Web层`通过限制一个 UID 五秒之类的请求服务层的次数(可利用 Redis 实现)。
+
+但如果是真的有 10W 个不同的 UID 来请求，比如黑客抓肉鸡的方式。
+
+这种情况可以在`服务层` 针对于写请求使用请求队列，再通过限流算法([限流算法](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Limiting.md))每秒钟放一部分请求到队列。
+
+对于读请求则尽量使用缓存，可以提前将数据准备好，不管是 `Redis` 还是其他缓存中间件效率都是非常高的。
+
+> ps : 刷新缓存情况，比如库存扣除成功这种情况不用马上刷新缓存，如果库存扣到了 0 再刷新缓存。因为大多数用户都只关心是否有货，并不关心现在还剩余多少。
+
+## 总结
+
+- 如果流量巨大，导致各个层的压力都很大可以适当的加机器横向扩容。如果加不了机器那就只有放弃流量直接返回失败。快速失败非常重要，至少可以保证系统的可用性。
+- 业务分批执行：对于下单、付款等操作可以异步执行提高吞吐率。
+- 主要目的就是尽量少的请求直接访问到 `DB`。
\ No newline at end of file
diff --git a/Java-Interview/MD/SpringAOP.md b/Java-Interview/MD/SpringAOP.md
new file mode 100644
index 0000000..808cfa8
--- /dev/null
+++ b/Java-Interview/MD/SpringAOP.md
@@ -0,0 +1,224 @@
+# Spring AOP 实现原理
+
+## 静态代理
+
+众所周知 Spring 的 `AOP` 是基于动态代理实现的，谈到动态代理就不得不提下静态代理。实现如下：
+
+假设有一接口 `InterfaceA`：
+
+```java
+public interface InterfaceA{
+    void exec();
+}
+```
+
+其中有实现类 `RealImplement`:
+```java
+public class RealImplement implement InterfaceA{
+    public void exec(){
+        System.out.println("real impl") ;
+    }
+}
+```
+
+这时也有一个代理类 `ProxyImplement` 也实现了 `InterfaceA`:
+```java
+public class ProxyImplement implement InterfaceA{
+    private InterfaceA interface ;
+    
+    public ProxyImplement(){
+        interface = new RealImplement() ;
+    }
+    
+    public void exec(){
+        System.out.println("dosomethings before);
+        //实际调用
+        interface.exec();
+        
+        System.out.println("dosomethings after);
+    }
+    
+}
+```
+使用如下:
+```
+public class Main(){
+    public static void main(String[] args){
+        InterfaceA interface = new ProxyImplement() ;
+        interface.exec();
+    }
+}
+```
+可以看出这样的代理方式调用者其实都不知道被代理对象的存在。
+
+## JDK 动态代理
+从静态代理中可以看出: 静态代理只能代理一个具体的类，如果要代理一个接口的多个实现的话需要定义不同的代理类。
+
+需要解决这个问题就可以用到 JDK 的动态代理。
+
+其中有两个非常核心的类:
+
+- `java.lang.reflect.Proxy`类。
+- `java.lang.reflect.InvocationHandle`接口。
+
+`Proxy` 类是用于创建代理对象，而 `InvocationHandler` 接口主要你是来处理执行逻辑。
+
+如下：
+```java
+public class CustomizeHandle implements InvocationHandler {
+    private final static Logger LOGGER = LoggerFactory.getLogger(CustomizeHandle.class);
+
+    private Object target;
+
+    public CustomizeHandle(Class clazz) {
+        try {
+            this.target = clazz.newInstance();
+        } catch (InstantiationException e) {
+            LOGGER.error("InstantiationException", e);
+        } catch (IllegalAccessException e) {
+            LOGGER.error("IllegalAccessException",e);
+        }
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+
+        before();
+        Object result = method.invoke(target, args);
+        after();
+
+        LOGGER.info("proxy class={}", proxy.getClass());
+        return result;
+    }
+
+
+    private void before() {
+        LOGGER.info("handle before");
+    }
+
+    private void after() {
+        LOGGER.info("handle after");
+    }
+}
+```
+
+其中构造方法传入被代理类的类类型。其实传代理类的实例或者是类类型并没有强制的规定，传类类型的是因为被代理对象应当有代理创建而不应该由调用方创建。
+
+使用方式如下：
+```java
+    @Test
+    public void test(){
+        CustomizeHandle handle = new CustomizeHandle(ISubjectImpl.class) ;
+        ISubject subject = (ISubject) Proxy.newProxyInstance(JDKProxyTest.class.getClassLoader(), new Class[]{ISubject.class}, handle);
+        subject.execute() ;
+    }
+```
+
+首先传入被代理类的类类型构建代理处理器。接着使用 `Proxy` 的`newProxyInstance` 方法动态创建代理类。第一个参数为类加载器，第二个参数为代理类需要实现的接口列表，最后一个则是处理器。
+
+其实代理类是由
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fms01lcml3j30ki09s75v.jpg)
+
+这个方法动态创建出来的。将 proxyClassFile 输出到文件并进行反编译的话就可以的到代理类。
+```java
+    @Test
+    public void clazzTest(){
+        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
+                "$Proxy1", new Class[]{ISubject.class}, 1);
+        try {
+            FileOutputStream out = new FileOutputStream("/Users/chenjie/Documents/$Proxy1.class") ;
+            out.write(proxyClassFile);
+            out.close();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+```
+
+反编译后结果如下:
+```java
+import com.crossoverjie.proxy.jdk.ISubject;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.UndeclaredThrowableException;
+
+public class $Proxy1 extends Proxy implements ISubject {
+    private static Method m1;
+    private static Method m2;
+    private static Method m3;
+    private static Method m0;
+
+    public $Proxy1(InvocationHandler var1) throws  {
+        super(var1);
+    }
+
+    public final boolean equals(Object var1) throws  {
+        try {
+            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
+        } catch (RuntimeException | Error var3) {
+            throw var3;
+        } catch (Throwable var4) {
+            throw new UndeclaredThrowableException(var4);
+        }
+    }
+
+    public final String toString() throws  {
+        try {
+            return (String)super.h.invoke(this, m2, (Object[])null);
+        } catch (RuntimeException | Error var2) {
+            throw var2;
+        } catch (Throwable var3) {
+            throw new UndeclaredThrowableException(var3);
+        }
+    }
+
+    public final void execute() throws  {
+        try {
+            super.h.invoke(this, m3, (Object[])null);
+        } catch (RuntimeException | Error var2) {
+            throw var2;
+        } catch (Throwable var3) {
+            throw new UndeclaredThrowableException(var3);
+        }
+    }
+
+    public final int hashCode() throws  {
+        try {
+            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
+        } catch (RuntimeException | Error var2) {
+            throw var2;
+        } catch (Throwable var3) {
+            throw new UndeclaredThrowableException(var3);
+        }
+    }
+
+    static {
+        try {
+            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
+            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
+            m3 = Class.forName("com.crossoverjie.proxy.jdk.ISubject").getMethod("execute", new Class[0]);
+            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
+        } catch (NoSuchMethodException var2) {
+            throw new NoSuchMethodError(var2.getMessage());
+        } catch (ClassNotFoundException var3) {
+            throw new NoClassDefFoundError(var3.getMessage());
+        }
+    }
+}
+```
+
+可以看到代理类继承了 `Proxy` 类，并实现了 `ISubject` 接口，由此也可以看到 JDK 动态代理为什么需要实现接口，已经继承了 `Proxy`是不能再继承其余类了。
+
+其中实现了 `ISubject` 的 `execute()` 方法，并通过 `InvocationHandler` 中的 `invoke()` 方法来进行调用的。
+
+
+## CGLIB 动态代理
+
+cglib 是对一个小而快的字节码处理框架 `ASM` 的封装。
+他的特点是继承于被代理类，这就要求被代理类不能被 `final` 修饰。
+
+
diff --git a/Java-Interview/MD/Synchronize.md b/Java-Interview/MD/Synchronize.md
new file mode 100644
index 0000000..a6dbd85
--- /dev/null
+++ b/Java-Interview/MD/Synchronize.md
@@ -0,0 +1,115 @@
+# synchronized 关键字原理
+
+众所周知 `synchronized` 关键字是解决并发问题常用解决方案，有以下三种使用方式:
+
+- 同步普通方法，锁的是当前对象。
+- 同步静态方法，锁的是当前 `Class` 对象。
+- 同步块，锁的是 `()` 中的对象。
+
+
+实现原理：
+`JVM` 是通过进入、退出对象监视器( `Monitor` )来实现对方法、同步块的同步的。
+
+具体实现是在编译之后在同步方法调用前加入一个 `monitor.enter` 指令，在退出方法和异常处插入 `monitor.exit` 的指令。
+
+其本质就是对一个对象监视器( `Monitor` )进行获取，而这个获取过程具有排他性从而达到了同一时刻只能一个线程访问的目的。
+
+而对于没有获取到锁的线程将会阻塞到方法入口处，直到获取锁的线程 `monitor.exit` 之后才能尝试继续获取锁。
+
+流程图如下:
+
+![](https://ws2.sinaimg.cn/large/006tNc79ly1fn27fkl07jj31e80hyn0n.jpg)
+
+
+通过一段代码来演示:
+
+```java
+    public static void main(String[] args) {
+        synchronized (Synchronize.class){
+            System.out.println("Synchronize");
+        }
+    }
+```
+
+使用 `javap -c Synchronize` 可以查看编译之后的具体信息。
+
+```
+public class com.crossoverjie.synchronize.Synchronize {
+  public com.crossoverjie.synchronize.Synchronize();
+    Code:
+       0: aload_0
+       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
+       4: return
+
+  public static void main(java.lang.String[]);
+    Code:
+       0: ldc           #2                  // class com/crossoverjie/synchronize/Synchronize
+       2: dup
+       3: astore_1
+       **4: monitorenter**
+       5: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
+       8: ldc           #4                  // String Synchronize
+      10: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
+      13: aload_1
+      **14: monitorexit**
+      15: goto          23
+      18: astore_2
+      19: aload_1
+      20: monitorexit
+      21: aload_2
+      22: athrow
+      23: return
+    Exception table:
+       from    to  target type
+           5    15    18   any
+          18    21    18   any
+}
+```
+
+可以看到在同步块的入口和出口分别有 `monitorenter,monitorexit`
+指令。
+
+
+## 锁优化
+`synchronized`  很多都称之为重量锁，`JDK1.6` 中对 `synchronized` 进行了各种优化，为了能减少获取和释放锁带来的消耗引入了`偏向锁`和`轻量锁`。
+
+
+### 轻量锁
+当代码进入同步块时，如果同步对象为无锁状态时，当前线程会在栈帧中创建一个锁记录(`Lock Record`)区域，同时将锁对象的对象头中 `Mark Word` 拷贝到锁记录中，再尝试使用 `CAS` 将 `Mark Word` 更新为指向锁记录的指针。
+
+如果更新**成功**，当前线程就获得了锁。
+
+如果更新**失败** `JVM` 会先检查锁对象的 `Mark Word` 是否指向当前线程的锁记录。
+
+如果是则说明当前线程拥有锁对象的锁，可以直接进入同步块。
+
+不是则说明有其他线程抢占了锁，如果存在多个线程同时竞争一把锁，**轻量锁就会膨胀为重量锁**。
+
+#### 解锁
+轻量锁的解锁过程也是利用 `CAS` 来实现的，会尝试锁记录替换回锁对象的 `Mark Word` 。如果替换成功则说明整个同步操作完成，失败则说明有其他线程尝试获取锁，这时就会唤醒被挂起的线程(此时已经膨胀为`重量锁`)
+
+轻量锁能提升性能的原因是：
+
+认为大多数锁在整个同步周期都不存在竞争，所以使用 `CAS` 比使用互斥开销更少。但如果锁竞争激烈，轻量锁就不但有互斥的开销，还有 `CAS` 的开销，甚至比重量锁更慢。
+
+### 偏向锁
+
+为了进一步的降低获取锁的代价，`JDK1.6` 之后还引入了偏向锁。
+
+偏向锁的特征是:锁不存在多线程竞争，并且应由一个线程多次获得锁。
+
+当线程访问同步块时，会使用 `CAS` 将线程 ID 更新到锁对象的 `Mark Word` 中，如果更新成功则获得偏向锁，并且之后每次进入这个对象锁相关的同步块时都不需要再次获取锁了。
+
+#### 释放锁
+当有另外一个线程获取这个锁时，持有偏向锁的线程就会释放锁，释放时会等待全局安全点(这一时刻没有字节码运行)，接着会暂停拥有偏向锁的线程，根据锁对象目前是否被锁来判定将对象头中的 `Mark Word` 设置为无锁或者是轻量锁状态。
+
+偏向锁可以提高带有同步却没有竞争的程序性能，但如果程序中大多数锁都存在竞争时，那偏向锁就起不到太大作用。可以使用 `-XX:-userBiasedLocking=false` 来关闭偏向锁，并默认进入轻量锁。
+
+
+### 其他优化
+
+#### 适应性自旋
+在使用 `CAS` 时，如果操作失败，`CAS` 会自旋再次尝试。由于自旋是需要消耗 `CPU` 资源的，所以如果长期自旋就白白浪费了 `CPU`。`JDK1.6`加入了适应性自旋:
+
+> 如果某个锁自旋很少成功获得，那么下一次就会减少自旋。
+
diff --git a/Java-Interview/MD/TCP-IP.md b/Java-Interview/MD/TCP-IP.md
new file mode 100644
index 0000000..3d5f37e
--- /dev/null
+++ b/Java-Interview/MD/TCP-IP.md
@@ -0,0 +1,24 @@
+# TCP/IP 协议
+
+`TCP/IP` 总结起来就三个要点
+- 三次握手的意义。
+- 超时重发。
+- 滑动窗口。
+
+## 三次握手
+![](https://ws4.sinaimg.cn/large/006tNc79gy1fms9a563c3j30o309ogmc.jpg)
+
+如图类似：
+1. 发送者问接收者我发消息了，你收到了嘛？
+2. 接收者回复发送者我收到了，你发消息没问题，我收消息也没问题。但我不知道我的发消息有没有问题，你收到了回复我下。
+3. 发送者告诉接收者，我收到你的消息了，你发消息没问题。通信成功我们开始工作吧！
+
+
+## 超时重发
+
+当发送者向接收者发包后，如果过了一段时间(超时时间)依然没有收到消息，就当做本次包丢失，需要重新补发。
+
+并且如果一次性发了三个包，只要最后一个包确认收到之后就默认前面两个也收到了。
+
+## 滑动窗口
+假设一次性发送包的大小为3，那么每次可以发3个包，而且可以边发边接收，这样就会增强效率。这里的 3 就是滑动窗口的大小，这样的发送方式也叫滑动窗口协议。
\ No newline at end of file
diff --git a/Java-Interview/MD/Thread-common-problem.md b/Java-Interview/MD/Thread-common-problem.md
new file mode 100644
index 0000000..1669307
--- /dev/null
+++ b/Java-Interview/MD/Thread-common-problem.md
@@ -0,0 +1,30 @@
+# Java 多线程常见问题
+
+## 上下文切换
+多线程并不一定是要在多核处理器才支持的，就算是单核也是可以支持多线程的。
+CPU 通过给每个线程分配一定的时间片，由于时间非常短通常是几十毫秒，所以 CPU 可以不停的切换线程执行任务从而达到了多线程的效果。
+
+但是由于在线程切换的时候需要保存本次执行的信息([详见](https://github.com/crossoverJie/Java-Interview/blob/master/MD/MemoryAllocation.md#%E7%A8%8B%E5%BA%8F%E8%AE%A1%E6%95%B0%E5%99%A8))，在该线程被 CPU 剥夺时间片后又再次运行恢复上次所保存的信息的过程就成为上下文切换。
+
+> 上下文切换是非常耗效率的。
+
+通常有以下解决方案:
+- 采用无锁编程，比如将数据按照 `Hash(id)` 进行取模分段，每个线程处理各自分段的数据，从而避免使用锁。
+- 采用 CAS(compare and swap) 算法，如 `Atomic` 包就是采用 CAS 算法([详见](https://github.com/crossoverJie/Java-Interview/blob/master/Threadcore.md#%E5%8E%9F%E5%AD%90%E6%80%A7))。
+- 合理的创建线程，避免创建了一些线程但其中大部分都是出于 `waiting` 状态，因为每当从 `waiting` 状态切换到 `running` 状态都是一次上下文切换。
+
+## 死锁
+
+死锁的场景一般是：线程 A 和线程 B 都在互相等待对方释放锁，或者是其中某个线程在释放锁的时候出现异常如死循环之类的。这时就会导致系统不可用。
+
+常用的解决方案如下：
+
+- 尽量一个线程只获取一个锁。
+- 一个线程只占用一个资源。
+- 尝试使用定时锁，至少能保证锁最终会被释放。
+
+## 资源限制
+
+当在带宽有限的情况下一个线程下载某个资源需要 `1M/S`,当开 10 个线程时速度并不会乘 10 倍，反而还会增加时间，毕竟上下文切换比较耗时。
+
+如果是受限于资源的话可以采用集群来处理任务，不同的机器来处理不同的数据，就类似于开始提到的无锁编程。
diff --git a/Java-Interview/MD/ThreadPoolExecutor.md b/Java-Interview/MD/ThreadPoolExecutor.md
new file mode 100644
index 0000000..b28f097
--- /dev/null
+++ b/Java-Interview/MD/ThreadPoolExecutor.md
@@ -0,0 +1,49 @@
+# 线程池原理分析
+
+首先要明确为什么要使用线程池，使用线程池会带来什么好处？
+
+- 线程是稀缺资源，不能频繁的创建。
+- 应当将其放入一个池子中，可以给其他任务进行复用。
+- 解耦作用，线程的创建于执行完全分开，方便维护。
+
+
+## 创建一个线程池
+
+以一个使用较多的 
+
+```java
+ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) 
+```
+
+为例：
+
+- 其中的 `corePoolSize` 为线程池的基本大小。
+- `maximumPoolSize` 为线程池最大线程大小。
+- `keepAliveTime` 和 `unit` 则是线程空闲后的存活时间。
+- `workQueue` 用于存放任务的阻塞队列。
+- `handler` 当队列和最大线程池都满了之后的饱和策略。
+
+## 处理流程
+当提交一个任务到线程池时它的执行流程是怎样的呢？
+
+![](https://ws1.sinaimg.cn/large/006tNbRwgy1fnbzmai8yrj30dw08574s.jpg)
+
+首先第一步会判断核心线程数有没有达到上限，如果没有则创建线程(会获取全局锁)，满了则会将任务丢进阻塞队列。
+
+如果队列也满了则需要判断最大线程数是否达到上限，如果没有则创建线程(获取全局锁)，如果最大线程数也满了则会根据饱和策略处理。
+
+常用的饱和策略有:
+- 直接丢弃任务。
+- 调用者线程处理。
+- 丢弃队列中的最近任务，执行当前任务。
+
+所以当线程池完成预热之后都是将任务放入队列，接着由工作线程一个个从队列里取出执行。
+
+## 合理配置线程池
+
+线程池并不是配置越大越好，而是要根据任务的熟悉来进行划分：
+如果是 `CPU` 密集型任务应当分配较少的线程，比如 `CPU` 个数相当的大小。
+
+如果是 IO 密集型任务，由于线程并不是一直在运行，所以可以尽可能的多配置线程，比如 `CPU 个数 * 2` 。
+
+当是一个混合型任务，可以将其拆分为 `CPU` 密集型任务以及 `IO` 密集型任务，这样来分别配置。
diff --git a/Java-Interview/MD/Threadcore.md b/Java-Interview/MD/Threadcore.md
new file mode 100644
index 0000000..5c35e2a
--- /dev/null
+++ b/Java-Interview/MD/Threadcore.md
@@ -0,0 +1,142 @@
+# Java 多线程三大核心
+
+## 原子性
+`Java` 的原子性就和数据库事物的原子性差不多，一个操作中要么全部执行成功或者失败。
+
+`JMM` 只是保证了基本的原子性，但类似于 `i++` 之类的操作，看似是原子操作，其实里面涉及到:
+
+- 获取 i 的值。
+- 自增。
+- 再赋值给 i。
+
+这三步操作，所以想要实现 `i++` 这样的原子操作就需要用到 `synchronize` 或者是 `lock` 进行加锁处理。
+
+如果是基础类的自增操作可以使用 `AtomicInteger` 这样的原子类来实现(其本质是利用了 `CPU` 级别的 的 `CAS` 指令来完成的)。
+
+其中用的最多的方法就是: `incrementAndGet()` 以原子的方式自增。
+源码如下:
+
+```java
+public final long incrementAndGet() {
+        for (;;) {
+            long current = get();
+            long next = current + 1;
+            if (compareAndSet(current, next))
+                return next;
+        }
+    }
+```
+
+首先是获得当前的值，然后自增 +1。接着则是最核心的 `compareAndSet() ` 来进行原子更新。
+
+```java
+public final boolean compareAndSet(long expect, long update) {
+        return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
+    }
+```
+
+其逻辑就是判断当前的值是否被更新过，是否等于 `current`，如果等于就说明没有更新过然后将当前的值更新为 `next`，如果不等于则返回`false` 进入循环，直到更新成功为止。
+
+还有其中的 `get()` 方法也很关键，返回的是当前的值，当前值用了 `volatile` 关键词修饰，保证了内存可见性。
+
+```java
+ private volatile int value;
+```
+
+
+## 可见性
+
+现代计算机中，由于 `CPU` 直接从主内存中读取数据的效率不高，所以都会对应的 `CPU` 高速缓存，先将主内存中的数据读取到缓存中，线程修改数据之后首先更新到缓存，之后才会更新到主内存。如果此时还没有将数据更新到主内存其他的线程此时来读取就是修改之前的数据。
+
+![](https://ws2.sinaimg.cn/large/006tKfTcly1fmouu3fpokj31ae0osjt1.jpg)
+
+如上图所示。
+
+`volatile` 关键字就是用于保证内存可见性，当线程A更新了 volatile 修饰的变量时，它会立即刷新到主线程，并且将其余缓存中该变量的值清空，导致其余线程只能去主内存读取最新值。
+
+使用 `volatile` 关键词修饰的变量每次读取都会得到最新的数据，不管哪个线程对这个变量的修改都会立即刷新到主内存。
+
+`synchronize`和加锁也能能保证可见性，实现原理就是在释放锁之前其余线程是访问不到这个共享变量的。但是和 `volatile` 相比开销较大。
+
+## 顺序性
+以下这段代码:
+
+```java
+int a = 100 ; //1
+int b = 200 ; //2
+int c = a + b ; //3
+```
+
+正常情况下的执行顺序应该是 `1>>2>>3`。但是有时 `JVM` 为了提高整体的效率会进行指令重排导致执行的顺序可能是 `2>>1>>3`。但是 `JVM` 也不能是什么都进行重排，是在保证最终结果和代码顺序执行结果一致的情况下才可能进行重排。
+
+重排在单线程中不会出现问题，但在多线程中会出现数据不一致的问题。
+
+Java 中可以使用 `volatile` 来保证顺序性，`synchronize 和 lock` 也可以来保证有序性，和保证原子性的方式一样，通过同一段时间只能一个线程访问来实现的。
+
+除了通过 `volatile` 关键字显式的保证顺序之外， `JVM` 还通过 `happen-before` 原则来隐式的保证顺序性。
+
+其中有一条就是适用于 `volatile` 关键字的，针对于 `volatile` 关键字的写操作肯定是在读操作之前，也就是说读取的值肯定是最新的。
+
+### volatile 的应用
+
+#### 双重检查锁的单例模式
+
+可以用 `volatile` 实现一个双重检查锁的单例模式：
+
+```java
+    public class Singleton {
+        private static volatile Singleton singleton;
+
+        private Singleton() {
+        }
+
+        public static Singleton getInstance() {
+            if (singleton == null) {
+                synchronized (Singleton.class) {
+                    if (singleton == null) {
+                        singleton = new Singleton();
+                    }
+                }
+            }
+            return singleton;
+        }
+
+    }
+```
+
+这里的 `volatile` 关键字主要是为了防止指令重排。
+如果不用 `volatile` ，`singleton = new Singleton();`，这段代码其实是分为三步：
+
+- 分配内存空间。(1)
+- 初始化对象。(2)
+- 将 `singleton` 对象指向分配的内存地址。(3)
+
+加上 `volatile` 是为了让以上的三步操作顺序执行，反之有可能第三步在第二步之前被执行就有可能导致某个线程拿到的单例对象还没有初始化，以致于使用报错。
+
+#### 控制停止线程的标记
+
+```java
+    private volatile boolean flag ;
+    private void run(){
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                doSomeThing();
+            }
+        });
+    }
+
+    private void stop(){
+        flag = false ;
+    }
+```
+
+这里如果没有用 volatile 来修饰 flag ，就有可能其中一个线程调用了 `stop()`方法修改了 flag 的值并不会立即刷新到主内存中，导致这个循环并不会立即停止。
+
+这里主要利用的是 `volatile` 的内存可见性。
+
+总结一下:
+- `volatile` 关键字只能保证可见性，顺序性，**不能保证原子性**。
+
+
+
diff --git a/Java-Interview/MD/collection/HashSet.md b/Java-Interview/MD/collection/HashSet.md
new file mode 100644
index 0000000..a18212d
--- /dev/null
+++ b/Java-Interview/MD/collection/HashSet.md
@@ -0,0 +1,49 @@
+# HashSet
+
+`HashSet` 是一个不允许存储重复元素的集合，它的实现比较简单，只要理解了 `HashMap`，`HashSet` 就水到渠成了。
+
+## 成员变量
+首先了解下 `HashSet` 的成员变量:
+
+```java
+    private transient HashMap<E,Object> map;
+
+    // Dummy value to associate with an Object in the backing Map
+    private static final Object PRESENT = new Object();
+```
+
+发现主要就两个变量:
+
+- `map` ：用于存放最终数据的。
+- `PRESENT` ：是所有写入 map 的 `value` 值。
+
+## 构造函数
+
+```java
+    public HashSet() {
+        map = new HashMap<>();
+    }
+    
+    public HashSet(int initialCapacity, float loadFactor) {
+        map = new HashMap<>(initialCapacity, loadFactor);
+    }    
+```
+构造函数很简单，利用了 `HashMap` 初始化了 `map` 。
+
+## add
+
+```java
+    public boolean add(E e) {
+        return map.put(e, PRESENT)==null;
+    }
+```
+
+比较关键的就是这个 `add()` 方法。
+可以看出它是将存放的对象当做了 `HashMap` 的健，`value` 都是相同的 `PRESENT` 。由于 `HashMap` 的 `key` 是不能重复的，所以每当有重复的值写入到 `HashSet` 时，`value` 会被覆盖，但 `key` 不会收到影响，这样就保证了 `HashSet` 中只能存放不重复的元素。
+
+## 总结
+
+`HashSet` 的原理比较简单，几乎全部借助于 `HashMap` 来实现的。
+
+所以 `HashMap` 会出现的问题 `HashSet` 依然不能避免。
+
diff --git a/Java-Interview/MD/collection/LinkedHashMap.md b/Java-Interview/MD/collection/LinkedHashMap.md
new file mode 100644
index 0000000..bbc49c3
--- /dev/null
+++ b/Java-Interview/MD/collection/LinkedHashMap.md
@@ -0,0 +1,278 @@
+# LinkedHashMap 底层分析
+
+众所周知 [HashMap](https://github.com/crossoverJie/Java-Interview/blob/master/MD/HashMap.md) 是一个无序的 `Map`，因为每次根据 `key` 的 `hashcode` 映射到 `Entry` 数组上，所以遍历出来的顺序并不是写入的顺序。
+
+因此 JDK 推出一个基于 `HashMap` 但具有顺序的 `LinkedHashMap` 来解决有排序需求的场景。
+
+它的底层是继承于 `HashMap` 实现的，由一个双向链表所构成。
+
+`LinkedHashMap` 的排序方式有两种：
+
+- 根据写入顺序排序。
+- 根据访问顺序排序。
+
+其中根据访问顺序排序时，每次 `get` 都会将访问的值移动到链表末尾，这样重复操作就能得到一个按照访问顺序排序的链表。
+
+## 数据结构
+
+```java
+	@Test
+	public void test(){
+		Map<String, Integer> map = new LinkedHashMap<String, Integer>();
+		map.put("1",1) ;
+		map.put("2",2) ;
+		map.put("3",3) ;
+		map.put("4",4) ;
+		map.put("5",5) ;
+		System.out.println(map.toString());
+
+	}
+```
+
+调试可以看到 `map` 的组成：
+
+![](https://ws2.sinaimg.cn/large/006tKfTcly1fo6l9xp91lj319m0s4tgi.jpg)
+
+
+打开源码可以看到：
+
+```java
+    /**
+     * The head of the doubly linked list.
+     */
+    private transient Entry<K,V> header;
+
+    /**
+     * The iteration ordering method for this linked hash map: <tt>true</tt>
+     * for access-order, <tt>false</tt> for insertion-order.
+     *
+     * @serial
+     */
+    private final boolean accessOrder;
+    
+    private static class Entry<K,V> extends HashMap.Entry<K,V> {
+        // These fields comprise the doubly linked list used for iteration.
+        Entry<K,V> before, after;
+
+        Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
+            super(hash, key, value, next);
+        }
+    }  
+```
+
+其中 `Entry` 继承于 `HashMap` 的 `Entry`，并新增了上下节点的指针，也就形成了双向链表。
+
+还有一个 `header` 的成员变量，是这个双向链表的头结点。 
+
+上边的 demo 总结成一张图如下：
+
+![](https://ws1.sinaimg.cn/large/006tKfTcgy1fodggwc523j30za0n4wgj.jpg)
+
+第一个类似于 `HashMap` 的结构，利用 `Entry` 中的 `next` 指针进行关联。
+
+下边则是 `LinkedHashMap` 如何达到有序的关键。
+
+就是利用了头节点和其余的各个节点之间通过 `Entry` 中的 `after` 和 `before` 指针进行关联。
+
+
+其中还有一个 `accessOrder` 成员变量，默认是 `false`，默认按照插入顺序排序，为 `true` 时按照访问顺序排序，也可以调用:
+
+```
+    public LinkedHashMap(int initialCapacity,
+                         float loadFactor,
+                         boolean accessOrder) {
+        super(initialCapacity, loadFactor);
+        this.accessOrder = accessOrder;
+    }
+```
+
+这个构造方法可以显示的传入 `accessOrder `。
+
+
+## 构造方法
+
+`LinkedHashMap` 的构造方法:
+
+```java
+    public LinkedHashMap() {
+        super();
+        accessOrder = false;
+    }
+```
+
+其实就是调用的 `HashMap` 的构造方法:
+
+`HashMap` 实现：
+
+```java
+    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;
+        threshold = initialCapacity;
+        //HashMap 只是定义了改方法，具体实现交给了 LinkedHashMap
+        init();
+    }
+```
+
+可以看到里面有一个空的 `init()`，具体是由 `LinkedHashMap` 来实现的：
+
+```java
+    @Override
+    void init() {
+        header = new Entry<>(-1, null, null, null);
+        header.before = header.after = header;
+    }
+```
+其实也就是对 `header` 进行了初始化。
+
+## put() 方法
+
+看 `LinkedHashMap` 的 `put()` 方法之前先看看 `HashMap` 的 `put` 方法：
+
+```
+    public V put(K key, V value) {
+        if (table == EMPTY_TABLE) {
+            inflateTable(threshold);
+        }
+        if (key == null)
+            return putForNullKey(value);
+        int hash = hash(key);
+        int i = indexFor(hash, table.length);
+        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
+            Object k;
+            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
+                V oldValue = e.value;
+                e.value = value;
+                //空实现，交给 LinkedHashMap 自己实现
+                e.recordAccess(this);
+                return oldValue;
+            }
+        }
+
+        modCount++;
+        // LinkedHashMap 对其重写
+        addEntry(hash, key, value, i);
+        return null;
+    }
+    
+    // LinkedHashMap 对其重写
+    void addEntry(int hash, K key, V value, int bucketIndex) {
+        if ((size >= threshold) && (null != table[bucketIndex])) {
+            resize(2 * table.length);
+            hash = (null != key) ? hash(key) : 0;
+            bucketIndex = indexFor(hash, table.length);
+        }
+
+        createEntry(hash, key, value, bucketIndex);
+    }
+    
+    // LinkedHashMap 对其重写
+    void createEntry(int hash, K key, V value, int bucketIndex) {
+        Entry<K,V> e = table[bucketIndex];
+        table[bucketIndex] = new Entry<>(hash, key, value, e);
+        size++;
+    }       
+```
+
+主体的实现都是借助于 `HashMap` 来完成的，只是对其中的 `recordAccess(), addEntry(), createEntry()` 进行了重写。
+
+`LinkedHashMap` 的实现：
+
+```java
+        //就是判断是否是根据访问顺序排序，如果是则需要将当前这个 Entry 移动到链表的末尾
+        void recordAccess(HashMap<K,V> m) {
+            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
+            if (lm.accessOrder) {
+                lm.modCount++;
+                remove();
+                addBefore(lm.header);
+            }
+        }
+        
+        
+    //调用了 HashMap 的实现，并判断是否需要删除最少使用的 Entry(默认不删除)    
+    void addEntry(int hash, K key, V value, int bucketIndex) {
+        super.addEntry(hash, key, value, bucketIndex);
+
+        // Remove eldest entry if instructed
+        Entry<K,V> eldest = header.after;
+        if (removeEldestEntry(eldest)) {
+            removeEntryForKey(eldest.key);
+        }
+    }
+    
+    void createEntry(int hash, K key, V value, int bucketIndex) {
+        HashMap.Entry<K,V> old = table[bucketIndex];
+        Entry<K,V> e = new Entry<>(hash, key, value, old);
+        //就多了这一步，将新增的 Entry 加入到 header 双向链表中
+        table[bucketIndex] = e;
+        e.addBefore(header);
+        size++;
+    }
+    
+        //写入到双向链表中
+        private void addBefore(Entry<K,V> existingEntry) {
+            after  = existingEntry;
+            before = existingEntry.before;
+            before.after = this;
+            after.before = this;
+        }  
+        
+```
+
+## get 方法
+
+LinkedHashMap 的 `get()` 方法也重写了：
+
+```java
+    public V get(Object key) {
+        Entry<K,V> e = (Entry<K,V>)getEntry(key);
+        if (e == null)
+            return null;
+            
+        //多了一个判断是否是按照访问顺序排序，是则将当前的 Entry 移动到链表头部。   
+        e.recordAccess(this);
+        return e.value;
+    }
+    
+    void recordAccess(HashMap<K,V> m) {
+        LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
+        if (lm.accessOrder) {
+            lm.modCount++;
+            
+            //删除
+            remove();
+            //添加到头部
+            addBefore(lm.header);
+        }
+    }
+    
+    
+```
+
+`clear()` 清空就要比较简单了：
+
+```java
+    //只需要把指针都指向自己即可，原本那些 Entry 没有引用之后就会被 JVM 自动回收。
+    public void clear() {
+        super.clear();
+        header.before = header.after = header;
+    }
+```
+
+
+## 总结
+
+总的来说 `LinkedHashMap` 其实就是对 `HashMap` 进行了拓展，使用了双向链表来保证了顺序性。
+
+因为是继承与 `HashMap` 的，所以一些 `HashMap` 存在的问题 `LinkedHashMap` 也会存在，比如不支持并发等。
+
+
diff --git a/Java-Interview/MD/concurrent/thread-communication.md b/Java-Interview/MD/concurrent/thread-communication.md
new file mode 100644
index 0000000..7570702
--- /dev/null
+++ b/Java-Interview/MD/concurrent/thread-communication.md
@@ -0,0 +1,588 @@
+# 深入理解线程通信
+
+## 前言
+
+开发中不免会遇到需要所有子线程执行完毕通知主线程处理某些逻辑的场景。
+
+或者是线程 A 在执行到某个条件通知线程 B 执行某个操作。
+
+可以通过以下几种方式实现：
+
+
+## 等待通知机制
+> 等待通知模式是 Java 中比较经典的线程通信方式。
+
+两个线程通过对同一对象调用等待 wait() 和通知 notify() 方法来进行通讯。
+
+如两个线程交替打印奇偶数：
+
+```java
+public class TwoThreadWaitNotify {
+
+    private int start = 1;
+
+    private boolean flag = false;
+
+    public static void main(String[] args) {
+        TwoThreadWaitNotify twoThread = new TwoThreadWaitNotify();
+
+        Thread t1 = new Thread(new OuNum(twoThread));
+        t1.setName("A");
+
+
+        Thread t2 = new Thread(new JiNum(twoThread));
+        t2.setName("B");
+
+        t1.start();
+        t2.start();
+    }
+
+    /**
+     * 偶数线程
+     */
+    public static class OuNum implements Runnable {
+        private TwoThreadWaitNotify number;
+
+        public OuNum(TwoThreadWaitNotify number) {
+            this.number = number;
+        }
+
+        @Override
+        public void run() {
+
+            while (number.start <= 100) {
+                synchronized (TwoThreadWaitNotify.class) {
+                    System.out.println("偶数线程抢到锁了");
+                    if (number.flag) {
+                        System.out.println(Thread.currentThread().getName() + "+-+偶数" + number.start);
+                        number.start++;
+
+                        number.flag = false;
+                        TwoThreadWaitNotify.class.notify();
+
+                    }else {
+                        try {
+                            TwoThreadWaitNotify.class.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+
+            }
+        }
+    }
+
+
+    /**
+     * 奇数线程
+     */
+    public static class JiNum implements Runnable {
+        private TwoThreadWaitNotify number;
+
+        public JiNum(TwoThreadWaitNotify number) {
+            this.number = number;
+        }
+
+        @Override
+        public void run() {
+            while (number.start <= 100) {
+                synchronized (TwoThreadWaitNotify.class) {
+                    System.out.println("奇数线程抢到锁了");
+                    if (!number.flag) {
+                        System.out.println(Thread.currentThread().getName() + "+-+奇数" + number.start);
+                        number.start++;
+
+                        number.flag = true;
+
+                        TwoThreadWaitNotify.class.notify();
+                    }else {
+                        try {
+                            TwoThreadWaitNotify.class.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+```
+
+输出结果：
+
+```
+t2+-+奇数93
+t1+-+偶数94
+t2+-+奇数95
+t1+-+偶数96
+t2+-+奇数97
+t1+-+偶数98
+t2+-+奇数99
+t1+-+偶数100
+```
+
+这里的线程 A 和线程 B 都对同一个对象 `TwoThreadWaitNotify.class` 获取锁，A 线程调用了同步对象的 wait() 方法释放了锁并进入 `WAITING` 状态。
+
+B 线程调用了 notify() 方法，这样 A 线程收到通知之后就可以从 wait() 方法中返回。
+
+这里利用了 `TwoThreadWaitNotify.class` 对象完成了通信。
+
+有一些需要注意:
+
+- wait() 、nofify() 、nofityAll() 调用的前提都是获得了对象的锁(也可称为对象监视器)。
+- 调用 wait() 方法后线程会释放锁，进入 `WAITING` 状态，该线程也会被移动到**等待队列**中。
+- 调用 notify() 方法会将**等待队列**中的线程移动到**同步队列**中，线程状态也会更新为 `BLOCKED`
+- 从 wait() 方法返回的前提是调用 notify() 方法的线程释放锁，wait() 方法的线程获得锁。
+
+等待通知有着一个经典范式：
+
+线程 A 作为消费者：
+
+1. 获取对象的锁。
+2. 进入 while(判断条件)，并调用 wait() 方法。
+3. 当条件满足跳出循环执行具体处理逻辑。
+
+线程 B 作为生产者:
+
+1. 获取对象锁。
+2. 更改与线程 A 共用的判断条件。
+3. 调用 notify() 方法。
+
+伪代码如下:
+
+```
+//Thread A
+
+synchronized(Object){
+    while(条件){
+        Object.wait();
+    }
+    //do something
+}
+
+//Thread B
+synchronized(Object){
+    条件=false;//改变条件
+    Object.notify();
+}
+
+```
+
+
+## join() 方法
+
+```java
+    private static void join() throws InterruptedException {
+        Thread t1 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running");
+                try {
+                    Thread.sleep(3000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }) ;
+        Thread t2 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running2");
+                try {
+                    Thread.sleep(4000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }) ;
+
+        t1.start();
+        t2.start();
+
+        //等待线程1终止
+        t1.join();
+
+        //等待线程2终止
+        t2.join();
+
+        LOGGER.info("main over");
+    }
+```
+
+输出结果:
+
+```
+2018-03-16 20:21:30.967 [Thread-1] INFO  c.c.actual.ThreadCommunication - running2
+2018-03-16 20:21:30.967 [Thread-0] INFO  c.c.actual.ThreadCommunication - running
+2018-03-16 20:21:34.972 [main] INFO  c.c.actual.ThreadCommunication - main over
+
+```
+
+在  `t1.join()` 时会一直阻塞到 t1 执行完毕，所以最终主线程会等待 t1 和 t2 线程执行完毕。
+
+其实从源码可以看出，join() 也是利用的等待通知机制：
+
+核心逻辑:
+
+```java
+    while (isAlive()) {
+        wait(0);
+    }
+```
+
+在 join 线程完成后会调用 notifyAll() 方法，是在 JVM 实现中调用，所以这里看不出来。
+
+## volatile 共享内存
+
+因为 Java 是采用共享内存的方式进行线程通信的，所以可以采用以下方式用主线程关闭 A 线程:
+
+```java
+public class Volatile implements Runnable{
+
+    private static volatile boolean flag = true ;
+
+    @Override
+    public void run() {
+        while (flag){
+            System.out.println(Thread.currentThread().getName() + "正在运行。。。");
+        }
+        System.out.println(Thread.currentThread().getName() +"执行完毕");
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        Volatile aVolatile = new Volatile();
+        new Thread(aVolatile,"thread A").start();
+
+
+        System.out.println("main 线程正在运行") ;
+
+        TimeUnit.MILLISECONDS.sleep(100) ;
+
+        aVolatile.stopThread();
+
+    }
+
+    private void stopThread(){
+        flag = false ;
+    }
+}
+```
+
+输出结果：
+```
+thread A正在运行。。。
+thread A正在运行。。。
+thread A正在运行。。。
+thread A正在运行。。。
+thread A执行完毕
+```
+
+这里的 flag 存放于主内存中，所以主线程和线程 A 都可以看到。
+
+flag 采用 volatile 修饰主要是为了内存可见性，更多内容可以查看[这里](http://crossoverjie.top/2018/03/09/volatile/)。
+
+
+## CountDownLatch 并发工具
+
+CountDownLatch 可以实现 join 相同的功能，但是更加的灵活。
+
+```java
+    private static void countDownLatch() throws Exception{
+        int thread = 3 ;
+        long start = System.currentTimeMillis();
+        final CountDownLatch countDown = new CountDownLatch(thread);
+        for (int i= 0 ;i<thread ; i++){
+            new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    LOGGER.info("thread run");
+                    try {
+                        Thread.sleep(2000);
+                        countDown.countDown();
+
+                        LOGGER.info("thread end");
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }).start();
+        }
+
+        countDown.await();
+        long stop = System.currentTimeMillis();
+        LOGGER.info("main over total time={}",stop-start);
+    }
+```
+
+输出结果:
+
+```
+2018-03-16 20:19:44.126 [Thread-0] INFO  c.c.actual.ThreadCommunication - thread run
+2018-03-16 20:19:44.126 [Thread-2] INFO  c.c.actual.ThreadCommunication - thread run
+2018-03-16 20:19:44.126 [Thread-1] INFO  c.c.actual.ThreadCommunication - thread run
+2018-03-16 20:19:46.136 [Thread-2] INFO  c.c.actual.ThreadCommunication - thread end
+2018-03-16 20:19:46.136 [Thread-1] INFO  c.c.actual.ThreadCommunication - thread end
+2018-03-16 20:19:46.136 [Thread-0] INFO  c.c.actual.ThreadCommunication - thread end
+2018-03-16 20:19:46.136 [main] INFO  c.c.actual.ThreadCommunication - main over total time=2012
+```
+
+CountDownLatch 也是基于 AQS(AbstractQueuedSynchronizer) 实现的，更多实现参考 [ReentrantLock 实现原理](http://crossoverjie.top/2018/01/25/ReentrantLock/)
+
+- 初始化一个 CountDownLatch 时告诉并发的线程，然后在每个线程处理完毕之后调用 countDown() 方法。
+- 该方法会将 AQS 内置的一个 state 状态 -1 。
+- 最终在主线程调用 await() 方法，它会阻塞直到 `state == 0` 的时候返回。
+
+## CyclicBarrier 并发工具
+
+```java
+    private static void cyclicBarrier() throws Exception {
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(3) ;
+
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("thread run");
+                try {
+                    cyclicBarrier.await() ;
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+
+                LOGGER.info("thread end do something");
+            }
+        }).start();
+
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("thread run");
+                try {
+                    cyclicBarrier.await() ;
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+
+                LOGGER.info("thread end do something");
+            }
+        }).start();
+
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("thread run");
+                try {
+                    Thread.sleep(5000);
+                    cyclicBarrier.await() ;
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+
+                LOGGER.info("thread end do something");
+            }
+        }).start();
+
+        LOGGER.info("main thread");
+    }
+```
+
+CyclicBarrier 中文名叫做屏障或者是栅栏，也可以用于线程间通信。
+
+它可以等待 N 个线程都达到某个状态后继续运行的效果。
+
+1. 首先初始化线程参与者。
+2. 调用 `await()` 将会在所有参与者线程都调用之前等待。
+3. 直到所有参与者都调用了 `await()` 后，所有线程从 `await()` 返回继续后续逻辑。
+
+运行结果:
+
+```
+2018-03-18 22:40:00.731 [Thread-0] INFO  c.c.actual.ThreadCommunication - thread run
+2018-03-18 22:40:00.731 [Thread-1] INFO  c.c.actual.ThreadCommunication - thread run
+2018-03-18 22:40:00.731 [Thread-2] INFO  c.c.actual.ThreadCommunication - thread run
+2018-03-18 22:40:00.731 [main] INFO  c.c.actual.ThreadCommunication - main thread
+2018-03-18 22:40:05.741 [Thread-0] INFO  c.c.actual.ThreadCommunication - thread end do something
+2018-03-18 22:40:05.741 [Thread-1] INFO  c.c.actual.ThreadCommunication - thread end do something
+2018-03-18 22:40:05.741 [Thread-2] INFO  c.c.actual.ThreadCommunication - thread end do something
+```
+
+可以看出由于其中一个线程休眠了五秒，所有其余所有的线程都得等待这个线程调用 `await()` 。
+
+该工具可以实现 CountDownLatch 同样的功能，但是要更加灵活。甚至可以调用 `reset()` 方法重置 CyclicBarrier (需要自行捕获 BrokenBarrierException 处理) 然后重新执行。
+
+## 线程响应中断
+
+```java
+public class StopThread implements Runnable {
+    @Override
+    public void run() {
+
+        while ( !Thread.currentThread().isInterrupted()) {
+            // 线程执行具体逻辑
+            System.out.println(Thread.currentThread().getName() + "运行中。。");
+        }
+
+        System.out.println(Thread.currentThread().getName() + "退出。。");
+
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        Thread thread = new Thread(new StopThread(), "thread A");
+        thread.start();
+
+        System.out.println("main 线程正在运行") ;
+
+        TimeUnit.MILLISECONDS.sleep(10) ;
+        thread.interrupt();
+    }
+
+
+}
+```
+
+输出结果:
+
+```
+thread A运行中。。
+thread A运行中。。
+thread A退出。。
+```
+
+可以采用中断线程的方式来通信，调用了 `thread.interrupt()` 方法其实就是将 thread 中的一个标志属性置为了 true。
+
+并不是说调用了该方法就可以中断线程，如果不对这个标志进行响应其实是没有什么作用(这里对这个标志进行了判断)。
+
+**但是如果抛出了 InterruptedException 异常，该标志就会被 JVM 重置为 false。**
+
+## 线程池 awaitTermination() 方法
+
+如果是用线程池来管理线程，可以使用以下方式来让主线程等待线程池中所有任务执行完毕:
+
+```java
+    private static void executorService() throws Exception{
+        BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(10) ;
+        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5,5,1, TimeUnit.MILLISECONDS,queue) ;
+        poolExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running");
+                try {
+                    Thread.sleep(3000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+        poolExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running2");
+                try {
+                    Thread.sleep(2000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+
+        poolExecutor.shutdown();
+        while (!poolExecutor.awaitTermination(1,TimeUnit.SECONDS)){
+            LOGGER.info("线程还在执行。。。");
+        }
+        LOGGER.info("main over");
+    }
+```
+
+输出结果:
+
+```
+2018-03-16 20:18:01.273 [pool-1-thread-2] INFO  c.c.actual.ThreadCommunication - running2
+2018-03-16 20:18:01.273 [pool-1-thread-1] INFO  c.c.actual.ThreadCommunication - running
+2018-03-16 20:18:02.273 [main] INFO  c.c.actual.ThreadCommunication - 线程还在执行。。。
+2018-03-16 20:18:03.278 [main] INFO  c.c.actual.ThreadCommunication - 线程还在执行。。。
+2018-03-16 20:18:04.278 [main] INFO  c.c.actual.ThreadCommunication - main over
+```
+
+使用这个 `awaitTermination()` 方法的前提需要关闭线程池，如调用了 `shutdown()` 方法。
+
+调用了 `shutdown()` 之后线程池会停止接受新任务，并且会平滑的关闭线程池中现有的任务。
+
+
+## 管道通信
+
+```java
+    public static void piped() throws IOException {
+        //面向于字符 PipedInputStream 面向于字节
+        PipedWriter writer = new PipedWriter();
+        PipedReader reader = new PipedReader();
+
+        //输入输出流建立连接
+        writer.connect(reader);
+
+
+        Thread t1 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running");
+                try {
+                    for (int i = 0; i < 10; i++) {
+
+                        writer.write(i+"");
+                        Thread.sleep(10);
+                    }
+                } catch (Exception e) {
+
+                } finally {
+                    try {
+                        writer.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+
+            }
+        });
+        Thread t2 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running2");
+                int msg = 0;
+                try {
+                    while ((msg = reader.read()) != -1) {
+                        LOGGER.info("msg={}", (char) msg);
+                    }
+
+                } catch (Exception e) {
+
+                }
+            }
+        });
+        t1.start();
+        t2.start();
+    }
+```
+
+输出结果:
+
+```
+2018-03-16 19:56:43.014 [Thread-0] INFO  c.c.actual.ThreadCommunication - running
+2018-03-16 19:56:43.014 [Thread-1] INFO  c.c.actual.ThreadCommunication - running2
+2018-03-16 19:56:43.130 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=0
+2018-03-16 19:56:43.132 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=1
+2018-03-16 19:56:43.132 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=2
+2018-03-16 19:56:43.133 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=3
+2018-03-16 19:56:43.133 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=4
+2018-03-16 19:56:43.133 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=5
+2018-03-16 19:56:43.133 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=6
+2018-03-16 19:56:43.134 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=7
+2018-03-16 19:56:43.134 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=8
+2018-03-16 19:56:43.134 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=9
+```
+
+Java 虽说是基于内存通信的，但也可以使用管道通信。
+
+需要注意的是，输入流和输出流需要首先建立连接。这样线程 B 就可以收到线程 A 发出的消息了。
+
+
+实际开发中可以灵活根据需求选择最适合的线程通信方式。
\ No newline at end of file
diff --git a/Java-Interview/MD/concurrent/volatile.md b/Java-Interview/MD/concurrent/volatile.md
new file mode 100644
index 0000000..e133719
--- /dev/null
+++ b/Java-Interview/MD/concurrent/volatile.md
@@ -0,0 +1,218 @@
+# 你应该知道的 volatile 关键字
+
+## 前言
+
+不管是在面试还是实际开发中 `volatile` 都是一个应该掌握的技能。
+
+首先来看看为什么会出现这个关键字。
+
+## 内存可见性
+由于 `Java` 内存模型(`JMM`)规定，所有的变量都存放在主内存中，而每个线程都有着自己的工作内存(高速缓存)。
+
+线程在工作时，需要将主内存中的数据拷贝到工作内存中。这样对数据的任何操作都是基于工作内存(效率提高)，并且不能直接操作主内存以及其他线程工作内存中的数据，之后再将更新之后的数据刷新到主内存中。
+
+> 这里所提到的主内存可以简单认为是**堆内存**，而工作内存则可以认为是**栈内存**。
+
+如下图所示：
+
+![](https://ws2.sinaimg.cn/large/006tKfTcly1fmouu3fpokj31ae0osjt1.jpg)
+
+所以在并发运行时可能会出现线程 B 所读取到的数据是线程 A 更新之前的数据。
+
+显然这肯定是会出问题的，因此 `volatile` 的作用出现了：
+
+> 当一个变量被 `volatile` 修饰时，任何线程对它的写操作都会立即刷新到主内存中，并且会强制让缓存了该变量的线程中的数据清空，必须从主内存重新读取最新数据。
+
+*`volatile` 修饰之后并不是让线程直接从主内存中获取数据，依然需要将变量拷贝到工作内存中*。
+
+### 内存可见性的应用 
+
+当我们需要在两个线程间依据主内存通信时，通信的那个变量就必须的用 `volatile` 来修饰：
+
+```java
+public class Volatile implements Runnable{
+
+    private static volatile boolean flag = true ;
+
+    @Override
+    public void run() {
+        while (flag){
+        }
+        System.out.println(Thread.currentThread().getName() +"执行完毕");
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        Volatile aVolatile = new Volatile();
+        new Thread(aVolatile,"thread A").start();
+
+
+        System.out.println("main 线程正在运行") ;
+
+        Scanner sc = new Scanner(System.in);
+        while(sc.hasNext()){
+            String value = sc.next();
+            if(value.equals("1")){
+
+                new Thread(new Runnable() {
+                    @Override
+                    public void run() {
+                        aVolatile.stopThread();
+                    }
+                }).start();
+
+                break ;
+            }
+        }
+
+        System.out.println("主线程退出了！");
+
+    }
+
+    private void stopThread(){
+        flag = false ;
+    }
+
+}
+```
+
+主线程在修改了标志位使得线程 A 立即停止，如果没有用 `volatile` 修饰，就有可能出现延迟。
+
+但这里有个误区，这样的使用方式容易给人的感觉是：
+
+> 对 `volatile` 修饰的变量进行并发操作是线程安全的。
+
+这里要重点强调，`volatile` 并**不能**保证线程安全性！
+
+如下程序:
+
+```java
+public class VolatileInc implements Runnable{
+
+    private static volatile int count = 0 ; //使用 volatile 修饰基本数据内存不能保证原子性
+
+    //private static AtomicInteger count = new AtomicInteger() ;
+
+    @Override
+    public void run() {
+        for (int i=0;i<10000 ;i++){
+            count ++ ;
+            //count.incrementAndGet() ;
+        }
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        VolatileInc volatileInc = new VolatileInc() ;
+        Thread t1 = new Thread(volatileInc,"t1") ;
+        Thread t2 = new Thread(volatileInc,"t2") ;
+        t1.start();
+        //t1.join();
+
+        t2.start();
+        //t2.join();
+        for (int i=0;i<10000 ;i++){
+            count ++ ;
+            //count.incrementAndGet();
+        }
+
+
+        System.out.println("最终Count="+count);
+    }
+}
+```
+
+当我们三个线程(t1,t2,main)同时对一个 `int` 进行累加时会发现最终的值都会小于 30000。
+
+> 这是因为虽然 `volatile` 保证了内存可见性，每个线程拿到的值都是最新值，但 `count ++` 这个操作并不是原子的，这里面涉及到获取值、自增、赋值的操作并不能同时完成。
+> 
+
+- 所以想到达到线程安全可以使这三个线程串行执行(其实就是单线程，没有发挥多线程的优势)。
+
+- 也可以使用 `synchronize` 或者是锁的方式来保证原子性。
+ 
+- 还可以用 `Atomic` 包中 `AtomicInteger` 来替换 `int`，它利用了 `CAS` 算法来保证了原子性。
+
+
+## 指令重排
+
+内存可见性只是 `volatile` 的其中一个语义，它还可以防止 `JVM` 进行指令重排优化。
+
+举一个伪代码:
+
+```java
+int a=10 ;//1
+int b=20 ;//2
+int c= a+b ;//3
+```
+
+一段特别简单的代码，理想情况下它的执行顺序是：`1>2>3`。但有可能经过 JVM 优化之后的执行顺序变为了 `2>1>3`。
+
+可以发现不管 JVM 怎么优化，前提都是保证单线程中最终结果不变的情况下进行的。
+
+可能这里还看不出有什么问题，那看下一段伪代码:
+
+```java
+private static Map<String,String> value ;
+private static volatile boolean flag = fasle ;
+
+//以下方法发生在线程 A 中 初始化 Map
+public void initMap(){
+	//耗时操作
+	value = getMapValue() ;//1
+	flag = true ;//2
+}
+
+
+//发生在线程 B中 等到 Map 初始化成功进行其他操作
+public void doSomeThing(){
+	while(!flag){
+		sleep() ;
+	}
+	//dosomething
+	doSomeThing(value);
+}
+
+```
+
+这里就能看出问题了，当 `flag` 没有被 `volatile` 修饰时，`JVM` 对 1 和 2 进行重排，导致 `value` 都还没有被初始化就有可能被线程 B 使用了。
+
+所以加上 `volatile` 之后可以防止这样的重排优化，保证业务的正确性。
+### 指令重排的的应用
+
+一个经典的使用场景就是双重懒加载的单例模式了:
+
+```java
+public class Singleton {
+
+    private static volatile Singleton singleton;
+
+    private Singleton() {
+    }
+
+    public static Singleton getInstance() {
+        if (singleton == null) {
+            synchronized (Singleton.class) {
+                if (singleton == null) {
+                    //防止指令重排
+                    singleton = new Singleton();
+                }
+            }
+        }
+        return singleton;
+    }
+}
+```
+
+这里的 `volatile` 关键字主要是为了防止指令重排。 
+
+如果不用 ，`singleton = new Singleton();`，这段代码其实是分为三步：
+- 分配内存空间。(1)
+- 初始化对象。(2)
+- 将 `singleton` 对象指向分配的内存地址。(3)
+
+加上 `volatile` 是为了让以上的三步操作顺序执行，反之有可能第二步在第三步之前被执行就有可能某个线程拿到的单例对象是还没有初始化的，以致于报错。
+
+## 总结
+
+`volatile` 在 `Java` 并发中用的很多，比如像 `Atomic` 包中的 `value`、以及 `AbstractQueuedLongSynchronizer` 中的 `state` 都是被定义为 `volatile` 来用于保证内存可见性。
+
+将这块理解透彻对我们编写并发程序时可以提供很大帮助。
\ No newline at end of file
diff --git a/Java-Interview/MD/newObject.md b/Java-Interview/MD/newObject.md
new file mode 100644
index 0000000..6c091b4
--- /dev/null
+++ b/Java-Interview/MD/newObject.md
@@ -0,0 +1,77 @@
+# 对象的创建与内存分配
+
+
+## 创建对象
+
+当 `JVM` 收到一个 `new` 指令时，会检查指令中的参数在常量池是否有这个符号的引用，还会检查该类是否已经被[加载](https://github.com/crossoverJie/Java-Interview/blob/master/MD/ClassLoad.md)过了，如果没有的话则要进行一次类加载。
+
+接着就是分配内存了，通常有两种方式：
+
+- 指针碰撞
+- 空闲列表
+
+使用指针碰撞的前提是堆内存是**完全工整**的，用过的内存和没用的内存各在一边每次分配的时候只需要将指针向空闲内存一方移动一段和内存大小相等区域即可。
+
+当堆中已经使用的内存和未使用的内存**互相交错**时，指针碰撞的方式就行不通了，这时就需要采用空闲列表的方式。虚拟机会维护一个空闲的列表，用于记录哪些内存是可以进行分配的，分配时直接从可用内存中直接分配即可。
+
+堆中的内存是否工整是有**垃圾收集器**来决定的，如果带有压缩功能的垃圾收集器就是采用指针碰撞的方式来进行内存分配的。
+
+分配内存时也会出现并发问题:
+
+这样可以在创建对象的时候使用 `CAS` 这样的乐观锁来保证。
+
+也可以将内存分配安排在每个线程独有的空间进行，每个线程首先在堆内存中分配一小块内存，称为本地分配缓存(`TLAB : Thread Local Allocation Buffer`)。
+
+分配内存时，只需要在自己的分配缓存中分配即可，由于这个内存区域是线程私有的，所以不会出现并发问题。
+
+可以使用 `-XX:+/-UseTLAB` 参数来设定 `JVM` 是否开启 `TLAB` 。
+
+内存分配之后需要对该对象进行设置，如对象头。对象头的一些应用可以查看 [Synchronize 关键字原理](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Synchronize.md)。
+
+### 对象访问
+
+一个对象被创建之后自然是为了使用，在 `Java` 中是通过栈来引用堆内存中的对象来进行操作的。
+
+对于我们常用的 `HotSpot` 虚拟机来说，这样引用关系是通过直接指针来关联的。
+
+如图:
+
+![](https://ws2.sinaimg.cn/large/006tKfTcly1fnkmy0bvu3j30o60heaaq.jpg)
+
+这样的好处就是：在 Java 里进行频繁的对象访问可以提升访问速度(相对于使用句柄池来说)。
+
+## 内存分配
+
+
+### Eden 区分配
+简单的来说对象都是在堆内存中分配的，往细一点看则是优先在 `Eden` 区分配。
+
+这里就涉及到堆内存的划分了，为了方便垃圾回收，JVM 将堆内存分为新生代和老年代。
+
+而新生代中又会划分为 `Eden` 区，`from Survivor、to Survivor` 区。
+
+其中 `Eden` 和 `Survivor` 区的比例默认是 `8:1:1`，当然也支持参数调整 `-XX:SurvivorRatio=8`。
+
+当在 `Eden` 区分配内存不足时，则会发生 `minorGC` ，由于 `Java` 对象多数是**朝生夕灭**的特性，所以 `minorGC` 通常会比较频繁，效率也比较高。
+
+当发生 `minorGC` 时，JVM 会根据[复制算法](https://github.com/crossoverJie/Java-Interview/blob/master/MD/GarbageCollection.md#%E5%A4%8D%E5%88%B6%E7%AE%97%E6%B3%95)将存活的对象拷贝到另一个未使用的 `Survivor` 区，如果 `Survivor` 区内存不足时，则会使用分配担保策略将对象移动到老年代中。
+
+谈到 `minorGC` 时，就不得不提到 `fullGC(majorGC)` ，这是指发生在老年代的 `GC` ，不论是效率还是速度都比 `minorGC` 慢的多，回收时还会发生 `stop the world` 使程序发生停顿，所以应当尽量避免发生 `fullGC` 。
+
+### 老年代分配
+
+也有一些情况会导致对象直接在老年代分配，比如当分配一个大对象时(大的数组，很长的字符串)，由于 `Eden` 区没有足够大的连续空间来分配时，会导致提前触发一次 `GC`，所以尽量别频繁的创建大对象。
+
+因此 `JVM` 会根据一个阈值来判断大于该阈值对象直接分配到老年代，这样可以避免在新生代频繁的发生 `GC`。
+
+
+对于一些在新生代的老对象 `JVM` 也会根据某种机制移动到老年代中。
+
+JVM 是根据记录对象年龄的方式来判断该对象是否应该移动到老年代，根据新生代的复制算法，当一个对象被移动到 `Survivor` 区之后 JVM 就给该对象的年龄记为1，每当熬过一次 `minorGC` 后对象的年龄就 +1 ，直到达到阈值(默认为15)就移动到老年代中。
+
+> 可以使用 `-XX:MaxTenuringThreshold=15` 来配置这个阈值。
+
+
+## 总结 
+
+虽说这些内容略显枯燥，但当应用发生不正常的 `GC` 时，可以方便更快的定位问题。
\ No newline at end of file
diff --git a/Java-Interview/MD/spring/spring-bean-lifecycle.md b/Java-Interview/MD/spring/spring-bean-lifecycle.md
new file mode 100644
index 0000000..b969356
--- /dev/null
+++ b/Java-Interview/MD/spring/spring-bean-lifecycle.md
@@ -0,0 +1,181 @@
+## Spring Bean 生命周期
+
+
+### 前言
+
+Spring Bean 的生命周期在整个 Spring 中占有很重要的位置，掌握这些可以加深对 Spring 的理解。
+
+首先看下生命周期图：
+
+![](https://ws3.sinaimg.cn/large/006tNc79gy1fpjsamy6uoj30nt0cqq4i.jpg)
+
+再谈生命周期之前有一点需要先明确：
+
+> Spring 只帮我们管理单例模式 Bean 的**完整**生命周期，对于 prototype 的 bean ，Spring 在创建好交给使用者之后则不会再管理后续的生命周期。
+
+
+### 注解方式
+
+在 bean 初始化时会经历几个阶段，首先可以使用注解 `@PostConstruct`, `@PreDestroy` 来在 bean 的创建和销毁阶段进行调用:
+
+```java
+@Component
+public class AnnotationBean {
+    private final static Logger LOGGER = LoggerFactory.getLogger(AnnotationBean.class);
+
+    @PostConstruct
+    public void start(){
+        LOGGER.info("AnnotationBean start");
+    }
+
+    @PreDestroy
+    public void destroy(){
+        LOGGER.info("AnnotationBean destroy");
+    }
+}
+```
+
+### InitializingBean, DisposableBean 接口
+
+还可以实现 `InitializingBean,DisposableBean` 这两个接口，也是在初始化以及销毁阶段调用：
+
+```java
+@Service
+public class SpringLifeCycleService implements InitializingBean,DisposableBean{
+    private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycleService.class);
+    @Override
+    public void afterPropertiesSet() throws Exception {
+        LOGGER.info("SpringLifeCycleService start");
+    }
+
+    @Override
+    public void destroy() throws Exception {
+        LOGGER.info("SpringLifeCycleService destroy");
+    }
+}
+```
+
+### 自定义初始化和销毁方法
+
+也可以自定义方法用于在初始化、销毁阶段调用:
+
+```java
+@Configuration
+public class LifeCycleConfig {
+
+
+    @Bean(initMethod = "start", destroyMethod = "destroy")
+    public SpringLifeCycle create(){
+        SpringLifeCycle springLifeCycle = new SpringLifeCycle() ;
+
+        return springLifeCycle ;
+    }
+}
+
+public class SpringLifeCycle{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycle.class);
+    public void start(){
+        LOGGER.info("SpringLifeCycle start");
+    }
+
+
+    public void destroy(){
+        LOGGER.info("SpringLifeCycle destroy");
+    }
+}
+```
+
+以上是在 SpringBoot 中可以这样配置，如果是原始的基于 XML 也是可以使用:
+
+```xml
+<bean class="com.crossoverjie.spring.SpringLifeCycle" init-method="start" destroy-method="destroy">
+</bean>
+```
+
+来达到同样的效果。
+
+### 实现 *Aware 接口
+
+`*Aware` 接口可以用于在初始化 bean 时获得 Spring 中的一些对象，如获取 `Spring 上下文`等。
+
+```java
+@Component
+public class SpringLifeCycleAware implements ApplicationContextAware {
+    private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycleAware.class);
+
+    private ApplicationContext applicationContext ;
+
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        this.applicationContext = applicationContext ;
+        LOGGER.info("SpringLifeCycleAware start");
+    }
+}
+```
+
+这样在 `springLifeCycleAware` 这个 bean 初始化会就会调用 `setApplicationContext` 方法，并可以获得 `applicationContext` 对象。
+
+### BeanPostProcessor 增强处理器
+
+实现 BeanPostProcessor 接口，Spring 中所有 bean 在做初始化时都会调用该接口中的两个方法，可以用于对一些特殊的 bean 进行处理：
+
+```java
+@Component
+public class SpringLifeCycleProcessor implements BeanPostProcessor {
+    private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycleProcessor.class);
+
+    /**
+     * 预初始化 初始化之前调用
+     * @param bean
+     * @param beanName
+     * @return
+     * @throws BeansException
+     */
+    @Override
+    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+        if ("annotationBean".equals(beanName)){
+            LOGGER.info("SpringLifeCycleProcessor start beanName={}",beanName);
+        }
+        return bean;
+    }
+
+    /**
+     * 后初始化  bean 初始化完成调用
+     * @param bean
+     * @param beanName
+     * @return
+     * @throws BeansException
+     */
+    @Override
+    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
+        if ("annotationBean".equals(beanName)){
+            LOGGER.info("SpringLifeCycleProcessor end beanName={}",beanName);
+        }
+        return bean;
+    }
+}
+```
+
+执行之后观察结果：
+
+```
+018-03-21 00:40:24.856 [restartedMain] INFO  c.c.s.p.SpringLifeCycleProcessor - SpringLifeCycleProcessor start beanName=annotationBean
+2018-03-21 00:40:24.860 [restartedMain] INFO  c.c.spring.annotation.AnnotationBean - AnnotationBean start
+2018-03-21 00:40:24.861 [restartedMain] INFO  c.c.s.p.SpringLifeCycleProcessor - SpringLifeCycleProcessor end beanName=annotationBean
+2018-03-21 00:40:24.864 [restartedMain] INFO  c.c.s.aware.SpringLifeCycleAware - SpringLifeCycleAware start
+2018-03-21 00:40:24.867 [restartedMain] INFO  c.c.s.service.SpringLifeCycleService - SpringLifeCycleService start
+2018-03-21 00:40:24.887 [restartedMain] INFO  c.c.spring.SpringLifeCycle - SpringLifeCycle start
+2018-03-21 00:40:25.062 [restartedMain] INFO  o.s.b.d.a.OptionalLiveReloadServer - LiveReload server is running on port 35729
+2018-03-21 00:40:25.122 [restartedMain] INFO  o.s.j.e.a.AnnotationMBeanExporter - Registering beans for JMX exposure on startup
+2018-03-21 00:40:25.140 [restartedMain] INFO  com.crossoverjie.Application - Started Application in 2.309 seconds (JVM running for 3.681)
+2018-03-21 00:40:25.143 [restartedMain] INFO  com.crossoverjie.Application - start ok!
+2018-03-21 00:40:25.153 [Thread-8] INFO  o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@3913adad: startup date [Wed Mar 21 00:40:23 CST 2018]; root of context hierarchy
+2018-03-21 00:40:25.155 [Thread-8] INFO  o.s.j.e.a.AnnotationMBeanExporter - Unregistering JMX-exposed beans on shutdown
+2018-03-21 00:40:25.156 [Thread-8] INFO  c.c.spring.SpringLifeCycle - SpringLifeCycle destroy
+2018-03-21 00:40:25.156 [Thread-8] INFO  c.c.s.service.SpringLifeCycleService - SpringLifeCycleService destroy
+2018-03-21 00:40:25.156 [Thread-8] INFO  c.c.spring.annotation.AnnotationBean - AnnotationBean destroy
+```
+
+直到 Spring 上下文销毁时则会调用自定义的销毁方法以及实现了 `DisposableBean` 的 `destroy()` 方法。
+
diff --git a/Java-Interview/README.md b/Java-Interview/README.md
new file mode 100644
index 0000000..56787ca
--- /dev/null
+++ b/Java-Interview/README.md
@@ -0,0 +1,101 @@
+[![Build Status](https://travis-ci.org/crossoverJie/Java-Interview.svg?branch=master)](https://travis-ci.org/crossoverJie/Java-Interview)
+[![QQ群](https://img.shields.io/badge/QQ%E7%BE%A4-787381170-yellowgreen.svg)](https://jq.qq.com/?_wv=1027&k=5HPYvQk)
+
+[qq0groupsvg]: https://img.shields.io/badge/QQ%E7%BE%A4-787381170-yellowgreen.svg
+[qq0group]: https://jq.qq.com/?_wv=1027&k=5HPYvQk
+
+Java 知识点，继续完善中。
+
+> 多数是一些 Java 基础知识、底层原理、算法详解。也有上层应用设计，其中不乏一些大厂面试真题。
+
+
+如果对你有帮助请点下 `Star`，有疑问欢迎提 [Issues](https://github.com/crossoverJie/Java-Interview/issues)，有好的想法请提 [PR](https://github.com/crossoverJie/Java-Interview/pulls)。
+
+
+[常用集合](https://github.com/crossoverJie/Java-Interview/blob/master/README.md#%E5%B8%B8%E7%94%A8%E9%9B%86%E5%90%88) | [Java 多线程](https://github.com/crossoverJie/Java-Interview/blob/master/README.md#java-%E5%A4%9A%E7%BA%BF%E7%A8%8B) | [JVM](https://github.com/crossoverJie/Java-Interview/blob/master/README.md#jvm) | [分布式相关](https://github.com/crossoverJie/Java-Interview/blob/master/README.md#%E5%88%86%E5%B8%83%E5%BC%8F%E7%9B%B8%E5%85%B3) |[常用框架\第三方组件](https://github.com/crossoverJie/Java-Interview/blob/master/README.md#%E5%B8%B8%E7%94%A8%E6%A1%86%E6%9E%B6%E7%AC%AC%E4%B8%89%E6%96%B9%E7%BB%84%E4%BB%B6)|[架构设计](https://github.com/crossoverJie/Java-Interview/blob/master/README.md#%E6%9E%B6%E6%9E%84%E8%AE%BE%E8%AE%A1)|[DB 相关](https://github.com/crossoverJie/Java-Interview/blob/master/README.md#db-%E7%9B%B8%E5%85%B3)|[数据结构与算法](https://github.com/crossoverJie/Java-Interview/blob/master/README.md#%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95)|[Netty 相关](https://github.com/crossoverJie/Java-Interview#netty-%E7%9B%B8%E5%85%B3)|[附加技能](https://github.com/crossoverJie/Java-Interview/blob/master/README.md#%E9%99%84%E5%8A%A0%E6%8A%80%E8%83%BD)|[联系作者](https://github.com/crossoverJie/Java-Interview#%E8%81%94%E7%B3%BB%E4%BD%9C%E8%80%85)
+---- | --- | --- | ---| ---| ---| ---| ---| ---|---|---
+
+
+
+### 常用集合
+- [ArrayList/Vector](https://github.com/crossoverJie/Java-Interview/blob/master/MD/ArrayList.md)
+- [LinkedList](https://github.com/crossoverJie/Java-Interview/blob/master/MD/LinkedList.md)
+- [HashMap](https://github.com/crossoverJie/Java-Interview/blob/master/MD/HashMap.md)
+- [HashSet](https://github.com/crossoverJie/Java-Interview/blob/master/MD/collection/HashSet.md)
+- [LinkedHashMap](https://github.com/crossoverJie/Java-Interview/blob/master/MD/collection/LinkedHashMap.md)
+
+### Java 多线程
+- [多线程中的常见问题](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Thread-common-problem.md)
+- [synchronize 关键字原理](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Synchronize.md)
+- [多线程的三大核心](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Threadcore.md)
+- [对锁的一些认知](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Java-lock.md)
+- [ReentrantLock 实现原理 ](https://github.com/crossoverJie/Java-Interview/blob/master/MD/ReentrantLock.md)
+- [ConcurrentHashMap 的实现原理](https://github.com/crossoverJie/Java-Interview/blob/master/MD/ConcurrentHashMap.md)
+- [线程池原理](https://github.com/crossoverJie/Java-Interview/blob/master/MD/ThreadPoolExecutor.md)
+- [深入理解线程通信](https://github.com/crossoverJie/Java-Interview/blob/master/MD/concurrent/thread-communication.md)
+- [交替打印奇偶数](https://github.com/crossoverJie/Java-Interview/blob/master/src/main/java/com/crossoverjie/actual/TwoThread.java)
+
+### JVM
+- [Java 运行时内存划分](https://github.com/crossoverJie/Java-Interview/blob/master/MD/MemoryAllocation.md)
+-  [类加载机制](https://github.com/crossoverJie/Java-Interview/blob/master/MD/ClassLoad.md)
+-  [OOM 分析](https://github.com/crossoverJie/Java-Interview/blob/master/MD/OOM-analysis.md)
+- [垃圾回收](https://github.com/crossoverJie/Java-Interview/blob/master/MD/GarbageCollection.md)
+- [对象的创建与内存分配](https://github.com/crossoverJie/Java-Interview/blob/master/MD/newObject.md)
+- [你应该知道的 volatile 关键字](https://github.com/crossoverJie/Java-Interview/blob/master/MD/concurrent/volatile.md)
+
+### 分布式相关
+
+- [分布式限流](http://crossoverjie.top/2018/04/28/sbc/sbc7-Distributed-Limit/)
+- [基于 Redis 的分布式锁](http://crossoverjie.top/2018/03/29/distributed-lock/distributed-lock-redis/)
+- [分布式缓存设计](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Cache-design.md)
+- [分布式 ID 生成器](https://github.com/crossoverJie/Java-Interview/blob/master/MD/ID-generator.md)
+
+### 常用框架\第三方组件
+
+- [Spring Bean 生命周期](https://github.com/crossoverJie/Java-Interview/blob/master/MD/spring/spring-bean-lifecycle.md)
+- [Spring AOP 的实现原理](https://github.com/crossoverJie/Java-Interview/blob/master/MD/SpringAOP.md) 
+- [Guava 源码分析（Cache 原理）](https://crossoverjie.top/2018/06/13/guava/guava-cache/)
+- SpringBoot 启动过程
+- Tomcat 类加载机制
+
+
+### 架构设计
+- [秒杀系统设计](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Spike.md)
+- [秒杀架构实践](http://crossoverjie.top/2018/05/07/ssm/SSM18-seconds-kill/)
+
+### DB 相关
+
+- [MySQL 索引原理](https://github.com/crossoverJie/Java-Interview/blob/master/MD/MySQL-Index.md)
+- [SQL 优化](https://github.com/crossoverJie/Java-Interview/blob/master/MD/SQL-optimization.md)
+- [数据库水平垂直拆分](https://github.com/crossoverJie/Java-Interview/blob/master/MD/DB-split.md)
+
+### 数据结构与算法
+- [红包算法](https://github.com/crossoverJie/Java-Interview/blob/master/src/main/java/com/crossoverjie/red/RedPacket.java)
+- [二叉树中序遍历](https://github.com/crossoverJie/Java-Interview/blob/master/src/main/java/com/crossoverjie/algorithm/BinaryNode.java#L76-L101)
+- [是否为快乐数字](https://github.com/crossoverJie/Java-Interview/blob/master/src/main/java/com/crossoverjie/algorithm/HappyNum.java#L38-L55)
+- [链表是否有环](https://github.com/crossoverJie/Java-Interview/blob/master/src/main/java/com/crossoverjie/algorithm/LinkLoop.java#L32-L59)
+- [从一个数组中返回两个值相加等于目标值的下标](https://github.com/crossoverJie/Java-Interview/blob/master/src/main/java/com/crossoverjie/algorithm/TwoSum.java#L38-L59)
+- [一致性 Hash 算法](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Consistent-Hash.md)
+- [限流算法](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Limiting.md)
+- [三种方式反向打印单向链表](https://github.com/crossoverJie/Java-Interview/blob/master/src/main/java/com/crossoverjie/algorithm/ReverseNode.java)
+- [合并两个排好序的链表](https://github.com/crossoverJie/Java-Interview/blob/master/src/main/java/com/crossoverjie/algorithm/MergeTwoSortedLists.java)
+- [两个栈实现队列](https://github.com/crossoverJie/Java-Interview/blob/master/src/main/java/com/crossoverjie/algorithm/TwoStackQueue.java)
+- [动手实现一个 LRU cache](http://crossoverjie.top/2018/04/07/algorithm/LRU-cache/)
+- [链表排序](./src/main/java/com/crossoverjie/algorithm/LinkedListMergeSort.java)
+- [数组右移 k 次](./src/main/java/com/crossoverjie/algorithm/ArrayKShift.java)
+
+### Netty 相关
+- [SpringBoot 整合长连接心跳机制](https://crossoverjie.top/2018/05/24/netty/Netty(1)TCP-Heartbeat/)
+- [从线程模型的角度看 Netty 为什么是高性能的？](https://crossoverjie.top/2018/07/04/netty/Netty(2)Thread-model/)
+
+### 附加技能
+
+- [TCP/IP 协议](https://github.com/crossoverJie/Java-Interview/blob/master/MD/TCP-IP.md)
+- [一个学渣的阿里之路](https://crossoverjie.top/2018/06/21/personal/Interview-experience/)
+
+
+### 联系作者
+
+> crossoverJie#gmail.com
+
+![](https://ws2.sinaimg.cn/large/006tKfTcly1fsa01u7ro1j30gs0howfq.jpg)
\ No newline at end of file
diff --git a/Java-Interview/java_pid26365.hprof b/Java-Interview/java_pid26365.hprof
new file mode 100644
index 0000000..4c16383
Binary files /dev/null and b/Java-Interview/java_pid26365.hprof differ
diff --git a/Java-Interview/pom.xml b/Java-Interview/pom.xml
new file mode 100644
index 0000000..d33d9cd
--- /dev/null
+++ b/Java-Interview/pom.xml
@@ -0,0 +1,119 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.crossoverjie.interview</groupId>
+    <artifactId>Java-Interview</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>1.5.6.RELEASE</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
+
+    <properties>
+        <!-- 文件拷贝时的编码 -->
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <!-- 编译时的编码 -->
+        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
+        <dubbo.version>2.5.3</dubbo.version>
+        <jdk.version>1.8</jdk.version>
+        <spring.version>4.3.10.RELEASE</spring.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <springboot.version>1.5.6.RELEASE</springboot.version>
+        <logback.version>1.2.3</logback.version>
+    </properties>
+
+
+    <dependencies>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-configuration-processor</artifactId>
+            <version>${springboot.version}</version>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+            <version>${springboot.version}</version>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-aop</artifactId>
+            <version>${springboot.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <version>${springboot.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.8.2</version>
+            <scope>test</scope>
+        </dependency>
+
+        <!--cglib-->
+        <dependency>
+            <groupId>cglib</groupId>
+            <artifactId>cglib</artifactId>
+            <version>3.2.5</version>
+        </dependency>
+
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>1.2.17</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.4</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>19.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+            <version>1.1.40</version>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>2.3.2</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                    <encoding>${project.build.sourceEncoding}</encoding>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>
\ No newline at end of file
diff --git a/Java-Interview/src/main/java/com/crossoverjie/Application.java b/Java-Interview/src/main/java/com/crossoverjie/Application.java
new file mode 100644
index 0000000..e0c3e3b
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/Application.java
@@ -0,0 +1,24 @@
+package com.crossoverjie;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * @author crossoverJie
+ *
+ */
+@SpringBootApplication
+public class Application {
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(Application.class);
+
+
+    public static void main(String[] args) throws Exception {
+        SpringApplication.run(Application.class, args);
+        LOGGER.info("start ok!");
+
+    }
+
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/actual/LRUAbstractMap.java b/Java-Interview/src/main/java/com/crossoverjie/actual/LRUAbstractMap.java
new file mode 100644
index 0000000..0415733
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/actual/LRUAbstractMap.java
@@ -0,0 +1,349 @@
+package com.crossoverjie.actual;
+
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Set;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Function:
+ *
+ * 1.在做 key 生成 hashcode 时是用的 HashMap 的 hash 函数
+ * 2.在做 put get 时，如果存在 key 相等时候为了简单没有去比较 equal 和 hashcode
+ * 3.限制大小， map的最大size是1024， 超过1024后，就淘汰掉最久没有访问的kv 键值对， 当淘汰时，需要调用一个callback   lruCallback(K key, V value)
+ * 是利用每次 put 都将值写入一个内部队列，这样只需要判断队列里的第一个即可。
+ * 4.具备超时功能， 当键值对1小时内没有被访问， 就被淘汰掉, 当淘汰时， 需要调用一个callback   timeoutCallback(K key, V value);
+ * 超时同理，单独开启一个守护进程来处理，取的是队列里的第一个 因为第一个是最早放进去的。
+ *
+ * 但是像 HashMap 里的扩容，链表在超过阈值之类的没有考虑进来。
+ *
+ * @author crossoverJie
+ *         Date: 02/02/2018 20:47
+ * @since JDK 1.8
+ */
+public class LRUAbstractMap extends java.util.AbstractMap {
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(LRUAbstractMap.class);
+
+    /**
+     * 检查是否超期线程
+     */
+    private ExecutorService checkTimePool ;
+
+    /**
+     * map 最大size
+     */
+    private final static int MAX_SIZE = 1024 ;
+
+    private final static ArrayBlockingQueue<Node> QUEUE = new ArrayBlockingQueue<>(MAX_SIZE) ;
+
+    /**
+     * 默认大小
+     */
+    private final static int DEFAULT_ARRAY_SIZE =1024 ;
+
+
+    /**
+     * 数组长度
+     */
+    private int arraySize ;
+
+    /**
+     * 数组
+     */
+    private Object[] arrays ;
+
+
+    /**
+     * 判断是否停止 flag
+     */
+    private volatile boolean flag = true ;
+
+
+    /**
+     * 超时时间
+     */
+    private final static Long EXPIRE_TIME = 60 * 60 * 1000L ;
+
+    /**
+     * 整个 Map 的大小
+     */
+    private volatile AtomicInteger size  ;
+
+
+    public LRUAbstractMap() {
+
+
+        arraySize = DEFAULT_ARRAY_SIZE;
+        arrays = new Object[arraySize] ;
+
+        //开启一个线程检查最先放入队列的值是否超期
+        executeCheckTime();
+    }
+
+    /**
+     * 开启一个线程检查最先放入队列的值是否超期 设置为守护线程
+     */
+    private void executeCheckTime() {
+        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
+                .setNameFormat("check-thread-%d")
+                .setDaemon(true)
+                .build();
+        checkTimePool = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
+                new ArrayBlockingQueue<>(1),namedThreadFactory,new ThreadPoolExecutor.AbortPolicy());
+        checkTimePool.execute(new CheckTimeThread()) ;
+
+    }
+
+    @Override
+    public Set<Entry> entrySet() {
+        return super.keySet();
+    }
+
+    @Override
+    public Object put(Object key, Object value) {
+        int hash = hash(key);
+        int index = hash % arraySize ;
+        Node currentNode = (Node) arrays[index] ;
+
+        if (currentNode == null){
+            arrays[index] = new Node(null,null, key, value);
+
+            //写入队列
+            QUEUE.offer((Node) arrays[index]) ;
+
+            sizeUp();
+        }else {
+            Node cNode = currentNode ;
+            Node nNode = cNode ;
+
+            //存在就覆盖
+            if (nNode.key == key){
+                cNode.val = value ;
+            }
+
+            while (nNode.next != null){
+                //key 存在 就覆盖 简单判断
+                if (nNode.key == key){
+                    nNode.val = value ;
+                    break ;
+                }else {
+                    //不存在就新增链表
+                    sizeUp();
+                    Node node = new Node(nNode,null,key,value) ;
+
+                    //写入队列
+                    QUEUE.offer(currentNode) ;
+
+                    cNode.next = node ;
+                }
+
+                nNode = nNode.next ;
+            }
+
+        }
+
+        return null ;
+    }
+
+
+    @Override
+    public Object get(Object key) {
+
+        int hash = hash(key) ;
+        int index = hash % arraySize ;
+        Node currentNode = (Node) arrays[index] ;
+
+        if (currentNode == null){
+            return null ;
+        }
+        if (currentNode.next == null){
+
+            //更新时间
+            currentNode.setUpdateTime(System.currentTimeMillis());
+
+            //没有冲突
+            return currentNode ;
+
+        }
+
+        Node nNode = currentNode ;
+        while (nNode.next != null){
+
+            if (nNode.key == key){
+
+                //更新时间
+                currentNode.setUpdateTime(System.currentTimeMillis());
+
+                return nNode ;
+            }
+
+            nNode = nNode.next ;
+        }
+
+        return super.get(key);
+    }
+
+
+    @Override
+    public Object remove(Object key) {
+
+        int hash = hash(key) ;
+        int index = hash % arraySize ;
+        Node currentNode = (Node) arrays[index] ;
+
+        if (currentNode == null){
+            return null ;
+        }
+
+        if (currentNode.key == key){
+            sizeDown();
+            arrays[index] = null ;
+
+            //移除队列
+            QUEUE.poll();
+            return currentNode ;
+        }
+
+        Node nNode = currentNode ;
+        while (nNode.next != null){
+
+            if (nNode.key == key){
+                sizeDown();
+                //在链表中找到了 把上一个节点的 next 指向当前节点的下一个节点
+                nNode.pre.next = nNode.next ;
+                nNode = null ;
+
+                //移除队列
+                QUEUE.poll();
+
+                return nNode;
+            }
+
+            nNode = nNode.next ;
+        }
+
+        return super.remove(key);
+    }
+
+    /**
+     * 增加size
+     */
+    private void sizeUp(){
+
+        //在put值时候认为里边已经有数据了
+        flag = true ;
+
+        if (size == null){
+            size = new AtomicInteger() ;
+        }
+        int size = this.size.incrementAndGet();
+        if (size >= MAX_SIZE) {
+            //找到队列头的数据
+            Node node = QUEUE.poll() ;
+            if (node == null){
+                throw new RuntimeException("data error") ;
+            }
+
+            //移除该 key
+            Object key = node.key ;
+            remove(key) ;
+            lruCallback() ;
+        }
+
+    }
+
+    /**
+     * 数量减小
+     */
+    private void sizeDown(){
+
+        if (QUEUE.size() == 0){
+            flag = false ;
+        }
+
+        this.size.decrementAndGet() ;
+    }
+
+    @Override
+    public int size() {
+        return size.get() ;
+    }
+
+    /**
+     * 链表
+     */
+    private class Node{
+        private Node next ;
+        private Node pre ;
+        private Object key ;
+        private Object val ;
+        private Long updateTime ;
+
+        public Node(Node pre,Node next, Object key, Object val) {
+            this.pre = pre ;
+            this.next = next;
+            this.key = key;
+            this.val = val;
+            this.updateTime = System.currentTimeMillis() ;
+        }
+
+        public void setUpdateTime(Long updateTime) {
+            this.updateTime = updateTime;
+        }
+
+        public Long getUpdateTime() {
+            return updateTime;
+        }
+
+        @Override
+        public String toString() {
+            return "Node{" +
+                    "key=" + key +
+                    ", val=" + val +
+                    '}';
+        }
+    }
+
+
+    /**
+     * copy HashMap 的 hash 实现
+     * @param key
+     * @return
+     */
+    public int hash(Object key) {
+        int h;
+        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
+    }
+
+    private void lruCallback(){
+        LOGGER.debug("lruCallback");
+    }
+
+
+    private class CheckTimeThread implements Runnable{
+
+        @Override
+        public void run() {
+            while (flag){
+                try {
+                    Node node = QUEUE.poll();
+                    if (node == null){
+                        continue ;
+                    }
+                    Long updateTime = node.getUpdateTime() ;
+
+                    if ((updateTime - System.currentTimeMillis()) >= EXPIRE_TIME){
+                        remove(node.key) ;
+                    }
+                } catch (Exception e) {
+                    LOGGER.error("InterruptedException");
+                }
+            }
+        }
+    }
+
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/actual/LRULinkedMap.java b/Java-Interview/src/main/java/com/crossoverjie/actual/LRULinkedMap.java
new file mode 100644
index 0000000..a055ada
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/actual/LRULinkedMap.java
@@ -0,0 +1,53 @@
+package com.crossoverjie.actual;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 05/04/2018 12:04
+ * @since JDK 1.8
+ */
+public class LRULinkedMap<K,V> {
+
+
+    /**
+     * 最大缓存大小
+     */
+    private int cacheSize;
+
+    private LinkedHashMap<K,V> cacheMap ;
+
+
+    public LRULinkedMap(int cacheSize) {
+        this.cacheSize = cacheSize;
+
+        cacheMap = new LinkedHashMap(16,0.75F,true){
+            @Override
+            protected boolean removeEldestEntry(Map.Entry eldest) {
+                if (cacheSize + 1 == cacheMap.size()){
+                    return true ;
+                }else {
+                    return false ;
+                }
+            }
+        };
+    }
+
+    public void put(K key,V value){
+        cacheMap.put(key,value) ;
+    }
+
+    public V get(K key){
+        return cacheMap.get(key) ;
+    }
+
+
+    public Collection<Map.Entry<K, V>> getAll() {
+        return new ArrayList<Map.Entry<K, V>>(cacheMap.entrySet());
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/actual/LRUMap.java b/Java-Interview/src/main/java/com/crossoverjie/actual/LRUMap.java
new file mode 100644
index 0000000..c0a4596
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/actual/LRUMap.java
@@ -0,0 +1,222 @@
+package com.crossoverjie.actual;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 03/04/2018 00:08
+ * @since JDK 1.8
+ */
+public class LRUMap<K, V> {
+    private final Map<K, V> cacheMap = new HashMap<>();
+
+    /**
+     * 最大缓存大小
+     */
+    private int cacheSize;
+
+    /**
+     * 节点大小
+     */
+    private int nodeCount;
+
+
+    /**
+     * 头结点
+     */
+    private Node<K, V> header;
+
+    /**
+     * 尾结点
+     */
+    private Node<K, V> tailer;
+
+    public LRUMap(int cacheSize) {
+        this.cacheSize = cacheSize;
+        //头结点的下一个结点为空
+        header = new Node<>();
+        header.next = null;
+
+        //尾结点的上一个结点为空
+        tailer = new Node<>();
+        tailer.tail = null;
+
+        //双向链表 头结点的上结点指向尾结点
+        header.tail = tailer;
+
+        //尾结点的下结点指向头结点
+        tailer.next = header;
+
+
+    }
+
+    public void put(K key, V value) {
+        cacheMap.put(key, value);
+
+        //双向链表中添加结点
+        addNode(key, value);
+    }
+
+    public V get(K key){
+
+        Node<K, V> node = getNode(key);
+
+        //移动到头结点
+        moveToHead(node) ;
+
+        return cacheMap.get(key);
+    }
+
+    private void moveToHead(Node<K,V> node){
+
+        //如果是最后的一个节点
+        if (node.tail == null){
+            node.next.tail = null ;
+            tailer = node.next ;
+            nodeCount -- ;
+        }
+
+        //如果是本来就是头节点 不作处理
+        if (node.next == null){
+            return ;
+        }
+
+        //如果处于中间节点
+        if (node.tail != null && node.next != null){
+            //它的上一节点指向它的下一节点 也就删除当前节点
+            node.tail.next = node.next ;
+            nodeCount -- ;
+        }
+
+        //最后在头部增加当前节点
+        //注意这里需要重新 new 一个对象，不然原本的node 还有着下面的引用，会造成内存溢出。
+        node = new Node<>(node.getKey(),node.getValue()) ;
+        addHead(node) ;
+
+    }
+
+    /**
+     * 链表查询 效率较低
+     * @param key
+     * @return
+     */
+    private Node<K,V> getNode(K key){
+        Node<K,V> node = tailer ;
+        while (node != null){
+
+            if (node.getKey().equals(key)){
+                return node ;
+            }
+
+            node = node.next ;
+        }
+
+        return null ;
+    }
+
+
+    /**
+     * 写入头结点
+     * @param key
+     * @param value
+     */
+    private void addNode(K key, V value) {
+
+        Node<K, V> node = new Node<>(key, value);
+
+        //容量满了删除最后一个
+        if (cacheSize == nodeCount) {
+            //删除尾结点
+            delTail();
+        }
+
+        //写入头结点
+        addHead(node);
+
+    }
+
+
+    /**
+     * 添加头结点
+     *
+     * @param node
+     */
+    private void addHead(Node<K, V> node) {
+
+        //写入头结点
+        header.next = node;
+        node.tail = header;
+        header = node;
+        nodeCount++;
+
+        //如果写入的数据大于2个 就将初始化的头尾结点删除
+        if (nodeCount == 2) {
+            tailer.next.next.tail = null;
+            tailer = tailer.next.next;
+        }
+
+    }
+
+    private void delTail() {
+        //把尾结点从缓存中删除
+        cacheMap.remove(tailer.getKey());
+
+        //删除尾结点
+        tailer.next.tail = null;
+        tailer = tailer.next;
+
+        nodeCount--;
+
+    }
+
+    private class Node<K, V> {
+        private K key;
+        private V value;
+        Node<K, V> tail;
+        Node<K, V> next;
+
+        public Node(K key, V value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        public Node() {
+        }
+
+        public K getKey() {
+            return key;
+        }
+
+        public void setKey(K key) {
+            this.key = key;
+        }
+
+        public V getValue() {
+            return value;
+        }
+
+        public void setValue(V value) {
+            this.value = value;
+        }
+
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder() ;
+        Node<K,V> node = tailer ;
+        while (node != null){
+            sb.append(node.getKey()).append(":")
+                    .append(node.getValue())
+                    .append("-->") ;
+
+            node = node.next ;
+        }
+
+
+        return sb.toString();
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/actual/ReadFile.java b/Java-Interview/src/main/java/com/crossoverjie/actual/ReadFile.java
new file mode 100644
index 0000000..f09ef22
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/actual/ReadFile.java
@@ -0,0 +1,123 @@
+package com.crossoverjie.actual;
+
+import com.google.common.io.Files;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.*;
+
+/**
+ * Function:读取文件
+ *
+ * @author crossoverJie
+ *         Date: 05/01/2018 14:11
+ * @since JDK 1.8
+ */
+public class ReadFile {
+    private final static Logger LOGGER = LoggerFactory.getLogger(ReadFile.class);
+
+    private static List<String> content ;
+    private static String path ="/Users/chenjie/Desktop/test.log" ;
+
+    /**
+     * 查找关键字
+     */
+    private static final String KEYWORD = "login" ;
+
+
+    private static Map<String,Integer> countMap ;
+    /**
+     * 去重集合
+     */
+    private static Set<SortString> contentSet ;
+    public static void main(String[] args) {
+        contentSet = new TreeSet<>() ;
+        countMap = new HashMap<>(30) ;
+        File file = new File(path) ;
+        try {
+            //查找
+            sortAndFindKeyWords(file);
+
+            LOGGER.info(contentSet.toString());
+
+        } catch (IOException e) {
+            LOGGER.error("IOException",e);
+        }
+    }
+
+    /**
+     * 查找关键字
+     * @param file
+     * @throws IOException
+     */
+    private static void sortAndFindKeyWords(File file) throws IOException {
+        content = Files.readLines(file, Charset.defaultCharset());
+        LOGGER.info(String.valueOf(content));
+
+        for (String value : content) {
+
+            boolean flag = value.contains(KEYWORD) ;
+            if (!flag){
+                continue;
+            }
+
+            if (countMap.containsKey(value)){
+                countMap.put(value,countMap.get(value) + 1) ;
+            } else {
+                countMap.put(value,1) ;
+            }
+        }
+
+        for (String key :countMap.keySet()){
+            SortString sort = new SortString() ;
+            sort.setKey(key);
+            sort.setCount(countMap.get(key));
+
+            contentSet.add(sort) ;
+        }
+
+    }
+
+    private static class SortString implements Comparable<SortString>{
+
+        private String key ;
+        private Integer count ;
+
+        public String getKey() {
+            return key;
+        }
+
+        public void setKey(String key) {
+            this.key = key;
+        }
+
+        public Integer getCount() {
+            return count;
+        }
+
+        public void setCount(Integer count) {
+            this.count = count;
+        }
+
+
+        @Override
+        public int compareTo(SortString o) {
+            if (this.getCount() >o.getCount()){
+                return 1;
+            }else {
+                return -1 ;
+            }
+        }
+
+        @Override
+        public String toString() {
+            return "SortString{" +
+                    "key='" + key + '\'' +
+                    ", count=" + count +
+                    '}';
+        }
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/actual/ThreadCommunication.java b/Java-Interview/src/main/java/com/crossoverjie/actual/ThreadCommunication.java
new file mode 100644
index 0000000..ecbda20
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/actual/ThreadCommunication.java
@@ -0,0 +1,239 @@
+package com.crossoverjie.actual;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.io.PipedInputStream;
+import java.io.PipedReader;
+import java.io.PipedWriter;
+import java.util.concurrent.*;
+
+/**
+ * Function:三种方式线程通信
+ *
+ * @author crossoverJie
+ *         Date: 04/01/2018 22:57
+ * @since JDK 1.8
+ */
+public class ThreadCommunication {
+    private final static Logger LOGGER = LoggerFactory.getLogger(ThreadCommunication.class);
+
+    public static void main(String[] args) throws Exception {
+        //join();
+        //executorService();
+        //countDownLatch();
+        //piped();
+        cyclicBarrier();
+    }
+
+    /**
+     * CyclicBarrier
+     *
+     * @throws Exception
+     */
+    private static void cyclicBarrier() throws Exception {
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(3) ;
+
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("thread run");
+                try {
+                    cyclicBarrier.await() ;
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+
+                LOGGER.info("thread end do something");
+            }
+        }).start();
+
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("thread run");
+                try {
+                    cyclicBarrier.await() ;
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+
+                LOGGER.info("thread end do something");
+            }
+        }).start();
+
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("thread run");
+                try {
+                    Thread.sleep(5000);
+                    cyclicBarrier.await() ;
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+
+                LOGGER.info("thread end do something");
+            }
+        }).start();
+
+        LOGGER.info("main thread");
+    }
+
+    private static void countDownLatch() throws Exception {
+        int thread = 3;
+        long start = System.currentTimeMillis();
+        final CountDownLatch countDown = new CountDownLatch(thread);
+        for (int i = 0; i < thread; i++) {
+            new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    LOGGER.info("thread run");
+                    try {
+                        Thread.sleep(2000);
+                        countDown.countDown();
+
+                        LOGGER.info("thread end");
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }).start();
+        }
+
+        countDown.await();
+        long stop = System.currentTimeMillis();
+        LOGGER.info("main over total time={}", stop - start);
+    }
+
+    /**
+     * 利用线程池的 awaitTermination 方法，每隔一秒钟检查线程池是否执行完毕
+     *
+     * @throws Exception
+     */
+    private static void executorService() throws Exception {
+        BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(10);
+        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 5, 1, TimeUnit.MILLISECONDS, queue);
+        poolExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running");
+                try {
+                    Thread.sleep(3000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+        poolExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running2");
+                try {
+                    Thread.sleep(2000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+
+        poolExecutor.shutdown();
+        while (!poolExecutor.awaitTermination(1, TimeUnit.SECONDS)) {
+            LOGGER.info("线程还在执行。。。");
+        }
+        LOGGER.info("main over");
+    }
+
+
+    /**
+     * 采用 join 线程间通信
+     *
+     * @throws InterruptedException
+     */
+    private static void join() throws InterruptedException {
+        Thread t1 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running");
+                try {
+                    Thread.sleep(3000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+        Thread t2 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running2");
+                try {
+                    Thread.sleep(4000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+
+        t1.start();
+        t2.start();
+
+        //等待线程1终止
+        t1.join();
+
+        //等待线程2终止
+        t2.join();
+
+        LOGGER.info("main over");
+    }
+
+    public static void piped() throws IOException {
+        //面向于字符 PipedInputStream 面向于字节
+        PipedWriter writer = new PipedWriter();
+        PipedReader reader = new PipedReader();
+
+        //输入输出流建立连接
+        writer.connect(reader);
+
+
+        Thread t1 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running");
+                try {
+                    for (int i = 0; i < 10; i++) {
+
+                        writer.write(i+"");
+                        Thread.sleep(10);
+                    }
+                } catch (Exception e) {
+
+                } finally {
+                    try {
+                        writer.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+
+            }
+        });
+        Thread t2 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOGGER.info("running2");
+                int msg = 0;
+                try {
+                    while ((msg = reader.read()) != -1) {
+                        LOGGER.info("msg={}", (char) msg);
+                    }
+
+                } catch (Exception e) {
+
+                }
+            }
+        });
+        t1.start();
+        t2.start();
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/actual/TwoThread.java b/Java-Interview/src/main/java/com/crossoverjie/actual/TwoThread.java
new file mode 100644
index 0000000..90c8392
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/actual/TwoThread.java
@@ -0,0 +1,119 @@
+package com.crossoverjie.actual;
+
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * Function: 两个线程交替执行打印 1~100
+ *
+ * lock 版
+ *
+ * @author crossoverJie
+ *         Date: 11/02/2018 10:04
+ * @since JDK 1.8
+ */
+public class TwoThread {
+
+    private int start = 1;
+
+    /**
+     * 保证内存可见性
+     * 其实用锁了之后也可以保证可见性 这里用不用 volatile 都一样
+     */
+    private boolean flag = false;
+
+    /**
+     * 重入锁
+     */
+    private final static Lock LOCK = new ReentrantLock();
+
+    public static void main(String[] args) {
+        TwoThread twoThread = new TwoThread();
+
+        Thread t1 = new Thread(new OuNum(twoThread));
+        t1.setName("t1");
+
+
+        Thread t2 = new Thread(new JiNum(twoThread));
+        t2.setName("t2");
+
+        t1.start();
+        t2.start();
+    }
+
+    /**
+     * 偶数线程
+     */
+    public static class OuNum implements Runnable {
+
+        private TwoThread number;
+
+        public OuNum(TwoThread number) {
+            this.number = number;
+        }
+
+        @Override
+        public void run() {
+            while (number.start <= 100) {
+
+                if (number.flag) {
+                    try {
+                        LOCK.lock();
+                        System.out.println(Thread.currentThread().getName() + "+-+" + number.start);
+                        number.start++;
+                        number.flag = false;
+
+
+                    } finally {
+                        LOCK.unlock();
+                    }
+                } else {
+                    try {
+                        //防止线程空转
+                        Thread.sleep(10);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 奇数线程
+     */
+    public static class JiNum implements Runnable {
+
+        private TwoThread number;
+
+        public JiNum(TwoThread number) {
+            this.number = number;
+        }
+
+        @Override
+        public void run() {
+            while (number.start <= 100) {
+
+                if (!number.flag) {
+                    try {
+                        LOCK.lock();
+                        System.out.println(Thread.currentThread().getName() + "+-+" + number.start);
+                        number.start++;
+                        number.flag = true;
+
+
+                    } finally {
+                        LOCK.unlock();
+                    }
+                } else {
+                    try {
+                        //防止线程空转
+                        Thread.sleep(10);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/actual/TwoThreadWaitNotify.java b/Java-Interview/src/main/java/com/crossoverjie/actual/TwoThreadWaitNotify.java
new file mode 100644
index 0000000..1c69da1
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/actual/TwoThreadWaitNotify.java
@@ -0,0 +1,101 @@
+package com.crossoverjie.actual;
+
+/**
+ * Function:两个线程交替执行打印 1~100
+ * 等待通知机制版
+ *
+ * @author crossoverJie
+ *         Date: 07/03/2018 13:19
+ * @since JDK 1.8
+ */
+public class TwoThreadWaitNotify {
+
+    private int start = 1;
+
+    private boolean flag = false;
+
+    public static void main(String[] args) {
+        TwoThreadWaitNotify twoThread = new TwoThreadWaitNotify();
+
+        Thread t1 = new Thread(new OuNum(twoThread));
+        t1.setName("t1");
+
+
+        Thread t2 = new Thread(new JiNum(twoThread));
+        t2.setName("t2");
+
+        t1.start();
+        t2.start();
+    }
+
+    /**
+     * 偶数线程
+     */
+    public static class OuNum implements Runnable {
+        private TwoThreadWaitNotify number;
+
+        public OuNum(TwoThreadWaitNotify number) {
+            this.number = number;
+        }
+
+        @Override
+        public void run() {
+
+            while (number.start <= 100) {
+                synchronized (TwoThreadWaitNotify.class) {
+                    System.out.println("偶数线程抢到锁了");
+                    if (number.flag) {
+                        System.out.println(Thread.currentThread().getName() + "+-+偶数" + number.start);
+                        number.start++;
+
+                        number.flag = false;
+                        TwoThreadWaitNotify.class.notify();
+
+                    }else {
+                        try {
+                            TwoThreadWaitNotify.class.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+
+            }
+        }
+    }
+
+
+    /**
+     * 奇数线程
+     */
+    public static class JiNum implements Runnable {
+        private TwoThreadWaitNotify number;
+
+        public JiNum(TwoThreadWaitNotify number) {
+            this.number = number;
+        }
+
+        @Override
+        public void run() {
+            while (number.start <= 100) {
+                synchronized (TwoThreadWaitNotify.class) {
+                    System.out.println("奇数线程抢到锁了");
+                    if (!number.flag) {
+                        System.out.println(Thread.currentThread().getName() + "+-+奇数" + number.start);
+                        number.start++;
+
+                        number.flag = true;
+
+                        TwoThreadWaitNotify.class.notify();
+                    }else {
+                        try {
+                            TwoThreadWaitNotify.class.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/algorithm/ArrayKShift.java b/Java-Interview/src/main/java/com/crossoverjie/algorithm/ArrayKShift.java
new file mode 100644
index 0000000..0b4d9dc
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/algorithm/ArrayKShift.java
@@ -0,0 +1,75 @@
+package com.crossoverjie.algorithm;
+
+import java.util.Arrays;
+
+/**
+ * 数组右移K次, 原数组<code> [1, 2, 3, 4, 5, 6, 7]</code> 右移3次后结果为 <code>[5,6,7,1,2,3,4]</code>
+ *
+ * 基本思路：不开辟新的数组空间的情况下考虑在原属组上进行操作
+ * 1 将数组倒置，这样后k个元素就跑到了数组的前面，然后反转一下即可
+ * 2 同理后 len-k个元素只需要翻转就完成数组的k次移动
+ *
+ * @author 656369960@qq.com
+ * @date 12/7/2018 1:38 PM
+ * @since 1.0
+ */
+public class ArrayKShift {
+
+    public void arrayKShift(int[] array, int k) {
+
+        /**
+         * constrictions
+         */
+
+        if (array == null || 0 == array.length) {
+            return ;
+        }
+
+        k = k % array.length;
+
+        if (0 > k) {
+            return;
+        }
+
+
+        /**
+         * reverse array , e.g: [1, 2, 3 ,4] to [4,3,2,1]
+         */
+
+        for (int i = 0; i < array.length / 2; i++) {
+            int tmp = array[i];
+            array[i] = array[array.length - 1 - i];
+            array[array.length - 1 - i] = tmp;
+        }
+
+        /**
+         * first k element reverse
+         */
+        for (int i = 0; i < k / 2; i++) {
+            int tmp = array[i];
+            array[i] = array[k - 1 - i];
+            array[k - 1 - i] = tmp;
+        }
+
+        /**
+         * last length - k element reverse
+         */
+
+        for (int i = k; i < k + (array.length - k ) / 2; i ++) {
+            int tmp = array[i];
+            array[i] = array[array.length - 1 - i + k];
+            array[array.length - 1 - i + k] = tmp;
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] array = {1, 2, 3 ,4, 5, 6, 7};
+        ArrayKShift shift = new ArrayKShift();
+        shift.arrayKShift(array, 6);
+
+        Arrays.stream(array).forEach(o -> {
+            System.out.println(o);
+        });
+
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/algorithm/BinaryNode.java b/Java-Interview/src/main/java/com/crossoverjie/algorithm/BinaryNode.java
new file mode 100644
index 0000000..8164347
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/algorithm/BinaryNode.java
@@ -0,0 +1,102 @@
+package com.crossoverjie.algorithm;
+
+import java.util.LinkedList;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 04/01/2018 18:26
+ * @since JDK 1.8
+ */
+public class BinaryNode {
+    private Object data ;
+    private BinaryNode left ;
+    private BinaryNode right ;
+
+    public BinaryNode() {
+    }
+
+    public BinaryNode(Object data, BinaryNode left, BinaryNode right) {
+        this.data = data;
+        this.left = left;
+        this.right = right;
+    }
+
+    public Object getData() {
+        return data;
+    }
+
+    public void setData(Object data) {
+        this.data = data;
+    }
+
+    public BinaryNode getLeft() {
+        return left;
+    }
+
+    public void setLeft(BinaryNode left) {
+        this.left = left;
+    }
+
+    public BinaryNode getRight() {
+        return right;
+    }
+
+    public void setRight(BinaryNode right) {
+        this.right = right;
+    }
+
+
+    public BinaryNode createNode(){
+        BinaryNode node = new BinaryNode("1",null,null) ;
+        BinaryNode left2 = new BinaryNode("2",null,null) ;
+        BinaryNode left3 = new BinaryNode("3",null,null) ;
+        BinaryNode left4 = new BinaryNode("4",null,null) ;
+        BinaryNode left5 = new BinaryNode("5",null,null) ;
+        BinaryNode left6 = new BinaryNode("6",null,null) ;
+        node.setLeft(left2) ;
+        left2.setLeft(left4);
+        left2.setRight(left6);
+        node.setRight(left3);
+        left3.setRight(left5) ;
+        return node ;
+    }
+
+    @Override
+    public String toString() {
+        return "BinaryNode{" +
+                "data=" + data +
+                ", left=" + left +
+                ", right=" + right +
+                '}';
+    }
+
+
+    /**
+     * 二叉树的层序遍历 借助于队列来实现 借助队列的先进先出的特性
+     *
+     * 首先将根节点入队列 然后遍历队列。
+     * 首先将根节点打印出来，接着判断左节点是否为空 不为空则加入队列
+     * @param node
+     */
+    public void levelIterator(BinaryNode node){
+        LinkedList<BinaryNode> queue = new LinkedList<>() ;
+
+        //先将根节点入队
+        queue.offer(node) ;
+        BinaryNode current ;
+        while (!queue.isEmpty()){
+            current = queue.poll();
+
+            System.out.print(current.data+"--->");
+
+            if (current.getLeft() != null){
+                queue.offer(current.getLeft()) ;
+            }
+            if (current.getRight() != null){
+                queue.offer(current.getRight()) ;
+            }
+        }
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/algorithm/HappyNum.java b/Java-Interview/src/main/java/com/crossoverjie/algorithm/HappyNum.java
new file mode 100644
index 0000000..2f20ef0
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/algorithm/HappyNum.java
@@ -0,0 +1,67 @@
+package com.crossoverjie.algorithm;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Function: 判断一个数字是否为快乐数字 19 就是快乐数字  11就不是快乐数字
+ * 19
+ * 1*1+9*9=82
+ * 8*8+2*2=68
+ * 6*6+8*8=100
+ * 1*1+0*0+0*0=1
+ *
+ * 11
+ * 1*1+1*1=2
+ * 2*2=4
+ * 4*4=16
+ * 1*1+6*6=37
+ * 3*3+7*7=58
+ * 5*5+8*8=89
+ * 8*8+9*9=145
+ * 1*1+4*4+5*5=42
+ * 4*4+2*2=20
+ * 2*2+0*0=2
+ *
+ * 这里结果 1*1+1*1=2 和 2*2+0*0=2 重复，所以不是快乐数字
+ * @author crossoverJie
+ *         Date: 04/01/2018 14:12
+ * @since JDK 1.8
+ */
+public class HappyNum {
+
+    /**
+     * 判断一个数字是否为快乐数字
+     * @param number
+     * @return
+     */
+    public boolean isHappy(int number) {
+        Set<Integer> set = new HashSet<>(30);
+        while (number != 1) {
+            int sum = 0;
+            while (number > 0) {
+                //计算当前值的每位数的平方 相加的和 在放入set中，如果存在相同的就认为不是 happy数字
+                sum += (number % 10) * (number % 10);
+                number = number / 10;
+            }
+            if (set.contains(sum)) {
+                return false;
+            } else {
+                set.add(sum);
+            }
+            number = sum;
+        }
+        return true;
+    }
+
+
+    public static void main(String[] args) {
+        int num = 345;
+        int i = num % 10;
+        int i1 = num / 10;
+        int i2 = i1 / 10;
+        System.out.println(i);
+        System.out.println(i1);
+        System.out.println(i2);
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/algorithm/LinkLoop.java b/Java-Interview/src/main/java/com/crossoverjie/algorithm/LinkLoop.java
new file mode 100644
index 0000000..9a65aa4
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/algorithm/LinkLoop.java
@@ -0,0 +1,60 @@
+package com.crossoverjie.algorithm;
+
+/**
+ * Function:是否是环链表，采用快慢指针，一个走的快些一个走的慢些 如果最终相遇了就说明是环
+ * 就相当于在一个环形跑道里跑步，速度不一样的最终一定会相遇。
+ *
+ * @author crossoverJie
+ *         Date: 04/01/2018 11:33
+ * @since JDK 1.8
+ */
+public class LinkLoop {
+
+    public static class Node{
+        private Object data ;
+        public Node next ;
+
+        public Node(Object data, Node next) {
+            this.data = data;
+            this.next = next;
+        }
+
+        public Node(Object data) {
+            this.data = data ;
+        }
+    }
+
+    /**
+     * 判断链表是否有环
+     * @param node
+     * @return
+     */
+    public boolean isLoop(Node node){
+        Node slow = node ;
+        Node fast = node.next ;
+
+        while (slow.next != null){
+            Object dataSlow = slow.data;
+            Object dataFast = fast.data;
+
+            //说明有环
+            if (dataFast == dataSlow){
+                return true ;
+            }
+
+            //一共只有两个节点，但却不是环形链表的情况，判断NPE
+            if (fast.next == null){
+                return false ;
+            }
+            //slow走慢点  fast走快点
+            slow = slow.next ;
+            fast = fast.next.next ;
+
+            //如果走的快的发现为空 说明不存在环
+            if (fast == null){
+                return false ;
+            }
+        }
+        return false ;
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/algorithm/LinkedListMergeSort.java b/Java-Interview/src/main/java/com/crossoverjie/algorithm/LinkedListMergeSort.java
new file mode 100644
index 0000000..6d183bf
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/algorithm/LinkedListMergeSort.java
@@ -0,0 +1,141 @@
+package com.crossoverjie.algorithm;
+
+/**
+ * 链表排序, 建议使用归并排序，
+ * 问题描述，给定一个Int的链表，要求在时间最优的情况下完成链表元素由大到小的排序，
+ *     e.g: 1->5->4->3->2
+ *     排序后结果 5->4->3->2->1
+ *
+ * @author 6563699600@qq.com
+ * @date 6/7/2018 11:42 PM
+ * @since 1.0
+ */
+public class LinkedListMergeSort {
+
+    /**
+     * 定义链表数据结构，包含当前元素，以及当前元素的后续元素指针
+     */
+    final static class Node {
+        int e;
+        Node next;
+
+        public Node() {
+        }
+
+        public Node(int e, Node next) {
+            this.e = e;
+            this.next = next;
+        }
+    }
+
+    public Node mergeSort(Node first, int length) {
+
+        if (length == 1) {
+            return first;
+        } else {
+            Node middle = new Node();
+            Node tmp = first;
+
+            /**
+             * 后期会对这里进行优化，通过一次遍历算出长度和中间元素
+             */
+            for (int i = 0; i < length; i++) {
+                if (i == length / 2) {
+                    break;
+                }
+                middle = tmp;
+                tmp = tmp.next;
+            }
+
+            /**
+             *  这里是链表归并时要注意的细节
+             *  在链表进行归并排序过程中，会涉及到将一个链表打散为两个独立的链表，所以需要在中间元素的位置将其后续指针指为null；
+             */
+            Node right = middle.next;
+            middle.next = null;
+
+            Node leftStart = mergeSort(first, length / 2);
+            Node rightStart;
+            if (length % 2 == 0) {
+                rightStart = mergeSort(right, length / 2);
+            } else {
+                rightStart = mergeSort(right, length / 2 + 1);
+            }
+            return mergeList(leftStart, rightStart);
+        }
+    }
+
+    /**
+     * 合并链表，具体的实现细节可参考<code>MergeTwoSortedLists</code>
+     *
+     * @param left
+     * @param right
+     * @return
+     */
+    public Node mergeList(Node left, Node right) {
+
+        Node head = new Node();
+        Node result = head;
+
+        /**
+         * 思想就是两个链表同时遍历，将更的元素插入结果中，同时更更大的元素所属的链表的指针向下移动
+         */
+        while (!(null == left && null == right)) {
+            Node tmp;
+            if (left == null) {
+                result.next = right;
+                break;
+            } else if (right == null) {
+                result.next = left;
+                break;
+            } else if (left.e >= right.e) {
+                tmp = left;
+                result.next = left;
+                result = tmp;
+                left = left.next;
+            } else {
+                tmp = right;
+                result.next = right;
+                result = tmp;
+                right = right.next;
+            }
+        }
+
+        return head.next;
+    }
+
+    public static void main(String[] args) {
+
+        Node head = new Node();
+
+        head.next = new Node(7,
+                new Node(2,
+                        new Node(5,
+                                new Node(4,
+                                        new Node(3,
+                                                new Node(6,
+                                                        new Node(11, null)
+                                                )
+                                        )
+                                )
+                        )
+                )
+        );
+
+        int length = 0;
+
+        for (Node e = head.next; null != e; e = e.next) {
+            length++;
+        }
+
+
+        LinkedListMergeSort sort = new LinkedListMergeSort();
+        head.next = sort.mergeSort(head.next, length);
+
+
+        for (Node n = head.next; n != null; n = n.next) {
+            System.out.println(n.e);
+        }
+
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/algorithm/MergeTwoSortedLists.java b/Java-Interview/src/main/java/com/crossoverjie/algorithm/MergeTwoSortedLists.java
new file mode 100644
index 0000000..924de40
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/algorithm/MergeTwoSortedLists.java
@@ -0,0 +1,78 @@
+package com.crossoverjie.algorithm;
+
+/**
+ * Function: 合并两个排好序的链表
+ *
+ * 每次比较两个链表的头结点，将较小结点放到新的链表，最后将新链表指向剩余的链表
+ *
+ * @author crossoverJie
+ *         Date: 07/12/2017 13:58
+ * @since JDK 1.8
+ */
+public class MergeTwoSortedLists {
+
+
+    /**
+     * 1. 声明一个头结点
+     * 2. 将头结点的引用赋值给一个临时结点，也可以叫做下一结点。
+     * 3. 进行循环比较，每次都将指向值较小的那个结点(较小值的引用赋值给 lastNode )。
+     * 4. 再去掉较小值链表的头结点，指针后移。
+     * 5. lastNode 指针也向后移，由于 lastNode 是 head 的引用，这样可以保证最终 head 的值是往后更新的。
+     * 6. 当其中一个链表的指针移到最后时跳出循环。
+     * 7. 由于这两个链表已经是排好序的，所以剩下的链表必定是最大的值，只需要将指针指向它即可。
+     * 8. 由于 head 链表的第一个结点是初始化的0，所以只需要返回 0 的下一个结点即是合并了的链表。
+     * @param l1
+     * @param l2
+     * @return
+     */
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        ListNode head = new ListNode(0) ;
+        ListNode lastNode = head ;
+
+        while (l1 != null  && l2 != null){
+            if (l1.currentVal < l2.currentVal){
+                lastNode.next = l1 ;
+                l1 = l1.next ;
+            } else {
+                lastNode.next = l2 ;
+                l2 = l2.next ;
+            }
+            lastNode =lastNode.next ;
+        }
+
+        if (l1 == null){
+            lastNode.next = l2 ;
+        }
+        if (l2 == null){
+            lastNode.next = l1 ;
+        }
+
+        return head.next ;
+    }
+
+
+    public static class ListNode {
+        /**
+         * 当前值
+         */
+        int currentVal;
+
+        /**
+         * 下一个节点
+         */
+        ListNode next;
+
+        ListNode(int val) {
+            currentVal = val;
+        }
+
+        @Override
+        public String toString() {
+            return "ListNode{" +
+                    "currentVal=" + currentVal +
+                    ", next=" + next +
+                    '}';
+        }
+    }
+
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/algorithm/ReverseNode.java b/Java-Interview/src/main/java/com/crossoverjie/algorithm/ReverseNode.java
new file mode 100644
index 0000000..a3c2a83
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/algorithm/ReverseNode.java
@@ -0,0 +1,106 @@
+package com.crossoverjie.algorithm;
+
+import java.util.Stack;
+
+/**
+ * Function: 三种方式反向打印单向链表
+ *
+ * @author crossoverJie
+ *         Date: 10/02/2018 16:14
+ * @since JDK 1.8
+ */
+public class ReverseNode {
+
+
+    /**
+     * 利用栈的先进后出特性
+     * @param node
+     */
+    public void reverseNode1(Node node){
+
+        System.out.println("====翻转之前====");
+
+        Stack<Node> stack = new Stack<>() ;
+        while (node != null){
+
+            System.out.print(node.value + "===>");
+
+            stack.push(node) ;
+            node = node.next ;
+        }
+
+        System.out.println("");
+
+        System.out.println("====翻转之后====");
+        while (!stack.isEmpty()){
+            System.out.print(stack.pop().value + "===>");
+        }
+
+    }
+
+
+    /**
+     * 利用头插法插入链表
+     * @param head
+     */
+    public  void reverseNode(Node head) {
+        if (head == null) {
+            return ;
+        }
+
+        //最终翻转之后的 Node
+        Node node ;
+
+        Node pre = head;
+        Node cur = head.next;
+        Node next ;
+        while(cur != null){
+            next = cur.next;
+
+            //链表的头插法
+            cur.next = pre;
+            pre = cur;
+
+            cur = next;
+        }
+        head.next = null;
+        node = pre;
+
+
+        //遍历新链表
+        while (node != null){
+            System.out.println(node.value);
+            node = node.next ;
+        }
+
+    }
+
+
+    /**
+     * 递归
+     * @param node
+     */
+    public void recNode(Node node){
+
+        if (node == null){
+            return ;
+        }
+
+        if (node.next != null){
+            recNode(node.next) ;
+        }
+        System.out.print(node.value+"===>");
+    }
+
+
+    public static class Node<T>{
+        public T value;
+        public Node<T> next ;
+
+
+        public Node(T value, Node<T> next ) {
+            this.next = next;
+            this.value = value;
+        }
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/algorithm/TwoArray.java b/Java-Interview/src/main/java/com/crossoverjie/algorithm/TwoArray.java
new file mode 100644
index 0000000..77dd5b2
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/algorithm/TwoArray.java
@@ -0,0 +1,41 @@
+package com.crossoverjie.algorithm;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Function: 在二维数组中判断是否存在查找的数字
+ *
+ * @author crossoverJie
+ *         Date: 09/02/2018 22:19
+ * @since JDK 1.8
+ */
+public class TwoArray {
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(TwoArray.class);
+
+
+
+
+    public static void main(String[] args) {
+        int[][] matrix = new int[][]{
+                {1, 2, 8, 9},
+                {2, 4, 9, 12},
+                {4, 7, 10, 13},
+                {6, 8, 11, 15},
+                {7, 9, 12, 16}
+        };
+
+        // 数组的行数
+        int rows = matrix.length;
+        // 数组行的列数
+        int cols = matrix[1].length;
+
+        LOGGER.info(String.valueOf(rows));
+        LOGGER.info(String.valueOf(cols));
+
+    }
+
+
+
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/algorithm/TwoStackQueue.java b/Java-Interview/src/main/java/com/crossoverjie/algorithm/TwoStackQueue.java
new file mode 100644
index 0000000..989e7d6
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/algorithm/TwoStackQueue.java
@@ -0,0 +1,61 @@
+package com.crossoverjie.algorithm;
+
+import java.util.Stack;
+
+/**
+ * Function: 两个栈实现队列
+ *
+ * 利用两个栈来实现，第一个栈存放写队列的数据。
+ * 第二个栈存放移除队列的数据，移除之前先判断第二个栈里是否有数据。
+ * 如果没有就要将第一个栈里的数据依次弹出压入第二个栈，这样写入之后的顺序再弹出其实就是一个先进先出的结构了。
+ *
+ * 这样出队列只需要移除第二个栈的头元素即可。
+ *
+ * @author crossoverJie
+ *         Date: 09/02/2018 23:51
+ * @since JDK 1.8
+ */
+public class TwoStackQueue<T> {
+
+    /**
+     * 写入的栈
+     */
+    private Stack<T> input = new Stack() ;
+
+    /**
+     * 移除队列所出的栈
+     */
+    private Stack<T> out = new Stack() ;
+
+
+    /**
+     * 写入队列
+     * @param t
+     */
+    public void appendTail(T t){
+        input.push(t) ;
+    }
+
+    /**
+     * 删除队列头结点 并返回删除数据
+     * @return
+     */
+    public T deleteHead(){
+
+        //是空的 需要将 input 出栈写入 out
+        if (out.isEmpty()){
+            while (!input.isEmpty()){
+                out.push(input.pop()) ;
+            }
+        }
+
+        //不为空时直接移除出栈就表示移除了头结点
+        return out.pop() ;
+    }
+
+
+    public int getSize(){
+        return input.size() + out.size() ;
+    }
+
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/algorithm/TwoSum.java b/Java-Interview/src/main/java/com/crossoverjie/algorithm/TwoSum.java
new file mode 100644
index 0000000..08f08f0
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/algorithm/TwoSum.java
@@ -0,0 +1,60 @@
+package com.crossoverjie.algorithm;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Function:{1,3,5,7} target=8 返回{2,3}
+ *
+ * @author crossoverJie
+ *         Date: 04/01/2018 09:53
+ * @since JDK 1.8
+ */
+public class TwoSum {
+
+    /**
+     * 时间复杂度为 O(N^2)
+     * @param nums
+     * @param target
+     * @return
+     */
+    public int[] getTwo1(int[] nums,int target){
+        int[] result = new int[2] ;
+
+        for (int i= 0 ;i<nums.length ;i++){
+            int a = nums[i] ;
+            for (int j = nums.length -1 ;j >=0 ;j--){
+                int b = nums[j] ;
+
+                if ((a+b) == target){
+                    result = new int[]{i,j} ;
+                }
+            }
+        }
+        return result ;
+    }
+
+
+    /**
+     * 时间复杂度 O(N)
+     * 利用Map Key存放目标值和当前值的差值，value 就是当前的下标
+     * 每次遍历是 查看当前遍历的值是否等于差值，如果是等于，说明两次相加就等于目标值。
+     * 然后取出 map 中 value ，和本次遍历的下标，就是两个下标值相加等于目标值了。
+     *
+     * @param nums
+     * @param target
+     * @return
+     */
+    public int[] getTwo2(int[] nums,int target){
+        int[] result = new int[2] ;
+        Map<Integer,Integer> map = new HashMap<>(2) ;
+        for (int i=0 ;i<nums.length;i++){
+
+            if (map.containsKey(nums[i])){
+                result = new int[]{map.get(nums[i]),i} ;
+            }
+            map.put(target - nums[i],i) ;
+        }
+        return result ;
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/basic/HashMapTest.java b/Java-Interview/src/main/java/com/crossoverjie/basic/HashMapTest.java
new file mode 100644
index 0000000..011910b
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/basic/HashMapTest.java
@@ -0,0 +1,42 @@
+package com.crossoverjie.basic;
+
+import java.security.Key;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 05/05/2018 12:42
+ * @since JDK 1.8
+ */
+public class HashMapTest {
+    public static void main(String[] args) {
+        Map<String, Integer> map = new HashMap<>(16);
+        map.put("1", 1);
+        map.put("2", 2);
+        map.put("3", 3);
+        map.put("4", 4);
+
+        Iterator<Map.Entry<String, Integer>> entryIterator = map.entrySet().iterator();
+        while (entryIterator.hasNext()) {
+            Map.Entry<String, Integer> next = entryIterator.next();
+            System.out.println("key=" + next.getKey() + " value=" + next.getValue());
+        }
+        System.out.println("=============");
+
+        Iterator<String> iterator = map.keySet().iterator();
+        while (iterator.hasNext()){
+            String key = iterator.next();
+            System.out.println("key=" + key + " value=" + map.get(key));
+
+        }
+
+        System.out.println("=============");
+        map.forEach((key, value) -> {
+            System.out.println("key=" + key + " value=" + map.get(key));
+        });
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/basic/StringTest.java b/Java-Interview/src/main/java/com/crossoverjie/basic/StringTest.java
new file mode 100644
index 0000000..29216e9
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/basic/StringTest.java
@@ -0,0 +1,39 @@
+package com.crossoverjie.basic;
+
+import java.lang.reflect.Field;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 08/03/2018 13:56
+ * @since JDK 1.8
+ */
+public class StringTest {
+
+    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
+        String a = "123";
+        //这里的 a 和 b  都是同一个对象，指向同一个字符串常量池对象。
+        String b = "123" ;
+        String c = new String("123") ;
+
+        System.out.println("a=b:" + (a == b));
+        System.out.println("a=c:" + (a == c));
+
+        System.out.println("a=" + a);
+
+        a = "456";
+        System.out.println("a=" + a);
+
+
+        //用反射的方式改变字符串的值
+        Field value = a.getClass().getDeclaredField("value");
+        //改变 value 的访问属性
+        value.setAccessible(true) ;
+
+        char[] values = (char[]) value.get(a);
+        values[0] = '9' ;
+
+        System.out.println(a);
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/classloader/ChildClass.java b/Java-Interview/src/main/java/com/crossoverjie/classloader/ChildClass.java
new file mode 100644
index 0000000..16331c3
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/classloader/ChildClass.java
@@ -0,0 +1,14 @@
+package com.crossoverjie.classloader;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 05/03/2018 23:11
+ * @since JDK 1.8
+ */
+public class ChildClass extends SuperClass {
+    static {
+        System.out.println("ChildClass init");
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/classloader/Main.java b/Java-Interview/src/main/java/com/crossoverjie/classloader/Main.java
new file mode 100644
index 0000000..24f6d0c
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/classloader/Main.java
@@ -0,0 +1,14 @@
+package com.crossoverjie.classloader;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 05/03/2018 23:12
+ * @since JDK 1.8
+ */
+public class Main {
+    public static void main(String[] args) {
+        System.out.println(ChildClass.A);
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/classloader/SuperClass.java b/Java-Interview/src/main/java/com/crossoverjie/classloader/SuperClass.java
new file mode 100644
index 0000000..d0d67a1
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/classloader/SuperClass.java
@@ -0,0 +1,20 @@
+package com.crossoverjie.classloader;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 05/03/2018 23:11
+ * @since JDK 1.8
+ */
+public class SuperClass {
+
+    /**
+     * 如果使用了 final 修饰的常量，再使用时父类也不会初始化
+     */
+    public static int A = 1;
+
+    static {
+        System.out.println("SuperClass init");
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/concurrent/Singleton.java b/Java-Interview/src/main/java/com/crossoverjie/concurrent/Singleton.java
new file mode 100644
index 0000000..fec4924
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/concurrent/Singleton.java
@@ -0,0 +1,28 @@
+package com.crossoverjie.concurrent;
+
+/**
+ * Function:单例模式-双重检查锁
+ *
+ * @author crossoverJie
+ *         Date: 09/03/2018 01:14
+ * @since JDK 1.8
+ */
+public class Singleton {
+
+    private static volatile Singleton singleton;
+
+    private Singleton() {
+    }
+
+    public static Singleton getInstance() {
+        if (singleton == null) {
+            synchronized (Singleton.class) {
+                if (singleton == null) {
+                    //防止指令重排
+                    singleton = new Singleton();
+                }
+            }
+        }
+        return singleton;
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/concurrent/StopThread.java b/Java-Interview/src/main/java/com/crossoverjie/concurrent/StopThread.java
new file mode 100644
index 0000000..1b5b860
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/concurrent/StopThread.java
@@ -0,0 +1,36 @@
+package com.crossoverjie.concurrent;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Function:响应中断
+ *
+ * @author crossoverJie
+ *         Date: 16/03/2018 01:41
+ * @since JDK 1.8
+ */
+public class StopThread implements Runnable {
+    @Override
+    public void run() {
+
+        while ( !Thread.currentThread().isInterrupted()) {
+            // 线程执行具体逻辑
+            System.out.println(Thread.currentThread().getName() + "运行中。。");
+        }
+
+        System.out.println(Thread.currentThread().getName() + "退出。。");
+
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        Thread thread = new Thread(new StopThread(), "thread A");
+        thread.start();
+
+        System.out.println("main 线程正在运行") ;
+
+        TimeUnit.MILLISECONDS.sleep(10) ;
+        thread.interrupt();
+    }
+
+
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/concurrent/ThreadState.java b/Java-Interview/src/main/java/com/crossoverjie/concurrent/ThreadState.java
new file mode 100644
index 0000000..ea0ec90
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/concurrent/ThreadState.java
@@ -0,0 +1,67 @@
+package com.crossoverjie.concurrent;
+
+import com.crossoverjie.classloader.Main;
+
+/**
+ * Function: 线程状态测试
+ *
+ * @author crossoverJie
+ *         Date: 06/03/2018 22:56
+ * @since JDK 1.8
+ */
+public class ThreadState {
+
+    public static void main(String[] args) {
+        new Thread(new TimeWaiting(),"TimeWaiting").start();
+        new Thread(new Waiting(),"Waiting").start();
+        new Thread(new Blocked(),"Blocked1").start();
+        new Thread(new Blocked(),"Blocked2").start();
+    }
+
+    static class TimeWaiting implements Runnable{
+
+        @Override
+        public void run() {
+            while (true){
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+    static class Waiting implements Runnable{
+
+        @Override
+        public void run() {
+            while (true){
+                synchronized (Waiting.class){
+                    try {
+                        Waiting.class.wait();
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+
+
+    static class Blocked implements Runnable{
+
+        @Override
+        public void run() {
+            while (true){
+                synchronized (Blocked.class){
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/concurrent/Volatile.java b/Java-Interview/src/main/java/com/crossoverjie/concurrent/Volatile.java
new file mode 100644
index 0000000..a910c61
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/concurrent/Volatile.java
@@ -0,0 +1,54 @@
+package com.crossoverjie.concurrent;
+
+import java.util.Scanner;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 09/03/2018 00:09
+ * @since JDK 1.8
+ */
+public class Volatile implements Runnable{
+
+    private static volatile boolean flag = true ;
+
+    @Override
+    public void run() {
+        while (flag){
+        }
+        System.out.println(Thread.currentThread().getName() +"执行完毕");
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        Volatile aVolatile = new Volatile();
+        new Thread(aVolatile,"thread A").start();
+
+
+        System.out.println("main 线程正在运行") ;
+
+        Scanner sc = new Scanner(System.in);
+        while(sc.hasNext()){
+            String value = sc.next();
+            if(value.equals("1")){
+
+                new Thread(new Runnable() {
+                    @Override
+                    public void run() {
+                        aVolatile.stopThread();
+                    }
+                }).start();
+
+                break ;
+            }
+        }
+
+        System.out.println("主线程退出了！");
+
+    }
+
+    private void stopThread(){
+        flag = false ;
+    }
+
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/concurrent/VolatileInc.java b/Java-Interview/src/main/java/com/crossoverjie/concurrent/VolatileInc.java
new file mode 100644
index 0000000..2a24777
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/concurrent/VolatileInc.java
@@ -0,0 +1,43 @@
+package com.crossoverjie.concurrent;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 09/03/2018 00:34
+ * @since JDK 1.8
+ */
+public class VolatileInc implements Runnable{
+
+    private static volatile int count = 0 ; //使用 volatile 修饰基本数据内存不能保证原子性
+
+    //private static AtomicInteger count = new AtomicInteger() ;
+
+    @Override
+    public void run() {
+        for (int i=0;i<10000 ;i++){
+            count ++ ;
+            //count.incrementAndGet() ;
+        }
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        VolatileInc volatileInc = new VolatileInc() ;
+        Thread t1 = new Thread(volatileInc,"t1") ;
+        Thread t2 = new Thread(volatileInc,"t2") ;
+        t1.start();
+        //t1.join();
+
+        t2.start();
+        //t2.join();
+        for (int i=0;i<10000 ;i++){
+            count ++ ;
+            //count.incrementAndGet();
+        }
+
+
+        System.out.println("最终Count="+count);
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Animal.java b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Animal.java
new file mode 100644
index 0000000..04556a4
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Animal.java
@@ -0,0 +1,26 @@
+package com.crossoverjie.design.pattern.factorymethod;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 19/03/2018 14:29
+ * @since JDK 1.8
+ */
+public abstract class Animal {
+
+    private String name ;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    /**
+     * 描述抽象方法
+     */
+    protected abstract void desc() ;
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/AnimalFactory.java b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/AnimalFactory.java
new file mode 100644
index 0000000..fb7f571
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/AnimalFactory.java
@@ -0,0 +1,13 @@
+package com.crossoverjie.design.pattern.factorymethod;
+
+/**
+ * Function:工厂方法模式
+ *
+ * @author crossoverJie
+ *         Date: 19/03/2018 14:29
+ * @since JDK 1.8
+ */
+public interface AnimalFactory {
+
+    Animal createAnimal() ;
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Cat.java b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Cat.java
new file mode 100644
index 0000000..7d0393c
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Cat.java
@@ -0,0 +1,15 @@
+package com.crossoverjie.design.pattern.factorymethod;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 19/03/2018 14:33
+ * @since JDK 1.8
+ */
+public class Cat extends Animal {
+    @Override
+    protected void desc() {
+        System.out.println("Cat name is=" + this.getName());
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/CatFactory.java b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/CatFactory.java
new file mode 100644
index 0000000..a8f90d6
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/CatFactory.java
@@ -0,0 +1,15 @@
+package com.crossoverjie.design.pattern.factorymethod;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 19/03/2018 15:21
+ * @since JDK 1.8
+ */
+public class CatFactory implements AnimalFactory {
+    @Override
+    public Animal createAnimal() {
+        return new Cat();
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Fish.java b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Fish.java
new file mode 100644
index 0000000..9820c1a
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Fish.java
@@ -0,0 +1,17 @@
+package com.crossoverjie.design.pattern.factorymethod;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 19/03/2018 14:32
+ * @since JDK 1.8
+ */
+public class Fish extends Animal {
+
+
+    @Override
+    protected void desc() {
+        System.out.println("fish name is=" + this.getName());
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/FishFactory.java b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/FishFactory.java
new file mode 100644
index 0000000..8e59610
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/FishFactory.java
@@ -0,0 +1,15 @@
+package com.crossoverjie.design.pattern.factorymethod;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 19/03/2018 15:21
+ * @since JDK 1.8
+ */
+public class FishFactory implements AnimalFactory {
+    @Override
+    public Animal createAnimal() {
+        return new Fish() ;
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Main.java b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Main.java
new file mode 100644
index 0000000..440aaa4
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/design/pattern/factorymethod/Main.java
@@ -0,0 +1,17 @@
+package com.crossoverjie.design.pattern.factorymethod;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 19/03/2018 14:34
+ * @since JDK 1.8
+ */
+public class Main {
+    public static void main(String[] args) {
+        AnimalFactory factory = new CatFactory() ;
+        Animal animal = factory.createAnimal();
+        animal.setName("猫咪");
+        animal.desc();
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/gc/MinorGC.java b/Java-Interview/src/main/java/com/crossoverjie/gc/MinorGC.java
new file mode 100644
index 0000000..a6867e8
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/gc/MinorGC.java
@@ -0,0 +1,36 @@
+package com.crossoverjie.gc;
+
+/**
+ * Function: Eden区不够分配时，发生minorGC
+ *
+ * @author crossoverJie
+ *         Date: 17/01/2018 22:57
+ * @since JDK 1.8
+ */
+public class MinorGC {
+
+    /**
+     * 1M
+     */
+    private static final int SIZE = 1024 * 1024 ;
+
+    /**
+     *
+     -XX:+PrintGCDetails
+     -Xms20M
+     -Xmx20M
+     -Xmn10M
+     -XX:SurvivorRatio=8
+     * @param args
+     */
+    public static void main(String[] args) {
+        byte[] one ;
+        byte[] four ;
+
+        one = new byte[2 * SIZE] ;
+
+
+        //再分配一个 5M 内存时，Eden区不够了，
+        four = new byte[5 * SIZE] ;
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/guava/CacheLoaderTest.java b/Java-Interview/src/main/java/com/crossoverjie/guava/CacheLoaderTest.java
new file mode 100644
index 0000000..9eb0893
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/guava/CacheLoaderTest.java
@@ -0,0 +1,91 @@
+package com.crossoverjie.guava;
+
+import com.google.common.cache.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 2018/6/12 15:33
+ * @since JDK 1.8
+ */
+public class CacheLoaderTest {
+    private final static Logger LOGGER = LoggerFactory.getLogger(CacheLoaderTest.class);
+    private LoadingCache<Integer, AtomicLong> loadingCache ;
+    private final static Integer KEY = 1000;
+
+
+    private final static LinkedBlockingQueue<Integer> QUEUE = new LinkedBlockingQueue<>(1000);
+
+
+    private void init() throws InterruptedException {
+        loadingCache = CacheBuilder.newBuilder()
+                .expireAfterWrite(2, TimeUnit.SECONDS)
+                .removalListener(new RemovalListener<Object, Object>() {
+                    @Override
+                    public void onRemoval(RemovalNotification<Object, Object> notification) {
+                        LOGGER.info("删除原因={}，删除 key={},删除 value={}",notification.getCause(),notification.getKey(),notification.getValue());
+                    }
+                })
+                .build(new CacheLoader<Integer, AtomicLong>() {
+                    @Override
+                    public AtomicLong load(Integer key) throws Exception {
+                        return new AtomicLong(0);
+                    }
+                });
+
+
+        for (int i = 10; i < 15; i++) {
+            QUEUE.put(i);
+        }
+    }
+
+    private void checkAlert(Integer integer) {
+        try {
+
+            //loadingCache.put(integer,new AtomicLong(integer));
+
+            TimeUnit.SECONDS.sleep(3);
+
+
+            LOGGER.info("当前缓存值={},缓存大小={}", loadingCache.get(KEY),loadingCache.size());
+            LOGGER.info("缓存的所有内容={}",loadingCache.asMap().toString());
+            loadingCache.get(KEY).incrementAndGet();
+
+        } catch (ExecutionException e ) {
+            LOGGER.error("Exception", e);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+    public static void main(String[] args) throws InterruptedException {
+        CacheLoaderTest cacheLoaderTest = new CacheLoaderTest() ;
+        cacheLoaderTest.init();
+
+
+
+        while (true) {
+
+            try {
+                Integer integer = QUEUE.poll(200, TimeUnit.MILLISECONDS);
+                if (null == integer) {
+                    break;
+                }
+                //TimeUnit.SECONDS.sleep(5);
+                cacheLoaderTest.checkAlert(integer);
+                LOGGER.info("job running times={}", integer);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/guava/callback/CallBackListener.java b/Java-Interview/src/main/java/com/crossoverjie/guava/callback/CallBackListener.java
new file mode 100644
index 0000000..cddad08
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/guava/callback/CallBackListener.java
@@ -0,0 +1,17 @@
+package com.crossoverjie.guava.callback;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 2018/7/15 13:49
+ * @since JDK 1.8
+ */
+public interface CallBackListener {
+
+    /**
+     * 回调通知函数
+     * @param msg
+     */
+    void callBackNotify(String msg) ;
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/guava/callback/Caller.java b/Java-Interview/src/main/java/com/crossoverjie/guava/callback/Caller.java
new file mode 100644
index 0000000..dc9f188
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/guava/callback/Caller.java
@@ -0,0 +1,79 @@
+package com.crossoverjie.guava.callback;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 2018/7/15 13:52
+ * @since JDK 1.8
+ */
+public class Caller {
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(Caller.class);
+
+    private CallBackListener callBackListener ;
+
+    private Notifier notifier ;
+
+    private String question ;
+
+    /**
+     * 使用
+     */
+    public void call(){
+
+        LOGGER.info("开始提问");
+
+        //新建线程，达到异步效果
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    notifier.execute(Caller.this,question);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }).start();
+
+        LOGGER.info("提问完毕，我去干其他事了");
+    }
+
+
+    public Notifier getNotifier() {
+        return notifier;
+    }
+
+    public void setNotifier(Notifier notifier) {
+        this.notifier = notifier;
+    }
+
+
+    public CallBackListener getCallBackListener() {
+        return callBackListener;
+    }
+
+    public void setCallBackListener(CallBackListener callBackListener) {
+        this.callBackListener = callBackListener;
+    }
+
+    public String getQuestion() {
+        return question;
+    }
+
+    public void setQuestion(String question) {
+        this.question = question;
+    }
+
+    @Override
+    public String toString() {
+        return "Caller{" +
+                "callBackListener=" + callBackListener +
+                ", notifier=" + notifier +
+                ", question='" + question + '\'' +
+                '}';
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/guava/callback/Main.java b/Java-Interview/src/main/java/com/crossoverjie/guava/callback/Main.java
new file mode 100644
index 0000000..9e90025
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/guava/callback/Main.java
@@ -0,0 +1,32 @@
+package com.crossoverjie.guava.callback;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 2018/7/15 14:18
+ * @since JDK 1.8
+ */
+public class Main {
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(Main.class);
+
+    public static void main(String[] args) {
+        Notifier notifier = new Notifier() ;
+
+        Caller caller = new Caller() ;
+        caller.setNotifier(notifier) ;
+        caller.setQuestion("你在哪儿！");
+        caller.setCallBackListener(new CallBackListener() {
+            @Override
+            public void callBackNotify(String msg) {
+                LOGGER.info("回复=【{}】" ,msg);
+            }
+        });
+
+        caller.call();
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/guava/callback/Notifier.java b/Java-Interview/src/main/java/com/crossoverjie/guava/callback/Notifier.java
new file mode 100644
index 0000000..26966af
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/guava/callback/Notifier.java
@@ -0,0 +1,30 @@
+package com.crossoverjie.guava.callback;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 2018/7/15 13:59
+ * @since JDK 1.8
+ */
+public class Notifier {
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(Notifier.class);
+
+    public void execute(Caller caller, String msg) throws InterruptedException {
+        LOGGER.info("收到消息=【{}】", msg);
+
+        LOGGER.info("等待响应中。。。。。");
+        TimeUnit.SECONDS.sleep(2);
+
+
+        caller.getCallBackListener().callBackNotify("我在北京！");
+
+    }
+
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/oom/heap/HeapOOM.java b/Java-Interview/src/main/java/com/crossoverjie/oom/heap/HeapOOM.java
new file mode 100644
index 0000000..5bf585c
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/oom/heap/HeapOOM.java
@@ -0,0 +1,21 @@
+package com.crossoverjie.oom.heap;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Function:堆内存溢出
+ *
+ * @author crossoverJie
+ *         Date: 29/12/2017 18:22
+ * @since JDK 1.8
+ */
+public class HeapOOM {
+
+    public static void main(String[] args) {
+        List<String> list = new ArrayList<>(10) ;
+        while (true){
+            list.add("1") ;
+        }
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/oom/heap/MetaSpaceOOM.java b/Java-Interview/src/main/java/com/crossoverjie/oom/heap/MetaSpaceOOM.java
new file mode 100644
index 0000000..b799d8f
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/oom/heap/MetaSpaceOOM.java
@@ -0,0 +1,33 @@
+package com.crossoverjie.oom.heap;
+
+import net.sf.cglib.proxy.Enhancer;
+import net.sf.cglib.proxy.MethodInterceptor;
+import net.sf.cglib.proxy.MethodProxy;
+
+import java.lang.reflect.Method;
+
+/**
+ * Function:方法区内存溢出 1.8之后修改为元数据区
+ *
+ * @author crossoverJie
+ *         Date: 29/12/2017 21:34
+ * @since JDK 1.8
+ */
+public class MetaSpaceOOM {
+
+    public static void main(String[] args) {
+        while (true){
+            Enhancer  enhancer = new Enhancer() ;
+            enhancer.setSuperclass(HeapOOM.class);
+            enhancer.setUseCache(false) ;
+            enhancer.setCallback(new MethodInterceptor() {
+                @Override
+                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
+                    return methodProxy.invoke(o,objects) ;
+                }
+            });
+            enhancer.create() ;
+
+        }
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/proxy/cglib/RealSubject.java b/Java-Interview/src/main/java/com/crossoverjie/proxy/cglib/RealSubject.java
new file mode 100644
index 0000000..905cc73
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/proxy/cglib/RealSubject.java
@@ -0,0 +1,19 @@
+package com.crossoverjie.proxy.cglib;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 24/12/2017 19:01
+ * @since JDK 1.8
+ */
+public class RealSubject {
+    private final static Logger LOGGER = LoggerFactory.getLogger(RealSubject.class);
+
+    public void exec(){
+        LOGGER.info("real exec");
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/proxy/cglib/RealSubjectIntercept.java b/Java-Interview/src/main/java/com/crossoverjie/proxy/cglib/RealSubjectIntercept.java
new file mode 100644
index 0000000..7ab1329
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/proxy/cglib/RealSubjectIntercept.java
@@ -0,0 +1,33 @@
+package com.crossoverjie.proxy.cglib;
+
+import net.sf.cglib.proxy.MethodInterceptor;
+import net.sf.cglib.proxy.MethodProxy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.lang.reflect.Method;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 24/12/2017 19:02
+ * @since JDK 1.8
+ */
+public class RealSubjectIntercept implements MethodInterceptor{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(RealSubjectIntercept.class);
+
+
+
+
+    @Override
+    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
+
+        LOGGER.info("before");
+
+        Object invoke = methodProxy.invoke(o, objects);
+        LOGGER.info("after");
+        return invoke;
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/proxy/jdk/CustomizeHandle.java b/Java-Interview/src/main/java/com/crossoverjie/proxy/jdk/CustomizeHandle.java
new file mode 100644
index 0000000..19df41f
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/proxy/jdk/CustomizeHandle.java
@@ -0,0 +1,50 @@
+package com.crossoverjie.proxy.jdk;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 23/12/2017 22:27
+ * @since JDK 1.8
+ */
+public class CustomizeHandle implements InvocationHandler {
+    private final static Logger LOGGER = LoggerFactory.getLogger(CustomizeHandle.class);
+
+    private Object target;
+
+    public CustomizeHandle(Class clazz) {
+        try {
+            this.target = clazz.newInstance();
+        } catch (InstantiationException e) {
+            LOGGER.error("InstantiationException", e);
+        } catch (IllegalAccessException e) {
+            LOGGER.error("IllegalAccessException",e);
+        }
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+
+        before();
+        Object result = method.invoke(target, args);
+        after();
+
+        LOGGER.info("proxy class={}", proxy.getClass());
+        return result;
+    }
+
+
+    private void before() {
+        LOGGER.info("handle before");
+    }
+
+    private void after() {
+        LOGGER.info("handle after");
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/proxy/jdk/ISubject.java b/Java-Interview/src/main/java/com/crossoverjie/proxy/jdk/ISubject.java
new file mode 100644
index 0000000..424776f
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/proxy/jdk/ISubject.java
@@ -0,0 +1,16 @@
+package com.crossoverjie.proxy.jdk;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 23/12/2017 22:37
+ * @since JDK 1.8
+ */
+public interface ISubject {
+
+    /**
+     * 执行
+     */
+    void execute() ;
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/proxy/jdk/impl/ISubjectImpl.java b/Java-Interview/src/main/java/com/crossoverjie/proxy/jdk/impl/ISubjectImpl.java
new file mode 100644
index 0000000..8978a6a
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/proxy/jdk/impl/ISubjectImpl.java
@@ -0,0 +1,23 @@
+package com.crossoverjie.proxy.jdk.impl;
+
+import com.crossoverjie.proxy.jdk.ISubject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 23/12/2017 22:43
+ * @since JDK 1.8
+ */
+public class ISubjectImpl implements ISubject {
+    private final static Logger LOGGER = LoggerFactory.getLogger(ISubjectImpl.class);
+    /**
+     * 执行
+     */
+    @Override
+    public void execute() {
+        LOGGER.info("ISubjectImpl execute");
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/red/RedPacket.java b/Java-Interview/src/main/java/com/crossoverjie/red/RedPacket.java
new file mode 100644
index 0000000..402f29f
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/red/RedPacket.java
@@ -0,0 +1,137 @@
+package com.crossoverjie.red;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Function: 模拟微信红包生成，以分为单位
+ *
+ * @author crossoverJie
+ *         Date: 03/01/2018 16:52
+ * @since JDK 1.8
+ */
+public class RedPacket {
+
+    /**
+     * 生成红包最小值 1分
+     */
+    private static final int MIN_MONEY = 1 ;
+
+    /**
+     * 生成红包最大值 200人民币
+     */
+    private static final int MAX_MONEY = 200 * 100 ;
+
+    /**
+     * 小于最小值
+     */
+    private static final int LESS = -1 ;
+    /**
+     * 大于最大值
+     */
+    private static final int MORE = -2 ;
+
+    /**
+     * 正常值
+     */
+    private static final int OK = 1 ;
+
+    /**
+     * 最大的红包是平均值的 TIMES 倍，防止某一次分配红包较大
+     */
+    private static final double TIMES = 2.1F ;
+
+    private int recursiveCount = 0 ;
+
+    private List<Integer> splitRedPacket(int money,int count){
+        List<Integer> moneys = new LinkedList<>() ;
+
+        //计算出最大红包
+        int max = (int) ((money / count) * TIMES) ;
+        max = max > MAX_MONEY ? MAX_MONEY : max ;
+
+        for (int i = 0 ; i< count ; i++){
+            //随机获取红包
+            int redPacket = randomRedPacket(money, MIN_MONEY,max,count - i) ;
+            moneys.add(redPacket);
+            //总金额每次减少
+            money -= redPacket ;
+        }
+
+        return moneys ;
+    }
+
+    private int randomRedPacket(int totalMoney, int minMoney, int maxMoney, int count) {
+        //只有一个红包直接返回
+        if (count == 1){
+            return totalMoney ;
+        }
+
+        if (minMoney == maxMoney){
+            return minMoney ;
+        }
+
+        //如果最大金额大于了剩余金额 则用剩余金额 因为这个 money 每分配一次都会减小
+        maxMoney = maxMoney > totalMoney ? totalMoney : maxMoney ;
+
+        //在 minMoney到maxMoney 生成一个随机红包
+        int redPacket = (int) (Math.random() * (maxMoney - minMoney) + minMoney) ;
+
+        int lastMoney = totalMoney - redPacket ;
+
+        int status = checkMoney(lastMoney,count - 1) ;
+
+        //正常金额
+        if (OK == status){
+            return redPacket ;
+        }
+
+        //如果生成的金额不合法 则递归重新生成
+        if (LESS == status){
+            recursiveCount ++ ;
+            System.out.println("recursiveCount==" + recursiveCount);
+            return randomRedPacket(totalMoney,minMoney,redPacket,count) ;
+        }
+
+        if (MORE == status){
+            recursiveCount ++ ;
+            System.out.println("recursiveCount===" + recursiveCount);
+            return randomRedPacket(totalMoney,redPacket,maxMoney,count) ;
+        }
+
+        return redPacket ;
+    }
+
+    /**
+     * 校验剩余的金额的平均值是否在 最小值和最大值这个范围内
+     * @param lastMoney
+     * @param count
+     * @return
+     */
+    private int checkMoney(int lastMoney, int count) {
+        double avg = lastMoney / count ;
+        if (avg < MIN_MONEY){
+            return LESS ;
+        }
+
+        if (avg > MAX_MONEY){
+            return MORE ;
+        }
+
+        return OK ;
+    }
+
+
+    public static void main(String[] args) {
+        RedPacket redPacket = new RedPacket() ;
+        List<Integer> redPackets = redPacket.splitRedPacket(20000, 100);
+        System.out.println(redPackets) ;
+
+        int sum = 0 ;
+        for (Integer red : redPackets) {
+            sum += red ;
+        }
+        System.out.println(sum);
+    }
+
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/spring/LifeCycleConfig.java b/Java-Interview/src/main/java/com/crossoverjie/spring/LifeCycleConfig.java
new file mode 100644
index 0000000..fd44aa6
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/spring/LifeCycleConfig.java
@@ -0,0 +1,25 @@
+package com.crossoverjie.spring;
+
+import com.crossoverjie.concurrent.Singleton;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Function:使用 initMethod 和 destroyMethod 的方式
+ *
+ * @author crossoverJie
+ *         Date: 19/03/2018 22:37
+ * @since JDK 1.8
+ */
+@Configuration
+public class LifeCycleConfig {
+
+
+    @Bean(initMethod = "start", destroyMethod = "destroy")
+    public SpringLifeCycle create(){
+        SpringLifeCycle springLifeCycle = new SpringLifeCycle() ;
+
+        return springLifeCycle ;
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/spring/SpringLifeCycle.java b/Java-Interview/src/main/java/com/crossoverjie/spring/SpringLifeCycle.java
new file mode 100644
index 0000000..0a016b3
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/spring/SpringLifeCycle.java
@@ -0,0 +1,28 @@
+package com.crossoverjie.spring;
+
+import com.crossoverjie.Application;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 20/03/2018 18:23
+ * @since JDK 1.8
+ */
+public class SpringLifeCycle{
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycle.class);
+    public void start(){
+        LOGGER.info("SpringLifeCycle start");
+    }
+
+
+    public void destroy(){
+        LOGGER.info("SpringLifeCycle destroy");
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/spring/annotation/AnnotationBean.java b/Java-Interview/src/main/java/com/crossoverjie/spring/annotation/AnnotationBean.java
new file mode 100644
index 0000000..e848581
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/spring/annotation/AnnotationBean.java
@@ -0,0 +1,31 @@
+package com.crossoverjie.spring.annotation;
+
+import com.crossoverjie.spring.SpringLifeCycle;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+
+/**
+ * Function:用注解的方法
+ *
+ * @author crossoverJie
+ *         Date: 20/03/2018 18:46
+ * @since JDK 1.8
+ */
+@Component
+public class AnnotationBean {
+    private final static Logger LOGGER = LoggerFactory.getLogger(AnnotationBean.class);
+
+    @PostConstruct
+    public void start(){
+        LOGGER.info("AnnotationBean start");
+    }
+
+    @PreDestroy
+    public void destroy(){
+        LOGGER.info("AnnotationBean destroy");
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/spring/aware/SpringLifeCycleAware.java b/Java-Interview/src/main/java/com/crossoverjie/spring/aware/SpringLifeCycleAware.java
new file mode 100644
index 0000000..d3b288a
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/spring/aware/SpringLifeCycleAware.java
@@ -0,0 +1,29 @@
+package com.crossoverjie.spring.aware;
+
+import com.crossoverjie.Application;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.stereotype.Component;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 20/03/2018 21:54
+ * @since JDK 1.8
+ */
+@Component
+public class SpringLifeCycleAware implements ApplicationContextAware {
+    private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycleAware.class);
+
+    private ApplicationContext applicationContext ;
+
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        this.applicationContext = applicationContext ;
+        LOGGER.info("SpringLifeCycleAware start");
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/spring/processor/SpringLifeCycleProcessor.java b/Java-Interview/src/main/java/com/crossoverjie/spring/processor/SpringLifeCycleProcessor.java
new file mode 100644
index 0000000..d0d664b
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/spring/processor/SpringLifeCycleProcessor.java
@@ -0,0 +1,50 @@
+package com.crossoverjie.spring.processor;
+
+import com.crossoverjie.Application;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.stereotype.Component;
+
+/**
+ * Function:
+ *
+ * @author crossoverJie
+ *         Date: 20/03/2018 22:11
+ * @since JDK 1.8
+ */
+@Component
+public class SpringLifeCycleProcessor implements BeanPostProcessor {
+    private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycleProcessor.class);
+
+    /**
+     * 预初始化 初始化之前调用
+     * @param bean
+     * @param beanName
+     * @return
+     * @throws BeansException
+     */
+    @Override
+    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+        if ("annotationBean".equals(beanName)){
+            LOGGER.info("SpringLifeCycleProcessor start beanName={}",beanName);
+        }
+        return bean;
+    }
+
+    /**
+     * 后初始化  bean 初始化完成调用
+     * @param bean
+     * @param beanName
+     * @return
+     * @throws BeansException
+     */
+    @Override
+    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
+        if ("annotationBean".equals(beanName)){
+            LOGGER.info("SpringLifeCycleProcessor end beanName={}",beanName);
+        }
+        return bean;
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/spring/service/SpringLifeCycleService.java b/Java-Interview/src/main/java/com/crossoverjie/spring/service/SpringLifeCycleService.java
new file mode 100644
index 0000000..302aac1
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/spring/service/SpringLifeCycleService.java
@@ -0,0 +1,30 @@
+package com.crossoverjie.spring.service;
+
+import com.crossoverjie.spring.SpringLifeCycle;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Service;
+
+/**
+ * Function:实现 InitializingBean DisposableBean 接口
+ *
+ * @author crossoverJie
+ *         Date: 20/03/2018 18:38
+ * @since JDK 1.8
+ */
+@Service
+public class SpringLifeCycleService implements InitializingBean,DisposableBean{
+    private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycleService.class);
+    @Override
+    public void afterPropertiesSet() throws Exception {
+        LOGGER.info("SpringLifeCycleService start");
+    }
+
+    @Override
+    public void destroy() throws Exception {
+        LOGGER.info("SpringLifeCycleService destroy");
+    }
+}
diff --git a/Java-Interview/src/main/java/com/crossoverjie/synchronize/Synchronize.java b/Java-Interview/src/main/java/com/crossoverjie/synchronize/Synchronize.java
new file mode 100644
index 0000000..911712b
--- /dev/null
+++ b/Java-Interview/src/main/java/com/crossoverjie/synchronize/Synchronize.java
@@ -0,0 +1,17 @@
+package com.crossoverjie.synchronize;
+
+/**
+ * Function:Synchronize 演示
+ *
+ * @author crossoverJie
+ *         Date: 02/01/2018 13:27
+ * @since JDK 1.8
+ */
+public class Synchronize {
+
+    public static void main(String[] args) {
+        synchronized (Synchronize.class){
+            System.out.println("Synchronize");
+        }
+    }
+}
diff --git a/Java-Interview/src/main/resources/application.properties b/Java-Interview/src/main/resources/application.properties
new file mode 100644
index 0000000..c9ef850
--- /dev/null
+++ b/Java-Interview/src/main/resources/application.properties
@@ -0,0 +1,3 @@
+spring.application.name=java-interview
+
+logging.level.root=INFO
\ No newline at end of file
diff --git a/Java-Interview/src/main/resources/logback.xml b/Java-Interview/src/main/resources/logback.xml
new file mode 100644
index 0000000..693796b
--- /dev/null
+++ b/Java-Interview/src/main/resources/logback.xml
@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <property name="LOG_PATH" value="/logs/interview" />
+    <property name="LOG_FILE_NAME" value="interview" />
+
+    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <appender name="LOGFILE-DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>DEBUG</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+        <File>${LOG_PATH}/${LOG_FILE_NAME}-debug.log</File>
+        <rollingPolicy
+                class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+
+            <FileNamePattern>${LOG_PATH}/${LOG_FILE_NAME}_debug_%d{yyyy-MM-dd}.log.%d{yyyy-MM-dd}</FileNamePattern>
+        </rollingPolicy>
+        <encoder>
+            <pattern>[%date{yyyy-MM-dd HH:mm:ss.SSS}] [%thread] %p %C %t, - %msg%n</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+    </appender>
+
+    <appender name="LOGFILE-INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>INFO</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+        <File>${LOG_PATH}/${LOG_FILE_NAME}-info.log</File>
+        <rollingPolicy
+                class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <FileNamePattern>${LOG_PATH}/${LOG_FILE_NAME}_info_%d{yyyy-MM-dd}.log.%d{yyyy-MM-dd}</FileNamePattern>
+
+        </rollingPolicy>
+        <encoder>
+            <pattern>[%date{yyyy-MM-dd HH:mm:ss.SSS}] [%thread] %p %C %t, - %msg%n</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+    </appender>
+
+    <appender name="LOGFILE-ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>ERROR</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+        <File>${LOG_PATH}/${LOG_FILE_NAME}-error.log</File>
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <FileNamePattern>${LOG_PATH}/${LOG_FILE_NAME}_error_%d{yyyy-MM-dd}.%d{yyyy-MM-dd}</FileNamePattern>
+        </rollingPolicy>
+        <encoder>
+            <pattern>[%date{yyyy-MM-dd HH:mm:ss.SSS}] [%thread] %p %C %t, - %msg%n</pattern>
+            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
+        </encoder>
+        <!--<layout class="ch.qos.logback.classic.PatternLayout">
+            <pattern>[%date{yyyy-MM-dd HH:mm:ss.SSS}] [%thread] %p %C %t, - %msg%n</pattern>
+        </layout>-->
+    </appender>
+
+    
+    <logger name="com.crossoverjie">
+        <level value="INFO" />
+        <appender-ref ref="LOGFILE-INFO"/>
+    </logger>
+
+
+    <root level="INFO">
+        <appender-ref ref="LOGFILE-DEBUG" />
+        <appender-ref ref="LOGFILE-INFO" />
+        <appender-ref ref="LOGFILE-ERROR" />
+        <appender-ref ref="CONSOLE" />
+    </root>
+
+
+</configuration>
\ No newline at end of file
diff --git a/Java-Interview/src/test/java/com/crossoverjie/actual/AbstractMapTest.java b/Java-Interview/src/test/java/com/crossoverjie/actual/AbstractMapTest.java
new file mode 100644
index 0000000..a384d5b
--- /dev/null
+++ b/Java-Interview/src/test/java/com/crossoverjie/actual/AbstractMapTest.java
@@ -0,0 +1,36 @@
+package com.crossoverjie.actual;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class AbstractMapTest {
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(AbstractMapTest.class);
+
+    @Test
+    public void test(){
+        LRUAbstractMap map = new LRUAbstractMap() ;
+        map.put(1,1) ;
+        map.put(2,2) ;
+
+        Object o = map.get(1);
+        LOGGER.info("getSize={}",map.size());
+
+        map.remove(1) ;
+        LOGGER.info("getSize"+map.size());
+    }
+
+    public static void main(String[] args) {
+        LRUAbstractMap map = new LRUAbstractMap() ;
+        map.put(1,1) ;
+        map.put(2,2) ;
+
+        Object o = map.get(1);
+        LOGGER.info("getSize={}",map.size());
+
+        map.remove(1) ;
+        map.remove(2) ;
+        LOGGER.info("getSize"+map.size());
+    }
+}
\ No newline at end of file
diff --git a/Java-Interview/src/test/java/com/crossoverjie/actual/LRULinkedMapTest.java b/Java-Interview/src/test/java/com/crossoverjie/actual/LRULinkedMapTest.java
new file mode 100644
index 0000000..600344f
--- /dev/null
+++ b/Java-Interview/src/test/java/com/crossoverjie/actual/LRULinkedMapTest.java
@@ -0,0 +1,65 @@
+package com.crossoverjie.actual;
+
+import org.junit.Test;
+
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class LRULinkedMapTest {
+    @Test
+    public void put() throws Exception {
+        LRULinkedMap<String,Integer> map = new LRULinkedMap(3) ;
+        map.put("1",1);
+        map.put("2",2);
+        map.put("3",3);
+
+        for (Map.Entry<String, Integer> e : map.getAll()){
+            System.out.print(e.getKey() + " : " + e.getValue() + "\t");
+        }
+
+        System.out.println("");
+        map.put("4",4);
+        for (Map.Entry<String, Integer> e : map.getAll()){
+            System.out.print(e.getKey() + " : " + e.getValue() + "\t");
+        }
+    }
+
+    @Test
+    public void put2() throws Exception {
+        LRULinkedMap<String,Integer> map = new LRULinkedMap(4) ;
+        map.put("1",1);
+        map.put("2",2);
+        map.put("3",3);
+        map.put("4",4);
+
+        for (Map.Entry<String, Integer> e : map.getAll()){
+            System.out.print(e.getKey() + " : " + e.getValue() + "\t");
+        }
+
+        System.out.println("");
+        map.put("5",5);
+        for (Map.Entry<String, Integer> e : map.getAll()){
+            System.out.print(e.getKey() + " : " + e.getValue() + "\t");
+        }
+    }
+    @Test
+    public void get() throws Exception {
+        LRULinkedMap<String,Integer> map = new LRULinkedMap(4) ;
+        map.put("1",1);
+        map.put("2",2);
+        map.put("3",3);
+        map.put("4",4);
+
+        for (Map.Entry<String, Integer> e : map.getAll()){
+            System.out.print(e.getKey() + " : " + e.getValue() + "\t");
+        }
+
+        System.out.println("");
+        map.get("1") ;
+        for (Map.Entry<String, Integer> e : map.getAll()){
+            System.out.print(e.getKey() + " : " + e.getValue() + "\t");
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/Java-Interview/src/test/java/com/crossoverjie/actual/LRUMapTest.java b/Java-Interview/src/test/java/com/crossoverjie/actual/LRUMapTest.java
new file mode 100644
index 0000000..eb9dcc2
--- /dev/null
+++ b/Java-Interview/src/test/java/com/crossoverjie/actual/LRUMapTest.java
@@ -0,0 +1,121 @@
+package com.crossoverjie.actual;
+
+import com.alibaba.fastjson.JSON;
+import com.sun.org.apache.bcel.internal.generic.LUSHR;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class LRUMapTest {
+
+    @Test
+    public void put() throws Exception {
+        LRUMap<String,Integer> lruMap = new LRUMap(3) ;
+        lruMap.put("1",1) ;
+        lruMap.put("2",2) ;
+        lruMap.put("3",3) ;
+
+        System.out.println(lruMap.toString());
+
+        lruMap.put("4",4) ;
+        System.out.println(lruMap.toString());
+
+        lruMap.put("5",5) ;
+        System.out.println(lruMap.toString());
+    }
+    @Test
+    public void put2() throws Exception {
+        LRUMap<String,Integer> lruMap = new LRUMap(4) ;
+        lruMap.put("1",1) ;
+        lruMap.put("2",2) ;
+        lruMap.put("3",3) ;
+
+        System.out.println(lruMap.toString());
+
+        lruMap.put("4",4) ;
+        System.out.println(lruMap.toString());
+
+        lruMap.put("5",5) ;
+        System.out.println(lruMap.toString());
+    }
+
+    @Test
+    public void put3() throws Exception {
+        LRUMap<String,Integer> lruMap = new LRUMap(4) ;
+        lruMap.put("1",1) ;
+        lruMap.put("2",2) ;
+        lruMap.put("3",3) ;
+        lruMap.put("2",2) ;
+
+        System.out.println(lruMap.toString());
+
+        lruMap.put("4",4) ;
+        System.out.println(lruMap.toString());
+
+        lruMap.put("5",5) ;
+        System.out.println(lruMap.toString());
+    }
+
+    @Test
+    public void put4() throws Exception {
+        LRUMap<String,Integer> lruMap = new LRUMap(3) ;
+        lruMap.put("1",1) ;
+        lruMap.put("2",2) ;
+        lruMap.put("3",3) ;
+
+        System.out.println(lruMap.toString());
+        lruMap.put("2",2) ;
+
+        System.out.println(lruMap.toString());
+
+    }
+
+    @Test
+    public void get() throws Exception {
+        LRUMap<String,Integer> lruMap = new LRUMap(3) ;
+        lruMap.put("1",1) ;
+        lruMap.put("2",2) ;
+        lruMap.put("3",3) ;
+
+        System.out.println(lruMap.toString());
+        System.out.println("==============");
+
+        Integer integer = lruMap.get("1");
+        System.out.println(integer);
+        System.out.println("==============");
+        System.out.println(lruMap.toString());
+    }
+
+    @Test
+    public void get2() throws Exception {
+        LRUMap<String,Integer> lruMap = new LRUMap(3) ;
+        lruMap.put("1",1) ;
+        lruMap.put("2",2) ;
+        lruMap.put("3",3) ;
+
+        System.out.println(lruMap.toString());
+        System.out.println("==============");
+
+        Integer integer = lruMap.get("2");
+        System.out.println(integer);
+        System.out.println("==============");
+        System.out.println(lruMap.toString());
+    }
+
+    @Test
+    public void get3() throws Exception {
+        LRUMap<String,Integer> lruMap = new LRUMap(3) ;
+        lruMap.put("1",1) ;
+        lruMap.put("2",2) ;
+        lruMap.put("3",3) ;
+
+        System.out.println(lruMap.toString());
+        System.out.println("==============");
+
+        Integer integer = lruMap.get("3");
+        System.out.println(integer);
+        System.out.println("==============");
+        System.out.println(lruMap.toString());
+    }
+
+}
\ No newline at end of file
diff --git a/Java-Interview/src/test/java/com/crossoverjie/algorithm/BinaryNodeTest.java b/Java-Interview/src/test/java/com/crossoverjie/algorithm/BinaryNodeTest.java
new file mode 100644
index 0000000..b9e8519
--- /dev/null
+++ b/Java-Interview/src/test/java/com/crossoverjie/algorithm/BinaryNodeTest.java
@@ -0,0 +1,19 @@
+package com.crossoverjie.algorithm;
+
+import org.junit.Test;
+
+public class BinaryNodeTest {
+
+    @Test
+    public void test1(){
+        BinaryNode node = new BinaryNode() ;
+        //创建二叉树
+        node = node.createNode() ;
+        System.out.println(node);
+
+        //中序遍历二叉树
+        node.levelIterator(node) ;
+
+    }
+
+}
\ No newline at end of file
diff --git a/Java-Interview/src/test/java/com/crossoverjie/algorithm/HappyNumTest.java b/Java-Interview/src/test/java/com/crossoverjie/algorithm/HappyNumTest.java
new file mode 100644
index 0000000..6f5b8d3
--- /dev/null
+++ b/Java-Interview/src/test/java/com/crossoverjie/algorithm/HappyNumTest.java
@@ -0,0 +1,28 @@
+package com.crossoverjie.algorithm;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class HappyNumTest {
+    @Test
+    public void isHappy() throws Exception {
+        HappyNum happyNum = new HappyNum() ;
+        boolean happy = happyNum.isHappy(19);
+        Assert.assertEquals(happy,true);
+    }
+
+    @Test
+    public void isHappy2() throws Exception {
+        HappyNum happyNum = new HappyNum() ;
+        boolean happy = happyNum.isHappy(11);
+        Assert.assertEquals(happy,false);
+    }
+
+    @Test
+    public void isHappy3() throws Exception {
+        HappyNum happyNum = new HappyNum() ;
+        boolean happy = happyNum.isHappy(100);
+        System.out.println(happy);
+    }
+
+}
\ No newline at end of file
diff --git a/Java-Interview/src/test/java/com/crossoverjie/algorithm/LinkLoopTest.java b/Java-Interview/src/test/java/com/crossoverjie/algorithm/LinkLoopTest.java
new file mode 100644
index 0000000..5fa0e84
--- /dev/null
+++ b/Java-Interview/src/test/java/com/crossoverjie/algorithm/LinkLoopTest.java
@@ -0,0 +1,62 @@
+package com.crossoverjie.algorithm;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class LinkLoopTest {
+
+    /**
+     * 无环
+     * @throws Exception
+     */
+    @Test
+    public void isLoop() throws Exception {
+        LinkLoop.Node node3 = new LinkLoop.Node("3");
+        LinkLoop.Node node2 = new LinkLoop.Node("2") ;
+        LinkLoop.Node node1 = new LinkLoop.Node("1") ;
+
+        node1.next = node2 ;
+        node2.next = node3 ;
+
+        LinkLoop linkLoop = new LinkLoop() ;
+        boolean loop = linkLoop.isLoop(node1);
+        Assert.assertEquals(loop,false);
+    }
+
+    /**
+     * 有环
+     * @throws Exception
+     */
+    @Test
+    public void isLoop2() throws Exception {
+        LinkLoop.Node node3 = new LinkLoop.Node("3");
+        LinkLoop.Node node2 = new LinkLoop.Node("2") ;
+        LinkLoop.Node node1 = new LinkLoop.Node("1") ;
+
+        node1.next = node2 ;
+        node2.next = node3 ;
+        node3.next = node1 ;
+
+        LinkLoop linkLoop = new LinkLoop() ;
+        boolean loop = linkLoop.isLoop(node1);
+        Assert.assertEquals(loop,true);
+    }
+
+    /**
+     * 无环
+     * @throws Exception
+     */
+    @Test
+    public void isLoop3() throws Exception {
+        LinkLoop.Node node2 = new LinkLoop.Node("2") ;
+        LinkLoop.Node node1 = new LinkLoop.Node("1") ;
+
+        node1.next = node2 ;
+
+
+        LinkLoop linkLoop = new LinkLoop() ;
+        boolean loop = linkLoop.isLoop(node1);
+        Assert.assertEquals(loop,false);
+    }
+
+}
\ No newline at end of file
diff --git a/Java-Interview/src/test/java/com/crossoverjie/algorithm/MergeTwoSortedListsTest.java b/Java-Interview/src/test/java/com/crossoverjie/algorithm/MergeTwoSortedListsTest.java
new file mode 100644
index 0000000..72b21ba
--- /dev/null
+++ b/Java-Interview/src/test/java/com/crossoverjie/algorithm/MergeTwoSortedListsTest.java
@@ -0,0 +1,93 @@
+package com.crossoverjie.algorithm;
+
+import com.crossoverjie.algorithm.MergeTwoSortedLists.ListNode;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class MergeTwoSortedListsTest {
+    MergeTwoSortedLists mergeTwoSortedLists ;
+    @Before
+    public void setUp() throws Exception {
+        mergeTwoSortedLists = new MergeTwoSortedLists();
+    }
+
+    @Test
+    public void mergeTwoLists() throws Exception {
+        ListNode l1 = new ListNode(1) ;
+        ListNode l1_2 = new ListNode(4);
+        l1.next = l1_2 ;
+        ListNode l1_3 = new ListNode(5) ;
+        l1_2.next = l1_3 ;
+
+        ListNode l2 = new ListNode(1) ;
+        ListNode l2_2 = new ListNode(3) ;
+        l2.next = l2_2 ;
+        ListNode l2_3 = new ListNode(6) ;
+        l2_2.next = l2_3 ;
+        ListNode l2_4 = new ListNode(9) ;
+        l2_3.next = l2_4 ;
+        ListNode listNode = mergeTwoSortedLists.mergeTwoLists(l1, l2);
+
+
+        ListNode node1 = new ListNode(1) ;
+        ListNode node2 = new ListNode(1);
+        node1.next = node2;
+        ListNode node3 = new ListNode(3) ;
+        node2.next= node3 ;
+        ListNode node4 = new ListNode(4) ;
+        node3.next = node4 ;
+        ListNode node5 = new ListNode(5) ;
+        node4.next = node5 ;
+        ListNode node6 = new ListNode(6) ;
+        node5.next = node6 ;
+        ListNode node7 = new ListNode(9) ;
+        node6.next = node7 ;
+        Assert.assertEquals(node1.toString(),listNode.toString());
+
+
+    }
+
+    @Test
+    public void mergeTwoLists2() throws Exception {
+
+        ListNode l2 = new ListNode(1) ;
+        ListNode l2_2 = new ListNode(3) ;
+        l2.next = l2_2 ;
+        ListNode l2_3 = new ListNode(6) ;
+        l2_2.next = l2_3 ;
+        ListNode l2_4 = new ListNode(9) ;
+        l2_3.next = l2_4 ;
+        ListNode listNode = mergeTwoSortedLists.mergeTwoLists(null, l2);
+
+        System.out.println(listNode.toString());
+
+
+    }
+
+    @Test
+    public void mergeTwoLists3() throws Exception {
+
+        ListNode l2 = new ListNode(1) ;
+        ListNode l2_2 = new ListNode(3) ;
+        l2.next = l2_2 ;
+        ListNode l2_3 = new ListNode(6) ;
+        l2_2.next = l2_3 ;
+        ListNode l2_4 = new ListNode(9) ;
+        l2_3.next = l2_4 ;
+        ListNode listNode = mergeTwoSortedLists.mergeTwoLists(l2, null);
+
+
+        ListNode node1 = new ListNode(1) ;
+        ListNode node2 = new ListNode(3);
+        node1.next = node2;
+        ListNode node3 = new ListNode(6) ;
+        node2.next= node3 ;
+        ListNode node4 = new ListNode(9) ;
+        node3.next = node4 ;
+
+        Assert.assertEquals(node1.toString(),listNode.toString());
+
+    }
+
+}
\ No newline at end of file
diff --git a/Java-Interview/src/test/java/com/crossoverjie/algorithm/ReverseNodeTest.java b/Java-Interview/src/test/java/com/crossoverjie/algorithm/ReverseNodeTest.java
new file mode 100644
index 0000000..301f1a0
--- /dev/null
+++ b/Java-Interview/src/test/java/com/crossoverjie/algorithm/ReverseNodeTest.java
@@ -0,0 +1,66 @@
+package com.crossoverjie.algorithm;
+
+import org.junit.Test;
+import static com.crossoverjie.algorithm.ReverseNode.Node;
+
+public class ReverseNodeTest {
+
+    @Test
+    public void reverseNode1() throws Exception {
+        ReverseNode.Node<String> node4 = new Node<>("4",null) ;
+        Node<String> node3 = new Node<>("3",node4);
+        Node<String> node2 = new Node<>("2",node3);
+        Node<String> node1 = new Node("1",node2) ;
+
+        ReverseNode reverseNode = new ReverseNode() ;
+        reverseNode.reverseNode1(node1);
+    }
+
+    @Test
+    public void reverseNode12() throws Exception {
+
+        Node<String> node1 = new Node("1",null) ;
+
+        ReverseNode reverseNode = new ReverseNode() ;
+        reverseNode.reverseNode1(node1);
+    }
+
+    @Test
+    public void reverseNode13() throws Exception {
+
+        Node<String> node1 = null ;
+
+        ReverseNode reverseNode = new ReverseNode() ;
+        reverseNode.reverseNode1(node1);
+    }
+
+
+    /**
+     * 头插法
+     * @throws Exception
+     */
+    @Test
+    public void reverseHead21() throws Exception {
+        Node<String> node4 = new Node<>("4",null) ;
+        Node<String> node3 = new Node<>("3",node4);
+        Node<String> node2 = new Node<>("2",node3);
+        Node<String> node1 = new Node("1",node2) ;
+
+        ReverseNode reverseNode = new ReverseNode() ;
+        reverseNode.reverseNode(node1);
+
+    }
+
+
+    @Test
+    public void recNodeTest31(){
+        Node<String> node4 = new Node<>("4",null) ;
+        Node<String> node3 = new Node<>("3",node4);
+        Node<String> node2 = new Node<>("2",node3);
+        Node<String> node1 = new Node("1",node2) ;
+
+        ReverseNode reverseNode = new ReverseNode() ;
+        reverseNode.recNode(node1);
+    }
+
+}
\ No newline at end of file
diff --git a/Java-Interview/src/test/java/com/crossoverjie/algorithm/TwoStackQueueTest.java b/Java-Interview/src/test/java/com/crossoverjie/algorithm/TwoStackQueueTest.java
new file mode 100644
index 0000000..dc0cda8
--- /dev/null
+++ b/Java-Interview/src/test/java/com/crossoverjie/algorithm/TwoStackQueueTest.java
@@ -0,0 +1,36 @@
+package com.crossoverjie.algorithm;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TwoStackQueueTest {
+    private final static Logger LOGGER = LoggerFactory.getLogger(TwoStackQueueTest.class);
+    @Test
+    public void queue(){
+        TwoStackQueue<String> twoStackQueue = new TwoStackQueue<String>() ;
+        twoStackQueue.appendTail("1") ;
+        twoStackQueue.appendTail("2") ;
+        twoStackQueue.appendTail("3") ;
+        twoStackQueue.appendTail("4") ;
+        twoStackQueue.appendTail("5") ;
+
+
+        int size = twoStackQueue.getSize();
+
+        for (int i = 0; i< size ; i++){
+            LOGGER.info(twoStackQueue.deleteHead());
+        }
+
+        LOGGER.info("========第二次添加=========");
+
+        twoStackQueue.appendTail("6") ;
+
+        size = twoStackQueue.getSize();
+
+        for (int i = 0; i< size ; i++){
+            LOGGER.info(twoStackQueue.deleteHead());
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/Java-Interview/src/test/java/com/crossoverjie/algorithm/TwoSumTest.java b/Java-Interview/src/test/java/com/crossoverjie/algorithm/TwoSumTest.java
new file mode 100644
index 0000000..75c0f2a
--- /dev/null
+++ b/Java-Interview/src/test/java/com/crossoverjie/algorithm/TwoSumTest.java
@@ -0,0 +1,25 @@
+package com.crossoverjie.algorithm;
+
+import com.alibaba.fastjson.JSON;
+import org.junit.Test;
+
+public class TwoSumTest {
+    @Test
+    public void getTwo1() throws Exception {
+        TwoSum twoSum = new TwoSum() ;
+        int[] nums ={1,3,5,7};
+        int[] two1 = twoSum.getTwo1(nums, 12);
+        System.out.println(JSON.toJSONString(two1));
+
+    }
+
+    @Test
+    public void getTwo2(){
+        TwoSum twoSum = new TwoSum() ;
+        int[] nums ={1,3,5,7};
+        int[] two = twoSum.getTwo2(nums, 10);
+        System.out.println(JSON.toJSONString(two));
+
+    }
+
+}
\ No newline at end of file
diff --git a/Java-Interview/src/test/java/com/crossoverjie/proxy/JDKProxyTest.java b/Java-Interview/src/test/java/com/crossoverjie/proxy/JDKProxyTest.java
new file mode 100644
index 0000000..56aaab4
--- /dev/null
+++ b/Java-Interview/src/test/java/com/crossoverjie/proxy/JDKProxyTest.java
@@ -0,0 +1,44 @@
+package com.crossoverjie.proxy;
+
+import com.crossoverjie.proxy.jdk.CustomizeHandle;
+import com.crossoverjie.proxy.jdk.ISubject;
+import com.crossoverjie.proxy.jdk.impl.ISubjectImpl;
+import org.junit.Test;
+import sun.misc.ProxyGenerator;
+
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.lang.reflect.Proxy;
+
+/**
+ * Function: JDK 代理单测
+ *
+ * @author crossoverJie
+ *         Date: 23/12/2017 22:40
+ * @since JDK 1.8
+ */
+public class JDKProxyTest {
+
+    @Test
+    public void test(){
+        CustomizeHandle handle = new CustomizeHandle(ISubjectImpl.class) ;
+        ISubject subject = (ISubject) Proxy.newProxyInstance(JDKProxyTest.class.getClassLoader(), new Class[]{ISubject.class}, handle);
+        subject.execute() ;
+    }
+
+    @Test
+    public void clazzTest(){
+        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
+                "$Proxy1", new Class[]{ISubject.class}, 1);
+        try {
+            FileOutputStream out = new FileOutputStream("/Users/chenjie/Documents/$Proxy1.class") ;
+            out.write(proxyClassFile);
+            out.close();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/TIJ4-code/pom.xml b/TIJ4-code/pom.xml
new file mode 100644
index 0000000..027f3a7
--- /dev/null
+++ b/TIJ4-code/pom.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>java-codes</artifactId>
+        <groupId>com.github.lihengming</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <packaging>pom</packaging>
+    <artifactId>TIJ4-code</artifactId>
+
+
+</project>
\ No newline at end of file
diff --git a/TIJ4-code/src/main/java/annotations/ExtractInterface.java b/TIJ4-code/src/main/java/annotations/ExtractInterface.java
new file mode 100644
index 0000000..d53e3a0
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/ExtractInterface.java
@@ -0,0 +1,15 @@
+package annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Created by zhangchunhui on 2018/7/23.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.SOURCE)
+public @interface ExtractInterface {
+    public String value();
+}
diff --git a/TIJ4-code/src/main/java/annotations/InterfaceExtractorProcessor.java b/TIJ4-code/src/main/java/annotations/InterfaceExtractorProcessor.java
new file mode 100644
index 0000000..d92320f
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/InterfaceExtractorProcessor.java
@@ -0,0 +1,9 @@
+package annotations;
+
+
+
+/**
+ * Created by zhangchunhui on 2018/7/23.
+ */
+public class InterfaceExtractorProcessor {
+}
diff --git a/TIJ4-code/src/main/java/annotations/Multiplier.java b/TIJ4-code/src/main/java/annotations/Multiplier.java
new file mode 100644
index 0000000..a13cfdc
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/Multiplier.java
@@ -0,0 +1,26 @@
+package annotations;
+
+/**
+ * Created by zhangchunhui on 2018/7/23.
+ */
+@ExtractInterface("IMultiplier")
+public class Multiplier {
+    public int multiply(int x, int y) {
+        int total = 0;
+        for (int i = 0; i < x; i++) {
+            total = add(total, y);
+        }
+        return total;
+    }
+
+    private int add(int x, int y) {
+        return x + y;
+    }
+
+    public static void main(String[] args) {
+        Multiplier m = new Multiplier();
+        System.out.println("11*16 = " + m.multiply(11, 16));
+    }
+
+
+}
diff --git a/TIJ4-code/src/main/java/annotations/PasswordUtils.java b/TIJ4-code/src/main/java/annotations/PasswordUtils.java
new file mode 100644
index 0000000..cf631ff
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/PasswordUtils.java
@@ -0,0 +1,25 @@
+package annotations;
+
+import java.util.List;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ */
+public class PasswordUtils {
+
+    @UseCase(id = 47, description = "Passwords must contain at least one numeric")
+    public boolean validayePassword(String password) {
+        return password.matches("\\w*\\d\\w*");
+    }
+
+    @UseCase(id = 48)
+    public String encryptPassword(String password) {
+        return new StringBuilder(password).reverse().toString();
+    }
+
+    @UseCase(id = 49, description = "New passwords can't equals prebiously used ones")
+    public boolean checkForNewPassword(List<String> prePasswords, String password) {
+        return !prePasswords.contains(password);
+    }
+
+}
diff --git a/TIJ4-code/src/main/java/annotations/SimulatingNull.java b/TIJ4-code/src/main/java/annotations/SimulatingNull.java
new file mode 100644
index 0000000..49948e8
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/SimulatingNull.java
@@ -0,0 +1,10 @@
+package annotations;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ * 默认值限制
+ */
+public @interface SimulatingNull {
+    public int id() default -1;
+    public String description() default "";
+}
diff --git a/TIJ4-code/src/main/java/annotations/Test.java b/TIJ4-code/src/main/java/annotations/Test.java
new file mode 100644
index 0000000..5145a0b
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/Test.java
@@ -0,0 +1,14 @@
+package annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Test {
+}
diff --git a/TIJ4-code/src/main/java/annotations/UseCase.java b/TIJ4-code/src/main/java/annotations/UseCase.java
new file mode 100644
index 0000000..c6850ec
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/UseCase.java
@@ -0,0 +1,16 @@
+package annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface UseCase {
+    public int id();
+    public String description() default "no description";
+}
diff --git a/TIJ4-code/src/main/java/annotations/UseCaseTracker.java b/TIJ4-code/src/main/java/annotations/UseCaseTracker.java
new file mode 100644
index 0000000..3d76be2
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/UseCaseTracker.java
@@ -0,0 +1,32 @@
+package annotations;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ */
+public class UseCaseTracker {
+
+    public static void trackUseCases(List<Integer> useCases, Class<?> cl) {
+        for (Method m :cl.getDeclaredMethods()){
+            UseCase uc = m.getDeclaredAnnotation(UseCase.class);
+            if (uc!=null){
+                System.out.println("Found UseCase:"+uc.id()+" "+uc.description());
+                useCases.remove(new Integer(uc.id()));
+            }
+        }
+        for (Integer i : useCases){
+            System.out.println("Warning:Missing UseCase-"+i);
+        }
+    }
+
+    public static void main(String[] args) {
+
+        List<Integer> useCases = new ArrayList<>();
+        Collections.addAll(useCases,47,48,49,50);
+        trackUseCases(useCases,PasswordUtils.class);
+    }
+}
diff --git a/TIJ4-code/src/main/java/annotations/annotations.md b/TIJ4-code/src/main/java/annotations/annotations.md
new file mode 100644
index 0000000..77e95a1
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/annotations.md
@@ -0,0 +1,2 @@
+## 注解
+* 注解（也被称为元数据）为我们在代码中添加信息提供了一种形式化的方法，使我们可以在稍后某个时刻非常方便的使用这些数据。
diff --git a/TIJ4-code/src/main/java/annotations/database/Constraints.java b/TIJ4-code/src/main/java/annotations/database/Constraints.java
new file mode 100644
index 0000000..35d9c10
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/database/Constraints.java
@@ -0,0 +1,17 @@
+package annotations.database;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Constraints {
+    boolean primaryKey() default  false;
+    boolean allowNull() default true;
+    boolean unique() default false;
+}
diff --git a/TIJ4-code/src/main/java/annotations/database/DBTable.java b/TIJ4-code/src/main/java/annotations/database/DBTable.java
new file mode 100644
index 0000000..b7b6439
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/database/DBTable.java
@@ -0,0 +1,16 @@
+package annotations.database;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DBTable {
+    public String name() default "";
+
+}
diff --git a/TIJ4-code/src/main/java/annotations/database/Member.java b/TIJ4-code/src/main/java/annotations/database/Member.java
new file mode 100644
index 0000000..a4f3e51
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/database/Member.java
@@ -0,0 +1,59 @@
+package annotations.database;
+
+import java.util.Date;
+
+/**
+ * Created by zhangchunhui on 2018/7/23.
+ */
+@DBTable(name = "MEMBER")
+public class Member {
+
+    @SQLString(30)
+    String firstName;
+    @SQLString(50)
+    String lastName;
+    @SQLInteger
+    Integer age;
+
+    @SQLDouble(size = 10,d=6)
+    float weight;
+    @SQLDate
+    Date birthDay;
+    @SQLString(value = 30, contraints = @Constraints(primaryKey = true))
+    String handle;
+    static int memberCount;
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+
+    public String getHandle() {
+        return handle;
+    }
+
+    public static int getMemberCount() {
+        return memberCount;
+    }
+
+    public float getWeight() {
+        return weight;
+    }
+
+    @Override
+    public String toString() {
+        return "Member{" +
+                "firstName='" + firstName + '\'' +
+                ", lastName='" + lastName + '\'' +
+                ", age=" + age +
+                ", handle='" + handle + '\'' +
+                '}';
+    }
+}
diff --git a/TIJ4-code/src/main/java/annotations/database/SQLDate.java b/TIJ4-code/src/main/java/annotations/database/SQLDate.java
new file mode 100644
index 0000000..66921ab
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/database/SQLDate.java
@@ -0,0 +1,16 @@
+package annotations.database;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface SQLDate {
+    String name() default "";
+    Constraints contraints() default @Constraints;
+}
diff --git a/TIJ4-code/src/main/java/annotations/database/SQLDouble.java b/TIJ4-code/src/main/java/annotations/database/SQLDouble.java
new file mode 100644
index 0000000..e63d49e
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/database/SQLDouble.java
@@ -0,0 +1,18 @@
+package annotations.database;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface SQLDouble {
+    int size() default 0; //长度
+    int d() default 0;//小数精度
+    String name() default "";
+    Constraints contraints() default @Constraints;
+}
diff --git a/TIJ4-code/src/main/java/annotations/database/SQLInteger.java b/TIJ4-code/src/main/java/annotations/database/SQLInteger.java
new file mode 100644
index 0000000..2ca30a7
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/database/SQLInteger.java
@@ -0,0 +1,16 @@
+package annotations.database;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface SQLInteger {
+    String name() default "";
+    Constraints contraints() default @Constraints;
+}
diff --git a/TIJ4-code/src/main/java/annotations/database/SQLString.java b/TIJ4-code/src/main/java/annotations/database/SQLString.java
new file mode 100644
index 0000000..a1a1418
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/database/SQLString.java
@@ -0,0 +1,17 @@
+package annotations.database;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface SQLString {
+    int value() default 0;
+    String name() default "";
+    Constraints contraints() default @Constraints;
+}
diff --git a/TIJ4-code/src/main/java/annotations/database/TableCreator.java b/TIJ4-code/src/main/java/annotations/database/TableCreator.java
new file mode 100644
index 0000000..b8ebc61
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/database/TableCreator.java
@@ -0,0 +1,95 @@
+package annotations.database;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by zhangchunhui on 2018/7/23.
+ */
+public class TableCreator {
+    public static void main(String[] args) throws Exception {
+        if (args.length < 1) {
+            System.out.println("arguments: annotated classes");
+            System.exit(0);
+        }
+        System.out.println("----------------");
+        for (String className : args) {
+            Class<?> cl = Class.forName(className);
+            DBTable dbTable = cl.getAnnotation(DBTable.class);
+            if (dbTable == null) {
+                System.out.println("No DBTable annotations in class " + className);
+                continue;
+            }
+            String tableName = dbTable.name();
+            if (tableName.length() < 1) {
+                tableName = cl.getName().toUpperCase();
+            }
+            List<String> columnDefs = new ArrayList<>();
+            for (Field field : cl.getDeclaredFields()) {
+                String columnName = null;
+                Annotation[] anns = field.getDeclaredAnnotations();
+                if (anns.length < 1) {
+                    continue;
+                }
+                if (anns[0] instanceof SQLInteger) {
+                    SQLInteger sInt = (SQLInteger) anns[0];
+                    if (sInt.name().length() < 1) {
+                        columnName = field.getName().toUpperCase();
+                    } else {
+                        columnName = sInt.name();
+                    }
+                    columnDefs.add(columnName + " INT" + getConstraints(sInt.contraints()));
+                }
+                if (anns[0] instanceof SQLString) {
+                    SQLString sqlString = (SQLString) anns[0];
+                    if (sqlString.name().length() < 1) {
+                        columnName = field.getName().toUpperCase();
+                    } else {
+                        columnName = sqlString.name();
+                    }
+                    columnDefs.add(columnName + " VARCHAR(" + sqlString.value() + ")" + getConstraints(sqlString.contraints()));
+                }
+                if (anns[0] instanceof SQLDouble) {
+                    SQLDouble sqlDouble = (SQLDouble) anns[0];
+                    if (sqlDouble.name().length() < 1) {
+                        columnName = field.getName().toUpperCase();
+                    } else {
+                        columnName = sqlDouble.name();
+                    }
+                    columnDefs.add(columnName + " decimal(" + sqlDouble.size()+","+sqlDouble.d() + ")" + getConstraints(sqlDouble.contraints()));
+                }
+                if (anns[0] instanceof SQLDate) {
+                    SQLDate sqlDate = (SQLDate) anns[0];
+                    if (sqlDate.name().length() < 1) {
+                        columnName = field.getName().toUpperCase();
+                    } else {
+                        columnName = sqlDate.name();
+                    }
+                    columnDefs.add(columnName + " datetime "+ getConstraints(sqlDate.contraints()));
+                }
+                StringBuilder creatCommand = new StringBuilder("CREATE TABLE " + tableName + "(");
+                for (String colemnDef : columnDefs) {
+                    creatCommand.append("\n   " + colemnDef + ",");
+                }
+                String tableCreate = creatCommand.substring(0, creatCommand.length() - 1) + ");";
+                System.out.println("Table Creation SQL for " + tableName + " is :\n" + tableCreate);
+            }
+        }
+    }
+
+    private static String getConstraints(Constraints con) {
+        String constrains = "";
+        if (!con.allowNull()) {
+            constrains += " NOT NULL";
+        }
+        if (con.primaryKey()) {
+            constrains += " PRIMARY KEY";
+        }
+        if (con.unique()) {
+            constrains += " UNIQUE";
+        }
+        return constrains;
+    }
+}
diff --git a/TIJ4-code/src/main/java/annotations/database/Uniqueness.java b/TIJ4-code/src/main/java/annotations/database/Uniqueness.java
new file mode 100644
index 0000000..8a2844a
--- /dev/null
+++ b/TIJ4-code/src/main/java/annotations/database/Uniqueness.java
@@ -0,0 +1,15 @@
+package annotations.database;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Created by zhangchunhui on 2018/7/22.
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Uniqueness {
+    Constraints contraints() default @Constraints(unique = true);
+}
diff --git a/design-pattern/src/main/java/README.md b/design-pattern/src/main/java/README.md
new file mode 100644
index 0000000..40a53d7
--- /dev/null
+++ b/design-pattern/src/main/java/README.md
@@ -0,0 +1,38 @@
+## 一.设计模式定义（Design Patterns)
+设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。  
+使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。  
+ 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。  
+ 项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。
+
+## 二.设计模式的分类
+总体来说设计模式分为三大类：
+* 创建型模式（Creational），共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
+* 结构型模式(Structural)，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
+* 行为型模式(Behavioral)，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
+* 其实还有两类：并发型模式和线程池模式。
+
+## 三、设计模式的六大原则
+* 1、开闭原则（Open Close Principle）  
+开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
+* 2、里氏代换原则（Liskov Substitution Principle）  
+里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科
+* 3、依赖倒转原则（Dependence Inversion Principle）  
+这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。
+* 4、接口隔离原则（Interface Segregation Principle）  
+这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
+* 5、迪米特法则（最少知道原则）（Demeter Principle）  
+为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
+* 6、合成复用原则（Composite Reuse Principle）  
+原则是尽量使用合成/聚合的方式，而不是使用继承。
+
+## 设计原则：(重要)
+* 1.逻辑代码独立到单独的方法中，注重封装性--易读，易复用。  
+ 不要在一个方法中，写下上百行的逻辑代码。  
+ 把各小逻辑代码独立出来，写于其它方法中，易读其可重复调用。
+* 2.写类，写方法，写功能时，应考虑其移植性，复用性：防止一次性代码！
+ 是否可以拿到其它同类事物中应该？是否可以拿到其它系统中应该？
+* 3.熟练运用继承的思想：  
+ 找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们；
+ 继承的思想，也方便将自己的逻辑建立于别人的成果之上。  
+ 如ImageField extends JTextField；  
+  熟练运用接口的思想：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
\ No newline at end of file
diff --git a/design-pattern/src/main/java/behavioral/ObserverPattern.java b/design-pattern/src/main/java/behavioral/ObserverPattern.java
new file mode 100644
index 0000000..242d110
--- /dev/null
+++ b/design-pattern/src/main/java/behavioral/ObserverPattern.java
@@ -0,0 +1,106 @@
+package behavioral;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.bind.attachment.AttachmentMarshaller;
+
+/**
+ * Created by 张春辉 on 2018年5月16日.
+ * <p>
+ * 观察者模式定义了一种一对多的依赖关系，让多个观察者对象
+ * 同时监听某一个主题对象。这个主题对象在状态发生变化时，
+ * 会通知所有观察者对象，使他们能够自动更新自己。
+ * <p>大白话：
+　*其实就是发布订阅模式，发布者发布信息，订阅者获取信息，订阅了就能收到信息，没订阅就收不到信息。
+ */
+public class ObserverPattern {
+	/***
+	 * 抽象被观察者接口
+	 * 声明了添加、删除、通知观察者方法
+	 */
+	interface Subject{
+		public void attach(Observer observer);
+		public void deatch(Observer observer);
+		public void notifyObserver();
+	}
+	
+	/***
+	 * 抽象观察者
+	 * 定义了一个update()方法，当被观察者调用notifyObservers()方法时，观察者的update()方法会被回调。
+	 */
+	interface Observer{
+		public void update(String message);
+	}
+	
+	
+	
+	
+	static class ConsumerSubject implements Subject{
+		
+		//注意到这个List集合的泛型参数为Observer接口，设计原则：面向接口编程而不是面向实现编程
+	    private List<Observer> list;
+	    private String message;
+	    
+	    public ConsumerSubject() {
+	        list = new ArrayList<Observer>();
+	    }
+	    
+		
+		@Override
+		public void attach(Observer observer) {
+			list.add(observer);
+		}
+
+		@Override
+		public void deatch(Observer observer) {
+			if(observer != null)
+			list.remove(observer);
+		}
+
+		@Override
+		public void notifyObserver() {
+			 for(int i = 0; i < list.size(); i++) {
+	            Observer oserver = list.get(i);
+	            oserver.update(message);
+	        }
+		}
+		
+		public void setInfomation(String s) {
+	        this.message = s;
+	        System.out.println("更新消息： " + s);
+	        //消息更新，通知所有观察者
+	        notifyObserver();
+	    }
+		
+	}
+	
+	static class ConsumerObserver implements Observer{
+		
+		String name;
+		String message;
+
+		public ConsumerObserver(String name){
+			this.name = name;
+		}
+		
+		@Override
+		public void update(String message) {
+			this.message = message;
+			 read();
+	    }
+	    
+	    public void read() {
+	        System.out.println(name + " 收到推送消息： " + message);
+	    }
+		
+	}
+
+	public static void main(String[] args) {
+		ConsumerSubject subject = new ConsumerSubject();
+		subject.attach(new ConsumerObserver("小红帽"));
+		subject.attach(new ConsumerObserver("白雪公主"));
+		subject.setInfomation("开始通知");
+	}
+	
+}
diff --git a/design-pattern/src/main/java/behavioral/strategy/Duck.java b/design-pattern/src/main/java/behavioral/strategy/Duck.java
new file mode 100644
index 0000000..d7065da
--- /dev/null
+++ b/design-pattern/src/main/java/behavioral/strategy/Duck.java
@@ -0,0 +1,32 @@
+package behavioral.strategy;
+
+import behavioral.strategy.fly.FlyBehavior;
+import behavioral.strategy.quack.QuackBehavior;
+
+/**
+ * 鸭子抽象类
+ * Created by zhangchunhui on 2018/7/28.
+ */
+public abstract class Duck {
+    FlyBehavior flyBehavior;
+    QuackBehavior quackBehavior;
+
+    public Duck(){}
+    public abstract void swim();
+
+    public void performFly(){
+        flyBehavior.fly();
+    }
+
+    public void performQuack(){
+        quackBehavior.quack();
+    }
+
+    public void setFlyBehavior(FlyBehavior flyBehavior) {
+        this.flyBehavior = flyBehavior;
+    }
+
+    public void setQuackBehavior(QuackBehavior quackBehavior) {
+        this.quackBehavior = quackBehavior;
+    }
+}
diff --git a/design-pattern/src/main/java/behavioral/strategy/STRATEGY.md b/design-pattern/src/main/java/behavioral/strategy/STRATEGY.md
new file mode 100644
index 0000000..e63b746
--- /dev/null
+++ b/design-pattern/src/main/java/behavioral/strategy/STRATEGY.md
@@ -0,0 +1,245 @@
+## 行为型设计模式-策略模式（Strategy Pattern）
+#### 把很简单的东西搞得那么复杂，一次性代码，设计模式优势的实例说明：（策略模式）
+说明：模拟鸭子游戏的应用程序，要求：游戏中会出现各种颜色外形的鸭子，一边游泳戏水，一边呱呱叫。
+* 第一种方法：（一次性代码）
+直接编写出各种鸭子的类：MallardDuck//野鸭，RedheadDuck//红头鸭，  
+各类有三个方法：  
+quack()：叫的方法  
+swim()：游水的方法  
+display()：外形的方法  
+
+* 第二种方法：运用继承的特性，将其中共同的部分提升出来，避免重复编程。  
+即：设计一个鸭子的超类（Superclass）,并让各种鸭子继承这个超类。
+```java
+public abstract class Duck{
+     public void quack(){  //呱呱叫
+          System.out.println("呱呱叫");
+      }
+     public void swim(){   //游泳
+          System.out.println("游泳");
+      }   
+     public  abstract void display(); /*因为外观不一样，让子类自己去决定了。*/
+} 
+```
+对于它的子类只需简单的继承就可以了，并实现自己的display()方法。  
+```java
+//野鸭
+ public class MallardDuck extends Duck{
+     public void display(){
+          System.out.println("野鸭的颜色...");
+   }
+ }
+//红头鸭
+ public class RedheadDuck extends Duck{
+     public void display(){
+          System.out.println("红头鸭的颜色...");
+   }
+}
+```
+不幸的是，现在客户又提出了新的需求，想让鸭子飞起来。这个对于我们OO程序员，在简单不过了，在超类中在加一
+个方法就可以了。
+```java
+public abstract class Duck{
+   public void quack(){  //呱呱叫
+              System.out.println("呱呱叫");
+      }
+   public void swim(){   //游泳
+            System.out.println(" 游泳");
+    }   
+   public abstract void display(); /*因为外观不一样，让子类自己去决定了。*/
+   public void fly(){
+        System.out.println("飞吧！鸭子");
+  }
+}
+```
+对于不能飞的鸭子，在子类中只需简单的覆盖。
+```java
+//残废鸭
+ public class DisabledDuck extends Duck{
+   public void display(){
+          System.out.println("残废鸭的颜色...");
+   }
+   public void fly(){
+    //覆盖，变成什么事都不做。
+  }
+}
+```
+其它会飞的鸭子不用覆盖。  
+这样所有的继承这个超类的鸭子都会fly了。但是问题又出来了，客户又提出有的鸭子会飞，有的不能飞。  
+>点评:对于上面的设计，你可能发现一些弊端，如果超类有新的特性，子类都必须变动，这是我们开发最不喜欢看到的，一个类变让另一个类也跟着变，这有点不符合OO设计了。这样很显然的耦合了一起。利用继承-->耦合度太高了.
+* 第三种方法：用接口改进.  
+我们把容易引起变化的部分提取出来并封装之，来应付以后的变法。虽然代码量加大了，但可用性提高了，耦合度也降低了。  
+我们把Duck中的fly方法和quack提取出来。
+```java
+public interface Flyable{
+   public void fly();
+}
+public interface Quackable{
+   public void quack();
+}
+```  
+最后Duck的设计成为：  
+```java
+public class Duck{
+    public void swim(){   //游泳
+            System.out.println(" 游泳");
+    }   
+    public  abstract void display(); /*因为外观不一样，让子类自 己去决定了。*/
+}
+```
+而MallardDuck,RedheadDuck,DisabledDuck 就可以写成为：  
+```java
+//野鸭
+ public class MallardDuck extends Duck implements Flyable,Quackable{
+  public void display(){
+          System.out.println("野鸭的颜色...");
+   }
+  public void fly(){
+    //实现该方法
+  }
+  public void quack(){
+    //实现该方法
+  }
+ }
+//红头鸭
+ public class RedheadDuck extends Duck implements Flyable,Quackable{
+  public void display(){
+          System.out.println("红头鸭的颜色...");
+   }
+  public void fly(){
+    //实现该方法
+  }
+  public void quack(){
+    //实现该方法
+  }
+}
+//残废鸭 只实现Quackable（能叫不能飞）
+ public class DisabledDuck extends Duck implements Quackable{
+   public void display(){
+          System.out.println("残废鸭的颜色...");
+   }
+   public void quack(){
+    //实现该方法
+  }
+}
+```
+>点评:  
+好处:这样已设计，我们的程序就降低了它们之间的耦合。  
+不足:Flyable和 Quackable接口一开始似乎还挺不错的，解决了问题（只有会飞到鸭子才实现 Flyable），但是Java接口不具有实现代码，所以实现接口无法达到代码的复用。
+* 第四种方法：
+对上面各方式的总结:  
+继承的好处:让共同部分,可以复用.避免重复编程.  
+继承的不好:耦合性高.一旦超类添加一个新方法,子类都继承,拥有此方法,
+    若子类相当部分不实现此方法,则要进行大批量修改.
+    继承时,子类就不可继承其它类了.  
+接口的好处:解决了继承耦合性高的问题.  
+    且可让实现类,继承或实现其它类或接口.
+接口的不好:不能真正实现代码的复用.可用以下的策略模式来解决.  
+ 
+#### ------------------------- Strategy Pattern(策略模式) -------------------------  
+我们有一个设计原则：  
+找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们；  
+找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 -->important.  
+现在，为了要分开“变化和不变化的部分”，我们准备建立两组类（完全远离Duck类），一个是"fly"相关的，另一个
+是“quack”相关的，每一组类将实现各自的动作。  
+比方说，我们可能有一个类实现“呱呱叫”，另一个类实现“吱吱叫”，还有一个类实现“安静”。  
+首先写两个接口。FlyBehavior(飞行行为)和QuackBehavior（叫的行为）.  
+```java
+public interface FlyBehavior{
+     public void fly();    
+ }
+ public interface QuackBehavior{
+     public void quack();
+ }
+```
+ 我们在定义一些针对FlyBehavior的具体实现。  
+ ```java
+ public class FlyWithWings implements FlyBehavior{
+    public void  fly(){
+     //实现了所有有翅膀的鸭子飞行行为。
+   }
+ }
+public class FlyNoWay implements FlyBehavior{
+    public void  fly(){
+      //什么都不做，不会飞
+    }
+ }  
+```
+针对QuackBehavior的几种具体实现。  
+```java
+public class Quack implements QuackBehavior{
+    public void quack(){
+      //实现呱呱叫的鸭子
+  }
+}
+
+public class Squeak implements QuackBehavior{
+    public void quack(){
+      //实现吱吱叫的鸭子
+  }
+}
+
+public class MuteQuack implements QuackBehavior{
+    public void quack(){
+      //什么都不做，不会叫
+  }
+}
+```
+
+> 点评一:
+这样的设计，可以让飞行和呱呱叫的动作被其他的对象复用，因为这些行为已经与鸭子类无关了。  
+而我们增加一些新的行为，不会影响到既有的行为类，也不会影响“使用”到飞行行为的鸭子类。
+
+最后我们看看Duck 如何设计。
+```java
+public abstract class Duck{       
+      //--------->在抽象类中,声明各接口,定义各接口对应的方法.
+    FlyBehavior flyBehavior;//接口
+    QuackBehavior quackBehavior;//接口
+    public Duck(){}
+    public abstract void display();
+    public void swim(){
+        //实现游泳的行为
+    }
+     public void performFly(){
+        flyBehavior.fly(); // -->由于是接口,会根据继承类实现的方式,而调用相应的方法.
+     }
+     public void performQuack(){
+          quackBehavior.quack();
+    }
+ }
+```   
+看看MallardDuck如何实现。  
+----->通过构造方法,生成'飞','叫'具体实现类的实例,从而指定'飞','叫'的具体属性   
+```java
+ public class MallardDuck extends Duck{
+    public MallardDuck(){      
+        flyBehavior = new FlyWithWings();
+        quackBehavior = new Quack();
+    }
+      //因为MallardDuck 继承了Duck，所有具有flyBehavior 与quackBehavior 实例变量}
+    public void display(){
+     //实现
+   }
+ }
+```
+这样就满足了即可以飞，又可以叫，同时展现自己的颜色了。  
+这样的设计我们可以看到是把flyBehavior ，quackBehavior 的实例化写在子类了。我们还可以动态的来决定。  
+我们只需在Duck中加上两个方法。  
+
+在构造方法中对属性进行赋值与用属性的setter的区别：  
+构造方法中对属性进行赋值：固定，不可变；  
+用属性的setter，可以在实例化对象后，动态的变化，比较灵活。  
+```java
+public class Duck{
+    FlyBehavior flyBehavior;//接口
+    QuackBehavior quackBehavior;//接口
+    public void setFlyBehavior(FlyBehavior flyBehavior){
+        this.flyBehavior = flyBehavior;
+    }
+    public void setQuackBehavior(QuackBehavior quackBehavior  {
+            this.quackBehavior= quackBehavior;
+     }
+ }
+```
+  
\ No newline at end of file
diff --git a/design-pattern/src/main/java/behavioral/strategy/WildDuck.java b/design-pattern/src/main/java/behavioral/strategy/WildDuck.java
new file mode 100644
index 0000000..4b6e6b2
--- /dev/null
+++ b/design-pattern/src/main/java/behavioral/strategy/WildDuck.java
@@ -0,0 +1,30 @@
+package behavioral.strategy;
+
+import behavioral.strategy.fly.FlyNoWay;
+import behavioral.strategy.fly.FlyWithWing;
+import behavioral.strategy.quack.QuackGua;
+import behavioral.strategy.quack.QuackZhi;
+
+/**
+ * 野鸭
+ * Created by zhangchunhui on 2018/7/28.
+ */
+public class WildDuck extends Duck{
+
+    public WildDuck(){
+        this.flyBehavior = new FlyWithWing();
+        this.quackBehavior = new QuackGua();
+    }
+    @Override
+    public void swim() {
+        System.out.println("用脚丫游泳");
+    }
+
+    public static void main(String[] args) {
+        WildDuck wildDuck = new WildDuck();
+        wildDuck.performFly();
+        wildDuck.performQuack();
+        wildDuck.setQuackBehavior(new QuackZhi());
+        wildDuck.performQuack();
+    }
+}
diff --git a/design-pattern/src/main/java/behavioral/strategy/fly/FlyBehavior.java b/design-pattern/src/main/java/behavioral/strategy/fly/FlyBehavior.java
new file mode 100644
index 0000000..b344879
--- /dev/null
+++ b/design-pattern/src/main/java/behavioral/strategy/fly/FlyBehavior.java
@@ -0,0 +1,8 @@
+package behavioral.strategy.fly;
+
+/**
+ * Created by zhangchunhui on 2018/7/28.
+ */
+public interface FlyBehavior {
+    public void fly();
+}
diff --git a/design-pattern/src/main/java/behavioral/strategy/fly/FlyNoWay.java b/design-pattern/src/main/java/behavioral/strategy/fly/FlyNoWay.java
new file mode 100644
index 0000000..a390eb3
--- /dev/null
+++ b/design-pattern/src/main/java/behavioral/strategy/fly/FlyNoWay.java
@@ -0,0 +1,11 @@
+package behavioral.strategy.fly;
+
+/**
+ * Created by zhangchunhui on 2018/7/28.
+ */
+public class FlyNoWay implements  FlyBehavior {
+    @Override
+    public void fly() {
+
+    }
+}
diff --git a/design-pattern/src/main/java/behavioral/strategy/fly/FlyWithWing.java b/design-pattern/src/main/java/behavioral/strategy/fly/FlyWithWing.java
new file mode 100644
index 0000000..e8def68
--- /dev/null
+++ b/design-pattern/src/main/java/behavioral/strategy/fly/FlyWithWing.java
@@ -0,0 +1,11 @@
+package behavioral.strategy.fly;
+
+/**
+ * Created by zhangchunhui on 2018/7/28.
+ */
+public class FlyWithWing implements FlyBehavior {
+    @Override
+    public void fly() {
+        System.out.println("fly with wing");
+    }
+}
diff --git a/design-pattern/src/main/java/behavioral/strategy/quack/QuackBehavior.java b/design-pattern/src/main/java/behavioral/strategy/quack/QuackBehavior.java
new file mode 100644
index 0000000..e7859c7
--- /dev/null
+++ b/design-pattern/src/main/java/behavioral/strategy/quack/QuackBehavior.java
@@ -0,0 +1,8 @@
+package behavioral.strategy.quack;
+
+/**
+ * Created by zhangchunhui on 2018/7/28.
+ */
+public interface QuackBehavior {
+    public void quack();
+}
diff --git a/design-pattern/src/main/java/behavioral/strategy/quack/QuackGua.java b/design-pattern/src/main/java/behavioral/strategy/quack/QuackGua.java
new file mode 100644
index 0000000..2b4ecc6
--- /dev/null
+++ b/design-pattern/src/main/java/behavioral/strategy/quack/QuackGua.java
@@ -0,0 +1,11 @@
+package behavioral.strategy.quack;
+
+/**
+ * Created by zhangchunhui on 2018/7/28.
+ */
+public class QuackGua implements QuackBehavior {
+    @Override
+    public void quack() {
+        System.out.println("呱呱叫");
+    }
+}
diff --git a/design-pattern/src/main/java/behavioral/strategy/quack/QuackNoVoice.java b/design-pattern/src/main/java/behavioral/strategy/quack/QuackNoVoice.java
new file mode 100644
index 0000000..ce3db0f
--- /dev/null
+++ b/design-pattern/src/main/java/behavioral/strategy/quack/QuackNoVoice.java
@@ -0,0 +1,11 @@
+package behavioral.strategy.quack;
+
+/**
+ * Created by zhangchunhui on 2018/7/28.
+ */
+public class QuackNoVoice implements QuackBehavior {
+    @Override
+    public void quack() {
+
+    }
+}
diff --git a/design-pattern/src/main/java/behavioral/strategy/quack/QuackZhi.java b/design-pattern/src/main/java/behavioral/strategy/quack/QuackZhi.java
new file mode 100644
index 0000000..6ec314d
--- /dev/null
+++ b/design-pattern/src/main/java/behavioral/strategy/quack/QuackZhi.java
@@ -0,0 +1,11 @@
+package behavioral.strategy.quack;
+
+/**
+ * Created by zhangchunhui on 2018/7/28.
+ */
+public class QuackZhi implements QuackBehavior {
+    @Override
+    public void quack() {
+        System.out.println("吱吱叫");
+    }
+}
diff --git a/pom.xml b/pom.xml
index 5bad714..920628c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -17,6 +17,8 @@
         <module>data-structure-algorithm</module>
         <module>codemarks</module>
         <module>design-pattern</module>
+        <module>TIJ4-code</module>
+        <module>Java-Interview</module>
     </modules>
 
 
diff --git a/settings.xml b/settings.xml
new file mode 100644
index 0000000..7f9c3e6
--- /dev/null
+++ b/settings.xml
@@ -0,0 +1,263 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+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.
+-->
+
+<!--
+ | This is the configuration file for Maven. It can be specified at two levels:
+ |
+ |  1. User Level. This settings.xml file provides configuration for a single user, 
+ |                 and is normally provided in ${user.home}/.m2/settings.xml.
+ |
+ |                 NOTE: This location can be overridden with the CLI option:
+ |
+ |                 -s /path/to/user/settings.xml
+ |
+ |  2. Global Level. This settings.xml file provides configuration for all Maven
+ |                 users on a machine (assuming they're all using the same Maven
+ |                 installation). It's normally provided in 
+ |                 ${maven.home}/conf/settings.xml.
+ |
+ |                 NOTE: This location can be overridden with the CLI option:
+ |
+ |                 -gs /path/to/global/settings.xml
+ |
+ | The sections in this sample file are intended to give you a running start at
+ | getting the most out of your Maven installation. Where appropriate, the default
+ | values (values used when the setting is not specified) are provided.
+ |
+ |-->
+<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" 
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
+  <!-- localRepository
+   | The path to the local repository maven will use to store artifacts.
+   |
+   | Default: ${user.home}/.m2/repository
+  <localRepository>/path/to/local/repo</localRepository>
+  -->
+	<localRepository>C:\Users\zhang\.m2\repository</localRepository><!--需要改成自己的maven的本地仓库地址-->  
+  <!-- interactiveMode
+   | This will determine whether maven prompts you when it needs input. If set to false,
+   | maven will use a sensible default value, perhaps based on some other setting, for
+   | the parameter in question.
+   |
+   | Default: true
+  <interactiveMode>true</interactiveMode>
+  -->
+
+  <!-- offline
+   | Determines whether maven should attempt to connect to the network when executing a build.
+   | This will have an effect on artifact downloads, artifact deployment, and others.
+   |
+   | Default: false
+  <offline>false</offline>
+  -->
+
+  <!-- pluginGroups
+   | This is a list of additional group identifiers that will be searched when resolving plugins by their prefix, i.e.
+   | when invoking a command line like "mvn prefix:goal". Maven will automatically add the group identifiers
+   | "org.apache.maven.plugins" and "org.codehaus.mojo" if these are not already contained in the list.
+   |-->
+  <pluginGroups>
+    <!-- pluginGroup
+     | Specifies a further group identifier to use for plugin lookup.
+    <pluginGroup>com.your.plugins</pluginGroup>
+    -->
+  </pluginGroups>
+
+  <!-- proxies
+   | This is a list of proxies which can be used on this machine to connect to the network.
+   | Unless otherwise specified (by system property or command-line switch), the first proxy
+   | specification in this list marked as active will be used.
+   |-->
+  <proxies>
+    <!-- proxy
+     | Specification for one proxy, to be used in connecting to the network.
+     |
+    <proxy>
+      <id>optional</id>
+      <active>true</active>
+      <protocol>http</protocol>
+      <username>proxyuser</username>
+      <password>proxypass</password>
+      <host>proxy.host.net</host>
+      <port>80</port>
+      <nonProxyHosts>local.net|some.host.com</nonProxyHosts>
+    </proxy>
+    -->
+  </proxies>
+
+  <!-- servers
+   | This is a list of authentication profiles, keyed by the server-id used within the system.
+   | Authentication profiles can be used whenever maven must make a connection to a remote server.
+   |-->
+  <servers>
+    <!-- server
+     | Specifies the authentication information to use when connecting to a particular server, identified by
+     | a unique name within the system (referred to by the 'id' attribute below).
+     | 
+     | NOTE: You should either specify username/password OR privateKey/passphrase, since these pairings are 
+     |       used together.
+     |
+    <server>
+      <id>deploymentRepo</id>
+      <username>repouser</username>
+      <password>repopwd</password>
+    </server>
+    -->
+    
+    <!-- Another sample, using keys to authenticate.
+    <server>
+      <id>siteServer</id>
+      <privateKey>/path/to/private/key</privateKey>
+      <passphrase>optional; leave empty if not used.</passphrase>
+    </server>
+    -->
+  </servers>
+
+  <!-- mirrors
+   | This is a list of mirrors to be used in downloading artifacts from remote repositories.
+   | 
+   | It works like this: a POM may declare a repository to use in resolving certain artifacts.
+   | However, this repository may have problems with heavy traffic at times, so people have mirrored
+   | it to several places.
+   |
+   | That repository definition will have a unique id, so we can create a mirror reference for that
+   | repository, to be used as an alternate download site. The mirror site will be the preferred 
+   | server for that repository.
+   |-->
+  <mirrors>
+    <!-- mirror
+     | Specifies a repository mirror site to use instead of a given repository. The repository that
+     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
+     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
+     |
+    <mirror>
+      <id>mirrorId</id>
+      <mirrorOf>repositoryId</mirrorOf>
+      <name>Human Readable Name for this Mirror.</name>
+      <url>http://my.repository.com/repo/path</url>
+    </mirror>
+     -->
+	 <mirror>
+            <id>aliyun</id>
+            <name>aliyun Maven</name>
+            <mirrorOf>*</mirrorOf>
+            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
+        </mirror>
+  </mirrors>
+  
+  <!-- profiles
+   | This is a list of profiles which can be activated in a variety of ways, and which can modify
+   | the build process. Profiles provided in the settings.xml are intended to provide local machine-
+   | specific paths and repository locations which allow the build to work in the local environment.
+   |
+   | For example, if you have an integration testing plugin - like cactus - that needs to know where
+   | your Tomcat instance is installed, you can provide a variable here such that the variable is 
+   | dereferenced during the build process to configure the cactus plugin.
+   |
+   | As noted above, profiles can be activated in a variety of ways. One way - the activeProfiles
+   | section of this document (settings.xml) - will be discussed later. Another way essentially
+   | relies on the detection of a system property, either matching a particular value for the property,
+   | or merely testing its existence. Profiles can also be activated by JDK version prefix, where a 
+   | value of '1.4' might activate a profile when the build is executed on a JDK version of '1.4.2_07'.
+   | Finally, the list of active profiles can be specified directly from the command line.
+   |
+   | NOTE: For profiles defined in the settings.xml, you are restricted to specifying only artifact
+   |       repositories, plugin repositories, and free-form properties to be used as configuration
+   |       variables for plugins in the POM.
+   |
+   |-->
+  <profiles>
+    <!-- profile
+     | Specifies a set of introductions to the build process, to be activated using one or more of the
+     | mechanisms described above. For inheritance purposes, and to activate profiles via <activatedProfiles/>
+     | or the command line, profiles have to have an ID that is unique.
+     |
+     | An encouraged best practice for profile identification is to use a consistent naming convention
+     | for profiles, such as 'env-dev', 'env-test', 'env-production', 'user-jdcasey', 'user-brett', etc.
+     | This will make it more intuitive to understand what the set of introduced profiles is attempting
+     | to accomplish, particularly when you only have a list of profile id's for debug.
+     |
+     | This profile example uses the JDK version to trigger activation, and provides a JDK-specific repo.
+    <profile>
+      <id>jdk-1.4</id>
+
+      <activation>
+        <jdk>1.4</jdk>
+      </activation>
+
+      <repositories>
+        <repository>
+          <id>jdk14</id>
+          <name>Repository for JDK 1.4 builds</name>
+          <url>http://www.myhost.com/maven/jdk14</url>
+          <layout>default</layout>
+          <snapshotPolicy>always</snapshotPolicy>
+        </repository>
+      </repositories>
+    </profile>
+    -->
+
+    <!--
+     | Here is another profile, activated by the system property 'target-env' with a value of 'dev',
+     | which provides a specific path to the Tomcat instance. To use this, your plugin configuration
+     | might hypothetically look like:
+     |
+     | ...
+     | <plugin>
+     |   <groupId>org.myco.myplugins</groupId>
+     |   <artifactId>myplugin</artifactId>
+     |   
+     |   <configuration>
+     |     <tomcatLocation>${tomcatPath}</tomcatLocation>
+     |   </configuration>
+     | </plugin>
+     | ...
+     |
+     | NOTE: If you just wanted to inject this configuration whenever someone set 'target-env' to
+     |       anything, you could just leave off the <value/> inside the activation-property.
+     |
+    <profile>
+      <id>env-dev</id>
+
+      <activation>
+        <property>
+          <name>target-env</name>
+          <value>dev</value>
+        </property>
+      </activation>
+
+      <properties>
+        <tomcatPath>/path/to/tomcat/instance</tomcatPath>
+      </properties>
+    </profile>
+    -->
+  </profiles>
+
+  <!-- activeProfiles
+   | List of profiles that are active for all builds.
+   |
+  <activeProfiles>
+    <activeProfile>alwaysActiveProfile</activeProfile>
+    <activeProfile>anotherAlwaysActiveProfile</activeProfile>
+  </activeProfiles>
+  -->
+</settings>