基础知识

1. Linux 内核当中有 3 种调度策略：
   • SCHED_OTHER 分时调度策略；
   • SCHED_FIFO 实时调度策略，先到先服务；
   • SCHED_RR 实时调度策略，时间片轮转。

如果有相同优先级的实时进程（根据优先级计算的调度权值是一样的）已经准备好，FIFO 时必须等待该进程主动放弃之后才可以运行这个优先级相同的任务。而 RR 可以每个任务都执行一段时间。

2. 获取线程设置的最高和最低优先级函数
   • int sched_get_priority_max(int policy)获取实时优先级的最大值；
   • int sched_get_priority_min(int policy)获取实时优先级的最小值；

SCHED_OTHER它 不 支 持 优 先 级 使 用 ， 而SCHED_RR/SCHED_FIFO 支持优先级使用，它们分别为 1-99，数值越大优先级越高。

实时调度策略（SCHED_FIFO/SCHED_RR）优先级最大值为99；普通调度策略
（SCHED_NORMAL/SCHED_BATCH/SCHED_IDLE），始终返回0，即普通任务调度的函数。

3. 设置和获取优先级的2个主要核心参数

   • int pthread_attr_setschedparam(pthread_attr_t* attr, const struct sched_param* param);设置线程优先级；
   • int pthread_attr_getschedparam(pthread_attr_t* attr, const struct sched_param* param)；获取线程优先级；

   struct sched_param {int __sched_priority; // 所有设定的线程优先级
   }param.sched_priority = 11; // 设置优先级
   

4. 当操作系统创建线程时，默认线程是 SCHED_OTHER，我们也可以通过改变调度策略，使用如下函数：

   • int pthread_attr_setschedpolicy(pthread_attr_t* attr, int policy);设置线程调度策略；

基础案例分析

1. 操作系统所支持优先级测试程序分析：

#include <stdio.h>
#include <pthread.h>
#include <sched.h>
#include <assert.h>static int GetThreadPolicyFunc(pthread_attr_t *pAttr)
{int iPlicy;int igp=pthread_attr_getschedpolicy(pAttr,&iPlicy);assert(igp==0);switch (iPlicy){case SCHED_FIFO:printf("Policy is --> SCHED_FIFO.\n");break;case SCHED_RR:printf("Policy is --> SCHED_RR.\n");break;case SCHED_OTHER:printf("Policy is --> SCHED_OTHER.\n");break;default:printf("Policy is --> Unknown.\n");break;}return iPlicy;
}static void PrintThreadPriorityFunc(pthread_attr_t *pAttr,int iPolicy)
{int iPriority=sched_get_priority_max(iPolicy); assert(iPriority!=-1);printf("Max_priority is : %d\n",iPriority);iPriority=sched_get_priority_min(iPolicy); assert(iPriority!=-1);printf("Min_priority is : %d\n",iPriority);
}static int GetThreadPriorityFunc(pthread_attr_t *pAttr)
{struct sched_param sParam;int irs=pthread_attr_getschedparam(pAttr,&sParam);assert(irs==0);printf("Priority=%d\n",sParam.__sched_priority);return sParam.__sched_priority;
}static void SetThreadPolicyFunc(pthread_attr_t *pAttr,int iPolicy)
{int irs=pthread_attr_setschedpolicy(pAttr,iPolicy);assert(irs==0);GetThreadPolicyFunc(pAttr);
}int main(int argc,char *argv[])
{pthread_attr_t pAttr;struct sched_param sched;int irs=pthread_attr_init(&pAttr);assert(irs==0);int iPlicy=GetThreadPolicyFunc(&pAttr);printf("\nExport current Configuration of priority.\n");PrintThreadPriorityFunc(&pAttr,iPlicy);printf("\nExport SCHED_FIFO of prioirty.\n");PrintThreadPriorityFunc(&pAttr,SCHED_FIFO);printf("\nExport SCHED_RR of prioirty.\n");PrintThreadPriorityFunc(&pAttr,SCHED_RR);printf("\nExport priority of current thread.\n");int iPriority=GetThreadPriorityFunc(&pAttr);printf("Set thread policy.\n");printf("\nSet SCHED_FIFO policy.\n");SetThreadPolicyFunc(&pAttr,SCHED_FIFO);printf("\nSet SCHED_RR policy.\n");SetThreadPolicyFunc(&pAttr,SCHED_RR);printf("\nRestore current policy.\n");SetThreadPolicyFunc(&pAttr,iPlicy);irs=pthread_attr_destroy(&pAttr);assert(irs==0);return 0;
}

