linux线程调度策略

系统中既有分时调度，又有时间片轮转调度和先进先出调度

学习这个主要为了在linux多线程中，解决几条指令间延时在1-2ms内；
1.比如之前处理过：给一个板子发送一个can指令，接着需要给另外一个模块发送移动指令，且两则间隔要求不超过4ms；
2.比如现在又遇到一个：给一个模块发一个串口rtu指令（阻塞的），然后给另外一个模块发一个串口rtu指令（阻塞的），然后给一个板子发can移动指令，且三者之间的间隔固定，偏差不超过2ms；

linux系统默认的调度方式

对于 Linux x86 平台来说，一般采用的是 CFS：完全公平调度算法。之所以叫做完全公平，是因为操作系统以每个线程占用 CPU 的比率来进行动态的计算，操作系统希望每一个进程都能够平均的使用 CPU 这个资源，雨露均沾。

我们在创建一个线程的时候，默认就是这个调度算法 SCHED_OTHER，默认的优先级为 0。（这个我在多个平台和板子进行了验证）

Linux 系统还支持两种实时调度策略：

1. SCHED_FIFO：根据进程的优先级进行调度，一旦抢占到 CPU 则一直运行，直达自己主动放弃或被被更高优先级的进程抢占;
2. SCHED_RR：在 SCHED_FIFO 的基础上，加上了时间片的概念。当一个进程抢占到 CPU 之后，运行到一定的时间后，调度器会把这个进程放在 CPU 中，当前优先级进程队列的末尾，然后选择另一个相同优先级的进程来执行;

Linux 线程优先级

https://zhuanlan.zhihu.com/p/387806696

这张图表示的是内核中的优先级，分为两段。

前面的数值 0-99 是实时任务，后面的数值 100-139 是普通任务。

数值越低，代表这个任务的优先级越高。以上是从内核角度来看的优先级。
但是内核并不会直接使用应用层设置的这个数值，而是经过了一定的运算，才得到内核中所使用的优先级数值(0 ~ 139)。

对于实时任务

我们在创建线程的时候，可以通过下面这样的方式设置优先级数值(0 ~ 99)：

struct sched_param param;
param.__sched_priority = xxx;

当创建线程函数进入内核层面的时候，内核通过下面这个公式来计算真正的优先级数值：

kernel priority = 100 - 1 - param.__sched_priority

与内核角度是相反的！

SCHED_FIFO ： 0-99
SCHED_RR： 0-99

对于普通任务

调整普通任务的优先级，是通过 nice 值来实现的，内核中也有一个公式来把应用层传入的 nice 值，转成内核角度的优先级数值：

kernel prifoity = 100 + 20 + nice

nice 的合法数值是：-20 ~ 19。
因此，从应用层的角度看，传输人优先级数值越小，线程的优先级就越高；数值越大，优先级就越低。
与内核角度是完全相同的！

测试代码说明

// filename: test.c
#define _GNU_SOURCE
#include <unistd.h>  
#include <stdio.h>
#include <stdlib.h>
#include <sched.h>
#include <pthread.h>

// 用来打印当前的线程信息：调度策略是什么？优先级是多少？
void get_thread_info(const int thread_index)
{
    int policy;
    struct sched_param param;

    printf("\n====> thread_index = %d \n", thread_index);

    pthread_getschedparam(pthread_self(), &policy, &param);
    if (SCHED_OTHER == policy)
        printf("thread_index %d: SCHED_OTHER \n", thread_index);
    else if (SCHED_FIFO == policy)
        printf("thread_index %d: SCHED_FIFO \n", thread_index);
    else if (SCHED_RR == policy)
        printf("thread_index %d: SCHED_RR \n", thread_index);

    printf("thread_index %d: priority = %d \n", thread_index, param.sched_priority);
}

// 线程函数，
void *thread_routine(void *args)
{

		
    // 参数是：线程索引号。四个线程，索引号从 1 到 4，打印信息中使用。
    int thread_index = *(int *)args;
    
    // 为了确保所有的线程都创建完毕，让线程睡眠1秒。
    sleep(1);

    // 打印一下线程相关信息：调度策略、优先级。
    get_thread_info(thread_index);

    long num = 0;
    for (int i = 0; i < 20; i++)
    {
        for (int j = 0; j < 5000000; j++)
        {
            // 没什么意义，纯粹是模拟 CPU 密集计算。
            float f1 = ((i+1) * 345.45) * 12.3 * 45.6 / 78.9 / ((j+1) * 4567.89);
            float f2 = (i+1) * 12.3 * 45.6 / 78.9 * (j+1);
            float f3 = f1 / f2;
            
        }usleep(100000);
        
        // 打印计数信息，为了能看到某个线程正在执行
        printf("thread_index %d: num = %ld \n", thread_index, num++);
    }
    
    // 线程执行结束
    printf("thread_index %d: exit \n", thread_index);
    return 0;
}

