跟运维学 Linux - 03

孤寂人生

权限机制和性能指标

前面我们学完了操作文件和用户相关知识，本篇学习权限和性能相关知识。
文件的属性看起

看 linux 的权限，先从文件的属性看起
ls -l 加 -d 是只看这个文件夹：

1. pjl@pjl-pc:~$ sudo ls -ld /root
2. drwx------ 8 root root 4096 7月  18 16:20 /root

复制代码

最左侧的 d 表示目录，这个前面已经说过，后面的又是什么？我们两部分来讲：rwx------、root root。
属主和属组

root root，第一个 root 表示这个文件夹是 root 用户，后一个 root 表示这个文件夹是 root 组的。
专业的叫法，前者叫做文件夹的属主，后者叫做文件夹的属组。
我们再来看一个：

1. pjl@pjl-pc:~$ ls -ld /home/test19
2. drwxr-xr-x 2 test19 test19 4096 7月  18 15:32 /home/test19

复制代码

这里说明 /home/test19 文件夹的主人是 test19 用户，test19 组成员也是这个文件夹的主人。
既然 root 用户和 root 组成员是 /root 文件夹的主人，是否就可以对其为所欲为？
权限位

明白了属主和属组，如何看一个一个的文件以及文件夹的权限？
我们把 rwx------ 拆成三部分来看：rwx、---、---。
root 用户的权限对应第一部分：rwx。可读，可写，可执行。
root 组成员的权限对应第二部分：---。不可读、不可写、不可执行
权限位由三部分组成：读权限(r/-) + 写权限(w/-) + 执行权限(x/-)。
位权限和普通文件的关系

普通文件和文件夹的权限位，代表的意思不一样。
先看普通文件：

1. pjl@pjl-pc:~/linux-test$ ls -l
2. 总用量 4
3. -rwxrw-r-- 1 pjl pjl 6 7月  19 17:14 a.txt

复制代码

pjl 用户对应的权限是可读可写可执行（rwx）。
对于 pjl 组成员的权限是可读可写不可执行（rw-）。
对于普通文件，可读就是能读取（例如 cat、head）文件内容：

1. pjl@pjl-pc:~/linux-test$ cat a.txt
2. apple

复制代码

对于普通文件，可写权限就是可以通过编辑保存。如果没有写权限，vim 不让你保存。
可执行权限，后续讲脚本的时候再说，简单理解：是否可以运行脚本。

1. // 创建一个脚本
2. pjl@pjl-pc:~/linux-test$ ls -l
3. -rw-rw-r-- 1 pjl pjl 26 7月  19 17:40 a.sh
4. // 没有执行权限
5. pjl@pjl-pc:~/linux-test$ ./a.sh
6. -bash: ./a.sh: 权限不够
7. // 增加执行权限
8. pjl@pjl-pc:~/linux-test$ chmod u+x a.sh
9. pjl@pjl-pc:~/linux-test$ ls -l
10. -rwxrw-r-- 1 pjl pjl 26 7月  19 17:40 a.sh
11. // 能执行了
12. pjl@pjl-pc:~/linux-test$ ./a.sh
13. hello

复制代码

位权限和文件夹的关系

以这个文件夹为例：

1. pjl@pjl-pc:~/linux-test$ ls -ld dir1
2. d-wxrwxr-x 2 pjl pjl 4096 7月  19 18:38 dir1

复制代码

文件夹如果有读权限，才能使用 ls：

1. pjl@pjl-pc:~/linux-test$ ls dir1
2. ls: 无法打开目录'dir1': 权限不够

复制代码

文件夹写权限，表示我们可以改变这个文件夹下的内容。比如创建文件、删除文件、创建子文件夹。

1. pjl@pjl-pc:~/linux-test$ touch dir1/b.txtpjl@pjl-pc:~/linux-test$ ls dir1
2. ls: 无法打开目录'dir1': 权限不够

复制代码

文件夹执行权限，表示能不能进入这个文件夹。最直接就是 cd 能不能用：

