背包问题实际上是动态规划的一种经典应用，本文想通过介绍一种模板用于解决各种背包问题。

• 模板统一采用二维数组来表示动态规划的状态，其中行表示物品的价值（或体积、大小、重量等），列表示背包的容量（或目标值）。
• 行和列都增加了一位，即从1开始计数，一来可以避免边界检查，二来dp[...][target]变得有意义，而非dp[...][target-1]，具体值和数组索引能够对上。根据不同题意来初始化dp，需要注意的是只要涉及到取物品的值，我们需要对索引减1，因为我们是从1开始计数的。

接下来分三种情况考虑动态规划中的状态转移表达式：

1. 完全背包（每件物品可以无限使用）：dp[i][j]=OPERATE(dp[i-1][j],dp[i][j-objs[i-1]])。这里的OPERATE可以是sum、max、or视具体的问题而定。第二个表达式的索引是i。
   

   1 2 3 4 5 6 7 8 9 10 11

   def bag_problem(self, bag: int, objs: List[int]) -> int: n=len(objs)+1 #将物品数量增加1，避免边界检查 #以下两行初始化dp状态 dp=[[xxx]*(bag+1) for _ in range(n)] dp[0][0]=xxx for i in range(1,n): for j in range(bag+1): dp[i][j]=dp[i-1][j] if j>=objs[i-1]: #涉及到物品的索引都需要减1 dp[i][j]=operate(dp[i-1][j],dp[i][j-objs[i-1]]) #注意第2项是i return dp[-1][-1]

2. 01背包（每件物品只可使用一次）：dp[i][j]=OPERATE(dp[i-1][j],dp[i-1][j-objs[i-1]])，注意和完全背包问题的区别，第二个表达式的索引是i-1。
   

   1 2 3 4 5 6 7 8 9 10 11

   def bag_problem(self, bag: int, objs: List[int]) -> int: n=len(objs)+1 #将物品数量增加1，避免边界检查 #以下两行初始化dp状态 dp=[[xxx]*(bag+1) for _ in range(n)] dp[0][0]=xxx for i in range(1,n): for j in range(bag+1): dp[i][j]=dp[i-1][j] if j>=objs[i-1]: #涉及到物品的索引都需要减1 dp[i][j]=operate(dp[i-1][j],dp[i-1][j-objs[i-1]]) #注意第2项是i-1 return dp[-1][-1]

3. 完全背包排列：dp[i][j]=OPERATE(dp[i-1][j],dp[-1][j-objs[i-1]])，第二个表达式的索引是-1，也即最后一行。

   遍历行时的顺序也即访问每件物品的顺序，虽然物品顺序不作限制，但这里有个隐藏条件，遍历过的物品是不会再次访问的，也就是说，选择物品是组合问题，无论先选哪个后选哪个，只要都被选了，只能算作一种状态。
   这里归到第3类的问题仍然归属于完全背包范畴，但是它是求排列而非组合，即先拿A或者先拿B，或者拿了A，B之后还可以再次拿A。
   在前面的2类问题中，我们优先行或者优先列遍历对结果来说并没有影响，但在这里由于状态转移方程中每次都需最后一行参与计算，所以必须优先列遍历。
   

   1 2 3 4 5 6 7 8 9 10 11

   def bag_problem(self, bag: int, objs: List[int]) -> int: n=len(objs)+1 #将物品数量增加1，避免边界检查 #以下两行初始化dp状态 dp=[[xxx]*(bag+1) for _ in range(n)] dp[0][0]=xxx for j in range(bag+1): #内外循环颠倒,按列遍历 for i in range(1,n): dp[i][j]=dp[i-1][j] if j>=objs[i-1]: #涉及到物品的索引都需要减1 dp[i][j]=operate(dp[i-1][j],dp[-1][j-objs[i-1]] #第2项是-1，表示最后一行 return dp[-1][-1]

下面，让我们使用该模板来解决力扣上的各种背包问题。

现在问题的关键就在于把实际问题抽象化为背包问题中的哪一类，然后套用模板即可。
在以下问题中，模板中的二维数组均可优化为一维数组以降低空间复杂度。不用加重记忆负担去考虑什么时候该顺序遍历，什么时候该逆序遍历，以及行列遍历顺序能不能颠倒。当你了解了这个模板的含义，知道动态规划是如何在二维数组上实现的，这些问题都可以迎刃而解。

完全背包

从n种物品中任选，每种物品可以无限取用

方案数

518. 零钱兑换 II

给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。

示例 1:

输入: amount = 5, coins = [1, 2, 5]
输出: 4
解释: 有四种方式可以凑成总金额:
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1

示例 2:

输入: amount = 3, coins = [2]
输出: 0
解释: 只用面额2的硬币不能凑成总金额3。

示例 3:

输入: amount = 10, coins = [10]
输出: 1

问题转换：从n种物品中任选，每种物品可以无限取用，恰好可以装满背包的组合数是多少？

1
2
3
4
5
6
7
8
9
10
11

def change(self, amount: int, coins: List[int]) -> int:
    n=len(coins)+1
    dp=[[0]*(amount+1) for _ in range(n)]
    dp[0][0]=1
    for i in range(1,n):
        for j in range(amount+1):
            dp[i][j]+=dp[i-1][j]
            if j>=coins[i-1]:
                # dp[i][j]=sum(dp[i-1][j],dp[i][j-objs[i-1]])
                dp[i][j]+=dp[i][j-coins[i-1]]
    return dp[-1][-1]

特例：求排列非组合

377. 组合总和 Ⅳ

给你一个由不同整数组成的数组nums，和一个目标整数target。请你从nums中找出并返回总和为target的元素组合的个数。
题目数据保证答案符合 32 位整数范围。

示例 1：

输入：nums = [1,2,3], target = 4
输出：7
解释：
所有可能的组合为：
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)
请注意，顺序不同的序列被视作不同的组合。

示例 2：

输入：nums = [9], target = 3
输出：0

问题转换：和完全背包的恰好装满问题一样，只不过是求排列数而非组合数。

1
2
3
4
5
6
7
8
9
10
11

def combinationSum4(self, nums: List[int], target: int) -> int:
    n=len(nums)+1
    dp=[[0]*(target+1) for _ in range(n)]
    dp[0][0]=1
    for j in range(target+1):   #内外循环颠倒,按列遍历
        for i in range(1,n):
            dp[i][j]+=dp[i-1][j]
            if j>=nums[i-1]:
                #这里是-1，不是i-1。dp[i][j]=sum(dp[i-1][j],dp[-1][j-objs[i-1]])
                dp[i][j]+=dp[-1][j-nums[i-1]]
    return dp[-1][-1]

最值

322. 零钱兑换

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。
你可以认为每种硬币的数量是无限的。

示例 1：

输入：coins = [1, 2, 5], amount = 11
输出：3
解释：11 = 5 + 5 + 1

示例 2：

输入：coins = [2], amount = 3
输出：-1

示例 3：

输入：coins = [1], amount = 0
输出：0

示例 4：

输入：coins = [1], amount = 1
输出：1

示例 5：

输入：coins = [1], amount = 2
输出：2

问题转换：完全背包恰好装满，所需最少物品数。

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

def coinChange(self, coins: List[int], amount: int) -> int:
    n=len(coins)+1
    dp=[[0]*(amount+1) for _ in range(n)]
    for j in range(1,amount+1):  #初始化为极值
        dp[0][j]=float('inf')
    for i in range(1,n):
        for j in range(amount+1):
            dp[i][j]=dp[i-1][j] #求dp[i-1][j]和dp[i][j-coins[i-1]]+1的较小值，这里是赋值而非累加
            if j>=coins[i-1]:
                # dp[i][j]=min(dp[i-1][j],dp[i][j-objs[i-1]])
                dp[i][j]=min(dp[i][j],dp[i][j-coins[i-1]]+1)
    return -1 if dp[-1][-1]==float('inf') else dp[-1][-1]

279. 完全平方数

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。
给你一个整数 n ，返回和为 n 的完全平方数的最少数量。
完全平方数是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

示例 1：

输入：n = 12
输出：3
解释：12 = 4 + 4 + 4

示例 2：

输入：n = 13
输出：2
解释：13 = 4 + 9

问题转换：完全背包恰好装满，所需最少物品数。把正整数n抽象化为背包容量，从1开始的正整数抽象化为物品，其重量是值的平方。它的平方不能超过n，所以可以确定数字的上限。

1
2
3
4
5
6
7
8
9
10

def numSquares(self, n: int) -> int:
    m=math.floor(n**0.5)  #最大物品的值
    dp=[[float('inf')]*(n+1) for _ in range(m+1)]
    dp[0][0]=0        
    for i in range(1,m+1):            
        for j in range(n+1):
            dp[i][j]=dp[i-1][j]
            if j>=i**2:
                dp[i][j]=min(dp[i-1][j],dp[i][j-i**2]+1)
    return dp[-1][-1]

注意：python语言采用此方法提交会超出时间限制，一个更好的办法是采用数学来解此题，会用到一个数学定理：四平方和定理。

1449. 数位成本和为目标值的最大数字

给你一个整数数组cost和一个整数target。请你返回满足如下规则可以得到的最大整数：

• 给当前结果添加一个数位（i + 1）的成本为cost[i]（cost 数组下标从 0 开始）。

• 总成本必须恰好等于target。

• 添加的数位中没有数字 0 。

由于答案可能会很大，请你以字符串形式返回。
如果按照上述要求无法得到任何整数，请你返回 “0” 。

示例 1：

输入：cost = [4,3,2,5,6,7,2,5,5], target = 9
输出：”7772”
解释：添加数位 ‘7’ 的成本为 2 ，添加数位 ‘2’ 的成本为 3 。所以 “7772” 的代价为 23+ 31 = 9 。 “977” 也是满足要求的数字，但 “7772” 是较大的数字。
数字 成本
1 -> 4
2 -> 3
3 -> 2
4 -> 5
5 -> 6
6 -> 7
7 -> 2
8 -> 5
9 -> 5

问题转换：每个物品体积不一样，完全背包恰好装满，最多可以装多少个物品。数字能选择的越多，必然能得到的数字越大，同时，我们是从1-9开始选择，也就是从数值的小到大，如果确定选择了这个数，也必然是目前最大的，那肯定放在最高位，得到的整数最大。

可完全套用完全背包模板，只需把operate抽象化为一个函数，这个函数类似于max函数，不过更高级，它比较2个值，在能恰好装满背包的前提下，谁组成的数字更大。

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

def largestNumber(self, cost: List[int], target: int) -> str:
    def maxValue(a,b,v):
        if a is None and b is None:  # 两种方案都不可行，返回None
            return None
        if b is None:    # 其中一种不行，就直接返回另一种
            return a
        b=v+b
        if a is None:
            return b
        n1,n2=len(a),len(b)   # 两种都可以，比较谁的数值更大
        if n1>n2:
            return a
        elif n1<n2:
            return b
        return max(a,b)
    n=len(cost)
    dp=[['']*(target+1) for _ in range(n+1)]  # 标准完全背包模板，只是把operate换成了自定义函数maxValue
    for j in range(1,target+1):
        dp[0][j]=None
    for i in range(1,n+1):
        for j in range(target+1):
            dp[i][j]=dp[i-1][j]
            if j>=cost[i-1]:
                dp[i][j]=maxValue(dp[i-1][j],dp[i][j-cost[i-1]],str(i))
    if dp[-1][-1] is None:
        return "0"
    return dp[-1][-1]

布尔值

139. 单词拆分

给定一个非空字符串 s 和一个包含非空单词的列表wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：

• 拆分时可以重复使用字典中的单词。
• 你可以假设字典中没有重复的单词。

示例 1：

输入: s = “leetcode”, wordDict = [“leet”, “code”]
输出: true
解释: 返回 true 因为 “leetcode” 可以被拆分成 “leet code”。

示例 2：

输入: s = “applepenapple”, wordDict = [“apple”, “pen”]
输出: true
解释: 返回 true 因为 “applepenapple” 可以被拆分成 “apple pen apple”。注意你可以重复使用字典中的单词。

示例 3：

输入: s = “catsandog”, wordDict = [“cats”, “dog”, “sand”, “and”, “cat”]
输出: false

问题转换：完全背包恰好装满，是否存在解决方案，单词用过之后可以再用，所以这里应该采用排列的策略。

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

