1

class Base<T extends Base<T>> { ... }

含义：T 必须是“某个继承自 Base<T> 的类型”，从而让 Base 在编译期“知道”子类的精确类型。

1 要解决什么问题：父类方法想返回“子类类型”

没用自引用泛型时的问题

1
2
3
4
5
6
7
8

class Base {
    Base withName(String n) { return this; }
}
class UserBuilder extends Base { }

UserBuilder b = new UserBuilder();
b.withName("a")   // 返回 Base
 .withName("b");  // 链式调用类型会退化成 Base

你会失去子类特有方法的链式调用：

1

b.withName("a").onlyInUser(); // 编译不过，因为 withName 返回 Base

用自引用泛型（让返回类型保持为子类）

1
2
3
4
5
6
7
8
9
10
11
12
13
14

abstract class Base<B extends Base<B>> {
    protected abstract B self();

    public B withName(String n) {
        // ... set field
        return self();
    }
}

class UserBuilder extends Base<UserBuilder> {
    @Override protected UserBuilder self() { return this; }

    public UserBuilder onlyInUser() { return this; }
}

现在：

1
2
3
4

new UserBuilder()
    .withName("a")
    .onlyInUser()
    .withName("b");

链式调用始终保持 UserBuilder 类型。

2 它到底“类型上”在约束什么？

这句：

1

B extends Base<B>

表示：B 不是随便的类型，它必须满足：

• B 是 Base<B> 的子类型

所以 class UserBuilder extends Base<UserBuilder> 合法；
但 class X extends Base<String> 不合法（String 不是 Base）。

这种约束让 Base 能安全地把 this 视作 B（通过 self() 或强转），从而在 Base 里写出“返回子类”的 API。

3 为什么需要 self()？能不能直接 (B) this？

可以强转，但不推荐暴露在公共基类里。

方案 A：强转（常见但有风险）

1
2
3
4
5
6

abstract class Base<B extends Base<B>> {
    @SuppressWarnings("unchecked")
    protected B self() { return (B) this; }

    public B withName(String n) { return self(); }
}

风险在于：如果有人写了“破坏约束”的继承结构（通过原始类型 raw type 绕过），运行期可能 ClassCastException。

方案 B：子类实现 self（更稳）

1
2
3

abstract class Base<B extends Base<B>> {
    protected abstract B self();
}

子类返回 this，不需要 unchecked cast，更清晰。

4 典型使用场景

4.1 Builder / Fluent API（最常见）

让基类提供通用链式方法（name、id、tags…），子类还能追加自身方法且不中断链式。

4.2 “可比较/可排序”这类自类型约束（JDK 经典）

Comparable 是个“弱化版”案例：

1

class MyType implements Comparable<MyType> { ... }

工具方法里常见约束：

1

static <T extends Comparable<? super T>> T max(List<? extends T> list) { ... }

这也是为了兼容继承关系（? super T）。

4.3 框架基类：返回子类、注册子类、DSL

例如：

• ORM/Query DSL：Query<T extends Query<T>> where(...)
• 图结构/节点 API：Node<N extends Node<N>> addChild(N child)

5 多层继承时怎么写？

你可以把“自类型参数”一路传下去：

1
2
3
4
5
6
7
8
9
10
11
12
13

abstract class Base<B extends Base<B>> {
    protected abstract B self();
    public B common() { return self(); }
}

abstract class Mid<B extends Mid<B>> extends Base<B> {
    public B mid() { return self(); }
}

class Concrete extends Mid<Concrete> {
    @Override protected Concrete self() { return this; }
    public Concrete only() { return this; }
}

调用：new Concrete().common().mid().only(); 都保持 Concrete。

6 常见坑

6.1 原始类型（raw type）会破坏类型安全

1
2
3

class Bad extends Base {   // 使用 raw type
    @Override protected Base self() { return this; }
}

这会导致泛型约束失效，可能埋下运行期强转问题。尽量禁止 raw type。

6.2 “写错自类型”导致诡异编译错误

1

class A extends Base<B> { ... } // B 不是 A

自引用泛型的关键是：参数必须是“自己”（或至少保持一致的自类型），一般写成 extends Base<当前类名>。

6.3 组合（composition）有时比继承更简单

如果只是想链式配置，有时用组合/返回 this 并配合接口也能做，别为了泛型而泛型。

7 一个更完整的“可复用 Builder 基类”例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

abstract class Builder<B extends Builder<B>> {
    protected String name;
    protected int age;

    protected abstract B self();

    public B name(String n) { this.name = n; return self(); }
    public B age(int a) { this.age = a; return self(); }
}

class UserBuilder extends Builder<UserBuilder> {
    private String email;

    @Override protected UserBuilder self() { return this; }

    public UserBuilder email(String e) { this.email = e; return this; }

    public User build() { return new User(name, age, email); }
}

一、概览

容器主要包括 Collection 和 Map 两种，Collection 存储着对象的集合，而 Map 存储着键值对（两个对象）的映射表。

Collection单列集合

1. Set

• TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。

• HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。

• LinkedHashSet：具有 HashSet 的查找效率，并且内部使用双向链表维护元素的插入顺序。

2. List

• ArrayList：基于动态数组实现，支持随机访问。

• Vector：和 ArrayList 类似，但它是线程安全的。

• LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。

3. Queue & Deque

• ArrayDeque：基于数组实现，和 ArrayList 类似，但是 ArrayDeque 不支持随机访问。

• LinkedList：可以用它来实现双向队列。

• PriorityQueue：基于堆结构实现，可以用它来实现优先队列。

Map双列映射

• TreeMap：基于红黑树实现。

• HashMap：基于哈希表实现。

• HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程同时写入 HashTable 不会导致数据不一致。它是遗留类，不应该去使用它，而是使用 ConcurrentHashMap 来支持线程安全，ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。

• LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。

二、容器中的设计模式

迭代器模式

Collection 继承了 Iterable 接口，其中的 iterator() 方法能够产生一个 Iterator 对象，通过这个对象就可以迭代遍历 Collection 中的元素。

从 JDK 1.5 之后可以使用 foreach 方法来遍历实现了 Iterable 接口的聚合对象。

1
2
3
4
5
6

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
for (String item : list) {
    System.out.println(item);
}

适配器模式

java.util.Arrays#asList() 可以把数组类型转换为 List 类型。

1
2

@SafeVarargs
public static <T> List<T> asList(T... a)

应该注意的是 asList() 的参数为泛型的变长参数，不能使用基本类型数组作为参数，只能使用相应的包装类型数组。

1
2

Integer[] arr = {1, 2, 3};
List list = Arrays.asList(arr);

也可以使用以下方式调用 asList()：

1

List list = Arrays.asList(1, 2, 3);

集合框架总览

数据结构分为

• 线性数据结构
• 树型数据结构
• 图型数据结构

C++中的容器分为（都是线性的）

• 顺序容器
  • array 数组
  • vector向量
  • list 链表
• 关联容器
  • map 映射
  • set 集合
• 容器适配器
  • stack 栈
  • queue 队列

Java中的集合容器分为单列集合collection和双列映射Map。除了一下基本集合类型，还有多个特殊的类型，后续补充

• List
  • Arraylist，有序，插入序
  • vector
  • stack
• Queue
  • linkedlist，双端队列有序，插入序
  • arrayqueue，有序，插入序
  • priorityQueue，有序，自然序
• Set
  • hashset，无序
  • linkedhashset，有序，插入序
  • treeSet，有序，自然序
• Map
  • hashmap，无序
  • linkedhashmap，有序，插入序
  • treemap 有序，自然序

1. 集合框架提供了两个遍历接口：Iterator和ListIterator，其中后者是前者的优化版，支持在任意一个位置进行前后双向遍历。注意图中的Collection应当继承的是Iterable而不是Iterator，后面会解释Iterable和Iterator的区别
2. 整个集合框架分为两个门派（类型）：Collection和Map，前者是一个容器，存储一系列的对象；后者是键值对<key, value>，存储一系列的键值对
3. 在集合框架体系下，衍生出四种具体的集合类型：Map、Set、List、Queue
4. Map存储<key,value>键值对，查找元素时通过key查找value
5. Set内部存储一系列不可重复的对象，且是一个无序集合，对象排列顺序不一
6. List内部存储一系列可重复的对象，是一个有序集合，对象按插入顺序排列
7. Queue是一个队列容器，其特性与List相同，但只能从队头和队尾操作元素
8. JDK 为集合的各种操作提供了两个工具类Collections和Arrays，之后会讲解工具类的常用方法
9. 四种抽象集合类型内部也会衍生出许多具有不同特性的集合类，不同场景下择优使用，没有最佳的集合

集合概要对比

章节结束各集合总结：（以 JDK1.8 为例）

参考资料

• Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
• Java Collection Framework
• Iterator 模式
• Java 8 系列之重新认识 HashMap
• What is difference between HashMap and Hashtable in Java?
• Java 集合之 HashMap
• The principle of ConcurrentHashMap analysis
• 探索 ConcurrentHashMap 高并发性的实现机制
• HashMap 相关面试题及其解答
• Java 集合细节（二）：asList 的缺陷
• Java Collection Framework – The LinkedList Class

方法概述

• 给数组赋值：通过 fill 方法。
• 对数组排序：通过 sort 方法,按升序。
• 比较数组：通过 equals 方法比较数组中元素值是否相等。
• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

具体方法

1
2
3
4
5
6
7
8
9
10
11
12

public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
public static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
public static void sort(Object[] a)
对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
public static void toString(array[])
依次打印元素
public static void stream()
转化成一个流

并发集合是指使用了最新并发能力的集合，在JUC包下。而同步集合指之前用同步锁实现的集合。

其对应的基础集合类的接口并没有发生太大变化，主要是针对并发场景进行优化，使用各种方式保证并发集合的安全性。

1 CopyOnWrite

CopyOnWriteArrayList

CopyOnWriteArrayList在写的时候会复制一个副本，对副本写，写完用副本替换原值，读的时候不需要同步，适用于写少读多的场合。

CopyOnWriteArraySet基于CopyOnWriteArrayList来实现的，只是在不允许存在重复的对象这个特性上遍历处理了一下。

读写分离

写操作在一个复制的数组上进行，读操作还是在原始数组中进行，读写分离，互不影响。

写操作需要加锁，防止并发写入时导致写入数据丢失。

写操作结束之后需要把原始数组指向新的复制数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

final void setArray(Object[] a) {
    array = a;
}

1
2
3
4

@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
    return (E) a[index];
}

适用场景

CopyOnWriteArrayList 在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。

但是 CopyOnWriteArrayList 有其缺陷：

• 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
• 数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。

所以 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。

用来替代vector，提供现成安全的list

底层原理

Java CopyOnWriteArrayList是ArrayList的thread-safe变体，其中所有可变操作（添加，设置等）都通过对基础array进行全新复制来实现。

• CopyOnWriteArrayList类实现List和RandomAccess接口，因此提供ArrayList类中可用的所有功能。
• 使用CopyOnWriteArrayList进行更新操作的成本很高，因为每个突变都会创建基础数组的克隆副本，并为其添加/更新元素。
• 它是ArrayList的线程安全版本。 每个访问列表的线程在初始化此列表的迭代器时都会看到自己创建的后备阵列快照版本。
• 因为它在创建迭代器时获取基础数组的快照，所以它不会抛出ConcurrentModificationException 。
• 不支持对迭代器的删除操作（删除，设置和添加）。 这些方法抛出UnsupportedOperationException 。
• CopyOnWriteArrayList是synchronized List的并发替代，当迭代的次数超过突变次数时，CopyOnWriteArrayList可以提供更好的并发性。
• 它允许重复的元素和异构对象（使用泛型来获取编译时错误）。因为它每次创建迭代器时都会创建一个新的数组副本，所以performance is slower比ArrayList performance is slower 。

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>(new Integer[] {1,2,3});
 