1. pjl@pjl-pc:~/linux-test$ cd dir1
2. pjl@pjl-pc:~/linux-test/dir1$ ls
3. ls: 无法打开目录'.': 权限不够
4. // 虽然文件夹没有读权限，但可以查看里面的文件内容
5. pjl@pjl-pc:~/linux-test/dir1$ cat b.txt
6. i am b.txt

复制代码

其他用户权限

rwx------ 的最后三位(---)表示其他用户的权限。也就是属主和属组以外的用户。
例如 /root 文件夹对于其他用户的权限是---：不可读、不可写、不可执行

1. drwx------ 12 root root 4096 6月  14 09:35 /root

复制代码

我们创建用户 user1 去读、写和执行：

1. // 不可读
2. user1@pjl-pc:~$ ls /root
3. ls: 无法打开目录'/root': 权限不够
4. // 不可执行
5. user1@pjl-pc:~$ cd /root
6. -bash: cd: /root: 权限不够
7. // 不可写
8. user1@pjl-pc:~$ touch /root/a.txt
9. touch: 无法创建 '/root/a.txt': 权限不够
10. user1@pjl-pc:~$

复制代码

修改权限

如何修改权限，用一个小任务来举例说明。
linux 下有一个用户 user1，他的家目录是 /home/user1，不过目前他无法进入自己的家目录。

1. pjl@pjl-pc:~/linux-test$ su - user1
2. 输入密码
3. su: warning: cannot change directory to /home/user1: 权限不够
4. -bash: /home/user1/.bash_profile: 权限不够
5. user1@pjl-pc:/home/pjl/linux-test$ ls /home/user1
6. ls: 无法打开目录'/home/user1': 权限不够

复制代码

作为系统管理员，我们要查看原因:

1. pjl@pjl-pc:~/linux-test$ ls -ld /home/user1
2. d--------- 4 root root 4096 7月  19 19:01 /home/user1

复制代码

这里有两个问题：

• 属主和属组不应该是 root，而应该是用户自己
  
• 位权限都是 -
  

使用 chown 改变属主和数组：

1. pjl@pjl-pc:~/linux-test$ sudo chown -R user1:user1 /home/user1
2. pjl@pjl-pc:~/linux-test$ ls -ld /home/user1
3. d--------- 4 user1 user1 4096 7月  19 19:01 /home/user1

复制代码

现在还是进不去，需要修改位权限。
使用 chmod 修改位权限：

1. // u=rwx 给属主位权限设置成 rwx
2. pjl@pjl-pc:~/linux-test$ sudo chmod u=rwx /home/user1
3. pjl@pjl-pc:~/linux-test$ ls -ld /home/user1
4. drwx------ 4 user1 user1 4096 7月  19 19:01 /home/user1
5. // g=rx 给属组位权限位设置成 rx
6. pjl@pjl-pc:~/linux-test$ sudo chmod g=rx /home/user1
7. pjl@pjl-pc:~/linux-test$ ls -ld /home/user1
8. drwxr-x--- 4 user1 user1 4096 7月  19 19:01 /home/user1

复制代码

Tip：用数字设置权限位更方便

1. // 同时设置属主、属组和其他用户权限
2. // 7 = r(4) + w(2) + x(1)
3. // 7 = r(4) + w(2) + x(1)
4. // 4 = r(4)
5. pjl@pjl-pc:~/linux-test$ sudo chmod 774 /home/user1
6. pjl@pjl-pc:~/linux-test$ ls -ld /home/user1
7. drwxrwxr-- 4 user1 user1 4096 7月  19 19:01 /home/user1

复制代码

现在就正常了：

1. pjl@pjl-pc:~/linux-test$ su - user1
2. 输入密码
3. user1@pjl-pc:~$ pwd
4. /home/user1
5. user1@pjl-pc:~$ ls -ld /home/user1
6. drwxrwxr-- 4 user1 user1 4096 7月  19 19:01 /home/user1

复制代码

性能指标

作为 linux 工程师，会听到主管：现在服务器够用吗，要在买几台吗？
先登录一遍服务器，查看当前容量和性能，在做决定。
在 linux 下如何查看性能指标？赶快学一下！
磁盘

