Linux源码阅读笔记05-进程优先级与调度策略-实战分析

简介: Linux源码阅读笔记05-进程优先级与调度策略-实战分析

基础知识

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

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

  1. 获取线程设置的最高和最低优先级函数
  • 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,即普通任务调度的函数。

  1. 设置和获取优先级的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; // 设置优先级
  1. 当操作系统创建线程时,默认线程是 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;
}

  1. 简单线程调度策略,我们创建三个线程,默认创建的线程它的调度策略为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;
}
  • 超级用户运行

目录
打赏
0
3
2
0
32
分享
相关文章
探索Python的并发编程:线程与进程的实战应用
【10月更文挑战第4天】 本文深入探讨了Python中实现并发编程的两种主要方式——线程和进程,通过对比分析它们的特点、适用场景以及在实际编程中的应用,为读者提供清晰的指导。同时,文章还介绍了一些高级并发模型如协程,并给出了性能优化的建议。
60 3
CentOS 7.6安装Docker实战案例及存储引擎和服务进程简介
关于如何在CentOS 7.6上安装Docker、介绍Docker存储引擎以及服务进程关系的实战案例。
261 3
CentOS 7.6安装Docker实战案例及存储引擎和服务进程简介
30 个实用的 Linux 命令贴与技巧,提升你的效率(附实战案例)
本文介绍了30个实用的Linux命令及其应用场景,帮助你提升命令行操作效率。涵盖返回目录、重新执行命令、查看磁盘使用情况、查找文件、进程管理、网络状态监控、定时任务设置等功能,适合各水平的Linux用户学习和参考。
|
5月前
|
python3多进程实战(python3经典编程案例)
该文章提供了Python3中使用多进程的实战案例,展示了如何通过Python的标准库`multiprocessing`来创建和管理进程,以实现并发任务的执行。
171 0
Linux用户组管理实战:创建、管理与删除的全面指南
在 Linux 系统中,用户组管理是实现权限控制和资源共享的关键。本文档详细介绍如何创建用户组、管理用户组成员及查看与删除用户组。首先,通过 `groupadd` 命令创建新用户组,并在 `/etc/group` 文件中记录。接着,利用 `usermod` 和 `gpasswd` 命令来添加或删除用户组成员,其中 `gpasswd` 提供更灵活的管理方式。最后,使用 `getent` 或直接读取 `/etc/group` 查看用户组信息,并通过 `groupdel` 删除空用户组。这些操作有助于高效管理和保护系统资源。
415 4
在Linux中,什么时候需要用到进程的优先级?
在Linux中,什么时候需要用到进程的优先级?
在Linux中,如何进行网络资源的优先级管理?
在Linux中,如何进行网络资源的优先级管理?
Linux源码阅读笔记13-进程通信组件中
Linux源码阅读笔记13-进程通信组件中
Linux源码阅读笔记19-插入删除模块实战
Linux源码阅读笔记19-插入删除模块实战
linux中几种任务的优先级
linux中几种任务的优先级

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等