Linux 线程或者进程在固定的CPU上运行方法

男娘i 2022-12-13 14:03 279阅读 0赞

### [https://blog.csdn.net/wanxuexiang/article/details/108590490][https_blog.csdn.net_wanxuexiang_article_details_108590490] ###

## ##

### 文章目录 ###

*  [Linux 线程或者进程在固定的CPU上运行方法][Linux _CPU]
 *   *  [1 如何查看进程或者线程运行在哪个CPU上？][1 _CPU]
     *   *  [1.1 利用PS命令进行查看][1.1 _PS]
         *  [1.2 利用top命令进行查看][1.2 _top]
         *  [1.3 利用 proc信息进行查看][1.3 _ proc]
     *  [2 利用 API 将线程和进程在固定的一个或者几个CPU运行][2 _ API _CPU]
     *   *  [2.1 更改线程运行的CPU][2.1 _CPU]
         *   *  [2.1.1 pthread\_setaffinity\_np 接口][2.1.1 pthread_setaffinity_np]
             *  [2.1.2 代码][2.1.2]
         *  [2.2 将进程运行在固定的CPU][2.2 _CPU]
         *   *  [2.2.1 sched\_setaffinity 接口使用][2.2.1 sched_setaffinity]
             *  [2.2.2 代码][2.2.2]
         *  [2.3 cpu亲和性（affinity）][2.3 cpu_affinity]
         *  [2.4 taskset][]
         *  [2.5 man 手册][2.5 man]

# Linux 线程或者进程在固定的CPU上运行方法 #

## 1 如何查看进程或者线程运行在哪个CPU上？ ##

### 1.1 利用PS命令进行查看 ###

利用 `ps -eLF`可以查看 进程或者线程运行在哪个CPU上：

UID         PID   PPID    LWP  C NLWP    SZ   RSS PSR STIME TTY          TIME CMD

*  1

其中 `PSR` 项就是 进程运行的CPU编号。可以通过 `cat /proc/cpuinfo` CPU 的核数和信息

具体我们看一下：

# ps -eLF | grep thread
    UID      PID    PPID  LWP    C    NLWP SZ   RSS   PSR STIME TTY    TIME     CMD
    root     100538  97073 100538  0    3  5771   892   6 10:12 pts/2    00:00:00 ./thread
    root     100538  97073 100539  0    3  5771   892   2 10:12 pts/2    00:00:00 ./thread
    root     100538  97073 100540  0    3  5771   892   3 10:12 pts/2    00:00:00 ./thread
    root     100615  43262 100615  0    1  5384  1036   4 10:35 pts/1    00:00:00 grep --color=auto thread

*  1
 *  2
 *  3
 *  4
 *  5
 *  6

通过命令我们可查看，进程 thread 的主线程 和两个子线程分别运行在CPU 6 2 3 上（当前运行的CPU有8个核心数）

### 1.2 利用top命令进行查看 ###

运行`top -p 100538`之后 键入 1 出现多个CPU信息 键入 H之后显示该进程下的多个线程，键入F之后，用上下键选择 P = Last Used Cpu (SMP) 然后用 空格键 选中 会出现 \* 号 最后键入 q 就会显示该进程和线程的所在的CPU

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbnh1ZXhpYW5n_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbnh1ZXhpYW5n_size_16_color_FFFFFF_t_70_pic_center 1]

### 1.3 利用 proc信息进行查看 ###

找到thread 对应的进程号

pidof thread
    100538

*  1
 *  2

进入 100538 下

cd /proc/100538/ 
    cd task
    cd 100538 
    cat stat

*  1
 *  2
 *  3
 *  4

可以查看信息

100538 (thread) S 97073 100538 97073 34818 100538 1077936128 90 0 0 0 0 23 0 0 20 0 3 0 231505018 23638016 223 18446744073709551615 94013987737600 94013987740192 140734159583136 0 0 0 0 0 0 1 0 0 17 6 0 0 0 0 0 94013989838224 94013989838864 94014014717952 140734159590686 140734159590695 140734159590695 140734159593455 0

*  1

可以对照 proc 下stat各个字段的含义（自行查阅资料） 找到该线程所在CPU的字段  
即：  
![在这里插入图片描述][20200914232804886.jpg_pic_center]

类似可以查看另外两个线程状态信息

