实验 4：高级系统和进程监控¶

目标¶

完成此实验后，您将能够

使用高级工具查看和管理进程
诊断和调试系统调用
使用高级 CLI 工具查看和设置进程优先级
查看和设置进程的自定义调度策略
分析系统和应用程序性能

完成此实验室的估计时间：90 分钟

简介¶

本实验中的命令涵盖了 Linux 中更广泛的进程管理、系统监控和资源控制。它们为您的系统管理员技能库增添了更多深度和多样性。

这些练习涵盖了额外的 Linux 命令和概念，提供了进程管理、资源监控和高级控制的实践经验。

练习 1¶

fuser¶

Linux 中的 fuser 命令用于识别使用文件或套接字的进程。它在文件相关的进程管理和冲突解决中非常有用。

创建脚本以模拟文件使用¶

首先，创建一个我们想要访问的空测试文件。键入
```
touch ~/testfile.txt
```

创建我们将用于模拟访问 testfile.txt 的脚本。键入

cat > ~/simulate_file_usage.sh << EOF
#!/bin/bash
tail -f ~/testfile.txt
EOF

使脚本可执行。键入
```
chmod +x ~/simulate_file_usage.sh
```
启动脚本。键入
```
~/simulate_file_usage.sh &
```

识别访问文件的进程¶

识别正在使用或访问 testfile.txt 的进程，运行
```
fuser ~/testfile.txt
```
使用 -v 选项探索其他 fuser 选项。键入
```
fuser -v ~/testfile.txt
```
testfile.txt 和 simulate_file_usage.sh 已经完成。您现在可以删除这些文件。键入
```
kill %1
rm ~/testfile.txt ~/simulate_file_usage.sh
```

识别访问 TCP/UDP 端口的进程¶

使用 fuser 命令识别正在访问服务器上 TCP 端口 22 的进程。键入
```
sudo fuser 22/tcp
```

练习 2¶

`perf`¶

perf 是一个用于分析 Linux 系统和应用程序性能的通用工具。它可以提供额外的见解，有助于性能调优。

安装 perf¶

如果 perf 应用程序未安装在您的服务器上，请进行安装。键入
```
sudo dnf -y install perf
```
bc 应用程序是一个命令行精确计算器。bc 将在此练习中使用以模拟高 CPU 负载。如果 bc 尚未在您的服务器上安装，请使用以下命令安装：
```
sudo dnf -y install bc
```

创建脚本以生成 CPU 负载¶

创建 CPU 负载脚本并使其可执行，运行

cat > ~/generate_cpu_load.sh << EOF
#!/bin/bash

# Check if the number of decimal places is passed as an argument
if [ "$#" -ne 1 ]; then
  echo "Usage: $0 <number_of_decimal_places>"
  exit 1
fi

# Calculate Pi to the specified number of decimal places
for i in {1..10}; do echo "scale=$1; 4*a(1)" | bc -l; done

EOF
chmod +x ~/generate_cpu_load.sh

技巧

generate_cpu_load.sh 脚本是一个简单的工具，通过高精度计算 Pi (π) 来生成 CPU 负载。相同的计算执行 10 次。该脚本接受一个整数作为参数，用于指定计算 Pi 的小数点位数。

模拟额外的 CPU 负载¶

运行一个简单的测试并计算 Pi 到 50 位小数。键入以下命令运行脚本：
```
~/generate_cpu_load.sh 50 & 
```
重新运行脚本，但使用 perf 记录脚本的性能，以分析 CPU 使用率和其他指标。键入
```
 ./generate_cpu_load.sh 1000  &  perf record -p $! sleep 5
```
技巧

perf record 命令中的 sleep 5 选项定义了 perf 收集 CPU 负载性能数据的时间窗口，该 CPU 负载由 generate_cpu_load.sh 脚本生成。它允许 `perf` 在自动停止之前记录 5 秒钟的系统性能指标。

分析性能数据并监控实时事件¶

