如何从命令行获取Linux中的CPU /内核数？

我有这个脚本，但是我不知道如何获取打印输出中的最后一个元素：

cat /proc/cpuinfo | awk '/^processor/{print $3}'

最后一个元素应该是CPU数量减1。

grep -c ^processor /proc/cpuinfo     

将计算以“处理器”开头的行数 /proc/cpuinfo

对于具有超线程的系统，可以使用

grep ^cpu\\scores /proc/cpuinfo | uniq |  awk '{print $4}' 

应该返回（例如）8（而上面的命令将返回16）

处理内容/proc/cpuinfo是不必要的巴洛克式。使用nproc，它是coreutils的一部分，因此大多数Linux安装中都应该可以使用它。

命令nproc显示当前进程可用的处理单元数，该数量可能少于在线处理器的数量。

要查找所有已安装内核/处理器的数量，请使用 nproc --all

在我的8核计算机上：

$ nproc --all
8

我找到的最可移植的解决方案是getconf命令：

getconf _NPROCESSORS_ONLN

这在Linux和Mac OS X上都可以使用。相对于其他方法，此方法的另一个好处是getconf已经存在了很长时间。我必须在其上进行开发的某些较旧的Linux机器没有nprocor lscpu命令，但是它们有getconf。

^{编者注：虽然该getconf 实用程序是POSIX要求的，但特定的_NPROCESSORS_ONLN和_NPROCESSORS_CONF 值不是。也就是说，如上所述，它们可以在Linux平台和macOS上运行。在FreeBSD / PC-BSD上，您必须省略开头_。}

前言：

• 在这个问题/proc/cpuinfo为基础的答案是，他们这是意味着解析信息的人的消费，从而缺乏专为机解析一个稳定的格式：输出格式可以跨平台和运行时的条件不同; 使用lscpu -p在Linux（和sysctl在MacOS）绕过这个问题。

• getconf _NPROCESSORS_ONLN/ getconf NPROCESSORS_ONLN不能区分逻辑 CPU 和物理 CPU。

这是一个sh（符合POSIX的）代码段，可在Linux和macOS上运行，用于确定在线逻辑或物理 CPU的数量；有关详细信息，请参见注释。

用途lscpu用于Linux和sysctlMacOS的。

术语注释：CPU是指OS所见的最小处理单元。每个非超线程内核对应于1个CPU，而超线程内核包含1个以上（通常为2个）-逻辑-CPU。
Linux使用以下分类法^[1]，从最小单位开始：
CPU < 核心 < 套接字 < book < 节点
，每个级别包含1个或多个下一个较低级别的实例。

#!/bin/sh

# macOS:           Use `sysctl -n hw.*cpu_max`, which returns the values of 
#                  interest directly.
#                  CAVEAT: Using the "_max" key suffixes means that the *maximum*
#                          available number of CPUs is reported, whereas the
#                          current power-management mode could make *fewer* CPUs 
#                          available; dropping the "_max" suffix would report the
#                          number of *currently* available ones; see [1] below.
#
# Linux:           Parse output from `lscpu -p`, where each output line represents
#                  a distinct (logical) CPU.
#                  Note: Newer versions of `lscpu` support more flexible output
#                        formats, but we stick with the parseable legacy format 
#                        generated by `-p` to support older distros, too.
#                        `-p` reports *online* CPUs only - i.e., on hot-pluggable 
#                        systems, currently disabled (offline) CPUs are NOT
#                        reported.

# Number of LOGICAL CPUs (includes those reported by hyper-threading cores)
  # Linux: Simply count the number of (non-comment) output lines from `lscpu -p`, 
  # which tells us the number of *logical* CPUs.
logicalCpuCount=$([ $(uname) = 'Darwin' ] && 
                       sysctl -n hw.logicalcpu_max || 
                       lscpu -p | egrep -v '^#' | wc -l)

# Number of PHYSICAL CPUs (cores).
  # Linux: The 2nd column contains the core ID, with each core ID having 1 or
  #        - in the case of hyperthreading - more logical CPUs.
  #        Counting the *unique* cores across lines tells us the
  #        number of *physical* CPUs (cores).
physicalCpuCount=$([ $(uname) = 'Darwin' ] && 
                       sysctl -n hw.physicalcpu_max ||
                       lscpu -p | egrep -v '^#' | sort -u -t, -k 2,4 | wc -l)

# Print the values.
cat <<EOF
# of logical CPUs:  $logicalCpuCount
# of physical CPUS: $physicalCpuCount
EOF

[1] macOS sysctl (3)文档

请注意，除macOS之外的BSD衍生系统（例如FreeBSD）仅支持hw.ncpufor 的密钥sysctl，而macOS上已弃用该密钥；我不清楚哪个新键hw.npu对应于：hw.(logical|physical)cpu_[max]。

^{@teambob的提示，以帮助更正physical-CPU-count lscpu命令。}