int main(void)
{
    // 一共创建四个线程：0和1-实时线程，2和3-普通线程(非实时)
    int thread_num = 4;
    
    // 分配的线程索引号，会传递给线程参数
    int index[4] = {1, 2, 3, 4};

    // 用来保存 4 个线程的 id 号
    pthread_t ppid[4];
    
    // 用来设置 2 个实时线程的属性：调度策略和优先级
    pthread_attr_t attr[2];
    struct sched_param param[2];

    // 实时线程，必须由 root 用户才能创建
    if (0 != getuid())
    {
        printf("Please run as root \n");
        //exit(0);
    }

    // 创建 4 个线程
    for (int i = 0; i < thread_num; i++)
    {
	 
				cpu_set_t mask;
		int cpus = sysconf(_SC_NPROCESSORS_CONF);
		CPU_ZERO(&mask);
		CPU_SET(0, &mask);
		if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0)
		{
			printf("set thread affinity failed! \n");
		}	
        if (i <= 1)    // 前2个创建实时线程
        {
            // 初始化线程属性
            pthread_attr_init(&attr[i]);
            
            // 设置调度策略为：SCHED_FIFO SCHED_RR
            int res = pthread_attr_setschedpolicy(&attr[i], SCHED_FIFO);
            if(res != 0) printf("i =1 or 2 \n");
            // 设置优先级为 51，52。
            param[i].__sched_priority = 51 + i;
            res = pthread_attr_setschedparam(&attr[i], &param[i]);
            if(res != 0) printf("i =1 or 2 \n");
            // 设置线程属性：不要继承 main 线程的调度策略和优先级。
            pthread_attr_setinheritsched(&attr[i], PTHREAD_EXPLICIT_SCHED);
            
            // 创建线程
            pthread_create(&ppid[i], &attr[i],(void *)thread_routine, (void *)&index[i]);
        }
        else        // 后两个创建普通线程
        {
            pthread_create(&ppid[i], 0, (void *)thread_routine, (void *)&index[i]);
        }
        
    }

    // 等待 4 个线程执行结束
    for (int i = 0; i < 4; i++)
        pthread_join(ppid[i], 0);

    for (int i = 0; i < 2; i++)
        pthread_attr_destroy(&attr[i]);
}

编译：

gcc -o test test.c -lpthread

预期：

实时性优先级高的先执行，后面普通优先级在执行

note：

1.可能需要使用root权限
2.如果是多核的片子，需要把几个线程设置到一个核进行跑，才会出预期，不然可能出现同步情况

1，RR调度和FIFO调度的进程属于实时进程，以分时调度的进程是非实时进程。

2，当实时进程准备就绪后，如果当前cpu正在运行非实时进程，则实时进程立即抢占非实时进程。

3，RR进程和FIFO进程都采用实时优先级做为调度的权值标准，RR是FIFO的一个延伸。FIFO时，如果两个进程的优先级一样，则这两个优先级一样的进程具体执行哪一个是由其在队列中的位置决定的，这样导致一些不公正性(优先级是一样的，为什么要让你一直运行?),如果将两个优先级一样的任务的调度策略都设为RR,则保证了这两个任务可以循环执行，保证了公平。

调度策略

系统中的每个线程都关联了一个调度策略和优先级，调度器正是根据调度策略和优先级进行线程调度的，从而决定哪个线程将在下一个调度中得到CPU时间；

对于普通调度策略（SCHED_OTHER, SCHED_IDLE, SCHED_BATCH），优先级是没有作用的，实际上必须是0，这样实时测量线程可以马上抢占普通线程；

对于实时调度策略（SCHED_FIFO, SCHED_RR），优先级需要设置为1（最小）-99（最大）中的某个值；

调度器为每个优先级维护了一个待调度线程的列表，当需要进行调度时，调度器访问最高优先级的非空的列表，然后从列表头选择一个线程调度运行；

线程的调度策略决定了一个可调度线程应该放在哪个列表的哪个位置；

所有的调度都是支持抢占的，如果有高优先级的线程准备好运行了，那么它将抢占当前运行的线程，这使得当前线程被重新加入到等待调度的链表中；调度策略决定了在同一个优先级列表中的可调度线程的顺序；

其它查询和设置模式和优先级的函数

伪代码：
查看policy

int ***类***::get_thread_policy( pthread_attr_t &attr )
{
     int policy;
     int rs = pthread_attr_getschedpolicy( &attr, &policy );
     if(rs != 0)
     {
         apl_error("[%s] set err! \n",__func__);
     }
     switch ( policy )
      {
         case SCHED_FIFO:
                  cout << "policy = SCHED_FIFO" << endl;
                 break;
         case SCHED_RR:
                  cout << "policy = SCHED_RR" << endl;
                 break;
         case SCHED_OTHER:
                  cout << "policy = SCHED_OTHER" << endl;
                 break;
         default:
                  cout << "policy = UNKNOWN" << endl;
                 break;
      }
     return policy;
}

查询前模式的最大最小优先级

void ***类***::show_thread_priority( pthread_attr_t &attr, int policy )
{
     int priority = sched_get_priority_max( policy );
      cout << "max_priority = " << priority << endl;
      priority = sched_get_priority_min( policy );
      cout << "min_priority = " << priority << endl;
}

查询优先级