使用 perf report 命令查看性能数据报告，以了解 CPU 和内存利用率模式。键入
```
sudo perf report
```
您可以使用各种键盘按键进一步探索报告。键入 q 退出/关闭 perf 报告查看器界面。
观察/捕获 40 秒的实时 CPU 缓存事件，以识别潜在的性能瓶颈。键入
```
sudo perf stat -e cache-references,cache-misses sleep 40
```

记录系统的全面性能¶

捕获系统范围的性能数据，可用于额外分析。键入
```
sudo perf record -a sleep 10
```
探索特定的事件计数器。计算 CPU 周期等特定事件，以评估给定脚本或应用程序的性能。让我们用一个基本的 find 命令进行测试，键入
```
sudo perf stat -e cycles find /proc
```
用 generate_cpu_load.sh 脚本执行相同的操作。计算 CPU 周期等特定事件，以评估 generate_cpu_load.sh 脚本的性能。键入
```
sudo perf stat -e cycles ./generate_cpu_load.sh 500
```
输出
```
...<SNIP>...
3.141592653589793238462643383279502884197169399375105820974944592307\
81640628620899862803482534211.....

Performance counter stats for './generate_cpu_load.sh 500':

  1,670,638,886      cycles

     0.530479014 seconds time elapsed

     0.488580000 seconds user
     0.034628000 seconds sys
```
注意

这是 perf stat 命令最终示例输出的明细：

1,670,638,886 cycles：这表示脚本执行期间消耗的总 CPU 周期数。每个周期代表 CPU 指令执行的一个步骤。

0.530479014 seconds time elapsed：这是脚本执行开始到结束的总实际经过时间（或挂钟时间）。此持续时间包括所有类型的等待（例如等待磁盘 I/O 或系统调用）。

0.488580000 seconds user：这是在用户模式下花费的 CPU 时间。此时间不包括显式花费在系统级任务上的时间。

0.034628000 seconds sys：这是在内核或系统模式下花费的 CPU 时间。这包括 CPU 花费在代表脚本执行系统调用或执行其他系统级任务上的时间。
perf 工具已全部完成。确保任何后台脚本都已结束，以保持干净的工作环境。
```
kill %1
```

练习 3¶

`strace`¶

strace 用于诊断和调试 Linux 中的系统调用交互。

创建脚本以探索 strace¶

创建一个名为 strace_script.sh 的简单脚本并使其可执行。键入

cat > ~/strace_script.sh << EOF
#!/bin/bash
while true; do
  date
  sleep 1
done
EOF
chmod +x ~/strace_script.sh

对正在运行的进程使用 strace¶

运行脚本并附加 strace。键入
```
~/strace_script.sh &
```
在单独的终端中查找 strace_script.sh 进程的 PID。将 PID 存储在名为 MYPID 的变量中。通过运行以下命令使用 pgrep 命令：
```
export MYPID=$(pgrep strace_script) ; echo $MYPID
```
输出
```
4006301
```
开始跟踪脚本的系统调用，以了解它如何与内核交互。通过键入以下命令将 strace 附加到正在运行的脚本进程：
```
sudo strace -p $MYPID
```
通过键入 Ctrl+C 分离或停止 strace 进程。
strace 输出可以通过专注于特定的系统调用（如 open 和 read）来过滤，以分析它们的行为。尝试为 open 和 read 系统调用执行此操作。键入
```
sudo strace -e trace=open,read -p $MYPID
```
当您完成尝试解读 strace 输出后，通过键入 Ctrl+C 停止 strace 进程。
将输出重定向到文件以供以后分析，这有助于诊断问题。通过运行以下命令将 strace 输出保存到文件：
```
sudo strace -o strace_output.txt -p $MYPID
```

分析系统调用的频率¶

总结系统调用计数，以识别进程使用频率最高的系统调用。仅执行 10 秒钟，通过附加 timeout 命令。键入

sudo timeout 10 strace -c -p $MYPID

您的示例系统显示如下的摘要报告输出：

输出

