nerkeler 2025-05-25T07:20:04.080Z https://nerkeler.github.io/ nerkeler Hexo EasyExcel动态表头实现 https://nerkeler.github.io/2024/01/29/asyExcel%E5%8A%A8%E6%80%81%E8%A1%A8%E5%A4%B4%E5%AE%9E%E7%8E%B0/ 2024-01-29T09:50:00.000Z 2025-05-25T07:20:04.080Z

EasyExcel动态表头实现

日常使用EasyExcel导出报表时，如果实体类字段较多，使用原始方式生成动态表头文件时会产生大量繁琐重复的代码，使用自定义注解和工具类处理可以大大简化代码开发

简单实现例子

准备一个实体类,注意@ExcelColumnIgnore注解为自定义注解，参数branchLv 表示当前机构层级

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
@Data
public class DemoEntity{
    @ExcelColumnIgnore(branchLv = 2)
    @ExcelProperty(value = {"二级机构代码"})
    @ApiModelProperty(value = "二级机构代码",example = "1110000")
    private String organIdTwo = "-";

    @ExcelColumnIgnore(branchLv = 2)
    @ExcelProperty(value = {"二级机构名称"})
    @ApiModelProperty(value = "二级机构名称",example = "北京市分公司")
    private String organNameTwo = "-";

    @ExcelColumnIgnore(branchLv = 3)
    @ExcelProperty(value = {"三级机构代码"})
    @ApiModelProperty(value = "三级机构代码",example = "1110100")
    private String organIdThree = "-";

    @ExcelColumnIgnore(branchLv = 3)
    @ExcelProperty(value = {"三级机构名称"})
    @ApiModelProperty(value = "三级机构名称",example = "北京市中心支公司本部")
    private String organNameThree = "-";

    @ExcelColumnIgnore(branchLv = 4)
    @ExcelProperty(value = {"四级机构代码"})
    @ApiModelProperty(value = "四级机构代码",example = "1110104")
    private String organIdFour = "-";

    @ExcelColumnIgnore(branchLv = 4)
    @ExcelProperty(value = {"四级机构名称"})
    @ApiModelProperty(value = "四级机构名称",example = "北京市朝阳区支公司")
    private String organNameFour = "-";

    
    @ExcelProperty(value = {"查询时间"})
    @ApiModelProperty(value = "查询时间",example = "2023-03-01至2023-06-26")
    private String queryTime = "-";
    
    @ExcelColumnIgnore
    @ExcelProperty(value = {"用户名"})
    @ApiModelProperty(value = "查询时间",example = "2023-03-01至2023-06-26")
    private String agentName = "-";
}

直接生成Excel

PS: EasyExcelUtils ExcelTitleWriteHandler 均在DEV环境，也可以从文章后看到具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void main(String[] args) {
       String title = "测试标题";
       // 展示层级
       int showLv = 2;
       // 展示层级排除字段
       List<String> Strings = EasyExcelUtils.getExcludeColumnFiledList(DemoEntity.class, showLv);

       List<DemoEntity> list = new ArrayList<>();
       list.add(new DemoEntity());
       // 生成Excel
       EasyExcel.write("file.xlsx", DemoEntity.class)
               .excludeColumnFiledNames(Strings)
               .sheet("title")
               .relativeHeadRowIndex(1)
               .registerWriteHandler(new ExcelTitleWriteHandler<>(title, DemoEntity.class, showLv))
               .doWrite(list);


   }

生成的结果会跟随showLv 展示层级不同出现不同的列数，实现动态表头并且跟随字段控制。

这里用到的两个自定义实现类EasyExcelUtils 、ExcelTitleWriteHandler ，和一个自定义注解@ExcelColumnIgnore 实现这个功能，背后的原理就是使用注解判断展示层级动态控制字段呈现

@ExcelColumnIgnore

1
2
3
4
5
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ExcelColumnIgnore {
    int branchLv() default 1000;
}

ExcelColumnIgnore 是一个自定义注解，只包含一个属性字段 branchLv 也就是标识当前字段的层级，默认1000是为了实现 无参数指定下 字段排除功能，也就是 在使用ExcelColumnIgnore 不指定参数 branchLv ,这个字段也将会被排除。

EasyExcelUtils

EasyExcelUtils 是一个自定义Easyexcel处理的工具类，getExcludeColumnFiledList方法就是配合ExcelColumnIgnore注解 动态获取需要排除的字段

getExcludeColumnFiledList(Class<T> t)

第一个方法需要指定实体类的类型，这样是为了获取当前实体类的所有字段和注解，这个方法默认排除所有带有@ExcelColumnIgnore 注解的字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * 获取动态排除字段
 * @return
 */
public static<T> List<String>   getExcludeColumnFiledList(Class<T> t){

    List<String> excludeColumnFiledList = new ArrayList<>();

    Field[] declaredFields = t.getDeclaredFields();
    for (Field field : declaredFields) {

        Annotation[] declaredAnnotations = field.getDeclaredAnnotations();
        for (Annotation declaredAnnotation : declaredAnnotations) {

            // 有 @ExcelColumnIgnore 表示要忽略当前字段计数 抵消 @ExcelProperty 的 +1
            if(declaredAnnotation instanceof ExcelColumnIgnore){
                excludeColumnFiledList.add(field.getName());
                break;
            }
        }
    }
    return excludeColumnFiledList;

}
getExcludeColumnFiledList(Class<T> t, int showLv)

重载方法增加了showLv 参数，表示要展示的层级，会保留 @ExcelColumnIgnore 注解上 branchLv <= showLv 的字段

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
public static<T> List<String>   getExcludeColumnFiledList(Class<T> t, int showLv){


    List<String> excludeColumnFiledList = new ArrayList<>();

    Field[] declaredFields = t.getDeclaredFields();
    for (Field field : declaredFields) {

        Annotation[] declaredAnnotations = field.getDeclaredAnnotations();
        for (Annotation declaredAnnotation : declaredAnnotations) {

            // 有 @ExcelColumnIgnore 表示要忽略当前字段计数 且branchLv > showLv 抵消 @ExcelProperty 的 +1
            if(declaredAnnotation instanceof ExcelColumnIgnore){
                ExcelColumnIgnore annotation = field.getAnnotation(ExcelColumnIgnore.class);
                int branchLv = annotation.branchLv();
                if (branchLv > showLv){
                    excludeColumnFiledList.add(field.getName());
                    break;
                }

            }
        }
    }
    return excludeColumnFiledList;

}

ExcelTitleWriteHandler

这个方法是动态生成表头的实现类, 构造方法如下

  • public ExcelTitleWriteHandler(String title,int column) //指定标题和列数
  • ExcelTitleWriteHandler(String title,Class<T> responseClass)// 指定标题和实体类（根据注解处理）
  • public ExcelTitleWriteHandler(String title,Class<T> responseClass,int showLv)// 指定标题、实体类、展示层级 （动态控制展示层级列数）

代码如下

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
package com.excel;

import cn.hutool.core.bean.BeanUtil;
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.write.handler.SheetWriteHandler;
import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
import com.alibaba.excel.write.metadata.holder.WriteWorkbookHolder;
import com.aop.annotation.ExcelColumnIgnore;
import io.swagger.annotations.ApiModelProperty;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;

/*
 * @description: Excel 表头生成器，指定动态标题 和 导出列数，生成对应表头内容
 *               如需表头样式自定义，可 添加属性  增加构造方法  动态修改当前样式设定 或 复制当前代码
 *               后续可补充内容  传入反参实体类，通过反射 自动计算当前类属性数量作为导出列数
 * @author: wcq
 * @date: 2023/11/28
 */
public class ExcelTitleWriteHandler<T> implements SheetWriteHandler {

    // 标题
    private String title = "";

    // 多少列
    private  int column = 0;

    // 实体类
    private  Class<T> responseClass = null;

    // 统计表展示层级
    private int showLv = 0;


    public ExcelTitleWriteHandler(String title,int column) {
        this.title = title;
        this.column = column;
    }

    /**
     * 用于明细表，注意字段必须要有 @ExcelProperty注解
     * @param title
     * @param responseClass
     */
    public ExcelTitleWriteHandler(String title,Class<T> responseClass) {
        this.title = title;
        this.responseClass = responseClass;
    }

    /**
     * 用于统计表，注意字段必须要有 @ExcelProperty注解，
     * showLv 标识展示层级 比如 展示到四级，则 @ExcelColumnIgnore(branchLv = 4)  branchLv > 4 和默认注解将被忽略
     * @param title
     * @param responseClass
     */
    public ExcelTitleWriteHandler(String title,Class<T> responseClass,int showLv) {
        this.title = title;
        this.responseClass = responseClass;
        this.showLv = showLv;
    }


    @Override
    public void beforeSheetCreate(WriteWorkbookHolder writeWorkbookHolder, WriteSheetHolder writeSheetHolder) {

    }

    @Override
    public void afterSheetCreate(WriteWorkbookHolder writeWorkbookHolder, WriteSheetHolder writeSheetHolder) {
 
        Workbook workbook = writeWorkbookHolder.getWorkbook();
        Sheet sheet = workbook.getSheetAt(0);
        Row row1 = sheet.createRow(0);
        row1.setHeight((short) 800);
        Cell cell = row1.createCell(0);

        //设置标题
        cell.setCellValue(title);
        CellStyle cellStyle = workbook.createCellStyle();

        //设置边框
        cellStyle.setBorderBottom(BorderStyle.THIN);
        cellStyle.setBorderLeft(BorderStyle.THIN);
        cellStyle.setBorderRight(BorderStyle.THIN);
        cellStyle.setBorderTop(BorderStyle.THIN);

        // 水平竖直居中
        cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
        cellStyle.setAlignment(HorizontalAlignment.CENTER);

        // 灰色填充背景
        cellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
        cellStyle.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());


        Font font = workbook.createFont();
        font.setBold(true);
        font.setFontHeight((short) 400);
        font.setFontName("宋体");
        cellStyle.setFont(font);
        cell.setCellStyle(cellStyle);


        // 明细表处理
        if(column == 0 ){
            Field[] declaredFields = responseClass.getDeclaredFields();
            for (Field field : declaredFields) {
                Annotation[] declaredAnnotations = field.getDeclaredAnnotations();
                for (Annotation declaredAnnotation : declaredAnnotations) {

                    // 有 @ExcelProperty 表示一个有效字段
                    if(declaredAnnotation instanceof ExcelProperty)
                        column++;

                }
            }

            for (Field declaredField : declaredFields) {
                Annotation[] declaredAnnotations = declaredField.getDeclaredAnnotations();
                for (Annotation declaredAnnotation : declaredAnnotations) {

                    // 有 @ExcelColumnIgnore 表示要忽略当前字段计数  当branchLv > show 时 抵消 @ExcelProperty 的 +1
                    if(declaredAnnotation instanceof ExcelColumnIgnore) {
                        ExcelColumnIgnore annotation = declaredField.getAnnotation(ExcelColumnIgnore.class);

                        if (showLv == 0){
                            column--;
                        }  else if (showLv > 0 && annotation.branchLv() > showLv){
                            column--;
                        }

                    }

                }
            }
        }



        sheet.addMergedRegionUnsafe(new CellRangeAddress(0, 0, 0, column-1));

    }

}

原理大同小异，配合注解可以动态处理字段的展示，从而获取准确的标题表头

使用建议

明细表

明细表因为没有动态展示的功能,一般不需要使用@ExcelColumnIgnore注解，如果要使用@ExcelColumnIgnore时也不需要指定参数branchLv

步骤建议

  1. 获取导出实体类列表
  2. 导出时使用 ExcelTitleWriteHandler 动态生成表头，传入 （title class ），即可计算列数，或指定column 参数
统计表

统计表大部分需要根据不同机构层级展示，在实体类 中需要在各层级字段使用@ExcelColumnIgnore注解，并标注准确的showLv参数，

步骤建议

  1. 实体类各层级字段使用@ExcelColumnIgnore 注解 二级机构 2、三级机构 3 、依次类推
  2. 获取导出实体类列表
  3. 使用EasyExcelUtils getExcludeColumnFiledList(Class<T> t, int showLv) 方法获取动态排除字段，注意传入展示层级
  4. 生成表头时ExcelTitleWriteHandler 使用public ExcelTitleWriteHandler(String title,Class<T> responseClass,int showLv) 构造方法，指定实体类和展示层级
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 回溯经典案例 https://nerkeler.github.io/2024/01/04/%E5%9B%9E%E6%BA%AF%E7%BB%8F%E5%85%B8%E6%A1%88%E4%BE%8B/ 2024-01-04T02:19:00.000Z 2025-05-25T07:20:42.324Z

回溯经典案例

全排列

全排列问题是回溯算法的一个典型应用。它的定义是在给定一个集合（如一个数组或字符串）的情况下，找 出这个集合中元素的所有可能的排列。

question1
1
输入一个整数数组，数组中不包含重复元素，返回所有可能的排列。

例如：

  • [1, 2] ：[1, 2], [2, 1]
  • [1, 2, 3] [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]

回溯代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
List<Integer> path = new ArrayList<>();
List<List<Integer>> result = new ArrayList<>();

List<List<Integer>> permutationsI(int[] nums) {

    backtrack(nums);
    return result;
}

private void backtrack( int[] nums) {
    if(path.size() >= nums.length){
        result.add(new ArrayList<>(path));
        return;
    }
    for (int num : nums) {
        // 排除重复元素 （剪枝）
        if (!path.contains(num)) {
            path.add(num);
            backtrack(nums);
            path.remove(path.size() - 1);
        }
    }

}

这里使用了列表去重，路径中如果包含当前元素表示已经有添加，直接跳过，这样就避免了 111 122 133 ..... 等排列的形式出现

当然去重的逻辑不止一种，使用布尔值，set 都可以，这里就不展开，感兴趣可以自己尝试。

子集

1
2
3
给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

例如：

  • 输入: nums = [1,2,3] 输出: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ]

回溯代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution {
    private List<Integer> path = new ArrayList<>();

    private List<List<Integer>> result = new ArrayList<>();


    public List<List<Integer>> subsets(int[] nums) {
        bfs(0, nums);
        return result;
    }

    public void bfs(int index, int[] nums) {
        
        result.add(new ArrayList<>(path));
        if (index >= nums.length) return;
        
        for (int i = index; i < nums.length; i++) {
            path.add(nums[i]);
            bfs(i + 1, nums);
            path.remove(path.size() - 1);
        }
    }
}

N皇后

1
2
根据国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。给定 𝑛
个皇后和一个 𝑛 × 𝑛 大小的棋盘，寻找使得所有皇后之间无法相互攻击的摆放方案。

八皇后问题可以看作是一个复合的回溯问题，比之一般的回溯问题的限定条件来说 十分复杂 放置每一个棋子（Q）时需要在 行、列、对角线 比较是否有冲突放置，而回溯的地方就是 放置的 ”Q“, 在不满足条件的时候需要回溯成原始的 ”.“

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
56
57
58
59
60
61
62
63
64
class Solution {
    List<List<String>> res = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        char[][] chessboard = new char[n][n];
        for (char[] c : chessboard) {
            Arrays.fill(c, '.');
        }
        backTrack(n, 0, chessboard);
        return res;
    }


    public void backTrack(int n, int row, char[][] chessboard) {
        if (row == n) {
            res.add(Array2List(chessboard));
            return;
        }

        for (int col = 0;col < n; ++col) {
            if (isValid (row, col, n, chessboard)) {
                chessboard[row][col] = 'Q';
                backTrack(n, row+1, chessboard);
                chessboard[row][col] = '.';
            }
        }

    }


    public List Array2List(char[][] chessboard) {
        List<String> list = new ArrayList<>();

        for (char[] c : chessboard) {
            list.add(String.copyValueOf(c));
        }
        return list;
    }


    public boolean isValid(int row, int col, int n, char[][] chessboard) {
        // 检查列
        for (int i=0; i<row; ++i) { // 相当于剪枝
            if (chessboard[i][col] == 'Q') {
                return false;
            }
        }

        // 检查45度对角线
        for (int i=row-1, j=col-1; i>=0 && j>=0; i--, j--) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }

        // 检查135度对角线
        for (int i=row-1, j=col+1; i>=0 && j<=n-1; i--, j++) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }
        return true;
    }
}
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 回溯基础 https://nerkeler.github.io/2024/01/04/%E5%9B%9E%E6%BA%AF%E5%9F%BA%E7%A1%80/ 2024-01-04T02:18:00.000Z 2024-01-04T02:26:13.322Z

回溯

理论基础

「回溯算法 backtracking algorithm」是一种通过穷举来解决问题的方法，它的核心思想是从一个初始状态出发，暴力搜索所有可能的解决方案，当遇到正确的解则将其记录，直到找到解或者尝试了所有可能的选择都无法找到解为止，所以回溯算法也通常采用“深度优先搜索”来遍历解空间。

回溯法解决的问题

  • 组合问题：N个数里面按一定规则找出k个数的集合
  • 切割问题：一个字符串按一定规则有几种切割方式
  • 子集问题：一个N个数的集合里有多少符合条件的子集
  • 排列问题：N个数按一定规则全排列，有几种排列方式
  • 棋盘问题：N皇后，解数独等等

如何理解回溯法

回溯法解决的问题都可以抽象为树形结构，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。

二叉树例子

题目
1
给定一个二叉树，搜索并记录所有值为 7 的节点，请返回节点列表

img

题解
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
## 回溯

#### 理论基础

「回溯算法 backtracking algorithm」是一种通过穷举来解决问题的方法，它的核心思想是从一个初始状态出发，暴力搜索所有可能的解决方案，当遇到正确的解则将其记录，直到找到解或者尝试了所有可能的选择都无法找到解为止，所以回溯算法也通常采用“深度优先搜索”来遍历解空间。

#### 回溯法解决的问题

- 组合问题：N个数里面按一定规则找出k个数的集合
- 切割问题：一个字符串按一定规则有几种切割方式
- 子集问题：一个N个数的集合里有多少符合条件的子集
- 排列问题：N个数按一定规则全排列，有几种排列方式
- 棋盘问题：N皇后，解数独等等

#### 如何理解回溯法

**回溯法解决的问题都可以抽象为树形结构**，**集合的大小就构成了树的宽度，递归的深度，都构成的树的深度**。



#### 二叉树例子

##### 题目

```css
给定一个二叉树，搜索并记录所有值为 7 的节点，请返回节点列表
```



