pthread线程优先级的调度

淡淡的烟草味﹌ 2022-07-13 09:28 181阅读 0赞

如果系统定义了 \_POSIX\_THREAD\_PRIORITY\_SCHEDULING ，则支持设置线程的实时调度优先级。

我们可以用下面的编译指令来判断：\#if defined(\_POSIX\_THREAD\_PRIORITY\_SCHEDULING)

调度策略 policy: 可以取三个值（SCHED\_FIFO、SCHED\_RR、SCHED\_OTHER）。

1.  \#include <pthread.h>
2.    
    
3.  int pthread\_attr\_setschedpolicy(pthread\_attr\_t \*attr, int policy);  
    
4.  int pthread\_attr\_getschedpolicy(pthread\_attr\_t \*attr, int \*policy);

函数：int pthread\_attr\_setschedpolicy(pthread\_attr\_t \*attr, int policy); 用来设置线程属性 attr 的调度策略为 policy，则用 attr 创建的线程，它的调度策略则为 policy 指定的方式。

函数：int pthread\_attr\_getschedpolicy(pthread\_attr\_t \*attr, int \*policy); 则用来从线程属性 attr 中获得调度策略，保存在 policy 中。

SCHED\_FIFO: 先进先出 调度策略允许一个线程运行直到有更高优先级的线程准备好，或者直到它自愿阻塞自己(比如调用pthread\_yield之类的函数)。在该调度策略下，当有一个更高优先级的线程准备好时，它将立即开始执行。