strace: Process 4006301 attached
strace: Process 4006301 detached
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
89.59    0.042553        1182        36        18 wait4
7.68    0.003648         202        18           clone
1.67    0.000794           5       144           rt_sigprocmask
0.45    0.000215           5        36           rt_sigaction
0.36    0.000169           9        18           ioctl
0.25    0.000119           6        18           rt_sigreturn
------ ----------- ----------- --------- --------- ----------------
100.00    0.047498         175       270        18 total

终止脚本并删除创建的任何文件。

kill $MYPID
rm ~/strace_script.sh ~/strace_output.txt

练习 4¶

`atop`¶

atop 提供系统性能的全面视图，涵盖各种资源指标。

启动并探索 atop¶

如果 atop 应用程序未安装在您的服务器上，请进行安装。键入
```
sudo dnf -y install atop
```
键入以下命令运行 atop：
```
sudo atop
```
在 atop 界面中，您可以通过按键盘上的特定键来探索各种 atop 指标。

使用 'm'、'd' 或 'n' 在内存、磁盘或网络视图之间切换。实时观察资源的使用情况。
以 2 秒的自定义间隔监控系统性能，从而更精细地查看系统活动。键入
```
sudo atop 2
```
在不同的资源视图之间切换，以专注于系统性能的特定方面。
生成系统活动的日志文件报告，每 60 秒捕获一次数据，共三次。键入
```
sudo atop -w /tmp/atop_log 60 3
```
在上一条命令完成后，您可以花时间查看保存日志的二进制文件。要读取保存的日志文件，请键入
```
sudo atop -r /tmp/atop_log   
```
清理，删除生成的任何日志或文件。
```
sudo rm /tmp/atop_log
```

练习 5¶

`numactl`¶

它是一种用于多处理的计算机内存设计/架构，通过考虑内存相对于处理器的物理位置来提高内存访问速度。在基于 NUMA 的系统中，多个处理器（或 CPU 核心）在物理上分组，每个组都有其本地内存。

numactl 应用程序管理 NUMA 策略，以优化基于 NUMA 的系统的性能。

安装 numactl¶

如果 numactl 应用程序未安装在您的服务器上，请进行安装。键入
```
sudo dnf -y install numactl
```

创建内存密集型脚本¶

创建一个简单的脚本以帮助模拟服务器上的内存密集型工作负载。键入

cat > ~/memory_intensive.sh << EOF
  #!/bin/bash

  awk 'BEGIN{for(i=0;i<1000000;i++)for(j=0;j<1000;j++);}{}'
  EOF
  chmod +x ~/memory_intensive.sh

使用 numactl¶

键入以下命令运行脚本：

numactl --membind=0 ~/memory_intensive.sh

如果您的系统有多个 NUMA 节点可用，您可以运行该脚本跨多个 NUMA 节点，方法如下：
```
numactl --cpunodebind=0,1 --membind=0,1 ~/memory_intensive.sh
```
显示 NUMA 节点上的内存分配
```
numactl --show
```
通过运行以下命令将内存绑定到特定节点：
```
numactl --membind=0 ~/memory_intensive.sh
```
通过删除脚本来清理您的工作环境。
```
rm ~/memory_intensive.sh
```

练习 6¶

`iotop`¶

iotop 命令监控进程和线程的磁盘 I/O（输入/输出）使用情况。它提供与 top 命令类似的实时信息，但专门针对磁盘 I/O。这对于诊断由磁盘活动引起的系统减速至关重要。

安装 iotop¶

如果 iotop 实用程序未安装，请进行安装。键入
```
sudo dnf -y install iotop
```

使用 iotop 监控磁盘 I/O¶

在不带任何选项的情况下运行 iotop 命令，以在其默认的交互模式下使用。键入
```
sudo iotop
```
观察各种进程的实时磁盘 I/O 使用情况。使用此命令来识别当前正在从磁盘读取或向磁盘写入数据的进程。
键入 q 退出或关闭 iotop。

以非交互模式使用 iotop¶

