2023蓝桥杯广东省赛个人题解

仅供参考，不保证思路和代码的正确性。

试题 A: 日期统计

暴力，忘记判重，白给

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

#include<bits/stdc++.h>
using namespace std;

int a[101] = { 5,6,8,6,9,1,6,1,2,4,9,1,9,8,2,3,6,4,7,7,5,9,5,0,3,8,7,5,8,1,5,8,6,1,8,3,0,3,7,9,2,7,0,5,8,8,5,7,0,9,9,1,9,4,4,6,8,6,3,3,8,5,1,6,3,4,6,7,0,7,8,2,7,6,8,9,5,6,5,6,1,4,0,1,0,0,9,4,8,0,9,1,2,8,5,0,2,5,3,3 };
long long ans = 0;
int b[20];
int c[20] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
void dfs(int x, int pos) {
if (pos == 1 && a[x] != 2) return;
if (pos == 2 && a[x] != 0) return;
if (pos == 3 && a[x] != 2) return;
if (pos == 4 && a[x] != 3) return;
b[pos] = a[x];
if (pos != 8) {
for (int i = x + 1; i < 100; i++) {
dfs(i, pos + 1);
}
}
else {

int m = b[5] * 10 + b[6];
int d = b[7] * 10 + b[8];

if (m < 1 || m > 12) return;
if (d < 1 || d > c[m]) return;

cout << b[1] << b[2] << b[3] << b[4] << "-" << b[5] << b[6] << "-" << b[7] << b[8] << endl;


ans++;

}
}
int main() {

for (int i = 0; i < 100; i++) {
dfs(i, 1);
}

cout << ans << endl;

return 0;
}

试题 B: 01 串的熵

暴力，记得处理四舍五入，11027421

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

#include<bits/stdc++.h>
using namespace std;

int a = 23333333;

int main() {


int mid = a / 2;

for (int i = mid; i >= 0; i--) {
double x = -1.0 * i / a * log2(1.0 * i / a);
double y = -1.0 * (a - i) / a * log2(1.0 * (a - i) / a);
long long ans = (x * i + y * (a - i)) * 100000;

if (ans % 10 >= 5) ans = ans / 10 + 1;
else ans = ans / 10;

if (ans == 116259075798) cout << i << endl;
}


return 0;
}

试题 C: 冶炼金属

思维，注意处理边界情况

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

#include<bits/stdc++.h>
using namespace std;

int n;

int main() {
ios::sync_with_stdio(0);

cin >> n;

int maxx = -1;
int minn = 1e9 + 7;

int a, b;
cin >> a >> b;


if (a == b) {
maxx = 1;
minn = 1;
}
else {
minn = a / (b + 1) + 1;
maxx = a / b;
}

for (int i = 2; i <= n; i++) {
cin >> a >> b;
if (a == b) {
maxx = 1;
minn = 1;
}
else {
minn = max(minn, a / (b + 1) + 1);
maxx = min(maxx, a / b);
}
}

cout << minn << " " << maxx << endl;

return 0;
}

试题 D: 飞机降落

全排列处理，复杂度为10! * 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

#include<bits/stdc++.h>
using namespace std;

int n;

int a[12];
int t[12], d[12], l[12];
int main() {
ios::sync_with_stdio(0);

int T;
cin >> T;
while (T--) {
cin >> n;
for (int i = 1; i <= n; i++) a[i] = i;

for (int i = 1; i <= n; i++) {
cin >> t[i] >> d[i] >> l[i];
}

int flag = 0;

do {

int now = 0;

for (int i = 1; i <= n; i++) {
if (d[a[i]] + t[a[i]] < now) break;

if (t[a[i]] > now) {
now = t[a[i]] + l[a[i]];
}
else {
now = now + l[a[i]];
}

if (i == n) flag = 1;
}
if (flag) break;

} while (next_permutation(a + 1, a + 1 + n));


if (flag) cout << "YES";
else cout << "NO";

if (T != 0) cout << endl;
}

return 0;
}

试题 E: 接龙数列

简单动态规划

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

#include<bits/stdc++.h>
using namespace std;

int n;

int a[100010];
int dp[100010];
int h[100010];
int last[11];
int maxi[11];


int main() {
ios::sync_with_stdio(0);

cin >> n;

for (int i = 1; i <= n; i++) {
cin >> a[i];
int k = a[i];
while (k) {
if (k < 10) h[i] = k;
k /= 10;
}

}

for (int i = 0; i <= 9; i++) {
last[i] = 0;
maxi[i] = 0;
}

for (int i = 1; i <= n; i++) {
dp[i] = maxi[h[i]] + 1;
maxi[a[i] % 10] = max(maxi[a[i] % 10], dp[i]);
last[a[i] % 10] = i;
}

int ans = n;
for (int i = 0; i <= 9; i++) {
ans = min(ans, n - maxi[i]);
}

cout << ans;

return 0;
}

试题 F: 岛屿个数

首先bfs每个点，判断是否能通过0到达岛外，可以斜着走，无法到达就说明是子岛屿，记得剪枝。第二次bfs判断连通块个数，即为答案。

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

#include<bits/stdc++.h>
using namespace std;

int n, m;
int a[60][60];
int flag;
int xi[8] = { 1, 0, -1, 0, 1, -1, 1, -1};
int yi[8] = { 0, 1, 0, -1, -1, 1, 1, -1};
int ans;
int ch[60][60];

int check(int x, int y) {
if (x < 1 || x > n || y < 1 || y > m) return 0;
return 1;
}

void init_bfs(int x, int y) {

queue<pair<int, int>>q;
q.push(make_pair(x, y));
int c[60][60];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
c[i][j] = 0;
}
}
c[x][y] = 1;

