Linux系统之Wait CPU time解析

简介: 上篇文章我们简要解析了用户CPU时间相关概念及应用实践,具体可参考链接🔗:Linux系统之User CPU time解析。 回顾之前的内容:在Linux操作系统中,通常采用8个不同的指标来研究Linux / Unix操作系统中的CPU消耗:用户CPU时间(us)、系统CPU时间(sy)、良好的CPU时间(ni)、空闲CPU时间(id)、等待CPU时间(wa)、硬件中断CPU时间(hi),软件中断CPU时间(si),被盗CPU时间(st)。在本文中,我们主要针对“等待CPU时间”进行解析。

     上篇文章我们简要解析了用户CPU时间相关概念及应用实践,具体可参考链接🔗:

Linux系统之User CPU time解析

      回顾之前的内容:在Linux操作系统中,通常采用8个不同的指标来研究Linux / Unix操作系统中的CPU消耗:用户CPU时间(us)、系统CPU时间(sy)、良好的CPU时间(ni)、空闲CPU时间(id)、等待CPU时间(wa)、硬件中断CPU时间(hi),软件中断CPU时间(si),被盗CPU时间(st)。在本文中,我们主要针对“等待CPU时间”进行解析。

 

什么是“等待” CPU时间?

     等待CPU时间表示CPU等待磁盘I / O或网络I / O操作完成所花费的时间。等待时间过长表示由于该设备上的I / O操作,CPU被“绞死”了。为了获得最佳性能,应该以使I / O等待CPU时间尽可能短为目标。如果等待时间> 10%,则需要对其进行问题排查。

      我们可以通过以下场景来形象化描述I / O等待时间:大家应该经历过或者已经在堵车中,有数百辆汽车在繁忙的道路上等待交通信号灯从“红色”切换为“绿色”。但是由于技术上的故障(此刻,交警也不在现场),交通信号灯从“红色”转换为“绿色”经历很长时间,迟迟没有发生更替。结果呢?数百辆汽车就傻傻的在原地等待,等待第三方介入处理。如果没有不及时处理,这将导致多种不良后果:乘客将无法及时到达目的地,驾驶员可能会感到沮丧并开始鸣喇叭(噪音污染),并且燃油将被浪费(空气污染),更有甚者直接无视交规,酿成大祸。    

如何查找“等待” CPU时间?

      可从以下来源找到等待的CPU时间:

     1、可以使用基于网络的根本原因分析工具来报告“等待”的CPU时间。如果“等待” CPU时间超出阈值,该工具便能够生成警报。


      2、Linux/Unix命令行工具“ wa”字段中的“ top”中也能够打印“等待” CPU时间,如下图所示:


[administrator@JavaLangOutOfMemory nacos-docker ]% top
top - 20:50:49 up 20:39,  2 users,  load average: 1.13, 0.86, 1.05
Tasks: 123 total,   1 running, 122 sleeping,   0 stopped,   0 zombie
%Cpu(s):  9.1 us,  6.2 sy,  0.0 ni, 83.9 id,  0.0 wa,  0.0 hi,  0.8 si,  0.0 st
KiB Mem :  3880584 total,  1006448 free,   859684 used,  2014452 buff/cache
KiB Swap:        0 total,        0 free,        0 used.  2583448 avail Mem 
  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND                                                                                                                  
 2824 root      20   0  621140 357616  18272 S  10.9  9.2 118:20.09 kube-apiserver                                                                                                           
 2805 root      20   0  222392  49924  11240 S   7.6  1.3  81:42.59 kube-controller                                                                                                          
11442 root      20   0 1512420  69476  33528 S   6.9  1.8   0:03.56 kubelet                                                                                                                  
 2783 root      20   0   10.1g  58052   8152 S   5.3  1.5  48:55.54 etcd                                                                                                                     
 1108 root      20   0  626628  85044  10092 S   4.3  2.2  45:54.18 dockerd                                                                                                                  
  974 root      20   0 1078420  41340   4352 S   1.0  1.1   8:44.73 containerd                                                                                                               
11794 root      20   0  162136   2248   1556 R   0.7  0.1   0:00.09 top                                                                                                                      
    6 root      20   0       0      0      0 S   0.3  0.0   1:05.12 ksoftirqd/0                                                                                                              
    9 root      20   0       0      0      0 S   0.3  0.0   2:42.23 rcu_sched                                                                                                                
  395 root      20   0       0      0      0 S   0.3  0.0   2:26.41 xfsaild/dm-0                                                                                                             
  641 root      20   0   21540   1204    976 S   0.3  0.0   0:07.82 irqbalance                                                                                                               
 2858 root      20   0  147076  20348   6116 S   0.3  0.5   3:58.21 kube-scheduler                                                                                                           
 3884 root      20   0  142856  15952   4376 S   0.3  0.4   1:26.73 kube-proxy                                                                                                               