警告：lscpu -p输出不包含“ book”列（该man页面将“ books”作为分类层次结构中套接字和节点之间的实体提到）。如果“书”在给定的Linux系统上起作用（有人知道何时何地？），则physical-CPU-count命令可能会低于 -report（这是基于以下假设：lscpu报告的ID 在更高版本中不唯一）级实体；例如：来自2个不同套接字的2个不同核心可能具有相同的ID）。

如果将上面的代码另存为shell脚本cpus，使其可以执行，chmod +x cpus然后将其放置在的文件夹中$PATH，则会看到以下输出：

$ cpus
logical  4
physical 4

^{[1] Xaekai阐明了一本书是什么：“一本书是一个模块，其中装有带有CPU插槽，RAM插槽，沿边缘的IO连接以及用于冷却系统集成的挂钩的电路板。它们在IBM大型机中使用。 。更多信息：http : //ewh.ieee.org/soc/cpmt/presentations/cpmt0810a.pdf “}

lscpu 以人类可读的格式收集CPU架构信息表/ proc / cpuinfon：

# lscpu


Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                8
On-line CPU(s) list:   0-7
Thread(s) per core:    1
Core(s) per socket:    4
CPU socket(s):         2
NUMA node(s):          1
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 15
Stepping:              7
CPU MHz:               1866.669
BogoMIPS:              3732.83
Virtualization:        VT-x
L1d cache:             32K
L1i cache:             32K
L2 cache:              4096K
NUMA node0 CPU(s):     0-7

另请参阅/unix/468766/understanding-output-of-lscpu。

这对我有用。tail -nX只允许您抓取最后的X行。

cat /proc/cpuinfo | awk '/^processor/{print $3}' | tail -1

如果您具有超线程，那么这应该可以获取物理内核的数量。

grep "^core id" /proc/cpuinfo | sort -u | wc -l

对于物理核心总数：

grep '^core id' /proc/cpuinfo |sort -u|wc -l

在多插槽计算机上（或始终），将以上结果乘以插槽数：

echo $(($(grep "^physical id" /proc/cpuinfo | awk '{print $4}' | sort -un | tail -1)+1))

@ mklement0在下面使用lscpu有一个很好的答案。我在评论中写了一个更简洁的版本

您也可以使用Python！要获取物理核心数：

$ python -c "import psutil; print(psutil.cpu_count(logical=False))"
4

要获取超线程核心数：

$ python -c "import psutil; print(psutil.cpu_count(logical=True))"
8

适用于Linux，MacOS，Windows的跨平台解决方案：

CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu || echo "$NUMBER_OF_PROCESSORS")

这是我用来计算Linux上在线物理核心数量的方法：

lscpu --online --parse=Core,Socket | grep --invert-match '^#' | sort --unique | wc --lines

或简而言之：

lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l

示例（1个插槽）：

> lscpu
...
CPU(s):                28
Thread(s) per core:    2
Core(s) per socket:    14
Socket(s):             1
....
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
14

示例（2个插槽）：

> lscpu
...
CPU(s):                56
Thread(s) per core:    2
Core(s) per socket:    14
Socket(s):             2
...
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
28

示例（4个插槽）：

> lscpu
...
CPU(s):                64
Thread(s) per core:    2
Core(s) per socket:    8
Socket(s):             4
...
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
32

使用getconf确实是最可移植的方法，但是变量在BSD和Linux中使用不同的名称来进行getconf，因此，您必须对这两者进行测试，如本要点所示：https : //gist.github.com/jj1bdx/5746298 （还包括使用ksh的Solaris修复程序）

我个人使用：

$ getconf _NPROCESSORS_ONLN 2>/dev/null || getconf NPROCESSORS_ONLN 2>/dev/null || echo 1

而且，如果您希望在python中使用此功能，则可以通过导入os模块来使用syscall getconf使用：

$ python -c 'import os; print os.sysconf(os.sysconf_names["SC_NPROCESSORS_ONLN"]);'

至于nproc，它是GNU Coreutils的一部分，因此默认情况下在BSD中不可用。在其他一些方法之后，它也使用sysconf（）。

如果要这样做，使其可以在linux和OS X上运行，则可以执行以下操作：

CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)

这很简单。只需使用以下命令：

lscpu

您可以使用以下方法之一来确定物理 CPU内核的数量。

• 计算唯一核心ID的数量（约等于grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l）。

  awk '/^core id\t/ {cores[$NF]++} END {print length(cores)}' /proc/cpuinfo

• 将“每个插槽的核心数”乘以插槽数。

  lscpu | awk '/^Core\(s\) per socket:/ {cores=$NF}; /^Socket\(s\):/ {sockets=$NF}; END{print cores*sockets}'

• 计算Linux内核使用的唯一逻辑CPU的数量。该-p选项生成的输出易于解析，并且与的早期版本兼容lscpu。

  lscpu -p | awk -F, '$0 !~ /^#/ {cores[$1]++} END {print length(cores)}'

仅重申其他人的说法，有许多相关的属性。

要确定可用的处理器数量：

getconf _NPROCESSORS_ONLN
grep -cP '^processor\t' /proc/cpuinfo