先执行命令 df（disk free 的缩写）查看磁盘使用情况：

1. pjl@pjl-pc:~/linux-test$ df -h
2. 文件系统        容量  已用  可用 已用% 挂载点
3. udev            3.8G  4.0K  3.8G    1% /dev
4. tmpfs           790M  1.4M  788M    1% /run
5. /dev/sda3        98G   23G   71G   25% /
6. /dev/sda2       2.0G  319M  1.5G   18% /boot
7. /dev/sda1       511M   11M  501M    3% /boot/efi
8. /dev/sda5       708G   55G  618G    9% /data

复制代码

感觉看不太懂！
我们最关心的是还剩多少空间，我们可以关注可用和已用%这2列。
每一行就是硬盘上各个分区的使用情况。
什么是分区，和windows的C盘、D盘有什么不同？带着这些疑问我们进入下一节。
硬盘和分区

以我们熟悉的 windows 为例，一块硬盘分成了两个分区（01、02），通常我们使用鼠标点击图标（C盘）进入分区01，或者用鼠标点击图标（D盘）进入分区02
在 linux 中，一块磁盘也分成两个分区（01、02），不同的是没有图标（C盘、D盘），也没有鼠标，而是通过目录进入对应的分区。
我们用命令 fdisk -l（全称是 fixed disk） 查看有几块硬盘，几个分区：

1. pjl@pjl-pc:~/linux-test$ sudo fdisk -l
2. Disk /dev/sda：931.53 GiB，1000204886016 字节，1953525168 个扇区
3. Disk model: WDC WD10EZEX-08W
4. 单元：扇区 / 1 * 512 = 512 字节
5. 扇区大小(逻辑/物理)：512 字节 / 4096 字节
6. I/O 大小(最小/最佳)：4096 字节 / 4096 字节
7. 磁盘标签类型：gpt
8. 磁盘标识符：ADCE9537-745A-4B58-94AD-E260DD688EF6
10. 设备             起点       末尾       扇区   大小 类型
11. /dev/sda1        2048    1050623    1048576   512M EFI 系统
12. /dev/sda2     1050624    5244927    4194304     2G Linux 文件系统
13. /dev/sda3     5244928  214960127  209715200   100G Linux 文件系统
14. /dev/sda4   214960128  424675327  209715200   100G Linux 文件系统
15. /dev/sda5   424675328 1934133247 1509457920 719.8G Linux 文件系统
16. /dev/sda6  1934133248 1953523711   19390464   9.3G Linux swap

复制代码

最上方的 /dev/sda 表一块磁盘。前面我们说过“linux 中一切都是文件”。在 linux 中，用来表示硬盘和分区（或者说设备）的文件，统一放在 /dev 目录中。
sda 代表什么？将其拆开 sd 和 a。sd 表示 SATA 接口的硬盘，而 a 表示第一块硬盘，如果有更多的硬盘，就顺序往下排列：b、c、d...
Tip: 一般个人电脑，硬盘接口分两种，老式的 ide硬盘 和新的 SATA硬盘，现在基本上都是 SATA。
磁盘上的分区就用数字表示，例如sda硬盘的分区：/dev/sda1、/dev/sda2...
结合 fdisk 和 df

现在我们结合 fdisk 和 df 来查看：

1. pjl@pjl-pc:~/linux-test$ sudo fdisk -l
2. 输入密码
3. Disk /dev/sda：931.53 GiB，1000204886016 字节，1953525168 个扇区
4. Disk model: WDC WD10EZEX-08W
5. 单元：扇区 / 1 * 512 = 512 字节
6. 扇区大小(逻辑/物理)：512 字节 / 4096 字节
7. I/O 大小(最小/最佳)：4096 字节 / 4096 字节
8. 磁盘标签类型：gpt
9. 磁盘标识符：ADCE9537-745A-4B58-94AD-E260DD688EF6
11. 设备             起点       末尾       扇区   大小 类型
12. /dev/sda1        2048    1050623    1048576   512M EFI 系统
13. /dev/sda2     1050624    5244927    4194304     2G Linux 文件系统
14. /dev/sda3     5244928  214960127  209715200   100G Linux 文件系统
15. /dev/sda4   214960128  424675327  209715200   100G Linux 文件系统
16. /dev/sda5   424675328 1934133247 1509457920 719.8G Linux 文件系统
17. /dev/sda6  1934133248 1953523711   19390464   9.3G Linux swap