def wordBreak(self, s: str, wordDict) -> bool:
    n=len(wordDict)+1
    dp=[[False]*(len(s)+1) for _ in range(n)]
    dp[0][0]=True
    for j in range(len(s)+1):  #内外循环颠倒,按列遍历（单词可以不在乎顺序，和排列类似）
        for i in range(1,n):
            dp[i][j]=dp[i-1][j]
            if j>=len(wordDict[i-1]) and s[j-len(wordDict[i-1]):j]==wordDict[i-1]:
                #这里是-1，不是i-1。
                # dp[i][j]=or(dp[i-1][j],dp[-1][j-objs[i-1]])
                dp[i][j]|=dp[-1][j-len(wordDict[i-1])]
    return dp[-1][-1]

01背包

从n件物品中任选，每件物品只可取用一次

方案数

494. 目标和

给定一个非负整数数组，a1, a2, …, an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。
返回可以使最终数组和为目标数 S 的所有添加符号的方法数。

示例：

输入：nums: [1, 1, 1, 1, 1], S: 3
输出：5
解释：

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

一共有5种方法让最终目标和为3。

问题转换：从一堆物品中选出若干个，恰好能装满背包的方案数。

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

def findTargetSumWays(self, nums: List[int], t: int) -> int:
    s=sum(nums)
    if t>s:
        return 0
    t+=s
    if t%2!=0:
        return 0
    t=t//2     #获取目标值，转换为01背包问题
    n=len(nums)+1
    dp=[[0]*(t+1) for _ in range(n)]
    dp[0][0]=1
    for i in range(1,n):
        for j in range(t+1):
            dp[i][j]+=dp[i-1][j]
            if j>=nums[i-1]:
                # 和完全背包问题不同之处：这里是i-1。
                # dp[i][j]=sum(dp[i-1][j],dp[i-1][j-objs[i-1]])
                dp[i][j]+=dp[i-1][j-nums[i-1]]
    return dp[-1][-1]

最值

474. 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
请你找出并返回 strs 的最大子集的大小，该子集中 最多 有 m 个 0 和 n 个 1 。
如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

示例 1：

输入：strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {“10”,”0001”,”1”,”0”} ，因此答案是 4 。
其他满足题意但较小的子集包括 {“0001”,”1”} 和 {“10”,”1”,”0”} 。{“111001”} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

示例 2：

输入：strs = [“10”, “0”, “1”], m = 1, n = 1
输出：2
解释：最大的子集是 {“0”, “1”} ，所以答案是 2 。

问题转换：01背包恰好装满，最多可以装多少个物品。注意这里的物品体积可以看作是由0的个数和1的个数2个维度构成的，仍然是01背包问题，只不过将物品的1维变成了2维。

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

def findMaxForm(self, strs, m: int, n: int) -> int:
    nums = []
    for s in strs:
        num = [0,0]
        for c in s:
            if ord(c) - ord('0') == 0:
                num[0]+=1
            else:
                num[1]+=1
        nums.append(num)
    #转换成01背包问题
    l = len(nums) + 1
    dp = [[[0] * (n + 1) for _ in range(m + 1)] for _ in range(l)]
    for i in range(1,l):
        for a in range(m + 1):
            for b in range(n + 1):
                dp[i][a][b] = dp[i - 1][a][b]
                if a >= nums[i - 1][0] and b >= nums[i - 1][1]:
                    # dp[i][j]=max(dp[i-1][j],dp[i-1][j-objs[i-1]])
                    dp[i][a][b] = max(dp[i][a][b],dp[i - 1][a - nums[i - 1][0]][b - nums[i - 1][1]] + 1)
    return dp[-1][-1][-1]

1049. 最后一块石头的重量 II

有一堆石头，用整数数组stones表示。其中stones[i]表示第i块石头的重量。
每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为x和y，且x <= y。那么粉碎的可能结果如下：
如果x == y，那么两块石头都会被完全粉碎；
如果x != y，那么重量为 x 的石头将会完全粉碎，而重量为y的石头新重量为y-x。
最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

示例 1：

输入：stones = [2,7,4,1,8,1]
输出：1
解释：
组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。

示例 2：

输入：stones = [31,26,33,21,40]
输出：5

问题转换：如果把石头分成两组，使两组的重量尽可能相同，那么最终剩下的重量就越小。所以尽可能使2组的石头重量倾向于总重量的一半，问题变成01背包问题：给定一些石头和一个指定容量的背包，最多可以装多少重量的石头（不能超过背包容量）。

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

def lastStoneWeightII(self, stones: List[int]) -> int:
    n=len(stones)+1
    s=sum(stones)
    t=s//2
    dp=[[0]*(t+1) for _ in range(n)]
    for i in range(1,n):
        for j in range(t+1):
            dp[i][j]=dp[i-1][j]
            if j>=stones[i-1]:
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-stones[i-1]]+stones[i-1])
    return s-2*dp[-1][-1]

布尔值

416. 分割等和子集

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例 1：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

示例 2：

输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。

问题转换：从nums选n个数字能否凑齐s//2。

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

def canPartition(self, nums: List[int]) -> bool:
    s=sum(nums)
    if s%2!=0:
        return False
    if max(nums)*2>s:
        return False
    s=s//2   #转换成01背包问题
    n=len(nums)+1
    dp=[[False]*(s+1) for _ in range(n)]
    dp[0][0]=True
    for i in range(1,n):
        for j in range(s+1):
            dp[i][j]=dp[i-1][j]
            if j>=nums[i-1]:
                # dp[i][j]=or(dp[i-1][j],dp[i-1][j-objs[i-1]])
                dp[i][j]|=dp[i-1][j-nums[i-1]]
    return dp[-1][-1]

多重背包

从n种物品中任选，每种物品可选数量有范围

方案数

3333. 找到初始输入字符串 II

有一个数组arr，比如[2,1,3,2]，其中arr[i]表示某一个物品的数量，从arr中最多选m个物品，也可以一个都不选，求总共的方案数

1
2
3
4
5
6
7
8
9
10
11

def count_ways(arr, m):
    n = len(arr)
    dp = [[0] * (m + 1) for _ in range(n + 1)]
    dp[0][0] = 1  # 选0个的方案数为1
    for i in range(1, n + 1):
        count = arr[i - 1]
        for j in range(m + 1): # 内层j表示当前总共选了多少个
            # k表示当前物品从0选到count个，上层dp范围为[j-count,j]
            for k in range(min(count, j) + 1):
                dp[i][j] += dp[i - 1][j - k]
    return sum(dp[-1]) # 选0~m个的方案数总和

时间优化，将dp转换成前缀和

1
2
3
4
5
6
7
8
9
10
11

def count_ways(self, arr, m):
    n = len(arr)
    preSum = [[0] * (m + 2) for _ in range(n + 1)]
    preSum[0] = [0] + [1] * (m + 1)  # 选0个的方案数为1
    for i in range(1, n + 1):
        count = arr[i - 1]
        for j in range(m + 1):  # 内层j表示当前总共选了多少个
            # k表示当前物品从0选到count个，上层dp范围为[j-count,j]
            dp = preSum[i - 1][j + 1] - preSum[i - 1][max(0, j - count)]
            preSum[i][j + 1] = preSum[i][j] + dp
    return preSum[-1][-1]  # 选0~m个的方案数总和

使用一维dp

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

def count_ways(arr, m):
    n = len(arr)
    dp = [0] * (m + 1)
    dp[0] = 1  # 选0个的方案数为1
    for i in range(n):
        count = arr[i]
        new_dp = dp[:]
        for j in range(m + 1): # 内层j表示当前总共选了多少个
            # 当前物品从1选到count个，不包含0，因为一个都不选直接从dp[j]转移过来，new_dp[j]一开始就包含了不选当前物品的情况
            for k in range(1, min(count, j) + 1):
                new_dp[j] += dp[j - k]
        dp = new_dp
    return sum(dp)  # 选0~m个的方案数总和

一维dp使用前缀和优化，减少一个内层循环

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

def count_ways(arr, m):
    dp = [0] * (m + 1)
    dp[0] = 1  # 选0个的方案数为1
    for count in arr:
        preSum = [0] * (len(dp) + 1)
        for i in range(1, len(preSum)):
            preSum[i] = preSum[i - 1] + dp[i - 1]
        new_dp = dp[:]
        for j in range(m + 1):  # 内层j表示当前总共选了多少个
            # 当前物品从1选到count个，不包含0，因为一个都不选直接从dp[j]转移过来，new_dp[j]一开始就包含了不选当前物品的情况
            # 当前物品的可选范围[1,count],则dp的范围是[i-count,i-1]
            # 注意左端点可能小于0，当物品可选最大数量count大于总数量i，left,right=max(0,j-count),j-1
            # 则dp[left,right]之和等于preSum[right+1]-preSum[left]
            new_dp[j] += preSum[j] - preSum[max(0, j - count)]
        dp = new_dp
    return sum(dp)  # 选0~m个的方案数总和

在微服务架构中，服务间的通信是核心环节。Spring Cloud Feign 作为一种声明式的 HTTP 客户端，极大地简化了服务调用的复杂性。然而，在实际开发中，我们常常会遇到需要为特定的 FeignClient 定制特殊配置的场景，例如处理特定的数据格式（如 LocalDateTime 的序列化）、设置特定的超时时间或添加特定的拦截器。本文将结合具体的代码示例，深入探讨如何为一个或多个特殊的 FeignClient 指定独立的配置，并解决可能遇到的配置隔离问题。

问题背景：默认配置的局限性

Spring Cloud Feign 默认会使用全局配置，包括默认的 Encoder 和 Decoder（通常是基于 Jackson）。但在某些情况下，默认配置可能无法满足需求：

1. 日期时间格式处理：后端服务可能要求特定的日期时间格式（如 "yyyy-MM-dd HH:mm:ss"），而默认的 Jackson 配置可能将 LocalDateTime 序列化为时间戳数组，导致服务调用失败或数据解析错误。
2. 特殊序列化/反序列化逻辑：某些接口可能返回非标准 JSON 结构或需要特殊的处理逻辑。
3. 不同服务的差异化需求：不同的下游服务可能对超时时间、重试策略有不同的要求。

这时，我们就需要为特定的 FeignClient 提供定制化的配置。

关键点一：使用 configuration 属性指定独立配置

@FeignClient 注解提供了一个 configuration 属性，允许我们为该客户端指定一个独立的配置类。这个配置类通常包含自定义的 Encoder, Decoder, Logger, Contract, Retryer, RequestInterceptor 等 Bean。

下面是一个示例，ISpecialFacadeService 这个 FeignClient 需要特殊的 JSON 处理（特别是针对 LocalDateTime），因此我们为其指定了 SpecialFeignConfig 作为配置类：

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

// 定义 Feign 客户端接口
@ResponseBody
@FeignClient(value = "myweb", configuration = ISpecialFacadeService.SpecialFeignConfig.class)
public interface ISpecialFacadeService {

    // 接口方法定义
    @RequestMapping("/getStatus")
    DataResult<Response> getStatus(@RequestParam("id") String id);


    /**
     * 专门为 ISpecialFacadeService 定制的 Feign 配置类
     * 注意：此类通常定义为内部类或单独的文件，避免被全局扫描到
     */
    @Configuration(proxyBeanMethods = false) // 优化配置类，不代理Bean方法
    class SpecialFeignConfig {

        /**
         * 自定义 JSON 解码器 (Decoder)
         * @return Decoder Bean
         */
        @Bean
        public Decoder specificFeignDecoder() {
            ObjectMapper objectMapper = new ObjectMapper();
            // 注册 Java 8 时间模块，支持 LocalDateTime 等类型的序列化/反序列化
            objectMapper.registerModule(new JavaTimeModule());
            // 配置 Jackson 不将日期序列化为时间戳
            objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
            // 可以在这里添加更多自定义配置...
            // objectMapper.enable(SerializationFeature.FAIL_ON_EMPTY_BEANS); // 根据需要启用或禁用
            return new JacksonDecoder(objectMapper);
        }

        /**
         * 自定义 JSON 编码器 (Encoder)
         * @return Encoder Bean
         */
        @Bean
        public Encoder specificFeignEncoder() {
            ObjectMapper objectMapper = new ObjectMapper();
            // 同样需要注册 Java 8 时间模块并配置日期格式
            objectMapper.registerModule(new JavaTimeModule());
            objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
            // 可以在这里添加更多自定义配置...
            return new JacksonEncoder(objectMapper);
        }
    }
}

代码解析：

