Skip to content

Commit f7a7e1c

Browse files
author
henryjia
committed
23
1 parent a39e5a3 commit f7a7e1c

17 files changed

Lines changed: 312 additions & 93 deletions

File tree

‎docs/.DS_Store‎

0 Bytes
Binary file not shown.
224 KB
Loading

‎docs/data-management/.DS_Store‎

0 Bytes
Binary file not shown.

‎docs/data-management/MySQL/MySQL-Framework.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@
66

77
下边是 MySQL 官网中 8.0 版本的一个图,我们展开看一下,对 MySQL 整体架构和可插拔的存储引擎先有个总体回顾。
88

9-
![https://dev.mysql.com/doc/refman/8.0/en/pluggable-storage-overview.html](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/mysql/mysql-architecture.png)
9+
![](/Users/apple/picBed/mysql/mysql-architecture.png)
1010

1111

1212

‎docs/design-pattern/Factory-Pattern.md‎

Lines changed: 3 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -381,7 +381,7 @@ public class Client {
381381

382382
1. 抽象产品
383383

384-
2. ```java
384+
```java
385385
public interface Keyboard {
386386
void input();
387387
}
@@ -391,7 +391,7 @@ public class Client {
391391
```
392392

393393
2. 具体产品
394-
394+
395395
```java
396396
//具体产品
397397
public class MacKeyboard implements Keyboard {
@@ -422,7 +422,7 @@ public class Client {
422422
}
423423
}
424424
```
425-
425+
426426
3. 抽象工厂
427427

428428
```java
@@ -544,7 +544,3 @@ https://blog.csdn.net/lovelion/article/details/17517213
544544
https://wiki.jikexueyuan.com/project/java-design-pattern/abstract-factory-pattern.html
545545

546546
https://blog.csdn.net/lovelion/article/details/17517213
547-
548-
549-
550-
![](https://i.loli.net/2020/03/19/AkRqgTo6y5crBSx.png)

‎docs/distribution/.DS_Store‎

0 Bytes
Binary file not shown.

‎docs/distribution/ZooKeeper/Consistency-Protocol.md‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,22 @@
44

55
![](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/zk/007S8ZIlly1gevqnrlzg6j30b60as3ys.jpg)
66

7+
8+
9+
> 大多数分布式系统都分布在多个子网络。每个子网络就叫做一个区(partition)。分区容错的意思是,区间通信可能失败。比如,一台服务器放在中国,另一台服务器放在美国,这就是两个区,它们之间可能无法通信。
10+
>
11+
> 一般来说,分区容错无法避免,因此可以认为 CAP 的 P 总是成立。
12+
>
13+
> ![img](https://www.wangbase.com/blogimg/asset/201807/bg2018071602.png)
14+
>
15+
> 一致性和可用性,为什么不可能同时成立?答案很简单,因为可能通信失败(即出现分区容错)。
16+
>
17+
> 如果保证 G2 的一致性,那么 G1 必须在写操作时,锁定 G2 的读操作和写操作。只有数据同步后,才能重新开放读写。锁定期间,G2 不能读写,没有可用性不。
18+
>
19+
> 如果保证 G2 的可用性,那么势必不能锁定 G2,所以一致性不成立。
20+
21+
22+
723
## 一致性模型
824

925
一致性(Consistency)是指多副本(Replications)问题中的数据一致性。关于分布式系统的一致性模型有以下几种:

‎docs/interview/Collections-FAQ.md‎

Lines changed: 49 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -382,6 +382,17 @@ public E get(int index) {
382382

383383

384384

385+
### Hash冲突及解决办法
386+
387+
解决哈希冲突的方法一般有:开放定址法、链地址法(拉链法)、再哈希法、建立公共溢出区等方法。
388+
389+
> - 开放定址法:从发生冲突的那个单元起,按照一定的次序,从哈希表中找到一个空闲的单元。然后把发生冲突的元素存入到该单元的一种方法。开放定址法需要的表长度要大于等于所需要存放的元素。
390+
> - 链接地址法(拉链法):是将哈希值相同的元素构成一个同义词的单链表,并将单链表的头指针存放在哈希表的第i个单元中,查找、插入和删除主要在同义词链表中进行。(链表法适用于经常进行插入和删除的情况)
391+
> - 再哈希法:就是同时构造多个不同的哈希函数: Hi = RHi(key) i= 1,2,3 … k; 当H1 = RH1(key) 发生冲突时,再用H2 = RH2(key) 进行计算,直到冲突不再产生,这种方法不易产生聚集,但是增加了计算时间
392+
> - 建立公共溢出区:将哈希表分为公共表和溢出表,当溢出发生时,将所有溢出数据统一放到溢出区
393+
394+
395+
385396
## HashMap的底层实现
386397

387398
> 什么时候会使用HashMap?他有什么特点?
@@ -408,7 +419,7 @@ HashMap 在 JDK 7 和 JDK8 中的实现方式略有不同。分开记录。
408419
409420
3. loadFactor:加载因子。所谓的加载因子就是 HashMap (当前的容量/总容量) 到达一定值的时候,HashMap 会实施扩容。加载因子也可以通过构造方法中指定,默认的值是 0.75 。举个例子,假设有一个 HashMap 的初始容量为 16 ,那么扩容的阀值就是 0.75 * 16 = 12 。也就是说,在你打算存入第 13 个值的时候,HashMap 会先执行扩容。
410421
411-
4. threshold:扩容阀值。即 扩容阀值 = HashMap 总容量 * 加载因子。当前 HashMap 的容量大于或等于扩容阀值的时候就会去执行扩容。扩容的容量为当前 HashMap 总容量的两倍。比如,当前 HashMap 的总容量为 16 ,那么扩容之后为 32 。
422+
4. threshold:扩容阀值。即 扩容阀值 = HashMap 总容量 * 加载因子(默认是12)。当前 HashMap 的容量大于或等于扩容阀值的时候就会去执行扩容。扩容的容量为当前 HashMap 总容量的两倍。比如,当前 HashMap 的总容量为 16 ,那么扩容之后为 32 。
412423
413424
5. table:Entry 数组。我们都知道 HashMap 内部存储 key/value 是通过 Entry 这个介质来实现的。而 table 就是 Entry 数组。
414425
@@ -662,8 +673,8 @@ HashMap 定位数组索引位置,直接决定了 hash 方法的离散性能。
662673
![hash](https://tva1.sinaimg.cn/large/007S8ZIlly1gdwv5m4g4sj30ga09cdfy.jpg)
663674

664675
> 为什么要这样呢?
665-
>
666-
> HashMap 的长度为什么是 2 的幂次方?
676+
677+
### HashMap 的长度为什么是 2 的幂次方?
667678

668679
目的当然是为了减少哈希碰撞,使 table 里的数据分布的更均匀。
669680

@@ -793,7 +804,7 @@ final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
793804

794805
④.判断table[i] 是否为treeNode,即table[i] 是否是红黑树,如果是红黑树,则直接在树中插入键值对,否则转向⑤;
795806

796-
⑤.遍历table[i],判断链表长度是否大于8,大于8的话把链表转换为红黑树,在红黑树中执行插入操作,否则进行链表的插入操作;遍历过程中若发现key已经存在直接覆盖value即可;
807+
⑤.遍历table[i],判断链表长度是否大于8(还会判断数组长度是否大于等于64),大于8的话把链表转换为红黑树,在红黑树中执行插入操作,否则进行链表的插入操作;遍历过程中若发现key已经存在直接覆盖value即可;
797808

798809
⑥.插入成功后,判断实际存在的键值对数量size是否超多了最大容量threshold,如果超过,进行扩容。
799810

@@ -890,7 +901,7 @@ final Node<K,V>[] resize() {
890901
}
891902
```
892903

893-
> HashMap的扩容操作是怎么实现的?
904+
### HashMap的扩容操作是怎么实现的?
894905

895906
1. 在 jdk1.8 中,resize 方法是在 HashMap 中的键值对大于阀值时或者初始化时,就调用 resize 方法进行扩容;
896907
2. 每次扩展的时候,都是扩展 2 倍;
@@ -1118,7 +1129,33 @@ final Node<K,V> untreeify(HashMap<K,V> map) {
11181129

11191130

11201131

1121-
#### HashMap 为什么线程不安全
1132+
### 为什么JDK1.8中HashMap从头插入改成尾插入
1133+
1134+
JDK1.7中扩容时,每个元素的rehash之后,都会插入到新数组对应索引的链表头,所以这就导致原链表顺序为A->B->C,扩容之后,rehash之后的链表可能为C->B->A,元素的顺序发生了变化。在并发场景下,**扩容时**可能会出现循环链表的情况。而JDK1.8从头插入改成尾插入元素的顺序不变,避免出现循环链表的情况
1135+
1136+
![](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/others/hashmap-1.7-cycle.png)
1137+
1138+
> 在扩容时,头插法会改变链表中元素原本的顺序,以至于在并发场景下导致链表成环的问题,而尾插法,在扩容时会保持链表元素原本的顺序,就不会出现链表成环的问题
1139+
>
1140+
> ### 死循环执行步骤1
1141+
>
1142+
> 死循环是因为并发 HashMap 扩容导致的,并发扩容的第一步,线程 T1 和线程 T2 要对 HashMap 进行扩容操作,此时 T1 和 T2 指向的是链表的头结点元素 A,而 T1 和 T2 的下一个节点,也就是 T1.next 和 T2.next 指向的是 B 节点,如下图所示:
1143+
>
1144+
> ![img](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/others/hashmap-cycle-1.png)
1145+
>
1146+
> ### 死循环执行步骤2
1147+
>
1148+
> 死循环的第二步操作是,线程 T2 时间片用完进入休眠状态,而线程 T1 开始执行扩容操作,一直到线程 T1 扩容完成后,线程 T2 才被唤醒,扩容之后的场景如下图所示:图片从上图可知线程 T1 执行之后,因为是头插法,所以 HashMap 的顺序已经发生了改变,但线程 T2 对于发生的一切是不可知的,所以它的指向元素依然没变,如上图展示的那样,T2 指向的是 A 元素,T2.next 指向的节点是 B 元素。
1149+
>
1150+
> ### 死循环执行步骤3
1151+
>
1152+
> 当线程 T1 执行完,而线程 T2 恢复执行时,死循环就建立了,如下图所示:
1153+
>
1154+
> ![img](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/others/hashmap-cycle-2.png)
1155+
>
1156+
> 因为 T1 执行完扩容之后 B 节点的下一个节点是 A,而 T2 线程指向的首节点是 A,第二个节点是 B,这个顺序刚好和 T1 扩完容完之后的节点顺序是相反的。T1 执行完之后的顺序是 B 到 A,而 T2 的顺序是 A 到 B,这样 A 节点和 B 节点就形成死循环了,这就是 HashMap 死循环导致的原因。
1157+
1158+
### HashMap 为什么线程不安全
11221159

11231160
1. put 的时候导致的多线程数据不一致。
11241161
这个问题比较好想象,比如有两个线程 A 和 B,首先 A 希望插入一个 key-value 对到 HashMap 中,首先计算记录所要落到的桶的索引坐标,然后获取到该桶里面的链表头结点,此时线程 A 的时间片用完了,而此时线程 B 被调度得以执行,和线程 A 一样执行,只不过线程 B 成功将记录插到了桶里面,假设线程 A 插入的记录计算出来的桶索引和线程 B 要插入的记录计算出来的桶索引是一样的,那么当线程 B 成功插入之后,线程 A 再次被调度运行时,它依然持有过期的链表头但是它对此一无所知,以至于它认为它应该这样做,如此一来就覆盖了线程 B 插入的记录,这样线程 B 插入的记录就凭空消失了,造成了数据不一致的行为。
@@ -1148,20 +1185,18 @@ void transfer(Entry[] newTable, boolean rehash) {
11481185

11491186
这个方法的功能是将原来的记录重新计算在新桶的位置,然后迁移过去。
11501187

1151-
![](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/img/20201009160422.png)
1188+
![](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/others/mysql-1.7-resize.png)
11521189

11531190
多线程HashMap的resize
11541191

11551192
我们假设有两个线程同时需要执行resize操作,我们原来的桶数量为2,记录数为3,需要resize桶到4,原来的记录分别为:[3,A],[7,B],[5,C],在原来的map里面,我们发现这三个entry都落到了第二个桶里面。
11561193
假设线程thread1执行到了transfer方法的Entry next = e.next这一句,然后时间片用完了,此时的e = [3,A], next = [7,B]。线程thread2被调度执行并且顺利完成了resize操作,需要注意的是,此时的[7,B]的next为[3,A]。此时线程thread1重新被调度运行,此时的thread1持有的引用是已经被thread2 resize之后的结果。线程thread1首先将[3,A]迁移到新的数组上,然后再处理[7,B],而[7,B]被链接到了[3,A]的后面,处理完[7,B]之后,就需要处理[7,B]的next了啊,而通过thread2的resize之后,[7,B]的next变为了[3,A],此时,[3,A]和[7,B]形成了环形链表,在get的时候,如果get的key的桶索引和[3,A]和[7,B]一样,那么就会陷入死循环。
11571194

1158-
如果在取链表的时候从头开始取(现在是从尾部开始取)的话,则可以保证节点之间的顺序,那样就不存在这样的问题了。
1159-
11601195

11611196

1162-
#### HashMap:JDK1.7 VS JDK1.8
1197+
### HashMap:JDK1.7 VS JDK1.8
11631198

1164-
JDK1.8主要解决或优化了一下问题:
1199+
JDK1.8主要解决或优化了以下问题:
11651200

11661201
- resize 扩容优化
11671202
- 引入了红黑树,目的是避免单条链表过长而影响查询效率
@@ -1225,9 +1260,9 @@ Hashtable,是线程安全的,它在所有涉及到多线程操作的都加
12251260

12261261
Hashtable 容器在竞争激烈的并发环境下表现出效率低下的原因,是因为所有访问 Hashtable 的线程都必须竞争同一把锁,那假如容器里有多把锁,每一把锁用于锁容器其中一部分数据,那么当多线程访问容器里不同数据段的数据时,线程间就不会存在锁竞争,这就是 ConcurrentHashMap 所使用的锁分段技术。
12271262

1228-
在 JDK1.7 版本中,ConcurrentHashMap 的数据结构是由一个 Segment 数组和多个 HashEntry 组成。Segment 数组的意义就是将一个大的 table 分割成多个小的 table 来进行加锁。每一个 Segment 元素存储的是 HashEntry数组+链表,这个和 HashMap 的数据存储结构一样。
1263+
在 JDK1.7 版本中,ConcurrentHashMap 的数据结构是由一个 Segment 数组和多个 HashEntry 组成。Segment 数组的意义就是将一个大的 table 分割成多个小的 table 来进行加锁。每一个 Segment 元素存储的是 HashEntry 数组+链表,这个和 HashMap 的数据存储结构一样。
12291264

1230-
![](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/img/20200910104046.jpg)
1265+
![](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/others/concurrenthashmap-1.7-segment.jpg)
12311266

12321267
ConcurrentHashMap 类中包含两个静态内部类 HashEntry 和 Segment。
12331268
HashEntry 用来封装映射表的键值对,Segment 用来充当锁的角色,每个 Segment 对象守护整个散列映射表的若干个桶。每个桶是由若干个 HashEntry 对象链接起来的链表。一个 ConcurrentHashMap 实例中包含由若干个 Segment 对象组成的数组。每个 Segment 守护着一个 HashEntry 数组里的元素,当对 HashEntry 数组的数据进行修改时,必须首先获得它对应的 Segment 锁。
@@ -1413,7 +1448,7 @@ public V get(Object key) {
14131448

14141449
### JDK1.8 实现
14151450

1416-
![](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/img/20200910104629.jpg)
1451+
![](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/others/concurrenthashmap-1.8.jpg)
14171452

14181453
ConcurrentHashMap 在 JDK8 中进行了巨大改动,光是代码量就从1000多行增加到6000行!1.8 摒弃了`Segment`(锁段)的概念,采用了 `CAS + synchronized` 来保证并发的安全性。
14191454

0 commit comments

Comments
 (0)