![](https://pic.imgdb.cn/item/6565a520c458853aef6e2cb0.png)

##### 题解

```java
/* 前序遍历： */
void preOrder(TreeNode root) {
    // 递归到终止节点
    if (root == null) {
        return;
    }
    if (root.val == 7) {
        // 记录解
        res.add(root);
    }
    preOrder(root.left);
    preOrder(root.right);
}

```

此时，我们遍历的顺序就是  ` 1-3-2-5-4-7-6`  ，也可以从下图中看出。



![](https://pic.imgdb.cn/item/6565a4dec458853aef6d60f0.png)

#### 简单组合例子

```yaml
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
```

例如  `n = 4、 k = 3`  ，相当于我们在 `[1,2,3,4`]中取 `3` 个数组合 则图解应为

![](https://pic.imgdb.cn/item/6565a9cdc458853aef7ba00b.png)

代码：

```java
    private List<List<Integer>> result = new ArrayList<>();
    private List<Integer> path = new ArrayList<>();

    public List<List<Integer>> combine(int n, int k) {
        int[] ints = new int[n];
        for (int i = 1; i <= n; i++) {
            ints[i-1] = i;
        }

        dfs(0,k,ints);

        return result;

    }
    private void dfs(int start,int k,int[] ints){

        if(path.size() == k)
            result.add(new ArrayList<>(path));

        if(start >= ints.length || path.size() >= k) return;

        for (int i = start; i < ints.length; i++) {
            path.add(ints[i]);
            dfs(i+1,k,ints);
            path.remove(path.size()-1);
        }


    }
```

代码暂且不管，从图中可以看到，我们将这个问题转化为一个树形遍历， 将回溯问题 转换为 数层遍历有助于我们理解回溯的过程。

#### 尝试与回退

**之所以称之为回溯算法，是因为该算法在搜索解空间时会采用“尝试”与“回退”的策略**。当算法在搜索过程中遇到某个状态无法继续前进或无法得到满足条件的解时，它会撤销上一步的选择，退回到之前的状态，并尝试其他可能的选择。

##### 尝试

在进入递归后紧接着就是 逻辑判断 的 `return` 语句，它会在尝试失败后返回到上一层递归，从树形结构理解就是返回到了它的父节点。

##### 回退

通常使用`path` 记录递归调用的路径，也就是大部分情况下的符合条件的解，当递归返回时，路径也要相应的回退

例如上述图解，我们在 `[1-2-3]` 得到一个满足的解后，程序 `return`, 这时需要弹出`path`中最后一个元素，也就是 使递归层 回到  `[1-2]`

##### 例子

在上述的二叉树例题中，如果要获取节点的路径呢？

```yaml
在二叉树中搜索所有值为 7 的节点，请返回根节点到这些节点的路径。
```

题解：

```java
/* 前序遍历：例题二 */
void preOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    // 尝试
    path.add(root);
    if (root.val == 7) {
        // 记录解
        res.add(new ArrayList<>(path));
    }
    preOrder(root.left);
    preOrder(root.right);
    // 回退
    path.remove(path.size() - 1);
}

```

**`path` ：路径，也就是满足条件的一条解。**

#### 剪枝

复杂的回溯问题通常包含一个或多个约束条件，**约束条件通常可用于“剪枝”**。

```yaml
在二叉树中搜索所有值为 7 的节点，请返回根节点到这些节点的路径，**并要求路径中不包含值为 3 的节点**。
```

这样的话，我们就需要剪枝，简单来说，就是增加递归的限定条件，不满足条件的路径会提前弹出

图示：

![](https://pic.imgdb.cn/item/6565b200c458853aef9446af.png)

代码：

```java
void preOrder(TreeNode root) {
    // 剪枝
    if (root == null || root.val == 3) {
        return;
    }
    // 尝试
    path.add(root);
    if (root.val == 7) {
        // 记录解
        res.add(new ArrayList<>(path));
    }
    preOrder(root.left);
    preOrder(root.right);
    // 回退
    path.remove(path.size() - 1);
}
```

剪枝操作不止在限定条件中，如 **简单组合例子** 中，横向遍历了 第一层 数值， 在下面的递归层级中，`start`都增加了 `1`

```java
 for (int i = start; i < ints.length; i++) {
            path.add(ints[i]);
            dfs(i+1,k,ints);
            path.remove(path.size()-1);
       }
```

这样 下一层级节点就从 `i+1`开始，这样就减少了  当前值的层级，相当于剪枝。



#### 框架代码

```java
// 结果集
private List  result;
// 路径
private List path

/* 回溯算法框架 */
void backtrack(int start, List<Choice> choices,) {
    // 判断是否为解
    if (isSolution(start)) {
        // 记录解
       result.add(path)
        // 停止继续搜索
        return;
    }
    // 遍历所有选择
    for (Choice choice : choices) {
        // 剪枝：判断选择是否合法
        if (isValid(state, choice)) {
            // 尝试：做出选择，更新状态
            makeChoice(state, choice);
            backtrack(state, choices, res);
            // 回退：撤销选择，恢复到之前的状态
            undoChoice(state, choice);
        }
    }
}

```



#### 参考

[HELLO 算法](https://www.hello-algo.com/chapter_backtracking/backtracking_algorithm/#1316)

[代码随想录](https://www.programmercarl.com/%E5%9B%9E%E6%BA%AF%E7%AE%97%E6%B3%95%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html#%E9%A2%98%E7%9B%AE%E5%88%86%E7%B1%BB)

此时，我们遍历的顺序就是 1-3-2-5-4-7-6 ，也可以从下图中看出。

img

简单组合例子

1
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

例如 n = 4、 k = 3 ，相当于我们在 [1,2,3,4]中取 3 个数组合 则图解应为

img

代码：

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
private List<List<Integer>> result = new ArrayList<>();
private List<Integer> path = new ArrayList<>();

public List<List<Integer>> combine(int n, int k) {
    int[] ints = new int[n];
    for (int i = 1; i <= n; i++) {
        ints[i-1] = i;
    }

    dfs(0,k,ints);

    return result;

}
private void dfs(int start,int k,int[] ints){

    if(path.size() == k)
        result.add(new ArrayList<>(path));

    if(start >= ints.length || path.size() >= k) return;

    for (int i = start; i < ints.length; i++) {
        path.add(ints[i]);
        dfs(i+1,k,ints);
        path.remove(path.size()-1);
    }


}

代码暂且不管，从图中可以看到，我们将这个问题转化为一个树形遍历， 将回溯问题 转换为 数层遍历有助于我们理解回溯的过程。

尝试与回退

之所以称之为回溯算法，是因为该算法在搜索解空间时会采用“尝试”与“回退”的策略。当算法在搜索过程中遇到某个状态无法继续前进或无法得到满足条件的解时，它会撤销上一步的选择，退回到之前的状态，并尝试其他可能的选择。

尝试

在进入递归后紧接着就是 逻辑判断 的 return 语句，它会在尝试失败后返回到上一层递归，从树形结构理解就是返回到了它的父节点。

回退

通常使用path 记录递归调用的路径，也就是大部分情况下的符合条件的解，当递归返回时，路径也要相应的回退

例如上述图解，我们在 [1-2-3] 得到一个满足的解后，程序 return, 这时需要弹出path中最后一个元素，也就是 使递归层 回到 [1-2]

例子

在上述的二叉树例题中，如果要获取节点的路径呢？

1
在二叉树中搜索所有值为 7 的节点，请返回根节点到这些节点的路径。

题解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* 前序遍历：例题二 */
void preOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    // 尝试
    path.add(root);
    if (root.val == 7) {
        // 记录解
        res.add(new ArrayList<>(path));
    }
    preOrder(root.left);
    preOrder(root.right);
    // 回退
    path.remove(path.size() - 1);
}

path ：路径，也就是满足条件的一条解。

剪枝

复杂的回溯问题通常包含一个或多个约束条件，约束条件通常可用于“剪枝”。

1
在二叉树中搜索所有值为 7 的节点，请返回根节点到这些节点的路径，**并要求路径中不包含值为 3 的节点**。

这样的话，我们就需要剪枝，简单来说，就是增加递归的限定条件，不满足条件的路径会提前弹出

图示：

img

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void preOrder(TreeNode root) {
    // 剪枝
    if (root == null || root.val == 3) {
        return;
    }
    // 尝试
    path.add(root);
    if (root.val == 7) {
        // 记录解
        res.add(new ArrayList<>(path));
    }
    preOrder(root.left);
    preOrder(root.right);
    // 回退
    path.remove(path.size() - 1);
}

剪枝操作不止在限定条件中，如 简单组合例子 中，横向遍历了 第一层 数值， 在下面的递归层级中，start都增加了 1

1
2
3
4
5
for (int i = start; i < ints.length; i++) {
           path.add(ints[i]);
           dfs(i+1,k,ints);
           path.remove(path.size()-1);
      }

这样 下一层级节点就从 i+1开始，这样就减少了 当前值的层级，相当于剪枝。

框架代码

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
// 结果集
private List  result;
// 路径
private List path

/* 回溯算法框架 */
void backtrack(int start, List<Choice> choices,) {
    // 判断是否为解
    if (isSolution(start)) {
        // 记录解
       result.add(path)
        // 停止继续搜索
        return;
    }
    // 遍历所有选择
    for (Choice choice : choices) {
        // 剪枝：判断选择是否合法
        if (isValid(state, choice)) {
            // 尝试：做出选择，更新状态
            makeChoice(state, choice);
            backtrack(state, choices, res);
            // 回退：撤销选择，恢复到之前的状态
            undoChoice(state, choice);
        }
    }
}

参考

HELLO 算法

代码随想录

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla SpringSecurity表单认证（一） https://nerkeler.github.io/2023/08/02/SpringSecurity%E8%A1%A8%E5%8D%95%E8%AE%A4%E8%AF%81%EF%BC%88%E4%B8%80%EF%BC%89/ 2023-08-02T06:55:00.000Z 2024-01-04T01:39:41.426Z

SpringSecurity表单认证（一）

新建一个SpringSecutiry项目

创建一个新项目，名称任意

pom文件引入依赖，版本任意。

1
2
3
4
5
6
7
8
9
10
11
12
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.3.3.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
        <version>2.3.3.RELEASE</version>
    </dependency>
</dependencies>

简略设置一下，启动文件

1
2
3
4
5
6
7
8
9
10
11
@SpringBootApplication
@RestController
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
    @GetMapping("/hello")
    public String hello(@RequestParam(value = "name", defaultValue = "World") String name) {
        return String.format("Hello %s!", name);
    }
}

此时访问任意路径都会被拦截到 /login 路径，呈现以下登录页面

到此为止，就已经新建了一个SpringSecutiry最基本的demo

思考

springsecutity作为重量级的安全框架（相对于shiro)，搭建起来却并没有很繁琐，其实这归功于springboot自动配置帮我们节省了繁琐的配置，springsecurity提供了很多强大的功能，但最核心的当属两方面

  • 认证 Authentication
  • 授权 Authorization

通俗来说，认证就是你是谁，授权就是你可以作什么

简述认证

springsecutiry支持多种不同的认证方式

  • 表单认证
  • OAuth2.0认证
  • SAML2.0认证
  • CAS2.0认证
  • RememberMe 自动认证
  • JAAS认证
  • OpenID 去中心化认证
  • Pre-Authentication Scenarios 认证
  • X509 认证
  • HTTP Basic认证
  • HTTP Digest认证

认证接口

认证信息主要的操作功能由Authentication 定义

1
2
3
4
5
6
7
8
9
10
11
12
13
public interface Authentication extends Principal, Serializable {
    Collection<? extends GrantedAuthority> getAuthorities();

    Object getCredentials();

    Object getDetails();

    Object getPrincipal();

    boolean isAuthenticated();

    void setAuthenticated(boolean var1) throws IllegalArgumentException;
}
  • getAuthorities 获取用户权限
  • getCredentials 获取用户凭证，一般来说就是密码
  • getDetails 获取用户携带的详细信息 请求路径等
  • getPrincipal 获取当前用户
  • isAuthenticated 是否认证成功

大致看一下Authentication 的子类实现，可以看到不同的认证方式会有不同的实现类，这里先不展开说明，大致有个印象

认证信息由Authentication和其子类提供，而认证工作则是由AuthenticationManager接口极其子类实现

AuthenticationManager接口只提供了一个认证方法。

1
2
3
public interface AuthenticationManager {
    Authentication authenticate(Authentication var1) throws AuthenticationException;
}

不同的子类也代表了不同的认证方式，只需要有个印象就够了，后面碰到会详细说明

过滤器链

在Spring Security中，认证和授权等功能都是基于过滤器完成，Spring Securiy常见的过滤器如下

过滤器过滤器作用预加载
ChannelProcessingFilter过滤请求协议，HTTPS/HTTPNO
WebAsyncManagerIntegrationFilter将WebAsyncManager 与Spring Security 上下文进行集成YES
SecurityContextPersistenceFilter在处理请求前，将安全信息加载到SecurityContextHolder中方便后续使用，请求结束后，在擦除掉信息YES
HeaderWriterFilter头信息加入到相应中YES
CorsFilter处理跨域问题NO
Csffilter处理CSRF攻击YES
LogoutFilter处理注销登录YES
OAuth2AuthorizationRequestRedirectFilter处理OAuth2认证重定向NO
Saml2WebSsoAuthenticationRequestFilter处理SAML认证NO
X509AuthenticationFilter处理X509认证NO
AbstractPreAuthenticatedProcessingFilter处理预认证问题NO
CasAuthenticationFilter处理CAS单点登录NO
OAuth2LoginAuthenticationFilter处理OAuth2NO
Saml2WebSsoAuthenticationFilter处理SAML认证NO
UsenamePasswordAuthenticationFilter处理表单登录YES
OpenIDAuthenticationFilter处理OpenID认证NO
DefaultLoginPageGenemtingFilter配置默认登录页面YES
DefaultLogoutPageGeneratingFilter配置默认注销页面YES
ConcurentSessionFilter处理Session有效期NO
DigestAuthenticationFilter处理HTTP摘要认证NO
BearerTokenAuthenticationFilter处理OAuth2认证时的Access TokenNO
BasicAuthenticationFilter处理HttpBasic登录YES
RequestCacheAwareFilter处理请求缓存YES
SecurityContextHolderAwareRequestFilter包装原始请求YES
JaasApiIntegrationFilter处理JAAS认证NO
RememberMeAuthenticationFilter处理RememberMe登录NO
AnonymousAuthenticationFilter配置匿名认证YES
OAuth2AuthorizationCodeGrantFilter处理OAuth2认证中的授权码NO
SessionManagementFilter处理Session并发问题YES
ExceptionTranslationFilter池异常认证/授权中的情况YES
FilterSecurityInterceptor处理授权YES
SwitchUserFilter处理账户切换NO

Spring Security提供的功能基本都是由上述过滤器来实现的，这些过滤器按照既定的优先级排列形成过滤器链。当然开发者也可以自定义过滤器的位置，这里暂不讨论。

Spring Security登录认证

上图中新建了一个最基本的Spring Security demo ，在访问/hello的时候，会自动重定向到/login页面，并且需要输入账号密码登录

而在启动时，发现终端上打印了一行

1
Using generated security password: 535d2c4d-44eb-4808-8ae1-f272b9317b29

也就是Spring Security 随机生成的密码（uuid） 默认用户名为user。

流程分析

上述流程以图标的方式展现如下

  1. 客户端（浏览器）发起请求 /hello 接口，由于引入了Spring Security，登录需要认证
  2. 请求会走一遍Spring Security 中的过滤链，在最后的FilterSecurityInterceptor过滤其中被拦截下来，因为系统发现用户未认证。请求拦截下拉后会抛出 AccessDeniedException 异常
  3. 抛出的AccessDeniedException 异常 在 ExceptionTranslationFilter过滤器中被捕获，ExceptionTranslationFilter 过滤器通过调用 LoginUrlAuthenticationEntryPoint中 commmence方法返回客户端302，要求客户端重定向到/login页面
  4. 客户端重新发送 /login请求
  5. /login 请求被 DefaultLoginPageGeneratingFilter过滤器拦截下来，并在该过滤器中返回登录页面。

代码分析

FilterSecurityInterceptor

当过滤链执行到FilterSecurityInterceptor时，会调用doFilter方法如下，可以看到主要调用了invoke方法，FilterInvocation分装了当前请求信息。

1
2
3
4
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    FilterInvocation fi = new FilterInvocation(request, response, chain);
    this.invoke(fi);
}

在invoke()方法中，它会调用beforeInvocation()方法，该方法是AbstractSecurityInterceptor的一个抽象方法，具体的实现由子类提供。beforeInvocation()方法会调用AccessDecisionManager来进行访问决策。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void invoke(FilterInvocation fi) throws IOException, ServletException {
    if (fi.getRequest() != null && fi.getRequest().getAttribute("__spring_security_filterSecurityInterceptor_filterApplied") != null && this.observeOncePerRequest) {
        fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
    } else {
        if (fi.getRequest() != null && this.observeOncePerRequest) {
            fi.getRequest().setAttribute("__spring_security_filterSecurityInterceptor_filterApplied", Boolean.TRUE);
        }

        InterceptorStatusToken token = super.beforeInvocation(fi);

        try {
            fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
        } finally {
            super.finallyInvocation(token);
        }

        super.afterInvocation(token, (Object)null);
    }

}

在beforeInvocation方法中并不会直接抛出异常。相反，它会委托给AccessDecisionManager来进行访问决策。如果访问决策失败，AccessDecisionManager将抛出AccessDeniedException异常，表示访问被拒绝。主要语句是

1
2
3
4
5
6
try {
    this.accessDecisionManager.decide(authenticated, object, attributes);
} catch (AccessDeniedException var7) {
    this.publishEvent(new AuthorizationFailureEvent(object, attributes, authenticated, var7));
    throw var7;
}

这里，FilterSecurityInterceptor会检查用户的认证状态和权限，然后调用AccessDecisionManager的decide方法来进行访问决策。

这里默认的决策器是AffirmativeBased，相关代码为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
while(var5.hasNext()) {
    AccessDecisionVoter voter = (AccessDecisionVoter)var5.next();
    int result = voter.vote(authentication, object, configAttributes);
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Voter: " + voter + ", returned: " + result);
    }

    switch(result) {
    case -1:
        ++deny;
        break;
    case 1:
        return;
    }
}

if (deny > 0) {
    throw new AccessDeniedException(this.messages.getMessage("AbstractAccessDecisionManager.accessDenied", "Access is denied"));
} else {
    this.checkAllowIfAllAbstainDecisions();
}

AffirmativeBased: 如果任何一个访问决策器返回ACCESS_GRANTED（访问允许），则决策通过；否则，如果所有访问决策器都返回ACCESS_ABSTAIN（弃权）或没有决策器，那么访问也会被允许。

AffirmativeBased 默认传入的构造器只有一个 WebExpressionVoter，这个构造器会根据你在配置文件中的配置进行逻辑处理得出投票结果，这里返回 -1，deny > 0 直接抛出异常。

ExceptionTranslationFilter

ExceptionTranslationFilter 捕获FilterSecurityInterceptor抛出的AccessDeniedException异常，通过调用 LoginUrlAuthenticationEntryPoint中 commmence方法返回客户端302，要求客户端重定向到/login页面。

这里走的是catch(Excception var10)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest)req;
    HttpServletResponse response = (HttpServletResponse)res;

    try {
        chain.doFilter(request, response);
        this.logger.debug("Chain processed normally");
    } catch (IOException var9) {
        throw var9;
    } catch (Exception var10) {
    ...........

        this.handleSpringSecurityException(request, response, chain, (RuntimeException)ase);
    }

}

handleSpringSecurityException方法主要是禁止访问和重定向

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private void handleSpringSecurityException(HttpServletRequest request, HttpServletResponse response, FilterChain chain, RuntimeException exception) throws IOException, ServletException {
    if (exception instanceof AuthenticationException) {
        this.logger.debug("Authentication exception occurred; redirecting to authentication entry point", exception);
        this.sendStartAuthentication(request, response, chain, (AuthenticationException)exception);
    } else if (exception instanceof AccessDeniedException) {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (!this.authenticationTrustResolver.isAnonymous(authentication) && !this.authenticationTrustResolver.isRememberMe(authentication)) {
            this.logger.debug("Access is denied (user is not anonymous); delegating to AccessDeniedHandler", exception);
            this.accessDeniedHandler.handle(request, response, (AccessDeniedException)exception);
        } else {
            this.logger.debug("Access is denied (user is " + (this.authenticationTrustResolver.isAnonymous(authentication) ? "anonymous" : "not fully authenticated") + "); redirecting to authentication entry point", exception);
            this.sendStartAuthentication(request, response, chain, new InsufficientAuthenticationException(this.messages.getMessage("ExceptionTranslationFilter.insufficientAuthentication", "Full authentication is required to access this resource")));
        }
    }

}

显而易见这里走的是 this.sendStartAuthentication(request, response, chain, new InsufficientAuthenticationException(this.messages.getMessage("ExceptionTranslationFilter.insufficientAuthentication", "Full authentication is required to access this resource")));

而sendStartAuthentication实际上调用的就是LoginUrlAuthenticationEntryPoint的commence方法

1
2
3
4
5
6
protected void sendStartAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, AuthenticationException reason) throws ServletException, IOException {
    SecurityContextHolder.getContext().setAuthentication((Authentication)null);
    this.requestCache.saveRequest(request, response);
    this.logger.debug("Calling Authentication entry point.");
    this.authenticationEntryPoint.commence(request, response, reason);
}

commence真正实现了由Spring Security 提供的默认/login 路径的重定向

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
    String redirectUrl = null;
    if (this.useForward) {
        if (this.forceHttps && "http".equals(request.getScheme())) {
            redirectUrl = this.buildHttpsRedirectUrlForRequest(request);
        }

        if (redirectUrl == null) {
            String loginForm = this.determineUrlToUseForThisRequest(request, response, authException);
            if (logger.isDebugEnabled()) {
                logger.debug("Server side forward to: " + loginForm);
            }

            RequestDispatcher dispatcher = request.getRequestDispatcher(loginForm);
            dispatcher.forward(request, response);
            return;
        }
    } else {
        redirectUrl = this.buildRedirectUrlToLoginPage(request, response, authException);
    }

    this.redirectStrategy.sendRedirect(request, response, redirectUrl);
}

DefaultLoginPageGeneratingFilter

经过上述重定向操作，客户端重新发起请求/hello，这个请求会在DefaultLoginPageGeneratingFilter被拦截下拉，并返回默认的登录页面

DefaultLoginPageGeneratingFilter的操作要简单些，当匹配到登录操作的时候（else)，会发送默认生成的页面，也就是我们看到的demo 登录页。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest)req;
    HttpServletResponse response = (HttpServletResponse)res;
    boolean loginError = this.isErrorPage(request);
    boolean logoutSuccess = this.isLogoutSuccess(request);
    if (!this.isLoginUrlRequest(request) && !loginError && !logoutSuccess) {
        chain.doFilter(request, response);
    } else {
        // 顾名思义，生成默认页面，详细代码可以点开generateLoginPageHtml方法
        String loginPageHtml = this.generateLoginPageHtml(request, loginError, logoutSuccess);
        response.setContentType("text/html;charset=UTF-8");
        response.setContentLength(loginPageHtml.getBytes(StandardCharsets.UTF_8).length);
        response.getWriter().write(loginPageHtml);
    }
}

小结

至此，解释了从输入/hello 到 重定向到 /login代码的原理，由于它的实现过程非常复杂，这里也只是定位到本次请求经过的代码链路操作。

除此之外，还有一个问题，就是生成了默认的登录页，那在哪里生成的默认账号和密码呢？后续将继续介绍

参考资料

《深入浅出Spring Security》王松

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla MySQL知识网络(一)-MYSQL结构体系 https://nerkeler.github.io/2023/07/21/MySQL%E7%9F%A5%E8%AF%86%E7%BD%91%E7%BB%9C-%E4%B8%80-MYSQL%E7%BB%93%E6%9E%84%E4%BD%93%E7%B3%BB/ 2023-07-21T06:20:00.000Z 2025-05-25T07:21:11.407Z

MySQL知识网络（一）

一条SQL是怎么执行的

入门java时观看宋红康老师的视频中有句话让我印象深刻，大处着眼，小处着手。学习一个新的技术，应该先鸟瞰其全貌，从高维度理解问题。在我们输入一个简单的SQL查询语句时，心中应该对他的整体执行流程有个概念，做到胸有成竹，才能在遇到问题时，准确定位，进而根据情况对应解决方案。而想要做到这点，不得不提的就是MYSQL结构体系。

MYSQL结构体系(Server层)

大体来说，MySQL可以分为Server层和存储引擎层两部分

Server层包括连接器、查询缓存、分析器、优化器、执行器等，涵盖MySQL的大多数核心服务功能，以及所有的内置函数（如日期、时间、数学和加密函数等），所有跨存储引擎的功能都在这一层实现，比如存存过程、触发器、视图等。

存储引擎层负责数据的存储和提取，其架构模式是插件式的，支持InnoDB、MyISAM、Memory等多个存储引擎。现在最常用的存储引擎是InnoDB,它从MySQL 5.5.5版本开始成为了默认存储引擎。

连接器和安全管理

1
mysql -h$ip -P$port -u$user -p

使用上述命令登录mysql服务器，其中

  • h （host）代表host 也就是主机ip
  • p (port)代表端口
  • u (user)代表用户名
  • p (password)代表密码，-p后面没填写密码是为了在终端中不可见的输入密码，一定程度上避免密码泄露。

我们一般使用的可视化工具需要提供的也是上述参数，如navicat

除了常规的账号密码登录，也可以使用套接字（SSL）登录，一旦客户端链接成功，服务器会继续验证客户端是否具有执行某个特定查询的权限。

查询缓存

在建立连接后，则进入了Server层执行查询条件，而查询首先要做的就是查询缓存

如上图中所示，MySQL在拿到一个查询请求后首先回到查询缓存中看看之前是否执行过这条语句。之前执行的语句及结果会以key-value形式存储在内存中，如果在缓存中找到这个查询语句的key，则直接返回value。反之则会继续后续的查询流程。

直接从缓存中查询会大大提高查询效率，但是实际使用中并不推荐这么做，因为在原SQL涉及表中，如果任一表格中的数据被更新（包括新建和删除），缓存则将失效，对于更新频繁的表格，缓存命中的几率会很小。缓存的使用则适合表更新不频繁情景下。

MySQL 8.0版本直接将查询缓存的整块功能删掉了，也就是说8.0开始彻底没有缓存功能了。

分析器

如果没有命中查询缓存，则进入分析器阶段进行此法分析和语法分析

所谓词法分析就是将我们输入的一整条SQL语句，拆解成对应的表名和字段等，语法分析则是根据MySQL语法规则判断输入的SQL语句是否符合语法。

举个例子，当我们输入以下SQL语句，则会收到“You have an error in your SQL syntax”的错误提醒。原因则是select少打了一个t

1
2
3
selec * from t where ID=1; 

-- 1064 - You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SELEC * FROM `T`' at line 1

优化器

经过了分析器，MySQL就知道你要做什么了。在开始执行之前，还要先经过优化器的处理。

优化器是在表中有多个索引的时候决定使用哪个索引，或者在一个语句关联多张表的时候，决定各个表的链接顺序

1
select * from t1 join t2 using(ID)  where t1.c=10 and t2.d=20;
  • 即可以先从表t1里面取出 c=10的记录的ID值，再根据ID值关联到表t2,再判断t2里面的d的值是否等于20
  • 也可以先从t2里面取出d = 20的ID值，再根据ID关联T1，再判断t1的c值是否等于10

这两种执行方法的逻辑结果是一样的，但是执行的效率会有不同，而优化器的作用就是决定选择使用哪一个方案。

执行器

分析器告诉我们改做什么，优化器告诉我们改怎么做，那么执行器就是要具体去做了

不过再执行之前测绘判断一下当前用户对SQL语句涉及到的表是否有执行查询的权限，如果没有，那边就会返回没有权限的错误。

如果有权限，则打开表执行查询语句，执行器通过表的引擎定义，去使用这个引擎提供的接口（如InnoDB)

1
2
3
show table STATUS

-- ordersInnoDB10Dynamic2081916384000212023-07-21 02:09:312023-07-21 02:10:01utf8mb4_0900_ai_ci

使用上述命令会展示当前表的信息, 其中InnoDB 表示这张表使用的引擎是InnoDB.

具体查询表格的细节后续会再详细描述。

MySQL的存储引擎

MySQL的存储引擎有很多，本文只简略介绍几个常见的，并且也不会详细介绍，只是为了做到有个印象。

InnoDB存储引擎

InnoDB是MySQL的默认事务型存储引擎，采用MVCC支持高并发，并实现了四个标准的隔离级别。其默认的隔离级别是REPEATABLE READ（可重复读），并且通过间隙锁（next-key locking)策略防止幻读的出现，间隙锁使得InnoDB不仅仅锁定查询涉及的行，还会对索引中的间隙进行锁定，以防止幻影行的插入。

MyISAM存储引擎

再MySQL5.1及之前的版本中，MyISAM是默认的存储引擎。MyISAM提供了大量的特性，包括全文索引、压缩、控件函数（GIS)等，但MyISAM不支持事务和行级锁，而且再崩溃后无法安全恢复。

现在MySQL默认引擎已经是InnoDB，所以MyISAM就不过多讨论了，需要知道的是MyISAM不支持事务，并且只支持表锁。

Memory引擎

类似于Redis,Memory引擎把所有的数据都保存再内存中，因而查询速度很快，因为存储再内存中，所以数据再机器重启后会丢失，但是表结构会保留。

当执行MySQL查询时需要使用临时表保存中间结果，这时候使用的临时表就是Memory表，不过当结果太大超出Memory表限制或者含有BLOB或者TEXT字段，临时表会转换位MyISAM表。

小结

通过一条SQL的执行流程，简略介绍了MySQL中的内部结构组成，包括 连接器、分析器、优化器、执行器、和MySQL的存储引擎，文章主要还是简略介绍，只是为了有个整体的概念，相关细节待后续补充

参考资料

林晓斌-极客时间MySQL45讲

《高性能MySQL》

《MySQL技术内幕-InnoDB存储引擎》

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla JWT详解 https://nerkeler.github.io/2023/06/27/JWT%E8%AF%A6%E8%A7%A3/ 2023-06-27T05:55:00.000Z 2024-01-04T01:47:47.890Z

JWT详解

转载自：JWT详解 (baobao555.tech)*

JWT简介

1.什么是JWT

在介绍JWT之前，我们先来回顾一下利用token进行用户身份验证的流程：

  1. 客户端使用用户名和密码请求登录
  2. 服务端收到请求，验证用户名和密码
  3. 验证成功后，服务端会签发一个token，再把这个token返回给客户端
  4. 客户端收到token后可以把它存储起来，比如放到cookie中
  5. 客户端每次向服务端请求资源时需要携带服务端签发的token，可以在cookie或者header中携带
  6. 服务端收到请求，然后去验证客户端请求里面带着的token，如果验证成功，就向客户端返回请求数据

这种基于token的认证方式相比传统的session认证方式更节约服务器资源，并且对移动端和分布式更加友好。其优点如下：

  • 支持跨域访问：cookie是无法跨域的，而token由于没有用到cookie(前提是将token放到请求头中)，所以跨域后不会存在信息丢失问题
  • 无状态：token机制在服务端不需要存储session信息，因为token自身包含了所有登录用户的信息，所以可以减轻服务端压力
  • 更适用CDN：可以通过内容分发网络请求服务端的所有资料
  • 更适用于移动端：当客户端是非浏览器平台时，cookie是不被支持的，此时采用token认证方式会简单很多
  • 无需考虑CSRF：由于不再依赖cookie，所以采用token认证方式不会发生CSRF，所以也就无需考虑CSRF的防御

而JWT就是上述流程当中token的一种具体实现方式，其全称是JSON Web Token，官网地址：https://jwt.io/

通俗地说，JWT的本质就是一个字符串，它是将用户信息保存到一个Json字符串中，然后进行编码后得到一个JWT token，并且这个JWT token带有签名信息，接收后可以校验是否被篡改，所以可以用于在各方之间安全地将信息作为Json对象传输。JWT的认证流程如下：

  1. 首先，前端通过Web表单将自己的用户名和密码发送到后端的接口，这个过程一般是一个POST请求。建议的方式是通过SSL加密的传输(HTTPS)，从而避免敏感信息被嗅探
  2. 后端核对用户名和密码成功后，将包含用户信息的数据作为JWT的Payload，将其与JWT Header分别进行Base64编码拼接后签名，形成一个JWT Token，形成的JWT Token就是一个如同lll.zzz.xxx的字符串
  3. 后端将JWT Token字符串作为登录成功的结果返回给前端。前端可以将返回的结果保存在浏览器中，退出登录时删除保存的JWT Token即可
  4. 前端在每次请求时将JWT Token放入HTTP请求头中的Authorization属性中(解决XSS和XSRF问题)
  5. 后端检查前端传过来的JWT Token，验证其有效性，比如检查签名是否正确、是否过期、token的接收方是否是自己等等
  6. 验证通过后，后端解析出JWT Token中包含的用户信息，进行其他逻辑操作(一般是根据用户信息得到权限等)，返回结果

