课程作业 on 蛋蛋忧桑

MapReduce工作原理及基础编程

Sat, 07 Jun 2025 01:05:58 +0800

概念介绍

MapReduce 是一种用于处理和生成大规模数据集的编程模型。

它将整个计算过程分为两个核心阶段：Map（映射） 和 Reduce（归并）。在 Map 阶段，数据被分成小块并并行处理，提取出中间的键值对结果；在 Reduce 阶段，框架会将所有具有相同键的数据聚合起来，由用户定义的逻辑进行归并处理，最终输出结果。

MapReduce 的核心优势是：可扩展性强、适合大数据分布式处理、编程模型简单，框架自动负责数据的调度与容错。

通俗地说，它就像是一条流水线：先把原料（大数据）切碎并加工（Map），然后将相同类型的零件集中起来装配成品（Reduce）。

执行流程

实际上MapReduce有三个阶段：Map（映射）、Shuffle（派发）、Reduce（规约）。

在 Map 阶段，每条输入数据（通常是一行文本）被送入用户自定义的 Mapper 类中进行处理。开发者在这个阶段编写逻辑，将每条原始数据“映射”为一组中间键值对（key-value），例如统计词频时，把一句话拆分成每个词，并赋予每个词一个初始计数（如 key 为单词，value 为 1）。这些中间结果不会立即输出，而是会经过分区、排序和归组。

接下来是 Shuffle 阶段，这是 MapReduce 框架自动完成的核心过程。框架会将所有 Mapper 输出的 key 按照值进行聚合，也就是说，把所有具有相同 key 的记录集中在一起，并将它们分发给相应的 Reducer。这个阶段还涉及网络传输（跨节点数据移动）、排序（对 key 进行字典序排列）以及归组（将相同 key 的 value 组成集合），是整个 MapReduce 中性能和资源消耗最多的一部分。

最后是 Reduce 阶段，所有已经被聚合并排序好的数据会输入到开发者自定义的 Reducer 中。Reducer 接收的是某一个 key 以及与它相关联的所有 value 列表，开发者在这个阶段编写聚合逻辑，如累加、求平均、取最大值等。处理后的结果会以最终输出的形式写入 HDFS 或本地文件系统，形成最终的数据处理结果。

所以说，根据以上叙述我们可以得知：在实际的编程中，我们要做的就是编写Map和Reduce操作的代码。同时我们也可以理解到，Map的处理过程应当是(行号, 一行文本) → (key, value)；Reduce的处理过程应当是(key, values) → (key, value)。

编程思想

在编写相关Java代码时，我认为最重要的就是理清楚输入输出类型和输入到输出的处理过程，也即(行号, 一行文本) 是怎么变到 (key, value)的，(key, values) 又是怎么变到 (key, value)的。

标准Mapper类

import org.apache.hadoop.io.*;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;

public class MyMapper extends Mapper {

 private Text outKey = new Text();
 private IntWritable outValue = new IntWritable();

 @Override
 protected void map(LongWritable key, Text value, Context context)
 throws IOException, InterruptedException {

 // 1. 读取一行文本
 String line = value.toString();

 // 2. 分割字段（假设是以逗号分隔的 CSV）
 String[] fields = line.split(",");

 // 3. 做简单校验
 if (fields.length >= 2) {
 String someKey = fields[0]; // 例如：用户ID
 int someValue = Integer.parseInt(fields[1]); // 例如：交易金额

 // 4. 设置输出
 outKey.set(someKey);
 outValue.set(someValue);

 // 5. 输出 key-value 对
 context.write(outKey, outValue);
 }
 }
}

标准Reducer类

import org.apache.hadoop.io.*;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;

public class MyReducer extends Reducer {

 private IntWritable result = new IntWritable();

 @Override
 protected void reduce(Text key, Iterable values, Context context)
 throws IOException, InterruptedException {

 int sum = 0;
 for (IntWritable val : values) {
 sum += val.get(); // 累加所有值
 }

 result.set(sum);
 context.write(key, result); // 输出结果
 }
}

标准Driver类

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.*;
import org.apache.hadoop.mapreduce.lib.output.*;

public class MyDriver {

 public static void main(String[] args) throws Exception {
 if (args.length != 2) {
 System.err.println("Usage: MyDriver ");
 System.exit(-1);
 }

 Configuration conf = new Configuration();
 Job job = Job.getInstance(conf, "My MapReduce Job");

 job.setJarByClass(MyDriver.class);
 job.setMapperClass(MyMapper.class);
 job.setReducerClass(MyReducer.class);

 job.setMapOutputKeyClass(Text.class);
 job.setMapOutputValueClass(IntWritable.class);
 job.setOutputKeyClass(Text.class);
 job.setOutputValueClass(IntWritable.class);

 FileInputFormat.addInputPath(job, new Path(args[0]));
 FileOutputFormat.setOutputPath(job, new Path(args[1]));

 System.exit(job.waitForCompletion(true) ? 0 : 1);
 }
}

实际上，按照以上标准代码，我们需要做的就是修改输入输出的Key/Value类型和数据处理逻辑。

常见的输入和输出 Key/Value 类型

类型	说明	用途示例
LongWritable	长整型（64位）	输入 key，通常表示文本行的字节偏移量（offset）
IntWritable	整型（32位）	常用于输出 value，如计数、数值统计
Text	字符串类型，Hadoop自带字符串类型	输入或输出的 key/value，多用于字符串数据
DoubleWritable	双精度浮点型	处理小数值，如评分、权重等
FloatWritable	单精度浮点型	同上，较少用
BooleanWritable	布尔型	标记型字段
NullWritable	空值类型	不输出 key 或 value 时用，比如只输出 key

Hadoop配置——两个节点（master和slave1）

Thu, 29 May 2025 14:42:14 +0800

配置要求

目标是配置一个基本的 Hadoop 分布式集群：

一台主节点：master
一台从节点：slave1
支持：HDFS + YARN
Java 已配置
Hadoop 已安装成功，路径在 /opt/hadoop（你可替换为实际路径）

使用 hadoop version 命令测试

注：前置参考资料在文末，建议先按照前置参考资料进行安装配置到 hadoop version 命令成功执行步骤，再继续参照本文章。

修改hosts、hostname

hosts: /etc/hosts 集群所有主机IP地址与对应主机名格式：IP（空）主机名

hostname: /etc/hostname 主节点命名为master，子节点命名为slave1 把主机名直接写入此文件（只能保留一个名字），定义本机的主机名（可能需要重启生效）使用 sudo hostnamectl set-hostname 新主机名 设置（即时生效）使用 hostname 命令查看当前主机名

SSH 配置免密

1. 生成 SSH 密钥对（如果尚未生成）

在每台机器上执行：ssh-keygen -t rsa

一路回车即可（不要设置密码短语）。

2. 将自己的公钥添加到目标机器的 authorized_keys 中

在 master 上执行以下命令，把自己的公钥发给 slave1 ：

ssh-copy-id root@localhost
ssh-copy-id root@slave1

同理，在 slave1 上执行：

ssh-copy-id root@localhost
ssh-copy-id root@master

从每台机器尝试 ssh 到其他机器（包括自己）进行验证：

ssh root@localhost
ssh root@master
ssh root@slave1

配置Hadoop的配置文件

1. core-site.xml


 hadoop.tmp.dir
 file:/opt/hadoop/tmp
 location to store temporary files

 fs.defaultFS
 hdfs://master:9000

2. hdfs-site.xml


 dfs.replication
 1

 dfs.namenode.name.dir
 file:/opt/hadoop/tmp/dfs/name

 dfs.datanode.data.dir
 file:/opt/hadoop/tmp/dfs/data

3. mapred-site.xml


 
 mapreduce.framework.name
 yarn
 

 
 yarn.app.mapreduce.am.env
 HADOOP_MAPRED_HOME=/opt/hadoop
 

 
 mapreduce.map.env
 HADOOP_MAPRED_HOME=/opt/hadoop
 

 
 mapreduce.reduce.env
 HADOOP_MAPRED_HOME=/opt/hadoop

4. yarn-site.xml


 yarn.resourcemanager.hostname
 master

 yarn.nodemanager.aux-services
 mapreduce_shuffle

5. workers（以前叫 slaves）

列出所有的从节点（一个 hostname 一行）。

slave1

复制配置文件

scp -r /opt/hadoop/etc/hadoop/ root@slave1:/opt/hadoop/etc/

启动 Hadoop

hdfs namenode -format
start-dfs.sh
start-yarn.sh

验证是否成功

在 master 和 slave1 分别运行：jps你应该看到：

master 节点有：

NameNode

SecondaryNameNode
ResourceManager
slave1 节点有：

DataNode

NodeManager

然后运行以下命令进行测试，检查是否有问题：

hdfs dfs -ls /
hdfs dfs -mkdir /testdir
hdfs dfs -ls /
echo "Hello Hadoop" > hello.txt
hdfs dfs -put hello.txt /testdir/
hdfs dfs -ls /testdir/
hdfs dfs -cat /testdir/hello.txt
hdfs dfs -get /testdir/hello.txt ./hello_from_hdfs.txt
hdfs dfs -rm /testdir/hello.txt
hdfs dfs -rmdir /testdir
hdfs dfsadmin -report

如果出现问题请先检查防火墙是否开放相应端口。

# 开放端口
for p in 9000 9870 {50010..50020} 50075 8088 8042 9864 9866 9867; do firewall-cmd --permanent --add-port=${p}/tcp; done && firewall-cmd --reload

# 关闭端口
for p in 9000 9870 {50010..50020} 50075 8088 8042 9864 9866 9867; do firewall-cmd --permanent --remove-port=${p}/tcp; done && firewall-cmd --reload

注意：经过后期实践，发现以上端口没有涵盖Hadoop的所有所需开放端口，最方便的解决方法是暂时关闭防火墙。

前置参考资料

https://dandansad.com/2025/05/22/%e5%ae%89%e8%a3%85hadoop/

Redis常用操作

Sun, 25 May 2025 14:26:00 +0800

通用命令

1. KEYS 
----------------------------------
作用：根据通配符匹配，列出所有符合条件的 key。
示例：
 KEYS user:* # 匹配所有以 user: 开头的 key
返回值：匹配的 key 列表
注意：遍历全库，性能差，**生产环境建议使用 SCAN 命令替代**。

2. DEL [key ...]
----------------------------------
作用：删除一个或多个指定的 key。
示例：
 DEL user:1001 # 删除 key 为 user:1001 的数据
 DEL key1 key2 key3 # 批量删除
返回值：成功删除的 key 数量

3. EXISTS [key ...]
----------------------------------
作用：检查指定的 key 是否存在。
示例：
 EXISTS user:1001 # 判断 user:1001 是否存在
 EXISTS key1 key2 # 多个 key，返回存在的数量
返回值：存在的 key 数量（0 表示全部不存在）

4. EXPIRE 
----------------------------------
作用：为指定的 key 设置过期时间（单位：秒）。
示例：
 EXPIRE user:1001 60 # 设置 user:1001 60 秒后过期
返回值：1 表示设置成功；0 表示 key 不存在或设置失败

5. TTL 
----------------------------------
作用：查看 key 剩余的过期时间（单位：秒）。
示例：
 TTL user:1001
返回值：
 - 正数：剩余秒数
 - -1：key 存在但没有设置过期时间
 - -2：key 不存在

String类型常见命令

1. SET 
----------------------------------
作用：设置指定 key 的字符串值，如果 key 已存在则覆盖。
示例：
 SET user:1001:name "Alice"
返回值：OK（设置成功）

2. GET 
----------------------------------
作用：获取指定 key 的字符串值。
示例：
 GET user:1001:name
返回值：对应的字符串值，或 nil（key 不存在）

3. MSET ...
----------------------------------
作用：同时设置多个 key 的值。
示例：
 MSET a 10 b 20 c 30
返回值：OK（全部设置成功）

4. MGET ...
----------------------------------
作用：同时获取多个 key 的值。
示例：
 MGET a b c
返回值：按顺序返回对应的值，key 不存在则返回 nil

5. INCR 
----------------------------------
作用：将 key 的值加 1（必须是整数），初始值不存在视为 0。
示例：
 INCR counter
返回值：递增后的结果（整数）

6. INCRBY 
----------------------------------
作用：将 key 的值增加指定的整数值。
示例：
 INCRBY score 5
返回值：递增后的结果（整数）

7. INCRBYFLOAT 
----------------------------------
作用：将 key 的值增加指定的浮点数值。
示例：
 INCRBYFLOAT price 1.5
返回值：递增后的结果（浮点数）

8. SETNX 
----------------------------------
作用：当 key 不存在时设置 key 的值（NX = Not eXists）。
示例：
 SETNX lock "1"
返回值：
 - 1：设置成功（key 原本不存在）
 - 0：未设置（key 已存在）

9. SETEX 
----------------------------------
作用：设置 key 的值并同时指定过期时间（秒）。
示例：
 SETEX temp:code 300 "xyz123"
返回值：OK

key的层级格式

Redis 的 key 可以用 : 做分隔符（区分层级），但这只是“命名规范”，实际存储并不是按照层级结构来实现的。

举一个层级结构的例子：项目名:业务名:类型:id

Hash类型常见命令

1. HSET 
----------------------------------
作用：设置哈希表 key 中字段 field 的值。如果字段已存在则覆盖。
示例：
 HSET user:1001 name "Alice"
返回值：
 - 1：新建字段
 - 0：更新已有字段

2. HGET 
----------------------------------
作用：获取哈希表 key 中指定字段的值。
示例：
 HGET user:1001 name
返回值：字段的值，或 nil（字段不存在）

3. HMSET ...
（⚠️ Redis 4.0 起被标记为过时，推荐用 HSET 替代）
----------------------------------
作用：同时设置多个字段的值。
示例：
 HMSET user:1001 name "Alice" age 20
返回值：OK

4. HMGET ...
----------------------------------
作用：同时获取多个字段的值。
示例：
 HMGET user:1001 name age
返回值：按顺序返回字段值，字段不存在返回 nil

5. HGETALL 
----------------------------------
作用：获取哈希表 key 中所有字段和值（键值对形式）。
示例：
 HGETALL user:1001
返回值：一个扁平数组（field1, value1, field2, value2, ...）

6. HKEYS 
----------------------------------
作用：获取哈希表 key 中所有字段（field）。
示例：
 HKEYS user:1001
返回值：字段列表（不包含值）

7. HVALS 
----------------------------------
作用：获取哈希表 key 中所有值（value）。
示例：
 HVALS user:1001
返回值：值的列表（不包含字段）

8. HINCRBY 
----------------------------------
作用：将哈希表 key 中指定字段的整数值加上增量。
示例：
 HINCRBY user:1001 age 1
返回值：递增后的整数值

9. HSETNX 
----------------------------------
作用：仅当字段不存在时设置值（NX = Not eXists）。
示例：
 HSETNX user:1001 age 20
返回值：
 - 1：设置成功（字段不存在）
 - 0：未设置（字段已存在）

List类型常见命令

1. LPUSH [value2 ...]
----------------------------------
作用：将一个或多个元素从左侧推入列表（即头部）。
示例：
 LPUSH mylist a b c # 列表变成 [c, b, a]
返回值：操作后列表的长度

2. LPOP 
----------------------------------
作用：从左侧弹出（移除）并返回列表的第一个元素。
示例：
 LPOP mylist
返回值：被弹出的元素，或 nil（列表为空）

3. RPUSH [value2 ...]
----------------------------------
作用：将一个或多个元素从右侧推入列表（即尾部）。
示例：
 RPUSH mylist x y z # 列表变成 [..., x, y, z]
返回值：操作后列表的长度

4. RPOP 
----------------------------------
作用：从右侧弹出（移除）并返回列表的最后一个元素。
示例：
 RPOP mylist
返回值：被弹出的元素，或 nil（列表为空）