System.out.println(list);   //[1, 2, 3]
 
//Get iterator 1
Iterator<Integer> itr1 = list.iterator();
 
//Add one element and verify list is updated
list.add(4);
 
System.out.println(list);   //[1, 2, 3, 4]
 
//Get iterator 2
Iterator<Integer> itr2 = list.iterator();
 
System.out.println("====Verify Iterator 1 content====");
 
itr1.forEachRemaining(System.out :: println);   //1,2,3
 
System.out.println("====Verify Iterator 2 content====");
 
itr2.forEachRemaining(System.out :: println);   //1,2,3,4

主要方法

1
2
3
4
5

CopyOnWriteArrayList() ：创建一个空列表。
CopyOnWriteArrayList(Collection c) ：创建一个列表，该列表包含指定集合的​​元素，并按集合的迭代器返回它们的顺序。
CopyOnWriteArrayList(object[] array) ：创建一个保存给定数组副本的列表。
boolean addIfAbsent(object o) ：如果不存在则追加元素。
int addAllAbsent(Collection c) ：以指定集合的​​迭代器返回的顺序，将指定集合中尚未包含在此列表中的所有元素追加到此列表的末尾。

CopyOnWriteArraySet

底层原理

HashSet的thread-safe变体，它对所有操作都使用基础CopyOnWriteArrayList

与CopyOnWriteArrayList相似，它的immutable snapshot样式iterator方法在创建iterator使用对数组状态（在后备列表内）的引用。 这在遍历操作远远超过集合更新操作且我们不想同步遍历并且在更新集合时仍希望线程安全的用例中很有用。

• 作为正常设置的数据结构，它不允许重复。
• CopyOnWriteArraySet类实现Serializable接口并扩展AbstractSet类。
• 使用CopyOnWriteArraySet进行更新操作成本很高，因为每个突变都会创建基础数组的克隆副本并向其添加/更新元素。
• 它是HashSet的线程安全版本。 每个访问该集合的线程在初始化此集合的迭代器时都会看到自己创建的后备阵列快照版本。
• 因为它在创建迭代器时获取基础数组的快照，所以它不会抛出ConcurrentModificationException 。不支持迭代器上的变异操作。 这些方法抛出UnsupportedOperationException 。
• CopyOnWriteArraySet是synchronized Set的并发替代，当迭代的次数超过突变次数时，CopyOnWriteArraySet提供更好的并发性。
• 它允许重复的元素和异构对象（使用泛型来获取编译时错误）。
• 由于每次创建迭代器时都会创建基础数组的新副本，因此performance is slower HashSet

主要方法

1
2
3
4
5
6
7
8
9
10

CopyOnWriteArraySet() ：创建一个空集。
CopyOnWriteArraySet(Collection c) ：创建一个包含指定集合元素的集合，其顺序由集合的迭代器返回。
boolean add(object o) ：将指定的元素添加到此集合（如果尚不存在）。
boolean addAll(collection c) ：将指定集合中的所有元素（如果尚不存在boolean addAll(collection c)添加到此集合中。
void clear() ：从此集合中删除所有元素。
boolean contains(Object o) ：如果此集合包含指定的元素，则返回true。
boolean isEmpty() ：如果此集合不包含任何元素，则返回true。
Iterator iterator() ：以添加这些元素的顺序在此集合中包含的元素上返回一个迭代器。
boolean remove(Object o) ：从指定的集合中删除指定的元素（如果存在）。
int size() ：返回此集合中的元素数

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

CopyOnWriteArraySet<Integer> set = new CopyOnWriteArraySet<>(Arrays.asList(1,2,3));
 
System.out.println(set);    //[1, 2, 3]
 
//Get iterator 1
Iterator<Integer> itr1 = set.iterator();
 
//Add one element and verify set is updated
set.add(4);
System.out.println(set);    //[1, 2, 3, 4]
 
//Get iterator 2
Iterator<Integer> itr2 = set.iterator();
 
System.out.println("====Verify Iterator 1 content====");
 
itr1.forEachRemaining(System.out :: println);   //1,2,3
 
System.out.println("====Verify Iterator 2 content====");
 
itr2.forEachRemaining(System.out :: println);   //1,2,3,4

2 BlockingQueue

在并发队列上JDK提供了两套实现，

• 一个是以ConcurrentLinkedQueue为代表的高性能队列
• 一个是以BlockingQueue接口为代表的阻塞队列。

ConcurrentLinkedQueue适用于高并发场景下的队列，通过无锁的方式实现，通常ConcurrentLinkedQueue的性能要优于BlockingQueue。BlockingQueue的典型应用场景是生产者-消费者模式中，如果生产快于消费，生产队列装满时会阻塞，等待消费。

java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：

• FIFO 队列 ：LinkedBlockingQueue、LinkedBlockingDeque、ArrayBlockingQueue（固定长度）
• 优先级队列 ：PriorityBlockingQueue
• TransferQueue
• DelayQueue

提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，直到队列有空闲位置。