2.为什么要用JWT

2.1 传统Session认证的弊端

我们知道HTTP本身是一种无状态的协议，这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，认证通过后HTTP协议不会记录下认证后的状态，那么下一次请求时，用户还要再一次进行认证，因为根据HTTP协议，我们并不知道是哪个用户发出的请求，所以为了让我们的应用能识别是哪个用户发出的请求，我们只能在用户首次登录成功后，在服务器存储一份用户登录的信息，这份登录信息会在响应时传递给浏览器，告诉其保存为cookie，以便下次请求时发送给我们的应用，这样我们的应用就能识别请求来自哪个用户了，这是传统的基于session认证的过程

然而，传统的session认证有如下的问题：

  • 每个用户的登录信息都会保存到服务器的session中，随着用户的增多，服务器开销会明显增大
  • 由于session是存在与服务器的物理内存中，所以在分布式系统中，这种方式将会失效。虽然可以将session统一保存到Redis中，但是这样做无疑增加了系统的复杂性，对于不需要redis的应用也会白白多引入一个缓存中间件
  • 对于非浏览器的客户端、手机移动端等不适用，因为session依赖于cookie，而移动端经常没有cookie
  • 因为session认证本质基于cookie，所以如果cookie被截获，用户很容易收到跨站请求伪造攻击。并且如果浏览器禁用了cookie，这种方式也会失效
  • 前后端分离系统中更加不适用，后端部署复杂，前端发送的请求往往经过多个中间件到达后端，cookie中关于session的信息会转发多次
  • 由于基于Cookie，而cookie无法跨域，所以session的认证也无法跨域，对单点登录不适用

2.2 JWT认证的优势

对比传统的session认证方式，JWT的优势是：

  • 简洁：JWT Token数据量小，传输速度也很快
  • 因为JWT Token是以JSON加密形式保存在客户端的，所以JWT是跨语言的，原则上任何web形式都支持
  • 不需要在服务端保存会话信息，也就是说不依赖于cookie和session，所以没有了传统session认证的弊端，特别适用于分布式微服务
  • 单点登录友好：使用Session进行身份认证的话，由于cookie无法跨域，难以实现单点登录。但是，使用token进行认证的话， token可以被保存在客户端的任意位置的内存中，不一定是cookie，所以不依赖cookie，不会存在这些问题
  • 适合移动端应用：使用Session进行身份认证的话，需要保存一份信息在服务器端，而且这种方式会依赖到Cookie（需要 Cookie 保存 SessionId），所以不适合移动端

因为这些优势，目前无论单体应用还是分布式应用，都更加推荐用JWT token的方式进行用户认证

JWT结构

JWT由3部分组成：标头(Header)、有效载荷(Payload)和签名(Signature)。在传输的时候，会将JWT的3部分分别进行Base64编码后用.进行连接形成最终传输的字符串

JWTString\=Base64(Header).Base64(Payload).HMACSHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)

JWTString = Base64(Header).Base64(Payload).HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)

1.Header

JWT头是一个描述JWT元数据的JSON对象，alg属性表示签名使用的算法，默认为HMAC SHA256（写为HS256）；typ属性表示令牌的类型，JWT令牌统一写为JWT。最后，使用Base64 URL算法将上述JSON对象转换为字符串保存

1
2
3
4
{
  "alg": "HS256",
  "typ": "JWT"
}

2.Payload

有效载荷部分，是JWT的主体内容部分，也是一个JSON对象，包含需要传递的数据。 JWT指定七个默认字段供选择

1
2
3
4
5
6
7
iss：发行人
exp：到期时间
sub：主题
aud：用户
nbf：在此之前不可用
iat：发布时间
jti：JWT ID用于标识该JWT

除以上默认字段外，我们还可以自定义私有字段，一般会把包含用户信息的数据放到payload中，如下例：

1
2
3
4
5
{
  "sub": "1234567890",
  "name": "Helen",
  "admin": true
}

请注意，默认情况下JWT是未加密的，因为只是采用base64算法，拿到JWT字符串后可以转换回原本的JSON数据，任何人都可以解读其内容，因此不要构建隐私信息字段，比如用户的密码一定不能保存到JWT中，以防止信息泄露。JWT只是适合在网络中传输一些非敏感的信息

3.Signature

签名哈希部分是对上面两部分数据签名，需要使用base64编码后的header和payload数据，通过指定的算法生成哈希，以确保数据不会被篡改。首先，需要指定一个密钥（secret）。该密码仅仅为保存在服务器中，并且不能向用户公开。然后，使用header中指定的签名算法（默认情况下为HMAC SHA256）根据以下公式生成签名

1
HMACSHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)

在计算出签名哈希后，JWT头，有效载荷和签名哈希的三个部分组合成一个字符串，每个部分用.分隔，就构成整个JWT对象

注意JWT每部分的作用，在服务端接收到客户端发送过来的JWT token之后：

  • header和payload可以直接利用base64解码出原文，从header中获取哈希签名的算法，从payload中获取有效数据
  • signature由于使用了不可逆的加密算法，无法解码出原文，它的作用是校验token有没有被篡改。服务端获取header中的加密算法之后，利用该算法加上secretKey对header、payload进行加密，比对加密后的数据和客户端发送过来的是否一致。注意secretKey只能保存在服务端，而且对于不同的加密算法其含义有所不同，一般对于MD5类型的摘要加密算法，secretKey实际上代表的是盐值

JWT的种类

其实JWT(JSON Web Token)指的是一种规范，这种规范允许我们使用JWT在两个组织之间传递安全可靠的信息，JWT的具体实现可以分为以下几种：

  • nonsecure JWT：未经过签名，不安全的JWT
  • JWS：经过签名的JWT
  • JWE：payload部分经过加密的JWT

1.nonsecure JWT

未经过签名，不安全的JWT。其header部分没有指定签名算法{

1
2
3
4
{
  "alg": "none",
  "typ": "JWT"
}

并且也没有Signature部分

2.JWS

JWS ，也就是JWT Signature，其结构就是在之前nonsecure JWT的基础上，在头部声明签名算法，并在最后添加上签名。创建签名，是保证jwt不能被他人随意篡改。我们通常使用的JWT一般都是JWS

为了完成签名，除了用到header信息和payload信息外，还需要算法的密钥，也就是secretKey。加密的算法一般有2类：

  • 对称加密：secretKey指加密密钥，可以生成签名与验签
  • 非对称加密：secretKey指私钥，只用来生成签名，不能用来验签(验签用的是公钥)

JWT的密钥或者密钥对，一般统一称为JSON Web Key，也就是JWK

到目前为止，jwt的签名算法有三种：

  • HMAC【哈希消息验证码(对称)】：HS256/HS384/HS512
  • RSASSA【RSA签名算法(非对称)】（RS256/RS384/RS512）
  • ECDSA【椭圆曲线数据签名算法(非对称)】（ES256/ES384/ES512）

Java中使用JWT

官网推荐了6个Java使用JWT的开源库，其中比较推荐使用的是java-jwt和jjwt-root

1.java-jwt

1.1 对称签名

首先引入依赖

1
2
3
4
5
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.10.3</version>
</dependency>

生成JWT的token

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class JWTTest {
    @Test
    public void testGenerateToken(){
        // 指定token过期时间为10秒
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND, 10);

        String token = JWT.create()
                .withHeader(new HashMap<>())  // Header
                .withClaim("userId", 21)  // Payload
                .withClaim("userName", "baobao")
                .withExpiresAt(calendar.getTime())  // 过期时间
                .sign(Algorithm.HMAC256("!34ADAS"));  // 签名用的secret

        System.out.println(token);
    }
}

注意多次运行方法生成的token字符串内容是不一样的，尽管我们的payload信息没有变动。因为JWT中携带了超时时间，所以每次生成的token会不一样，我们利用base64解密工具可以发现payload确实携带了超时时间

解析JWT字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
public void testResolveToken(){
    // 创建解析对象，使用的算法和secret要与创建token时保持一致
    JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("!34ADAS")).build();
    // 解析指定的token
    DecodedJWT decodedJWT = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6ImJhb2JhbyIsImV4cCI6MTU5OTkyMjUyOCwidXNlcklkIjoyMX0.YhA3kh9KZOAb7om1C7o3vBhYp0f61mhQWWOoCrrhqvo");
    // 获取解析后的token中的payload信息
    Claim userId = decodedJWT.getClaim("userId");
    Claim userName = decodedJWT.getClaim("userName");
    System.out.println(userId.asInt());
    System.out.println(userName.asString());
    // 输出超时时间
    System.out.println(decodedJWT.getExpiresAt());
}

运行后发现报异常，原因是之前生成的token已经过期

再运行一次生成token的方法，然后在过期时间10秒之内将生成的字符串拷贝到解析方法中，运行解析方法即可成功

我们可以将上述方法封装成工具类

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
public class JWTUtils {
    // 签名密钥
    private static final String SECRET = "!DAR$";

    /**
     * 生成token
     * @param payload token携带的信息
     * @return token字符串
     */
    public static String getToken(Map<String,String> payload){
        // 指定token过期时间为7天
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE, 7);

        JWTCreator.Builder builder = JWT.create();
        // 构建payload
        payload.forEach((k,v) -> builder.withClaim(k,v));
        // 指定过期时间和签名算法
        String token = builder.withExpiresAt(calendar.getTime()).sign(Algorithm.HMAC256(SECRET));
        return token;
    }


    /**
     * 解析token
     * @param token token字符串
     * @return 解析后的token
     */
    public static DecodedJWT decode(String token){
        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(SECRET)).build();
        DecodedJWT decodedJWT = jwtVerifier.verify(token);
        return decodedJWT;
    }
}

1.2 非对称签名

生成jwt串的时候需要指定私钥，解析jwt串的时候需要指定公钥

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
private static final String RSA_PRIVATE_KEY = "...";
private static final String RSA_PUBLIC_KEY = "...";

/**
     * 生成token
     * @param payload token携带的信息
     * @return token字符串
     */
public static String getTokenRsa(Map<String,String> payload){
    // 指定token过期时间为7天
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.DATE, 7);

    JWTCreator.Builder builder = JWT.create();
    // 构建payload
    payload.forEach((k,v) -> builder.withClaim(k,v));

    // 利用hutool创建RSA
    RSA rsa = new RSA(RSA_PRIVATE_KEY, null);
    // 获取私钥
    RSAPrivateKey privateKey = (RSAPrivateKey) rsa.getPrivateKey();
    // 签名时传入私钥
    String token = builder.withExpiresAt(calendar.getTime()).sign(Algorithm.RSA256(null, privateKey));
    return token;
}

/**
     * 解析token
     * @param token token字符串
     * @return 解析后的token
     */
public static DecodedJWT decodeRsa(String token){
    // 利用hutool创建RSA
    RSA rsa = new RSA(null, RSA_PUBLIC_KEY);
    // 获取RSA公钥
    RSAPublicKey publicKey = (RSAPublicKey) rsa.getPublicKey();
    // 验签时传入公钥
    JWTVerifier jwtVerifier = JWT.require(Algorithm.RSA256(publicKey, null)).build();
    DecodedJWT decodedJWT = jwtVerifier.verify(token);
    return decodedJWT;
}

2.jjwt-root

2.1 对称签名

引入依赖

1
2
3
4
5
6
7
8
<!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>


使用方法类似，可参考下列代码

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
public class JwtUtils {
    // token时效：24小时
    public static final long EXPIRE = 1000 * 60 * 60 * 24;
    // 签名哈希的密钥，对于不同的加密算法来说含义不同
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHO";

    /**
     * 根据用户id和昵称生成token
     * @param id  用户id
     * @param nickname 用户昵称
     * @return JWT规则生成的token
     */
    public static String getJwtToken(String id, String nickname){
        String JwtToken = Jwts.builder()
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                .setSubject("baobao-user")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                .claim("id", id)
                .claim("nickname", nickname)
            // HS256算法实际上就是MD5加盐值，此时APP_SECRET就代表盐值
                .signWith(SignatureAlgorithm.HS256, APP_SECRET)
                .compact();

        return JwtToken;
    }

    /**
     * 判断token是否存在与有效
     * @param jwtToken token字符串
     * @return 如果token有效返回true，否则返回false
     */
    public static boolean checkToken(String jwtToken) {
        if(StringUtils.isEmpty(jwtToken)) return false;
        try {
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 判断token是否存在与有效
     * @param request Http请求对象
     * @return 如果token有效返回true，否则返回false
     */
    public static boolean checkToken(HttpServletRequest request) {
        try {
            // 从http请求头中获取token字符串
            String jwtToken = request.getHeader("token");
            if(StringUtils.isEmpty(jwtToken)) return false;
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 根据token获取会员id
     * @param request Http请求对象
     * @return 解析token后获得的用户id
     */
    public static String getMemberIdByJwtToken(HttpServletRequest request) {
        String jwtToken = request.getHeader("token");
        if(StringUtils.isEmpty(jwtToken)) return "";
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        Claims claims = claimsJws.getBody();
        return (String)claims.get("id");
    }
}

注意：

  • jjwt在0.10版本以后发生了较大变化，pom依赖要引入多个
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.2</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId> <!-- or jjwt-gson if Gson is preferred -->
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>

  • 标准规范中对各种加密算法的secretKey的长度有如下要求：

    • HS256：要求至少 256 bits (32 bytes)
    • HS384：要求至少384 bits (48 bytes)
    • HS512：要求至少512 bits (64 bytes)
    • RS256 and PS256：至少2048 bits
    • RS384 and PS384：至少3072 bits
    • RS512 and PS512：至少4096 bits
    • ES256：至少256 bits (32 bytes)
    • ES384：至少384 bits (48 bytes)
    • ES512：至少512 bits (64 bytes)

    在jjwt0.10版本之前，没有强制要求，secretKey长度不满足要求时也可以签名成功。但是0.10版本后强制要求secretKey满足规范中的长度要求，否则生成jws时会抛出异常

  • 新版本的jjwt中，之前的签名和验签方法都是传入密钥的字符串，已经过时。最新的方法需要传入Key对象

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
public class JwtUtils {
    // token时效：24小时
    public static final long EXPIRE = 1000 * 60 * 60 * 24;
    // 签名哈希的密钥，对于不同的加密算法来说含义不同
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHOsdadasdasfdssfeweee";

    /**
     * 根据用户id和昵称生成token
     * @param id  用户id
     * @param nickname 用户昵称
     * @return JWT规则生成的token
     */
    public static String getJwtToken(String id, String nickname){
        String JwtToken = Jwts.builder()
                .setSubject("baobao-user")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                .claim("id", id)
                .claim("nickname", nickname)
                // 传入Key对象
                .signWith(Keys.hmacShaKeyFor(APP_SECRET.getBytes(StandardCharsets.UTF_8)), SignatureAlgorithm.HS256)
                .compact();
        return JwtToken;
    }

    /**
     * 判断token是否存在与有效
     * @param jwtToken token字符串
     * @return 如果token有效返回true，否则返回false
     */
    public static Jws<Claims> decode(String jwtToken) {
        // 传入Key对象
        Jws<Claims> claimsJws = Jwts.parserBuilder().setSigningKey(Keys.hmacShaKeyFor(APP_SECRET.getBytes(StandardCharsets.UTF_8))).build().parseClaimsJws(jwtToken);
        return claimsJws;
    }
}

2.2 非对称签名

生成jwt串的时候需要指定私钥，解析jwt串的时候需要指定公钥

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
private static final String RSA_PRIVATE_KEY = "...";
private static final String RSA_PUBLIC_KEY = "...";

/**
     * 根据用户id和昵称生成token
     * @param id  用户id
     * @param nickname 用户昵称
     * @return JWT规则生成的token
     */
public static String getJwtTokenRsa(String id, String nickname){
    // 利用hutool创建RSA
    RSA rsa = new RSA(RSA_PRIVATE_KEY, null);
    RSAPrivateKey privateKey = (RSAPrivateKey) rsa.getPrivateKey();
    String JwtToken = Jwts.builder()
        .setSubject("baobao-user")
        .setIssuedAt(new Date())
        .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
        .claim("id", id)
        .claim("nickname", nickname)
        // 签名指定私钥
        .signWith(privateKey, SignatureAlgorithm.RS256)
        .compact();
    return JwtToken;
}

/**
     * 判断token是否存在与有效
     * @param jwtToken token字符串
     * @return 如果token有效返回true，否则返回false
     */
public static Jws<Claims> decodeRsa(String jwtToken) {
    RSA rsa = new RSA(null, RSA_PUBLIC_KEY);
    RSAPublicKey publicKey = (RSAPublicKey) rsa.getPublicKey();
    // 验签指定公钥
    Jws<Claims> claimsJws = Jwts.parserBuilder().setSigningKey(publicKey).build().parseClaimsJws(jwtToken);
    return claimsJws;
}

实际开发中的应用

在实际的SpringBoot项目中，一般我们可以用如下流程做登录：

  1. 在登录验证通过后，给用户生成一个对应的随机token(注意这个token不是指jwt，可以用uuid等算法生成)，然后将这个token作为key的一部分，用户信息作为value存入Redis，并设置过期时间，这个过期时间就是登录失效的时间
  2. 将第1步中生成的随机token作为JWT的payload生成JWT字符串返回给前端
  3. 前端之后每次请求都在请求头中的Authorization字段中携带JWT字符串
  4. 后端定义一个拦截器，每次收到前端请求时，都先从请求头中的Authorization字段中取出JWT字符串并进行验证，验证通过后解析出payload中的随机token，然后再用这个随机token得到key，从Redis中获取用户信息，如果能获取到就说明用户已经登录
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
public class JWTInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String JWT = request.getHeader("Authorization");
        try {
            // 1.校验JWT字符串
            DecodedJWT decodedJWT = JWTUtils.decode(JWT);
            // 2.取出JWT字符串载荷中的随机token，从Redis中获取用户信息
            ...
            return true;
        }catch (SignatureVerificationException e){
            System.out.println("无效签名");
            e.printStackTrace();
        }catch (TokenExpiredException e){
            System.out.println("token已经过期");
            e.printStackTrace();
        }catch (AlgorithmMismatchException e){
            System.out.println("算法不一致");
            e.printStackTrace();
        }catch (Exception e){
            System.out.println("token无效");
            e.printStackTrace();
        }
        return false;
    }
}

在实际开发中需要用下列手段来增加JWT的安全性：

  • 因为JWT是在请求头中传递的，所以为了避免网络劫持，推荐使用HTTPS来传输，更加安全
  • JWT的哈希签名的密钥是存放在服务端的，所以只要服务器不被攻破，理论上JWT是安全的。因此要保证服务器的安全
  • JWT可以使用暴力穷举来破解，所以为了应对这种破解方式，可以定期更换服务端的哈希签名密钥(相当于盐值)。这样可以保证等破解结果出来了，你的密钥也已经换了
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla EasyExcel 数值型和最后一列超出文本框问题 https://nerkeler.github.io/2023/06/27/EasyExcel-%E6%95%B0%E5%80%BC%E5%9E%8B%E5%92%8C%E6%9C%80%E5%90%8E%E4%B8%80%E5%88%97%E8%B6%85%E5%87%BA%E6%96%87%E6%9C%AC%E6%A1%86%E9%97%AE%E9%A2%98/ 2023-06-27T02:49:00.000Z 2025-05-25T07:22:08.383Z

EasyExcel 数值型和最后一列超出文本框问题

Alibaba出品的EasyExcel对比原版excel库POI，极大的简化了开发人员的代码编写工作。EasyExcel使用注解和监听器等简化读写开发，

问题说明

在我的日常工作中，很大一部分的工作都是将数据库的数据整理归纳后导出为Excel，当然会碰到许许多多的问题，比如导出超时（当然这个问题大多数都是SQL执行的问题，日常几十万条数据的excel并不会花费多少时间），字段类型与需求不匹配、文本超出单元格、动态头…..

这里主要记录和说明其中几个问题

  • 字段类型不匹配
  • 最后一列文本内容超出单元格

字段类型不匹配

解决方法可看easyexcel 官方github Issues :https://github.com/alibaba/easyexcel/issues/2409

问题展示

如上图所示，当我们设置实体类的属性为字符串型时，默认导出的时候数值型会模糊单元格的格式，所以上方有个三角符号，这时候excel是无法进行数值的求和汇总等运算的。

分析

我们看一下导出excel时的实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Data
public class Student implements Serializable {

    @ExcelProperty( "学生编号")
    private String id;

    @ExcelProperty( "学生姓名")
    private String name;

    @ExcelProperty( "学生生日")
    @DateTimeFormat("yyyy-mm-dd")
    private Date birthday;

    @ExcelProperty("学号")
    private String stuNo;
}

注意 private String stuNo;为String类型，这里就是导致导出excel无法确定单元格格式的主要原因。

解决方法

修改方式很简单，将String改为对应的数值型格式即可如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Data
public class Student implements Serializable {

    @ExcelProperty( "学生编号")
    private String id;

    @ExcelProperty( "学生姓名")
    private String name;

    @ExcelProperty( "学生生日")
    @DateTimeFormat("yyyy-mm-dd")
    private Date birthday;

    @ExcelProperty("学号")
    private Integer stuNo;
}

结果

PS: 第一列仍为String类型，所以导出仍有三角符号。

最后一列文本内容超出单元格

这个问题我在issues 中没有找到，可能问题比较简单:joy::joy::joy:

先说一下思路，构造出一列空值覆盖前一列内容超出部分，再手动生成标题头

问题

如果最后一列导出为长文本字符型时，很容易超出单元格，观感不佳，现象如下。

分析

我们看一下实体类多加了一个note字段，这个也就是上方长文本的字段。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Data
public class Student implements Serializable {

    @ExcelProperty( "学生编号")
    private String id;

    @ExcelProperty( "学生姓名")
    private String name;

    @ExcelProperty( "学生生日")
    @DateTimeFormat("yyyy-mm-dd")
    private Date birthday;

    @ExcelProperty("学号")
    private Integer stuNo;

    @ExcelProperty("备注")
    private String note;
}

解决方法

我们首先看一下导出代码

1
2
3
4
EasyExcel.write("学生信息表.xlsx", Student.class)
        .sheet()
        .head(Student.class)
        .doWrite(WriteDemo.getData());

注意一下其中的方法和参数write()和head()

write()重载方法入参

  • File file
  • File file,@Nullable Class head
  • String pathName
  • String pathName, @Nullable Class head
  • outputStream outputStream
  • outputStream outputStream, @Nullable Class head

所有的重载方法入参第一个都是确定文件名称（File ）和位置（pathName），outputStream 是web上传、下载。我们关注后面一个参数 Class head这里指定了导出文件的head，同head方法功能相似，也就是说，这里我们去到 .head(Student.class)或者.write("学生信息表.xlsx", Student.class)中的Student.class都是正常的。

简单分析一下源代码
write
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class EasyExcelFactory {
    public static ExcelWriterBuilder write(String pathName, Class head) {
        ExcelWriterBuilder excelWriterBuilder = new ExcelWriterBuilder();
        excelWriterBuilder.file(pathName);
        if (head != null) {
            excelWriterBuilder.head(head);
        }

        return excelWriterBuilder;
    }
}


public abstract class AbstractParameterBuilder<T extends AbstractParameterBuilder, C extends BasicParameter> {
 

    public T head(Class clazz) {
        this.parameter().setClazz(clazz);
        return this.self();
    }
}

我们可以看到这里给excelWriterBuilder设置了一个head然后调用了AbstractParameterBuilder的head方法

1
2
3
4
5
6
7
8
9
10
public abstract class AbstractParameterBuilder<T extends AbstractParameterBuilder, C extends BasicParameter> {
 /***/
    public T head(Class clazz) {
        this.parameter().setClazz(clazz);
        return this.self();
    }
     /***/
    protected abstract C parameter();
     /***/
}

这里给 this.parameter()设置了类名，这里的this.parameter指的是AbstractParameterBuilder 中的protected abstract C parameter();方法，我们可以看到，这里其实本质上是调用了同一个方法。

head的特别之处

head方法本质上是用来动态生成头文件的，详情可参照官方文档https://easyexcel.opensource.alibaba.com/docs/current/quickstart/write#%E5%8A%A8%E6%80%81%E5%A4%B4%E5%AE%9E%E6%97%B6%E7%94%9F%E6%88%90%E5%A4%B4%E5%86%99%E5%85%A5

如果我们再write方法上没有指定标题头，则可以手动通过head方法构造，这样我们就可以实现最后一列不出单元格了

具体实现

先修改导出实体类添加一个占位符并赋初始值为空（注意，如果没有赋值为空字符串，则不会写入excel进行覆盖前一列）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Data
public class Student implements Serializable {

    @ExcelProperty( "学生编号")
    private String id;

    @ExcelProperty( "学生姓名")
    private String name;

    @ExcelProperty( "学生生日")
    @DateTimeFormat("yyyy-mm-dd")
    private Date birthday;

    @ExcelProperty("学号")
    private Integer stuNo;

    @ExcelProperty("备注")
    private String note;

    // 占位符
    private String palaceHolder = "";
}

手动构造头文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private List<List<String>> setHead() {

    List<String> list = Arrays.asList(
            "学生编号",
            "学生姓名",
            "学生生日",
            "学号",
            "备注"
    );

    return list.stream()
            .map(Arrays::asList)
            .collect(Collectors.toList());

}

最后生成excel

1
2
3
4
5
6
7
8
9
10
public void dynamicHeadWrite() {


    EasyExcel.write("学生信息表.xlsx")
            .sheet()
            .head(setHead())
            .doWrite(WriteDemo.getData());


}

结果

可以看到，最后一列内容没有超出单元格了。

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla Java中的并发工具类-CountDownLatch和CyclicBarrier https://nerkeler.github.io/2023/06/16/Java%E4%B8%AD%E7%9A%84%E5%B9%B6%E5%8F%91%E5%B7%A5%E5%85%B7%E7%B1%BB-CountDownLatch%E5%92%8CCyclicBarrier/ 2023-06-16T08:34:00.000Z 2024-01-04T01:49:49.425Z

Java中的并发工具类-CountDownLatch和CyclicBarrier

在JDK的并发包中，有几个非常有用的并发工具类，它们分别是：CountDownLatch、CyclicBarrier、Semaphore和Exchanger。

  • CountDownLatch（倒计时门闩）：它允许一个或多个线程等待其他线程完成操作后再继续执行。它通过一个计数器来实现，线程通过调用 countDown() 方法来减少计数器的值，await()方法进行阻塞等待计数器减少，当计数器达到零时，等待的线程将被释放。
  • CyclicBarrier（循环屏障）：它允许一组线程互相等待，直到到达一个共同的屏障点，然后继续执行后续操作。与CountDownLatch不同的是，CyclicBarrier的计数器可以重复使用（reset()方法），当所有等待线程都到达屏障点后，计数器会重置，线程可以继续下一次等待。
  • Semaphore（信号量）：它用于控制对某个资源的访问权限。Semaphore维护了一组许可证，线程在访问资源前需要获取许可证，如果许可证不可用，则线程必须等待，直到有可用的许可证。
  • Exchanger（交换器）：它提供了一种线程间交换数据的机制。两个线程可以通过Exchanger交换数据，当两个线程都调用 exchange() 方法后，他们会彼此交换数据，并继续执行后续操作。

CountDownLatch

Latch（门闩）设计模式

当多个线程并发执行任务，然后只有等待所有子任务全部完成进行汇总，程序的门闩才能打开让程序继续往下执行。它指定了一个屏障，只有所有条件都满足的时候，门阀才能打开。

比如小明和小红相约周末去爬山，约定在人民广场碰头，然后一同出发去爬山，他们各自从家里出发，无论是其中某一个先到达了人民广场都要等待另一个到达之后才可以继续进行下去，这里的人民广场碰头就相当于上述的门闩。

示例

还是使用上面的例子，我们模拟小明和小红从家出发，设定不同的等待时间模拟到达人民广场的路程耗时。代码如下

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
public static void main(String[] args) throws InterruptedException, ExecutionException {
        final int threadNum = 2;
        ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
        CountDownLatch countDownLatch = new CountDownLatch(threadNum);

        executorService.execute(() -> {

            System.out.println("小明开始出发");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();  // 计数器 -1
            System.out.println("小明到达人民广场");


        });
        executorService.execute(() -> {

            System.out.println("小红开始出发");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();  // 计数器 -1
            System.out.println("小红到达人民广场");


        });
        countDownLatch.await();
        System.out.println("小明和小红都到达了人民广场，开始一起出发去爬山");
        executorService.shutdown();

    }

结果

1
2
3
4
5
6
7
小明开始出发
小红开始出发
小明到达人民广场  // 2s后打印
小红到达人民广场  // 3s后打印
小明和小红都到达了人民广场，开始一起出发去爬山 //3s后打印

Process finished with exit code 0

与Join()的区别

可能这里会有疑问，使用Thread.join()也可以实现相同的功能，这与使用CountDownLatch有什么区别呢？

join()的实现

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 static void main(String[] args) throws InterruptedException {
    Thread thread1 = new Thread(() -> {
        System.out.println("小明开始出发");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("小明到达人民广场");

    }, "thread1");
    Thread thread2 = new Thread(() -> {
        System.out.println("小红开始出发");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("小红到达人民广场");

    }, "thread2");

    thread1.start();
    thread2.start();
    thread1.join();
    thread2.join();
    System.out.println("小明和小红都到达了人民广场，开始一起出发去爬山");

}

结果

1
2
3
4
5
6
7
小明开始出发
小红开始出发
小明到达人民广场  // 2s后打印
小红到达人民广场  // 3s后打印
小明和小红都到达了人民广场，开始一起出发去爬山 //3s后打印

Process finished with exit code 0

发现使用join()实现和countDownCatch实现好像在代码上的体现并没有太大差异，不急，我们接着往下看

join()实现原理

我们点进去join的jdk源码查看它的实现逻辑

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 final void join() throws InterruptedException {
    join(0);
}

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
// 调用join真正执行的方法
        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

我们看到他的核心代码就几行

1
2
3
while (isAlive()) {
    wait(0);
}

这几行代码不难理解，通过不停的检查join线程是否存活，如果线程状态是活动的，那么就一直等待下去（wait(0)表示永久等待），直到join线程中止后，线程的this.notifyAll()方法会被调用，不过调用notifyAll()方法是在JVM里 实现的，所以在JDK里看不到。

Join()与countDownLatch比较

回到上一个问题，join到底和countDownLatch有什么区别，countDownLatch底层使用了计数器来控制线程的唤醒，提供了更细粒度的线程控制，比如我们运行了100个线程，但是只需要80个线程执行结束就可以继续下去，那么使用join就不合适了。

综上所述 CountDownLatch相对于Join的优势：

  • CountDownLatch可以等待多个线程的完成，而Join只能等待一个线程。
  • CountDownLatch可以灵活地设置计数器的值，不仅仅限于线程数，可以根据需要自由控制。
  • CountDownLatch提供了更细粒度的线程间协作和控制，可以在任意位置进行countDown()和await()的调用，更灵活地控制线程的流程。

CountDownLatch程序实现

上面说了很多CountDownLatch的示例和与join比较，也提了一下CountDownLatch底层的原理，下面就看一下如何实现一个简单的CountDownLatch

程序

我们先新建一个抽象类，包含countDownLatch需要的参数和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public abstract class Latch {
    // 控制了多少线程完成后门阀才能打开
    protected int limit;

    // 构造函数
    public Latch(int limit){
        this.limit = limit;
    }

    // 方法使得线程一直等待
    public abstract void await() throws InterruptedException;

    // 当前任务线程完成工作之后调用该方法使得计数器减一
    public abstract void countDown();

    // 获取当前还有多少个线程没有完成任务
    public abstract int getUnArrived();

}

然后实现这个抽象类，并写入具体逻辑代码

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
public class CountDownLatch extends Latch {

    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();


    public CountDownLatch(int limit) {
        super(limit);
    }

    @Override
    public void await() throws InterruptedException {
        lock.lock();
        while (limit > 0){
            condition.await();
        }
        lock.unlock();
    }

    @Override
    public void countDown() {

        lock.lock();
        if(limit < 0){
            throw new IllegalStateException();
        }
        limit--;
        condition.signalAll();

        lock.unlock();

    }

    @Override
    public int getUnArrived() {
        return limit;
    }
}

测试

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
public class LatchDemo {
    public static void main(String[] args) throws InterruptedException {
        Latch latch = new CountDownLatch(2);

        ExecutorService executorService = Executors.newFixedThreadPool(2);

        executorService.execute(()->{
            System.out.println("小明开始出发");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            latch.countDown();  // 计数器 -1
            System.out.println("小明到达人民广场");
        });
        executorService.execute(()->{
            System.out.println("小红开始出发");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            latch.countDown();  // 计数器 -1
            System.out.println("小红到达人民广场");
        });


        latch.await();
        System.out.println("小明和小红都到达了人民广场，开始一起出发去爬山");

        executorService.shutdown();

    }
}

结果

1
2
3
4
5
6
7
小明开始出发
小红开始出发
小明到达人民广场
小红到达人民广场
小明和小红都到达了人民广场，开始一起出发去爬山

Process finished with exit code 0

可以看到结果如前文一致，这就实现了一个简单的CountDownLatch,当然具体实现还有更多的细节，如有需要，请翻阅源码。

总结

通过上面的简单实现，我们可以看到CountDownLatch基于计数器实现了多线程之间的门阀拦截，底层还是通过线程之间的通讯、锁和计数器控制。

CyclicBarrier

除了使用CountDownLatch来实现多线程之间的阻塞同步,也可以使用CyclicBarrier来实现，并且CyclicBarrier提供了比CountDownLatch更强大的功能。

CyclicBarrier的字面意思是可循环使用的屏障。它提供了一种同步机制，使一组线程能够在达到屏障时被阻塞，直到最后一个线程到达屏障时，屏障才会开启，所有被阻塞的线程才能继续执行。

网上找的一张示意图

示例

还是用之前的例子，模拟小明和小红去爬山，代码如下，结果就不赘述了。

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
public static void main(String[] args) throws InterruptedException, BrokenBarrierException {

    CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

    ExecutorService executorService = Executors.newFixedThreadPool(2);

    executorService.execute(()->{
        System.out.println("小明开始出发");
        try {
            TimeUnit.SECONDS.sleep(2);
            System.out.println("小明到达人民广场");
            cyclicBarrier.await(); // 计数器 -1
        } catch (Exception e) {
            e.printStackTrace();
        }

    });
    executorService.execute(()->{
        System.out.println("小红开始出发");
        try {
            TimeUnit.SECONDS.sleep(3);
            System.out.println("小红到达人民广场");
            cyclicBarrier.await(); // 计数器 -1
        } catch (Exception e) {
            e.printStackTrace();
        }
    });
    cyclicBarrier.await();
    System.out.println("小明和小红都到达了人民广场，开始一起出发去爬山");

    executorService.shutdown();

}

不同的是，这里我设置了三个屏障点 cyclicBarrier.await();，而使用CountDownLatch只用了两个计数器减一操作 + 一个wait()方法，使用起来很相似，我们说cyclicBarrier 比 CountDownLatch 功能更强大，那么强大在哪里呢？

重置计数器和获取状态

重置计数器

CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置。所以CyclicBarrier能处理更为复杂的业务场景。例如，如果计算发生错误，可以重置计数器，并让线程重新执行一次。

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
public static void main(String[] args) throws InterruptedException, BrokenBarrierException {

    final int threadNum = 3;
    ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
    CyclicBarrier cyclicBarrier = new CyclicBarrier(threadNum, () -> {
        System.out.println("所有线程都到达屏障");
    });

    for (int i = 0; i < threadNum; i++) {
        executorService.execute(() -> {
            System.out.println(Thread.currentThread().getName() + " 到达屏障");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        });
    }

    Thread.sleep(2000); // 等待一段时间，确保所有线程都到达屏障

    cyclicBarrier.reset(); // 重置屏障

    System.out.println("屏障已重置");

    for (int i = 0; i < threadNum-1; i++) {
        executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " 到达屏障");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        });
    }

    System.out.println("第二次进入 循环屏障");
    cyclicBarrier.await();
    System.out.println("第二次循环  迈过屏障");


    executorService.shutdown();


}