while (!q.empty()) {
auto p = q.front();
q.pop();
for (int i = 0; i < 8; i++) {
int xn = p.first + xi[i];
int yn = p.second + yi[i];
if (check(xn, yn)) {
if (c[xn][yn])continue;
c[xn][yn] = 1;

if (a[xn][yn] == 2) {

flag = 2;
break;
}
else if (a[xn][yn] == 1) {
continue;
}
q.push(make_pair(xn, yn));
}
else {

flag = 1;
break;
}
}
if (flag != 0) break;
}

}

void bfs(int x, int y) {

queue<pair<int, int>>q;
q.push(make_pair(x, y));
ch[x][y] = 1;

while (!q.empty()) {
auto p = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int xn = p.first + xi[i];
int yn = p.second + yi[i];
if (check(xn, yn)) {
if (ch[xn][yn])continue;
ch[xn][yn] = 1;

if (a[xn][yn] == 0) {
continue;
}

q.push(make_pair(xn, yn));
}
}
}
}

int main() {
ios::sync_with_stdio(0);

int T;
cin >> T;
while (T--) {
cin >> n >> m;
string s;
for (int i = 1; i <= n; i++) {
cin >> s;
for (int j = 0; j < m; j++) {
a[i][j + 1] = s[j] - '0';
ch[i][j + 1] = 0;
}
}

for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 0) continue;
flag = 0;
init_bfs(i, j);

if (flag != 1) a[i][j] = 2;
}
}

ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ch[i][j] == 1 || a[i][j] != 1) continue;
ans++;
bfs(i, j);

}
}

cout << ans;
if (T != 0) cout << endl;


}


return 0;
}

试题 G: 子串简写

前缀和，但这个位置的题目真的这么简单么，怀疑可能读错题。

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

#include<bits/stdc++.h>
using namespace std;

int k;
string s;
char a, b;

int pre[1000010];

int main() {
ios::sync_with_stdio(0);

cin >> k;
cin >> s >> a >> b;

int n = s.length();
long long ans = 0;

for (int i = 0; i < n; i++) {
if (i != 0) pre[i] = pre[i - 1];
else pre[i] = 0;
if (s[i] == a) pre[i]++;
if (s[i] == b && i - k + 1 >= 0) ans += pre[i - k + 1];
}

cout << ans;

return 0;
}

试题 H: 整数删除

维护链表和一个set，每次取出set中最小的，判断是否合法，并对链表节点和值进行修改。

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

#include<bits/stdc++.h>
using namespace std;

int c[1000010];

int n, k;
long long a[500010];

int l[500010], r[500010];

set<pair<int, int>> s;

int main() {
ios::sync_with_stdio(0);

cin >> n >> k;

int w = n - k;

l[0] = r[0] = l[n + 1] = r[n + 1] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
l[i] = i - 1;
r[i] = i + 1;
s.insert(make_pair(a[i], i));
}

while (1) {
if (k == 0) break;

auto it = s.begin();
auto p = *it;

int val = p.first, pos = p.second;
if (c[pos] || a[pos] != val) {
s.erase(it);
continue;
}

k--;
c[pos] = 1;
int pl = l[pos], pr = r[pos];
if (pl > 0 && pl <= n) {
a[pl] += a[pos];
r[pl] = pr;
s.insert(make_pair(a[pl], pl));
}
if (pr > 0 && pr <= n) {
a[pr] += a[pos];
l[pr] = pl;
s.insert(make_pair(a[pr], pr));
}
}

for (int i = 1; i <= n; i++) {
if (c[i]) continue;
cout << a[i];
if (w != 0) cout << " ";
w--;
}


return 0;
}

试题 I: 景区导游

最近公共祖先+简单容斥，LCA边想边敲，敲的很烂，思路应该问题不大。

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

#include<bits/stdc++.h>
using namespace std;

int pow2[21];
int n, k;
vector<pair<int, int>>edge[100010];
long long st[100010][21];
int stt[100010][21];
int fa[100010];
int dep[100010];
int kk[100010];

void init(int x, int f) {

for (int i = 0; i < edge[x].size(); i++) {
auto p = edge[x][i];
int to = p.first;
int val = p.second;

if (to == f) continue;
dep[to] = dep[x] + 1;
fa[to] = x;
st[to][0] = val;
stt[to][0] = x;
for (int j = 1; j <= 20; j++) {
int now = x;
st[to][j] = val;
for (int k = j - 1; k >= 0; k--) {
st[to][j] += st[now][k];
now = stt[now][k];
}
stt[to][j] = now;
}

init(to, x);

}

}

long long solve(int x, int y) {

if (dep[x] > dep[y]) swap(x, y);

int cha = dep[y] - dep[x];

int now = y;
long long ans = 0;
for (int i = 20; i >= 0; i--) {
if (pow2[i] <= cha) {
ans += st[now][i];
cha -= pow2[i];
now = stt[now][i];
}
}

int lpos = x, rpos = now;
while (1) {
if (lpos == rpos) break;
if (stt[lpos][0] == stt[rpos][0]) {
ans += st[lpos][0] + st[rpos][0];
break;
}

for (int i = 20; i >= 0; i--) {
if (stt[lpos][i] == stt[rpos][i]) continue;
ans += st[lpos][i] + st[rpos][i];
lpos = stt[lpos][i];
rpos = stt[rpos][i];
}
}

return ans;

}

