问题描述：

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

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

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

解决方案 1：

处理的内容/proc/cpuinfo是不必要的复杂化。使用nproc，它是 coreutils 的一部分，因此它应该在大多数 Linux 安装中可用。

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

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

在我的 8 核机器上：

$ nproc --all
8

解决方案 2：

grep -c ^processor /proc/cpuinfo

将计算以“processor”开头的行数/proc/cpuinfo

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

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

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

解决方案 3：

我发现最便携的解决方案是getconf命令：

getconf _NPROCESSORS_ONLN

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

编者注：虽然该getconf 实用程序符合 POSIX 规定，但具体_NPROCESSORS_ONLN和_NPROCESSORS_CONF 值却不符合。也就是说，如前所述，它们适用于 Linux 平台以及 macOS；在 FreeBSD/PC-BSD 上，必须省略前导的_。

解决方案 4：

前言：

• 基于 的答案的问题/proc/cpuinfo在于，它们解析的信息是供人类使用，因此缺乏为机器解析设计的稳定格式：输出格式可能因平台和运行时条件而异；在 Linux （和macOS ）上使用可以lscpu -p`sysctl`绕过该问题。

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

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

适用lscpu于 Linux 和sysctlmacOS。

术语说明：CPU是指操作系统所见的最小处理单元。非超线程核心每个对应 1 个 CPU，而超线程核心包含 1 个以上（通常为 2 个）逻辑 CPU。Linux

使用以下分类法[1]，从最小单元开始：

CPU <核心<插槽<书<节点

，每个级别包含下一较低级别的 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] macOSsysctl (3)文档

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

向@teambob 致敬，感谢他帮助修正了 physical-CPU-countlscpu命令。

警告：lscpu -p输出不包括“书籍”列（man页面提到“书籍”是分类层次结构中插槽和节点之间的实体）。如果“书籍”在给定的 Linux 系统上运行（有人知道何时以及如何运行吗？），则 physical-CPU-count 命令可能会报告不足（这是基于报告 ID 在更高级别实体lscpu中不唯一的假设；例如：来自 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 ”

解决方案 5：

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

# 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

另请参阅https://unix.stackexchange.com/questions/468766/understanding-output-of-lscpu。

解决方案 6：

这是我用来计算 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

解决方案 7：

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

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

获取超线程核心的数量：

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

解决方案 8：

对于物理核心的总数：

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 给出了相当不错的答案。我在评论中写了一个更简洁的版本

解决方案 9：

使用 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 模块来使用 getconf 使用的 syscall：

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

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

解决方案 10：

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

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

解决方案 11：

如果您想这样做以使其在 Linux 和 OS X 上运行，您可以执行以下操作：

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

解决方案 12：

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

lscpu

解决方案 13：

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

• 计算唯一核心 ID 的数量（大致相当于grep -P '^core id ' /proc/cpuinfo | sort -u | wc -l）。

awk '/^core id / {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    ' /proc/cpuinfo

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

nproc

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

解决方案 14：

上面的答案适用于大多数情况，但是如果你在docker容器环境中，并且你的容器受到限制CpusetCpus，那么你实际上无法通过上面的方法获取真实的cpu核心。

在这种情况下，您需要执行以下操作来获取真正的 CPU 核心：

grep -c 'cpu[0-9]' /proc/stat

解决方案 15：

如果有人感到好奇，以下是psutil.cpu_count(logical=False)在 Linux 上 Python 调用等效 shell 脚本所做的事情：

cat /sys/devices/system/cpu/cpu[0-9]*/topology/core_cpus_list | sort -u | wc -l

下面是一个稍长的版本，如果core_cpus_list不可用，则会回退到已弃用的thread_siblings_list文件中的信息（psutil 有此回退功能）：

cat /sys/devices/system/cpu/cpu[0-9]*/topology/{core_cpus_list,thread_siblings_list} | sort -u | wc -l

解决方案 16：

我也以为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

解决方案 17：

本主题中的大多数答案都与逻辑核心有关。

在 Ubuntu 18.x 上使用 BaSH，我发现这可以很好地确定物理CPU 的数量：

numcpu="$(lscpu | grep -i 'socket(s)' | awk '{print $(2)}')"

它应该可以在大多数 Linux 发行版上运行。

解决方案 18：

考虑到您的特定示例代码片段打印有关可用 CPU 核心的信息，例如

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

两种方法

根据最高 CPU 核心 ID 值得出总值

利用 CPU 核心具有序列号并存储在字段下这一事实processor。由于proc文件中存储的每个 CPU 核心的信息都按字段升序排列processor，因此您可以简单地抓取该序列的最后一个条目并观察字段中的数值，processor例如

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

