Linux线程调度策略以及优先级实验

什么是线程调度策略？

Linux内核共有三种调度算法，他们分别是：

1、SCHED_OTHER 分时调度策略，
2、SCHED_FIFO实时调度策略，先到先服务
3、SCHED_RR实时调度策略，时间片轮转

其中，SCHED_FIFO与SCHED_RR属于实时策略，SCHED_OTHER属于分时策略。
实时策略线程将得到优先调用，实时策略线程根据实时优先级决定调度权值，分时策略线程则通过nice和counter值决定权值，nice越小，counter越大，被调度的概率越大，也就是曾经使用了cpu最少的线程将会得到优先调度。

三种调度策略

分时调度策略

SCHED_OTHER 分时调度策略：
非实时的，无法设置优先级

实时调度策略

SCHED_FIFO实时调度策略：
先到先服务。一旦占用cpu则一直运行。一直运行直到有更高优先级任务到达或自己放弃

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

调度策略组合情况

所有任务都采用linux分时调度策略(SCHED_OTHER)时:
创建时指定优先级nice值，根据nice值确定在cpu上的执行时间(counter)，对每个任务动态优先级的计算(counter+20-nice)结果去选择运行，当这 个时间片用完后(counter减至0)或者主动放弃cpu时，该任务被放在就绪队列末尾(时间片用完)或等待队列(因等待资源而放弃cpu)中。

所有任务都采用FIFO时:
优先级高的先运行，并且该任务将一直占有CPU直到优先级更高的任务就绪或者主动放弃。同优先级先入队列先运行。

所有任务都采用RR时
综合了前两种策略，优先级高的先运行，优先级相同共分时间片，用完时间片的去就绪队列尾。

任务中同时含有实时和分时时
当实时进程准备就绪后，如果当前cpu正在运行非实时进程，则实时进程立即抢占非实时进程。

测试实验

主要目的时测试在不同的调度策略以及不同的优先级设定的状况下，线程的抢占情况。

测试方法主要为在设定线程策略与优先级后，创建三个线程，观察它们的log输出情况以及使用busybox top查看CPU占用情况。

修改线程属性的代码部分如下：

    param1.sched_priority = 40;                            //修改优先级 
    pthread_attr_setinheritsched(&attr1,PTHREAD_EXPLICIT_SCHED);       
    pthread_attr_setschedpolicy(&attr1,SCHED_FIFO);        //修改调度策略
    if(0!=pthread_attr_setschedparam(&attr1,&param1))
    {
        printf("setschedpolicy attr1 NG! \n");
    }

实验全部代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
#include <assert.h>
#include <time.h>

#if 1
void *Thread1(void* pp)
{
  sleep(1);
  int i;
  int policy;
  struct sched_param param;
  pthread_getschedparam(pthread_self(),&policy,&param);
  switch(policy)
  {
  case SCHED_OTHER:
      printf("SCHED_OTHER 1\n");
      break;
  
  case SCHED_RR:
      printf("SCHED_RR 1 \n");
      break;
  
  case SCHED_FIFO:
      printf("SCHED_FIFO 1\n");
      break;
  }
  
while(1)
{
    for(i=1;i<5000000;i++)
    {
    
    
    }
    printf("Pthread 1\n");
    //usleep(500);    
}
  printf("Pthread 1 exit\n");
}

void *Thread2(void* pp)
{
  sleep(2);
  int i;
  int policy;
  struct sched_param param;
  pthread_getschedparam(pthread_self(),&policy,&param);
    switch(policy)
  {
  case SCHED_OTHER:
      printf("SCHED_OTHER 2\n");
      break;
  
  case SCHED_RR:
      printf("SCHED_RR 2 \n");
      break;
  
  case SCHED_FIFO:
      printf("SCHED_FIFO 2\n");
      break;
  }
while(1)
{
    for(i=1;i<5000000;i++)
    {
     
    
    }
    printf("Pthread 2\n");
    //usleep(500);
}
  printf("Pthread 2 exit\n");
}

void *Thread3(void* pp)
{
  sleep(3);
  int i;
  int policy;
  struct sched_param param;
  pthread_getschedparam(pthread_self(),&policy,&param);
    switch(policy)
  {
  case SCHED_OTHER:
      printf("SCHED_OTHER 3\n");
      break;
  
  case SCHED_RR:
      printf("SCHED_RR 3 \n");
      break;
  
  case SCHED_FIFO:
      printf("SCHED_FIFO 3\n");
      break;
  }
while(1)
{
    for(i=1;i<5000000;i++)
    {
     
    
    }
    printf("Pthread 3\n");
    //usleep(500);
}
  printf("Pthread 3 exit\n");
}
#endif

