2020-03-21 pthread线程设置priority 9

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

#include <unistd.h>
#include <pthread.h>
#include <sched.h>

void show_system_proiority_limits()
{
    int max_priority;
    int min_priority;

    max_priority = sched_get_priority_max(SCHED_FIFO);
    min_priority = sched_get_priority_min(SCHED_FIFO);
    printf("SCHED_FIFO max_priority = %d\n", max_priority);
    printf("SCHED_FIFO min_priority = %d\n", min_priority);

    max_priority = sched_get_priority_max(SCHED_RR);
    min_priority = sched_get_priority_min(SCHED_RR);
    printf("SCHED_RR max_priority = %d\n", max_priority);
    printf("SCHED_RR min_priority = %d\n", min_priority);

    max_priority = sched_get_priority_max(SCHED_OTHER);
    min_priority = sched_get_priority_min(SCHED_OTHER);
    printf("SCHED_OTHER max_priority = %d\n", max_priority);
    printf("SCHED_OTHER min_priority = %d\n", min_priority);
}

void show_thread_info()
{
    int err;
    int policy;
    struct sched_param schedule_parameters;

    printf("--- Show policy and priority of current thread:\n");
    err = pthread_getschedparam(pthread_self(), &policy, &schedule_parameters);
    assert( !err );
    switch (policy)
    {
    case SCHED_FIFO:
        printf("--- policy = SCHED_FIFO\n");
        break;
    case SCHED_RR:
        printf("--- policy = SCHED_RR\n");
        break;
    case SCHED_OTHER:
        printf("--- policy = SCHED_OTHER\n");
        break;
    default:
        printf("--- policy = UNKNOWN\n");
        break;
    }
    printf("--- Current thread's sched_priority = %d\n", schedule_parameters.sched_priority);
}

void *routine1(void *arg)
{
    (void) arg;
    printf("--- In routine1, func_name=%s\n", __FUNCTION__);
    show_thread_info();
    return NULL;
}

void *routine2(void *arg)
{
    (void) arg;
    printf("--- In routine2, func_name=%s\n", __FUNCTION__);
    show_thread_info();
    return NULL;
}

void *routine3(void *arg)
{
    (void) arg;
    printf("--- In routine3, func_name=%s\n", __FUNCTION__);
    show_thread_info();
    return NULL;
}

int main(int argc, char *argv[])
{
    (void) argc;
    int err;

    show_system_proiority_limits();

    if (getuid() != 0) {
        printf("This application must be run as root...\n");
        printf("Try: sudo %s\n", argv[0]);
        return 0;
    }

    printf("Create threads with different policy:\n");
    {
        pthread_t thread1;
        struct sched_param param1;
        pthread_attr_t attr1;

        pthread_attr_init(&attr1);
        printf("--- [Test 1 Begin] ---\n");
        printf("--- Set SCHED_FIFO policy\n");
        err = pthread_attr_setinheritsched(&attr1, PTHREAD_EXPLICIT_SCHED);
        assert( !err );
        err = pthread_attr_setschedpolicy(&attr1, SCHED_FIFO);
        assert( !err );
        param1.sched_priority = sched_get_priority_max(SCHED_FIFO);
        err = pthread_attr_setschedparam(&attr1, &param1);
        assert( !err );
        pthread_create(&thread1, &attr1, routine1, NULL);
        pthread_join(thread1, NULL);
        printf("--- [Test 1 End] ---\n");
        pthread_attr_destroy(&attr1);
    }
    printf("\n");
    {
        pthread_t thread2;
        struct sched_param param2;
        pthread_attr_t attr2;

        pthread_attr_init(&attr2);
        printf("--- [Test 2 Begin] ---\n");
        printf("--- Set SCHED_RR policy\n");
        err = pthread_attr_setinheritsched(&attr2, PTHREAD_EXPLICIT_SCHED);
        assert( !err );
        err = pthread_attr_setschedpolicy(&attr2, SCHED_RR);
        assert( !err );
        param2.sched_priority = sched_get_priority_max(SCHED_RR);
        err = pthread_attr_setschedparam(&attr2, &param2);
        assert( !err );
        pthread_create(&thread2, &attr2, routine2, NULL);
        pthread_join(thread2, NULL);
        printf("--- [Test 2 End] ---\n");
        pthread_attr_destroy(&attr2);
    }
    printf("\n");
    {
        pthread_t thread3;
        struct sched_param param3;
        pthread_attr_t attr3;

        pthread_attr_init(&attr3);
        printf("--- [Test 3 Begin] ---\n");
        printf("--- Set SCHED_OTHER policy\n");
        err = pthread_attr_setinheritsched(&attr3, PTHREAD_EXPLICIT_SCHED);
        assert( !err );
        err = pthread_attr_setschedpolicy(&attr3, SCHED_OTHER);
        assert( !err );
        param3.sched_priority = sched_get_priority_max(SCHED_OTHER);
        err = pthread_attr_setschedparam(&attr3, &param3);
        assert( !err );
        pthread_create(&thread3, &attr3, routine3, NULL);
        pthread_join(thread3, NULL);
        printf("--- [Test 3 End] ---\n");
        pthread_attr_destroy(&attr3);
    }
    return 0;
}