使用 BlockingQueue 实现生产者消费者问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class ProducerConsumer {

    private static BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);

    private static class Producer extends Thread {
        @Override
        public void run() {
            try {
                queue.put("product");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print("produce..");
        }
    }

    private static class Consumer extends Thread {

        @Override
        public void run() {
            try {
                String product = queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print("consume..");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public static void main(String[] args) {
    for (int i = 0; i < 2; i++) {
        Producer producer = new Producer();
        producer.start();
    }
    for (int i = 0; i < 5; i++) {
        Consumer consumer = new Consumer();
        consumer.start();
    }
    for (int i = 0; i < 3; i++) {
        Producer producer = new Producer();
        producer.start();
    }
}

1

produce..produce..consume..consume..produce..consume..produce..consume..produce..consume..

PriorityBlockingQueue

底层原理

Java PriorityBlockingQueue类是concurrent阻塞队列数据结构的实现，其中根据对象的priority对其进行处理。 名称的“阻塞”部分已添加，表示线程将阻塞等待，直到队列上有可用的项目为止 。

在priority blocking queue ，添加的对象根据其优先级进行排序。 默认情况下，优先级由对象的自然顺序决定。 队列构建时提供的Comparator器可以覆盖默认优先级。

• PriorityBlockingQueue是一个无界队列，并且会动态增长。 默认初始容量为’11’ ，可以在适当的构造函数中使用initialCapacity参数覆盖此初始容量。
• 它提供了阻塞检索操作。
• 它不允许使用NULL对象。
• 添加到PriorityBlockingQueue的对象必须具有可比性，否则它将引发ClassCastException 。
• 默认情况下，优先级队列的对象以自然顺序排序 。
• 比较器可用于队列中对象的自定义排序。
• 优先级队列的head是基于自然排序或基于比较器排序的least元素。 当我们轮询队列时，它从队列中返回头对象。
• 如果存在多个具有相同优先级的对象，则它可以随机轮询其中的任何一个。
• PriorityBlockingQueue是thread safe 。

主要方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

boolean add(object) ：将指定的元素插入此优先级队列。
boolean offer(object) ：将指定的元素插入此优先级队列。
boolean remove(object) ：从此队列中移除指定元素的单个实例（如果存在）。
Object poll() ：检索并删除此队列的头部，并在必要时等待指定的等待时间，以使元素可用。
Object poll(timeout, timeUnit) ：检索并删除此队列的头部，如果有必要，直到指定的等待时间，元素才可用。
Object take() ：检索并删除此队列的头部，如有必要，请等待直到元素可用。
void put(Object o) ：将指定的元素插入此优先级队列。
void clear() ：从此优先级队列中删除所有元素。
Comparator comparator() ：返回用于对此队列中的元素进行排序的Comparator comparator()如果此队列是根据其元素的自然顺序排序的，则返回null。
boolean contains(Object o) ：如果此队列包含指定的元素，则返回true。
Iterator iterator() ：返回对该队列中的元素进行迭代的迭代器。
int size() ：返回此队列中的元素数。
int drainTo(Collection c) ：从此队列中删除所有可用元素，并将它们添加到给定的collection中。
intrainToTo（Collection c，int maxElements） ：从此队列中最多移除给定数量的可用元素，并将它们添加到给定的collection中。
int remainingCapacity() Integer.MAX_VALUE int remainingCapacity() ：总是返回Integer.MAX_VALUE因为PriorityBlockingQueue不受容量限制。
Object[] toArray() ：返回一个包含此队列中所有元素的数组。

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.TimeUnit;
 
public class PriorityQueueExample 
{
    public static void main(String[] args) throws InterruptedException 
    {
        PriorityBlockingQueue<Integer> priorityBlockingQueue = new PriorityBlockingQueue<>();
         
        new Thread(() -> 
        {
          System.out.println("Waiting to poll ...");
          
          try
          {
              while(true) 
              {
                  Integer poll = priorityBlockingQueue.take();
                  System.out.println("Polled : " + poll);
 
                  Thread.sleep(TimeUnit.SECONDS.toMillis(1));
              }
               
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
           
        }).start();
          
        Thread.sleep(TimeUnit.SECONDS.toMillis(2));
        priorityBlockingQueue.add(1);
         
        Thread.sleep(TimeUnit.SECONDS.toMillis(2));
        priorityBlockingQueue.add(2);
         
        Thread.sleep(TimeUnit.SECONDS.toMillis(2));
        priorityBlockingQueue.add(3);
    }
}

ArrayBlockingQueue

底层原理

ArrayBlockingQueue类是由数组支持的Java concurrent和bounded阻塞队列实现。 它对元素FIFO（先进先出）进行排序。

ArrayBlockingQueue的head是一直在队列中最长时间的那个元素。 ArrayBlockingQueue的tail是最短时间进入队列的元素。 新元素插入到队列的尾部 ，并且队列检索操作在队列的开头获取元素 。

• ArrayBlockingQueue是由数组支持的固定大小的有界队列。
• 它对元素FIFO（先进先出）进行排序。
• 元素插入到尾部，并从队列的开头检索。
• 创建后，队列的容量无法更改。
• 它提供阻塞的插入和检索操作 。
• 它不允许使用NULL对象。
• ArrayBlockingQueue是thread safe 。
• 方法iterator()提供的Iterator按从第一个（头）到最后一个（尾部）的顺序遍历元素。
• ArrayBlockingQueue支持可选的fairness policy用于订购等待的生产者线程和使用者线程。 将fairness设置为true ，队列按FIFO顺序授予线程访问权限。

生产消费者实例

使用阻塞插入和检索从ArrayBlockingQueue中放入和取出元素的Java示例。

• 当队列已满时，生产者线程将等待。 一旦从队列中取出一个元素，它就会将该元素添加到队列中。
• 如果队列为空，使用者线程将等待。 队列中只有一个元素时，它将取出该元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
 
public class ArrayBlockingQueueExample 
{
    public static void main(String[] args) throws InterruptedException 
    {
        ArrayBlockingQueue<Integer> priorityBlockingQueue = new ArrayBlockingQueue<>(5);
 
        //Producer thread
        new Thread(() -> 
        {
            int i = 0;
            try
            {
                while (true) 
                {
                    priorityBlockingQueue.put(++i);
                    System.out.println("Added : " + i);
                     
                    Thread.sleep(TimeUnit.SECONDS.toMillis(1));
                }
 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
        }).start();
 
        //Consumer thread
        new Thread(() -> 
        {
            try
            {
                while (true) 
                {
                    Integer poll = priorityBlockingQueue.take();
                    System.out.println("Polled : " + poll);
                     
                    Thread.sleep(TimeUnit.SECONDS.toMillis(2));
                }
 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
        }).start();
    }
}

主要方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

ArrayBlockingQueue(int capacity) ：构造具有给定（固定）容量和默认访问策略的空队列。
ArrayBlockingQueue（int capacity，boolean fair） ：构造具有给定（固定）容量和指定访问策略的空队列。 如果公允值为true ，则按FIFO顺序处理在插入或移除时阻塞的线程的队列访问； 如果为false，则未指定访问顺序。
ArrayBlockingQueue（int capacity，boolean fair，Collection c） ：构造一个队列，该队列具有给定（固定）的容量，指定的访问策略，并最初包含给定集合的元素，并以集合迭代器的遍历顺序添加。
void put(Object o) ：将指定的元素插入此队列的尾部，如果队列已满，则等待空间变为可用。
boolean add(object) : Inserts the specified element at the tail of this queue if it is possible to do so immediately without exceeding the queue’s capacity, returning true upon success and throwing an IllegalStateException if this queue is full.
boolean offer(object) ：如果可以在不超出队列容量的情况下立即执行此操作，则在此队列的尾部插入指定的元素，如果成功，则返回true，如果此队列已满，则抛出IllegalStateException。
boolean remove(object) ：从此队列中移除指定元素的单个实例（如果存在）。
Object peek() ：检索但不删除此队列的头部；如果此队列为空，则返回null。
Object poll() ：检索并删除此队列的头部；如果此队列为空，则返回null。
Object poll(timeout, timeUnit) ：检索并删除此队列的头部，如果有必要，直到指定的等待时间，元素才可用。
Object take() ：检索并删除此队列的头部，如有必要，请等待直到元素可用。
void clear() ：从队列中删除所有元素。
boolean contains(Object o) ：如果此队列包含指定的元素，则返回true。
Iterator iterator() ：以适当的顺序返回对该队列中的元素进行迭代的迭代器。
int size() ：返回此队列中的元素数。
int drainTo(Collection c) ：从此队列中删除所有可用元素，并将它们添加到给定的collection中。
intrainToTo（Collection c，int maxElements） ：从此队列中最多移除给定数量的可用元素，并将它们添加到给定的collection中。
int remainingCapacity() ：返回该队列理想情况下（在没有内存或资源限制的情况下）可以接受而不阻塞的其他元素的数量。
Object[] toArray() ：以适当的顺序返回一个包含此队列中所有元素的数组。

LinkedTransferQueue

底层原理

直接消息队列。也就是说，生产者生产后，必须等待消费者来消费才能继续执行。

Java TransferQueue是并发阻塞队列的实现，生产者可以在其中等待使用者使用消息。 LinkedTransferQueue类是Java中TransferQueue的实现。

• LinkedTransferQueue是链接节点上的unbounded队列。
• 此队列针对任何给定的生产者对元素FIFO（先进先出）进行排序。
• 元素插入到尾部，并从队列的开头检索。
• 它提供阻塞的插入和检索操作 。
• 它不允许使用NULL对象。
• LinkedTransferQueue是thread safe 。
• 由于异步性质，size（）方法不是固定时间操作，因此，如果在遍历期间修改此集合，则可能会报告不正确的结果。
• 不保证批量操作addAll，removeAll，retainAll，containsAll，equals和toArray是原子执行的。 例如，与addAll操作并发操作的迭代器可能仅查看某些添加的元素。

实例

非阻塞实例

1
2
3
4
5
6
7
8
9

LinkedTransferQueue<Integer> linkedTransferQueue = new LinkedTransferQueue<>();
         
linkedTransferQueue.put(1);
 
System.out.println("Added Message = 1");
 
Integer message = linkedTransferQueue.poll();
 
System.out.println("Recieved Message = " + message);

阻塞插入实例，用于现成状态同步通信
使用阻塞插入和检索从LinkedTransferQueue放入和取出元素的Java示例。

• 生产者线程将等待，直到有消费者准备从队列中取出项目为止。
• 如果队列为空，使用者线程将等待。 队列中只有一个元素时，它将取出该元素。 只有在消费者接受了消息之后，生产者才可以再发送一条消息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

import java.util.Random;
import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TimeUnit;
 
public class LinkedTransferQueueExample 
{
    public static void main(String[] args) throws InterruptedException 
    {
        LinkedTransferQueue<Integer> linkedTransferQueue = new LinkedTransferQueue<>();
 
        new Thread(() -> 
        {
            Random random = new Random(1);
            try
            {
                while (true) 
                {
                    System.out.println("Producer is waiting to transfer message...");
                     
                    Integer message = random.nextInt();
                    boolean added = linkedTransferQueue.tryTransfer(message);
                    if(added) {
                        System.out.println("Producer added the message - " + message);
                    }
                    Thread.sleep(TimeUnit.SECONDS.toMillis(3));
                }
 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
        }).start();
         
        new Thread(() -> 
        {
            try
            {
                while (true) 
                {
                    System.out.println("Consumer is waiting to take message...");
                     
                    Integer message = linkedTransferQueue.take();
                     
                    System.out.println("Consumer recieved the message - " + message);
                     
                    Thread.sleep(TimeUnit.SECONDS.toMillis(3));
                }
 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
        }).start();
    }
}

主要方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

LinkedTransferQueue() ：构造一个初始为空的LinkedTransferQueue。
LinkedTransferQueue(Collection c) ：构造一个LinkedTransferQueue，最初包含给定集合的元素，并以该集合的迭代器的遍历顺序添加。
Object take() ：检索并删除此队列的头部，如有必要，请等待直到元素可用。
void transfer(Object o) ：将元素传输给使用者，如有必要，请等待。
boolean tryTransfer(Object o) ：如果可能，立即将元素传输到等待的使用者。
boolean tryTransfer（Object o，long timeout，TimeUnit unit） ：如果有可能，则在超时之前将元素传输给使用者。
int getWaitingConsumerCount() ：返回等待通过BlockingQueue.take（）或定时轮询接收元素的使用者数量的估计值。
boolean hasWaitingConsumer() ：如果至少有一个使用者正在等待通过BlockingQueue.take（）或定时轮询接收元素，则返回true。
void put(Object o) ：将指定的元素插入此队列的尾部。
boolean add(object) : Inserts the specified element at the tail of this queue.
boolean offer(object) ：将指定的元素插入此队列的尾部。
boolean remove(object) ：从此队列中移除指定元素的单个实例（如果存在）。
Object peek() ：检索但不删除此队列的头部；如果此队列为空，则返回null。
Object poll() ：检索并删除此队列的头部；如果此队列为空，则返回null。
Object poll(timeout, timeUnit) ：检索并删除此队列的头部，如果有必要，直到指定的等待时间，元素才可用。
void clear() ：从队列中删除所有元素。
boolean contains(Object o) ：如果此队列包含指定的元素，则返回true。
Iterator iterator() ：以适当的顺序返回对该队列中的元素进行迭代的迭代器。
int size() ：返回此队列中的元素数。
int drainTo(Collection c) ：从此队列中删除所有可用元素，并将它们添加到给定的collection中。
intrainToTo（Collection c，int maxElements） ：从此队列中最多移除给定数量的可用元素，并将它们添加到给定的collection中。
int remainingCapacity() ：返回该队列理想情况下（在没有内存或资源限制的情况下）可以接受而不阻塞的其他元素的数量。
Object[] toArray() ：以适当的顺序返回一个包含此队列中所有元素的数组。

3 Concurrent

• ConcurrentLinkedQueue

• ConcurrentLinkedDeque

• ConcurrentHashMap

• ConcurrentHashSet

• ConcurrentSkipListMap

• ConcurrentSkipListSet

ConcurrentHashMap是专用于高并发的Map实现，内部实现进行了锁分离，get操作是无锁的。

java api也提供了一个实现ConcurrentSkipListMap接口的类，ConcurrentSkipListMap接口实现了与ConcurrentNavigableMap接口有相同行为的一个非阻塞式列表。从内部实现机制来讲，它使用了一个Skip List来存放数据。Skip List是基于并发列表的数据结构，效率与二叉树相近。
当插入元素到映射中时，ConcurrentSkipListMap接口类使用键值来排序所有元素。除了提供返回一个具体元素的方法外，这个类也提供获取子映射的方法。

ConcurrentSkipListMap类提供的常用方法：

1
2
3
4
5

1.headMap(K toKey)：K是在ConcurrentSkipListMap对象的 泛型参数里用到的键。这个方法返回映射中所有键值小于参数值toKey的子映射。
2.tailMap(K fromKey)：K是在ConcurrentSkipListMap对象的 泛型参数里用到的键。这个方法返回映射中所有键值大于参数值fromKey的子映射。
3.putIfAbsent(K key,V value)：如果映射中不存在键key，那么就将key和value保存到映射中。
4.pollLastEntry()：返回并移除映射中的最后一个Map.Entry对象。
5.replace(K key,V value)：如果映射中已经存在键key，则用参数中的value替换现有的值。

ConcurrentHashMap

底层原理

1. 存储结构

1
2
3
4
5
6

static final class HashEntry<K,V> {
    final int hash;
    final K key;
    volatile V value;
    volatile HashEntry<K,V> next;
}

ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。

Segment 继承自 ReentrantLock。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

static final class Segment<K,V> extends ReentrantLock implements Serializable {

    private static final long serialVersionUID = 2249069246763182397L;

    static final int MAX_SCAN_RETRIES =
        Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;

    transient volatile HashEntry<K,V>[] table;

    transient int count;

    transient int modCount;

    transient int threshold;

    final float loadFactor;
}

1

final Segment<K,V>[] segments;

默认的并发级别为 16，也就是说默认创建 16 个 Segment。

1

static final int DEFAULT_CONCURRENCY_LEVEL = 16;

2. size 操作

每个 Segment 维护了一个 count 变量来统计该 Segment 中的键值对个数。

1
2
3
4
5

/**
 * The number of elements. Accessed only either within locks
 * or among other volatile reads that maintain visibility.
 */
transient int count;

在执行 size 操作时，需要遍历所有 Segment 然后把 count 累计起来。

ConcurrentHashMap 在执行 size 操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。

尝试次数使用 RETRIES_BEFORE_LOCK 定义，该值为 2，retries 初始值为 -1，因此尝试次数为 3。

如果尝试的次数超过 3 次，就需要对每个 Segment 加锁。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

/**
 * Number of unsynchronized retries in size and containsValue
 * methods before resorting to locking. This is used to avoid
 * unbounded retries if tables undergo continuous modification
 * which would make it impossible to obtain an accurate result.
 */
static final int RETRIES_BEFORE_LOCK = 2;

public int size() {
    // Try a few times to get accurate count. On failure due to
    // continuous async changes in table, resort to locking.
    final Segment<K,V>[] segments = this.segments;
    int size;
    boolean overflow; // true if size overflows 32 bits
    long sum;         // sum of modCounts
    long last = 0L;   // previous sum
    int retries = -1; // first iteration isn't retry
    try {
        for (;;) {
            // 超过尝试次数，则对每个 Segment 加锁
            if (retries++ == RETRIES_BEFORE_LOCK) {
                for (int j = 0; j < segments.length; ++j)
                    ensureSegment(j).lock(); // force creation
            }
            sum = 0L;
            size = 0;
            overflow = false;
            for (int j = 0; j < segments.length; ++j) {
                Segment<K,V> seg = segmentAt(segments, j);
                if (seg != null) {
                    sum += seg.modCount;
                    int c = seg.count;
                    if (c < 0 || (size += c) < 0)
                        overflow = true;
                }
            }
            // 连续两次得到的结果一致，则认为这个结果是正确的
            if (sum == last)
                break;
            last = sum;
        }
    } finally {
        if (retries > RETRIES_BEFORE_LOCK) {
            for (int j = 0; j < segments.length; ++j)
                segmentAt(segments, j).unlock();
        }
    }
    return overflow ? Integer.MAX_VALUE : size;
}

3. JDK 1.8 的改动

JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发度与 Segment 数量相等。

JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。

并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。

使用方法

创建和读写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
 
public class HashMapExample 
{
    public static void main(String[] args) throws CloneNotSupportedException 
    {
        ConcurrentHashMap<Integer, String> concurrHashMap = new ConcurrentHashMap<>();
         
        //Put require no synchronization
        concurrHashMap.put(1, "A");
        concurrHashMap.put(2, "B");
         
        //Get require no synchronization
        concurrHashMap.get(1);
         
        Iterator<Integer> itr = concurrHashMap.keySet().iterator();
         
        //Using synchronized block is advisable
        synchronized (concurrHashMap) 
        {
            while(itr.hasNext()) {
                System.out.println(concurrHashMap.get(itr.next()));
            }
        }
    }
}

使用Collection.synchronizedMap也有同样的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
 
public class HashMapExample 
{
    public static void main(String[] args) throws CloneNotSupportedException 
    {
        Map<Integer, String> syncHashMap = Collections.synchronizedMap(new HashMap<>());
         
        //Put require no synchronization
        syncHashMap.put(1, "A");
        syncHashMap.put(2, "B");
         
        //Get require no synchronization
        syncHashMap.get(1);
         
        Iterator<Integer> itr = syncHashMap.keySet().iterator();
         
        //Using synchronized block is advisable
        synchronized (syncHashMap) 
        {
            while(itr.hasNext()) {
                System.out.println(syncHashMap.get(itr.next()));
            }
        }
    }
}

如何评测效果。有哪些指标，性能提升也要有指标，用哪些业务负载。要具体到用什么负载、用什么指标衡量，这个指标为什么能衡量，评测方案是如何设计的。

不要说你认为好的指标，而是经过筛选的最能反应负载的指标。

如何跟调度器集成

list watch的实现方案

代码没看原理应该清楚可以讲一讲。

2.1 概述

虚拟机提供的最大的能力：自动内存管理。不再需要用户为每一个操作去写配对的delete、free代码，不需要手动管理内存的申请和释放，不容易出现内存泄漏的问题。这也符合并奠定了Java的操作哲学，通过各种各样的运行时接管一些常规的传统语言的操作。

2.2 运行时内存区域

1. 程序计数器：当前线程所执行的字节码的行号指示器。多线程通过线程切换、分配处理器执行，每条线程都需要一个独立的程序计数器，各线程之间计数器互不影响、独立存储，是线程私有的内存。
2. Java虚拟机栈：Java方法执行的内存模型。每个方法执行的时候，创建一个栈帧用于存储局部变量表、操作数栈、动态链接、方法出口等信息。线程私有的内存。局部变量表存放了编译器可知的各种Java虚拟机基本变量类型、对象引用、返回地址类型，局部变量表所需要的空间是在编译期间分配完成的，运行过程中，当进入一个方法时，这个方法需要再栈帧中分配多大的局部变量空间是完全确定的。
3. 本地方法栈：本地方法的栈帧。也是线程私有的内存。
4. 堆：用于存放对象实例。被所有线程共享的一块内存区域，是垃圾收集器管理的内存区域。可以处在物理上不连续的内存空间。通过虚拟机参数-Xmx和Xms控制堆的大小。当Java堆无法再扩展时，就会抛出OOM异常。
5. 方法区：存储已经被虚拟机加载的类信息、常量、静态变量，即时编译后的代码缓存等数据。
6. 运行时常量池：方法区的一部分。Class文件包括版本、字段、方法、接口等描述信息，还有常量池表，用来存放编译期产生的各种字面常量与符号引用。运行时常量池具有动态性，不仅包括编译期产生的常量与符号引用，还包括运行期将常量放入常量池中，例如通过String的intern()方法创建的字符串常量。常量池无法再申请到内存时会抛出OOM异常。
7. 直接内存：NIO的通过和缓冲区可以使用Native函数库直接分配堆外内存，然后通过存储在Java堆里的DirectByteBuffer对象作为这块内存的引用进行操作。这样操作能够显著提高性能，避免在Java堆和Native堆中来回复制数据。本机的内存分配不会受到Java堆大小的限制。

2.3 虚拟机对象

对象创建的过程

1. 遇到一个new命令
2. 检查类。检查这个指令的参数，是否能在常量池中定位到一个类的符号引用，如果没有那么必须执行类加载过程，如果检查到这个符号，则代表这个类已经被加载、解析和初始化过。
3. 分配内存。对象所需要的内存大小在类加载完成后便可以确定。
   1. 指针碰撞：假如是规整内存，使用过的内存和未使用的内存都会规整存放，两者中间通过分界点指示器分割，那么分配内存就是移动一下分界点的指针。空闲内存列表：如果内存并不规整，虚拟机维护了一个可用的内存列表，在分配的时候从列表中找到一块足够大的空间划分给对象实例，并更新可用内存列表。
   2. Serial和ParNew等收集器带有内存压缩能力，采用了指针碰撞方式。CMS标记清楚算法收集器采用空闲内存列表的方式分配内存。
   3. 并发安全问题：CAS保证内存分配操作的原子性。本地线程分配缓存，每个线程在Java堆中预先分配一小块内存，内存分配动作按照线程划分在不同的空间中运行，
4. 初始化：初始化内存值，将分配到的内存初始化位0.初始化对象头，包括类指针，对象的哈希码，对象的GC分代年龄等信息。
5. 执行用户初始化操作：执行方法，按照程序员的意愿对对象进行初始化。

对象的内存布局

对象在堆内存中的存储布局分为三部分：对象头，实例数据，对齐填充。

1. 对象头：哈希码、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳。还包括类型指针，指向它的类型元数据的指针，通过这个指针可以确定对象属于哪个类的实力。对于Java数组这里还会保存数组的长度。
2. 实例数据：真正存储的有效信息，程序代码里定义的各种类型段内容。
3. 对齐填充。8字节的整数倍。

对象的访问定位

Java程序通过栈上的reference数据来操作堆上的具体对象。

1. 句柄访问。对象移动的时候改变句柄值即可。
   
2. 访问速度快减少一次寻址操作。
   

2.4 OOM

1.什么是OOM？

OOM，全称“Out Of Memory”，翻译成中文就是“内存用完了”，来源于java.lang.OutOfMemoryError。看下关于的官方说明： Thrown when the Java Virtual Machine cannot allocate an object because it is out of memory, and no more memory could be made available by the garbage collector. 意思就是说，当JVM因为没有足够的内存来为对象分配空间并且垃圾回收器也已经没有空间可回收时，就会抛出这个error（注：非exception，因为这个问题已经严重到不足以被应用处理）。

2.为什么会OOM?

为什么会没有内存了呢？原因不外乎有两点：

• 1）分配的少了：比如虚拟机本身可使用的内存（一般通过启动时的VM参数指定）太少。
• 2）应用用的太多，并且用完没释放，浪费了。此时就会造成内存泄露或者内存溢出。主要分为以下两种情况：
  • 内存泄露：申请使用完的内存没有释放，导致虚拟机不能再次使用该内存，此时这段内存就泄露了，因为申请者不用了，而又不能被虚拟机分配给别人用。
  • 内存溢出：申请的内存超出了JVM能提供的内存大小，此时称之为溢出。

在之前没有垃圾自动回收的日子里，比如C语言和C++语言，我们必须亲自负责内存的申请与释放操作，如果申请了内存，用完后又忘记了释放，比如C++中的new了但是没有delete，那么就可能造成内存泄露。偶尔的内存泄露可能不会造成问题，而大量的内存泄露可能会导致内存溢出。

而在Java语言中，由于存在了垃圾自动回收机制，所以，我们一般不用去主动释放不用的对象所占的内存，也就是理论上来说，是不会存在“内存泄露”的。但是，如果编码不当，比如，将某个对象的引用放到了全局的Map中，虽然方法结束了，但是由于垃圾回收器会根据对象的引用情况来回收内存，导致该对象不能被及时的回收。如果该种情况出现次数多了，就会导致内存溢出，比如系统中经常使用的缓存机制。Java中的内存泄露，不同于C++中的忘了delete，往往是逻辑上的原因泄露。

3.OOM类型

JVM内存模型：

按照JVM规范，JAVA虚拟机在运行时会管理以下的内存区域：

• 程序计数器：当前线程执行的字节码的行号指示器，线程私有
• JAVA虚拟机栈：Java方法执行的内存模型，每个Java方法的执行对应着一个栈帧的进栈和出栈的操作。
• 本地方法栈：类似“ JAVA虚拟机栈 ”，但是为native方法的运行提供内存环境。
• JAVA堆：对象内存分配的地方，内存垃圾回收的主要区域，所有线程共享。可分为新生代，老生代。
• 方法区：用于存储已经被JVM加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。Hotspot中的“永久代”。
• 运行时常量池：方法区的一部分，存储常量信息，如各种字面量、符号引用等。
• 直接内存：并不是JVM运行时数据区的一部分， 可直接访问的内存， 比如NIO会用到这部分。

按照JVM规范，除了程序计数器不会抛出OOM外，其他各个内存区域都可能会抛出OOM。

最常见的OOM情况有以下三种：

• java.lang.OutOfMemoryError: Java heap space ——>java堆内存溢出，此种情况最常见，一般由于内存泄露或者堆的大小设置不当引起。对于内存泄露，需要通过内存监控软件查找程序中的泄露代码，而堆大小可以通过虚拟机参数-Xms,-Xmx等修改。

• java.lang.OutOfMemoryError: PermGen space ——>java永久代溢出，即方法区溢出了，一般出现于大量Class或者jsp页面，或者采用cglib等反射机制的情况，因为上述情况会产生大量的Class信息存储于方法区。此种情况可以通过更改方法区的大小来解决，使用类似-XX:PermSize=64m -XX:MaxPermSize=256m的形式修改。另外，过多的常量尤其是字符串也会导致方法区溢出。

• java.lang.StackOverflowError ——> 不会抛OOM error，但也是比较常见的Java内存溢出。JAVA虚拟机栈溢出，一般是由于程序中存在死循环或者深度递归调用造成的，栈大小设置太小也会出现此种溢出。可以通过虚拟机参数-Xss来设置栈的大小。

各种触发OOM的方式

1. OOM：Java heap Space：在循环中不断地创建新的对象 -Xms20m -Xmx20m
2. 虚拟机栈和本地方法栈：无限制递归、不断创建线程执行方法
3. 方法区和常量池：不断执行String::intern()、使用CGlib不断创建类 -XX:MaxMetaspaceSize -XX:MaxPermSize
4. 本机直接内存溢出：Usafe不断直接分配内存空间 -XX:MaxDirectMemorySize

4.OOM分析–heapdump

要dump堆的内存镜像，可以采用如下两种方式：

• 设置JVM参数-XX:+HeapDumpOnOutOfMemoryError，设定当发生OOM时自动dump出堆信息。不过该方法需要JDK5以上版本。
• 使用JDK自带的jmap命令。”jmap -dump:format=b,file=heap.bin “ 其中pid可以通过jps获取。

dump堆内存信息后，需要对dump出的文件进行分析，从而找到OOM的原因。常用的工具有：

• mat: eclipse memory analyzer, 基于eclipse RCP的内存分析工具。详细信息参见：http://www.eclipse.org/mat/，推荐使用。
• jhat：JDK自带的java heap analyze tool，可以将堆中的对象以html的形式显示出来，包括对象的数量，大小等等，并支持对象查询语言OQL，分析相关的应用后，可以通过http://localhost:7000来访问分析结果。不推荐使用，因为在实际的排查过程中，一般是先在生产环境 dump出文件来，然后拉到自己的开发机器上分析，所以，不如采用高级的分析工具比如前面的mat来的高效。

这个链接：http://www.ibm.com/developerworks/cn/opensource/os-cn-ecl-ma/index.html中提供了一个采用mat分析的例子 。

注意：因为JVM规范没有对dump出的文件的格式进行定义，所以不同的虚拟机产生的dump文件并不是一样的。在分析时，需要针对不同的虚拟机的输出采用不同的分析工具（当然，有的工具可以兼容多个虚拟机的格式）。IBM HeapAnalyzer也是分析heap的一个常用的工具。

5.小结

涉及到的虚拟机的技术或者工具，往往需要考虑到虚拟机规范以及不同的虚拟机实现。尤其是针对虚拟机调优时，往往需要针对虚拟机在某些方面的实现策略来考虑，比如，不同的虚拟机的垃圾回收算法是不一样的，而这直接影响了虚拟机某些参数的设置，以达到虚拟机的最佳性能。

而针对JVM运行时的分析与诊断，则需要掌握分析基本方法，针对具体情况，运用虚拟机的原理，具体分析。一句话，水很深啊。

6. Mat使用简介

MAT，全称Memory Analysis Tools，是一款分析Java堆内存的工具，可以快速定位到堆内泄漏问题。该工具提供了两种使用方式，一种是插件版，可以安装到Eclipse使用，另一种是独立版，可以直接解压使用。

https://github.com/TangBean/understanding-the-jvm/blob/master/Ch1-Java%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86%E6%9C%BA%E5%88%B6/02-%E5%9E%83%E5%9C%BE%E6%94%B6%E9%9B%86(GC).md

3.1 概述

垃圾收集器的概念

定义：在应用程序运行时，应用程序会创建许多对象，每个对象都有其生命周期。 在内存中，被其他对象引用的对象被称为live objects 。 不再由任何活动对象引用的对象被视为dead objects ，并称为garbage 。 查找和释放（也称为回收）这些对象使用的空间的过程称为garbage collection 。

范围：在Java内存运行区域中，私有内存（程序计数器、虚拟机栈、本地方法栈）都是随着线程创建或者销毁。栈中的栈帧随着方法的进入和退出进行入栈和出栈操作。每一个栈帧多少内存基本上是在类结构确定下来的时候就是已经知道地，会由及时编译器进行优化。这里讨论的垃圾回收机制，主要针对堆上的内存，只有层序运行期间我们才会知道究竟会创建哪些对象、创建多少个对象，这一部分的内存分配是动态的。

职责：Java中的Memory management是垃圾收集器的职责。

• allocating memory
• 确保所有引用的对象都保留在内存中，并且
• 恢复由执行代码中的引用无法访问的对象使用的内存。

垃圾回收解决了许多但不是全部的内存分配问题。 例如，我们可以无限期地创建对象并继续引用它们，直到没有更多可用内存为止（ Out of memory error ）。 垃圾收集是一项复杂的任务，需要花费时间和资源。 它在通常由称为堆的大型内存池分配的空间上运行。

垃圾收集的时间取决于垃圾收集器。 通常，整个堆或堆的一部分会在堆满或达到占用率的百分比时收集。

3.2 垃圾判定算法

引用计数算法

概念： 在引用计数技术中，每个对象都有从其他对象和堆栈指向该对象的指针数。 每次引用新对象时，计数器都会增加一。 同样，当任何对象丢失其引用时，计数器将减一。 当count达到’0’时，垃圾回收器可以取消分配对象。

引用计数算法的主要优点是：占用了少量的额外内存进行计数，但是原理十分简单，判定效率很高。 但是它存在循环引用的问题：当第一个对象被第二个对象引用，第二个对象被第一个对象（ cyclic references ） cyclic references ，计数永远不会为零，因此它们永远不会被垃圾回收。

可达性分析算法

概念：通过一系列称为GC Roots的跟对象作为起始节点集，从节点开始根据引用关系向下搜索，搜索过程所走过的路称为引用链，如果某个对象到GC Roots没有引用，则该对象不可能再被使用。

常见的GC Roots对象包括

• 在虚拟机栈中引用的对象。例如当前正在运行的方法的参数、局部变量等。
• 在方法区中静态属性引用的对象。例如Java类中的静态变量。
• 在静态方法区中常量引用的对象。例如字符串常量池中的引用。
• Java虚拟机内部的引用，基本数据类型对应的Class对象
• 所有被同步所锁持有的对象
• 反映Java虚拟机内部的情况，JMXBean、JBMTI中注册的回调，本地代码缓存等。
• 分区垃圾收集算法，还需要将跨区引用作为计算的一部分。

引用类型

对引用的类型进行扩充

• 强引用，传统的直接引用。垃圾收集器永远不会回收掉被引用的对象。
• 软引用，SofaReference。系统发生内存溢出前进行回收。
• 弱引用，WeakReference。只能生存到下一次垃圾收集发生为止。
• 虚引用，PhantomReference。虚引用的存在完全不影响垃圾收集。

自我拯救

一个对象真正的死亡会经历两次标记的过程，

1. 首先对象在进行可达性分析的时候没有与GCRoots相连接，会被第一次标记。
2. 然后给予是否执行过finalizer()方法进行第二次标记，如果执行过则标记结束，如果没执行过需要加入F-Queue队列中，并在稍后由虚拟机自动建立的、低调度优先级的Finalizer线程去执行他们的finalize()方法。

方法区的回收

方法去垃圾手机的性价比非常低。方法去垃圾收集主要回收两部分内容：

1. 废弃的常量
2. 不再使用的类型

3.3 垃圾收集算法

分代收集理论

分代收集理论建立在两个假说的基础上：

• 弱分代假说：绝大多数对象都是朝生夕灭。
• 强分代假说：熬过越多次垃圾收集过程的对象就越难以消亡。
• 跨代引用假说：跨代引用相对于同代引用来说仅占极少数。因为存在引用关系的两个对象，应该倾向于同时生存或者同时消亡。

收集器将Java堆划分成不同的区域，然后将对象依据年龄分配到不同区域中存储。这样不用为了少量的跨代引用去扫描整个老年代，不用浪费空间专门记录每一个对象是否存在，以及存在哪些跨代引用。只需要在新生代上建立一个全局的数据结构——记忆集。这样在发生miniorGC的时候，只需要将存在跨代引用的小块内存里的对象加入到GCRoots进行扫描。

在java堆划分出不同区域之后，垃圾收集器可以每次只回收其中一个或者某些部分的数据。就可以针对不同区域，安排与里面存储对象存亡特征相匹配的垃圾收集算法。因而诞生了三种主要的垃圾收集算法

• 标记复制算法
• 标记清除算法
• 标记整理算法

根据垃圾收集的范围不同，可以将垃圾收集分为以下几种类型：

• 部分收集PratialGC
  • 新生代收集MinorGC/YoungGC
  • 老年代收集MajorGC/OldGC
  • 混合收集MixedGC
• 整堆收集FullGC

标记清除算法

标记清除算法是第一个开发的able to reclaim cyclic data structures垃圾收集算法。 在这种算法中，GC将首先将某些对象标识为默认可达对象，这些对象通常是堆栈中的全局变量和局部变量。 有所谓的活动对象。在下一步中，算法开始从这些活动对象中跟踪对象，并将它们也标记为活动对象。 继续执行此过程，直到检查所有对象并将其标记为活动。 完全跟踪后未标记为活动的对象被视为死对象。

• 暂停应用程序一段时间外，
• 该技术还需要经常对内存地址空间de-fragmentation清除碎片整理

标记复制算法

像“标记和清除”一样，该算法还取决于识别活动对象并对其进行标记。 区别在于它处​​理活动对象的方式。停止和复制技术将整个堆设计为两个semi-spaces 。 一次只有一个半空间处于活动状态，而为新创建的对象分配的内存仅发生在单个半空间中，而另一个保持平静。GC运行时，它将开始标记当前半空间中的活动对象，完成后，它将所有活动对象复制到其他半空间中。 当前半空间中的所有其余对象都被视为已死，并已被垃圾回收。

• 接触活动对象。但是如果内存中大部分对象都是存活的，将产生大量内存复制的开销。
• 不需要考虑空间碎片的问题，会直接进行空间的压缩。
• 需要将所需的内存大小增加一倍，因为在给定的时间点仅使用一半的内存。
• 需要在切换半空间时停止世界。

在标记清除算法上做的改进：

1. 新生代中有98%的对象熬不过第一轮，所以不需要按照1：1的比例来划分新生代中的内存空间。
2. Appel式回收算法，将空间分为一块较大的Eden和两块较小的Survivor，每次空间分配只使用Eden和其中一块Survior。发生垃圾收集的时候，将内存中的对象都复制到空闲的Survivor上。一般情况下空间比例式8:1:1，如果出现例外情况，Survivor的空间不足，就会依赖其他内存区域进行担保。

标记整理算法

与标记复制算法相似，但是整理是将所有存活的对象向内存空间的一端移动，然后直接清理到边界以外的内存。

优缺点：

1. 存在大量存活的对象，移动对象并更新引用是一种负重的操作。
2. 必须要暂停用户的应用进程才能进行。

3.4 HotSpot算法实现细节

根节点枚举

1. 根节点枚举必须暂停用户线程。
2. 使用OopMap快速扫描GCRoots

安全点

1. OopMap只在安全点进行记录。用户进程运行到安全点的时候才可以安全的挂起等待GCRoots的扫描。
2. 安全点在指令复用中才会记录，如方法调用、循环跳转、异常跳转。
3. 用户进程采用主动式中断的方式在安全点挂起。

安全区域

上述安全点方案可以解决运行中的用户线程停顿的时机，但是处于阻塞状态的用户线程无法感知到虚拟机GC中断请求。安全区域确保在某一段代码片段中，引用关系不会发生变化。

这样用户进程在进入安全区域的时候，会标识自己已经进入安全区域。当离开的时候，会检测是否已经完成GCRoots的枚举。

记忆集与卡表

为了解决跨代对象引用的问题，避免在新生代垃圾收集的时候将整个老年代的对象加入到GCRoots当中。

记忆集是从非收集区域指向收集区域的指针集合的抽象数据结构。

如果记录全部的跨代指针会浪费时间和空间，所以直接记录某个一存在跨代指针的区域。卡表是记忆集的一种实现，就是用来记录这样的存在跨代引用的内存区域的数据结构，它定义了记忆集的记录精度、与堆内存的映射关系。

卡表中的每一个元素对应其标识的内存区域中一块特定大小的内存块，这个内存块被称为卡页。

写屏障

卡表上记录了跨代引用，需要再对象赋值的时候维护卡表的数据。

通过写屏障技术维护卡表的状态。写屏障可以看做在虚拟机层面对引用类型字段赋值这个动作的AOP切面。在引用对象赋值的时候会产生一个环形通知，供程序执行额外的操作。

并行可达性分析

首先可达性分析算法要求全过程基于一个能够保证一致性的快照当中才能进行分析，必须冻结全部的用户线程。主要包括以下两个步骤

1. 根节点枚举。这个步骤必须进行用户线程冻结。
2. GCRoots向下遍历对象图，可以进行并行操作。

引入三色标记的理论

• 白色：对象尚未被垃圾收集器访问过。
• 黑色：对象已经被垃圾收集器访问过，并且对象的所有引用都已经扫描过。
• 灰色：对象已经被垃圾收集器扫描过，但是对象上至少存在一个引用还没有被扫描过。

在并发扫描过程中可能会出现以下问题，可以从三色标记理论出发描述一下两种错误发生的场景：

• 原本消亡的对象被错误标记成存活。这个可以容忍，下次GC会回收掉。
• 原本存活的对象被错误标记为消亡。这个无法容忍，会导致用户进程出错。灰色标记中的对象引用断开，并且新增了黑色标记的对象引用，导致该对象应该被扫描但是被错过了。

研究表明出现第二个无法容忍的错误需要满足以下两个条件

1. 赋值器插入一条或者多条从黑色对象到白色对象的引用。
2. 赋值器删除了全部从灰色对象到该白色对象的直接或者间接引用。

所以解决方案也由两个，只需要破坏其中的一个条件即可。

1. 增量更新。破坏第一个条件，当黑色对象插入新的指向白色对象的引用关系时，就将这个新插入的引用记录下来，等并发扫描结束后，再将这些记录过的引用关系中的黑色对象为根，重新进行一次扫描。即，黑色对象一旦插入了白色对象的引用之后，就会变回灰色对象了。

2. 原始快照。破坏第二个条件。当灰色对象要删除指向白色对象的引用关系时，就将这个要删除的引用记录下来，在并发扫描结束后，再将这些记录过的应用关系中的灰色对象为根，重新扫描一次。即，无论关系是否删除，都会按照刚开始扫描那一刻的对象图来快照进行搜索。

另外，虚拟机的记录操作都是通过写屏障实现的。CMS基于增量更新来做并发表及，G1和Shenandoah基于原始快照来实现。

3.5 经典垃圾收集器

Serial收集器

主要包括两个算法。算法对年轻一代使用mark-copy，称为Serial收集器；对老一代使用mark-sweep-compact，成为Serial Old收集器。 它在单个线程上工作。 执行时，它将冻结所有其他线程，直到垃圾回收操作结束。由于串行垃圾回收具有线程冻结特性，因此仅适用于非常小的程序。要使用串行GC，请使用以下JVM参数：

1

-XX:+UseSerialGC

特点：

1. 单线程工作收集器。垃圾收集时必须暂停其他所有工作线程，直到它收集结束。
2. 简单有效，额外消耗最小的收集器。由于没有现成交互的开销，专心做垃圾收集可以获得最高的单线程收集效率。

应用场景

1. 桌面引用场景或者部分微服务应用中，分配给虚拟机的内存一般不会太大。可以容忍一百毫秒以上的垃圾收集延迟。

Parallel收集器

主要包括两个算法。与串行GC相似，它在年轻代中使用mark-copy，称为Parallel Scavenge；在老年代中使用mark-sweep-compact，称为Parallel Old收集器。与串行GC最大的不同，就是使用多个并发线程用于标记和复制/压缩阶段。

可以使用-XX:ParallelGCThreads=N选项配置线程数。如果您的主要目标是通过有效利用现有系统资源来提高吞吐量，那么Parallel Garbage Collector将适用于多核计算机。 使用这种方法，可以大大减少GC循环时间。

1

-XX:+UseParallelGC 

可以使用一下两个参数精确的控制吞吐量

1
2
3

-XX:MaxGCPauseMills：最大 GC 停顿的秒数；
-XX:GCTimeRatio 用户期望虚拟机消耗在GC上的时间不超过程序运行时间的1/(1+N)，默认值为99。
-XX:+UseAdaptiveSizePolicy：一个开关参数，打开后就无需手工指定 -Xmn，-XX:SurvivorRatio 等参数了，虚拟机会根据当前系统的运行情况收集性能监控信息，自行调整。

特点：

• 吞吐量优先。其他收集器关注于尽可能缩短垃圾收集时用户线程的停顿时间，而 Parallel Scavenge 收集器的目的是达到一个可控的吞吐量。

吞吐量 = 运行用户代码时间 / ( 运行用户代码时间 + 垃圾收集时间 )

适用场景：

• Parallel Scavenge 收集器不管是新生代还是老年代都是多个线程同时进行垃圾收集，十分适合于应用在注重吞吐量以及 CPU 资源敏感的场合。

ParNew+CMS收集器

这两个收集器经常配合使用。

ParNew收集器采用标记复制算法，支持多线程并行，同时使用多条线程进行垃圾收集。一般搭配CMS在服务端使用。

CMS垃圾回收实质上是一种升级的标记-清除方法。 它using multiple threads扫描堆内存。 对其进行了修改，以利用更快的系统并增强了性能。它尝试通过与应用程序线程concurrently执行大多数垃圾回收工作来最大程度地减少由于垃圾回收导致的​​暂停。 它在年轻一代中使用并行的世界停止mark-copy算法，而在老一代中使用大多数并发的mark-sweep算法。

1
2
3

-XX:+UseConcMarkSweepGC
-XX:+UseCMSCompactAtFullCollection：在 CMS 要进行 Full GC 时进行内存碎片整理（默认开启）
-XX:CMSFullGCsBeforeCompaction：在多少次 Full GC 后进行一次空间整理（默认是 0，即每一次 Full GC 后都进行一次空间整理）

特点：

1. 以获取最短回收停顿时间为目标的收集器。
2. 标记清除算法

适用场景：

1. 互联网站的服务端上。关注服务的响应速度。停顿时间尽可能短，以给客户较好体验。

运行原理

它是初始且非常基本的算法，分为两个阶段运行：

• Marking live objects –找出所有仍然存在的对象。
• Removing unreachable objects -摆脱所有其他东西-所谓的已死和未使用的对象。

第一阶段介绍：

1. mark live objects。首先，GC将某些特定对象定义为“ Garbage Collection Roots 。 例如，当前执行方法的局部变量和输入参数，活动线程，已加载类的静态字段和JNI引用。 现在，GC遍历了内存中的整个对象图，从这些根开始，然后是从根到其他对象的引用。 GC访问的每个对象都被标记为活动对象。

第二阶段介绍

1. mark-sweep。Normal deletion 普通删除将未引用的对象删除以释放空间并保留引用的对象和指针。 内存分配器（某种哈希表）保存对可分配新对象的可用空间块的引用。它通常被称为mark-sweep算法。
   

2. mark-sweep-compact 。Deletion with compacting仅删除未使用的对象效率不高，因为可用内存块分散在整个存储区域中，并且如果创建的对象足够大且找不到足够大的内存块，则会导致OutOfMemoryError 。为了解决此问题，删除未引用的对象后，将对其余的引用对象进行压缩。 这里的压缩指的是将参考对象一起移动的过程。 这使得新的内存分配变得更加容易和快捷。它通常被称为mark-sweep-compact算法。
   

3. mark-copy 。Deletion with copying –与标记和补偿方法非常相似，因为它们也会重新放置所有活动对象。 重要的区别是重定位的目标是不同的存储区域。它通常被称为mark-copy算法。
   

G1收集器

G1（垃圾优先）垃圾收集器已在Java 7中提供，旨在长期替代CMS收集器。 G1收集器是并行的，并发的，渐进压缩的低暂停垃圾收集器。此方法涉及将内存堆分段为多个小区域（通常为2048）。 每个区域都被标记为年轻一代（进一步划分为伊甸园地区或幸存者地区）或老一代。 这样，GC可以避免立即收集整个堆，而可以逐步解决问题。 这意味着一次只考虑区域的一个子集。

特点

1. G1跟踪每个区域包含的实时数据量。 此信息用于确定包含最多垃圾的区域。 因此它们是首先收集的。
2. 这就是为什么它是名称garbage-first集合。与其他算法一样，不幸的是，压缩操作是使用Stop the World方法进行的。 但是根据其设计目标，您可以为其设置特定的性能目标。 您可以配置暂停持续时间，例如在任何给定的秒内不超过10毫秒。 垃圾优先GC将尽最大可能（但不能确定，由于OS级线程管理，这很难实时实现）来尽力实现该目标。

控制参数：

1
2
3
4
5
6

-XX:+UseG1GC

-XX:G1HeapRegionSize=16m based on the minimum Java heap size.
-XX:MaxGCPauseMillis=200
-XX:G1ReservePercent=5
-XX:GCPauseIntervalMillis=200

3.6 更高效的收集器

ZGC收集器

1. 内存占用、吞吐量、延迟不可能三角。

3.7 选择合适的收集器

如何选择

GC日志分析

内存分配与回收策略

自动内存管理主要包括两部分：自动给对象分配内存和自动回收分配给对象的内存。
以下是最基本的内存分配原则：

对象优先在Eden中分配

1. 大多数情况下对象在Eden中分配。
2. 当Eden没有足够的空间进行分配时，虚拟机将发起一次MinorGC

大对象直接进入老年代

1. 需要大量连续内存空间的对象直接进入老年代。很长的字符串或者元素数量很庞大的数组。
2. 因为如果分配在年轻代会进行标记复制算法，导致大对象在Eden和Survior区之间来回复制。

长期存活的对象进入老年代

1. 每个对象都有年龄计数器，在对象头中。每熬过一次minorGC年龄就会增加1
2. 当年龄增加到15时，就会被晋升到老年代。可以通过-XX:MaxTenuringThreshold=15设置。
3. 大量对象在young gc后任然存活。survivor空间不够，在 Young GC 时，JVM 会检查 目标 Survivor 区（通常是 S1）是否足够容纳 Eden 区中存活的对象。如果 S1 区空间不足（比如 S1 当前使用率已经是 100%），JVM 会绕过 Survivor 区，直接将存活对象晋升到老年代。

动态对象年龄判断

1. 当Survior区中低于或等于某年龄的所有对象总和大于Survivor空间的一半，大于等于该年龄的对象就可以直接进入老年代。

空间分配担保

风险：新生代使用标记复制收集算法。需要留有足够的空间，但是如果情况非常不理想所有的对象都存活则需要老年代有足够的空间担保能够完全存下Eden区。

1. MinorGC虚拟机必须先检查老年代中最大可用的连续空间是否大于新生代所有对象的总空间。如果条件成立则MinorGC可以确保是安全的。
2. 如果不成立，则虚拟机会先查看-XX:HandlePromotionFailure参数的设置值是否允许担保失败。如果允许会检查最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，则进行MinorGC，但需要冒风险。
3. 否则进行FullGC

总结

• 对象生命周期分为三个阶段，即对象创建，对象使用和对象销毁。
• mark-sweep ， mark-sweep-compact和mark-copy机制如何工作。
• 不同的单线程和并发GC算法。
• 直到Java 8，并行GC才是默认算法。
• 从Java 9开始，将G1设置为默认GC算法。


一个语言应该包括以下几个部分

• 核心语法：数据类型和变量、控制流程、数据结构、函数、面向对象、其他
• 内置工具库：数学、日期、字符串、系统、序列化等
• 内置高阶库：文件IO、网络编程、并发编程
• 生态库：Web框架、客户端、分布式
• 编译原理：虚拟机

安装

1. 安装rustup，用来管理rust版本的工具。

1

$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

2. 安装更新rust

1

rustup update

3. 查看安装的版本

1

rustc --version

优势分析

1. 所有权\move语法\借用引用
2. 表达式与语句概念

变量

变量和常量

1. 默认情况下是不可变的。这也是rust的设计哲学之一：通过默认的方式避免掉了很多种可能会出现的错误，非常好的设计思路，将最稳定、最安全的方式作为默认的方式。
2. 可变变量使用mut关键字修饰。

1
2

let mut x = 5;
x =6;

3. 常量使用const关键字修饰。必须在声明的时候初始化，只能是字面常量或者常量表达式，不能是函数调用结果，因为要在编译阶段计算常量的值。常量可以在任意作用域内声明，包括全局作用域，这对于代码中很多部分都需要知道一个值的情况特别有用。

1

const X:i32 = 5;

4. 变量遮蔽。可以声明和前面变量具有相同名称的新变量。通过使用相同的变量名并重复使用 let 关键字来遮蔽变量。其实变量遮蔽功能跟变量支持重复赋值功能已经没有什么区别了，但是换了一个概念，就解决了内存管理的问题，太厉害了。
   1. mut和变量遮蔽不同。变量遮蔽可以讲变量声明为不同的类型。而且新的变量有自己的地址。

1
2
3
4
5
6
7
8
9
10
11
12

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {}", x);
    }

    println!("The value of x is: {}", x);
}

数据类型

数据类型的规则

Rust 是一种静态类型（statically typed）的语言，每个值都有确切的数据类型（data type），必须在编译期知道所有变量的类型。

标量（scalar）类型表示单个值。Rust 有 4 个基本的标量类型：整型、浮点型、布尔型和字符。

整型

整型。每个定义形式要么是有符号类型要么是无符号类型，且带有一个显式的大小。有符号和无符号表示数字能否取负数——也就是说，这个数是否可能是负数（有符号类型），或一直为正而不需要带上符号（无符号类型）。就像在纸上写数字一样：当要强调符号时，数字前面可以带上正号或负号；然而，当很明显确定数字为正数时，就不需要加上正号了。有符号数字以二进制补码（译者补充：“补码”百度百科）形式存储。

1
2
3
4
5
6

8 位i8u8
16 位i16u16
32 位i32u32
64 位i64u64
128 位i128u128
archisizeusize

Rust 的整型字面量

1
2
3
4
5
6

数字字面量示例
十进制98_222
十六进制0xff
八进制0o77
二进制0b1111_0000
字节 (仅限于 u8)b'A'

Rust 的所有数字类型都支持基本数学运算：加法、减法、乘法、除法和取模运算。整数除法会向下取整。

浮点类型

浮点数（floating-point number）是带有小数点的数字，在 Rust 中浮点类型（简称浮点型）数字也有两种基本类型。Rust 的浮点型是 f32 和 f64，它们的大小分别为 32 位和 64 位。

1
2
3
4
5

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

布尔类型

和大多数编程语言一样，Rust 中的布尔类型也有两个可能的值：true 和 false。布尔值的大小为 1 个字节。Rust 中的布尔类型使用 bool 声明。

1
2
3
4
5

fn main() {
    let t = true;

    let f: bool = false; // with explicit type annotation
}

复合类型-元祖

复合类型（compound type）可以将多个值组合成一个类型。Rust 有两种基本的复合类型：元组（tuple）和数组（array）。

元组是将多种类型的多个值组合到一个复合类型中的一种基本方式。元组的长度是固定的：声明后，它们就无法增长或缩小。

元组中的每个位置都有一个类型，并且元组中不同值的类型不要求是相同的。

1
2
3

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

使用模式匹配来解构（destructure）元组的一个值

1
2
3
4
5
6
7

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {}", y);
}

使用一个句点（.）连上要访问的值的索引来直接访问元组元素。

1
2
3
4
5
6
7
8
9

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

复合类型-数组

将多个值组合在一起的另一种方式就是使用数组（array）。与元组不同，数组的每个元素必须具有相同的类型。与某些其他语言中的数组不同，Rust 中的数组具有固定长度。

1
2
3
4
5
6
7
8
9

fn main() {
    // 直接初始化
    let a = [1, 2, 3, 4, 5];
    // 隐含的类型
    let a: [i32; 5] = [1, 2, 3, 4, 5];
    // 重复元素初始化
    let a = [3; 5];

}

注释

1
2
3
4
5

// Hello, world.

fn main() {
    let lucky_number = 7; // I’m feeling lucky today
}

语句和表达式

这个设计也太舒服了，非常非常符合直觉且非常好用

所有的代码块都支持两种形式，语句或者表达式。语句就是执行一段代码，表达式就是返回一个值，表达式返回值的可以用于给变量赋值形成语句、用于循环的判断条件等。这里重点讲表达式。

1. 最简单的表达式

1
2

5 + 6 //这是一个表达式
a = 5 + 6; //这是一个利用表达式的赋值语句

2. 代码块表达式

1
2
3
4
5
6
7
8
9

{
    let a = 5;
    a
} //这是一个代码块表达式

test = {
    let a = 5;
    a
}; //这是一个表达式赋值语句

3. 函数表达式
4. 条件语句表达式
5. 宏表达式

基本语句

if 表达式允许根据条件执行不同的代码分支。你提供一个条件并表示 “如果条件满足，运行这段代码；如果条件不满足，不运行这段代码。”

1
2
3
4
5
6
7
8
9

fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

elseif多重条件

可以将 if 和 else 组成的 else if 表达式来实现多重条件。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

将if代码块视作表达式

在 let 语句中使用 if

1
2
3
4
5
6
7

fn main() {
    let condition = true;

    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {}", number);
}

循环表达式

loop循环

loop 关键字告诉 Rust 一遍又一遍地执行一段代码直到你明确要求停止。

• 循环中的 continue 关键字告诉程序跳过这个循环迭代中的任何剩余代码，并转到下一个迭代
• 使用 break 关键字来告诉程序何时停止循环。

循环标签：如果存在嵌套循环，break 和 continue 应用于此时最内层的循环。你可以选择在一个循环上指定一个循环标签（loop label），然后将标签与 break 或 continue 一起使用，使这些关键字应用于已标记的循环而不是最内层的循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {}", count);
        let mut remaining = 10;

        loop {
            println!("remaining = {}", remaining);
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }

        count += 1;
    }
    println!("End count = {}", count);
}

从循环返回：loop 的一个用例是重试可能会失败的操作，比如检查线程是否完成了任务。然而你可能会需要将操作的结果从循环中传递给其它的代码。为此，你可以在用于停止循环的 break 表达式添加你想要返回的值；

1
2
3
4
5
6
7
8
9
10
11
12
13

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {}", result);
}

while循环

在程序中计算循环的条件也很常见。当条件为真，执行循环。当条件不再为真，调用 break 停止循环。

1
2
3
4
5
6
7
8
9
10
11

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);

        number -= 1;
    }

    println!("LIFTOFF!!!");
}