此外SCHED\_FIFO是一个非分时的简单调度策略，当一个线程变成可运行状态，它将被追加到对应优先级队列的尾部((POSIX 1003.1)。当所有高优先级的线程终止或者阻塞时，它将被运行。对于相同优先级别的线程，按照简单的先进先运行的规则运行。我们考虑一种很坏的情况，如果有若干相同优先级的线程等待执行，然而最早执行的线程无终止或者阻塞动作，那么其他线程是无法执行的，除非当前线程调用如pthread\_yield之类的函数，所以在使用SCHED\_FIFO的时候要小心处理相同级别线程的动作。 （百度百科）

SCHED\_RR：轮循 调度策略，除了考虑优先级之外，还加入了时间片的限制。当一个线程执行完了一个时间片，并且有其它的SCHED\_RR或者SCHED\_FIFO调度策略的相同优先级的线程准备好时，运行线程将被准备好的线程抢占。

鉴于SCHED\_FIFO调度策略的一些缺点，SCHED\_RR对SCHED\_FIFO做出了一些增强功能。从实质上看，它还是SCHED\_FIFO调用策略。它使用最大运行时间来限制当前进程的运行，当运行时间大于等于最大运行时间的时候，当前线程将被切换并放置于相同优先级队列的最后。这样做的好处是其他具有相同级别的线程能在“自私“线程下执行。 （百度百科）

SCHED\_OTHER：是Linux默认的分时调度策略。

它是默认的线程分时调度策略，所有的线程的优先级别都是0，线程的调度是通过分时来完成的。简单地说，如果系统使用这种调度策略，程序将无法设置线程的优先级。请注意，这种调度策略也是抢占式的，当高优先级的线程准备运行的时候，当前线程将被抢占并进入等待队列。这种调度策略仅仅决定线程在可运行线程队列中的具有相同优先级的线程的运行次序。 （百度百科）

优先级 priority: 各个调度策略支持的最大和最小的优先级可以通过下面的两个函数获得。

1.  \#include <sched.h>  
    
2.    
    
3.  int sched\_get\_priority\_max(int policy);  
    
4.  int sched\_get\_priority\_min(int policy);

调度参数 sched\_param：调度参数由一个结构体给出

1.  struct sched\_param \{   
    
2.  //... ....  
    
3.  int sched\_priority; /\* Scheduling priority \*/  
    
4.  //... ....  
    
5.  \};

POSIX 要求结构体sched\_param至少包含调度优先级 sched\_priority 一个成员。下面两个函数分别用来设置和获得线程属性attr的调度参数param：

1.  \#include <pthread.h>  
    
2.    
    
3.  int pthread\_attr\_setschedparam(pthread\_attr\_t \*attr, const struct sched\_param \*param);  
    
4.  int pthread\_attr\_getschedparam(pthread\_attr\_t \*attr, struct sched\_param \*param);

继承调度属性 inheritsched：当我手动设置了调度策略或优先级时，必须显示的设置线程调度策略的inheritsched属性，因为pthread没有为inheritsched设置默认值。所以在改变了调度策略或优先级时必须总是设置该属性。

1.  \#include <pthread.h>  
    
2.    
    
3.  int pthread\_attr\_setinheritsched(pthread\_attr\_t \*attr, int inheritsched);  
    
4.  int pthread\_attr\_getinheritsched(pthread\_attr\_t \*attr, int \*inheritsched);

第一个函数中inheritsched的取值为：PTHREAD\_INHERIT\_SCHED 或者 PTHREAD\_EXPLICIT\_SCHED。

前者为继承创建线程的调度策略和优先级，后者指定不继承调度策略和优先级，而是使用自己设置的调度策略和优先级。

无论何时，当你需要控制一个线程的调度策略或优先级时，必须将inheritsched属性设置为PTHREAD\_EXPLICIT\_SCHED。

注意：

1）调度策略和优先级是分开来描述的。前者使用预定义的SCHED\_RR、SCHED\_FIFO、SCHED\_OTHER，后者是通过结果体struct sched\_param给出的。

2）这些设置调度策略和优先级的函数操作的对象是线程的属性pthread\_attr\_t，而不是直接来操作线程的调度策略和优先级的。函数的第一个参数都是pthread\_attr\_t。

实例：（《POSIX多线程程序设计》 ）

1.  \#include <unistd.h>
2.  \#include <pthread.h>  
    
3.  \#include <sched.h>  
    
4.  \#include "errors.h"  
    
5.    
    
6.  void \*thread\_routine(void \*arg)
7.  \{   
    
8.  int my\_policy;  
    
9.  struct sched\_param my\_param;  
    
10.   
    
11. \#if defined(\_POSIX\_THREAD\_PRIORITY\_SCHEDULING) && !defined(sun)
12. pthread\_getschedparam(pthread\_self(), &my\_policy, &my\_param);  
    
13. printf("thread\_routine running at %s/%d\\n",  
    
14. (my\_policy == SCHED\_FIFO ? "FIFO"  
    
15. : (my\_policy == SCHED\_RR ? "RR"  
    
16. : (my\_policy == SCHED\_OTHER ? "OTHER"  
    
17. : "unknown"))),  
    
18. my\_param.sched\_priority);  
    
19. \#else  
    
20. printf("thread\_routine running\\n");  
    
21. \#endif  
    
22. return NULL;  
    
23. \}  
    
24.   
    
25. int main(int argc, char \*argv\[\])  
    
26. \{   
    
27. pthread\_t thread\_id;  
    
28. pthread\_attr\_t thread\_attr;  
    
29. int thread\_policy;  
    
30. struct sched\_param thread\_param;  
    
31. int status, rr\_min\_priority, rr\_max\_priority;  
    
32.   
    
33. pthread\_attr\_init(&thread\_attr);  
    
34.   
    
35. \#if defined(\_POSIX\_THREAD\_PRIORITY\_SCHEDULING) && !defined(sun)  
    
36. pthread\_attr\_getschedpolicy(&thread\_attr, &thread\_policy);  
    
37. pthread\_attr\_getschedparam(&thread\_attr, &thread\_param);  
    
38. printf("Default policy is %s, priority is %d\\n",  
    
39. (thread\_policy == SCHED\_FIFO ? "FIFO"  
    
40. : (thread\_policy == SCHED\_RR ? "RR"  
    
41. : (thread\_policy == SCHED\_OTHER ? "OTHER"  
    
42. : "unknown"))),  
    
43. thread\_param.sched\_priority);  
    
44.   
    
45. status = pthread\_attr\_setschedpolicy(&thread\_attr, SCHED\_RR);  
    
46. if(status != 0)  
    
47. printf("Unable to set SCHED\_RR policy.\\n");  
    
48. else\{ 
49. rr\_min\_priority = sched\_get\_priority\_min(SCHED\_RR);  
    
50. if(rr\_min\_priority == \-1)  
    
51. errno\_abort("Get SCHED\_RR min priority");  
    
52. rr\_max\_priority = sched\_get\_priority\_max(SCHED\_RR);  
    
53. if(rr\_max\_priority == \-1)  
    
54. errno\_abort("Get SCHED\_RR max priority");  
    
55. thread\_param.sched\_priority = (rr\_min\_priority \+ rr\_max\_priority)/2;  
    
56. printf("SCHED\_RR priority range is %d to %d: using %d\\n",  
    
57. rr\_min\_priority, rr\_max\_priority, thread\_param.sched\_priority);  
    
58. pthread\_attr\_setschedparam(&thread\_attr, &thread\_param);  
    
59. printf("Creating thread at RR/%d\\n", thread\_param.sched\_priority);  
    
60. pthread\_attr\_setinheritsched(&thread\_attr, PTHREAD\_EXPLICIT\_SCHED);  
    
61. \}  
    
62. \#else  
    
63. printf("Priority scheduling not supported\\n");  
    
64. \#endif  
    
65. pthread\_create(&thread\_id, &thread\_attr, thread\_routine, NULL);  
    
66. pthread\_join(thread\_id, NULL);  
    
67. printf("Main exiting\\n");
68. return 0;  
    
69. \}

运行结果：

1.  digdeep@ubuntu:~/pthread/learnthread$ ./sched\_attr  
    
2.  Default policy is OTHER, priority is 0  
    
3.  SCHED\_RR priority range is 1 to 99: using 50  
    
4.  Creating thread at RR/50  
    
5.  Main exiting

直接设置正在运行的线程的调度策略和优先级：(动态设置线程的调度策略和优先级)

上面提到，前面的那些函数只能通过线程的属性对象 pthread\_attr\_t 来设置线程的调度策略和优先级，不能够直接设置正在运行的线程的调度策略和优先级。下面的函数可以直接设置：

1.  \#include <pthread.h>  
    
2.    
    
3.  pthread\_setschedparam(pthread\_t thread, int policy, const struct sched\_param \*param);
4.  pthread\_getschedparam(pthread\_t thread, int \*policy, struct sched\_param \*param);

但是注意：当 pthread\_setschedparam函数的参数 policy == SCHED\_RR 或者 SCHED\_FIFO 时，程序必须要在超级用户下运行！！！

实例： （《POSIX多线程程序设计》 ）

1.  /\*  
    
2.  \* sched\_thread.c  
    
3.  \* Demonstrate dynamic scheduling policy use.  
    
4.  \*/  
    
5.  \#include <unistd.h>  
    
6.  \#include <pthread.h>  
    
7.  \#include <sched.h>  
    
8.  \#include "errors.h"  
    
9.    
    
10. \#define THREADS 5  
    
11.   
    
12. typedef struct thread\_tag \{   
    
13. int index;  
    
14. pthread\_t id;  
    
15. \} thread\_t;  
    
16.   
    
17. thread\_t threads\[THREADS\];  
    
18. int rr\_min\_priority;  
    
19.   
    
20. void \*thread\_routine(void \*arg)  
    
21. \{   
    
22. thread\_t \*self = (thread\_t \*)arg;  
    
23. struct sched\_param my\_param;  
    
24. int my\_policy;  
    
25. int status;  
    
26.   
    
27. my\_param.sched\_priority = rr\_min\_priority \+ self\->index;  
    
28. if(pthread\_setschedparam(self\->id, SCHED\_RR, &my\_param) != 0)
29. printf("pthread\_setschedparam failed\\n");  
    
30. pthread\_getschedparam(self\->id, &my\_policy, &my\_param);  
    
31. printf("thread\_routine %d running at %s/%d\\n",  
    
32. self\->index,  
    
33. (my\_policy == SCHED\_FIFO ? "FIFO"  
    
34. : (my\_policy == SCHED\_RR ? "RR"  
    
35. : (my\_policy == SCHED\_OTHER ? "OTHER"  
    
36. : "unknown"))),  
    
37. my\_param.sched\_priority);  
    
38.   
    
39. return NULL;  
    
40. \}  
    
41.   
    
42. int main(int argc, char \*argv\[\])  
    
43. \{   
    
44. int count;  
    
45.   
    
46. rr\_min\_priority = sched\_get\_priority\_min(SCHED\_RR);  
    
47. if(rr\_min\_priority == \-1)\{   
    
48. errno\_abort("Get SCHED\_RR min priority");
49. \}  
    
50. for(count = 0; count < THREADS; count\+\+)\{   
    
51. threads\[count\].index = count;  
    
52. pthread\_create(&threads\[count\].id, NULL,  
    
53. thread\_routine, (void \*)&threads\[count\]);  
    
54. \}  
    
55. for(count = 0; count < THREADS; count\+\+)\{   
    
56. pthread\_join(threads\[count\].id, NULL);  
    
57. \}  
    
58. printf("Main exiting\\n");  
    
59.   
    
60. return 0;  
    
61. \}

运行结果：

1.  digdeep@ubuntu:~/pthread/learnthread$ gcc \-Wall \-lpthread \-o sched\_thread sched\_thread.c  
    
2.  digdeep@ubuntu:~/pthread/learnthread$ ./sched\_threadpthread\_setschedparam failed  
    
3.  pthread\_setschedparam failed  
    
4.  pthread\_setschedparam failed  
    
5.  thread\_routine 1 running at OTHER/0  
    
6.  thread\_routine 3 running at OTHER/0  
    
7.  pthread\_setschedparam failed  
    
8.  pthread\_setschedparam failed  
    
9.  thread\_routine 2 running at OTHER/0  
    
10. thread\_routine 4 running at OTHER/0  
    
11. thread\_routine 0 running at OTHER/0  
    
12. Main exiting  
    
13. digdeep@ubuntu:~/pthread/learnthread$ sudo ./sched\_thread
14. \[sudo\] password for digdeep:  
    
15. thread\_routine 1 running at RR/2  
    
16. thread\_routine 3 running at RR/4  
    
17. thread\_routine 2 running at RR/3  
    
18. thread\_routine 0 running at RR/1  
    
19. thread\_routine 4 running at RR/5  
    
20. Main exiting  
    
21. digdeep@ubuntu:~/pthread/learnthread$

从上面的运行结果可以看出：在第一次执行 ./sched\_thread 时，函数 pthread\_setschedparam(self\->id, SCHED\_RR, &my\_param) 调用失败了，在第二次运行时：

sudo ./sched\_thread (输入密码)时，函数 pthread\_setschedparam(self\->id, SCHED\_RR, &my\_param) 调用成功。

将SCHED\_RR换成SCHED\_FIFO，结果也是一样的。

另：利 pthread\_setschedparam  函数改变在运行线程的调度策略和优先级肯定就不用调用函数来设置inheritsched属性了： pthread\_attr\_setinheritsched(&thread\_attr, PTHREAD\_EXPLICIT\_SCHED);  因为该函数设置的对象是pthread\_attr\_t !!!