linux下线程优先级设定

linux内核的三种调度方法：

1，SCHED_OTHER 分时调度策略，

2，SCHED_FIFO实时调度策略，先到先服务

3，SCHED_RR实时调度策略，时间片轮转

实时进程将得到优先调用，实时进程根据实时优先级决定调度权值，分时进程则通过nice和counter值决定权值，nice越小，counter越大，被调度的概率越大，也就是曾经使用了cpu最少的进程将会得到优先调度。

SHCED_RR和SCHED_FIFO的不同：当采用SHCED_RR策略的进程的时间片用完，系统将重新分配时间片，并置于就绪队列尾。放在队列尾保证了所有具有相同优先级的RR任务的调度公平。

SCHED_FIFO一旦占用cpu则一直运行。一直运行直到有更高优先级任务到达或自己放弃。如果有相同优先级的实时进程（根据优先级计算的调度权值是一样的）已经准备好，FIFO时必须等待该进程主动放弃后才可以运行这个优先级相同的任务。而RR可以让每个任务都执行一段时间。

01.#include    <stdio.h>   
02.#include    <stdlib.h>   
03.#include    <unistd.h>   
04.#include    <pthread.h>   
05.#include    <signal.h>   
06.#include    <string.h>   
07.void * thr_fun(void *arg)  
08.{  
09.    int policy, ret;  
10.    struct sched_param param;  
11.    //获取线程调度参数   
12.    ret = pthread_getschedparam(pthread_self(), &policy, ¶m);  
13.    if(ret!=0)  
14.    {  
15.        printf("pthread_getschedparam %s/n", strerror(ret) );  
16.        exit(1);  
17.    }  
18.    if (policy == SCHED_FIFO)  
19.    {  
20.        printf("policy:SCHED_FIFO/n");  
21.    }  
22.    else if (policy == SCHED_OTHER)  
23.    {  
24.        printf("policy:SCHED_OTHER/n");  
25.    }  
26.    else if (policy == SCHED_RR)  
27.    {  
28.        printf("policy:SCHED_RR/n");  
29.    }  
30.    printf("param:%d/n", param.sched_priority);   
31.    long long i;  
32.    while (1) {  
33.        i++;  
34.        i *= 2;  
35.    }  
36.    pthread_exit(NULL);   
37.}  
38.int main(void)  
39.{  
40.    int ret;  
41.    pthread_t tid;  
42.    pthread_attr_t attr;  
43.    int policy, inher;  
44.    struct sched_param param;  
45.      
46.    //初始化线程属性   
47.    pthread_attr_init(&attr);  
48.    //获取继承的调度策略   
49.    ret = pthread_attr_getinheritsched(&attr, &inher);  
50.    if (ret!=0)  
51.    {  
52.        printf("pthread_attr_getinheritsched/n%s/n", strerror(ret));  
53.        exit(1);  
54.    }  
55.    //   
56.    if (inher == PTHREAD_EXPLICIT_SCHED)   
57.    {  
58.        printf("PTHREAD_EXPLICIT_SCHED/n");  
59.    }  
60.    else if (inher == PTHREAD_INHERIT_SCHED)   
61.    {     
62.        printf("PTHREAD_INHERIT_SCHED/n");  
63.        inher = PTHREAD_EXPLICIT_SCHED;  
64.    }  
65.    //设置继承的调度策略   
66.    //必需设置inher的属性为 PTHREAD_EXPLICIT_SCHED，否则设置线程的优先级会被忽略   
67.    ret = pthread_attr_setinheritsched(&attr, inher);  
68.    if (ret!=0)  
69.    {  
70.        printf("pthread_attr_setinheritsched/n%s/n", strerror(ret));  
71.        exit(1);  
72.    }  
73.      
74.    policy = SCHED_FIFO;//在Ubuntu9.10上需要root权限   
75.    //设置线程调度策略   
76.    ret = pthread_attr_setschedpolicy(&attr, policy);  
77.    if (ret!=0)  
78.    {  
79.        printf(" pthread_attr_setschedpolicy/n%s/n", strerror(ret));  
80.        exit(1);  
81.    }  
82.    param.sched_priority = 3;  
83.    //设置调度参数   
84.    ret = pthread_attr_setschedparam(&attr, ¶m);  
85.    if (ret!=0)  
86.    {  
87.        printf(" pthread_attr_setschedparam/n%s/n", strerror(ret));  
88.        exit(1);  
89.    }  
90.    //创建线程   
91.    ret = pthread_create(&tid, &attr, thr_fun, NULL);  
92.    if (ret!=0)  
93.    {  
94.        printf("pthread_create/n%s/n", strerror(ret));  
95.        exit(1);  
96.    }  
97.    while (1) {  
98.        printf("hello world/n");  
99.    }  
100.    pthread_join(tid, NULL);  
101.    pthread_exit(NULL);  
102.}  

root@# top -H

Priority 15 FIFO [99-100-15=-16]???

root@:/proc/1699/task/1762# cat sched  

99-15 =84 realtime:99-99=0[realtime]

0 SCHED_OTHER
1.SCHED_FIFO
2.SCHED_RR