int main()
{
    int uid;
    uid = getuid();
    if(uid==0)
        printf("The current user is root\n");
    else
        printf("The current user is not root\n");

    pthread_t ppid1,ppid2,ppid3;
    
    struct sched_param param1;
    struct sched_param param2;
    struct sched_param param3;

    pthread_attr_t attr1,attr2,attr3;

    pthread_attr_init(&attr1);
    pthread_attr_init(&attr2);
    pthread_attr_init(&attr3);
          
    param1.sched_priority = 40;
    pthread_attr_setinheritsched(&attr1,PTHREAD_EXPLICIT_SCHED);
    pthread_attr_setschedpolicy(&attr1,SCHED_OTHER);
    if(0!=pthread_attr_setschedparam(&attr1,&param1))
    {
        printf("setschedpolicy attr1 NG! \n");
    }
    

    param2.sched_priority = 20;
    pthread_attr_setinheritsched(&attr2,PTHREAD_EXPLICIT_SCHED);
    pthread_attr_setschedpolicy(&attr2,SCHED_RR);
    pthread_attr_setschedparam(&attr2,&param2);
    if(0!=pthread_attr_setschedparam(&attr2,&param2))
    {
        printf("setschedpolicy attr2 NG! \n");
    }    

    param3.sched_priority = 20;
    pthread_attr_setinheritsched(&attr3,PTHREAD_EXPLICIT_SCHED);
    pthread_attr_setschedpolicy(&attr3,SCHED_RR);
    pthread_attr_setschedparam(&attr3,&param3);
    if(0!=pthread_attr_setschedparam(&attr3,&param3))
    {
        printf("setschedpolicy attr3 NG! \n");
    }    

    pthread_create(&ppid1,&attr1,Thread1,NULL);
    
    pthread_create(&ppid2,&attr2,Thread2,NULL);
    
    pthread_create(&ppid3,&attr3,Thread3,NULL);

    pthread_join(ppid1,NULL);
    pthread_join(ppid2,NULL);
    pthread_join(ppid3,NULL);    
    //while(1) {           
        //sleep(100);
        //printf("main loop\n");
    //}
    
    pthread_attr_destroy(&attr1);
    pthread_attr_destroy(&attr2);
    pthread_attr_destroy(&attr3);
    return 0;
}

实验过程现象

SCHED_OTHER

创建三个分时线程：
因分时策略不能设置优先级，所以不进行优先级不同的测试。
实验结果如下：

SCHED_FIFO

创建三个实时FIFO线程，且它们三个的优先级相同，皆为30。
实验结果如下：

SCHED_RR

创建三个实时RR线程：

且它们三个的优先级相同，皆为30。
实验结果如下：

全为实时且不同优先级

创建三个实时线程，优先级不同：

分时实时同时存在

创建两个实时/分时线程，优先级不同，实验结果如下：

实验结论

实验结论：
1、三种调度策略线程满足自身策略特性。
2、实时线程无条件抢占分时线程，分时线程无法抢占实时线程。
3、实时线程中，高优先级线程抢占低优先级线程。
4、实时线程中，高优先级线程运行中不会被低优先级线程所打断。

实验课题（以下说明并未在实验中测出）：
linux有一个组策略就是分配实时和分时的时间片
sysctl -n kernel.sched_rt_period_us # 实时进程调度的单位CPU时间 1 秒
1000000
sysctl -n kernel.sched_rt_runtime_us # 实时进程在 1 秒中实际占用的CPU时间, 0.95秒
950000
这个设置说明实时进程在运行时并不是完全占用CPU的, 每1秒中有0.05秒的时间可以给其它进程运行.
这样既不会对实时进程的响应时间造成太大的影响, 也避免了实时进程卡住时导致整个系统无响应.

在Linux下运行应用方案，在某些场景下，为了调试和调优，可能会有调整任务的优先级的需求，它的基本流程是这样的：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stddef.h>
#include <stdint.h>
#include <unistd.h>
#include <pthread.h>

static void * worker_thread1(void * param)
{
	while(1)
	{
		printf("%s line %d.\n", __func__, __LINE__);
		sleep(1);
	}
	return NULL;
}

static void * worker_thread(void * param)
{
	pthread_t demo_handle;

	int ret = pthread_create(&demo_handle, NULL, worker_thread1, NULL);
	if(ret != 0)
	{
		printf("%s line %d, fatal error.\n", __func__, __LINE__);
		return NULL;
	}

	while(1)
	{
		printf("%s line %d.\n", __func__, __LINE__);
		sleep(1);
	}
	pthread_join(demo_handle, NULL);
	return NULL;
}

int main(void)
{
	pthread_t pthread_demo_handle;
	int policy = 0;
	pthread_attr_t attr;
	struct sched_param param;

	bzero((void*)&param, sizeof(struct sched_param));
	pthread_attr_init(&attr);

	/*pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);*/
	//pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
	pthread_attr_setschedpolicy(&attr, SCHED_RR);
	pthread_attr_getschedpolicy(&attr, &policy);

	int max_priority = sched_get_priority_max(policy);
	int min_priority = sched_get_priority_min(policy);
	
	param.sched_priority = max_priority;

	pthread_attr_setschedparam(&attr, &param);
	pthread_attr_setstacksize(&attr, 1*1024*1024);

	int ret = pthread_create(&pthread_demo_handle, &attr, worker_thread, NULL);
	if(ret != 0)
	{
		printf("%s line %d, fatal error.\n", __func__, __LINE__);
		return -1;
	}

	pthread_join(pthread_demo_handle, NULL);
	return 0;
}

