如何从命令行获取Linux中的CPU /核心数？-Java 学习之路

392

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

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

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

22 回答

11
对于物理核心的总数：
```
grep '^core id' /proc/cpuinfo |sort -u|wc -l
```
在多插槽机器上（或总是），将上面的结果乘以套接字的数量：
```
echo $(($(grep "^physical id" /proc/cpuinfo | awk '{print $4}' | sort -un | tail -1)+1))
```
使用lscpu，@ mklement0下面有一个很好的答案 . 我在评论中写了一个更简洁的版本
回复于 2024-04-26T03:22:58+08:00
6
我找到的最便携的解决方案是 getconf 命令：
```
getconf _NPROCESSORS_ONLN
```
这适用于Linux和Mac OS X.这比其他一些方法的另一个好处是getconf已经存在了很长时间 . 我必须进行开发的一些较旧的Linux机器没有可用的 nproc 或 lscpu 命令，但它们有 getconf .

编者注：虽然getconf实用程序是POSIX强制的，但特定的_NPROCESSORS_ONLN和_NPROCESSORS_CONF值不是 . 也就是说，如上所述，它们可以在Linux平台和macOS上运行;在FreeBSD / PC-BSD上，你必须省略前导_ .
回复于 2024-04-26T03:22:58+08:00
0
```
cat /proc/cpuinfo | awk '/^processor/{print $3}' | wc -l
```
或简单地说
```
grep -c ^processor /proc/cpuinfo
```
这将计算 /proc/cpuinfo 中以"processor"开头的行数

对于具有超线程的系统，您可以使用
```
grep ^cpu\\scores /proc/cpuinfo | uniq |  awk '{print $4}'
```
应该返回（例如） 8 （而上面的命令将返回 16 ）
回复于 2024-04-26T03:22:58+08:00
8
这对我有用 . tail -nX 允许您仅抓取最后的X行 .
```
cat /proc/cpuinfo | awk '/^processor/{print $3}' | tail -1
```
如果你有超线程，这应该可以用于获取 physical 核心的数量 .
```
grep "^core id" /proc/cpuinfo | sort -u | wc -l
```
回复于 2024-04-26T03:22:58+08:00

前言：

problem with the /proc/cpuinfo-based answers 是他们解析供人类消费的信息因此 lacks a stable format designed for machine parsing ：输出格式可能因平台和运行时条件而异; using lscpu -p on Linux (and sysctl on macOS) bypasses that problem .
getconf _NPROCESSORS_ONLN / getconf NPROCESSORS_ONLN 不区分逻辑CPU和物理CPU .

这是一个 sh （符合POSIX标准）的片段，可用于 Linux and macOS 以确定 number of - online - logical or physical CPUs ;请参阅评论了解详情 .

对于Linux使用 lscpu ，对于macOS使用 sysctl .

Terminology note ：CPU是指操作系统看到的最小处理单元 . 非超线程内核每个对应1个CPU，而超线程内核包含多于1个（通常为2个）逻辑CPU .
Linux使用以下分类法，从最小单位开始：CPU <core <socket <book <node，每个级别包含下一个较低级别的1个或多个实例 .
我的知识在这里有些不稳定 - 如果我错了，请告诉我 . 有谁知道"book"在这种情况下是什么？

#!/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) documentation

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

向@teambob提供帮助纠正physical-CPU-count lscpu命令的提示 .

Caveat ： lscpu -p 输出不包含"book"列（ man 页面提到"books"作为分类层次结构中套接字和节点之间的实体） . 如果"books"在给定的Linux系统上运行（有人知道何时以及如何？），则物理CPU计数命令可能报告不足（这是基于 lscpu 报告在更高的位置上非唯一的ID的假设 - 级别实体;例如：来自2个不同套接字的2个不同核心可以具有相同的ID） .

如果您将上面的代码保存为shell脚本 cpus ，使其可执行 chmod +x cpus 并将其放在 $PATH 的文件夹中，您将看到如下输出：

$ cpus
logical  4
physical 4

回复于 2024-04-26T03:22:58+08:00

0
您可以使用以下方法之一来确定 physical 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 确定配置的处理器数量（而不是简单的可用/在线处理器） . 要确定想要解析 lscpu -ap 输出的CPU的总数's (offline and online) you' .
回复于 2024-04-26T03:22:58+08:00
1
使用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中使用它，你可以使用syscall getconf通过导入os模块使用：
```
$ python -c 'import os; print os.sysconf(os.sysconf_names["SC_NPROCESSORS_ONLN"]);'
```
至于 nproc ，它是GNU Coreutils的一部分，因此默认情况下在BSD中不可用 . 它使用sysconf（）以及其他一些方法 .
回复于 2024-04-26T03:22:58+08:00
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 ，所以在 2 sockets 之间相乘并最终得到 16 cores .

哪里 lscpu 给我 20 CPUs - 这是完全错误的 - 不知道为什么 . （同样适用于 cat /proc/cpu - 以 20 结束 .
回复于 2024-04-26T03:22:58+08:00

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

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

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

回复于 2024-04-26T03:22:58+08:00

1
以下内容应该为您提供超线程和非超线程系统上的“真实”内核数量 . 至少它在我的所有测试中都有效 .
```
awk -F: '/^physical/ && !ID[$2] { P++; ID[$2]=1 }; /^cpu cores/ { CORES=$2 };  END { print CORES*P }' /proc/cpuinfo
```
回复于 2024-04-26T03:22:58+08:00

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

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

要获得超线程核心的数量：

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

回复于 2024-04-26T03:22:58+08:00

0
```
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
```
回复于 2024-04-26T03:22:58+08:00
2
处理 /proc/cpuinfo 的内容是不必要的巴洛克式 . 使用nproc这是coreutils的一部分，因此它应该可以在大多数Linux安装上使用 .

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

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

在我的8核机器上：
```
$ nproc --all
8
```
回复于 2024-04-26T03:22:58+08:00

201

如果你可以使用Python，那么numexpr module有一个函数：

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())"

回复于 2024-04-26T03:22:58+08:00

如果“核心ID”不可用（如覆盆子），则使用awk并使用“处理器”计数后退计算“物理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)

回复于 2024-04-26T03:22:58+08:00

483

更快，没有叉子

这项工作与almsost所有shell .

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

为了与shell，dash，busybox和其他人保持兼容，我使用了 ncore=$((ncore+1)) 而不是 ((ncore++)) .

bash版

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

回复于 2024-04-26T03:22:58+08:00

448

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

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

回复于 2024-04-26T03:22:58+08:00

6
如果你想这样做，它适用于Linux和OS X，你可以这样做：
```
CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)
```
回复于 2024-04-26T03:22:58+08:00
7
这个命令：
```
echo $(nproc)
```
应返回系统可用的数量或核心数
回复于 2024-04-26T03:22:58+08:00
1

不是我的网页，但http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902的这个命令对我来说非常适合我 . 即使启用了超线程，它也会显示实际的cpus .

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

回复于 2024-04-26T03:22:58+08:00

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

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

或简而言之：

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

回复于 2024-04-26T03:22:58+08:00

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

回复于 2024-04-26T03:22:58+08:00

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

22 回答

更快，没有叉子

bash版

相关问题