TCP三次握手和四次挥手的问题在面试中是最为常见的考点之一。很多读者都知道三次和四次，但是如果问深入一点，他们往往都无法作出准确回答。

本篇尝试使用动画来对这个知识点进行讲解，期望读者们可以更加简单地地理解TCP交互的本质。

## TCP 三次握手

TCP 三次握手就好比两个人在街上隔着50米看见了对方，但是因为雾霾等原因不能100%确认，所以要通过招手的方式相互确定对方是否认识自己。

![1643a1dd6df4813b~tplv-t2oaga2asx-jj-mark_3024_0_0_0_q75.gif](https://blog.liushigong.cn/static/img/18669b87afb180f53f6cb101b8ea3ec1.1643a1dd6df4813b~tplv-t2oaga2asx-jj-mark_3024_0_0_0_q75.gif)

张三首先向李四招手(syn)，李四看到张三向自己招手后，向对方点了点头挤出了一个微笑(ack)。张三看到李四微笑后确认了李四成功辨认出了自己(进入estalished状态)。

但是李四还有点狐疑，向四周看了一看，有没有可能张三是在看别人呢，他也需要确认一下。所以李四也向张三招了招手(syn)，张三看到李四向自己招手后知道对方是在寻求自己的确认，于是也点了点头挤出了微笑(ack)，李四看到对方的微笑后确认了张三就是在向自己打招呼(进入established状态)。

于是两人加快步伐，走到了一起，相互拥抱。

![](https://blog.liushigong.cn/static/img/aa313e24d4b3221aae5478838d794e6a.1643a1f3fa6c21b0~tplv-t2oaga2asx-jj-mark_3024_0_0_0_q75.gif)

我们看到这个过程中一共是四个动作，张三招手--李四点头微笑--李四招手--张三点头微笑。其中李四连续进行了2个动作，先是点头微笑(回复对方)，然后再次招手(寻求确认)，实际上可以将这两个动作合一，招手的同时点头和微笑(syn+ack)。于是四个动作就简化成了三个动作，张三招手--李四点头微笑并招手--张三点头微笑。这就是三次握手的本质，中间的一次动作是两个动作的合并。

我们看到有两个中间状态，syn\_sent和syn\_rcvd，这两个状态叫着「半打开」状态，就是向对方招手了，但是还没来得及看到对方的点头微笑。syn\_sent是主动打开方的「半打开」状态，syn\_rcvd是被动打开方的「半打开」状态。客户端是主动打开方，服务器是被动打开方。

* syn\_sent: syn package has been sent
* syn\_rcvd: syn package has been received

## TCP 数据传输

TCP 数据传输就是两个人隔空对话，差了一点距离，所以需要对方反复确认听见了自己的话。

![](https://blog.liushigong.cn/static/img/f09b2dfefaea042df0e35bd8359e05ff.1643a1f92f5af34a~tplv-t2oaga2asx-jj-mark_3024_0_0_0_q75.gif)

张三喊了一句话(data)，李四听见了之后要向张三回复自己听见了(ack)。

如果张三喊了一句，半天没听到李四回复，张三就认为自己的话被大风吹走了，李四没听见，所以需要重新喊话，这就是tcp重传。

也有可能是李四听到了张三的话，但是李四向张三的回复被大风吹走了，以至于张三没听见李四的回复。张三并不能判断究竟是自己的话被大风吹走了还是李四的回复被大风吹走了，张三也不用管，重传一下就是。

既然会重传，李四就有可能同一句话听见了两次，这就是「去重」。「重传」和「去重」工作操作系统的网络内核模块都已经帮我们处理好了，用户层是不用关心的。

![](https://blog.liushigong.cn/static/img/b09fee656f7345e061de2278358a6e10.1643a1fc9435605c~tplv-t2oaga2asx-jj-mark_3024_0_0_0_q75.gif)

张三可以向李四喊话，同样李四也可以向张三喊话，因为tcp链接是「双工的」，双方都可以主动发起数据传输。不过无论是哪方喊话，都需要收到对方的确认才能认为对方收到了自己的喊话。

张三可能是个高射炮，一说连说了八句话，这时候李四可以不用一句一句回复，而是连续听了这八句话之后，一起向对方回复说前面你说的八句话我都听见了，这就是批量ack。但是张三也不能一次性说了太多话，李四的脑子短时间可能无法消化太多，两人之间需要有协商好的合适的发送和接受速率，这个就是「TCP窗口大小」。

网络环境的数据交互同人类之间的对话还要复杂一些，它存在数据包乱序的现象。同一个来源发出来的不同数据包在「网际路由」上可能会走过不同的路径，最终达到同一个地方时，顺序就不一样了。操作系统的网络内核模块会负责对数据包进行排序，到用户层时顺序就已经完全一致了。

## TCP 四次挥手

TCP断开链接的过程和建立链接的过程比较类似，只不过中间的两部并不总是会合成一步走，所以它分成了4个动作，张三挥手(fin)——李四伤感地微笑(ack)——李四挥手(fin)——张三伤感地微笑(ack)。

![](https://blog.liushigong.cn/static/img/c566c0e0416366d895388ec8f99333b8.1643a20296de1ff0~tplv-t2oaga2asx-jj-mark_3024_0_0_0_q75.gif)

之所以中间的两个动作没有合并，是因为tcp存在「半关闭」状态，也就是单向关闭。张三已经挥了手，可是人还没有走，只是不再说话，但是耳朵还是可以继续听，李四呢继续喊话。等待李四累了，也不再说话了，朝张三挥了挥手，张三伤感地微笑了一下，才彻底结束了。

![](https://blog.liushigong.cn/static/img/016314f80f3dae1e76641299731c4db9.1643b1147fbbc5e7~tplv-t2oaga2asx-jj-mark_3024_0_0_0_q75.gif)

上面有一个非常特殊的状态 `time_wait`，它是主动关闭的一方在回复完对方的挥手后进入的一个长期状态，这个状态标准的持续时间是4分钟，4分钟后才会进入到closed状态，释放套接字资源。不过在具体实现上这个时间是可以调整的。

它就好比主动分手方要承担的责任，是你提出的要分手，你得付出代价。这个后果就是持续4分钟的 `time_wait` 状态，不能释放套接字资源(端口)，就好比守寡期，这段时间内套接字资源(端口)不得回收利用。

它的作用是重传最后一个ack报文，确保对方可以收到。因为如果对方没有收到ack的话，会重传fin报文，处于time\_wait状态的套接字会立即向对方重发ack报文。

同时在这段时间内，该链接在对话期间于网际路由上产生的残留报文(因为路径过于崎岖，数据报文走的时间太长，重传的报文都收到了，原始报文还在路上)传过来时，都会被立即丢弃掉。4分钟的时间足以使得这些残留报文彻底消逝。不然当新的端口被重复利用时，这些残留报文可能会干扰新的链接。

4分钟就是2个MSL，每个MSL是2分钟。MSL就是 `maximium segment lifetime` ——最长报文寿命。这个时间是由官方RFC协议规定的。至于为什么是2个MSL而不是1个MSL，我还没有看到一个非常满意的解释。

四次挥手也并不总是四次挥手，中间的两个动作有时候是可以合并一起进行的，这个时候就成了三次挥手，主动关闭方就会从 `fin_wait_1` 状态直接进入到 `time_wait` 状态，跳过了 `fin_wait_2` 状态。

## 总结

TCP状态转换是一个非常复杂的过程，本文仅对一些简单的基础知识点进行了类比讲解。关于TCP的更多知识还需要读者去搜寻相关技术文章进入深入学习。如果读者对TCP的基础知识掌握得比较牢固，高级的知识理解起来就不会太过于吃力。

网络编程 - 跟着动画来学习TCP三次握手和四次挥手

日常开发中使用Map时经常会遇到很多复杂的处理场景，例如：多个键的Map、不仅可以根据键获取值也可以根据值获取键且不用遍历、重复键的Map、数字等范围内映射相同的值、内存中缓存对象等，Guava提供了以上场景的解决方案。

## 实现

根据不同的场景，使用不用的解决方案

| 场景 | 解决方案 | 具体实现 |
| --- | --- | --- |
| 多个键的Map | Table | HashBasedTable、TreeBasedTable、ImmutableTable |
| 不仅可以根据键获取值也可以根据值获取键且不用遍历 | BiMap | HashBiMap、ImmutableBiMap |
| 重复键的Map | Multimap | ArrayListMultimap、LinkedListMultimap、LinkedHashMultimap、ImmutableListMultimap、ImmutableSetMultimap |
| 数字等范围内映射相同的值 | RangeMap | TreeRangeMap、ImmutableRangeMap |
| 内存中缓存对象 | ClassToInstanceMap | MutableClassToInstanceMap、ImmutableClassToInstanceMap |

## 依赖

截止到今年最新的依赖包版本是 `33.4.6-jre`，很多人不知道如何找maven依赖，提供个[官方仓库地址](https://mvnrepository.com/) `https://mvnrepository.com/`

```
xml


<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.4.6-jre</version>
</dependency>
```

## 示例

以下为具体使用的 Demo

### Table

官方注释翻译：将一对有序键（称为行键和列键）与单个值相关联的集合。

```
java

// HashMap
Map<String, Integer> deptMap = new HashMap<>();
deptMap.put("A部门", 10);
deptMap.put("B部门", 20);
Map<String, Map<String, Integer>> companyMap = new HashMap<>();
companyMap.put("xx公司", deptMap);
// HashMap 获取值
Integer val = companyMap.get("xx公司").get("A部门");
System.out.println("HashMap 获取值: " + val);

// 创建Hash类型Table, 基于Hash表实现
// Table<R, C, V>中三个泛型: R-行, C-列, V-值
Table<String, String, Integer> hashTable = HashBasedTable.create();
hashTable.put("xx公司", "A部门", 10);
hashTable.put("xx公司", "B部门", 20);
hashTable.put("xx公司", "C部门", 30);

System.out.println("\nHash Table: " + hashTable);

// 创建Tree类型Table, 基于红黑树实现
Table<String, String, Integer> treeTable = TreeBasedTable.create();
treeTable.put("xx公司", "C部门", 30);
treeTable.put("xx公司", "B部门", 20);
treeTable.put("xx公司", "A部门", 10);

System.out.println("\nTree Table: " + treeTable);

// 创建不可变Table, 无法新增、更新或删除
Table<String, String, Integer> immutableTable = ImmutableTable.<String, String, Integer>builder()
        .put("xx公司", "C部门", 30)
        .put("xx公司", "B部门", 20)
        .put("xx公司", "A部门", 10)
        .build();

System.out.println("\nImmutable Table: " + immutableTable);

// Table 获取值
Integer val2 = hashTable.get("xx公司", "A部门");
System.out.println("\nTable 获取值: " + val2);

// Table 删除值
Integer remove = hashTable.remove("xx公司", "C部门");
System.out.println("\nTable 删除值: " + remove);

// 根据行获取列和值映射
Map<String, Integer> columnvalueMap = hashTable.row("xx公司");
System.out.println("\nTable 列和值 映射: " + columnvalueMap);

// 根据列获取行和值映射
Map<String, Integer> rowvalueMap = hashTable.column("A部门");
System.out.println("\nTable 行和值 映射: " + rowvalueMap);

// 获取key集合
Set<String> rowKeySet = hashTable.rowKeySet();
System.out.println("\nTable Row key 集合: " + rowKeySet);
Set<String> columnKeySet = hashTable.columnKeySet();
System.out.println("\nTable Column key 集合: " + columnKeySet);

// 获取值集合
Collection<Integer> values = hashTable.values();
System.out.println("\nTable 值集合: " + values);

// 判断包含行
boolean containsRow = hashTable.containsRow("xx公司");
System.out.println("\nTable 包含行: " + containsRow);

// 判断包含列
boolean containsColumn = hashTable.containsColumn("A部门");
System.out.println("\nTable 包含列: " + containsColumn);

// 判断包含行和列
boolean contains = hashTable.contains("xx公司", "A部门");
System.out.println("\nTable 包含行和列: " + contains);

// 判断包含值
boolean containsValue = hashTable.containsValue(10);
System.out.println("\nTable 包含值: " + containsValue);

// 行和列转置 - 行 转 列
Table<String, String, Integer> transposeTable = Tables.transpose(hashTable);

// 获取所有的行
Set<Table.Cell<String, String, Integer>> cells = transposeTable.cellSet();

// 遍历输出
System.out.println("\n遍历输出开始----------------------------");
cells.forEach(cell -> System.out.println(cell.getRowKey() + ", " + cell.getColumnKey() + ", " + cell.getValue()));
System.out.println("\n遍历输出结束----------------------------");

// 转换为嵌套的Map
Map<String, Map<String, Integer>> rowMap = hashTable.rowMap();
System.out.println("\nTable RowMap: " + rowMap);
Map<String, Map<String, Integer>> columnMap = hashTable.columnMap();
System.out.println("\nTable ColumnMap: " + columnMap);
```

输出结果

![image.png](https://blog.liushigong.cn/static/img/8f932973adc45ebbb7b86e276c915055.image.webp)

### BiMap

双映射（或“双向映射”）是一种保留其值及其键的唯一性的映射。此约束使双映射能够支持“反向视图”，即另一个双映射，其中包含与此双映射相同的条目，但具有相反的键和值。

```
java

//创建BiMap, 底层为两个Hash表的Map
BiMap<Integer, String> biMap = HashBiMap.create();
biMap.put(1, "one");
biMap.put(2, "two");
biMap.put(3, "three");
biMap.put(4, "four");
biMap.put(5, "five");

System.out.println("BiMap: " + biMap);

//创建不可变BiMap, 无法新增、更新或删除
BiMap<Object, Object> immutableBiMap = ImmutableBiMap.builder().put(1, "one").put(2, "two").put(3, "three").put(4, "four").put(5, "five").build();

System.out.println("\nImmutable BiMap: " + immutableBiMap);

//通过key获取value
String value = biMap.get(1);
System.out.println("\nBiMap 根据key获取value: " + value);

Integer key = biMap.inverse().get("one");
System.out.println("\nBiMap 根据value获取key: " + key);

//翻转后修改
biMap.inverse().put("six", 6);
//返回双映射的逆视图, 并没有创建新对象, 还是之前的对象, 所以操作翻转后的BiMap会影响之前的BiMap
System.out.println("\nBiMap 被影响: " + biMap);

//底层是HashMap, key不可重复
//value不可重复
try {
    biMap.put(11, "one");
} catch (Exception e) {
    System.err.println("BiMap 替换value异常: " + e.getMessage());
}

//翻转后key不能重复
try {
    biMap.inverse().put("first", 1);
} catch (Exception e) {
    System.err.println("BiMap 替换key异常: " + e.getMessage());
}

//key和value可为null
biMap.put(null, null);
System.out.println("\nBiMap 根据Null key获取Null value: " + biMap.get(null));
System.out.println("\nBiMap 根据Null value获取Null key: " + biMap.inverse().get(null));

//强制替换key
biMap.forcePut(11, "one");
System.out.println("\nBiMap 获取新key: " + biMap.inverse().get("one"));

//values为Set集合
Set<String> values = biMap.values();
System.out.println("\nBiMap 不重复的value: " + values);
```

输出结果

![image.png](https://blog.liushigong.cn/static/img/4085eecb9e7275d6d4e20e57b7ed4781.image.webp)

### Multimap

将键映射到值的集合，类似于 Map，但其中每个键可能与多个值相关联。

```
java

// 创建Multimap, key为HashMap, value为ArrayList
Multimap<String, Integer> arrayListMultimap = ArrayListMultimap.create();
arrayListMultimap.put("张三", 90);
arrayListMultimap.put("张三", 80);
arrayListMultimap.put("张三", 100);
arrayListMultimap.put("李四", 88);

System.out.println("Multimap key为HashMap, value为ArrayList: " + arrayListMultimap);

// 创建Multimap, key为HashMap, value为HashSet
Multimap<String, Integer> hashMultimap = HashMultimap.create();
hashMultimap.put("张三", 90);
hashMultimap.put("张三", 80);
hashMultimap.put("张三", 100);
hashMultimap.put("李四", 88);

System.out.println("Multimap key为HashMap, value为HashSet: " + hashMultimap);

// 创建Multimap, key为LinkedHashMap, value为LinkedList
Multimap<String, Integer> linkedListMultimap = LinkedListMultimap.create();
linkedListMultimap.put("张三", 90);
linkedListMultimap.put("张三", 80);
linkedListMultimap.put("张三", 100);
linkedListMultimap.put("李四", 88);

System.out.println("Multimap key为LinkedHashMap, value为LinkedList: " + linkedListMultimap);

// 创建Multimap, key为LinkedHashMap, value为LinkedHashMap
Multimap<String, Integer> linkedHashMultimap = LinkedHashMultimap.create();
linkedHashMultimap.put("张三", 90);
linkedHashMultimap.put("张三", 80);
linkedHashMultimap.put("张三", 100);
linkedHashMultimap.put("李四", 88);

System.out.println("Multimap key为LinkedHashMap, value为LinkedHashMap: " + linkedHashMultimap);

// 创建Multimap, key为TreeMap, value为TreeSet
Multimap<String, Integer> treeMultimap = TreeMultimap.create();
treeMultimap.put("张三", 90);
treeMultimap.put("张三", 80);
treeMultimap.put("张三", 100);
treeMultimap.put("李四", 88);

System.out.println("Multimap key为TreeMap, value为TreeSet: " + treeMultimap);

// 创建不可变Multimap, 无法新增、更新或删除, key为ImmutableMap, value为ImmutableList
Multimap<String, Integer> immutableListMultimap = ImmutableListMultimap.<String, Integer>builder()
        .put("张三", 90)
        .put("张三", 80)
        .put("张三", 100)
        .put("李四", 88)
        .build();

System.out.println("Multimap key为ImmutableMap, value为ImmutableList: " + immutableListMultimap);

// 创建不可变Multimap, 无法新增、更新或删除, key为ImmutableMap, value为ImmutableSet
Multimap<String, Integer> immutableSetMultimap = ImmutableSetMultimap.<String, Integer>builder()
        .put("张三", 90)
        .put("张三", 80)
        .put("张三", 100)
        .put("李四", 88)
        .build();

System.out.println("Multimap key为ImmutableMap, value为ImmutableSet: " + immutableSetMultimap);

// 获取值
Collection<Integer> values = arrayListMultimap.get("张三");
System.out.println("Multimap 获取值集合: " + values);

// 获取不存在key的值, 返回的是空集合, 而不是null
Collection<Integer> valuesByNotExistsKey = arrayListMultimap.get("王五");
System.out.println("Multimap 获取不存在的Key值集合: " + valuesByNotExistsKey);

// 获取值集合添加值
// 返回的是多重映射中关联的值的视图集合, 并没有创建新对象, 还是之前的对象, 所以操作值集合会影响之前的Multimap
values.add(60);
System.out.println("Multimap 被影响: " + arrayListMultimap);

// 获取大小
System.out.println("Multimap 大小:" + arrayListMultimap.size());

// 判断是否为空
System.out.println("Multimap 是否为空: " + arrayListMultimap.isEmpty());

// 包含key
System.out.println("Multimap 包含key: " + arrayListMultimap.containsKey("张三"));

// 包含value
System.out.println("Multimap 包含value: " + arrayListMultimap.containsValue(60));

// 包含key-value键值对
System.out.println("Multimap 包含key-value对: " + arrayListMultimap.containsEntry("张三", 60));

// 替换value
arrayListMultimap.replaceValues("张三", Arrays.asList(10, 20, 30));
System.out.println("Multimap 替换value: " + arrayListMultimap);

// 根据key-value删除
arrayListMultimap.remove("张三", 10);
System.out.println("Multimap 根据key-value删除: " + arrayListMultimap);

// 根据key删除
Collection<Integer> removeAll = arrayListMultimap.removeAll("张三");
System.out.println("Multimap 根据key删除: " + removeAll);

// 获取key集合
Set<String> keySet = arrayListMultimap.keySet();
System.out.println("Multimap 获取key集合(HashSet): " + keySet);
Multiset<String> keys = arrayListMultimap.keys();
System.out.println("Multimap 获取key集合(MultiSet): " + keys);

// 获取所有的key-value
Collection<Map.Entry<String, Integer>> entries = arrayListMultimap.entries();
System.out.println("遍历key-value开始--------------------------");
entries.forEach(entry -> System.out.println(entry.getKey() + " : " + entry.getValue()));
System.out.println("遍历key-value结束--------------------------");

// 转换为Map<K, Collection<V>>
Map<String, Collection<Integer>> collectionMap = arrayListMultimap.asMap();
System.out.println("Multimap 转换为Map<K, Collection<V>>: " + collectionMap);
```

输出结果

![image.png](https://blog.liushigong.cn/static/img/510345cdc98e33d2aa226e2ed404b541.image.webp)

### RangeMap

从不相交的非空范围到非 null 值的映射。查询查找与包含指定键的范围（如果有）关联的值。

```
java

// if-else
int score = 88;
String rank;
if (0 <= score && score < 60) {
    rank = "不及格";
} else if (60 <= score && score <= 84) {
    rank = "及格";
} else if (84 < score && score <= 100) {
    rank = "优秀";
} else {
    rank = "无效";
}

System.out.println("if-else 获取值: " + rank);

// 创建RangeMap, 基于TreeMap（红黑树）实现
RangeMap<Integer, String> treeRangeMap = TreeRangeMap.create();
treeRangeMap.put(Range.closedOpen(0, 60), "不及格");
treeRangeMap.put(Range.closed(60, 84), "及格");
treeRangeMap.put(Range.openClosed(84, 100), "优秀");
treeRangeMap.put(Range.lessThan(0), "无效");
treeRangeMap.put(Range.greaterThan(100), "无效");

rank = treeRangeMap.get(score);
System.out.println("RangeMap 获取值: " + rank);

// 创建不可变RangeMap, 无法新增、更新或删除
ImmutableRangeMap<Integer, String> immutableRangeMap = ImmutableRangeMap.<Integer, String>builder()
        .put(Range.closedOpen(0, 60), "不及格")
        .put(Range.closed(60, 84), "及格")
        .put(Range.openClosed(84, 100), "优秀")
        .put(Range.lessThan(0), "无效")
        .put(Range.greaterThan(100), "无效")
        .build();

rank = immutableRangeMap.get(score);
System.out.println("ImmutableRangeMap 获取值: " + rank);

// 获取key-value对
Map.Entry<Range<Integer>, String> entry = treeRangeMap.getEntry(88);
System.out.println("RangeMap 获取key-value对: " + entry.getKey() + " : " + entry.getValue());

// 返回不可变的升序的Map
Map<Range<Integer>, String> asMapOfRanges = treeRangeMap.asMapOfRanges();
System.out.println("RangeMap 不可变的升序的Map: " + asMapOfRanges);

// 返回不可变的降序的Map
Map<Range<Integer>, String> asDescendingMapOfRanges = treeRangeMap.asDescendingMapOfRanges();
System.out.println("RangeMap 不可变的降序的Map: " + asDescendingMapOfRanges);

// 相连范围合并
RangeMap<Integer, String> treeRangeMap2 = TreeRangeMap.create();
treeRangeMap2.putCoalescing(Range.closedOpen(0, 60), "不及格");
treeRangeMap2.putCoalescing(Range.closed(60, 84), "及格");
treeRangeMap2.putCoalescing(Range.openClosed(84, 100), "及格"); // 或者 [60..84]范围合并
treeRangeMap2.putCoalescing(Range.lessThan(0), "无效");
treeRangeMap2.putCoalescing(Range.greaterThan(100), "无效");
System.out.println("RangeMap 不合并相连范围: " + treeRangeMap.asMapOfRanges());
System.out.println("RangeMap 合并相连范围: " + treeRangeMap2.asMapOfRanges());

// 最小范围
Range<Integer> span = treeRangeMap.span();
System.out.println("RangeMap 最小范围: " + span);

// 子范围Map
RangeMap<Integer, String> subRangeMap = treeRangeMap.subRangeMap(Range.closed(70, 90));
System.out.println("RangeMap 子范围Map: " + subRangeMap);

// 合并范围
treeRangeMap.merge(Range.closed(60, 100), "及格", (s, s2) -> s2);
System.out.println("RangeMap 合并Map: " + treeRangeMap);

// 移除范围
treeRangeMap.remove(Range.open(90, 95));
System.out.println("RangeMap 移除范围: " + treeRangeMap);

// 清除所有范围
treeRangeMap.clear();
System.out.println("RangeMap 清除所有范围: " + treeRangeMap);
```

输出结果

![image.png](https://blog.liushigong.cn/static/img/c71f907f9c6ad4edd542dffdfd1c3800.image.webp)

### ClassToInstanceMap

映射，其每个条目将一个 Java 原始类型 映射到该类型的实例。除了实现 Map之外，还提供额外的类型安全操作 putInstance 和 getInstance 。与任何其他 Map<Class, Object>映射一样，此映射可能包含基元类型的条目，并且基元类型及其相应的包装器类型可以映射到不同的值。

```
java

static class UserBean {
    private final Integer id;
    private final String username;

    public UserBean(Integer id, String username) {
        this.id = id;
        this.username = username;
    }

    @Override
    public String toString() {
        return "UserBean{" + "id=" + id + ", username='" + username + '\'' + '}';
    }
}
public static void main(String[] args) {
    // 创建Bean
    UserBean userBean = new UserBean(1, "张三");

    // HashMap
    HashMap<Class, Object> hashMap = new HashMap<>();
    hashMap.put(UserBean.class, userBean);

    // 获取值，需要强转
    UserBean value = (UserBean) hashMap.get(UserBean.class);
    System.out.println("HashMap 获取对象实例: " + value);
    System.out.println("HashMap 获取对象实例等于创建的Bean: " + (value == userBean));

    // 创建ClassToInstanceMap
    ClassToInstanceMap<Object> classToInstanceMap = MutableClassToInstanceMap.create();
    classToInstanceMap.putInstance(UserBean.class, userBean);

    // 获取值，无需强转
    UserBean value2 = classToInstanceMap.getInstance(UserBean.class);
    System.out.println("\nClassToInstanceMap 获取对象实例: " + value2);
    System.out.println("ClassToInstanceMap 获取对象实例等于创建的Bean: " + (value2 == userBean));

    // 创建不可变ClassToInstanceMap, 无法新增、更新或删除
    ClassToInstanceMap<UserBean> immutableClassToInstanceMap = ImmutableClassToInstanceMap.<UserBean>builder()
        .put(UserBean.class, userBean)
        .build();

    // 获取值，无需强转
    UserBean value3 = immutableClassToInstanceMap.getInstance(UserBean.class);
    System.out.println("\nImmutableClassToInstanceMap 获取对象实例: " + value3);
    System.out.println("ImmutableClassToInstanceMap 获取对象实例等于创建的Bean: " + (value3 == userBean));

    // 限制类型，避免使用HashMap存储对象时，因为使用Object值类型而在添加缓存时需要今天类型校验
    ClassToInstanceMap<Collection> classToInstanceMap1 = MutableClassToInstanceMap.create();
    classToInstanceMap1.put(ArrayList.class, new ArrayList());
    classToInstanceMap1.put(HashSet.class, new HashSet());
    // 编译保存: 'put(java.lang.Class<? extends java.util.@org.checkerframework.checker.nullness.qual.NonNull Collection>, java.util.Collection)' in 'com.google.common.collect.MutableClassToInstanceMap' cannot be applied to '(java.lang.Class<java.util.HashMap>, java.util.HashMap)'
    //        classToInstanceMap1.put(HashMap.class, new HashMap());
}
```

输出结果

![image.png](https://blog.liushigong.cn/static/img/196274a8601760add8f03875a4b66478.image.webp)

Guava - Map增强工具类

作为Java开发者，我们常关注代码逻辑和功能实现，但高并发下的性能瓶颈才是线上系统的“隐形杀手”。JMeter作为Apache开源压测工具，能模拟海量用户请求，帮助我们发现：

* 接口响应时间延迟
* 数据库连接池耗尽
* 线程阻塞、内存泄漏
* 微服务链路雪崩效应

## JMeter核心概念速览

### 测试计划(Test Plan)

压测的顶层容器，可添加线程组、监听器等组件。

### 线程组(Thread Group)

模拟并发用户的核心单元，关键参数：

* 线程数（模拟用户数）
* Ramp-Up时间（用户启动间隔，秒）
* 循环次数（每个用户执行次数）

![image.png](https://blog.liushigong.cn/static/img/ebf49832360e3478b6cfd8a20fafb61d.image.webp)

### 采样器(Sampler)

支持HTTP、JDBC、JMS、Java请求等协议，Java开发者常用：

* HTTP Request：测试RESTful API
* JDBC Request：压测数据库性能
* Java Request：直接调用Java方法（需集成JMeter插件）

![image.png](https://blog.liushigong.cn/static/img/d2aa9965642c5f12042c71d2a852aef0.image.webp)

![image.png](https://blog.liushigong.cn/static/img/c38e3648afa278c39cee1a00ad0b0b7f.image.webp)

### 监听器(Listener)

收集结果的组件，推荐：

* 聚合报告(Aggregate Report)：TPS、响应时间统计
* 响应时间图(Response Time Graph)：可视化波动
* 后端监听器(Backend Listener)：实时输出结果到InfluxDB+Grafana

![image.png](https://blog.liushigong.cn/static/img/9555425121f588c5379725a9ed77dfdb.image.webp)

![image.png](https://blog.liushigong.cn/static/img/acb55f12289c083f2e634f439a5471a8.image.webp)

## 实战：压测Spring Boot API

场景：测试 /api/users 接口的QPS（每秒查询率）

### 执行步骤

![deepseek_mermaid_20250615_3e69d5.png](https://blog.liushigong.cn/static/img/938b480ac18e4632fed81a689c227eeb.deepseek_mermaid_20250615_3e69d5.webp)

### 关键配置

![image.png](https://blog.liushigong.cn/static/img/d593a0dfbbf17f3a984441492b580eb1.image.webp)

HTTP请求路径：<http://localhost:8080/api/users>

请求头：Content-Type: application/json

请求体（JSON）：

```
json

{ "page": 1, "size": 10 }
```

![image.png](https://blog.liushigong.cn/static/img/e3ccb467790c9729a87c2bc95b546070.image.webp)

断言：响应状态码200，响应时间<500ms

![image.png](https://blog.liushigong.cn/static/img/c6770bdb355a20a03609d61823658abe.image.webp)

## 分布式压测（提升并发能力）

在使用Jmeter进行性能测试时，如果并发数比较大(比如项目需要支持1000并发)，单台主机的配置(CPU和内存)可能无法支持，这时可以使用Jmeter提供的分布式测试的功能。

### 执行原理

![image.png](https://blog.liushigong.cn/static/img/967c66a8adf0effcd6c3ec8421ff6f8d.image.webp)

Jmeter分布式测试时，本地jmeter作为控制机(master)，其它机器做为执行机(slave)。执行时，master会把脚本发送到每台slave上，slave 拿到脚本后就开始执行。执行完成后，slave会把结果回传给master，master会收集所有slave的信息并汇总。

### 配置

#### 控制机(master)配置

修改apache-jmeter-5.1.1\bin目录里的jmeter.properties文件，在260行新增remote\_hosts配置，配置里配置的是两台slave主机的ip和slave主机里安装的jmeter的端口号。

![image.png](https://blog.liushigong.cn/static/img/03c648f0603bf4b0bf4b3585ba88d5f9.image.webp)

#### 执行机（slave）配置

解压jdk和jmeter后，配置环境变量

![image.png](https://blog.liushigong.cn/static/img/b34c17576b4d728de72217a43cd40ede.image.webp)

![image.png](https://blog.liushigong.cn/static/img/5c016bb2fc6614ab3bee1a22711fd159.image.webp)

```
bash

#java环境变量export JAVA_HOME=/software/jdk1.8.0_131/export 

PATH=$JAVA_HOME/bin:$PATHexport
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

#jmeter环境变量expor 

JMETER_HOME=/software/apache-jmeter-5.1.1export 
CLASSPATH=$JMETER_HOME/lib/ext/ApacheJMeter_core.jar:$JMETER_HOME/lib/jorphan.jar:$JMETER_HOME/lib/logkit-2.0.jar:$CLASSPATHexport PATH=$JMETER_HOME/bin/:$PATH
```

修改jmeter部分配置，打开/ apache-jmeter-5.1.1/bin目录

（1）修改jmeter.properties文件

![image.png](https://blog.liushigong.cn/static/img/9c77579d046ba37b41ab9c2ce53e5d68.image.webp)

```
sh

#ip是这台slave主机的ip
remote_hosts=192.168.0.132 

#端口号是jmeter自定义的端口号，默认是1099
server_port=1098
```

注意

该remote\_hosts和server\_port配置需要和本地master的jmeter.properties文件里新增的260行配置一致。

![image.png](https://blog.liushigong.cn/static/img/240f5bde4078c82bd5e9a45c2a5587ae.image.webp)

```
sh

server.rmi.localport=1098
```

![image.png](https://blog.liushigong.cn/static/img/3f04a330484de40019ce57e31272680b.image.webp)

```
sh

# ssl 设置为 true，否则远程执行，会报一个ssl错误
server.rmi.ssl.disable ＝ true
```

![image.png](https://blog.liushigong.cn/static/img/2c73ad86de04f1b5e683010bb0e30e1d.image.webp)

```
sh

#防止响应回来的数据有中文乱码
jmeter.save.saveservice.response_data=true 
jmeter.save.saveservice.samplerData=true
```

（2）修改jmeter-server文件

![image.png](https://blog.liushigong.cn/static/img/1c6221281ee198d0877688d4bf8a8fd3.image.webp)

```
sh

# 配置这台slave主机的ip
RMI_HOST_DEF=-Djava.rmi.server.hostname=192.168.0.132
```

配置完成以后， 启动各个slave上的jmeter

```
bash

# 控制机执行（分发任务）
jmeter -n -t test.jmx -R 192.168.1.101,192.168.1.102

# 压力机启动Agent
jmeter-server -Djava.rmi.server.hostname=192.168.1.101
```

### 执行测试

本地远程连接slave主机上的jmeter，并执行脚本（有两种启动方式）

![image.png](https://blog.liushigong.cn/static/img/d31162df86d469108e04cece356c67fe.image.webp)

例如：本地jmeter脚本是往数据库里添加随机数据，循环20次。

![image.png](https://blog.liushigong.cn/static/img/5556e729f22364e7b4570503594fd98c.image.webp)

## 结果分析技巧

### 核心指标解读

| 指标 | 健康值 | 说明 |
| --- | --- | --- |
| TPS | >100 (根据业务调整) | 每秒处理请求数 |
| Avg Response Time | <300ms | 平均响应时间 |
| Error % | 0% | 请求失败率 |
| 90th Percentile | <800ms | 90%请求的响应时间上限 |

### 典型性能瓶颈定位

* TPS低 + CPU占用高 → Java代码效率问题（如算法优化）
* TPS低 + DB CPU高 → SQL慢查询（需EXPLAIN分析）
* 错误率突增 → 线程池满/连接超时（调整资源池配置）

### 分析技巧指南

除了关注平均响应时间 → 还应监控90/95百分位数

将压测环境配置与生产一致 → 确保JVM参数、DB配置同步

关注垃圾回收日志 → 添加JVM参数：`-XX:+PrintGCDetails -Xloggc:gc.log`

## 总结

JMeter是Java开发者性
能优化的“显微镜”。通过科学压测+结果分析，我们不仅能预防系统崩溃，更能精准定位代码层缺陷。

记住：没有压测的性能优化，如同盲人摸象！

性能分析 - JMeter 压测

通常，本地开发环境无法访问生产环境。如果在生产环境中遇到问题，则无法使用 IDE 远程调试。更糟糕的是，在生产环境中调试是不可接受的，因为它会暂停所有线程，导致服务暂停。

开发人员可以尝试在测试环境或者预发环境中复现生产环境中的问题。但是，某些问题无法在不同的环境中轻松复现，甚至在重新启动后就消失了。

如果您正在考虑在代码中添加一些日志以帮助解决问题，您将必须经历以下阶段：测试、预发，然后生产。这种方法效率低下，更糟糕的是，该问题可能无法解决，因为一旦 JVM 重新启动，它可能无法复现，如上文所述。

Arthas 旨在解决这些问题。开发人员可以在线解决生产问题。无需 JVM 重启，无需代码更改。 Arthas 作为观察者永远不会暂停正在运行的线程。

## Arthas

Arthas 是 Alibaba 开源的 Java 诊断工具，深受开发者喜爱。

当你遇到以下类似问题而束手无策时，Arthas可以帮助你解决：

* 这个类从哪个 jar 包加载的？为什么会报各种类相关的 Exception？
* 我改的代码为什么没有执行到？难道是我没 commit？分支搞错了？
* 遇到问题无法在线上 debug，难道只能通过加日志再重新发布吗？
* 线上遇到某个用户的数据处理有问题，但线上同样无法 debug，线下无法重现！
* 是否有一个全局视角来查看系统的运行状况？
* 有什么办法可以监控到 JVM 的实时运行状态？
* 怎么快速定位应用的热点，生成火焰图？
* 怎样直接从 JVM 内查找某个类的实例？

Arthas 支持 JDK 6+（4.x 版本不再支持 JDK 6 和 JDK 7），支持 Linux/Mac/Windows，采用命令行交互模式，同时提供丰富的 Tab 自动补全功能，进一步方便进行问题的定位和诊断。

官方文档：<https://arthas.aliyun.com/doc/quick-start.html>

### 下载和安装

#### 使用arthas-boot（推荐）

下载arthas-boot.jar，然后用java -jar的方式启动：

```
sh

curl -O https://arthas.aliyun.com/arthas-boot.jar
java -jar arthas-boot.jar
```

### 使用as.sh

Arthas 支持在 Linux/Unix/Mac 等平台上一键安装，请复制以下内容，并粘贴到命令行中，敲 回车 执行即可：

```
sh

curl -L https://arthas.aliyun.com/install.sh | sh
```

上述命令会下载启动脚本文件 as.sh 到当前目录，你可以放在任何地方或将其加入到 $PATH 中。

直接在 shell 下面执行./as.sh，就会进入交互界面。

也可以执行./as.sh -h来获取更多参数信息。

### 快速入门

1、直接java -jar arthas-boot.jar。选择attach的进程绑定

一般是出现arthas的这种，就是进入了想要监控的进程中

![image.png](https://blog.liushigong.cn/static/img/275c3330972872b096deb2b656aa5c08.image.webp)

### 常用命令与功能

#### Dashboard

注意在arthas中，有tab键填充功能，所以比较好用。但是这个界面是实时刷新的，一般5s刷新一次，使用q键退出刷新（没有退出arthasq）

![image.png](https://blog.liushigong.cn/static/img/57c9cc60268425eb45768b24ed773459.image.webp)

#### Thread

这个命令和jstack很相似，但是功能更加强大，主要是查看当前JVM的线程堆栈信息

同时可以结合使用thread –b 来进行死锁的排查死锁。

参数解释：

* `-n` 指定最忙的前n个线程并打印堆栈
* `-b` 找出阻塞当前线程的线程
* `-i` 指定cpu占比统计的采样间隔，单位为毫秒

**thread – b  找出阻塞当前线程的线程**

![image.png](https://blog.liushigong.cn/static/img/e4afbd09ba3311a79bc16b4008819f50.image.webp)

**thread -i 1000 -n 3 每过1000毫秒进行采样，显示最占CPU时间的前3个线程**

![image.png](https://blog.liushigong.cn/static/img/624d07b866490a567b54bcea29fe7244.image.webp)

**thread --state WAITING 查看处于等待状态的线程**

![image.png](https://blog.liushigong.cn/static/img/c5bd59db58af1389d99e75a6dd9a8f0f.image.webp)

#### JVM

显示当前JVM的进程信息

![image.png](https://blog.liushigong.cn/static/img/277457282c3fbea914fd48a72d7bbe56.image.webp)

#### **Jad**

反编译指定已加载类的源码

![image.png](https://blog.liushigong.cn/static/img/da90e6c69d639944b9bb840919557f79.image.webp)

#### trace

使用 **trace** 命令可以跟踪统计方法耗时

![image.png](https://blog.liushigong.cn/static/img/0e711258fff85d5d424122bbb4b27f66.image.webp)

比如使用一个Springboot 项目控制层 getUser 方法调用了 userService.get(uid);，这个方法中分别进行check、service、redis、mysql等操作操作。就可以根据这个命令跟踪出来哪里的耗时最长。

#### monitor

监控方法的执行情况

每5秒统计一次cn.enjoyedu.demo.controller.DemoController类的test方法执行情况

![image.png](https://blog.liushigong.cn/static/img/f8825580aa0d75ab47f757aedbbd684f.image.webp)

#### watch

观察方法的入参出参信息

查看入参和出参

```
sh

watch  cn.enjoyedu.demo.controller.DemoController test '{params[0],returnObj}'
```

![image.png](https://blog.liushigong.cn/static/img/8372e33db7c7d0b882f77d2751bbfe22.image.webp)

![image.png](https://blog.liushigong.cn/static/img/aecab5587b2d5914d2688339f7380405.image.webp)

![image.png](https://blog.liushigong.cn/static/img/66cfcdcd301095b18b5762ceb3d28714.image.webp)

### idea 插件

在 idea 插件中搜索 arthas

![image.png](https://blog.liushigong.cn/static/img/1d22c180803b12825e37d71f62bfd316.image.webp)

鼠标指针聚焦在方法上，右键选中 `Arthas Command` 后根据想要操作的命令，可基于当前方法自动生成，也可直接选中指令，会自动将命令复制到剪贴板，随时使用

![image.png](https://blog.liushigong.cn/static/img/f8907ff941e8f5088b8af10addc1e21f.image.webp)

![image.png](https://blog.liushigong.cn/static/img/c6433ec7d7a801ebadfa85c1cfa1d7ba.image.webp)

### 命令汇总

| **命令** | **介绍** |
| --- | --- |
| dashboard | 当前系统的实时数据面板 |
| thread | 查看当前JVM的线程堆栈信息 |
| watch | 方法执行数据观测 |
| trace | 方法内部调用路径，并输出方法路径上的每个节点上耗时 |
| stack | 输出当前方法被调用的调用路径 |
| tt | 方法执行数据的时空隧道，记录下指定方法每次调用的入参和返回信息，并能对这些不同的时间下调用进行观测 |
| monitor | 方法执行监控 |
| jvm | 查看当前JVM信息 |
| vmoption | 查看，更新JVM诊断相关的参数 |
| sc | 查看JVM已加载的类信息 |
| sm | 查看已加载类的方法信息 |
| jad | 反编译指定已加载类的源码 |
| classloader | 查看classloader的继承树，urls，类加载信息 |
| heapdump | 类似jmap命令的 heap dump 功能 |

性能分析 - 诊断工具 Arthas

对于 `SkyWalking` 、`Zipkin`、`Arthas` 来说都是无侵入式的组件，你是否有思考过其底层是如何实现？今天让我们了解下 **动态追踪技术的底层分析**

动态追踪技术是一个可以不用重启线上java项目来进行问题排查的技术，比如前面讲的 `Arthas` 就属于一种动态追踪的工具。Arthas里面提供的**monitor**还有**watch**等命令就是动态的追踪技术。

当然我们学技术要知其然还要知其所以然，Arthas工具的基础，就是 Java Agent 技术，可以利用它来构建一个附加的代理程序，用来协助检测性能，还可以替换一些现有功能，甚至 JDK 的一些类我们也能修改，有点像 JVM 级别的 AOP 功能。

## Java Agent 技术

既然作为JVM的AOP，就必须要有AOP的功能，所以Java Agent提供了两个类似于AOP的方法：

* 一个方法叫做premain方法，可以在main 运行之前的进行一些操作(Java 入口是一个 main 方法)
* 一个是agentmain方法，是控制类运行时的行为（Arthas使用的就是这种）

但在一个JVM 中，只会调用一个

### premain

#### 演示案例

javaagent-demo

![image.png](https://blog.liushigong.cn/static/img/6919d21fbcac568dd16354195a6b282f.image.webp)

![image.png](https://blog.liushigong.cn/static/img/5a05a73ec3c0405b29ea96c119f67d58.image.webp)

打包生成agent包，然后放入英文目录下

![image.png](https://blog.liushigong.cn/static/img/f058141b7887475efe2c7b8fd39fc44a.image.webp)

运行另外 一个项目，然后在VM参数加入jar的配置。

![image.png](https://blog.liushigong.cn/static/img/7b534aba37d32cfbe8a8f23e0158b2ca.image.webp)

看到修改后的效果。

![image.png](https://blog.liushigong.cn/static/img/bacd0903644d1cb31c0f6f57e0c6acf0.image.webp)

### agentmain

具体javaagent-demo

这种模式一般用在一些诊断工具上（arthas之类的）。使用jdk/lib/tools.jar 中的工具类中的Attach API，可以动态的为运行中的程序加入一些功能。它的主要运行步骤如下：

* 获取机器上运行的所有JVM 进程 ID；
* 选择要诊断的jvm；
* 将jvm 使用 attach 函数链接上；
* 使用loadAgent 函数加载 agent，动态修改字节码；
* 卸载jvm。

#### 演示案例

Attach API 不是 Java 的标准 API，而是 Sun 公司提供的一套扩展 API，用来向目标 JVM ”附着”（Attach）代理工具程序的。有了它，开发者可以方便的监控一个 JVM，运行一个外加的代理程序。Attach API只有 2 个主要的类，都在 com.sun.tools.attach 包(在jdk的lib目录下tools.jar里面)里面：

VirtualMachine 代表一个 Java 虚拟机，也就是程序需要监控的目标虚拟机，提供了 JVM 枚举，Attach 动作和 Detach 动作（Attach 动作的相反行为，从 JVM 上面解除一个代理）等等 ;

VirtualMachineDescriptor 则是一个描述虚拟机的容器类，配合 VirtualMachine 类完成各种功能。

Java Attach API是一个API接口，JDK提供的，它可以将应用程序连接到另一个目标虚拟机。然后，您的应用程序可以将代理应用程序装入目标虚拟机，例如，用于执行监视状态之类的任务。

JVM Attach API功能上非常简单，主要功能如下

* Attach到其中一个JVM上，建立通信管道
* 让目标JVM加载Agent

![image.png](https://blog.liushigong.cn/static/img/8ea81ce539d44a0abcd20da8e72b5a55.image.webp)

下面的代码的主要功能是：

1. 列出当前所有正在运行的 JVM 实例。
2. 查找显示名称以 "MainRun" 结尾的 JVM 实例。
3. 连接到该 JVM 实例并获取其 Java 版本信息。
4. 打印出该版本信息，然后断开连接。

![image.png](https://blog.liushigong.cn/static/img/0d9de84b89a0729cafa319777bebb257.image.webp)

![image.png](https://blog.liushigong.cn/static/img/66c63b876a1169d6bf0d56ed9ae31d34.image.webp)

![image.png](https://blog.liushigong.cn/static/img/bbf474e9a131b1f008ddbe7301e38a13.image.webp)

## 借助Btrace手写动态追踪框架

#### BTrace是什么

BTrace是基于Java语言的一个安全的、可提供动态追踪服务的工具。

BTrace基于ASM、Java Attach API、Instrument开发，为用户提供了很多注解。依靠这些注解，我们可以编写BTrace脚本（简单的Java代码）达到我们想要的效果，而不必深陷于ASM对字节码的操作中不可自拔。

BTrace和Arthas都是用于Java应用程序的动态监控和调试工具，但它们的设计目标和实现方式有所不同：

### BTrace与Arthas的关系

* **互补性**：BTrace和Arthas可以视为互补的工具。BTrace适合于需要在特定场景下插桩追踪的情况，而Arthas则适合于实时监控和快速诊断。
* **使用场景**：在需要进行深入的性能分析或特定方法的追踪时，可以使用BTrace。而在需要快速定位问题或进行实时监控时，Arthas则是更好的选择。
* **技术基础**：两者都基于Java的动态代理和字节码操作，但实现细节和使用方式不同。

总之，BTrace和Arthas都是强大的Java工具，开发者可以根据具体需求选择使用其中一个或两个工具来帮助调试和监控Java应用程序。

#### BTrace配置

首先要下载btrace的压缩包，并解压，

![image.png](https://blog.liushigong.cn/static/img/66018f011d10679af4ea69de762005f3.image.webp)

配置环境变量

path变量新增

![image.png](https://blog.liushigong.cn/static/img/cad7244e2749da189b455b308b46b145.image.webp)

![image.png](https://blog.liushigong.cn/static/img/f3511fd6b6372c02a78081282c3f4bf9.image.webp)

打开CMD命令行，输入btrace出现帮助及配置成功

![image.png](https://blog.liushigong.cn/static/img/ebbdca38b1dbd16ed1763793e1615026.image.webp)

### 实战案例

#### 前置准备

1、准备一个springboot的工程，写一个controller。

![image.png](https://blog.liushigong.cn/static/img/b7e9b5543e1d550c06429513c1b572f6.image.webp)

2、写几个动态追踪框架的类（一般是单独的项目，这里简化放一起）

项目中引入需要引入几个jar包的依赖

![image.png](https://blog.liushigong.cn/static/img/15a50fc1481fcac36984a3c0c95ee4d0.image.webp)

![image.png](https://blog.liushigong.cn/static/img/a16b68d49ae51654cc0f3ba092bb571a.image.webp)

![image.png](https://blog.liushigong.cn/static/img/73bf82694506a351c987c9c8e4a1480a.image.webp)

#### 监控DemoController的test方法，打印class和method以及方法的参数

![image.png](https://blog.liushigong.cn/static/img/31684a5443c67a18828a6d5968accde0.image.webp)

效果

![image.png](https://blog.liushigong.cn/static/img/b10e8e002b98dbf963c33cb35c12d151.image.webp)

![image.png](https://blog.liushigong.cn/static/img/4a868bf71a98941da893a318eaac80ab.image.webp)

#### 监控DemoController的test方法，打印这个方法中所有的方法调用后的实例、参数、方法名、耗时（纳秒）

![image.png](https://blog.liushigong.cn/static/img/3c08812c5bb07a5c2432e2f5a6013baa.image.webp)

![image.png](https://blog.liushigong.cn/static/img/c59705fe7b0130163dcf8f8bb0100555.image.webp)

#### 监控DemoController的exception方法，进行对应的处理

![image.png](https://blog.liushigong.cn/static/img/a35971c96a5f1326d2d7e239748fbe8a.image.webp)

![image.png](https://blog.liushigong.cn/static/img/94d6852aba80375988c351e282fc7c5e.image.webp)

![image.png](https://blog.liushigong.cn/static/img/d9a30c25c47f9966a5ae9745226f2a8d.image.webp)

![image.png](https://blog.liushigong.cn/static/img/69c60a0aeb884d6c1af8f6589aa9c29d.image.webp)

### Btrace语法简介

详细语法见官方：<https://github.com/btraceio/btrace/blob/master/docs/BTraceTutorial.md>

下面是我总结的一些核心的

#### BTrace注解

BTrace注解可以分为：

* 类注解 `@BTrace`
* 方法注解如 `@OnMethod`
* 参数注解如 `@ProbeClassName`

##### 参数注解

* @ProbeClassName 用于标记处理方法的参数,仅用户@OnMethod, 该参数的值就是被跟踪的类名称
* @ProbeMethodName 用于表姐处理方法的参数,仅用户 @OnMethod,该参数值是被跟踪方法名称
* @Self 当前截取方法的封闭实例参数
* @Return 当前截取方法的的返回值, 只对 location=@Location(Kind.RETURN) 生效
* @Duration 当前截取方法的执行时间
* @TargetInstance 当前截取方法内部调用的实例
* @TargetMethodOrField 当前截取方法内部被调用的方法名

##### 方法注解

@OnMethod - 用于指定跟踪方法到目标类,目标方法和目标位置

@Kind注解

* Kind.ENTRY-被trace方法参数
* Kind.RETURN-被trace方法返回值
* Kind.THROW -抛异常
* Kind.ARRAY\_SET, Kind.ARRAY\_GET -数组索引
* Kind.CATCH -捕获异常
* Kind.FIELD\_SET -属性值
* Kind.LINE -行号
* Kind.NEW -类名
* Kind.ERROR -抛异常

@OnTimer - 用于指定跟踪操作定时执行。value用于指定时间间隔

@OnError - 当trace代码抛异常或者错误时，该注解的方法会被执行.如果同一个trace脚本中其他方法抛异常,该注解方法也会被执行。

### Btrace的限制

BTrace最终借Instrument实现class的替换。出于安全考虑，Instrument在使用上存在诸多的限制，这就好比给一架正在飞行的飞机换发动机一样一样的，因此BTrace脚本的限制如下：

1. 不允许创建对象
2. 不允许创建数组
3. 不允许抛异常
4. 不允许catch异常

不允许随意调用其他对象或者类的方法，只允许调用com.sun.btrace.BTraceUtils中提供的静态方法（一些数据处理和信息输出工具）

1. 不允许改变类的属性
2. 不允许有成员变量和方法，只允许存在static public void方法
3. 不允许有内部类、嵌套类
4. 不允许有同步方法和同步块
5. 不允许有循环
6. 不允许随意继承其他类（当然，java.lang.Object除外）
7. 不允许实现接口
8. 不允许使用assert
9. 不允许使用Class对象

如此多的限制，其实可以理解。BTrace要做的是，虽然修改了字节码，但是除了输出需要的信息外，对整个程序的正常运行并没有影响。

### 总结

其实作为Java的动态追踪技术，站在比较底层的角度上来说，底层无非就是基于ASM、Java Attach API、Instrument开发的创建。Arthas都是针前面这些技术的一个封装而已。

Btrace功能虽然强大，但都是比较难入门，这就是为什么 Btrace 出来这么多年，还是只在小范围内被使用。相对来说，Arthas 显的友好而且安全的多。

但无论工具如何强大，一些基础知识是需要牢固掌握的，否则，工具中出现的那些术语，也会让人一头雾水。

工具常变，但基础更加重要。如果你想要一个适应性更强的技术栈，还是要多花点时间在原始的排查方法上。