1. @FeignClient(value = "myweb", configuration = ISpecialFacadeService.SpecialFeignConfig.class)：明确告诉 Spring Cloud Feign，ISpecialFacadeService 这个客户端要使用 SpecialFeignConfig 类中定义的 Bean 来覆盖默认配置。
2. SpecialFeignConfig：这是一个标准的 Spring @Configuration类。
   • proxyBeanMethods = false：这是一个优化选项，适用于配置类，表示不需要 CGLIB 代理。
   • specificFeignDecoder() 和 specificFeignEncoder()：这两个 @Bean 方法分别创建了自定义的 Decoder 和 Encoder。
   • ObjectMapper 配置：我们在 ObjectMapper 中注册了 JavaTimeModule 并禁用了 WRITE_DATES_AS_TIMESTAMPS。这是处理 java.time.LocalDateTime 等 JSR-310 日期时间类型的关键，使其能够正确地序列化为字符串（如 "2023-10-27 10:00:00"）而不是数字时间戳。

关键点二：避免特殊配置污染全局环境

将配置类 SpecialFeignConfig 定义为 ISpecialFacadeService 的内部类或放在单独的、不被主 @ComponentScan 扫描到的包下，是一种常见的避免配置污染的方式。

然而，如果配置类没有定义为内部类，并且不小心被 Spring Boot 的组件扫描（@ComponentScan）扫描到了，那么这个配置类中的 Bean（比如自定义的 Decoder 和 Encoder）可能会意外地成为全局默认配置，影响到所有其他的 FeignClient。

为了确保这个特殊配置只应用于指定的 FeignClient，我们需要在主应用程序或配置类上使用 @ComponentScan 的 excludeFilters 属性，将这个特殊的配置类排除在全局扫描之外。

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

@SpringBootApplication // 通常包含了 @ComponentScan
@ComponentScan(
    excludeFilters = {
        // 通过 ASSIGNABLE_TYPE 类型精确排除指定的配置类
        @ComponentScan.Filter(
            type = FilterType.ASSIGNABLE_TYPE,
            classes = {ISpecialFacadeService.SpecialFeignConfig.class}
        )
        // 可以添加其他需要排除的类或规则
    }
)
// 启用 Feign 客户端，并指定扫描 Feign 接口的基础包
@EnableFeignClients(basePackages = {"xxx.xxx.xx"})
public class StdSpApplication extends SpringBootServletInitializer {
    // ... main method etc.
}

代码解析：

• @ComponentScan(excludeFilters = ...)：我们在这里添加了一个过滤器。
• @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {ISpecialFacadeService.SpecialFeignConfig.class})：这个过滤器指定了类型为 ASSIGNABLE_TYPE，这意味着任何是 ISpecialFacadeService.SpecialFeignConfig 类型或其子类型的类，在组件扫描时都将被忽略。这样就保证了 SpecialFeignConfig 不会被注册为全局 Bean，只在被 ISpecialFacadeService 通过 configuration 属性引用时才生效。

LocalDateTime 处理的另一种方式：@JsonFormat

值得一提的是，如果仅仅是为了控制 LocalDateTime 字段的序列化/反序列化格式，也可以直接在 DTO 的字段上使用 @JsonFormat 注解：

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

import com.fasterxml.jackson.annotation.JsonFormat;
import java.time.LocalDateTime;

public class Response {
    private String status;

    // 直接在字段上指定格式
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime handleTime;

    // getters and setters
}

这种方式更简单直接，适用于只需要格式化特定字段的场景。但如果需要更复杂的 Jackson 定制（比如启用/禁用某些特性、注册多个模块等），或者希望对某个 FeignClient 的所有接口调用统一应用这种格式，那么通过 configuration 提供自定义的 ObjectMapper 是更优、更集中的做法。

实际上，也可以去掉配置类SpecialFeignConfig的@Configuration注解

为什么移除 @Configuration 可以解决问题？

• 当 SpecialFeignConfig 类上没有 @Configuration 注解时，Spring 的常规组件扫描会忽略这个类，它不会被注册为 Spring 应用上下文中的一个标准配置类。
• 然而，Spring Cloud OpenFeign 在处理 @FeignClient 的 configuration 属性时，仍然会读取这个指定的类（即使它没有 @Configuration 注解），并查找其中的 @Bean 方法。
• Feign 会在为 ISpecialFacadeService 创建的专用子上下文中，实例化并注册这些 @Bean 方法定义的 Bean。
• 这样，这些 Bean 就只存在于 ISpecialFacadeService 的特定上下文中，不会影响到父上下文，也不会被其他 Feign 客户端共享。

关键点三：contextId 彻底隔离

在实践中，我们可能会遇到一个更棘手的问题：假设你有两个或多个 FeignClient 接口，它们都指向同一个服务名（即 @FeignClient 的 value 或 name 属性相同），其中一个指定了特殊的 configuration，而另一个没有。

1
2
3
4
5
6
7

// 特殊配置的 Client
@FeignClient(name = "myweb", configuration = ISpecialFacadeService.SpecialFeignConfig.class)
public interface ISpecialFacadeService { ... }

// 使用默认配置（期望）的 Client，但指向同一个服务
@FeignClient(name = "myweb")
public interface IOtherFacadeService { ... } // 调用 "myweb" 服务的其他接口

在这种情况下，即使你使用了 excludeFilters，Spring Cloud OpenFeign 在默认情况下可能会为这两个指向相同 name 的客户端创建同一个 Spring ApplicationContext。这意味着，IOtherFacadeService 仍然可能会意外地使用为 ISpecialFacadeService 定制的 SpecialFeignConfig 配置！这显然不是我们想要的。

为了实现真正的隔离，确保每个 FeignClient（即使它们指向同一个服务）都有自己独立的上下文和配置，我们需要使用 @FeignClient 的 contextId 属性。contextId 为每个 FeignClient 提供了一个唯一的标识符，强制 Spring Cloud 为其创建独立的 ApplicationContext。

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

// Client 1: 使用特殊配置，并指定唯一的 contextId
@FeignClient(value = "myweb", configuration = SpecialFeignConfig.class, contextId = "specialClientContext")
public interface ISpecialFacadeService {
    // ... methods
}

// Client 2: 指向同一个服务，不指定 configuration（使用默认或全局配置），
// 但必须指定一个不同的 contextId 以确保隔离
@FeignClient(value = "myweb", contextId = "otherClientContext")
public interface IOtherFacadeService {
    // ... methods
}

代码解析：

• 通过为每个指向 "myweb" 服务的 FeignClient 设置不同的 contextId（如 "specialClientContext", "otherClientContext"），我们强制 Spring Cloud OpenFeign 为它们创建了隔离的上下文环境。
• 现在，ISpecialFacadeService 会使用其指定的 SpecialFeignConfig。
• IOtherFacadeService则会使用 Feign 的默认配置或全局自定义配置（如果存在的话），而不会受到 SpecialFeignConfig 的影响。

何时必须使用 contextId？

当你有多个 @FeignClient 接口指向同一个 name（服务名），并且其中至少有一个需要与其他客户端不同的特定配置时，强烈建议为所有指向该服务的客户端都显式指定唯一的 contextId，以保证配置的隔离性。

总结

为 Spring Cloud Feign 中的特定客户端定制配置是微服务开发中的常见需求。本文介绍了三种关键技术：

1. @FeignClient(configuration = ...)：为特定 FeignClient 指定独立的配置类，常用于定制 Encoder, Decoder (如处理 LocalDateTime) 等。
2. @ComponentScan(excludeFilters = ...)：防止特殊配置类被全局扫描，避免污染其他 FeignClient。
3. @FeignClient(contextId = ...)：当多个 FeignClient 指向同一服务名时，使用 contextId 提供唯一标识，确保每个客户端拥有独立的上下文和配置，实现真正的隔离。

掌握这些技巧，可以让你更灵活、更精确地控制 FeignClient 的行为，更好地应对复杂的微服务通信场景。

基础用法

最基本的 curl 命令可以直接用来发送 HTTP 请求。例如：

1

curl https://example.com

上述命令会向 https://example.com 发送一个 GET 请求，并输出返回的内容。

常用参数解析

1. -X 指定请求方法

默认情况下，curl 使用 GET 方法发送请求。如果需要指定其他方法（如 POST、PUT、DELETE 等），可以使用 -X 参数。例如：

1

curl -X POST https://example.com/api

2. -d 发送请求数据

在发送 POST 或 PUT 请求时，通常需要附带数据。-d 参数可以用来指定请求体中的数据。例如：

1
2
3

curl -X POST https://example.com/api \
     -d '{"name": "John", "age": 30}' \
     -H "Content-Type: application/json"

3. -H 设置请求头

通过 -H 参数可以自定义请求头。例如，设置 Authorization 头以传递认证信息：

1
2

curl https://example.com/api \
     -H "Authorization: Bearer YOUR_TOKEN"

4. -o 保存响应内容到文件

如果希望将服务器的响应保存到本地文件中，可以使用 -o 参数。例如：

1

curl https://example.com/file.zip -o file.zip

5. -L 自动跳转

当服务器返回重定向响应（如 301 或 302）时，curl 默认不会自动跳转。使用 -L 参数可以让 curl 自动跟随重定向：

1

curl -L https://example.com

6. -I 获取响应头

如果只需要获取响应头信息，而不需要响应体，可以使用 -I 参数：

1

curl -I https://example.com

7. -u 基本认证

对于需要基本认证的资源，可以使用 -u 参数提供用户名和密码：

1

curl -u username:password https://example.com

8. --data-urlencode 编码数据

当需要对请求数据进行 URL 编码时，可以使用 --data-urlencode 参数：

1
2
3

curl -X POST https://example.com/api \
     --data-urlencode "name=John Doe" \
     --data-urlencode "age=30"

9. -v 显示详细信息

使用 -v 参数可以查看请求和响应的详细信息，包括请求头、响应头和状态码：

1

curl -v https://example.com

10. -w 自定义输出信息

-w 参数允许你指定在请求完成后输出的特定信息。你可以在输出中使用占位符（如 %{http_code}、%{time_total}）来定制输出格式。这个参数非常适用于调试和性能监控。

例如，查看 HTTP 状态码和请求总时间：

1

curl -w "HTTP状态码: %{http_code}\n总耗时: %{time_total}秒\n" https://example.com

该命令将输出类似以下的内容：

1
2

HTTP状态码: 200
总耗时: 0.123秒

常用的占位符包括：

• %{http_code}: 返回的 HTTP 状态码
• %{time_total}: 完成请求的总时间（秒）
• %{time_namelookup}: DNS 查询时间
• %{time_connect}: 建立连接的时间
• %{time_starttransfer}: 从发送请求到开始接收到第一个字节的时间

更多占位符的详细列表，可以参考 curl 的官方文档。

高级用法

1. 文件上传

可以通过 -F 参数模拟表单上传文件：

1
2

curl -X POST https://example.com/upload \
     -F "file=@/path/to/local/file.txt"

2. 下载多个文件

结合通配符可以一次性下载多个文件：

1

curl -O https://example.com/files/[1-5].jpg

3. 使用代理

如果需要通过代理服务器访问目标地址，可以使用 -x 参数：

1

curl -x http://proxy.example.com:8080 https://example.com

总结

curl 是一个功能强大的工具，适用于各种网络请求场景。通过合理使用其参数，可以轻松完成复杂的任务。无论是调试 API 还是自动化脚本，curl 都是一个不可或缺的利器。

如果你对某些参数的具体用法还有疑问，可以通过 curl --help 查看更多选项说明，或者参考官方文档进一步学习。

从某一天开始，我们突然发现AI可以帮忙生成文字、图片、音频、视频等等内容了，而且让人难以分清背后的创作者到底是人类还是AI。

这些AI生成的内容被叫做AIGC，它是AI Generated Content即“AI生成内容”的简写。像ChatGPT生成的文章，Github Copilot生成的代码，Midjourney生成的图片等等都属于AIGC。

而当AIGC这个词在国内火爆的同时，海外更流行的是另外一个词 —— Generative AI，即生成式AI。从字面上来看，生成式AI和AIGC之间的关系很好理解，生成式AI所生成的内容就是AIGC。所以ChatGPT，Github Copilot，Midjourney等都属于生成式AI。由此可见，AIGC和生成式AI的概念都是很简单直白的。

但因为AIGC这个词在国内比生成式AI更加流行。很多语境下，AIGC也被用于指代生成式AI。那么生成式AI和AI、机器学习、监督学习、无监督学习、强化学习、深度学习、大语言模型等等词汇之间又是什么关系呢？有没有一种剪不断理还乱的感觉，这个很难一言以蔽之，但通过一张图就可以直观理解他们之间的关系了。

AI

AI也叫人工智能，是计算机科学下的一个学科，旨在让计算机系统去模拟人类的智能，从而解决问题和完成任务。

早在1956年AI就被确立为了一个学科领域。在此后数十年间，经历过多轮低谷与繁荣。

