linux线程设置cpu亲和性与调度方式及优先级

最新推荐文章于 2024-03-04 09:53:56 发布
最新推荐文章于 2024-03-04 09:53:56 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： linux线程调度 文章标签： c语言 数据结构 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41039916/article/details/121428186
版权

cpus_set.c


#include "cpus_set.h"

int get_cpu_nums()
{
    return sysconf(_SC_NPROCESSORS_CONF);
}
int set_cpus_mask(int* cpus_arr, int nums, cpu_set_t *mask)
{
    CPU_ZERO(mask);
    if (nums > get_cpu_nums())
    {
        printf("%s:%d nums must less then cpu nums total\n", __FUNCTION__, __LINE__);
        return -1;
    }

    for (int i = 0; i < nums; i++)
    {
        if (cpus_arr[i] > (get_cpu_nums() - 1) || cpus_arr[i] < 0)
        {
            printf("cpus_arr[%d]: %d\n",i,cpus_arr[i]);
            printf("%s:%d cpus_arr error\n", __FUNCTION__, __LINE__);
            return -1;
        }
        CPU_SET(cpus_arr[i], mask); //将CPU号加入到mask集合
    }
    //printf("set_cpus_mask success\n");
    return 0;
}
int del_cpu_mask(int cpu_num, cpu_set_t *mask)
{
    if (!CPU_ISSET(cpu_num, mask))
    {
        printf("%s:%d cpu_num does not exist in mask\n", __FUNCTION__, __LINE__);
        return -1;
    }
    CPU_CLR(cpu_num, mask);
    return 0;
}
int bind_pthread_cpu_cores(cpu_set_t *mask, pthread_t pid)
{
    int ret = pthread_setaffinity_np(pid, sizeof(cpu_set_t), mask); /* 设置cpu 亲和性(affinity)*/
    if (ret < 0)
    {
        printf("%s:%d:", __FUNCTION__, __LINE__);
        perror("faild sched_setaffinity");
        return -1;
    }
    //printf("bind_cpu_cores success\n");
    return 0;
}
int bind_fork_cpu_cores(cpu_set_t *mask)
{

    int ret = sched_setaffinity(0, sizeof(cpu_set_t), mask);
    if (ret < 0)
    {
        printf("%s:%d:", __FUNCTION__, __LINE__);
        perror("faild sched_setaffinity");
        return -1;
    }
    //printf("bind_cpu_cores success\n");
    return 0;
}
void cpu_get(char* thread_name)
{
     usleep(10000);
    {
        int ret;
        cpu_set_t get_cpus;
        CPU_ZERO(&get_cpus);
        ret = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &get_cpus);
        if (ret < 0)
        {
            perror("faild sched_getaffinity");
        }
        printf("%s [%ld] is running in processor:",thread_name, pthread_self());
        for (int i = 0; i < 4; i++)
        {
            if (CPU_ISSET(i, &get_cpus))
            {
                printf("%d ", i);
            }
        }
        printf("\n");
    }
}
int create_pthread(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine)(void *), void *arg, int* cpus_arr,int nums)
{
    int ret;
    cpu_set_t mask;
    ret = set_cpus_mask(cpus_arr, nums, &mask);
    if (ret < 0)
    {
        printf("set_cpus_mask failed\n");
        return -1;
    }
    ret = pthread_create(thread, NULL, start_routine, arg);
    if (ret < 0)
    {
        printf("pthread_create failed\n");
        return -1;
    }
    ret = bind_pthread_cpu_cores(&mask, *thread);
    if (ret < 0)
    {
        printf("bind_pthread_cpu_cores failed\n");
        return -1;
    }
    
    usleep(100000);
}

int pthread_attribute_init(pthread_attr_t *attr){
    return pthread_attr_init(attr);
}
int pthread_attribute_destory(pthread_attr_t *attr){
    return pthread_attr_destroy(&attr);
}
int pthread_set_inheritsched(pthread_attr_t *attr,int __inherit){
    return pthread_attr_setinheritsched(attr, __inherit);
}
int pthread_set_schedpolicy(pthread_attr_t *attr,int policy){
    pthread_attr_setschedpolicy(attr, policy);
}

cpus_set.h


#ifndef __CPUS_SET_H__
#define __CPUS_SET_H__

#define _GNU_SOURCE
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sched.h>
#include <stdlib.h>

/*
    return : Number of CPU cores
*/
extern int get_cpu_num();
/*
    
*/
extern int set_cpus_mask(int *cpus_arr, int nums,cpu_set_t* mask);

extern int del_cpu_mask(int cpu_num,cpu_set_t* mask);

extern int bind_cpu_cores(cpu_set_t* mask,pthread_t pid);