int main() {
ios::sync_with_stdio(0);

pow2[0] = 1;
for (int i = 1; i <= 20; i++) pow2[i] = pow2[i - 1] * 2;

cin >> n >> k;
for (int i = 1; i < n; i++) {
int u, v, t;
cin >> u >> v >> t;
edge[u].push_back(make_pair(v, t));
edge[v].push_back(make_pair(u, t));

}
dep[1] = 1;
init(1, 0);

for (int i = 1; i <= k; i++) cin >> kk[i];

long long ans = 0;

for (int i = 2; i <= k; i++) {
ans += solve(kk[i - 1], kk[i]);
}

for (int i = 1; i <= k; i++) {
long long ff = ans;
if (i == 1) {
ff -= solve(kk[i], kk[i + 1]);
}
else if (i == k) {
ff -= solve(kk[i - 1], kk[i]);
}
else {
ff -= solve(kk[i], kk[i + 1]);
ff -= solve(kk[i - 1], kk[i]);
ff += solve(kk[i - 1], kk[i + 1]);
}
cout << ff;
if (i != k) cout << " ";
}

return 0;
}

试题 J: 砍树

正解没有想到，枚举砍掉的边，用LCA判断是否在一颗子树上，可以通过30%样例。

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

#include<bits/stdc++.h>
using namespace std;

int pow2[21];
int n, k;
vector<int>edge[100010];
int stt[100010][21];
int fa[100010];
int dep[100010];
int kl[100010], kr[100010];
int ledge[100010], redge[100010];

void init(int x, int f) {

for (int i = 0; i < edge[x].size(); i++) {
int to = edge[x][i];

if (to == f) continue;
dep[to] = dep[x] + 1;
fa[to] = x;
stt[to][0] = x;
for (int j = 1; j <= 20; j++) {
int now = x;
for (int k = j - 1; k >= 0; k--) {
now = stt[now][k];
}
stt[to][j] = now;
}

init(to, x);

}

}

int solve(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);

int cha = dep[y] - dep[x];

int now = y;
for (int i = 20; i >= 0; i--) {
if (pow2[i] <= cha) {
cha -= pow2[i];
now = stt[now][i];
}
}

int lpos = x, rpos = now;


while (1) {
if (lpos == rpos) break;
if (stt[lpos][0] == stt[rpos][0]) {
lpos = stt[lpos][0];
break;
}

for (int i = 20; i >= 0; i--) {
if (stt[lpos][i] == stt[rpos][i]) continue;
lpos = stt[lpos][i];
rpos = stt[rpos][i];
}
}

return lpos;

}

int main() {
ios::sync_with_stdio(0);

pow2[0] = 1;
for (int i = 1; i <= 20; i++) pow2[i] = pow2[i - 1] * 2;

cin >> n >> k;
for (int i = 1; i < n; i++) {
int u, v, t;
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
ledge[i] = u;
redge[i] = v;

}
dep[1] = 1;
init(1, 0);
for (int i = 1; i <= k; i++) {
cin >> kl[i] >> kr[i];
}

int ans = -1;

for (int i = 1; i < n; i++) {
if (dep[ledge[i]] < dep[redge[i]]) swap(ledge[i], redge[i]);

int flag = 0;
for (int j = 1; j <= k; j++) {
int ansa = solve(kl[j], ledge[i]);
int ansb = solve(kr[j], ledge[i]);

if ((ansa == ledge[i] || ansb == ledge[i]) && ansa != ansb) continue;
flag = 1;
break;

}
if (!flag) ans = i;

}
cout << ans;


return 0;
}

死锁问题

获取锁的进程在锁未释放时终止，其他进程无法获取到锁，形成死锁

解决死锁问题？

原子操作设置过期时间

过期时间的两个问题

• 未执行完key就过期，导致其他进程获取到锁：锁续期
• 删除到其他线程的锁：设定不冲突的key值

提升redis锁性能

分段锁

比如把相同的商品的id分段

集群引发的问题

主服务器加锁，未同步到从服务器就挂掉，选举的新的主服务器没有加锁

Redis红锁方案

• 存活的Redis服务器有一半加锁成功，才算成功
• 实现工具：redission

JVM的STW对Redis影响

拿到锁后，JVM发生STW，锁无法续期，其他进程可以拿到锁

使用zookeeper解决

第一章 并发编程的挑战

减少上下文切换的四种方法 p3

第二章 Java并发机制的底层实现原理

volatile如何保证可见性 p9

synchronized实现原理 p12

锁的升级 p13

处理器实现原子操作的两种方式 p17

java实现原子操作 p18

CAS实现原子操作的三大问题 p19

第三章 Java内存模型

volatile两大特性的含义（可见性与原子性） p39

双重检查锁定（单例模式） p67

类初始化的5个阶段 p74

第四章 Java并发编程基础

线程的状态 p87

队列同步器AQS p121

重入锁 p136

公平锁与非公平锁 p137

读写锁 p140

Seata是什么？

Seata是2019年1月蚂蚁金服和阿里巴巴共同开源的分布式事务解决方案。致力于提供高性能和简单易用的分布式事务服务，为用户打造一站式的分布式解决方案。

Seata架构

Seata事务管理中有三个重要角色

• TC - 事务协调者：维护全局和分支事务的状态，协调全局事务提交或回滚
• TM - 事务管理器：定义全局事务的范围、开始全局事务、提交或回滚全局事务
• RM - 资源管理器：管理分支事务处理的资源，与TC交谈以注册分支事务和报告分支事务的状态，并驱动分支事务提交或回滚

Seata提供了四种不同的分布式事务解决方案

• XA模式：强一致分阶段事务模式，牺牲了一定的可用性，无业务侵入
• TCC模式：最终一致的分阶段事务模式，有业务侵入
• AT模式：最终一致的分阶段事务模式，无业务侵入，也是Seata的默认模式
• SAGA模式：长事务模式，有业务侵入