复制代码

df 最左侧是分区，最右侧是分区的入口：

1. pjl@pjl-pc:~/linux-test$ df -h
2. 文件系统        容量  已用  可用 已用% 挂载点
3. udev            3.8G  4.0K  3.8G    1% /dev
4. tmpfs           790M  1.4M  788M    1% /run
5. /dev/sda3        98G   23G   71G   25% /
6. /dev/sda2       2.0G  319M  1.5G   18% /boot
7. /dev/sda1       511M   11M  501M    3% /boot/efi
8. /dev/sda5       708G   55G  618G    9% /datatmpfs           3.9G  8.0K  3.9G    1% /dev/shmtmpfs           5.0M  4.0K  5.0M    1% /run/locktmpfs           3.9G     0  3.9G    0% /sys/fs/cgrouptmpfs           790M   48K  789M    1% /run/user/1000

复制代码

比如分区 /dev/sda3 入口是 /。前面我们已经知道 / 是根目录。
比如 /dev/sda5 入口是 /data。
现在我们做一个试验，来验证分区的入口。
现在 /dev/sda5 已用容量是 55590 M：

1. // -m 表示M
2. pjl@pjl-pc:/data$  df -m |egrep 'sda5|可用'
3. 文件系统        1M-块  已用   可用 已用% 挂载点
4. /dev/sda5      724447 55590 631989    9% /data

复制代码

我们在 /data 目录中使用 dd 生成一个200M的文件：

1. // /dev/zero 是一个特殊的文件，当你读它的时候，它会提供无限的空字符
2. pjl@pjl-pc:/data$ dd if=/dev/zero of=swapfile bs=1M count=200
3. 记录了200+0 的读入
4. 记录了200+0 的写出
5. 209715200 bytes (210 MB, 200 MiB) copied, 0.224172 s, 936 MB/s
6. pjl@pjl-pc:/data$ ls
7. home  lost+found  root  swapfile  usershare

复制代码

现在 /dev/sda5 已用容量比之前正好多 200M。

1. pjl@pjl-pc:/data$ df -m |egrep 'sda5|可用'
2. 文件系统        1M-块  已用   可用 已用% 挂载点
3. /dev/sda5      724447 55790 631789    9% /data

复制代码

tmpfs 又是什么，带着疑问我们进入下一节。
内存

快速理解内存

平时我们玩电脑，无非就是听音乐、玩游戏、看电影，这些数据平时统统放在硬盘中，因为硬盘空间大。以玩下象棋为例，电脑会有如下一个大致流程：

• cpu 向硬盘发送命令，找到所需的游戏数据
  
• 游戏数据从硬盘调入到内存中
  
• 每玩一步都在内存中。cpu 大多数也只和内存互动数据，因为内存比硬盘快得多。
  
• 游戏结束，将结果保存到磁盘中，等待下次在玩。
  

Tip：硬盘容量最大，存放的都是暂时不用的；内存通过不能永久存储数据，断电就清空了；计算机速度：cpu > 内存 > 硬盘；如果 cpu 直接和硬盘交互，就得苦苦等候。
free 查看内存指标

既然内存那么重要，我们最关心的是还有多少可用内存。
命令很简单，使用 free 查看：

1. pjl@pjl-pc:/data$ free -h
2.               总计         已用        空闲      共享    缓冲/缓存    可用
3. 内存：       7.7Gi       1.6Gi       1.3Gi        10Mi       4.8Gi       5.9Gi
4. 交换：       9.2Gi          0B       9.2Gi

复制代码

我们看第一行，总共有 7.7 G，已使用 1.6G。
Tip：共享，几乎无实际用处。
空闲1.3G，可用5.9G，哪个才是剩余内存？为了弄清楚，我们得说一下 linux 内存原理。
free 查看内存的基本原理

