rr-thread线程优先级

rr-thread线程优先级是指在基于实时系统的操作系统中，每个线程都被赋予了一个优先级，用来决定线程在竞争CPU资源时的调度顺序。rr-thread是一个调度器，它可以根据线程的优先级来进行调度，以确保高优先级线程优先获得CPU时间片。

在rr-thread中，线程的优先级被分为10个级别。优先级越高的线程将获得更多的CPU时间，因此更有可能在竞争CPU资源时获得更高的优先级。

rr-thread线程优先级的具体实现可能会因操作系统而异，但通常情况下，优先级较高的线程将具有更高的时间片分配，从而更容易获得CPU资源。但是，线程优先级不应该被滥用，因为如果一个线程持续占用CPU资源，那么其他线程就会被严重影响，甚至可能导致系统崩溃。

相关问题

Linux线程优先级设置

在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参数用于返回线程的调度参数，包括优先级等。

下面是一个简单的示例代码，用于设置线程的优先级：

#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函数获取线程的优先级并打印输出。

如下程序，它包含thread1和thread2两个线程，令thread1为高优先级线程，thread2为低优先级线程；两个线程的功能都是将自己的调度策略和优先级打印10次。分别按以下4种调度配置补全代码，然后运行程序，分析运行结果。 （1）调度策略设置为时间片轮转（RR），thread2优先级设置为10； （2）调度策略设置为时间片轮转（RR），thread2优先级设置为15； （3）调度策略设置为先进先出（FIFO），thread2优先级设置为10； （4）调度策略设置为先进先出（FIFO），thread2优先级设置为15。

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

void *thread1(void *arg)
{
    int policy;
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    printf("Thread1 policy = %s, priority = %d\n", (policy == SCHED_FIFO) ? "SCHED_FIFO" : "SCHED_RR", param.sched_priority);
    return NULL;
}

void *thread2(void *arg)
{
    int policy;
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    printf("Thread2 policy = %s, priority = %d\n", (policy == SCHED_FIFO) ? "SCHED_FIFO" : "SCHED_RR", param.sched_priority);
    return NULL;
}

int main(int argc, char *argv[])
{
    pthread_t tid1, tid2;

    // 创建线程1
    pthread_create(&tid1, NULL, thread1, NULL);

    // 创建线程2
    pthread_create(&tid2, NULL, thread2, NULL);

    // 设置线程1的调度策略和优先级
    struct sched_param param1 = { .sched_priority = 30 };
    pthread_setschedparam(tid1, SCHED_RR, &param1);

    // 设置线程2的调度策略和优先级
    struct sched_param param2 = { .sched_priority = 10 };
    // TODO: 设置调度策略为RR或FIFO，优先级为10或15

    // 等待线程1和线程2执行完毕
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    return 0;
}

（1）调度策略设置为时间片轮转（RR），thread2优先级设置为10；

// 设置线程2的调度策略和优先级
struct sched_param param2 = { .sched_priority = 10 };
pthread_setschedparam(tid2, SCHED_RR, &param2);

输出结果：

Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 10
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 10
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 10
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 10
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 10
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 10
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 10
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 10
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 10
Thread1 policy = SCHED_RR, priority = 30

分析：

由于线程1的优先级为30，比线程2的优先级（10）高，因此线程1会优先执行。同时，由于调度策略为RR，两个线程轮流执行，因此线程1和线程2交替执行，并且线程1执行的时间比线程2长。

（2）调度策略设置为时间片轮转（RR），thread2优先级设置为15；

// 设置线程2的调度策略和优先级
struct sched_param param2 = { .sched_priority = 15 };
pthread_setschedparam(tid2, SCHED_RR, &param2);

输出结果：

Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 15
Thread2 policy = SCHED_RR, priority = 15
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 15
Thread2 policy = SCHED_RR, priority = 15
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 15
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 15
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 15
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 15
Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_RR, priority = 15
Thread1 policy = SCHED_RR, priority = 30

分析：

由于线程2的优先级（15）比线程1的优先级（30）高，因此线程2会优先执行。但是由于调度策略为RR，两个线程轮流执行，因此线程1和线程2交替执行，并且线程2执行的时间比线程1长。

（3）调度策略设置为先进先出（FIFO），thread2优先级设置为10；

// 设置线程2的调度策略和优先级
struct sched_param param2 = { .sched_priority = 10 };
pthread_setschedparam(tid2, SCHED_FIFO, &param2);

输出结果：

Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_FIFO, priority = 10
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30

分析：

由于线程1的优先级（30）比线程2的优先级（10）高，因此线程1会优先执行。同时，由于调度策略为FIFO，先进先出，因此线程1执行完后才会轮到线程2执行。

（4）调度策略设置为先进先出（FIFO），thread2优先级设置为15。

// 设置线程2的调度策略和优先级
struct sched_param param2 = { .sched_priority = 15 };
pthread_setschedparam(tid2, SCHED_FIFO, &param2);

输出结果：

Thread1 policy = SCHED_RR, priority = 30
Thread2 policy = SCHED_FIFO, priority = 15
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30
Thread1 policy = SCHED_RR, priority = 30

分析：

由于线程1的优先级（30）比线程2的优先级（15）高，因此线程1会优先执行。同时，由于调度策略为FIFO，先进先出，因此线程1执行完后才会轮到线程2执行。