这种结构消除了很多使用 loop、if、else 和 break 时所必须的嵌套，这样更加清晰。当条件为真就执行，否则退出循环。

for循环

可以使用 while 结构来遍历集合中的元素，比如数组。例如，示例 3-4 中的循环打印数组 a 中的每个元素。

1
2
3
4
5
6
7

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {}", element);
    }
}

for 循环的安全性和简洁性使得它成为 Rust 中使用最多的循环结构。即使是在想要循环执行代码特定次数时，例如示例 3-3 中使用 while 循环的倒计时例子，大部分 Rustacean 也会使用 for 循环。使用 Range，它是标准库提供的类型，用来生成从一个数字开始到另一个数字之前结束的所有数字的序列。for-range实例

1
2
3
4
5
6

fn main() {
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("LIFTOFF!!!");
}

结构体定义

结构体和我们在“元组类型”章节论过的元组类似。和元组一样，结构体的每一部分可以是不同类型。但不同于元组，结构体需要命名各部分数据以便能清楚的表明其值的意义。由于有了这些名字，结构体比元组更灵活：不需要依赖顺序来指定或访问实例中的值。

定义结构体，需要使用 struct 关键字并为整个结构体提供一个名字。结构体的名字需要描述它所组合的数据的意义。接着，在大括号中，定义每一部分数据的名字和类型，我们称为 字段（field）。例如，示例 5-1 展示了一个存储用户账号信息的结构体：