古代打战使用屯田制，没有战争的时候，士兵就去耕田。
这里的空闲(free)就是不打战也不耕田的士兵。
缓冲/缓存(cache/buffer)就是耕田的士兵。
在君王眼中，耕田没有打战的优先级高。一旦战事来临，空闲的和耕田的都可派出去。
可用=空闲+缓冲/缓存。所以这里剩余内存是 5.9G。
空闲很好理解，那么缓冲/缓存代表什么意思？请看下节。
内存中的 cache 高速缓存

内存的速度很快，但远远赶不上 cpu。
把 CPU 比作给灾区送水的车，内存比作灾区用桶取水的人，车出水的速度很快，灾区的人用桶取水的速度却很慢，水车不能一直在这等着灾民慢慢取水，因为还得去其他灾区送水。
cache 就好比蓄水池，cpu 把水快速放入蓄水池就走了，灾区的人从蓄水池中慢慢取水。
就像这样：

1. cpu（送水车） -> cache（蓄水池） -> 内存（灾区取水的人）

复制代码

buffer 缓冲区

buffer 缓冲区是为了提高写硬盘的速度。
打个比方，姑娘摘苹果要运到集市卖，如果每摘一个苹果就放到卡车中，效率太低，所以会准备一个箩筐，先把苹果放入箩筐，箩筐满了在一次性放入卡车。
buffer 就是一个大箩筐，每当有大量数据要写入硬盘时，把零碎的数据先放入 buffer。当 buffer 积累到一定程度，在一次性写入硬盘。
cache 是为了高效的读，buffer 为了高效的写。
现在缓冲/缓存是 4585 M：

1. pjl@pjl-pc:/data$ free -m
2.               总计         已用        空闲      共享    缓冲/缓存    可用
3. 内存：        7890        1897        1407          14        4585        5778
4. 交换：        9467           9        9458

复制代码

清理缓存后是 579 M：

1. // 清理页缓存、目录项和inode缓存
2. pjl@pjl-pc:/data$ sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches'
3. pjl@pjl-pc:/data$ free -m
4.               总计         已用        空闲      共享    缓冲/缓存    可用
5. 内存：        7890        1846        5463          13         579        5856
6. 交换：        9467           1        9466

复制代码

测试失败：打算先查看缓存，通过执行 time find /，预期缓存增加，下次在执行 time find /，所花费的的时间应该减少
CPU

这一项指标有点抽象，不像硬盘和内存那么一目了然。
有朋友可能就会疑问：不就是一个 cpu 使用率吗，比如现在用了80%，一个数字而已。
很遗憾，linux 没有这样直观的方法来看 cpu，而是需要掌握一定的CPU使用率计算公式，才能了解当下 cpu 的高低。
先学什么是进程

进程就是一个应用。
比如你使用浏览器是一个进程，使用QQ又是一个进程。
由于 windows 是图形化的，所以看得比较清楚。
而在 linux 中想要看到进程，就需要一些方法。
比如我们用 ping 命令就会开启一个进程：

1. pjl@pjl-pc:/data$ ping 192.168.1.110
2. PING 192.168.1.110 (192.168.1.110) 56(84) bytes of data.
3. 64 bytes from 192.168.1.110: icmp_seq=1 ttl=64 time=0.028 ms
4. 64 bytes from 192.168.1.110: icmp_seq=2 ttl=64 time=0.021 ms
5. 64 bytes from 192.168.1.110: icmp_seq=3 ttl=64 time=0.020 ms
6. 64 bytes from 192.168.1.110: icmp_seq=4 ttl=64 time=0.034 ms
7. 64 bytes from 192.168.1.110: icmp_seq=5 ttl=64 time=0.032 ms
8. 64 bytes from 192.168.1.110: icmp_seq=6 ttl=64 time=0.031 ms
9. 64 bytes from 192.168.1.110: icmp_seq=7 ttl=64 time=0.028 ms
10. 64 bytes from 192.168.1.110: icmp_seq=8 ttl=64 time=0.036 ms
11. 64 bytes from 192.168.1.110: icmp_seq=9 ttl=64 time=0.034 ms
12. 64 bytes from 192.168.1.110: icmp_seq=10 ttl=64 time=0.038 ms
13. ...