root@wan:/proc/100538/task# cat 100539/stat
    100539 (thread) S 97073 100538 97073 34818 100538 1077936192 2 0 0 0 0 59 0 0 20 0 3 0 231505018 23638016 223 18446744073709551615 94013987737600 94013987740192 140734159583136 0 0 0 0 0 0 1 0 0 -1 6 0 0 0 0 0 94013989838224 94013989838864 94014014717952 140734159590686 140734159590695 140734159590695 140734159593455 0

*  1
 *  2

root@wan:/proc/100538/task# cat 100540/stat
    100540 (thread) S 97073 100538 97073 34818 100538 1077936192 0 0 0 0 2 59 0 0 20 0 3 0 231505018 23638016 223 18446744073709551615 94013987737600 94013987740192 140734159583136 0 0 0 0 0 0 1 0 0 -1 3 0 0 0 0 0 94013989838224 94013989838864 94014014717952 140734159590686 140734159590695 140734159590695 140734159593455 0

*  1
 *  2

## 2 利用 API 将线程和进程在固定的一个或者几个CPU运行 ##

### 2.1 更改线程运行的CPU ###

2.1.1 pthread\_setaffinity\_np 接口

root@wan:/wan# man pthread_setaffinity_np
    PTHREAD_SETAFFINITY_NP(3)                           Linux Programmer's Manual                          PTHREAD_SETAFFINITY_NP(3)
    
    NAME
           pthread_setaffinity_np, pthread_getaffinity_np - set/get CPU affinity of a thread
    
    SYNOPSIS
           #define _GNU_SOURCE             /* See feature_test_macros(7) */
           #include <pthread.h>
    
           int pthread_setaffinity_np(pthread_t thread, size_t cpusetsize,
                                      const cpu_set_t *cpuset);
           int pthread_getaffinity_np(pthread_t thread, size_t cpusetsize,
                                      cpu_set_t *cpuset);
    
           Compile and link with -pthread.
    
    DESCRIPTION
           The  pthread_setaffinity_np()  function  sets  the  CPU  affinity  mask of the thread thread to the CPU set pointed to by
           cpuset.  If the call is successful, and the thread is not currently running on one of the CPUs  in  cpuset,  then  it  is
           migrated to one of those CPUs.
    
           The  pthread_getaffinity_np()  function  returns  the  CPU affinity mask of the thread thread in the buffer pointed to by
           cpuset.
    
           For more details on CPU affinity masks, see sched_setaffinity(2).  For a description of a set of macros that can be  used
           to manipulate and inspect CPU sets, see CPU_SET(3).
    
           The  argument  cpusetsize is the length (in bytes) of the buffer pointed to by cpuset.  Typically, this argument would be
           specified as sizeof(cpu_set_t).  (It may be some other value, if using the macros described in CPU_SET(3) for dynamically
           allocating a CPU set.)
    
    RETURN VALUE
           On success, these functions return 0; on error, they return a nonzero error number.
    
    ERRORS
           EFAULT A supplied memory address was invalid.
    
           EINVAL (pthread_setaffinity_np())  The affinity bit mask mask contains no processors that are currently physically on the
                  system and permitted to the thread according to any restrictions that may be imposed  by  the  "cpuset"  mechanism
                  described in cpuset(7).
    
           EINVAL (pthread_setaffinity_np())  cpuset  specified a CPU that was outside the set supported by the kernel.  (The kernel
                  configuration option CONFIG_NR_CPUS defines the range of the set supported by the kernel data type used to  repre‐
                  sent CPU sets.)
    
           EINVAL (pthread_getaffinity_np()) cpusetsize is smaller than the size of the affinity mask used by the kernel.
    
           ESRCH  No thread with the ID thread could be found.
    
    VERSIONS
           These functions are provided by glibc since version 2.3.4.
    
    ATTRIBUTES
           For an explanation of the terms used in this section, see attributes(7).
    
           ┌──────────────────────────┬───────────────┬─────────┐
           │Interface                 │ Attribute     │ Value   │
           ├──────────────────────────┼───────────────┼─────────┤
           │pthread_setaffinity_np(), │ Thread safety │ MT-Safe │
           │pthread_getaffinity_np()  │               │         │
           └──────────────────────────┴───────────────┴─────────┘
    CONFORMING TO
           These functions are nonstandard GNU extensions; hence the suffix "_np" (nonportable) in the names.
    
    NOTES
           After a call to pthread_setaffinity_np(), the set of CPUs on which the thread will actually run is  the  intersection  of
           the  set  specified  in  the  cpuset argument and the set of CPUs actually present on the system.  The system may further
           restrict the set of CPUs on which the thread runs if the "cpuset" mechanism described in cpuset(7) is being used.   These
           restrictions on the actual set of CPUs on which the thread will run are silently imposed by the kernel.
    
           These functions are implemented on top of the sched_setaffinity(2) and sched_getaffinity(2) system calls.
    
           In  glibc 2.3.3 only, versions of these functions were provided that did not have a cpusetsize argument.  Instead the CPU
           set size given to the underlying system calls was always sizeof(cpu_set_t).
    
           A new thread created by pthread_create(3) inherits a copy of its creator's CPU affinity mask.
    
    EXAMPLE
           In the following program, the main thread uses pthread_setaffinity_np() to set its CPU affinity mask to include CPUs 0 to
           7  (which  may  not  all  be available on the system), and then calls pthread_getaffinity_np() to check the resulting CPU
           affinity mask of the thread.
    
           #define _GNU_SOURCE
           #include <pthread.h>
           #include <stdio.h>
           #include <stdlib.h>
           #include <errno.h>
    
           #define handle_error_en(en, msg) \
                   do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)
    
           int
           main(int argc, char *argv[])
           {
               int s, j;
               cpu_set_t cpuset;
               pthread_t thread;
    
               thread = pthread_self();
    
               /* Set affinity mask to include CPUs 0 to 7 */
    
               CPU_ZERO(&cpuset);
               for (j = 0; j < 8; j++)
                   CPU_SET(j, &cpuset);
    
               s = pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
               if (s != 0)
                   handle_error_en(s, "pthread_setaffinity_np");
    
               /* Check the actual affinity mask assigned to the thread */
    
               s = pthread_getaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
               if (s != 0)
                   handle_error_en(s, "pthread_getaffinity_np");
    
               printf("Set returned by pthread_getaffinity_np() contained:\n");
               for (j = 0; j < CPU_SETSIZE; j++)
                   if (CPU_ISSET(j, &cpuset))
                       printf("    CPU %d\n", j);
    
               exit(EXIT_SUCCESS);
           }
    
    SEE ALSO
           sched_setaffinity(2),   CPU_SET(3),   pthread_attr_setaffinity_np(3),   pthread_self(3),   sched_getcpu(3),    cpuset(7),
           pthreads(7), sched(7)
    
    COLOPHON
           This  page  is  part  of  release  4.15  of the Linux man-pages project.  A description of the project, information about
           reporting bugs, and the latest version of this page, can be found at https://www.kernel.org/doc/man-pages/.
    
    Linux                                                      2017-09-15                                  PTHREAD_SETAFFINITY_NP(3)

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64
 *  65
 *  66
 *  67
 *  68
 *  69
 *  70
 *  71
 *  72
 *  73
 *  74
 *  75
 *  76
 *  77
 *  78
 *  79
 *  80
 *  81
 *  82
 *  83
 *  84
 *  85
 *  86
 *  87
 *  88
 *  89
 *  90
 *  91
 *  92
 *  93
 *  94
 *  95
 *  96
 *  97
 *  98
 *  99
 *  100
 *  101
 *  102
 *  103
 *  104
 *  105
 *  106
 *  107
 *  108
 *  109
 *  110
 *  111
 *  112
 *  113
 *  114
 *  115
 *  116
 *  117
 *  118
 *  119
 *  120
 *  121
 *  122
 *  123
 *  124
 *  125
 *  126
 *  127
 *  128
 *  129
 *  130
 *  131
 *  132
 *  133
 *  134
 *  135
 *  136