1
2
3
4
5
6
7
8

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {}

结构体使用

通过为每个字段指定具体值的方式来创建该结构体的实例。创建一个实例需要以结构体的名字开头，接着在大括号中使用 key: value 键-值对的形式提供字段，其中 key 是字段的名字，value 是需要存储在字段中的数据值。实例中字段的顺序不需要和它们在结构体中声明的顺序一致。换句话说，结构体的定义就像一个类型的通用模板，而实例则会在这个模板中放入特定数据来创建这个类型的值。

1
2
3
4
5
6

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

访问结构体中的数据，与元祖一样，通过.语法访问，元祖中feild是索引，而结构体中是feild的名称

1
2
3
4
5
6
7
8
9

fn main() {
    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };
    user1.email = String::from("anotheremail@example.com");
}

注意整个实例必须是可变的；Rust 并不允许只将某个字段标记为可变。另外需要注意同其他任何表达式一样，我们可以在函数体的最后一个表达式中构造一个结构体的新实例，来隐式地返回这个实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        email: email,
        username: username,
        active: true,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}

参数名与字段名都完全相同，我们可以使用字段初始化简写语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        email,
        username,
        active: true,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}

结构体更新

使用旧实例的大部分值但改变其部分值来创建一个新的结构体实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    // --snip--

    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        active: user1.active,
        username: user1.username,
        email: String::from("another@example.com"),
        sign_in_count: user1.sign_in_count,
    };
}