XA模式

原理

XA规范是X/Open组织定义的分布式事务处理(DTP)标准，XA规范描述了全局的TM与局部RM之间的接口，几乎所有主流的数据库都对XA规范提供了支持

• RM一阶段工作：
  • 注册分支事务到TC
  • 执行分支事务sql但不提交
  • 报告执行状态到TC
• TC二阶段工作：
  • TC检测各分支事务执行状态
  • 判断提交或回滚
• RM二阶段工作：
  • 接收TC指令，提交或回滚事务

实现XA模式

Seata的starter已经完成了XA模式的自动装配

• 修改配置文件

1
2

seata:
    data-source-proxy-mode: XA

• 发起全局事务的入口添加@GlobalTransactional注解

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

@Override
@GlobalTransactional
public Long create(Order order) {
    // 创建订单
    orderMapper.insert(order);
    try {
        // 扣用户余额
        accountClient.deduct(order.getUserId(), order.getMoney());
        // 扣库存
        storageClient.deduct(order.getCommodityCode(), order.getCount());

    } catch (FeignException e) {
        log.error("下单失败，原因:{}", e.contentUTF8(), e);
        throw new RuntimeException(e.contentUTF8(), e);
    }
    return order.getId();
}

AT模式

原理

AT模式同样是分阶段提交的事务模型，不过弥补了XA模型中资源锁定周期过长的缺陷

• RM一阶段工作：
  • 注册分支事务到TC
  • 记录undo-log（数据快照）
  • 执行分支事务sql并提交
  • 报告执行状态到TC
• TC二阶段工作：
  • TC检测各分支事务执行状态
  • 判断提交或回滚，提交删除快照，回滚读取快照
• RM二阶段回滚工作：
  • 根据undo-log恢复数据

AT模式的写隔离

全局锁：由TC（在数据库中）记录当前正在操作某行数据的事务，该事务持有全局锁，具备执行权

• 事务1获取了全局锁，准备回滚，等待事务2释放DB锁（读写隔离）
• 事务2持有DB锁，等待全局锁，重试默认30次，间隔10毫秒，超时释放（避免死锁）
• 事务1获取DB锁，将数据库当前数据和更新后undo-log数据对比，判断是否一致

TCC模式

与AT模式相似，每阶段都是独立事务，但不加锁。不同的是TCC通过人工编码来实现数据恢复，需要实现三个方法

• Try：资源的检测和预留，比如可用余额预留为冻结余额，不同的操作冻结的余额相互隔离
• Confirm：完成资源操作业务；要求Try成功Confirm一定要成功
• Cancel：预留资源释放，try的反向操作

优点

• 一阶段完成直接提交事务，释放数据库资源，性能好
• 相比AT模型，无需生成快照，无需使用全局锁，性能最强
• 不依赖数据库事务，而是依赖补偿操作，可以用非事务数据库

缺点

• 有代码侵入，需要人为编写try、Confirm和Cancel接口
• 软状态，最终一致
• 需要考虑Confirm和Cancel失败情况，做好幂等处理

空回滚

当某分支事务的try阶段阻塞时，可能导致全局事务超时而触发二阶段的cancel操作，在未执行try操作时先执行了cancel操作，这时cancel不能做回滚，就是空回滚

业务悬挂

对于已经空回滚的业务，如果以后继续执行try，就永远不可能confirm或cancel，这就是业务悬挂。应当组织执行空回滚后try操作，避免悬挂

业务分析

为了实现空回滚，防止业务悬挂，以及幂等性要求。我们必须在数据库记录预留资源信息同时，记录当前事务id和执行状态

声明TCC接口，并实现三个方法

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

@Service
public class AccountTCCServiceImpl implements AccountTCCService {

    @Autowired
    private AccountMapper accountMapper;
    @Autowired
    private AccountFreezeMapper accountFreezeMapper;

    @Override
    @Transactional
    public void deduct(String userId, int money) {
        //获取事务id
        String xid = RootContext.getXID();

        //业务悬挂判断
        AccountFreeze oldFreeze = accountFreezeMapper.selectById(xid);
        if(oldFreeze != null) {
            return;
        }

        //扣减可用余额
        accountMapper.deduct(userId, money);
        //记录冻结余额与事务状态
        AccountFreeze freeze = new AccountFreeze();
        freeze.setUserId(userId);
        freeze.setFreezeMoney(money);
        freeze.setState(AccountFreeze.State.TRY);
        freeze.setXid(xid);
        accountFreezeMapper.insert(freeze);
    }

    @Override
    public boolean confirm(BusinessActionContext ctx) {
        //获取事务id
        String xid = ctx.getXid();
        //根据id删除冻结记录
        int count = accountFreezeMapper.deleteById(xid);

        return count == 1;
    }

    @Override
    public boolean cancel(BusinessActionContext ctx) {
        //获取事务id,查询freeze对象
        String xid = ctx.getXid();
        String userId = ctx.getActionContext("userId").toString();
        AccountFreeze freeze = accountFreezeMapper.selectById(xid);

        //空回滚判断，判断freeze是否为null
        if(freeze == null) {
            AccountFreeze newFreeze = new AccountFreeze();
            freeze.setUserId(userId);
            freeze.setFreezeMoney(0);
            freeze.setState(AccountFreeze.State.CANCEL);
            freeze.setXid(xid);
            int count = accountFreezeMapper.insert(newFreeze);

            return count == 1;
        }

        //幂等判断
        if(freeze.getState().equals(AccountFreeze.State.CANCEL)) {
            return true;
        }

        //恢复可用余额
        accountMapper.refund(freeze.getUserId(), freeze.getFreezeMoney());

        //将冻结金额清零，状态改为CANCEL
        freeze.setFreezeMoney(0);
        freeze.setState(AccountFreeze.State.CANCEL);

        int count = accountFreezeMapper.updateById(freeze);

        return count == 1;
    }
}

