Linux 线程调度与优先级

秒速五厘米 2022-06-05 11:49 194阅读 0赞

Linux内核的三种调度策略：  
  
　　1，SCHED\_OTHER 分时调度策略，  
　　2，SCHED\_FIFO实时调度策略，先到先服务。一旦占用cpu则一直运行。一直运行直到有更高优先级任务到达或自己放弃

3，SCHED\_RR实时调度策略，时间片轮转。当进程的时间片用完，系统将重新分配时间片，并置于就绪队列尾。放在队列尾保证了所有具有相同优先级的RR任务的调度公平

Linux线程优先级设置  
   首先，可以通过以下两个函数来获得线程可以设置的最高和最低优先级，函数中的策略即上述三种策略的宏定义：  
  
　　int sched\_get\_priority\_max(int policy);  
  
　　int sched\_get\_priority\_min(int policy);  
  
　 SCHED\_OTHER是不支持优先级使用的，而SCHED\_FIFO和SCHED\_RR支持优先级的使用，他们分别为1和99，数值越大优先级越高。  
设置和获取优先级通过以下两个函数

`   系统创建线程时，默认的线程是SCHED_OTHER。所以如果我们要改变线程的调度策略的话，可以通过下面的这个函数实现。`

上面的param使用了下面的这个数据结构：

我们可以通过下面的测试程序来说明，我们自己使用的系统的支持的优先级：

<table style="margin:0px; padding:0px; border:1px solid silver; border-collapse:collapse; word-break:break-word; width:947px"> 
 <tbody style="margin:0px; padding:0px"> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> <code style="margin:0px; padding:0px">#include&nbsp;&lt;stdio.h&gt; #include&nbsp;&lt;pthread.h&gt; #include&nbsp;&lt;sched.h&gt; #include&nbsp;&lt;assert.h&gt; static&nbsp;int&nbsp;get_thread_policy(pthread_attr_t&nbsp;*attr) { &nbsp;&nbsp;int&nbsp;policy; &nbsp;&nbsp;int&nbsp;rs&nbsp;=&nbsp;pthread_attr_getschedpolicy(attr,&amp;policy); &nbsp;&nbsp;assert(rs==0); &nbsp;&nbsp;switch(policy) &nbsp;&nbsp;{ &nbsp;&nbsp;case&nbsp;SCHED_FIFO: &nbsp;&nbsp;&nbsp;&nbsp;printf("policy= SCHED_FIFO\n"); &nbsp;&nbsp;&nbsp;&nbsp;break; &nbsp;&nbsp;case&nbsp;SCHED_RR: &nbsp;&nbsp;&nbsp;&nbsp;printf("policy= SCHED_RR"); &nbsp;&nbsp;&nbsp;&nbsp;break; &nbsp;&nbsp;case&nbsp;SCHED_OTHER: &nbsp;&nbsp;&nbsp;&nbsp;printf("policy=SCHED_OTHER\n"); &nbsp;&nbsp;&nbsp;&nbsp;break; &nbsp;&nbsp;default: &nbsp;&nbsp;&nbsp;&nbsp;printf("policy=UNKNOWN\n"); &nbsp;&nbsp;&nbsp;&nbsp;break; &nbsp;&nbsp;} &nbsp;&nbsp;return&nbsp;policy; } static&nbsp;void&nbsp;show_thread_priority(pthread_attr_t&nbsp;*attr,int&nbsp;policy) { &nbsp;&nbsp;int&nbsp;priority&nbsp;=&nbsp;sched_get_priority_max(policy); &nbsp;&nbsp;assert(priority!=-1); &nbsp;&nbsp;printf("max_priority=%d\n",priority); &nbsp;&nbsp;priority=&nbsp;sched_get_priority_min(policy); &nbsp;&nbsp;assert(priority!=-1); &nbsp;&nbsp;printf("min_priority=%d\n",priority); } static&nbsp;int&nbsp;get_thread_priority(pthread_attr_t&nbsp;*attr) { &nbsp;&nbsp;struct&nbsp;sched_param param; &nbsp;&nbsp;int&nbsp;rs&nbsp;=&nbsp;pthread_attr_getschedparam(attr,&amp;param); &nbsp;&nbsp;assert(rs==0); &nbsp;&nbsp;printf("priority=%d",param.__sched_priority); &nbsp;&nbsp;return&nbsp;param.__sched_priority; } static&nbsp;void&nbsp;set_thread_policy(pthread_attr_t&nbsp;*attr,int&nbsp;policy) { &nbsp;&nbsp;int&nbsp;rs&nbsp;=&nbsp;pthread_attr_setschedpolicy(attr,policy); &nbsp;&nbsp;assert(rs==0); &nbsp;&nbsp;get_thread_policy(attr); } int&nbsp;main(void) { &nbsp;&nbsp;pthread_attr_t&nbsp;attr; &nbsp;&nbsp;struct&nbsp;sched_param sched; &nbsp;&nbsp;int&nbsp;rs; &nbsp;&nbsp;rs&nbsp;=&nbsp;pthread_attr_init(&amp;attr); &nbsp;&nbsp;assert(rs==0); &nbsp;&nbsp;int&nbsp;policy&nbsp;=&nbsp;get_thread_policy(&amp;attr); &nbsp;&nbsp;printf("Show current configuration of priority\n"); &nbsp;&nbsp;&nbsp;&nbsp;show_thread_priority(&amp;attr,policy); &nbsp;&nbsp;printf("show SCHED_FIFO of priority\n"); &nbsp;show_thread_priority(&amp;attr,SCHED_FIFO); &nbsp;&nbsp;printf("show SCHED_RR of priority\n"); &nbsp;&nbsp;show_thread_priority(&amp;attr,SCHED_RR); &nbsp;&nbsp;printf("show priority of current thread\n"); &nbsp;&nbsp;int&nbsp;priority&nbsp;=&nbsp;get_thread_priority(&amp;attr); &nbsp;&nbsp;printf("Set thread policy\n"); &nbsp;&nbsp;printf("set SCHED_FIFO policy\n"); &nbsp;&nbsp;set_thread_policy(&amp;attr,SCHED_FIFO); &nbsp;&nbsp;printf("set SCHED_RR policy\n"); &nbsp;&nbsp;set_thread_policy(&amp;attr,SCHED_RR); &nbsp;&nbsp;printf("Restore current policy\n"); &nbsp;&nbsp;set_thread_policy(&amp;attr,policy); &nbsp;&nbsp;rs&nbsp;=&nbsp;pthread_attr_destroy(&amp;attr); &nbsp;&nbsp;assert(rs==0); &nbsp;&nbsp;return&nbsp;0; } </code> </td> 
 </tr> 
 </tbody> 
