首页 > 系统相关 >Linux-线程优先级学习

Linux-线程优先级学习

时间：2023-12-07 22:33:53浏览次数：43  
标签：优先级 pthread sched 线程 Linux policy SCHED

概念

Linux系统中常用的几种调度类为SCHED_NORMAL、SCHED_FIFO、SCHED_RR。

  • SCHED_NORMAL：用于普通线程的调度类
  • SCHED_FIFO和SCHED_RR是用于实时线程的调度类，优先级高于SCHED_NORMAL。

内核中区分普通线程与实时线程是根据线程的优先级，实时线程拥有实时优先级（real-time priority），默认取值为0~99，数值越高优先级越高

普通线程只具有nice值，nice值映射到用户层的取值范围为-20～+19，数值越高优先级越低，默认初始值为0 ，子线程会继承父线程的优先级。

标准函数

#include <pthread.h>

pthread_setschedparam(pthread_t thread, int policy,
                        const struct sched_param *param);
pthread_getschedparam(pthread_t thread, int *policy,
                        struct sched_param *param);

Compile and link with -pthread.

  • 描述：

    • pthread_setschedparam函数用于设置调度策略policy和线程参数(也就是优先级)
    • pthread_getschedparam函数用户获取调度策略policy和线程参数(也就是优先级)

  • 参数说明：

    • policy参数：线程新的调度策略，policy的描述可查看sched_setscheduler(2)
    // /usr/include/bits/sched.h
#define SCHED_OTHER  0
#define SCHED_FIFO   1
#define SCHED_RR     2
    • param参数：指定新的调度策略的参数，每一种调度策略的优先级允许设置的范围可查看sched_setscheduler(2)
    struct sched_param {
    int sched_priority;     /* Scheduling priority */
};

  • 返回值：成功返回0，失败返回非0值。常见的错误值

    // /usr/include/asm-generic/errno-base.h
#define EPERM        1  /* Operation not permitted */
#define ESRCH        3  /* No such process */
#define EINVAL      22  /* Invalid argument */
    • ESRCH: 线程ID未发现
    • EINVAL: policy不合法，或者param不合法
    • EPERM: 没有权限，policy为SCHED_FIFO、SCHED_RR时，需要root权限

标准示例

示例演示了使用pthread_setschedparam() 和 pthread_getschedparam()和其它一些与实施调度相关的一些函数。

  • main thread设置为SCHED_FIFO调度策略，优先级设置为10，并且初始化一个线程属性对象：调度策略SCHED_RR，优先级20。
  • 接着程序设置线程的继承调度器属性为PTHREAD_EXPLICIT_SCHED -- 创建的线程属性应该为线程属性对象的调度器属性。
  • 接着使用线程属性对象创建一个线程，然后显示线程的调度策略和优先级。

源码：standerd_examp.c.c

/* pthreads_sched_test.c */

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

#define handle_error_en(en, msg) \
    do {                         \
        errno = en;              \
        perror(msg);             \
        exit(EXIT_FAILURE);      \
    } while (0)

static void
usage(char *prog_name, char *msg)
{
    if (msg != NULL)
        fputs(msg, stderr);

    fprintf(stderr, "Usage: %s [options]\n", prog_name);
    fprintf(stderr, "Options are:\n");
#define fpe(msg) fprintf(stderr, "\t%s", msg); /* Shorter */
    fpe("-a<policy><prio> Set scheduling policy and priority in\n");
    fpe("                 thread attributes object\n");
    fpe("                 <policy> can be\n");
    fpe("                     f  SCHED_FIFO\n");
    fpe("                     r  SCHED_RR\n");
    fpe("                     o  SCHED_OTHER\n");
    fpe("-A               Use default thread attributes object\n");
    fpe("-i {e|s}         Set inherit scheduler attribute to\n");
    fpe("                 'explicit' or 'inherit'\n");
    fpe("-m<policy><prio> Set scheduling policy and priority on\n");
    fpe("                 main thread before pthread_create() call\n");
    exit(EXIT_FAILURE);
}