结果

1
2
3
4
5
6
7
8
9
10
11
12
13
pool-1-thread-2 到达屏障
pool-1-thread-3 到达屏障
pool-1-thread-1 到达屏障
所有线程都到达屏障
屏障已重置
第二次进入 循环屏障
pool-1-thread-2 到达屏障
pool-1-thread-1 到达屏障
所有线程都到达屏障
第二次循环  迈过屏障

Process finished with exit code 0

先说一下CyclicBarrier提供的另一个构造函数CyclicBarrier（int parties，Runnable barrierAction），用于在线程到达屏障时，优先执行barrierAction，也就是上方代码中用到的这几段

1
2
3
CyclicBarrier cyclicBarrier = new CyclicBarrier(threadNum, () -> {
    System.out.println("所有线程都到达屏障");
});

这里用于提示所有的线程到达屏障。紧接着是比较常规的代码，循环构造线程并在线程中执行了 cyclicBarrier.await();到达屏障。重点是 cyclicBarrier.reset(); 重置屏障后，我留下一个屏障给主线程测试使用，而在新构造的线程中停留1s, System.out.println("第二次循环 迈过屏障");打印在 System.out.println(Thread.currentThread().getName() + " 到达屏障");之后，说明屏障计数器已经重置并且生效了。

获取状态

除了上述的基本功能外，CyclicBarrier也提供了以下API用来查看状态，

  • getNumberWaiting() // 顾名思义，获取目前正在屏障处阻塞等待的线程数量。
  • getParties() // 获取屏障数量 也就是我们传入构造函数中的parties参数
  • isBroken() // 查询阻塞的线程是否被中断

参考资源

《Java并发编程的艺术》

《Java高并发编程详解》

jdk1.8 api文档

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla HashMap为什么线程不安全 https://nerkeler.github.io/2023/06/16/HashMap%E4%B8%BA%E4%BB%80%E4%B9%88%E7%BA%BF%E7%A8%8B%E4%B8%8D%E5%AE%89%E5%85%A8/ 2023-06-16T03:24:00.000Z 2024-01-04T01:51:03.391Z

HashMap为什么线程不安全

转载自：java - HashMap为什么线程不安全 - 个人文章 - SegmentFault 思否

一、学习目标

1、HashMap线程不安全原因：

原因：

  • JDK1.7 中，由于多线程对HashMap进行扩容，调用了HashMap#transfer()，具体原因：某个线程执行过程中，被挂起，其他线程已经完成数据迁移，等CPU资源释放后被挂起的线程重新执行之前的逻辑，数据已经被改变，造成死循环、数据丢失。
  • JDK1.8 中，由于多线程对HashMap进行put操作，调用了HashMap#putVal()，具体原因：假设两个线程A、B都在进行put操作，并且hash函数计算出的插入下标是相同的，当线程A执行完第六行代码后由于时间片耗尽导致被挂起，而线程B得到时间片后在该下标处插入了元素，完成了正常的插入，然后线程A获得时间片，由于之前已经进行了hash碰撞的判断，所有此时不会再进行判断，而是直接进行插入，这就导致了线程B插入的数据被线程A覆盖了，从而线程不安全。

改善：

  • 数据丢失、死循环已经在在JDK1.8中已经得到了很好的解决，如果你去阅读1.8的源码会发现找不到HashMap#transfer()，因为JDK1.8直接在HashMap#resize()中完成了数据迁移。

2、HashMap线程不安全的体现：

  • JDK1.7 HashMap线程不安全体现在：死循环、数据丢失
  • JDK1.8 HashMap线程不安全体现在：数据覆盖

二、HashMap线程不安全、死循环、数据丢失、数据覆盖的原因

1、JDK1.7 扩容引发的线程不安全

HashMap的线程不安全主要是发生在扩容函数中，其中调用了JDK1.7 HashMap #transfer()：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    for (Entry<K,V> e : table) {
        while(null != e) {
            Entry<K,V> next = e.next;
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            int i = indexFor(e.hash, newCapacity);
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

这段代码是HashMap的扩容操作，重新定位每个桶的下标，并采用头插法将元素迁移到新数组中。头插法会将链表的顺序翻转，这也是形成死循环的关键点。理解了头插法后再继续往下看是如何造成死循环以及数据丢失的。

2、扩容造成死循环和数据丢失

假设现在有两个线程A、B同时对下面这个HashMap进行扩容操作：

image

正常扩容后的结果是下面这样的：

image

但是当线程A执行到上面transfer函数的第11行代码时，CPU时间片耗尽，线程A被挂起。即如下图中位置所示：

image

此时线程A中：e=3、next=7、e.next=null

image

当线程A的时间片耗尽后，CPU开始执行线程B，并在线程B中成功的完成了数据迁移

image

重点来了，根据Java内存模式可知，线程B执行完数据迁移后，此时主内存中newTable和table都是最新的，也就是说：7.next=3、3.next=null。

随后线程A获得CPU时间片继续执行newTable[i] = e，将3放入新数组对应的位置，执行完此轮循环后线程A的情况如下：

image

接着继续执行下一轮循环，此时e=7，从主内存中读取e.next时发现主内存中7.next=3，此时next=3，并将7采用头插法的方式放入新数组中，并继续执行完此轮循环，结果如下：

image

此时没任何问题。

上轮next=3，e=3，执行下一次循环可以发现，3.next=null，所以此轮循环将会是最后一轮循环。

接下来当执行完e.next=newTable[i]即3.next=7后，3和7之间就相互连接了，当执行完newTable[i]=e后，3被头插法重新插入到链表中，执行结果如下图所示：

image

上面说了此时e.next=null即next=null，当执行完e=null后，将不会进行下一轮循环。到此线程A、B的扩容操作完成，很明显当线程A执行完后，HashMap中出现了环形结构，当在以后对该HashMap进行操作时会出现死循环。

并且从上图可以发现，元素5在扩容期间被莫名的丢失了，这就发生了数据丢失的问题。

3、JDK1.8中的线程不安全

上面的扩容造成的数据丢失、死循环已经在在JDK1.8中已经得到了很好的解决，如果你去阅读1.8的源码会发现找不到HashMap#transfer()，因为JDK1.8直接在HashMap#resize()中完成了数据迁移。

为什么说 JDK1.8会出现数据覆盖的情况？ 我们来看一下下面这段JDK1.8中的put操作代码：

image

其中第六行代码是判断是否出现hash碰撞，假设两个线程A、B都在进行put操作，并且hash函数计算出的插入下标是相同的，当线程A执行完第六行代码后由于时间片耗尽导致被挂起，而线程B得到时间片后在该下标处插入了元素，完成了正常的插入，然后线程A获得时间片，由于之前已经进行了hash碰撞的判断，所有此时不会再进行判断，而是直接进行插入，这就导致了线程B插入的数据被线程A覆盖了，从而线程不安全。

除此之前，还有就是代码的第38行处有个++size，我们这样想，还是线程A、B，这两个线程同时进行put操作时，假设当前HashMap的zise大小为10，当线程A执行到第38行代码时，从主内存中获得size的值为10后准备进行+1操作，但是由于时间片耗尽只好让出CPU，线程B快乐的拿到CPU还是从主内存中拿到size的值10进行+1操作，完成了put操作并将size=11写回主内存，然后线程A再次拿到CPU并继续执行(此时size的值仍为10)，当执行完put操作后，还是将size=11写回内存，此时，线程A、B都执行了一次put操作，但是size的值只增加了1，所有说还是由于数据覆盖又导致了线程不安全。

三、如何使HashMap在多线程情况下进行线程安全操作？

使用 Collections.synchronizedMap(map)，包装成同步Map，原理就是在HashMap的所有方法上synchronized。

例如：Collections.SynchronizedMap#get()

1
2
3
4
5
public V get(Object key) {
    synchronized (mutex) {
        return m.get(key);
    }
}

四、总结

1、HashMap线程不安全原因：

原因：

  • JDK1.7 中，由于多线程对HashMap进行扩容，调用了HashMap#transfer()，具体原因：某个线程执行过程中，被挂起，其他线程已经完成数据迁移，等CPU资源释放后被挂起的线程重新执行之前的逻辑，数据已经被改变，造成死循环、数据丢失。
  • JDK1.8 中，由于多线程对HashMap进行put操作，调用了HashMap#putVal()，具体原因：假设两个线程A、B都在进行put操作，并且hash函数计算出的插入下标是相同的，当线程A执行完第六行代码后由于时间片耗尽导致被挂起，而线程B得到时间片后在该下标处插入了元素，完成了正常的插入，然后线程A获得时间片，由于之前已经进行了hash碰撞的判断，所有此时不会再进行判断，而是直接进行插入，这就导致了线程B插入的数据被线程A覆盖了，从而线程不安全。

改善：

  • 数据丢失、死循环已经在在JDK1.8中已经得到了很好的解决，如果你去阅读1.8的源码会发现找不到HashMap#transfer()，因为JDK1.8直接在HashMap#resize()中完成了数据迁移。

2、HashMap线程不安全的体现：

  • JDK1.7 HashMap线程不安全体现在：死循环、数据丢失
  • JDK1.8 HashMap线程不安全体现在：数据覆盖
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla Java线程池 https://nerkeler.github.io/2023/06/11/Java%E7%BA%BF%E7%A8%8B%E6%B1%A0/ 2023-06-11T11:45:00.000Z 2024-01-04T01:51:56.002Z

Java线程池

以下内容为阅读《JAVA并发编程的艺术》学习总结 笔记

简介

Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序 都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处。

线程池的优点

  • 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
  • 提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行
  • 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不久会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用线程池，必须对其实现原理了如指掌。

线程池的实现原理

线程池的创建

我们可以通过ThreadPoolExecutor构造方法生成一个线程池对象，移除了内部代码，只留下了构造参数，便于理解，代码如下

1
2
3
4
5
6
7
8
9
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
       
    }

参数对应关系

参数含义
corePoolSize核心线程数
maximumPoolSize最大线程数
keepAliveTime线程活动保持时间
TimeUnit线程活动保持时间的单位
BlockingQueue任务队列
ThreadFactory线程工厂
RejectedExecutionHandler拒绝策略

大致明白参数意义后，我们说一下线程池新建一个线程的过程

先看一下线程池的执行示意图

  1. 主线程执行execute()提交一个新线程，首先进入核心线程池corePoolSize并判断是否已满，如果未满则新建一个线程（注意，执行这一步骤 需要获取全局锁）。
  2. 如果核心线程池已满，则进入阻塞队列BlockingQueue进行判断是否已满，如果未满则插入队列（队列保持先进先出的顺序执行 ）
  3. 如果阻塞队列已满，则判断线程池是否达到最大线程数量maximumPoolSize，如果没有，则新建线程（注意，执行这一步骤 需要获取全局锁）。
  4. 如果达到最大线程数量，则执行拒绝策略RejectedExecutionHandler

如果将上述描述转化成流程图则为

源码分析

上面的流程分析让我们很直观地了解了线程池的工作原理，让我们再通过源代 码来看看是如何实现的，线程池执行任务的方法如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();

    int c = ctl.get();
    
    // 是否小于核心线程数，小于执行当前线程
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 否则尝试加入阻塞队列中
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 最后尝试加入最大线程中
    else if (!addWorker(command, false))
        reject(command);
}

工作线程

线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会循环获取工作队列中的任务来执行，我们可以从Worker类的run()方法里看到这点。