</table>

下面是测试程序的运行结果：

这里测试一下其中的两种特性，SCHED\_OTHER和SCHED\_RR，还有就是优先级的问题，是不是能够保证，高优先级的线程，就可以保证先运行。  
    下面的这个测试程序，创建了三个线程，默认创建的线程的调度策略是SCHED\_OTHER，其余的两个线程的调度策略设置成SCHED\_RR。我的Linux的内核版本是2.6.31。SCHED\_RR是根据时间片来确定线程的调度。时间片用完了，不管这个线程的优先级有多高都不会在运行，而是进入就绪队列中，等待下一个时间片的到了，那这个时间片到底要持续多长时间？在《深入理解Linux内核》中的第七章进程调度中，是这样描诉的，Linux采取单凭经验的方法，即选择尽可能长、同时能保持良好相应时间的一个时间片。这里也没有给出一个具体的时间来，可能会根据不同的CPU 来定，还有就是多CPU 的情况。

<table style="margin:0px; padding:0px; border:1px solid silver; border-collapse:collapse; word-break:break-word; color:rgb(0,0,0); font-family:Verdana,Arial,Helvetica,sans-serif; font-size:13px; width:947px"> 
 <tbody style="margin:0px; padding:0px"> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> <code style="margin:0px; padding:0px">#include&nbsp;&lt;stdio.h&gt; #include&nbsp;&lt;unistd.h&gt; #include&nbsp;&lt;stdlib.h&gt; #include&nbsp;&lt;pthread.h&gt; void&nbsp;Thread1() { &nbsp;&nbsp;sleep(1); &nbsp;&nbsp;int&nbsp;i,j; &nbsp;&nbsp;int&nbsp;policy; &nbsp;&nbsp;struct&nbsp;sched_param param; &nbsp;&nbsp;pthread_getschedparam(pthread_self(),&amp;policy,&amp;param); &nbsp;&nbsp;if(policy&nbsp;==&nbsp;SCHED_OTHER) &nbsp;&nbsp;&nbsp;&nbsp;printf("SCHED_OTHER\n"); &nbsp;&nbsp;if(policy&nbsp;==&nbsp;SCHED_RR); &nbsp;&nbsp;printf("SCHED_RR 1 \n"); &nbsp;&nbsp;if(policy==SCHED_FIFO) &nbsp;&nbsp;&nbsp;&nbsp;printf("SCHED_FIFO\n"); &nbsp;&nbsp;for(i=1;i&lt;10;i++) &nbsp;&nbsp;{ &nbsp;&nbsp;&nbsp;&nbsp;for(j=1;j&lt;5000000;j++) &nbsp;&nbsp;&nbsp;&nbsp;{ &nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;printf("thread 1\n"); &nbsp;&nbsp;} &nbsp;&nbsp;printf("Pthread 1 exit\n"); } void&nbsp;Thread2() { &nbsp;&nbsp;sleep(1); &nbsp;&nbsp;int&nbsp;i,j,m; &nbsp;&nbsp;int&nbsp;policy; &nbsp;&nbsp;struct&nbsp;sched_param param; pthread_getschedparam(pthread_self(),&amp;policy,&amp;param); &nbsp;if(policy&nbsp;==&nbsp;SCHED_OTHER) &nbsp;&nbsp;&nbsp;&nbsp;printf("SCHED_OTHER\n"); &nbsp;&nbsp;if(policy&nbsp;==&nbsp;SCHED_RR); &nbsp;&nbsp;printf("SCHED_RR\n"); &nbsp;&nbsp;if(policy==SCHED_FIFO) &nbsp;&nbsp;&nbsp;&nbsp;printf("SCHED_FIFO\n"); &nbsp;&nbsp;for(i=1;i&lt;10;i++) &nbsp;&nbsp;{ &nbsp;&nbsp;&nbsp;&nbsp;for(j=1;j&lt;5000000;j++) &nbsp;&nbsp;&nbsp;&nbsp;{ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;printf("thread 2\n"); &nbsp;&nbsp;} &nbsp;&nbsp;printf("Pthread 2 exit\n"); } void&nbsp;Thread3() { &nbsp;&nbsp;sleep(1); &nbsp;&nbsp;int&nbsp;i,j; &nbsp;&nbsp;int&nbsp;policy; &nbsp;&nbsp;struct&nbsp;sched_param param; pthread_getschedparam(pthread_self(),&amp;policy,&amp;param); &nbsp;if(policy&nbsp;==&nbsp;SCHED_OTHER) &nbsp;&nbsp;&nbsp;&nbsp;printf("SCHED_OTHER\n"); &nbsp;&nbsp;if(policy&nbsp;==&nbsp;SCHED_RR) &nbsp;&nbsp;&nbsp;&nbsp;printf("SCHED_RR \n"); &nbsp;&nbsp;if(policy==SCHED_FIFO) &nbsp;&nbsp;&nbsp;&nbsp;printf("SCHED_FIFO\n"); &nbsp;&nbsp;for(i=1;i&lt;10;i++) &nbsp;&nbsp;{ &nbsp;&nbsp;&nbsp;&nbsp;for(j=1;j&lt;5000000;j++) &nbsp;&nbsp;&nbsp;&nbsp;{ &nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;printf("thread 3\n"); &nbsp;&nbsp;} &nbsp;&nbsp;printf("Pthread 3 exit\n"); } int&nbsp;main() { &nbsp;&nbsp;int&nbsp;i; &nbsp;&nbsp;i&nbsp;=&nbsp;getuid(); &nbsp;&nbsp;if(i==0) &nbsp;&nbsp;&nbsp;&nbsp;printf("The current user is root\n"); &nbsp;&nbsp;else &nbsp;&nbsp;&nbsp;&nbsp;printf("The current user is not root\n"); &nbsp;&nbsp;pthread_t&nbsp;ppid1,ppid2,ppid3; &nbsp;&nbsp;struct&nbsp;sched_param param; &nbsp;&nbsp;pthread_attr_t&nbsp;attr,attr1,attr2; &nbsp;&nbsp; &nbsp;&nbsp;pthread_attr_init(&amp;attr1); pthread_attr_init(&amp;attr); pthread_attr_init(&amp;attr2); &nbsp;</code><code style="margin:0px; padding:0px">&nbsp;param.sched_priority&nbsp;=&nbsp;51;</code> <code style="margin:0px; padding:0px">&nbsp;pthread_attr_setschedpolicy(&amp;attr2,SCHED_RR); &nbsp;pthread_attr_setschedparam(&amp;attr2,&amp;param); &nbsp;pthread_attr_setinheritsched(&amp;attr2,PTHREAD_EXPLICIT_SCHED);//要使优先级其作用必须要有这句话 &nbsp;param.sched_priority&nbsp;=&nbsp;21; &nbsp;pthread_attr_setschedpolicy(&amp;attr1,SCHED_RR); &nbsp;pthread_attr_setschedparam(&amp;attr1,&amp;param); &nbsp;pthread_attr_setinheritsched(&amp;attr1,PTHREAD_EXPLICIT_SCHED); &nbsp; &nbsp;pthread_create(&amp;ppid3,&amp;attr,(void&nbsp;*)Thread3,NULL); &nbsp;pthread_create(&amp;ppid2,&amp;attr1,(void&nbsp;*)Thread2,NULL); &nbsp;pthread_create(&amp;ppid1,&amp;attr2,(void&nbsp;*)Thread1,NULL); &nbsp; &nbsp;pthread_join(ppid3,NULL); &nbsp;pthread_join(ppid2,NULL); &nbsp;pthread_join(ppid1,NULL); &nbsp;pthread_attr_destroy(&amp;attr2); &nbsp;pthread_attr_destroy(&amp;attr1); &nbsp;return&nbsp;0; } </code> </td> 
 </tr> 
 </tbody> 