使用结构体更新语法，我们可以通过更少的代码来达到相同的效果。.. 语法指定了剩余未显式设置值的字段应有与给定实例对应字段相同的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    // --snip--

    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        email: String::from("another@example.com"),
        ..user1
    };
}

代码还创建了一个新实例 user2，该实例具有不同的 email 值，但 username、 active 和 sign_in_count 字段的值与 user1 相同。..user1 必须放在最后，以指定其余的字段应从 user1 的相应字段中获取其值，但我们可以选择以任何顺序为任意字段指定值，而不用考虑结构体定义中字段的顺序。

结构更新语法就像带有 = 的赋值，因为它移动了数据，就像我们在“变量与数据交互的方式（一）：移动”部分讲到的一样。在这个例子中，我们在创建 user2 后不能再使用 user1，因为 user1 的 username 字段中的 String 被移到 user2 中。如果我们给 user2 的 email 和 username 都赋予新的 String 值，从而只使用 user1 的 active 和 sign_in_count 值，那么 user1 在创建 user2 后仍然有效。

其他结构体

元组结构体

使用没有命名字段的元组结构体来创建不同的类型

元组结构体有着结构体名称提供的含义，但没有具体的字段名，只有字段的类型。当你想给整个元组取一个名字，并使元组成为与其他元组不同的类型时，元组结构体是很有用的，这时像常规结构体那样为每个字段命名就显得多余和形式化了。