注意：由于/proc/cpuinfo保存了与 CPU 数量相对应的条目数，processor字段初始值为 0，请不要忘记将最后一个 CPU 核心的值加 1。

$ last_cpu_core_id=$(/proc/cpuinfo | awk '/^processor/{print $3}' | tail -n 1)
$ echo $((last_cpu_core_id + 1))

计算输出的行数

这种方法与第一种方法不同，我们并不真正关心 CPU 核心 ID 的特定值，我们只是计算输出行数。计算时，过程通常从 1 开始，这简化了我们的解决方案。

使用grep

$ cat /proc/cpuinfo | grep processor | wc -l

或者，我们不一定记住processor字段本身，而是利用每个描述单个 CPU 核心详细信息的条目都由换行符分隔的事实，例如

cat /proc/cpuinfo | grep -v '^w' | wc -l

使用awk

cat /proc/cpuinfo | awk '($1 == "processor") {count++ } END { print count }'

解决方案 19：

下面应该会给出超线程和非超线程系统上“真实”核心的数量。至少在我所有的测试中它都有效。

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

解决方案 20：

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

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

解决方案 21：

使用 awk 按“物理 ID”方法计算“核心 ID”，如果“核心 ID”不可用，则回退到“处理器”计数（如 raspberry）

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)

解决方案 22：

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

解决方案 23：

如果您可以使用 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())"

解决方案 24：

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

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

解决方案 25：

如果您只想计算物理核心，这个命令就可以帮我计算。

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

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

解决方案 26：

Fravadona 的答案很棒而且正确，但它需要存在lscpu。由于它在我需要物理核心数量的系统中不存在，所以我试图想出一个仅依赖于proc/cpuinfo

`cat /proc/cpuinfo | grep -B2 'core id' | sed 's/siblings.*/'/ | tr -d '[:space:]' | sed 's/--/
/'g | sort -u | wc -l`

它工作得很好，但不幸的是它不像 Fravadona 的那么坚固，因为如果

• 内部字段的名称或顺序/proc/cpuinfo发生变化

• grep`--`用其他字符串替换其插入的行分隔符（当前）。

但除此之外，它运行完美：）

以下是对正在发生的一切的简要解释

grep -B2 'core id'

仅获取我们感兴趣的行（即“核心 id”和前两行）

sed 's/siblings.*/'/

删除“兄弟姐妹......”行

tr -d '[:space:]'

替换空格字符

sed 's/--/
/'g

将 grep 插入的 '--' 字符替换为换行符

sort -u

按“物理 ID，核心 ID”分组

wc -l

计算行数

作为一个完全的菜鸟，当这个方法奏效时，我对自己非常满意。我从来没有想过我能够将所需的行连接在一起，按“物理 ID”和“核心 ID”进行分组。这有点儿像黑客，但确实有效。

如果有哪位大师知道如何简化这个烂摊子，请告诉我。

解决方案 27：

在前面的众多答案中，还有一个答案。当 cgroup 可用时，可以使用它们。cpuset子系统提供活动 cpu 的列表。这可以在/sys/fs/cgroup中层次结构最顶层的 cgroup 中列出。例如：

$ cat /sys/fs/cgroup/cpuset/cpuset.effective_cpus
0-3

然后，需要解析后者以获取活动 CPU 的数量。此文件的内容是以逗号分隔的 CPU 集列表。

tr下面是一个使用将列表分解为单个表达式并使用sed将间隔转换为传递给的算术运算的示例expr：

#!/bin/sh

# For test purposes, the CPU sets are passed as parameters
#cpuset=`cat /sys/fs/cgroup/cpuset/cpuset.effective_cpus`
cpuset=$1

ncpu=0
for e in `echo $cpuset | tr ',' ' '`
do
  case $e in

    # CPU interval ==> Make an arithmetic operation
    *-*) op=`echo $e | sed -E 's/([0-9]+)-([0-9]+)/ - 
 + 1/'`;;

    # Single CPU number
    *) op=1;;

  esac

  ncpu=`expr $ncpu + $op`

done

echo $ncpu

以下是使用几种不同的 CPU 集执行的示例：

$ for cpuset in "0" "0,3" "0-3" "0-3,67" "0-3,67,70-75" "0,1-3,67,70-75"
> do
>   ncpu.sh $cpuset
> done
1
2
4
5
11
11

解决方案 28：

 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。

解决方案 29：

Python 3 也提供了几种简单的方法来获取它：

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

4

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

4

解决方案 30：

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

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

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

grep -c ^processor /proc/cpuinfo

/proc<<这是您需要的有关流程和

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