只关注while循环和内部task.run即可

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
public void run() {
    runWorker(this);
}

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        while (task != null || (task = getTask()) != null) {
            w.lock();
            // 二次验证线程是否中断或停止
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            
            // 线程执行
            try {
                beforeExecute(wt, task);
                try {
                    task.run();
                    afterExecute(task, null);
                } catch (Throwable ex) {
                    afterExecute(task, ex);
                    throw ex;
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
            
            
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

ThreadPoolExecutor中线程执行任务的示意图如下

线程池中得先成功执行任务份两种情况

  • 在execute()方法中创建一个线程时，会让这个线程执行当前任务
  • 这个线程执行完上图中1得任务后，会反复从BlockingQueue获取任务来执行

线程池参数

corePoolSize（核心线程数）

当提交一个任务到线程池中时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等待需要执行的任务数大于线程池基本大小（核心线程数）时就不在创建。如果调用了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有核心线程。

runnableTaskQueue（任务队列）

用于保存等待执行的任务的阻塞队列。有以下几种

  • ArrayBlockingQueue: 一个基于数组结构的有界阻塞队列，按照FIFO（first in first out)先进先出的原则对元素进行排序。
  • LinkedBlockingQueue:一个基于链表结构的阻塞队列，也是按照FIFO 原则排序元素，吞吐量通常高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
  • SynchronousQueue: 一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue,静态工厂方法Executors.newCachedThreadPool使用了这个队列
  • ProirityBlockingQueue:一个具有优先级的无限阻塞队列
maximumPoolSize（最大线程数）

线程池允许创建的最大线程数。如果核心线程和队列都已经满了，并且已创建的线程数小于最大线程数，也就是上图中3这种情况，后续提交的线程则会创建新线程，当使用无界的任务队列时，提交的线程会无限阻塞在任务队列中，这个参数就失去了意义。

ThreadFactory（线程工厂）

ThreadFactory 是一个接口，用于创建线程的工厂。它提供了一种创建和定制线程的方式，让你能够对线程进行更多的控制和管理。例如自定义线程名称、设置线程优先级、设置线程组等。

RejectedExecutionHandler（拒绝策略）

当队列和线程池都满了，说明明线程池处于饱和状态，那么必须才需一种策略处理提交的新任务。默认请情况下使用的时AbortPolicy,表示无法处理新任务时抛出异常。自JDK1.5 Java线程池提供了4中策略

  • AbortPolicy 直接抛出异常
  • CallerRunsPolicy 只用调用者所在的线程运行任务
  • DiscardOldestPolicy 丢弃队列里最旧的任务也就是最早添加的一个任务，并尝试执行当前任务
  • DiscardPolicy 不处理 直接丢弃

除此之外，我们可以根据业务场景自己实现RejectedExecutionHandler接口自定义策略，比如记录日志或持久化不能处理的任务

keepAliveTime（存活时间）

线程池对的工作线程空闲后，保持存活的时间，线程在存活时间内可被重复利用，如果我们执行任务的时间比较短，调大存活时间可以提高线程利用率，避免线程的重新启动和终止所产生的额外时间消耗

TimeUnit(存活时间单位)
1
java.util.concurrent.TimeUnit

可选

  • SECONDS 秒
  • DAYS 天
  • HOURS 小时
  • MICROSECONDS 微秒
  • MILLISECONDS 毫秒
  • MINUTES 分钟
  • NANOSECONDS 纳秒

提交线程任务

线程池提交任务使用execute()方法和submit()方法，区别在于execute()方法无返回值，submit()方法可以获取线程执行返回值，它返回一个Future接口对象，可以使用future.get()阻塞线程获取返回值

execute()

构造方法

1
public void execute(Runnable command)

可以看到execute()接收一个Runnable的实例对象，也无返回值，所以无法判断任务是否是否被线程池执行成功（如果线程没有打印或日志的情况下），一个小例子如下

1
2
3
4
5
6
public static void main(String[] args) {

    ExecutorService executorService = Executors.newFixedThreadPool(3);
    executorService.execute(()-> System.out.println("提交新线程成功"));
    executorService.shutdown();
}

结果不言而喻

1
2
3
提交新线程成功

Process finished with exit code 0
submit()

构造方法

1
2
3
4
Future<?> submit(Runnable task);
<T> Future<T> submit(Runnable task, T result);
<T> Future<T> submit(Callable<T> task);

可以看到submit()方法返回一个Future接口对象，我们可以通过Future的get()方法获取返回值，当然get()方法会阻塞当前线程

一个小例子

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) {

    ExecutorService executorService = Executors.newFixedThreadPool(3);
    Future<String> submit = executorService.submit(() -> "提交新线程成功");
    try {
        System.out.println(submit.get());
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
    executorService.shutdown();
}

结果

1
2
3
提交新线程成功

Process finished with exit code 0

关闭线程池

关闭线程池可以使用shutdown或shutdownNow方法，他们的原理是遍历线程池的工作线程，然后逐个调用线程的interrupt方法来中断线程。

区别在于shutdownNow会先将线程池的状态设置成stop,然后尝试停止所有正在执行或暂停的任务线程，并返回等待执行任务的列表，而shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行的任务线程

只要调用这两个方法中的任意一个，isShutdown方法就会返回ture,当所有任务都已经关闭后，才表示线程池关闭成功，这个时候调用idTerminaed方法会返回true。通常使用shutdown方法关闭线程。

合理地配置线程池

要想合理地配置线程池，就必须首先分析任务特性，可以从以下几个角度来分析。

  • 任务的性质：CPU密集型任务、IO密集型任务和混合型任务。
  • 任务的优先级：高、中和低。 ·任务的执行时间：长、中和短。
  • 任务的依赖性：是否依赖其他系统资源，如数据库连接。

性质不同的任务可以用不同规模的线程池分开处理。CPU密集型任务应配置尽可能小的 线程，如配置**Ncpu+1**个线程的线程池。由于IO密集型任务线程并不是一直在执行任务，则应配 置尽可能多的线程，如**2*Ncpu**。混合型的任务，如果可以拆分，将其拆分成一个CPU密集型任务 和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐量 将高于串行执行的吞吐量。如果这两个任务执行时间相差太大，则没必要进行分解。可以通过 **Runtime.getRuntime().availableProcessors()**方法获得当前设备的CPU个数。

  • 优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高 的任务先执行。
  • 执行时间不同的任务可以交给不同规模的线程池来处理，或者可以使用优先级队列，让 执行时间短的任务先执行。
  • 依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，等待的时间越 长，则CPU空闲时间就越长，那么线程数应该设置得越大，这样才能更好地利用CPU。

PS:

***如果一直有优先级高的任务提交到队列里，那么优先级低的任务可能永远不能 执行。***

​*建议使用有界队列,有界队列能增加系统的稳定性和预警能力。

线程池的监控

如果在系统中大量使用线程池，则有必要对线程池进行监控，方便在出现问题时，可以根据线程池的使用状况快速定位问题。

可以通过线程池提供的参数进行监控，在监控线程池的 时候可以使用以下属性。

  • taskCount：线程池需要执行的任务数量。
  • completedTaskCount：线程池在运行过程中已完成的任务数量，小于或等于taskCount。
  • largestPoolSize：线程池里曾经创建过的最大线程数量。通过这个数据可以知道线程池是 否曾经满过。如该数值等于线程池的最大大小，则表示线程池曾经满过。
  • getPoolSize：线程池的线程数量。如果线程池不销毁的话，线程池里的线程不会自动销 毁，所以这个大小只增不减。
  • getActiveCount：获取活动的线程数。

通过扩展线程池进行监控。可以通过继承线程池来自定义线程池，重写线程池的 beforeExecute、afterExecute和terminated方法，也可以在任务执行前、执行后和线程池关闭前执 行一些代码来进行监控。例如，监控任务的平均执行时间、最大执行时间和最小执行时间等。 这几个方法在线程池里是空方法。

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla Future和CompletableFuture https://nerkeler.github.io/2023/06/04/UntitledFuture%E5%92%8CCompletableFuture/ 2023-06-04T03:36:00.000Z 2024-01-04T01:53:26.499Z

Future和CompletableFuture

FutureTask

1
2
3
4
5
6
/*
* @since 1.5
* @author Doug Lea
* @param <V> The result type returned by this FutureTask's {@code get} methods
*/
public class FutureTask<V> implements RunnableFuture<V> {

Future接口在Java 5中被引入，设计初衷是对将来某个时刻会发生的结果进行建模。它建模 了一种异步计算，返回一个执行运算结果的引用，当运算结束后，这个引用被返回给调用方。

一个简单例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static void main(String[] args) throws InterruptedException, ExecutionException {
       ExecutorService executor = Executors.newCachedThreadPool();
       // 把需要耗时得事情交给 future 中得线程池
       Future<Double> future = executor.submit(() -> {
           TimeUnit.SECONDS.sleep(4);
           System.out.println("doSomeLongComputation");
           return ThreadLocalRandom.current().nextDouble();
       });
       // 做一些其他的事情
       System.out.println("doSomethingElse");
       try {
           Double result = future.get(1, TimeUnit.SECONDS);
           System.out.println(result);
       } catch (Exception e) {
           // 计算抛出一个异常
           e.printStackTrace();
       }

       // 关闭线程池
       executor.shutdown();
   }

程序结果

1
2
3
4
5
doSomethingElse
doSomeLongComputation
0.3039716200549002

Process finished with exit code 0

上述代码让我们可以以并发得方式调用另一个线程执行耗时操作得同时，也可以去执行一些其他的任务。启动异步任务，后我们可以调用它得get()方法获取操作返回值，如果通过get获取时程序在传入规定时间还没有返回值，则会抛出异常，获取时还没有生成返回值则会进行阻塞。

理解了上述执行流程，我们看一下Future接口提供的几个基本方法

Modifier and TypeMethod and Description
booleancancel(boolean mayInterruptIfRunning) 尝试取消执行此任务。
Vget() 等待计算完成，然后检索其结果。
Vget(long timeout, TimeUnit unit) 如果需要等待最多在给定的时间计算完成，然后检索其结果（如果可用）。
booleanisCancelled() 如果此任务在正常完成之前被取消，则返回 true 。
booleanisDone() 返回 true如果任务已完成。

我们看到get方法有两个重载得方法，get(long timeout,TimeUnit unit) 和get(）的区别是如果在指定时间内没有得到结果的返回值，则会抛出异常，程序会继续运行，而get()方法则会阻塞主线程进行等待，知道获取返回值，如果异步线程是一个极其耗费时间的操作，则会导致主线程进入漫长的等待

Future 接口的局限性

通过上述例子可以看到Future接口可能会导致程序进入漫长的等待或者直接抛弃获取值操作，虽然我们可以通过isDone()检测程序是否运行完毕，但是始终还是存在一定的运行阻塞与等待
如果我们有这样一个需求：我们需要完成两个计算任务，当前一个计算任务结束后，需要将改计算的结果通知到另一个长时间运行的计算任务，当两个计算任务都结束后，将两个计算任务合并后输出。 新的CompletableFuture类 会很方便的解决这类问题。

CompletableFuture

1
public class CompletableFuture<T> implements Future<T>, CompletionStage<T>

查看类图可知，CompletableFuture 实现了Future接口和CompletionStage接口，也就是说在原有Future接口的基础上提供了一些扩展，自然功能更为强大

CompletionStage接口

CompletionStage 是 Java 8 引入的接口，用于支持异步计算和处理结果的操作。它是 Java 中的一个 Future 接口的扩展，并提供了更强大的异步编程模型

  1. CompletionStage代表异步计算过程中的某一个阶段,一个阶段完成后可能会触发另外一个阶段
  2. 一个阶段的计算执行可以是一个Funcation、Consumer、Runnable。比如:stage.thenApply (x->square(x)).thenAccept(x->System.out.println(x)).thenRun(()->{System.out.println()});
  3. 一个阶段的执行可能是被单个阶段的完成触发,也可能是由多个阶段一起触发.有些类似Linux系统的管道分隔符传参数

示例

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
public class CompletableFutureExample {
    public static void main(String[] args) {
        // 创建一个异步任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello, CompletableFuture!";
        });

        // 注册任务完成后的回调
        future.thenAccept(result -> {
            System.out.println("Task completed: " + result);
        });

        System.out.println("Main thread continues to execute...");

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结果

1
2
3
4
Main thread continues to execute...
Task completed: Hello, CompletableFuture!

Process finished with exit code 0

如上所示CompletableFuture使用静态方法构造CompletableFuture对象，常用的静态构造方法如下所示

常用静态构造方法

Modifier and TypeModifier and Typedescribe
CompletableFuturerunAsync(Runnablerunnable)无返回值
CompletableFuturerunAsync(Runnablerunnable, Executorexecutor)无返回值，指定线程池
CompletableFuturesupplyAsync(Suppliersupplier)有返回值
CompletableFuturesupplyAsync(Suppliersupplier, Executor executor)有返回值，指定线程池

为什么不用构造方法呢？我们看一下jdk文档的描述

构造方法摘要

Constructor and Description
CompletableFuture() 创建一个新的不完整的CompletableFuture。

默认空参构造器只能新建一个不完整的CompletableFuture对象，原因简略看一下

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * Returns a new CompletableFuture that is asynchronously completed
 * by a task running in the {@link ForkJoinPool#commonPool()} with
 * the value obtained by calling the given Supplier.
 *
 * @param supplier a function returning the value to be used
 * to complete the returned CompletableFuture
 * @param <U> the function's return type
 * @return the new CompletableFuture
 */
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
    return asyncSupplyStage(asyncPool, supplier);
}
1
2
3
4
5
6
7
static <U> CompletableFuture<U> asyncSupplyStage(Executor e,
                                                 Supplier<U> f) {
    if (f == null) throw new NullPointerException();
    CompletableFuture<U> d = new CompletableFuture<U>();
    e.execute(new AsyncSupply<U>(d, f));
    return d;
}

supplyAsync静态方法在执行时，也new了一个新的ComPletableFuture对象，不同的是，supplyAsync方法调用asyncSupplyStage后使用e.execute 开启了线程。所以ComPletableFuture 空参构造只是一个ComPletableFuture对象，还需要进一步开启线程，其他静态构造方法原理一致。

线程池相关

通过上面的构造方法可以看到，相同两个方法名之间的区别就是是否指定了新的线程池，如果没有指定线程池，则会使用ComPletableFuture内置的线程池ForkJoinPool。

实现源码如下

1
2
3
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
    return asyncSupplyStage(asyncPool, supplier);
}
1
2
3
4
5
6
7
8
9
10
11
/**
 * Default executor -- ForkJoinPool.commonPool() unless it cannot
 * support parallelism.
 */
private static final Executor asyncPool = useCommonPool ?
    ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

/** Fallback if ForkJoinPool.commonPool() cannot support parallelism */
static final class ThreadPerTaskExecutor implements Executor {
    public void execute(Runnable r) { new Thread(r).start(); }
}

可以看到，这里只是做了一个三目运算来判断是否指定了线程池。

简单实践

我们指定一个字符串列表，取出每个字符串并获得第一个字符 ，等待一秒后，与一个随机数相乘, 比如字符串”hello” ,取出h，等待一秒后，用h的ASCII码与一个随机浮点数相乘。

Stream流方式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static void main(String[] args) {


    List<String> strings = Arrays.asList("BestPrice", "LetsSaveBig", "MyFavoriteShop", "BuyItAll");

    long start = System.currentTimeMillis();

    List<Double> collect = strings.stream()
            .map(s -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return s.charAt(0) * ThreadLocalRandom.current().nextDouble();

            })
            .collect(Collectors.toList());


    long end = System.currentTimeMillis();
    System.out.println(end - start);
    
}

执行时间为： 4108毫秒

并行流方式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static void main(String[] args) {


    List<String> strings = Arrays.asList("BestPrice", "LetsSaveBig", "MyFavoriteShop", "BuyItAll");

    long start = System.currentTimeMillis();

    List<Double> collects = strings.parallelStream()
            .map(s -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return s.charAt(0) * ThreadLocalRandom.current().nextDouble();
            })
            .collect(Collectors.toList());


    long end = System.currentTimeMillis();
    System.out.println(end - start);

}

改动之处：stream（）—》parallelStream()

执行时间为：1067毫秒

CompletableFuture实现
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 static void main(String[] args) {


    List<String> strings = Arrays.asList("BestPrice", "LetsSaveBig", "MyFavoriteShop", "BuyItAll");

    long start = System.currentTimeMillis();

    List<CompletableFuture<Double>> collect = strings.stream()
            .map(s ->
                    CompletableFuture.supplyAsync(() -> {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        return s.charAt(0) * ThreadLocalRandom.current().nextDouble();
                    })
            )
            .collect(Collectors.toList());

    List<Double> collect1 = collect.stream()
            .map(CompletableFuture::join)
            .collect(Collectors.toList());


    long end = System.currentTimeMillis();
    System.out.println(end - start);

}

执行时间为：1072毫秒

可以看到，使用并行流和CompletableFuture实现比原先顺序流要快了很多，而并行流和CompletableFuture好像并没有多大差别。这是因为什么呢？

并行流和CompletableFuture差别

并行流和CompletableFuture内部采用的是同样的通用线程池也就是上文说的ForkJoinPool ，默认都使用固定数目的线程，具体线程数取决于Runtime.getRuntime().availableProcessors()的返回值。

而CompletableFuture不止可以使用默认的线程池，我们也可以根据自己的实际需求提供对应的线程池对象，尤其是线程池的大小，这是并行流API无法提供的，而CompletableFuture也并非仅仅为了实现多线程，更重要是是弥补Future接口使用带来的缺陷和不足。

执行流程图

而CompletableFuture实现则是先用顺序流返回了一个CompletableFuture对象，相当于收集了一个多线程集合，然后顺序启动多线程。

CompletableFuture 常用方法

获取结果
  • public T get( ) 实现了Future接口的方法，等待线程执行获取结果，可能会阻塞线程去等待
  • public T get(long timeout, TimeUnit unit) 实现了Future接口的方法，等待线程获取结果，超过指定时间抛出异常
  • public T getNow(T valuelfAbsent) 相当于三元运算，需要立即获取结果，如果没有则使用valuelfAbsent
  • public T join( ): join方法和get( ) 方法作用几乎,不同的是,join方法不抛出异常

简单演示一下getNow()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args) {

      CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
          try { TimeUnit.SECONDS.sleep(1);  } catch (InterruptedException e) {e.printStackTrace();}
          return 1;
      });
      Integer now1 = future.getNow(3);
      try { TimeUnit.SECONDS.sleep(2);  } catch (InterruptedException e) {e.printStackTrace();}

      Integer now2 = future.getNow(3);
      System.out.println("now1: "+ now1);
      System.out.println("now2: "+ now2);
  }

结果：

1
2
3
4
now1: 3
now2: 1

Process finished with exit code 0
对计算结果进行处理
(thenApply、handle)

**thenApply(Function<? super T,? extends U> fn)**：

  • 该方法用于在异步任务完成后对结果进行转换，返回一个新的 CompletableFuture 对象。
  • 它接受一个 Function 参数，该函数将任务的结果类型 T 转换为类型 U。
  • thenApply() 方法会等待当前任务完成，并将任务的结果作为参数传递给函数，然后返回一个新的 CompletableFuture 对象，该对象表示对结果进行转换后的值。
1
2
3
4
5
6
7
8
public static void main(String[] args) {

    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
    CompletableFuture<Integer> future1 = future.thenApply(String::length);
    CompletableFuture<Integer> future2 = future1.thenApply(s -> s * 100 +88);
    System.out.println(future2.join());

}

结果

1
2
3
588

Process finished with exit code 0

可以看到thenApply就是把上一个结果传递给下一个CompletableFuture 对象，相当于链式调用。

上述代码也可以这样实现，也就是链式调用

1
2
3
4
5
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> "Hello")
            .thenApply(String::length)
            .thenApply(s -> s * 100 +88);

System.out.println(future.join());

**handle(BiFunction<? super T,Throwable,? extends U> fn)**：

  • 该方法用于在异步任务完成后对结果进行处理，无论任务是否发生异常，都会执行处理逻辑，并返回一个新的 CompletableFuture 对象。
  • 它接受一个 BiFunction 参数，该函数接受任务的结果类型 T 和可能发生的异常类型 Throwable，并返回类型 U。
  • handle() 方法会等待当前任务完成，并将任务的结果或异常作为参数传递给函数，然后返回一个新的 CompletableFuture 对象，该对象表示处理后的结果。

handle方法和thenApply方法类似，不同的是handle在中间操作时出现异常不会停止任务，而是把异常传递给下一个Completable对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) {

    CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10)
                    .handle((result, ex) -> {
                            if (ex != null) {
                                System.out.println("Exception occurred: " + ex);
                                return -1;  // 处理异常情况，返回默认值
                            } else {
                                return result * 2;  // 处理正常情况，返回结果的两倍
                            }
                     });


    System.out.println(future.join());
}

结果

1
2
3
20

Process finished with exit code 0

稍微改动一点

1
2
3
4
5
6
7
8
9
10
11
12
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 1/0)
                .handle((result, ex) -> {
                        if (ex != null) {
                            System.out.println("Exception occurred: " + ex);
                            return -1;  // 处理异常情况，返回默认值
                        } else {
                            return result * 2;  // 处理正常情况，返回结果的两倍
                        }
                 });


System.out.println(future.join());

结果

1
2
3
4
Exception occurred: java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
-1

Process finished with exit code 0

也就是出现了异常并捕获，但是并没有影响结果执行。

对计算结果进行消费
(thenRun、thenAccept、thenApply)

thenRun(Runnable action):

  • 该方法在异步任务完成后执行指定的操作，不接收任务的结果。
  • 它接受一个 Runnable 参数，表示要执行的操作。
  • thenRun() 方法会等待当前任务完成后，执行指定的操作，无论前一个任务的结果是什么。
1
2
3
4
5
public static void main(String[] args) {

    CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> "Hello")
            .thenRun(() -> System.out.println("Task completed"));
}

结果

1
2
3
Task completed

Process finished with exit code 0

thenAccept(Consumer<? super T> action):

  • 该方法在异步任务完成后对结果进行消费，不返回任何结果。
  • 它接受一个 Consumer 参数，表示对结果进行消费的操作。
  • thenAccept() 方法会等待当前任务完成后，将任务的结果作为参数传递给操作进行消费。

通过传参可以看到，该方法是一个消费型接口，对传入数据进行消费，不返回结果。

1
2
3
4
5
6
public static void main(String[] args) {

    CompletableFuture.supplyAsync(() -> "Hello")
            .thenApply(s -> s+ " world")
            .thenAccept(s -> System.out.println("Result: " + s));
}

结果：

1
2
3
Result: Hello world

Process finished with exit code 0

thenApply方法同上

对计算结果进行合并
(thenCombine、thenAcceptBoth、runAfterBoth)

thenCombine(CompletableFuture<? extends U> other, BiFunction<? super T, ? super U, ? extends V> fn):

  • 该方法用于组合两个异步任务的结果，并在两个任务都完成后执行指定的操作，并返回一个新的 CompletableFuture 对象。
  • 它接受另一个 CompletableFuture 对象 other 和一个 BiFunction 参数，该函数接受两个任务的结果类型 T 和 U，并返回类型 V。
  • thenCombine() 方法会等待当前任务和 other 任务都完成后，将两个任务的结果作为参数传递给函数，并返回一个新的 CompletableFuture 对象，表示对结果进行组合后的值。
1
2
3
4
5
6
7
public static void main(String[] args) {

    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
    CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20)
                            .thenCombine(future1, (s1,s2) -> s1*s2);
    System.out.println(future2.join());
}

结果

1
2
3
200

Process finished with exit code 0

thenAcceptBoth(CompletableFuture<? extends U> other, BiConsumer<? super T, ? super U> action):

  • 该方法用于在两个异步任务都完成后执行指定的操作，不返回任何结果。
  • 它接受另一个 CompletableFuture 对象 other 和一个 BiConsumer 参数，该函数接受两个任务的结果类型 T 和 U，并执行指定的操作。
  • thenAcceptBoth() 方法会等待当前任务和 other 任务都完成后，将两个任务的结果作为参数传递给操作进行消费。
1
2
3
4
5
6
7
8
public static void main(String[] args) {

    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
    CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
    CompletableFuture<Void> combinedFuture = future1.
            thenAcceptBoth(future2, (result1, result2) ->
                    System.out.println("Combined result: " + (result1 + result2)));
}

使用方法与thenCombine类似，区别在于thenCombine有返回，而thenAcceptBoth无返回值

结果不言而喻

1
2
3
Combined result: 30

Process finished with exit code 0

runAfterBoth(CompletableFuture<?> other, Runnable action):

  • 该方法用于在两个异步任务都完成后执行指定的操作，不接收任务的结果。

  • 它接受另一个 CompletableFuture 对象 other 和一个 Runnable 参数，表示要执行的操作。

  • runAfterBoth() 方法会等待当前任务和 other 任务都完成后，执行指定的操作。

1
2
3
4
5
6
7
public static void main(String[] args) {

    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
    CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
    CompletableFuture<Void> combinedFuture = future1.
            runAfterBoth(future2, () -> System.out.println("Both tasks completed"));
}

相较于上面两个方法，runAfterBoth 又有些不同，他既不接收返回值，也不返回，而是等待两个future执行好了之后在去执行，所以一般用于在程序结束

结果

1
2
3
Both tasks completed

Process finished with exit code 0
对计算速度进行选用
(applyToEither、acceptEither、runAfterEither)

applyToEither(CompletableFuture<? extends T> other, Function<? super T, U> fn):

  • 该方法接受另一个 CompletableFuture 对象 other 和一个 Function 参数，并返回一个新的 CompletableFuture 对象。
  • applyToEither() 方法会等待当前任务和 other 任务中的任意一个完成，并将首先完成的任务的结果作为参数传递给函数进行转换。
  • 返回的 CompletableFuture 对象的结果类型为 U，表示对首先完成任务的结果进行转换后的值。
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 static void main(String[] args) {

    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 10;
    });
    CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 20;
    });

    CompletableFuture<Void> voidCompletableFuture = future1.applyToEither(future2, s -> s * 123)
            .thenApply(s -> "Result: " + s)
            .thenAccept(res -> {
                System.out.println("--------------------------");
                System.out.println(res);
            });
    voidCompletableFuture.join();


}

结果

1
2
3
4
--------------------------
Result: 2460

Process finished with exit code 0

很明显返回的是 future2 的20

acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action)

acceptEither 是 CompletableFuture 类中的一个方法，用于处理两个独立的异步任务，并且只接受其中一个操作的结果。可以这么理解：如果第一个异步任务完成了，则使用它的结果进行处理，否则使用第二个异步任务的结果

示例 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static void main(String[] args) {

    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 10;
    });

    CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 20;
    });

    future1.acceptEither(future2, System.out::println).join();


}

结果

1
2
3
10

Process finished with exit code 0

runAfterEither方法签名

1
public CompletionStage<Void> runAfterEither(CompletionStage<?> other, Runnable action);

runAfterEither 方法接收两个参数：一个是另一个 CompletionStage 对象，另一个是一个 Runnable 或者 Consumer 对象。当其中任意一个 CompletionStage 完成（无论是正常完成还是异常完成），就会执行指定的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 执行某个任务
    return 42;
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    // 执行另一个任务
    return "Hello";
});

future1.runAfterEither(future2, () -> {
    System.out.println("执行了操作");
});

我们创建了两个 CompletableFuture 对象 future1 和 future2，分别代表两个异步任务。然后，我们调用 runAfterEither 方法，传递了这两个 CompletableFuture 对象和一个 Runnable 对象作为参数。当 future1 或者 future2 中的任意一个完成时，即可执行传入的操作，这里是简单地打印一条消息。

多任务组合

allOf(CompletableFuture<?>... futures):

  • 该方法接受一个 CompletableFuture 数组作为参数，并返回一个新的 CompletableFuture 对象。
  • allOf() 方法等待所有给定的任务都完成后，返回一个新的 CompletableFuture 对象。
  • 返回的 CompletableFuture 对象的结果为 Void，表示所有任务都已完成。
1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {

    CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Result 1");
    CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 42);
    CompletableFuture<Boolean> future3 = CompletableFuture.supplyAsync(() -> true);

    CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2, future3);
    allFutures.thenRun(() -> System.out.println("All tasks completed"));

}

allof方法使用类似于遍历一个CompletableFuture数组并执行，不同是的，他会等待所有结果出来后才会打印 thenRun()后得内容。而不返回任何内容。

结果不言而喻

1
2
3
All tasks completed

Process finished with exit code 0

anyOf(CompletableFuture<?>... futures):

  • 该方法接受一个 CompletableFuture 数组作为参数，并返回一个新的 CompletableFuture 对象。
  • anyOf() 方法等待任何一个给定的任务完成后，返回一个新的 CompletableFuture 对象。
  • 返回的 CompletableFuture 对象的结果为第一个完成的任务的结果。
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
public static void main(String[] args) {

    CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Result 1";
    });
    CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 42;
    });
    CompletableFuture<Boolean> future3 = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return true;
    });

    CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(future1, future2, future3);
    System.out.println(anyFuture.join());


}

我们创建了三个Completable对象，并一次加入一个新的CompletableFuture.anyof方法中，三个线程分别等待不同的时间，我们预计anyFuture接收第一个运行结束并返回得CompletableFuture对象

结果

1
2
3
42

Process finished with exit code 0
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla synchronized和lock https://nerkeler.github.io/2023/05/29/synchronized%E5%92%8Clock/ 2023-05-29T08:31:00.000Z 2025-05-25T07:23:13.793Z

synchronized和lock

synchronized

synchronized关键字用于Java中同步方法或同步代码块中，防止资源冲突。当任务要执行被synchronized关键字保护的代码片段的时候，它将检查锁是否可用，然后获取锁，执行代码，释放锁。

基本使用

同步方法

