Merge branch 'master' into dev

crossoverJie · crossoverJie · commit 959eb5bf1412 · 2018-04-02T22:40:42.000+08:00
diff --git a/MD/ArrayList.md b/MD/ArrayList.md
@@ -55,6 +55,65 @@
 
 由此可见 `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
 
diff --git a/MD/Java-lock.md b/MD/Java-lock.md
@@ -32,8 +32,8 @@
 
 使用 `setNX(key) setEX(timeout)` 命令，只有在该 `key` 不存在的时候创建和这个 `key`，就相当于获取了锁。由于有超时时间，所以过了规定时间会自动删除，这样也可以避免死锁。
 
-风险点：
+可以参考：
 
-- 如果在 `setNX` 之后释放锁的时候挂掉了那么这个 `key` 将永远挂起，等到超时之后自动删除，如果在超时时间之内这个操作还没有完成就容易发生并发问题(如果超时时间设置过短，任务还没有执行完毕锁就释放了)。
+[基于 Redis 的分布式锁](http://crossoverjie.top/2018/03/29/distributed-lock/distributed-lock-redis/)
 
 ### 基于 ZK
diff --git a/MD/Spike.md b/MD/Spike.md
@@ -13,17 +13,18 @@
 
 这样其实就可以过滤掉大部分普通用户。
 
-但是防不住直接抓包循环调用。这种情况可以最简单的处理:在`Web层`通过限制一个UID 五秒之类的请求服务层的次数。
+但是防不住直接抓包循环调用。这种情况可以最简单的处理:在`Web层`通过限制一个 UID 五秒之类的请求服务层的次数(可利用 Redis 实现)。
 
-但如果是真的有 10W 个不同的 UID来请求，比如黑客抓肉鸡的方式。
+但如果是真的有 10W 个不同的 UID 来请求，比如黑客抓肉鸡的方式。
 
-这种情况可以在`服务层` 针对于写请求使用请求队列，再通过限流算法每秒钟放一部分请求到队列。
+这种情况可以在`服务层` 针对于写请求使用请求队列，再通过限流算法([限流算法](https://github.com/crossoverJie/Java-Interview/blob/master/MD/Limiting.md))每秒钟放一部分请求到队列。
 
 对于读请求则尽量使用缓存，可以提前将数据准备好，不管是 `Redis` 还是其他缓存中间件效率都是非常高的。
 
-> ps : 刷新缓存情况，比如库存扣除成功这种情况不用马上刷新缓存，如果库存扣到了0再刷新缓存。因为大多数用户都只关心是否有货，并不关心现在还剩余多少。
+> ps : 刷新缓存情况，比如库存扣除成功这种情况不用马上刷新缓存，如果库存扣到了 0 再刷新缓存。因为大多数用户都只关心是否有货，并不关心现在还剩余多少。
+
+## 总结
 
-总结: 
 - 如果流量巨大，导致各个层的压力都很大可以适当的加机器横向扩容。如果加不了机器那就只有放弃流量直接返回失败。快速失败非常重要，至少可以保证系统的可用性。
 - 业务分批执行：对于下单、付款等操作可以异步执行提高吞吐率。
-- 最根本的就是尽量少的请求直接访问到 `DB`。
+- 主要目的就是尽量少的请求直接访问到 `DB`。
diff --git a/README.md b/README.md
@@ -15,7 +15,7 @@ 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)
+- [对锁的一些认知](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)
@@ -30,9 +30,13 @@ Java 知识点，继续完善中。
 - [对象的创建与内存分配](https://github.com/crossoverJie/Java-Interview/blob/master/MD/newObject.md)
 - [你应该知道的 volatile 关键字](https://github.com/crossoverJie/Java-Interview/blob/master/MD/concurrent/volatile.md)
 
+### 分布式相关
+
+- [基于 Redis 的分布式锁](https://github.com/crossoverJie/distributed-lock-redis)
+
 ### 常用框架
 
-- Spring IOC 的实现原理
+- [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) 
 
 ### SpringBoot
