如何在Linux服务器上产生高的CPU负载？

试试stress，这几乎相当于Windows的consume.exe：

oliver$ ./stress --cpu 3
stress: info: [18472] dispatching hogs: 3 cpu, 0 io, 0 vm, 0 hdd
```。

不需要安装任何额外的软件包，你的老牌shell就能独自完成。

这个单行本将100%加载你的四个内核1：

for i in 1 2 3 4; do while : ; do : ; done & done

工作原理很简单，它开始了四个无休止的循环。每个循环都在重复空指令（:）。每个循环都能100%加载一个CPU内核。

如果你使用的是bash，ksh93和其他支持范围的shell，（即不是dash或更早的ksh），你可以使用这个非移植语法：

for i in {1..4}; do ...

for i in 1 2 3 4; do kill %$i; done

如果与4不同，用你想加载的CPU数量代替4。假设你在启动这些循环时没有后台工作已经运行，你可以用这个命令停止负载生成：

# Usage: lc [number_of_cpus_to_load [number_of_seconds] ]
lc() {
  (
    pids=""
    cpus=${1:-1}
    seconds=${2:-60}
    echo loading $cpus CPUs for $seconds seconds
    trap 'for p in $pids; do kill $p; done' 0
    for ((i=0;i<cpus;i++)); do while : ; do : ; done & pids="$pids $!"; done
    sleep $seconds
  )
}

回应@underscore_d的评论，这里有一个增强版，可以简化很多停止负载的操作，并且允许指定一个超时（默认60秒）。这个shell函数至少在bash和ksh下有效。

&001 &001

1注意，当CPU每个内核支持一个以上的线程（超线程）时，操作系统将把负载分配给所有的虚拟CPU。在这种情况下，负载行为取决于实现（每个线程可能被报告为100%忙或不忙）。

我做了一个简单的python脚本，也是这样做的。你可以控制你想要加载的cpu核心数量。这样做的好处是，除了cpu之外，它不会消耗任何其他资源（我认为Mark johnson的想法会消耗大量的I/O资源，这在这里是不需要的）

from multiprocessing import Pool

def f(x):
    # Put any cpu (only) consuming operation here. I have given 1 below -
    while True:
        x * x

# decide how many cpus you need to load with.
no_of_cpu_to_be_consumed = 3

p = Pool(processes=no_of_cpu_to_be_consumed)
p.map(f, range(no_of_cpu_to_be_consumed))

只要在终端上运行这个脚本$ python temp1.py就可以了。

这里是我在加载3个内核时的CPU消耗输出。

另一种方法是

openssl speed -multi $(grep -ci processor /proc/cpuinfo)

或者（如果有nproc的话）

openssl speed -multi $(nproc --all)

OpenSSL几乎在现在的发行版上都有，所以不需要额外的软件包。

我一直在开发压力-ng，这是一个更新的压力工具，可以对Linux系统的各方面进行压力测试。更多信息，请参阅 http://kernel.ubuntu.com/~cking/stress-ng/

使用方法与 stress

$ stress-ng --cpu 4 --vm 2 --fork 8 --switch 4 --timeout 1m
stress-ng: info: [32254] dispatching hogs: 4 cpu, 8 fork, 4 switch, 2 vm
stress-ng: info: [32254] cache allocate: default cache size: 8192K

sudo apt-get install stress-ng
``` 安装方法类似

我通常采用的cpuburn套件：

sudo apt-get install cpuburn
for i in {1..4}; do burnK7 & done

burnP6 & burnP6 & burnP6 & burnP6 & 
[1] 28520
[2] 28521
[3] 28522
[4] 28523

用你有或想强调的核心数/HT线程数代替4。我不得不第二次写了这个帖子，不知为何我的机器不喜欢这个帖子 :-(

你也可以按顺序做cpuburn：

killall burnP6

当你想停止它们时：

&001

你也可以把burnP6 &乘以匹配你系统上的CPU核心数。

你可以多次运行该命令，每次都会占用不同的内核：

$ CORES=1
$ for i in `seq 1 $CORES`; do cat /dev/zero > /dev/null &
> done
[1] 8388

https://github.com/GaetanoCarlucci/CPULoadGenerator

相当简单和科学的解决方案。

这里你可以看到一个动态的例子，在CPU核心0上产生50%的负载：

你可以在其他核心上同时运行这个进程。

pxz是xz的并行实现。

pxz -9e /dev/zero --stdout >/dev/null应该可以做到，因为这对CPU来说是相当密集的。

我把+jlliagre和+ecabuk结合在一起。

#!/bin/bash
lc() {
    nowMs=$(date +%s)
    (
        pids=""
        cpus=${1:-1}
        seconds=${2:-60}
        echo "[$(date)] loading $cpus CPUs for $seconds seconds"
        echo "[$(date)] Expected completion: [$(date --date=@$(expr $nowMs + $seconds))]"
        trap 'for p in $pids; do kill $p; done' 0
        for ((i=0;i<cpus;i++)); do
            sha1sum /dev/zero &
            pids="$pids $!";
        done
        sleep $seconds
    )
    echo "[$(date)] Done"
}

lc $@

你可以使用：

fulload() { dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null & }; fulload; read; killall dd

重复一遍dd if=/dev/zero of=/dev/null，对你的CPU核心进行测试。

以下是我使用的方法，不需要额外安装任何东西。

比如说要从4个进程开始，

nproc | xargs seq | xargs -n1 -P4 md5sum /dev/zero

你可以通过上面的选项"-P “来改变进程的数量。

一个简单的命令行也能做到：

x="x" ; while : ; do x=$x$x ; echo -n "." ; done

我想在@jlliagre的评论中补充一下，但我的名气不够大。如果你要在多个服务器上使用这个代码，而且CPU数量会有不同，你可以使用下面的命令：

for ((i=1; i<=`nproc --all`; i++)); do while : ; do : ; done & done

这将利用你服务器上所有的核心，不管你有多少个核心。nproc 命令是 coreutils 的一部分，所以在大多数 Linux 安装中都应该有。