extern int create_pthread(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine)(void *), void *arg, int *cpus_arr,int nunms);

#endif

main

#define _GNU_SOURCE

#include "cpus_set.h"
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sched.h>
#include <stdlib.h>
void printf_str(char *str)
{
    printf("%s", str);
}
void *thread_run1()
{
    usleep(10000);
    {
        int ret;
        cpu_set_t get_cpus;
        CPU_ZERO(&get_cpus);
        ret = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &get_cpus);
        if (ret < 0)
        {
            perror("faild sched_getaffinity");
        }
        printf("pthread_run1[%ld] is running in processor:", pthread_self());
        for (int i = 0; i < 4; i++)
        {
            if (CPU_ISSET(i, &get_cpus))
            {
                printf("%d ", i);
            }
        }
        printf("\n");
    }
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run1 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run1 is running!\n");
    }
    pthread_exit(NULL);
}
void *thread_run2()
{
    usleep(10000);
    {
        int ret;
        cpu_set_t get_cpus;
        CPU_ZERO(&get_cpus);
        ret = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &get_cpus);
        if (ret < 0)
        {
            perror("faild sched_getaffinity");
        }
        printf("pthread_run2[%ld] is running in processor:", pthread_self());
        for (int i = 0; i < 4; i++)
        {
            if (CPU_ISSET(i, &get_cpus))
            {
                printf("%d ", i);
            }
        }
        printf("\n");
    }
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run2 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run2 is running!\n");
    }
    pthread_exit(NULL);
}
void *thread_run3()
{
   
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run3 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run3 is running!\n");
    }
    pthread_exit(NULL);
}
int main(int argc, char const *argv[])
{
    pthread_t th1, th2, th3;

    pthread_attr_t attr;
    struct sched_param sched;
    int ret;
    int cpu_arr1[1] = {0};
    cpu_set_t mask1;
    sched.__sched_priority = 99;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th1, &attr, thread_run1, NULL, cpu_arr1,sizeof(cpu_arr1)/sizeof(cpu_arr1[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread1 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    int cpu_arr2[1] = {0};
    cpu_set_t mask2;
    sched.__sched_priority = 50;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th2, &attr, thread_run2, NULL, cpu_arr2,sizeof(cpu_arr2)/sizeof(cpu_arr2[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread2 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    int cpu_arr3[1] = {0};
    cpu_set_t mask3;
    sched.__sched_priority = 1;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th3, &attr, thread_run3, NULL, cpu_arr3,sizeof(cpu_arr3)/sizeof(cpu_arr3[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread3 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    pthread_join(th1, NULL);
    pthread_join(th2, NULL);
    pthread_join(th3, NULL);

    return 0;
}
#if 0
#define _GNU_SOURCE

#include "cpus_set.h"
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sched.h>
#include <stdlib.h>
void printf_str(char *str)
{
    printf("%s", str);
}
void *thread_run1()
{
    usleep(10000);
    {
        int ret;
        cpu_set_t get_cpus;
        CPU_ZERO(&get_cpus);
        ret = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &get_cpus);
        if (ret < 0)
        {
            perror("faild sched_getaffinity");
        }
        printf("pthread_run1[%ld] is running in processor:", pthread_self());
        for (int i = 0; i < 4; i++)
        {
            if (CPU_ISSET(i, &get_cpus))
            {
                printf("%d ", i);
            }
        }
        printf("\n");
    }
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run1 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run1 is running!\n");
    }
    pthread_exit(NULL);
}
void *thread_run2()
{
    usleep(10000);
    {
        int ret;
        cpu_set_t get_cpus;
        CPU_ZERO(&get_cpus);
        ret = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &get_cpus);
        if (ret < 0)
        {
            perror("faild sched_getaffinity");
        }
        printf("pthread_run2[%ld] is running in processor:", pthread_self());
        for (int i = 0; i < 4; i++)
        {
            if (CPU_ISSET(i, &get_cpus))
            {
                printf("%d ", i);
            }
        }
        printf("\n");
    }
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run2 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run2 is running!\n");
    }
    pthread_exit(NULL);
}
void *thread_run3()
{
   
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run3 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run3 is running!\n");
    }
    pthread_exit(NULL);
}
int main(int argc, char const *argv[])
{
    pthread_t th1, th2, th3;

    pthread_attr_t attr;
    struct sched_param sched;
    int ret;
    int cpu_arr1[1] = {0};
    cpu_set_t mask1;
    sched.__sched_priority = 99;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th1, &attr, thread_run1, NULL, cpu_arr1,sizeof(cpu_arr1)/sizeof(cpu_arr1[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread1 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    int cpu_arr2[1] = {0};
    cpu_set_t mask2;
    sched.__sched_priority = 50;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th2, &attr, thread_run2, NULL, cpu_arr2,sizeof(cpu_arr2)/sizeof(cpu_arr2[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread2 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    int cpu_arr3[1] = {0};
    cpu_set_t mask3;
    sched.__sched_priority = 1;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th3, &attr, thread_run3, NULL, cpu_arr3,sizeof(cpu_arr3)/sizeof(cpu_arr3[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread3 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    pthread_join(th1, NULL);
    pthread_join(th2, NULL);
    pthread_join(th3, NULL);

    return 0;
}

#endif
卑微小丁
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言线程调度与优先级配置示例
01-31
通过配置线程调度策略与优先级，可使各线程按照设定的顺序执行，从而达到线程间同步的目的，线程属性配置函数包括： pthread_attr_init(&attr[i]);// 初始化线程属性 pthread_attr_setschedpolicy(&attr[i], SCHED...
线程绑定CPU核详解
zxs9999的专栏
01-06 1795
线程绑定CPU核详解
linux中查看线程的亲和性
flyingnosky的专栏
07-19 2195
每个线程在创建时会有CPU亲和性设置，对于fio，存在一个参数-cpu_allowed，设置fio线程可以在哪些CPU上执行，而对于已经运行的任意线程如何查看CPU亲和性呢？其实也可以查到的，首先需要知道线程所对应的PID，然后cat /proc/PID/status，在打印的信息中就会有线程所对应的CPU亲和性。 如下图所示为TOP执行后各线程基本情况： 可以知道VIM所在的线程PID为...
linux 线程设置cpu亲和
最新发布
jiangliuhuan123的博客
03-04 461
linux 线程设置cpu亲和
查看线程优先级
sun007700的专栏
02-11 7113
ps -efLl | grep vm_auto
Linux线程性能分析和CPU亲和力
stevenqian的专栏
09-19 1964
本文描述了在SMP多处理的Linux系统中，线程迁移、负载均衡和CPU亲和力的概念。同时给出了如何通过ps命令和top命令查看调度每个线程的CPU的方法。对于多线程高性能要求的系统，如何跟踪每个核调度了哪些线程，已经如何通过pidstat 周期跟踪一个或者多个线程（进程）占用的CPU核核CPU在用户空间和内核空间的占用百分比。最后介绍了如何通过绑定和隔离等方法和原则防止实时性要求高的线程得到无调度被执行，从而满足软件的性能要求。
【linux】线程的cpu亲和性
PJZero
12-06 501
文章目录说明实现设置亲和性获取亲和性参考文档 说明 可以将不同的线程设置到不同的cpu上运行，以此来是发挥多核效率 实现 设置亲和性 bool binding_cpu(std::thread& thr, int cpuid) { #ifdef __linux__ int result = 0; cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(cpuid, &cpuset); result = pthre
Linux线程调度策略与优先级
dinghuiyang的博客
12-14 2518
Linux线程调度策略与优先级
Linux下线程的调度策略与优先级
hexun110的专栏
08-29 1537
Linux内核的三种调度策略： 　　1，SCHED_OTHER 分时调度策略， 2，SCHED_FIFO实时调度策略，先到先服务。一旦占用cpu则一直运行。一直运行直到有更高优先级任务到达或自己放弃    3，SCHED_RR实时调度策略，时间片轮转。当进程的时间片用完，系统将重新分配时间片，并置于就绪队列尾。放在队列尾保证了所有具有相同优先级的RR任务的调度公平 Linux线程优先级
Linux系统下进程的优先级
weixin_45501045的博客
05-16 750
​ Linux操作系统是一个多用户多任务的操作系统，处理机的分配是通过时间片轮转的方式进行的。当CPU的负载过高时，进程的优先级就会起作用。NI 数值越小优先级越高，可以通过手动设置NI的数值，改变PR的数值。NI的范围是-20~19。nice命令只能调整没有运行的程序优先级。使用top 命令查看进程的优先级。PR 数值越小优先级越高。
linux 下设置线程优先级
xqhrs232的专栏
09-08 1518
原文地址:https://blog.csdn.net/m0_37329910/article/details/100765833 1、https://blog.csdn.net/null_plus/article/details/78444649 2、https://blog.csdn.net/weibo1230123/article/details/81410241 3、https://blog.csdn.net/nullzxy/article/details/9278495 ...
CPU Affinity (CPU亲合力)
JeffYang2016的博客
03-16 1213
在Linux下进行多核编程的时候，通常要设置CPU的亲和力(Affinity)。下面通过讲解sched_setaffinity()和sched_getaffinity()函数以及CPU_ZERO()、CPU_SET()、CPU_CLR()、CPU_ISSET()对CPU的亲和力进行分析。
易语言设置cpu亲和性
06-25
设置cpu 亲和性的 易语言源代码 我的cpu是 4核8线程cpu编号0-7 -2 在任务管理器设置相关性里面 就会显示6号cpu 如果减去1 那就是7号cpu NUMBER_OF_PROCESSORS 环境变量是显示你多少核心数
线程的调度、优先级和亲缘性.pdf
11-05
抢占式操作系统必须使用某种算法来确定哪些线程应该在何时调度和运行多长时间。本章 将要介绍Microsoft Windows 98和Windows 2000使用的一些算法。
内核线程优先级设置的方法介绍
12-31
个人理解，内核级线程和进程是一样的，前者与POSIX线程（pthread）有很大的区别。因此，内核的进程调度策略和系统调用也适用于内核级线程。 　调度策略有三种： 　1.SCHED_NORMAL 非实时调度策略，默认情况下是100～...
Linux超线程感知的调度算法研究
07-29
Intel公司的超线程技术(Hyper-ThreadingTechnology)是一项新的微处理器体系结构技术,...分析了超线程技术的特点,重点研究了Linux超线程感知调度优化技术,解决了对Intel处理器的有效支持问题,并且进行了相关的性能评测。
Linux系统调优详解（十）——CPU调优
永远是少年
07-14 2618
今天继续给大家介绍Linux运维相关知识，本文主要内容是CPU调优。 一、CPU中断次数查看 二、进程优先级设置 三、CPU亲和力设置 四、CPU性能和利用率
linux服务器怎么降低内核cpu进程,Linux性能挖潜的隐藏招数:内核CPU亲和性参数调整...
weixin_32251525的博客
04-28 421
作者：李彬，赵雪枫，金融科技工程师，架构师社区特邀作者！应用服务性能调优，是每个系统投产前都需要关注的问题，系统及软件层面的调优方法均有大量文章介绍，但在所有招数使出后，是否就无潜可挖了？如果了解Linux内核运行特征，经过简单的配置，仍存在不少可行的方案。本文将介绍的是基于Linux内核CPU亲和性参数调整，榨取最后一丝性能优势的方案。一、背景知识CPU是常规应用运行计算的核心，从性能角度至少需...
Linux中CPU亲和性(affinity)
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
11-21 3159
就是利用特殊的硬件指令，（一个核模拟出两个核？）让，进而兼容多线程操作系统和软件，减少了CPU的闲置时间，提高的CPU的运行效率。我们常听到的双核四线程/四核八线程指的就是支持超线程技术的CPU.**物理CPU:**机器上安装的实际CPU, 比如说你的主板上安装了一个8核CPU,那么物理CPU个数就是1个,所以物理CPU个数就是主板上安装的CPU个数。**逻辑CPU:**一般情况，我们认为一颗CPU可以有多核，加上intel的超线程技术(HT), 可以在逻辑上再分一倍数量的CPU core出来；
Linux线程优先级设置
05-14
在Linux系统中，线程的优先级可以通过设置线程的调度策略和优先级来实现。 1. 调度策略：Linux系统提供了多种线程调度策略，包括SCHED_FIFO、SCHED_RR、SCHED_OTHER等。其中，SCHED_FIFO和SCHED_RR是实时调度策略，而SCHED_OTHER是非实时调度策略。一般情况下，我们可以使用SCHED_OTHER策略来进行线程的调度。 2. 优先级：Linux系统中，线程的优先级是一个整数值，范围为0~99，数值越大，优先级越高。默认情况下，线程的优先级为0。 线程的优先级可以通过以下两个函数来设置： - int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param) 该函数用于设置线程的调度策略和优先级。其中，thread参数指定要设置的线程，policy参数指定线程的调度策略，param参数指定线程的调度参数，包括优先级等。 - int pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param) 该函数用于获取线程的调度策略和优先级。其中，thread参数指定要获取的线程，policy参数用于返回线程的调度策略，param参数用于返回线程的调度参数，包括优先级等。 下面是一个简单的示例代码，用于设置线程的优先级： ```c #include <pthread.h> void *thread_func(void *arg) { // 线程执行的代码 return NULL; } int main() { pthread_t thread; struct sched_param param; int policy; // 创建线程 pthread_create(&thread, NULL, thread_func, NULL); // 设置线程的优先级 param.sched_priority = 80; pthread_setschedparam(thread, SCHED_OTHER, &param); // 获取线程的优先级 pthread_getschedparam(thread, &policy, &param); printf("Thread priority is %d\n", param.sched_priority); // 等待线程结束 pthread_join(thread, NULL); return 0; } ``` 在上面的代码中，我们首先创建了一个线程，然后使用pthread_setschedparam函数设置线程的优先级为80，最后使用pthread_getschedparam函数获取线程的优先级并打印输出。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值