2. 简单线程调度策略，我们创建三个线程，默认创建的线程它的调度策略为SCHED_OTHER，另外两个线程调度策略为 SCHED_RR/FIFO：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>void ThreadFunc1() {sleep(1);int i, j;int policy;struct sched_param param;pthread_getschedparam(pthread_self(), &policy, &param);switch (policy) {case SCHED_OTHER:printf("SCHED_OTHER\n");break;case SCHED_FIFO:printf("SCHED_FIFO\n");case SCHED_RR:printf("SCHED_RR Thread1\n");default:break;}for(i = 1; i <= 5; i++){for(j = 1; j <= 5000000; j++){}printf("Execute thread function 1.\n");}printf("ThreadFunc1 Exit\n");
}void ThreadFunc2() {sleep(2);int policy;struct sched_param param;pthread_getschedparam(pthread_self(), &policy, &param);switch(policy) {case SCHED_OTHER:printf("SCHED_OTHER\n");break;case SCHED_FIFO:printf("SCHED_FIFO\n");break;case SCHED_RR:printf("SCHED_RR Thread2");break;}for(int i = 1; i <= 6; i++){for(int j = 1; j <= 6000000; j++){}printf("Execute thread function 2.\n");}printf("ThreadFunc2 Exit\n");
}void ThreadFunc3() {sleep(3);int policy;struct sched_param param;pthread_getschedparam(pthread_self(), &policy, &param);switch(policy) {case SCHED_OTHER:printf("SCHED_OTHER\n");break;case SCHED_FIFO:printf("SCHED_FIFO\n");break;case SCHED_RR:printf("SCHED_RR\n");break;}for(int i = 1; i <= 7; i++) {for(int j = 0; j <= 7000000; j++){}printf("Execute thread function 3.\n");}printf("ThreadFunc3 Exit\n");
}int main(int argc, char* argv[]) {int i = 0;i = getuid();if(i == 0) {printf("The current user is root.\n\n");}else {printf("The current user is not root.\n\n");}pthread_t pid1, pid2, pid3;struct sched_param param;pthread_attr_t attr1, attr2, attr3;pthread_attr_init(&attr1);pthread_attr_init(&attr2);pthread_attr_init(&attr3);param.sched_priority = 31;pthread_attr_setschedpolicy(&attr2, SCHED_RR);pthread_attr_setschedparam(&attr2, &param);pthread_attr_setinheritsched(&attr2, PTHREAD_EXPLICIT_SCHED);param.sched_priority = 11;pthread_attr_setschedpolicy(&attr1, SCHED_FIFO);pthread_attr_setschedparam(&attr1, &param);pthread_attr_setinheritsched(&attr1, PTHREAD_EXPLICIT_SCHED);pthread_create(&pid3, &attr3, (void*)ThreadFunc3, NULL);pthread_create(&pid2, &attr2, (void*)ThreadFunc2, NULL);pthread_create(&pid1, &attr1, (void*)ThreadFunc1, NULL);pthread_join(pid3, NULL);pthread_join(pid2, NULL);pthread_join(pid1, NULL);pthread_attr_destroy(&attr3);pthread_attr_destroy(&attr2);pthread_attr_destroy(&attr1);return 0;
}

• 超级用户运行