要定义元组结构体，以 struct 关键字和结构体名开头并后跟元组中的类型。例如，下面是两个分别叫做 Color 和 Point 元组结构体的定义和用法：

1
2
3
4
5
6
7
8

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

类单元结构体

我们也可以定义一个没有任何字段的结构体！它们被称为类单元结构体（unit-like structs），因为它们类似于 ()，即“元组类型”一节中提到的 unit 类型。类单元结构体常常在你想要在某个类型上实现 trait 但不需要在类型中存储数据的时候发挥作用。我们将在第 10 章介绍 trait。下面是一个声明和实例化一个名为 AlwaysEqual 的 unit 结构的例子。

1
2
3
4
5

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

结构体方法

定义

方法 与函数类似：它们使用 fn 关键字和名称声明，可以拥有参数和返回值，同时包含在某处调用该方法时会执行的代码。不过方法与函数是不同的，因为它们在结构体的上下文中被定义。并且它们第一个参数总是 self，它代表调用该方法的结构体实例。

让我们把前面实现的获取一个 Rectangle 实例作为参数的 area 函数，改写成一个定义于 Rectangle 结构体上的 area 方法，如示例 5-13 所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}

为了使函数定义于 Rectangle 的上下文中，我们开始了一个 impl 块（impl 是 implementation 的缩写），这个 impl 块中的所有内容都将与 Rectangle 类型相关联。接着将 area 函数移动到 impl 大括号中，并将签名中的第一个（在这里也是唯一一个）参数和函数体中其他地方的对应参数改成 self。然后在 main 中将我们先前调用 area 方法并传递 rect1 作为参数的地方，改成使用方法语法（method syntax）在 Rectangle 实例上调用 area 方法。方法语法获取一个实例并加上一个点号，后跟方法名、圆括号以及任何参数。