11268 root      20   0       0      0      0 S   0.3  0.0   0:00.01 kworker/u4:0                                                                                                             
    1 root      20   0  125616   3692   2152 S   0.0  0.1   0:42.74 systemd                                                                                                                  
    2 root      20   0       0      0      0 S   0.0  0.0   0:00.02 kthreadd                                                                                                                 
    4 root       0 -20       0      0      0 S   0.0  0.0   0:00.00 kworker/0:0H                                                                                                             
    7 root      rt   0       0      0      0 S   0.0  0.0   0:03.03 migration/0                                                                                                              
    8 root      20   0       0      0      0 S   0.0  0.0   0:00.00 rcu_bh                                                                                                                   
   10 root       0 -20       0      0      0 S   0.0  0.0   0:00.00 lru-add-drain                                                                                                            
   11 root      rt   0       0      0      0 S   0.0  0.0   0:05.44 watchdog/0

     

如何模拟较高的“等待” CPU时间?

      为了模拟高“等待” CPU报告,同样原理,与之前的“用户” CPU时间场景类似,我们写个简单的Demon。将其打成jar包,使其运行以模拟各种性能问题。当我们启动此应用jar包时,它将导致主机上的“等待” CPU消耗激增。具体如下:


[administrator@JavaLangOutOfMemory cpu ]% java -jar devopsDemo.jar PROBLEM_IO
Application started!
Starting to write to iofile-01.log
Starting to write to iofile-02.log
Starting to write to iofile-03.log
Starting to write to iofile-04.log
Starting to write to iofile-05.log
Starting to write to iofile-06.log
Read & write 1000 times to iofile-05.log
Read & write 1000 times to iofile-02.log
Read & write 1000 times to iofile-01.log
Read & write 1000 times to iofile-04.log
Read & write 1000 times to iofile-03.log
Read & write 1000 times to iofile-06.log
Read & write 1000 times to iofile-04.log
Read & write 1000 times to iofile-02.log
... ...

     

       针对此应用jar包,我们看下其部分代码如下:


public class IODemo {
    public void start() {              
             for (int counter =1; counter <= 6; ++counter) { 
            // Launch 6 threads.             
            new IOThread ("iofile-" + counter + ".log").start();         
         }     
     } 
}
public class IOThread extends Thread {     
    public String fileName; 
    public static final String CONTENT = 
"Hello CPU World! We are building a world where cpu resources are wasted and memmory resource are leaking. \n" + 
"Hello CPU World! We are building a world where cpu resources are wasted and memmory resource are leaking. \n" + 
"Hello CPU World! We are building a world where cpu resources are wasted and memmory resource are leaking. \n" + 
"Hello CPU World! We are building a world where cpu resources are wasted and memmory resource are leaking. \n" 
"Hello CPU World! We are building a world where cpu resources are wasted and memmory resource are leaking. \n" + 
"Hello CPU World! We are building a world where cpu resources are wasted and memmory resource are leaking. \n" + 
"Hello CPU World! We are building a world where cpu resources are wasted and memmory resource are leaking. \n" + 
"Hello CPU World! We are building a world where cpu resources are wasted and memmory resource are leaking. \n" 
    public IOThread(String fileName) {         
           this.fileName = fileName;     
}     
    public void run() {     
        int counter = 0; 
        // Loop infinitely trying to read and close the file.         
       while (true) { 
            // Write the contents to the file.             
            FileUtil.write(fileName, CONTENT);                          
            // Read the contents from the file.             
             FileUtil.read(fileName);         
         }        
     } 
} 

 

如何解决高“等待时间”?

      如果我们的资源设备的I / O等待时间过长,则可以尝试参考以下步骤进行优化及调整:

       1、借助命令行及相关分析工具,该工具会指向应用程序中的代码行,从而导致较高的I / O等待时间。

       2、可以通过执行以下操作来优化应用程序的等待时间:

     (1)减少数据库调用次数

     (2)优化数据库查询,以减少从数据库返回到应用程序的数据

     (3)减少对外部应用程序进行的网络呼叫数量

     (4)尝试最小化在外部应用程序和您的应用程序之间发送的有效负载量

     (5)尝试减少写入磁盘的文件数量。

     (6)尝试减少从磁盘读取的数据量。

     (7)确保仅将基本日志语句写入磁盘。

       3、确保我们的操作系统在安装了所有补丁程序的最新版本上运行。从安全性的角度来看,这不仅很好,而且还可以提高性能。

       4、确保在设备上分配了足够的可用内存。缺少可用内存有两个有害影响:

    (1)如果缺少可用内存,则将交换进程进出内存。磁盘将频繁写入和读取几页。它将增加磁盘I / O操作。

    (2)如果可用内存较少,则操作系统将无法在内存中缓存常用磁盘块。当高速缓存的磁盘块被缓存时,I / O等待时间将减少。

       5、将文件系统磁盘使用率保持在80%以下,以避免过多的碎片。当磁盘碎片过多时,I / O时间将增加。

       6、如果上述所有步骤均失败,则我们也可以尝试考虑升级存储以提高性能。例如,可以考虑切换到更快的SSD,NVMe,SAN存储等。