复制代码

现在这个命令行完全被这个进程占据，我们不能再输入其他命令。这个叫前台进程。
与之对应的有后台进程，比如：

1. // >> 是追加内容。这里是将 ping 的输出追加到 ping.log 文件中
2. pjl@pjl-pc:~/linux-test$ ping 192.168.1.110 >> ping.log &
3. [1] 486803
4. pjl@pjl-pc:~/linux-test$

复制代码

通过 & 读做and，把它放在命令行末尾，可以将该进程放在后台。于是我们可以继续敲别的命令。
这个命令是否还在执行，我们可以通过 tail -f 看到ping 进程正不停地往文件中写数据：

1. pjl@pjl-pc:~/linux-test$ tail -f ping.log
2. 64 bytes from 192.168.1.110: icmp_seq=5 ttl=64 time=0.031 ms
3. 64 bytes from 192.168.1.110: icmp_seq=6 ttl=64 time=0.022 ms
4. 64 bytes from 192.168.1.110: icmp_seq=7 ttl=64 time=0.031 ms
5. 64 bytes from 192.168.1.110: icmp_seq=8 ttl=64 time=0.029 ms
6. 64 bytes from 192.168.1.110: icmp_seq=9 ttl=64 time=0.024 ms
7. 64 bytes from 192.168.1.110: icmp_seq=10 ttl=64 time=0.026 ms
8. ...

复制代码

ps 查看用户自己的进程

1. pjl@pjl-pc:~/linux-test$ jobs
2. [1]+  运行中               ping 192.168.1.110 >> ping.log &

复制代码

这里看到刚才放在后台运行的 ping 进程。
jobs 只能看到那些用 & 放入后台的进程，更多的后台进程无法显示。
接下来我们需要使用：ps(process status) 进程状态。
直接输入 ps 通常只会显示两个进程：

1. pjl@pjl-pc:~/linux-test$ ps
2.     PID TTY          TIME CMD
3.   56412 pts/1    00:00:00 bash
4. 499971 pts/1    00:00:00 ps
5. pjl@pjl-pc:~/linux-test$ whoami
6. pjl

复制代码

第一个 bash，指当前用户正在用的命令行是 bash；第二个 ps 是刚才我们运行了 ps，所以自身产生了一瞬间的进程，也同样显示在这里。
使用另一个用户输入 ps，虽然也是 bash 和 ps 进程，从进程号(PID)我们可以看出，每个用户的进程是不同的。

1. user1@pjl-pc:~$ ps
2.     PID TTY          TIME CMD
3. 499859 pts/0    00:00:00 bash
4. 499878 pts/0    00:00:00 ps
5. user1@pjl-pc:~$ whoami
6. user1

复制代码

ps 查看全局进程

通过 ps -ef 查看操作系统所有的进程：

1. pjl@pjl-pc:~/linux-test$ ps -ef | head
2. UID          PID    PPID  C STIME TTY          TIME CMD
3. root           1       0  0 7月19 ?       00:00:19 /sbin/init splash
4. root           2       0  0 7月19 ?       00:00:00 [kthreadd]
5. root           3       2  0 7月19 ?       00:00:00 [rcu_gp]
6. root           4       2  0 7月19 ?       00:00:00 [rcu_par_gp]
7. root           6       2  0 7月19 ?       00:00:00 [kworker/0:0H-kblockd]
8. root           8       2  0 7月19 ?       00:00:00 [mm_percpu_wq]
9. root           9       2  0 7月19 ?       00:00:04 [ksoftirqd/0]
10. root          10       2  0 7月19 ?       00:00:36 [rcu_sched]
11. root          11       2  0 7月19 ?       00:00:00 [migration/0]

复制代码

PID 表示进程Id，PPID是父进程id。
先有父亲，然后有儿子，我们可以看到有许多进程的 PPID 是 1:

1. UID          PID    PPID  C STIME TTY          TIME CMD
2. root         889       1  0 7月19 ?       00:08:41 /usr/sbin/NetworkManager --no-daemon
3. root         890       1  0 7月19 ?       00:00:00 /usr/bin/python3 /usr/bin/location.py
4. root         894       1  0 7月19 ?       00:00:00 /usr/bin/python3 /usr/bin/hedron-domain-hook.py
5. root         897       1  0 7月19 ?       00:00:04 /usr/sbin/kylin-daq-daemon
6. root         903       1  0 7月19 ?       00:00:00 /usr/bin/systime
7. root         906       1  0 7月19 ?       00:00:00 /usr/bin/miracat_uibcctl
8. root         907       1  0 7月19 ?       00:00:00 /bin/bash /usr/bin/execstart.sh
9. syslog       910       1  0 7月19 ?       00:00:00 /usr/sbin/rsyslogd -n -iNONE

复制代码

PID 是 1 的进程通常是操作系统的启动进程（叫init），是所有进程的祖先进程，它是系统启动时第一个被创建的进程。
STIME 是进程启动的时间，例如这里是7月19，如果是24小时内，则会显示 13:11 类似的时间。
Time 指从启动到当前，一共花费cpu多长时间。
我们可能会疑惑：第一个进程（PID=1）从昨天开始运行，到现在才花费 cpu 19秒，这个进程不是一直都在吗？请看下节
Tip: ps -ef 和 ps aux 都是用于显示当前系统运行的进程信息，但输出格式略有差异。

1. pjl@pjl-pc:~/linux-test$ ps aux | head
2. USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
3. root           1  0.0  0.1 168768 11008 ?        Ss   7月19   0:19 /sbin/init splash
4. root           2  0.0  0.0      0     0 ?        S    7月19   0:00 [kthreadd]
5. root           3  0.0  0.0      0     0 ?        I<   7月19   0:00 [rcu_gp]
6. root           4  0.0  0.0      0     0 ?        I<   7月19   0:00 [rcu_par_gp]
7. root           6  0.0  0.0      0     0 ?        I<   7月19   0:00 [kworker/0:0H-kblockd]
8. root           8  0.0  0.0      0     0 ?        I<   7月19   0:00 [mm_percpu_wq]
9. root           9  0.0  0.0      0     0 ?        S    7月19   0:04 [ksoftirqd/0]
10. root          10  0.0  0.0      0     0 ?        I    7月19   0:36 [rcu_sched]
11. root          11  0.0  0.0      0     0 ?        S    7月19   0:00 [migration/0]

复制代码

用令牌计算CPU使用率

我们可以同时在计算机上干很多事，比如写作、听音乐、玩游戏...，cpu 不是同一时刻做多件事（cpu 同一时刻只能执行一条指令），而是一会干这个，一会干那个，只是速度非常快。
cpu 工作方式是这样的：有好多任务等待 cpu 处理，根据先来后到的原则以及优先级的不同，会给任务分配CPU令牌（也就是时间片）。
为了方便理解，假如一个时间片是1秒，在60秒内，cpu 的工作情况如下：
10秒20秒10秒10秒10秒进程01cpu没事做进程01进程02进程03cpu 给进程01分配了20秒的时间，进程01的cpu使用率是20/60≈33%。
如果需要瞬时的使用率，将这60秒想象成1秒即可。
通过 ps aux 可以查看当前系统运行的进程，里面就有 ping，进程号是 486803：

1. // 存在 ping 进程
2. pjl@pjl-pc:~$ ps aux |egrep 'ping|PID'
3. USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
4. pjl   486803  0.0  0.0  12028   840 pts/1    S    15:58   0:00 ping 192.168.1.110
5. pjl   489792  0.0  0.0  11652   692 pts/0    S+   16:07   0:00 grep -E --color=auto ping|PID

复制代码

上文我们留了一个问题：某个进程从昨天开始运行，到现在为止才花费 cpu 19秒。
这个进程可能只需要在特定事件或触发条件下执行任务，并且在其他时间内保持休眠或空闲状态。
我们启动一个进程，让 cpu 负荷：