Saga模式

Saga模式时SEATA提供的长事务解决方案。也分为两个阶段

• 一阶段：直接提交事务，与TCC不同的是不做预留操作
• 二阶段：失败则通过编写补偿业务来回滚

优点

• 事务参与者可以基于事件驱动实现异步调用，吞吐高
• 一阶段直接提交事务，无锁，性能好
• 不用编写TCC中三个阶段，实现简单

缺点

• 软状态持续时间不确定，时效性差
• 无锁，无事务隔离，会有脏写

在分布式系统下，一个业务跨越多个服务或数据源，每个服务都是一个分支事务，要保证所有分支事务最终状态一致，这样的事务就是分布式事务。

CAP定理

分布式系统三个指标：

• Consistency（一致性）：用户访问分布式系统中的任意节点，得到的数据必须一致
• Availability（可用性）：用户访问集群中的任意健康节点，必须能得到响应，而不是超时或拒绝
• Partition tolerance（分区容错性）：出现分区问题，C和A无法同时满足
  • 分区：因为网络故障或其它原因导致分布式系统中的部分节点与其它节点失去连接，形成独立分区
  • 容错：在集群出现分区时，整个系统也要持续对外提供服务

Eric Brewer认为，分布式系统无法同时满足三个指标，这个结论就是CAP定理

BASE理论

BASE理论时对CAP的一种解决思路

• Basically Available（基本可用）：分布式系统出现故障时，允许损失部分可用性，即保证核心可用
• Soft State（软状态）：在一定时间内，允许出现中间状态，比如临时的不一致状态
• Eventually Consistent（最终一致性）：虽然无法保证强一致，但是在软状态结束后，最终达到数据一直

AP模式

各子事务分别执行和提交，允许出现结果不一致，然后采用弥补措施恢复数据即可，实现最终一致

CP模式

各个子事务执行后互相等待，同时提交，同时回滚，达成强一致，但事务等待过程中，处于弱可用状态

事务协调者

各个子系统之间必须能感知到彼此的事务状态，才能保证状态一致，因此需要一个事务协调者来协调每一个事务的参与者（子系统事务）

授权规则可以对调用方的来源做控制，有白名单和黑名单两种方式

• 白名单：来源在白名单内的调用者允许访问
• 黑名单：来源在黑名单内的调用者不允许访问

可以解决绕过网关直接访问微服务的问题

授权方法

• 实现RequestOriginParser接口，自定义处理逻辑

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

@Component
public class HeaderOriginParser implements RequestOriginParser {
    @Override
    public String parseOrigin(HttpServletRequest request) {

        String origin = request.getHeader("origin");

        if(StringUtils.isEmpty(origin)) {
            origin = "blank";
        }
        return origin;
    }
}

• 在gateway服务中，利用过滤器添加指定请求头

1
2
3
4
5
6

spring:
  cloud:
    gateway:
      default-filters:
        - AddRequestHeader=Truth,Itcast is freaking awesome!
        - AddRequestHeader=origin,gateway

• 在sentinel中添加约定好的授权规则

自定义异常

实现BlockExceptionHandler接口

BlockException包含多个子类：

规则持久化

规则管理模式

• 原始模式：默认模式，将规则保存在内存，重启服务丢失
• pull模式：控制台将配置的规则推送给Sentinel客户端，客户端会保存到本地文件或数据库中。之后定时轮询更新
• push模式：控制台将配置规则推送到远程配置中心，例如Nacos。Sentinel客户端监听Nacos，获取配置变更的推送消息，完成本地更新

虽然限流可以尽量避免因高并发而引起的服务故障，但服务还会因为其它原因而故障。而要将这些故障控制在一定范围，避免雪崩，就要靠线程隔离（舱壁模式）和熔断降级的手段。

Feign整合Sentinel

SpringCloud中，微服务调用都是通过Feign来实现的，因此做客户端保护必须整合Feign和Sentinel

• 修改配置文件，开启Feign的Sentinel功能
• 给FeignClient编写失败后的降级逻辑
  • 方式一：FallbackClass，无法对远程调用的异常做处理
  • 方式二：FallbackFactory，可以对远程调用的异常做处理

使用FallbackFactory实现降级逻辑

• 定义类，实现FallbackFactory接口的create方法

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

@Slf4j
public class UserClientFallBackFactory implements FallbackFactory<UserClient> {
    @Override
    public UserClient create(Throwable throwable) {
        return new UserClient() {
            @Override
            public User findById(Long id) {
                log.error("查询用户异常", throwable);
                return new User();
            }
        };
    }
}

• 将实现的FallbackFactory注册为一个Bean

1
2
3
4

@Bean
public UserClientFallBackFactory userClientFallBackFactory() {
    return new UserClientFallBackFactory();
}

• 在Client接口中使用FallbackFactory（注解添加）

1

@FeignClient(value = "userservice", fallbackFactory = UserClientFallBackFactory.class)

线程隔离

• 线程池隔离
  • 支持主动超时和异步调用
  • 但线程额外开销较大
  • 场景：低扇出
• 信号量隔离（Sentinel默认）
  • 轻量级，无额外开销
  • 不支持主动超时、异步调用
  • 场景：高频调用，高扇出

熔断降级