相关实践学习
CentOS 7迁移Anolis OS 7
龙蜥操作系统Anolis OS的体验。Anolis OS 7生态上和依赖管理上保持跟CentOS 7.x兼容,一键式迁移脚本centos2anolis.py。本文为您介绍如何通过AOMS迁移工具实现CentOS 7.x到Anolis OS 7的迁移。
相关文章
|
15天前
|
存储 缓存 监控
Linux缓存管理:如何安全地清理系统缓存
在Linux系统中,内存管理至关重要。本文详细介绍了如何安全地清理系统缓存,特别是通过使用`/proc/sys/vm/drop_caches`接口。内容包括清理缓存的原因、步骤、注意事项和最佳实践,帮助你在必要时优化系统性能。
144 78
|
19天前
|
Linux Shell 网络安全
Kali Linux系统Metasploit框架利用 HTA 文件进行渗透测试实验
本指南介绍如何利用 HTA 文件和 Metasploit 框架进行渗透测试。通过创建反向 shell、生成 HTA 文件、设置 HTTP 服务器和发送文件,最终实现对目标系统的控制。适用于教育目的,需合法授权。
53 9
Kali Linux系统Metasploit框架利用 HTA 文件进行渗透测试实验
|
15天前
|
存储 监控 Linux
嵌入式Linux系统编程 — 5.3 times、clock函数获取进程时间
在嵌入式Linux系统编程中,`times`和 `clock`函数是获取进程时间的两个重要工具。`times`函数提供了更详细的进程和子进程时间信息,而 `clock`函数则提供了更简单的处理器时间获取方法。根据具体需求选择合适的函数,可以更有效地进行性能分析和资源管理。通过本文的介绍,希望能帮助您更好地理解和使用这两个函数,提高嵌入式系统编程的效率和效果。
75 13
|
16天前
|
Ubuntu Linux C++
Win10系统上直接使用linux子系统教程(仅需五步!超简单,快速上手)
本文介绍了如何在Windows 10上安装并使用Linux子系统。首先,通过应用商店安装Windows Terminal和Linux系统(如Ubuntu)。接着,在控制面板中启用“适用于Linux的Windows子系统”并重启电脑。最后,在Windows Terminal中选择安装的Linux系统即可开始使用。文中还提供了注意事项和进一步配置的链接。
39 0
|
27天前
|
存储 Oracle 安全
服务器数据恢复—LINUX系统删除/格式化的数据恢复流程
Linux操作系统是世界上流行的操作系统之一,被广泛用于服务器、个人电脑、移动设备和嵌入式系统。Linux系统下数据被误删除或者误格式化的问题非常普遍。下面北亚企安数据恢复工程师简单聊一下基于linux的文件系统(EXT2/EXT3/EXT4/Reiserfs/Xfs) 下删除或者格式化的数据恢复流程和可行性。
|
1月前
|
存储 缓存 监控
Docker容器性能调优的关键技巧,涵盖CPU、内存、网络及磁盘I/O的优化策略,结合实战案例,旨在帮助读者有效提升Docker容器的性能与稳定性。
本文介绍了Docker容器性能调优的关键技巧,涵盖CPU、内存、网络及磁盘I/O的优化策略,结合实战案例,旨在帮助读者有效提升Docker容器的性能与稳定性。
95 7
|
2月前
|
弹性计算 Kubernetes Perl
k8s 设置pod 的cpu 和内存
在 Kubernetes (k8s) 中,设置 Pod 的 CPU 和内存资源限制和请求是非常重要的,因为这有助于确保集群资源的合理分配和有效利用。你可以通过定义 Pod 的 `resources` 字段来设置这些限制。 以下是一个示例 YAML 文件,展示了如何为一个 Pod 设置 CPU 和内存资源请求(requests)和限制(limits): ```yaml apiVersion: v1 kind: Pod metadata: name: example-pod spec: containers: - name: example-container image:
266 1
|
2月前
|
存储 关系型数据库 MySQL
查询服务器CPU、内存、磁盘、网络IO、队列、数据库占用空间等等信息
查询服务器CPU、内存、磁盘、网络IO、队列、数据库占用空间等等信息
871 2
|
4月前
|
存储 关系型数据库 MySQL
查询服务器CPU、内存、磁盘、网络IO、队列、数据库占用空间等等信息
查询服务器CPU、内存、磁盘、网络IO、队列、数据库占用空间等等信息
220 5
|
3月前
|
C# 开发工具 Windows
C# 获取Windows系统信息以及CPU、内存和磁盘使用情况
C# 获取Windows系统信息以及CPU、内存和磁盘使用情况
82 0

热门文章

最新文章