2.1.2 代码

直接上代码：

#include <stdio.h>
    #define __USE_GNU
    #define __GNU_SOURCE
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <sched.h>
    #include <pthread.h>
    
    
    void * thread_func(void * arg)
    {
    	while(1)
    	{
    
    	}
    }
    
    
    int main(void)
    {
    	pthread_t t1;
    	pthread_t t2;
    
    	pthread_create(&t1,NULL,thread_func,NULL);
    	pthread_create(&t2,NULL,thread_func,NULL);
    
    	cpu_set_t mask;	
    	CPU_ZERO(&mask);
    
    	CPU_SET(5,&mask);
    	// 将线程1 固定在CPU5上运行
    	if(pthread_setaffinity_np(t1,sizeof(mask),&mask) < 0)
    	{
    		printf("pthread_setaffinity_np failed\n");
    	}
    
    	CPU_ZERO(&mask);
    
    	CPU_SET(7,&mask);
    	// 将线程2 固定在CPU7上运行
    	if(pthread_setaffinity_np(t2,sizeof(mask),&mask) < 0)
    	{
    		printf("pthread_setaffinity_np failed\n");
    	}
    
    
    	CPU_ZERO(&mask);
    
    	CPU_SET(3,&mask);
    	// 将主线程 固定在CPU3上运行
    
    	pthread_setaffinity_np(pthread_self(),sizeof(mask),&mask);
    	while(1)
    	{
    
    	}
    	return 0;
    
    }