static int
get_policy(char p, int *policy)
{
    switch (p) {
        case 'f':
            *policy = SCHED_FIFO;
            return 1;
        case 'r':
            *policy = SCHED_RR;
            return 1;
        case 'o':
            *policy = SCHED_OTHER;
            return 1;
        default:
            return 0;
    }
}

static void
display_sched_attr(int policy, struct sched_param *param)
{
    printf("    policy=%s, priority=%d\n",
           (policy == SCHED_FIFO)  ? "SCHED_FIFO" :
           (policy == SCHED_RR)    ? "SCHED_RR" :
           (policy == SCHED_OTHER) ? "SCHED_OTHER" :
                                     "???",
           param->sched_priority);
}

static void
display_thread_sched_attr(char *msg)
{
    int                policy, s;
    struct sched_param param;

    s = pthread_getschedparam(pthread_self(), &policy, &param);
    if (s != 0)
        handle_error_en(s, "pthread_getschedparam");

    printf("%s\n", msg);
    display_sched_attr(policy, &param);
}

static void *
thread_start(void *arg)
{
    display_thread_sched_attr("Scheduler attributes of new thread");

    return NULL;
}

int main(int argc, char *argv[])
{
    int                s, opt, inheritsched, use_null_attrib, policy;
    pthread_t          thread;
    pthread_attr_t     attr;
    pthread_attr_t    *attrp;
    char              *attr_sched_str, *main_sched_str, *inheritsched_str;
    struct sched_param param;

    /* Process command-line options */

    use_null_attrib = 0;
    attr_sched_str = NULL;
    main_sched_str = NULL;
    inheritsched_str = NULL;

    while ((opt = getopt(argc, argv, "a:Ai:m:")) != -1) {
        switch (opt) {
            case 'a':
                attr_sched_str = optarg;
                break;
            case 'A':
                use_null_attrib = 1;
                break;
            case 'i':
                inheritsched_str = optarg;
                break;
            case 'm':
                main_sched_str = optarg;
                break;
            default:
                usage(argv[0], "Unrecognized option\n");
        }
    }

    if (use_null_attrib && (inheritsched_str != NULL || attr_sched_str != NULL))
        usage(argv[0], "Can't specify -A with -i or -a\n");

    /* Optionally set scheduling attributes of main thread,
       and display the attributes */

    if (main_sched_str != NULL) {
        if (!get_policy(main_sched_str[0], &policy))
            usage(argv[0], "Bad policy for main thread (-s)\n");
        param.sched_priority = strtol(&main_sched_str[1], NULL, 0);

        s = pthread_setschedparam(pthread_self(), policy, &param);
        if (s != 0)
            handle_error_en(s, "pthread_setschedparam");
    }

    display_thread_sched_attr("Scheduler settings of main thread");
    printf("\n");

    /* Initialize thread attributes object according to options */

    attrp = NULL;

    if (!use_null_attrib) {
        s = pthread_attr_init(&attr);
        if (s != 0)
            handle_error_en(s, "pthread_attr_init");
        attrp = &attr;
    }

    if (inheritsched_str != NULL) {
        if (inheritsched_str[0] == 'e')
            inheritsched = PTHREAD_EXPLICIT_SCHED;
        else if (inheritsched_str[0] == 'i')
            inheritsched = PTHREAD_INHERIT_SCHED;
        else
            usage(argv[0], "Value for -i must be 'e' or 'i'\n");

        s = pthread_attr_setinheritsched(&attr, inheritsched);
        if (s != 0)
            handle_error_en(s, "pthread_attr_setinheritsched");
    }

    if (attr_sched_str != NULL) {
        if (!get_policy(attr_sched_str[0], &policy))
            usage(argv[0],
                  "Bad policy for 'attr' (-a)\n");
        param.sched_priority = strtol(&attr_sched_str[1], NULL, 0);

        s = pthread_attr_setschedpolicy(&attr, policy);
        if (s != 0)
            handle_error_en(s, "pthread_attr_setschedpolicy");
        s = pthread_attr_setschedparam(&attr, &param);
        if (s != 0)
            handle_error_en(s, "pthread_attr_setschedparam");
    }

    /* If we initialized a thread attributes object, display
       the scheduling attributes that were set in the object */

    if (attrp != NULL) {
        s = pthread_attr_getschedparam(&attr, &param);
        if (s != 0)
            handle_error_en(s, "pthread_attr_getschedparam");
        s = pthread_attr_getschedpolicy(&attr, &policy);
        if (s != 0)
            handle_error_en(s, "pthread_attr_getschedpolicy");

        printf("Scheduler settings in 'attr'\n");
        display_sched_attr(policy, &param);

        s = pthread_attr_getinheritsched(&attr, &inheritsched);
        printf("    inheritsched is %s\n",
               (inheritsched == PTHREAD_INHERIT_SCHED)  ? "INHERIT" :
               (inheritsched == PTHREAD_EXPLICIT_SCHED) ? "EXPLICIT" :
                                                          "???");
        printf("\n");
    }

    /* Create a thread that will display its scheduling attributes */

    s = pthread_create(&thread, attrp, &thread_start, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_create");

    /* Destroy unneeded thread attributes object */

    s = pthread_attr_destroy(&attr);
    if (s != 0)
        handle_error_en(s, "pthread_attr_destroy");

    s = pthread_join(thread, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_join");

    exit(EXIT_SUCCESS);
}

测试：

# 默认启动的线程为调度policy为SCHED_OTHER, 默认的调度优先级为0
root@ubuntu:/home/grace# ./a.out 
Scheduler settings of main thread
    policy=SCHED_OTHER, priority=0
# 没有设置attribute
Scheduler settings in 'attr'
    policy=SCHED_OTHER, priority=0
    inheritsched is INHERIT
# 新创建线程优先级和main一致
Scheduler attributes of new thread
    policy=SCHED_OTHER, priority=0

# 设置main线程调度策略为SCHED_FIFO, 调度优先级为10
# 设置thread attributes object的调度策略为SCHED_RR, 优先级为20
# 设置inherit scheduler attribute为PTHREAD_EXPLICIT_SCHED
# 测试结果为新创建的线程的调度策略和优先级为attribute object设置的值
root@ubuntu:/home/grace# ./a.out -mf10 -ar20 -i e
Scheduler settings of main thread
    policy=SCHED_FIFO, priority=10

Scheduler settings in 'attr'
    policy=SCHED_RR, priority=20
    inheritsched is EXPLICIT

Scheduler attributes of new thread
    policy=SCHED_RR, priority=20

# 设置main线程调度策略为SCHED_FIFO, 调度优先级为10
# 设置thread attributes object的调度策略为SCHED_RR, 优先级为20
# 设置inherit scheduler attribute为PTHREAD_INHERIT_SCHED,
# 测试结果为新创建的线程会忽略attribute object设置的值, 属性值直接从父线程继承
root@ubuntu:/home/grace# ./a.out -mf10 -ar20 -i i
Scheduler settings of main thread
    policy=SCHED_FIFO, priority=10

Scheduler settings in 'attr'
    policy=SCHED_RR, priority=20
    inheritsched is INHERIT

Scheduler attributes of new thread
    policy=SCHED_FIFO, priority=10

相关工具

ps

可以查看线程的调度优先级和nice值。

测试代码：ps.c

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

#define handle_error_en(en, msg) \
    do {                         \
        errno = en;              \
        perror(msg);             \
        exit(EXIT_FAILURE);      \
    } while (0)


static void *thread0_func(void *arg)
{
    int                policy;
    int                s;
    struct sched_param param;

    policy = SCHED_FIFO;
    param.sched_priority = 60;
    s = pthread_setschedparam(pthread_self(), policy, &param);
    if (s != 0)
        handle_error_en(s, "pthread_setschedparam");

    while (1) {
        sleep(1);
    }
    return NULL;
}

static void *thread1_func(void *arg)
{
    int                policy;
    int                s;
    struct sched_param param;

    policy = SCHED_RR;
    param.sched_priority = 20;
    s = pthread_setschedparam(pthread_self(), policy, &param);
    if (s != 0)
        handle_error_en(s, "pthread_setschedparam");

    while (1) {
        sleep(1);
    }
    return NULL;
}

static void *thread2_func(void *arg)
{
    int                policy;
    int                s;
    struct sched_param param;

    policy = SCHED_OTHER;
    param.sched_priority = 0; // 设置调度策略为SCHED_OTHER时, 优先级必须设置为0
    s = pthread_setschedparam(pthread_self(), policy, &param);
    if (s != 0) {
        handle_error_en(s, "pthread_setschedparam");
    }

    while (1) {
        sleep(1);
    }
    return NULL;
}

int main(int argc, char *argv[])
{
    int s;
    pthread_t thread0, thread1, thread2;

    s = pthread_create(&thread0, NULL, &thread0_func, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_create");

    s = pthread_create(&thread1, NULL, &thread1_func, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_create");

    s = pthread_create(&thread2, NULL, &thread2_func, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_create");

    s = pthread_join(thread0, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_join");

    s = pthread_join(thread1, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_join");

    s = pthread_join(thread2, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_join");

    exit(EXIT_SUCCESS);
}

功能：在主线程中会创建三个线程

  • 第一个线程的调度策略为SCHED_FIFO, 优先级为60
  • 第二个线程的调度策略为SCHED_RR, 优先级为20
  • 第三个线程德调度策略为SCHED_OTHER, 优先级只能配置为0
$ ps -Telf
F S UID     PID  SPID  PPID   C  PRI NI ADDR SZ WCHAN STIME TTY     TIME     CMD
4 S root   2139  2139  2138   0  80   0  -  6840 -    20:41 pts/6  00:00:00 ./a.out # 线程调度策略为SCHED_OTHER, nice值为0
5 S root   2139  2140  2138   0  -1   -  -  6840 -    20:41 pts/6  00:00:00 ./a.out # real-time调度策略
5 S root   2139  2141  2138   0  39   -  -  6840 -    20:41 pts/6  00:00:00 ./a.out # real-time调度策略
5 S root   2139  2142  2138   0  80   0  -  6840 -    20:41 pts/6  00:00:00 ./a.out

部分字段含义：

  • PRI: priority of the process. Higher number means lower priority.
  • NI: nice value. This ranges from 19 (nicest) to -20 (not nice to others), see nice(1). (alias nice).

chrt工具

用来查看或改变线程的real-time调度属性


F S UID     PID  SPID  PPID   C  PRI NI ADDR SZ WCHAN STIME TTY     TIME     CMD
4 S root   2139  2139  2138   0  80   0  -  6840 -    20:41 pts/6  00:00:00 ./a.out # 线程调度策略为SCHED_OTHER, nice值为0
5 S root   2139  2140  2138   0  -1   -  -  6840 -    20:41 pts/6  00:00:00 ./a.out # real-time调度策略
5 S root   2139  2141  2138   0  39   -  -  6840 -    20:41 pts/6  00:00:00 ./a.out # real-time调度策略
5 S root   2139  2142  2138   0  80   0  -  6840 -    20:41 pts/6  00:00:00 ./a.out

$ chrt -p 2139
pid 2139's current scheduling policy: SCHED_OTHER
pid 2139's current scheduling priority: 0

$ chrt -p 2140
pid 2140's current scheduling policy: SCHED_FIFO
pid 2140's current scheduling priority: 60

$ chrt -p 2141
pid 2141's current scheduling policy: SCHED_RR
pid 2141's current scheduling priority: 20

$ chrt -p 2142
pid 2142's current scheduling policy: SCHED_OTHER
pid 2142's current scheduling priority: 0

chrt工具看到的SCHED_OTHER类型的进程的优先级都为0，可以通过cat /proc/tast-num/sched查看：

SessionLeader (734, #threads: 1)
-------------------------------------------------------------------
policy                                       :                    0   # 调度策略
prio                                         :                  120   # 优先级
clock-delta                                  :                  100

SCHED_SETSCHEDULER(2)

参考：https://zhuanlan.zhihu.com/p/618044514?utm_id=0

#include <sched.h>
int sched_setscheduler(pid_t pid, int policy, const struct sched_param *param);
int sched_getscheduler(pid_t pid);

struct sched_param {
    ...
    int sched_priority;
    ...
};

sched_setscheduler函数的作用是为pid指定的线程设置调度策略和优先级。如果pid为0，则会设置调用该函数的线程的策略和优先级。

sched_getscheduler函数作用是查询pid指定的线程的调度策略和优先级。如果pid为0，则会查询调用该函数的线程的策略和优先级。

Linux支持的调度策略分为两类：

  • normal类型：
    • SCHED_OTHER the standard round-robin time-sharing policy; # 循环分时调度策略
    • SCHED_IDLE for running very low priority background jobs. # 低优先级线程作为背景线程运行
  • real-time类型
    • SCHED_FIFO a first-in, first-out policy; # 先进先出调度策略
    • SCHED_RR a round-robin policy. # 轮转调度

Scheduling policies

  • 调度器是内核的一部分，用来决定哪个就绪态线程获取CPU执行。每一个线程有一个关联的调度策略和一个static调度优先级sched_priority，这些参数可以通过sched_setscheduler()函数设置。内核中的调度器根据调度策略和所有处理器的static priority决定调度哪个线程。
  • 使用normal调度策略（SCHED_OTHER, SCHED_IDLE, SCHED_BATCH）的线程，sched_priority参数没有使用，必须设置为0。
  • 使用real-time调度策略（SCHED_FIFO, SCHED_RR）有一个sched_priority，范围1 (low) 到 99 (high)。（real-time类型线程总是高于normal类型线程）。可以使用sched_get_priority_min()和sched_get_priority_max()函数查看每个调度策略对应的优先级范围。
  • 调度器根据sched_priority值保存一个可运行线程列表，然后调度器选择最高的static priority线程列表，选择列表开头的线程运行。
  • 同样的static priority的线程，调度器根据调度算法决定哪个运行。
  • 线程的调度策略决定线程将插入到具有同等优先级的线程列表中的位置。
  • 所有的调度都是抢占式的，如果具有高静态优先级的线程准备运行，则当前正在运行的线程将被抢占并返回到其静态优先级的等待列表中。调度策略仅在具有同等静态优先级的可运行线程列表中确定排序。

SCHED_FIFO: First in-first out scheduling

  • SCHED_FIFO只能使用static priorities大于0的值。这表示，当一个调度策略为SCHED_FIFO的线程变成运行态时，总是优先于当前正在运行的SCHED_OTHER, SCHED_BATCH, or SCHED_IDLE策略的线程。
  • SCHED_FIFO是一个简单的调度算法，没有切分时间片。
  • 调度策略为SCHED_FIFO的线程遵循下面的规则：
    • 一个低优先级SCHED_FIFO调度的线程被更高优先级的线程抢占后，会放在同等优先级列表的头部，等待所有更高优先级的线程执行完毕后，会恢复执行。
    • 当一个阻塞的SCHED_FIFO线程变成就绪态时，会放在同等优先级列表的尾部。
    • 可以使用sched_setscheduler（2）、sched_setparam（2）、sched_setattr（2）、pthread_setschedparam（3） 或 pthread_setschedprio（3）函数设置正在运行的SCHED_FIFO调度线程的优先级，则对线程在列表中的位置影响却决于线程优先级的更改方向。
      • 如果线程的优先级提高，将其放在新的线程列表的尾部。
      • 如果线程的优先级不变，则其在列表中的位置不变。
      • 如果线程的优先级降低，则将其放在新优先级列表的前面。
    • 一个线程调用sched_yield()函数将放到列表的尾部。
    • 一个SCHED_FIFO线程会一直运行，除非被I/O请求阻塞，或者被更高优先级线程抢占，或者调用sched_yield()函数。

SCHED_RR: Round-robin scheduling

  • SCHED_RR调度策略是SCHED_FIFO策略的增强版本。
  • 适用于SCHED_FIFO的策略也适用于SCHED_RR，除了每一个线程仅被运行执行一个最大的时间片。
  • 如果SCHED_RR线程运行时间已经大于等于了时间片，它会被放在同等优先级列表的尾部。
  • 一个SCHED_RR线程被更高优先级的线程抢占后，恢复执行时使用未消耗完的时间片。
  • 时间片可以使用sched_rr_get_interval()函数查询。

SCHED_OTHER: Default Linux time-sharing scheduling

  • SCHED_OTHER调度策略仅能使用static priority为0（real-time的优先级始终高于normal）。
  • SCHED_OTHER是标准的时间片轮转调度，适用于不需要特殊实时机制的所有线程。
  • 要运行的线程是从static priority为0列表中选择的，该列表基于一个动态优先级。
  • 动态优先级基于nice值，可以通过nice()或者setpriority()设置。
  • 当线程准备运行但被调度器拒绝运行时，nice值也会增加。
  • nice值是一个属性，它会影响SCHED_OTHER和SCHED_BATCH（见下文）进程的调度。nice 值可以使用 nice（2）、setpriority（2） 或 sched_setattr（2） 进行修改。
  • Linux上，nice值的范围是-20（高优先级）到+19（低优先级）。

SCHED_IDLE: Scheduling very low priority jobs

  • SCHED_IDLE线程的static priority值为0。线程的nice值对此调度策略没有影响。
  • SCHED_IDLE调度策略适用于优先级非常低的线程。

Resetting scheduling policy for child processes

  • 每一个线程有一个reset-on-fork调度标志。设置此标志后，fork()创建的子进程不会继承特权调度策略，可以通过下面的方式设置此标志：
    • 当调用sched_setscheduler()函数时，将标志SCHED_RESET_ON_FORK放入策略参数中。
    • 调用 sched_setattr（2） 时，在 attr.sched_flags 中指定 SCHED_FLAG_RESET_ON_FORK 标志。
  • 当SCHED_RESET_ON_FORK标志设置后，创建的子线程将遵循下面的规则：
    • 如果父线程调度策略为SCHED_FIFO或者SCHED_RR，子线程将恢复为SCHED_OTHER；
    • 如果父线程有一个负的nice值，子线程的nice值将变为0；
    • 这个标志将在fork()函数创建子线程后失效，也就是子线程不继承这个标志；
    • 这个标志可以通过sched_getscheduler()函数查询。

Privileges and resource limits

  • 在Linux 2.6.12版本后，RLIMIT_RTPRIO限制了SCHED_RR和SCHED_FIFO调度策略的非特权程序的static priority上限。更改调度策略和优先级遵守下面的规则：
    • 如果一个非特权程序有非0的RLIMIT_RTPRIO软件限制，它可以改变它的调度策略和优先级。但优先级不能设置高于它当前的优先级的最大值和RLIMIT_RTPRIO软限制。
    • 如果RLIMIT_RTPRIO为0，则唯一允许的更改是降低优先级或切换到非real-time调度策略。
  • 可以使用RLIMIT_RTTIME资源限制来设置实时进程可能消耗的 CPU 时间的上限，详见getrlimit(2)
  • 从 Linux 2.6.25 开始，Linux 还提供了两个 /proc 文件，可用于保留一定数量的 CPU 时间供非real-time进程使用。以这种方式保留 CPU 时间允许将一些 CPU 时间分配给（例如）可用于终止失控进程的根 shell。这两个文件都以微秒为单位指定时间值：
    • /proc/sys/kernel/sched_rt_period_us: 指定相当于 100% CPU 带宽的调度周期。此文件中的值范围为 1 到 INT_MAX，工作范围为 1 微秒到 35 分钟左右。此文件中的默认值为 1,000,000（1 秒）。
    • /proc/sys/kernel/sched_rt_runtime_us: 此文件中的值指定系统上所有实时进程可以使用多少“周期”时间。此文件中的值的范围可以从 -1 到 INT_MAX-1。指定 -1 可使运行时间与周期相同;也就是说，没有为非实时进程留出 CPU 时间（这是 Linux 2.6.25 之前的行为）。此文件中的默认值为 950,000（0.95 秒），这意味着 5% 的 CPU 时间保留给不在实时调度策略下运行的进程。

测试代码

sched_test.c

#include <sched.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main(int argc,char *argv[]) 
{
    struct sched_param param; 
    int minpri, maxpri, count; 

    // 获取SCHED_FIFO调度策略可配置的最大优先级
    maxpri = sched_get_priority_max(SCHED_FIFO);
    if(maxpri == -1) { 
        perror("sched_get_priority_max() failed"); 
        return -1; 
    }
    printf("max priority of SCHED_FIFO is %d\n", maxpri);

    minpri = sched_get_priority_min(SCHED_FIFO);
    if(minpri == -1) { 
        perror("sched_get_priority_min() failed"); 
        return -1; 
    }
    printf("min priority of SCHED_FIFO is %d\n", minpri);

#if 0
    param.sched_priority = maxpri; 
    if (sched_setscheduler(getpid(), SCHED_FIFO, &param) == -1) { 
        perror("sched_setscheduler() failed"); 
        return -1; 
    }
#endif

    fork();
    fork();

    while(1) {
        count++;
    }

    return 0;
}

功能：设置进程的调度策略为SCHED_FIFO, 并且优先级设置为最大，创建的子进程也会继承父进程的策略和优先级。

F S UID          PID    SPID    PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
4 R root       19435   19435   19434 99 -40   - -   693 -      22:07 pts/5    00:00:07 ./a.out
1 R root       19436   19436   19435 99 -40   - -   693 -      22:07 pts/5    00:00:07 ./a.out
1 R root       19437   19437   19435 99 -40   - -   693 -      22:07 pts/5    00:00:07 ./a.out
1 R root       19438   19438   19436 99 -40   - -   693 -      22:07 pts/5    00:00:07 ./a.out

grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 19435
pid 19435's current scheduling policy: SCHED_FIFO
pid 19435's current scheduling priority: 99
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 19436
pid 19436's current scheduling policy: SCHED_FIFO
pid 19436's current scheduling priority: 99
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 19437
pid 19437's current scheduling policy: SCHED_FIFO
pid 19437's current scheduling priority: 99
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 19438
pid 19438's current scheduling policy: SCHED_FIFO
pid 19438's current scheduling priority: 99

如果把#if 1改为#if 0, 则默认创建的是SCHED_OTHER类型进程

F S UID          PID    SPID    PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
0 R grace      21187   17702 99  80   0 -   694 -      22:13 pts/0    00:00:02 ./a.out
1 R grace      21189   21187 99  80   0 -   694 -      22:13 pts/0    00:00:02 ./a.out
1 R grace      21190   21187 99  80   0 -   694 -      22:13 pts/0    00:00:02 ./a.out
1 R grace      21191   21189 99  80   0 -   694 -      22:13 pts/0    00:00:02 ./a.out

grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 17702
pid 17702's current scheduling policy: SCHED_OTHER
pid 17702's current scheduling priority: 0
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 21187
pid 21187's current scheduling policy: SCHED_OTHER
pid 21187's current scheduling priority: 0
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 21189
pid 21189's current scheduling policy: SCHED_OTHER
pid 21189's current scheduling priority: 0
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 21190
pid 21190's current scheduling policy: SCHED_OTHER
pid 21190's current scheduling priority: 0
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 21191
pid 21191's current scheduling policy: SCHED_OTHER
pid 21191's current scheduling priority: 0

标签：优先级,pthread,sched,线程,Linux,policy,SCHED
From： https://www.cnblogs.com/mrlayfolk/p/17884131.html

相关文章

  • Linux命令：TOP
    省流：用一张图来解释top命令，它就是：解释Top命令用于显示Linux的运行状态，它提供了一个动态的，实时的系统监控视图。一般情况下，这个命令会展示系统运行状态和各线程任务运行状态。在这篇博客中，我将逐条解释其中的对应信息。输入top后，会进入交互式命令模式。按下q退出。上......
  • node.js - 在linux系统上安装和配置nodejs
    step1:根据自己的系统架构下载nodejs软件包https://nodejs.org/en/download/curl-Ohttps://nodejs.org/dist/v20.10.0/node-v20.10.0-linux-arm64.tar.xzstep2:创建目录sudomkdir-p/usr/local/lib/nodejsstep3:解压二进制软件包sudotar-xJvfnode-v20.10.0-lin......
  • Linux I\O重定向与管道
    一：I\O重定向 linu系统中的三种I/O设备所代表的编号分别是：标准输入（STDIN），文件描述符为0，默认从键盘获取输入；标准输出（STDOUT），文件描述符为1，默认输出到显示屏；标准错误（STDERR），文件描述符为2，默认输出到显示屏。 I/O重定向就是为了改变默认输入、输出的位置：>：表示标准输出覆盖重定向；>>：......
  • Linux文件权限
    一：基本权限UGO权限对象：u：属主（拥有者）g：属组（拥有者同组）o：其他人（其他用户）特殊对象：a：所有人（u+g+o） 权限类型：符号表示数字表示说明符号表示数字表示说明r4只读rx5读和执行w2只写wx3写和执行x1只执行rwx7读、写和执行rw6读和写---0无权限......
  • Linux端ALSA音频处理库
    1.项目介绍项目Github地址：https://github.com/alsa-project/alsa-libALSA（AdvancedLinuxSoundArchitecture）是Linux操作系统上的音频处理框架。它提供了对音频设备的抽象和控制，使应用程序能够与音频硬件进行交互。ALSA库是ALSA项目的一部分，它为开发者提供了一组API（应用程序编......
  • does not have a SELinux domain defined. android 开机启动
    问题：dmesg [  46.089306]init:Servicemysvc2 doesnothaveaSELinuxdomaindefined. servicemysvc1/system/vendor/bin/app1classmainuserrootgrouprootsystemreadprocdisabledwritepid/dev/cpuset/foreground/tasksservicemysvc2......
  • java打包好的jar包在Linux服务器上指定端口并后台运行命令
    前提条件：a.已经在Linux服务器上安装了java环境。b.切换到jar包所在的目录下。c.运行方式为:java-jar运行。举例说明：包名  运行端口test.jar  8080命令如下：java-jar-Dserver.port=8080test.jar&>test.out&1解释：1.表示将test.jar这个jar包运行在8080端口（前提是端口......
  • java使用ftp连接linux处理文件
    1、Maven依赖<!--FTP使用包--><dependency><groupId>commons-net</groupId><artifactId>commons-net</artifactId><version>3.6</version></dependency>......
  • linux-ELK安装配置
    前言：  ELK是三个开源项目的首字母缩写，这三个项目分别是：Elasticsearch、Logstash和Kibana。   •Elasticsearch是一个搜索和分析引擎。   •Logstash是服务器端数据处理管道，能够同时从多个来源采集数据，转换数据，然后将数据发送到诸如Elasticsearch等存储库中。......
  • 响应式编程又变天了？看JDK21虚拟线程如何颠覆！
    本文解释为啥会有响应式编程，为什么它在开发者中不太受欢迎，以及引入Java虚拟线程后它可能最终会消失。命令式风格编程一直深受开发者喜爱，如if-then-else、while循环、函数和代码块等结构使代码易理解、调试，异常易追踪。然而，像所有好的东西一样，通常也有问题。这种编程风格导致......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99