docker 内存 cpu 限制简介

怼烎@ 2021-09-08 10:20 499阅读 0赞

**目录**

一、Docker资源管理接口概览

二、Docker资源管理原理——Cgroups子系统介绍

1. memory -- 用来限制cgroup中的任务所能使用的内存上限

读取内存对应的cgroups文件

读取交换内存对应的cgroups文件

2. 使用stress镜像学习如何为容器分配内存

centos-stress-source:1.0.2镜像创建

分配的内存比指定的内存和交换内存小时，执行正常，不断释放与分配

分配的内存比指定的内存和交换内存大时

不指定swap-memory时，默认swap的值确认

3. cpu子系统

设置cpu权重，容器竞争cpu资源时是才起作用，但容器情况下可以使用到全部的容器资源

4. Block IO

磁盘的读写权重

BLKIO限额具有竞争资源的情况，与 cpu 配额一样

--------------------

随着Docker技术被越来越多的个人、企业所接受，其用途也越来越广泛。Docker资源管理包含对CPU、内存、IO等资源的限制，但大部分Docker使用者在使用资源管理接口时往往还比较模糊。  
　　本文将尝试介绍Docker资源管理背后的Cgroups机制，并且列举主要的资源管理接口对应的Cgroups接口，让Docker使用者对资源管理更加清晰。

# 一、Docker资源管理接口概览 #

