在数字化浪潮席卷能源行业的今天，一座中型光伏电站每天产生着怎样的数据洪流？想象一下：数十万台逆变器如同数字神经末梢，每5分钟传递一次发电"心跳"，一日便产生千万条数据记录。

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

当业务要求的复杂聚合查询需要跨越 320 张物理表进行分布式 JOIN —— 我们不禁要问：传统关系型数据库就算是分库分表，在处理光伏逆变器产生的海量时序数据时，是否已经触及了架构的天花板？

这正是无数新能源企业正在面对的真实困境。当发电数据从简单的记录存储升级为驱动决策的核心资产，传统数据库在时序数据处理的天然短板暴露无遗。区域发电效率对比、设备性能退化分析、发电量预测优化——这些关乎运营效率的关键分析，在现有架构下竟成了技术团队的噩梦。

但曙光已然显现。一种专为时序数据而生的新型数据库正在颠覆传统，它能否在百万级数据写入压力的同时，实现毫秒级的多维度复杂查询？当分库分表的桎梏被打破，我们是否终于可以任意穿梭于时间与维度之间，自由探索发电数据的每一个角落？本文将带你踏上一场存储架构的重构之旅，揭秘如何让海量光伏发电数据真正"发光发电"。

## 光伏发电大数据存储解决方案：从分库分表到时序数据库的实战演进

### 现有架构的痛点分析

当前系统采用分库分表方式存储光伏逆变器数据，已有9亿多条记录，且数据量持续快速增长。每个逆变器从早晨开始发电，每5分钟传输一条发电量信息，到傍晚停止传输。现有架构面临以下核心问题：

* 查询性能急剧下降：随着数据量增长，跨多个分表的查询性能显著降低
* 复杂条件过滤困难：按区域、逆变器型号、电站状态等多维度查询效率低下
* 时间范围查询效率低：查询日期区间发电量数据需要跨多个分表扫描
* 扩展性受限：传统数据库的分库分表需要人工干预，自动化程度低

### 光伏发电数据场景的深度分析

光伏发电数据是一种典型的时间序列数据，具有明显的时序特征：每个数据点都包含时间戳、数值和标签信息。在实际业务中，8万个逆变器从日出开始工作，每5分钟传输一条发电量数据，到傍晚停止传输。这种业务模式导致数据产生具有周期性、间歇性和季节性的特点。

根据行业数据，单个100MW风电场年数据量可达10TB+，而光伏电站同样面临数据量巨大的挑战。在我们的场景中，8万个逆变器每天产生的数据量相当可观：每5分钟8万条记录，按每天有效发电时间10小时计算，每天新增数据量达960万条。

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

同时光伏发电系统的数据查询需求复杂多样，主要包括：

* 时间区间查询：查询任意日期范围、时间区间的发电量汇总数据
* 多维度筛选：根据区域、逆变器型号、电站状态等条件进行筛选
* 实时监控：对当前发电状态进行实时监控和预警
* 历史数据分析：长期趋势分析、设备性能退化评估、发电效率优化

根据以上场景，最终我们选择了时序库 InfluxDB 作为核心时序数据存储解决方案。

## InfluxDB 概念

InfluxDB 是一个专门处理时间序列数据的开源数据库。简单来说，就是专门存储带时间戳数据的数据库。比如股票价格变化、服务器CPU使用率、传感器温度读数等等。

想象一下，你有一个温度传感器，每分钟记录一次温度。这些数据按时间顺序排列，就是典型的时间序列数据。InfluxDB就是为了高效处理这类数据而生的。

### 数据结构组成

InfluxDB 的数据结构包含几个核心部分：

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

#### 数据库（Database）

就像MySQL里的数据库概念一样，用来分类存储不同项目的数据。比如你可以建一个"智能家居"数据库，专门存放家里各种传感器的数据。

#### 测量（Measurement）

这个概念类似于关系型数据库中的表。每个测量代表一类数据，比如"温度测量"、“湿度测量”、"网络流量测量"等。

#### 标签（Tags）

标签是用来给数据打标记的，方便后续查询和筛选。比如温度数据，你可以用标签标记是哪个房间的、哪种传感器类型的。标签的值只能是字符串。

#### 字段（Fields）

字段存储真正的数值数据。比如温度值25.5度、湿度60%等。字段可以存储各种数据类型：整数、小数、字符串、布尔值。

#### 时间戳（Timestamp）

每条数据都必须有时间戳，精确到纳秒级别。这是InfluxDB的核心，所有数据都按时间排序。