</table>

下面是该程序的其中之一的运行结果：                ** 注意运行时必须加sudo权限，才能进行优先级抢占**

这里我们可以看到，由于**线程3的调度策略是SCHED\_OTHER**，而**线程2的调度策略是SCHED\_RR**，所以，在Thread3中，线程3被线程1，线程2给抢占了。由于线程1的优先级大于线程2的优先级，所以，在线程1以先于线程2运行，不过，这里线程2有一部分代码还是先于线程1运行了。  
    我原以为，**只要线程的优先级高，就会一定先运行，其实，这样的理解是片面的，特别是在SMP的PC机上更会增加其不确定性。**  
    其实，**普通进程的调度，是CPU根据进程优先级算出时间片，这样并不能一定保证高优先级的进程一定先运行，只不过和优先级低的进程相比，通常优先级较高的进程获得的CPU时间片会更长而已**。其实，如果要想保证一个线程运行完在运行另一个线程的话，就要使用多线程的同步技术，信号量，条件变量等方法。而不是绝对依靠优先级的高低，来保证。  
    不过，从运行的结果上，我们可以看到，调度策略为SCHED\_RR的线程1，线程2确实抢占了调度策略为SCHED\_OTHER的线程3。这个是可以理解的，由于SCHER\_RR是实时调度策略。  
   只有在下述事件之一发生时，实时进程才会被另外一个进程取代。  
  （1） 进程被另外一个具有更高实时优先级的实时进程抢占。  
  （2） 进程执行了阻塞操作并进入睡眠  
  （3）进程停止（处于TASK\_STOPPED 或TASK\_TRACED状态）或被杀死。  
  （4）进程通过调用系统调用sched\_yield()，自愿放弃CPU 。  
  （5）进程基于时间片轮转的实时进程（SCHED\_RR），而且用完了它的时间片。  
   基于时间片轮转的实时进程是，不是真正的改变进程的优先级，而是改变进程的基本时间片的长度。所以基于时间片轮转的进程调度，并不能保证高优先级的进程先运行。  
   下面是另一种运行结果：

