• Linux合集之Linux实用运维脚本分享及Linux CPU的上下文切换

    Linux实用运维脚本分享

    1. #查看僵尸进程
    2. ps -al | gawk '{print $2,$4}' | grep Z
    3.  
    4. # 匹配电子邮件的地址
    5. cat index.html | egrep -o "[A-Za-z0-9._]+@[A-Za-z0-9.]+\.[a-zA-Z]{2,4}" > ans.txt
    6.  
    7. #匹配http URL
    8. cat index.html | egrep -o "http://[A-Za-z0-9.]+\.[a-zA-Z]{2,3}" > ans.txt 
    9.  
    10. #纯文本形式下载网页
    11. lynx -dump www.rumenz.com > plain.txt
    12.  
    13. #只打印HTTP头部信息，无须远程下载文件
    14. curl --head www.rumenz.com
    15.  
    16. #使用POST提交数据
    17. curl -d "param2=nickwolfe¶m2=12345" http://www.rumenz.com/login.cgi
    18.  
    19. #显示分组途经的网关
    20. traceroute www.rumenz.com
    21.  
    22. #列出系统中的开放端口以及运行在端口上的服务
    23. lsof -i 
    24.  
    25. #nc命令建立socket连接
    26.  
    27. #设置监听 nc -l 5555
    28. #连接到套接字 nc 192.0.0.1 5555
    29.  
    30. #快速文件传输
    31. #接收端 nc -l 5555 > destination_filename
    32. #发送端 nc 192.0.0.1 5555 < source_filename
    33.  
    34. #找出指定目录最大的n个文件
    35. du -ak target_dir | sort -nrk 1 | head -n 4
    36. # du中a为递归,k为kb；sort中n为数字,r为降序,k指定列
    37.  
    38. #向终端中的所有登陆用户发送广播信息
    39. cat message.txt | wall
    40.  
    41. #创建新的screen窗口
    42. screen
    43.  
    44. #打印所有的.txt和.pdf文件
    45. find . \( -name "*.txt" -o -name "*.pdf" \) -print
    46.  
    47. # -exec command {} \;是连用的，所有符合的都会放置在{}中，去执行command 
    48.  
    49. #将文件分割成多个大小为10kb的文件
    50. split -b 10k data.file 
    51.  
    52. #打印两个文件的交集
    53. comm A.txt B.txt -3 | sed 's/^\t//'
    54.  
    55. #sed移除空白行
    56. sed '/^$/d' file
    57.

    mysql备份

    1. #!/bin/bash
    2.  
    3. set -e
    4.  
    5. USER="backup"
    6. PASSWORD="backup"
    7. # 数据库数据目录 #
    8. DATA_DIR="/data/mysql"
    9. BIN_INDEX=$DATA_DIR"/mysql-bin.index"
    10. # 备份目录 #
    11. BACKUP_DIR="/data/backup/mysql"
    12. BACKUP_LOG="/var/log/mysql/backup.log"
    13.  
    14. DATE=`date +"%Y%m%d"`
    15. TIME=`date +"%Y%m%d%H"`
    16.  
    17. LOG_TIME=`date +"%Y-%m-%d %H:%M:%S"`
    18. DELETE_BINLOG_TIME="7 day"
    19. INCREMENT_INTERVAL="3 hour"
    20.  
    21. note() {
    22.     printf "[$LOG_TIME] note: $*\n" >> $BACKUP_LOG;
    23. }
    24.  
    25. warning() {
    26.     printf "[$LOG_TIME] warning: $*\n" >> $BACKUP_LOG;
    27. }
    28.  
    29. error() {
    30.     printf "[$LOG_TIME] error: $*\n" >> $BACKUP_LOG;
    31.     exit 1;
    32. }
    33.  
    34. full_backup() {
    35.     local dbs=`ls -l $DATA_DIR | grep "^d" | awk -F " " '{print $9}'`
    36.  
    37.     for db in $dbs
    38.     do
    39.         local backup_dir=$BACKUP_DIR"/full/"$db
    40.         local filename=$db"."$DATE
    41.         local backup_file=$backup_dir"/"$filename".sql"
    42.  
    43.         if [ ! -d $backup_dir ]
    44.         then
    45.             mkdir -p $backup_dir || { error "创建数据库 $db 全量备份目录 $backup_dir 失败"; continue; }
    46.             note "数据库 $db 全量备份目录 $backup_dir  不存在，创建完成";
    47.         fi
    48.  
    49.         note "full backup $db start ..."
    50.         mysqldump --user=${USER} --password=${PASSWORD} --flush-logs --skip-lock-tables --quick $db > $backup_file || { warning "数据库 $db 备份失败"; continue; }
    51.  
    52.         cd $backup_dir
    53.         tar -cPzf $filename".tar.gz" $filename".sql"
    54.         rm -f $backup_file
    55.         chown -fR mysql:mysql $backup_dir
    56.  
    57.         note "数据库 $db 备份成功";
    58.         note "full backup $db end."
    59.     done
    60. }
    61.  
    62. increment_backup() {
    63.     local StartTime=`date "-d $INCREMENT_INTERVAL ago" +"%Y-%m-%d %H:%M:%S"`
    64.     local DELETE_BINLOG_END_TIME=`date "-d $DELETE_BINLOG_TIME ago" +"%Y-%m-%d %H:%M:%S"`
    65.     local dbs=`ls -l $DATA_DIR | grep "^d" | awk -F " " '{print $9}'`
    66.  
    67.     mysql -u$USER -p$PASSWORD -e "purge master logs before '$DELETE_BINLOG_END_TIME'" && note "delete $DELETE_BINLOG_TIME days before log";
    68.  
    69.     filename=`cat $BIN_INDEX | awk -F "/" '{print $2}'`
    70.     for i in $filename
    71.     do
    72.         for db in $dbs
    73.         do
    74.             local backup_dir=$BACKUP_DIR"/increment/"$db
    75.             local filename=$db"."$TIME
    76.             local backup_file=$backup_dir"/"$filename".sql"
    77.  
    78.             if [ ! -d $backup_dir ]
    79.             then
    80.                 mkdir -p $backup_dir || { error "创建数据库 $db 增量备份目录 $backup_dir 失败"; continue; }
    81.                 note "数据库 $db 增量备份目录 $backup_dir  不存在，创建完成";
    82.             fi
    83.  
    84.             note "increment backup $db form time $StartTime start ..."
    85.  
    86.             mysqlbinlog -d $db --start-datetime="$StartTime" $DATA_DIR/$i >> $backup_file || { warning "数据库 $db 备份失败"; continue; }
    87.  
    88.             note "increment backup $db end."
    89.         done
    90.     done
    91.  
    92.     for db in $dbs
    93.     do
    94.         local backup_dir=$BACKUP_DIR"/increment/"$db
    95.         local filename=$db"."$TIME
    96.         local backup_file=$backup_dir"/"$filename".sql"
    97.  
    98.         cd $backup_dir
    99.         tar -cPzf $filename".tar.gz" $filename".sql"
    100.         rm -f $backup_file
    101.  
    102.         note "数据库 $db 备份成功";
    103.     done
    104. }
    105.  
    106. case "$1" in
    107.     full)
    108.         full_backup
    109.     ;;
    110.     increment)
    111.         increment_backup
    112.     ;;
    113.     *)
    114.         exit 2
    115.     ;;
    116. esac
    117.  
    118. exit 1
    119.

    目录备份

    1. #!/bin/bash
    2. #
    3. #
    4. # 时间
    5. DATE=$(date '+%Y-%m-%d_%H_%M_%S')
    6. # 备份目录 
    7. BACKUPDIR="/home/backups"
    8. # 需要备份的目录
    9. SORFILE=/opt
    10. # 目标文件名
    11. DESFILE=/home/backups/$SORFILE.$(date '+%Y-%m-%d_%H_%M_%S').zip
    12.  
    13. [ ! -d $BACKUPDIR ] && mkdir -p $BACKUPDIR
    14. cd $BACKUPDIR
    15.  
    16. echo "start backup $SORFILE ..."
    17. sleep 3
    18. #echo "$DESFILE"
    19.  
    20.  
    21. #tar cvf $DESFILE $SORFILE
    22. #gzip -f .zip $DESFILE
    23. zip -r $DESFILE $SORFILE &>/dev/null
    24. if [ "$?" == "0" ]
    25. then
    26.    echo $(date +%Y-%m-%d)" zip sucess">>backup.log
    27. else
    28.    echo $(date +%Y-%m-%d)" zip failed">>backup.log
    29.    exit 0
    30. fi
    31.  
    32. # 删除3天前的备份
    33. find $BACKUPDIR -type f -ctime +3 | xargs rm -rf
    34.

    PING查询

    1. #!/bin/bash
    2. #用途：根据网络配置对网络地址192.168.0进行修改，检查是否是活动状态
    3.  
    4. #{start..end}shell扩展生成一组地址
    5. for ip in 192.168.0.{1..255}
    6. do 
    7.     (
    8.     ping $ip -c 2 &> /dev/null 
    9.     # > 标准输出重定向，和1>一致
    10.     # 2>&1 将标准错误输出 重定向 到标准输出
    11.     # &>file 将标准输出和标准错误输出都重定向到文件filename中
    12.  
    13.     if [ $? -eq 0 ];then
    14.         echo $ip is alive
    15.     fi
    16.     )&
    17. done
    18. wait
    19. #并行ping,加速
    20.

    磁盘IO检查

    1. ##iostat是查看磁盘活动统计情况
    2.  
    3. ##显示所有设备负载情况 r/s:  每秒完成的读 I/O 设备次数。即 rio/s；w/s:  每秒完成的写 I/O 设备次数。即 wio/s等
    4. iostat 
    5.  
    6. ##每隔2秒刷新磁盘IO信息，并且每次显示3次
    7. iostat 2 3
    8.  
    9. #显示某个磁盘的IO信息
    10. iostat -d sda1
    11.  
    12. ##显示tty和cpu信息
    13. iostat -t
    14.  
    15. ##以M为单位显示磁盘IO信息
    16. iostat -m
    17.  
    18. ##查看TPS和吞吐量信息  kB_read/s：每秒从设备（drive expressed）读取的数据量；kB_wrtn/s：每秒向设备（drive expressed）写入的数据量；kB_read：读取的总数据量；kB_wrtn：写入的总数量数据量；
    19. iostat -d -k 1 1
    20.  
    21. #查看设备使用率（%util）、响应时间（await）
    22. iostat -d -x -k 1 1
    23.  
    24. #查看CPU状态
    25. iostat -c 1 3
    26.  
    27. #统计进程(pid)的stat,进程的stat自然包括进程的IO状况
    28. pidstat
    29.  
    30. #只显示IO
    31. pidstat -d  1 
    32.  
    33. #-d IO 信息,-r 缺页及内存信息-u CPU使用率-t 以线程为统计单位1  1秒统计一次
    34. pidstat -u -r -d -t 1
    35.  
    36. #文件级IO分析,查看当前文件由哪些进程打开
    37. lsof   
    38. ls /proc/pid/fd
    39.  
    40. #利用 sar 报告磁盘 I/O 信息DEV 正在监视的块设备 tps 每秒钟物理设备的 I/O 传输总量 rd_sec/s 每秒从设备读取的扇区数量 wr_sec/s 每秒向设备写入的扇区数量 avgrq-sz I/O 请求的平均扇区数
    41. #avgqu-sz I/O 请求的平均队列长度 await I/O 请求的平均等待时间，单位为毫秒 svctm I/O 请求的平均服务时间，单位为毫秒 %util I/O 请求所占用的时间的百分比，即设备利用率
    42. sar -pd 10 3 
    43.  
    44. #iotop  top的io版
    45. iotop
    46.  
    47. #查看页面缓存信息 其中的Cached 指用于pagecache的内存大小（diskcache-SwapCache）。随着写入缓存页，Dirty 的值会增加 一旦开始把缓存页写入硬盘,Writeback的值会增加直到写入结束。
    48. cat /proc/meminfo 
    49.  
    50. #查看有多少个pdflush进程 Linux 用pdflush进程把数据从缓存页写入硬盘
    51. #pdflush的行为受/proc/sys/vm中的参数的控制/proc/sys/vm/dirty_writeback_centisecs (default 500): 1/100秒, 多长时间唤醒pdflush将缓存页数据写入硬盘。默认5秒唤醒2个（更多个）线程。如果wrteback的时间长于dirty_writeback_centisecs的时间，可能会出问题
    52. cat /proc/sys/vm/nr_pdflush_threads
    53.  
    54. #查看I/O 调度器
    55. #调度算法
    56. #noop anticipatory deadline [cfq] 
    57. #deadline :    deadline 算法保证对既定的IO请求以最小的延迟时间。
    58. #anticipatory：有个IO发生后，如果又有进程请求IO，则产生一个默认6ms猜测时间，猜测下一个进程请求IO是干什么。这对于随机读取会造成较大的延时。对数据库应用很糟糕，而对于Web Server等则会表现不错。
    59. #cfq:        对每个进程维护一个IO队列，各个进程发来的IO请求会被cfq以轮循方式处理，对每一个IO请求都是公平。适合离散读的应用。
    60. #noop:        对所有IO请求都用FIFO队列形式处理。默认IO不会存在性能问题。
    61. cat /sys/block/[disk]/queue/scheduler
    62.  
    63.  
    64. #改变IO调度器
    65. $ echo deadline > /sys/block/sdX/queue/scheduler
    66. #提高调度器请求队列的
    67. $ echo 4096 > /sys/block/sdX/queue/nr_requests
    68.

    性能相关

    1. #查看当前系统load
    2. uptime
    3.  
    4. #查看系统状态和每个进程的系统资源使用状况
    5. top
    6.  
    7. #可视化显示CPU的使用状况
    8. htop
    9.  
    10. #查看每个CPU的负载信息
    11. mpstat -P ALL 1
    12.  
    13. #每隔1秒查看磁盘IO的统计信息
    14. iostat -xkdz 1
    15.  
    16. #每隔一秒查看虚拟内存的使用信息
    17. vmstat 1
    18.  
    19. #查看内存使用统计信息
    20. free
    21.  
    22. #查看网络使用信息
    23. nicstat -z 1
    24.  
    25. #类似vmstat的显示优化的工具
    26. dstat 1
    27.  
    28. #查看系统活动状态，比如系统分页统计，块设备IO统计等
    29. sar
    30.  
    31. #网络连接状态查看
    32. netstat -s
    33.  
    34. #进程资源使用信息查看
    35. pidstat 1
    36. pidstat -d 1
    37.  
    38. #查看某个进程的系统调用信息 -p后面是进程id，-tttT 进程系统后的系统调用时间
    39. strace -tttT -p 12670
    40. #统计IO设备输入输出的系统调用信息
    41. strace -c dd if=/dev/zero of=/dev/null bs=512 count=1024k
    42.  
    43.  
    44. #tcpdump 查看网络数据包
    45. tcpdump -nr /tmp/out.tcpdump
    46.  
    47. #块设备的读写事件信息统计
    48. btrace /dev/sdb 
    49.  
    50. #iotop查看某个进程的IO操作统计信息
    51. iotop -bod5
    52.  
    53. #slabtop 查看内核 slab内存分配器的使用信息
    54. slabtop -sc
    55.  
    56. #系统参数设置
    57. sysctl -a
    58.  
    59. #系统性能指标统计信息
    60. perf stat gzip file1
    61. #系统cpu活动状态查看
    62. perf record -a -g -F 997 sleep 10
    63.

    进程相关

    1. ## processes  进程管理
    2.  
    3. ##ps查看当前系统执行的线程列表，进行瞬间状态，不是连续状态，连续状态需要使用top名称查看  更多常用参数请使用 man ps查看
    4. ps
    5.  
    6. ##显示所有进程详细信息
    7. ps aux
    8.  
    9. ##-u 显示某个用户的进程列表
    10. ps -f -u www-data 
    11.  
    12. ## -C 通过名字或者命令搜索进程
    13. ps -C apache2
    14.  
    15. ## --sort  根据进程cpu使用率降序排列，查看前5个进程  -pcpu表示降序  pcpu升序
    16. ps aux --sort=-pcpu | head -5 
    17.  
    18. ##-f 用树结构显示进程的层次关系，父子进程情况下
    19. ps -f --forest -C apache2 
    20.  
    21. ##显示一个父进程的所有子进程
    22. ps -o pid,uname,comm -C apache2
    23. ps --ppid 2359 
    24.  
    25. ##显示一个进程的所有线程  -L 参数
    26. ps -p 3150 -L 
    27.  
    28. ##显示进程的执行时间 -o参数
    29. ps -e -o pid,comm,etime 
    30.  
    31. ##watch命令可以用来实时捕捉ps显示进程
    32. watch -n 1 'ps -e -o pid,uname,cmd,pmem,pcpu --sort=-pmem,-pcpu | head -15' 
    33.  
    34. ##jobs 查看后台运行的进程  jobs命令执行的结果，＋表示是一个当前的作业，减号表是是一个当前作业之后的一个作业，jobs -l选项可显示所有任务的PID,jobs的状态可以是running, stopped, Terminated,但是如果任务被终止了（kill），shell 从当前的shell环境已知的列表中删除任务的进程标识；也就是说，jobs命令显示的是当前shell环境中所起的后台正在运行或者被挂起的任务信息
    35. jobs
    36.  
    37. ##查看后台运营的进程号
    38. jobs -p
    39.  
    40. ##查看现在被终止或者退出的进程号
    41. jobs -n
    42.  
    43.  
    44. ##kill命令 终止一个前台进程可以使用Ctrl+C键   kill  通过top或者ps获取进程id号  kill [-s 信号 | -p ] [ -a ] 进程号 ...
    45. ##发送指定的信号到相应进程。不指定型号将发送SIGTERM（15）终止指定进程。关闭进程号12的进程
    46. kill 12
    47.  
    48.  
    49. ##等同于在前台运行PID为123的进程时按下Ctrl+C键
    50. kill -2 123
    51.  
    52. ##如果任无法终止该程序可用“-KILL” 参数，其发送的信号为SIGKILL(9) ，将强制结束进程  
    53. kill -9 123
    54.  
    55. ##列出所有信号名称
    56. ##HUP    1    终端断线
    57. ##INT     2    中断（同 Ctrl + C）
    58. ##QUIT    3    退出（同 Ctrl + \）
    59. ##TERM   15    终止
    60. ##KILL    9    强制终止
    61. ##CONT   18    继续（与STOP相反， fg/bg命令）
    62. ##STOP    19    暂停（同 Ctrl + Z）
    63. kill -l
    64.  
    65. ##得到指定信号的数值
    66. kill -l KILL
    67.  
    68. ##杀死指定用户所有进程
    69. kill -u peidalinux
    70. kill -9 $(ps -ef | grep peidalinux) 
    71.  
    72. ##将后台中的命令调至前台继续运行  将进程123调至前台执行
    73. fg 123
    74.  
    75. ##将一个在后台暂停的命令，变成继续执行
    76. bg  123
    77.  
    78. ##该命令可以在你退出帐户/关闭终端之后继续运行相应的进程。nohup就是不挂起的意思  下面输出被重定向到myout.file文件中
    79. nohup command > myout.file 2>&1 &
    80.  
    81. ##at：计划任务，在特定的时间执行某项工作，在特定的时间执行一次。
    82. ## 格式：at HH:MM YYYY-MM-DD //HH（小时）:MM（分钟） YYYY（年）-MM（月份）-DD（日）
    83. ##HH[am pm]+D(天) days //HH（小时）[am（上午）pm（下午）]+days（天）
    84. at 12:00（时间） //at命令设定12:00执行一项操作
    85. #at>useradd aaa //在at命令里设定添加用户aaa
    86. #ctrl+d //退出at命令
    87. #tail -f /etc/passwd //查看/etc/passwd文件后十行是否增加了一个用户aaa
    88.  
    89. ##计划任务设定后，在没有执行之前我们可以用atq命令来查看系统没有执行工作任务。
    90. atq
    91.  
    92. ##启动计划任务后，如果不想启动设定好的计划任务可以使用atrm命令删除。
    93. atrm 1 //删除计划任务1
    94.  
    95. ##pstree命令：列出当前的进程，以及它们的树状结构  格式：pstree [选项] [pid|user]
    96. pstree
    97.  
    98. ##nice命令：改变程序执行的优先权等级 应用程序优先权值的范围从-20～19，数字越小，优先权就越高。一般情况下，普通应用程序的优先权值（CPU使用权值）都是0，如果让常用程序拥有较高的优先权等级，自然启动和运行速度都会快些。需要注意的是普通用户只能在0～19之间调整应用程序的优先权值，只有超级用户有权调整更高的优先权值（从-20～19）。
    99. nice [-n <优先等级>][--help][--version][命令]
    100. nice -n 5 ls
    101.  
    102. ##sleep命令：使进程暂停执行一段时间
    103. date;sleep 1m;date
    104.  
    105.  
    106. ##renice命令 renice命令允许用户修改一个正在运行进程的优先权。利用renice命令可以在命令执行时调整其优先权。
    107. ##其中，参数number与nice命令的number意义相同。（1） 用户只能对自己所有的进程使用renice命令。（2） root用户可以在任何进程上使用renice命令。（3） 只有root用户才能提高进程的优先权
    108. renice -5 -p 5200  #PID为5200的进程nice设为-5 
    109.  
    110. ##pmap命令用于显示一个或多个进程的内存状态。其报告进程的地址空间和内存状态信息 #pmap PID 
    111. pmap 20367
    112.

    javadump.sh

    1. #!/bin/sh
    2.  
    3. DUMP_PIDS=`ps  --no-heading -C java -f --width 1000 |awk '{print $2}'`
    4. if [ -z "$DUMP_PIDS" ]; then
    5.     echo "The server $HOST_NAME is not started!"
    6.     exit 1;
    7. fi
    8.  
    9. DUMP_ROOT=~/dump
    10. if [ ! -d $DUMP_ROOT ]; then
    11.   mkdir $DUMP_ROOT
    12. fi
    13.  
    14. DUMP_DATE=`date +%Y%m%d%H%M%S`
    15. DUMP_DIR=$DUMP_ROOT/dump-$DUMP_DATE
    16. if [ ! -d $DUMP_DIR ]; then
    17.   mkdir $DUMP_DIR
    18. fi
    19.  
    20. for PID in $DUMP_PIDS ; do
    21. #Full thread dump 用来查线程占用，死锁等问题
    22.   $JAVA_HOME/bin/jstack $PID > $DUMP_DIR/jstack-$PID.dump 2>&1
    23.   echo -e ".\c"
    24. #打印出一个给定的Java进程、Java core文件或远程Debug服务器的Java配置信息，具体包括Java系统属性和JVM命令行参数。
    25.   $JAVA_HOME/bin/jinfo $PID > $DUMP_DIR/jinfo-$PID.dump 2>&1
    26.   echo -e ".\c"
    27. #jstat能够动态打印jvm(Java Virtual Machine Statistics Monitoring Tool)的相关统计信息。如young gc执行的次数、full gc执行的次数，各个内存分区的空间大小和可使用量等信息。
    28.   $JAVA_HOME/bin/jstat -gcutil $PID > $DUMP_DIR/jstat-gcutil-$PID.dump 2>&1
    29.   echo -e ".\c"
    30.   $JAVA_HOME/bin/jstat -gccapacity $PID > $DUMP_DIR/jstat-gccapacity-$PID.dump 2>&1
    31.   echo -e ".\c"
    32. #未指定选项时，jmap打印共享对象的映射。对每个目标VM加载的共享对象，其起始地址、映射大小及共享对象文件的完整路径将被打印出来，  
    33.   $JAVA_HOME/bin/jmap $PID > $DUMP_DIR/jmap-$PID.dump 2>&1
    34.   echo -e ".\c"
    35. #-heap打印堆情况的概要信息，包括堆配置，各堆空间的容量、已使用和空闲情况  
    36.   $JAVA_HOME/bin/jmap -heap $PID > $DUMP_DIR/jmap-heap-$PID.dump 2>&1
    37.   echo -e ".\c"
    38. #-dump将jvm的堆中内存信息输出到一个文件中,然后可以通过eclipse memory analyzer进行分析
    39. #注意：这个jmap使用的时候jvm是处在假死状态的，只能在服务瘫痪的时候为了解决问题来使用，否则会造成服务中断。
    40.   $JAVA_HOME/bin/jmap -dump:format=b,file=$DUMP_DIR/jmap-dump-$PID.dump $PID 2>&1
    41.   echo -e ".\c"
    42. #显示被进程打开的文件信息
    43. if [ -r /usr/sbin/lsof ]; then
    44.   /usr/sbin/lsof -p $PID > $DUMP_DIR/lsof-$PID.dump
    45.   echo -e ".\c"
    46.   fi
    47. done
    48. #主要负责收集、汇报与存储系统运行信息的。
    49. if [ -r /usr/bin/sar ]; then
    50.   /usr/bin/sar > $DUMP_DIR/sar.dump
    51. echo -e ".\c"
    52. fi
    53. #主要负责收集、汇报与存储系统运行信息的。
    54. if [ -r /usr/bin/uptime ]; then
    55.   /usr/bin/uptime > $DUMP_DIR/uptime.dump
    56. echo -e ".\c"
    57. fi
    58. #内存查看
    59. if [ -r /usr/bin/free ]; then
    60.   /usr/bin/free -t > $DUMP_DIR/free.dump
    61. echo -e ".\c"
    62. fi
    63. #可以得到关于进程、内存、内存分页、堵塞IO、traps及CPU活动的信息。
    64. if [ -r /usr/bin/vmstat ]; then
    65.   /usr/bin/vmstat > $DUMP_DIR/vmstat.dump
    66. echo -e ".\c"
    67. fi
    68. #报告与CPU相关的一些统计信息
    69. if [ -r /usr/bin/mpstat ]; then
    70.   /usr/bin/mpstat > $DUMP_DIR/mpstat.dump
    71. echo -e ".\c"
    72. fi
    73. #报告与IO相关的一些统计信息
    74. if [ -r /usr/bin/iostat ]; then
    75.   /usr/bin/iostat > $DUMP_DIR/iostat.dump
    76. echo -e ".\c"
    77. fi
    78. #报告与网络相关的一些统计信息
    79. if [ -r /bin/netstat ]; then
    80.   /bin/netstat > $DUMP_DIR/netstat.dump
    81. echo -e ".\c"
    82. fi
    83. echo "OK!"
    84.

    常用工具安装

    1. #!/usr/bin/env bash
    2.  
    3. # ---------------------------------------------------------------------------------
    4. # 控制台颜色
    5. BLACK="\033[1;30m"
    6. RED="\033[1;31m"
    7. GREEN="\033[1;32m"
    8. YELLOW="\033[1;33m"
    9. BLUE="\033[1;34m"
    10. PURPLE="\033[1;35m"
    11. CYAN="\033[1;36m"
    12. RESET="$(tput sgr0)"
    13. # ---------------------------------------------------------------------------------
    14.  
    15. printf "${BLUE}\n"
    16. cat << EOF
    17. ###################################################################################
    18. # 安装常用命令工具
    19. # 命令工具清单如下：
    20. # 核心工具：df、du、chkconfig
    21. # 网络工具：ifconfig、netstat、route、iptables
    22. # IP工具：ip、ss、ping、tracepath、traceroute
    23. # DNS工具：dig、host、nslookup、whois
    24. # 端口工具：lsof、nc、telnet
    25. # 下载工具：curl、wget
    26. # 编辑工具：emacs、vim
    27. # 流量工具：iftop、nethogs
    28. # 抓包工具：tcpdump
    29. # 压缩工具：unzip、zip
    30. # 版本控制工具：git、subversion
    31. #
    32. ###################################################################################
    33. EOF
    34. printf "${RESET}\n"
    35.  
    36. printf "\n${GREEN}>>>>>>>>> 安装常用命令工具开始${RESET}\n"
    37.  
    38. # 核心工具
    39. printf "\n${CYAN}>>>> install coreutils(df、du)${RESET}\n"
    40. yum install -y coreutils
    41. printf "\n${CYAN}>>>> install chkconfig${RESET}\n"
    42. yum install -y chkconfig
    43.  
    44. # 网络工具
    45. printf "\n${CYAN}>>>> install net-tools(ifconfig、netstat、route)${RESET}\n"
    46. yum install -y net-tools
    47. printf "\n${CYAN}>>>> install iptables${RESET}\n"
    48. yum install -y iptables
    49.  
    50. # IP工具
    51. printf "\n${CYAN}>>>> install iputils(ping、tracepath)${RESET}\n"
    52. yum install -y iputils
    53. printf "\n${CYAN}>>>> install traceroute${RESET}\n"
    54. yum install -y traceroute
    55. printf "\n${CYAN}>>>> install iproute(ip、ss)${RESET}\n"
    56. yum install -y iproute
    57.  
    58. # 端口工具
    59. printf "\n${CYAN}>>>> install lsof${RESET}\n"
    60. yum install -y lsof
    61. printf "\n${CYAN}>>>> install nc${RESET}\n"
    62. yum install -y nc
    63. printf "\n${CYAN}>>>> install netstat${RESET}\n"
    64. yum install -y netstat
    65.  
    66. # DNS工具
    67. printf "\n${CYAN}>>>> install bind-utils(dig、host、nslookup)${RESET}\n"
    68. yum install -y bind-utils
    69. printf "\n${CYAN}>>>> install whois${RESET}\n"
    70. yum install -y whois
    71.  
    72. # 下载工具
    73. printf "\n${CYAN}>>>> install curl${RESET}\n"
    74. yum install -y curl
    75. printf "\n${CYAN}>>>> install wget${RESET}\n"
    76. yum install -y wget
    77.  
    78. # 编辑工具
    79. printf "\n${CYAN}>>>> install emacs${RESET}\n"
    80. yum install -y emacs
    81. printf "\n${CYAN}>>>> install vim${RESET}\n"
    82. yum install -y vim
    83.  
    84. # 流量工具
    85. printf "\n${CYAN}>>>> install iftop${RESET}\n"
    86. yum install -y iftop
    87. printf "\n${CYAN}>>>> install nethogs${RESET}\n"
    88. yum install -y nethogs
    89.  
    90. # 抓包工具
    91. printf "\n${CYAN}>>>> install tcpdump${RESET}\n"
    92. yum install -y tcpdump
    93.  
    94. # 压缩工具
    95. printf "\n${CYAN}>>>> install unzip${RESET}\n"
    96. yum install -y unzip
    97.  
    98. # 版本控制工具
    99. printf "\n${CYAN}>>>> install git${RESET}\n"
    100. yum install -y git
    101. printf "\n${CYAN}>>>> install subversion${RESET}\n"
    102. yum install -y subversion
    103.  
    104. printf "\n${GREEN}<<<<<<<< 安装常用命令工具结束${RESET}\n"
    105.

    常用lib库安装

    1. #!/usr/bin/env bash
    2.  
    3. # ---------------------------------------------------------------------------------
    4. # 控制台颜色
    5. BLACK="\033[1;30m"
    6. RED="\033[1;31m"
    7. GREEN="\033[1;32m"
    8. YELLOW="\033[1;33m"
    9. BLUE="\033[1;34m"
    10. PURPLE="\033[1;35m"
    11. CYAN="\033[1;36m"
    12. RESET="$(tput sgr0)"
    13. # ---------------------------------------------------------------------------------
    14.  
    15. printf "${BLUE}\n"
    16. cat << EOF
    17. ###################################################################################
    18. # 安装常见 lib
    19. # 如果不知道命令在哪个 lib，可以使用 yum search xxx 来查找
    20. # lib 清单如下：
    21. # gcc gcc-c++ kernel-devel libtool
    22. # openssl openssl-devel
    23. # zlib zlib-devel
    24. # pcre
    25. ###################################################################################
    26. EOF
    27. printf "${RESET}\n"
    28.  
    29. printf "\n${GREEN}>>>>>>>>> 安装常见 lib 开始${RESET}\n"
    30.  
    31. printf "\n${CYAN}>>>> install gcc gcc-c++ kernel-devel libtool${RESET}\n"
    32. yum -y install make gcc gcc-c++ kernel-devel libtool
    33.  
    34. printf "\n${CYAN}>>>> install openssl openssl-devel${RESET}\n"
    35. yum -y install make openssl openssl-devel
    36.  
    37. printf "\n${CYAN}>>>> install zlib zlib-devel${RESET}\n"
    38. yum -y install make zlib zlib-devel
    39.  
    40. printf "\n${CYAN}>>>> install pcre${RESET}\n"
    41. yum -y install pcre
    42.  
    43. printf "\n${GREEN}<<<<<<<< 安装常见 lib 结束${RESET}\n"
    44.

    系统检查脚本

    1. #!/usr/bin/env bash
    2.  
    3. ##############################################################################
    4. # console color
    5. C_RESET="$(tput sgr0)"
    6. C_BLACK="\033[1;30m"
    7. C_RED="\033[1;31m"
    8. C_GREEN="\033[1;32m"
    9. C_YELLOW="\033[1;33m"
    10. C_BLUE="\033[1;34m"
    11. C_PURPLE="\033[1;35m"
    12. C_CYAN="\033[1;36m"
    13. C_WHITE="\033[1;37m"
    14. ##############################################################################
    15.  
    16. printf "${C_PURPLE}"
    17. cat << EOF
    18. ###################################################################################
    19. # 系统信息检查脚本
    20. ###################################################################################
    21. EOF
    22. printf "${C_RESET}"
    23.  
    24. [[ $(id -u) -gt 0 ]] && echo "请用root用户执行此脚本！" && exit 1
    25. sysversion=$(rpm -q centos-release | cut -d- -f3)
    26. double_line="==============================================================="
    27. line="----------------------------------------------"
    28.  
    29. # 打印头部信息
    30. printHeadInfo() {
    31.   cat << EOF
    32. +---------------------------------------------------------------------------------+
    33. |                           欢迎使用 【系统信息检查脚本】                          |
    34. +---------------------------------------------------------------------------------+
    35. EOF
    36. }
    37.  
    38. # 打印尾部信息
    39. printFootInfo() {
    40.   cat << EOF
    41. +---------------------------------------------------------------------------------+
    42. |                            脚本执行结束，感谢使用！|
    43. +---------------------------------------------------------------------------------+
    44. EOF
    45. }
    46.  
    47. options=( "获取系统信息" "获取服务信息" "获取CPU信息" "获取系统网络信息" "获取系统内存信息" "获取系统磁盘信息" "获取CPU/内存占用TOP10" "获取系统用户信息" "输出所有信息" "退出" )
    48. printMenu() {
    49.   printf "${C_BLUE}"
    50.   printf "主菜单：\n"
    51.   for i in "${!options[@]}"; do
    52.     index=`expr ${i} + 1`
    53.     val=`expr ${index} % 2`
    54.     printf "\t(%02d) %-30s" "${index}" "${options[$i]}"
    55.     if [[ ${val} -eq 0 ]]; then
    56.       printf "\n"
    57.     fi
    58.   done
    59.   printf "${C_BLUE}请输入需要执行的指令：\n"
    60.   printf "${C_RESET}"
    61. }
    62.  
    63. # 获取系统信息
    64. get_systatus_info() {
    65.   sys_os=$(uname -o)
    66.   sys_release=$(cat /etc/redhat-release)
    67.   sys_kernel=$(uname -r)
    68.   sys_hostname=$(hostname)
    69.   sys_selinux=$(getenforce)
    70.   sys_lang=$(echo $LANG)
    71.   sys_lastreboot=$(who -b | awk '{print $3,$4}')
    72.   sys_runtime=$(uptime | awk '{print  $3,$4}' | cut -d, -f1)
    73.   sys_time=$(date)
    74.   sys_load=$(uptime | cut -d: -f5)
    75.  
    76.   cat << EOF
    77. 【系统信息】
    78. 系统: ${sys_os}
    79. 发行版本:   ${sys_release}
    80. 系统内核:   ${sys_kernel}
    81. 主机名:    ${sys_hostname}
    82. selinux状态:  ${sys_selinux}
    83. 系统语言:   ${sys_lang}
    84. 系统当前时间: ${sys_time}
    85. 系统最后重启时间:   ${sys_lastreboot}
    86. 系统运行时间: ${sys_runtime}
    87. 系统负载:   ${sys_load}
    88. EOF
    89. }
    90.  
    91. # 获取CPU信息
    92. get_cpu_info() {
    93.   Physical_CPUs=$(grep "physical id" /proc/cpuinfo | sort | uniq | wc -l)
    94.   Virt_CPUs=$(grep "processor" /proc/cpuinfo | wc -l)
    95.   CPU_Kernels=$(grep "cores" /proc/cpuinfo | uniq | awk -F ': ' '{print $2}')
    96.   CPU_Type=$(grep "model name" /proc/cpuinfo | awk -F ': ' '{print $2}' | sort | uniq)
    97.   CPU_Arch=$(uname -m)
    98.   cat << EOF
    99. 【CPU信息】
    100. 物理CPU个数:$Physical_CPUs
    101. 逻辑CPU个数:$Virt_CPUs
    102. 每CPU核心数:$CPU_Kernels
    103. CPU型号:$CPU_Type
    104. CPU架构:$CPU_Arch
    105. EOF
    106. }
    107.  
    108. # 获取服务信息
    109. get_service_info() {
    110.   port_listen=$(netstat -lntup | grep -v "Active Internet")
    111.   kernel_config=$(sysctl -p 2> /dev/null)
    112.   if [[ ${sysversion} -gt 6 ]]; then
    113.     service_config=$(systemctl list-unit-files --type=service --state=enabled | grep "enabled")
    114.     run_service=$(systemctl list-units --type=service --state=running | grep ".service")
    115.   else
    116.     service_config=$(/sbin/chkconfig | grep -E ":on|:启用" | column -t)
    117.     run_service=$(/sbin/service --status-all | grep -E "running")
    118.   fi
    119.   cat << EOF
    120. 【服务信息】
    121. ${service_config}
    122.   ${line}
    123. 运行的服务:
    124. ${run_service}
    125.   ${line}
    126. 监听端口:
    127. ${port_listen}
    128.   ${line}
    129. 内核参考配置:
    130. ${kernel_config}
    131. EOF
    132. }
    133.  
    134. # 获取系统内存信息
    135. get_mem_info() {
    136.   check_mem=$(free -m)
    137.   MemTotal=$(grep MemTotal /proc/meminfo | awk '{print $2}') #KB
    138.   MemFree=$(grep MemFree /proc/meminfo | awk '{print $2}') #KB
    139.   let MemUsed=MemTotal-MemFree
    140.   MemPercent=$(awk "BEGIN {if($MemTotal==0){printf 100}else{printf \"%.2f\",$MemUsed*100/$MemTotal}}")
    141.   report_MemTotal="$((MemTotal/1024))" "MB" #内存总容量(MB)
    142.   report_MemFree="$((MemFree/1024))" "MB" #内存剩余(MB)
    143.   report_MemUsedPercent=$(free | sed -n '2p' | gawk 'x = int(( $3 / $2 ) * 100) {print x}' | sed 's/$/%/')
    144.  
    145.   cat << EOF
    146. 【内存信息】
    147. 内存总容量(MB): ${report_MemTotal}
    148. 内存剩余量(MB):${report_MemFree}
    149. 内存使用率: ${report_MemUsedPercent}
    150. EOF
    151. }
    152.  
    153. # 获取系统网络信息
    154. get_net_info() {
    155.   pri_ipadd=$(ip addr | awk '/^[0-9]+: / {}; /inet.*global/ {print gensub(/(.*)\/(.*)/, "\\1", "g", $2)}')
    156.   pub_ipadd=$(curl ifconfig.me -s)
    157.   gateway=$(ip route | grep default | awk '{print $3}')
    158.   mac_info=$(ip link | egrep -v "lo" | grep link | awk '{print $2}')
    159.   dns_config=$(egrep -v "^$|^#" /etc/resolv.conf)
    160.   route_info=$(route -n)
    161.   cat << EOF
    162. 【网络信息】
    163. 系统公网地址:${pub_ipadd}
    164. 系统私网地址:${pri_ipadd}
    165. 网关地址:${gateway}
    166. MAC地址:${mac_info}
    167. 路由信息:
    168. ${route_info}
    169. DNS 信息:
    170. ${dns_config}
    171. EOF
    172. }
    173.  
    174. # 获取系统磁盘信息
    175. get_disk_info() {
    176.   disk_info=$(fdisk -l | grep "Disk /dev" | cut -d, -f1)
    177.   disk_use=$(df -hTP | awk '$2!="tmpfs"{print}')
    178.   disk_percent=$(free | sed -n '2p' | gawk 'x = int(( $3 / $2 ) * 100) {print x}' | sed 's/$/%/')
    179.   disk_inode=$(df -hiP | awk '$1!="tmpfs"{print}')
    180.  
    181.   cat << EOF
    182. 【磁盘信息】
    183. ${disk_info}
    184. 磁盘使用: ${disk_use}
    185. 磁盘使用百分比: ${disk_percent}
    186. inode信息: ${disk_inode}
    187. EOF
    188. }
    189.  
    190. # 获取系统用户信息
    191. get_sys_user() {
    192.   login_user=$(awk -F: '{if ($NF=="/bin/bash") print $0}' /etc/passwd)
    193.   ssh_config=$(egrep -v "^#|^$" /etc/ssh/sshd_config)
    194.   sudo_config=$(egrep -v "^#|^$" /etc/sudoers | grep -v "^Defaults")
    195.   host_config=$(egrep -v "^#|^$" /etc/hosts)
    196.   crond_config=$(for cronuser in /var/spool/cron/*; do
    197.     ls ${cronuser} 2> /dev/null | cut -d/ -f5; egrep -v "^$|^#" ${cronuser} 2> /dev/null;
    198.     echo "";
    199.   done)
    200.   cat << EOF
    201. 【用户信息】
    202. 系统登录用户:
    203. ${login_user}
    204.   ${line}
    205. ssh 配置信息:
    206. ${ssh_config}
    207.   ${line}
    208. sudo 配置用户:
    209. ${sudo_config}
    210.   ${line}
    211. 定时任务配置:
    212. ${crond_config}
    213.   ${line}
    214. hosts 信息:
    215. ${host_config}
    216. EOF
    217. }
    218.  
    219. # 获取CPU/内存占用TOP10
    220. get_process_top_info() {
    221.  
    222.   top_title=$(top -b n1 | head -7 | tail -1)
    223.   cpu_top10=$(top -b n1 | head -17 | tail -11)
    224.   mem_top10=$(top -b n1 | head -17 | tail -10 | sort -k10 -r)
    225.  
    226.   cat << EOF
    227. 【TOP10】
    228. CPU占用TOP10:
    229. ${cpu_top10}
    230. 内存占用TOP10:
    231. ${top_title}
    232.   ${mem_top10}
    233. EOF
    234. }
    235.  
    236. show_dead_process() {
    237.   printf "僵尸进程：\n"
    238.   ps -al | gawk '{print $2,$4}' | grep Z
    239. }
    240.  
    241. get_all_info() {
    242.   get_systatus_info
    243.   echo ${double_line}
    244.   get_service_info
    245.   echo ${double_line}
    246.   get_cpu_info
    247.   echo ${double_line}
    248.   get_net_info
    249.   echo ${double_line}
    250.   get_mem_info
    251.   echo ${double_line}
    252.   get_disk_info
    253.   echo ${double_line}
    254.   get_process_top_info
    255.   echo ${double_line}
    256.   get_sys_user
    257. }
    258.  
    259. main() {
    260.   while [[ 1 ]]
    261.   do
    262.     printMenu
    263.     read option
    264.     local index=$[ ${option} - 1 ]
    265.     case ${options[${index}]} in
    266.       "获取系统信息")
    267.         get_systatus_info ;;
    268.       "获取服务信息")
    269.         get_service_info ;;
    270.       "获取CPU信息")
    271.         get_cpu_info ;;
    272.       "获取系统网络信息")
    273.         get_net_info ;;
    274.       "获取系统内存信息")
    275.         get_mem_info ;;
    276.       "获取系统磁盘信息")
    277.         get_disk_info ;;
    278.       "获取CPU/内存占用TOP10")
    279.         get_process_top_info ;;
    280.       "获取系统用户信息")
    281.         get_sys_user ;;
    282.       "输出所有信息")
    283.         get_all_info > sys.log
    284.         printf "${C_GREEN}信息已经输出到 sys.log 中。${C_RESET}\n\n"
    285.       ;;
    286.       "退出")
    287.         exit ;;
    288.       *)
    289.         clear
    290.         echo "抱歉，不支持此选项" ;;
    291.     esac
    292.   done
    293. }
    294.  
    295. ######################################## MAIN ########################################
    296. printHeadInfo
    297. main
    298. printFootInfo
    299. printf "${C_RESET}"

    sed进阶

    1. #!/bin/bash
    2.  
    3. #多个空格只保留一个
    4. #sed '/./,/^$/!d' test
    5.  
    6. #删除开头的空白行
    7. #sed '/./,$!d' test
    8.  
    9. #删除结尾的空白行
    10. sed '{
    11. :start
    12.   /^\n*$/{$d; N; b start}
    13. }' test
    14.  
    15. #删除html标签
    16. #有问题
    17. #s/<.*>//g
    18.  
    19. #sed 's/<[^>]*>//g' test1
    20.  
    21. #sed 's/<[^>]*>//g;/^$/d' test1
    22.  
    23. #and符号，代表替换命令中的匹配模式，不管预定义模式是什么文本，都可以用and符号替换，and符号会提取匹配替换命令中指定替换模式中的所有字符串
    24. echo "The cat sleeps in his hat" | sed 's/.at/"&"/g'
    25.  
    26. #替换单独的单词
    27. echo "The System Administrator manual" | sed 's/\(System\) Administrator/\1 user/'
    28.  
    29. #在长数字中插入逗号
    30. echo "1234567" | sed '{:start; s/\(.*[0-9]\)\([0-9]\{3\}\)/\1,\2/; t start}'
    31.  
    32. #给文件中的行编号
    33. sed '=' test | sed 'N; s/\n/ /'

    Linux CPU的上下文切换

    我们都知道 Linux 是一个多任务操作系统，它支持的任务同时运行的数量远远大于 CPU 的数量。当然，这些任务实际上并不是同时运行的（Single CPU），而是因为系统在短时间内将 CPU 轮流分配给任务，造成了多个任务同时运行的假象。

    CPU 上下文（CPU Context）

    在每个任务运行之前，CPU 需要知道在哪里加载和启动任务。这意味着系统需要提前帮助设置 CPU 寄存器和程序计数器。

    CPU 寄存器是内置于 CPU 中的小型但速度极快的内存。程序计数器用于存储 CPU 正在执行的或下一条要执行指令的位置。

    它们都是 CPU 在运行任何任务之前必须依赖的依赖环境，因此也被称为 “CPU 上下文”。如下图所示：

    图片

    知道了 CPU 上下文是什么，我想你理解 CPU 上下文切换就很容易了。“CPU上下文切换”指的是先保存上一个任务的 CPU 上下文（CPU寄存器和程序计数器），然后将新任务的上下文加载到这些寄存器和程序计数器中，最后跳转到程序计数器。

    这些保存的上下文存储在系统内核中，并在重新安排任务执行时再次加载。这确保了任务的原始状态不受影响，并且任务似乎在持续运行。

    CPU 上下文切换的类型

    你可能会说 CPU 上下文切换无非就是更新 CPU 寄存器和程序计数器值，而这些寄存器是为了快速运行任务而设计的，那为什么会影响 CPU 性能呢？

    在回答这个问题之前，请问，你有没有想过这些“任务”是什么？你可能会说一个任务就是一个进程或者一个线程。是的，进程和线程正是最常见的任务，但除此之外，还有其他类型的任务。

    别忘了硬件中断也是一个常见的任务，硬件触发信号，会引起中断处理程序的调用。

    因此，CPU 上下文切换至少有三种不同的类型：

    • 进程上下文切换
    • 线程上下文切换
    • 中断上下文切换

    让我们一一来看看。

    进程上下文切换

    Linux 按照特权级别将进程的运行空间划分为内核空间和用户空间，分别对应下图中 Ring 0 和 Ring 3 的 CPU 特权级别的 。

    • 内核空间（Ring 0）拥有最高权限，可以直接访问所有资源
    • 用户空间（Ring 3）只能访问受限资源，不能直接访问内存等硬件设备。它必须通过系统调用被陷入（trapped）内核中才能访问这些特权资源。

    图片

    从另一个角度看，一个进程既可以在用户空间也可以在内核空间运行。当一个进程在用户空间运行时，称为该进程的用户态，当它落入内核空间时，称为该进程的内核态。

    从用户态到内核态的转换需要通过系统调用来完成。例如，当我们查看一个文件的内容时，我们需要以下系统调用：

    • open()：打开文件
    • read()：读取文件的内容
    • write()：将文件的内容写入到输出文件（包括标准输出）
    • close()：关闭文件

    那么在上述系统调用过程中是否会发生 CPU 上下文切换呢？当然是的。

    这需要先保存 CPU 寄存器中原来的用户态指令的位置。接下来，为了执行内核态的代码，需要将 CPU 寄存器更新到内核态指令的新位置。最后是跳转到内核态运行内核任务。

    那么系统调用结束后，CPU 寄存器需要恢复原来保存的用户状态，然后切换到用户空间继续运行进程。

    因此，在一次系统调用的过程中，实际上有两次 CPU 上下文切换。

    但需要指出的是，系统调用进程不会涉及进程切换，也不会涉及虚拟内存等系统资源切换。这与我们通常所说的“进程上下文切换”不同。进程上下文切换是指从一个进程切换到另一个进程，而系统调用期间始终运行同一个进程

    系统调用过程通常被称为特权模式切换，而不是上下文切换。但实际上，在系统调用过程中，CPU 的上下文切换也是不可避免的。

    进程上下文切换 vs 系统调用

    那么进程上下文切换和系统调用有什么区别呢？首先，进程是由内核管理的，进程切换只能发生在内核态。因此，进程上下文不仅包括虚拟内存、栈和全局变量等用户空间资源，还包括内核栈和寄存器等内核空间的状态。

    所以进程上下文切换比系统调用要多出一步：

    在保存当前进程的内核状态和 CPU 寄存器之前，需要保存进程的虚拟内存、栈等；并加载下一个进程的内核状态。

    根据 Tsuna 的测试报告，每次上下文切换需要几十纳秒至微秒的 CPU 时间。这个时间是相当可观的，尤其是在大量进程上下文切换的情况下，很容易导致 CPU 花费大量时间来保存和恢复寄存器、内核栈、虚拟内存等资源。这正是我们在上一篇文章中谈到的，一个导致平均负载上升的重要因素。

    那么，该进程何时会被调度/切换到在 CPU 上运行？其实有很多场景，下面我为大家总结一下：

    • 当一个进程的 CPU 时间片用完时，它会被系统挂起，并切换到其他等待 CPU 运行的进程。
    • 当系统资源不足（如内存不足）时，直到资源充足之前，进程无法运行。此时进程也会被挂起，系统会调度其他进程运行。
    • 当一个进程通过 sleep 函数自动挂起自己时，自然会被重新调度。
    • 当优先级较高的进程运行时，为了保证高优先级进程的运行，当前进程会被高优先级进程挂起运行。
    • 当发生硬件中断时，CPU 上的进程会被中断挂起，转而执行内核中的中断服务程序。

    了解这些场景是非常有必要的，因为一旦上下文切换出现性能问题，它们就是幕后杀手。

    线程上下文切换

    线程和进程最大的区别在于，线程是任务调度的基本单位，而进程是资源获取的基本单位。

    说白了，内核中所谓的任务调度，实际的调度对象是线程；而进程只为线程提供虚拟内存和全局变量等资源。所以，对于线程和进程，我们可以这样理解：

    • 当一个进程只有一个线程时，可以认为一个进程等于一个线程
    • 当一个进程有多个线程时，这些线程共享相同的资源，例如虚拟内存和全局变量。
    • 此外，线程也有自己的私有数据，比如栈和寄存器，在上下文切换时也需要保存。

    这样，线程的上下文切换其实可以分为两种情况：

    • 首先，前后两个线程属于不同的进程。此时，由于资源不共享，切换过程与进程上下文切换相同。
    • 其次，前后两个线程属于同一个进程。此时，由于虚拟内存是共享的，所以切换时虚拟内存的资源保持不变，只需要切换线程的私有数据、寄存器等未共享的数据。

    显然，同一个进程内的线程切换比切换多个进程消耗的资源要少。这也是多线程替代多进程的优势。

    中断上下文切换

    除了前面两种上下文切换之外，还有另外一种场景也输出 CPU 上下文切换的，那就是中断。

    为了快速响应事件，硬件中断会中断正常的调度和执行过程，进而调用中断处理程序。

    在中断其他进程时，需要保存进程的当前状态，以便中断后进程仍能从原始状态恢复。

    与进程上下文不同，中断上下文切换不涉及进程的用户态。因此，即使中断进程中断了处于用户态的进程，也不需要保存和恢复进程的虚拟内存、全局变量等用户态资源。

    另外，和进程上下文切换一样，中断上下文切换也会消耗 CPU。过多的切换次数会消耗大量的 CPU 资源，甚至严重降低系统的整体性能。因此，当您发现中断过多时，需要注意排查它是否会对您的系统造成严重的性能问题。

    结论

    综上所述，无论哪种场景导致上下文切换，你都应该知道：

    CPU 上下文切换是保证 Linux 系统正常运行的核心功能之一，一般不需要我们特别关注。

    但是过多的上下文切换会消耗 CPU 的时间来保存和恢复寄存器、内核栈、虚拟内存等数据，从而缩短进程的实际运行时间，导致系统整体性能显着下降。

  • 相关阅读:
    web前端期末大作业 html+css古诗词主题网页设计
    读书笔记_小米创业思考
    为什么我们需要企业架构？
    安装mosek，license安装位置查找
    一、认识微服务
    Swift下Data处理全流程：从网络下载，数模转换，本地缓存到页面使用
    [模型部署]：TVM模型部署实战
    5款可以在学习和办公上提供帮助的软件
    PHP连接达梦数据库DM8（Window）
    大模型为使用Prompt提供的指导和建议
  • 原文地址：https://blog.csdn.net/weixin_68548441/article/details/125445050