5. LRANGE 
----------------------------------
作用：获取列表指定范围内的元素（闭区间，支持负数索引）。
示例：
 LRANGE mylist 0 2 # 获取索引 0 到 2 的元素
 LRANGE mylist 0 -1 # 获取整个列表
返回值：元素列表

6. BLPOP [key2 ...] 
----------------------------------
作用：从左侧弹出元素，若列表为空则阻塞等待，直到超时或有值。
示例：
 BLPOP mylist 5 # 最多等待 5 秒直到有元素可弹出
返回值：一个包含 [key, value] 的数组，或 nil（超时）

7. BRPOP [key2 ...] 
----------------------------------
作用：从右侧弹出元素，若列表为空则阻塞等待，直到超时或有值。
示例：
 BRPOP mylist 5
返回值：一个包含 [key, value] 的数组，或 nil（超时）

Set类型常见命令

1. SADD [member2 ...]
----------------------------------
作用：向集合添加一个或多个成员（去重，不允许重复元素）。
示例：
 SADD myset a b c
返回值：成功添加的元素数量（已存在的不计入）

2. SREM [member2 ...]
----------------------------------
作用：从集合中移除一个或多个指定成员。
示例：
 SREM myset a b
返回值：成功移除的成员数量

3. SCARD 
----------------------------------
作用：获取集合中元素的数量。
示例：
 SCARD myset
返回值：集合的大小（元素个数）

4. SISMEMBER 
----------------------------------
作用：判断某个值是否是集合的成员。
示例：
 SISMEMBER myset a
返回值：
 - 1：是成员
 - 0：不是成员

5. SMEMBERS 
----------------------------------
作用：返回集合中的所有元素。
示例：
 SMEMBERS myset
返回值：元素列表（无序）

6. SINTER [...]
----------------------------------
作用：返回所有给定集合的交集。
示例：
 SINTER set1 set2
返回值：交集成员列表（仅在两个集合中都存在的元素）

7. SDIFF [...]
----------------------------------
作用：返回在 key1 中但不在其他集合中的元素（差集）。
示例：
 SDIFF set1 set2
返回值：差集成员列表（存在于 set1，但不在 set2 中）

8. SUNION [...]
----------------------------------
作用：返回所有给定集合的并集。
示例：
 SUNION set1 set2
返回值：并集成员列表（所有唯一元素）

SortedSet类型常见命令

1. ZADD [score2 member2 ...]
----------------------------------
作用：向有序集合添加一个或多个成员，并设置分数。
示例：
 ZADD leaderboard 100 user1 200 user2
返回值：成功添加的新成员数量（已存在的更新分数但不计入）

2. ZREM [member2 ...]
----------------------------------
作用：移除一个或多个成员。
示例：
 ZREM leaderboard user1
返回值：成功移除的成员数量

3. ZSCORE 
----------------------------------
作用：获取指定成员的分数。
示例：
 ZSCORE leaderboard user2
返回值：分数（字符串类型），或 nil（成员不存在）

4. ZRANK 
----------------------------------
作用：返回指定成员的排名（从小到大，0 开始）。
示例：
 ZRANK leaderboard user2
返回值：排名索引，或 nil（成员不存在）

5. ZCARD 
----------------------------------
作用：返回有序集合中的成员数量。
示例：
 ZCARD leaderboard
返回值：成员总数

6. ZCOUNT 
----------------------------------
作用：统计分数在指定范围内的成员数量。
示例：
 ZCOUNT leaderboard 100 200
返回值：符合条件的成员数量

7. ZINCRBY 
----------------------------------
作用：为指定成员的分数增加指定值（可为负）。
示例：
 ZINCRBY leaderboard 10 user2
返回值：增加后的分数

8. ZRANGE [WITHSCORES]
----------------------------------
作用：按索引范围获取成员（从低分到高分）。
示例：
 ZRANGE leaderboard 0 2
 ZRANGE leaderboard 0 2 WITHSCORES
返回值：成员列表，或成员+分数列表（如果加了 WITHSCORES）

9. ZRANGEBYSCORE [WITHSCORES]
----------------------------------
作用：按分数范围获取成员（可指定区间范围）。
示例：
 ZRANGEBYSCORE leaderboard 100 200
返回值：符合条件的成员列表，默认按分数升序排列

10. ZINTER ... [AGGREGATE SUM|MIN|MAX]
（Redis 6.2 起支持简化命令：ZINTERSTORE destination key1 key2 ...）
----------------------------------
作用：求多个有序集合的交集，可合并分数。
示例：
 ZINTER 2 zset1 zset2
返回值：交集中成员及其计算后的分数

11. ZDIFF ...
（Redis 6.2+ 支持）
----------------------------------
作用：返回第一个集合中存在、其余集合中不存在的成员。
示例：
 ZDIFF 2 zset1 zset2
返回值：差集成员列表（不含分数）

12. ZUNION ... [AGGREGATE SUM|MIN|MAX]
（Redis 6.2 起支持简化命令：ZUNIONSTORE destination key1 key2 ...）
----------------------------------
作用：求多个有序集合的并集，可合并分数。
示例：
 ZUNION 2 zset1 zset2
返回值：并集中所有成员及其合并分数

NoSQL数据库的四大类型

Sat, 24 May 2025 23:50:37 +0800

什么是NoSQL？

NoSQL 是 “Not Only SQL” 的缩写（起初也有另一种解释为“No SQL”），表示“不仅仅是 SQL”。它泛指一类 非关系型数据库，与传统的关系型数据库（如 MySQL、PostgreSQL）不同，它们通常不使用固定的表结构（没有严格的“表、行、列”模型），而是采用更灵活的数据模型来存储数据。

NoSQL 的设计理念

NoSQL 的出现是为了解决传统关系型数据库在以下几个方面的不足：

可扩展性差：关系型数据库在处理海量数据、分布式存储和高并发时难以扩展。
灵活性不足：数据结构固定（表结构定义死），变更麻烦。
性能瓶颈：对海量数据的读写性能不够友好，尤其是在互联网、大数据场景下。

NoSQL 数据库的目标是更好地支持 高并发访问、大数据存储、灵活的数据结构，常用于互联网公司、分布式系统、大数据处理等领域。

NoSQL数据库的四大类型

1. 键值型（Key-Value Store）

这类数据库把数据存成一对对的“键”和“值”，就像一个超大号的字典或哈希表。你通过 key 查找对应的 value，速度非常快，适合做缓存、会话数据等简单存取操作，但不支持复杂查询。

适用场景：

缓存系统（如 Redis 缓存用户信息）
会话状态存储
配置管理

2. 文档型（Document Store）

文档型数据库把每条记录存成一个结构化的文档（如 JSON），每个文档可以拥有不同的字段，非常灵活。它支持根据文档中的字段进行查询，是 NoSQL 中功能较强、用得最广的一类，常用于 Web 系统、内容管理等场景。

适用场景：

内容管理系统（CMS）
用户资料、日志、评论系统
灵活业务模型（字段常变）

3. 列族型（Column-Family Store）

这类数据库按“列”而不是“行”来存储数据，适合处理大规模结构化数据。每一列族就像一个独立的表，可高效读取某一类数据。它在写入和读取性能上非常出色，常用于大数据分析、日志处理、时间序列数据等。

适用场景：

实时分析（如用户行为记录）
时间序列数据
日志和传感器数据存储

4. 图数据库（Graph Database）

图数据库使用“节点”和“边”来表示数据及其关系，非常适合处理复杂的网络关系，比如社交网络、推荐系统等。它能快速进行“找朋友的朋友”这种关系链查询，是建模复杂关系结构的利器。

适用场景：

社交网络、推荐系统
知识图谱
网络拓扑分析、安全风控

对比表

类型	数据模型	优势	缺点	示例
键值型	Key-Value	极致性能，简单易用	只能按 key 查	Redis, DynamoDB
文档型	JSON/BSON 文档	灵活结构，支持查询	不支持多文档事务、JOIN	MongoDB, CouchDB
列族型	表 + 列簇	适合海量数据分析	学习曲线高，调优复杂	Cassandra, HBase
图数据库	节点 + 边	关系建模强、查询高效	不适合无关系数据	Neo4j, ArangoDB

NoSQL vs SQL 对比

特性	NoSQL	SQL（关系型数据库）
数据结构	灵活（文档、键值、图等）	表结构，模式固定
可扩展性	易水平扩展（分布式）	多为垂直扩展
事务支持	一般不强制支持 ACID	严格支持 ACID
查询语言	没有统一标准，通常基于 API	使用标准 SQL
适用场景	海量数据、高并发、动态数据结构	数据一致性强、结构清晰场景
常见代表	MongoDB、Redis、Cassandra等	MySQL、PostgreSQL、Oracle等

NoSQL 的应用场景

社交网络系统（用户关系、动态结构）
实时分析（大数据场景下的读写性能）
内容管理系统（CMS）
缓存系统（如 Redis）
日志、传感器、监控数据存储（时序数据）

访问控制策略

Thu, 08 May 2025 14:32:12 +0800

1. DAC（Discretionary Access Control）

自主访问控制

核心特点：

资源拥有者决定权限：用户对其拥有的资源（如文件）有控制权，可以授予或撤销他人的访问权限。
权限可继承/传播：被授权的用户可以继续把权限授予其他用户（这可能导致“权限扩散”）。

举例：

用户 A 拥有一个文件 file.txt，他设置权限让用户 B 也能读取它。
用户 B 如果有权，也可以把这个文件分享给用户 C。

类似系统：

类 Unix 的系统默认使用 DAC，通过 chmod、chown 控制文件权限。

2. MAC（Mandatory Access Control）

强制访问控制

核心特点：

系统控制访问权限：用户无权修改自己的资源权限，所有访问规则由系统策略统一定义。
基于安全标签（level）：对象（资源）和主体（用户）都有安全级别，比如“机密”、“受限”、“公开”，系统强制根据这些级别控制访问。

举例：

一个“秘密”级别的文件只有“秘密”级别或更高级别的用户才能访问，不能随意共享。
用户即使拥有文件，也无法更改其访问权限。

类似系统：

SELinux（Security-Enhanced Linux）
AppArmor（Ubuntu 上使用）这些系统就使用了 MAC 模型。

3. RBAC（Role-Based Access Control）

基于角色的访问控制

核心特点：

以“角色”为中心：权限分配给“角色”，用户根据其角色获得权限。
灵活、集中管理：适合组织结构复杂、职责分明的环境。

举例：

角色“管理员”拥有系统配置权限；角色“用户”只能读写自己的数据。
用户 A 被分配为“管理员”，系统自动赋予所有“管理员”权限。

类似系统：

多数企业应用和身份管理系统（如 Active Directory、Kubernetes、数据库权限管理）使用 RBAC。

4. TBAC（Task-Based Access Control）

基于任务的访问控制

核心特点：

权限与具体任务绑定，而不是与用户或角色绑定。
用户只有在执行某个“已授权任务”时，才能获得所需权限。
强调“动态激活权限”，避免静态分配带来的过度权限问题。

举例：

某人是“医生”角色，但只有在处理某个病人的病历任务时，才能访问该病历。
执行完任务后，权限自动撤销。

应用场景：

工作流系统、审批系统、临时授权操作（如 DevOps 自动化脚本）

5. OBAC（Object-Based Access Control）

基于对象的访问控制

核心特点：

访问控制依赖对象本身的属性和策略。
不看用户或角色，看“对象是否允许某类用户访问”。

举例：

一个文件设置了“仅允许创建者和其直属上级访问”，访问控制规则写在对象的元数据或策略中。
不依赖用户的角色或任务，只要对象规则允许，就能访问。

应用场景：

微服务架构、面向对象系统、基于资源策略的授权系统（如某些云平台）

总结对比表：

模型	控制基础	权限分配方式	粒度	动态性	上下文感知	安全性	灵活性	常见场景/系统
DAC	用户（资源拥有者）	手动分配	中	静态	低	低	高	Unix/Linux 文件系统、用户共享
MAC	系统策略/安全标签	统一策略控制	高	静态	中	很高	低	SELinux、军事系统、政府保密系统
RBAC	用户角色	基于角色分配	中	静态	中	高	中	企业权限管理、数据库、Kubernetes
TBAC	当前执行任务	任务自动授权	高	动态	高	高	中	工作流系统、临时任务授权、自动化系统
OBAC	对象自身策略	对象定义控制策略	非常高	动态或静态	高	高	高	云服务（如 AWS IAM）、微服务资源管理

三种 FreeRTOS 通信方式

Tue, 06 May 2025 21:21:12 +0800

在嵌入式系统中，任务之间的通信是实现并发、同步和资源共享的关键。FreeRTOS 提供了多种通信机制，以满足不同的应用场景和性能要求。本文将重点介绍三种常用的通信方式：消息队列（Queue）、邮箱（Semaphore）和任务通知（Task Notification），并通过代码示例分析其适用场景和使用方法。

一、消息队列（Queue）

概述

消息队列用于在任务之间传递消息或数据。它可以存储多个数据项，常用于任务与任务、中断与任务之间的通信，适合需要“带数据”传递的情况。

使用场景

按钮中断向任务传递事件编号
任务间传输传感器值、指令等

示例代码

// 定义一个整型队列
QueueHandle_t my_queue;

// 初始化队列，容量为10，每个元素是int类型
my_queue = xQueueCreate(10, sizeof(int));

// 消费者任务：从队列接收数据
void consumer_task(void *arg) {
 int received_data;
 while (1) {
 if (xQueueReceive(my_queue, &received_data, portMAX_DELAY)) {
 printf("Received value: %d\n", received_data);
 // 在此处理数据
 }
 }
}