也是解决雪崩问题的重要手段。由断路器统计服务调用的异常比例、慢请求比例，如果超出阈值则会熔断该服务。即拦截访问该服务的一切请求；而当服务恢复时，断路器会放行访问该服务的请求

断路器三种状态

• Closed：不会拦截任何请求
• Open：熔断，拦截进入该服务的请求，有持续时间
• Half-Open：Open状态时间结束，会放行请求，根据结果切换状态

熔断策略-慢调用

业务响应时长（RT）大于指定时长的请求认定为慢调用请求。在指定时间内，如果请求数量超过设定的最小数量且慢调用比例大于设定的阈值，则触发熔断

熔断策略-异常比例

慢调用比例换成抛出异常比例即可

熔断策略-异常数

指定异常次数

雪崩问题

微服务调用链路中的某个服务故障，引起整个链路中的所有微服务都不可用

解决雪崩问题的常见方式有四种（前三种避免故障传递，流量控制预防故障发生）：

• 超时处理：设定超时时间，请求超过一定时间没有响应就返回错误信息，不会无休止等待
• 舱壁模式：限定每个业务能使用的线程数，避免耗尽整个tomcat资源，因此也叫线程隔离
• 熔断降级：由断路器统计业务执行的异常比例，如果超出阈值则会熔断该业务，拦截访问该业务的一切请求
• 流量控制：限制业务访问的QPS（每秒钟请求数量），避免服务因流量的突增而故障

服务保护技术对比(Sentinel与Hystrix)

安装Sentinel控制台

• 运行jar包
• 访问页面，默认账号密码为sentinel
• 通过配置修改

• 启动时修改

1

java -jar sentinel-dashboard-1.8.1.jar -Dserver.port=8090

微服务整合Sentinel

• 引入sentinel依赖

1
2
3
4

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

• 配置控制台地址

1
2
3
4
5

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080

• 访问微服务任意端点，触发sentinel监控

Sentinel限流规则

簇点链路

项目内的调用链路，链路中被监控的每个接口就是一个资源。默认情况下Sentinel会监控SpringMVC每一个端点

在Sentinel控制台设置流控规则

• 设置QPS，并使用Apache JMeter测试
• 高级配置：流控模式、流控效果

• 流控模式：直接、关联、链路

  • 直接：默认模式，统计当前资源请求，触发阈值对当前资源限流
  • 关联：统计与当前资源相关的另一个资源，触发阈值对当前资源限流(A触发阈值对B限流)，如触发修改订单阈值，对查询订单限流
  • 链路：只统计从指定链路访问到本地的资源的请求，触发阈值时，对指定链路限流

• 流控效果，请求达到流控阈值时应该采取的措施，包括三种：快速失败、warm up、排队等待

  • 快速失败：达到阈值后，新的请求立即被拒绝抛出FlowException异常
  • warm up：预热模式，对超出阈值的请求同样拒绝，但这种模式的阈值会动态变化，从小增大到最大阈值
  • 排队等待：让所有请求按照先后次序排队执行，间隔不小于指定时常

添加限流方法

• Sentinel默认只标记Controller中的方法为资源，如果要标记其它方法，需要利用@SentinelResource注解

• Sentinel默认会将Controller方法做context整合，导致链路模式的流控失效，需要修改application.yml

1
2
3
4

spring:
  cloud:
    sentinel:
      web-context-unify: false #关闭context整合

流控效果-warm up

应对服务冷启动的一种方案，请求阈值初始值为threshold/coldFactor，持续指定时长后，逐渐提高到threshold，coldFactor（冷启动因子）默认值为3

流控效果-排队等待

让所有请求进入一个队列中，然后按着阈值允许的时间间隔依次执行。后来的请求必须等待前面执行完成，如果请求预期时间超出最大时长，则会被拒绝

• 例如，QPS=5，也就是每200ms处理一个请求。timeout=2000，意味着等待超过2000ms就会抛出异常

热点参数限流

分别统计与设定参数值相同的请求，判断是否超过QPS阈值

• 例如参数索引为0，单机阈值为5，统计窗口时长为1，含义为：对当前资源0号参数（第一个参数）的请求做统计，每1秒的请求数量不超过5
• 高级选项可以对部分参数做例外配置

• 服务器之间通过数据库进行数据共享
• 用加锁的方式抢夺资源

核心组件

• 核心调度工具类：Scheduler
• 定义任务接口：Job
• 配置Job的接口：JobDetail(Job信息)、Trigger(触发器)

核心数据库表

• qrtz_job_details表：job相关信息
• qrtz_simple_triggers表：trigger简单内容
• qrtz_triggers表：trigger详细内容
• qrtz_scheduler_state表：定时器的信息状态
• qrtz_locks表：锁信息

定时任务创建基本步骤

• 创建工具类，用于将创建的jobDetail和trigger存储到数据库，实现二者FactoryBean

  • FactoryBean作用：简化Bean的实例化过程
    • Spring通过FactoryBean封装Bean实例化过程
    • 将FactoryBean装配到Spring容器里
    • 将FactoryBean注入给其它Bean
    • 该Bean就得到了FactoryBean所管理对象的实例

• 创建Job实体类，实现Job接口的execute方法

什么是SpringAMQP

AMQP（高级消息队列协议）

是用于在应用程序或之间传递业务消息的开放标准。该协议与语言和平台无关，更符合微服务中独立性的要求

Spirng AMQP

基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息。包含两部分，其中spring-amqp是基础抽象，spring-rabbit是底层的默认实现

利用SpringAMQP实现基础消息队列功能

发送消息

• 在父工程中引入spring-amqp依赖
• 在publisher服务中利用RabbitTemplate发送消息到simple.queue这个队列

