经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 数据库/运维 » Linux/Shell » 查看文章
跟运维学 Linux - 03
来源:cnblogs  作者:彭加李  时间:2023/8/4 9:56:51  对本文有异议

权限机制和性能指标

前面我们学完了操作文件用户相关知识,本篇学习权限性能相关知识。

文件的属性看起

看 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.txt
  2. pjl@pjl-pc:~/linux-test$ ls dir1
  3. 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/sda931.53 GiB1000204886016 字节,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
  9. 设备 起点 末尾 扇区 大小 类型
  10. /dev/sda1 2048 1050623 1048576 512M EFI 系统
  11. /dev/sda2 1050624 5244927 4194304 2G Linux 文件系统
  12. /dev/sda3 5244928 214960127 209715200 100G Linux 文件系统
  13. /dev/sda4 214960128 424675327 209715200 100G Linux 文件系统
  14. /dev/sda5 424675328 1934133247 1509457920 719.8G Linux 文件系统
  15. /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/sda931.53 GiB1000204886016 字节,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
  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

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% /data
  9. tmpfs 3.9G 8.0K 3.9G 1% /dev/shm
  10. tmpfs 5.0M 4.0K 5.0M 1% /run/lock
  11. tmpfs 3.9G 0 3.9G 0% /sys/fs/cgroup
  12. tmpfs 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 又是什么,带着疑问我们进入下一节。

内存

快速理解内存

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

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

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 719 ? 00:00:19 /sbin/init splash
  4. root 2 0 0 719 ? 00:00:00 [kthreadd]
  5. root 3 2 0 719 ? 00:00:00 [rcu_gp]
  6. root 4 2 0 719 ? 00:00:00 [rcu_par_gp]
  7. root 6 2 0 719 ? 00:00:00 [kworker/0:0H-kblockd]
  8. root 8 2 0 719 ? 00:00:00 [mm_percpu_wq]
  9. root 9 2 0 719 ? 00:00:04 [ksoftirqd/0]
  10. root 10 2 0 719 ? 00:00:36 [rcu_sched]
  11. root 11 2 0 719 ? 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 719 ? 00:08:41 /usr/sbin/NetworkManager --no-daemon
  3. root 890 1 0 719 ? 00:00:00 /usr/bin/python3 /usr/bin/location.py
  4. root 894 1 0 719 ? 00:00:00 /usr/bin/python3 /usr/bin/hedron-domain-hook.py
  5. root 897 1 0 719 ? 00:00:04 /usr/sbin/kylin-daq-daemon
  6. root 903 1 0 719 ? 00:00:00 /usr/bin/systime
  7. root 906 1 0 719 ? 00:00:00 /usr/bin/miracat_uibcctl
  8. root 907 1 0 719 ? 00:00:00 /bin/bash /usr/bin/execstart.sh
  9. syslog 910 1 0 719 ? 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 -efps 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 719 0:19 /sbin/init splash
  4. root 2 0.0 0.0 0 0 ? S 719 0:00 [kthreadd]
  5. root 3 0.0 0.0 0 0 ? I< 719 0:00 [rcu_gp]
  6. root 4 0.0 0.0 0 0 ? I< 719 0:00 [rcu_par_gp]
  7. root 6 0.0 0.0 0 0 ? I< 719 0:00 [kworker/0:0H-kblockd]
  8. root 8 0.0 0.0 0 0 ? I< 719 0:00 [mm_percpu_wq]
  9. root 9 0.0 0.0 0 0 ? S 719 0:04 [ksoftirqd/0]
  10. root 10 0.0 0.0 0 0 ? I 719 0:36 [rcu_sched]
  11. root 11 0.0 0.0 0 0 ? S 719 0:00 [migration/0]
用令牌计算CPU使用率

我们可以同时在计算机上干很多事,比如写作、听音乐、玩游戏...,cpu 不是同一时刻做多件事(cpu 同一时刻只能执行一条指令),而是一会干这个,一会干那个,只是速度非常快。

cpu 工作方式是这样的:有好多任务等待 cpu 处理,根据先来后到的原则以及优先级的不同,会给任务分配CPU令牌(也就是时间片)。

为了方便理解,假如一个时间片是1秒,在60秒内,cpu 的工作情况如下:

10秒 20秒 10秒 10秒 10秒
进程01 cpu没事做 进程01 进程02 进程03

cpu 给进程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
  6. 进程号 USER PR NI VIRT RES SHR %CPU %MEM TIME+ COMMAND
  7. 141089 pjl 20 0 10596 484 420 R 93.3 0.0 1:00.62 md5sum
  8. 143856 root 20 0 12336 2208 2016 S 10.8 0.0 0:00.24 ping
  9. 134506 pjl 20 0 26996 7032 5564 R 9.0 0.1 0:12.68 sshd
  10. 143657 root 20 0 12336 2408 2216 S 7.6 0.0 0:00.37 ping
  11. 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
  3. 进程号 USER PR NI VIRT RES SHR %CPU %MEM TIME+ COMMAND
  4. 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
  10. 进程号 USER PR NI VIRT RES SHR %CPU %MEM TIME+ COMMAND
  11. 141089 pjl 20 0 10596 484 420 R 90.0 0.0 1:09.05 md5sum
  12. 144346 root 20 0 12336 2136 1944 R 8.7 0.0 0:00.27 ping
  13. 144364 root 20 0 12336 2308 2116 R 6.5 0.0 0:00.20 ping
  14. 144354 root 20 0 12336 2236 2044 R 6.1 0.0 0:00.19 ping
  15. 134506 pjl 20 0 26996 7032 5564 S 5.8 0.1 0:13.91 sshd
  16. 144248 root 20 0 12336 2124 1932 R 5.5 0.0 0:00.37 ping
  17. 144370 root 20 0 12336 2124 1932 R 3.2 0.0 0:00.10 ping
  18. 144371 root 20 0 12336 2124 1932 R 2.9 0.0 0:00.09 ping
  19. 144280 root 20 0 12336 2204 2012 S 2.6 0.0 0:00.15 ping
  20. 144345 root 20 0 12336 2236 2044 S 2.6 0.0 0:00.08 ping

原文链接:https://www.cnblogs.com/pengjiali/p/17578893.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号