• &self 的理由跟在函数版本中使用 &Rectangle 是相同的：我们并不想获取所有权，只希望能够读取结构体中的数据，而不是写入。
• 如果想要在方法中改变调用方法的实例，需要将第一个参数改为 &mut self。通过仅仅使用 self 作为第一个参数来使方法获取实例的所有权是很少见的；

使用方法替代函数，除了可使用方法语法和不需要在每个函数签名中重复 self 的类型之外，其主要好处在于组织性。我们将某个类型实例能做的所有事情都一起放入 impl 块中，而不是让将来的用户在我们的库中到处寻找 Rectangle 的功能。

函数定义

Rust 代码中的函数和变量名使用下划线命名法（snake case，直译为蛇形命名法）规范风格。在下划线命名法中，所有字母都是小写并使用下划线分隔单词。这是一个包含函数定义示例的程序：

1
2
3
4
5
6
7
8
9

fn main() {
    println!("Hello, world!");

    another_function();
}

fn another_function() {
    println!("Another function.");
}

函数参数

函数也可以被定义为拥有参数（parameter），参数是特殊变量，是函数签名的一部分。当函数拥有参数（形参）时，可以为这些参数提供具体的值（实参）。技术上讲，这些具体值被称为实参（argument），但是在日常交流中，人们倾向于不区分使用 parameter 和 argument 来表示函数定义中的变量或调用函数时传入的具体值。

1
2
3
4
5
6
7

fn main() {
    another_function(5);
}

fn another_function(x: i32) {
    println!("The value of x is: {}", x);
}

语句和表达式

函数体由一系列语句组成，也可选择以表达式结尾。

语句（statement）是执行一些操作但不返回值的指令。表达式（expression）计算并产生一个值。

语句并不返回值，表达式会计算出一个值。语句 let y = 6; 中的 6 是一个表达式，它计算出的值是 6。函数调用是一个表达式。宏调用是一个表达式。我们用来创建新作用域的大括号（代码块） {} 也是一个表达式

列子

1
2
3
4
5
6
7
8
9

fn five() -> i32 {
    5
}

fn main() {
    let x = five();

    println!("The value of x is: {}", x);
}

代码块像是一个没有名称的函数，允许有代码块的返回值。函数更像是一个有名称和参数的代码块，也允许有返回值。

基本规则

• Rust 中的每一个值都有一个被称为其 所有者（owner）的变量。
• 值在任一时刻有且只有一个所有者。
• 当所有者（变量）离开作用域，这个值将被丢弃。

变量作用域

变量 s 绑定到了一个字符串字面量，这个字符串值是硬编码进程序代码中的。该变量从声明的那一刻开始直到当前 作用域 结束时都是有效的。

• 当 s 进入作用域 时，它就是有效的。
• 这一直持续到它 离开作用域 为止。

1
2
3
4
5

{                      // s 在这里无效, 它尚未声明
    let s = "hello";   // 从此处起，s 开始有效

    // 使用 s
}                      // 此作用域已结束，s 不再有效

内存分配

这是一个将 String 需要的内存返回给分配器的很自然的位置：当 s 离开作用域的时候。当变量离开作用域，Rust 为我们调用一个特殊的函数。这个函数叫做 drop，在这里 String 的作者可以放置释放内存的代码。Rust 在结尾的 } 处自动调用 drop。

1
2
3
4
5
6

{
    let s = String::from("hello"); // 从此处起，s 开始有效

    // 使用 s
}                                  // 此作用域已结束，
                                   // s 不再有效

堆上的数据：移动

1
2

let s1 = String::from("hello");
  let s2 = s1;

在 let s2 = s1 之后，Rust 认为 s1 不再有效，因此 Rust 不需要在 s1 离开作用域后清理任何东西。
Rust 永远也不会自动创建数据的 “深拷贝”。因此，任何 自动 的复制可以被认为对运行时性能影响较小

克隆

我们 确实 需要深度复制 String 中堆上的数据，而不仅仅是栈上的数据，可以使用一个叫做 clone 的通用函数。

1
2
3
4

let s1 = String::from("hello");
let s2 = s1.clone();

println!("s1 = {}, s2 = {}", s1, s2);

当出现 clone 调用时，你知道一些特定的代码被执行而且这些代码可能相当消耗资源。

只在栈上的数据：克隆

1
2
3
4

let x = 5;
 let y = x;

 println!("x = {}, y = {}", x, y);

所有权与函数

将值传递给函数在语义上与给变量赋值相似。向函数传递值可能会移动或者复制，就像赋值语句一样。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

fn main() {
  let s = String::from("hello");  // s 进入作用域

  takes_ownership(s);             // s 的值移动到函数里 ...
                                  // ... 所以到这里不再有效

  let x = 5;                      // x 进入作用域

  makes_copy(x);                  // x 应该移动函数里，
                                  // 但 i32 是 Copy 的，所以在后面可继续使用 x

} // 这里, x 先移出了作用域，然后是 s。但因为 s 的值已被移走，
  // 所以不会有特殊操作

fn takes_ownership(some_string: String) { // some_string 进入作用域
  println!("{}", some_string);
} // 这里，some_string 移出作用域并调用 `drop` 方法。占用的内存被释放

fn makes_copy(some_integer: i32) { // some_integer 进入作用域
  println!("{}", some_integer);
} // 这里，some_integer 移出作用域。不会有特殊操作

返回值与所有权

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

fn main() {
  let s1 = gives_ownership();         // gives_ownership 将返回值
                                      // 移给 s1

  let s2 = String::from("hello");     // s2 进入作用域

  let s3 = takes_and_gives_back(s2);  // s2 被移动到
                                      // takes_and_gives_back 中,
                                      // 它也将返回值移给 s3
} // 这里, s3 移出作用域并被丢弃。s2 也移出作用域，但已被移走，
  // 所以什么也不会发生。s1 移出作用域并被丢弃

fn gives_ownership() -> String {           // gives_ownership 将返回值移动给
                                           // 调用它的函数

  let some_string = String::from("yours"); // some_string 进入作用域

  some_string                              // 返回 some_string 并移出给调用的函数
}

// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域

  a_string  // 返回 a_string 并移出给调用的函数
}

变量的所有权总是遵循相同的模式：将值赋给另一个变量时移动它。当持有堆中数据值的变量离开作用域时，其值将通过 drop 被清理掉，除非数据被移动为另一个变量所有。

引用

基本规则

• 在任意给定时间，要么 只能有一个可变引用，要么 只能有多个不可变引用。
• 引用必须总是有效的。

引用定义

& 符号就是 引用，它们允许你使用值但不获取其所有权。

借用（borrowing）创建一个引用的行为.

https://rustwiki.org/zh-CN/book/img/trpl04-05.svg

1
2
3
4
5
6
7
8
9
10
11

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

变量 s 有效的作用域与函数参数的作用域一样，不过当引用停止使用时并不丢弃它指向的数据，因为我们没有所有权。当函数使用引用而不是实际值作为参数，无需返回值来交还所有权，因为就不曾拥有所有权。

引用默认是不可变的。

可变引用

1
2
3
4
5
6
7
8
9

fn main() {
    let mut s = String::from("hello");

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

将 s 改为 mut。然后必须在调用 change 函数的地方创建一个可变引用 &mut s，并更新函数签名以接受一个可变引用 some_string: &mut String。这就非常清楚地表明，change 函数将改变它所借用的值。

规则一： 在同一时间，只能有一个对某一特定数据的可变引用。尝试创建两个可变引用的代码将会失败。

1
2
3
4
5
6

let mut s = String::from("hello");

   let r1 = &mut s;
   let r2 = &mut s;

   println!("{}, {}", r1, r2);

防止同一时间对同一数据进行多个可变引用的限制允许可变性，不过是以一种受限制的方式允许。新 Rustacean 们经常难以适应这一点，因为大部分语言中变量任何时候都是可变的。

这个限制的好处是 Rust 可以在编译时就避免数据竞争。数据竞争（data race）类似于竞态条件，它由这三个行为造成：

1. 两个或更多指针同时访问同一数据。
2. 至少有一个指针被用来写入数据。
3. 没有同步数据访问的机制。

可以使用大括号来创建一个新的作用域，以允许拥有多个可变引用，只是不能 同时 拥有：

1
2
3
4
5
6
7
8

let mut s = String::from("hello");

 {
     let r1 = &mut s;
 } // r1 在这里离开了作用域，所以我们完全可以创建一个新的引用

 let r2 = &mut s;

规则二： 不能在拥有不可变引用的同时拥有可变引用。使用者可不希望不可变引用的值在他们的眼皮底下突然被改变了！然而，多个不可变引用是可以的，因为没有哪个只能读取数据的人有能力影响其他人读取到的数据。

• 读写和写写互斥存在
• 读读不互斥。

规则三： 引用的作用域从声明的地方开始一直持续到最后一次使用为止。例如，因为最后一次使用不可变引用（println!)，发生在声明可变引用之前，所以如下代码是可以编译的：

1
2
3
4
5
6
7
8
9
10
11
12

fn main() {
    let mut s = String::from("hello");

    let r1 = &s; // 没问题
    let r2 = &s; // 没问题
    println!("{} and {}", r1, r2);
    // 此位置之后 r1 和 r2 不再使用

    let r3 = &mut s; // 没问题
    println!("{}", r3);
}

悬垂引用

在具有指针的语言中，很容易通过释放内存时保留指向它的指针而错误地生成一个 悬垂指针（dangling pointer），所谓悬垂指针是其指向的内存可能已经被分配给其它持有者。相比之下，在 Rust 中编译器确保引用永远也不会变成悬垂状态：当你拥有一些数据的引用，编译器确保数据不会在其引用之前离开作用域。

让我们尝试创建一个悬垂引用，Rust 会通过一个编译时错误来避免：

1
2
3
4
5
6
7
8
9
10

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s
}

在任意给定时间，要么 只能有一个可变引用，要么 只能有多个不可变引用。
引用必须总是有效的。

切片与引用

切片的使用

1
2
3
4
5
6
7
8
9
10
11