1.总结脚本高级命令trap, install, mktemp, expect,
进程优先级命令：nice, renice,
进程管理工具: ps, pstree, pidstat, pgrep, pidof, uptime, mpstat, top, htop, free, pmap, vmstat, iostat, iotop, iftop, nload, nethogs, iptraf-ng, dstat, glances, cockpit, kill, jobs,
任务相关的命令: at, crontab, 命令，选项，示例。
trap
Linux 的 trap 指令用于设置或清除 shell 信号处理程序。当 shell 接收到指定的信号时，会启动相应的处理程序。例如，可以使用 trap 指令来捕获 shell 进程结束的信号，以便在 shell 进程结束时进行清理操作。
trap 指令的基本语法如下：
trap command signal-list其中，command 是要执行的命令或函数，signal-list 是一个或多个信号名称的列表。当 shell 接收到信号列表中的任意一个信号时，会执行command中所指定的命令或函数。
以下是一些常用的信号名称：
SIGHUP：挂起信号SIGINT：中断信号SIGQUIT：退出信号SIGTSTP：终止进程信号
例如，下面的命令将捕获 SIGINT 信号，并在接收到该信号时打印一条消息：
trap 'echo Interrupted; exit' INT在上述例子中，当 shell 接收到 SIGINT 信号时，会执行 echo Interrupted; exit 命令，打印一个消息并退出 shell 进程。
当shell收到 HUP INT PIPE QUIT TERM 这几个命令时，当前执行的程序会执行 exit 1。
[root@pc root]$ trap "exit 1" HUP INT PIPE QUIT TERM清理临时文件
下面展示了如果有人试图从终端中止程序时，如何删除文件然后退出：
trap "rm -f $WORKDIR/work1 $WORKDIR/dataout; exit" 2执行shell程序，如果程序接收信号为2，那么这两个文件 （work1 和 dataout） 将被自动删除。
添加信号1 SIGHUP：
$ trap "rm $WORKDIR/work1 $WORKDIR/dataout; exit" 1 2忽略信号
如果陷阱列出的命令是空的，指定的信号接收时，将被忽略：
$ trap '' 2忽略多个信号：
$ trap '' 1 2 3 15重置陷阱
当你改变了收到信号后采取的动作，你可以省略第一个参数来重置到默认行为。
$ trap 1 2install
在Linux中，install命令通常用于将一个或多个文件从源位置复制到目标位置。它的一般形式如下：
install [OPTION]... SOURCE DEST其中，OPTION表示可选参数，SOURCE表示源文件或目录，DEST表示目标位置。
install命令的一些常见选项包括：
-D：如果DEST是目录，则创建与SOURCE相同的文件名并将其复制到目录中。-g：设置文件的组ID为指定的值。-m：设置文件的权限模式。-o：设置文件的所有者为指定的用户。-p：保留源文件的时间戳、所有权、权限等元数据。-v：显示详细的输出。
例如，要将 file.txt 复制到 /usr/local/bin 目录，并设置文件的权限为 755，可以使用以下命令：
install -m 755 file.txt /usr/local/bin/mktemp
mktemp命令是在Linux中创建临时文件或目录的命令。它的作用是生成一个唯一的、安全的、临时的文件名或目录名，可以帮助我们避免并发访问问题。
mktemp命令的语法如下：
mktemp [OPTION]... [TEMPLATE]其中，OPTION是可选参数，用于指定mktemp命令的行为；TEMPLATE是必须的参数，用于指定生成临时文件/目录名的模板。
TEMPLATE通常是以字符串形式提供的以“XXXXXX”结尾的路径名模板。在模板中，“X”表示随机字符，mktemp命令会自动生成一组随机字符来填充模板中的“X”。例如：
mktemp /tmp/test.XXXXXX执行以上命令后，mktemp会在/tmp/目录下生成一个以“test.”开头、“XXXXXX”结尾的随机文件名。
mktemp命令还提供了一些有用的选项，比如-d选项用于生成临时目录、-p选项用于指定临时文件/目录所在的目录等。具体用法可以使用man mktemp命令查看帮助文档。
expect
expect是一种自动化交互式命令行应用程序的工具，在Linux和UNIX环境下非常有用。它可以通过编写脚本自动实现交互操作，比如登录远程服务器并执行特定命令、配置网络设备等。
expect工具主要用于自动化测试和系统管理等领域，它可以让用户自动输入命令，并可以处理程序返回的输出结果。使用expect可以避免手动输入重复的命令流程，从而提高工作效率。
expect脚本通常包含五个阶段：spawn、expect、send、interact和exit。其中：
- spwan：启动需要交互的程序或命令；
- expect：等待特定的输出结果（字符串或正则表达式）；
- send：向终端发送命令或数据；
- interact：进入交互模式，允许用户手动输入命令；
- exit：退出脚本。
例如，下面是一个简单的expect脚本，用于登录远程服务器：
#!/usr/bin/expect
set timeout 20
set user username
set password "yourpassword"
set server "192.168.1.101"
spawn ssh $user@$server
expect {
"(yes/no)?" {
send "yes\r"
exp_continue
}
"password:" {
send "$password\r"
}
}
interact该脚本首先使用spawn命令启动ssh命令，然后使用expect命令等待输出字符“(yes/no)?”或“password:”，分别输入“yes”和密码。最后进入interact模式，允许用户手动输入命令。
expect的用法比较灵活，可以根据实际情况进行调整。如果需要深入了解expect的更多用法，可以参考相关文档或手册。
nice
在Linux系统中，nice命令用于调整进程的优先级。通过修改进程的优先级，可以让系统更好地响应用户的操作，避免某些耗费大量CPU资源的程序使整个系统变得非常缓慢。
nice命令可以通过-n选项指定进程的优先级，取值范围是-20到19，其中-20为最高优先级，19为最低优先级。默认情况下，进程的优先级为0。
例如，如果要将一个名为test的进程的优先级调整为-5，可以使用以下命令：
nice -n -5 test此命令将使进程test的优先级提高，系统分配给它的CPU资源也会相应增加。
renice
在Linux中，renice命令可以用于调整进程的优先级，从而改变其在系统资源分配中的地位。简单来说，它可以让正在运行的进程变得更加优先或者降低优先级，以实现系统资源的合理利用和进程执行的优化。
具体来讲，renice命令可以让一个正在运行的进程重新设定优先级。该命令使用的格式如下：
renice [-n] priority pid其中，-n表示指定要调整的优先级值，取值范围为-20到19；priority是要设置的优先级值，pid则是要修改优先级的进程ID号。举例来说，如果我想将进程PID为123的优先级值提高3个单位，则可以使用如下命令：
renice +3 123同样的，如果我想将进程PID为234的优先级值降低2个单位，则可以使用如下命令：
renice -2 234需要注意的是，renice命令一般只能由root用户或者具有CAP_SYS_NICE权限的用户去运行，否则会提示“Operation not permitted”错误。
ps
ps命令是Linux中常用的进程查看命令，它可以用来列出系统中当前运行的进程。
常用的ps命令选项如下：
- -a 显示所有进程。
- -u 显示进程的详细状态。
- -x 显示没有控制终端的进程。
- -e 显示所有进程，包括系统进程。
- -f 显示进程的完整信息。
例如，要显示所有进程以及它们的详细信息，可以使用以下命令：
ps -ef该命令会列出所有进程的详细信息，包括进程的PID、PPID、用户、CPU占用率等等。如果想要仅查看某个特定用户的进程，可以加上-u选项：
ps -ef -u username其中，"username"代表要查看的用户名。
实例
ps axo pid,comm,pcpu # 查看进程的PID、名称以及CPU 占用率
ps aux | sort -rnk 4 # 按内存资源的使用量对进程进行排序
ps aux | sort -nk 3 # 按 CPU 资源的使用量对进程进行排序
ps -A # 显示所有进程信息
ps -u root # 显示指定用户信息
ps -efL # 查看线程数
ps -e -o "%C : %p :%z : %a"|sort -k5 -nr # 查看进程并按内存使用大小排列
ps -ef # 显示所有进程信息，连同命令行
ps -ef | grep ssh # ps 与grep 常用组合用法，查找特定进程
ps -C nginx # 通过名字或命令搜索进程
ps aux --sort=-pcpu,+pmem # CPU或者内存进行排序,-降序，+升序
ps -f --forest -C nginx # 用树的风格显示进程的层次关系
ps -o pid,uname,comm -C nginx # 显示一个父进程的子进程
ps -e -o pid,uname=USERNAME,pcpu=CPU_USAGE,pmem,comm # 重定义标签
ps -e -o pid,comm,etime # 显示进程运行的时间
ps -aux | grep named # 查看named进程详细信息
ps -o command -p 91730 | sed -n 2p # 通过进程id获取服务名称将目前属于您自己这次登入的 PID 与相关信息列示出来
ps -l
# UID PID PPID F CPU PRI NI SZ RSS WCHAN S ADDR TTY TIME CMD
# 501 566 559 4006 0 31 0 4317620 228 - Ss 0 ttys001 0:00.05 /App...cOS/iTerm2 --server /usr/bin/login -fpl kenny /Ap...s/MacOS/iTerm2 --launch_shel
# 501 592 577 4006 0 31 0 4297048 52 - S 0 ttys001 0:00.63 -zsh- F 代表这个程序的旗标 (flag)， 4 代表使用者为 super user
- S 代表这个程序的状态 (STAT)，关于各 STAT 的意义将在内文介绍
- UID 程序被该 UID 所拥有
- PID 就是这个程序的 ID ！
- PPID 则是其上级父程序的ID
- C CPU 使用的资源百分比
- PRI 这个是 Priority (优先执行序) 的缩写，详细后面介绍
- NI 这个是 Nice 值，在下一小节我们会持续介绍
- ADDR 这个是 kernel function，指出该程序在内存的那个部分。如果是个 running的程序，一般就是 "-"
- SZ 使用掉的内存大小
- WCHAN 目前这个程序是否正在运作当中，若为 - 表示正在运作
- TTY 登入者的终端机位置
- TIME 使用掉的 CPU 时间。
- CMD 所下达的指令为何
在预设的情况下， ps 仅会列出与目前所在的 bash shell 有关的 PID 而已，所以， 当我使用 ps -l 的时候，只有三个 PID。
列出目前所有的正在内存当中的程序
ps aux
# USER PID %CPU %MEM VSZ RSS TT STAT STARTED TIME COMMAND
# kenny 6155 21.3 1.7 7969944 284912 ?? S 二03下午 199:14.14 /Appl...OS/WeChat
# kenny 559 20.4 0.8 4963740 138176 ?? S 二03下午 33:28.27 /Appl...S/iTerm2
# _windowserver 187 18.0 0.6 7005748 95884 ?? Ss 二03下午 288:44.97 /Syst...Light.WindowServer -daemon
# kenny 1408 10.7 2.1 5838592 347348 ?? S 二03下午 138:51.63 /Appl...nts/MacOS/Google Chrome
# kenny 327 5.8 0.5 5771984 79452 ?? S 二03下午 2:51.58 /Syst...pp/Contents/MacOS/Finder- USER：该 process 属于那个使用者账号的
- PID ：该 process 的号码
- %CPU：该 process 使用掉的 CPU 资源百分比
- %MEM：该 process 所占用的物理内存百分比
- VSZ ：该 process 使用掉的虚拟内存量 (Kbytes)
- RSS ：该 process 占用的固定的内存量 (Kbytes)
- TTY ：该 process 是在那个终端机上面运作，若与终端机无关，则显示 ?，另外， tty1-tty6 是本机上面的登入者程序，若为 pts/0 等等的，则表示为由网络连接进主机的程序。
- STAT：该程序目前的状态，主要的状态有
- R ：该程序目前正在运作，或者是可被运作
- S ：该程序目前正在睡眠当中 (可说是 idle 状态)，但可被某些讯号 (signal) 唤醒。
- T ：该程序目前正在侦测或者是停止了
- Z ：该程序应该已经终止，但是其父程序却无法正常的终止他，造成 zombie (疆尸) 程序的状态
- START：该 process 被触发启动的时间
- TIME ：该 process 实际使用 CPU 运作的时间
- COMMAND：该程序的实际指令
列出类似程序树的程序显示
ps -axjf
# USER PID PPID PGID SESS JOBC STAT TT TIME COMMAND UID C STIME TTY
# root 1 0 1 0 0 Ss ?? 10:51.90 /sbin/launchd 0 0 二03下午 ??
# root 50 1 50 0 0 Ss ?? 0:10.07 /usr/sbin/syslog 0 0 二03下午 ??
# root 51 1 51 0 0 Ss ?? 0:29.90 /usr/libexec/Use 0 0 二03下午 ??找出与 cron 与 syslog 这两个服务有关的 PID 号码
ps aux | egrep '(cron|syslog)'
# root 50 0.0 0.0 4305532 1284 ?? Ss 二03下午 0:10.08 /usr/sbin/syslogd
# kenny 90167 0.0 0.0 4258468 184 s007 R+ 9:23下午 0:00.00 egrep (cron|syslog)把所有进程显示出来，并输出到ps001.txt文件
ps -aux > ps001.txtpstree
pstree是Linux中常用的进程查看命令，它以树状图的形式展示进程之间的关系。
pstree命令可以显示当前进程及其子进程的树形结构。如果不带任何参数，则默认显示init进程及其所有子进程的树形结构。
选项
-a：显示每个程序的完整指令，包含路径，参数或是常驻服务的标示；
-c：不使用精简标示法；
-G：使用VT100终端机的列绘图字符；
-h：列出树状图时，特别标明现在执行的程序；
-H<程序识别码>：此参数的效果和指定"-h"参数类似，但特别标明指定的程序；
-l：采用长列格式显示树状图；
-n：用程序识别码排序。预设是以程序名称来排序；
-p：显示程序识别码；
-u：显示用户名称；
-U：使用UTF-8列绘图字符；
-V：显示版本信息。例如，以下是使用pstree命令显示进程树的示例输出：
systemd─┬─ModemManager───2*[{ModemManager}]
├─NetworkManager─┬─dhclient
│ └─3*[{NetworkManager}]
├─accounts-daemon───2*[{accounts-daemon}]
├─agetty
├─avahi-daemon───avahi-daemon
├─bluetoothd
├─colord───2*[{colord}]
├─cron
├─4*[dbus-daemon]
├─fwupd───3*[{fwupd}]
├─gdm3─┬─Xorg───29*[{Xorg}]
│ ├─gnome-session-b─┬─gnome-shell─┬─ibus-daemon───3*[{ibus-daemon}]
│ │ │ ├─radeon-profile─┬─cat
│ │ │ │ ├─sed───grep
│ │ │ │ └─tee
│ │ │ ├─ssh-agent
│ │ │ ├─tracker-miner-fs───4*[{tracker-miner-fs}]
│ │ │ ├─tracker-store─┬─tracker-extract───2*[{tracker-extract}]
│ │ │ │ ├─tracker-miner───3*[{tracker-miner}]
│ │ │ │ └─3*[{tracker-store}]
│ │ │ └─3*[{gnome-shell}]
│ │ └─3*[{gnome-session-b}]
│ ├─gdm-x-session─┬─gnome-terminal-─┬─bash───pstree
│ │ │ ├─gnome-pty-helpe───4*[{gnome-pty-helpe}]
│ │ │ └─4*[{gnome-terminal-}]
│ │ └─2*[{gdm-x-session}]
│ ├─pulseaudio─┬─gsettings-helper───2*[{gsettings-helper}]
│ │ ├─gconf-helper───2*[{gconf-helper}]
│ │ └─3*[{pulseaudio}]
│ ├─ssh-agent
│ └─3*[{gdm3}]
├─irqbalance───{irqbalance}
├─kerneloops───2*[{kerneloops}]
├─2*[kworker/0:0-eve]
├─2*[kworker/1:1-eve]
├─2*[kworker/2:1-eve]
├─2*[kworker/3:1-eve]
├─2*[kworker/4:1-eve]
├─2*[kworker/5:1-eve]
├─2*[kworker/6:1-eve]
├─2*[kworker/7:1-eve]
├─2*[kworker/u8:0-eve]
├─polkitd───3*[{polkitd}]
├─rsyslogd───3*[{rsyslogd}]
├─rtkit-daemon───2*[{rtkit-daemon}]
├─snapd───10*[{snapd}]
├─spice-vdagent───2*[{spice-vdagent}]
├─sshd───sshd───sshd───bash───pstree
├─systemd-journal
├─systemd-logind
├─systemd-udevd
└─thermald───{thermald}每一行就代表一个进程或者是线程，其中每个进程的名称都被展开为列表示进程层次结构的树形图。在上面的例子中，以systemd作为根节点，其下每个实体名称后面的横杠（-）表示该实体是前一个实体的子进程。此外，大括号花括号（{}）中的内容表示守护进程（Daemon），如irqbalance、kerneloops和thermald等。
使用pstree命令可以更方便地查看进程之间的关系，并帮助我们在排查问题时定位异常进程和线程。
pidstat
pidstat 是 Linux 系统中的一个性能监控工具，用于监视进程的资源使用情况，包括 CPU、内存、磁盘 I/O 等指标。它可以帮助您监控进程的性能和瓶颈，并进行故障排查。
使用 pidstat 命令可以监视某个或某些进程的资源使用情况。常用的选项如下：
-p：指定要监视的进程 ID。-u：显示 CPU 利用率和上下文切换次数等信息。-r：显示内存使用情况。-d：显示磁盘 I/O 使用情况。-t：显示任务信息，包括进程名称、进程 ID 等。
例如，以下命令可以每1秒钟显示进程 ID 为 1234 的进程的 CPU、内存和磁盘 I/O 使用情况：
pidstat -p 1234 -u -r -d 1在上述命令中，-u 参数表示显示 CPU 利用率和上下文切换次数等信息，-r 表示显示内存使用情况，-d 表示显示磁盘 I/O 使用情况，1表示每秒更新一次。
除此之外，还可以通过设置特定的选项来自定义输出。 pidstat 命令是 sysstat 包中的一部分，在大多数 Linux 操作系统中已经预装了该包，如果您的系统没有安装该包，可以使用包管理工具来安装。
实例
查看所有进程的CPU使用情况
# pidstat -u -p ALL
11:04:06 AM UID PID %usr %system %guest %CPU CPU Command
11:04:06 AM 0 1 0.03 0.05 0.00 0.08 20 systemd
11:04:06 AM 0 2 0.00 0.00 0.00 0.00 28 kthreadd
11:04:06 AM 0 3 0.00 0.00 0.00 0.00 0 rcu_gp
11:04:06 AM 0 4 0.00 0.00 0.00 0.00 0 rcu_par_gp
11:04:06 AM 0 6 0.00 0.00 0.00 0.00 0 kworker/0:0H-kblockd
11:04:06 AM 0 9 0.00 0.00 0.00 0.00 38 mm_percpu_wq
11:04:06 AM 0 10 0.00 0.01 0.00 0.01 0 ksoftirqd/0
11:04:06 AM 0 11 0.00 0.23 0.00 0.23 15 rcu_sched
11:04:06 AM 0 12 0.00 0.00 0.00 0.00 0 migration/0
11:04:06 AM 0 14 0.00 0.00 0.00 0.00 0 cpuhp/0
11:04:06 AM 0 15 0.00 0.00 0.00 0.00 1 cpuhp/1
...表头字段说明
- PID：进程ID
- %usr：进程在用户空间占用cpu的百分比
- %system：进程在内核空间占用cpu的百分比
- %guest：进程在虚拟机占用cpu的百分比
- %CPU：进程占用cpu的百分比
- CPU：处理进程的cpu编号
- Command：当前进程对应的命令
查看所有进程的内存使用情况
# pidstat -r
11:10:35 AM UID PID minflt/s majflt/s VSZ RSS %MEM Command
11:10:35 AM 0 1 7.24 0.05 191312 4208 0.01 systemd
11:10:35 AM 0 1407 2.02 0.09 39316 9016 0.03 systemd-journal
11:10:35 AM 0 1442 0.03 0.00 190380 1080 0.00 lvmetad
11:10:35 AM 0 1457 0.46 0.00 46252 1560 0.00 systemd-udevd
11:10:35 AM 0 2429 0.11 0.00 163620 9472 0.03 sshd
11:10:35 AM 992 2446 0.02 0.00 8588 996 0.00 lsmd
11:10:35 AM 0 2447 0.05 0.00 90572 1468 0.00 rngd
11:10:35 AM 0 2448 0.15 0.02 451272 3520 0.01 udisksd
11:10:35 AM 0 2449 0.18 0.02 396488 1948 0.01 accounts-daemon
11:10:35 AM 0 2454 0.02 0.02 201336 1464 0.00 gssproxy
...表头字段说明
- PID：进程标识符
- Minflt/s:任务每秒发生的次要错误，不需要从磁盘中加载页
- Majflt/s:任务每秒发生的主要错误，需要从磁盘中加载页
- VSZ：虚拟地址大小，虚拟内存的使用KB
- RSS：常驻集合大小，非交换区五里内存使用KB
- Command：task命令名
查看所有进程的IO使用情况
# pidstat -d
11:12:30 AM UID PID kB_rd/s kB_wr/s kB_ccwr/s Command
11:12:30 AM 0 1 250.05 11.57 2.13 systemd
11:12:30 AM 0 224 1.21 0.00 0.00 khugepaged
11:12:30 AM 0 290 0.03 0.00 0.00 kswapd0
11:12:30 AM 0 291 0.02 0.00 0.00 kswapd1
11:12:30 AM 0 1312 1.03 0.00 0.00 xfsaild/dm-0
11:12:30 AM 0 1407 1.31 0.00 0.00 systemd-journal
11:12:30 AM 0 1442 0.01 0.00 0.00 lvmetad
11:12:30 AM 0 1457 1.77 0.00 0.00 systemd-udevd
11:12:30 AM 992 2446 0.79 0.00 0.00 lsmd
11:12:30 AM 0 2447 0.07 0.00 0.00 rngd
11:12:30 AM 0 2448 0.46 0.00 0.00 udisksd
...表头字段说明
- PID：进程id
- kB_rd/s：每秒从磁盘读取的KB
- kB_wr/s：每秒写入磁盘KB
- kB_ccwr/s：任务取消的写入磁盘的KB。当任务截断脏的pagecache的时候会发生。
- COMMAND:task的命令名
查看进程的上下文切换情况
# pidstat -w
11:15:52 AM UID PID cswch/s nvcswch/s Command
11:15:52 AM 0 1 3.15 0.03 systemd
11:15:52 AM 0 2 0.13 0.00 kthreadd
11:15:52 AM 0 3 0.00 0.00 rcu_gp
11:15:52 AM 0 4 0.00 0.00 rcu_par_gp
11:15:52 AM 0 6 0.00 0.00 kworker/0:0H-kblockd
11:15:52 AM 0 9 0.00 0.00 mm_percpu_wq
11:15:52 AM 0 10 1.99 0.00 ksoftirqd/0
...表头字段含义
- PID:进程id
- Cswch/s:每秒主动任务上下文切换数量
- Nvcswch/s:每秒被动任务上下文切换数量
- Command:命令名
pgrep
pgrep是一个Linux/Unix命令行工具，用于通过进程名称或PID（进程ID）来查找正在运行的进程。它可以帮助用户查找并获取有关进程的详细信息。如果可以找到匹配的进程，pgrep将返回该进程的PID，否则将不返回任何内容。常见的用法是在一条命令中与kill命令结合使用，以终止特定的进程。例如， pgrep firefox | xargs kill 可以杀掉正在运行的Firefox进程。
选项
-o：仅显示找到的最小（起始）进程号；
-n：仅显示找到的最大（结束）进程号；
-l：显示进程名称；
-P：指定父进程号；
-g：指定进程组；
-t：指定开启进程的终端；
-u：指定进程的有效用户ID。实例
pgrep -lo httpd
4557 httpd
[root@localhost ~]# pgrep -ln httpd
4566 httpd
[root@localhost ~]# pgrep -l httpd
4557 httpd
4560 httpd
4561 httpd
4562 httpd
4563 httpd
4564 httpd
4565 httpd
4566 httpd
[root@localhost ~]# pgrep httpd 4557
4560
4561
4562
4563
4564
4565
4566pidof
pidof是一个Linux/Unix命令行工具，用于查找指定程序的PID（进程ID）。与pgrep命令类似，不同之处在于`pidof`命令只能通过进程名称来查找进程。如果找到匹配的进程，pidof将返回该进程的PID，否则将不返回任何内容。
与pgrep一样，pidof也可以与其他命令结合使用，例如，kill $(pidof firefox)可以用来杀掉正在运行的Firefox进程。
需要注意的是，pidof仅返回当前用户执行的进程的PID，如果您想查找其他用户执行的进程，则需要使用-u选项将pidof命令的执行权限提升为root用户。
选项
-s：仅返回一个进程号；
-c：仅显示具有相同“root”目录的进程；
-x：显示由脚本开启的进程；
-o：指定不显示的进程ID。查找某个指定服务所对应的进程PID号码：
[root@linuxcool ~]# pidof sshd 7518查找多个指定服务所对应的进程PID号码：
[root@linuxcool ~]# pidof sshd crond 7518 2443uptime
uptime是一个Linux/Unix命令行工具，用于显示当前系统的运行时间、平均负载以及当前登录用户数。执行uptime命令将返回一个类似以下格式的输出：
10:25:01 up 7 days, 3:12, 4 users, load average: 0.23, 0.27, 0.25输出中包含了以下信息：
- 当前时间：10:25:01
- 系统已经运行的时间：7天3小时12分钟
- 当前登录用户数：4
- 近1分钟、5分钟、15分钟的平均负载：0.23, 0.27, 0.25
平均负载指的是正在运行和等待CPU处理的进程数目的平均值。在Linux中，当平均负载高于CPU核心数量的时候，系统则可能出现瓶颈或者压力。因此，通过查看平均负载可以帮助我们快速识别和定位系统压力或瓶颈的来源。
mpstat
mpstat是一个Linux/Unix命令行工具，用于显示每个可用CPU的使用情况。执行mpstat命令将返回一些类似以下格式的输出：
Linux 5.0.0-23-generic (hostname) 08/26/20 _x86_64_ (4 CPU)
20:47:35 CPU %usr %nice %sys %iowait %irq %soft %steal %guest %gnice %idle
20:47:35 all 1.71 0.00 0.58 0.24 0.00 0.13 0.00 0.00 0.00 97.34
20:47:35 0 1.25 0.00 0.59 0.57 0.00 0.24 0.00 0.00 0.00 97.34
20:47:35 1 2.44 0.00 0.71 0.12 0.00 0.06 0.00 0.00 0.00 96.67
20:47:35 2 1.09 0.00 0.48 0.26 0.00 0.10 0.00 0.00 0.00 98.08
20:47:35 3 1.06 0.00 0.37 0.09 0.00 0.03 0.00 0.00 0.00 98.45输出中包含了以下信息：
- 系统版本、主机名和CPU数量。
- 时间戳、CPU编号以及CPU使用率（%usr、%sys、%idle等）等内容。其中，%usr表示CPU正在执行用户进程代码的时间比例，而%sys表示CPU正在执行内核代码的时间比例。
表头含义
- %user：表示处理用户进程所使用CPU的百分比。
- %nice：表示在用户级别处理经nice降级的程序所使用CPU的百分比。
- %system：表示内核进程使用的CPU百分比。
- %iowait：表示等待进行I/O所占用CPU时间百分比。
- %irq：表示用于处理系统中断的CPU百分比。
- %soft：表示用于处理软件中断的CPU百分比。
- %steal：在管理程序为另一个虚拟处理器服务时，显示虚拟的一个或多个CPU在非自愿等待中花费的时间的百分比。
- %guest：表示一个或多个CPU在运行虚拟处理器时所花费的时间百分比。
- %gnice：表示一个或多个CPU在运行经nice降级后的虚拟处理器时所花费的时间百分比。
- %idle：CPU的空闲时间百分比。
mpstat可以帮助您监控整个系统或特定进程使用的资源，并且可以在调查性能问题时提供有价值的信息。除了显示CPU使用情况外，mpstat还可以显示其他指标，例如内存使用率、磁盘I/O等。
top
top是一个Linux/Unix命令行工具，用于实时显示系统中占用CPU和内存等资源最高的进程。执行top命令将返回类似以下的输出：
top - 10:45:15 up 7 days, 3:19, 5 users, load average: 0.00, 0.01, 0.05
Tasks: 204 total, 1 running, 203 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.2 us, 0.1 sy, 0.0 ni, 99.6 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
MiB Mem : 15709.8 total, 5361.2 free, 8486.0 used, 1862.6 buff/cache
MiB Swap: 2048.0 total, 2048.0 free, 0.0 used. 5834.4 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
2155 username 20 0 1185408 321276 12228 S 1.2 2.0 56:22.02 gnome-shell
15971 username 20 0 824728 26308 20736 S 1.0 0.2 0:00.53 gnome-terminal-
22294 username 20 0 180884 49704 32264 S 1.0 0.3 0:01.49 chrome
1 root 20 0 169344 9736 6412 S 0.0 0.1 0:03.02 systemd
2 root 20 0 0 0 0 S 0.0 0.0 0:00.00 kthreadd
4 root 0 -20 0 0 0 I 0.0 0.0 0:00.00 kworker/0:-H输出中包含了以下信息：
- 当前时间、系统的运行时间和平均负载等信息。
- 系统中任务的数量和状态，以及CPU和内存的使用情况。
- 各个进程的PID、占用CPU和内存的百分比、执行时间以及进程名等信息。
通过top命令，您可以快速查看系统中哪些进程正在占用大量的资源，以便及时定位和解决性能问题。此外，top还可帮助您了解系统的整体运行情况，例如负载状况、内存使用情况等。
htop
htop是一个Linux/Unix命令行工具，用于实时显示系统中占用CPU和内存等资源最高的进程。执行htop命令将返回类似以下的输出：
1 [||||||| 10.0%] Tasks: 174, 23 thr; 1 running
2 [||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| 52.7%] Load average: 2.86 2.92 2.98
Mem[||||||||||||||||||||||||||||||||||||||||||||||||||| 16.7G/31.3G] Uptime: 3 days, 07:34:38
Swp[|||||||||||||||||||||||||||| 1.9G/2.0G]
PID USER PRI NI VIRT RES SHR S CPU% MEM% TIME+ Command
6523 user1 20 0 2.2G 1.3G 6616 S 29.9 4.2 33:40.11 /usr/bin/java -server -Xms14336m -Xmx14336m -XX:PermSize=1024M -XX:MaxPe
5015 user2 20 0 853M 156M 102M S 2.8 0.5 155:18.02 /usr/bin/redis-server *:6379
8314 user3 20 0 2931M 678M 10M S 1.9 2.1 50:22.11 /usr/sbin/mysqld --basedir=/usr --datadir=/var/lib/mysql --plugin-dir=/usr/l输出中包含了以下信息：
- 系统负载、内存和交换空间使用情况的实时图形化表示。
- 每个进程的PID、用户、CPU和内存使用率、命令名称、优先级和状态等信息。
与top相比，htop提供了更加直观和友好的界面，并且支持鼠标交互和快捷键操作，使得查看和管理进程更加方便和高效。同时，htop还提供了一些额外的功能，例如进程筛选、进程树形结构显示、进程服务端口监听等，让您更好地定位和管理系统资源。
free
free是一个Linux/Unix命令行工具，用于显示系统的内存使用情况。执行free命令将返回类似以下的输出：
total used free shared buff/cache available
Mem: 32946424 27224828 2663636 450328 3030960 4338944
Swap: 33554428 0 33554428输出中包含了以下信息：
total表示总共的物理内存大小。used表示已使用的物理内存大小。free表示可用的物理内存大小。shared表示被共享使用的物理内存大小。buff/cache表示被缓存的物理内存大小。available表示当前可用的物理内存大小。
选项
-b # 以Byte为单位显示内存使用情况；
-k # 以KB为单位显示内存使用情况；
-m # 以MB为单位显示内存使用情况；
-g # 以GB为单位显示内存使用情况。
-o # 不显示缓冲区调节列；
-s<间隔秒数> # 持续观察内存使用状况；
-t # 显示内存总和列；
-V # 显示版本信息。同时，free还会显示交换空间的使用情况，包括总共的交换空间大小、已使用的交换空间大小和可用的交换空间大小。
通过free命令，您可以了解系统当前的内存使用情况，包括总内存、已使用内存、可用内存、共享内存、缓存内存以及交换空间使用情况。可以根据这些信息来查看系统是否存在内存不足的问题，并且可以用来诊断和解决性能问题。
pmap
pmap是一个Linux/Unix命令行工具，用于显示指定进程或进程集合的内存映射信息。执行pmap命令将返回类似以下的输出：
0000562cd1709000 252K r-x-- nginx
0000562cd1aab000 64K rw--- nginx
0000562cd1aba000 8K rw--- [ anon ]
00007f98f99c3000 72K r-x-- libnss_files-2.33.so
00007f98f99d6000 2044K ----- libnss_files-2.33.so
00007f98f9bd5000 4K r---- libnss_files-2.33.so
00007f98f9bd6000 4K rw--- libnss_files-2.33.so
00007f98f9bd7000 164K r-x-- libpthread-2.33.so
00007f98f9c00000 2048K ----- libpthread-2.33.so
00007f98f9e00000 4K r---- libpthread-2.33.so
00007f98f9e01000 4K rw--- libpthread-2.33.so
00007f98f9e02000 20K rw--- [ anon ]
00007f98f9e07000 1488K r-x-- libc-2.33.so
00007f98f9fbb000 2048K ----- libc-2.33.so
00007f98fa1bb000 16K r---- libc-2.33.so
00007f98fa1bf000 12K rw--- libc-2.33.so
00007f98fa1c2000 20K rw--- [ anon ]输出中包含了以下信息：
- 内存地址范围：第一列是内存地址范围的起始地址，第二列是内存地址范围的结束地址。这些地址通常以16进制表示。
- 内存映射类型：第三列是内存映射的类型，包括r-x（可执行代码）、r--（只读数据）、rw-（读写数据）等。
- 映射文件或库名：第四列是映射到此内存区域的文件或库的名称，如果没有则显示[anon]（匿名映射）。
- 偏移量：第五列是文件或库的偏移量，通常为0。
- 其他信息：还有一些其他的信息，例如权限位和共享内存标记等。
选项
-x：显示扩展格式；
-d：显示设备格式；
-q：不显示头尾行；
-V：显示指定版本。通过pmap命令，您可以查看指定进程的内存映射情况，包括内存地址范围、内存映射类型、映射文件或库名等，可以帮助您了解系统中进程的内存使用情况。可以根据这些信息来诊断和解决性能问题。
vmstat
vmstat是一个Linux/Unix命令行工具，用于显示系统的虚拟内存状态。执行vmstat命令将返回类似以下的输出：
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
1 0 496 32456 7744 152836 0 0 0 4 2 1 0 0 100 0 0输出中包含了以下信息：
procs列表示正在运行和等待运行的进程数。memory列包括以下信息：
swpd表示使用的交换空间大小（单位为KB）。free表示空闲的物理内存大小（单位为KB）。buff表示被用作缓冲的内存大小（单位为KB）。cache表示被用作缓存的内存大小（单位为KB）。
swap列包括以下信息：
si表示从磁盘读入交换空间的速度（单位为KB/s）。so表示向磁盘写出交换空间的速度（单位为KB/s）。
io列包括以下信息：
bi表示从块设备（通常是硬盘）读取的数据量（单位为KB/s）。bo表示向块设备（通常是硬盘）写入的数据量（单位为KB/s）。
system列包括以下信息：
in表示每秒中断数（包括时钟中断）。cs表示每秒上下文切换数。
cpu列包括以下信息：
us表示用户空间程序占用CPU的时间百分比。sy表示系统内核占用CPU的时间百分比。id表示CPU空闲时间百分比。wa表示等待I/O操作完成的时间百分比。st表示在虚拟化环境中发生的被偷取的时间百分比。
通过vmstat命令，您可以了解系统的虚拟内存使用情况，包括交换空间、空闲内存、缓冲和缓存内存、磁盘读写速度、中断数、上下文切换数以及CPU使用情况等。可以根据这些信息来查看系统是否存在内存或I/O瓶颈，并且可以用来诊断和解决性能问题。
iostat
iostat是一个Linux/Unix命令行工具，用于显示系统的磁盘I/O活动情况，包括磁盘读写速度、I/O等待时间和CPU使用率等。执行iostat命令将返回类似以下的输出：
Linux 5.11.0-16-generic (ubuntu) 04/20/23 _x86_64_ (4 CPU)
avg-cpu: %user %nice %system %iowait %steal %idle
1.70 0.00 0.38 0.14 0.00 97.79
Device tps kB_read/s kB_wrtn/s kB_dscd/s kB_read kB_wrtn kB_dscd
sda 0.98 0.80 22.67 0.00 363065491 10260990328 0
sdb 8.35 0.03 102.17 0.00 14684240 46223094920 0输出中包含了以下信息：
avg-cpu列汇总显示了系统中所有CPU的平均使用情况，包括以下信息：
%user表示用户空间程序占用CPU的时间百分比。%nice表示NICE值较高的进程占用CPU的时间百分比。%system表示内核占用CPU的时间百分比。%iowait表示等待I/O操作完成的时间百分比。%steal表示在虚拟化环境中发生的被偷取的时间百分比。%idle表示CPU空闲时间百分比。
Device列显示了每个磁盘的名称。tps列表示每秒钟的磁盘I/O请求数量。kB_read/s列表示每秒钟从磁盘读取的数据量（单位为KB）。kB_wrtn/s列表示每秒钟向磁盘写入的数据量（单位为KB）。kB_dscd/s列表示每秒钟从磁盘丢弃的数据量（单位为KB，通常为0）。kB_read列表示自系统启动以来从磁盘读取的总数据量（单位为KB）。kB_wrtn列表示自系统启动以来向磁盘写入的总数据量（单位为KB）。kB_dscd列表示自系统启动以来从磁盘丢弃的总数据量（单位为KB，通常为0）。
通过iostat命令，您可以查看每个磁盘的I/O活动情况，包括磁盘读写速度、I/O等待时间和CPU使用率等。可以根据这些信息来查看系统是否存在磁盘I/O瓶颈，并且可以用来诊断和解决性能问题。
iotop
iotop是一个Linux/Unix命令行工具，用于实时监控系统中磁盘I/O活动情况，包括每个进程的磁盘读写速度、I/O等待时间以及磁盘I/O使用率等。执行iotop命令将返回类似以下的输出：
Total DISK READ : 30.25 K/s | Total DISK WRITE : 605.54 K/s
Actual DISK READ: 30.25 K/s | Actual DISK WRITE: 605.54 K/s
TID PRIO USER DISK READ DISK WRITE SWAPIN IO COMMAND
899 be/4 root 0.00 B 28.20 M 0.00 % 49.10 % [jbd2/sda1-8]
1213 be/4 www-data 0.00 B 21.64 M 0.00 % 0.69 % apache2 -k start
1639 be/4 www-data 0.00 B 6.37 M 0.00 % 0.07 % apache2 -k start
1642 be/4 www-data 0.00 B 6.35 M 0.00 % 0.06 % apache2 -k start
1198 be/4 www-data 0.00 B 6.15 M 0.00 % 0.57 % apache2 -k start
1755 be/4 www-data 0.00 B 4.49 M 0.00 % 0.05 % apache2 -k start
1775 be/4 www-data 0.00 B 4.45 M 0.00 % 0.05 % apache2 -k start
1214 be/4 www-data 0.00 B 4.10 M 0.00 % 0.31 % apache2 -k start
1656 be/4 www-data 0.00 B 3.94 M 0.00 % 0.09 % apache2 -k start
1668 be/4 www-data 0.00 B 3.89 M 0.00 % 0.06 % apache2 -k start输出中包含了以下信息：
Total DISK READ列显示了自系统启动以来读取的磁盘数据总量（单位为KB/s）。Total DISK WRITE列显示了自系统启动以来写入的磁盘数据总量（单位为KB/s）。Actual DISK READ列显示当前磁盘读取速度（单位为KB/s）。Actual DISK WRITE列显示当前磁盘写入速度（单位为KB/s）。TID列显示了进程的线程ID号。PRIO列显示了进程的优先级。USER列显示了进程所属的用户。DISK READ列显示了该进程的从磁盘读取的数据量（单位为B）。DISK WRITE列显示了该进程的向磁盘写入的数据量（单位为B）。SWAPIN列显示了该进程从磁盘交换区读取的数据量（单位为B）。IO列显示了该进程的I/O使用率（读取和写入的总数据量占总I/O活动时间的百分比）。COMMAND列显示了该进程的名称及其参数。
通过iotop命令，您可以实时监控系统中磁盘I/O活动情况，并查看每个进程的磁盘读写速度、I/O等待时间以及磁盘I/O使用率等。可以根据这些信息来查看系统是否存在磁盘I/O瓶颈，并且可以用来诊断和解决性能问题。
iftop
iftop是一个开源的Linux/Unix网络流量监控工具，可以实时监测系统中网络接口的流量情况，即实时显示网络带宽占用情况及占用带宽最高的进程信息。执行iftop命令将返回类似以下的输出：
Interface: eth0
IP address : 192.168.0.100/24
===============================================================================
TX RX Total Cummulative
-------------------------------------------------------------------------------
tcp://example.com:22 4.80KB 6.32KB 11.12KB 11.12KB
tcp://example.com:443 2.78KB 1.62KB 4.39KB 15.51KB
tcp://example.com:4443 21.09KB 23.45KB 44.55KB 60.06KB
-------------------------------------------------------------------------------
Total 28.67KB 31.39KB 60.06KB
===============================================================================输出中包含了以下信息：
Interface列显示了当前监测的网络接口名称。IP address列显示了当前网络接口的IP地址及子网掩码。TX列显示了网络接口上以TCP或UDP协议发送的数据量（单位为KB）。RX列显示了网络接口上以TCP或UDP协议接收的数据量（单位为KB）。Total列显示了网络接口上总的数据传输量（即TX+RX，单位为KB）。Cummulative列显示了自iftop启动以来网络接口上总的数据传输量（即所有连接的总数据传输量，单位为KB）。tcp://example.com:22显示了正在进行TCP连接的远程主机IP和端口号，同时显示了该连接在当前时间内以TCP协议发送和接收的数据量（单位为KB）。Total列显示了该连接在当前时间内总的数据传输量（即TX + RX，单位为KB）。
通过iftop命令，您可以实时监测系统中网络接口的流量情况，并查看每个连接的数据传输量。可以根据这些信息来诊断和解决网络性能问题。
nload
nload是一个简单易用的基于命令行的Linux/Unix网络流量监控工具，可以实时监测系统中网络接口的流量情况，即实时显示网络带宽占用情况。执行nload命令将返回类似以下的输出：
Device: eth0
Incoming:
Curr: 11.19 MBit/s
Avg1: 7.11 MBit/s
Avg5: 5.85 MBit/s
Avg15: 5.74 MBit/s
Outgoing:
Curr: 3.62 MBit/s
Avg1: 2.65 MBit/s
Avg5: 2.34 MBit/s
Avg15: 2.30 MBit/s输出中包含了以下信息：
Device列显示了当前监测的网络接口名称。Incoming列显示了网络接口接收实时数据传输量（单位为Mbit/s）以及过去1、5、15分钟内的平均数据传输量。Outgoing列显示了网络接口发送实时数据传输量（单位为Mbit/s）以及过去1、5、15分钟内的平均数据传输量。
通过nload命令，您可以实时查看系统中每个网络接口上的网络流量并且可以通过计算出入数据传输速度的平均值，来更好地了解系统的网络流量状况。可以根据这些信息来诊断和解决网络性能问题。
nethogs
nethogs是一个基于命令行的Linux/Unix网络流量监控工具，可以实时监测和分析系统中每个进程的网络流量状况。执行nethogs命令将返回类似以下的输出：
------------------------------------------------------------------------
NetHogs version 0.8.5-19-g0b9f9e0
PID USER PROGRAM DEV SENT RECEIVED
2355 root sshd: user@pts/2 eth0 1.0674 195.0122 KB/sec
1781 www-data /usr/sbin/apache2 eth0 0.0000 0.0000 KB/sec
3567 mysql mysqld eth0 0.0000 0.0000 KB/sec
1378 root dhclient eth0 0.0000 0.0000 KB/sec
------------------------------------------------------------------------
Total sent: 1.0674 KB/sec (2.6%)
Total received: 195.0122 KB/sec (97.4%)输出中包含了以下信息：
PID列显示了每个进程的进程ID。USER列显示了每个进程所属的用户。PROGRAM列显示了每个进程的名称及程序路径。DEV列显示了进程使用的网络设备（即网络接口）名称。SENT列显示了进程发送数据的速率（单位为KB/s）。RECEIVED列显示了进程接收数据的速率（单位为KB/s）。
通过nethogs命令，您可以实时查看系统每个进程的网络流量状况，并将它们按照使用带宽的大小进行排列。这对于诊断网络性能问题以及查找网络资源使用情况非常有用。
iptraf-ng
iptraf-ng 是一款开源的网络流量监控工具，它能够用于实时地监控网络流量、统计每个 IP 地址的流量和分组数量、分析 TCP、UDP 和其他协议的流量等。它的用户界面基于 ncurses 库，可以在终端中直接运行，非常适合在命令行环境下使用。
iptraf-ng 主要特点包括：
- 实时监控：可以实时地监控网络接口的入站和出站流量，以及当前连接数、速率、协议等信息。
- 统计功能：可以统计每个 IP 地址的流量和分组数量，也可以统计整个网络的流量和分组数量等。
- 协议分析：支持对 TCP、UDP、ICMP、IGMP 等协议的流量进行分析和监控。
- 连接信息：可以查看现有的 TCP/UDP 连接信息，包括源地址、目标地址、端口号、状态等。
- 流量图表：类似于 iftop 的实时流量图表，可以清晰地显示每个连接的网络流量信息。
- 日志记录：可以将监控数据记录到日志文件中，方便后续分析。
iptraf-ng 参数：
-i：指定要监控的网络接口名，如 iptraf-ng -i eth0。
-s：指定要统计的时间间隔，单位为秒，如 iptraf-ng -s 5 表示每隔 5 秒统计一次流量。
-B：打开广播地址流量监控功能。
-M：打开多播地址流量监控功能。
-t：显示 TCP 连接信息面版。
-u：显示 UDP 连接信息面版。
-g：显示一个实时流量图表面板，类似于 iftop。
-L：将监控数据记录到日志文件中。
-h：显示帮助信息。
-V：显示版本信息。- 监控网络流量并记录到日志文件中
sudo iptraf-ng -i eth0 -L该命令会在终端中打开 iptraf-ng，监控 eth0 网络接口的流量，并将监控数据记录到 /var/log/iptraf-ng.log 文件中。
- 实时监控 TCP 连接信息和流量图表
sudo iptraf-ng -i eth0 -t -g该命令会在终端中打开 iptraf-ng，实时监控 eth0 网络接口的 TCP 连接信息和流量图表。用户可以根据需要进行查看和分析，以便识别网络瓶颈和异常情况。
总体来说，iptraf-ng 是一款非常实用的网络流量监控工具，它可以帮助用户快速了解网络通信情况，识别瓶颈和异常，保证网络的正常运行。同时，它也具有开源、跨平台等优点，非常适合安装在 Linux 系统上使用。
dstat
在Linux系统中，dstat是一个命令行工具，它可以提供实时系统资源的统计数据。它可以监测CPU使用率、内存占用、网络流量、磁盘I/O等系统性能指标，并将它们以可读性高的方式展示出来。通常情况下，dstat会周期性地输出这些统计数据，从而使用户能够了解系统在某个时间段内的运行状态。
dstat支持多种不同的数据源，可以通过命令行参数来指定需要监测的数据类型。例如，通过指定-d参数可以监测磁盘I/O，而通过-n参数则可以监测网络流量。此外，dstat还支持将统计数据输出到文件或者CSV格式中，以便用户进行更进一步的分析或者图表展示。
dstat命令具有多个参数，以下是一些常用的参数：
- -c: 监视CPU使用率。
- -d: 监视磁盘I/O，包括读取和写入。
- -g: 监视页面交换、中断和上下文切换。
- -i: 监视网络接口的统计信息，包括接收和发送数据包。
- -l: 监视进程的统计信息，包括运行的进程和它们所消耗的资源。
- -m: 监视内存使用情况。
- -n: 监视网络流量，包括TCP、UDP和ICMP流量。
- -p: 指定要监视的进程或进程组。
- -r: 监视系统负载、内存使用情况和其他相关的统计信息。
- -s: 指定统计间隔时间，默认值是1秒。
- --vmstat: 以vmstat格式输出系统状态信息。
除了以上的参数外，还有许多其他的选项供用户控制dstat的行为，可以通过运行“dstat --help”命令查看所有可用的选项。
glances
在Linux系统中，Glances是一个跨平台的系统监视工具。它可以显示关于CPU、内存、磁盘、网络等方面的实时信息，并提供了一个用户友好的Web界面进行查看。Glances可以通过命令行或Web界面进行操作，而且还支持插件机制，可以自定义扩展功能。
Glances主要特点如下：
- 显示系统资源实时使用情况。
- 支持远程监视。
- 提供Web界面和命令行界面。
- 可扩展性强，支持插件。
使用Glances非常简单，在终端中输入“glances”即可启动它。此外，还可以通过添加一些选项来定制Glances的行为，比如：
-b：以后台模式运行Glances。
-C：禁用颜色输出。
-i：设置更新间隔时间（默认为两秒）。
-w：将Glances输出成网页格式并以Web服务的方式运行。
-p：设置Web服务的监听端口。以下是一些使用Glances的例子：
- 在命令行中启动Glances：
glances- 以Web服务方式运行Glances：
glances -w- 设置更新间隔时间为5秒钟：
glances -i 5- 以指定端口号（例如8888）的Web服务模式启动Glances：
glances -w -p 8888- 在命令行中启动Glances，并以后台模式运行：
glances -b在运行Glances之后，你可以看到一个实时监控系统资源使用情况的窗口。在窗口中，你会看到CPU、内存、磁盘、网络等不同方面的实时信息，并且它们的状态颜色也会显示出来。此外，你还可以使用键盘输入各种控制命令。通过输入"H"来查看所有可用的控制命令。
如果你使用的是Web服务模式启动Glances，在电脑浏览器中访问"localhost:61208"（默认端口号）即可查看系统的资源使用情况。
另外，Glances还支持很多其他的命令行选项，你可以通过命令"glances --help"来查看所有可用选项。
cockpit
Cockpit是一种在Linux系统上管理服务器的Web应用程序。它提供了一个现代化的Web界面，可让用户轻松远程管理服务器，以及监视和管理诸如系统日志、服务和用户等方面的信息。
Cockpit是一个开源的项目，已成为众多流行Linux发行版的标准组件之一，包括Red Hat Enterprise Linux、Fedora、CentOS等等。它适用于服务器管理员、开发人员以及需要监视和管理多台服务器的企业。
以下是使用Cockpit进行一些操作的例子：
- 在Linux系统上安装Cockpit（假设使用的是Debian/Ubuntu系统）：
sudo apt-get install cockpit- 启动Cockpit并登录Web界面（默认端口为9090）：
在Web浏览器中输入"localhost:9090"或"服务器IP地址:9090"来访问Cockpit的Web界面。输入管理员用户名和密码以登录。
- 查看系统资源使用情况：
在Cockpit的仪表板页面，你可以看到有关系统资源使用情况的概览信息，包括CPU、内存、磁盘和网络等方面的实时数据。你还可以单击每个小部件来查看更详细的信息。
- 查看系统日志：
Cockpit提供了一个名为"日志"的选项卡，你可以在这里查看系统的各种日志，包括系统日志、安全日志和应用程序日志等。
- 管理用户和组：
你可以通过Cockpit管理系统上的用户和组。在"用户"选项卡中，你可以添加、删除、编辑用户，并设置他们的密码和访问权限等。在"组"选项卡中，你可以创建、删除和编辑用户组。
- 管理服务：
在"Cockpit"中，你可以查看当前正在运行的服务、停止服务以及启动已经停止的服务。此外，你还可以启用或禁用系统默认服务，并配置它们的选项。
以上只是使用Cockpit的部分例子，你可以根据自己的需要和系统要求，选择其他选项卡和功能模块以进行系统管理和监控。
kill
在Linux系统中，kill命令用于终止或杀死进程。
下面是一些常见的使用方法：
- 使用
kill命令终止进程：
kill 进程ID例如，要终止进程ID为1234的进程，可以使用以下命令：
kill 1234- 使用
kill命令强制终止进程：
如果进程没有正常终止的方式，可以使用以下命令来强制终止进程：
kill -9 进程ID例如，要强制终止进程ID为1234的进程，可以使用以下命令：
kill -9 1234- 使用
killall命令终止同名进程：
如果你有多个同名进程正在运行，可以使用killall命令终止它们。
killall 进程名例如，要终止所有名称为"firefox"的进程，可以使用以下命令：
killall firefox需要注意的是，kill和killall命令可以终止普通用户的进程。如果要终止root用户的进程，则需要使用sudo命令或以root用户的身份执行命令。另外，杀死进程会造成该进程的数据丢失，所以在使用kill或killall命令时需要小心。
选项
-s sig 信号名称。
-n sig 信号名称对应的数字。
-l 列出信号名称。如果在该选项后提供了数字那么假设它是信号名称对应的数字。
-L 等价于-l选项。例子
[user2@pc] kill -l 9
KILL
# 列出所有信号名称：
[user2@pc] kill -l
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL
5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE
9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2
13) SIGPIPE 14) SIGALRM 15) SIGTERM 16) SIGSTKFLT
17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU
25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH
29) SIGIO 30) SIGPWR 31) SIGSYS 34) SIGRTMIN
35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+4
39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12
47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14
51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10
55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6
59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX
# 下面是常用的信号。
# 只有第9种信号(SIGKILL)才可以无条件终止进程，其他信号进程都有权利忽略。
HUP 1 终端挂断
INT 2 中断（同 Ctrl + C）
QUIT 3 退出（同 Ctrl + \）
KILL 9 强制终止
TERM 15 终止
CONT 18 继续（与STOP相反，fg/bg命令）
STOP 19 暂停（同 Ctrl + Z）# 以下发送KILL信号的形式等价。当然还有更多的等价形式，在此不一一列举了。
[user2@pc] kill -s SIGKILL PID
[user2@pc] kill -s KILL PID
[user2@pc] kill -n 9 PID
[user2@pc] kill -9 PID
[user2@pc] sleep 90 &
[1] 178420
# 终止作业标识符为1的作业。
[user2@pc] kill -9 %1
[user2@pc] jobs -l
[1]+ 178420 KILLED ssh 192.168.1.4
[user2@pc] sleep 90 &
[1] 181357
# 发送停止信号。
[user2@pc] kill -s STOP 181357
[user2@pc] jobs -l
[1]+ 181537 Stopped (signal) sleep 90
# 发送继续信号。
[user2@pc] kill -s CONT 181357
[user2@pc] jobs -l
[1]+ 181537 Running sleep 90 &jobs
在Linux中，job是指在一个终端窗口（也就是shell）上运行的命令，可以是前台作业或后台作业。
- 前台作业：
当你在终端中输入命令并按下回车键时，该命令将成为该终端的前台作业。在该命令执行期间，该终端将被占用，直到该命令完成执行并返回提示符。
如果要停止正在进行的前台作业，可以使用Ctrl + C快捷键。可以使用jobs命令列出当前正在运行的前台和后台作业。
- 后台作业：
如果你在命令末尾添加&字符，该命令将成为一个后台作业，并且立即将控制权返回给终端。这意味着你可以在后台启动一个长时间运行的进程，而不必等待该进程完成执行。例如：
$ long_running_command &如果需要把一个正在运行的前台作业转换成后台作业，可以使用Ctrl + Z快捷键来暂停该作业，然后使用bg命令将其转换为后台作业。例如：
$ long_running_command #运行前台作业
Ctrl + Z #用Ctrl+Z挂起一个前台作业
$ bg #在后台恢复作业可以使用jobs命令列出当前正在运行的前台和后台作业，并使用kill命令来终止作业。
选项
-l 在作业信息中额外的列出PID。
-n 只列出最近一次通知以来状态变更的作业。
-p 只列出PID。
-r 只输出处于运行状态的作业。
-s 只输出处于停止状态的作业。at
在 Linux 中，at 是一个用于定时执行命令的工具。它允许用户指定一次性的任务在未来特定的时间点运行，而不是立即运行。
用户可以使用 at 命令将要执行的命令添加到队列中，并指定任务执行的时间。队列中的任务将在指定的时间点被执行，并产生相应的输出结果。
选项
-f：指定包含具体指令的任务文件；
-q：指定新任务的队列名称；
-l：显示待执行任务的列表；
-d：删除指定的待执行任务；
-m：任务执行完成后向用户发送E-mail。以下是 at 命令的基本用法：
- 使用 at 命令启动交互式 shell：
$ at now + 1 hour- 输入要执行的命令：
at> echo "Hello, World!" > /tmp/hello.txt- 按下 Ctrl + D 保存并退出。
上述命令的含义是在当前时间的一个小时后执行 echo 命令，并将其输出重定向到 /tmp/hello.txt 文件中。
实例
三天后的下午 5 点执行/bin/ls：
[root@localhost ~]# at 5pm+3 days
at> /bin/ls
at> <EOT>
job 7 at 2013-01-08 17:00明天17点钟，输出时间到指定文件内：
[root@localhost ~]# at 17:20 tomorrow
at> date >/root/2013.log
at> <EOT>
job 8 at 2013-01-06 17:20计划任务设定后，在没有执行之前我们可以用atq命令来查看系统没有执行工作任务：
[root@localhost ~]# atq
8 2013-01-06 17:20 a root
7 2013-01-08 17:00 a root
[root@localhost ~]# atrm 7
[root@localhost ~]# atq
8 2013-01-06 17:20 a root可以使用 atq 命令来查看当前队列中所有待执行的任务，使用 atrm 命令来删除指定的任务。
crontab
在 Linux 系统中，crontab 是一个用于定期执行任务的工具。通过在 crontab 文件中添加命令和相应的执行时间，用户可以指定一些重复性的任务在特定时间间隔内执行。
以下是 crontab 的基本用法：
- 使用 crontab -e 命令编辑当前用户的 crontab 文件
$ crontab -e这将会打开一个类似于编辑器的界面，允许用户在其中添加新的任务或修改已有任务的执行时间和命令。
- 在 crontab 文件中添加任务。每一行表示一个任务，可以用五个时间字段来指定任务在何时执行：
* * * * * command-to-be-executed
- - - - -
| | | | |
| | | | ----- 周 (0 - 6) (Sunday is both 0 and 7)
| | | ------- 月 (1 - 12)
| | --------- 日 (1 - 31)
| ----------- 时 (0 - 23)
------------- 分 (0 - 59)例如，下面的命令表示每分钟都要运行 command-to-be-executed：
* * * * * command-to-be-executed- 保存并退出编辑器。
此外，还可以使用 crontab -l 命令来列出所有当前用户的任务，也可以使用 crontab -r 命令来删除所有任务。
请注意，在使用 crontab 时需要小心，确保所添加的任务不会对系统安全或稳定性造成影响。
2.总结索引数组和关联数组，字符串处理，高级变量使用及示例
索引数组和关联数组
在Bash中，数组是一种数据结构，可以用来存储一组值。Bash中支持两种类型的数组：索引数组和关联数组。
- 索引数组： 索引数组是按照数字索引访问元素的数组类型。在Bash中，索引从0开始。可以使用下标语法获取数组元素的值。例如：
# 定义一个索引数组
my_array=("apple" "banana" "orange")
# 访问数组中的元素
echo ${my_array[0]} # 输出 "apple"
echo ${my_array[1]} # 输出 "banana"
echo ${my_array[2]} # 输出 "orange"- 关联数组：
关联数组是一种根据键名（字符串）访问元素的数组类型。定义关联数组时需要使用声明
-A。可以使用键名访问数组元素的值。例如：
# 定义一个关联数组
declare -A my_array
my_array["红"]="苹果"
my_array["黄"]="雪梨"
my_array["橙"]="橘子"
# 访问数组中的元素
echo ${my_array["红"]} # 输出 "苹果"
echo ${my_array["黄"]} # 输出 "雪梨"
echo ${my_array["橙"]} # 输出 "橘子"需要注意的是，Bash的版本需要在 4.0 及以上才支持关联数组。
字符串处理
Bash中有很多内置的字符串处理工具和技巧，可以对字符串进行各种操作。以下是一些 Bash 中常用的字符串处理函数和示例：
${#string}可以获得字符串的长度：
my_string="hello, world"
echo ${#my_string} # 输出 12${string:start:length}可以截取子字符串，其中start是子字符串开始的位置，length是子字符串的长度：
my_string="hello, world"
echo ${my_string:0:5} # 输出 "hello"
echo ${my_string:7:5} # 输出 "world"${string#substring}可以从字符串的开头删除指定的子字符串，其中substring是要删除的子字符串：
my_string="hello, world"
echo ${my_string#hello, } # 输出 "world"${string%substring}可以从字符串的末尾删除指定的子字符串，其中substring是要删除的子字符串：
my_string="hello, world"
echo ${my_string%world} # 输出 "hello, "${string/find/replace}可以将字符串中的所有指定子字符串find替换为replace：
my_string="hello, world"
echo ${my_string/world/there} # 输出 "hello, there"${string//find/replace}可以将字符串中的所有指定子字符串find替换为replace，并且不止替换一次：
my_string="hello, world"
echo ${my_string//l/L} # 输出 "heLLo, worLd"高级变量
在 Bash 中，更加高级的变量设置方式可以让我们更加灵活地控制变量的使用。下面我将介绍一些常见的高级变量赋值方式：
${parameter:=word}：当变量parameter不存在时，将其赋值为word。
echo "MY_VAR is ${MY_VAR:=default}"
# 输出 MY_VAR is default
echo "MY_VAR is ${MY_VAR}"
# 输出 MY_VAR is default${parameter:+word}：当变量parameter存在时，将其赋值为word。
MY_VAR="value"
echo "MY_VAR is ${MY_VAR:+default}"
# 输出 MY_VAR is default
echo "MY_VAR is ${MY_VAR}"
# 输出 MY_VAR is value${parameter:?error message}：如果变量parameter不存在或者为空，则显示错误信息error message并退出脚本的执行。
echo "MY_VAR is ${MY_VAR:?Variable not set}"
# 在 MY_VAR 为空或未定义时，输出 Variable not set 并退出Bash 中的变量间接引用是一种非常有用的技巧，它允许我们使用一个变量的值作为另一个变量的名称来引用它。这个技巧可以用在很多场景中，比如说根据运行时参数来动态引用变量。
在 Bash 中，变量间接引用可以通过 ${!varname} 的语法来实现。其中 varname 为一个变量名，通过 $ 和 {} 来包围表示这是一个变量名的表达式。${!varname} 表示按照 varname 变量中存储的名称引用另一个变量。
下面是一个例子：
#!/bin/bash
var1="Hello"
var2="World"
varname="var1"
echo "${!varname}, ${var2}!" # 输出 "Hello, World!"在这个例子中，我们首先定义了两个变量 var1 和 var2，然后将 varname 设为 var1，表示我们希望引用 var1 这个变量。在输出中，我们使用 ${!varname} 引用了 var1 这个变量，从而得到了输出 Hello, World!。
需要注意的是，即使 varname 存储的变量名称是不存在的，${!varname} 表达式依然会被展开，并且其结果为空字符串。因此，在使用变量间接引用时应该特别小心，避免因为引用了不存在的变量而产生不可预测的结果。
3.求10个随机数的最大值与最小值
#!/bin/bash
declare -i min max
declare -a nums
for ((i=0;i<10;i++));do
nums[$i]=$RANDOM
[ $i -eq 0 ] && min=${nums[0]} && max=${nums[0]} && continue
[ ${nums[$i]} -gt $max ] && max=${nums[$i]} && continue
[ ${nums[$i]} -lt $min ] && min=${nums[$i]}
done
echo "All numbers are ${nums[*]}"
echo Max is $max
echo Min is $min4.使用递归调用，完成阶乘算法实现
#!/bin/bash
function factorial {
if [ $1 -eq 0 -o $1 -eq 1 ]; then
echo 1
else
echo $[$1*(factorial $[$1-1])]
}
factorial $15.解析进程和线程的区别？
进程和线程都是计算机中实现并发的方式，但它们有不同的特点和作用。
进程是操作系统分配资源的基本单位，每个进程都拥有独立的内存空间、代码和数据，进程之间不能直接共享数据。每个进程都有自己的地址空间、堆栈、文件描述符等信息，并且进程之间通过进程间通信（IPC）的方式来进行数据传输。进程的创建、切换和销毁会消耗一定的系统资源，因此进程通常是比较重量级的。
线程是进程中执行任务的最小单位，是进程内部的一个执行路径。线程与进程共享同一份数据和代码段，每个线程都有自己的堆栈和程序计数器，但是所有线程共享进程的虚拟地址空间和物理资源，线程之间可以直接访问同一片内存区域，因此线程之间的通信和数据交换比进程之间更加轻便快捷。线程的创建、切换和销毁所需的系统资源比进程要少得多，因此线程通常是比较轻量级的。
总的来说，进程和线程都是实现并发的方式，但是它们的作用和特点不同。进程是基本的资源分配单位，而线程则是程序执行的最小单位，线程可以更高效地实现并发操作和多任务处理。
6.解析进程的结构
进程是计算机中最基本的资源分配单位，它由操作系统负责创建、管理和调度，进程可以看做是一个程序的执行实例。
进程的结构主要包括以下几个部分：
- 程序段（Code Segment）：也称为文本段，是存放程序指令的内存区域，通常是只读的。程序段是进程运行期间不变的部分，它包含了所有可执行指令，程序段在进程创建时就已经确定好了。
- 数据段（Data Segment）：数据段存储的是程序中已经初始化的全局变量、静态变量和常量等数据，数据段通常是可读写的。
- 堆栈段（Stack Segment）：堆栈段存储着程序执行过程中产生的临时数据和函数调用的返回地址等信息，堆栈段是一个后进先出的数据结构，它的大小可以动态扩展，通常是可读写的。
- 堆区（Heap）：堆区是程序执行期间动态申请和释放内存所使用的区域，堆区是可读写的，其大小可以动态调整。
- 进程控制块（Process Control Block，PCB）：进程控制块是系统管理进程的数据结构，它包括了进程的基本信息，如进程状态、进程标识符、进程优先级、程序计数器、寄存器等，同时还记录了进程的资源使用情况，如打开的文件、分配的内存等。
以上是进程的主要组成部分，不同操作系统或编程语言中可能会有所差异，但是它们的基本结构都包含了上述的内容。
7.解析磁盘中的代码如何在计算机上运行的？
磁盘中的代码需要被加载到内存中才能在计算机上运行。以下是代码从磁盘中加载到内存并运行的主要步骤：
- 磁盘的文件系统会根据程序文件的路径找到该文件，并将其读入内存。读取的过程通常会将磁盘上的代码按照固定大小的块（或扇区）读入内存，直到文件被完全读入。
- 操作系统负责管理内存，在代码被读入内存后，操作系统会创建一个新进程来运行这段代码。进程的空间被划分成多个段，其中包括代码段、数据段和堆栈段等。代码段用于存储可执行指令，数据段用于存储全局变量和静态变量等数据，堆栈段用于存储局部变量和函数调用的返回地址等信息。
- 操作系统通过程序计数器（Program Counter）记录代码段中当前正在执行的指令地址，指令地址从代码段中获取。
- 当操作系统把控制权交给进程时，CPU会从代码段中读取指令，并按照指令逐条执行。执行完一条指令后，操作系统会更新程序计数器，指向下一条指令的地址，使得CPU能够继续执行下一条指令。
- 在运行期间，程序可能会调用系统函数或者发生中断等事件，这些事件会导致CPU跳转到操作系统内核态执行相应的处理。当操作系统处理完相应的事件后，它会把控制权交还给用户态运行的程序，程序继续执行从而完成相应的任务。
- 当程序运行结束时，操作系统释放该进程所使用的内存，并回收资源。
总之，磁盘中的代码需要被加载到内存中，并创建一个新的进程来运行，通过程序计数器实现指令的逐条执行，同时与操作系统进行交互，最终完成相应的任务并释放内存。
8.总结OOM原理，及处理方法
OOM（Out-Of-Memory）是指操作系统中的内存耗尽问题。当系统无法满足当前进程所需的内存时，就会发生OOM事件。在Linux中，OOM事件通常会导致进程被终止。对于系统管理员来说，必须了解OOM事件的原理，并采取措施来避免或处理OOM事件。
Linux中的OOM事件是由两个因素引起的：内存过度使用和内存压力。内存过度使用是指某个进程占用了过多的内存，导致系统中可用内存不足；而内存压力是指系统整体内存不足，甚至可能导致系统崩溃。
为了避免OOM事件的发生，可以采取以下几种方法：
- 增加系统内存：这是最简单的方法，可以增加系统的内存容量以避免OOM事件的发生。
- 使用内存限制：可以使用系统资源管理器或操作系统内置的工具来限制进程的内存使用，从而确保系统的内存不会被耗尽。
- 调整虚拟内存交换设置：在Linux中，可以使用虚拟内存交换机制来管理内存。通过调整虚拟内存的设置，可以避免OOM事件的发生。例如，可以将虚拟内存交换设置到硬盘上，以扩展系统内存。
- 使用内存压缩：内存压缩是一种技术，可以将内存内容压缩并存储在物理内存中，从而节省物理内存的使用量。在Linux中，可以使用内存压缩技术来避免OOM事件的发生。
当OOM事件不可避免时，可以采取以下几种处理方法：
- 调整进程优先级：可以通过调整进程的优先级，使其减少对系统资源的占用，从而避免OOM事件的发生。
- 杀死进程：对于OOM事件，可以手动杀死占用内存过多的进程，以释放系统资源。
- 重启系统：如果OOM事件导致系统无法继续正常运行，可以考虑重新启动系统。
9.结合进程管理命令，说明进程各种状态
在进程管理中，常见的进程状态有以下几种：
- 运行态（Running）：指该进程正在CPU上运行。
- 就绪态（Ready）：指该进程已经准备好，只等待CPU分配时间片后就能运行。
- 阻塞态（Blocked）：指该进程由于等待某些事件（例如输入/输出、信号等）而无法被执行。
- 创建态（New）：表示该进程已被创建，但还没有被操作系统调度运行。
- 终止态（Terminated）：表示该进程已经运行完毕或者被强制终止。
在Linux系统中，可以使用ps命令查看进程状态。其中，运行态的进程会被标记为“R”，就绪态的进程则会被标记为“S”，阻塞态的进程会被标记为“D”，终止态的进程会被标记为“Z”，而创建态的进程则不会在进程列表中出现。
在ps aux命令的输出中，STAT表示进程状态。在Linux系统中，进程可以有不同的状态，常见的状态包括：
- R：进程正在运行；
- S：进程处于休眠状态，例如等待某个事件的发生，或者正在进行I/O操作；
- D：进程不可中断的休眠状态，例如等待排队在块设备上的输入/输出；
- Z：进程被终止，但是它的父进程还没有来得及回收它的资源；
- T：进程被暂停或者停止。
通常情况下，我们关注的进程状态是R和S，因为它们代表的进程正在运行或者等待CPU以及其他资源。而D和Z状态通常表示该进程出现了异常情况，需要进一步的检查和处理。
10.说明IPC通信和RPC通信实现的方式
IPC通信（Inter-Process Communication，进程间通信）和RPC通信（Remote Procedure Call，远程过程调用）都是用于不同进程之间进行通信的方式。
IPC通信实现的方式较为多样化，其中最常见的方式包括：
1.管道（Pipe）：管道是一种半双工的通信方式，通常用于父子进程之间的通信。管道只支持单向数据传输，它的基本思想是用一个缓冲区作为共享区域来实现父子进程之间的数据交换。
2.消息队列（Message Queue）：消息队列是一种消息传递机制，通常用于同一主机内的进程间通信。消息队列提供了一种异步的通信方式，发送方发送消息后即可立即返回，而接收方则可以在需要时从消息队列中取出消息。
3.信号量（Semaphore）：信号量是一种用于进程间同步的机制。信号量的作用是保护一段代码，在同一时刻只允许一个进程执行。当一个进程想要执行这段被信号量保护起来的代码时，需要先获取信号量，执行完代码后再释放信号量，以便其他进程能够获取信号量并继续执行。
4.共享内存（Shared Memory）：共享内存是一种高效的进程间通信方式。它将一段内存映射到多个进程的地址空间中，多个进程可以直接访问这段共享内存，从而实现数据共享。
RPC通信则通过网络实现跨主机进程之间的通信，其实现方式通常包括：
1.客户端-服务器（Client-Server）模式：在此模式下，客户端应用程序向服务器应用程序发送请求，并等待响应。服务器应用程序接收请求，执行相应的操作，并将结果返回给客户端。
2.远程对象调用（Remote Object Invocation）：在此模式下，客户端使用远程对象代理来调用远程对象。远程对象代理掌握着远程对象的网络地址信息，并将请求序列化为网络字节流进行传输，然后等待远程对象返回结果。
3.Web服务（Web Service）：Web服务是一种基于HTTP协议实现的RPC机制。客户端通过HTTP请求访问Web服务，Web服务接收请求并调用相应的处理函数，最终将处理结果封装为XML或JSON格式返回给客户端。
11.通过mkfifo, cat, 来解释秒杀的并发问题，如何通过队列解决的？最好结合图形。说明消息队列的作用？
假设在秒杀场景中，有很多用户在同时抢购同一个商品，如果不采用并发控制的方式进行处理，就会出现超卖的情况，即销售数量大于库存数量。
下面结合mkfifo和cat来说明并发控制的问题。
首先，mkfifo命令可以创建一个命名管道（也称为FIFO），FIFO是一种特殊类型的文件，它可以被用作进程间通信的方法之一。而cat命令可以将一个文件内容输出到标准输出中。
接下来，假设在抢购页面中，用户点击“秒杀”按钮后，会向服务器发送请求，服务器会根据库存数量判断能否进行秒杀，当库存数量为0时，则返回秒杀失败的响应。
如果多个用户同时点击“秒杀”按钮，那么它们的请求都会同时发送到服务器，此时就会出现并发的问题。假设有10个用户同时请求，但是库存只有5件商品，如果不进行并发控制，就会出现超卖的情况。
下面我们来看如何通过队列解决这个问题。假设我们使用消息队列作为并发控制的方式。每次请求到达服务器时，服务器会将请求放入消息队列中，然后再从队列中取出请求进行处理。由于消息队列是先进先出的顺序，因此可以保证每个请求按顺序进行处理。
下图是使用消息队列进行并发控制的示意图。
从上图可以看出，当有多个请求同时到达服务器时，服务器会将请求放入消息队列中，然后再从队列中依次取出请求进行处理。这样就可以避免多个请求同时对共享资源进行访问，从而保证系统的安全性和可靠性。
综上所述，消息队列的作用主要是在并发环境下实现进程之间的通信和同步。它可以解决多个进程同时访问共享资源的问题，保证系统的安全性和可靠性。
12.总结Linux，前台和后台作业的区别，并说明如何在前台和后台中进行状态转换
Linux中，前台作业和后台作业的区别在于是否占用当前命令行终端。
前台作业是指当前正在命令行终端中运行的程序，它会占用终端，此时用户需要等待该程序执行完毕才能输入下一个命令。而后台作业是指在后台运行的程序，即该程序不占用当前终端，用户可以继续输入其它命令。
在前台和后台之间进行状态转换有以下两种方法：
- 在前台作业中执行后台作业：
在前台运行的作业可以通过在命令后面添加 "&" 实现将其转为后台作业。例如：
$ ./my-program &- 在后台作业中切换到前台：
使用命令 fg 可以将后台作业切换至前台，让程序重新占用当前终端。例如：
$ fg [job ID]其中， [job ID] 是后台作业的进程号或任务号。
使用命令 bg 可以将前台作业转为后台作业。例如：
$ bg [job ID]同样， [job ID] 是前台作业的进程号或任务号。
13.总结内核设计流派及特点
内核设计是操作系统的核心组成部分，其设计流派主要有单内核、微内核和混合内核。
- 单内核 单内核是最初的内核设计模式。在单内核中，所有的操作系统服务和驱动程序都运行在核心空间内，这些服务和驱动程序直接访问硬件设备，并且实现了内存管理、进程调度、文件系统等核心功能。这种设计模式的优点是效率高，因为所有服务和驱动程序都在同一个地址空间内工作。缺点是安全性不高，因为一个错误的服务或驱动程序可能会破坏整个系统。
- 微内核 微内核是将内核功能分解成多个独立的程序运行的设计模式，每个程序都运行在独立的地址空间内，只提供最基本的服务。例如，任务调度、内存管理、IPC（进程间通信）和设备驱动程序等服务都是以相互独立的方式运行的。这种设计模式的优点是可靠性和安全性高，因为每个服务都以独立的方式运行，并且错误的服务或驱动程序的影响只限于自己的进程。缺点是性能低，因为由于每个服务都是独立的程序运行，因此在服务之间传递数据需要额外的开销。
- 混合内核 混合内核是单内核和微内核的结合。它将一些核心函数移动到独立的地址空间中，以提高系统的可靠性和安全性，并以较低的开销提供IPC和设备驱动程序等服务。这种设计模式的优点是可靠性和安全性高，同时性能也比微内核设计模式高。缺点是代码复杂性高，因为不同的服务和驱动程序有不同的运行方式和限制，所以必须确保它们之间的协作和一致性。
14.总结centos 6启动流程，grub工作流程
CentOS 6启动流程大致如下：
1.计算机通电后，BIOS会自动运行并执行POST（Power-On Self Test）。
2.BIOS会寻找可启动设备，通常会先寻找硬盘、光驱和USB设备。
3.当BIOS找到可启动设备后，它会将引导扇区（boot sector）加载到内存中，并将控制权交给引导扇区程序。
4.引导扇区程序会加载GRUB（Grand Unified Bootloader）引导程序。GRUB是CentOS 6默认的引导程序。
5.GRUB会显示启动菜单，让用户选择要启动的操作系统或内核。
6.用户选择了操作系统或内核后，GRUB会加载内核文件和启动选项，并将控制权交给内核。
7.内核会初始化硬件、加载驱动程序、挂载文件系统等操作。
8.内核完成初始化后，会运行/sbin/init程序，此时系统进入用户空间。
9./sbin/init程序会根据配置文件/etc/inittab启动各种服务，并设置系统运行级别。
10.至此，CentOS 6系统启动完成。而GRUB的工作流程大致如下：
1.GRUB被加载到内存中后，显示启动菜单。
2.用户选择要启动的操作系统或内核后，GRUB会加载内核文件和启动选项。
3.GRUB会从文件系统中读取内核文件和相关的初始化文件，例如/etc/grub.conf。
4.GRUB会将内核和相关文件加载到内存中，并设置启动参数。
5.最后，GRUB会将控制权交给内核，让内核开始启动操作系统。15.手写chkconfig服务脚本，可以实现服务的开始，停止，重启
#!/bin/bash
# chkconfig: - 96 3
# description: This is test service script
. /etc/init.d/functions
start(){
[ -e /var/lock/subsys/testsrv ] && exit || touch /var/lock/subsys/testsrv
echo $PATH
action "Starting testsrv"
sleep 3
}
stop(){
[ -e /var/lock/subsys/testsrv ] && rm /var/lock/subsys/testsrv || exit
action "Stopping testsrv"
}
status(){
[ -e /var/lock/subsys/testsrv ] && echo "testsrv is running..." || echo "testsrv is stopped"
}
case $1 in
start)
start
;;
stop)
stop
;;
restart)
stop
start
;;
status)
status
;;
*)
echo $"Usage: $0 {start|stop|status|restart}"
exit 2
esac16.总结systemd服务配置文件
systemd是一个Linux系统的初始化系统和服务管理器。在systemd中，每个服务都有一个对应的配置文件，其中定义了服务的各种属性和行为。通常情况下，这些配置文件存储在/etc/systemd/system目录下。
以下是一个简单的systemd服务配置文件的示例：
[Unit]
Description=My Service
After=network.target
[Service]
ExecStart=/usr/local/bin/my-service
Restart=always
[Install]
WantedBy=multi-user.target该文件分为三个部分：
[Unit]：包含服务的基本信息和依赖关系。
Description：服务的描述信息。After：指定服务所需的其他服务或者单元，在这个例子中，服务需要在网络服务之后启动。
[Service]：包含服务执行时的相关信息。
ExecStart：指定服务的启动命令。Restart：指定服务异常退出后的重启策略，这里设置为always表示总是重启。
[Install]：包含安装服务时的相关信息。
WantedBy：指定服务在哪些运行级别下启动，这里设置为multi-user.target表示在多用户模式下启动。
一个标准的systemd服务配置文件通常由三个主要部分组成：[Unit]、[Service]和[Install]。下面我们将详细介绍这些部分以及它们的属性。
[Unit]
该部分包含了服务的基本信息和依赖关系。下面是一些常用的属性：
Description：服务的描述信息。After：指定服务所需的其他服务或者单元启动完成之后才能启动。Requires：指定服务所需的其他服务或者单元(必须同时启动)。Wants：指定服务所需的其他服务或者单元(推荐同时启动)。Before：指定服务启动之前需要启动的服务或者单元。Conflicts：指定服务与其他服务或单元存在冲突。
[Service]
该部分包含了服务执行时的相关信息。下面是常用的属性：
Type：指定服务的类型，可以是simple(默认，直到服务退出才会返回控制权)、forking(在服务启动时派生一个子进程)、oneshot(服务只会运行一次)等。ExecStart：指定服务的启动命令。ExecStop：指定服务的停止命令。Restart：指定服务异常退出后的重启策略，可以是no(不重启)、always(总是重启)、on-failure(仅在非0退出状态时重启)等。User：指定服务所属的用户。Group：指定服务所属的组。Environment：指定服务执行时需要的环境变量。WorkingDirectory：指定服务执行时的工作目录。
[Install]
该部分包含了安装服务时的相关信息。下面是常用的属性：
WantedBy：指定服务在哪些运行级别下启动，可以是multi-user.target(多用户模式)、graphical.target(图形化模式)等。RequiredBy：指定需要该服务的其他服务或单元(必须同时启动)。Also：指定需要该服务的其他服务或单元(推荐同时启动)。
以上是systemd服务配置文件的主要部分和属性介绍，这些属性根据服务需求而异。使用systemd配置文件来管理服务非常方便，可以有效地提高系统管理的效率和可靠性。
17.总结systemd启动流程
systemd 是一个具有启动管理、服务管理、日志管理和设备管理等功能的系统和服务管理器，其启动流程主要包括以下几个步骤：
- 系统引导：当计算机启动时，BIOS/UEFI会加载GRUB2或者其他引导程序，并从硬盘、光盘或者网络中读取内核映像文件。
- 内核初始化：内核映像文件被加载后，内核会对硬件进行初始化操作，并创建第一个用户空间进程systemd（PID 1）。
- systemd初始化：systemd会读取所有的unit文件，并按照启动顺序将它们加入到启动队列中，这些unit文件包括target文件、service文件、socket文件等。
- 启动目标：每个target文件都是一套预定义的unit，在systemd启动时，会根据指定的default target决定启动哪一个target文件（比如multi-user.target，表示只启动多用户模式，并不启动图形界面）。
- 加载依赖项：在启动target前，systemd会根据unit文件中的Requires和Wants字段，来查找并自动加载必要的依赖文件和服务。
- 启动服务：在所有依赖关系满足后，systemd会按照启动顺序执行服务文件，并在执行过程中记录各种系统日志。
- 启动完成：一旦所有服务都启动完毕，systemd会进入idle状态，并等待下一次事件发生。
总之，systemd启动流程非常复杂和庞大，但由于其高度集成和可扩展性，已成为众多Linux发行版的标配启动管理器。
18.总结awk工作原理，awk命令，选项，示例。总结awk的数组，函数。
awk是一种文本处理工具，它按行读取输入文件并将每行分解为字段。可以使用任意分隔符来指定字段之间的分隔符，默认情况下使用空格和制表符。在每个字段中，awk执行指定的动作，并且可以根据需要打印输出结果。
awk的基本工作原理如下：
- 将输入文件读入内存，一行一行地处理。
- 按照指定的字段分隔符将每行拆分为多个字段。
- 对于每个字段，执行指定的操作，这些操作包括条件判断、变量设置、数学计算、字符串操作等。
- 根据需要输出结果。
对于每个输入行，awk会执行指定的操作，这些操作可以是内置函数、用户自定义函数、条件语句、循环语句等。awk还支持多种模式和模式匹配方式，以便更容易地处理文本数据。常见的应用包括文本处理、报告生成、数据转换和格式化等。
awk命令的一般语法格式为：
awk 'pattern {action}' input_file其中，pattern用于指定需要匹配的模式，action用于指定匹配成功后需要执行的操作，input_file表示要处理的输入文件。如果没有指定输入文件，则awk默认从标准输入读取数据。
以下是一些常见的awk命令使用示例：
- 输出指定列：打印第1列和第3列
awk '{print $1, $3}' input_file- 根据条件过滤数据：打印第2列等于"hello"的行
awk '$2 == "hello" {print}' input_file- 基于统计信息生成报告：输出文件的行数、单词数和字符数
awk 'BEGIN {lines=words=chars=0} {lines++; words+=NF; chars+=length} END {print lines, words, chars}' input_file- 对数据进行计算：求第2列的平均值
awk '{sum+=$2} END {print sum/NR}' input_fileawk命令有许多选项可用于指定模式匹配和规则动作的行为。以下是一些常见的awk选项：
-F：指定字段分隔符，默认为制表符或空格。例如，-F:将冒号作为字段之间的分隔符。-v：定义变量并将其传递给awk程序。例如，awk -v var=value 'pattern {action}' input_file中的var变量可在awk程序中使用。-f：从文件中读取awk程序。例如，awk -f script.awk input_file将从script.awk文件中读取awk程序。-i inplace：启用原地编辑模式，并将结果写回到输入文件中，而不是打印到标准输出。该选项只适用于GNU awk（gawk）版本4.1及更高版本。-W：指定gawk扩展功能。例如，-W interactive可以启用交互式模式，-W compat可以使gawk与旧版awk兼容。-n：禁用默认打印操作，只执行指定的规则操作，不输出处理的数据。-N：禁用所有输入记录的拆分，默认情况下，awk将根据空格和制表符分割输入记录。
这只是一小部分常见的awk选项，还有其他许多选项和功能可供选择，具体取决于你所使用的awk版本。可以通过查看man awk命令来获取完整的选项列表和说明。
awk中的数组是一种关联数组，它可以存储多个值，并使用一个键来引用每个值。awk数组中的键通常是字符串或数字，数组中的值可以是任何类型的数据，包括字符串、数字、其他数组等。
在awk中，可以通过以下方法声明和访问数组：
- 声明数组：使用下面的语法来声明数组：
# 基于数字索引声明数组
array[index]=value
# 基于字符串索引声明数组
array["key"]=value其中，index和key都是索引值，value则是与索引相关联的值。
- 访问数组：可以使用以下语法来访问数组中的元素:
# 通过数字索引访问数组
array[index]
# 通过字符串索引访问数组
array["key"]可以像访问普通变量一样使用数组来访问它们的元素。
以下是一个简单的例子，演示了如何在awk中创建和使用数组：
# test.txt
apple,fruit,red
banana,fruit,yellow
carrot,vegetable,orange
# awk程序获取test.txt文件中所有水果的名称
awk -F, '{ if ($2 == "fruit") { fruits[$1] = $3 } } END { for (f in fruits) print f, fruits[f] }' test.txt在上面的例子中，我们创建了一个名为fruits的数组，存储了所有水果的名称和颜色。在每一行上，如果水果的类型是fruit，则将该水果的名称和颜色存储到fruits数组中。最后，使用for循环遍历fruits数组并输出所有水果的名称和颜色。
希望这个例子演示了如何使用awk数组来处理文本数据。
awk是一种强大的文本处理工具，它还提供了许多内置函数来处理文本和数值类型。此外，awk还允许用户定义自己的函数，以便更好地组织和重复使用代码。
在awk中，可以通过以下语法来定义和调用函数：
- 定义函数：定义一个函数需要使用
function关键字，并在函数名称后面跟一个括号。如果函数有参数，这些参数应该放在括号中，并用逗号分隔。
function name(parameter1, parameter2, ...) {
# 函数体，包括语句和表达式
}函数体可以包含任意数量的语句和表达式。
- 调用函数：使用函数名称和参数列表来调用函数。参数应该用逗号分隔，并放在括号中。
name(argument1, argument2, ...)以下是一个简单的例子，演示如何在awk中定义和调用函数：
# awk程序计算两个数字之和
function add(x, y) {
return x + y
}
# 在main out中调用add函数
BEGIN {
a = 2
b = 3
print "The sum of", a, "and", b, "is", add(a, b)
}在上面的例子中，我们定义了一个名为add的函数，它接受两个参数并返回它们的和。然后，在BEGIN块中，我们声明了两个变量a和b，并在print语句中调用了add函数，以显示它们的和。
除此之外，awk还提供了许多内置函数，例如字符串函数、数学函数、时间函数等。可以在awk的官方文档中查找完整列表，并在需要时使用它们来处理数据。
19.总结CA管理相关的工具，根据使用场景总结示例
要建立私有证书颁发机构（CA），可以参考以下步骤：
- 选择适合的CA软件：可以根据自己的需求选择开源的或商业的CA软件，如OpenSSL、EJBCA、Microsoft Certificate Services等。这些软件提供了创建和管理证书的工具和面板，能够方便地处理数字证书。
- 创建根证书：在选择好CA软件后，需要创建一个根证书。根证书是CA的顶级证书，对其进行签名的证书只有两种方式，即信任或被撤销。创建根证书时需要输入一些组织信息，如组织名称、国家、州/省、城市以及联系信息等。
- 创建中间证书（可选）：如果需要更复杂的证书结构，可以在根证书下创建其他中间CA。中间CA是通过根CA签名的证书，用于颁发子证书。中间CA的目的是为了隔离根证书，防止根证书被泄露后全部证书都失效。
- 颁发子证书：在创建完根证书和中间证书（可选）之后，可以开始颁发子证书。颁发子证书时需要指定证书的一些信息，如证书名称、公钥、有效期限等。子证书颁发之前必须使用父证书进行签名，以便证书链的完整性验证。
- 处理证书吊销：如果某个证书不再被信任或者存在安全风险，需要对其进行吊销操作。在吊销证书后，该证书将不再被认为是有效的，并且无法用来进行加密或数字签名。吊销证书可以通过CA软件中提供的工具来完成。
- 公开证书：最后，需要将颁发的证书公开发布到可信赖的目录中，这样其他人才能获得并验证证书的合法性。
需要注意的是，在建立私有CA时，需要非常小心和谨慎地保护私钥，确保它们不被泄露。泄露私钥可能会导致他人伪造证书，进而进行恶意attack。
OpenSSL的openssl.cnf配置文件比较复杂，包括多个节（section）以及各种选项参数，下面是一些比较常见的选项参数：
- RANDFILE：用于指定随机数文件的路径，这个文件存储了OpenSSL需要生成加密算法中所需的随机数，例如需要创建自签名证书时。
- HOME：用于指定OpenSSL默认的主目录，默认值为/etc/pki/tls。
- certificate：用于设置证书文件的名称，默认值为$dir/cert.pem。
- private_key：用于设置私钥文件的名称，默认值为$dir/private/key.pem。
- default_md：用于设置默认使用的消息摘要算法，默认值为sha256。
- req_extensions：用于设置证书请求时添加的扩展信息。
- x509_extensions：用于设置证书时添加的扩展信息。
此外，根据你的应用场景，还可以设置其它许多参数，比如：
- [ca] 配置 CA 证书和 CA 目录信息
- [req] 配置证书的请求信息
- [req_distinguished_name] 配置证书请求的 DN
- [usr_cert] 配置用户证书信息
- [v3_ca] 配置 CA 证书的 V3 扩展
- [v3_req] 配置证书请求的 V3 扩展
需要注意的是，在修改openssl.cnf文件时需要小心操作，确保其符合安全标准，并进行相应的测试和验证，以保证系统的安全性和稳定性。
创建CA所需要的文件
#生成证书索引数据库文件
touch /etc/pki/CA/index.txt
#指定第一个颁发证书的序列号
echo 01 > /etc/pki/CA/serial生成CA私钥
cd /etc/pki/CA/
(umask 066; openssl genrsa -out private/cakey.pem 2048)生成CA自签名证书
openssl req -new -x509 -key /etc/pki/CA/private/cakey.pem -day 3650 -out /etc/pki/CA/cacert.pem
-new:生成新证书签署请求
-x509:专用于CA生成自签证书
-key:生成请求用到的私钥文件
-days n:证书的有效期限
-out /PATH/TO/SOMECERTFILE:证书的保存路径用户生成私钥和证书申请
#生成私钥文件
(umask 066;openssl genrsa -out /data/app1/app1.key 2048)
#生成证书申请文件
openssl req -new -key /data/app1/app1.key -out /data/app1/app1.csrCA 颁发证书
openssl ca -in /data/app1/app1.csr -out /etc/pki/CA/certs/app1.crt -days 100020.总结openssh免密认证原理，及免认证实现过程
OpenSSH 免密认证是通过使用公钥、私钥实现的。在 OpenSSH 中，客户端和服务器端都会有一对密钥：私钥和公钥。
- 首先在客户端生成一对密钥（ssh-keygen）
- 并将客户端的公钥ssh-copy-id复制到服务端
- 当客户端再次发送一个连接请求，包括ip、用户名
- 服务端得到客户端的请求后，会到authorized_keys中查找，如果有响应的IP和用户，就会随机生成一个字符穿，例如：13579
- 服务端将使用客户端复制过来的公钥进行加密，然后发送给客户端
- 得到服务端发来的消息后，客户端会使用私钥进行解密，然后解密后的字符串发送给服务端
- 服务端接受到客户端发来的字符串后，跟之前的字符串进行对比，如果一致，就允许免密码登录