我们认为，学习的每个方面或智能的任何其他特性原则上都可以被如此精确地描述，以至于可以制造一台机器来模拟它。我们将尝试找出如何使机器使用语言、形成抽象和概念、解决现在仅保留给人类的问题，并提高自己。我们认为，如果一个精心挑选的科学家团队在夏天一起工作，那么这一个或多个问题上都可以取得重大进展。

——《达特茅斯人工智能夏季研究项目提案》(McCarthy等，1955年)

机器学习

机器学习是AI的一个子集。它的核心在于不需要人类做显示编程，而是让计算机通过算法，自行学习和改进去识别模式，做出预测和决策。

比如，如果我们通过代码告诉电脑，图片里有红色说明是玫瑰，图片里有橙色说明是向日葵，那程序对花种类的判断，就是通过人类直接明确编写逻辑达成的，不属于机器学习，机器什么也没学。

但如果我们给电脑大量玫瑰和向日葵的图片，让电脑自行识别模式总结规律，从而能对没见过的图片进行预测和判断，这种就是机器学习。

机器学习领域下有多个分支，包括监督学习、无监督学习、强化学习。

监督学习

在监督学习里，机器学习算法会接受有标签的训练数据。标签就是期望的输出值，所以每个训练数据点都既包括输入特征，也包括期望的输出值。

算法的目标是学习输入和输出之间的映射关系，从而在给定新的输入特征后，能够准确预测出相应的输出值。

经典的监督学习任务，包括分类，也就是把数据划分为不同的类别；以及回归，也就是对数值进行预测。

比如拿一堆猫猫狗狗的照片和照片，对应的猫狗标签进行训练，然后让模型根据没见过的照片，预测是猫还是狗，这就属于分类。

拿一些房子特征的数据，比如面积卧室数是否带阳台等和相应的房价作为标签进行训练，然后让模型根据没见过的房子的特征预测房价，这就属于回归。

无监督学习

无监督学习和监督学习不同的是，它学习的数据是没有标签的。所以算法的任务是自主发现数据里的模式或规律。

经典的无监督学习任务，包括聚类，也就是把数据进行分组。比如拿一堆新闻文章，让模型根据主题或内容的特征，自动把相似文章进行组织。

强化学习

强化学习，则是让模型在环境里采取行动，获得结果反馈，从反馈里学习，从而能在给定情况下采取最佳行动来最大化奖励或是最小化损失。

所以就跟训小狗似的。刚开始的时候，小狗会随心所欲，做出很多动作。但随着和训犬师的互动，小狗会发现，某些动作能够获得零食，某些动作没有零食，某些动作甚至会遭受惩罚。通过观察动作和奖惩之间的联系。小狗的行为会逐渐接近训犬师的期望。

强化学习可以应用在很多任务上，比如说让模型下围棋，获得不同行动导致的奖励或损失反馈，从而在一局局游戏里优化策略学习如何采取行动达到高分。

深度学习

那么问题来了，深度学习属于这三类里的哪一类呢？它不属于里面的任何一类。深度学习是机器学习的一个方法。核心在于使用人工神经网络，模仿人脑处理信息的方式，通过层次化的方法提取和表示数据的特征。

神经网络是由许多基本的计算和储存单元组成，这些单元被称为神经元。这些神经元通过层层连接来处理数据，并且深度学习模型，通常有很多层，因此称为深度。

比如要让计算机识别小猫的照片，在深度学习中，数据首先被传递到一个输入层，就像人类的眼睛看到图片一样。然后数据通过多个隐藏层，每一层都会对数据进行一些复杂的数学运算，来帮助计算机理解图片中的特征，例如小猫的耳朵眼睛等等。

最后，计算机会输出一个答案，表明这是否是一张小猫的图片。

神经网络可以用于监督学习，无监督学习，强化学习。所以，深度学习不属于他们的子集。

生成式AI

生成式AI是深度学习的一种应用。它利用神经网络来识别现有内容的模式和结构，学习生成新的内容。内容形式可以是文本、图片、音频等等。

大语言模型

大语言模型也叫LLM，Large Language Model，也是深度学习的一种应用，专门用于进行自然语言处理任务。

大语言模型里面的大字说明模型的参数量非常大，可能有数十亿甚至到万亿个，而且训练过程中也需要海量文本数据集，所以能更好的理解自然语言以及生成高质量的文本。

大语言模型的例子有非常多，比如国外的GPT、LLaMA，国内的ERNIE、ChatGLM等，可以进行文本的理解和生成。以GPT-3这个模型为例子，它会根据输入提示以及前面生成过的词，通过概率计算逐步生成下一个词或Token来输出文本序列。

但不是所有的生成式AI都是大语言模型，而所有的大语言模型是否都是生成式AI这也存在些许争议。

前半句很好理解，生成图像的扩散模型就不是大语言模型，它并不输出文本。同时，有些人认为不是所有大语言模型都是生成式AI。这是因为有些大语言模型，由于其架构特点不适合进行文本生成。

谷歌的BERT模型就是一个例子，它的参数量和训练数据很大，属于大语言模型。应用方面，BERT理解上下文的能力很强。因此，被谷歌用在搜索上，用来提高搜索排名和信息摘要的准确性，它也被用于情感分析、文本分类等任务。但同时，BERT的不擅长文本生成，特别是连贯的长文本生成。所以有些人认为，此类模型不属于生成式AI的范畴。

这些概念共同构成了生成式AI的核心要素，希望能帮助你对时下热门的AIGC建立更多了解。

4张牌打乱从中间剪开并叠放得到8张牌，牌的顺序无关紧要，但剪开后的牌上下叠放，则2张相同的牌相互之间一定相隔4张，不妨假设这8张牌的排列顺序为ABCDABCD。

名字

无论名字有几个字，即将几张牌放到底部（最末端）得到的依然是个循环序列。比如名字2个字得到CDABCDAB，名字3个字得到DABCDABC。

可以将这8张牌排成一个圆环，无论名字是几个字，也即无论从哪张牌作为圆环起点，始终都是在圆环中循环。

插入三张牌

观察即可发现，从这个环中任意位置取走连续的3张，则剩下的5张牌都会形成首尾相同的一个序列：

将取走的3张牌插入到序列的中间位置（注意不能插到最底部），则一定能得到一个由8张牌构成的并且首尾相同的序列AxxxxxxA。

隐藏第一张牌

根据规则，将第1张牌隐藏起来，后续经过一系列摆放和丢弃操作，最终目的都是为了将最末尾的牌留下来，而这张牌正好和隐藏的牌相同，可拼在一起，实现了魔术效果。

由于最后结果只和序列最后一张牌有关，其他牌都需要丢弃，此时序列为长度为7的xxxxxxA，x表示其他牌，A表示隐藏牌。

南北方

取出序列开头任意的1张2张或3张牌并插入中间，此时并没有改变序列最末尾的牌，而序列中其他牌的位置是对结果没有任何影响的，所以该操作可有可无，刘谦可能只是为了增加神秘感或者让观众更有参与感才加入该步骤。尼格买提可能正是在该步骤将牌插入了末尾，改变了序列中最末尾的牌才导致结果错误。此时序列仍然可看作是xxxxxxA。

性别

男生丢弃最开头1张牌，形成长度为6的序列xxxxxA；女生丢弃最开头的2张牌，形成长度为5的序列xxxxA。

咒语

“见证奇迹的时刻”共7个字，则需要将序列最开头的牌移到最末尾共执行7次。男生的牌有6张，6次为一个闭环（6次后序列相当于未发生任何改变），则相当于执行7-6=1次；同理，女生的牌有5张，则5次为一个闭环，相对于执行7-5=2次。男女生的最终序列分别为xxxxAx和xxAxx。

好运留下来，烦恼丢出去

将序列第1张牌插入末尾，并丢弃第2张，将第3张牌插入末尾，并丢弃第4张，以此类推，直到剩下最后一张。这很容易让人想到一个通用问题，假如有n张牌排成一个圆环，并且从1到n按顺序排列，如果一直按上述规则操作，那么最后剩下那张牌的编号是几呢？

其实这个问题早就有人研究过了，它还有一个经典名字叫做约瑟夫环。答案就是，如果这个n恰好可以表示为2的多少次方，比如16正好是2的4次方，8正好是2的3次方，那么最终留下牌的一定是编号1。

观察可发现，如果n正好是2的x次幂（$ n=2^x $），那么第一轮会正好丢弃掉 $ 2^{x-1} $张牌，同时第二轮依然会从编号1开始计数，然后丢弃掉 $ 2^{x-2} $ 张牌……，每一轮都会从编号1开始，直到最后丢弃 $ 2^0=1 $ 张牌只剩下编号1。

换个角度，如果一个数n正好是2的整数次方，那么这个数用二进制表示，它的数位中只会有一个1，比如16的二进制为1000，8的二进制位100，它们都只有最高位的一个1。

对于任意数n来说，我们都可以表示为 $ n=2^x+a $ 。我们可以考虑先丢弃掉a张牌，则剩下的 $ 2^x $ 张牌中，第1张牌一定是最终留下的那张，因为如果对剩下的牌重新从1开始编号，这张牌就是编号1。对于要丢弃掉a张牌，由于是留1去1，则需要数到编号2a，才能正好丢弃a张，所以编号2a+1则是剩下 $ 2^x $ 张牌中的第1张。

比如对于n=7，$ 7=2^2+3 $，a=3，丢弃3张牌好正好剩下 $ 2^2=4 $ 张牌，则走到编号6时正好剩下4张牌，而对于这剩下的4张牌重新编号，则编号7成为了编号1。所以n=7时，答案为7，也就是 $ 2a+1=2*3+1=7 $。

也就是说对于任意数n，$ n=2^x+a $，只要算出a，那么就能计算出答案，为2a+1。

站在程序员的角度，a的值等于n去除二进制表示中最高位后的值，用代码实现约瑟夫环的这个问题为：

1
2
3
4
5
6
7

def JosephRing(n):
    for i in range(32):  # 假设n最大不超过32位
        j = 1 << (31 - i)
        if n & j:
            n = n ^ j    # 移除最高位的1
            break
    return n * 2 + 1

回到魔术中，男生的序列为xxxxAx，长度为6，相当于n=6，计算结果为5，而A对应的编号正好是5；同理女生的序列为xxAxx，长度为5，n=5计算结果为3，A对应的编号正好是3，所以最终一定是A这张牌保留到最后。

以上，就是整个魔术的秘密。

在现代多核CPU架构下，并发编程已成为提升应用程序性能的关键技术。Java的java.util.concurrent(JUC)包提供了丰富的工具类来帮助开发者更安全、更高效地处理并发问题。本文将深入探讨JUC中几个常用的锁和同步器：ReentrantReadWriteLock、StampedLock、Semaphore、CountDownLatch和CyclicBarrier，理解它们的设计理念、使用场景及注意事项。

ReentrantReadWriteLock：读写分离锁

ReentrantReadWriteLock是一种读写分离锁，它允许多个线程同时读取共享资源，但在写入时则需要独占访问。这在“读多写少”的场景下能显著提高性能，因为它避免了不必要的阻塞。

核心特性：

1. 读锁与写锁互斥：当一个线程持有写锁时，其他线程（无论是读线程还是写线程）都必须等待。当一个线程持有读锁时，写线程必须等待。
2. 写锁与写锁互斥：同一时间只允许一个线程持有写锁。
3. 读锁与读锁不互斥：多个线程可以同时持有读锁，并发读取。

锁升级与降级：

• 锁升级（不支持）：持有读锁的线程尝试获取写锁，会导致死锁或永久等待。这是因为获取写锁需要等待所有读锁释放，而当前线程持有的读锁永远无法释放（因为它在等待写锁）。
• 锁降级（支持）：持有写锁的线程可以继续获取读锁，然后释放写锁。这样就从写锁降级为了读锁，允许其他读线程进入，但仍阻止其他写线程。

示例代码：

下面是一个简单的示例，演示了ReentrantReadWriteLock的基本用法。DataContainer类使用读写锁来保护共享数据data。

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

// 使用Slf4j或其他日志框架
// import lombok.extern.slf4j.Slf4j;
// @Slf4j(topic = "c.TestReadWriteLock")
public class TestReadWriteLock {
    private static final Logger log = LoggerFactory.getLogger(TestReadWriteLock.class);

