【Linux 内核】线程调度示例一 ④ ( pthread_attr_init 初始化线程属性对象 | 完整代码示例 )

#include <pthread.h> 
int pthread_attr_init(pthread_attr_t *attr); 

int main(int argc, char *argv){
    // 线程属性结构体
    pthread_attr_t p_attr;

    // 调度相关参数
    struct sched_param sched;

    // 初始化线程参数
    int ret = pthread_attr_init(&p_attr);

    // 确保线程参数初始化成功
    assert(ret == 0);

    // 获取线程调度策略, SCHED_OTHER 是普通进程
    // SCHED_OTHER 类型调度策略
    int policy = get_thread_policy(&p_attr);

    printf("\n输出当前 SCHED_OTHER 调度策略优先级：\n");
    // 打印当前线程的优先级
    // 0 调度策略的 最大优先级为 0
    // 0 调度策略的 最小优先级为 0
    print_thread_priority_with_policy(&p_attr, policy);

    printf("\n输出 SCHED_FIFO 调度策略优先级：\n");
    // 打印当前线程的优先级
    // 1 调度策略的 最大优先级为 99
    // 1 调度策略的 最小优先级为 1
    print_thread_priority_with_policy(&p_attr, SCHED_FIFO);

    printf("\n输出 SCHED_RR 调度策略优先级：\n");
    // 打印当前线程的优先级
    // 2 调度策略的 最大优先级为 99
    // 2 调度策略的 最小优先级为 1
    print_thread_priority_with_policy(&p_attr, SCHED_RR);

    // 获取当前线程的优先级
    // 获取的线程优先级为 -879536928
    // 打印出来是一个随机数 ， 只有 实时调度策略 时 ， 优先级才有效
    printf("\n输出当前线程的优先级：\n");
    get_thread_priority(&p_attr);

    printf("\n设置当前线程调度策略为 SCHED_FIFO ：\n");
    set_thread_policy(&p_attr, SCHED_FIFO);

    printf("\n设置当前线程调度策略为 SCHED_RR ：\n");
    set_thread_policy(&p_attr, SCHED_RR);

    // 销毁 线程属性 结构体
    ret = pthread_attr_destroy(&p_attr);
    assert(ret == 0);


    printf("\nmain 函数执行完毕 ！\n");
    return 0;
}

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

/**
 * @brief 获取线程调度策略
 * 
 * @return int 
 */
static int get_thread_policy(pthread_attr_t *p_attr){
    // 用于接收调度策略返回值
    int policy;

    // 获取线程的调度策略, 如 SCHED_FIFO, SCHED_RR, SCHED_OTHER
    int ret = pthread_attr_getschedpolicy(p_attr, &policy);

    // 断言操作 , 保证下面的代码正常执行 , 如果 ret == 0 继续执行 , 否则进程退出
    assert(ret == 0);

    // 打印调度策略
    switch (policy)
    {
    case SCHED_FIFO:
        printf("SCHED_FIFO 类型调度策略\n");
        break;

    case SCHED_RR:
        printf("SCHED_RR 类型调度策略\n");
        break;

    case SCHED_OTHER:
        printf("SCHED_OTHER 类型调度策略\n");
        break;
    
    default:
        printf("未知类型调度策略 %d\n", policy);
        break;
    }
    return policy;
}

/**
 * @brief 打印指定调度策略的最大和最小优先级
 * 
 * @return int 
 */
static int print_thread_priority_with_policy(pthread_attr_t *p_attr, int policy){
    // 用于接收调度策略最大优先级返回值
    int priority_max;

    // 获取指定调度策略的最大优先级
    priority_max = sched_get_priority_max(policy);

    // 获取失败会返回 -1
    assert(priority_max != -1);

    printf("%d 调度策略的 最大优先级为 %d\n", policy, priority_max);

    // 用于接收调度策略最小优先级返回值
    int priority_min;

    // 获取指定调度策略的最小优先级
    priority_min = sched_get_priority_min(policy);

    // 获取失败会返回 -1
    assert(priority_min != -1);

    printf("%d 调度策略的 最小优先级为 %d\n", policy, priority_min);

    return 0;
}

/**
 * @brief 获取线程优先级
 * 
 * @return int 
 */
static int get_thread_priority(pthread_attr_t *p_attr){
	// 获取调度参数
	struct sched_param param;

    // 获取线程调度优先级
    int ret = pthread_attr_getschedparam(p_attr, &param);

    // 确保获取优先级操作执行成功，如果执行失败，则退出程序
    assert(ret == 0);

    printf("获取的线程优先级为 %d\n", param.sched_priority);

    return param.sched_priority;
}

/**
 * @brief 设置线程调度策略
 * 
 * @return int 
 */
static int set_thread_policy(pthread_attr_t *p_attr, int policy){
    // 设置线程调度策略
    int ret = pthread_attr_setschedpolicy(p_attr, policy);

    // 确保获取优先级操作执行成功，如果执行失败，则退出程序
    assert(ret == 0);

    // 验证线程是否设置调度策略成功， 打印调度策略
    get_thread_policy(p_attr);

    return 0;
}


int main(int argc, char *argv){
    // 线程属性结构体
    pthread_attr_t p_attr;

    // 调度相关参数
    struct sched_param sched;

    // 初始化线程参数
    int ret = pthread_attr_init(&p_attr);

    // 确保线程参数初始化成功
    assert(ret == 0);

    // 获取线程调度策略, SCHED_OTHER 是普通进程
    // SCHED_OTHER 类型调度策略
    int policy = get_thread_policy(&p_attr);

    printf("\n输出当前 SCHED_OTHER 调度策略优先级：\n");
    // 打印当前线程的优先级
    // 0 调度策略的 最大优先级为 0
    // 0 调度策略的 最小优先级为 0
    print_thread_priority_with_policy(&p_attr, policy);

    printf("\n输出 SCHED_FIFO 调度策略优先级：\n");
    // 打印当前线程的优先级
    // 1 调度策略的 最大优先级为 99
    // 1 调度策略的 最小优先级为 1
    print_thread_priority_with_policy(&p_attr, SCHED_FIFO);

    printf("\n输出 SCHED_RR 调度策略优先级：\n");
    // 打印当前线程的优先级
    // 2 调度策略的 最大优先级为 99
    // 2 调度策略的 最小优先级为 1
    print_thread_priority_with_policy(&p_attr, SCHED_RR);

    // 获取当前线程的优先级
    // 获取的线程优先级为 -879536928
    // 打印出来是一个随机数 ， 只有 实时调度策略 时 ， 优先级才有效
    printf("\n输出当前线程的优先级：\n");
    get_thread_priority(&p_attr);

    printf("\n设置当前线程调度策略为 SCHED_FIFO ：\n");
    set_thread_policy(&p_attr, SCHED_FIFO);

    printf("\n设置当前线程调度策略为 SCHED_RR ：\n");
    set_thread_policy(&p_attr, SCHED_RR);

    // 销毁 线程属性 结构体
    ret = pthread_attr_destroy(&p_attr);
    assert(ret == 0);


    printf("\nmain 函数执行完毕 ！\n");
    return 0;
}