如何创建一个bash命令CPU秒杀如何创建一个bash命令CPU秒杀(How to create a

我想在Linux机器上创建一个接近100％的负载。 它的四核系统，我想会全速所有核心。 理想的情况下，CPU的负荷会持续指定的时间量，然后停止。 我希望有在bash一些技巧。 我想某种无限循环的。

Answer 1:

你也可以做

dd if=/dev/zero of=/dev/null

要运行更多的这些投入对更多内核的负载，尽量到餐桌吧：

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

在大括号重复命令多次，要产生（这里是4个线程）的线程数。 简单的进入严重的将停止它（只需确保没有其他的DD这个用户运行，或者您杀死它太）。

Answer 2:

我用应力为这种事情，你可以告诉它有多少个核，以最大程度的发挥..它允许强调内存和磁盘为好。

实施例强调2个核60秒

stress --cpu 2 --timeout 60

Answer 3:

我觉得这个是比较简单的。 打开终端，并键入以下命令，然后按Enter键。

yes > /dev/null &

要充分利用现代CPU，一条线是不够的，你可能需要重复的命令，用尽所有的CPU供电。

要结束这一切，只是把

killall yes

这个想法最初是发现在这里 ，虽然它的目的是为Mac用户，但这应该对* nix的正常工作。

Answer 4:

一个核心（不调用外部程序）：

while true; do true; done

两个核心：

while true; do /bin/true; done

后者不仅使这两个矿的去〜50％，但...

这一次将俩去到100％：

while true; do echo; done

Answer 5:

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

你的Linux系统上轻松安装

./configure
make
make install

并启动它在一个简单的命令行

stress -c 40

强调所有的CPU（但是你有），每运行一个复杂的40个线程sqrt在ramdomly生成的数字计算。

你甚至可以定义程序的超时

stress -c 40 -timeout 10s

不同于与所提出的方案dd命令，它与基本涉及IO ，因此并没有真正超载您的系统，因为处理数据。

应力程序真正重载系统，因为处理计算。

Answer 6:

虽然我迟到了，这个帖子是在谷歌搜索“产生在linux负荷”顶部结果中。

标记为溶液中的结果可以被用于产生一个系统负载，我宁愿使用sha1sum /dev/zero强加一个CPU核心上的负载。

我们的想法是从无限数据流计算哈希总和（如的/ dev /零的/ dev / urandom的，...），这个过程将尝试最大程度的发挥一个CPU核心，直到该进程被中止。 要生成更多的核的负载，多个命令可以一起输送。

例如。 产生2芯负载： sha1sum /dev/zero | sha1sum /dev/zero sha1sum /dev/zero | sha1sum /dev/zero

Answer 7:

加载3芯5秒：

seq 3 | xargs -P0 -n1 timeout 5 yes > /dev/null

这导致从众多的write（）系统调用内核高（SYS）负载。

如果你喜欢大多用户级CPU负载：

seq 3 | xargs -P0 -n1 timeout 5 md5sum /dev/zero

如果你只是想负荷继续下去，直到你按下Ctrl-C：

seq 3 | xargs -P0 -n1 md5sum /dev/zero

Answer 8:

我会分裂的事情在2个脚本：

infinite_loop.bash：

#!/bin/bash
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

cpu_spike.bash：

#!/bin/bash
# Either use environment variables for NUM_CPU and DURATION, or define them here
for i in `seq ${NUM_CPU}` : do
    # Put an infinite loop on each CPU
    infinite_loop.bash &
done

# Wait DURATION seconds then stop the loops and quit
sleep ${DURATION}
killall infinite_loop.bash

Answer 9:

:(){ :|:& };:

这fork炸弹会造成严重破坏的CPU，并可能会崩溃您的计算机。

Answer 10:

一个无限循环的想法，我也有。 一个奇特的外观的一个是：

while :; do :; done

（ :是一样的true ，什么也不做，用零退出）

你可以调用，在一个子shell，并在后台运行。 这样做$num_cores时间应该够了。 睡眠所需的时间，你可以把他们都杀掉，你得到的PID jobs -p （提示： xargs ）

Answer 11:

cat /dev/urandom > /dev/null

Answer 12:

#!/bin/bash
duration=120    # seconds
instances=4     # cpus
endtime=$(($(date +%s) + $duration))
for ((i=0; i<instances; i++))
do
    while (($(date +%s) < $endtime)); do :; done &
done

Answer 13:

我用bc （ 二进制计算器 ），要求他们为PI用大很多小数。

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

与（在Linux下）NUMCPU：

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

这种方法是强劲，但似乎系统友好的 ，因为我从来没有使用这个崩溃的系统。

Answer 14:

#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done

Answer 15:

我通过互联网去寻找类似的东西，发现这非常方便CPU锤脚本。

#!/bin/sh

# unixfoo.blogspot.com

if [ $1 ]; then
    NUM_PROC=$1
else
    NUM_PROC=10
fi

for i in `seq 0 $((NUM_PROC-1))`; do
    awk 'BEGIN {for(i=0;i<10000;i++)for(j=0;j<10000;j++);}' &
done

Answer 16:

使用这里提到的例子，但也从IRC帮助，我开发了我自己的CPU压力测试脚本。 它采用每个线程一个子shell和无限循环技术。 您还可以指定线程的数量和时间交互量。

#!/bin/bash
# Simple CPU stress test script

# Read the user's input
echo -n "Number of CPU threads to test: "
read cpu_threads
echo -n "Duration of the test (in seconds): "
read cpu_time

# Run an endless loop on each thread to generate 100% CPU
echo -e "\E[32mStressing ${cpu_threads} threads for ${cpu_time} seconds...\E[37m"
for i in $(seq ${cpu_threads}); do
    let thread=${i}-1
    (taskset -cp ${thread} $BASHPID; while true; do true; done) &
done

# Once the time runs out, kill all of the loops
sleep ${cpu_time}
echo -e "\E[32mStressing complete.\E[37m"
kill 0

Answer 17:

这里利用的理念，创建了一套时间后自动退出的代码，也不必终止进程 -

#!/bin/bash
echo "Usage : ./killproc_ds.sh 6 60  (6 threads for 60 secs)"

# Define variables
NUM_PROCS=${1:-6} #How much scaling you want to do
duration=${2:-20}    # seconds

function infinite_loop {
endtime=$(($(date +%s) + $duration))
while (($(date +%s) < $endtime)); do
    #echo $(date +%s)
    echo $((13**99)) 1>/dev/null 2>&1
    $(dd if=/dev/urandom count=10000 status=none| bzip2 -9 >> /dev/null) 2>&1 >&/dev/null
done
echo "Done Stressing the system - for thread $1"
}


echo Running for duration $duration secs, spawning $NUM_PROCS threads in background
for i in `seq ${NUM_PROCS}` ;
do
# Put an infinite loop
    infinite_loop $i  &
done

Answer 18:

这确实一招对我来说：

bash -c 'for (( I=100000000000000000000 ; I>=0 ; I++ )) ; do echo $(( I+I*I )) & echo $(( I*I-I )) & echo $(( I-I*I*I )) & echo $(( I+I*I*I )) ; done' &>/dev/null

它使用什么，除了庆典。

Answer 19:

为了提高丁巳的答案，并提供更多的东西可插拔（因为我需要类似的东西）。 我已经写了使用dd负载了概念如下：d

它会检查当前的核心，并创造许多DD线程。 起点和终点与进入核心负载

#!/bin/bash

load_dd() {
    dd if=/dev/zero of=/dev/null
}

fulload() {
    unset LOAD_ME_UP_SCOTTY
    export cores="$(grep proc /proc/cpuinfo -c)"
    for i in $( seq 1 $( expr $cores - 1 ) )
      do
    export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd | ')"
  done
        export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd &')"
    eval ${LOAD_ME_UP_SCOTTY}
}

echo press return to begin and stop fullload of cores
  read
  fulload
  read
  killall -9 dd

Answer 20:

我结合一些问题的答案，并添加了一种压力扩展到所有可用的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

Answer 21:

丁巳的dd if=/dev/zero of=/dev/null肯定是正确的，但还值得一提的是验证杏的CPU，以100％的使用率。 你可以这样做

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

这个请求由每个进程的CPU使用情况的一分钟平均的输出为ps，然后对其求和与AWK。 虽然这是一个平均1分钟，PS是足够聪明，知道如果一个进程只存在了几秒钟，并相应地调整时间窗口。 因此，你可以使用此命令立即看到结果。

Answer 22:

只需粘贴这个坏小子到任何服务器上运行Linux的SSH或控制台。 您可以手动终止这些进程，但我只是关机时，我做的服务器，速度更快。

编辑：我已经更新了这个剧本到现在已经有一个计时器功能，这样就没有必要杀死进程。

read -p "Please enter the number of minutes for test >" MINTEST && [[ $MINTEST == ?(-)+([0-9]) ]]; NCPU="$(grep -c ^processor /proc/cpuinfo)";  ((endtime=$(date +%s) + ($MINTEST*60))); NCPU=$((NCPU-1)); for ((i=1; i<=$NCPU; i++)); do while (($(date +%s) < $endtime)); do : ; done & done

文章来源: How to create a CPU spike with a bash command