运行 之后查看结果如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbnh1ZXhpYW5n_size_16_color_FFFFFF_t_70_pic_center 2]

### 2.2 将进程运行在固定的CPU ###

2.2.1 sched\_setaffinity 接口使用

void CPU_ZERO (cpu_set_t *set)
     /*这个宏对 CPU 集 set 进行初始化，将其设置为空集。*/
     void CPU_SET (int cpu, cpu_set_t *set)
     /*这个宏将 指定的 cpu 加入 CPU 集 set 中*/
     void CPU_CLR (int cpu, cpu_set_t *set)
     /*这个宏将 指定的 cpu 从 CPU 集 set 中删除。*/
     int CPU_ISSET (int cpu, const cpu_set_t *set)
     /*如果 cpu 是 CPU 集 set 的一员，这个宏就返回一个非零值（true），否则就返回零（false）。*/
     
     #define _GNU_SOURCE             /* See feature_test_macros(7) */
     #include <sched.h>
    
    int sched_setaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask);
    /*该函数设置进程为pid的这个进程,让它运行在mask所设定的CPU上.如果pid的值为0,
     *则表示指定的是当前进程,使当前进程运行在mask所设定的那些CPU上.
     *第二个参数cpusetsize是mask所指定的数的长度.通常设定为sizeof(cpu_set_t).
     *如果当前pid所指定的进程此时没有运行在mask所指定的任意一个CPU上,
     *则该指定的进程会从其它CPU上迁移到mask的指定的一个CPU上运行.*/
    
    int sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask);
    /*该函数获得pid所指示的进程的CPU位掩码,并将该掩码返回到mask所指向的结构中.
     *即获得指定pid当前可以运行在哪些CPU上.
     *同样,如果pid的值为0.也表示的是当前进程*/

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24

2.2.2 代码