举个例子，一条完整的数据可能长这样：

```
text

temperature,room=living_room,sensor_type=DHT22 value=25.5,humidity=60.2 1630425600000000000
```

这里：

* `temperature` 是测量名
* `room=living_room,sensor_type=DHT22` 是标签
* `value=25.5,humidity=60.2` 是字段
* 最后那串数字是时间戳

## 核心概念详解

### 标签键和标签值

#### 标签键（Tag Keys）

标签的名字，比如 `sensor_location`、`sensor_type`。这些都是字符串，主要用来分类和索引数据。

#### 标签值（Tag Values）

标签对应的具体值，比如 `room1`、`temperature`。也必须是字符串。

标签的组合帮你快速找到想要的数据。比如你想查"客厅的温度传感器数据"，就可以通过 `sensor_location=living_room` 和 `sensor_type=temperature` 这两个标签组合来查询。

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

```
text

measurement,sensor_location=room1,sensor_type=temperature value=25.5 1630425600000000000
```

在这个例子中：

* `sensor_location` 和 `sensor_type` 是标签键
* `room1` 和 `temperature` 是对应的标签值

### 字段键

#### 字段键（Field Keys）

字段的名字，比如 `temperature`、`humidity`、`pressure`。字段键对应的值可以是各种数据类型，不像标签只能是字符串。

字段存储的是你真正关心的测量数据。比如：

```
text

measurement,sensor_location=room1,sensor_type=temperature temperature=25.5,humidity=60.2 1630425600000000000
```

这里 `temperature` 和 `humidity` 就是字段键，25.5 和 60.2 是对应的数值。

### 序列（Series）

##### 序列（Series）

序列是一个逻辑概念，指的是具有相同测量名和标签组合的所有数据点。

比如说，所有来自"客厅温度传感器"的数据点就构成一个序列。即使时间不同、温度值不同，但只要是同一个传感器（相同的标签组合），就属于同一个序列。

假设你有这样的数据：

```
text

sensor_data,sensor_location=room1,sensor_type=temperature temperature=25.5 1630425600000000000
sensor_data,sensor_location=room1,sensor_type=temperature temperature=26.0 1630425660000000000
sensor_data,sensor_location=room1,sensor_type=temperature temperature=25.8 1630425720000000000
```

这三条数据就属于同一个序列，因为它们有相同的测量名（`sensor_data`）和相同的标签组合（`sensor_location=room1`,`sensor_type=temperature`）。

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

## 关键区别总结

### 数据类型差异

标签（Tags）只能存储字符串，而字段（Fields）可以存储多种数据类型：

* 整数：`count=100`
* 浮点数：`temperature=25.5`
* 字符串：`status="online"`
* 布尔值：`is_active=true`

### 功能用途不同

**标签的作用**

* 数据分类和筛选
* 建立索引，加快查询速度
* 类似于数据库的WHERE条件

**字段的作用**

* 存储实际的测量数据
* 用于数学计算和聚合操作
* 这是你真正要分析的数据

**序列的作用**

* 数据组织和管理
* 查询优化
* 理解数据的逻辑分组

### 索引特性

InfluxDB 会自动为所有标签建立索引，所以按标签查询很快。但字段没有自动索引，如果要按字段值查询，可能会比较慢。

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

这就是为什么要合理设计标签和字段：

* 经常用来筛选的属性设为标签
* 需要计算分析的数值设为字段

比如传感器数据：

* 传感器位置、类型 → 设为标签（经常用来筛选）
* 温度值、湿度值 → 设为字段（需要计算平均值、最大值等）

掌握了这些基础概念，你就能更好地设计InfluxDB的数据结构，让查询更快、存储更合理。

## 实战：InfluxDB 数据模型设计

### 数据点结构设计

```
java

// 逆变器发电量数据点
public class InverterDataPoint {
    private String measurement = "power_generation";
    
    // Tags - 用于过滤和分组
    private String inverterId;     // 逆变器ID
    private String region;         // 区域
    private String modelType;      // 型号
    private String stationStatus;  // 电站状态
    private String province;       // 省份
    private String city;           // 城市
    
    // Fields - 实际测量值
    private Double powerOutput;    // 发电功率(kW)
    private Double dailyEnergy;    // 日发电量(kWh)
    private Double temperature;    // 设备温度(℃)
    private Double voltage;        // 电压(V)
    private Integer statusCode;    // 状态码
    
    // Timestamp
    private Long timestamp;        // 数据时间戳
}
```