可以看出并没有每一次都保证高优先级的线程先运行。

转自：

https://www.cnblogs.com/xiaotlili/p/3510224.html

[http://blog.chinaunix.net/uid-20788636-id-1841334.html][http_blog.chinaunix.net_uid-20788636-id-1841334.html]

[http://blog.chinaunix.net/uid-20788636-id-1841335.html][http_blog.chinaunix.net_uid-20788636-id-1841335.html]

\-----------------------------------------------------------------------------------------------------------------------------------------------------------------------

# Linux编程-线程优先级的设定 #

最近在学习Linux的编程，这里在博客中记录一下学习的过程。

对于线程的优先级设定，在网上也看了不少的文章，大多数都只介绍了一个线程，关键是介绍的例程，设置的线程优先级都不起作用。由于之前接触的Linux编程知识比较少，这个问题困扰了我一晚上。于是接着在网上看资料，终于能够使线程的优先级设置有效。

1、相关知识介绍

首先总结一下，线程优先级设置的条件：

a、线程的**调度策略**必须为：SCHED\_RR或SCHED\_FIFO；

b、线程的**继承策略**必须为：PTHREAD\_EXPLICIT\_SCHED

对于继承策略，这里举个简单的例子：

如果线程A创建了线程B，则线程B的调度策略与线程A的调度策略和线程B的继承策略有关的：

如果线程B继承策略为PTHREAD\_INHERIT\_SCHED，则线程B的调度策略与线程A相同，线程B的优先级也与线程A相同，但是线程B不能够自己修改调度策略与优先级（个人理解，不对请指教）；

如果线程B**继承策略**为**PTHREAD\_EXPLICIT\_SCHED**，则线程B的调度策略由线程属性attr决定，**可以自行设置调度策略与优先级。**

其中**继承策略必须为PTHREAD\_EXPLICIT\_SCHED，否则设置线程的优先级会被忽略**。

2、程序示例：

在**设置继承的调度策略** 时，只有**具有root权限的用户才能执行pthread\_attr\_setinheritsched操作，否则创建线程会失败。**

下面是一个简单的设置优先级的程序示例，通过修改任务1与任务2的优先级高低，可以观察到打印信息中，先打印的是优先级高的任务的信息：

/*
 ********************************************************************************
 *描述:设置线程优先级
 *Use:gcc prio.c -lpthread
 *By:Ailson Jack
 *Date:2016.03.25
 *Blog:www.only2fire.com
 ********************************************************************************
 */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <string.h>
 #include <time.h>
 
 //在用户层或者应用层,1表示优先级最低,99表示优先级最高
 #define Task1_Prio 6
 #define Task2_Prio 7
 
 pthread_barrier_t barrier;
 
 void *Task1(void *arg);
 void *Task2(void *arg);
 
 int main(void)
 {
 int policy,inher;
 pthread_t tid;
 pthread_attr_t attr;
 struct sched_param param;
 
 pthread_barrier_init(&barrier,NULL,2+1);
 
 //初始化线程属性
 pthread_attr_init(&attr);
 //获取继承的调度策略
 pthread_attr_getinheritsched(&attr,&inher);
 
 if(inher == PTHREAD_EXPLICIT_SCHED)
 printf("PTHREAD_EXPLICIT_SCHED\r\n");
 else if(inher == PTHREAD_INHERIT_SCHED)
 {
 printf("PTHREAD_INHERIT_SCHED\r\n");
 //必需设置inher的属性为 PTHREAD_EXPLICIT_SCHED,否则设置线程的优先级会被忽略
 inher = PTHREAD_EXPLICIT_SCHED;
 }
 
 //设置继承的调度策略
 //具有root权限的用户才能执行pthread_attr_setinheritsched操作,
 //否则创建线程会失败
 pthread_attr_setinheritsched(&attr,inher);
 //设置线程调度策略
 policy = SCHED_FIFO;
 pthread_attr_setschedpolicy(&attr,policy);
 //设置调度参数
 param.sched_priority = Task1_Prio;
 pthread_attr_setschedparam(&attr,¶m);
 //创建线程
 pthread_create(&tid, &attr,Task1,NULL);
 
 //设置调度参数
 param.sched_priority = Task2_Prio;
 pthread_attr_setschedparam(&attr,¶m);
 //创建线程
 pthread_create(&tid, &attr,Task2,NULL);
 
 sleep(1);
 pthread_barrier_wait(&barrier);
 pthread_join(tid, NULL);
 }
 
 void *Task1(void *arg)
 {
 pthread_barrier_wait(&barrier);
 while(1)
 {
 printf("Task1 is running.\r\n");
 sleep(3);//延时3s
 }
 pthread_exit(NULL);
 }
 
 void *Task2(void *arg)
 {
 pthread_barrier_wait(&barrier);
 while(1)
 {
 printf("Task2 is running.\r\n");
 sleep(3);//延时3s
 }
 pthread_exit(NULL);
 }

编译运行程序，由于任务2的优先级比任务1的优先级高，因此打印信息，先打印的是任务2

转自：http://blog.csdn.net/jackailson/article/details/51058094

\--------------------------------------------------------------------------------------------------------------------------------------

//我修改的。在**设置继承的调度策略** 时，只有**具有root权限的用户才能执行pthread\_attr\_setinheritsched操作，否则创建线程会失败。**

/*运行时必须加sudo权限，才能进行优先级抢占
 ********************************************************************************
 *描述:设置线程优先级
 *Use:gcc prio.c -lpthread
 *By:Ailson Jack
 *Date:2016.03.25
 *Blog:www.only2fire.com
 ********************************************************************************
 */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <string.h>
 #include <time.h>
 
 //在用户层或者应用层,1表示优先级最低,99表示优先级最高
 #define Task1_Prio 6
 #define Task2_Prio 7
 
 
 void *Task1(void *arg);
 void *Task2(void *arg);
 
 int main(void)
 {
 int policy,inher;
 pthread_t tid1,tid2;
 pthread_attr_t attr;
 struct sched_param param;
 int i;
 
 	 i = getuid();
 	 if(i==0)
 	 printf("The current user is root\n");
 	 else
 	 printf("The current user is not root\n");
 	 
 
 //初始化线程属性
 pthread_attr_init(&attr);
 //获取继承的调度策略
 pthread_attr_getinheritsched(&attr,&inher);
 
 if(inher == PTHREAD_EXPLICIT_SCHED)
 printf("PTHREAD_EXPLICIT_SCHED\r\n");
 else if(inher == PTHREAD_INHERIT_SCHED)
 {
 printf("PTHREAD_INHERIT_SCHED\r\n");
 //必需设置inher的属性为 PTHREAD_EXPLICIT_SCHED,否则设置线程的优先级会被忽略
 inher = PTHREAD_EXPLICIT_SCHED;
 }
 
 //设置继承的调度策略
 //具有root权限的用户才能执行pthread_attr_setinheritsched操作,
 //否则创建线程会失败
 pthread_attr_setinheritsched(&attr,inher);
 //设置线程调度策略
 policy = SCHED_FIFO;
 pthread_attr_setschedpolicy(&attr,policy);
 //设置调度参数
 param.sched_priority = Task1_Prio;
 pthread_attr_setschedparam(&attr,¶m);
 //创建线程
 pthread_create(&tid1, &attr,Task1,NULL);
 
 
 
 //设置调度参数
 param.sched_priority = Task2_Prio;
 pthread_attr_setschedparam(&attr,¶m);
 //创建线程
 pthread_create(&tid2, &attr,Task2,NULL);
 
 sleep(1);
 pthread_join(tid1, NULL);
 pthread_join(tid2, NULL);
 pthread_attr_destroy(&attr);
 }
 
 void *Task1(void *arg)
 {
 while(1)
 {
 printf("Task1 is running.\r\n");
 sleep(3);//延时3s
 }
 pthread_exit(NULL);
 }
 
 void *Task2(void *arg)
 {
 while(1)
 {
 printf("Task2 is running.\r\n");
 sleep(3);//延时3s
 }
 pthread_exit(NULL);
 }

编译、运行：  
gcc -o priority2 priority2.c -lpthread

sudo ./priority2

The current user is root  
PTHREAD\_INHERIT\_SCHED  
Task1 is running.  
Task2 is running.  
Task2 is running.  
Task1 is running.  
Task2 is running.  
Task1 is running.  
Task2 is running.  
Task1 is running.

在查看运行结果，可以发现  “并不是优先级高的先运行！”

我原以为，**只要线程的优先级高，就会一定先运行，其实，这样的理解是片面的，特别是在SMP的PC机上更会增加其不确定性。**  
    其实，**普通进程的调度，是CPU根据进程优先级算出时间片，这样并不能一定保证高优先级的进程一定先运行，只不过和优先级低的进程相比，通常优先级较高的进程获得的CPU时间片会更长而已**。其实，如果要想保证一个线程运行完在运行另一个线程的话，就要使用多线程的同步技术，信号量，条件变量等方法。而不是绝对依靠优先级的高低，来保证。

[http_blog.chinaunix.net_uid-20788636-id-1841334.html]: http://blog.chinaunix.net/uid-20788636-id-1841334.html
[http_blog.chinaunix.net_uid-20788636-id-1841335.html]: http://blog.chinaunix.net/uid-20788636-id-1841335.html