以批处理模式（-b）运行 iotop，以获得非交互的、一次性的 I/O 使用情况视图。-n 10 选项告诉 iotop 在退出前进行 10 次采样。
```
sudo iotop -b -n 10
```
iotop 可以过滤特定进程的 I/O。使用 ps 命令或 iotop 显示来识别系统中的进程 ID (PID)。然后，过滤该特定 PID 的 iotop 输出。例如，通过运行以下命令过滤 sshd 进程的 PID：
```
sudo iotop -p $(pgrep sshd | head -1)
```
iotop 中的 -o 选项可用于显示正在执行实际 I/O 的进程或线程，而不是显示所有进程或线程。通过运行以下命令仅显示 I/O 进程：
```
sudo iotop -o
```
讨论

讨论磁盘 I/O 对整体系统性能的影响，以及像 iotop 这样的工具如何有助于系统优化。

练习 7¶

`cgroups`¶

控制组 (cgroups) 提供了一种在 Linux 中组织、限制和优先处理进程资源使用情况的机制。

本实验演示了与 cgroup v2 文件系统的直接交互。

探索 cgroup 文件系统¶

使用 ls 命令探索 cgroup 文件系统的内容和结构。键入
```
ls /sys/fs/cgroup/
```
再次使用 ls 命令列出 cgroup 文件系统下的 *.slice 文件夹。键入
```
ls -d /sys/fs/cgroup/*.slice
```
带有 .slice 后缀的文件夹通常在 systemd 中用于表示系统资源的切片。这些是 systemd 管理的标准 cgroups，用于组织和管理系统进程。

创建自定义 cgroup¶

在 /sys/fs/cgroup 文件系统下创建一个名为 "exercise_group" 的目录。这个新文件夹将包含此练习其余部分所需的控制组结构。使用 mkdir 命令，键入
```
sudo mkdir -p /sys/fs/cgroup/exercise_group
```
列出 /sys/fs/cgroup/exercise_group 结构下的文件和目录。键入
```
sudo ls /sys/fs/cgroup/exercise_group/
```
输出显示了 cgroup 子系统自动创建的文件和目录，用于管理和监控 cgroup 的资源。

设置新的内存资源限制¶

设置内存资源限制，将内存使用限制为 4096 字节 (4kB)。要将 cgroup 中的进程限制为最多使用 4kB 内存，请键入
```
echo 4096 | sudo tee /sys/fs/cgroup/exercise_group/memory.max
```

确认内存限制已设置。键入

cat /sys/fs/cgroup/exercise_group/memory.max

创建 memory_stress 测试脚本¶

使用 dd 命令创建一个简单的可执行脚本来测试内存资源限制。键入

bash cat > ~/memory_stress.sh << EOF #!/bin/bash dd if=/dev/zero of=/tmp/stress_test bs=10M count=2000 EOF chmod +x ~/memory_stress.sh

运行并将进程/脚本添加到内存 cgroup¶

启动 memory_stress.sh 脚本，捕获其 PID，并将 PID 添加到 cgroup.procs。键入
```
~/memory_stress.sh &
echo $! | sudo tee /sys/fs/cgroup/exercise_group/cgroup.procs
```
使用 /sys/fs/cgroup/exercise_group/cgroup.procs 文件来添加或查看属于给定 cgroup 的进程的 PID（进程 ID）。将 PID 写入此文件会将 memory_stress.sh 脚本进程分配给 exercise_group cgroup。
由于内存超过了 cgroup 的限制，因此上一个命令将非常快速地结束，而无法完成。您可以在另一个终端中使用以下 journalctl 命令来查看发生的错误。键入
```
journalctl -xe -f  | grep -i memory
```
技巧

如果您知道进程的 PID，您可以使用 ps 命令快速检查进程的大致内存使用情况，方法是运行
```
pidof <PROCESS_NAME> | xargs ps -o pid,comm,rss
```
此输出应显示指定进程在某个时间点使用的内存（以 KB 为单位的驻留集大小 RSS）。当进程的 RSS 值超过 cgroup 的 memory.max 值中指定的内存限制时，该进程可能会受到内核或 cgroup 本身强制执行的内存管理策略的影响。根据系统配置，系统可能会采取措施，例如限制进程的内存使用、杀死进程或触发内存不足 (OOM) 事件。