#include <stdio.h>
    #define __USE_GNU
    #define __GNU_SOURCE
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <sched.h>
    #include <pthread.h>
    
    int main(void)
    {
    
    	cpu_set_t mask;	
    
    	CPU_ZERO(&mask);
    
    	CPU_SET(6,&mask);
    	// 利用 进程 函数来固定主线程运行的CPU
    	sched_setaffinity(getpid(),sizeof(mask),&mask);
    	
    	while(1)
    	{
    
    	}
    	return 0;
    
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28

查看结果与预期一致。

### 2.3 cpu亲和性（affinity） ###

CPU的亲和性， 就是进程要在指定的 CPU 上尽量长时间地运行而不被迁移到其他处理器，也称为CPU关联性；再简单的点的描述就将制定的进程或线程绑定到相应的cpu上；在多核运行的机器上，每个CPU本身自己会有缓存，缓存着进程使用的信息，而进程可能会被OS调度到其他CPU上，如此，CPU cache命中率就低了，当绑定CPU后，程序就会一直在指定的cpu跑，不会由操作系统调度到其他CPU上，性能有一定的提高。

*  1

**软亲和性（affinity）**: 就是进程要在指定的 CPU 上尽量长时间地运行而不被迁移到其他处理器，Linux 内核进程调度器天生就具有被称为 软 CPU 亲和性（affinity） 的特性，这意味着进程通常不会在处理器之间频繁迁移。这种状态正是我们希望的，因为进程迁移的频率小就意味着产生的负载小。

**硬亲和性（affinity）**：简单来说就是利用linux内核提供给用户的API，强行将进程或者线程绑定到某一个指定的cpu核运行。

\*\*解释：\*\*在linux内核中，所有的进程都有一个相关的数据结构，称为 task\_struct。这个结构非常重要，原因有很多；其中与 亲和性（affinity）相关度最高的是 cpus\_allowed 位掩码。这个位掩码由 n 位组成，与系统中的 n 个逻辑处理器一一对应。 具有 4 个物理 CPU 的系统可以有 4 位。如果这些 CPU 都启用了超线程，那么这个系统就有一个 8 位的位掩码。 如果为给定的进程设置了给定的位，那么这个进程就可以在相关的 CPU 上运行。因此，如果一个进程可以在任何 CPU 上运行，并且能够根据需要在处理器之间进行迁移，那么位掩码就全是 1。  
下面把task\_struct 中相关变量摘出来如下：

int				nr_cpus_allowed;
    	const cpumask_t			*cpus_ptr;
    	cpumask_t			cpus_mask;

*  1
 *  2
 *  3

### 2.4 taskset ###

我们可以利用 taskset 命令显示或者更改一个进程或线程的CPU亲和性。taskset 具体用法可以查看man手册

TASKSET(1)                                                User Commands                                               TASKSET(1)
    
    NAME
           taskset - set or retrieve a process's CPU affinity
    
    SYNOPSIS
           taskset [options] mask command [argument...]
           taskset [options] -p [mask] pid
    
    DESCRIPTION
           taskset is used to set or retrieve the CPU affinity of a running process given its pid, or to launch a new command with a
           given CPU affinity.  CPU affinity is a scheduler property that "bonds" a process to a given set of CPUs  on  the  system.
           The  Linux  scheduler  will  honor  the given CPU affinity and the process will not run on any other CPUs.  Note that the
           Linux scheduler also supports natural CPU affinity: the scheduler attempts to keep processes on the same CPU as  long  as
           practical for performance reasons.  Therefore, forcing a specific CPU affinity is useful only in certain applications.
    
           The  CPU  affinity  is represented as a bitmask, with the lowest order bit corresponding to the first logical CPU and the
           highest order bit corresponding to the last logical CPU.  Not all CPUs may exist on a given system but a mask may specify
           more  CPUs  than are present.  A retrieved mask will reflect only the bits that correspond to CPUs physically on the sys‐
           tem.  If an invalid mask is given (i.e., one that corresponds to no valid  CPUs  on  the  current  system)  an  error  is
           returned.   The  masks  may  be  specified  in  hexadecimal  (with  or without a leading "0x"), or as a CPU list with the
           --cpu-list option.  For example,
    
               0x00000001  is processor #0,
    
               0x00000003  is processors #0 and #1,
    
               0xFFFFFFFF  is processors #0 through #31,
    
               32          is processors #1, #4, and #5,
    
               --cpu-list 0-2,6
                           is processors #0, #1, #2, and #6.
    
           When taskset returns, it is guaranteed that the given program has been scheduled to a legal CPU.
    
    OPTIONS
           -a, --all-tasks
                  Set or retrieve the CPU affinity of all the tasks (threads) for a given PID.
    
           -c, --cpu-list
                  Interpret mask as numerical list of processors instead of a bitmask.  Numbers are  separated  by  commas  and  may
                  include ranges.  For example: 0,5,8-11.
    
           -p, --pid
                  Operate on an existing PID and do not launch a new task.
    
           -V, --version
                  Display version information and exit.
    
           -h, --help
                  Display help text and exit.
    
    USAGE
           The default behavior is to run a new command with a given affinity mask:
                  taskset mask command [arguments]
    
           You can also retrieve the CPU affinity of an existing task:
                  taskset -p pid
    
           Or set it:
                  taskset -p mask pid
    
    PERMISSIONS
           A  user  can change the CPU affinity of a process belonging to the same user.  A user must possess CAP_SYS_NICE to change
           the CPU affinity of a process belonging to another user.  A user can retrieve the affinity mask of any process.
    
    SEE ALSO
           chrt(1), nice(1), renice(1), sched_getaffinity(2), sched_setaffinity(2)
    
           See sched(7) for a description of the Linux scheduling scheme.
    
    AUTHOR
           Written by Robert M. Love.
    
    COPYRIGHT
           Copyright © 2004 Robert M. Love.  This is free software; see the source for copying conditions.  There  is  NO  warranty;
           not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    
    AVAILABILITY
           The  taskset command is part of the util-linux package and is available from https://www.kernel.org/pub/linux/utils/util-
           linux/.

用法：taskset [选项] [掩码 | cpu列表] [pid|命令 [参数...]]
    
    
    显示或更改某个进程的 CPU 亲和力。
    
    Options:
     -a, --all-tasks         operate on all the tasks (threads) for a given pid
     -p, --pid               operate on existing given pid
     -c, --cpu-list          display and specify cpus in list format
     -h, --help              display this help
     -V, --version           display version
    
    默认行为是运行一条新命令：
        taskset 03 sshd -b 1024
    您可以获取现有任务的掩码：
        taskset -p 700
    或设置掩码：
        taskset -p 03 700
    使用逗号分隔的列表格式而不是掩码：
        taskset -pc 0,3,7-11 700
    列表格式中的范围可以带一个跨度参数：
        例如 0-31:2 与掩码 0x55555555 等效

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22

**使用示例：**

首先利用top 查看出线程的cpu亲和性，运行在哪个核

进程 USER      PR  NI    VIRT    RES    SHR PU %MEM     TIME+ COMMAND        P 
    115380 root      20   0   23088    880    800 R 99.9  0.0   0:31.79 a.out     7
    115378 root      20   0   23088    880    800 R 99.7  0.0   0:31.81 a.out     6
    115379 root      20   0   23088    880    800 R 99.7  0.0   0:31.81 a.out     5

*  1
 *  2
 *  3
 *  4

利用 taskset 查看如下：

taskset -p 115378
    pid 115378 的当前亲和力掩码：40  // 40 是 16进制
    taskset -p 115379
    pid 115379 的当前亲和力掩码：20
    taskset -p 115380
    pid 115380 的当前亲和力掩码：80

*  1
 *  2
 *  3
 *  4
 *  5
 *  6

更改cpu亲和性

taskset -cp 1 115380  
    pid 115380 的当前亲和力列表：7
    pid 115380 的新亲和力列表：1

*  1
 *  2
 *  3

利用top查看

进程 USER      PR  NI    VIRT    RES    SHR CPU %MEM     TIME+ COMMAND   P 
    115380 root      20   0   23088    880    800 R 299.8  0.0  17:17.82 a.out     1

*  1
 *  2

### 2.5 man 手册 ###

man pthread_setaffinity_np
    man sched_setaffinity
    man CPU_ZERO

[https_blog.csdn.net_wanxuexiang_article_details_108590490]: https://blog.csdn.net/wanxuexiang/article/details/108590490
[Linux _CPU]: https://blog.csdn.net/wanxuexiang/article/details/108590490#Linux_CPU_1
[1 _CPU]: https://blog.csdn.net/wanxuexiang/article/details/108590490#1_CPU_2
[1.1 _PS]: https://blog.csdn.net/wanxuexiang/article/details/108590490#11_PS_3
[1.2 _top]: https://blog.csdn.net/wanxuexiang/article/details/108590490#12_top_24
[1.3 _ proc]: https://blog.csdn.net/wanxuexiang/article/details/108590490#13__proc_32
[2 _ API _CPU]: https://blog.csdn.net/wanxuexiang/article/details/108590490#2__API_CPU_68
[2.1 _CPU]: https://blog.csdn.net/wanxuexiang/article/details/108590490#21_CPU_70
[2.1.1 pthread_setaffinity_np]: https://blog.csdn.net/wanxuexiang/article/details/108590490#211_pthread_setaffinity_np__72
[2.1.2]: https://blog.csdn.net/wanxuexiang/article/details/108590490#212__213
[2.2 _CPU]: https://blog.csdn.net/wanxuexiang/article/details/108590490#22_CPU_285
[2.2.1 sched_setaffinity]: https://blog.csdn.net/wanxuexiang/article/details/108590490#221_sched_setaffinity__287
[2.2.2]: https://blog.csdn.net/wanxuexiang/article/details/108590490#222__317
[2.3 cpu_affinity]: https://blog.csdn.net/wanxuexiang/article/details/108590490#23_cpuaffinity_350
[2.4 taskset]: https://blog.csdn.net/wanxuexiang/article/details/108590490#24_taskset_367
[2.5 man]: https://blog.csdn.net/wanxuexiang/article/details/108590490#25_man__519
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbnh1ZXhpYW5n_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/b3a9ff9bb2fb4c33aff9c25a87902243.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbnh1ZXhpYW5n_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/972640ba5166464ba5381c2f77c3876a.png
[20200914232804886.jpg_pic_center]: /images/20221123/34ef6f4b11e74635944f5031a5764334.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbnh1ZXhpYW5n_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/b22c2f8ac97241f78c891d722fc74fff.png