### 数据写入优化

```
java

@Component
public class InfluxDBWriter {
    
    @Autowired
    private InfluxDB influxDB;
    
    private static final int BATCH_SIZE = 5000;
    private List<Point> batchPoints = new ArrayList<>();
    
    /**
     * 批量写入逆变器数据
     */
    @Async
    public void writeInverterData(List<InverterData> dataList) {
        List<Point> points = dataList.stream()
            .map(this::convertToPoint)
            .collect(Collectors.toList());
        
        // 批量写入优化
        if (batchPoints.size() + points.size() >= BATCH_SIZE) {
            flushBatch();
        }
        
        batchPoints.addAll(points);
    }
    
    private Point convertToPoint(InverterData data) {
        return Point.measurement("power_generation")
            .time(data.getTimestamp(), TimeUnit.MILLISECONDS)
            .tag("inverter_id", data.getInverterId())
            .tag("region", data.getRegion())
            .tag("model_type", data.getModelType())
            .tag("station_status", data.getStationStatus())
            .tag("province", data.getProvince())
            .tag("city", data.getCity())
            .addField("power_output", data.getPowerOutput())
            .addField("daily_energy", data.getDailyEnergy())
            .addField("temperature", data.getTemperature())
            .addField("voltage", data.getVoltage())
            .addField("status_code", data.getStatusCode())
            .build();
    }
    
    @Scheduled(fixedRate = 5000) // 5秒刷写一次
    public void flushBatch() {
        if (!batchPoints.isEmpty()) {
            influxDB.write(batchPoints);
            batchPoints.clear();
        }
    }
}
```

### 复杂查询场景实战

时间区间发电量汇总

```
java

/**
 * 查询指定时间区间内的总发电量
 */
public PowerSummary queryPowerSummary(String startTime, String endTime, 
                                     List<String> regions, String modelType) {
    
    String fluxQuery = String.format(
        "from(bucket: \"%s\")\n" +
        "  |> range(start: %s, stop: %s)\n" +
        "  |> filter(fn: (r) => r._measurement == \"power_generation\")\n" +
        "  |> filter(fn: (r) => r._field == \"power_output\")\n" +
        "  |> filter(fn: (r) => r.region =~ /%s/)\n" +
        "  |> filter(fn: (r) => r.model_type == \"%s\")\n" +
        "  |> aggregateWindow(every: 1h, fn: mean)\n" +
        "  |> sum()",
        BUCKET_NAME, startTime, endTime, 
        String.join("|", regions), modelType
    );
    
    return executeFluxQuery(fluxQuery);
}
```

多维度条件过滤查询

```
java

/**
 * 复杂条件查询：区域、型号、状态多维度组合
 */
public List<InverterStats> queryInverterStats(PowerQueryDTO queryDTO) {
    StringBuilder fluxBuilder = new StringBuilder();
    fluxBuilder.append(String.format(
        "from(bucket: \"%s\")\n" +
        "  |> range(start: %s, stop: %s)\n" +
        "  |> filter(fn: (r) => r._measurement == \"power_generation\")\n",
        BUCKET_NAME, queryDTO.getStartTime(), queryDTO.getEndTime()
    ));
    
    // 动态添加过滤条件
    if (CollectionUtils.isNotEmpty(queryDTO.getRegions())) {
        String regionFilter = queryDTO.getRegions().stream()
            .map(region -> "/" + region + "/")
            .collect(Collectors.joining("|"));
        fluxBuilder.append(String.format(
            "  |> filter(fn: (r) => r.region =~ %s)\n", regionFilter
        ));
    }
    
    if (StringUtils.isNotEmpty(queryDTO.getModelType())) {
        fluxBuilder.append(String.format(
            "  |> filter(fn: (r) => r.model_type == \"%s\")\n", 
            queryDTO.getModelType()
        ));
    }
    
    if (StringUtils.isNotEmpty(queryDTO.getStationStatus())) {
        fluxBuilder.append(String.format(
            "  |> filter(fn: (r) => r.station_status == \"%s\")\n", 
            queryDTO.getStationStatus()
        ));
    }
    
    fluxBuilder.append(
        "  |> group(columns: [\"inverter_id\"])\n" +
        "  |> mean()\n" +
        "  |> sort(desc: true)\n" +
        "  |> limit(n: 1000)"
    );
    
    return executeComplexQuery(fluxBuilder.toString());
}
```