可是经过实际的测试，发现被创建任务的优先级并没有出现预期的结果

 可以看到，根据sched节点获取到的信息，并未出现被修改线程的优先级成为实时优先级的情况，这是为何呢？

pthread_attr_setinheritsched

出现设置子线程调度策略不成功的原因是我们没有调用pthread_attr_setinheritsched并设置正确的参数。

pthread_attr_setinheritsched  的作用是设置线程是否继承父线程调度策略，分为两种情况：

• attr：线程属性结构体地址
• inheritsched：是否继承父线程的调度策略
• PTHREAD_EXPLICIT_SCHED：不继承，只有不继承父线程的调度策略才可以设置线程的调度策略
• PTHREAD_INHERIT_SCHED：继承父进程的调度策略 

 默认的情况下，设置的是PTHREAD_INHERIT_SCHED，也就是说，被创建线程完全按照父线程的调度策略创建，即便程序创建线程时，指定了不同的调度策略，这会导致设置失效，这就是我们上面遇到的情况。 

那该怎么处理呢？方法是调用

pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);

修改后的代码如下：

可见这次，新创建线程的调度策略和调度优先级都有了新的变化，变成了我们预期的设定值。

几个关键函数解析

bzero:

pthread_attr_init

int pthread_attr_setinheritsched(pthread_attr_t *a, int inherit):

pthread_attr_getinheritsched:

 pthread_attr_setschedpolicy:

 pthread_attr_getschedpolicy: 

sched_get_priority_max/sched_get_priority_min:

pthread_create:

运行过程中，改变线程调度策略和优先级的调用：pthread_setschedparam

关于调度策略的继承关系，可以从sched_fork函数下面的逻辑即可看出

p->policy的初始化是在struct task_struct分配的时候，由父线程的内容做memcpy完成的，所以一开始大部分的成员都是按照父线程的样子初始化的，后面在根据各种各样的条件，修改成子线程应该有的样子。

结束

简述

linux系统调度执行的最小单位是线程，线程的调度策略有以下三种：

（1）SCHED_FIFO
其静态优先级必须设置为1~99，这将意味着一旦线程处于就绪态，他就能立即抢占任何静态优先级为0的普通线程。采样SCHED_FIFO调度策略的线程还遵循以下原则：

• 当他处于就绪态时，就会被放入其所在优先级队列的队尾位置
• 当被更高优先级的线程抢占后，他会被放入其所在优先级队列的队头位置，当所有优先级比他高的线程不再运行后，他就恢复运行
• 当它调用sched_yield()后，他会被放入其所在优先级队列的队尾位置

总的来说，一个具有SCHED_FIFO调度策略的线程会一直运行直到发送I/O请求，或被更高优先级线程抢占，或调用sched_yield()主动让出cpu

（2)SCHED_RR
这种策略的情况与SCHED_FIFO类似，区别是：每一个SCHED_RR策略下的线程都会被分配一个时间片，当时间片耗光时，它会被放入其所在优先级队列的队尾位置。
可以用sched_rr_get_interval()来获取时间片的具体数值。

（3）SCHED_OTHER
其静态优先级必须设置为0，该策略是linux系统调度的默认策略，处于0优先级的这些线程按照所谓的动态优先级（nice值）被调度，且每当一个线程已处于就绪态但被调度器调度无视的时候，其动态优先级会自动增加一个单位，这样能保证这些线程竞争cpu的公平性。
如何设置线程的静态优先级和动态优先级，相关的API如下：

非实时线程

静态优先级为0的线程是非实时线程

实时线程

静态优先级为1~99的线程都是实时线程

静态优先级

什么是静态优先级？

线程的静态优先级之所以被称为“静态”，是因为只要不强行使用api函数修改它，它不会随着线程的执行而发生改变，静态优先级决定了实时线程的基本调度次序，如果他们的静态优先级一样，那么调度策略再为调度器提供进一步的调度依据。

动态优先级

什么是动态优先级？

线程的动态优先级是非实时的普通线程独有的概念，之所以被称为“动态”，是因为它会随着线程的运行，根据线程的表现而发生改变。具体来讲，如果一条线程是“CPU消耗型”的，比如视频解码算法，这类线程只要一运行就会“黏住”cpu不放，这类线程的动态优先级会慢慢降低，因为这类线程不需要很高的响应速度，我们只要保证一定的执行时间片就可以了。相反，另一类线程称为“IO消耗型”，比如编辑器，这类线程绝大部分时间都在睡眠，调度器发现每次调度它，他都毅然决然放弃了，将宝贵的cpu让给了其他线程，因此会慢慢地提高它的动态优先级，使得这类线程在同等的非实时普通线程中，有越来越高的响应速度，表现出更好的交互性能，这也正是我们想要的结果；线程的优先级可以动态调整，以上就是动态优先级的概念。

相关API

1、设置线程调度策略

2、设置线程静态优先级

3、设置线程动态优先级

总结

后面我有时间再慢慢补充linux系统线程相关的一些知识点。