确定可用的处理单元数（不一定与核心数相同）。这是超线程感知的。

nproc

我不想走得太远，但是您也可以通过确定确定已配置处理器的数量（而不是简单的可用/在线处理器）getconf _NPROCESSORS_CONF。要确定CPU的总数（离线和在线），您需要解析的输出lscpu -ap。

我还以为cat /proc/cpuinfo会给出正确的答案，但是最近我看到我的ARM四核Cortex A53系统仅显示一个核。似乎/ proc / cpuinfo仅显示活动的核心，而：

cat /sys/devices/system/cpu/present

可以更好地衡量其中的内容。你也可以

cat /sys/devices/system/cpu/online

查看哪些核心在线，以及

cat /sys/devices/system/cpu/offline

查看哪些核心处于脱机状态。的online，offline和presentsysfs的条目返回CPU的索引，所以返回值0只是手段核心0，而的一个返回值1-3的装置芯1,2，和3。

参见https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-devices-system-cpu

以下内容将为您提供超线程和非超线程系统上“实际”内核的数量。至少在我所有的测试中都有效。

awk -F: '/^physical/ && !ID[$2] { P++; ID[$2]=1 }; /^cpu cores/ { CORES=$2 };  END { print CORES*P }' /proc/cpuinfo

不是我的网页，但是来自http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902的此命令在centos上对我很好。即使启用了超线程，它也会显示实际的cpus。

cat /proc/cpuinfo | egrep "core id|physical id" | tr -d "\n" | sed s/physical/\\nphysical/g | grep -v ^$ | sort | uniq | wc -l

使用awk对“物理ID”方法的“核心ID”计数，如果“核心ID”不可用（如树莓），则回退到“处理器”计数

echo $(awk '{ if ($0~/^physical id/) { p=$NF }; if ($0~/^core id/) { cores[p$NF]=p$NF }; if ($0~/processor/) { cpu++ } } END { for (key in cores) { n++ } } END { if (n) {print n} else {print cpu} }' /proc/cpuinfo)

cat /proc/cpuinfo | grep processor

这很好。当我尝试第一个答案时，我得到3个CPU作为输出。我知道我的系统上有4个CPU，所以我只grep为处理器做了一个，输出看起来像这样：

[root@theservername ~]# cat /proc/cpuinfo | grep processor
processor       : 0
processor       : 1
processor       : 2
processor       : 3

 dmidecode  | grep -i cpu | grep Version

给我

版本：Intel（R）Xeon（R）CPU E5-2667 v4 @ 3.20GHz

版本：Intel（R）Xeon（R）CPU E5-2667 v4 @ 3.20GHz

这是正确的插口计数-仰视E5-2667告诉我，每个插座都有8 cores，所以乘法和结了16 cores跨越2 sockets。

在哪里lscpu给我20 CPUs-这是完全不正确的-不知道为什么。（相同的cat /proc/cpu最终以20。

更快，无需叉

这项工作几乎全部 贝壳。

ncore=0
while read line ;do
    [ "$line" ] && [ -z "${line%processor*}" ] && ncore=$((ncore+1))
  done </proc/cpuinfo
echo $ncore
4

为了保持兼容 贝壳， 短跑， 忙箱等，我用ncore=$((ncore+1))代替((ncore++))。

重击 版

ncore=0
while read -a line ;do
    [ "$line" = "processor" ] && ((ncore++))
  done </proc/cpuinfo
echo $ncore
4

如果可以使用Python没问题，则numexpr模块具有以下功能：

In [5]: import numexpr as ne

In [6]: ne.detect_number_of_cores()
Out[6]: 8

还有这个：

In [7]: ne.ncores
Out[7]: 8

要从命令提示符处查询此信息，请使用：

# runs whatever valid Python code given as a string with `-c` option
$ python -c "import numexpr as ne; print(ne.ncores)"
8

或者只是可以从multiprocessing.cpu_count()函数中获取此信息

$ python -c "import multiprocessing; print(multiprocessing.cpu_count())"

甚至更简单地使用 os.cpu_count()

$ python -c "import os; print(os.cpu_count())"

如果您只想计算物理核数，则此命令为我完成了此工作。

lscpu -e | tail -n +2 | tr -s " " | cut -d " " -f 4 | sort | uniq | wc -w

相当基础，但似乎要计算实际的物理核心，而忽略逻辑计数

Python 3还提供了一些简单的方法来获取它：

$ python3 -c "import os; print(os.cpu_count());"

4

$ python3 -c "import multiprocessing; print(multiprocessing.cpu_count())"

4

使用以下查询获取核心详细信息

[oracle@orahost](TESTDB)$ grep -c ^processor /proc/cpuinfo
8

摘要：要获取物理CPU，请执行以下操作：

grep 'core id' /proc/cpuinfo | sort -u

要获取物理和逻辑 CPU，请执行以下操作：

grep -c ^processor /proc/cpuinfo

/proc <<这是您需要的有关流程和流程的任何信息的黄金来源

/proc/cpuinfo <<是任何CPU信息的黄金来源。