接受消息

• 引入amqp的starter依赖
• 配置RabbitMQ地址
• 定义类，添加@Component注解
• 类中声明方法，添加@RabbitListener注解，方法参数就是消息

Work Queue 工作队列

与基础消息队列区别：多个消费者，可以提高消息处理速度，避免队列消息堆积

消费预取限制

配置文件设置preFetch值，可以控制预取消息上限

1
2
3
4
5

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 #每次只能获取一条消息，处理完才能获取下一条,默认无限

发布、订阅模型（Publish&Subscribe）

允许将同一消息发送给多个消费者，实现方式是加入了交换机（exchange）

实现方式：通过交换机发送给多个队列

常见交换机类型：

• Fanout：广播
• Direct：路由
• Topic：话题

注意：exchange负责消息路由，只负责转发消息，路由失败则消息丢失

发布订阅-FanoutExchange

会将接收到的消息路由到每一个与其绑定的queue

实现思路如下：

• 在cunsumer服务中，声明队列、交换机，并将两者绑定
• 在consumer服务中，编写消费者方法，分别监听各个队列
• 在publisher中编写测试方法，发送消息

发布订阅-DirectExchange

会将接收到的消息根据规则路由到指定的Queue，因此称为路由模式

• 每一个Queue都与Exchange设置一个BindingKey，可以绑定多个
• 发布者发送消息时，指定消息的RoutingKey
• Exchange将消息路由到BindingKey宇RoutingKey一致的队列

1
2
3
4
5

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "direct.queue1"),
        exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
        key = {"red", "blue"}
))

发布订阅-TopicExchange

与DirectExchange类似，区别在于routingKey必须是多个单词的列表，并且以.分割

Queue与Exchange指定BindingKey时可以使用通配符：

• ：代指0个或多个单词

• *：代指一个单词

1
2
3
4
5

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "topic.queue2"),
        exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
        key = "#.news"
))

消息转换器

消息发送Java对象时，SpringAMQP会帮我们序列化为字节后发送，基于JDK的ObjectOutputStream完成序列化

如果要修改只需要定义一个MessageConverter的Bean即可。推荐使用JSON方式序列化，步骤如下：

发送消息

• 在publisher服务引入依赖

1
2
3
4
5

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

• 在publisher服务声明MessageConverter

1
2
3
4

@Bean
public MessageConverter jsonMessageConverter() {
    return new Jackson2JsonMessageConverter();
}

• 发送消息即可

接收消息

• 在consumer服务引入Jackson依赖

1
2
3
4
5

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

• 在consumer服务定义MessageConverter：

1
2
3
4

@Bean
public MessageConverter jsonMessageConverter() {
    return new Jackson2JsonMessageConverter();
}

• 接收消息即可

常见消息模型

MQ的官方文档中给出了5个MQ的Demo示例，对应了几种不同的用法：

• 基本消息队列（BasicQueue）
• 工作消息队列（WorkQueue）
• 发布订阅（Publish、Subscribe），又根据交换机类型不同分为三种：
  • Fanout Exchange：广播
  • Direct Exchange：路由
  • Topic Exchange：主题

基本消息队列（官方提供API）

消息发送流程

• 建立connection
• 创建channel
• 利用channel声明队列
• 利用channel向队列发送消息

基本消息队列的消息接收流程

• 建立connection
• 创建channel
• 利用channel声明队列
• 定义consumer的消费行为handleDelivery()
• 利用channel将消费者与队列绑定

1
2
3
4
5
6
7
8
9

docker run \
-e RABBITMQ_DEFAULT_USER=用户名 \
-e RABBITMQ_DEFAULT_PASS=密码\
--name mq \
--hostname mq1 \
>p 15672:15672 \
-p 5672:5672 \
-d \
rabbitmq:3-management

基本概念

• channel：操作MQ的工具
• exchange：路由消息到队列中
• queue：缓存消息
• virtual host：虚拟主机，是对queue、exchange等资源的逻辑分组

• UV(Unique Visitor)
  • 独立访客，需通过用户IP排重统计数据
  • 每次访问都要进行统计
  • HyperLogLog，性能好，存储空间小
• DAU(Daily Active User)
  • 日活跃用户，需通过用户ID排重统计数据
  • 访问过一次，则认为其活跃
  • Bitmap，性能好、且可以精确统计结果

• 功能实现
  • 点击置顶，修改帖子类型
  • 点击加精、删除，修改帖子状态
• 权限管理
  • 版主可以执行置顶、加精操作
  • 管理员可以执行删除操作
• 按钮显示
  • 版主可以看到置顶、加精按钮
  • 管理员可以看到删除按钮

简介

SpringSecurity是一个专注于为Java应用程序提供身份认证和授权的框架，它的强大之处在于它可以轻松扩展以满足自定义的需求

特征

• 对身份的认证和授权提供全面的、可扩展的支持
• 防止各种攻击，如会话固定攻击、点击劫持、csrf攻击等
• 支持与Servlet API、Spring MVC等Web技术集成

用户权限管理

• User实体类实现UserDetails接口

  • isAccountNonExpired()方法：返回true，账号未过期
  • isAccountNonLocked()方法：返回true，账号未锁定
  • isCredentialsNonExpired()方法：返回true，凭证未过期
  • isEnabled()方法：返回true，账号可用
  • getAuthorities()方法：返回用户的权限集合，权限实现GrantedAuthority接口

• UserService实现UserDetailsService接口

  • loudUserByUsername()方法：通过用户名查找用户