设置新的 CPU 资源限制¶

将脚本限制为仅使用一个 CPU 核心的 10%。键入
```
echo 10000 | sudo tee /sys/fs/cgroup/exercise_group/cpu.max
```
10000 代表 CPU 带宽限制。它设置为单个 CPU 核心总容量的 10%。

确认 CPU 限制已设置。键入

cat /sys/fs/cgroup/exercise_group/cpu.max

创建 CPU stress 测试脚本¶

创建一个脚本并为其设置可执行权限，以生成高 CPU 使用率。键入
```
cat > ~/cpu_stress.sh << EOF
#!/bin/bash
exec yes > /dev/null
EOF
chmod +x ~/cpu_stress.sh
```
注意

yes > /dev/null 是一个产生高 CPU 负载的简单命令。

运行并将进程/脚本添加到 CPU cgroup¶

运行脚本并立即将其 PID 添加到 cgroup，键入

~/cpu_stress.sh &
echo $! | sudo tee /sys/fs/cgroup/exercise_group/cgroup.procs

确认进程 CPU 使用资源控制¶

检查进程的 CPU 使用情况。
```
pidof yes | xargs top -b -n 1 -p
```
输出应显示 yes 进程的实时 CPU 使用情况。yes 的 %CPU 应根据 cgroup 配置受到限制（例如，如果限制设置为 10000，则约为 10%）。
为 exercise_group cgroup 设置并尝试其他 cpu.max 值，然后在每次在控制组中重新运行 ~/cpu_stress.sh 脚本时观察效果。

识别和选择主存储设备¶

主存储设备可以是设置 I/O 资源限制的目标。Linux 系统上的存储设备具有主设备号和次设备号，可用于唯一标识它们。

首先，创建一组辅助变量来检测并存储服务器上主存储设备的设备号。键入

primary_device=$(lsblk | grep disk | awk '{print $1}' | head -n 1)
primary_device_num=$(ls -l /dev/$primary_device | awk '{print $5, $6}' | sed 's/,/:/')

显示 $primary_device_num 变量的值。键入

echo "Primary Storage Device Number: $primary_device_num"

主次设备号应与您在此 ls 输出中看到的内容匹配
```
  ls -l /dev/$primary_device
```

设置新的 I/O 资源限制¶

将 exercise_group cgroup 下的读写进程的 I/O 操作设置为 1 MB/s。键入

echo "$primary_device_num rbps=1048576 wbps=1048576" | \
sudo tee /sys/fs/cgroup/exercise_group/io.max

确认 I/O 限制已设置。键入

cat /sys/fs/cgroup/exercise_group/io.max

创建 I/O stress 测试进程¶

启动一个 dd 进程以创建一个名为 /tmp/io_stress 的大文件。同时，捕获并存储 dd 进程的 PID 在名为 MYPID 的变量中。键入
```
dd if=/dev/zero of=/tmp/io_stress bs=10M count=500 oflag=dsync \
& export MYPID=$!
```

将进程/脚本添加到 I/O cgroup¶

将前面 dd 进程的 PID 添加到 exercise_group 控制 cgroup。键入

echo $MYPID | sudo tee /sys/fs/cgroup/exercise_group/cgroup.procs

确认进程 I/O 使用资源控制¶

通过执行以下命令检查进程的 I/O 使用情况：
```
iotop -p $MYPID
```
输出将显示 io_stress.sh 进程的 I/O 读/写速度，根据限制，其速度不应超过 1 MB/s。

删除 cgroups¶

键入以下命令以停止任何后台进程，删除不再需要的 cgroup，并删除 /tmp/io_stress 文件。
```
kill %1
sudo rmdir /sys/fs/cgroup/exercise_group/
sudo rm -rf /tmp/io_stress
```

练习 8¶

`taskset`¶

CPU 亲和性将特定进程或线程绑定到多核系统中的特定 CPU 核心。本实验演示了使用 taskset 在 Linux 中设置或检索进程的 CPU 亲和性。

使用 taskset 探索 CPU 亲和性¶