// 中断服务程序：向队列发送数据
void EXTI_IRQHandler(void) {
 int data = 42;
 BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 xQueueSendFromISR(my_queue, &data, &xHigherPriorityTaskWoken);
 portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

特点

✅ 可传递任意数据类型
✅ 可用于任务与中断间通信
❌ 内存开销略大
❌ 比任务通知慢一些

二、邮箱（Semaphore）

概述

邮箱本质上是一种二值信号量，主要用于任务同步，不承载数据。它常被用作“任务启动信号”或“事件通知”，而非传输数据。

使用场景

通知任务“有事情要做了”，但不传递数据
中断触发任务启动

示例代码

// 创建一个二值信号量
SemaphoreHandle_t binary_semaphore;

// 初始化
binary_semaphore = xSemaphoreCreateBinary();

// 任务：等待信号量
void led_task(void *arg) {
 while (1) {
 if (xSemaphoreTake(binary_semaphore, portMAX_DELAY)) {
 printf("Button pressed, toggle LED.\n");
 // 翻转 LED 状态
 }
 }
}

// 中断服务程序：发送信号量
void button_isr(void) {
 BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 xSemaphoreGiveFromISR(binary_semaphore, &xHigherPriorityTaskWoken);
 portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

特点

✅ 简单高效
✅ 适合事件同步（不含数据）
❌ 无法携带数据
✅ 支持中断触发

三、任务通知（Task Notification）

概述

任务通知是 FreeRTOS 中一种轻量级的任务间通信机制，每个任务有一个 32 位的“通知值”，可以在任务之间或中断中更新和读取。它支持传递一个整数值，效率高，是性能最优的通信方式。

使用场景

单一任务之间快速通信
按钮等中断触发简单事件通知
替代低开销信号量和队列

示例代码

// 假设我们已经获得任务句柄 task_handle

// 任务：等待通知
void notify_task(void *arg) {
 uint32_t value;
 while (1) {
 // 阻塞等待通知，并获取通知值
 if (xTaskNotifyWait(0, 0, &value, portMAX_DELAY)) {
 printf("Received notify value: %lu\n", value);
 // 响应事件
 }
 }
}

// 中断服务程序：发送通知
void notify_isr(void) {
 BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 xTaskNotifyFromISR(task_handle, 1, eSetValueWithOverwrite, &xHigherPriorityTaskWoken);
 portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

特点

✅ 传输单个整数值
✅ 效率最高、开销最小
❌ 每个任务只能有一个通知槽位
✅ 适合中断触发事件通知

四、总结对比

特性	消息队列	邮箱（信号量）	任务通知
是否传递数据	✅ 是（任意类型）	❌ 否（仅通知）	✅ 是（单个整数）
是否支持中断调用	✅ 是	✅ 是	✅ 是
通信效率	中	高	最高
资源开销	较大（占用内存）	小	最小（无堆内存）
多对一通信支持	✅ 支持（多个任务写入）	✅ 支持	❌ 单槽位，需注意覆盖
典型使用场景	传输数据、任务调度	同步任务、事件触发	快速事件触发、ISR通信

算法设计与分析：要点总结-3

Mon, 28 Apr 2025 10:11:52 +0800

贪婪算法（Greedy Algorithm）

1. 基本思想

每一步都做当前看来最优的选择（即局部最优），希望通过一系列局部最优，达到整体最优。
特点是只顾眼前（每次选择最优），不回溯。

2. 贪婪问题分类

绝对贪婪问题：

每一步的局部最优选择，最终一定得到全局最优解。

例子：活动安排问题、最小生成树问题。
相对贪婪问题：

贪婪算法得到的解不是全局最优，但通常是一个近似最优（有时足够好了）。

例子：一些NP问题的贪婪近似，比如旅行商问题的贪婪解。

贪婪算法与问题复杂性

P问题：可以在多项式时间内求解的问题（即存在有效算法）。
NP问题：能在多项式时间内验证一个解是否正确，但不一定能快速求解。
贪婪算法通常用于P问题或NP问题的近似解。
有效算法：

运行时间是问题规模的多项式函数，比如 O(n^2), O(nlog⁡n)。

相对的，指数时间 O(2^n)算法就不是有效算法。

经典例题

1. 工资分发问题（类似找零问题）

题意：用最少数量的钱币发工资。
解法：每次选面额最大且不超过剩余金额的钱币。
注意：有些面额组合下贪心策略不一定最优（比如奇怪的硬币系统）。

2. 活动安排问题

题意：给定若干活动，每个活动有开始、结束时间，要求安排最多不重叠活动。
贪心策略：优先选结束时间最早的活动。

3. 多机调度问题

题意：n个任务分配到k台机器，使得最晚完成时间最早。
贪心策略：每次将任务分配到当前负载最轻的机器上。

重要贪婪算法

1. Huffman树构造（最优编码问题）

题意：给定字符及其出现频率，设计编码使总编码长度最短。
方法：

每次选取出现频率最小的两个节点合并。

最后生成哈夫曼树。

2. 单源最短路径：Dijkstra算法

适用于边权非负的图。
思路：

维护一张最短距离表。

每次选取当前未访问、距离源点最短的点，更新它的邻居。

3. 最小生成树

Prim算法：

从任意点开始，逐步将最近的点连入生成树。

Kruskal算法：

把边按权值从小到大排序，逐条选边，如果不会成环就加入生成树。

用并查集快速判断成环。

ActiveMQ-Exercise

Mon, 21 Apr 2025 23:26:38 +0800

项目理解

一个使用了ActiveMQ消息队列的订单-物流系统，两个系统之间通过消息队列来通信，主要有order.created.queue和logistics.updated.queue两个消息队列。

order.created.queue是一个订单创建消息队列。当新订单创建时，系统会将订单信息发送到此队列，通知其他系统或者服务去处理与该订单相关的后续操作。

logistics.updated.queue是一个物流更新消息队列。当订单的物流信息发生更新（比如订单发货、配送进度等）时，系统会将物流信息发送到此队列，通知其他系统或者服务更新或处理订单的物流状态。

消息队列在这个场景中充当了异步通信机制，不是传统意义上的“推送通知”（比如给用户发送消息），而是指在系统内部，消息队列作为一种通信机制，允许服务之间通过异步消息交换来实现解耦。队列本身不会主动“传递”消息给目标服务，而是由目标服务去监听这个队列，然后被动拉取新消息进行处理。

ActiveMQ-Exercise/
├── README.md # 项目说明文档，描述项目的目的、使用方法等
├── common # 公共模块，包含多个共享的类、配置、DTO等
│ ├── pom.xml # 公共模块的Maven配置文件
│ ├── src
│ │ └── main
│ │ └── java
│ │ └── com
│ │ └── example
│ │ └── common
│ │ ├── config
│ │ │ ├── ActiveMQConfig.java # ActiveMQ配置，连接消息队列
│ │ │ └── JmsConverterConfig.java # JMS消息转换器配置
│ │ ├── constants
│ │ │ └── JmsConstants.java # 定义常量，如消息队列的名称等
│ │ ├── dto
│ │ │ ├── LogisticsOrderDTO.java # 物流订单DTO
│ │ │ ├── LogisticsUpdateDTO.java # 物流更新DTO
│ │ │ └── OrderDTO.java # 订单DTO
│ │ ├── model
│ │ │ └── OrderStatus.java # 订单状态枚举类
│ │ └── util
│ │ └── EntityDtoConverter.java # 实体类与DTO类的转换工具类
├── logistics-system # 物流系统模块
│ ├── logistics-system.iml # IntelliJ IDEA项目文件
│ ├── pom.xml # 物流系统模块的Maven配置文件
│ └── src
│ └── main
│ └── java
│ └── com
│ └── example
│ └── logistics
│ ├── LogisticsSystemApplication.java # 物流系统启动类
│ ├── config
│ │ └── JacksonConfig.java # 配置Jackson，处理JSON序列化和反序列化
│ ├── controller
│ │ └── LogisticsController.java # 处理物流订单的控制器
│ ├── entity
│ │ ├── LogisticsOrder.java # 物流订单实体类
│ │ └── LogisticsOrderItem.java # 物流订单项实体类
│ ├── listener
│ │ └── OrderCreatedListener.java # 监听新订单创建的事件
│ ├── repository
│ │ └── LogisticsOrderRepository.java # 物流订单的数据库操作接口
│ └── service
│ ├── LogisticsService.java # 物流服务接口
│ └── impl
│ └── LogisticsServiceImpl.java # 物流服务实现类
│ └── resources
│ ├── application-local.properties # 本地配置文件，包含数据库、消息队列等配置
│ ├── application.properties # 默认配置文件
│ ├── static
│ │ └── css
│ │ └── apple-style.css # CSS样式文件
│ └── templates
│ └── logistics
│ ├── list.html # 物流订单列表页面
│ └── shipped.html # 物流订单已发货页面
├── order-system # 订单系统模块
│ ├── pom.xml # 订单系统模块的Maven配置文件
│ └── src
│ └── main
│ └── java
│ └── com
│ └── example
│ └── order
│ ├── OrderSystemApplication.java # 订单系统启动类
│ ├── controller
│ │ └── OrderController.java # 处理订单的控制器
│ ├── entity
│ │ ├── Order.java # 订单实体类
│ │ └── OrderItem.java # 订单项实体类
│ ├── listener
│ │ └── LogisticsUpdateListener.java # 监听物流更新事件
│ ├── repository
│ │ └── OrderRepository.java # 订单数据库操作接口
│ └── service
│ ├── OrderService.java # 订单服务接口
│ └── impl
│ └── OrderServiceImpl.java # 订单服务实现类
│ └── resources
│ ├── application-local.properties # 本地配置文件
│ ├── application.properties # 默认配置文件
│ ├── static
│ │ └── css
│ │ └── apple-style.css # CSS样式文件
│ └── templates
│ └── order
│ ├── create.html # 创建订单页面
│ └── list.html # 订单列表页面
└── pom.xml # 根目录的Maven配置文件，管理依赖和构建配置

在本项目中，消息队列的作用可以概括为：订单系统在用户创建订单后，通过 Controller 层的业务逻辑将订单信息封装为消息发送到 ActiveMQ 队列中（如 order.created.queue），而物流系统则通过监听器持续监听该队列，一旦接收到新消息，立即触发对应的处理逻辑（如入库、更新状态等）。这一过程实现了服务之间的解耦，使得各模块可以异步通信、独立扩展，提高了系统的可靠性与可维护性。

[订单系统前端] --> [OrderController] --> [JmsTemplate 发送消息到 MQ]
 ↓
 [ActiveMQ 消息队列: order.created.queue]
 ↓
 [物流系统 OrderCreatedListener 自动监听并处理消息]

接触到的新技术

技术 / 框架	作用说明	项目中的使用示例
Spring Boot	简化配置和启动流程，快速构建微服务项目	构建订单系统和物流系统两个独立的 Spring Boot 服务
Spring JPA (Hibernate)	简化数据库操作，基于实体类自动生成数据库表及 SQL	使用 JpaRepository 快速实现订单、物流数据的增删改查
ActiveMQ（JMS）	实现系统间异步通信，消息解耦	用于订单系统与物流系统之间通过消息队列进行数据传递
JmsTemplate / @JmsListener	发送和监听消息的核心工具	OrderServiceImpl 中发送消息，OrderCreatedListener 中接收并处理
H2 内存数据库	用于开发测试的轻量级数据库，启动即用	默认配置存储订单与物流信息，无需手动创建数据库
Jackson 配置自定义 ObjectMapper	处理 JSON 与对象间的序列化、反序列化，尤其是日期格式等	在 JacksonConfig.java 中配置 JavaTimeModule 支持时间类型
DTO（数据传输对象）设计	实体与传输对象分离，增强系统灵活性与安全性	使用 OrderDTO、LogisticsOrderDTO 进行跨系统数据传输
Thymeleaf 模板引擎	用于前端展示，结合 Spring MVC 渲染页面	项目中如 order/list.html、logistics/list.html 等模板
Lombok（@Data、@Slf4j、@RequiredArgsConstructor）	简化 Java 代码的开发，自动生成 getter/setter 等	提高开发效率，减少模板代码，如实体类、服务类中大量使用
多模块 Maven 工程结构	实现模块复用和结构清晰，便于维护	common 模块抽象公共部分，order-system 和 logistics-system 各自独立
@ConditionalOnProperty（Spring Boot）	条件注解，只有在配置文件中某个属性满足特定值时，才会启用对应的配置类或Bean。	当 application.properties 中 jms.implementation=spring，或者该属性缺失（matchIfMissing=true）时，启用当前Bean或配置。

后续新增

后续新增了底层JMS API的使用方法。

✅ 点对点模型（Queue）

📤 生产者代码（QueueProducer.java）

import javax.jms.*;
import org.apache.activemq.ActiveMQConnectionFactory;

public class QueueProducer {
 public static void main(String[] args) throws JMSException {
 // 创建连接工厂，连接到ActiveMQ服务器
 ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
 
 // 创建连接
 Connection connection = factory.createConnection();
 
 // 创建会话（不使用事务，自动确认消息）
 Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
 
 // 创建一个队列（Queue）目的地
 Queue queue = session.createQueue("myQueue");
 
 // 创建生产者，发送到指定队列
 MessageProducer producer = session.createProducer(queue);
 
 // 创建一条文本消息
 TextMessage message = session.createTextMessage("Hello from QueueProducer!");
 
 // 发送消息
 producer.send(message);
 
 // 输出发送内容
 System.out.println("Sent message: " + message.getText());

 // 关闭资源
 session.close();
 connection.close();
 }
}

📥 消费者代码（QueueConsumer.java）

import javax.jms.*;
import org.apache.activemq.ActiveMQConnectionFactory;

public class QueueConsumer {
 public static void main(String[] args) throws JMSException {
 // 创建连接工厂
 ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
 
 // 创建连接
 Connection connection = factory.createConnection();
 connection.start(); // 启动连接，消费者必须先启动才能接收消息
 
 // 创建会话（不使用事务，自动确认消息）
 Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
 
 // 创建队列（与生产者的队列名称必须一致）
 Queue queue = session.createQueue("myQueue");
 
 // 创建消费者，从队列接收消息
 MessageConsumer consumer = session.createConsumer(queue);
 
 // 接收消息（这是一个阻塞方法，直到接收到消息为止）
 Message message = consumer.receive();
 
 // 判断消息类型并打印内容
 if (message instanceof TextMessage) {
 System.out.println("Received: " + ((TextMessage) message).getText());
 }

 // 关闭资源
 session.close();
 connection.close();
 }
}

✅ 发布/订阅模型（Topic）

📢 发布者代码（TopicPublisher.java）

import javax.jms.*;
import org.apache.activemq.ActiveMQConnectionFactory;

public class TopicPublisher {
 public static void main(String[] args) throws JMSException {
 // 创建连接工厂
 ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
 
 // 创建连接
 Connection connection = factory.createConnection();
 
 // 创建会话
 Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
 
 // 创建主题（Topic）目的地
 Topic topic = session.createTopic("myTopic");
 
 // 创建消息发布者
 MessageProducer producer = session.createProducer(topic);
 
 // 创建文本消息
 TextMessage message = session.createTextMessage("Hello from TopicPublisher!");
 
 // 发布消息到主题
 producer.send(message);

 // 打印消息内容
 System.out.println("Published message: " + message.getText());

 // 关闭资源
 session.close();
 connection.close();
 }
}

📡 订阅者代码（TopicSubscriber.java）

import javax.jms.*;
import org.apache.activemq.ActiveMQConnectionFactory;

public class TopicSubscriber {
 public static void main(String[] args) throws JMSException {
 // 创建连接工厂
 ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
 
 // 创建连接
 Connection connection = factory.createConnection();
 
 // 为连接设置客户端 ID（用于持久订阅）
 connection.setClientID("client1");
 
 // 启动连接，必须启动后才能接收消息
 connection.start();
 
 // 创建会话
 Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
 
 // 创建主题（Topic）
 Topic topic = session.createTopic("myTopic");
 
 // 创建订阅者（普通订阅；如果你想要持久订阅，请使用 `createDurableSubscriber`）
 MessageConsumer consumer = session.createConsumer(topic);
 
 // 接收消息
 Message message = consumer.receive();
 
 // 打印消息内容
 if (message instanceof TextMessage) {
 System.out.println("Received: " + ((TextMessage) message).getText());
 }

 // 关闭资源
 session.close();
 connection.close();
 }
}

算法设计与分析：要点总结-2

Mon, 21 Apr 2025 00:36:48 +0800

分治算法

分治思想：分治算法是一种将一个复杂问题分解成多个较小的子问题，通过递归解决子问题，再将子问题的解合并起来，得到原问题的解。分治思想的核心是通过将问题规模减小、分解和组合来简化问题的解决。

分治算法的基本步骤：

分解：将问题划分为多个规模较小、结构与原问题类似的子问题。
解决：递归地解决这些子问题，当子问题的规模足够小或问题简单时，可以直接求解。
合并：将子问题的解合并成原问题的解。

减治算法：减治算法是分治算法的一种特殊形式，它也将问题分解成多个子问题，但在减治算法中，通常没有合并步骤。每次递归都是通过缩小问题规模来直接逼近解决方案，典型的例子是 归纳法 和 动态规划。

二分法

什么是二分法：二分法是一种通过将问题的解空间不断对半分割，逐步缩小搜索范围的算法。通常用来解决有序数据的查找问题。二分法的典型例子是 二分查找，其基本思想是通过比较目标值和中间元素来决定查找区间，逐步缩小查找范围。

二分法变异：二分法变异是对传统二分法的扩展或修改，常见的变异包括：

变异1：处理不完全有序的情况（例如，寻找最左或最右的目标元素）。
变异2：用于解决更复杂的决策问题，比如 最小最大值问题 或 区间问题。

为什么需要变异二分法：传统二分法只适用于简单的查找问题，但在实际应用中，经常遇到更复杂的情况，如：

查找某个值的最左或最右位置。
求解某个条件成立的最小/最大值。
寻找某个阈值条件下的解空间。

这些问题需要对标准二分法进行适当变异，以适应更复杂的需求。

重要例题

金块问题：

问题：给定一个二维矩阵，其中每个位置都有金块，如何找到从左上角到右下角的最大金块数？你可以在矩阵中上下左右移动。

引出结论：通过分治，将问题分解成子问题，利用动态规划的思想来求解最大值。
残缺棋盘问题：

问题：给定一个 2^n x 2^n 的棋盘，其中一个小方块被去除，如何将其余部分覆盖上 L 型小块？

引出结论：这是一道典型的分治问题，通过递归分割棋盘并覆盖，可以有效地解决。
循环赛日程表：

问题：有 n 个队伍，如何安排一个循环赛程，使得每个队伍与其他队伍比赛一次？

引出结论：通过分治，将问题划分为较小的子问题，求解比赛安排。
最大子段和问题：

问题：给定一个整数数组，求出其中和最大的连续子数组。

引出结论：这道题目可以通过分治的方式进行求解，分解成较小的子问题，最终合并求得最大子段和。

重要算法

冒泡排序

时间复杂度：O(n^2)
空间复杂度：O(1)
特点：通过多次遍历，将最大（或最小）元素“冒泡”到数组的一端。适合小规模数据。

def bubble_sort(arr):
 n = len(arr)
 for i in range(n):
 for j in range(0, n-i-1):
 if arr[j] > arr[j+1]:
 arr[j], arr[j+1] = arr[j+1], arr[j]
 return arr

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("冒泡排序结果:", bubble_sort(arr))

插入排序

时间复杂度：O(n^2)
空间复杂度：O(1)
特点：通过从未排序的部分插入元素到已排序部分，逐步扩大已排序部分。

def insertion_sort(arr):
 for i in range(1, len(arr)):
 key = arr[i]
 j = i - 1
 while j >= 0 and arr[j] > key:
 arr[j + 1] = arr[j]
 j -= 1
 arr[j + 1] = key
 return arr

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("插入排序结果:", insertion_sort(arr))

快速排序

时间复杂度：O(n log n)（平均），O(n^2)（最坏）
空间复杂度：O(log n)（平均）
特点：通过选择一个基准元素，将数组分为两个部分，递归地对每个部分进行排序。效率较高。

def quick_sort(arr):
 if len(arr) pivot]
 return quick_sort(left) + middle + quick_sort(right)

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("快速排序结果:", quick_sort(arr))

归并排序

时间复杂度：O(n log n)
空间复杂度：O(n)
特点：通过递归地将数组分成两个子数组，然后合并排序。稳定且适用于大规模数据。

def merge_sort(arr):
 if len(arr) > 1:
 mid = len(arr) // 2
 left_half = arr[:mid]
 right_half = arr[mid:]

 merge_sort(left_half)
 merge_sort(right_half)

 i = j = k = 0
 while i < len(left_half) and j < len(right_half):
 if left_half[i] < right_half[j]:
 arr[k] = left_half[i]
 i += 1
 else:
 arr[k] = right_half[j]
 j += 1
 k += 1

 while i < len(left_half):
 arr[k] = left_half[i]
 i += 1
 k += 1

 while j < len(right_half):
 arr[k] = right_half[j]
 j += 1
 k += 1
 return arr

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("归并排序结果:", merge_sort(arr))

spring-demo

Fri, 11 Apr 2025 00:46:25 +0800

一个Spring的AOP练习程序。

\---springdemo
 │ SpringDemoApplication.java
 │ 
 ├─aop
 │ MyAspect.java
 │ 
 ├─controller
 │ Test.java
 │
 └─service
 Another.java

对于Spring来说，其AOP的实现十分简单。只需要在导入相关依赖之后在注解类上使用@Aspect和@Component注解，然后使用@Pointcut定义切点，在相关方法上用你需要的AOP通知类型注解即可。

RMI-Exercise

Fri, 11 Apr 2025 00:37:35 +0800

Java RMI，即 远程方法调用（Remote Method Invocation），它的实现依赖于Java虚拟机(JVM)，RMI允许在一个Java虚拟机中运行的对象调用在另一个Java虚拟机中运行的对象上的方法。RMI是Java的一组拥护开发分布式应用程序的API，RMI使用Java语言接口定义了远程对象，它集合了Java序列化和Java远程方法协议(Java Remote Method Protocol)，RMI能直接传输序列化后的Java对象和分布式垃圾收集，因此它仅支持从一个JVM到另一个JVM的调用。RMI提供了用Java编程语言编写的程序之间的远程通信。

这是一个RMI（Remote Method Invocation）远程方法调用的练习程序。

\--rmi
 RemoteService.java
 RMIClient.java
 RMIServer.java
 RMIService.java

RemoteService.java

一个远程接口文件，它定义了可以被远程调用的方法。

RMIService.java

远程服务的实现类。继承了UnicastRemoteObject类，这是RMI中实现远程对象的基类。实现了RemoteService接口，提供了run()方法的具体实现

RMIClient.java

RMI客户端程序。定义了与服务器相同的注册表端口(9999)、主机(localhost)和服务URL。在main方法中使用Naming.lookup查找远程服务对象，将返回的对象强制转换为RemoteService接口类型，然后调用远程服务的run()方法。

RMIServer.java

RMI服务器程序。定义了RMI注册表端口(9999)、主机(localhost)和服务URL。在main方法中创建RMIService实例作为远程服务实现，然后使用LocateRegistry.createRegistry创建RMI注册表，并使用Naming.rebind将远程服务绑定到命名服务。

总结

RMI的实现较为简单便捷，只需要在服务端创建实例、创建注册表、绑定远程服务到命名服务即可。在客户端使用Naming.lookup查找远程服务对象，将返回的对象强制转换为RemoteService接口类型即可直接调用。

RMI本质上只传输方法调用的参数和返回值。当你在远程对象的方法中执行System.out.println()时，这些输出会打印在远程JVM的终端/日志中，而不是调用方的控制台。这是因为System.out是本地进程的标准输出流，与RMI调用无关。

AOP-Exercise

Thu, 10 Apr 2025 22:19:28 +0800

一个面向切面编程的练习程序。其中面向切面编程采用的是配置文件的做法，支持多个前置方法和后置方法，按照配置文件中的优先级区分执行顺序。食物类通过注解获取食物名称和价格。

\--aop
 │ FoodInfo.java
 │ Kitchen.java
 │ MyAspect.java
 │ Proxyhandler.java
 │ Restaurant.java
 │ RestaurantInterface.java
 │ TestRestaurant.java
 │
 └─foods
 Beef.java
 Broccoli.java
 Chicken.java
 Food.java
 Newfood.java

foods包下的类

食物类，其中食物名称和价格用注解标注。

FoodInfo.java

注解，食物名称和价格。

Kitchen.java

工厂类，主要负责根据名称创建食物实例、获取食物价格。

MyAspect.java

切面方法。

Proxyhandler.java

调用处理器类，在其中实现面向切面编程，在需要切入的方法前后分别按照优先级执行前置方法和后置方法。

Restaurant.java

RestaurantInterface的实现类，实现餐厅的方法。

RestaurantInterface.java

接口，定义餐厅的方法。

TestRestaurant.java

主类，完成点餐功能。在开始时读入并加载配置文件，创建动态代理对象，之后执行正常的点餐流程，当用户点餐时调用Kitchen创建食物类，下单并享用食物。

总结

这个程序主要使用动态代理实现了AOP，从配置文件中读取前置方法和后置方法。

RPC-Exercise

Thu, 10 Apr 2025 20:24:07 +0800

一个RPC（Remote Procedure Call）远程过程调用的练习程序。

\---client
 Client.java
 Connector.java
 DynamicProxyFactory.java
 RemoteCall.java
 RPCService.java
 RPCServiceImpl.java
 Server.java

RemoteCall.java

是一个用于传输的对象。它是RPC（远程过程调用）系统中非常关键的一个组件，负责封装远程方法调用的所有必要信息。

RPCService.java

一个接口，定义request方法。

RPCServiceImpl.java

RPCService的实现类，实现request方法。

Client.java

客户端，调用DynamicProxyFactory.getProxy返回动态代理对象，从而进行远程调用。

Connector.java

协助客户端与服务器之间通信的通信工具类，主要包括建立网络连接、数据传输、连接管理。

DynamicProxyFactory.java

用于创建客户端的动态代理对象。主要功能就是隐藏了网络通信细节，将方法调用转换为网络请求。返回进行远程调用的动态代理。

Server.java

服务端，用于接收客户端请求、执行本地服务实现的方法并返回结果。首先监听指定端口，然后注册服务，再启动服务。在服务运行的过程中不断接到连接请求，接到连接请求后便开启新线程处理请求。

总结

实现远程过程调用主要就是使用动态代理对象，让其看起来像切切实实的本地方法，但实际是隐藏了网络通信细节，将方法调用转换为网络请求，从而获取到远程调用的结果。服务端只需要不断地监听端口，处理请求并返回RemoteCall对象即可。

Proxy-Exercise

Thu, 10 Apr 2025 10:33:01 +0800

在代理模式中，我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

\---demo
 DynamicProxyDemo.java
 OneService.java
 Service.java
 StaticProxyDemo.java
 TwoService.java

Service.java

接口，提供perform()方法。

OneService.java

实现类，实现perform()方法。

TwoService.java

实现类，实现perform()方法。

StaticProxyDemo.java（静态代理）

静态代理，里面有一个ServiceProxy类，在该类中也重写了perform()方法。在perform()方法中，调用了真实对象的perform()方法，同时新增了一些操作。

但是静态代理有个缺点：一个真实对象要对应一个静态代理对象，代码编写十分繁琐。

DynamicProxyDemo.java（动态代理）

动态代理，创建实现InvocationHandler接口的类，再通过Proxy.newProxyInstance方法创建代理对象，之后便可以通过代理对象调用perform方法。

区别

静态代理需要为每个接口创建代理类，并为每个方法编写代理逻辑，这会导致大量的重复代码。在实际开发中，当涉及到多个类和方法需要类似的代理逻辑时，通过动态代理来实现通常是更好的选择。动态代理通过创建调用处理器（InvocationHandler）、创建代理实例（Proxy.newProxyInstance），然后便可以直接调用代理方法。

算法设计与分析：要点总结-1

Mon, 31 Mar 2025 01:48:48 +0800

算法概述

算法的5大特性

确定性:算法的每一步骤必须有明确的定义，无二义性。即在相同输入下，每次执行都应得到相同的结果。
能行性:算法的每一步都必须是可实现的，即在有限时间内能用有限资源完成。
输入：算法可以有零个或多个输入，输入是算法处理的初始数据。
输出：算法必须有一个或多个输出，输出是算法处理的结果。
有穷性/有限性：算法必须在执行有限步骤后终止，不能无限循环。

算法与计算过程的区别

计算过程可能无限执行（如操作系统），而算法必须是有穷的。

算法描述的主要语言

自然语言：直观但容易歧义。
伪代码：介于自然语言和编程语言之间，结构清晰，无语法限制。
流程图：图形化表示，直观展示控制流。
编程语言：直接实现，但需关注语法细节。

渐进表示

定义

O（大O符号，上界）： f(n)=O(g(n)) 表示存在常数 c>0 和 n0，使得对所有 n≥n0，有 f(n)≤c⋅g(n)。

表示算法的最坏情况时间复杂度。

Ω（Omega，下界）： f(n)=Ω(g(n)) 表示存在常数 c>0 和 n0，使得对所有 n≥n0，有 f(n)≥c⋅g(n)。

表示算法的最好情况时间复杂度。

Θ（Theta，紧确界）： f(n)=Θ(g(n)) 当且仅当 f(n)=O(g(n)) 且 f(n)=Ω(g(n))。

表示算法的平均情况时间复杂度。

多项式定理

若 f(n) 是 d 次多项式，则 f(n)=Θ(n**d)。

常见的多项式/指数限界函数

O(1) < O(logn) < O(n) < O(nlogn) < O(n2) < O(n3) < O(2n) < O(n!) < O(nn)

渐进符号O运算性质

传递性：若 f(n)=O(g(n)) 且 g(n)=O(h(n))，则 f(n)=O(h(n))。
加法规则：O(f(n))+O(g(n))=O(max⁡(f(n),g(n)))。
乘法规则：O(f(n))⋅O(g(n))=O(f(n)⋅g(n))。

重要例题

冒泡排序

def bubble_sort(arr):
 n = len(arr)
 for i in range(n):
 for j in range(0, n-i-1):
 if arr[j] > arr[j+1]:
 arr[j], arr[j+1] = arr[j+1], arr[j]
 return arr

# 示例
print(bubble_sort([64, 34, 25, 12, 22, 11, 90])) # 输出: [11, 12, 22, 25, 34, 64, 90]

警察抓小偷

信息数字化。

竞赛预测

信息数字化。将逻辑问题转化为代码，遍历求解。

楼梯台阶问题

def climb_stairs(n):
 if n 
- **基准情形**：明确递归终止条件（如 n=0 或 n=1）。

- **递归调用**：将问题分解为更小的同类子问题。

- **正确性证明**：通常用数学归纳法验证。

### 循环与递归的比较

| 比较维度 | 循环（迭代） | 递归 |
| --- | --- | --- |
| 程序可读性 | 通常更直观，适合线性逻辑（如遍历数组）。 | 更符合数学思维，适合分治、树/图遍历等问题，但嵌套过深时难理解。 |
| 代码量 | 通常较短，尤其是简单循环（如 for、while）。 | 可能更简洁（如阶乘、斐波那契数列），但需要额外递归终止条件。 |
| 时间效率 | 无函数调用开销，执行更快（适合大规模数据）。 | 每次递归调用需保存栈帧，函数调用开销大，可能更慢。 |
| 占用空间 | 仅需固定内存（如几个变量），空间复杂度通常为 O(1)。 | 需保存每一层调用的栈帧，空间复杂度取决于递归深度（如 O(n) 或 O(log⁡n)），可能栈溢出。 |
| 适用范围 | 所有可迭代问题（如数组遍历、数值计算）。 | 适合分治（如归并排序）、回溯（如八皇后）、树/图遍历（如DFS）等递归定义的问题。 |
| 设计难度 | 较直观，适合顺序逻辑。 | 需找到子问题分解方式，设计递归终止条件，对思维抽象能力要求更高。 |

 一般的，理论上，循环（迭代）都可以改写成递归，反之不然。 

### 常用数据结构的比较

- **数组**：随机访问快，插入/删除慢。

- **链表**：插入/删除快，访问需遍历。

- **栈/队列**：特定顺序操作（LIFO/FIFO）。

- **哈希表**：快速查找，但需处理冲突。

### 重要例题

#### 欧几里得算法

```python
def gcd(a, b):
 while b:
 a, b = b, a % b
 return a

# 示例
print(gcd(48, 18)) # 输出: 6

Hanoi塔

def hanoi(n, source, target, auxiliary):
 """
 汉诺塔递归解法
 :param n: 盘子数量
 :param source: 起始柱子（如 'A'）
 :param target: 目标柱子（如 'C'）
 :param auxiliary: 辅助柱子（如 'B'）
 """
 if n == 1:
 # 基准情形：只有一个盘子时，直接移动到目标柱子
 print(f"Move disk 1 from {source} to {target}")
 else:
 # 递归步骤：
 # 1. 将前 n-1 个盘子从 source 移到 auxiliary（借助 target）
 hanoi(n-1, source, auxiliary, target)
 
 # 2. 将第 n 个盘子（最大的）从 source 移到 target
 print(f"Move disk {n} from {source} to {target}")
 
 # 3. 将前 n-1 个盘子从 auxiliary 移到 target（借助 source）
 hanoi(n-1, auxiliary, target, source)

# 示例：移动 3 个盘子从 A 到 C，借助 B
hanoi(3, 'A', 'C', 'B')

整数的划分

def integer_partition(n, m):
 """
 计算将整数 n 划分为最大部分不超过 m 的划分数。
 :param n: 待划分的整数。
 :param m: 划分中允许的最大部分。
 """
 if n == 0:
 return 1 # 空划分算一种
 if m == 1:
 return 1 # 只能划分为 1+1+...+1
 if n 
- **初始化**：设定初始状态（如变量初值）。

- **迭代过程**：通过循环逐步更新状态。

- **终止条件**：达到目标时退出循环。

### 递推法vs倒推法

- **递推法**：从已知条件逐步推导到目标（如斐波那契数列）。

- **倒推法**：从目标反向推导初始条件（如猴子吃桃问题）。

### 重要例题

#### 兔子繁衍问题

```python
def fibonacci(n):
 a, b = 0, 1
 for _ in range(n):
 a, b = b, a + b
 return a

# 示例
print(fibonacci(6)) # 输出: 8（第6个月有8对兔子）

猴子吃桃问题

def peach_count(days):
 peaches = 1 # 最后一天剩1个
 for _ in range(days-1):
 peaches = (peaches + 1) * 2
 return peaches

# 示例
print(peach_count(5)) # 输出: 46（第1天有46个桃子）

杨辉三角形

递推关系：C(n,k)=C(n−1,k−1)+C(n−1,k)。

穿越沙漠问题（重点在于如何理解其思想）

核心思想：分段设立补给站，逆向计算资源消耗。

牛顿迭代法

求方程根：xn+1=xn−f(xn)/f′(xn)。

蛮力法

重要例题

百钱百鸡问题

def hundred_chickens():
 for x in range(0, 21): # 公鸡最多20只
 for y in range(0, 34): # 母鸡最多33只
 z = 100 - x - y
 if 5*x + 3*y + z/3 == 100:
 print(f"公鸡: {x}, 母鸡: {y}, 小鸡: {z}")

# 示例
hundred_chickens() # 输出所有解

解数字迷（ABCAB X A = DDDDDD）

def solve_abcab():
 for a in range(1, 10):
 for b in range(10):
 for c in range(10):
 abcab = 10000*a + 1000*b + 100*c + 10*a + b
 d = abcab * a
 if len(str(d)) == 6 and len(set(str(d))) == 1:
 print(f"ABCAB = {abcab}, A = {a}, D = {d}")

# 示例
solve_abcab() # 输出: ABCAB = 37037, A = 3, D = 111111

狱吏问题（蛮力->数学技巧->深入挖掘数学规律）

def prison_doors(n):
 doors = [False] * n # False表示门关闭
 for i in range(1, n+1):
 for j in range(i-1, n, i):
 doors[j] = not doors[j]
 return [i+1 for i, door in enumerate(doors) if door]

# 示例
print(prison_doors(10)) # 输出: [1, 4, 9]（完全平方数编号的门开着）

IOC-Exercise

Tue, 18 Mar 2025 13:31:24 +0800

严格地说，这个不算IOC，详见：IOC? IOC与DI？。

一个IOC（控制反转）和DI（依赖注入）的练习程序，实际上和Highway-Toll-Framework的实现基本类似。

\---IOC-Exercise
 Agent.java
 Person.java
 Vehicle.java
 VehicleType.java

Agent.java

提供findVehicleClasses方法，扫描包中的类，返回class列表。提供getVehicle方法，创建所给名称对应的车辆类，返回相应实例。

Person.java

这个程序的主类，在里面通过Agent类来获取所需的具体对象，在通过setVehicle方法注入到Person类中，从而调用不同类的同名方法。

Vehicle.java

接口，所有车辆类实现该接口，再在车辆类上打注解便可以不侵入原有代码增加新类。

VehicleType.java

注解类，存储了类的名称值，一个类对应多个名称。

E2_AES

Tue, 18 Mar 2025 13:09:22 +0800

算法主要原理

算法流程如下：

算法步骤

AES算法是一种对称分组密码算法，采用代换-置换网络（SPN）结构，通过多轮迭代的加密过程对数据进行混淆和扩散，确保其安全性。该算法将明文分成固定长度的128位数据块（实际上分组长度也有128位、192位或256位三种选择），并支持128位、192位或256位的密钥，分别对应10轮、12轮或14轮的加密轮次。每一轮加密过程包括四个核心操作：字节代换、行移位、列混淆和轮密钥加，其中最后一轮省略列混淆步骤。通过密钥扩展算法，初始密钥被扩展为多组轮密钥，供每一轮加密使用。AES算法的安全性依赖于其非线性的S盒变换、扩散层操作以及密钥的复杂性，使其能够有效抵抗线性攻击和差分攻击，成为当前最广泛使用的对称加密标准之一。

1.字节代换

字节代换是AES加密的核心非线性变换，它通过一个被称为S盒的查找表对状态矩阵中的每个字节进行独立替换。其中，S盒是经过精心设计的，它基于有限域GF(2⁸)上的乘法逆运算，再加上一个仿射变换，使得输出与输入之间不存在明显的数学关系。具体来说，每个字节先被看作GF(2⁸)中的元素，计算其乘法逆元（0x00映射到自身），然后经过一个固定的仿射变换。这种设计让S盒具备极强的非线性特性，有效抵抗线性密码分析。而解密过程则使用逆S盒进行反向替换，但这两个S盒并不是简单的互逆关系，而是各自独立构造的。

2.行移位

行移位步骤是对状态矩阵的行进行循环移位操作。具体来说，状态矩阵是一个4行4列的字节数组。第一行保持不变，第二行循环左移1个字节，第三行循环左移2个字节，第四行循环左移3个字节。这个操作使得原本在同一列中的字节被分散到不同列中。在解密时，需要进行相反方向的循环右移操作。行移位的目的是实现字节在状态矩阵中的扩散，使得后续的列混淆操作能更有效地传播变化。

3.列混淆

列混淆步骤对状态矩阵的每一列进行线性变换。该操作将每一列视为GF(2^8)上的多项式，与固定多项式进行有限域上的乘法。这个运算可以表示为矩阵乘法，其中每个字节的变换都是与固定系数的乘法和异或组合。

在实际实现中，这个步骤可以使用xtime进行化简。xtime定义为这样的一个函数，其输入是一个 8 位字节（即 GF(2⁸) 的元素），输出是该字节与 {02}（即多项式 x）相乘的结果，并在必要时进行模 x⁸ + x⁴ + x³ + x + 1（AES 使用的不可约多项式）的约简，也即异或0x1B。

在解密时，只需要变换固定系数矩阵即可。值得注意的是，最后一轮加密不包含列混淆操作。这个步骤增强了AES的扩散特性，使得单个字节的变化会影响整个列。

4.轮密钥加

轮密钥加步骤将当前轮的扩展密钥与状态矩阵进行简单的按位异或操作。每一轮都使用不同的轮密钥，这些密钥是通过密钥扩展算法从初始密钥派生出来的。这个操作是AES中唯一直接使用密钥的步骤。由于异或操作的可逆性，解密时只需使用相同的轮密钥再次异或即可恢复原始数据。这个步骤为算法提供了基于密钥的安全性。

5.密钥扩展算法

密钥扩展算法负责从初始密钥生成各轮所需的轮密钥。对于128位密钥，需要生成10个轮密钥（共44个32位字）。算法首先将初始密钥分成4个字（w[0]-w[3]），然后递归生成后续的字。我们这里只讨论128位密钥的扩展，其他位数的扩展步骤大致相同。

对于非4k个字，计算方式为前一个字w[i-1]与w[i-4]的简单异或（XOR）。每第4k个字（如w[4],w[8]等）需要特殊处理，计算方式为先对前一个字w[i-1]进行字节代换、循环移位，再与w[i-4]、轮常数异或。轮常数是一个与轮次相关的固定值，用于打破对称性。对于192位和256位密钥，扩展过程类似但细节略有不同。这个算法确保每个轮密钥都与前一个不同，且整个密钥调度具有足够的随机性。

6.DES与AES的对比

DES和AES在结构设计上采用了不同的密码学架构，体现了对称加密算法演进的思路。DES基于Feistel网络结构，这种结构将输入分组分为左右两部分，每轮只对其中一半进行加密变换，再通过交换左右部分实现数据混淆。Feistel结构的特点是加密解密过程对称，只需调整子密钥顺序即可实现逆向运算，这使得硬件实现相对简单。然而DES的56位密钥长度在计算能力提升后显得不足，且固定的S盒设计存在潜在的分析风险。

AES则采用了更为现代的SPN（Substitution-Permutation Network）结构，这种结构通过多轮重复的代换和置换操作实现数据加密。与Feistel网络不同，SPN结构在每一轮都对整个数据块进行完整的非线性变换和线性扩散。具体来说，AES的每轮加密都包含字节代换、行移位、列混淆和轮密钥加四个步骤，其中前三步分别实现非线性代换和线性扩散，最后一步引入密钥相关变换。这种设计使得AES在相同轮数下能实现更强的混淆和扩散效果。

从安全性角度来看，AES的SPN结构具有明显优势。其更大的分组长度（128位起）和可变的密钥长度（128/192/256位）能更好抵抗穷举攻击。每一轮对整个数据块的处理方式使得差分和线性分析更加困难，而DES的Feistel结构由于每轮只处理半块数据，需要更多轮数才能达到相似的混淆效果。此外，AES的S盒设计基于严密的数学理论，相比DES的固定S盒具有更强的抗分析能力。

在性能表现上，AES的SPN结构更适合现代计算环境。其算法设计充分考虑了软硬件实现的效率，在各类平台上都能展现出优异的性能。而DES由于其初始设计年代较早，在软件实现效率上相对较低，特别是在处理大数据量时更为明显。AES的轮数可以根据密钥长度灵活调整（10/12/14轮），在安全性和效率之间取得了更好的平衡。

NIST提出AES标准的主要原因在于DES已不能满足现代安全需求。随着计算能力的提升，DES的56位密钥面临被暴力破解的风险。1997年DES挑战赛被成功攻破，加速了新标准的制定进程。AES的选拔过程公开透明，最终Rijndael算法因其在安全性、性能和实现灵活性上的综合优势胜出。相比DES，AES提供了更高的安全强度、更优的执行效率以及更好的算法透明度，这些特点使其成为21世纪最重要的对称加密标准。

程序运行截图

参考代码

aes.py

# AES 128 bit encryption and decryption
# 128 bit 密钥 == 16 bytes == 32位十六进制
# 192 bit 密钥 == 24 bytes == 48位十六进制
# 256 bit 密钥 == 32 bytes == 64位十六进制

Sbox = (
 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16,
)

InvSbox = (
 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D,
)

# xtime函数，用于有限域上的乘法运算
# 如果a的最高位为1，则左移1位后与0x1B异或，否则直接左移1位
# 0x1B 是 0001 1011 的十六进制表示，
# 0xFF 是 1111 1111 的十六进制表示，& 0xFF 运算只保留最低8位，其余位为0
# 0x80 是 1000 0000 的十六进制表示，& 0x80 运算只保留最高位，其余位为0
xtime = lambda a: (((a > (8 * (15 - i))) & 0xFF
 if i % 4 == 0:
 # 每4个字节开始一个新行
 matrix.append([byte])
 else:
 # 将字节添加到当前行
 matrix[int(i / 4)].append(byte)
 return matrix

def matrix2text(matrix):
 # 将矩阵转换为文本
 text = 0
 for i in range(4):
 for j in range(4):
 # 将每个字节移动到正确的位置并组合
 text |= (matrix[i][j] ![](/images/2025/03/image-11-1024x429.png)

## 参考资料

[bozhu/AES-Python: A pure Python implementation of AES](https://github.com/bozhu/AES-Python)

[AES - CTF Wiki](https://ctf-wiki.org/crypto/blockcipher/aes)

[密码学基础：AES加密算法 - 知乎](https://zhuanlan.zhihu.com/p/78913397)

E1_Vigenere

Tue, 18 Mar 2025 12:32:52 +0800

算法主要原理

加密公式：C = (P + K)%26

C：密文
P：原文
K：第几套加密方式

解密公式：P = (C - K)%26

C：密文
P：原文
K：第几套加密方式
如果P<0,P+26取得正序

简单来说，Vigenere密码实际上就是分组的凯撒密码。而分组的方法就是重复密钥，密钥相同的明文为同一组。每一组都可以看作是由不同的密钥所加密的凯撒密码。

算法步骤

加/解密

维吉尼亚密码是一种经典的多表替换加密算法，其改进了凯撒密码单表替换的弱点，通过使用不同的字母移位规则，使得频率分析攻击更加困难。

实际上可以将维吉尼亚密码理解为多个凯撒密码的加密，它的核心思想是用一个关键词来控制加密过程，使得同样的字母在明文的不同位置可能会被加密成不同的密文字母，这样就比简单的凯撒密码安全得多。

加密的时候就是把明文的每个字母按照密钥字母对应的数值进行移位，比如密钥字母A代表移0位（相当于不变），B移1位，一直到Z移25位。例如，当加密"HELLO"这个单词，选择的密钥是"KEY"，首先要把密钥重复到和明文一样长变成"KEYKE"，然后每个明文字母都对应一个密钥字母。然后每个字母加密时，H（在字母表里排第7位）对应K（排第10位），就往后移10位变成R（第17位）；E（第4位）对应E（第4位），移4位变成I（第8位）；第一个L（第11位）对应Y（第24位），11加24等于35，因为字母表只有26个字母，所以35减26得到9，对应J；第二个L（第11位）对应K（第10位），11加10等于21，对应V；O（第14位）对应E（第4位），14加4等于18，对应S。这样最终"HELLO"就被加密成了"RIJVS"。但要注意的是字母表是循环的，超过Z就要回到A继续算，所以计算时要取模26。

解密过程与加密过程相反，用密文字母和密钥字母相减，比如R（17位）减去K（10位）得到7对应H，I（8位）减E（4位）得到4对应E，以此类推。如果遇到字母相减得到负数的情况，把负数加上26就能得到正确的结果。

破解

维吉尼亚密码的核心安全特性来自于它的多表代换机制，但这也恰恰成为它被破解的突破口。要理解破解原理，我们需要先认清一个关键事实：维吉尼亚密码本质上是多个凯撒密码的交替使用。****

具体说来则是密钥长度决定了位移序列的长度，也即维吉尼亚密码是在循环应用一组固定的凯撒密码。若是我们确定了其密钥长度，则分组后的密码实际上呈现出单表特性，每组内部都是纯粹的凯撒密码，完全保留自然语言的统计特征。

因此破解维吉尼亚密码的重中之重是要破解出密钥长度，确定了密钥长度后就和破解凯撒密码无异了。所以说我们的破解步骤就分为确定密钥长度和确定密钥内容两步。

（一）确定密钥长度——重合指数法确定密钥长度

确定密钥长度这一步，我们采用重合指数法来确定。

因为对于正常的英语分布来说，从正常英语句子中随机取两个元素相同的概率是0.065，而如果是完全随机的字符串概率则是0.038。0.038~0.065之间的差距，让我们可以检验某一段文字是否符合正常的英语分布。

所以说，我们先假定密钥长度，便可以分出多组密文。每组密文内都是用相同的密钥加密的，因此只要是正常的、有意义的英文句子便符合0.065的概率。我们遍历可能的密钥长度，计算出接近0.065的值后取最小值就可以得到密钥长度。（当遍历的密钥长度稍长时，可能会出现真正密钥长度的倍数的IC会更接近0.065的情况，因此最好选容许的误差范围中的最小值）

以下是详细的数学证明过程：

（二）确定密钥内容——使用卡方检验确定密钥的内容

在确定密钥内容这一步，我们使用卡方检验来确定。

之前的步骤中我们已经将维吉尼亚密码转换为了多组凯撒密码。而对于凯撒密码来说，因为所有自然语言都存在特定的字母出现频率规律，单表替换加密虽然改变了字母的表象，但完整保留了这种统计特征。以英语为例，字母E的出现频率高达12.7%，T约9.1%，A约8.2%，这种分布特征就像语言的"指纹"一样稳定。当我们将明文通过凯撒密码加密时，整个字母表只是被整体平移了一定位数，比如位移3的情况下，原本高频的E会被统一替换成H，T变成W，A变成D，此时密文中H、W、D就会成为新的高频字母，它们与原始高频字母的对应关系完全由位移量决定。

那我们首先需要统计密文中各字母的出现频率，制作频率分布表，然后将这个统计结果与目标语言的标准字母频率进行对比匹配，这一步我们使用卡方检验。卡方检验可以通过量化比较两个字母频率分布的差异程度，来找出最可能使用的位移量。这个卡方值的计算公式是：将每个字母在解密文本中的观察频次与标准英语中的期望频次之差的平方除以期望频次后求和。卡方值越小，说明解密后的字母频率分布与标准英语越接近，也就意味着这个位移量越有可能是正确的密钥。求出密钥后，我们便可以轻松解密维吉尼亚密码了。

总结

破解Vigenere算法最主要就是两个步骤——确定密钥长度和确定密钥内容，而这两个步骤实际上都是利用了英语字母的分布规律来破解的，一个是通过重合指数，一个是通过卡方检验。

程序运行截图

参考代码

endecrypt.py

# Vigenere Cipher Encrypt/Decrypt

# 字母转数字
def L2N(L):
 return ord(L.upper()) - ord('A')

# 数字转字母
def N2L(N):
 return chr(N + ord('A'))

# 加密
def encrypt(text, key):
 encrypted_text = ''
 j=0
 for i in range(len(text)):
 if(text[i].isalpha()):
 encrypted_text += N2L((L2N(text[i]) + L2N(key[j%len(key)])) % 26)
 j+=1
 
 return encrypted_text
 
# 解密
def decrypt(text, key):
 decrypted_text = ''
 j=0
 for i in range(len(text)):
 decrypted_text += N2L((L2N(text[i]) - L2N(key[j%len(key)])) % 26)
 j+=1
 
 return decrypted_text

if __name__ == '__main__':
 text = 'I am alive here, my beloved, for the reason to adore you. Oh!How anxious I have been for you and how sorry I am about all you must have suffered in having no news from us. May heaven grant that this letter reaches you. Do not write to me, this would compromise all of us and above all,do not return under any circumstances. It is known that it was you who helped us to get away from here and all would be lost if you should show yourself.We are guarded day and night. I do not care you are not here. Do not be troubled on my account. Nothing will happen to me. The national assemble will show leniency. Farewell the most loved of men. Be quiet if you can take care of yourself.For myself I cannot write any more, but nothing in the world could stop me to adore you up to the death.'
 key = 'crypt'
 print(encrypt(text, key).lower())

crack.py

# Vigenere Cipher Crack
import math
import numpy as np
from typing import List, Tuple

def alpha(cipher: str) -> str:
 """
 预处理函数：去掉密文中的非字母字符（如空格、回车、标点符号等）。
 :param cipher: 密文字符串
 :return: 只包含字母的密文字符串
 """
 c = ""
 for char in cipher:
 if char.isalpha():
 c += char
 return c

def count_IC(cipher: str) -> float:
 """
 计算字符串的重合指数（IC）。
 :param cipher: 密文字符串
 :return: 重合指数值
 """
 count = [0] * 26
 L = len(cipher)
 IC = 0.0
 for char in cipher:
 if char.isupper():
 count[ord(char) - ord("A")] += 1
 elif char.islower():
 count[ord(char) - ord("a")] += 1
 for i in range(26):
 IC += (count[i] * (count[i] - 1)) / (L * (L - 1))
 return IC

def count_key_len(cipher: str, key_len: int) -> float:
 """
 对密文按密钥长度分组，并计算每组的平均重合指数。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :return: 平均重合指数
 """
 groups = [""] * key_len
 IC = [0] * key_len
 for i in range(len(cipher)):
 m = i % key_len
 groups[m] += cipher[i]
 for i in range(key_len):
 IC[i] = count_IC(groups[i])
 print(f"长度为{key_len}时, 平均重合指数为{np.mean(IC):.5f}")
 return np.mean(IC)

def determine_key_length(cipher: str, tolerance: float = 0.01) -> int:
 """
 确定最可能的密钥长度。
 :param cipher: 密文字符串
 :param tolerance: 允许的重合指数误差范围
 :return: 最可能的密钥长度
 """
 possible_lengths = [] # 存储可能的密钥长度
 for key_len in range(1, 100): # 尝试密钥长度从1到100
 avg_IC = count_key_len(cipher, key_len)
 if abs(avg_IC - 0.065) int:
 """
 确定最可能的密钥长度。(老旧版本)
 :param cipher: 密文字符串
 :return: 最可能的密钥长度
 """
 key_len = 0
 min_diff = 100
 avg_IC = 0.0
 for i in range(1, 10):
 current_IC = count_key_len(cipher, i)
 if abs(current_IC - 0.065) float:
 """
 计算卡方统计量，用于评估解密后的文本是否符合英文字母频率分布。
 :param vec: 密文的子串（按密钥长度分组后的某一组）
 :param key: 尝试的密钥偏移量
 :return: 卡方统计量
 """
 freq = [0] * 26 # 统计字母频率
 for c in vec:
 if c.isalpha():
 c = c.lower()
 c = chr((ord(c) - ord("a") + (26 - key)) % 26 + ord("a"))
 freq[ord(c) - ord("a")] += 1

 # 英文字母的期望频率
 expected_freq = [
 0.08167,
 0.01492,
 0.02782,
 0.04253,
 0.12702,
 0.02228,
 0.02015,
 0.06094,
 0.06966,
 0.00153,
 0.00772,
 0.04025,
 0.02406,
 0.06749,
 0.07507,
 0.01929,
 0.00095,
 0.05987,
 0.06327,
 0.09056,
 0.02758,
 0.00978,
 0.02360,
 0.00150,
 0.01974,
 0.00074,
 ]

 # 确保期望频率的总和为1.0
 assert abs(1.0 - sum(expected_freq)) List[int]:
 """
 使用卡方检验确定每组最可能的相对偏移量。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :return: 相对偏移量列表
 """
 possible_key = [] # 存储可能的密钥

 for i in range(key_len):
 # 生成当前分组的子串
 vec = [cipher[j] for j in range(i, len(cipher), key_len)]

 # 尝试所有可能的偏移量（0-25）
 possibility_array = []
 for j in range(26):
 curr_chi_square = chi_square(vec, j)
 possibility_array.append((chr(ord("a") + j), curr_chi_square))

 # 按卡方值从小到大排序（卡方值越小，可能性越大）
 possibility_array.sort(key=lambda x: x[1])

 # 选择卡方值最小的偏移量作为当前分组的密钥字母
 possible_key.append(ord(possibility_array[0][0]) - ord("a"))

 return possible_key

def decrypt(cipher: str, key_len: int, shifts: List[int]) -> str:
 """
 使用密钥对密文进行解密。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :param shifts: 密钥字母的下标列表
 :return: 解密后的明文字符串
 """
 plain = ""
 i = 0
 while i str:
 """
 预处理函数：去掉密文中的非字母字符（如空格、回车、标点符号等）。
 :param cipher: 密文字符串
 :return: 只包含字母的密文字符串
 """
 c = ""
 for char in cipher:
 if char.isalpha():
 c += char
 return c

def count_IC(cipher: str) -> float:
 """
 计算字符串的重合指数（IC）。
 :param cipher: 密文字符串
 :return: 重合指数值
 """
 count = [0] * 26
 L = len(cipher)
 IC = 0.0
 for char in cipher:
 if char.isupper():
 count[ord(char) - ord("A")] += 1
 elif char.islower():
 count[ord(char) - ord("a")] += 1
 for i in range(26):
 IC += (count[i] * (count[i] - 1)) / (L * (L - 1))
 return IC

def count_key_len(cipher: str, key_len: int) -> float:
 """
 对密文按密钥长度分组，并计算每组的平均重合指数。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :return: 平均重合指数
 """
 groups = [""] * key_len
 IC = [0] * key_len
 for i in range(len(cipher)):
 m = i % key_len
 groups[m] += cipher[i]
 for i in range(key_len):
 IC[i] = count_IC(groups[i])
 return np.mean(IC)

def determine_key_length(cipher: str, tolerance: float = 0.01) -> int:
 """
 确定最可能的密钥长度。
 :param cipher: 密文字符串
 :param tolerance: 允许的重合指数误差范围
 :return: 最可能的密钥长度
 """
 possible_lengths = [] # 存储可能的密钥长度
 IC_values = [] # 存储每个密钥长度对应的重合指数
 for key_len in range(1, 100): # 尝试密钥长度从1到100
 avg_IC = count_key_len(cipher, key_len)
 IC_values.append(avg_IC)
 if abs(avg_IC - 0.065) float:
 """
 计算卡方统计量，用于评估解密后的文本是否符合英文字母频率分布。
 :param vec: 密文的子串（按密钥长度分组后的某一组）
 :param key: 尝试的密钥偏移量
 :return: 卡方统计量
 """
 freq = [0] * 26 # 统计字母频率
 for c in vec:
 if c.isalpha():
 c = c.lower()
 c = chr((ord(c) - ord('a') + (26 - key)) % 26 + ord('a'))
 freq[ord(c) - ord('a')] += 1

 # 英文字母的期望频率
 expected_freq = [
 0.08167, 0.01492, 0.02782, 0.04253, 0.12702, 0.02228, 0.02015, 0.06094, 0.06966, 0.00153,
 0.00772, 0.04025, 0.02406, 0.06749, 0.07507, 0.01929, 0.00095, 0.05987, 0.06327, 0.09056,
 0.02758, 0.00978, 0.02360, 0.00150, 0.01974, 0.00074
 ]

 # 确保期望频率的总和为1.0
 assert abs(1.0 - sum(expected_freq)) Tuple[List[int], List[List[float]]]:
 """
 使用卡方检验确定每组与第一组之间的相对偏移量。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :return: 相对偏移量列表和每一组的卡方值列表（未排序）
 """
 possible_key = [] # 存储可能的密钥
 chi_square_values = [] # 存储每一组的卡方值（未排序）

 for i in range(key_len):
 # 生成当前分组的子串
 vec = [cipher[j] for j in range(i, len(cipher), key_len)]

 # 尝试所有可能的偏移量（0-25）
 chi_values = [] # 存储当前分组的卡方值（未排序）
 for j in range(26):
 curr_chi_square = chi_square(vec, j)
 chi_values.append(curr_chi_square)

 # 按卡方值从小到大排序（卡方值越小，可能性越大）
 sorted_indices = np.argsort(chi_values) # 获取排序后的索引
 best_shift = sorted_indices[0] # 选择卡方值最小的偏移量

 # 存储结果
 possible_key.append(best_shift)
 chi_square_values.append(chi_values) # 存储未排序的卡方值

 return possible_key, chi_square_values

def decrypt(cipher: str, key_len: int, shifts: List[int]) -> str:
 """
 使用密钥对密文进行解密。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :param shifts: 密钥字母的下标列表
 :return: 解密后的明文字符串
 """
 plain = ""
 i = 0
 while i < len(cipher):
 for j in range(key_len):
 if cipher[i].isupper():
 plain += chr(
 (ord(cipher[i]) - ord("A") - shifts[j] + 26) % 26 + ord("A")
 )
 else:
 plain += chr(
 (ord(cipher[i]) - ord("a") - shifts[j] + 26) % 26 + ord("a")
 )
 i += 1
 if i == len(cipher):
 break
 return plain

# GUI 界面
class VigenereCrackerApp:
 def __init__(self, root):
 self.root = root
 self.root.title("维吉尼亚密码工具")
 self.cipher = ""
 self.key_len = 0
 self.shifts = []
 self.plain = ""
 self.show_plots = tk.BooleanVar(value=True) # 是否展示柱状图

 # 创建选项卡
 self.notebook = ttk.Notebook(root)
 self.notebook.pack(fill="both", expand=True)

 # 添加“加/解密”选项卡
 self.add_encrypt_decrypt_tab()

 # 添加“破解”选项卡
 self.add_crack_tab()

 def add_encrypt_decrypt_tab(self):
 """添加加/解密选项卡"""
 tab = ttk.Frame(self.notebook)
 self.notebook.add(tab, text="加/解密")

 # 输入框
 input_label = ttk.Label(tab, text="原文：")
 input_label.grid(row=0, column=0, padx=10, pady=10, sticky="w")
 self.input_text_encrypt = tk.Text(tab, height=15, width=80)
 self.input_text_encrypt.grid(row=0, column=1, padx=10, pady=10)

 # 密钥输入框
 key_label = ttk.Label(tab, text="密钥：")
 key_label.grid(row=1, column=0, padx=10, pady=10, sticky="w")
 self.key_entry = ttk.Entry(tab, width=80)
 self.key_entry.grid(row=1, column=1, padx=10, pady=10, sticky="w")

 # 创建一个 Frame 来放置按钮
 button_frame = ttk.Frame(tab)
 button_frame.grid(row=2, column=0, columnspan=2, padx=10, pady=10)

 # 加密按钮
 encrypt_button = ttk.Button(button_frame, text="👇加密👇", command=self.encrypt_text)
 encrypt_button.pack(side="left", padx=10)

 # 解密按钮
 decrypt_button = ttk.Button(button_frame, text="👆解密👆", command=self.decrypt_text)
 decrypt_button.pack(side="left", padx=10)

 # 输出框
 output_label = ttk.Label(tab, text="密文：")
 output_label.grid(row=3, column=0, padx=10, pady=10, sticky="w")
 self.output_text_encrypt = tk.Text(tab, height=15, width=80)
 self.output_text_encrypt.grid(row=3, column=1, padx=10, pady=10)

 def add_crack_tab(self):
 """添加破解选项卡"""
 tab = ttk.Frame(self.notebook)
 self.notebook.add(tab, text="破解")

 # 输入框
 input_label = ttk.Label(tab, text="输入密文：")
 input_label.grid(row=0, column=0, padx=10, pady=10, sticky="w")
 self.input_text = tk.Text(tab, height=15, width=80)
 self.input_text.grid(row=0, column=1, padx=10, pady=10)

 # 输出框
 output_label = ttk.Label(tab, text="输出结果：")
 output_label.grid(row=1, column=0, padx=10, pady=10, sticky="w")
 self.output_text = tk.Text(tab, height=15, width=80)
 self.output_text.grid(row=1, column=1, padx=10, pady=10)

 # 按钮
 self.step1_button = ttk.Button(tab, text="1. 确定密钥长度", command=self.step1)
 self.step1_button.grid(row=2, column=0, padx=10, pady=10)

 self.step2_button = ttk.Button(tab, text="2. 确定密钥", command=self.step2)
 self.step2_button.grid(row=2, column=1, padx=10, pady=10)

 self.step3_button = ttk.Button(tab, text="3. 解密", command=self.step3)
 self.step3_button.grid(row=2, column=2, padx=10, pady=10)

 # 是否展示柱状图
 self.plot_check = ttk.Checkbutton(tab, text="展示柱状图", variable=self.show_plots)
 self.plot_check.grid(row=3, column=1, padx=10, pady=10)

 def encrypt_text(self):
 """加密文本"""
 text = self.input_text_encrypt.get("1.0", tk.END).strip() # 获取明文
 key = self.key_entry.get().strip() # 获取密钥
 if not text or not key:
 messagebox.showerror("错误", "请输入明文和密钥！")
 return
 encrypted_text = encrypt(text, key) # 调用加密函数
 self.output_text_encrypt.delete("1.0", tk.END) # 清空输出框
 self.output_text_encrypt.insert(tk.END, encrypted_text) # 显示密文

 def decrypt_text(self):
 """解密文本"""
 text = self.output_text_encrypt.get("1.0", tk.END).strip() # 获取密文
 key = self.key_entry.get().strip() # 获取密钥
 if not text or not key:
 messagebox.showerror("错误", "请输入密文和密钥！")
 return
 decrypted_text = decrypt_vigenere(text, key) # 调用解密函数
 self.input_text_encrypt.delete("1.0", tk.END) # 清空输入框
 self.input_text_encrypt.insert(tk.END, decrypted_text) # 显示明文

 def step1(self):
 """第一步：确定密钥长度"""
 self.cipher = alpha(self.input_text.get("1.0", tk.END).strip())
 try:
 self.key_len, IC_values = determine_key_length(self.cipher)
 self.output_text.delete("1.0", tk.END)
 self.output_text.insert(tk.END, f"密钥长度为: {self.key_len}\n")

 # 展示重合指数与密钥长度的图
 if self.show_plots.get():
 self.plot_IC_vs_keylen(IC_values)
 except ValueError as e:
 messagebox.showerror("错误", str(e))

 def step2(self):
 """第二步：确定密钥"""
 if not self.key_len:
 messagebox.showerror("错误", "请先确定密钥长度！")
 return

 # 调用 determine_relative_shifts 获取密钥和卡方值
 self.shifts, chi_square_values = determine_relative_shifts(self.cipher, self.key_len)
 self.output_text.insert(tk.END, f"相对偏移量: {self.shifts}\n")

 # 展示每一组的卡方与偏移量的图
 if self.show_plots.get():
 self.plot_chi_square_vs_shift(chi_square_values)

 def step3(self):
 """第三步：解密"""
 if not self.shifts:
 messagebox.showerror("错误", "请先确定密钥！")
 return
 self.plain = decrypt(self.cipher, self.key_len, self.shifts)
 self.output_text.insert(tk.END, f"解密后的明文: \n{self.plain}\n")

 def plot_IC_vs_keylen(self, IC_values):
 """绘制重合指数与密钥长度的柱状图"""
 fig, ax = plt.subplots()
 x = range(1, len(IC_values) + 1) # 横轴：密钥长度
 ax.bar(x, IC_values) # 绘制柱状图
 ax.set_xlabel("密钥长度")
 ax.set_ylabel("重合指数")
 ax.set_title("重合指数与密钥长度的关系")
 plt.show()

 def plot_chi_square_vs_shift(self, chi_square_values):
 """
 绘制每一组的卡方与偏移量的图。
 :param chi_square_values: 每一组的卡方值列表（未排序）
 """
 for i, chi_values in enumerate(chi_square_values):
 fig, ax = plt.subplots()
 x = range(26) # 横轴：偏移量（0-25）
 ax.bar(x, chi_values) # 绘制柱状图
 ax.set_xlabel("偏移量")
 ax.set_ylabel("卡方值")
 ax.set_title(f"分组 {i+1} 的偏移量与卡方值")
 plt.show()

# 运行 GUI
if __name__ == "__main__":
 root = tk.Tk()
 app = VigenereCrackerApp(root)
 root.mainloop()

参考资料

维吉尼亚密码的破解算法及python代码实现_维吉尼亚密码解密代码-CSDN博客

维吉尼亚密码产生密文，和密钥，如何得到明文? - 知乎

Highway-Toll-Framework

Tue, 11 Mar 2025 01:59:54 +0800

一个高速收费站框架，新增车辆类型（包括是真的新增车辆类型或者同一类型车辆叫法不同）不用修改原有代码，只需要在类上加注解（或注解配合properties配置文件）即可。

\---highway
 | Main.java
 | MainV2.java
 | MainV3.java
 | MainV4.java
 |
 +---annotation
 | VehicleType.java
 | VehicleTypeV2.java
 |
 +---config
 | VehicleConfig.java
 |
 +---toll
 | TollManager.java
 | TollManagerV2.java
 | TollManagerV3.java
 | TollManagerV4.java
 |
 \---vehicle
 | Bus.java
 | Car.java
 | NewElectricCar.java
 | NewEmergencyVehicle.java
 | NewMotorcycle.java
 | Truck.java
 | Vehicle.java
 |
 +---v2
 | Bus.java
 | Car.java
 | ElectricCar.java
 | EmergencyVehicle.java
 | Motorcycle.java
 | Truck.java
 | Vehicle.java
 |
 +---v3
 | BaseVehicle.java
 | Bus.java
 | Car.java
 | ElectricCar.java
 | EmergencyVehicle.java
 | Motorcycle.java
 | Truck.java
 | Vehicle.java
 |
 \---v4
 BaseVehicle.java
 Bus.java
 Car.java
 ElectricCar.java
 EmergencyVehicle.java
 Motorcycle.java
 Truck.java
 Vehicle.java

1. 单纯使用注解信息

注解类

在注解类中定义所需要的元素，这里是一个名称列表和每公里收费。

收费管理器类

在收费管理器类中扫描和加载所有带有@VehicleType注解的车辆类，并提供计算收费的方法。在这里获取信息是直接通过注解进行的。

车辆接口

车辆接口，用于提供一个默认方法计算车辆收费。

各种车辆类

只需要在类前加上@VehicleType注解，指定相应值即可，不用侵入原有代码。

主函数

创建TollManager实例进行业务逻辑。

2. 配合properties配置文件

注解类

在注解类中定义所需要的元素，在配合properties配置文件的情况下只需要一个配置文件中的键名。

车辆配置管理类

从配置文件（vehicles.properties）中读取和管理车辆相关的配置信息。

收费管理器类

在收费管理器类中扫描和加载所有带有@VehicleType注解的车辆类，并提供计算收费的方法。在这里获取信息是先拿到注解中的配置文件中的键名，再通过车辆配置管理类提供的方法从配置文件中获取相应的数据。

车辆接口

车辆接口，用于提供一个默认方法计算车辆收费。

各种车辆类

只需要在类前加上@VehicleType注解，指定相应值即可，不用侵入原有代码。

主函数

创建TollManager实例进行业务逻辑。

3. 只用properties配置文件，不用注解

只用properties配置文件唯一的不同就在于，将类的所有信息都放在配置文件中，包括类名，名称，价格等等，只需要从配置文件中读取即可。

4. 使用 Reflections 库

使用reflections库，信息读取的方式变成了使用 Reflections 扫描指定包下的所有 Vehicle 实现类，从实现类中读取信息。

5. 主要区别

用不用配置文件的主要区别就在于注解中信息的多少，你可以把全部信息都放到注解中，也可以只放一个配置文件中的键名。在之后的获取信息步骤，要么通过注解拿到所有信息，要么通过注解中的键名用车辆配置管理类从配置文件（vehicles.properties）中读取和管理车辆相关的配置信息。

使用不同的方法的主要区别就是读取信息方式的不同，单纯用注解就是到注解中获取所需的信息；注解加配置文件就是先从注解中读取键名，再到配置文件中读取其他信息；只用properties配置文件，不用注解就只从配置文件中读取信息；使用 Reflections 库就是使用 Reflections 扫描指定包下的所有 Vehicle 实现类，从实现类中读取信息。

Three-terminal-communication

Tue, 11 Mar 2025 01:37:05 +0800

一个socket应用程序，有服务端、消费端和充值端。不同端通过对象处理流用一个MyTransaction类来进行信息传输。服务端监听端口，并开一个新线程对发来的信息执行相应操作。消费端向服务端发送消费请求，充值端向服务端发送充值请求。

\---v2
 ConsumeClient.java
 MyTransaction.java
 RechargeClient.java
 Server.java

MyTransaction.java

交易类，用于传输交易信息，实现了java.io.Serializable接口用于序列化。除了该有的账户名、金额、交易信息、是否成功外，还用了一个枚举类型来区分是消费请求还是充值请求。此外，还有应有的构造函数和GetSet方法。

Server.java

主函数中使用ServerSocket不断对指定端口进行监听是否有连接请求，通过 accept() 方法接受连接后创建一个实际的网络连接Socket。然后新开一个实现了Runnable接口的ClientHandler方法的线程，在线程中从客户端 Socket 获取输入输出流，并将输入输出流包装成ObjectInputStream/ObjectOutputStream。之后从流中读取MyTransaction对象，执行相应逻辑后修改MyTransaction对象信息重新发回客户端。同时由于涉及到多线程，于是使用Collections.synchronizedMap将Map变成线程安全的Map。

RechargeClient.java

循环读入用户输入，创建Socket连接向服务端发送信息，之后等待接收回复信息，输出结果。Socket连接不保持，每个请求都重新创建。

ConsumeClient.java

用户事件调度线程EDT：负责对GUI组件的渲染和刷新，它只有一个，一定要注意这个问题，它处理的就是事件队列里的事情，他通过调用事件处理器来响应用户交互。所有的事件处理都是在EDT上进行的。

不能在主线程更新UI操作或执行耗时操作

所有的耗时操作应在非EDT中执行

所有的更新UI操作应该在EDT中执行

在主函数中调用SwingUtilities.invokeLater()在EDT队列尾部插入GUI界面生成事件，并等待异步执行。GUI绘制省略不说。输入信息点击按钮后执行handleTransaction()函数校验输入，通过后调用sendTransaction()方法发送交易信息。在sendTransaction()函数中，也是同充值端一样创建Socket连接向服务端发送信息，之后等待接收回复信息，输出结果。

软件工程课堂讨论二

Fri, 01 Nov 2024 02:59:46 +0800

计算器实现

class Calculator:
 def __init__(self):
 self.queue = [] # 用于存储输入的计算表达式

 def press_key(self, key):
 if self.is_valid_key(key):
 if key == '=':
 result = self.calculate()
 if result is not None:
 self.just_clear()
 # for ch in str(result):
 # self.add_to_queue(ch) # 将结果添加到队列中
 print(result)
 elif key == 'AC':
 self.clear()
 elif key == '+/-':
 self.toggle_sign()
 elif key == '%':
 self.percent()
 else:
 self.add_to_queue(key)

 def is_valid_key(self, key):
 valid_keys = {'AC', '+/-', '%', '/', '*', '-', '+', '=', '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
 return key in valid_keys

 def add_to_queue(self, key):
 if key.isdigit():
 # 处理数字输入
 if len(self.queue) == 0 and key == '0':
 return # 避免添加无意义的0
 if len(self.queue) > 0 and self.queue[-1].isdigit() and self.queue[-1] == '0':
 self.queue.pop() # 删除之前的无意义0
 self.queue.append(key)
 elif key == '.':
 # 检查队列中是否已有小数点，确保只能在数字后添加小数点
 if len(self.queue) > 0 and self.queue[-1].isdigit():
 # 遍历队列，确保在最近的运算符前没有小数点
 for i in range(len(self.queue) - 1, -1, -1):
 if self.queue[i] in {'+', '-', '*', '/'}:
 break # 遇到运算符停止
 if '.' in self.queue[i]:
 return # 如果在数字中已经有小数点，忽略输入
 self.queue[-1] += '.' # 将小数点添加到最后的数字
 else:
 if len(self.queue) == 0: # 如果队列为空，不允许直接输入运算符
 return
 last_key = self.queue[-1]
 # 不允许连续运算符
 if last_key in {'+', '-', '*', '/'} and key in {'+', '-', '*', '/'}:
 return
 self.queue.append(key)

 def clear(self):
 self.queue = []
 print("Calculator cleared.")
 
 def just_clear(self):
 self.queue = []

 def toggle_sign(self):
 if len(self.queue) > 0 and self.queue[-1].replace('.', '', 1).isdigit(): # 处理数字或小数
 number = str(-float(self.queue[-1]))
 self.queue[-1] = number
 print(f"Toggled sign: {number}")

 def percent(self):
 if len(self.queue) > 0 and self.queue[-1].replace('.', '', 1).isdigit(): # 处理数字或小数
 number = str(float(self.queue[-1]) / 100)
 self.queue[-1] = number
 print(f"Percent: {number}")

 def calculate(self):
 expression = ''.join(self.queue)
 print(expression,end='=')
 try:
 result = eval(expression)
 return result
 except Exception as e:
 print(f"Error\n{e}")
 self.clear()
 return None

# 示例用法
calculator = Calculator()
calculator.press_key('1')
calculator.press_key('0')
calculator.press_key('+')
calculator.press_key('5')
calculator.press_key('=')

calculator.press_key('AC')

calculator.press_key('0')
calculator.press_key('2')
calculator.press_key('*')
calculator.press_key('.')
calculator.press_key('5') # 形成小数0.5
calculator.press_key('=')

calculator.press_key('3')
calculator.press_key('.')
calculator.press_key('3')
calculator.press_key('+')
calculator.press_key('2')
calculator.press_key('.')
calculator.press_key('1')
calculator.press_key('=')

calculator.press_key('3')
calculator.press_key('.')
calculator.press_key('3')
calculator.press_key('+')
calculator.press_key('.')
calculator.press_key('2')
calculator.press_key('.')
calculator.press_key('1')
calculator.press_key('.')
calculator.press_key('5')
calculator.press_key('=')

calculator.press_key('0')
calculator.press_key('0')
calculator.press_key('0')
calculator.press_key('.')
calculator.press_key('3')
calculator.press_key('0')
calculator.press_key('+')
calculator.press_key('.')
calculator.press_key('0')
calculator.press_key('2')
calculator.press_key('1')
calculator.press_key('=')

calculator.press_key('0')
calculator.press_key('0')
calculator.press_key('0')
calculator.press_key('3')
calculator.press_key('0')
calculator.press_key('+')
calculator.press_key('0')
calculator.press_key('0')
calculator.press_key('0')
calculator.press_key('.')
calculator.press_key('2')
calculator.press_key('1')
calculator.press_key('=')

calculator.press_key('0')
calculator.press_key('0')
calculator.press_key('0')
calculator.press_key('3')
calculator.press_key('0')
calculator.press_key('+')
calculator.press_key('0')
calculator.press_key('0')
calculator.press_key('0')
calculator.press_key('.')
calculator.press_key('2')
calculator.press_key('1')
calculator.press_key('=')

软件工程课堂讨论一

Fri, 11 Oct 2024 03:01:25 +0800

从运行状态到阻塞状态有等待锁的情况吗？

当一个线程试图获取一个锁（如 synchronized 块或 ReentrantLock），如果该锁已经被其他线程持有，当前线程无法立即获取锁时，就会从运行状态（Running）转换为阻塞状态（Blocked），直到锁被释放。

文章最后部分有两个讨论：

获取到锁的线程为什么不直接执行到结束，这样就不会占用锁了？

为什么不在调度线程前检测这个线程要用到的锁有没有被占用从而判断要不要调度该线程？

`yield`的使用场景？

yield在Python和Java中的作用完全不同。

Python中的 yield:

在 Python 中，yield 是一种用于定义生成器（Generator）的关键字，它的作用是将函数变成一个生成器函数。生成器函数在调用时不会一次性执行完毕，而是返回一个生成器对象，可以在迭代过程中多次暂停并继续。

使用场景：

迭代大数据集合：当处理的数据量非常大时，如果使用普通的 return 返回整个集合，会导致内存占用过高。使用 yield 可以让函数每次返回一个数据，迭代时才真正计算或生成下一个数据。例如，从文件中逐行读取数据，或生成一个无限序列时，yield 可以显著减少内存使用。
简化迭代器实现：Python 中可以通过 yield 简单地创建一个自定义的迭代器，而不需要实现 __iter__ 和 __next__ 方法。生成器函数使用 yield 暂停并返回一个值，下次迭代时从上次暂停的地方继续执行。
流水线数据处理：在数据流处理的场景中，例如从某个源头获取数据，逐步处理并将结果传递给下游，yield 可以用于构建数据管道。这种方式能够按需生成数据，节省内存和处理时间。

Java 中的 yield:

在 Java 中，yield 这个关键字是 Thread 类的一个静态方法，用于线程调度。Java 的 Thread.yield() 方法使当前线程将 CPU 的执行权暂时让给其他同样处于可运行状态的线程。

sleep执行后线程进入阻塞状态

yield执行后线程进入就绪状态

join执行后线程进入阻塞状态

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

所以说yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

使用场景：

让步 CPU 时间片：当当前线程执行到某个位置，可以适当让出 CPU，给其他优先级相同的线程执行的机会时，可以调用 Thread.yield()。这并不意味着当前线程会立刻进入阻塞状态，只是让操作系统重新调度当前线程和其他可运行线程。使用 yield 通常是为了优化多线程的执行效率，在某些高并发环境中，有助于避免一个线程独占 CPU 资源。
测试和调试目的：在调试多线程代码时，有时为了观察线程调度的行为，可以插入 yield()，以便更清晰地观察不同线程的执行顺序。在这种情况下，yield() 可以帮助程序员更好地理解多线程程序的行为。
配合轻量级任务：在编写一些不需要长时间运行的轻量级任务时，可以使用 yield() 来避免某个线程在循环或任务中长时间占用 CPU，从而提高系统资源的利用率。

不使用`yield`发生IO操作/远程调用会自动进入阻塞状态吗？

其实这个问题问出来是有问题的。

首先，yield在Python和Java中的作用完全不同，我们这里并没有明确指出我们讨论的是哪一个。当然了，依照问题提出的场景，我们可以确定这个问题更准确的版本是——在用Python写的爬虫中，如果我不使用yield，当发生IO操作/远程调用会自动进入阻塞状态吗？

当然，这样问的话又引出了第二个问题。那就是在Python中yield是一种用于定义生成器的关键字，是实现异步操作的，与线程调度完完全全没有关系。所以对于这个问题，不管你使用还是不使用yield，都不能回答发生IO操作/远程调用是否会自动进入阻塞状态。

那对于发生IO操作/远程调用是否会自动进入阻塞状态这个问题来说，答案是只要你使用了线程，就会在该线程发生IO操作/远程调用时自动进入阻塞状态，也即会自动进行线程调度。

对于提出错误问题的原因有二：

一是把Python和Java中的yield搞混淆了。
二是把异步编程与线程调度的概念搞混淆了。

文章最后部分有两个讨论：

在Python写的爬虫里面会用到yield吗?

异步操作和线程调度的区别

一些讨论

1. 获取到锁的线程为什么不直接执行到结束，这样就不会占用锁了？

线程执行过程中被操作系统挂起：

线程的执行并不是连续的，它受限于操作系统的线程调度机制。在多任务操作系统中，CPU 会在多个线程之间进行时间片轮转调度。

假设 Thread A 获得了锁并开始执行，但在执行过程中，操作系统把它的时间片分配给了其他线程，此时 Thread A 被挂起。
尽管 Thread A 还没有完成对锁的操作，但它的执行被暂停了，锁依然被它持有，其他线程如 Thread B 只能等待，直到操作系统再次调度 Thread A 执行并完成释放锁的操作。
锁保护的代码块执行时间过长：

如果 Thread A 在持有锁时，执行的受保护的代码块非常耗时，例如需要进行复杂的计算、文件读写操作、数据库访问等，就会导致它占用锁的时间变长。

这种情况下，其他线程在 Thread A 完成这些耗时操作之前，都无法获取到锁，只能进入阻塞状态等待。
线程在持有锁期间发生阻塞操作：

如果 Thread A 在持有锁时，执行了可能会阻塞的操作，比如：

等待 I/O 操作完成（如读取文件、网络请求）。

调用了 sleep() 方法或其他可能导致线程暂停的操作。
这会导致 Thread A 在持有锁的情况下等待外部资源，而此时锁不能被释放，其他线程就只能等待。
代码设计不合理：

有时候，程序设计者可能没有合理地设计锁的粒度，即锁住的代码块过大，导致持有锁的时间变长。

比如，某个方法中的很多操作其实不需要加锁，但是由于整个方法都被 synchronized 关键字修饰，导致所有操作都必须等到锁释放后才能执行。
更好的做法是缩小锁的粒度，只在必要的地方使用锁，这样可以减少锁的持有时间，从而提高并发性能。
死锁问题：

在某些情况下，可能出现死锁，即多个线程相互等待对方释放锁，导致所有线程都被阻塞，无法继续执行。

例如，Thread A 持有锁 Lock1，等待 Lock2，而 Thread B 持有 Lock2，等待 Lock1。这就会导致两者相互等待，永远无法完成。
如何优化锁的使用：

缩小锁的粒度：只对真正需要保护的代码段加锁，尽量减少锁的使用范围。

使用更高效的锁机制：如 ReentrantLock 提供了更多的灵活性，还可以用 tryLock() 方法来避免无限制等待。
避免持有锁时进行耗时操作：例如，尽量不要在持有锁的代码段中进行 I/O 操作。
使用读写锁（如 ReadWriteLock）：如果有大量的读操作，可以使用读写锁来提高性能，让多个读线程并发访问，而写线程会独占。

2. 为什么不在调度线程前检测这个线程要用到的锁有没有被占用从而判断要不要调度该线程？

锁的持有状态是动态的：

锁的状态会随着线程执行过程中的操作而不断变化。一个锁可能在某一时刻被占用，但在另一个时刻就释放了。操作系统在调度线程时，如果预先检测锁状态，就可能在做出调度决定时，锁的状态已经改变了。

举例来说，如果操作系统在某个瞬间检测到 Thread A 想要使用的锁 Lock1 被 Thread B 占用，因此不调度 Thread A，但这时 Thread B 可能正好释放了 Lock1。如果再重新调度 Thread A，就会引入额外的延迟。
线程的调度和锁管理分属不同层次：

线程调度是由操作系统的内核负责的，而锁的管理则往往由用户级的程序或线程库（如 Java 的 synchronized 或 ReentrantLock）来实现。

调度器不直接知道一个线程将要访问哪些具体资源，它只是基于线程的优先级、状态（如就绪、运行）等进行调度。而锁的管理发生在更高层次的应用逻辑中，操作系统不会对应用层的锁状态进行管理。
为了让调度器了解每一个线程在未来会访问哪些锁，并在调度前进行检查，需要建立复杂的机制，这会大大增加操作系统的复杂性和调度开销。
预判锁的使用并不总是可靠：

在多线程环境中，线程的执行顺序和锁的请求顺序是不可预知的。提前检测一个线程是否需要使用某个锁，实际上是对未来执行路径的预测。这个预测不仅复杂，而且可能并不准确。

线程的逻辑中，锁的使用通常是由程序执行路径决定的，例如只有在满足某个条件时，才会去获取某个锁。操作系统很难提前判断某个线程在执行过程中一定会请求某个锁。
效率问题：调度开销和频繁检测：

假设操作系统在每次调度前都要检查一个线程要使用的锁是否被占用，那么对于大量的线程和锁，这种检查操作会极大地增加调度的开销。

频繁的锁状态检查会消耗更多的系统资源，尤其是当有大量线程频繁竞争少数几个锁时，这种机制可能会导致更多的系统开销，而不是提升整体的效率。
现代调度器的设计已经优化了线程的等待：

现代操作系统的调度器已经优化了线程在等待状态下的调度。例如，当一个线程因为等待锁进入阻塞状态时，调度器会将它放入等待队列中，而不会浪费 CPU 资源反复检查。

当锁释放时，调度器会及时唤醒等待的线程，并尽快让其获取锁继续执行。这样做的好处是，可以让其他不需要该锁的线程在这段时间内利用 CPU 资源，提升系统的整体效率。
锁的竞争是正常的并发现象：

锁竞争是多线程编程中的一种正常现象，操作系统通过调度算法和锁管理机制，尽量让锁的竞争对系统性能的影响降到最低。提前预判并不总是最佳选择，因为在多数情况下，线程在获取锁后能够快速完成操作。

通过设计更高效的并发程序，例如减少临界区的代码量、合理使用锁的粒度、避免不必要的锁定操作，往往可以更有效地解决锁竞争问题。

3. 在Python写的爬虫里面会用到`yield`吗?

答案是是的，但是在 Python 写的爬虫中，yield 是被用来进行异步操作和作为生成器的。下面是 Python 爬虫中使用 yield 的一些常见场景及其优势：

1. 逐步获取网页数据：

在爬取大量网页时，如果一次性将所有数据加载到内存中，会占用大量内存。使用 yield 可以在每次请求到数据时返回一部分，允许逐步处理数据，而不是一次性获取所有内容。
这在处理分页数据时尤为常见，比如爬取多页列表数据时，通过生成器逐页获取。

示例：逐页爬取网页数据

import requests

def fetch_pages(url, max_pages=5):
 page = 1
 while page 
- 爬虫抓取到大量数据时，可以使用生成器逐个解析和处理每条记录。通过 `yield`，你可以在读取数据的同时进行解析，避免一次性处理所有数据。

- 这对于解析 JSON 格式的 API 数据或 HTML 页面中的条目非常有用。

**示例：逐条解析 JSON 数据**

```python
import requests
import json

def fetch_items(api_url):
 response = requests.get(api_url)
 data = json.loads(response.content)
 for item in data.get('results', []):
 yield item # 使用 yield 返回每一条记录

# 逐条处理数据
for item in fetch_items("https://example.com/api/data"):
 print(item)

这个例子中，fetch_items 函数使用 yield 将解析后的每条记录逐条返回。调用方可以一条条处理数据，适合处理数据量大的场景。

3. 实现异步爬取与处理：

在协程和异步编程中，yield 可以配合 asyncio 和 aiohttp 等库使用，构建异步生成器。这种方式可以同时爬取多个网页，而不必等待每一个网页的响应，从而提高爬取速度。
虽然在 Python 3.5 以后，async 和 await 更为常用，但 yield 仍然可以在某些特定场景中与异步生成器结合使用。

示例：异步爬虫中的生成器

import aiohttp
import asyncio

async def fetch(url):
 async with aiohttp.ClientSession() as session:
 async with session.get(url) as response:
 yield await response.text() # 使用 yield 返回网页内容

async def main(urls):
 for url in urls:
 async for page_content in fetch(url):
 print(f"Page content: {page_content[:100]}") # 打印前100个字符

urls = ["https://example.com/page1", "https://example.com/page2"]
asyncio.run(main(urls))

在这个例子中，fetch 是一个异步生成器函数，它使用 yield 返回每个请求到的网页内容。这种方式能够更高效地爬取多个网页。

4. 数据管道与流水线处理：

爬虫的数据处理往往需要多个步骤，比如下载页面、解析内容、提取信息等。使用 yield 可以在这些步骤之间构建数据管道，使得数据在各个步骤之间流动。
这种方式让爬虫的逻辑更加清晰，并且可以按需生成和处理数据。

示例：构建数据管道

def download_pages(urls):
 for url in urls:
 response = requests.get(url)
 if response.status_code == 200:
 yield response.content

def parse_pages(pages):
 for page in pages:
 # 假设这里使用 BeautifulSoup 解析 HTML
 yield page[:100] # 简单返回前100个字符作为示例

# 组合生成器
urls = ["https://example.com/page1", "https://example.com/page2"]
pages = download_pages(urls)
parsed_data = parse_pages(pages)

# 逐步处理数据
for data in parsed_data:
 print(f"Parsed data: {data}")

在这个例子中，download_pages 和 parse_pages 都是生成器，使用 yield 形成数据管道。这使得每个步骤都能逐步处理数据，避免一次性占用大量内存。

4. 异步操作和线程调度的区别

简单来说，异步操作和线程调度会在某种程度上有一些表现相似，但它们在设计理念、工作方式和适用场景上仍然存在显著的区别。

由于这是一个比较复杂的问题，而且撰写这篇文章的时候也比较晚了（2024年10月11日星期五02:59），所以这部分是待补充状态。

以下文章中讨论了异步操作和线程调度的区别：

https://dandansad.com/2025/04/26/%e5%90%8c%e6%ad%a5%e4%b8%8e%e5%bc%82%e6%ad%a5%ef%bc%9f/

当AI成熟之后，老板会选择AI还是真人？

Tue, 08 Oct 2024 12:08:51 +0800

自ChatGPT在2022年11月上线后，一路开挂，5天时间便突破百万用户，仅2个月时间月活用户就突破1亿，成为史上增速最快的消费级应用，远超TikTok、Facebook、Google等全球应用。也因此，ChatGPT掀起了一场全民AI热潮。

在当前科技迅猛发展的背景下，各种AI工具如雨后春笋般涌现，并迅速渗透到各行各业。从ChatGPT、Midjourney到自动驾驶技术，这些AI工具在数据分析、图像生成、自然语言处理等领域展现出了强大的能力。企业也纷纷引入AI技术来提升工作效率、降低运营成本。这种趋势使得AI逐渐从辅助工具演变为工作中的重要角色，企业管理者们也面临一个关键选择：当未来AI完全成熟时，是选择AI作为员工，还是保留真人作为员工？

要讨论这个问题，我认为最重要的前提应该要先行设置好，那就是AI的成熟程度。接下来的讨论将依照AI的成熟程度分为三个阶段进行讨论。

阶段一：AI只作为工作中的辅助工具

当AI只是作为工作中的辅助工具时，AI主要作为人类员工的“助手”，帮助他们提高工作效率。例如，在客服行业，AI可以通过自动化回答常见问题，减轻客服人员的负担；在金融领域，AI可以进行数据筛选和风险初步评估，为分析师提供辅助数据。在这一阶段，AI的作用更多是减少重复性劳动和优化流程，而对创造性和复杂决策的工作仍依赖于人类。此时，企业管理者通常会选择将AI与人类员工结合使用，以提高工作效率，为企业赚取更多利益。

阶段二：AI作为工作中的一大主力

随着AI技术的进一步发展，当AI作为工作中的一大主力时。在这个阶段，AI能够处理大多数门槛较低的工作，但仍需要人类的共同工作。在此时，管理者会倾向于减少人类员工的雇用，并且雇用的员工也会被要求能够与AI协同工作，以此进一步降低成本，提高工作效率，为企业赚取更多利益。

阶段三：AI成为合格员工

在这个阶段，AI已经发展得非常成熟，几乎可以替代大部分人类员工，甚至在某些方面超越了普通水平的员工。AI不仅能够处理复杂的任务，还具备高度的自主学习和适应能力，可以根据环境和需求不断优化自身的工作方式。AI只需要听从企业管理者的命令，自行迭代地完成相应工作。

而在这个阶段，企业管理者需要考虑的问题就是：是否要全面用AI替代人类员工，或是保留部分人类岗位。此时企业管理者最主要考虑的问题应该是成本问题。因为一个合格的AI员工各方面的开销也不一定会小于人类员工，所以一些简单的工作，出于成本考虑可能仍然会选择雇用人类员工。

一些遗漏

刚刚的讨论部分并没有提到一些头部的工作，在这里我是默认一些头部的工作是无法被替代的。因为拘于AI的原理特性，AI并不能进行自主的创新，因此一些头部的工作（复杂的、创新型的）是无法被替代的。

同时，我们的讨论还忽略掉了现实的一些法律法规、社会责任、企业形象等更广泛的考量。我们只是简单从盈利角度讨论这个问题，并不是对现实生活的完美预测。

总结

总的来说，一些不会被AI替代的职位一定会有以下几个特质：

成本比AI还要低的工作
行业里的顶尖工作
需要与人类有情感共鸣的工作
需要参杂人类道德判断的工作以及一些需要找到责任人的工作
剩余一些没有单独罗列的AI无法承担的工作

总结下来，老板会选择AI的情况就是AI能够胜任该工作并且当使用AI的费用会低于一个人类员工的情况。所以说，当AI成熟之后，老板会在大部分岗位都选择使用AI，然而仍会保留部分真人的岗位。