实时聚合与降采样

```
java

/**
 * 创建连续查询进行实时数据聚合
 */
public void createContinuousQueries() {
    // 按小时聚合
    String hourlyAggregation = 
        "CREATE CONTINUOUS QUERY cq_power_hourly ON photovoltaic \n" +
        "BEGIN \n" +
        "  SELECT MEAN(power_output) as mean_power, \n" +
        "         SUM(daily_energy) as total_energy \n" +
        "  INTO photovoltaic.autogen.:MEASUREMENT \n" +
        "  FROM power_generation \n" +
        "  GROUP BY time(1h), region, model_type \n" +
        "END";
    
    // 按天聚合  
    String dailyAggregation =
        "CREATE CONTINUOUS QUERY cq_power_daily ON photovoltaic \n" +
        "BEGIN \n" +
        "  SELECT MEAN(mean_power) as daily_mean_power, \n" +
        "         SUM(total_energy) as daily_total_energy \n" +
        "  INTO photovoltaic.one_year.daily_power \n" +
        "  FROM photovoltaic.autogen.power_generation \n" +
        "  GROUP BY time(1d), region, model_type \n" +
        "END";
    
    influxDB.query(new Query(hourlyAggregation));
    influxDB.query(new Query(dailyAggregation));
}
```

## 迁移方案与实施路径

### 平滑迁移策略

从分库分表方案迁移到InfluxDB需要谨慎规划，确保业务连续性：

分阶段迁移方案：

* 并行运行阶段（1-2周）：新老系统同时运行，数据双写，验证数据一致性
* 查询迁移阶段（2-3周）：逐步将查询业务迁移到新系统，按业务重要性从低到高
* 历史数据迁移阶段（3-4周）：逐步迁移历史数据，按时间从近到远
* 老系统下线阶段（1周）：完全切换到新系统，老系统只读备用

数据双写实现：

```
java

// 双写管理器
@Component
public class DualWriteManager {
    
    @Value("${dual.write.enabled:true}")
    private boolean dualWriteEnabled;
    
    public void writeGenerationData(PowerGenerationData data) {
        // 写入InfluxDB
        writeToInfluxDB(data);
        
        // 双写期间同时写入MySQL
        if (dualWriteEnabled) {
            writeToMySQL(data);
        }
    }
    
    public void switchToSingleWrite() {
        this.dualWriteEnabled = false;
        // 切换后仅写入InfluxDB
    }
}
```

### 数据一致性保障

迁移过程中必须确保数据一致性，一致性检查方案：

```
java

// 数据一致性校验
@Service
public class DataConsistencyChecker {
    
    public ConsistencyResult checkConsistency(String startTime, String endTime) {
        // 从InfluxDB查询统计
        PowerStatistic influxStat = queryFromInfluxDB(startTime, endTime);
        
        // 从MySQL查询统计
        PowerStatistic mysqlStat = queryFromMySQL(startTime, endTime);
        
        // 对比结果
        return compareStatistics(influxStat, mysqlStat);
    }
    
    private ConsistencyResult compareStatistics(PowerStatistic s1, PowerStatistic s2) {
        double diff = Math.abs(s1.getTotalGeneration() - s2.getTotalGeneration());
        double tolerance = s1.getTotalGeneration() * 0.01; // 1%容差
        
        if (diff <= tolerance) {
            return ConsistencyResult.ok();
        } else {
            return ConsistencyResult.error("数据不一致，差异: " + diff);
        }
    }
}
```

## InfluxDB 带来的价值

通过迁移到InfluxDB，我们实现了：

性能优化

* 时间范围查询从分钟级降至秒级
* 复杂条件查询性能提升5-10倍
* 写入吞吐量满足逆变器增量并发需求

成本优化

* 存储压缩比达到1:8，存储成本降低60%
* 自动数据分层，冷数据存储成本进一步降低
* 减少运维复杂度，降低人力成本

业务价值

* 支持实时监控和大屏展示
* 赋能精准发电预测和故障预警
* 为电站运营决策提供数据支撑

InfluxDB 作为专业的时序数据库，在光伏发电监控场景中展现出了显著优势，为海量时序数据的存储和分析提供了完美的解决方案。

> 技术选型的关键：认清数据本质——光伏逆变器数据是典型的时间序列数据，选择专业的时序数据库而非通用的关系型数据库，是解决性能瓶颈的根本之道。

时序数据库 - InfluxDB 入门指南与企业级实战

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 功能 |