int ***类***::getThreadPriority( pthread_attr_t &attr )
{
     struct sched_param param;
     int rs = pthread_attr_getschedparam( &attr, &param );
     if(rs != 0)
     {
         apl_error("[%s] set err! \n",__func__);
     }
     apl_info("[%s] priority:%d \n" ,__func__ ,param.sched_priority);
     return param.sched_priority;
}

设置优先级

void ***类***::setThreadPolicy( pthread_attr_t &attr, int policy )
{
     int rs = pthread_attr_setschedpolicy( &attr, policy );
     if(rs != 0)
     {
         apl_error("[%s] set err! \n",__func__);
     }
     getThreadPolicy( attr );
}

设置模式

// 设置线程调度策略为SCHED_FIFO
 int res = pthread_attr_setschedpolicy(&(pUnit->startMethodTaskAttr), SCHED_FIFO);
  if(res != 0) apl_error("[%s] pthread_attr_setschedpolicy set err! \n",__func__);
// 设置线程优先级为99
                  param.sched_priority = 99;
                  res = pthread_attr_setschedparam(&(pUnit->startMethodTaskAttr), &param);

设置不继承
// 设置线程属性：不继承 main 线程的调度策略和优先级
pthread_attr_setinheritsched(&(*Attr), PTHREAD_EXPLICIT_SCHED);

其它

SCHED_FIFO：先进先出调度

SCHED_FIFO线程的优先级必须大于0，当它运行时，一定会抢占正在运行的普通策略的线程（SCHED_OTHER, SCHED_IDLE, SCHED_BATCH）；SCHED_FIFO策略是没有时间片的算法，需要遵循以下规则：

1）如果一个SCHED_FIFO线程被高优先级线程抢占了，那么它将会被添加到该优先级等待列表的首部，以便当所有高优先级的线程阻塞的时候得到继续运行；

2）当一个阻塞的SCHED_FIFO线程变为可运行时，它将被加入到同优先级列表的尾部；

3）如果通过系统调用改变线程的优先级，则根据不同情况有不同的处理方式：

a）如果优先级提高了，那么线程会被添加到所对应新优先级的尾部，因此，这个线程有可能会抢占当前运行的同优先级的线程；

b）如果优先级没变，那么线程在列表中的位置不变；

c）如果优先级降低了，那么它将被加入到新优先级列表的首部；

根据POSIX.1-2008规定，除了使用pthread_setschedprio(3)以外，通过使用其他方式改变策略或者优先级会使得线程加入到对应优先级列表的尾部；

4）如果线程调用了sched_yield(2)，那么它将被加入到列表的尾部；

SCHED_FIFO会一直运行，直到它被IO请求阻塞，或者被更高优先级的线程抢占，亦或者调用了sched_yield()；

SCHED_RR：轮转调度

SCHED_RR是SCHED_FIFO的简单增强，除了对于线程占用的时间总量之外，对于SCHED_FIFO适用的规则对于SCHED_RR同样适用；如果SCHED_RR线程的运行时间大于等于时间总量，那么它将被加入到对应优先级列表的尾部；如果SCHED_RR线程被抢占了，当它继续运行时它只运行剩余的时间量；时间总量可以通过sched_rr_get_interval()函数获取；

SCHED_OTHER：默认Linux时间共享调度

SCHED_OTHER只能用于优先级为0的线程，SCHED_OTHER策略是所有不需要实时调度线程的统一标准策略；调度器通过动态优先级来决定调用哪个SCHED_OTHER线程，动态优先级是基于nice值的，nice值随着等待运行但是未被调度执行的时间总量的增长而增加；这样的机制保证了所有SCHED_OTHER线程调度的公平性；

限制实时线程的CPU使用时间

SCHED_FIFO, SCHED_RR的线程如果内部是一个非阻塞的死循环，那么它将一直占用CPU，使得其它线程没有机会运行；

在2.6.25以后出现了限制实时线程运行时间的新方式，可以使用RLIMIT_RTTIME来限制实时线程的CPU占用时间；Linux也提供了两个proc文件，用于控制为非实时线程运行预留CPU时间；

/proc/sys/kernel/sched_rt_period_us

这个文件中的数值指定了总CPU(100%)时间的宽度值，默认值是1,000,000；

/proc/sys/kernel/sched_rt_runtime_us

sched_rt_runtime_us 表示所有实时进程一次能占有CPU的最长时间，缺省是1秒，当这个时间被用完，他们必须等待下面参数sched_rt_period_us 表示的时间(缺省是0.95s)才能被重新调度。
sched_rt_period_us 表示下一次调度实时进程的时间。
看来这两个参数是在调度实时进程和非实时进程之间做调整和平衡。

两个文件的默认值是1s和0.95s，表示每秒种为一个周期，在这个周期中，所有实时进程运行的总时间不超过0.95秒，剩下的至少0.05秒会留给普通进程。也就是说，实时进程占有不超过95%的CPU。而在这两个文件出现之前，实时进程的运行时间是没有限制的，如果一直有处于TASK_RUNNING状态的实时进程，则普通进程会一直不能得到运行。相当于sched_rt_runtime_us等于sched_rt_period_us。