mirror of
https://github.com/Snailclimb/JavaGuide
synced 2025-06-16 18:10:13 +08:00
[docs update]typo
This commit is contained in:
Guide
parent
0c882c8057
commit
c288ded935
@ -145,6 +145,8 @@ star: 2
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
**无任何套路，无任何潜在收费项。用心做内容，不割韭菜！**
|
||||
|
||||
不过， **一定要确定需要再进** 。并且， **三天之内觉得内容不满意可以全额退款** 。
|
||||
|
||||
@ -56,7 +56,7 @@ index = hash % array_size
|
||||
|
||||
为了减少 Hash 冲突的发生，一个好的哈希函数应该“均匀地”将数据分布在整个可能的哈希值集合中。
|
||||
|
||||
MySQL 的 InnoDB 存储引擎不直接支持常规的哈希索引，但是，InnoDB 存储引擎中存在一种特殊的“自适应哈希索引”（Adaptive Hash Index），自适应哈希索引并不是传统意义上的纯哈希索引，而是结合了 B+Tree 和哈希索引的特点，以便更好地适应实际应用中的数据访问模式和性能需求。自适应哈希索引的每个哈希桶实际上是一个小型的 B+Tree 结构。这个 B+Tree 结构可以存储多个键值对，而不仅仅是一个键。这有助于减少哈希冲突链的长度，提高了索引的效率。
|
||||
MySQL 的 InnoDB 存储引擎不直接支持常规的哈希索引，但是，InnoDB 存储引擎中存在一种特殊的“自适应哈希索引”（Adaptive Hash Index），自适应哈希索引并不是传统意义上的纯哈希索引，而是结合了 B+Tree 和哈希索引的特点，以便更好地适应实际应用中的数据访问模式和性能需求。自适应哈希索引的每个哈希桶实际上是一个小型的 B+Tree 结构。这个 B+Tree 结构可以存储多个键值对，而不仅仅是一个键。这有助于减少哈希冲突链的长度，提高了索引的效率。关于 Adaptive Hash Index 的详细介绍，可以查看 [MySQL各种“Buffer”之Adaptive Hash Index](https://mp.weixin.qq.com/s/ra4v1XR5pzSWc-qtGO-dBg) 这篇文章。
|
||||
|
||||
既然哈希表这么快，**为什么 MySQL 没有使用其作为索引的数据结构呢？** 主要是因为 Hash 索引不支持顺序和范围查询。假如我们要对表中的数据进行排序或者进行范围查询，那 Hash 索引可就不行了。并且，每次 IO 只能取一个。
|
||||
|
||||
|
||||
@ -126,7 +126,7 @@ Redis 集群可以进行节点的动态扩容缩容，这一过程目前还处
|
||||
|
||||
**什么是 Swap？** Swap 直译过来是交换的意思，Linux 中的 Swap 常被称为内存交换或者交换分区。类似于 Windows 中的虚拟内存，就是当内存不足的时候，把一部分硬盘空间虚拟成内存使用，从而解决内存容量不足的情况。因此，Swap 分区的作用就是牺牲硬盘，增加内存，解决 VPS 内存不够用或者爆满的问题。
|
||||
|
||||
Swap 对于 Redis 来说是非常致命的，Redis 保证高性能的一个重要前提是所有的数据在内存中。如果操作系统把 Redis 使用的部分内存换出硬盘，由于内存与硬盘读写的速度并几个数量级，会导致发生交换后的 Redis 性能急剧下降。
|
||||
Swap 对于 Redis 来说是非常致命的，Redis 保证高性能的一个重要前提是所有的数据在内存中。如果操作系统把 Redis 使用的部分内存换出硬盘，由于内存与硬盘的读写速度差几个数量级，会导致发生交换后的 Redis 性能急剧下降。
|
||||
|
||||
识别 Redis 发生 Swap 的检查方法如下：
|
||||
|
||||
|
||||
@ -67,16 +67,8 @@ System.out.println(listOfStrings);
|
||||
这里以 JDK1.8为例，分析一下 `ArrayList` 的底层源码。
|
||||
|
||||
```java
|
||||
package java.util;
|
||||
|
||||
import java.util.function.Consumer;
|
||||
import java.util.function.Predicate;
|
||||
import java.util.function.UnaryOperator;
|
||||
|
||||
|
||||
public class ArrayList<E> extends AbstractList<E>
|
||||
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
|
||||
{
|
||||
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
|
||||
private static final long serialVersionUID = 8683452581122892189L;
|
||||
|
||||
/**
|
||||
@ -160,8 +152,10 @@ public class ArrayList<E> extends AbstractList<E>
|
||||
//下面是ArrayList的扩容机制
|
||||
//ArrayList的扩容机制提高了性能，如果每次只扩充一个，
|
||||
//那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。
|
||||
|
||||
/**
|
||||
* 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
|
||||
*
|
||||
* @param minCapacity 所需的最小容量
|
||||
*/
|
||||
public void ensureCapacity(int minCapacity) {
|
||||
@ -177,20 +171,25 @@ public class ArrayList<E> extends AbstractList<E>
|
||||
ensureExplicitCapacity(minCapacity);
|
||||
}
|
||||
}
|
||||
//1.得到最小扩容量
|
||||
//2.通过最小容量扩容
|
||||
private void ensureCapacityInternal(int minCapacity) {
|
||||
|
||||
// 根据给定的最小容量和当前数组元素来计算所需容量。
|
||||
private static int calculateCapacity(Object[] elementData, int minCapacity) {
|
||||
// 如果当前数组元素为空数组（初始情况），返回默认容量和最小容量中的较大值作为所需容量
|
||||
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
|
||||
// 获取“默认的容量”和“传入参数”两者之间的最大值
|
||||
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
|
||||
return Math.max(DEFAULT_CAPACITY, minCapacity);
|
||||
}
|
||||
// 否则直接返回最小容量
|
||||
return minCapacity;
|
||||
}
|
||||
|
||||
ensureExplicitCapacity(minCapacity);
|
||||
// 确保内部容量达到指定的最小容量。
|
||||
private void ensureCapacityInternal(int minCapacity) {
|
||||
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
|
||||
}
|
||||
|
||||
//判断是否需要扩容
|
||||
private void ensureExplicitCapacity(int minCapacity) {
|
||||
modCount++;
|
||||
|
||||
// overflow-conscious code
|
||||
if (minCapacity - elementData.length > 0)
|
||||
//调用grow方法进行扩容，调用此方法代表已经开始扩容了
|
||||
@ -222,6 +221,7 @@ public class ArrayList<E> extends AbstractList<E>
|
||||
// minCapacity is usually close to size, so this is a win:
|
||||
elementData = Arrays.copyOf(elementData, newCapacity);
|
||||
}
|
||||
|
||||
//比较minCapacity和 MAX_ARRAY_SIZE
|
||||
private static int hugeCapacity(int minCapacity) {
|
||||
if (minCapacity < 0) // overflow
|
||||
@ -569,15 +569,13 @@ public class ArrayList<E> extends AbstractList<E>
|
||||
public Iterator<E> iterator() {
|
||||
return new Itr();
|
||||
}
|
||||
|
||||
|
||||
```
|
||||
|
||||
## ArrayList 扩容机制分析
|
||||
|
||||
### 先从 ArrayList 的构造函数说起
|
||||
|
||||
**（JDK8）ArrayList 有三种方式来初始化，构造方法源码如下：**
|
||||
ArrayList 有三种方式来初始化，构造方法源码如下（JDK8）：
|
||||
|
||||
```java
|
||||
/**
|
||||
@ -585,7 +583,6 @@ public class ArrayList<E> extends AbstractList<E>
|
||||
*/
|
||||
private static final int DEFAULT_CAPACITY = 10;
|
||||
|
||||
|
||||
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
|
||||
|
||||
/**
|
||||
@ -606,8 +603,7 @@ public class ArrayList<E> extends AbstractList<E>
|
||||
//创建空数组
|
||||
this.elementData = EMPTY_ELEMENTDATA;
|
||||
} else {//初始容量小于0，抛出异常
|
||||
throw new IllegalArgumentException("Illegal Capacity: "+
|
||||
initialCapacity);
|
||||
throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
|
||||
}
|
||||
}
|
||||
|
||||
@ -627,25 +623,24 @@ public class ArrayList<E> extends AbstractList<E>
|
||||
this.elementData = EMPTY_ELEMENTDATA;
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
细心的同学一定会发现：**以无参数构造方法创建 `ArrayList` 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10。** 下面在我们分析 ArrayList 扩容时会讲到这一点内容！
|
||||
细心的同学一定会发现：**以无参数构造方法创建 `ArrayList` 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10。** 下面在我们分析 `ArrayList` 扩容时会讲到这一点内容！
|
||||
|
||||
> 补充：JDK6 new 无参构造的 `ArrayList` 对象时，直接创建了长度是 10 的 `Object[]` 数组 elementData 。
|
||||
> 补充：JDK6 new 无参构造的 `ArrayList` 对象时，直接创建了长度是 10 的 `Object[]` 数组 `elementData` 。
|
||||
|
||||
### 一步一步分析 ArrayList 扩容机制
|
||||
|
||||
这里以无参构造函数创建的 ArrayList 为例分析
|
||||
这里以无参构造函数创建的 `ArrayList` 为例分析。
|
||||
|
||||
#### 先来看 `add` 方法
|
||||
#### add 方法
|
||||
|
||||
```java
|
||||
/**
|
||||
* 将指定的元素追加到此列表的末尾。
|
||||
*/
|
||||
public boolean add(E e) {
|
||||
//添加元素之前，先调用ensureCapacityInternal方法
|
||||
// 加元素之前，先调用ensureCapacityInternal方法
|
||||
ensureCapacityInternal(size + 1); // Increments modCount!!
|
||||
// 这里看到ArrayList添加元素的实质就相当于为数组赋值
|
||||
elementData[size++] = e;
|
||||
@ -653,54 +648,49 @@ public class ArrayList<E> extends AbstractList<E>
|
||||
}
|
||||
```
|
||||
|
||||
> **注意**：JDK11 移除了 `ensureCapacityInternal()` 和 `ensureExplicitCapacity()` 方法
|
||||
**注意**：JDK11 移除了 `ensureCapacityInternal()` 和 `ensureExplicitCapacity()` 方法
|
||||
|
||||
#### 再来看看 `ensureCapacityInternal()` 方法
|
||||
|
||||
（JDK7）可以看到 `add` 方法 首先调用了`ensureCapacityInternal(size + 1)`
|
||||
`ensureCapacityInternal` 方法的源码如下：
|
||||
|
||||
```java
|
||||
//得到最小扩容量
|
||||
private void ensureCapacityInternal(int minCapacity) {
|
||||
// 根据给定的最小容量和当前数组元素来计算所需容量。
|
||||
private static int calculateCapacity(Object[] elementData, int minCapacity) {
|
||||
// 如果当前数组元素为空数组（初始情况），返回默认容量和最小容量中的较大值作为所需容量
|
||||
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
|
||||
// 获取默认的容量和传入参数的较大值
|
||||
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
|
||||
return Math.max(DEFAULT_CAPACITY, minCapacity);
|
||||
}
|
||||
// 否则直接返回最小容量
|
||||
return minCapacity;
|
||||
}
|
||||
|
||||
ensureExplicitCapacity(minCapacity);
|
||||
// 确保内部容量达到指定的最小容量。
|
||||
private void ensureCapacityInternal(int minCapacity) {
|
||||
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
|
||||
}
|
||||
```
|
||||
|
||||
**当 要 add 进第 1 个元素时，minCapacity 为 1，在 Math.max()方法比较后，minCapacity 为 10。**
|
||||
|
||||
> 此处和后续 JDK8 代码格式化略有不同，核心代码基本一样。
|
||||
|
||||
#### `ensureExplicitCapacity()` 方法
|
||||
|
||||
如果调用 `ensureCapacityInternal()` 方法就一定会进入（执行）这个方法，下面我们来研究一下这个方法的源码！
|
||||
`ensureCapacityInternal` 方法非常简单，内部直接调用了 `ensureExplicitCapacity` 方法：
|
||||
|
||||
```java
|
||||
//判断是否需要扩容
|
||||
private void ensureExplicitCapacity(int minCapacity) {
|
||||
modCount++;
|
||||
|
||||
// overflow-conscious code
|
||||
//判断当前数组容量是否足以存储minCapacity个元素
|
||||
if (minCapacity - elementData.length > 0)
|
||||
//调用grow方法进行扩容，调用此方法代表已经开始扩容了
|
||||
//调用grow方法进行扩容
|
||||
grow(minCapacity);
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
我们来仔细分析一下：
|
||||
|
||||
- 当我们要 add 进第 1 个元素到 ArrayList 时，elementData.length 为 0 （因为还是一个空的 list），因为执行了 `ensureCapacityInternal()` 方法 ，所以 minCapacity 此时为 10。此时，`minCapacity - elementData.length > 0`成立，所以会进入 `grow(minCapacity)` 方法。
|
||||
- 当 add 第 2 个元素时，minCapacity 为 2，此时 elementData.length(容量)在添加第一个元素后扩容成 10 了。此时，`minCapacity - elementData.length > 0` 不成立，所以不会进入 （执行）`grow(minCapacity)` 方法。
|
||||
- 当我们要 `add` 进第 1 个元素到 `ArrayList` 时，`elementData.length` 为 0 （因为还是一个空的 list），因为执行了 `ensureCapacityInternal()` 方法 ，所以 `minCapacity` 此时为 10。此时，`minCapacity - elementData.length > 0`成立，所以会进入 `grow(minCapacity)` 方法。
|
||||
- 当 `add` 第 2 个元素时，`minCapacity` 为 2，此时 `elementData.length`(容量)在添加第一个元素后扩容成 `10` 了。此时，`minCapacity - elementData.length > 0` 不成立，所以不会进入 （执行）`grow(minCapacity)` 方法。
|
||||
- 添加第 3、4···到第 10 个元素时，依然不会执行 grow 方法，数组容量都为 10。
|
||||
|
||||
直到添加第 11 个元素，minCapacity(为 11)比 elementData.length（为 10）要大。进入 grow 方法进行扩容。
|
||||
直到添加第 11 个元素，`minCapacity`(为 11)比 `elementData.length`（为 10）要大。进入 `grow` 方法进行扩容。
|
||||
|
||||
#### `grow()` 方法
|
||||
#### grow 方法
|
||||
|
||||
```java
|
||||
/**
|
||||
@ -717,37 +707,40 @@ public class ArrayList<E> extends AbstractList<E>
|
||||
// 将oldCapacity 右移一位，其效果相当于oldCapacity /2，
|
||||
// 我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
|
||||
int newCapacity = oldCapacity + (oldCapacity >> 1);
|
||||
|
||||
// 然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
|
||||
if (newCapacity - minCapacity < 0)
|
||||
newCapacity = minCapacity;
|
||||
|
||||
// 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
|
||||
// 如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
|
||||
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);
|
||||
}
|
||||
```
|
||||
|
||||
**int newCapacity = oldCapacity + (oldCapacity >> 1),所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍左右（oldCapacity 为偶数就是 1.5 倍，否则是 1.5 倍左右）！** 奇偶不同，比如：10+10/2 = 15, 33+33/2=49。如果是奇数的话会丢掉小数.
|
||||
**`int newCapacity = oldCapacity + (oldCapacity >> 1)`,所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍左右（oldCapacity 为偶数就是 1.5 倍，否则是 1.5 倍左右）！** 奇偶不同，比如：10+10/2 = 15, 33+33/2=49。如果是奇数的话会丢掉小数.
|
||||
|
||||
> ">>"（移位运算符）：>>1 右移一位相当于除 2，右移 n 位相当于除以 2 的 n 次方。这里 oldCapacity 明显右移了 1 位所以相当于 oldCapacity /2。对于大数据的 2 进制运算,位移运算符比那些普通运算符的运算要快很多,因为程序仅仅移动一下而已,不去计算,这样提高了效率,节省了资源
|
||||
|
||||
**我们再来通过例子探究一下`grow()` 方法：**
|
||||
|
||||
- 当 add 第 1 个元素时，oldCapacity 为 0，经比较后第一个 if 判断成立，newCapacity = minCapacity(为 10)。但是第二个 if 判断不会成立，即 newCapacity 不比 MAX_ARRAY_SIZE 大，则不会进入 `hugeCapacity` 方法。数组容量为 10，add 方法中 return true,size 增为 1。
|
||||
- 当 add 第 11 个元素进入 grow 方法时，newCapacity 为 15，比 minCapacity（为 11）大，第一个 if 判断不成立。新容量没有大于数组最大 size，不会进入 hugeCapacity 方法。数组容量扩为 15，add 方法中 return true,size 增为 11。
|
||||
- 当 `add` 第 1 个元素时，`oldCapacity` 为 0，经比较后第一个 if 判断成立，`newCapacity = minCapacity`(为 10)。但是第二个 if 判断不会成立，即 `newCapacity` 不比 `MAX_ARRAY_SIZE` 大，则不会进入 `hugeCapacity` 方法。数组容量为 10，`add` 方法中 return true,size 增为 1。
|
||||
- 当 `add` 第 11 个元素进入 `grow` 方法时，`newCapacity` 为 15，比 `minCapacity`（为 11）大，第一个 if 判断不成立。新容量没有大于数组最大 size，不会进入 huge`C`apacity 方法。数组容量扩为 15，add 方法中 return true,size 增为 11。
|
||||
- 以此类推······
|
||||
|
||||
**这里补充一点比较重要，但是容易被忽视掉的知识点：**
|
||||
|
||||
- java 中的 `length`属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了 length 这个属性.
|
||||
- java 中的 `length()` 方法是针对字符串说的,如果想看这个字符串的长度则用到 `length()` 这个方法.
|
||||
- java 中的 `size()` 方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!
|
||||
- Java 中的 `length`属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了 length 这个属性.
|
||||
- Java 中的 `length()` 方法是针对字符串说的,如果想看这个字符串的长度则用到 `length()` 这个方法.
|
||||
- Java 中的 `size()` 方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!
|
||||
|
||||
#### `hugeCapacity()` 方法。
|
||||
#### hugeCapacity() 方法
|
||||
|
||||
从上面 `grow()` 方法源码我们知道：如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，如果 minCapacity 大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
|
||||
从上面 `grow()` 方法源码我们知道：如果新容量大于 `MAX_ARRAY_SIZE`,进入(执行) `hugeCapacity()` 方法来比较 `minCapacity` 和 `MAX_ARRAY_SIZE`，如果 `minCapacity` 大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 `MAX_ARRAY_SIZE` 即为 `Integer.MAX_VALUE - 8`。
|
||||
|
||||
```java
|
||||
private static int hugeCapacity(int minCapacity) {
|
||||
@ -765,7 +758,7 @@ public class ArrayList<E> extends AbstractList<E>
|
||||
|
||||
### `System.arraycopy()` 和 `Arrays.copyOf()`方法
|
||||
|
||||
阅读源码的话，我们就会发现 ArrayList 中大量调用了这两个方法。比如：我们上面讲的扩容操作以及`add(int index, E element)`、`toArray()` 等方法中都用到了该方法！
|
||||
阅读源码的话，我们就会发现 `ArrayList` 中大量调用了这两个方法。比如：我们上面讲的扩容操作以及`add(int index, E element)`、`toArray()` 等方法中都用到了该方法！
|
||||
|
||||
#### `System.arraycopy()` 方法
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user