stack = new Stack<>();
for (int pushIndex = 0, popIndex = 0; pushIndex < n; pushIndex++) {
stack.push(pushSequence[pushIndex]);
- while (popIndex < n && stack.peek() == popSequence[popIndex]) {
+ while (popIndex < n && !stack.isEmpty()
+ && stack.peek() == popSequence[popIndex]) {
stack.pop();
popIndex++;
}
@@ -1578,7 +1579,7 @@ private boolean verify(int[] sequence, int first, int last) {
int cutIndex = first;
while (cutIndex < last && sequence[cutIndex] <= rootVal)
cutIndex++;
- for (int i = cutIndex + 1; i < last; i++)
+ for (int i = cutIndex; i < last; i++)
if (sequence[i] < rootVal)
return false;
return verify(sequence, first, cutIndex - 1) && verify(sequence, cutIndex, last - 1);
diff --git a/notes/攻击技术.md b/notes/攻击技术.md
index 46dd4616..31eeaaa4 100644
--- a/notes/攻击技术.md
+++ b/notes/攻击技术.md
@@ -13,6 +13,8 @@
跨站脚本攻击（Cross-Site Scripting, XSS），可以将代码注入到用户浏览的网页上，这种代码包括 HTML 和 JavaScript。
+## 攻击原理
+
例如有一个论坛网站，攻击者可以在上面发布以下内容：
```html
@@ -43,40 +45,23 @@
例如将 `<` 转义为 `<`，将 `>` 转义为 `>`，从而避免 HTML 和 Jascript 代码的运行。
-## 富文本编辑器
-
富文本编辑器允许用户输入 HTML 代码，就不能简单地将 `<` 等字符进行过滤了，极大地提高了 XSS 攻击的可能性。
富文本编辑器通常采用 XSS filter 来防范 XSS 攻击，通过定义一些标签白名单或者黑名单，从而不允许有攻击性的 HTML 代码的输入。
以下例子中，form 和 script 等标签都被转义，而 h 和 p 等标签将会保留。
-> [XSS 过滤在线测试](http://jsxss.com/zh/try.html)
-
```html
XSS Demo
-
-Sanitize untrusted HTML (to prevent XSS) with a configuration specified by a Whitelist.
-
+123
hello
-
- http
-
-
-Features:
-
- - Specifies HTML tags and their attributes allowed with whitelist
- - Handle any tags or attributes using custom function
-
-
@@ -85,32 +70,21 @@ alert(/xss/);
```html
XSS Demo
-
-Sanitize untrusted HTML (to prevent XSS) with a configuration specified by a Whitelist.
-
+123
<form>
<input type="text" name="q" value="test">
- <button id="submit">Submit</button>
</form>
hello
-
- http
-
-
-Features:
-
- - Specifies HTML tags and their attributes allowed with whitelist
- - Handle any tags or attributes using custom function
-
-
<script type="text/javascript">
alert(/xss/);
</script>
```
+> [XSS 过滤在线测试](http://jsxss.com/zh/try.html)
+
# 二、跨站请求伪造
## 概念
@@ -119,6 +93,8 @@ alert(/xss/);
XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户浏览器的信任。
+## 攻击原理
+
假如一家银行用以执行转账操作的 URL 地址如下：
```
diff --git a/notes/消息队列.md b/notes/消息队列.md
index bc80894d..2226de74 100644
--- a/notes/消息队列.md
+++ b/notes/消息队列.md
@@ -70,7 +70,7 @@
接收端能够从消息队列成功消费一次消息。
-实现方法：
+两种实现方法：
- 保证接收端处理消息的业务逻辑具有幂等性：只要具有幂等性，那么消费多少次消息，最后处理的结果都是一样的。
- 保证消息具有唯一编号，并使用一张日志表来记录已经消费的消息编号。
diff --git a/notes/缓存.md b/notes/缓存.md
index 26d96be1..8f7449bf 100644
--- a/notes/缓存.md
+++ b/notes/缓存.md
@@ -58,6 +58,7 @@ public class LRU implements Iterable {
}
}
+
public LRU(int maxSize) {
this.maxSize = maxSize;
@@ -70,6 +71,7 @@ public class LRU implements Iterable {
tail.pre = head;
}
+
public V get(K key) {
if (!map.containsKey(key)) {
@@ -83,6 +85,7 @@ public class LRU implements Iterable {
return node.v;
}
+
public void put(K key, V value) {
if (map.containsKey(key)) {
@@ -100,30 +103,34 @@ public class LRU implements Iterable {
}
}
+
private void unlink(Node node) {
Node pre = node.pre;
- node.pre = node.next;
- node.next = pre;
+ Node next = node.next;
+ pre.next = next;
+ next.pre = pre;
}
+
private void appendHead(Node node) {
node.next = head.next;
+ node.pre = head;
head.next = node;
}
+
private Node removeTail() {
Node node = tail.pre;
- node.pre = tail;
+ tail.pre = node.pre;
return node;
}
+
@Override
public Iterator iterator() {
return new Iterator() {
-
private Node cur = head.next;
-
@Override
public boolean hasNext() {
return cur != tail;
@@ -162,7 +169,7 @@ public class LRU implements Iterable {
使用 Redis、Memcache 等分布式缓存将数据缓存在分布式缓存系统中。
-相对于本地缓存来说，分布式缓存单独部署，可以根据需求分配硬件资源。不仅如此，服务器集群都可以访问分布式缓存，而本地缓存需要在服务器集群之间进行同步，实现和性能开销上都非常大。
+相对于本地缓存来说，分布式缓存单独部署，可以根据需求分配硬件资源。不仅如此，服务器集群都可以访问分布式缓存，而本地缓存需要在服务器集群之间进行同步，实现难度和性能开销上都非常大。
## 数据库缓存
@@ -241,7 +248,7 @@ Distributed Hash Table（DHT） 是一种哈希分布方式，其目的是为了
-一致性哈希在增加或者删除节点时只会影响到哈希环中相邻的节点，例如下图中新增节点 X，只需要将它后一个节点 C 上的数据重新进行分布即可，对于节点 A、B、D 都没有影响。
+一致性哈希在增加或者删除节点时只会影响到哈希环中相邻的节点，例如下图中新增节点 X，只需要将它前一个节点 C 上的数据重新进行分布即可，对于节点 A、B、D 都没有影响。
diff --git a/notes/计算机操作系统.md b/notes/计算机操作系统.md
index 4125d86d..e6c462a6 100644
--- a/notes/计算机操作系统.md
+++ b/notes/计算机操作系统.md
@@ -13,8 +13,8 @@
* [经典同步问题](#经典同步问题)
* [进程通信](#进程通信)
* [三、死锁](#三死锁)
- * [死锁的必要条件](#死锁的必要条件)
- * [死锁的处理方法](#死锁的处理方法)
+ * [必要条件](#必要条件)
+ * [处理方法](#处理方法)
* [鸵鸟策略](#鸵鸟策略)
* [死锁检测与死锁恢复](#死锁检测与死锁恢复)
* [死锁预防](#死锁预防)
@@ -181,7 +181,7 @@ QQ 和浏览器是两个进程，浏览器进程里面有很多线程，例如 H
Ⅳ 通信方面
-进程间通信 (IPC) 需要进程同步和互斥手段的辅助，以保证数据的一致性。而线程间可以通过直接读/写同一进程中的数据段（如全局变量）来进行通信。
+进程间通信需要进程同步和互斥手段的辅助，以保证数据的一致性。而线程间可以通过直接读/写同一进程中的数据段（如全局变量）来进行通信（需要做好同步）。
## 进程状态的切换
@@ -458,6 +458,116 @@ void writer() {
}
```
+以下内容由 [@Bandi Yugandhar](https://github.com/yugandharbandi) 提供。
+
+The first case may result Writer to starve. This case favous Writers i.e no writer, once added to the queue, shall be kept waiting longer than absolutely necessary(only when there are readers that entered the queue before the writer).
+
+```source-c
+int readcount, writecount; //(initial value = 0)
+semaphore rmutex, wmutex, readLock, resource; //(initial value = 1)
+
+//READER
+void reader() {
+
+ down(&readLock); // reader is trying to enter
+ down(&rmutex); // lock to increase readcount
+ readcount++;
+ if (readcount == 1)
+ down(&resource); //if you are the first reader then lock the resource
+ up(&rmutex); //release for other readers
+ up(&readLock); //Done with trying to access the resource
+
+
+//reading is performed
+
+
+ down(&rmutex); //reserve exit section - avoids race condition with readers
+ readcount--; //indicate you're leaving
+ if (readcount == 0) //checks if you are last reader leaving
+ up(&resource); //if last, you must release the locked resource
+ up(&rmutex); //release exit section for other readers
+}
+
+//WRITER
+void writer() {
+
+ down(&wmutex); //reserve entry section for writers - avoids race conditions
+ writecount++; //report yourself as a writer entering
+ if (writecount == 1) //checks if you're first writer
+ down(&readLock); //if you're first, then you must lock the readers out. Prevent them from trying to enter CS
+ up(&wmutex); //release entry section
+
+
+ down(&resource); //reserve the resource for yourself - prevents other writers from simultaneously editing the shared resource
+ //writing is performed
+ up(&resource); //release file
+
+
+ down(&wmutex); //reserve exit section
+ writecount--; //indicate you're leaving
+ if (writecount == 0) //checks if you're the last writer
+ up(&readLock); //if you're last writer, you must unlock the readers. Allows them to try enter CS for reading
+ up(&wmutex); //release exit section
+}
+```
+
+We can observe that every reader is forced to acquire ReadLock. On the otherhand, writers doesn’t need to lock individually. Once the first writer locks the ReadLock, it will be released only when there is no writer left in the queue.
+
+From the both cases we observed that either reader or writer has to starve. Below solutionadds the constraint that no thread shall be allowed to starve; that is, the operation of obtaining a lock on the shared data will always terminate in a bounded amount of time.
+
+```source-c
+int readCount; // init to 0; number of readers currently accessing resource
+
+// all semaphores initialised to 1
+Semaphore resourceAccess; // controls access (read/write) to the resource
+Semaphore readCountAccess; // for syncing changes to shared variable readCount
+Semaphore serviceQueue; // FAIRNESS: preserves ordering of requests (signaling must be FIFO)
+
+void writer()
+{
+ down(&serviceQueue); // wait in line to be servicexs
+ //
+ down(&resourceAccess); // request exclusive access to resource
+ //
+ up(&serviceQueue); // let next in line be serviced
+
+ //
+ writeResource(); // writing is performed
+ //
+
+ //
+ up(&resourceAccess); // release resource access for next reader/writer
+ //
+}
+
+void reader()
+{
+ down(&serviceQueue); // wait in line to be serviced
+ down(&readCountAccess); // request exclusive access to readCount
+ //
+ if (readCount == 0) // if there are no readers already reading:
+ down(&resourceAccess); // request resource access for readers (writers blocked)
+ readCount++; // update count of active readers
+ //
+ up(&serviceQueue); // let next in line be serviced
+ up(&readCountAccess); // release access to readCount
+
+ //
+ readResource(); // reading is performed
+ //
+
+ down(&readCountAccess); // request exclusive access to readCount
+ //
+ readCount--; // update count of active readers
+ if (readCount == 0) // if there are no readers left:
+ up(&resourceAccess); // release resource access for all
+ //
+ up(&readCountAccess); // release access to readCount
+}
+
+```
+
+
### 2. 哲学家进餐问题
@@ -596,7 +706,7 @@ FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客户
# 三、死锁
-## 死锁的必要条件
+## 必要条件
@@ -605,7 +715,7 @@ FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客户
- 不可抢占：已经分配给一个进程的资源不能强制性地被抢占，它只能被占有它的进程显式地释放。
- 环路等待：有两个或者两个以上的进程组成一条环路，该环路中的每个进程都在等待下一个进程所占有的资源。
-## 死锁的处理方法
+## 处理方法
主要有以下四种方法：
diff --git a/notes/计算机网络.md b/notes/计算机网络.md
index 3a08e2a0..fba8a6d0 100644
--- a/notes/计算机网络.md
+++ b/notes/计算机网络.md
@@ -5,7 +5,7 @@
* [主机之间的通信方式](#主机之间的通信方式)
* [电路交换与分组交换](#电路交换与分组交换)
* [时延](#时延)
- * [计算机网络体系结构*](#计算机网络体系结构)
+ * [计算机网络体系结构](#计算机网络体系结构)
* [二、物理层](#二物理层)
* [通信方式](#通信方式)
* [带通调制](#带通调制)
@@ -13,14 +13,14 @@
* [基本问题](#基本问题)
* [信道分类](#信道分类)
* [信道复用技术](#信道复用技术)
- * [CSMA/CD 协议*](#csmacd-协议)
+ * [CSMA/CD 协议](#csmacd-协议)
* [PPP 协议](#ppp-协议)
* [MAC 地址](#mac-地址)
* [局域网](#局域网)
- * [以太网*](#以太网)
- * [交换机*](#交换机)
+ * [以太网](#以太网)
+ * [交换机](#交换机)
* [虚拟局域网](#虚拟局域网)
-* [四、网络层*](#四网络层)
+* [四、网络层](#四网络层)
* [概述](#概述)
* [IP 数据报格式](#ip-数据报格式)
* [IP 地址编址方式](#ip-地址编址方式)
@@ -31,7 +31,7 @@
* [路由器的结构](#路由器的结构)
* [路由器分组转发流程](#路由器分组转发流程)
* [路由选择协议](#路由选择协议)
-* [五、运输层*](#五运输层)
+* [五、运输层](#五运输层)
* [UDP 和 TCP 的特点](#udp-和-tcp-的特点)
* [UDP 首部格式](#udp-首部格式)
* [TCP 首部格式](#tcp-首部格式)
@@ -121,7 +121,7 @@
分组在路由器的输入队列和输出队列中排队等待的时间，取决于网络当前的通信量。
-## 计算机网络体系结构*
+## 计算机网络体系结构
@@ -129,11 +129,11 @@
- **应用层** ：为特定应用程序提供数据传输服务，例如 HTTP、DNS 等。数据单位为报文。
-- **运输层** ：提供的是进程间的通用数据传输服务。由于应用层协议很多，定义通用的运输层协议就可以支持不断增多的应用层协议。运输层包括两种协议：传输控制协议 TCP，提供面向连接、可靠的数据传输服务，数据单位为报文段；用户数据报协议 UDP，提供无连接、尽最大努力的数据传输服务，数据单位为用户数据报。TCP 主要提供完整性服务，UDP 主要提供及时性服务。
+- **运输层** ：为进程提供通用数据传输服务。由于应用层协议很多，定义通用的运输层协议就可以支持不断增多的应用层协议。运输层包括两种协议：传输控制协议 TCP，提供面向连接、可靠的数据传输服务，数据单位为报文段；用户数据报协议 UDP，提供无连接、尽最大努力的数据传输服务，数据单位为用户数据报。TCP 主要提供完整性服务，UDP 主要提供及时性服务。
-- **网络层** ：为主机间提供数据传输服务，而运输层协议是为主机中的进程提供服务。网络层把运输层传递下来的报文段或者用户数据报封装成分组。
+- **网络层** ：为主机提供数据传输服务。而运输层协议是为主机中的进程提供数据传输服务。网络层把运输层传递下来的报文段或者用户数据报封装成分组。
-- **数据链路层** ：网络层针对的还是主机之间的数据传输服务，而主机之间可以有很多链路，链路层协议就是为同一链路的主机提供服务。数据链路层把网络层传下来的分组封装成帧。
+- **数据链路层** ：网络层针对的还是主机之间的数据传输服务，而主机之间可以有很多链路，链路层协议就是为同一链路的主机提供数据传输服务。数据链路层把网络层传下来的分组封装成帧。
- **物理层** ：考虑的是怎样在传输媒体上传输数据比特流，而不是指具体的传输媒体。物理层的作用是尽可能屏蔽传输媒体和通信手段的差异，使数据链路层感觉不到这些差异。
@@ -271,7 +271,7 @@ TCP/IP 协议族是一种沙漏形状，中间小两边大，IP 协议在其中
-## CSMA/CD 协议*
+## CSMA/CD 协议
CSMA/CD 表示载波监听多点接入 / 碰撞检测。
@@ -316,7 +316,7 @@ MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标
-## 以太网*
+## 以太网
以太网是一种星型拓扑结构局域网。
@@ -333,7 +333,7 @@ MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标
-## 交换机*
+## 交换机
交换机具有自学习能力，学习的是交换表的内容，交换表中存储着 MAC 地址到接口的映射。
@@ -353,7 +353,7 @@ MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标
-# 四、网络层*
+# 四、网络层
## 概述
@@ -578,7 +578,7 @@ BGP 只能寻找一条比较好的路由，而不是最佳路由。
-# 五、运输层*
+# 五、运输层
网络层只把分组发送到目的主机，但是真正通信的并不是主机而是主机中的进程。运输层提供了进程间的逻辑通信，运输层向高层用户屏蔽了下面网络层的核心细节，使应用程序看起来像是在两个运输层实体之间有一条端到端的逻辑通信信道。
diff --git a/notes/设计模式.md b/notes/设计模式.md
index 9d9ab38f..536072c2 100644
--- a/notes/设计模式.md
+++ b/notes/设计模式.md
@@ -175,6 +175,50 @@ public class Singleton {
}
```
+#### Ⅵ 枚举实现
+
+ ```java
+public enum Singleton {
+
+ INSTANCE;
+
+ private String objName;
+
+
+ public String getObjName() {
+ return objName;
+ }
+
+
+ public void setObjName(String objName) {
+ this.objName = objName;
+ }
+
+
+ public static void main(String[] args) {
+
+ // 单例测试
+ Singleton firstSingleton = Singleton.INSTANCE;
+ firstSingleton.setObjName("firstName");
+ System.out.println(firstSingleton.getObjName());
+ Singleton secondSingleton = Singleton.INSTANCE;
+ secondSingleton.setObjName("secondName");
+ System.out.println(firstSingleton.getObjName());
+ System.out.println(secondSingleton.getObjName());
+
+ // 反射获取实例测试
+ try {
+ Singleton[] enumConstants = Singleton.class.getEnumConstants();
+ for (Singleton enumConstant : enumConstants) {
+ System.out.println(enumConstant.getObjName());
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+}
+ ```
+
该实现在多次序列化再进行反序列化之后，不会得到多个实例。而其它实现，为了保证不会出现反序列化之后出现多个实例，需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法。
该实现可以防止反射攻击。在其它实现中，通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象，如果要防止这种攻击，需要在构造函数中添加防止实例化第二个对象的代码。但是该实现是由 JVM 保证只会实例化一次，因此不会出现上述的反射攻击。
@@ -595,25 +639,30 @@ abc
```java
public abstract class Handler {
+
protected Handler successor;
+
public Handler(Handler successor) {
this.successor = successor;
}
+
protected abstract void handleRequest(Request request);
}
```
```java
public class ConcreteHandler1 extends Handler {
+
public ConcreteHandler1(Handler successor) {
super(successor);
}
+
@Override
protected void handleRequest(Request request) {
- if (request.getType() == RequestType.type1) {
+ if (request.getType() == RequestType.TYPE1) {
System.out.println(request.getName() + " is handle by ConcreteHandler1");
return;
}
@@ -625,14 +674,16 @@ public class ConcreteHandler1 extends Handler {
```
```java
-public class ConcreteHandler2 extends Handler{
+public class ConcreteHandler2 extends Handler {
+
public ConcreteHandler2(Handler successor) {
super(successor);
}
+
@Override
protected void handleRequest(Request request) {
- if (request.getType() == RequestType.type2) {
+ if (request.getType() == RequestType.TYPE2) {
System.out.println(request.getName() + " is handle by ConcreteHandler2");
return;
}
@@ -645,38 +696,47 @@ public class ConcreteHandler2 extends Handler{
```java
public class Request {
+
private RequestType type;
private String name;
+
public Request(RequestType type, String name) {
this.type = type;
this.name = name;
}
+
public RequestType getType() {
return type;
}
+
public String getName() {
return name;
}
}
+
```
```java
public enum RequestType {
- type1, type2
+ TYPE1, TYPE2
}
```
```java
public class Client {
+
public static void main(String[] args) {
+
Handler handler1 = new ConcreteHandler1(null);
Handler handler2 = new ConcreteHandler2(handler1);
- Request request1 = new Request(RequestType.type1, "request1");
+
+ Request request1 = new Request(RequestType.TYPE1, "request1");
handler2.handleRequest(request1);
- Request request2 = new Request(RequestType.type2, "request2");
+
+ Request request2 = new Request(RequestType.TYPE2, "request2");
handler2.handleRequest(request2);
}
}
diff --git a/notes/集群.md b/notes/集群.md
index 338ddcb4..111495c3 100644
--- a/notes/集群.md
+++ b/notes/集群.md
@@ -18,12 +18,12 @@
负载均衡器可以用来实现高可用以及伸缩性：
- 高可用：当某个节点故障时，负载均衡器会将用户请求转发到另外的节点上，从而保证所有服务持续可用；
-- 伸缩性：可以很容易地添加移除节点。
+- 伸缩性：根据系统整体负载情况，可以很容易地添加移除节点。
负载均衡运行过程包含两个部分：
-1. 根据负载均衡算法得到请求转发的节点；
-2. 将请求进行转发。
+1. 根据负载均衡算法得到转发的节点；
+2. 进行转发。
## 负载均衡算法
@@ -205,4 +205,3 @@ HTTP 重定向负载均衡服务器使用某种负载均衡算法计算得到服
- [Session Management using Spring Session with JDBC DataStore](https://sivalabs.in/2018/02/session-management-using-spring-session-jdbc-datastore/)
-
From 90440d840d1971478de98e1fea3c8fed393bdad8 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 8 Sep 2018 10:14:41 +0800
Subject: [PATCH 033/139] auto commit
---
notes/Java 容器.md | 6 +--
notes/Java 并发.md | 115 +++++++--------------------------------------
notes/Socket.md | 8 ++--
notes/设计模式.md | 4 +-
4 files changed, 27 insertions(+), 106 deletions(-)
diff --git a/notes/Java 容器.md b/notes/Java 容器.md
index fd1ee97e..84189928 100644
--- a/notes/Java 容器.md
+++ b/notes/Java 容器.md
@@ -13,7 +13,7 @@
* [HashMap](#hashmap)
* [ConcurrentHashMap](#concurrenthashmap)
* [LinkedHashMap](#linkedhashmap)
- * [WeekHashMap](#weekhashmap)
+ * [WeakHashMap](#weakhashmap)
* [附录](#附录)
* [参考资料](#参考资料)
@@ -974,7 +974,7 @@ void afterNodeAccess(Node e) { // move node to last
### afterNodeInsertion()
-在 put 等操作之后执行，当 removeEldestEntry() 方法返回 ture 时会移除最晚的节点，也就是链表首部节点 first。
+在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最晚的节点，也就是链表首部节点 first。
evict 只有在构建 Map 的时候才为 false，在这里为 true。
@@ -1034,7 +1034,7 @@ public static void main(String[] args) {
[3, 1, 4]
```
-## WeekHashMap
+## WeakHashMap
### 存储结构
diff --git a/notes/Java 并发.md b/notes/Java 并发.md
index 03aaa9fd..977d85f2 100644
--- a/notes/Java 并发.md
+++ b/notes/Java 并发.md
@@ -44,9 +44,10 @@
* [内存模型三大特性](#内存模型三大特性)
* [先行发生原则](#先行发生原则)
* [十一、线程安全](#十一线程安全)
- * [线程安全定义](#线程安全定义)
- * [线程安全分类](#线程安全分类)
- * [线程安全的实现方法](#线程安全的实现方法)
+ * [不可变](#不可变)
+ * [互斥同步](#互斥同步)
+ * [非阻塞同步](#非阻塞同步)
+ * [无同步方案](#无同步方案)
* [十二、锁优化](#十二锁优化)
* [自旋锁](#自旋锁)
* [锁消除](#锁消除)
@@ -1274,19 +1275,13 @@ Thread 对象的结束先行发生于 join() 方法返回。
# 十一、线程安全
-## 线程安全定义
+多个线程不管以何种方式访问某个类，并在在主调代码中不需要进行同步，都能表现正确的行为。
-一个类在可以被多个线程安全调用时就是线程安全的。
+线程安全有以下几种实现方式：
-## 线程安全分类
+## 不可变
-线程安全不是一个非真即假的命题，可以将共享数据按照安全程度的强弱顺序分成以下五类：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。
-
-### 1. 不可变
-
-不可变（Immutable）的对象一定是线程安全的，不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确地构建出来，永远也不会看到它在多个线程之中处于不一致的状态。
-
-多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
+不可变（Immutable）的对象一定是线程安全的，不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确地构建出来，永远也不会看到它在多个线程之中处于不一致的状态。多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
不可变的类型：
@@ -1321,99 +1316,23 @@ public V put(K key, V value) {
}
```
-### 2. 绝对线程安全
-
-不管运行时环境如何，调用者都不需要任何额外的同步措施。
-
-### 3. 相对线程安全
-
-相对线程安全需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施。但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。
-
-在 Java 语言中，大部分的线程安全类都属于这种类型，例如 Vector、HashTable、Collections 的 synchronizedCollection() 方法包装的集合等。
-
-对于下面的代码，如果删除元素的线程删除了 Vector 的一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 ArrayIndexOutOfBoundsException。
-
-```Java
-public class VectorUnsafeExample {
- private static Vector vector = new Vector<>();
-
- public static void main(String[] args) {
- while (true) {
- for (int i = 0; i < 100; i++) {
- vector.add(i);
- }
- ExecutorService executorService = Executors.newCachedThreadPool();
- executorService.execute(() -> {
- for (int i = 0; i < vector.size(); i++) {
- vector.remove(i);
- }
- });
- executorService.execute(() -> {
- for (int i = 0; i < vector.size(); i++) {
- vector.get(i);
- }
- });
- executorService.shutdown();
- }
- }
-}
-```
-
-```html
-Exception in thread "Thread-159738" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 3
- at java.util.Vector.remove(Vector.java:831)
- at VectorUnsafeExample.lambda$main$0(VectorUnsafeExample.java:14)
- at VectorUnsafeExample$$Lambda$1/713338599.run(Unknown Source)
- at java.lang.Thread.run(Thread.java:745)
-```
-
-
-如果要保证上面的代码能正确执行下去，就需要对删除元素和获取元素的代码进行同步。
-
-```java
-executorService.execute(() -> {
- synchronized (vector) {
- for (int i = 0; i < vector.size(); i++) {
- vector.remove(i);
- }
- }
-});
-executorService.execute(() -> {
- synchronized (vector) {
- for (int i = 0; i < vector.size(); i++) {
- vector.get(i);
- }
- }
-});
-```
-
-### 4. 线程兼容
-
-线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API 中大部分的类都是属于线程兼容的，如与前面的 Vector 和 HashTable 相对应的集合类 ArrayList 和 HashMap 等。
-
-### 5. 线程对立
-
-线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于 Java 语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。
-
-## 线程安全的实现方法
-
-### 1. 互斥同步
+## 互斥同步
synchronized 和 ReentrantLock。
-### 2. 非阻塞同步
+## 非阻塞同步
互斥同步最主要的问题就是线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。
互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
-**（一）CAS**
+### 1. CAS
随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步。
乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
-**（二）AtomicInteger**
+### 2. AtomicInteger
J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。
@@ -1450,17 +1369,17 @@ public final int getAndAddInt(Object var1, long var2, int var4) {
}
```
-**（三）ABA**
+### 3. ABA
如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
-### 3. 无同步方案
+## 无同步方案
要保证线程安全，并不是一定就要进行同步。如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性。
-**（一）栈封闭**
+### 1. 栈封闭
多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的。
@@ -1491,7 +1410,7 @@ public static void main(String[] args) {
100
```
-**（二）线程本地存储（Thread Local Storage）**
+### 2. 线程本地存储（Thread Local Storage）
如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
@@ -1597,7 +1516,7 @@ ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因
在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，应该尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
-**（三）可重入代码（Reentrant Code）**
+### 3. 可重入代码（Reentrant Code）
这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
diff --git a/notes/Socket.md b/notes/Socket.md
index 482bafe6..7cb4fbf0 100644
--- a/notes/Socket.md
+++ b/notes/Socket.md
@@ -307,14 +307,14 @@ select 可移植性更好，几乎被所有主流平台所支持。
poll 没有最大描述符数量的限制，如果平台支持并且对实时性要求不高，应该使用 poll 而不是 select。
-需要同时监控小于 1000 个描述符，就没有必要使用 epoll，因为这个应用场景下并不能体现 epoll 的优势。
-
-需要监控的描述符状态变化多，而且都是非常短暂的，也没有必要使用 epoll。因为 epoll 中的所有描述符都存储在内核中，造成每次需要对描述符的状态改变都需要通过 epoll_ctl() 进行系统调用，频繁系统调用降低效率。并且epoll 的描述符存储在内核，不容易调试。
-
### 3. epoll 应用场景
只需要运行在 Linux 平台上，并且有非常大量的描述符需要同时轮询，而且这些连接最好是长连接。
+需要同时监控小于 1000 个描述符，就没有必要使用 epoll，因为这个应用场景下并不能体现 epoll 的优势。
+
+需要监控的描述符状态变化多，而且都是非常短暂的，也没有必要使用 epoll。因为 epoll 中的所有描述符都存储在内核中，造成每次需要对描述符的状态改变都需要通过 epoll_ctl() 进行系统调用，频繁系统调用降低效率。并且epoll 的描述符存储在内核，不容易调试。
+
# 参考资料
- Stevens W R, Fenner B, Rudoff A M. UNIX network programming[M]. Addison-Wesley Professional, 2004.
diff --git a/notes/设计模式.md b/notes/设计模式.md
index 536072c2..d44d0e33 100644
--- a/notes/设计模式.md
+++ b/notes/设计模式.md
@@ -2952,7 +2952,7 @@ Java 利用缓存来加速大量小对象的访问时间。
- 远程代理（Remote Proxy）：控制对远程对象（不同地址空间）的访问，它负责将请求及其参数进行编码，并向不同地址空间中的对象发送已经编码的请求。
- 虚拟代理（Virtual Proxy）：根据需要创建开销很大的对象，它可以缓存实体的附加信息，以便延迟对它的访问，例如在网站加载一个很大图片时，不能马上完成，可以用虚拟代理缓存图片的大小信息，然后生成一张临时图片代替原始图片。
- 保护代理（Protection Proxy）：按权限控制对象的访问，它负责检查调用者是否具有实现一个请求所必须的访问权限。
-- 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个持久化对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。
+- 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。
@@ -3004,6 +3004,7 @@ public class HighResolutionImage implements Image {
```java
public class ImageProxy implements Image {
+
private HighResolutionImage highResolutionImage;
public ImageProxy(HighResolutionImage highResolutionImage) {
@@ -3027,6 +3028,7 @@ public class ImageProxy implements Image {
```java
public class ImageViewer {
+
public static void main(String[] args) throws Exception {
String image = "http://image.jpg";
URL url = new URL(image);
From 5c5c056de67f7c7788b64c1b903c408f3a46d904 Mon Sep 17 00:00:00 2001
From: blueli <34030887+blueblueblueblueblueblue@users.noreply.github.com>
Date: Mon, 10 Sep 2018 15:45:26 +0800
Subject: [PATCH 034/139] =?UTF-8?q?Update=20Java=20=E5=9F=BA=E7=A1=80.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
notes/Java 基础.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index d8f17cef..2cd0c825 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -196,9 +196,9 @@ String 不可变性天生具备线程安全，可以在多个线程中安全地
## String Pool
-字符串常量池（String Poll）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Poll 中。
+字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。
-当一个字符串调用 intern() 方法时，如果 String Poll 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Poll 中字符串的引用；否则，就会在 String Poll 中添加一个新的字符串，并返回这个新字符串的引用。
+当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。
下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。
From e697abdc3d00a74e9b43ce1cb81cb9b4145202fb Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Mon, 10 Sep 2018 16:01:25 +0800
Subject: [PATCH 035/139] auto commit
---
notes/Java 基础.md | 6 +--
notes/Java 容器.md | 6 +--
notes/Java 并发.md | 120 +++++++++------------------------------------
notes/设计模式.md | 4 +-
4 files changed, 31 insertions(+), 105 deletions(-)
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index d8f17cef..b3aed5d6 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -196,9 +196,9 @@ String 不可变性天生具备线程安全，可以在多个线程中安全地
## String Pool
-字符串常量池（String Poll）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Poll 中。
+字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Poll 中。
-当一个字符串调用 intern() 方法时，如果 String Poll 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Poll 中字符串的引用；否则，就会在 String Poll 中添加一个新的字符串，并返回这个新字符串的引用。
+当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。
下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。
@@ -219,7 +219,7 @@ String s6 = "bbb";
System.out.println(s4 == s5); // true
```
-在 Java 7 之前，String Poll 被放在运行时常量池中，它属于永久代。而在 Java 7，String Poll 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
+在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
- [StackOverflow : What is String interning?](https://stackoverflow.com/questions/10578984/what-is-string-interning)
- [深入解析 String#intern](https://tech.meituan.com/in_depth_understanding_string_intern.html)
diff --git a/notes/Java 容器.md b/notes/Java 容器.md
index fd1ee97e..84189928 100644
--- a/notes/Java 容器.md
+++ b/notes/Java 容器.md
@@ -13,7 +13,7 @@
* [HashMap](#hashmap)
* [ConcurrentHashMap](#concurrenthashmap)
* [LinkedHashMap](#linkedhashmap)
- * [WeekHashMap](#weekhashmap)
+ * [WeakHashMap](#weakhashmap)
* [附录](#附录)
* [参考资料](#参考资料)
@@ -974,7 +974,7 @@ void afterNodeAccess(Node e) { // move node to last
### afterNodeInsertion()
-在 put 等操作之后执行，当 removeEldestEntry() 方法返回 ture 时会移除最晚的节点，也就是链表首部节点 first。
+在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最晚的节点，也就是链表首部节点 first。
evict 只有在构建 Map 的时候才为 false，在这里为 true。
@@ -1034,7 +1034,7 @@ public static void main(String[] args) {
[3, 1, 4]
```
-## WeekHashMap
+## WeakHashMap
### 存储结构
diff --git a/notes/Java 并发.md b/notes/Java 并发.md
index 03aaa9fd..add3982a 100644
--- a/notes/Java 并发.md
+++ b/notes/Java 并发.md
@@ -44,9 +44,10 @@
* [内存模型三大特性](#内存模型三大特性)
* [先行发生原则](#先行发生原则)
* [十一、线程安全](#十一线程安全)
- * [线程安全定义](#线程安全定义)
- * [线程安全分类](#线程安全分类)
- * [线程安全的实现方法](#线程安全的实现方法)
+ * [不可变](#不可变)
+ * [互斥同步](#互斥同步)
+ * [非阻塞同步](#非阻塞同步)
+ * [无同步方案](#无同步方案)
* [十二、锁优化](#十二锁优化)
* [自旋锁](#自旋锁)
* [锁消除](#锁消除)
@@ -739,6 +740,7 @@ java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.
```java
public class CountdownLatchExample {
+
public static void main(String[] args) throws InterruptedException {
final int totalThread = 10;
CountDownLatch countDownLatch = new CountDownLatch(totalThread);
@@ -787,6 +789,7 @@ public CyclicBarrier(int parties) {
```java
public class CyclicBarrierExample {
+
public static void main(String[] args) {
final int totalThread = 10;
CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
@@ -821,6 +824,7 @@ Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的
```java
public class SemaphoreExample {
+
public static void main(String[] args) {
final int clientCount = 3;
final int totalRequestCount = 10;
@@ -865,6 +869,7 @@ FutureTask 可用于异步获取执行结果或取消执行任务的场景。当
```java
public class FutureTaskExample {
+
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask futureTask = new FutureTask(new Callable() {
@Override
@@ -970,6 +975,7 @@ produce..produce..consume..consume..produce..consume..produce..consume..produce.
```java
public class ForkJoinExample extends RecursiveTask {
+
private final int threshold = 5;
private int first;
private int last;
@@ -1274,19 +1280,13 @@ Thread 对象的结束先行发生于 join() 方法返回。
# 十一、线程安全
-## 线程安全定义
+多个线程不管以何种方式访问某个类，并在在主调代码中不需要进行同步，都能表现正确的行为。
-一个类在可以被多个线程安全调用时就是线程安全的。
+线程安全有以下几种实现方式：
-## 线程安全分类
+## 不可变
-线程安全不是一个非真即假的命题，可以将共享数据按照安全程度的强弱顺序分成以下五类：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。
-
-### 1. 不可变
-
-不可变（Immutable）的对象一定是线程安全的，不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确地构建出来，永远也不会看到它在多个线程之中处于不一致的状态。
-
-多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
+不可变（Immutable）的对象一定是线程安全的，不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确地构建出来，永远也不会看到它在多个线程之中处于不一致的状态。多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
不可变的类型：
@@ -1321,99 +1321,23 @@ public V put(K key, V value) {
}
```
-### 2. 绝对线程安全
-
-不管运行时环境如何，调用者都不需要任何额外的同步措施。
-
-### 3. 相对线程安全
-
-相对线程安全需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施。但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。
-
-在 Java 语言中，大部分的线程安全类都属于这种类型，例如 Vector、HashTable、Collections 的 synchronizedCollection() 方法包装的集合等。
-
-对于下面的代码，如果删除元素的线程删除了 Vector 的一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 ArrayIndexOutOfBoundsException。
-
-```Java
-public class VectorUnsafeExample {
- private static Vector vector = new Vector<>();
-
- public static void main(String[] args) {
- while (true) {
- for (int i = 0; i < 100; i++) {
- vector.add(i);
- }
- ExecutorService executorService = Executors.newCachedThreadPool();
- executorService.execute(() -> {
- for (int i = 0; i < vector.size(); i++) {
- vector.remove(i);
- }
- });
- executorService.execute(() -> {
- for (int i = 0; i < vector.size(); i++) {
- vector.get(i);
- }
- });
- executorService.shutdown();
- }
- }
-}
-```
-
-```html
-Exception in thread "Thread-159738" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 3
- at java.util.Vector.remove(Vector.java:831)
- at VectorUnsafeExample.lambda$main$0(VectorUnsafeExample.java:14)
- at VectorUnsafeExample$$Lambda$1/713338599.run(Unknown Source)
- at java.lang.Thread.run(Thread.java:745)
-```
-
-
-如果要保证上面的代码能正确执行下去，就需要对删除元素和获取元素的代码进行同步。
-
-```java
-executorService.execute(() -> {
- synchronized (vector) {
- for (int i = 0; i < vector.size(); i++) {
- vector.remove(i);
- }
- }
-});
-executorService.execute(() -> {
- synchronized (vector) {
- for (int i = 0; i < vector.size(); i++) {
- vector.get(i);
- }
- }
-});
-```
-
-### 4. 线程兼容
-
-线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API 中大部分的类都是属于线程兼容的，如与前面的 Vector 和 HashTable 相对应的集合类 ArrayList 和 HashMap 等。
-
-### 5. 线程对立
-
-线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于 Java 语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。
-
-## 线程安全的实现方法
-
-### 1. 互斥同步
+## 互斥同步
synchronized 和 ReentrantLock。
-### 2. 非阻塞同步
+## 非阻塞同步
互斥同步最主要的问题就是线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。
互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
-**（一）CAS**
+### 1. CAS
随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步。
乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
-**（二）AtomicInteger**
+### 2. AtomicInteger
J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。
@@ -1450,17 +1374,17 @@ public final int getAndAddInt(Object var1, long var2, int var4) {
}
```
-**（三）ABA**
+### 3. ABA
如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
-### 3. 无同步方案
+## 无同步方案
要保证线程安全，并不是一定就要进行同步。如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性。
-**（一）栈封闭**
+### 1. 栈封闭
多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的。
@@ -1491,7 +1415,7 @@ public static void main(String[] args) {
100
```
-**（二）线程本地存储（Thread Local Storage）**
+### 2. 线程本地存储（Thread Local Storage）
如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
@@ -1597,7 +1521,7 @@ ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因
在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，应该尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
-**（三）可重入代码（Reentrant Code）**
+### 3. 可重入代码（Reentrant Code）
这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
diff --git a/notes/设计模式.md b/notes/设计模式.md
index 536072c2..d44d0e33 100644
--- a/notes/设计模式.md
+++ b/notes/设计模式.md
@@ -2952,7 +2952,7 @@ Java 利用缓存来加速大量小对象的访问时间。
- 远程代理（Remote Proxy）：控制对远程对象（不同地址空间）的访问，它负责将请求及其参数进行编码，并向不同地址空间中的对象发送已经编码的请求。
- 虚拟代理（Virtual Proxy）：根据需要创建开销很大的对象，它可以缓存实体的附加信息，以便延迟对它的访问，例如在网站加载一个很大图片时，不能马上完成，可以用虚拟代理缓存图片的大小信息，然后生成一张临时图片代替原始图片。
- 保护代理（Protection Proxy）：按权限控制对象的访问，它负责检查调用者是否具有实现一个请求所必须的访问权限。
-- 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个持久化对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。
+- 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。
@@ -3004,6 +3004,7 @@ public class HighResolutionImage implements Image {
```java
public class ImageProxy implements Image {
+
private HighResolutionImage highResolutionImage;
public ImageProxy(HighResolutionImage highResolutionImage) {
@@ -3027,6 +3028,7 @@ public class ImageProxy implements Image {
```java
public class ImageViewer {
+
public static void main(String[] args) throws Exception {
String image = "http://image.jpg";
URL url = new URL(image);
From 07dff03dd49c3fb7d60ad9946bad0a878d67bc01 Mon Sep 17 00:00:00 2001
From: Yongtao Zhang
Date: Tue, 11 Sep 2018 14:32:05 +0800
Subject: [PATCH 036/139] =?UTF-8?q?Update=20=E6=95=B0=E6=8D=AE=E5=BA=93?=
=?UTF-8?q?=E7=B3=BB=E7=BB=9F=E5=8E=9F=E7=90=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
高性能 MYSQL 在事务隔离级别中还有一个概念为加锁读。
---
notes/数据库系统原理.md | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/notes/数据库系统原理.md b/notes/数据库系统原理.md
index 1bcd2533..1ce774fa 100644
--- a/notes/数据库系统原理.md
+++ b/notes/数据库系统原理.md
@@ -294,12 +294,12 @@ SELECT ... FOR UPDATE;
----
-| 隔离级别 | 脏读 | 不可重复读 | 幻影读 |
-| :---: | :---: | :---:| :---: |
-| 未提交读 | √ | √ | √ |
-| 提交读 | × | √ | √ |
-| 可重复读 | × | × | √ |
-| 可串行化 | × | × | × |
+| 隔离级别 | 脏读 | 不可重复读 | 幻影读 | 加锁读 |
+| :---: | :---: | :---:| :---: | :---: |
+| 未提交读 | √ | √ | √ | × |
+| 提交读 | × | √ | √ | × |
+| 可重复读 | × | × | √ | × |
+| 可串行化 | × | × | × | √ |
# 五、多版本并发控制
From b88cef16b9032c0a8c98fa0cd01a55ac49307337 Mon Sep 17 00:00:00 2001
From: Yif_Corleone
Date: Thu, 13 Sep 2018 18:08:37 +0800
Subject: [PATCH 037/139] =?UTF-8?q?Java=20=E5=9F=BA=E7=A1=80=20219?=
=?UTF-8?q?=E8=A1=8C=E7=AC=94=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
应是 s5 == s6
---
notes/Java 基础.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index 9da25851..22c94e60 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -216,7 +216,7 @@ System.out.println(s3 == s4); // true
```java
String s5 = "bbb";
String s6 = "bbb";
-System.out.println(s4 == s5); // true
+System.out.println(s5 == s6); // true
```
在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
From d167aaf9961f7346afe850a49f903c6be819d658 Mon Sep 17 00:00:00 2001
From: Yif_Corleone
Date: Thu, 13 Sep 2018 18:24:14 +0800
Subject: [PATCH 038/139] =?UTF-8?q?String=20poll=E7=AC=94=E8=AF=AF?=
=?UTF-8?q?=E4=BF=AE=E6=94=B9=20227~272=E8=A1=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
notes/Java 基础.md | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index 9da25851..8dcbff2a 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -226,9 +226,9 @@ System.out.println(s4 == s5); // true
## new String("abc")
-使用这种方式一共会创建两个字符串对象（前提是 String Poll 中还没有 "abc" 字符串对象）。
+使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。
-- "abc" 属于字符串字面量，因此编译时期会在 String Poll 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
+- "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
- 而使用 new 的方式会在堆中创建一个字符串对象。
创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。
@@ -267,7 +267,7 @@ Constant pool:
// ...
```
-在 Constant Poll 中，#19 存储这字符串字面量 "abc"，#3 是 String Poll 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Poll 中的字符串对象作为 String 构造函数的参数。
+在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
From b751fc80239a6ef8991c2c8019937bee2a87883b Mon Sep 17 00:00:00 2001
From: Yif_Corleone
Date: Fri, 14 Sep 2018 11:32:07 +0800
Subject: [PATCH 039/139] =?UTF-8?q?Java=20=E5=9F=BA=E7=A1=80=EF=BC=8C?=
=?UTF-8?q?=E5=AF=B9final=E5=85=B3=E9=94=AE=E5=AD=97=E8=A1=A5=E5=85=85?=
=?UTF-8?q?=E6=9E=84=E9=80=A0=E5=99=A8=E7=9B=B8=E5=85=B3=E7=82=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
notes/Java 基础.md | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index bc856d4d..c5aac14e 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -1042,6 +1042,10 @@ private 方法隐式地被指定为 final，如果在子类中定义的方法和
声明类不允许被继承。
+**4. 构造器**
+
+声明类不允许被`new`实例化，多用于`Singleton`模式中。如果该类有子类需要继承，若该类无其他构造器，则不允许被继承。
+
## static
**1. 静态变量**
From f2e8961f3706020cd17dd4e758851c7c9f4a312e Mon Sep 17 00:00:00 2001
From: Yif_Corleone
Date: Fri, 14 Sep 2018 14:13:33 +0800
Subject: [PATCH 040/139] =?UTF-8?q?Java=20=E5=9F=BA=E7=A1=80=20=E2=80=9C?=
=?UTF-8?q?=E9=9A=90=E5=BC=8F=E7=B1=BB=E5=9E=8B=E8=BD=AC=E6=8D=A2=E2=80=9D?=
=?UTF-8?q?=E4=B8=AD++=E5=92=8C+=3D=E6=95=88=E6=9E=9C=E4=B8=80=E6=A0=B7?=
=?UTF-8?q?=EF=BC=8C=E4=B9=9F=E4=BC=9A=E6=89=A7=E8=A1=8C=E9=9A=90=E5=BC=8F?=
=?UTF-8?q?=E7=9A=84=E7=B1=BB=E5=9E=8B=E8=BD=AC=E6=8D=A2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
notes/Java 基础.md | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index c5aac14e..9992d1ec 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -368,10 +368,11 @@ short s1 = 1;
// s1 = s1 + 1;
```
-但是使用 += 运算符可以执行隐式类型转换。
+但是使用 += 或 ++ 运算符可以执行隐式类型转换。
```java
s1 += 1;
+// s1++;
```
上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
From 60ed4f498ca07d3ef6058dd5f783c8156ab97413 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Fri, 14 Sep 2018 21:35:10 +0800
Subject: [PATCH 041/139] auto commit
---
notes/Java IO.md | 7 ++++---
notes/Java 基础.md | 21 +++++++++++++--------
notes/Java 并发.md | 5 +++++
notes/剑指 offer 题解.md | 2 +-
notes/数据库系统原理.md | 12 ++++++------
notes/缓存.md | 4 +++-
6 files changed, 32 insertions(+), 19 deletions(-)
diff --git a/notes/Java IO.md b/notes/Java IO.md
index acb95b36..a2dd668b 100644
--- a/notes/Java IO.md
+++ b/notes/Java IO.md
@@ -69,16 +69,17 @@ public static void listAllFiles(File dir) {
```java
public static void copyFile(String src, String dist) throws IOException {
-
FileInputStream in = new FileInputStream(src);
FileOutputStream out = new FileOutputStream(dist);
+
byte[] buffer = new byte[20 * 1024];
+ int cnt;
// read() 最多读取 buffer.length 个字节
// 返回的是实际读取的个数
// 返回 -1 的时候表示读到 eof，即文件尾
- while (in.read(buffer, 0, buffer.length) != -1) {
- out.write(buffer);
+ while ((cnt = in.read(buffer, 0, buffer.length)) != -1) {
+ out.write(buffer, 0, cnt);
}
in.close();
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index d8f17cef..0087fde7 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -196,9 +196,9 @@ String 不可变性天生具备线程安全，可以在多个线程中安全地
## String Pool
-字符串常量池（String Poll）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Poll 中。
+字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。
-当一个字符串调用 intern() 方法时，如果 String Poll 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Poll 中字符串的引用；否则，就会在 String Poll 中添加一个新的字符串，并返回这个新字符串的引用。
+当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。
下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。
@@ -216,19 +216,19 @@ System.out.println(s3 == s4); // true
```java
String s5 = "bbb";
String s6 = "bbb";
-System.out.println(s4 == s5); // true
+System.out.println(s5 == s6); // true
```
-在 Java 7 之前，String Poll 被放在运行时常量池中，它属于永久代。而在 Java 7，String Poll 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
+在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
- [StackOverflow : What is String interning?](https://stackoverflow.com/questions/10578984/what-is-string-interning)
- [深入解析 String#intern](https://tech.meituan.com/in_depth_understanding_string_intern.html)
## new String("abc")
-使用这种方式一共会创建两个字符串对象（前提是 String Poll 中还没有 "abc" 字符串对象）。
+使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。
-- "abc" 属于字符串字面量，因此编译时期会在 String Poll 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
+- "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
- 而使用 new 的方式会在堆中创建一个字符串对象。
创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。
@@ -267,7 +267,7 @@ Constant pool:
// ...
```
-在 Constant Poll 中，#19 存储这字符串字面量 "abc"，#3 是 String Poll 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Poll 中的字符串对象作为 String 构造函数的参数。
+在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
@@ -368,10 +368,11 @@ short s1 = 1;
// s1 = s1 + 1;
```
-但是使用 += 运算符可以执行隐式类型转换。
+但是使用 += 或者 ++ 运算符可以执行隐式类型转换。
```java
s1 += 1;
+// s1++;
```
上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
@@ -1042,6 +1043,10 @@ private 方法隐式地被指定为 final，如果在子类中定义的方法和
声明类不允许被继承。
+**4. 构造器**
+
+声明类不允许被 `new` 实例化，多用于 `Singleton` 模式中。如果该类有子类需要继承，若该类无其他构造器，则不允许被继承。
+
## static
**1. 静态变量**
diff --git a/notes/Java 并发.md b/notes/Java 并发.md
index 977d85f2..add3982a 100644
--- a/notes/Java 并发.md
+++ b/notes/Java 并发.md
@@ -740,6 +740,7 @@ java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.
```java
public class CountdownLatchExample {
+
public static void main(String[] args) throws InterruptedException {
final int totalThread = 10;
CountDownLatch countDownLatch = new CountDownLatch(totalThread);
@@ -788,6 +789,7 @@ public CyclicBarrier(int parties) {
```java
public class CyclicBarrierExample {
+
public static void main(String[] args) {
final int totalThread = 10;
CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
@@ -822,6 +824,7 @@ Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的
```java
public class SemaphoreExample {
+
public static void main(String[] args) {
final int clientCount = 3;
final int totalRequestCount = 10;
@@ -866,6 +869,7 @@ FutureTask 可用于异步获取执行结果或取消执行任务的场景。当
```java
public class FutureTaskExample {
+
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask futureTask = new FutureTask(new Callable() {
@Override
@@ -971,6 +975,7 @@ produce..produce..consume..consume..produce..consume..produce..consume..produce.
```java
public class ForkJoinExample extends RecursiveTask {
+
private final int threshold = 5;
private int first;
private int last;
diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index 2c8f2822..2c2be5b2 100644
--- a/notes/剑指 offer 题解.md
+++ b/notes/剑指 offer 题解.md
@@ -1154,7 +1154,7 @@ public ListNode FindKthToTail(ListNode head, int k) {
## 解题思路
-使用双指针，一个指针 fast 每次移动两个节点，一个指针 slow 每次移动一个节点。因为存在环，所以两个指针必定相遇在环中的某个节点上。假设相遇点在下图的 z1 位置，此时 fast 移动的节点数为 x+2y+z，slow 为 x+y，由于 fast 速度比 slow 快一倍，因此 x+2y+z=2(x+y)，得到 x=z。
+使用双指针，一个指针 fast 每次移动两个节点，一个指针 slow 每次移动一个节点。因为存在环，所以两个指针必定相遇在环中的某个节点上。假设相遇点在下图的 y4 位置，此时 fast 移动的节点数为 x+2y+z，slow 为 x+y，由于 fast 速度比 slow 快一倍，因此 x+2y+z=2(x+y)，得到 x=z。
在相遇点，slow 要到环的入口点还需要移动 z 个节点，如果让 fast 重新从头开始移动，并且速度变为每次移动一个节点，那么它到环入口点还需要移动 x 个节点。在上面已经推导出 x=z，因此 fast 和 slow 将在环入口点相遇。
diff --git a/notes/数据库系统原理.md b/notes/数据库系统原理.md
index 1bcd2533..1ce774fa 100644
--- a/notes/数据库系统原理.md
+++ b/notes/数据库系统原理.md
@@ -294,12 +294,12 @@ SELECT ... FOR UPDATE;
----
-| 隔离级别 | 脏读 | 不可重复读 | 幻影读 |
-| :---: | :---: | :---:| :---: |
-| 未提交读 | √ | √ | √ |
-| 提交读 | × | √ | √ |
-| 可重复读 | × | × | √ |
-| 可串行化 | × | × | × |
+| 隔离级别 | 脏读 | 不可重复读 | 幻影读 | 加锁读 |
+| :---: | :---: | :---:| :---: | :---: |
+| 未提交读 | √ | √ | √ | × |
+| 提交读 | × | √ | √ | × |
+| 可重复读 | × | × | √ | × |
+| 可串行化 | × | × | × | √ |
# 五、多版本并发控制
diff --git a/notes/缓存.md b/notes/缓存.md
index 8f7449bf..07a9e866 100644
--- a/notes/缓存.md
+++ b/notes/缓存.md
@@ -99,7 +99,7 @@ public class LRU implements Iterable {
if (map.size() > maxSize) {
Node toRemove = removeTail();
- map.remove(toRemove);
+ map.remove(toRemove.k);
}
}
@@ -114,6 +114,7 @@ public class LRU implements Iterable {
private void appendHead(Node node) {
node.next = head.next;
+ node.next.pre = node;
node.pre = head;
head.next = node;
}
@@ -122,6 +123,7 @@ public class LRU implements Iterable {
private Node removeTail() {
Node node = tail.pre;
tail.pre = node.pre;
+ node.pre.next = tail;
return node;
}
From 325595d41bd597a57a102b75150e939aafa7e42f Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Fri, 14 Sep 2018 22:13:46 +0800
Subject: [PATCH 042/139] auto commit
---
notes/Java 基础.md | 2 +-
notes/剑指 offer 题解.md | 2 +-
pics/70fa1f83-dae7-456d-b94b-ce28963b2ba1.png | Bin 0 -> 17408 bytes
3 files changed, 2 insertions(+), 2 deletions(-)
create mode 100644 pics/70fa1f83-dae7-456d-b94b-ce28963b2ba1.png
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index 5bb41ea6..0087fde7 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -1045,7 +1045,7 @@ private 方法隐式地被指定为 final，如果在子类中定义的方法和
**4. 构造器**
-声明类不允许被`new`实例化，多用于`Singleton`模式中。如果该类有子类需要继承，若该类无其他构造器，则不允许被继承。
+声明类不允许被 `new` 实例化，多用于 `Singleton` 模式中。如果该类有子类需要继承，若该类无其他构造器，则不允许被继承。
## static
diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index 2c2be5b2..a797eaa1 100644
--- a/notes/剑指 offer 题解.md
+++ b/notes/剑指 offer 题解.md
@@ -1158,7 +1158,7 @@ public ListNode FindKthToTail(ListNode head, int k) {
在相遇点，slow 要到环的入口点还需要移动 z 个节点，如果让 fast 重新从头开始移动，并且速度变为每次移动一个节点，那么它到环入口点还需要移动 x 个节点。在上面已经推导出 x=z，因此 fast 和 slow 将在环入口点相遇。
- 
+ 
```java
public ListNode EntryNodeOfLoop(ListNode pHead) {
diff --git a/pics/70fa1f83-dae7-456d-b94b-ce28963b2ba1.png b/pics/70fa1f83-dae7-456d-b94b-ce28963b2ba1.png
new file mode 100644
index 0000000000000000000000000000000000000000..0d28e99622f41e6d1d67f1d1d4f94cef7505530b
GIT binary patch
literal 17408
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
literal 0
HcmV?d00001
From 170f0fc3eb056c5b8ad4f16f5bac5396bcad250e Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Fri, 14 Sep 2018 22:14:52 +0800
Subject: [PATCH 043/139] auto commit
---
notes/剑指 offer 题解.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index a797eaa1..4af993dd 100644
--- a/notes/剑指 offer 题解.md
+++ b/notes/剑指 offer 题解.md
@@ -1154,7 +1154,7 @@ public ListNode FindKthToTail(ListNode head, int k) {
## 解题思路
-使用双指针，一个指针 fast 每次移动两个节点，一个指针 slow 每次移动一个节点。因为存在环，所以两个指针必定相遇在环中的某个节点上。假设相遇点在下图的 y4 位置，此时 fast 移动的节点数为 x+2y+z，slow 为 x+y，由于 fast 速度比 slow 快一倍，因此 x+2y+z=2(x+y)，得到 x=z。
+使用双指针，一个指针 fast 每次移动两个节点，一个指针 slow 每次移动一个节点。因为存在环，所以两个指针必定相遇在环中的某个节点上。假设相遇点在下图的 y6 位置，此时 fast 移动的节点数为 x+2y+z，slow 为 x+y，由于 fast 速度比 slow 快一倍，因此 x+2y+z=2(x+y)，得到 x=z。
在相遇点，slow 要到环的入口点还需要移动 z 个节点，如果让 fast 重新从头开始移动，并且速度变为每次移动一个节点，那么它到环入口点还需要移动 x 个节点。在上面已经推导出 x=z，因此 fast 和 slow 将在环入口点相遇。
From b802b8add8fa367d09494c37fe20c13e123b14a3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=81=AA=E5=A8=81?=
Date: Sun, 16 Sep 2018 14:17:21 +0800
Subject: [PATCH 044/139] =?UTF-8?q?Update=20=E5=89=91=E6=8C=87=20offer=20?=
=?UTF-8?q?=E9=A2=98=E8=A7=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
notes/剑指 offer 题解.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index 4af993dd..e1a87b5b 100644
--- a/notes/剑指 offer 题解.md
+++ b/notes/剑指 offer 题解.md
@@ -1559,7 +1559,7 @@ public ArrayList> Print(TreeNode pRoot) {
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。假设输入的数组的任意两个数字都互不相同。
-例如，下图是后序遍历序列 3,1,2 所对应的二叉搜索树。
+例如，下图是后序遍历序列 1,3,2 所对应的二叉搜索树。
From 55f1d4e2f53effb4e75e349ccf9b278060bf62f3 Mon Sep 17 00:00:00 2001
From: 0xl2oot <0xl2oot@gmail.com>
Date: Mon, 17 Sep 2018 21:42:01 +0800
Subject: [PATCH 045/139] Update SUMMARY.md
---
SUMMARY.md | 25 +++++++++++++++++++------
1 file changed, 19 insertions(+), 6 deletions(-)
diff --git a/SUMMARY.md b/SUMMARY.md
index 69b6103c..a864c37f 100644
--- a/SUMMARY.md
+++ b/SUMMARY.md
@@ -27,10 +27,23 @@ This file used to generate gitbook catalogue.
* [Java 虚拟机](/notes/Java 虚拟机.md)
* [Java 并发](/notes/Java 并发.md)
* [Java 容器](/notes/Java 容器.md)
- * [Java I/O](/notes/Java I/O.md)
-* 分布式
- * [一致性](/notes/一致性.md)
- * [分布式问题分析](/notes/分布式问题分析.md)
-
-
+ * [Java I/O](/notes/Java IO.md)
+* 系统设计
+ * [系统设计基础](/notes/系统设计基础.md)
+ * [分布式](/notes/分布式.md)
+ * [集群](/notes/集群.md)
+ * [攻击技术](/notes/攻击技术.md)
+ * [缓存](/notes/缓存.md)
+ * [消息队列](/notes/消息队列.md)
+* 工具
+ * [Git](/notes/Git.md)
+ * [Docker](/notes/Docker.md)
+ * [正则表达式](/notes/正则表达式.md)
+ * [构建工具](/notes/构建工具.md)
+* 编码实践
+ * [重构](/notes/重构.md)
+ * [代码可读性](/notes/代码可读性.md)
+ * [代码风格规范](/notes/代码风格规范.md)
+* 参考书目
+ * [BOOKLIST](/BOOKLIST.md)
From e56a80629286fad24633654a1b27494081952b53 Mon Sep 17 00:00:00 2001
From: Yif_Corleone
Date: Tue, 18 Sep 2018 00:44:56 +0800
Subject: [PATCH 046/139] Java
---
notes/Java 基础.md | 4 ----
1 file changed, 4 deletions(-)
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index 0087fde7..eb3572cd 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -1043,10 +1043,6 @@ private 方法隐式地被指定为 final，如果在子类中定义的方法和
声明类不允许被继承。
-**4. 构造器**
-
-声明类不允许被 `new` 实例化，多用于 `Singleton` 模式中。如果该类有子类需要继承，若该类无其他构造器，则不允许被继承。
-
## static
**1. 静态变量**
From 338d0bff7fab7d27537b91b1c48a1d035991e527 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 18 Sep 2018 09:31:50 +0800
Subject: [PATCH 047/139] auto commit
---
notes/Java 基础.md | 4 ----
notes/剑指 offer 题解.md | 2 +-
notes/计算机操作系统.md | 2 +-
notes/设计模式.md | 2 +-
4 files changed, 3 insertions(+), 7 deletions(-)
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index 0087fde7..eb3572cd 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -1043,10 +1043,6 @@ private 方法隐式地被指定为 final，如果在子类中定义的方法和
声明类不允许被继承。
-**4. 构造器**
-
-声明类不允许被 `new` 实例化，多用于 `Singleton` 模式中。如果该类有子类需要继承，若该类无其他构造器，则不允许被继承。
-
## static
**1. 静态变量**
diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index 4af993dd..e1a87b5b 100644
--- a/notes/剑指 offer 题解.md
+++ b/notes/剑指 offer 题解.md
@@ -1559,7 +1559,7 @@ public ArrayList> Print(TreeNode pRoot) {
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。假设输入的数组的任意两个数字都互不相同。
-例如，下图是后序遍历序列 3,1,2 所对应的二叉搜索树。
+例如，下图是后序遍历序列 1,3,2 所对应的二叉搜索树。
diff --git a/notes/计算机操作系统.md b/notes/计算机操作系统.md
index e6c462a6..c0c4364e 100644
--- a/notes/计算机操作系统.md
+++ b/notes/计算机操作系统.md
@@ -1038,7 +1038,7 @@ gcc -o hello hello.c
## 静态链接
-静态连接器以一组可重定向目标文件为输入，生成一个完全链接的可执行目标文件作为输出。链接器主要完成以下两个任务：
+静态链接器以一组可重定向目标文件为输入，生成一个完全链接的可执行目标文件作为输出。链接器主要完成以下两个任务：
- 符号解析：每个符号对应于一个函数、一个全局变量或一个静态变量，符号解析的目的是将每个符号引用与一个符号定义关联起来。
- 重定位：链接器通过把每个符号定义与一个内存位置关联起来，然后修改所有对这些符号的引用，使得它们指向这个内存位置。
diff --git a/notes/设计模式.md b/notes/设计模式.md
index d44d0e33..3b53a66a 100644
--- a/notes/设计模式.md
+++ b/notes/设计模式.md
@@ -177,7 +177,7 @@ public class Singleton {
#### Ⅵ 枚举实现
- ```java
+```java
public enum Singleton {
INSTANCE;
From 57a741092b3d04dcb7f4019e1fa7cbcd47a6db17 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 18 Sep 2018 09:33:33 +0800
Subject: [PATCH 048/139] auto commit
---
notes/设计模式.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/notes/设计模式.md b/notes/设计模式.md
index 3b53a66a..8c9f0b22 100644
--- a/notes/设计模式.md
+++ b/notes/设计模式.md
@@ -217,7 +217,7 @@ public enum Singleton {
}
}
}
- ```
+```
该实现在多次序列化再进行反序列化之后，不会得到多个实例。而其它实现，为了保证不会出现反序列化之后出现多个实例，需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法。
From f89ef4cf591d2ef04f89e3428fc2af34be56617d Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 18 Sep 2018 09:42:24 +0800
Subject: [PATCH 049/139] auto commit
---
notes/设计模式.md | 3 +++
1 file changed, 3 insertions(+)
diff --git a/notes/设计模式.md b/notes/设计模式.md
index 8c9f0b22..c177ff92 100644
--- a/notes/设计模式.md
+++ b/notes/设计模式.md
@@ -276,6 +276,7 @@ public class ConcreteProduct2 implements Product {
```java
public class Client {
+
public static void main(String[] args) {
int type = 1;
Product product;
@@ -295,6 +296,7 @@ public class Client {
```java
public class SimpleFactory {
+
public Product createProduct(int type) {
if (type == 1) {
return new ConcreteProduct1();
@@ -308,6 +310,7 @@ public class SimpleFactory {
```java
public class Client {
+
public static void main(String[] args) {
SimpleFactory simpleFactory = new SimpleFactory();
Product product = simpleFactory.createProduct(1);
From e3c63b6637f4a95981c4a6b54286667daab01c06 Mon Sep 17 00:00:00 2001
From: Yutong Wang
Date: Mon, 17 Sep 2018 21:50:19 -0700
Subject: [PATCH 050/139] Simplify House Robber solution
---
notes/Leetcode 题解.md | 31 +++++++++++--------------------
1 file changed, 11 insertions(+), 20 deletions(-)
diff --git a/notes/Leetcode 题解.md b/notes/Leetcode 题解.md
index 04a751c7..2d6b2d5f 100644
--- a/notes/Leetcode 题解.md
+++ b/notes/Leetcode 题解.md
@@ -2415,27 +2415,19 @@ public int climbStairs(int n) {
定义 dp 数组用来存储最大的抢劫量，其中 dp[i] 表示抢到第 i 个住户时的最大抢劫量。
由于不能抢劫邻近住户，因此如果抢劫了第 i 个住户那么只能抢劫 i - 2 或者 i - 3 的住户，所以
-
-+nums[i])
+dp[i] = max(dp[i-1], dp[i-2] + nums[i])
```java
public int rob(int[] nums) {
- int n = nums.length;
- if (n == 0) {
- return 0;
- }
- if (n == 1) {
- return nums[0];
- }
- int pre3 = 0, pre2 = 0, pre1 = 0;
- for (int i = 0; i < n; i++) {
- int cur = Math.max(pre2, pre3) + nums[i];
- pre3 = pre2;
+ int pre2 = 0, pre1 = 0;
+ for (int i = 0; i < nums.length; i++) {
+ int cur = Math.max(pre2 + nums[i], pre1);
pre2 = pre1;
pre1 = cur;
}
- return Math.max(pre1, pre2);
+ return pre1;
}
+
```
**强盗在环形街区抢劫**
@@ -2443,7 +2435,7 @@ public int rob(int[] nums) {
[213. House Robber II (Medium)](https://leetcode.com/problems/house-robber-ii/description/)
```java
-public int rob(int[] nums) {
+public int rob(int[] nums) {
if (nums == null || nums.length == 0) {
return 0;
}
@@ -2454,15 +2446,14 @@ public int rob(int[] nums) {
return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1));
}
-private int rob(int[] nums, int first, int last) {
- int pre3 = 0, pre2 = 0, pre1 = 0;
+private int rob(int[] nums, int first, int last) {
+ int pre2 = 0, pre1 = 0;
for (int i = first; i <= last; i++) {
- int cur = Math.max(pre3, pre2) + nums[i];
- pre3 = pre2;
+ int cur = Math.max(pre1, pre2 + nums[i]);
pre2 = pre1;
pre1 = cur;
}
- return Math.max(pre2, pre1);
+ return pre1;
}
```
From 497812bd4232da65e88b9e7628a0e7de5abb3030 Mon Sep 17 00:00:00 2001
From: Yutong Wang
Date: Mon, 17 Sep 2018 23:40:06 -0700
Subject: [PATCH 051/139] Fix a bug in the Minimum Path Sum solution
Check boundary
---
notes/Leetcode 题解.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/notes/Leetcode 题解.md b/notes/Leetcode 题解.md
index 2d6b2d5f..d09ff18d 100644
--- a/notes/Leetcode 题解.md
+++ b/notes/Leetcode 题解.md
@@ -2505,9 +2505,9 @@ public int minPathSum(int[][] grid) {
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (i == 0) {
- dp[j] = dp[j - 1];
+ if (j>0) dp[j] = dp[j - 1];
} else {
- dp[j] = Math.min(dp[j - 1], dp[j]);
+ if (j>0) dp[j] = Math.min(dp[j - 1], dp[j]);
}
dp[j] += grid[i][j];
}
From 177a4325950ebebbfcc69c9c9a41d31ddba091d3 Mon Sep 17 00:00:00 2001
From: Jingui Ren <1198980993@qq.com>
Date: Tue, 18 Sep 2018 10:31:09 +0000
Subject: [PATCH 052/139] =?UTF-8?q?mask=E8=AE=A1=E7=AE=97=E9=94=99?=
=?UTF-8?q?=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
当mask = 11011000的时候，mask |= mask >> 2这个时候的值应该为11111110
---
notes/Java 容器.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/notes/Java 容器.md b/notes/Java 容器.md
index 84189928..e42a42f0 100644
--- a/notes/Java 容器.md
+++ b/notes/Java 容器.md
@@ -738,7 +738,7 @@ HashMap 构造函数允许用户传入的容量不是 2 的 n 次方，因为它
```
mask |= mask >> 1 11011000
-mask |= mask >> 2 11111100
+mask |= mask >> 2 11111110
mask |= mask >> 4 11111111
```
From 642411cdc62dde62b7e9bfbc583a3cd3624e9633 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 19 Sep 2018 12:56:03 +0800
Subject: [PATCH 053/139] auto commit
---
notes/Java 基础.md | 11 +++----
notes/Java 容器.md | 2 +-
notes/Leetcode 题解.md | 28 ++++++------------
notes/MySQL.md | 2 +-
notes/剑指 offer 题解.md | 6 ++--
notes/数据库系统原理.md | 12 ++++----
notes/算法.md | 6 ++--
notes/系统设计基础.md | 5 ++++
notes/缓存.md | 4 ++-
notes/计算机操作系统.md | 2 +-
notes/设计模式.md | 7 +++--
pics/70fa1f83-dae7-456d-b94b-ce28963b2ba1.png | Bin 0 -> 17408 bytes
12 files changed, 43 insertions(+), 42 deletions(-)
create mode 100644 pics/70fa1f83-dae7-456d-b94b-ce28963b2ba1.png
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index 9da25851..eb3572cd 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -216,7 +216,7 @@ System.out.println(s3 == s4); // true
```java
String s5 = "bbb";
String s6 = "bbb";
-System.out.println(s4 == s5); // true
+System.out.println(s5 == s6); // true
```
在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
@@ -226,9 +226,9 @@ System.out.println(s4 == s5); // true
## new String("abc")
-使用这种方式一共会创建两个字符串对象（前提是 String Poll 中还没有 "abc" 字符串对象）。
+使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。
-- "abc" 属于字符串字面量，因此编译时期会在 String Poll 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
+- "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
- 而使用 new 的方式会在堆中创建一个字符串对象。
创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。
@@ -267,7 +267,7 @@ Constant pool:
// ...
```
-在 Constant Poll 中，#19 存储这字符串字面量 "abc"，#3 是 String Poll 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Poll 中的字符串对象作为 String 构造函数的参数。
+在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
@@ -368,10 +368,11 @@ short s1 = 1;
// s1 = s1 + 1;
```
-但是使用 += 运算符可以执行隐式类型转换。
+但是使用 += 或者 ++ 运算符可以执行隐式类型转换。
```java
s1 += 1;
+// s1++;
```
上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
diff --git a/notes/Java 容器.md b/notes/Java 容器.md
index 84189928..e42a42f0 100644
--- a/notes/Java 容器.md
+++ b/notes/Java 容器.md
@@ -738,7 +738,7 @@ HashMap 构造函数允许用户传入的容量不是 2 的 n 次方，因为它
```
mask |= mask >> 1 11011000
-mask |= mask >> 2 11111100
+mask |= mask >> 2 11111110
mask |= mask >> 4 11111111
```
diff --git a/notes/Leetcode 题解.md b/notes/Leetcode 题解.md
index 04a751c7..def70c60 100644
--- a/notes/Leetcode 题解.md
+++ b/notes/Leetcode 题解.md
@@ -2420,21 +2420,13 @@ public int climbStairs(int n) {
```java
public int rob(int[] nums) {
- int n = nums.length;
- if (n == 0) {
- return 0;
- }
- if (n == 1) {
- return nums[0];
- }
- int pre3 = 0, pre2 = 0, pre1 = 0;
- for (int i = 0; i < n; i++) {
- int cur = Math.max(pre2, pre3) + nums[i];
- pre3 = pre2;
+ int pre2 = 0, pre1 = 0;
+ for (int i = 0; i < nums.length; i++) {
+ int cur = Math.max(pre2 + nums[i], pre1);
pre2 = pre1;
pre1 = cur;
}
- return Math.max(pre1, pre2);
+ return pre1;
}
```
@@ -2443,7 +2435,7 @@ public int rob(int[] nums) {
[213. House Robber II (Medium)](https://leetcode.com/problems/house-robber-ii/description/)
```java
-public int rob(int[] nums) {
+public int rob(int[] nums) {
if (nums == null || nums.length == 0) {
return 0;
}
@@ -2454,15 +2446,14 @@ public int rob(int[] nums) {
return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1));
}
-private int rob(int[] nums, int first, int last) {
- int pre3 = 0, pre2 = 0, pre1 = 0;
+private int rob(int[] nums, int first, int last) {
+ int pre2 = 0, pre1 = 0;
for (int i = first; i <= last; i++) {
- int cur = Math.max(pre3, pre2) + nums[i];
- pre3 = pre2;
+ int cur = Math.max(pre1, pre2 + nums[i]);
pre2 = pre1;
pre1 = cur;
}
- return Math.max(pre2, pre1);
+ return pre1;
}
```
@@ -7063,4 +7054,3 @@ public int[] countBits(int num) {
- 何海涛, 软件工程师. 剑指 Offer: 名企面试官精讲典型编程题[M]. 电子工业出版社, 2014.
- 《编程之美》小组. 编程之美[M]. 电子工业出版社, 2008.
- 左程云. 程序员代码面试指南[M]. 电子工业出版社, 2015.
-
diff --git a/notes/MySQL.md b/notes/MySQL.md
index 2c5d8935..f5479685 100644
--- a/notes/MySQL.md
+++ b/notes/MySQL.md
@@ -374,7 +374,7 @@ MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提
### 2. 连接
-可以将原来的连接分解成多个单表连接查询，然后在用户程序中进行连接。
+可以将原来的连接分解成多个单表查询，然后在用户程序中进行连接。
### 3. ID 唯一性
diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index 2c8f2822..e1a87b5b 100644
--- a/notes/剑指 offer 题解.md
+++ b/notes/剑指 offer 题解.md
@@ -1154,11 +1154,11 @@ public ListNode FindKthToTail(ListNode head, int k) {
## 解题思路
-使用双指针，一个指针 fast 每次移动两个节点，一个指针 slow 每次移动一个节点。因为存在环，所以两个指针必定相遇在环中的某个节点上。假设相遇点在下图的 z1 位置，此时 fast 移动的节点数为 x+2y+z，slow 为 x+y，由于 fast 速度比 slow 快一倍，因此 x+2y+z=2(x+y)，得到 x=z。
+使用双指针，一个指针 fast 每次移动两个节点，一个指针 slow 每次移动一个节点。因为存在环，所以两个指针必定相遇在环中的某个节点上。假设相遇点在下图的 y6 位置，此时 fast 移动的节点数为 x+2y+z，slow 为 x+y，由于 fast 速度比 slow 快一倍，因此 x+2y+z=2(x+y)，得到 x=z。
在相遇点，slow 要到环的入口点还需要移动 z 个节点，如果让 fast 重新从头开始移动，并且速度变为每次移动一个节点，那么它到环入口点还需要移动 x 个节点。在上面已经推导出 x=z，因此 fast 和 slow 将在环入口点相遇。
-
+
```java
public ListNode EntryNodeOfLoop(ListNode pHead) {
@@ -1559,7 +1559,7 @@ public ArrayList> Print(TreeNode pRoot) {
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。假设输入的数组的任意两个数字都互不相同。
-例如，下图是后序遍历序列 3,1,2 所对应的二叉搜索树。
+例如，下图是后序遍历序列 1,3,2 所对应的二叉搜索树。
diff --git a/notes/数据库系统原理.md b/notes/数据库系统原理.md
index 1bcd2533..1ce774fa 100644
--- a/notes/数据库系统原理.md
+++ b/notes/数据库系统原理.md
@@ -294,12 +294,12 @@ SELECT ... FOR UPDATE;
----
-| 隔离级别 | 脏读 | 不可重复读 | 幻影读 |
-| :---: | :---: | :---:| :---: |
-| 未提交读 | √ | √ | √ |
-| 提交读 | × | √ | √ |
-| 可重复读 | × | × | √ |
-| 可串行化 | × | × | × |
+| 隔离级别 | 脏读 | 不可重复读 | 幻影读 | 加锁读 |
+| :---: | :---: | :---:| :---: | :---: |
+| 未提交读 | √ | √ | √ | × |
+| 提交读 | × | √ | √ | × |
+| 可重复读 | × | × | √ | × |
+| 可串行化 | × | × | × | √ |
# 五、多版本并发控制
diff --git a/notes/算法.md b/notes/算法.md
index cb83830b..1bc0690a 100644
--- a/notes/算法.md
+++ b/notes/算法.md
@@ -459,7 +459,7 @@ public abstract class MergeSort> extends Sort {
将一个大数组分成两个小数组去求解。
-因为每次都将问题对半分成两个子问题，而这种对半分的算法复杂度一般为 O(NlogN)，因此该归并排序方法的时间复杂度也为 O(NlogN)。
+因为每次都将问题对半分成两个子问题，这种对半分的算法复杂度一般为 O(NlogN)。
```java
public class Up2DownMergeSort> extends MergeSort {
@@ -617,7 +617,7 @@ public class ThreeWayQuickSort> extends QuickSort {
可以利用这个特性找出数组的第 k 个元素。
-该算法是线性级别的，因为每次能将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。
+该算法是线性级别的，假设每次能将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。
```java
public T select(T[] nums, int k) {
@@ -2292,7 +2292,7 @@ from H1 to H3
可以将每种字符转换成二进制编码，例如将 a 转换为 00，b 转换为 01，c 转换为 10，d 转换为 11。这是最简单的一种编码方式，没有考虑各个字符的权值（出现频率）。而哈夫曼编码采用了贪心策略，使出现频率最高的字符的编码最短，从而保证整体的编码长度最短。
-首先生成一颗哈夫曼树，每次生成过程中选取频率最少的两个节点，生成一个新节点作为它们的父节点，并且新节点的频率为两个节点的和。选取频率最少的原因是，生成过程使得先选取的节点在树的最底层，那么需要的编码长度更长，频率更少可以使得总编码长度更少。
+首先生成一颗哈夫曼树，每次生成过程中选取频率最少的两个节点，生成一个新节点作为它们的父节点，并且新节点的频率为两个节点的和。选取频率最少的原因是，生成过程使得先选取的节点位于树的更低层，那么需要的编码长度更长，频率更少可以使得总编码长度更少。
生成编码时，从根节点出发，向左遍历则添加二进制位 0，向右则添加二进制位 1，直到遍历到叶子节点，叶子节点代表的字符的编码就是这个路径编码。
diff --git a/notes/系统设计基础.md b/notes/系统设计基础.md
index 4a961140..ffa5de70 100644
--- a/notes/系统设计基础.md
+++ b/notes/系统设计基础.md
@@ -4,6 +4,7 @@
* [三、扩展性](#三扩展性)
* [四、可用性](#四可用性)
* [五、安全性](#五安全性)
+* [参考资料](#参考资料)
@@ -102,3 +103,7 @@
# 五、安全性
要求系统的应对各种攻击手段时能够有可靠的应对措施。
+
+# 参考资料
+
+- 大型网站技术架构：核心原理与案例分析
diff --git a/notes/缓存.md b/notes/缓存.md
index 8f7449bf..07a9e866 100644
--- a/notes/缓存.md
+++ b/notes/缓存.md
@@ -99,7 +99,7 @@ public class LRU implements Iterable {
if (map.size() > maxSize) {
Node toRemove = removeTail();
- map.remove(toRemove);
+ map.remove(toRemove.k);
}
}
@@ -114,6 +114,7 @@ public class LRU implements Iterable {
private void appendHead(Node node) {
node.next = head.next;
+ node.next.pre = node;
node.pre = head;
head.next = node;
}
@@ -122,6 +123,7 @@ public class LRU implements Iterable {
private Node removeTail() {
Node node = tail.pre;
tail.pre = node.pre;
+ node.pre.next = tail;
return node;
}
diff --git a/notes/计算机操作系统.md b/notes/计算机操作系统.md
index e6c462a6..c0c4364e 100644
--- a/notes/计算机操作系统.md
+++ b/notes/计算机操作系统.md
@@ -1038,7 +1038,7 @@ gcc -o hello hello.c
## 静态链接
-静态连接器以一组可重定向目标文件为输入，生成一个完全链接的可执行目标文件作为输出。链接器主要完成以下两个任务：
+静态链接器以一组可重定向目标文件为输入，生成一个完全链接的可执行目标文件作为输出。链接器主要完成以下两个任务：
- 符号解析：每个符号对应于一个函数、一个全局变量或一个静态变量，符号解析的目的是将每个符号引用与一个符号定义关联起来。
- 重定位：链接器通过把每个符号定义与一个内存位置关联起来，然后修改所有对这些符号的引用，使得它们指向这个内存位置。
diff --git a/notes/设计模式.md b/notes/设计模式.md
index d44d0e33..c177ff92 100644
--- a/notes/设计模式.md
+++ b/notes/设计模式.md
@@ -177,7 +177,7 @@ public class Singleton {
#### Ⅵ 枚举实现
- ```java
+```java
public enum Singleton {
INSTANCE;
@@ -217,7 +217,7 @@ public enum Singleton {
}
}
}
- ```
+```
该实现在多次序列化再进行反序列化之后，不会得到多个实例。而其它实现，为了保证不会出现反序列化之后出现多个实例，需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法。
@@ -276,6 +276,7 @@ public class ConcreteProduct2 implements Product {
```java
public class Client {
+
public static void main(String[] args) {
int type = 1;
Product product;
@@ -295,6 +296,7 @@ public class Client {
```java
public class SimpleFactory {
+
public Product createProduct(int type) {
if (type == 1) {
return new ConcreteProduct1();
@@ -308,6 +310,7 @@ public class SimpleFactory {
```java
public class Client {
+
public static void main(String[] args) {
SimpleFactory simpleFactory = new SimpleFactory();
Product product = simpleFactory.createProduct(1);
diff --git a/pics/70fa1f83-dae7-456d-b94b-ce28963b2ba1.png b/pics/70fa1f83-dae7-456d-b94b-ce28963b2ba1.png
new file mode 100644
index 0000000000000000000000000000000000000000..0d28e99622f41e6d1d67f1d1d4f94cef7505530b
GIT binary patch
literal 17408
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
-
-
### :pencil2: 算法
- [剑指 Offer 题解](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/剑指%20offer%20题解.md)
From 9aebc4660fd0cd02d43f03e81d16178fbd00447b Mon Sep 17 00:00:00 2001
From: peierlong 
