Linux线程调度

代码如下：

#include <stdio.h>
#include <pthread.h>
#include <sched.h>
#include <assert.h>

static int api_get_thread_policy(pthread_attr_t *attr)
{
    int policy = 0;
    int rs = 0;

    rs = pthread_attr_getschedpolicy(attr, &policy);
    assert(0 == rs);

    switch(policy)
    {
        case SCHED_FIFO:
            printf("policy = SCHED_FIFO
");
            break;
        case SCHED_RR:
            printf("policy = SCHED_RR
");
            break;
        case SCHED_OTHER:
            printf("policy = SCHED_OTHER
");
            break;
        default:
            printf("policy = UNKNOWN
");
            break;
    }

    return policy;
}

static void api_set_thread_policy(pthread_attr_t *attr, int policy)
{
    int rs = 0;

    rs = pthread_attr_setschedpolicy(attr, policy);
    assert(0 == rs);
    (void)api_get_thread_policy(attr);
}

static void api_show_thread_priority(int policy)
{
    int priority = 0;

    priority = sched_get_priority_max(policy);
    assert(-1 != priority);
    printf("max_priority = %d
", priority);

    priority = sched_get_priority_min(policy);
    assert(-1 != priority);
    printf("min_priority = %d
", priority);
}

static int api_get_thread_priority(pthread_attr_t *attr)
{
    struct sched_param param;
    int rs = 0;

    rs = pthread_attr_getschedparam(attr, &param);
    assert(0 == rs);
    printf("priority = %d
", param.__sched_priority);

    return param.sched_priority;
}

static void api_set_thread_priority(pthread_attr_t *attr, int priority)
{
    struct sched_param param;
    int rs = 0;

    rs = pthread_attr_getschedparam(attr, &param);
    assert(0 == rs);

    param.__sched_priority = priority;
    rs = pthread_attr_setschedparam(attr, &param);
    assert(0 == rs);

    (void)api_get_thread_priority(attr);
}

//int api_set_policy_priority_main()
int main()
{
    pthread_attr_t attr;
    int rs = 0;

    rs = pthread_attr_init(&attr);
    assert(0 == rs);

    int policy = api_get_thread_policy(&attr);

    printf("Show current configuration of priofity
");
    api_show_thread_priority(policy);

    printf("Show SCHED_FIFO of priority
");
    api_show_thread_priority(SCHED_FIFO);

    printf("Show SCHED_RR of priority
");
    api_show_thread_priority(SCHED_RR);

    printf("Show priority of current thread
");
    int priority = api_get_thread_priority(&attr);

    printf("Set SCHED_FIFO policy
");
    api_set_thread_policy(&attr, SCHED_FIFO);

    printf("Set SCHED_RR policy
");
    api_set_thread_policy(&attr, SCHED_RR);

    printf("Restore current policy
");
    api_set_thread_policy(&attr, policy);

    printf("Restore current priority
");
    api_set_thread_priority(&attr, priority);

    rs = pthread_attr_destroy(&attr);
    assert(0 == rs);

    return 0;
}