使用 lscpu 列出系统上的可用 CPU。键入
```
lscpu | grep "On-line"
```
使用 dd 实用程序创建一个示例进程，并将其 PID 存储在 MYPID 变量中。键入
```
dd if=/dev/zero of=/dev/null & export MYPID="$!"
echo $MYPID
```
检索 dd 进程的当前亲和性。键入
```
taskset -p $MYPID
```
输出
```
pid 1211483's current affinity mask: f
```
输出显示了 PID 为 1211483 ($MYPID) 的进程的 CPU 亲和性掩码，以十六进制格式表示。在我们的示例系统中，显示的亲和性掩码是 "f"，通常意味着该进程可以在任何 CPU 核心上运行。

注意

CPU 亲和性掩码 "f" 代表一个所有 CPU 核心都启用的配置。在十六进制表示法中，"f" 对应于二进制值 "1111"。二进制表示中的每个位都对应一个 CPU 核心，"1" 表示该核心已启用且可供进程运行。

因此，在四核 CPU 上，使用掩码 "f"：

核心 0：已启用核心 1：已启用核心 2：已启用核心 3：已启用

设置/更改 CPU 亲和性¶

将 dd 进程的 CPU 亲和性设置为单个 CPU（CPU 0）。键入

taskset -p 0x1 $MYPID

输出

pid 1211483's current affinity mask: f
pid 1211483's new affinity mask: 1

通过运行以下命令验证更改：
```
taskset -p $MYPID
```
输出显示了 PID 为 $MYPID 的进程的 CPU 亲和性掩码。亲和性掩码以十进制表示为 "1"，这转化为二进制表示为 "1"。这意味着该进程当前绑定到 CPU 核心 0。
现在，将 dd 进程的 CPU 亲和性设置为多个 CPU（CPU 0 和 CPU 1）。键入
```
taskset -p 0x3 $MYPID
```
发出正确的 tasksel 命令以验证最新更改。
```
taskset -p $MYPID
```
在我们演示的 4 核 CPU 服务器上，输出显示进程的 CPU 亲和性掩码为 "3"（十进制）。这转化为二进制的 "11"。

技巧

十进制 "3" 在二进制中是 "11"（或 0011）。每个二进制数字对应一个 CPU 核心：核心 0、核心 1、核心 2、核心 3（从右到左）。从右边开始的第四个和第三个位置的数字 "1" 表示该进程可以在核心 0 和核心 1 上运行。因此，"3" 表示该进程绑定到 CPU 核心 0 和 1。
在单独的终端中启动 top 或 htop 实用程序，并在尝试为某个进程配置不同的 taskset 配置时观察是否有任何值得注意之处。
一切完成。使用其 PID ($MYPID) 终止 dd 进程。

练习 9¶

`systemd-run`¶

systemd-run 命令创建并启动临时服务单元，用于运行命令或进程。它还可以运行临时范围单元、路径/套接字/计时器触发的服务单元中的程序。

本实验展示了如何使用 systemd-run 在 systemd 中创建临时服务单元。

将命令作为临时服务运行¶

使用 systemd-run 将简单的 sleep 300 命令作为临时 systemd 服务运行。键入

systemd-run --unit=mytransient.service --description="Example Service" sleep 300

使用 systemctl status 检查临时服务的状态。键入
```
systemctl status mytransient.service
```

为临时服务设置内存资源限制¶

使用 --property 参数和 systemd-run 将临时进程的最大内存使用量限制为 200M。键入
```
systemd-run --unit=mylimited.service --property=MemoryMax=200M sleep 300
```
查看对应 cgroup 文件系统中的进程以验证设置。键入
```
sudo cat /sys/fs/cgroup/system.slice/mytransient.service/memory.max
```
技巧

systemd.resource-control 是 systemd 框架内的一个配置或管理实体（概念），用于控制和分配系统资源给进程和服务。而 systemd.exec 是 systemd 的一个组件，负责定义命令运行的执行环境。要查看使用 systemd-run 时可以调整的各种设置（属性），请查阅 systemd.resource-control 和 systemd.exec 的手册页。在这里，您将找到 MemoryMax、CPUAccounting、IOWeight 等属性的文档。