1. // 会一直运行下去
2. pjl@pjl-pc:~$ md5sum /dev/zero &
3. [1] 141089

复制代码

执行 top 命令：

1. top - 10:48:29 up 8 days, 17:13,  2 users,  load average: 75.53, 82.12, 83.52
2. 任务: 944 total,   8 running, 936 sleeping,   0 stopped,   0 zombie
3. %Cpu(s): 22.6 us, 35.7 sy,  0.0 ni, 41.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
4. MiB Mem :   7890.4 total,   2118.1 free,   2614.4 used,   3157.8 buff/cache
5. MiB Swap:   9468.0 total,   9392.5 free,     75.5 used.   5055.7 avail Mem
7. 进程号 USER      PR  NI    VIRT    RES    SHR    %CPU  %MEM     TIME+ COMMAND
8. 141089 pjl   20   0   10596    484    420 R  93.3   0.0   1:00.62 md5sum
9. 143856 root      20   0   12336   2208   2016 S  10.8   0.0   0:00.24 ping
10. 134506 pjl   20   0   26996   7032   5564 R   9.0   0.1   0:12.68 sshd
11. 143657 root      20   0   12336   2408   2216 S   7.6   0.0   0:00.37 ping
12. 143665 root      20   0   12336   2208   2016 S   7.6   0.0   0:00.36 ping

复制代码

抽取这段信息来看，md5sum cpu 使用率 93.3，而CPU空闲的时间比例(41.7 id) 是 41.7，也就是 cpu 使用率是 58.3，对不上！

1. // 空闲时间（id）
2. %Cpu(s): 22.6 us, 35.7 sy,  0.0 ni, 41.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
4. 进程号 USER      PR  NI    VIRT    RES    SHR    %CPU  %MEM     TIME+ COMMAND
5. 141089 pjl   20   0   10596    484    420 R  93.3   0.0   1:00.62 md5sum

复制代码

在按一下键盘 1，笔者这里显示有4个核，所以 58.3 是4核总共的 cpu 使用率。

1. top - 10:49:01 up 8 days, 17:14,  2 users,  load average: 91.78, 86.05, 84.82
2. 任务: 966 total,  42 running, 923 sleeping,   0 stopped,   1 zombie
3. // 4 核
4. %Cpu0  : 34.6 us, 30.6 sy,  0.0 ni, 34.8 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
5. %Cpu1  :  1.1 us, 33.7 sy,  0.0 ni, 65.2 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
6. %Cpu2  :  7.6 us, 41.6 sy,  0.0 ni, 50.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
7. %Cpu3  : 32.7 us, 37.2 sy,  0.0 ni, 30.1 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
8. MiB Mem :   7890.4 total,   2115.8 free,   2616.2 used,   3158.3 buff/cache
9. MiB Swap:   9468.0 total,   9392.5 free,     75.5 used.   5053.9 avail Mem
11. 进程号 USER      PR  NI    VIRT    RES    SHR    %CPU  %MEM     TIME+ COMMAND
12. 141089 pjl   20   0   10596    484    420 R  90.0   0.0   1:09.05 md5sum
13. 144346 root      20   0   12336   2136   1944 R   8.7   0.0   0:00.27 ping
14. 144364 root      20   0   12336   2308   2116 R   6.5   0.0   0:00.20 ping
15. 144354 root      20   0   12336   2236   2044 R   6.1   0.0   0:00.19 ping
16. 134506 pjl   20   0   26996   7032   5564 S   5.8   0.1   0:13.91 sshd
17. 144248 root      20   0   12336   2124   1932 R   5.5   0.0   0:00.37 ping
18. 144370 root      20   0   12336   2124   1932 R   3.2   0.0   0:00.10 ping
19. 144371 root      20   0   12336   2124   1932 R   2.9   0.0   0:00.09 ping
20. 144280 root      20   0   12336   2204   2012 S   2.6   0.0   0:00.15 ping
21. 144345 root      20   0   12336   2236   2044 S   2.6   0.0   0:00.08 ping

复制代码

来源:https://www.cnblogs.com/pengjiali/p/17578893.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！