1
2
3
4
public synchronized void synchronizedMethod() {
    // 该方法的内容在同一时间只能被一个线程执行
    // ...
}

同步代码块

1
2
3
4
5
6
7
8
9
10
public void someMethod() {
    // 非同步的代码

    synchronized (this) {
        // 被同步的代码块
        // ...
    }

    // 非同步的代码
}

其余不在赘述，相关使用应该很常见

lock

ReentrantLock

除了使用synchronized外，我们可以使用Lock接口写的ReentrantLock 实现独占锁的功能。

查看类图可知，ReentrantLock 实现了Lock接口

Lock接口定义了几个方法用来实现锁的基本功能

  • lock() : void //获得锁。
  • lockInterruptibly() : void // 获取锁定，除非当前线程是 interrupted 。
  • tryLock() : boolean // 只有在调用时才可以获得锁
  • tryLock(time : long,unit : TimeUnit ) : boolean // 如果在给定的等待时间内是空闲的，并且当前的线程尚未得到 interrupted，则获取该锁。
  • unlock() : void // 释放锁。
  • newCondition() : Condition // 返回一个新Condition绑定到该实例Lock实例。

常用方法应该是lock()/unlock()和newCondition(),简要阐述一下，由ReentrantLock实现

lock和unlock

lock和unlock方法是Lock接口提供的重要的加锁解锁方法，他们包围的代码片段就是相应的加锁处理片段，下面是一个简单的示例

1
2
3
4
5
6
7
8
9
10
11
12
public class LockExample {
    
    private Lock lock   = new ReentrantLock();
    
    private Object object = new Object();

    public  void test(String[] args) {
        lock.lock();
        System.out.println("lock 测试"+ object.toString());
        lock.unlock();
    }
}

只需要新建Lock对象后在需要锁的开始和结束处使用lock方法和unlock方法进行加锁和解锁就可以完成相应的功能。

需要注意，如果锁内部代码出现异常可能会造成lock对象的unlock方法没有执行，从而未释放锁。所以相应的功能应该卸载try catch代码块中

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

    private Lock lock   = new ReentrantLock();

    private Object object = new Object();

    public  void test(String[] args) {
        
        lock.lock();
        try{
            System.out.println("lock 测试"+ object.toString());

        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }
}

newCondition

newCondition()方法是Lock接口中线程通讯的重要实现，他返回一个Condition对象，Condition类似于Object监视器方法（ wait ， notify和notifyAll ），将其中的重要方法封装成了不同的对象，以得到具有多个等待集的每个对象，通过将它们与使用任意的组合的效果Lock个实现。 Lock替换synchronized方法和语句的使用， Condition取代了对象监视器方法的使用。 下面是一个简单的示例

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
package com.juc;


import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    // 定义一个共享的计数器
    private int count = 0;

    // 定义一个锁和条件变量
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    // 定义一个增加计数器的方法
    public void increment() {
        lock.lock();
        try {
            count++;
            System.out.println("Counter value: " + count);
            // 通知其他线程，计数器已经增加
            condition.signal();
        } finally {
            lock.unlock();
        }
    }

    // 定义一个减少计数器的方法
    public void decrement() {
        lock.lock();
        try {
            while (count == 0) {
                // 等待其他线程通知，计数器已经增加
                condition.await();
            }
            count--;
            System.out.println("Counter value: " + count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Counter counter = new Counter();

        // 创建两个线程，一个增加计数器，一个减少计数器
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.decrement();
            }
        });

        // 启动线程
        t1.start();
        t2.start();

        // 等待线程结束
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

该类定义了一个资源类和两个方法，一个增加计数，一个减少计数，循环5次，后通知另一线程执行，结果如下：

1
2
3
4
5
6
7
8
9
10
Counter value: 1
Counter value: 2
Counter value: 3
Counter value: 4
Counter value: 5
Counter value: 4
Counter value: 3
Counter value: 2
Counter value: 1
Counter value: 0

