【Linux】实时线程的优先级设置、调度和抢占

前言

看了一些关于Linux多线程编程的书籍和网络资料，发现关于对实时线程调度和抢占的主题的代码和文章比较少（也可能是我还没找到）。而对于一些系统，例如机器人控制系统，对于任务的实时性要求是比较高的，所以需要了解一下实时线程的编程方法。
Linux虽然是一个非实时操作系统，但是其线程也有实时和分时之分，具体的调度策略可以分为3种：
实时线程：SCHED_FIFO（先来先服务策略调度）；
实时线程：SCHED_RR（时间片轮转）；
普通线程：Linux中称为SCHED_MORMAL；POSIX称为SCHED_OTHER，是一种分时调度策略。
我们创建线程的时候可以指定调度策略，默认的调度策略为SCHED_OTHER。

示例代码

下边给出一个Linux实时线程抢占的编程示例，我认为尤其需要注意的两点是：
（1）必须在sudo模式下运行程序；
（2）需要将实时线程绑定到同一个CPU核上；

#include 
#include 
#include 
#include 
#include 

#define __USE_GNU

long long a = 0;
long long b = 0;

// 获取调度策略的函数
static int get_thread_policy(pthread_attr_t *attr)
{
    int policy;
    int rs = pthread_attr_getschedpolicy(attr, &policy);
    // assert(rs == 0);
    switch (policy)
    {
    case SCHED_FIFO:
        printf("policy= SCHED_FIFO\n");
        break;
    case SCHED_RR:
        printf("policy= SCHED_RR");
        break;
    case SCHED_OTHER:
        printf("policy=SCHED_OTHER\n");
        break;
    default:
        printf("policy=UNKNOWN\n");
        break;
    }
    return policy;
}

// 将线程绑定到某个cpu核上
int attach_cpu(int cpu_index)
{
    int cpu_num = sysconf(_SC_NPROCESSORS_CONF);
    if (cpu_index < 0 || cpu_index >= cpu_num)
    {
        printf("cpu index ERROR!\n");
        return -1;
    }
    
    cpu_set_t mask;
    CPU_ZERO(&mask);
    CPU_SET(cpu_index, &mask);

    if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0)
    {
        printf("set affinity np ERROR!\n");
        return -1;
    }

    return 0;
}

// 线程函数1
void *thread1(void *param)
{
    attach_cpu(0);

    long long i;
    for (i = 0; i < 10000000000; i++)
    {
        a++;
    }
}

// 线程函数2
void *thread2(void *param)
{
    attach_cpu(0);

    long long i;
    for (i = 0; i < 10000000000; i++)
    {
        b++;
    }
}

int main()
{
    pthread_t t1;
    pthread_t t2;
    pthread_attr_t attr1;
    pthread_attr_t attr2;
    struct sched_param param1;
    struct sched_param param2;

    //1、初始化
    pthread_attr_init(&attr1);
    pthread_attr_init(&attr2);

    //2、自己决定调度策略
    pthread_attr_setinheritsched(&attr1, PTHREAD_EXPLICIT_SCHED);
    pthread_attr_setinheritsched(&attr2, PTHREAD_EXPLICIT_SCHED);

    //3、设置调度策略
    pthread_attr_setschedpolicy(&attr1, SCHED_FIFO);
    pthread_attr_setschedpolicy(&attr2, SCHED_FIFO);
    // 获取调度策略
    get_thread_policy(&attr1);
    get_thread_policy(&attr2);

    //4、设置优先级
    param1.sched_priority = 10;// 线程1设置优先级为10
    param2.sched_priority = 12;// 线程2设置优先级为12
    pthread_attr_setschedparam(&attr1, &param1);
    pthread_attr_setschedparam(&attr2, &param2);

    //5、创建线程
    pthread_create(&t1, &attr1, thread1, NULL);
    sleep(1);
    pthread_create(&t2, &attr2, thread2, NULL);

    while (1)
    {
        printf("a=%lld, b=%lld\n", a, b);
        sleep(1);
    }

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    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
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

代码结果

这里线程2的优先级设置为12，大于线程1的优先级11，所以线程2一旦就绪，就会抢占CPU资源，进入运行态，而线程1进入就绪态。如下所示，线程函数1中的a累加到366407710后就不再累加，被线程函数2中的b累加抢占，持续运行下去。

[linux-xx@xxx]$ sudo ./test 
policy= SCHED_FIFO
policy= SCHED_FIFO
a=366407710, b=0
a=366407710, b=360397117
a=366407710, b=720418977
a=366407710, b=1080623671
a=366407710, b=1443246909
a=366407710, b=1802815022
a=366407710, b=2165877123
^C
1
2
3
4
5
6
7
8
9
10
11