Исходный код программы

/* pthreads_sched_test.c */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#define handle_error_en(en, msg) \

        do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)
static void
usage(char *prog_name, char *msg)
{

    if (msg != NULL)

        fputs(msg, stderr);

    fprintf(stderr, "Использование: %s [параметры]\n", prog_name);

    fprintf(stderr, "Параметры:\n");
#define fpe(msg) fprintf(stderr, "\t%s", msg);       /* для краткости */

    fpe("-a<алгоритм><приоритет> Алгоритм и приоритет планирования\n");

    fpe("                 объекте атрибутов нити\n");

    fpe("                 значения для <алгоритм>:\n");

    fpe("                     f  SCHED_FIFO\n");

    fpe("                     r  SCHED_RR\n");

    fpe("                     o  SCHED_OTHER\n");

    fpe("-A               Исп. объект атрибутов нити по умолчанию\n");

    fpe("-i {e|i}         Атрибут наследования планировщика\n");

    fpe("                 'явный' or 'унаследованный'\n");

    fpe("-m<алгоритм><приоритет> Алгоритм и приоритет планирования\n");

    fpe("               главной нити перед вызовом pthread_create()\n");

    exit(EXIT_FAILURE);
}
static int
get_policy(char p, int *policy)
{

    switch (p) {

    case 'f': *policy = SCHED_FIFO;     return 1;

    case 'r': *policy = SCHED_RR;       return 1;

    case 'o': *policy = SCHED_OTHER;    return 1;

    default:  return 0;

    }
}
static void
display_sched_attr(int policy, struct sched_param *param)
{

    printf("    алгоритм=%s, приоритет=%d\n",

            (policy == SCHED_FIFO)  ? "SCHED_FIFO" :

            (policy == SCHED_RR)    ? "SCHED_RR" :

            (policy == SCHED_OTHER) ? "SCHED_OTHER" :

            "???",

            param->sched_priority);
}
static void
display_thread_sched_attr(char *msg)
{

    int policy, s;

    struct sched_param param;

    s = pthread_getschedparam(pthread_self(), &policy, &param);

    if (s != 0)

        handle_error_en(s, "pthread_getschedparam");

    printf("%s\n", msg);

    display_sched_attr(policy, &param);
}
static void *
thread_start(void *arg)
{

    display_thread_sched_attr("Атрибуты планировщика в новой нити");

    return NULL;
}
int
main(int argc, char *argv[])
{

    int s, opt, inheritsched, use_null_attrib, policy;

    pthread_t thread;

    pthread_attr_t attr;

    pthread_attr_t *attrp;

    char *attr_sched_str, *main_sched_str, *inheritsched_str;

    struct sched_param param;

    /* обработка параметров командной строки */

    use_null_attrib = 0;

    attr_sched_str = NULL;

    main_sched_str = NULL;

    inheritsched_str = NULL;

    while ((opt = getopt(argc, argv, "a:Ai:m:")) != -1) {

        switch (opt) {

        case 'a': attr_sched_str = optarg;      break;

        case 'A': use_null_attrib = 1;          break;

        case 'i': inheritsched_str = optarg;    break;

        case 'm': main_sched_str = optarg;      break;

        default:  usage(argv[0], "Неизвестный параметр\n");

        }

    }

    if (use_null_attrib &&

            (inheritsched_str != NULL || attr_sched_str != NULL))

        usage(argv[0], "Нельзя указывать -A вместе с -i или -a\n");

    /* необязательная установка атрибутов планирования главной нити

       вывод этих атрибутов */

    if (main_sched_str != NULL) {

        if (!get_policy(main_sched_str[0], &policy))

            usage(argv[0], "Некоррект. алгоритм для главной нити (-m)\n");

        param.sched_priority = strtol(&main_sched_str[1], NULL, 0);

        s = pthread_setschedparam(pthread_self(), policy, &param);

        if (s != 0)

            handle_error_en(s, "pthread_setschedparam");

    }

    display_thread_sched_attr("Настройки планировщика главной нити");

    printf("\n");

    /* инициализация объекта атрибутов нити согласно параметрам */

    attrp = NULL;

    if (!use_null_attrib) {

        s = pthread_attr_init(&attr);

        if (s != 0)

            handle_error_en(s, "pthread_attr_init");

        attrp = &attr;

    }

    if (inheritsched_str != NULL) {

        if (inheritsched_str[0] == 'e')

            inheritsched = PTHREAD_EXPLICIT_SCHED;

        else if (inheritsched_str[0] == 'i')

            inheritsched = PTHREAD_INHERIT_SCHED;

        else

            usage(argv[0], "Значение -i должно быть 'e' или 'i'\n");

        s = pthread_attr_setinheritsched(&attr, inheritsched);

        if (s != 0)

            handle_error_en(s, "pthread_attr_setinheritsched");

    }

    if (attr_sched_str != NULL) {

        if (!get_policy(attr_sched_str[0], &policy))

            usage(argv[0],

                    "Некорректный алгоритм для 'attr' (-a)\n");

        param.sched_priority = strtol(&attr_sched_str[1], NULL, 0);

        s = pthread_attr_setschedpolicy(&attr, policy);

        if (s != 0)

            handle_error_en(s, "pthread_attr_setschedpolicy");

        s = pthread_attr_setschedparam(&attr, &param);

        if (s != 0)

            handle_error_en(s, "pthread_attr_setschedparam");

    }

    /* если мы инициализируем объект атрибутов нити, то покажем

       атрибуты планирования, установленные в объекте */

    if (attrp != NULL) {

        s = pthread_attr_getschedparam(&attr, &param);

        if (s != 0)

            handle_error_en(s, "pthread_attr_getschedparam");

        s = pthread_attr_getschedpolicy(&attr, &policy);

        if (s != 0)

            handle_error_en(s, "pthread_attr_getschedpolicy");

        printf("Настройки планировщика в 'attr'\n");

        display_sched_attr(policy, &param);

        s = pthread_attr_getinheritsched(&attr, &inheritsched);

        printf("    наследование планировщика %s\n",

                (inheritsched == PTHREAD_INHERIT_SCHED)  ? "ВКЛЮЧЕНО" :

                (inheritsched == PTHREAD_EXPLICIT_SCHED) ? "ЯВНОЕ" :

                "???");

        printf("\n");

    }

    /* создаём нить, которая покажет свои атрибуты планирования */

    s = pthread_create(&thread, attrp, &thread_start, NULL);

    if (s != 0)

        handle_error_en(s, "pthread_create");

    /* уничтожаем ненужный объект атрибутов нити */

    if (!use_null_attrib) {

      s = pthread_attr_destroy(&attr);

      if (s != 0)

          handle_error_en(s, "pthread_attr_destroy");

    }

    s = pthread_join(thread, NULL);

    if (s != 0)

        handle_error_en(s, "pthread_join");

    exit(EXIT_SUCCESS);
}