condition的使用类似于Object方法中的wait和notify方法，不同的是Condition类可以提供多个条件，实现更细粒度的线程等待和通知

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package com.juc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MultiConditionExample {
    private final Lock lock = new ReentrantLock();
    private final Condition condition1 = lock.newCondition();
    private final Condition condition2 = lock.newCondition();
    private boolean condition1Met = false;
    private boolean condition2Met = false;

    public void awaitCondition1() throws InterruptedException {
        lock.lock();
        try {
            while (!condition1Met) {
                condition1.await();
            }
            // condition1Met 为 true，执行相关操作
            System.out.println("Condition 1 开始运行");
        } finally {
            lock.unlock();
        }
    }

    public void awaitCondition2() throws InterruptedException {
        lock.lock();
        try {
            while (!condition2Met) {
                condition2.await();
            }
            // condition2Met 为 true，执行相关操作
            System.out.println("Condition 2 met");
        } finally {
            lock.unlock();
        }
    }

    public void signalCondition1() {
        lock.lock();
        try {
            condition1Met = true;
            condition1.signal();
        } finally {
            lock.unlock();
        }
    }

    public void signalCondition2() {
        lock.lock();
        try {
            condition2Met = true;
            condition2.signal();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        MultiConditionExample example = new MultiConditionExample();

        Thread thread1 = new Thread(() -> {
            try {
                Thread.sleep(2000);
                example.signalCondition1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                Thread.sleep(3000);
                example.signalCondition2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread thread3 = new Thread(() -> {
            try {
                example.awaitCondition1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread thread4 = new Thread(() -> {
            try {
                example.awaitCondition2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

        try {
            thread1.join();
            thread2.join();
            thread3.join();
            thread4.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结果

1
2
Condition 1 met
Condition 2 met

这个示例只是将一对Condition信号复制了一份放在一个类中执行，不同于wait/notify，Condition在这个可以根据实例信号（condition1/condition2)来指定需要通讯的线程。

Synchronized和Lock对比

  1. 获取方式：
    • Synchronized：通过 synchronized 关键字来实现，可以修饰方法或代码块。
    • Lock：通过 Lock 接口的实现类（如 ReentrantLock）来创建实例，并调用其方法进行获取锁。
  2. 使用方式：
    • Synchronized：在方法上使用 synchronized 关键字或使用 synchronized 块来指定需要同步的代码块。
    • Lock：使用 Lock 对象的 lock() 方法获取锁，然后使用 unlock() 方法释放锁。
  3. 灵活性：
    • Synchronized：是内置的、隐式的锁机制，具有自动释放锁的特性，可以很方便地使用，但相对较为简单，提供的功能相对有限。
    • Lock：是显式的锁机制，提供了更多的灵活性和功能，例如可重入性、公平性、条件变量等，但需要手动管理锁的获取和释放。
  4. 性能：
    • Synchronized：在 Java 6 之后进行了很多优化，性能已经大幅提升，尤其在无竞争的情况下，性能表现良好。
    • Lock：性能相对较好，并且在高度竞争的情况下能够提供更好的性能表现。
  5. 可中断性：
    • Synchronized：一旦获取到锁，无法被其他线程中断，只能等待锁的释放。
    • Lock：提供了可中断的获取锁的方法 lockInterruptibly()，可以在等待锁的过程中响应中断。
  6. 条件变量：
    • Synchronized：不直接支持条件变量，但可以通过 Object 的 wait()、notify() 和 notifyAll() 方法结合 synchronized 关键字来实现类似的功能。
    • Lock：提供了 Condition 接口来支持条件变量，可以使用 newCondition() 方法创建条件对象，并使用其 await()、signal() 和 signalAll() 方法进行线程等待和通知。

参考：

JDK官方文档：Synchronized Methods (The Java™ Tutorials > Essential Java Classes > Concurrency) (oracle.com)

synchronized VS Lock, wait-notify VS Condition

chatGPT3.5

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 如何超过大多数人 https://nerkeler.github.io/2023/05/19/%E5%A6%82%E4%BD%95%E8%B6%85%E8%BF%87%E5%A4%A7%E5%A4%9A%E6%95%B0%E4%BA%BA/ 2023-05-19T09:22:00.000Z 2025-05-25T07:23:34.022Z

如何超过大多数人

转载自 https://coolshell.cn/articles/19464.html 原作者：陈皓（左耳朵耗子）酷 壳 – CoolShell****
1
2
3
4
5
ps:读这篇文章前先看看下面这段话，避免误导大家。

切记，这篇文章不要过度深思（任何东西都无法经得起审视，因为这世上没有同样的成长环境，也没有同样的认知水平同时也**没有适用于所有人的解决方案**；也不要去急着评判里面列出的观点，只需代入到其中适度审视一番自己即可，能**跳脱出来从外人的角度看看现在的自己处在什么样的阶段**就行。具体怎么想怎么做全在你自己去**不断实践中寻找那个适合自己的方案**）

引用自：https://juejin.cn/post/7207648496978870333

当你看到这篇文章的标题，你一定对这篇文章产生了巨大的兴趣，因为你的潜意识在告诉你，这是一本人生的“武林秘籍”，而且还是左耳朵写的，一定有干货满满，只要读完，一定可以练就神功并找到超过大多数人的快车道和捷径……然而…… 当你看到我这样开篇时，你一定会觉得我马上就要有个转折，告诉你这是不可能的，一切都需要付出和努力……然而，你错了，这篇文章还真就是一篇“秘籍”，只要你把这些“秘籍”用起来，你就一定可以超过大多数人。而且，这篇文章只有我这个“人生导师”可以写得好。毕竟，我的生命过到了十六进制2B的年纪，踏入这个社会已超过20年，舍我其谁呢？！

P.S. 这篇文章借鉴于《如何写出无法维护的代码》一文的风格……嘿嘿

相关技巧和最佳实践

要超过别人其实还是比较简单的，尤其在今天的中国，更是简单。因为，你只看看中国的互联网，你就会发现，他们基本上全部都是在消费大众，让大众变得更为地愚蠢和傻瓜。所以，在今天的中国，你基本上不用做什么，只需要不使用中国互联网，你就很自然地超过大多数人了。当然，如果你还想跟他们彻底拉开，甩他们几个身位，把别人打到底层，下面的这些“技巧”你要多多了解一下。

在信息获取上，你要不断地向大众鼓吹下面的这些事：

  • 让大家都用百度搜索引擎查找信息，订阅微信公众号或是到知乎上学习知识……要做到这一步，你就需要把“百度一下”挂在嘴边，然后要经常在群或朋友圈中转发微信公众号的文章，并且转发知乎里的各种“如何看待……”这样的文章，让他们爱上八卦，爱上转发，爱上碎片。
  • 让大家到微博或是知识星球上粉一些大咖，密切关注他们的言论和动向……是的，告诉大家，大咖的任何想法一言一行都可以在微博、朋友圈或是知识星球上获得，让大家相信，你的成长和大咖的见闻和闲扯非常有关系，你跟牛人在一个圈子里你也会变牛。
  • 把今日头条和抖音这样的APP推荐给大家……你只需要让你有朋友成功地安装这两个APP，他们就会花大量的时间在上面，而不能自拔，要让他们安装其实还是很容易的，你要不信你就装一个试玩一会看看（嘿嘿嘿）。
  • 让大家热爱八卦，八卦并不一定是明星的八卦，还可以是你身边的人，比如，公司的同事，自己的同学，职场见闻，社会热点，争议话题，……这些东西总有一些东西会让人心态有很多微妙的变化，甚至花大量的时间去搜索和阅读大量的观点，以及花大量时间与人辩论争论，这个过程会让人上瘾，让人欲罢不能，然而这些事却和自己没有半毛钱关系。你要做的事就是转发其中一些SB或是很极端的观点，造成大家的一睦讨论后，就早早离场……
  • 利用爱国主义，让大家觉得不用学英文，不要出国，不要翻墙，咱们已经是强国了……这点其实还是很容易做到的，因为学习是比较逆人性的，所以，只要你鼓吹那些英文无用论，出国活得更惨，国家和民族都变得很强大，就算自己过得很底层，也有大国人民的感觉。

然后，在知识学习和技能训练上，让他们不得要领并产生幻觉

  • 让他们混淆认识和知识，以为开阔认知就是学习，让他们有学习和成长的幻觉……
  • 培养他们要学会使用碎片时间学习。等他们习惯利用碎片时间吃快餐后，他们就会失去精读一本书的耐性……
  • 不断地给他们各种各样“有价值的学习资料”，让他们抓不住重点，成为一个微信公众号或电子书“收藏家”……
  • 让他们看一些枯燥无味的基础知识和硬核知识，这样让他们只会用“死记硬背”的方式来学习，甚至直接让他们失去信心，直接放弃……
  • 玩具手枪是易用的，重武器是难以操控的，多给他们一些玩具，这样他们就会对玩具玩地得心应手，觉得玩玩具就是自己的专业……
  • 让他们喜欢直接得到答案的工作和学习方式，成为一个伸手党，从此学习再也不思考……
  • 告诉他们东西做出来就好了，不要追求做漂亮，做优雅，这样他们就会慢慢地变成劳动密集型……
  • 让他们觉得自己已经很努力了，剩下的就是运气，并说服他们去‘及时行乐’，然后再也找不到高阶和高效率学习的感觉……
  • 让他们觉得“读完书”、“读过书”就行了，不需要对书中的东西进行思考，进行总结，或是实践，只要囫囵吞枣尽快读完就等同于学好了……

最后，在认知和格局上，彻底打垮他们，让他们变成韭菜。

  • 让他们尽可能地用拼命和加班，尽可能的996，并告诉他们这就是通往成功的唯一路径。这样一来，他们必然会被永远困在低端成为最低的劳动力。
  • 让他们不要看到大的形势，只看到眼前的一亩三分地，做好一个井底之蛙。其实这很简单，就是不要告诉他还有另外一种活法，不要扩大他的认识……
  • 宣扬一夜暴富以及快速挣钱的案例，最好让他们进入“赌博类”或是“传销类”的地方，比如：股市、数字货币……要让他们相信各种财富神话，相信他们就是那个幸运儿，他们也可以成为巴菲特，可以成为马云……
  • 告诉他们，一些看上去很难的事都是有捷径的，比如：21天就能学会机器学习，用区块链就能颠覆以及重构整个世界等等……
  • 多跟他们讲一些小人物的励志的故事，这样让他们相信，不需要学习高级知识，不需要掌握高级技能，只需要用低等的知识和低级的技能，再加上持续不断拼命重复现有的工作，终有一天就会成功……
  • 多让他们跟别人比较，人比人不会气死人，但是会让人变得浮躁，变得心急，变得焦虑，当一个人没有办法控制自己的情绪，没有办法让自己静下心来，人会失去耐性和坚持，开始好大喜欢功，开始装逼，开始歪门邪道剑走偏锋……
  • 让他们到体制内的一些非常稳定的地方工作，这样他们拥有不思进取、怕承担责任、害怕犯错、喜欢偷懒、得过且过的素质……
  • 让他们到体制外的那些喜欢拼命喜欢加班的地方工作，告诉他们爱拼才会赢，努力加班是一种福报，青春就是用来拼的，让他们喜欢上使蛮力的感觉……
  • 告诉他们你的行业太累太辛苦，干不到30岁。让他们早点转行，不要耽误人生和青春……
  • 当他们要做决定的时候，一定要让他们更多的关注自己会失去的东西，而不是会得到的东西。培养他们患得患失心态，让他们认识不到事物真正的价值，失去判断能力……（比如：让他们觉得跟对人拍领导的马屁忠于公司比自我的成长更有价值）
  • 告诉他们，你现有的技能和知识不用更新，就能过好一辈子，新出来的东西没有生命力的……这样他们就会像我们再也不学习的父辈一样很快就会被时代所抛弃……
  • 每个人都喜欢在一些自己做不到的事上找理由，这种能力不教就会，比如，事情太多没有时间，因为工作上没有用到，等等，你要做的就是帮他们为他们做不到的事找各种非常合理的理由，比如：没事的，一切都是最好的安排；你得不到的那个事没什么意思；你没有面好主要原因是那个面试官问的问题都是可以上网查得到的知识，而不没有问到你真正的能力上；这些东西学了不用很快会忘了，等有了环境再学也不迟……

最后友情提示一下，上述的这些“最佳实践”你要小心，是所谓，贩毒的人从来不吸毒，开赌场的人从来不赌博！所以，你要小心别自己也掉进去了！这就是“欲练神功，必先自宫”的道理。

相关原理和思维模型

对于上面的这些技巧还有很多很多，你自己也可以发明或是找到很多。所以，我来讲讲这其中的一些原理。

一般来说，超过别人一般来说就是两个维度：

  1. 在认知、知识和技能上。这是一个人赖以立足社会的能力（参看《程序员的荒谬之言还是至理名言？》和《21天教你学会C++》）
  2. 在领导力上。所谓领导力就是你跑在别人前面，你得要有比别人更好的能力更高的标准（参看《技术人员发展之路》）

首先，我们要明白，人的技能是从认识开始，然后通过学校、培训或是书本把“零碎的认知”转换成“系统的知识”，而有要把知识转换成技能，就需要训练和实践，这样才能完成从：认识 -> 知识 -> 技能 的转换。这个转换过程是需要耗费很多时间和精力的，而且其中还需要有强大的学习能力和动手能力，这条路径上有很多的“关卡”，每道关卡都会过滤掉一大部分人。比如：对于一些比较枯燥的硬核知识来说，90%的人基本上就倒下来，不是因为他们没有智商，而是他们没有耐心。

认知

要在认知上超过别人，就要在下面几个方面上做足功夫：

1）信息渠道。试想如果别人的信息源没有你的好，那么，这些看不见信息源的人，只能接触得到二手信息甚至三手信息，只能获得被别人解读过的信息，这些信息被三传两递后必定会有错误和失真，甚至会被传递信息的中间人hack其中的信息（也就是“中间人攻击”），而这些找不出信息源的人，只能“被人喂养”，于是，他们最终会被困在信息的底层，永世不得翻身。（比如：学习C语言，放着原作者K&R的不用，硬要用错误百出谭浩强的书，能有什么好呢？）

2）信息质量。信息质量主要表现在两个方面，一个是信息中的燥音，另一个是信息中的质量等级，我们都知道，在大数据处理中有一句名言，叫 garbage in garbage out，你天天看的都是垃圾，你的思想和认识也只有垃圾。所以，如果你的信息质量并不好的话，你的认知也不会好，而且你还要花大量的时间来进行有价值信息的挖掘和处理。

3）信息密度。优质的信息，密度一般都很大，因为这种信息会逼着你去干这么几件事，a）搜索并学习其关联的知识，b）沉思和反省，c）亲手去推理、验证和实践……一般来说，经验性的文章会比知识性的文章会更有这样的功效。比如，类似于像 Effiective C++/Java，设计模式，Unix编程艺术，算法导论等等这样的书就是属于这种密度很大的书，而像Netflix的官方blog和AWS CTO的blog等等地方也会经常有一些这样的文章。

知识

要在知识上超过别人，你就需要在下面几个方面上做足功夫：

1）知识树（图）。任何知识，只在点上学习不够的，需要在面上学习，这叫系统地学习，这需要我们去总结并归纳知识树或知识图，一个知识面会有多个知识板块组成，一个板块又有各种知识点，一个知识点会导出另外的知识点，各种知识点又会交叉和依赖起来，学习就是要系统地学习整个知识树（图）。而我们都知道，对于一棵树来说，“根基”是非常重要的，所以，学好基础知识也是非常重要的，对于一个陌生的地方，有一份地图是非常重要的，没有地图的你只会乱窜，只会迷路、练路、走冤枉路！

2）知识缘由。任何知识都是有缘由的，了解一个知识的来龙去脉和前世今生，会让你对这个知识有非常强的掌握，而不再只是靠记忆去学习。靠记忆去学习是一件非常糟糕的事。而对于一些操作性的知识（不需要了解由来的），我把其叫操作知识，就像一些函数库一样，这样的知识只要学会查文档就好了。能够知其然，知其所以然的人自然会比识知识到表皮的人段位要高很多。

3）方法套路。学习不是为了找到答案，而是找到方法。就像数学一样，你学的是方法，是解题思路，是套路，会用方程式解题的和不会用方程式解题的在解题效率上不可比较，而在微积分面前，其它的解题方法都变成了渣渣。你可以看到，掌握高级方法的人比别人的优势有多大，学习的目的就是为了掌握更为高级的方法和解题思路。

技能

要在技能上超过别人，你就需要在下面几个方面做足功夫：

1）精益求精。如果你想拥有专业的技能，你要做不仅仅是拼命地重复一遍又一遍的训练，而是在每一次重复训练时你都要找到更好的方法，总结经验，让新的一遍能够更好，更漂亮，更有效率，否则，用相同的方法重复，那你只不过在搬砖罢了。

2）让自己犯错。犯错是有利于成长的，这是因为出错会让人反思，反思更好的方法，反思更完美的方案，总结教训，寻求更好更完美的过程，是技能升级的最好的方式。尤其是当你在出错后，被人鄙视，被人嘲笑后，你会有更大的动力提升自己，这样的动力才是进步的源动力。当然，千万不要同一个错误重复地犯！

3）找高手切磋。下过棋，打个球的人都知道，你要想提升自己的技艺，你必需找高手切磋，在和高手切磋的过程中你会感受到高手的技能和方法，有时候你会情不自禁地哇地一下，我靠，还可以这么玩！

领导力

最后一个是领导力，要有领导力或是影响力这个事并不容易，这跟你的野心有多大，好胜心有多强 ，你愿意付出多少很有关系，因为一个人的领导力跟他的标准很有关系，因为有领导力的人的标准比绝大多数人都要高。

1）识别自己的特长和天赋。首先，每个人DNA都可能或多或少都会有一些比大多数人NB的东西（当然，也可能没有），如果你有了，那么在你过去的人生中就一定会表现出来了，就是那种大家遇到这个事会来请教你的寻求你帮助的现象。那种，别人要非常努力，而且毫不费劲的事。一旦你有了这样的特长或天赋，那你就要大力地扩大你的领先优势，千万不要进到那些会限制你优势的地方。你是一条鱼，你就一定要把别人拉到水里来玩，绝对不要去陆地上跟别人拼，不断地在自己的特长和天赋上扩大自己的领先优势，彻底一骑绝尘。

2）识别自己的兴趣和事业。没有天赋也没有问题，还有兴趣点，都说兴趣是最好的老师，当年，Linus就是在学校里对minx着迷了，于是整出个Linux来，这就是兴趣驱动出的东西，一般来说，兴趣驱动的事总是会比那些被动驱动的更好。但是，这里我想说明一下什么叫“真∙兴趣”，真正的兴趣不是那种三天热度的东西，而是那种，你愿意为之付出一辈子的事，是那种无论有多大困难有多难受你都要死磕的事，这才是“真∙兴趣”，这也就是你的“野心”和“好胜心”所在，其实上升到了你的事业。相信我，绝大多数人只有职业而没有事业的。

3）建立高级的习惯和方法。没有天赋没有野心，也还是可以跟别人拼习惯拼方法的，只要你有一些比较好的习惯和方法，那么你一样可以超过大多数人。对此，在习惯上你要做到比较大多数人更自律，更有计划性，更有目标性，比如，每年学习一门新的语言或技术，并可以参与相关的顶级开源项目，每个月训练一个类算法，掌握一种算法，每周阅读一篇英文论文，并把阅读笔记整理出来……自律的是非常可怕的。除此之外，你还需要在方法上超过别人，你需要满世界的找各种高级的方法，其中包括，思考的方法，学习的方法、时间管理的方法、沟通的方法这类软实力的，还有，解决问题的方法（trouble shooting 和 problem solving），设计的方法，工程的方法，代码的方法等等硬实力的，一开始照猫画虎，时间长了就可能会自己发明或推导新的方法。

4）勤奋努力执着坚持。如果上面三件事你都没有也没有能力，那还有最后一件事了，那就是勤奋努力了，就是所谓的“一万小时定律”了（参看《21天教你学会C++》中的十年学编程一节），我见过很多不聪明的人，悟性也不够（比如我就是一个），别人学一个东西，一个月就好了，而我需要1年甚至更长，但是很多东西都是死的，只要肯花时间就有一天你会搞懂的，耐不住我坚持十年二十年，聪明的人发明个飞机飞过去了，笨一点的人愚公移山也过得去，因为更多的人是懒人，我不用拼过聪明人，我只用拼过那些懒人就好了。

好了，就这么多，如果哪天你变得消极和不自信，你要来读读我的这篇文章，子曰：温故而知新。

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 线程的生命周期和常用方法 https://nerkeler.github.io/2023/05/19/%E7%BA%BF%E7%A8%8B%E7%9A%84%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F%E5%92%8C%E5%B8%B8%E7%94%A8%E6%96%B9%E6%B3%95/ 2023-05-19T03:14:00.000Z 2023-05-19T03:15:32.000Z

线程的生命周期和常用方法

生命周期

根据jdk官方文档，线程状态有以下几种

  • NEW
    尚未启动的线程处于此状态。
  • RUNNABLE
    在Java虚拟机中执行的线程处于此状态。
  • BLOCKED
    被阻塞等待监视器锁定的线程处于此状态。
  • WAITING
    正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING
    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED
    已退出的线程处于此状态。

一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

如图示所见

代码演示

NEW / TIMED_WAITING / TERMINATED

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
package ThreadMethod;

import java.util.concurrent.TimeUnit;

public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                

            }


        });
        System.out.println("线程状态："+ thread.getState());
        thread.start();
        Thread.sleep(2000);
        System.out.println("线程状态：" + thread.getState());
        Thread.sleep(2000);
        System.out.println("线程状态：" + thread.getState());

    }


}
结果
1
2
3
4
线程状态：NEW
线程状态：TIMED_WAITING
线程状态：TERMINATED
线程状态：TERMINATED

WAITING / BLOCKED

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
package ThreadMethod;

public class BlockThreadState implements Runnable {

    static final Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {

        BlockThreadState blockThread = new BlockThreadState();
        Thread thread = new Thread(blockThread);
        System.out.println("thread state : " + thread.getState());
        thread.start();
        Thread.sleep(20);
        System.out.println("thread state : " + thread.getState());
        synchronized (lock){
            lock.notify();
        }
        System.out.println("thread state : " + thread.getState());
        Thread.sleep(20);
        System.out.println("thread state : " + thread.getState());

    }



    @Override
    public void run() {
        try {
            synchronized (lock){
// wait状态
                lock.wait();
                // synchronized重新拿到锁 处于block状态
                for (int i = 0; i < 1000000000; i++) {
                    continue;
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


结果
1
2
3
4
thread state : NEW
thread state : WAITING
thread state : BLOCKED
thread state : TERMINATED

常见方法

wait()

wait()方法执行后，会阻塞线程，同时释放锁，如果想要唤醒该线程，则需要以下条件

  • 另一个线程调用这个对象的notify()方法，且刚好被唤醒的时本线程
  • 另一个线程调用了这个对象的notifyAll()方法
  • 过了wait(long timeout) 规定的超时时间，如果传入0就是永久等待
  • 线程自身调用了interrupt()

PS： 使用wait()方法时，必须先拥有monitor锁, 也就是说wait方法需要放在同步代码块中执行

notify/notifyAll

notify/notifyAll用于唤醒线程，当另一个线程调用wait()进入 waitting状态时，另一个线程调用notifyAll()可唤醒当前线程（如果有多个线程，使用notify并不一定能够唤醒线程）

组合使用示例

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
public class BlockThread {
    public static void main(String[] args) {
        Message message = new Message();

        // 创建一个等待线程
        Thread waitThread = new Thread(new WaitThread(message));
        // 创建一个唤醒线程
        Thread notifyThread = new Thread(new NotifyThread(message));

        // 启动等待线程和唤醒线程
        waitThread.start();
        notifyThread.start();
    }
}

// 共享的消息类
class Message {
    private boolean isReady = false;

    // 等待方法
    public synchronized void waitForMessage() {
        while (!isReady) {
            try {
                // 当消息不可用时，线程进入等待状态
                System.out.println("线程进入等待状态");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 执行到这里表示收到消息，进行处理
        System.out.println("收到消息！");
    }

    // 唤醒方法
    public synchronized void sendMessage() {
        // 做一些准备工作，例如获取消息

        // 唤醒等待的线程
        isReady = true;
        System.out.println("唤醒等待的线程");
        notify();
    }
}

// 等待线程
class WaitThread implements Runnable {
    private Message message;

    public WaitThread(Message message) {
        this.message = message;
    }

    @Override
    public void run() {
        // 等待消息
        message.waitForMessage();
    }
}

// 唤醒线程
class NotifyThread implements Runnable {
    private Message message;

    public NotifyThread(Message message) {
        this.message = message;
    }

    @Override
    public void run() {
        // 发送消息
        message.sendMessage();
    }
}

/*

线程进入等待状态
唤醒等待的线程
收到消息！

Process finished with exit code 0
*/

图示 monitor锁

  • Entry Set 入口集
    • 线程进入后抢锁
  • The owner 锁持有线程
    • 如果方法没有执行完之前没有释放锁，则程序正常退出并释放锁
    • 如果方法没有执行完之前释放了锁如调用了wait()方法，则程序再次进入等待集进行抢锁
  • Wait Set 等待集
    • 如果上方入口集，不同点是等待集在执行方法锁时中途释放了锁

wait、notify 实现生产者消费者模式

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
import java.util.LinkedList;
import java.util.List;
import java.util.TreeMap;

public class ProductAndConsumer {

    List<Object> container = new LinkedList<>();

    public static void main(String[] args) {
        ProductAndConsumer productAndConsumer = new ProductAndConsumer();
        Thread thread1 = new Thread(new Product(productAndConsumer));
        Thread thread2 = new Thread(new Consumer(productAndConsumer));
        thread1.start();
        thread2.start();
    }


    public synchronized void addObject() throws InterruptedException {
        if (container.size() >=100){
            wait();
        }
        container.add(new Object());
        System.out.println("正在生产第"+ container.size() + "个");
        notify();
    }

    public synchronized void conObject() throws InterruptedException {
        if (container.size() == 0){
            wait();
        }
        container.remove(0);
        System.out.println("正在消费第"+ container.size() + "个");
        notify();
    }
}

class Product implements Runnable{
    private final ProductAndConsumer productAndConsumer;

    Product(ProductAndConsumer productAndConsumer){
        this.productAndConsumer = productAndConsumer;
    }

    @Override
    public void run() {
       while (true){
           try {
               productAndConsumer.addObject();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
}

class Consumer implements Runnable{
    private final ProductAndConsumer productAndConsumer;

    Consumer(ProductAndConsumer productAndConsumer){
        this.productAndConsumer = productAndConsumer;
    }

    @Override
    public void run() {
       while (true){
           try {
               productAndConsumer.conObject();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
}

解释

  • 使用类ProductAndConsumer作为锁对象，container作为容器
  • wait notify来进行线程之间的通讯，在数量满足条件时使用wait释放当前锁对象，另一个对象拿到锁之后进行生产或消费

图示

sleep()

Thread.sleep()是Java中一个静态native方法，用于使当前线程进入休眠状态（暂停执行）一段指定的时间。

它的方法签名为：

1
public static native void sleep(long millis) throws InterruptedException;

参数millis表示线程休眠的时间，以毫秒为单位。传入的值是一个正整数，表示线程要休眠的毫秒数。注意，该方法会抛出InterruptedException异常，因为线程在休眠期间可能被其他线程中断。

特点和用法

  • 线程阻塞：调用Thread.sleep()方法会导致当前线程暂停执行，进入阻塞状态。在指定的时间内，线程不会进行任何操作。
  • 时间精度：传入的休眠时间是以毫秒为单位，但实际的休眠时间可能会稍长或稍短。具体的精度取决于底层操作系统和JVM的实现。
  • 中断响应：如果在线程休眠期间，另一个线程中断了正在休眠的线程，Thread.sleep()方法会抛出InterruptedException异常。可以在catch块中处理该异常，或者将异常继续向上抛出。
  • 不会释放锁：Thread.sleep()方法会暂停当前线程的执行，但不会释放任何锁。如果线程在执行同步代码块或同步方法时调用了Thread.sleep()，其他线程仍无法获得该锁。
  • 静态方法：Thread.sleep()是一个静态方法，可以直接通过Thread类调用，无需创建线程对象。
  • 用途：常见的用途包括模拟延迟、定时任务、控制线程执行顺序等。

Thread.sleep和TimeUnit比较

  • 精度和可读性： Thread.sleep()的参数是以毫秒为单位的时间值，表示线程要休眠的时间。而TimeUnit提供了更高层次的时间单位，如TimeUnit.SECONDS表示秒，TimeUnit.MILLISECONDS表示毫秒等。使用TimeUnit可以使代码更具可读性，而不需要手动计算毫秒数。
  • 异常处理： Thread.sleep()方法会抛出InterruptedException异常，因为线程在休眠期间可能会被其他线程中断。而TimeUnit方式不会直接抛出异常，需要开发者手动处理中断情况。
  • 静态与非静态： Thread.sleep()是Thread类的静态方法，可以直接通过类名调用。而TimeUnit是一个枚举类，需要通过具体的枚举常量来调用其方法，例如TimeUnit.SECONDS.sleep(1)。
  • 可读性和易用性： 使用TimeUnit可以提高代码的可读性，因为可以直观地表示时间单位。此外，TimeUnit还提供了其他方法，如TimeUnit.toMillis()、TimeUnit.toSeconds()等，方便进行时间单位之间的转换。
TimeUnit源码

以下是截取部分源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public enum TimeUnit {
      /**
     * Performs a {@link Thread#sleep(long, int) Thread.sleep} using
     * this time unit.
     * This is a convenience method that converts time arguments into the
     * form required by the {@code Thread.sleep} method.
     *
     * @param timeout the minimum time to sleep. If less than
     * or equal to zero, do not sleep at all.
     * @throws InterruptedException if interrupted while sleeping
     */
    public void sleep(long timeout) throws InterruptedException {
        if (timeout > 0) {
            long ms = toMillis(timeout);
            int ns = excessNanos(timeout, ms);
            Thread.sleep(ms, ns);
        }
    }
}

可以看到TimeUnit底层还是调用了Thread.sleep() 有一个比较隐含的地方就是当使用过TimeUnit的sleep方法时，如果传入的时间小于是不会进入if判断，而Thread.sleep()方法如果传参小于0则会抛出异常(源码见下)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void sleep(long millis, int nanos)
throws InterruptedException {
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
        millis++;
    }

    sleep(millis);
}

join()

Thread.join()是Java中的一个方法，用于等待调用该方法的线程执行完毕。它的作用是让当前线程等待指定线程执行结束，然后再继续执行当前线程的后续代码。

简单来说就是阻塞主线程。

简单示例

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

public class JoinMethod {
    public static void main(String[] args) {
        Thread thread1 =  new Thread(()->{
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程执行完毕");
        },"子线程");
        thread1.start();
        try {
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程执行完毕");
    }
}
结果
1
2
子线程执行完毕
主线程执行完毕

可以看到子线程等待了3秒，但是最终还是子线程先执行完毕在执行主线程打印，原因是因为thread1.join 对主线程进行了阻塞，这是主线程需要等子线程执行完毕才会执行后面的语句

特点和注意事项

  • 等待执行： 调用join()方法的线程将会等待指定线程执行完毕。如果指定线程已经执行完毕，则join()方法会立即返回。
  • 阻塞调用线程： 在调用join()方法期间，当前线程将会被阻塞，暂停执行。只有当指定线程执行完毕后，当前线程才会解除阻塞，继续执行。
  • 异常处理： join()方法会抛出InterruptedException异常，因为在等待过程中，当前线程可能会被中断。可以在catch块中处理该异常，或将异常继续向上抛出。
  • 顺序执行： 通过使用join()方法，可以控制线程的执行顺序。调用join()方法后，当前线程会等待指定线程执行完毕，然后再继续执行后续代码。
  • 调用对象： join()方法是一个实例方法，需要通过线程对象调用。例如，如果thread1是一个Thread对象，可以使用thread1.join()来等待thread1执行完毕。

源码和底层实现

以下截取部分Thread.join源码

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
// 入口
public final void join() throws InterruptedException {
    join(0);
}

// 调用的join(0)
public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

// 实际调用的本地native方法  wait
public final native void wait(long timeout) throws InterruptedException;

可以看到join的底层还是使用wait方法实现的，子线程调用wait方法让主线程进入等待状态，在运行结束后自动调用notify方法唤醒主线程。（具体唤醒的方法在jvm中）

有一点疑问我没有找到解释：为什么调用子线程的wait(0)方法，阻塞的确是主线程呢？

CountDownLatch和CyclicBarrier

使用countDownLatch和CyclicBarrier也可以实现线程之间的阻塞，具体暂不讨论

yeild() (让步)

yield() 是一个静态方法，它属于 Thread 类，用于提示调度器将当前线程让出 CPU 的执行权，使得其他具有相同优先级的线程有机会执行。

yield() 方法的调用并不能保证一定会使其他线程获得执行机会，它仅是一个提示。具体的调度行为取决于操作系统和 JVM 的实现。因此，在实际应用中，不应过度依赖 yield() 方法来控制线程的执行顺序，而应使用更可靠的线程同步机制来实现需要的线程协作和同步。

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 如何正确停止线程 https://nerkeler.github.io/2023/05/11/%E5%A6%82%E4%BD%95%E6%AD%A3%E7%A1%AE%E5%81%9C%E6%AD%A2%E7%BA%BF%E7%A8%8B/ 2023-05-11T03:21:00.000Z 2025-05-25T07:25:17.317Z

如何正确停止线程

新建线程

新建线程的方式有多种
  • 实现Runnable接口，重写run()方法
  • 继承Thread类，重写run()方法
  • 实现callable接口，重写call方法
  • 使用线程池
  • 使用定时器
  • …………..
代码举例-Runnable接口

Runnable接口重写run方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class NewRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("I am NewRunnable Thread");
    }

    public static void main(String[] args) {
        NewRunnable newRunnable = new NewRunnable();
        Thread thread = new Thread(newRunnable);
        thread.start();
    }
}

// 结果
/*
    I am NewRunnable Thread
*/

上述代码中新建NewRunnable 类实现了Runnable接口后重写了run方法，实现新建一个线程，可能这样体现不出来多线程，可以加个循环。

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
public class NewThread  {

    public static void main(String[] args) {

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(200);
                        System.out.println("i am "+ i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        });
        thread.start();
        try {
            Thread.sleep(500);
            System.out.println("i am mainThread");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

运行结果

1
2
3
4
5
6
i am 0
i am 1
i am mainThread
i am 2
i am 3
i am 4

使用了匿名内部类重写了Runnable接口run方法，然后循环五次，每次睡眠200毫秒，主线程中睡眠500毫秒，所以当子线程循环两次后，在第三次打印中间主线程开始打印。

代码举例-Thread类

继承Thread类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class NewThread extends Thread {

    @Override
    public void run() {
        System.out.println("I am NewThread!");
    }

    public static void main(String[] args) {
        NewThread newThread = new NewThread();
        newThread.start();
    }
}
/*
   I am NewThread!
*/
新建线程总结

无论是实现Runnable接口还是继承Thread类，发现最终都是通过Thread类的start()方法开启的线程，而不是通过run()方法，看一下run方法和start方法的源代码

run()方法
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Thread implements Runnable {
    
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

发现Thread也实现了Runnable接口，并重写了run方法，如上所示，我们在使用实现Runnable接口，并把对象当作参数传给Thread类中 public Thread(Runnable target)；构造器时，这时候run()方法执行的就是传入对象的run()方法，run()方法中也只有这三行代码，所以并没有实现多线程。

start()方法
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
public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

可以看到首先run()方法if (threadStatus != 0) 判断线程状态，而后调用了start0方法，而start0方法private native void start0();可以看到是一个native方法，并非是由java实现

搜索后得知

1
2
3
在Java中，Thread类是用于实现多线程编程的类。当我们创建一个新线程并启动它时，实际上是调用了Thread类中的start()方法，该方法会执行一个本地方法start0()。start0()方法会启动一个新的系统线程，并调用run()方法。run()方法是线程执行的代码，当run()方法执行完毕后，线程就会自动结束。

start0()方法是一个本地方法（native method），它是由JVM实现的。本地方法是指使用C/C++等低级语言编写的方法，它们通常由JVM加载并在本地系统上执行。start0()方法在底层实现了线程的创建和启动，其具体实现会依赖于不同的操作系统和JVM实现。在JVM中，start0()方法的实现是由native层面提供的，因此我们无法直接查看其源代码。

所以我们可以得知，在java中真正实现多线程的是Thread类中的start()方法。

补充 callable接口
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
public class NewCallable implements Callable {
    @Override
    public String call() throws Exception {
        String s = "I am newCallable!";
        System.out.println(Thread.currentThread().getName());

        return s;
    }

    public static void main(String[] args) {
        NewCallable newCallable = new NewCallable();

        FutureTask futureTask = new FutureTask<>(newCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            Object o = futureTask.get();
            System.out.println(o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("i am mainThread");
        System.out.println(Thread.currentThread().getName());


    }
}

/*
    Thread-0
    I am newCallable!
    i am mainThread
    main
*/

可以看到实现callable接口也是通过Thread类创建的新线程，不同的是使用了FutureTask类接收了返回值

简要说一下futureTask可以看到该类间接继承了Runnable接口，所以依然可以理解成callable接口就是实现Runnbale接口，重写了run方法的方式实现了多线程，其他方式不在过多阐释。

停止线程

如何停止线程？
  • stop()?
  • destroy()?
  • suspend()?
  • interrupt()?

查看 API，我们会看到 java.lang.Thread 类型提供了一系列的方法如 start()、stop()、resume()、suspend()、destroy()等方法来管理线程。但是除了 start() 之外，其它几个方法都被声名为已过时（deprecated）

详细原因可看jdk文档的解释 

1
https://docs.oracle.com/javase/1.5.0/docs/guide/misc/threadPrimitiveDeprecation.html

正确停止线程的方式是使用interrupt()方法

Interrupt()方法

在 Java 中，Thread.interrupt() 方法用于中断线程，其作用是设置线程的中断标志位为 true。被中断的线程可以通过检查自身的中断标志位来判断是否被中断，然后执行适当的操作。

如果线程被阻塞在某些操作上（如等待 I/O 操作、sleep() 等），调用 interrupt() 方法会中断该线程的阻塞状态，抛出 InterruptedException 异常，并清除中断标志位。如果线程没有被阻塞，则调用 interrupt() 方法只是设置线程的中断标志位为 true，线程仍然可以继续运行。

举个例子
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
public class MyThread extends Thread {
    public void run() {
        try {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("MyThread is running...");
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            System.out.println("MyThread is interrupted!");
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myThread.interrupt();
    }
}

// 结果
/*
    MyThread is running...
    MyThread is running...
    MyThread is running...
    MyThread is running...
    MyThread is running...
    MyThread is interrupted!
*/

新建了一个线程，在主线程中，我们睡眠5S后将新建线程中断，这是新线程捕获中断，并打印了MyThread is interrupted!，

中断标志位

上方代码中，如果我们把while (!Thread.currentThread().isInterrupted()) 换成 while (true)发现运行结果是一样的，为什么呢？这就牵扯到中断标志位了，如上方所言 如果线程被阻塞在某些操作上（如等待 I/O 操作、sleep() 等），调用 interrupt() 方法会中断该线程的阻塞状态，抛出 InterruptedException 异常，并清除中断标志位。上方代码中5s中断线程时，线程在sleep状态，这时候程序抛出 InterruptedException 异常，并清除中断标志位。在抛出异常时线程已经停止了。

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
public class MyThread extends Thread {
    public void run() {
            int i =0;
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("正在打印："+ ++i);
            }

    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        int sum = 0;
        for (int i = 0; i < 1000000; i++) {
            sum += i;
        }
        myThread.interrupt();
    }
}


// 结果
/*
正在打印：0
正在打印：1
正在打印：2
正在打印：3
........
正在打印：104
*/

可以看到我们通过判断程序的中断信号来执行代码，当程序被中断时，跳出while循环，新线程运行结束

循环中使用注意事项

如果我们将try catch 放在循环中发现程序响应中断后并未停止，这是因为sleep（）清除了中断标志位，所以不能将try catch语句放在循环中，而应该放在循环外。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class MyThread extends Thread {
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                System.out.println("MyThread is running...");
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myThread.interrupt();
    }
}

结果

1
2
3
4
5
6
7
8
9
10
11
/*
MyThread is running...
MyThread is running...
MyThread is running...
MyThread is running...
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at threadToStop.MyThread.run(MyThread.java:8)
MyThread is running...
MyThread is running...
    */
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla Python日志模块logging的使用详解 https://nerkeler.github.io/2023/05/04/ython%E6%97%A5%E5%BF%97%E6%A8%A1%E5%9D%97logging%E7%9A%84%E4%BD%BF%E7%94%A8%E8%AF%A6%E8%A7%A3/ 2023-05-04T08:28:00.000Z 2025-05-25T07:23:54.105Z

Python日志模块logging的使用详解

PS: 转载自 https://github.com/HuiDBK/LogSetupDemo

日志

在开发一些大型项目的时候，都会使用日志来记录项目运行时产生的信息，以备出错时定位分析和从日志信息中提取数据统计分析等。在 Python 中使用 logging 内置模块即可对项目进行日志的配置。

logging模块的使用

简单使用

logging 模块提供了一系列便利的函数

它们分别是 debug(), info(), warning(), error(), critical()

1
2
3
4
5
6
7
import logging

logging.debug('debug log test')
logging.info('info log test')
logging.warning('warning log test')
logging.error('error log test')
logging.critical('critical log test')

输出结果：

1
2
3
WARNING:root:warning log test
ERROR:root:error log test
CRITICAL:root:critical log test

为什么只输出了 warning， error 和 critical 的结果，因为 logging 模块默认使用 warning 日志级别，就是只有 warning 及以上日志等级才会显示。

日志等级从高到低，如下所示

级别数值何时使用
CRITICAL50严重的错误，表明程序已不能继续执行
ERROR40由于严重的问题，程序的某些功能已经不能正常执行
WARNING30表明有已经或即将发生的意外，程序仍按预期进行
INFO20确认程序按预期运行
DEBUG10细节信息，仅当诊断问题时适用。
NOTSET0无任何等级限制

我们只要把 logging 的默认日志等级改下就好了

1
2
3
4
5
6
7
8
9
import logging

# 配置日志等级
logging.basicConfig(level=logging.DEBUG)

logging.debug('debug log test')
logging.info('info log test')
logging.warning('warning log test')
logging.error('error log test')

输出结果如下：

1
2
3
4
DEBUG:root:debug log test
INFO:root:info log test
WARNING:root:warning log test
ERROR:root:error log test

指定日志输出样式

当然我们还可以指定日志输出格式

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


# 日志输出样式
log_format = '%(levelname)s %(asctime)s %(filename)s %(lineno)d %(message)s'
logging.basicConfig(format=log_format, level=logging.DEBUG)

logging.debug('debug log test')
logging.info('info log test')
logging.warning('warning log test')
logging.error('error log test')
logging.critical('critical log test')

输出结果如下：

1
2
3
4
5
DEBUG 2021-05-27 00:04:26,327 main.py 65 debug log test
INFO 2021-05-27 00:04:26,327 main.py 66 info log test
WARNING 2021-05-27 00:04:26,327 main.py 67 warning log test
ERROR 2021-05-27 00:04:26,327 main.py 68 error log test
CRITICAL 2021-05-27 00:04:26,327 main.py 69 critical log test

其中日志信息格式化输出配置样式说明

  • %(levelname)s ，日志等级
  • %(asctime)s ，时间
  • %(filename)s ，文件名
  • %(lineno)d ，行号
  • %(message)s，日志信息

这些配置都是固定，不可随便写，还有好多日志格式化样式，这里只介绍了一些常用的格式配置，大家可以去官网查看更多的格式化配置信息。https://docs.python.org/zh-cn/3.7/library/logging.html#formatter-objects

日志记录到文件中

在 logging.basicConfig 中设置 filename 属性即可把日志信息写入文件中

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


# 日志输出样式
log_format = '%(levelname)s %(asctime)s %(filename)s %(lineno)d %(message)s'
logging.basicConfig(
    filename='test.log',
    format=log_format,
    level=logging.DEBUG
)

logging.debug('debug log test')
logging.info('info log test')
logging.warning('warning log test')
logging.error('error log test')
logging.critical('critical log test')

运行程序后 test.log 如下内容

日志信息展示

自定义日志配置

通常我们在项目中都是自定义一些通用日志配置，然后供项目全局使用。写好这些配置下次要在别的项目使用之间复制粘贴过来修改修改一下即可。来康康是如何配置的。

准备日志配置信息

配置日志详细信息，需要导入 logging.config 来进行加载日志配置信息

首先准备日志配置信息字典

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
log_dict = {
    'version': 1,
    'disable_existing_loggers': False,  # 是否禁用已经存在的日志器

    # 日志信息格式化输出配置
    'formatters': {

        # 简单的日志输出
        'simple': {
            'format': '%(levelname)s %(module)s %(lineno)d %(message)s'
        },

        # 详细的日志输出
        'verbose': {
            'format': '%(levelname)s %(asctime)s %(filename)s %(lineno)d %(message)s'
        },
    },

    # 日志信息处理器配置
    'handlers': {
        
        # 向终端中输出日志
        'console': {
            'level': 'DEBUG',                   # 处理的日志等级，DEBUG及以上
            'class': 'logging.StreamHandler',   # 日志处理器
            'formatter': 'simple'               # 日志格式化配置
        },

        # 向文件中输出日志
        'file': {
            'level': 'INFO',                                    # 处理的日志等级，DEBUG及以上
            'class': 'logging.handlers.RotatingFileHandler',    # 使用文件日志处理器
            'formatter': 'verbose',                             # 日志格式化配置
            'filename': './logs/test.log',                      # 日志文件存储位置
            'maxBytes': 1024 * 1024,        # 每个日志文件最大 10MB, 单位: byte
            'backupCount': 20,              # 如果文件满了, 自动扩充, 最多保留 20 个日志文件
            'encoding': 'utf8',
        },
    },

    # 默认根日志器
    'root': {
        'level': 'DEBUG',           # 允许接受的日志等级
        'handlers': ['console']     # 选择日志处理器
    },

    # 自定义的日志器
    'loggers': {
        'server': {
            'level': 'DEBUG',
            'handlers': ['file'],
            'propagate': True       # 设为 False则禁止将日志消息传递给父级记录器的处理程序中
        }
    }
}

其中大字典的 key 都是固定，例如 version,formatters, handlers, root, loggers等都是固定的配置项。而有一些子选项是可以自己自定义如

  • formatters 下的 simple 和 verbose，是可以改成自己想要的名字。
  • handlers 下的 console 和 file 也是可以修改的。
  • loggers 下的 server 都是一样可以修改的

具体配置的说明，在这字典中都有一一注释我就不全介绍了，我就介绍一下 handlers 日志处理器的配置

在 logging 模块中有许多 日志处理器类，我们只需要在 pycharm 中输入 logging.Handler 就能弹出最基本的几个日志处理类。

日志处理器

而上文所用到的 StreamHandler 则是流处理器，日志将随着系统标准输入、输出流展示，而我们的 PyCharm终端、控制台等 显示的信息就属于系统标准输出流。

而 RotatingFileHandler 日志处理器则是 FileHandler 的子类。其主要作用就是把日志写入文件中，当文件内容达到最大限制时可以自动扩充日志文件，以达到日志文件的轮换。

加载日志配置信息

然后使用 logging.config.dictConfig() 方法加载日志配置，该方法接受一个 字典 参数。

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
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author: Hui
# @Desc: { 日志模块logging的使用 }
# @Date: 2021/05/26 23:14
import logging
import logging.config

log_dict = {
    'version': 1,
    'disable_existing_loggers': False,  # 是否禁用已经存在的日志器

    ...与上文一致故省略

    # 默认根日志器
    'root': {
        'level': 'DEBUG',  # 接受的日志等级
        'handlers': ['console']
    },
    
    # 自定义的日志器
    'loggers': {
        'server': {
            'level': 'DEBUG',
            'handlers': ['file'],
            'propagate': True       # 设为 False则禁止将日志消息传递给父级记录器的处理程序中
        }
    }
}


def setup_logging():
    """
    配置日志信息
    :return:
    """
    logging.config.dictConfig(config=log_dict)
    logger = logging.getLogger()
# logger = logging.getLogger('root')
    
    logger.debug('debug log test')
    logger.info('info log test')
    logger.warning('warning log test')
    logger.error('error log test')


def main():
    setup_logging()


if __name__ == '__main__':
    main()

使用 logging.getLogger() 即可获取相应配置日志器，其接受一个日志器的名字，不传则默认使用 root 根日志器，同 logging.getLogger('root') 效果一致。

如果之间运行程序会出现如下错误

1
ValueError: Unable to configure handler 'file'

那是因为你在日志配置中设置了一个文件处理器 file ，其日志文件将存储在 filename 配置项中，在这里是

1
./logs/test.log# 代表存储在当前路径下的 logs目录下的 test.log 文件

logging 模块不会自动帮我们创建目录，因此只需在当前目录中创建一个 logs 目录即可。

最后程序运行结果如下

1
2
3
4
DEBUG main 74 debug log test
INFO main 75 info log test
WARNING main 76 warning log test
ERROR main 77 error log test

不用跟 root 根日志器，使用 server 日志器，代码如下

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
import logging
import logging.config

log_dict = {...同上文省略...}

def setup_logging():
    """
    配置日志信息
    :return:
    """
    logging.config.dictConfig(config=log_dict)
    # logger = logging.getLogger()

    logger = logging.getLogger('server')
    logger.debug('debug log test')
    logger.info('info log test')
    logger.warning('warning log test')
    logger.error('error log test')
    
    
def main():
    setup_logging()


if __name__ == '__main__':
    main()

运行结果如下：

控制台

1
2
3
4
DEBUG main 75 debug log test
INFO main 76 info log test
WARNING main 77 warning log test
ERROR main 78 error log test

日志文件 logs/test.log

文件日志信息

由于 server 日志器设置了 'propagate': True，会 将日志消息传递给父级记录器的处理程序中，因此不仅控制台会显示日志信息，文件也会记录，但文件记录的等级被设置成 INFO 了，因此 DEBUG 调试日志信息，将不会出现在文件中。

使用日志配置文件

这里我将采用 yaml 格式的日志配置文件。具体配置内容和上文大致一样，多了一个 error_file_handler 错误日志处理器，目的就是把 错误日志单独放在一个文件中，方便以后排查错误。

创建日志配置文件

创建 logging.yaml 文件，内容如下所示

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
version: 1
disable_existing_loggers: true

# 日志信息格式化输出配置
formatters:
    simple:
        format: '%(levelname)s %(filename)s %(lineno)d %(message)s'
    verbose:
        format: '%(levelname)s %(asctime)s -Loc %(filename)s -Row %(lineno)d -%(name)s %(message)s'

# 日志信息处理器配置
handlers:
    console:
        class: logging.StreamHandler
        level: DEBUG
        formatter: simple
        stream: ext://sys.stdout

    # 错误日志单独处理
    error_file_handler:
        class: logging.handlers.RotatingFileHandler
        level: ERROR
        formatter: verbose
        filename: ./logs/errors.log   # 错误日志文件存储位置
        maxBytes: 10485760            # 每个日志文件最大 10MB
        backupCount: 20               # 如果文件满了, 自动扩充, 最多保留 20 个日志文件
        encoding: utf8

    server_file_handler:
      class: logging.handlers.RotatingFileHandler
      level: INFO                     # 只在文件中记录INFO级别及以上的log
      formatter: verbose
      filename: ./logs/server.log    # 项目日志文件, 记录所有日志信息
      maxBytes: 10485760             # 10MB
      backupCount: 30
      encoding: utf8

# 根日志器
root:
    level: DEBUG
    handlers: [console]

# 日志器
loggers:
    server:
        level: DEBUG      # 允许打印 DEBUG 及以上log
        handlers: [server_file_handler, error_file_handler]
        propagate: True   # 设为 False则禁止将日志消息传递给父级记录器的处理程序中

加载日志配置函数

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
# log_test.py 文件

import os
import yaml
import logging
import coloredlogs
import logging.config


# 项目根路径
BASE_DIR = os.path.dirname(os.path.abspath(__file__))

# 日志配置文件
LOG_CONF_FILE = os.path.join(BASE_DIR, 'logging.yaml')


def setup_logging(default_path=LOG_CONF_FILE, default_level=logging.DEBUG, env_key='LOG_CFG'):
    """
    配置项目日志信息
    :param default_path: 日志文件默认路径
    :param default_level: 日志默认等级
    :param env_key: 系统环境变量名
    :return:
    """
    path = default_path

    value = os.getenv(env_key, None)  # 获取对应的环境变量值
    if value is not None:
        path = value

    if os.path.exists(path):
        with open(path, mode='r', encoding='utf-8') as f:
            try:
                logging_yaml = yaml.safe_load(f.read())
                logging.config.dictConfig(logging_yaml)
                coloredlogs.install(level='DEBUG')
            except Exception as e:
                print(e)
                print('无法加载日志配置文件, 请检查日志目录是否创建, 使用默认的日志配置')
                logging.basicConfig(level=default_level)
                coloredlogs.install(level=default_level)
    else:
        logging.basicConfig(level=default_level)
        coloredlogs.install(level=default_level)
        print('日志配置文件不存在, 使用默认的日志配置')

这里使用到第三方库如下

  • yaml 是用于读取 yaml 格式的日志配置文件
  • coloredlogs 用于让日志在控制台中有颜色显示。

然后我们在项目中只要执行完 setup_logging() 日志配置函数

其他模块直接使用 logging.getLogger('server') 就可获取我们配置好的日志器。

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
# log_demo.py 文件

import logging

logger = logging.getLogger('server')  # 维护一个全局日志对象

logger.debug('debug log test')


def log_test1():
    logger.info('info log test')


def log_test2():
    try:
        a = 1 / 0
    except Exception as e:
        logger.error(e)


class LogDemo(object):

    @staticmethod
    def log_test():
        logger.warning('warning log test')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# log_test.py

def main():
    setup_logging()

    logger = logging.getLogger('server')
    logger.debug('debug log test')
    logger.info('info log test')
    logger.warning('warning log test')
    logger.error('error log test')

    # 日志在其他模块中使用演示
    import log_demo
    log_demo.log_test1()
    log_demo.log_test2()
    log_demo.LogDemo.log_test()
    
    
if __name__ == '__main__':
    main()

日志效果展示

运行 log_test.py 结果如下

控制台信息

带颜色的日志信息

全部日志配置文件信息

全部日志文件信息

错误日志文件信息

错误日志文件信息

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 动漫之家《镖人》爬虫 https://nerkeler.github.io/2023/03/31/%E5%8A%A8%E6%BC%AB%E4%B9%8B%E5%AE%B6%E3%80%8A%E9%95%96%E4%BA%BA%E3%80%8B%E7%88%AC%E8%99%AB/ 2023-03-31T02:21:00.000Z 2025-05-25T07:24:08.070Z

前言

初学python时写的爬虫小程序，爬取动漫之家 《镖人》漫画所有文件到本地，单线程爬取，速度一般，如果用多线程会有很大速度提升，抽取爬虫逻辑可爬全站漫画资源

代码

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
import os
import re
import requests
from bs4 import BeautifulSoup
from tqdm import tqdm


# 获取当前漫画总链接文本
def get_url(url):
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.75 Safari/537.36"}
    res = requests.get(url, headers=headers)
    res.encoding = res.apparent_encoding
    if res.status_code == 200:
        return res.text
    else:
        return None


# 爬取所有章节标题、链接
def get_page(html):
    title_list, href_list = [], []

    soups = BeautifulSoup(html, "lxml")
    soups = soups.find(attrs={"class": "list_con_li autoHeight"})

    for soup in soups.select("li a"):
        title_list.insert(0, soup['title'])
        href_list.insert(0, soup['href'])

    return title_list, href_list  # 返回列表


# 判断是否为数字型字符串
def is_number(s):
    try:
        float(s)
        return True
    except ValueError:
        pass


# 爬取章节内所有图片
def main_download(name, url):
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.75 Safari/537.36",
        "Referer": url}  # 浏览器标识
    res = requests.get(url, headers=headers)
    html = res.text  # 动态页面，返回js代码
    link = re.findall("function\(p,a,c,k,e,d\).*?split", html)  # 匹配图片代码片段
    """解码js，构造图片真实链接"""
    first_number = link[0].split("'.split")
    first_number = first_number[0].split("||")
    links, second = [], []
    first = ""
    for i in first_number:
        number = i.split("|")
        for num in number:
            try:
                if is_number(num) and len(num) == 4:
                    first = num  # 链接开始四位数数字串
                elif is_number(num) and (len(num) == 5 or len(num) == 6):
                    second.append(int(num))  # 链接中间数字串
                elif is_number(num) and len(num) >= 7:
                    links.append(num)  # 链接末尾数字串

            except:
                pass
    links = sorted(links)  # 由小到大排序
    # 开始下载图片
    for i in links:
        imgs_link = f'https://images.dmzj.com/img/chapterpic/{first}/{second[0]}/{i}.jpg'  # 构造真实链接

        response = requests.get(url=imgs_link, headers=headers)
        try:
            with open(f"镖人/{name}/{i}.jpg", 'wb') as f:
                f.write(response.content)
        except:
            pass
    print(f"{name}: 已经下载完成")


# 主循环
def main():
    if not os.path.exists("镖人"):  # 创建总文件夹
        os.mkdir("镖人")
    url = "https://www.dmzj.com/info/biaoren.html"
    html = get_url(url)
    title_list, href_list = get_page(html)
    #processing = tqdm(range(0,len(title_list)))
    for name, url in zip(title_list, href_list,):
        if not os.path.exists(f"镖人/{name}"):
            os.mkdir(f"镖人/{name}")
        main_download(name, url)


if __name__ == '__main__':
    main()
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla Java日期小工具类 https://nerkeler.github.io/2023/03/30/Java%E6%97%A5%E6%9C%9F%E5%B0%8F%E5%B7%A5%E5%85%B7%E7%B1%BB/ 2023-03-30T08:04:00.000Z 2025-05-25T07:24:25.602Z

Java 日期月份处理小工具类

再sql的月份和日期查询中，可能会需要将日期或者月份相应推迟/提前一天或一段时间，当然，这个逻辑放在sql中也是可以的，具体还是要看需求是否合适。分享三个小方法，一个是计算月份差、日期加减一/多天、月份加减一/多天

月份差

输入参数：
  • startMonth
    • 字符串，格式应该为yyyy-MM对应下面SimpleDateFormat("yyyy-MM");可根据需要更改格式
  • endMonth
    • 字符串，格式应该为yyyy-MM对应下面SimpleDateFormat("yyyy-MM");可根据需要更改格式
返回值
  • diff
    • 整型，月份差值，如3月-6月 返回3
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
public  int getMonthDiff(String startMonth, String endMonth) {
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM");
    Date start = null;
    Date end = null;
    try {
        start = dateFormat.parse(startMonth);
        end = dateFormat.parse(endMonth);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    Calendar c1 = Calendar.getInstance();
    Calendar c2 = Calendar.getInstance();
    c1.setTime(start);
    c2.setTime(end);
    int year1 = c1.get(Calendar.YEAR);
    int year2 = c2.get(Calendar.YEAR);
    int month1 = c1.get(Calendar.MONTH);
    int month2 = c2.get(Calendar.MONTH);
    int day1 = c1.get(Calendar.DAY_OF_MONTH);
    int day2 = c2.get(Calendar.DAY_OF_MONTH);
    // 获取年的差值
    int yearInterval = year1 - year2;
    // 如果 d1的 月-日 小于 d2的 月-日 那么 yearInterval-- 这样就得到了相差的年数
    if (month1 < month2 || month1 == month2 && day1 < day2) {
        yearInterval--;
    }
    // 获取月数差值
    int monthInterval = (month1 + 12) - month2;
    if (day1 < day2) {
        monthInterval--;
    }
    monthInterval %= 12;
    int monthsDiff = Math.abs(yearInterval * 12 + monthInterval);
    return monthsDiff;
}

日期加减

输入参数：
  • day
    • 字符串，日期，格式应该为yyyy-MM-dd对应下面SimpleDateFormat("yyyy-MM-dd");可根据需要更改格式
  • num
    • 整型，偏移量 为正 时间往后加，负 时间往前推
返回值
  • date
    • String，格式处理后的时间，如3月1-3月4 返回3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
private String dayFormat(String day, int num) {
       DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
       Date date = null;
       try {
           date = dateFormat.parse(day);
       } catch (ParseException e) {
           e.printStackTrace();
       }
       Calendar c = Calendar.getInstance();
       c.setTime(date);
       c.add(Calendar.DATE,num);
       date = c.getTime();
       return  dateFormat.format(date);
   }

月份加减

输入参数：
  • day
    • 字符串，日期，格式应该为yyyy-MM对应下面SimpleDateFormat("yyyy-MM");可根据需要更改格式
  • num
    • 整型，偏移量 为正 月份往后加，负 时间往前推
返回值
  • date
    • String，格式处理后的时间，如3月-6月 返回3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
private String monthFormat(String month, int num) {
       DateFormat dateFormat = new SimpleDateFormat("yyyy-MM");
       Date date = null;
       try {
           date = dateFormat.parse(month);
       } catch (ParseException e) {
           e.printStackTrace();
       }
       Calendar c = Calendar.getInstance();
       c.setTime(date);
       c.add(Calendar.MONTH,num);
       date = c.getTime();
       return  dateFormat.format(date);
   }

小结

最近太水了，已经托更一周了，这次又是水了一篇，争取下次好好写一篇

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla windows本地密码管理器 https://nerkeler.github.io/2023/03/20/windows%E5%AF%86%E7%A0%81%E7%AE%A1%E7%90%86%E5%99%A8/ 2023-03-20T00:42:00.000Z 2025-05-25T07:24:53.760Z

本地密码管理器4.0

github地址：https://github.com/nerkeler/account.git

蓝奏云：https://wwtf.lanzoul.com/b01ereqoh 密码:9920
文叔叔：https://t.wss.ink/f/b4jc2yer65e

重要提示

程序默认密码：password

密钥位置：./resource/aesKey 建议另存一份以作备份

修改点

  • 本地密码导出中文乱码修复
  • 引入日志记录
  • 优化edge/chrome 浏览器导出适配管理

PS: 程序第一次打开关于页面显示不完整，如果遇到，请关闭后再打开

================================================================

前言

闲来无事，看到自己有很多网站的账户密码，有些网站可能打开一两次也就忘记了，下一次在输入账户密码就想不起来，这样很容易丢失账号（当然也可以保存在浏览器自带的密码管理器中），虽然市面上也有很多优秀的账户密码管理软件，一来是这些程序大都是联网运行，在提供了多端存档的同时，也将密码和账户在网络上传输，虽然实际上很安全，但是并不是绝对的安全，二来，部分优秀的程序都是订阅付费机制，就想着自己干脆写个简单的本地的账户管理器，于是就有了这个小程序

先说一下优点吧，同市面上的程序比较，一个最突出的优点就是完全运行在本地，账户密码经过AES加密，在逻辑上可以说是非常安全的，因为你的密码不会暴漏在网络上，本地也进行了加密处理。

当然缺点也很明显，一是功能不是十分完善，二是该程序使用tkinter 模块编写，在布局和界面展示上都显得十分简陋，好在基本的功能没有问题

使用说明

  1. 下载解压程序文件
  2. 运行account.exe文件
  3. 点击新建账号按钮添加新的账号密码信息
  4. 双击表格中的数据进行编辑或删除
  5. 点击导出按钮验证密钥密码后将数据导出为CSV格式文件
  6. 点击导入按钮选择CSV文件进行导入数据
  7. 可按需求导入并管理Chrome/Edge密码本浏览器密码

登录

第一次登陆密钥弹出框被关闭时，就进入了程序的登录界面，默认账户名admin 不可修改，默认密码为 ：**password**，建议第一次登陆时修改密码

PS: 多用户功能尚未开发，因此账户名锁定不可编辑

修改密码

在登陆界面 点击 改密 进入修改密码界面，新密码要求字符数大于8位，点击确定 按钮即可进行密码修改，修改成功后会提示修改成功，重新登陆，如下图所示

chrome/edge浏览器密码导入管理

依次点击：

  1. 设置

  2. 自动填充

  3. 密码管理器

    找到如图红框内容，验证设备密码后导出chrome密码本csv文件到本地

回到程序后点击导入

对应导入源后选择导入文件即可导入数据，单线程导入较慢，请耐心等待，快捷键暂未适配

主页面

主界面略作修改

主界面共分为两个区域：

  • 一个是上方的功能区，提供了查询、查看、新增、删除（软删除）功能，
  • 一个是下方的账户展示区域，默认打开时按照列表展示所有账户信息
相关操作

  • 下拉框提供了 账户编号（对应下方序号列）、网站名称（对应下方网站列）、网站网址（对应下方网址列）查询条件转换

  • 文本框接受 下拉框的对应字段，为空时默认查询所有

  • 点击某一项账户时，点击查看/双击当前项 可进入当前账户查看界面，如图所示，当前页面也可以更新账户信息

  • 新增按钮会弹出新增界面，按照规定指示填写字段即可新增一条记录

  • 删除按钮 在点击某一项账户时，点击删除，即可删除当前记录（软删除，更改了当前的状态）

随机密码

可以按照自己的需求生成相应的密码规则，ABC/123/abc/#$&

注：在密码长度>字符类型数的时候会补数字 如 密码长度选30 规则选abc 会在26个字符后再补几个数字构成随机字符

关于

聊胜于无，简单说一下，详细见程序页面

补充说明

忘记登陆账户密码时，可将account.db 文件使用数据库可视化工具打开，取出当前账户的相关信息和密码，根据密钥和加密逻辑解密当前账户的密码明文

加密逻辑如下：

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
import hashlib
from Crypto.Cipher import AES


def encode_password(password):
key = yourkey# key 表示你的密钥 
    
slot = "nerkeler"
    encode = key + slot
    myKey = hashlib.md5(encode.encode("utf-8")).hexdigest().__str__()[:24]
    return aes_encode(myKey, password)


def aes_decode(key, ciphertext):
    # 将密钥填充到16的倍数
    key = key + (16 - len(key) % 16) * '\0'
    # 创建AES密码器对象
    cipher = AES.new(key.encode(), AES.MODE_ECB)
    # 解码Base64编码的密文
    ciphertext = base64.b64decode(ciphertext)
    # 解密
    plaintext = cipher.decrypt(ciphertext)
    # 去除填充字符
    plaintext = plaintext.rstrip(b'\0')
    return plaintext.decode()

总结

后期打算使用pyside6重写一版，Tkinter版本不准备大改动了，如果有使用建议和bug,欢迎打扰，详见关于页

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla 对称加密和非对称加密 https://nerkeler.github.io/2023/03/10/%E5%AF%B9%E7%A7%B0%E5%8A%A0%E5%AF%86%E5%92%8C%E9%9D%9E%E5%AF%B9%E7%A7%B0%E5%8A%A0%E5%AF%86/ 2023-03-10T01:52:00.000Z 2023-03-30T08:10:02.000Z

对称加密AES和非对称加密RSA

AES（ Advanced Encryption Standard ）

对称加密算法，加密和解密过程使用同一个密钥

AES为分组加密法，把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文，在AES标准规范中，分组长度只能是128位，AES是按照字节进行加密的，也就是说每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。这导致密钥长度不同，推荐加密的轮数也不同。

因为明文和密钥必须是128位（密钥可以是192/256 位），所以需要将分组明文和密钥进行补位

python代码实现

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
from Crypto.Cipher import AES
import base64

# 加密  ECB模式  16代表16字节也就是128位
def aes_encode(key, password):
    # 将密钥填充到16的倍数
    key = key + (16 - len(key) % 16) * '\0'
    # 创建AES密码器对象
    cipher = AES.new(key.encode(), AES.MODE_ECB)
    # 将明文填充到16的倍数
    password = password + (16 - len(password) % 16) * '\0'
    # 加密
    ciphertext = cipher.encrypt(password.encode())
    # 将密文进行Base64编码
    ciphertext = base64.b64encode(ciphertext)
    return ciphertext.decode()


# 解密
def aes_decode(key, ciphertext):
    # 将密钥填充到16的倍数
    key = key + (16 - len(key) % 16) * '\0'
    # 创建AES密码器对象
    cipher = AES.new(key.encode(), AES.MODE_ECB)
    # 解码Base64编码的密文
    ciphertext = base64.b64decode(ciphertext)
    # 解密
    plaintext = cipher.decrypt(ciphertext)
    # 去除填充字符
    plaintext = plaintext.rstrip(b'\0')
    return plaintext.decode()


RSA

RSA是一种公钥加密算法，它可以用于保护数据的机密性和完整性。它基于两个大质数的乘积难以被分解的数学问题，通过这种问题的解决来保护数据的安全性。

RSA算法包括三个步骤：密钥生成、加密和解密。在密钥生成过程中，首先选择两个大质数p和q，计算它们的乘积n=pq，并选择一个整数e，使得e和(p-1)(q-1)互质。然后计算d，使得(de) mod((p-1)(q-1))=1。公钥是(e,n)，私钥是(d,n)。

在加密过程中，要发送的消息m被转换为整数M，并用公钥(e,n)进行加密，计算C=M^e mod n。

在解密过程中，使用私钥(d,n)对加密的消息进行解密，计算M=C^d mod n。

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
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
import base64

def generate_key_pair():
    """生成RSA密钥对"""
    key_pair = RSA.generate(2048)
    private_key = key_pair.export_key()
    public_key = key_pair.publickey().export_key()
    return private_key, public_key

def encrypt(public_key, plaintext):
    """RSA加密"""
    key = RSA.import_key(public_key)
    cipher = PKCS1_v1_5.new(key)
    ciphertext = cipher.encrypt(plaintext.encode('utf-8'))
    return base64.b64encode(ciphertext).decode('utf-8')

def decrypt(private_key, ciphertext):
    """RSA解密"""
    key = RSA.import_key(private_key)
    cipher = PKCS1_v1_5.new(key)
    ciphertext = base64.b64decode(ciphertext.encode('utf-8'))
    plaintext = cipher.decrypt(ciphertext, None).decode('utf-8')
    return plaintext

if __name__ == '__main__':
    # 生成RSA密钥对
    private_key, public_key = generate_key_pair()
    
    # unicode 转str
    print(private_key.decode("utf-8"))
    print(public_key.decode("utf-8"))
    # 加密消息
    message = 'Hello, world!'
    ciphertext = encrypt(public_key, message)
    print('加密后的消息：', ciphertext)
    # 解密消息
    plaintext = decrypt(private_key, ciphertext)
    print('解密后的消息：', plaintext)

摘要算法，非对称加密算法与对称加密算法 安全性 比较

引用博客 https://blog.betamao.me/posts/2021/24/pkcs-v1_5_misuse/

  • 摘要算法通过单向陷门函数将任意长度映射到固定长度，这个过程是不可逆的，再加上它的抗碰撞性让它成为标识数据的好方法，这方面如果用的算法是老古董就可能受碰撞和长度扩展攻击的影响。
  • 对称加密算法使用的加解密钥相同，可再分为流密码与分组密码，流密码将它的密钥作为随机数种子通过伪随机生成函数源源不断地生成随机数，明文与之异或就得到了密文，由于异或运算的特性密文与之异或也就恢复了明文，因此它的加解密算法是一样的，而且它针对的任意长度的数据。分组密码的密钥和加密长度是固定的，它会对加密密钥进行一些变换，再与明文进行运算，该过程可能进行多次因此加解密算法不一定相同，由于它只能加密固定长度的数据，而一般要加密的数据长度都不满足要求，此时就需要把数据分组，若分组后最后一组的长度不满足要求又需要对其填充，前者就是分组密码的工作模式。是否需要填充也和工作模式相关，如OFB模式就可以将过程转换为类似流密码的方式，而XTS使用密文窃取也不需要填充，另外即使长度刚好符合也可能需要填充，如PKCS7此时就需要再填充一个完整的分组，之前提到若PKCS7与CBC模式组合时，就有可能出现PaddingOracle漏洞，即若服务端会返回解密状态则可以通过推测加密任何数据。
  • 非对称加密算法加解密不再使用相同的密钥，而且它的结构和对称密码有很大的不同，对称密码更像是逻辑位运算而非对称是数学运算，它利用的全是数学上的难题，就是(给一个限制)后只有正向计算的算法，而还没有逆向计算的算法(大整数分解，椭圆曲线离散对数，格最短向量等)，先随机生成符合要求的私钥，私钥到公钥的生成过程是正向的有算法因此很容易，而反过来就没有算法可恢复，通过公开公钥就可实现加密与签名功能，由于这种加密也是在有限的范围上完成的因此单次运算的数字大小有限制，为此也需要对其分组填充，RSA就有PKCS1 V1.5与PKCS OAEP。
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="\assets\css\APlayer.min.css"><script src="\assets\js\APlayer.min.js" cla