我结合了一些答案，并添加了一种将压力扩展到所有可用cpu的方法:

#!/bin/bash

function infinite_loop { 
    while [ 1 ] ; do
        # Force some computation even if it is useless to actually work the CPU
        echo $((13**99)) 1>/dev/null 2>&1
    done
}

# Either use environment variables for DURATION, or define them here
NUM_CPU=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)
PIDS=()
for i in `seq ${NUM_CPU}` ;
do
# Put an infinite loop on each CPU
    infinite_loop &
    PIDS+=("$!")
done

# Wait DURATION seconds then stop the loops and quit
sleep ${DURATION}

# Parent kills its children 
for pid in "${PIDS[@]}"
do
    kill $pid
done

你可以在这里下载一个程序

在Linux系统上轻松安装

./configure
make
make install

并在简单的命令行中启动它

stress -c 40

让所有的cpu(不管你有多少)都有40个线程，每个线程在随机生成的数字上运行复杂的根号计算。

您甚至可以定义程序的超时时间

stress -c 40 -timeout 10s

与提议的dd命令解决方案不同，dd命令主要处理IO，因此不会因为处理数据而真正使系统过载。

压力程序会使系统超负荷因为要处理计算。

我用过bc(二进制计算器)，用一大堆小数求圆周率。

$ for ((i=0;i<$NUMCPU;i++));do
    echo 'scale=100000;pi=4*a(1);0' | bc -l &
    done ;\
    sleep 4; \
    killall bc

NUMCPU (Linux下):

$ NUMCPU=$(grep $'^processor\t*:' /proc/cpuinfo |wc -l)

这个方法很强大，但似乎对系统友好，因为我从未使用过这个方法导致系统崩溃。

增加负载或消耗CPU 100%或X%

sha1sum /dev/zero &

在某些系统上，这将增加X%插槽的负载，在这种情况下，你必须多次运行相同的命令。

然后你可以通过输入命令查看CPU使用情况

top

释放负荷

killall sha1sum

Dimba的dd if=/dev/zero of=/dev/null绝对是正确的，但值得一提的是验证cpu使用率最大化到100%。你可以用

ps -axro pcpu | awk '{sum+=$1} END {print sum}'

它要求每个进程的1分钟平均cpu使用量的ps输出，然后将它们与awk相加。虽然它是1分钟的平均值，但ps足够聪明，可以知道一个进程是否只运行了几秒钟，并相应地调整时间窗口。因此，您可以使用此命令立即查看结果。

awk是一种编写长时间运行的CPU循环的好方法，它不会产生大量内存流量或系统调用，也不会使用大量内存或污染缓存，从而使其他内核的速度降低到最低程度。(如果您使用简单的CPU-stress方法进行安装，则stress或stress-ng也可以做到这一点。)

awk 'BEGIN{for(i=0;i<100000000;i++){}}'   # about 3 seconds on 4GHz Skylake

这是一个计数循环，所以你可以让它在有限时间后自行退出。(Awk使用FP数字，因此由于舍入，i++可能无法达到2^54这样的限制，但这比几秒到几分钟所需的要大得多。)

要并行运行它，可以使用shell循环在后台启动n次

for i in {1..6};do awk 'BEGIN{for(i=0;i<100000000;i++){}}' & done

######     6 threads                      each running about 3 seconds

$ for i in {1..6};do awk 'BEGIN{for(i=0;i<100000000;i++){}}' & done
[1] 3047561
[2] 3047562
[3] 3047563
[4] 3047564
[5] 3047565
[6] 3047566
$              # this shell is usable.
(wait a while before pressing return)
[1]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[2]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[3]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[4]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[5]-  Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[6]+  Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
$

我使用perf来查看它对CPU的负载:它每个时钟周期运行2.6条指令，所以它对共享同一个物理内核的超线程不是最友好的。但是它的缓存占用非常小，即使在L1d缓存中也可以忽略不计。strace将显示它在退出之前不进行系统调用。

$ perf stat -r5 -d awk 'BEGIN{for(i=0;i<100000000;i++){}}'

 Performance counter stats for 'awk BEGIN{for(i=0;i<100000000;i++){}}' (5 runs):

          3,277.56 msec task-clock                #    0.997 CPUs utilized            ( +-  0.24% )
                 7      context-switches          #    2.130 /sec                     ( +- 12.29% )
                 1      cpu-migrations            #    0.304 /sec                     ( +- 40.00% )
               180      page-faults               #   54.765 /sec                     ( +-  0.18% )
    13,708,412,234      cycles                    #    4.171 GHz                      ( +-  0.18% )  (62.29%)
    35,786,486,833      instructions              #    2.61  insn per cycle           ( +-  0.03% )  (74.92%)
     9,696,339,695      branches                  #    2.950 G/sec                    ( +-  0.02% )  (74.99%)
           340,155      branch-misses             #    0.00% of all branches          ( +-122.42% )  (75.08%)
    12,108,293,527      L1-dcache-loads           #    3.684 G/sec                    ( +-  0.04% )  (75.10%)
           217,064      L1-dcache-load-misses     #    0.00% of all L1-dcache accesses  ( +- 17.23% )  (75.10%)
            48,695      LLC-loads                 #   14.816 K/sec                    ( +- 31.69% )  (49.90%)
             5,966      LLC-load-misses           #   13.45% of all LL-cache accesses  ( +- 31.45% )  (49.81%)

           3.28711 +- 0.00772 seconds time elapsed  ( +-  0.23% )

对x86 CPU上的其他超线程最“友好”的是这样的C程序，它只是在循环中运行暂停指令。(或可移植地，Rust程序运行std::hint::spin_loop。)至于操作系统的进程调度器，它停留在用户空间(与yield()系统调用不同)，但在硬件上，它不会占用太多资源，让其他逻辑核心拥有多个周期的前端。

#include <immintrin.h>
int main(){                    // use atoi(argv[1])*10000ULL as a loop count if you want.
    while(1) _mm_pause();
}