    public static void main(String[] args) throws InterruptedException {
        DataContainer dataContainer = new DataContainer();

        // 启动两个读线程
        new Thread(() -> {
            dataContainer.read();
        }, "t1-Reader").start();

        new Thread(() -> {
            dataContainer.read();
        }, "t2-Reader").start();

        // 稍等片刻，启动一个写线程
        TimeUnit.MILLISECONDS.sleep(100);
        new Thread(() -> {
            dataContainer.write("New Data");
        }, "t3-Writer").start();

        // 再启动一个读线程，观察其是否被写锁阻塞
         TimeUnit.MILLISECONDS.sleep(100);
         new Thread(() -> {
            dataContainer.read();
        }, "t4-Reader").start();
    }

    // 模拟休眠，简化代码
    public static void sleep(double seconds) {
        try {
            TimeUnit.MILLISECONDS.sleep((long) (seconds * 1000));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

// 使用Slf4j或其他日志框架
// import lombok.extern.slf4j.Slf4j;
// @Slf4j(topic = "c.DataContainer")
class DataContainer {
    private static final Logger log = LoggerFactory.getLogger(DataContainer.class);
    private Object data = "Initial Data";
    // 1. 创建读写锁对象
    private final ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
    // 2. 获取读锁和写锁实例
    private final ReentrantReadWriteLock.ReadLock r = rw.readLock();
    private final ReentrantReadWriteLock.WriteLock w = rw.writeLock();

    public Object read() {
        log.debug("尝试获取读锁...");
        r.lock(); // 3. 加读锁
        try {
            log.debug("成功获取读锁，开始读取...");
            sleep(1); // 模拟读取耗时
            log.debug("读取完成, data: {}", data);
            return data;
        } finally {
            log.debug("准备释放读锁...");
            r.unlock(); // 4. 释放读锁
        }
    }

    public void write(Object newData) {
        log.debug("尝试获取写锁...");
        w.lock(); // 3. 加写锁
        try {
            log.debug("成功获取写锁，开始写入...");
            this.data = newData;
            sleep(1); // 模拟写入耗时
            log.debug("写入完成, data: {}", data);
        } finally {
            log.debug("准备释放写锁...");
            w.unlock(); // 4. 释放写锁
        }
    }

    // 模拟休眠
    private static void sleep(double seconds) {
        try {
            TimeUnit.MILLISECONDS.sleep((long) (seconds * 1000));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

运行结果分析：

你会观察到 t1-Reader 和 t2-Reader 可以并发执行读取操作。当 t3-Writer 尝试获取写锁时，它会等待 t1 和 t2 释放读锁。一旦 t3 持有写锁，后续的 t4-Reader 会被阻塞，直到 t3 释放写锁。

StampedLock：带版本戳的乐观读写锁

StampedLock 是 JDK 8 引入的一种更高级的锁，它在ReentrantReadWriteLock的基础上进行了优化，特别是在读操作远多于写操作的场景下。StampedLock 提供了乐观读（Optimistic Reading）的模式。

核心概念：

• 戳（Stamp）：每次获取锁（读锁、写锁或乐观读）都会返回一个非零的版本戳。释放锁或转换锁状态时需要传入相应的戳。

• 乐观读 (tryOptimisticRead)：尝试获取一个非独占的读锁，但实际上不加锁，只是获取当前的版本戳。之后，线程可以读取共享资源。读取完成后，需要调用validate(stamp)方法检查在读取期间是否有写操作介入（即版本戳是否发生变化）。

• 如果validate返回true，表示没有写操作干扰，读取的数据有效，性能极高（无锁操作）。

  • 如果validate返回false，表示有写操作干扰，数据可能已失效，此时需要升级为悲观读锁（调用readLock()）重新读取数据。

• 悲观读锁 (readLock)：类似ReentrantReadWriteLock的读锁，会阻塞写操作，但不阻塞其他读操作。

• 写锁 (writeLock)：类似ReentrantReadWriteLock的写锁，独占访问。

优点：

• 在读多写少且写操作时间短的场景下，乐观读能大幅减少锁竞争，提升吞吐量。

缺点：

• StampedLock是不可重入的。如果一个线程已经持有写锁，再尝试获取写锁会导致死锁；持有读锁再尝试获取读锁也可能产生问题。
• 不支持条件变量（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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.StampedLock;

// 使用Slf4j或其他日志框架
// import lombok.extern.slf4j.Slf4j;
// @Slf4j(topic = "c.TestStampedLock")
public class TestStampedLock {
    private static final Logger log = LoggerFactory.getLogger(TestStampedLock.class);

    public static void main(String[] args) {
        DataContainerStamped dataContainer = new DataContainerStamped(1);

        // 线程t1进行一次快速读取（乐观读成功）
        new Thread(() -> {
            dataContainer.read(1); // 模拟读取时间1秒
        }, "t1-optimistic-success").start();

        sleep(0.1); // 确保t1开始

        // 线程t-writer进行写操作
        new Thread(() -> {
            log.debug("Writer thread starting write operation...");
            dataContainer.write(99);
        }, "t-writer").start();

        sleep(0.5); // 确保写操作有机会介入

        // 线程t2进行一次较慢的读取（乐观读失败，升级为读锁）
        new Thread(() -> {
            dataContainer.read(2); // 模拟读取时间2秒，期间writer会修改数据
        }, "t2-optimistic-fail").start();
    }

     // 模拟休眠，简化代码
    public static void sleep(double seconds) {
        try {
            TimeUnit.MILLISECONDS.sleep((long) (seconds * 1000));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

// 使用Slf4j或其他日志框架
// import lombok.extern.slf4j.Slf4j;
// @Slf4j(topic = "c.DataContainerStamped")
class DataContainerStamped {
    private static final Logger log = LoggerFactory.getLogger(DataContainerStamped.class);
    private int data;
    private final StampedLock lock = new StampedLock();

    public DataContainerStamped(int data) {
        this.data = data;
    }

    public int read(int readTime) {
        long stamp = lock.tryOptimisticRead(); // 1. 尝试乐观读，获取戳
        log.debug("Optimistic read attempt, stamp: {}", stamp);
        sleep(readTime); // 模拟读取操作耗时

        // 2. 校验戳，检查读取期间是否有写操作介入
        if (lock.validate(stamp)) {
            log.debug("Optimistic read validation successful (stamp: {}), data: {}", stamp, data);
            return data; // 校验成功，数据有效
        }

        // 3. 乐观读失败，升级为悲观读锁
        log.debug("Optimistic read validation failed (stamp: {}), upgrading to read lock...", stamp);
        try {
            stamp = lock.readLock(); // 获取悲观读锁，阻塞写操作
            log.debug("Acquired read lock, stamp: {}", stamp);
            sleep(readTime); // 模拟重新读取耗时
            log.debug("Read finished under read lock (stamp: {}), data: {}", stamp, data);
            return data; // 返回在读锁保护下读取的数据
        } finally {
            log.debug("Releasing read lock, stamp: {}", stamp);
            lock.unlockRead(stamp); // 4. 释放悲观读锁
        }
    }

    public void write(int newData) {
        long stamp = lock.writeLock(); // 1. 获取写锁，阻塞所有读写
        log.debug("Acquired write lock, stamp: {}", stamp);
        try {
            log.debug("Writing data...");
            sleep(2); // 模拟写入耗时
            this.data = newData;
            log.debug("Write finished, new data: {}", data);
        } finally {
            log.debug("Releasing write lock, stamp: {}", stamp);
            lock.unlockWrite(stamp); // 2. 释放写锁
        }
    }

     // 模拟休眠
    private static void sleep(double seconds) {
        try {
            TimeUnit.MILLISECONDS.sleep((long) (seconds * 1000));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

运行结果分析：

• t1-optimistic-success 线程尝试乐观读，由于读取期间没有写操作，validate成功，快速返回。
• t-writer 获取写锁并修改数据。
• t2-optimistic-fail 线程尝试乐观读，但在其读取期间（sleep(2)），t-writer 修改了数据，导致validate失败。随后 t2 升级为悲观读锁，等待 t-writer 释放写锁后，再重新获取数据。

Semaphore：信号量

Semaphore（信号量）用于控制同时访问特定资源的线程数量。它维护了一个许可（permit）集，线程必须先获得许可才能访问资源，使用完毕后释放许可。如果许可数量为0，则尝试获取许可的线程将被阻塞，直到有其他线程释放许可。

常用场景：

• 限流：控制对某个服务的并发调用量。
• 资源池：管理有限的资源，如数据库连接池。

核心方法：

• Semaphore(int permits)：构造函数，初始化许可数量。
• acquire()：获取一个许可，如果无可用许可则阻塞。
• acquire(int permits)：获取指定数量的许可。
• release()：释放一个许可。
• release(int permits)：释放指定数量的许可。
• tryAcquire()：尝试获取一个许可，立即返回成功或失败，不阻塞。

示例代码：

下面的示例模拟了10个线程尝试访问一个只有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
36
37
38
39
40
41
42
43
44
45

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

// 使用Slf4j或其他日志框架
// import lombok.extern.slf4j.Slf4j;
// @Slf4j(topic = "c.TestSemaphore")
public class TestSemaphore {
    private static final Logger log = LoggerFactory.getLogger(TestSemaphore.class);

    public static void main(String[] args) {
        // 1. 创建 Semaphore 对象，设置许可数量为 3
        Semaphore semaphore = new Semaphore(3);

        // 2. 创建 10 个线程尝试获取许可并执行任务
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    // 3. 尝试获取许可，获取不到则阻塞
                    semaphore.acquire();
                    log.debug(" acquired permit, running...");
                    sleep(1); // 模拟执行任务
                    log.debug(" task finished, releasing permit...");
                } catch (InterruptedException e) {
                    log.error("Thread interrupted", e);
                    Thread.currentThread().interrupt();
                } finally {
                    // 4. 释放许可
                    semaphore.release();
                }
            }, "Thread-" + i).start();
        }
    }

    // 模拟休眠，简化代码
    public static void sleep(double seconds) {
        try {
            TimeUnit.MILLISECONDS.sleep((long) (seconds * 1000));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

运行结果分析：

同一时间内，最多只有3个线程能够获得许可并打印 “running…”。其他线程会阻塞在 acquire() 方法上，直到有线程调用 release() 释放许可。

CountDownLatch：倒计时门闩

CountDownLatch 是一种同步辅助类，它允许一个或多个线程等待其他一组线程完成操作。它像一个倒计时器，主线程（或任何需要等待的线程）调用 await() 方法阻塞，直到计数器减到零。其他线程则通过调用 countDown() 方法来使计数器减一。

核心特性：

• 一次性：计数器的值只能被初始化一次，并且一旦减到零，就不能再重置或增加。
• 等待机制：await() 方法阻塞调用线程，直到计数器为零。
• 计数递减：countDown() 方法将计数器减一。

常用场景：

• 等待多个初始化任务完成：主线程等待所有初始化子线程完成后再继续执行。
• 模拟并发：确保多个线程同时开始执行某个任务。

示例代码：

下面的示例模拟了一个游戏加载场景，主线程需要等待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
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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class TestCountDownLatch {
    private static final Logger log = LoggerFactory.getLogger(TestCountDownLatch.class);

    public static void main(String[] args) throws InterruptedException {
        testLoadingGame();
    }

    private static void testLoadingGame() throws InterruptedException {
        AtomicInteger threadCounter = new AtomicInteger(0);
        ExecutorService service = Executors.newFixedThreadPool(10, (r) -> {
            // 自定义线程名
            return new Thread(r, "loader-" + threadCounter.getAndIncrement());
        });

        // 1. 初始化 CountDownLatch，计数为 10
        CountDownLatch latch = new CountDownLatch(10);
        String[] loadingProgress = new String[10]; // 用于显示加载进度
        Arrays.fill(loadingProgress, "0%"); // 初始化进度

        Random random = new Random();
        log.info("Starting game loading process...");

        // 2. 提交 10 个加载任务到线程池
        for (int j = 0; j < 10; j++) {
            int taskIndex = j; // lambda 中需要 final 或 effectively final 变量
            service.submit(() -> {
                try {
                    log.debug("{} starting loading...", Thread.currentThread().getName());
                    // 模拟加载过程
                    for (int i = 0; i <= 100; i++) {
                        try {
                            TimeUnit.MILLISECONDS.sleep(random.nextInt(50)); // 随机加载耗时
                        } catch (InterruptedException e) {
                             Thread.currentThread().interrupt();
                        }
                        // 更新进度（注意：这里的更新方式不是线程安全的，仅为演示）
                        // 在实际应用中，更新共享状态需要同步或使用并发集合
                        synchronized (loadingProgress) {
                             loadingProgress[taskIndex] = Thread.currentThread().getName() + "(" + i + "%)";
                             // 打印进度条（\r 实现原地更新）
                             System.out.print("\rLoading progress: " + Arrays.toString(loadingProgress));
                        }
                    }
                    log.debug("{} finished loading.", Thread.currentThread().getName());
                } finally {
                    // 3. 任务完成，计数器减一
                    latch.countDown();
                }
            });
        }

        // 4. 主线程调用 await() 等待所有加载任务完成（计数器归零）
        log.info("Main thread waiting for all loading tasks to complete...");
        latch.await(); // 阻塞直到 latch 计数为 0

        System.out.println(); // 换行
        log.info("All loading tasks completed. Game starting...");
        service.shutdown(); // 关闭线程池
    }
}

运行结果分析：

主线程会打印 “Main thread waiting…” 并阻塞在 latch.await()。同时，10个加载线程并发执行，每个线程完成加载后调用 latch.countDown()。当第10个线程完成并调用 countDown() 后，计数器变为0，await() 方法返回，主线程继续执行，打印 “Game starting…”。

CyclicBarrier：循环栅栏

CyclicBarrier（循环栅栏）与CountDownLatch类似，也是用于线程协作，但它更像一个可重用的屏障。它允许一组线程相互等待，直到所有线程都到达某个公共屏障点（barrier point），然后所有线程再同时继续执行。

核心特性：

• 计数等待：构造时指定参与的线程数（parties）。线程调用 await() 方法到达屏障，并阻塞等待，直到指定数量的线程都调用了await()。
• 屏障动作（可选）：可以在构造时提供一个 Runnable 任务，当所有线程都到达屏障后，在任何线程被释放之前，会由最后一个到达屏障的线程执行这个任务。
• 可重用：当所有等待线程被释放后，CyclicBarrier 可以被重置（自动或手动），用于下一轮的同步。这就像“人满发车”，发车后可以等待下一批人。

常用场景：

• 多线程计算：将一个大任务分解给多个线程，等待所有线程计算完成中间结果后，再进行汇总或下一步计算。
• 并行测试：确保所有测试线程都准备好后再开始执行测试。

CyclicBarrier vs CountDownLatch：

• CountDownLatch 是一次性的，计数减到0后不能重置；CyclicBarrier 是可重用的。
• CountDownLatch 主要用于一个或多个线程等待其他线程完成某事；CyclicBarrier 用于一组线程相互等待，直到所有成员都到达某个点。

示例代码：

下面的示例模拟了两个任务（task1, task2）需要协同工作，每一轮都需要双方都完成后才能进入下一轮。

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.*;

// 使用Slf4j或其他日志框架
// import lombok.extern.slf4j.Slf4j;
// @Slf4j(topic = "c.TestCyclicBarrier")
public class TestCyclicBarrier {
     private static final Logger log = LoggerFactory.getLogger(TestCyclicBarrier.class);

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);

        // 1. 创建 CyclicBarrier，指定参与者数量为 2，并提供一个屏障动作
        CyclicBarrier barrier = new CyclicBarrier(2, () -> {
            // 这个 Runnable 会在两个线程都到达屏障后，由最后一个到达的线程执行
            log.info("--- Both task1 and task2 reached the barrier. Barrier action executed. Proceeding to next round... ---");
        });

        // 模拟执行 3 轮任务
        for (int i = 0; i < 3; i++) {
            log.info("Starting round {}", i + 1);
            // 提交 task1
            service.submit(() -> {
                try {
                    log.debug("task1 starting work for round...");
                    sleep(1); // 模拟 task1 工作耗时
                    log.debug("task1 finished work, waiting at barrier...");
                    // 2. task1 到达屏障，等待 task2
                    barrier.await(); // 如果是第一个到达，会阻塞；如果是第二个到达，会唤醒等待的线程，并触发屏障动作
                    log.debug("task1 passed barrier.");
                } catch (InterruptedException | BrokenBarrierException e) {
                     log.error("Task1 interrupted or barrier broken", e);
                     Thread.currentThread().interrupt();
                }
            });

            // 提交 task2
            service.submit(() -> {
                try {
                    log.debug("task2 starting work for round...");
                    sleep(2); // 模拟 task2 工作耗时 (比 task1 长)
                    log.debug("task2 finished work, waiting at barrier...");
                    // 2. task2 到达屏障，等待 task1
                    barrier.await();
                    log.debug("task2 passed barrier.");
                } catch (InterruptedException | BrokenBarrierException e) {
                    log.error("Task2 interrupted or barrier broken", e);
                    Thread.currentThread().interrupt();
                }
            });

            // 等待一轮结束，为了清晰观察日志
             sleep(3);
        }

        service.shutdown();
    }

    // 模拟休眠，简化代码
    public static void sleep(double seconds) {
        try {
            TimeUnit.MILLISECONDS.sleep((long) (seconds * 1000));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

运行结果分析：

在每一轮中，task1 先完成工作并调用 await() 等待。task2 稍后完成工作并调用 await()。当 task2 调用 await() 时，满足了屏障所需的2个线程数，此时：

1. 屏障动作（打印 “— Both task1 and task2 reached…”）被执行。
2. task1 和 task2 都从 await() 调用中返回，继续执行后续代码（打印 “passed barrier.”）。
3. CyclicBarrier 自动重置，可以开始下一轮的等待。 这个过程会重复3次。

总结

Java并发包（JUC）提供了强大的工具来应对并发编程的挑战。

• ReentrantReadWriteLock：适用于读多写少的场景，通过读写分离提高性能。注意锁升级不支持，锁降级支持。
• StampedLock：JDK 8 引入的优化读写锁，提供乐观读模式，在特定场景下性能优于ReentrantReadWriteLock，但不可重入且使用更复杂。
• Semaphore：控制对有限资源的并发访问数量，常用于限流和资源池管理。
• CountDownLatch：一次性的同步工具，用于等待一组操作完成。
• CyclicBarrier：可重用的同步工具，用于让一组线程在某个点相互等待，达到同步执行的效果。

理解这些工具的特性和适用场景，是编写高效、健壮的并发程序的关键。根据具体的业务需求选择合适的并发工具，能够有效提升系统性能和可靠性。

之前在讨论二叉搜索树的时候，已经介绍过一种可高度平衡的二叉搜索树，即AVL平衡二叉树。现在我们将介绍另一种鼎鼎有名的平衡二叉树-红黑树，它因节点存储红或黑两种颜色之一而命名。相较于AVL树，它是一种弱平衡二叉树，不需要像AVL树那样严格要求平衡，这也导致它的查询效率并没有AVL树那么高，但相对的，它带来的好处是对于调整失衡，红黑树的旋转次数更少，所以频繁的插入或删除操作，红黑树更有优势。

定义

引用自百度百科：

红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，它是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。

红黑树是一种平衡二叉查找树的变体，它的左右子树高差有可能大于 1，所以红黑树不是严格意义上的平衡二叉树（AVL），但对之进行平衡的代价较低， 其平均统计性能要强于 AVL 。

由于每一棵红黑树都是一颗二叉排序树，因此，在对红黑树进行查找时，可以采用运用于普通二叉排序树上的查找算法，在查找过程中不需要颜色信息。

2-3搜索树

在介绍红黑树之前，我们需要先了解一下什么是2-3搜索树。顾名思义，2-3搜索树也是一种搜索树，不过相较于一般的二叉搜索树，它的节点不仅可以存储1个键，还可以存储2个键，也就是说，它包含2种类型的节点：

• 2-节点：含有一个键和两条链接，左链接指向的节点的键都小于该节点的键，右链接指向的节点的键都大于该节点的键。这也就是传统二叉搜索树的节点。
• 3-节点：含有两个键和三条链接，左链接指向的节点的键都小于该节点的小键，右链接指向的节点的键都大于该节点的大键，中链接指向的节点的键都介于该节点两个键之间。

简单起见，我们这里提到的2-3查找树都是指完美平衡的2-3查找树，完美平衡表示树中所有的叶子节点到根节点的距离都是相同的。我们之后将介绍如何维持这种平衡，以下是一棵2-3查找树的例子：

查找

要判断一个键是否在树中，我们先将它和根结点中的键比较。如果它和其中任意一个相等，查找命中；否则我们就根据比较的结果找到指向相应区间的链接，并在其指向的子树中递归地继续查找。如果这是个空链接，查找未命中。

以下是2个例子，对于H的命中查找：

对于B的未命中查找：

插入

要在 2-3 树中插入一个新节点，我们可以和二叉查找树一样先进行一次未命中的查找，然后把新节点挂在树的底部。但这样的话就破坏了树的完美平衡性，我们需要继续维持这种平衡性。以下根据2种插入情况分别讨论。

插入在2-节点

如果未命中的查找结束于一个2-节点，事情就好办了，我们只要把这个2-节点替换为一个3-结点，将要插入的键保存在其中即可，比如在树中插入K：

• 对K的查找在2-节点结束

  

• 将2-节点替换为3-节点

  

插入在3-节点

如果未命中的查找结束于一个3-结点，则相对麻烦一些。我们会得到一个临时的4-节点，而4-节点在2-3树中并不被允许，我们需要将它进行分解。分解步骤为将4-节点分解为3个2-节点，然后将中键插入到它的父节点中。如果父节点是2-节点则转变为3-节点，然后停止；如果父节点是3-节点，则变成临时的4-节点，然后继续分解并向上转移，直至最终转移到根节点。根节点分解后，会使树的高度增加1，但仍然维持了树的完美平衡性。比如在树中插入Z：

• 对Z的查找在3-节点结束

  

• 将3-节点替换为临时的4-节点

  

• 4-节点分解为3个2-节点，中间节点上移至父节点

  

红黑树

理解了2-3树的原理，接下来，我们定义一种名为红黑树的数据结构，它使用标准的二叉搜索树（完全由2-节点构成的树）以及一些额外的信息（颜色，用于替换3-节点）来模拟2-3树的实现。

我们将树中的链接分为两种类型：

• 红链接：将两个2-节点连接起来构成一个3-节点；
• 黑链接：2-3树中的普通链接；

准确的说，我们将3-节点表示为一条左斜的红色链接相连的两个2-节点。根据我们的定义，这棵红黑树应该是一棵满足如下条件的二叉搜索树：

1. 红链接均为左链接；
2. 没有任何一个节点同时和两条红链接相连；
3. 该树是完美黑色平衡的，即任意空链接到根节点的路径上的黑链接数量相同。

如果将这棵红黑树的所有红链接画平，并将由红链接相连的节点看成一个整体，那么我们会发现，它和2-3树是一模一样的。

颜色表示

除了根节点外，每个节点都只会有一条指向自己的链接（由它的父节点指向它），我们将链接的颜色保存在节点中，同时我们规定指向空节点和根节点的链接颜色为黑色。我们定义如下的数据结构：

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

const bool RED = true;
const bool BLACK = false;
class Node
{
    public TKey key;
    public Node left, right;
    public bool color;
    public Node(TKey key)
    {
        this.key = key;
        color = RED;
    }
}

我们再封装一个私有方法，以确保可以获得任意节点（包含空节点）和它父节点的链接颜色：

1
2
3
4
5
6

private bool isRed(Node x)
{
    if (x == null)
        return false;
    return x.color == RED;
}

旋转

与AVL树类似，我们在执行完某些操作后，可能会出现红色右链接或者两条连续的红色左链接，这破坏了我们之前关于红黑树的约定，需要对其进行修复，其中最基本的操作就是旋转。

左旋转

其实现目标为将红色右链接转换为红色左链接。

1
2
3
4
5
6
7
8
9

private Node rotateLeft(Node h)
{
    Node x = h.right;
    h.right = x.left;
    x.left = h;
    x.color = h.color;
    h.color = RED;
    return x;
}

旋转之后，我们返回x作为新的根节点，同时x保留了原来根节点h的颜色。

右旋转

其实现目标为将红色左链接转换为红色右链接，该旋转目的主要是为了消除连续的红色左链接。

1
2
3
4
5
6
7
8
9

private Node rotateRight(Node h)
{
    Node x = h.left;
    h.left = x.right;
    x.right = h;
    x.color = h.color;
    h.color = RED;
    return x;
}

颜色转换

我们通过旋转会消除红色右链接或者两条连续的红色左链接的情况，但最终可能会出现一种情况，亦即某个节点同时拥有左右2个红色子节点。

我们定义一个flipColors方法来转换一个节点的两个红色子节点的颜色。除了将子结点的颜色由红变黑之外，同时还将父结点的颜色由黑变红。这项操作最重要的性质在于它和旋转操作一样是局部变换，不会影响整棵树的黑色平衡性。

1
2
3
4
5

private void flipColors(Node h)
{
    h.color = RED;
    h.left.color = h.right.color = BLACK;
}

这个操作相当于在2-3树中，我们将临时的4-节点分解为3个2-节点，同时让中间节点和父节点相结合，并一直向上转移。

注意：根节点始终是黑色，因为红色的根节点表示根节点是一个3-节点的一部分，这并不符合实际情况。所以如果我们对根节点进行了flipColors操作，需要将根节点设置为黑色（实际操作中，每次调整失衡我们都将根节点设置为了黑色）。对根节点进行flipColors操作，同时也意味着树的黑链接高度增加了1。

插入操作

我们使用二叉搜索树相同的方式往红黑树中插入节点，插入会发生在树的叶子节点上，可能是2-节点也可能是3-节点。我们统一使用红链接将新节点和它的父节点相连。

在2-节点中插入新键

1. 新键小于2-节点的键

   

   此情况无须做任何操作，插入完成后本身就是一个合法的3-节点。

2. 新键大于2-节点的键

   

   此情况需进行一次左旋转，将红色右链接转变成左链接，变成一个合法的3-节点。

在3-节点中插入新键

1. 新键大于3-节点的最大键

   

   此情况无须任何旋转操作。

2. 新键小于3-节点的最小键

   

   此情况出现了两条连续的红色左链接，需对节点C做右旋转。

3. 新键介于3-节点两个键之间

   

   此情况出现了红色左链接以及两条连续的红色左链接，需进行两次旋转。

此三种情况最终都会产生一个同时连接到两条红链接的节点，此时我们进行一次颜色转换操作即可完成修复。

调整失衡

针对以上情况总结，我们可以得到如下规律：

• 如果右子节点是红色的而左子节点是黑色，进行左旋转；
• 如果左子节点是红色的且它的左子节点也是红色的，进行右旋转；
• 如果左右子节点均为红色，进行颜色转换。

对于某个节点调整失衡的实现代码：

1
2
3
4
5
6
7
8
9
10
11

private Node balance(Node h)
{
    if (isRed(h.right) && !isRed(h.left))
        h = rotateLeft(h);
    if (isRed(h.left) && isRed(h.left.left))
        h = rotateRight(h);
    if (isRed(h.left) && isRed(h.right))
        flipColors(h);
    h.N = size(h.left) + size(h.right) + 1;
    return h;
}

最终我们实现的插入操作和普通二叉搜索树几乎一模一样，只是插入完成后，需要由叶子节点至底向上，一步步为查找路径上的节点调整平衡。

1
2
3
4
5
6
7
8
9
10
11

private Node put(Node h, TKey key)
{
    if (h == null)
        return new Node(key);
    int cmp = compare(key, h.key);
    if (cmp < 0)
        h.left = put(h.left, key);
    else if (cmp > 0)
        h.right = put(h.right, key);
    return balance(h);
}

删除操作

红黑树的删除操作较为复杂和难以理解，不过我们这里仍然以2-3树为例，首先明确在2-3树中应该如何操作后仍然保持平衡，再使用我们定义的红黑树来模拟这个过程。简单起见，我们先从删除最小键开始。

删除最小键

在二叉搜索树中，最小键就是树最左边的节点，所以如果某个节点的左节点为空，那么这个节点就是最小节点，在一般二叉搜索树中，我们只需要将这个节点的右节点赋值给它的父节点，即完成了最小节点的删除。但是在2-3树中，我们不能将节点留空，因为这样就失去了平衡。可以考虑这样一种情况，假如我们要删除的最小键是在一个3-节点中，这样一来当我们删除这个键的时候，3-节点就变成了2-节点，对于2-3树来说就依然是平衡的。

接下来，我们定义一个共用方法moveRedLeft，该方法进行一系列转换，确保最小键一定位于最底端的3-节点（或4-节点）中，以下是moveRedLeft方法进行的2种转换：

• 从兄弟节点借变成3-节点后删除

  

• 从父节点借变成4-节点后删除

  

对于deleteMin方法，我们自顶向下递归，当我们找到最小节点（最左边的节点）时，直接返回空即可，否则继续对子节点进行变换。该变换可能导致会出现4-节点，不过不用担心，因为最后我们会通过之前的调整失衡balance方法自底向上来消除这种情况。

1
2
3
4
5
6
7
8

private Node deleteMin(Node h)
{
    if (h.left == null)
        return null;
    h = moveRedLeft(h);
    h.left = deleteMin(h.left);
    return balance(h);
}

最后，我们以下面这棵红黑树为例，来理解moveRedLeft方法的实现

首先如果节点本身是3-节点，或者其左子节点是3-节点时，则无需任何处理，直接递归其左子节点即可，比如对该树根节点进行moveRedLeft操作会直接返回。

否则我们进行颜色变换，将父节点融合进来，变成4-节点：

如果节点的右子节点为2-节点，则还需要对其进行旋转操作：

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

private Node moveRedLeft(Node h)
{
    //当节点本身是2-节点，或者其左子节点是3-节点时，无需处理
    if (isRed(h.left) || isRed(h.left.left))
        return h;
    //颜色转换，相当于从父节点借
    h.color = BLACK;
    h.left.color = h.right.color = RED;
    //旋转，相当于从兄弟节点借
    if (isRed(h.right.left))
    {
        h.right = rotateRight(h.right);  //右子节点右旋
        h = rotateLeft(h);               //h节点左旋
    }
    return h;
}

处理完毕之后，我们便可毫无顾虑的删除最小键，最后再通过平衡操作，调整成一棵合法的红黑树。

注意到这里的转换颜色操作和之前介绍的flipColors方法恰好相反，我们可以将该方法抽离出来：如果是自底向上进行调整失衡，我们定义参数top为true；如果是自顶向下，融合父节点操作，则定义参数top为false。

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

private void flipColors(Node h, bool top)
{
    if (top)
    {
        h.color = RED;
        h.left.color = h.right.color = BLACK;
    }
    else
    {
        h.color = BLACK;
        h.left.color = h.right.color = RED;
    }
}

类似于插入叶子节点，当最终删除最小键后，也需要自底向上平衡到根节点，此时我们需要将根节点置为黑色。

1
2
3
4
5
6
7
8

public void deleteMin()
{
    if (root == null)
        return;
    root = deleteMin(root);
    if (root != null)
        root.color = BLACK;
}

通过以上的例子，可以观察到对于红黑树最小键的删除过程，实际体现在2-3树中的结果如下图所示：

删除任意键

现在我们考虑在红黑树中删除任意键的算法，在删除最小键的时候我们通过变换让最小键位于3-或4-节点中再进行删除，其中用到了moveRedLeft方法，该方法保证让右边的节点3-节点可以转移到左边到2-节点，现在当我们要删除的键可能位于右边的2-节点时，也需要考虑将左边的3-节点转移到右边的2-节点中，类似地，我们定义moveRedRight方法：

1
2
3
4
5
6
7

private Node moveRedRight(Node h)
{
    if (isRed(h.right) || isRed(h.right.left))
        return h;
    flipColors(h, false);
    return h;
}

相比较moveRedLeft而言，这里除了颜色转换没用到任何旋转，因为我们约定红连接都是左链接，根据我们的平衡算法，即使没有从左兄弟节点转移到右2-节点，最后调整平衡的时候也可以恢复正常的，比如删除一个2-节点H：

而如果要删除的键在左边的2-节点中，则无法直接恢复平衡，删之前需先旋转：

值得注意的是，因为红链接都是在左侧，所以一个3-节点中较大的那个键为父节点，假如要删除的是这个大键，那么必须先进行右旋转，让小键提升为父节点再进行删除，而如果要删除的是小键就没有必要了，因为它本身就是一个左子节点。

比如这里如果删除的键是H则需要右旋转，而如果是F则无需旋转：

最后，我们来剖析一下完整的删除算法，首先从根节点开始和删除键进行比较：

• 小于当前键，递归左子节点，类似于删除最小键的做法，递归前需先执行融合方法moveRedLeft：
  • 没有左子节点：已经不存在更小的键了，抛出异常；
  • 有左子节点：继续递归左子节点；
• 大于等于当前键，先判断是否需要进行右旋转（把大键旋转到右侧），然后分情况：
  • 没有右子节点：
    • 等于当前键：直接返回空；
    • 大于当前键：已经不存在更大的键了，抛出异常；
  • 有右子节点，先通过moveRedRight方法融合：
    • 等于当前键：将当前节点的键替换成右子树的最小键，同时删除右子树的最小键；
    • 大于当前键：继续递归右子节点

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

private Node delete(Node h, TKey key)
{
    if (h == null)
        throw new KeyNotFoundException("给定关键字不在字典中。");
    if (compare(key, h.key) < 0)
    {
        if (h.left == null)
            throw new KeyNotFoundException("给定关键字不在字典中。");
        h = moveRedLeft(h);
        h.left = delete(h.left, key);
    }
    else
    {
        if (isRed(h.left))
            h = rotateRight(h);
        if (h.right == null)
        {
            if (compare(key, h.key) == 0)
                return null;
            throw new KeyNotFoundException("给定关键字不在字典中。");
        }
        h = moveRedRight(h);
        if (compare(key, h.key) == 0)
        {
            var m = min(h.right);
            h.key = m.key;
            h.right = deleteMin(h.right);
        }
        else
            h.right = delete(h.right, key);
    }
    return balance(h);
}

下面我们以删除一棵红黑树的根节点为例，通过图片来演示算法是如何运作的：

完整代码

如果忽略这棵红黑树的颜色属性，那么它就是一棵普通的二叉搜索树，只不过它是高度平衡的，所以查询相关的代码和普通二叉搜索树完全一致。

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

public class RedBlackBST<TKey>
{
    const bool RED = true;
    const bool BLACK = false;
    class Node
    {
        public TKey key;
        public Node left, right;
        public bool color;
        public Node(TKey key)
        {
            this.key = key;
            color = RED;
        }
    }

    public RedBlackBST(IComparer<TKey> comparer)
    {
        compare = comparer.Compare;
    }

    private Node root;
    private Func<TKey, TKey, int> compare;

    private bool isRed(Node x)
    {
        if (x == null)
            return false;
        return x.color == RED;
    }

    private Node rotateLeft(Node h)
    {
        Node x = h.right;
        h.right = x.left;
        x.left = h;
        x.color = h.color;
        h.color = RED;
        return x;
    }

    private Node rotateRight(Node h)
    {
        Node x = h.left;
        h.left = x.right;
        x.right = h;
        x.color = h.color;
        h.color = RED;
        return x;
    }

    private void flipColors(Node h, bool top)
    {
        if (top)
        {
            h.color = RED;
            h.left.color = h.right.color = BLACK;
        }
        else
        {
            h.color = BLACK;
            h.left.color = h.right.color = RED;
        }
    }
    
    private Node balance(Node h)
    {
        if (isRed(h.right) && !isRed(h.left))
            h = rotateLeft(h);
        if (isRed(h.left) && isRed(h.left.left))
            h = rotateRight(h);
        if (isRed(h.left) && isRed(h.right))
            flipColors(h, true);
        return h;
    }
    
    public void put(TKey key)
    {
        root = put(root, key);
        root.color = BLACK;
    }
    
    private Node put(Node h, TKey key)
    {
        if (h == null)
            return new Node(key);
        int cmp = compare(key, h.key);
        if (cmp < 0)
            h.left = put(h.left, key);
        else if (cmp > 0)
            h.right = put(h.right, key);
        return balance(h);
    }
    
    private Node moveRedLeft(Node h)
    {
        if (isRed(h.left) || isRed(h.left.left))
            return h;
        flipColors(h, false);
        if (isRed(h.right.left))
        {
            h.right = rotateRight(h.right);
            h = rotateLeft(h);
        }
        return h;
    }

    private Node moveRedRight(Node h)
    {
        if (isRed(h.right) || isRed(h.right.left))
            return h;
        flipColors(h, false);
        return h;
    }

    public void deleteMin()
    {
        if (root == null)
            return;
        root = deleteMin(root);
        if (root != null)
            root.color = BLACK;
    }
    
    private Node deleteMin(Node h)
    {
        if (h.left == null)
            return null;
        h = moveRedLeft(h);
        h.left = deleteMin(h.left);
        return balance(h);
    }

    public void delete(TKey key)
    {
        root = delete(root, key);
        if (root != null)
            root.color = BLACK;
    }
    
    private Node delete(Node h, TKey key)
    {
        if (h == null)
            throw new KeyNotFoundException("给定关键字不在字典中。");
        if (compare(key, h.key) < 0)
        {
            if (h.left == null)
                throw new KeyNotFoundException("给定关键字不在字典中。");
            h = moveRedLeft(h);
            h.left = delete(h.left, key);
        }
        else
        {
            if (isRed(h.left))
                h = rotateRight(h);
            if (h.right == null)
            {
                if (compare(key, h.key) == 0)
                    return null;
                throw new KeyNotFoundException("给定关键字不在字典中。");
            }
            h = moveRedRight(h);
            if (compare(key, h.key) == 0)
            {
                var m = min(h.right);
                h.key = m.key;
                h.right = deleteMin(h.right);
            }
            else
                h.right = delete(h.right, key);
        }
        return balance(h);
    }      
    
    private Node min(Node x)
    {
        if (x.left == null)
            return x;
        return min(x.left);
    }
}

参考文献：《算法》第四版

在Python中，常用的用于写错误日志的库是logging。以下是一个简单的示例，演示如何在Python中使用logging库来记录错误日志：

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

import logging

# 创建日志记录器
logger = logging.getLogger('error_logger')
logger.setLevel(logging.ERROR)

# 创建一个文件处理器，将日志写入文件
file_handler = logging.FileHandler('error.log')
file_handler.setLevel(logging.ERROR)

# 创建一个控制台处理器，将日志输出到控制台
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.ERROR)

# 定义日志格式
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 将处理器添加到日志记录器
logger.addHandler(file_handler)
logger.addHandler(console_handler)

try:
    # 在这里写你的代码
    # 如果发生了错误
    raise Exception('这是一个错误示例')
except Exception as e:
    # 记录错误日志
    logger.error(str(e))

以上代码创建了一个名为error_logger的日志记录器，并将错误级别设置为logging.ERROR。然后，创建了一个文件处理器（FileHandler）和一个控制台处理器（StreamHandler），分别用于将日志写入文件和输出到控制台。最后，定义了日志的格式，并将处理器添加到日志记录器中。

在try块中的代码中，如果发生了错误，可以使用logger.error()方法将错误信息记录到日志文件和控制台中。

请注意，在使用logging库之前，需要先导入logging模块。

格式

logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')这句代码是用于定义日志的格式。

• %(asctime)s：表示日志记录的时间，即当前时间，以可读的形式显示（例如：”2022-09-30 10:30:15”）。
• %(levelname)s：表示日志的级别，如DEBUG、INFO、WARNING、ERROR、CRITICAL等。
• %(message)s：表示实际的日志消息。

这样的定义可以让日志以特定的格式显示，方便阅读和分析日志。在这个例子中，日志的格式为：时间 - 日志级别 - 日志消息。例如：2022-09-30 10:30:15 - ERROR - 这是一个错误示例。

还可以根据需要自定义日志的格式，使用不同的占位符来输出不同的信息，例如输出日志记录器的名称%(name)s、输出所在的模块%(module)s等等。更多的占位符和格式选项可以参考Python官方文档的Logging.Formatter部分。

分隔存储

如果所有错误日志都写入同一个文件，会导致文件越来越大。为了解决这个问题，可以使用logging库的RotatingFileHandler或TimedRotatingFileHandler来分隔文件存储。下面是示例代码：

1.使用RotatingFileHandler：

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

import logging
from logging.handlers import RotatingFileHandler

logger = logging.getLogger('error_logger')
logger.setLevel(logging.ERROR)

# 创建一个RotatingFileHandler，最多存储10个日志文件，每个文件最大为1MB
file_handler = RotatingFileHandler('error.log', maxBytes=1048576, backupCount=10)
file_handler.setLevel(logging.ERROR)

# 设置日志格式
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)

# 添加处理器到日志记录器
logger.addHandler(file_handler)

try:
    # 在这里写你的代码
    # 如果发生了错误
    raise Exception('这是一个错误示例')
except Exception as e:
    logger.error(str(e))

使用RotatingFileHandler时，可以通过maxBytes参数设置每个日志文件的最大大小，通过backupCount参数设置最多存储的日志文件数量。

2.使用TimedRotatingFileHandler：

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

import logging
from logging.handlers import TimedRotatingFileHandler

logger = logging.getLogger('error_logger')
logger.setLevel(logging.ERROR)

# 创建一个TimedRotatingFileHandler，每天生成一个日志文件
file_handler = TimedRotatingFileHandler('error.log', when='midnight', interval=1)
file_handler.setLevel(logging.ERROR)

# 设置日志格式
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)

# 添加处理器到日志记录器
logger.addHandler(file_handler)

try:
    # 在这里写你的代码
    # 如果发生了错误
    raise Exception('这是一个错误示例')
except Exception as e:
    logger.error(str(e))

使用TimedRotatingFileHandler时，可以通过when参数指定日志文件的轮转时间间隔（例如：midnight表示每天生成一个日志文件），通过interval参数指定轮转时间间隔的数量。

除了midnight，TimedRotatingFileHandler的when参数还支持以下几种有效的取值：

• S: 表示每秒生成一个日志文件。
• M: 表示每分钟生成一个日志文件。
• H: 表示每小时生成一个日志文件。
• D: 表示每天生成一个日志文件。
• W0 ~ W6: 表示每个星期的周一至周日分别生成一个日志文件。
• midnight: 表示每天的午夜（00:00）生成一个日志文件。

这些取值可以根据需要灵活选择，以满足不同的日志轮转需求。例如，如果需要每小时生成一个日志文件，可以将when参数设置为'H'；如果需要每周生成一个日志文件，可以将when参数设置为'W0' ~ 'W6'，其中W0表示周一，W1表示周二，依此类推。

注意，这些取值均为大小写敏感。另外，TimedRotatingFileHandler还支持interval参数，用于指定轮转时间间隔的数量。例如，interval=2表示每2个时间单位生成一个日志文件（如每2小时、每2天等）。

更多关于TimedRotatingFileHandler的详细信息，可以查看Python官方文档的Logging.handlers.TimedRotatingFileHandler部分。

拉取镜像：docker pull jenkinsci/blueocean:latest

创建主目录：mkdir -p /data/jenkins

运行容器：

1
2
3
4
5
6
7

docker run -d -u root \
-p 8080:8080 \
-p 50000:50000 \
-v /data/jenkins:/var/jenkins_home \
-v /etc/localtime:/etc/localtime \
-v /var/run/docker.sock:/var/run/docker.sock \
--name jenkins jenkinsci/blueocean:latest

访问页面

浏览器访问http://ip:8080进入Jenkins管理界面
初始密码查询：cat /data/jenkins/secrets/initialAdminPassword
默认账号名：admin

插件安装

如果在页面安装插件失败，也可进入jenkins容器内部用命令安装，比如安装git插件：

1

jenkins-plugin-cli --plugins git

修改插件镜像源

Jenkins在安装插件时，默认使用官方地址下载，有时可能速度太慢导致安装失败，可换成国内镜像地址：

vim /data/jenkins/hudson.model.UpdateCenter.xml

修改改成清华大学镜像地址：

https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

部署mvn程序

安装插件Docker 和 Docker Pipeline

设置maven镜像仓库，创建一个文件/data/jenkins/settings.xml，里面指定镜像路径：

1
2
3
4
5
6
7
8

 <mirrors>
 <mirror>  
     <id>alimaven</id>  
     <name>aliyun maven</name>  
     <url>http://maven.aliyun.com/nexus/content/groups/public/</url>  
     <mirrorOf>central</mirrorOf>          
</mirror>
 </mirrors>

新建流水线项目，由于这是使用的maven是容器，把配置文件映射进去，表示从阿里云获取maven依赖，这样拉取依赖会快很多；mvn容器默认使用的jdk11，有时候为了使用低版本的java，还需要把java环境变量配置进去：

1
2
3
4
5
6
7
8

pipeline {
    agent {
        docker {
                    image 'maven:latest'
                    args '-v /root/.m2:/root/.m2 -v /data/jenkins/settings.xml:/usr/share/maven/conf/settings.xml -v /home/xtwh/jdk1.8.0_271:/usr/local/jdk1.8.0_271 -e JAVA_HOME=/usr/local/jdk1.8.0_271' 
              }
    }
}

配置ssh拉取git代码

1. 在Jenkins服务器上创建公私钥对ssh-keygen；

2. jenkins中添加私钥：Dashboard -> 凭据 -> 系统 -> 全局凭据，添加凭据SSH Username with private key得到唯一凭据id；

3. 在git服务器中添加公钥；

4. 在流水线项目中添加唯一凭据id：

   1 2 3 4 5 6 7 8 9 10 11

   pipeline { agent any stages { stage('Git Clone') { steps { git credentialsId: 'xxx-xxx-xxx', url: 'ssh://git@xxx.xxx.xxx/gitlab-instance-xxx/xxx.git' } } // ... } }

报错一

You’re using ‘Known hosts file’ strategy to verify ssh host keys, but your known_hosts file does not exist, please go to ‘Manage Jenkins’ -> ‘Configure Global Security’ -> ‘Git Host Key Verification Configuration’ and configure host key verification.

方式一：

在容器中手动创建文件/root/.ssh/known_hosts

方式二：
修改配置系统管理 -> 全局安全配置

报错二

Couldn’t find any revision to build. Verify the repository and branch configuration for this job.

Jenkins调用git时用了默认的master分支，而gitlab这边使用的是main分支，指定分支名：

1
2
3
4
5

stage('Git Clone') {
    steps {
        git branch: 'main', credentialsId: 'xxx-xxx-xxx', url: 'ssh://git@xxx.xxx.xxx/gitlab-instance-xxx/xxx.git'
    }
}

发布

需要安装Publish Over SSH插件

系统管理 -> 系统配置中找到Publish over SSH选项，添加服务器，主要配置如下：

• SSH Server Name: ssh配置名称（自定义）记住这个名称，pipeline代码中要用到
• Hostname: 主机IP
• Username: ssh账户名
• Password: ssh密码
• Remote Directory: 远程路径，可以理解为ssh连接上后自动cd到目录

完整部署脚本：

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

def remoteId = 'xxx.xxx.xxx.xxx'  // 远程服务器配置名

pipeline {
    agent {
        docker {
                    image 'maven:latest'
                    args '-v /root/.m2:/root/.m2 -v /data/jenkins/settings.xml:/usr/share/maven/conf/settings.xml -v /home/xtwh/jdk1.8.0_271:/usr/local/jdk1.8.0_271 -e JAVA_HOME=/usr/local/jdk1.8.0_271' 
              }
    }
    stages {
        stage('Checkout') { 
            steps {
                git branch: 'main', credentialsId: 'xxx-xxx-xxx', url: 'ssh://git@xxx.xxx.xxx/gitlab-instance-xxx/xxx.git'
            }
        }   
        stage('Build') {
            steps {
                sh 'mvn -B -DskipTests clean package'
            }
        } 
        stage('Zip'){
            steps{
            // 将生成的Dockerfile，deploy.sh 和jar包整成压缩包发往远程服务器
                sh """
                cd ./your-soa-test/target
rm -rf target.tar.gz
tar -zcvf target.tar.gz lib/* resources/* your-soa-test-0.0.1-SNAPSHOT-boot.jar
                """
            }
        }
        stage('Publish'){
            steps {
            // 必须装了Publish over SSH插件才能写这个
                sshPublisher(publishers: [sshPublisherDesc(configName: """$remoteId""", transfers: [sshTransfer(cleanRemote: false, excludes: '',
                        execCommand: """
                        supervisorctl status > 1.txt   // 这里的1.txt在/root目录，即默认工作目录~
                        """,
                        execTimeout: 120000,
                        flatten: false,
                        makeEmptyDirs: false,
                        noDefaultExcludes: false,
                        patternSeparator: '[, ]+',
                        remoteDirectory: '/test',         // 这里是相对路径（相对于远程服务器的Remote Directory目录/usr/local/jars）
                        remoteDirectorySDF: false,  
                        removePrefix: 'your-soa-test/target',
                        sourceFiles: 'your-soa-test/target/target.tar.gz')],   // 这里是相对路径(相对于Jenkins的工作目录/var/jenkins_home/workspace/project_name)
                        usePromotionTimestamp: false,
                        useWorkspaceInPromotion: false,
                        verbose: true)])
                echo "发布成功"
            }
        }
    }
}

触发（基于推送gitlab）

Jenkins操作

安装插件gitlab

项目的构建触发器，勾选gitlab选项

设置Secret token，最后保存配置

Gitlab操作

项目 -> 设置 -> Webhooks，创建一个Webhook，主要配置如下3项

• Jenkins触发url地址
• token值
• 触发条件：推送

报错

Urlis blocked: Requests to the local network are not allowed

在gitlab的admin -> Settings -> Network的Outbound requests选项中，勾选Allow requests to the local network from webhooks and integrations：