为临时服务设置 CPU 资源限制¶

创建一个名为 "myrealtime.service" 的临时 systemd 单元。使用特定的轮转调度策略 (rr) 和优先级运行 myrealtime.service。键入
```
systemd-run --unit=myrealtime.service \
--property=CPUSchedulingPolicy=rr --property=CPUSchedulingPriority=50 sleep 300
```
查看 myrealtime.service 的状态。另外，捕获/存储主 [sleep] PID 到 MYPID 变量。键入
```
MYPID=$(systemctl status myrealtime.service   |  awk '/Main PID/ {print $3}')
```

在服务仍在运行时，验证其 CPU 调度策略。键入

chrt  -p $MYPID
pid 2553792's current scheduling policy: SCHED_RR
pid 2553792's current scheduling priority: 50

创建临时计时器单元¶

创建一个简单的计时器单元，它运行一个简单的 echo 命令。--on-active=2m 选项将计时器设置为在计时器单元激活后 2 分钟触发。键入
```
systemd-run --on-active=2m --unit=mytimer.timer \
--description="Example Timer" echo "Timer triggered"
```
计时器将从单元激活时开始倒计时，并在 2 分钟后触发指定的操作。
查看刚刚创建的计时器单元的详细信息/状态。键入
```
systemctl status mytimer.timer
```

停止并清理临时 systemd 单元¶

键入以下命令，以确保本练习中启动的各种临时服务/进程已正确停止并从您的系统中移除。键入

systemctl stop mytransient.service
systemctl stop mylimited.service
systemctl stop myrealtime.service
systemctl stop mytimer.timer

练习 10¶

`schedtool`¶

本实验演示了使用 schedtool 在 Rocky Linux 中理解和操作进程调度。您还将创建一个脚本来模拟一个用于此目的的进程。

安装 schedtool¶

如果 schedtool 应用程序未安装在您的服务器上，请进行安装。键入
```
sudo dnf -y install schedtool
```

创建模拟进程脚本¶

创建一个生成 CPU 负载以用于测试目的的脚本。键入

cat > ~/cpu_load_generator.sh << EOF
#!/bin/bash
while true; do
     openssl speed > /dev/null 2>&1
     openssl speed > /dev/null 2>&1

done
EOF
chmod +x ~/cpu_load_generator.sh

在后台启动脚本。键入
```
~/cpu_load_generator.sh & echo $!
```
捕获在 cpu_load_generator.sh 脚本中启动的主 openssl 进程的 PID。将 PID 存储在名为 $MYPID 的变量中。键入
```
export  MYPID=$(pidof openssl) ; echo $MYPID
```

使用 schedtool 检查当前调度策略¶

使用 schedtool 命令显示 PID 为 $MYPID 的进程的调度信息。键入

schedtool $MYPID

输出

PID 2565081: PRIO   0, POLICY N: SCHED_NORMAL  , NICE   0, AFFINITY 0xf

使用 schedtool 修改调度策略¶

将进程的调度策略和优先级分别更改为 FIFO 和 10。键入
```
sudo schedtool -F -p 10 $!
```
查看更改的效果。键入
```
schedtool $MYPID
```
将进程的调度策略和优先级分别更改为轮转 (SCHED_RR) 和 50。键入
```
  sudo schedtool -R -p 50 $MYPID
```
查看更改的效果。键入
```
schedtool $MYPID
```
将进程的调度策略更改为 Idle 或 SCHED_IDLEPRIO (D)。键入
```
sudo schedtool -D $MYPID
```
查看更改的效果。
最后，将进程的调度策略重置回原始默认值 SCHED_NORMAL (N 或其他)。键入
```
sudo schedtool -N $MYPID
```

终止并清理 cpu_load_generator.sh 进程¶

一切完成。终止脚本并删除 cpu_load_generator.sh 脚本。
```
kill $MYPID
rm ~/cpu_load_generator.sh
```

作者：Wale Soyinka

贡献者：Steven Spencer, Ganna Zhrynova