<table> 
 <tbody> 
  <tr> 
   <td> <p>格式</p> </td> 
   <td> <p>描述</p> </td> 
  </tr> 
  <tr> 
   <td>-m, --memory=" &lt;数字&gt;[&lt;单位&gt;]"</td> 
   <td>内存使用限制。 数字需要使用整数，对应的单位是b, k, m, g中的一个。最小取值是4M。</td> 
  </tr> 
  <tr> 
   <td>--memory-swap="&lt;数字&gt;[&lt;单位&gt;]"</td> 
   <td>总内存使用限制 (物理内存 + 交换分区，数字需要使用整数，对应的单位是b, k, m, g中的一个。</td> 
  </tr> 
  <tr> 
   <td>--memory-reservation="&lt;数字&gt;[&lt;单位&gt;]"</td> 
   <td>内存软限制。 数字需要使用正整数，对应的单位是b, k, m, g中的一个。</td> 
  </tr> 
  <tr> 
   <td>--kernel-memory="&lt;数字&gt;[&lt;单位&gt;]"</td> 
   <td>内核内存限制。 数字需要使用正整数，对应的单位是b, k, m, g中的一个。最小取值是4M。</td> 
  </tr> 
  <tr> 
   <td>--oom-kill-disable=false</td> 
   <td>内存耗尽时是否杀掉容器</td> 
  </tr> 
  <tr> 
   <td>--memory-swappiness=""</td> 
   <td>调节容器内存使用交换分区的选项，取值为0和100之间的整数(含0和100)。</td> 
  </tr> 
  <tr> 
   <td>-c, --cpu-shares=0</td> 
   <td>CPU份额 (相对权重)</td> 
  </tr> 
  <tr> 
   <td>--cpu-period=0</td> 
   <td>完全公平算法中的period值</td> 
  </tr> 
  <tr> 
   <td>--cpu-quota=0</td> 
   <td>完全公平算法中的quota值</td> 
  </tr> 
  <tr> 
   <td>--cpuset-cpus="&lt;数字&gt;"</td> 
   <td>限制容器使用的cpu核(0-3, 0,1)</td> 
  </tr> 
  <tr> 
   <td>--cpuset-mems=""</td> 
   <td>限制容器使用的内存节点，该限制仅仅在NUMA系统中生效。</td> 
  </tr> 
  <tr> 
   <td>--blkio-weight=0</td> 
   <td>块设备IO相对权重，取值在10值1000之间的整数（包含10和1000）</td> 
  </tr> 
  <tr> 
   <td>--blkio-weight-device="设备名称:权重值"</td> 
   <td>指定的块设备的IO相对权重</td> 
  </tr> 
  <tr> 
   <td>--device-read-bps="&lt;设备路径&gt;:&lt;数字&gt;[&lt;单位&gt;]"</td> 
   <td>限制对某个设备的读取速率 ，数字需要使用正整数，单位是kb, mb, or gb中的一个。</td> 
  </tr> 
  <tr> 
   <td>--device-write-bps="&lt;设备路径&gt;:&lt;数字&gt;[&lt;单位&gt;]"</td> 
   <td>限制对某个设备的写速率 ，数字需要使用正整数，单位是kb, mb, or gb中的一个。</td> 
  </tr> 
  <tr> 
   <td>--device-read-iops="&lt;设备路径&gt;:&lt;数字&gt;"</td> 
   <td>限制对某个设备每秒IO的读取速率，数字需要使用正整数。</td> 
  </tr> 
  <tr> 
   <td>--device-write-iops="&lt;设备路径&gt;:&lt;数字&gt;"</td> 
   <td>限制对某个设备每秒IO的写速率，数字需要使用正整数。</td> 
  </tr> 
 </tbody> 
</table>

# 二、Docker资源管理原理——Cgroups子系统介绍 #

Cgroups是control groups的缩写，最初由google的工程师提出，后来被整合进Linux内核。Cgroups是Linux内核提供的一种可以限制、记录、隔离进程组（process groups）所使用的物理资源（如：CPU、内存、IO等）的机制。Cgroups由7个子系统组成：分别是cpuset、cpu、cpuacct、blkio、devices、freezer、memory。不同类型资源的分配和管理是由各个cgroup子系统负责完成的。

在 /sys/fs/cgroup/子系统名称/docker 目录中为每个容器创建一个 cgroup 目录，并且以容器长ID命名，如下 cpu 资源系统，目录中包含所有与 cpu 相关的 cgroup 配置：

[vagrant@localhost docker]$ pwd
    /sys/fs/cgroup/cpu/docker
    [vagrant@localhost docker]$ ll
    total 0
    drwxr-xr-x. 2 root root 0 Feb 27 02:37 02c8442f5e65909bc1f7ecfc1596f1474d7d9d1dcd3e2cd34d059cabc578d2c5
    [vagrant@localhost docker]$ cd 02c8442f5e65909bc1f7ecfc1596f1474d7d9d1dcd3e2cd34d059cabc578d2c5/
    [vagrant@localhost 02c8442f5e65909bc1f7ecfc1596f1474d7d9d1dcd3e2cd34d059cabc578d2c5]$ ll
    total 0
    -rw-r--r--. 1 root root 0 Feb 27 02:37 cgroup.clone_children
    --w--w--w-. 1 root root 0 Feb 27 02:37 cgroup.event_control
    -rw-r--r--. 1 root root 0 Feb 27 02:37 cgroup.procs
    -r--r--r--. 1 root root 0 Feb 27 02:37 cpuacct.stat
    -rw-r--r--. 1 root root 0 Feb 27 02:37 cpuacct.usage
    -r--r--r--. 1 root root 0 Feb 27 02:37 cpuacct.usage_percpu
    -rw-r--r--. 1 root root 0 Feb 27 02:37 cpu.cfs_period_us
    -rw-r--r--. 1 root root 0 Feb 27 02:37 cpu.cfs_quota_us
    -rw-r--r--. 1 root root 0 Feb 27 02:37 cpu.rt_period_us
    -rw-r--r--. 1 root root 0 Feb 27 02:37 cpu.rt_runtime_us
    -rw-r--r--. 1 root root 0 Feb 27 02:37 cpu.shares
    -r--r--r--. 1 root root 0 Feb 27 02:37 cpu.stat
    -rw-r--r--. 1 root root 0 Feb 27 02:37 notify_on_release
    -rw-r--r--. 1 root root 0 Feb 27 02:37 tasks

## 1. memory -- 用来限制cgroup中的任务所能使用的内存上限 ##

<table> 
 <tbody> 
  <tr> 
   <td> <p>子系统常用cgroups接口</p> </td> 
   <td> <p>描述</p> </td> 
   <td> <p>对应的docker接口</p> </td> 
  </tr> 
  <tr> 
   <td>cgroup/memory/memory.limit_in_bytes<br> &nbsp;</td> 
   <td>设定内存上限，单位是字节，也可以使用k/K、m/M或者g/G表示要设置数值的单位。</td> 
   <td>-m, --memory=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/memory/memory.memsw.limit_in_bytes<br> &nbsp;</td> 
   <td>设定内存加上交换分区的使用总量。通过设置这个值，可以防止进程把交换分区用光。</td> 
   <td>--memory-swap=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/memory/memory.soft_limit_in_bytes<br> &nbsp;</td> 
   <td>设定内存限制，但这个限制并不会阻止进程使用超过限额的内存，只是在系统内存不足时，会优先回收超过限额的进程占用的内存，使之向限定值靠拢。</td> 
   <td>--memory-reservation=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/memory/memory.kmem.limit_in_bytes<br> &nbsp;</td> 
   <td>设定内核内存上限。</td> 
   <td>--kernel-memory=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/memory/memory.oom_control<br> &nbsp;</td> 
   <td>如果设置为0，那么在内存使用量超过上限时，系统不会杀死进程，而是阻塞进程直到有内存被释放可供使用时，另一方面，系统会向用户态发送事件通知，用户态的监控程序可以根据该事件来做相应的处理，例如提高内存上限等。</td> 
   <td>--oom-kill-disable=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/memory/memory.swappiness<br> &nbsp;</td> 
   <td>控制内核使用交换分区的倾向。取值范围是0至100之间的整数（包含0和100）。值越小，越倾向使用物理内存。</td> 
   <td>--memory-swappiness=</td> 
  </tr> 
 </tbody> 
</table>

### **读取内存对应的cgroups文件** ###

[vagrant@localhost cgroup]$ docker run -ti --rm -m 200M centos bash -c "cat /sys/fs/cgroup/memory/memory.limit_in_bytes"                   
    209715200

当内存限制在200M时，cgoups的文件数值为 209715200，单位为字节，刚好等于200M。其中，--rm 表示退出之后删除创建的容器。

### **读取交换内存对应的cgroups文件** ###

[vagrant@localhost cgroup]$ docker run -ti --rm -m 200M --memory-swap=300M centos bash -c "cat /sys/fs/cgroup/memory/memory.memsw.limit_in_bytes"
    314572800

当内存限制在300M时，cgoups的文件数值为 314572800，单位为字节，刚好等于300M。

其余的，以此类推。

## 2. 使用stress镜像学习如何为容器分配内存　　　 ##

### centos-stress-source:1.0.2镜像创建 ###

1.创建Dockerfile目录

[vagrant@localhost ~]$ mkdir -p /tmp/stress
    [vagrant@localhost stress]$ sudo vi Dockerfile                                            
    FROM library/centos
    
    ADD Centos-7.repo /etc/yum.repos.d/CentOS-Base.repo
    ADD stress-1.0.4.tar.gz  /usr/local/src
    RUN yum clean all && yum makecache && yum install -y make automake autoconf gcc gcc-c++
    WORKDIR /usr/local/src/stress-1.0.4
    RUN ./configure --prefix=/usr/local/stress
    RUN make && make install
    ENV PATH /usr/local/stress/bin:$PATH
    #CMD与ENTRYPOINT的区别在于执行docker run时参数传递的方式不同
    ENTRYPOINT ["stress", "--verbose"]

2.根据Dockerfile生成创建一个stress镜像

docker build -t centos-stress-source:1.0.2 .

3.查看镜像

[vagrant@localhost stress]$ docker images
    REPOSITORY                                       TAG                 IMAGE ID            CREATED             SIZE
    centos-stress-source                             1.0.2               4f8b1ae5f7e8        7 minutes ago       546MB

4.测试是否可用

[vagrant@localhost stress]$ docker run -ti --rm -m 200M --memory-swap=300M centos-stress-source:1.0.2 --vm 1 --vm-bytes 280M 
    stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
    stress: dbug: [1] using backoff sleep of 3000us
    stress: dbug: [1] --> hogvm worker 1 [5] forked
    stress: dbug: [5] allocating 293601280 bytes ...
    stress: dbug: [5] touching bytes in strides of 4096 bytes ...
    stress: dbug: [5] freed 293601280 bytes
    stress: dbug: [5] allocating 293601280 bytes ...
    stress: dbug: [5] touching bytes in strides of 4096 bytes ...

### 分配的内存比指定的内存和交换内存小时，执行正常，不断释放与分配 ###

[vagrant@localhost cgroup]$  docker run -ti --rm -m 200M --memory-swap=300M centos-stress-source:1.0.2 --vm 1 --vm-bytes 280M
    stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
    stress: dbug: [1] using backoff sleep of 3000us
    stress: dbug: [1] --> hogvm worker 1 [5] forked
    stress: dbug: [5] allocating 293601280 bytes ...
    stress: dbug: [5] touching bytes in strides of 4096 bytes ...
    stress: dbug: [5] freed 293601280 bytes
    stress: dbug: [5] allocating 293601280 bytes ...
    stress: dbug: [5] touching bytes in strides of 4096 bytes ...

### 分配的内存比指定的内存和交换内存大时 ###

[vagrant@localhost cgroup]$  docker run -ti --rm -m 200M --memory-swap=300M centos-stress-source:1.0.2 --vm 1 --vm-bytes 310M
    stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
    stress: dbug: [1] using backoff sleep of 3000us
    stress: dbug: [1] --> hogvm worker 1 [5] forked
    stress: dbug: [5] allocating 325058560 bytes ...
    stress: dbug: [5] touching bytes in strides of 4096 bytes ...
    stress: FAIL: [1] (415) <-- worker 5 got signal 9
    stress: WARN: [1] (417) now reaping child worker processes
    stress: FAIL: [1] (421) kill error: No such process
    stress: FAIL: [1] (451) failed run completed in 1s

分配的内存试图超过300M时，stress线程报错，容器强行退出。

### 不指定swap-memory时，默认swap的值确认 ###

*1、指定 -m 内存值为100M*

[vagrant@localhost tmp]$ docker run -ti --rm -m 100M centos bash -c "cat /sys/fs/cgroup/memory/memory.limit_in_bytes && cat /sys/fs/cgroup/memory/memory.memsw.limit_in_bytes" 
    104857600
    209715200

*可以看到上述情况，在不指定 memory-swap 大小的情况下，默认取memory的两倍值， 即 200M。  
  
2、当一方的指定值为-1时，表示无限大*

[vagrant@localhost tmp]$docker run -ti --rm -m 100M --memory-swap -1 centos bash -c "cat /sys/fs/cgroup/memory/memory.limit_in_bytes && cat /sys/fs/cgroup/memory/memory.memsw.limit_in_bytes"    
    104857600
    9223372036854771712

可以看到，memory-swap为 无限大。

*3、memory 和 memory-swap的关系*

memory-swap = memory + swap

*所以，当memory-swap值小于memory设定值的时候，会报错如下*

[vagrant@localhost tmp]$ docker run -ti --rm -m 200M --memory-swap 100M centos bash -c "cat /sys/fs/cgroup/memory/memory.limit_in_bytes && cat /sys/fs/cgroup/memory/memory.memsw.limit_in_bytes" 
    docker: Error response from daemon: Minimum memoryswap limit should be larger than memory limit, see usage.
    See 'docker run --help'.

##    3. cpu子系统 ##

<table> 
 <tbody> 
  <tr> 
   <td> <p>子系统常用cgroups接口</p> </td> 
   <td> <p>描述</p> </td> 
   <td> <p>对应的docker接口</p> </td> 
  </tr> 
  <tr> 
   <td>cgroup/cpu/cpu.shares<br> &nbsp;</td> 
   <td>负责CPU比重分配的接口。假设我们在cgroupfs的根目录下创建了两个cgroup（C1和C2），并且将cpu.shares分别配置为512和1024，那么当C1和C2争用CPU时，C2将会比C1得到多一倍的CPU占用率。要注意的是，只有当它们争用CPU时CPU share才会起作用，如果C2是空闲的，那么C1可以得到全部的CPU资源。</td> 
   <td>-c, --cpu-shares=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/cpu/cpu.cfs_period_us<br> &nbsp;</td> 
   <td>负责CPU带宽限制，需要与cpu.cfs_quota_us搭配使用。我们可以将period设置为1秒，将quota设置为0.5秒，那么cgroup中的进程在1秒内最多只能运行0.5秒，然后就会被强制睡眠，直到下一个1秒才能继续运行。</td> 
   <td>--cpu-period=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/cpu/cpu.cfs_quota_us<br> &nbsp;</td> 
   <td>负责CPU带宽限制，需要与cpu.cfs_period_us搭配使用。</td> 
   <td>--cpu-quota=""</td> 
  </tr> 
 </tbody> 
</table>

### 设置cpu权重，容器竞争cpu资源时是才起作用，但容器情况下可以使用到全部的容器资源 ###

启动容器 container\_a，设置 cpu share = 1024

[vagrant@localhost tmp]$ docker run --rm --name container_a -it -c 1024 centos-stress-source:1.0.2  --cpu 1
    stress: info: [1] dispatching hogs: 1 cpu, 0 io, 0 vm, 0 hdd
    stress: dbug: [1] using backoff sleep of 3000us
    stress: dbug: [1] --> hogcpu worker 1 [5] forked

启动容器 container\_b，设置 cpu share = 512

[vagrant@localhost ~]$ docker run --rm --name container_b -it -c 512 centos-stress-source:1.0.2  --cpu 1 
    stress: info: [1] dispatching hogs: 1 cpu, 0 io, 0 vm, 0 hdd
    stress: dbug: [1] using backoff sleep of 3000us
    stress: dbug: [1] --> hogcpu worker 1 [5] forked

在host中执行 top 查看 cpu 的使用情况

[vagrant@localhost ~]$ top
    top - 12:09:26 up 10:39,  3 users,  load average: 2.07, 0.82, 0.40
    Tasks: 101 total,   3 running,  98 sleeping,   0 stopped,   0 zombie
    %Cpu(s): 99.7 us,  0.3 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
    KiB Mem :   500108 total,   160592 free,   107168 used,   232348 buff/cache
    KiB Swap:  1572860 total,  1370868 free,   201992 used.   337508 avail Mem 
    
      PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND                         
     7996 root      20   0    7264     96      0 R 66.3  0.0   2:37.42 stress                          
     8142 root      20   0    7264     96      0 R 33.3  0.0   0:20.98 stress

以上，可以看到 container\_a 占用的 cpu 资源是 container\_b 的两倍。  
暂停container\_a 可以发现数据如下

[vagrant@localhost ~]$ docker pause container_a
    container_a
    [vagrant@localhost ~]$ top
    top - 12:11:08 up 10:41,  3 users,  load average: 2.02, 1.18, 0.58
    Tasks: 101 total,   2 running,  99 sleeping,   0 stopped,   0 zombie
    %Cpu(s):100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
    KiB Mem :   500108 total,   160468 free,   107288 used,   232352 buff/cache
    KiB Swap:  1572860 total,  1370868 free,   201992 used.   337384 avail Mem 
    
      PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND                         
     8142 root      20   0    7264     96      0 R 99.3  0.0   1:01.57 stress                          
     3276 root      20   0  644028  28028   9832 S  0.3  5.6   1:41.57 dockerd

可以看到，当 在container\_a空闲的时候，container\_b 能够用满整个 cpu。

PS. 需要退出当前测试时，需要直接ctrl+c，或者 直接执行 docker stop <container name>，执行过 docker pause <container name>的，只能执行stop退出。

## 4. Block IO ##

<table> 
 <tbody> 
  <tr> 
   <td> <p>子系统常用cgroups接口</p> </td> 
   <td> <p>描述</p> </td> 
   <td> <p>对应的docker接口</p> </td> 
  </tr> 
  <tr> 
   <td>cgroup/blkio/blkio.weight<br> &nbsp;</td> 
   <td>设置权重值，取值范围是10至1000之间的整数（包含10和1000）。这跟cpu.shares类似，是比重分配，而不是绝对带宽的限制，因此只有当不同的cgroup在争用同一个块设备的带宽时，才会起作用。</td> 
   <td>--blkio-weight=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/blkio/blkio.weight_device<br> &nbsp;</td> 
   <td>对具体的设备设置权重值，这个值会覆盖上述的blkio.weight。</td> 
   <td>--blkio-weight-device=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/blkio/blkio.throttle.read_bps_device<br> &nbsp;</td> 
   <td>对具体的设备，设置每秒读块设备的带宽上限。</td> 
   <td>--device-read-bps=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/blkio/blkio.throttle.write_bps_device<br> &nbsp;</td> 
   <td>设置每秒写块设备的带宽上限。同样需要指定设备。</td> 
   <td>--device-write-bps=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/blkio/blkio.throttle.read_iops_device<br> &nbsp;</td> 
   <td>设置每秒读块设备的IO次数的上限。同样需要指定设备。</td> 
   <td>--device-read-iops=""</td> 
  </tr> 
  <tr> 
   <td>cgroup/blkio/blkio.throttle.write_iops_device<br> &nbsp;</td> 
   <td>设置每秒写块设备的IO次数的上限。同样需要指定设备。</td> 
   <td>--device-write-iops=""</td> 
  </tr> 
 </tbody> 
</table>

### 磁盘的读写权重 ###

docker 可通过设置权重、限制 bps （每秒读写的数据量）和 iops（每秒 IO 的次数） 的方式控制容器读写磁盘的带宽。  
  
1、限制读写 IO 为50M/s，则最终的读写速度会在50M左右。

[vagrant@localhost tmp]$ docker  run -it --rm --device-write-bps /dev/sda:50M centos               [root@540f9b91405e /]# time dd if=/dev/zero of=test.out bs=1M count=800 oflag=direct
    800+0 records in
    800+0 records out
    838860800 bytes (839 MB) copied, 15.9115 s, 52.7 MB/s
    
    real    0m15.913s
    user    0m0.002s
    sys     0m0.321s

2、不限制 IO

[vagrant@localhost tmp]$ docker  run -it --rm centos
    [root@77f63fec8b34 /]# time dd if=/dev/zero of=test.out bs=1M count=800 oflag=direct
    800+0 records in
    800+0 records out
    838860800 bytes (839 MB) copied, 1.6477 s, 509 MB/s
    
    real    0m1.649s
    user    0m0.000s
    sys     0m0.302s

PS.注意oflag=direct，需要指定IO方式，目前BLKIO限额只对direct（不使用文件缓存）生效。因为容器的文件系统在 host /dev/sda 上，所以在容器中写文件，相当于对 host /dev/sda 进行写操作

### BLKIO限额具有竞争资源的情况，与 cpu 配额一样 ###

1、是 container\_b 的BLKIO 优先级是 container\_a 的两倍  
  
 设置 container\_a 的 --blkio-weight 300

[vagrant@localhost tmp]$ docker  run -it --rm --name container_a --blkio-weight 300 centos 
    [root@7cd7ff76edb4 /]# time dd if=/dev/zero of=test.out bs=1M count=800 oflag=direct
    800+0 records in
    800+0 records out
    838860800 bytes (839 MB) copied, 3.12988 s, 268 MB/s
    
    real    0m3.131s
    user    0m0.001s
    sys     0m0.335s

设置 container\_b 的 --blkio-weight 600

[vagrant@localhost ~]$ docker  run -it --rm --name container_b --blkio-weight 600 centos 
    [root@89aa5264b9d1 /]# time dd if=/dev/zero of=test.out bs=1M count=800 oflag=direct
    800+0 records in
    800+0 records out
    838860800 bytes (839 MB) copied, 2.10906 s, 398 MB/s
    
    real    0m2.111s
    user    0m0.001s
    sys     0m0.296s

ps. 由于收到执行命令没有办法做到同时IO，所以读写速度上的比例并没有严格的1：2。