• SecurityConfig配置类，要求继承于WebSecurityConfigurerAdapter类

  • configure(WebSecurity web)方法

    • web.ignoring(),antMatchers(“资源路径”)：忽略静态资源访问

  • configure(AuthenticationManagerBuilder auth)方法

    • AuthenticationManager：认证核心接口
    • AuthenticationManagerBuilder：用于构建AuthenticationManager实例
    • ProviderManager：AuthenticationManager接口的默认实现类
    • AuthenticationProvider：每个ProviderManager持有一组AuthenticationProvider，每个AuthenticationProvider负责一种认证（委托模式）
    • Aythentication：用于封装认证信息的接口，不同实现类代表不同认证信息
    • 内置认证规则：auth.userDetailsService(xxxService).passwordEncoder(内置密码加密方式);
    • 自定义认证规则：auth.authenticationProvider(new AuthenticationProvider())，实现 AuthenticationProvider的接口
      • authenticate()方法：实现认证逻辑，reutrn UsernamePasswordAuthenticationToken(user, user.getPassword(), user.getAuthorities())，信息、证书、权限
      • supports()方法：返回当前接口支持哪种认证类型，例如return UsernamePasswordAuthenticationToken.class.equals(aClass)。UsernamePasswordAuthenticationToken：Aythentication常用实现类，代表账号密码认证

  • configure(HttpSecurity http)方法，登陆相关配置

    • http.formLogin().loginPage()

      .loginProcessingUrl()

      .successHandler(new AuthenticationSuccessHandler())

      .failureHandler(new AuthenticationFailureHandler())

    • 退出相关配置：

    ​ http.logout().logoutUrl().logoutSuccessHandler()

    • 授权配置

    ​ http.authorizeRequests()

    ​ .antMatchers(“路径”).hasAnyAuthority(权限，权限)

    ​ .and().exceptionHandling().accessDeniedPage(“权限不足页面”)

    • 增加Filter，处理验证码

    ​ http.addFilterBefore(new Filter())

    • 记住我功能

    ​ http.rememberMe()

同步调用存在的问题

• 耦合度高
• 性能下降
• 资源浪费
• 级联失败

异步调用

• 异步调用常见实现是事件驱动模式
• 优势
  • 服务解耦
  • 性能提升，吞吐量提高
  • 服务没有强依赖，不担心级联失败问题，故障隔离
  • 流量削峰（缓冲）
• 缺点
  • 依赖于Broker的可靠性、安全性、吞吐能力
  • 架构复杂，业务没有明显的流程线，不好追踪管理

常见镜像仓库服务

镜像仓库有公有和私有的两种形式

• 公共仓库：官方的Docker Hub，网易云镜像，DaoCloud镜像，阿里云镜像等。
• 本地搭建私有Docker Registry

创建私有镜像仓库（可视化界面）

配置Docker信任地址

我们的私服采用的是http协议，默认不被Docker信任，所以需要做一个配置：

1
2
3
4
5
6
7
8

# 打开要修改的文件
vi /etc/docker/daemon.json
# 添加内容：
"insecure-registries":["http://{ip地址}:8080"]
# 重加载
systemctl daemon-reload
# 重启docker
systemctl restart docker

使用DockerCompose部署带有图象界面的DockerRegistry

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

version: '3.0'
services:
  registry:
    image: registry
    volumes:
      - ./registry-data:/var/lib/registry
  ui:
    image: joxit/docker-registry-ui:static
    ports:
      - 8080:80
    environment:
      - REGISTRY_TITLE=私有仓库1
      - REGISTRY_URL=http://registry:5000
    depends_on:
      - registry

在私有镜像仓库推送或拉取镜像

• 重新tag本地镜像，名称前缀为私有仓库地址

1

docker tag nginx:latest 116.62.168.80:8081/nginx:1.0

• 推送镜像

1

docker push 116.62.168.80:8081/nginx:1.0

• 拉取镜像

1

docker pull 116.62.168.80:8081/nginx:1.0

什么是DockerCompose

• DockerCompose可以基于Compose文件帮用户快速部署分布式应用，而无需手动一个个创建和运行容器
• Compose文件是一个文本文件，通过指令定义集群中每个容器如何运行

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

version: "3.2"

services:
  nacos:
    image: nacos/nacos-server
    environment:
      MODE: standalone
    ports:
      - "8848:8848"
  mysql:
    image: mysql:5.7.25
    environment:
      MYSQL_ROOT_PASSWORD: 123456
    volumes:
      - "$PWD/mysql/data:/var/lib/mysql"
      - "$PWD/mysql/conf:/etc/mysql/conf.d/"
  userservice:
    build: ./user-service
  orderservice:
    build: ./order-service
  gateway:
    build: ./gateway
    ports:
      - "10010:10010"

可以看到，其中包含5个service服务：

• nacos：作为注册中心和配置中心
  • image: nacos/nacos-server： 基于nacos/nacos-server镜像构建
  • environment：环境变量
    • MODE: standalone：单点模式启动
  • ports：端口映射，这里暴露了8848端口
• mysql：数据库
  • image: mysql:5.7.25：镜像版本是mysql:5.7.25
  • environment：环境变量
    • MYSQL_ROOT_PASSWORD: 123456：设置数据库root账户的密码
  • volumes：数据卷挂载，这里挂载了mysql的data、conf目录，其中有我提前准备好的数据
• userservice、orderservice、gateway：都是基于Dockerfile临时构建的

• 修改cloud-demo项目，将数据库、nacos地址都命名为docker-compose中的服务名
• 使用maven打包工具，将项目中的每个微服务都打包为app.jar
• 将打包好的app.jar拷贝到cloud-demo中的每一个对应子目录中
• 将cloud-demo上传至虚拟机，利用docker-compose up -d来部署