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

#define _GNU_SOURCE     /* для объявления pthread_getattr_np() */
#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
display_stack_related_attributes(pthread_attr_t *attr, char *prefix)
{

    int s;

    size_t stack_size, guard_size;

    void *stack_addr;

    s = pthread_attr_getguardsize(attr, &guard_size);

    if (s != 0)

        handle_error_en(s, "pthread_attr_getguardsize");

    printf("%sРазмер защиты            = %d байт\n", prefix, guard_size);

    s = pthread_attr_getstack(attr, &stack_addr, &stack_size);

    if (s != 0)

        handle_error_en(s, "pthread_attr_getstack");

    printf("%sАдрес стека       = %p", prefix, stack_addr);

    if (stack_size > 0)

        printf(" (EOS = %p)", (char *) stack_addr + stack_size);

    printf("\n");

    printf("%sРазмер стека          = 0x%x (%d) байт\n",

            prefix, stack_size, stack_size);
}
static void
display_thread_attributes(pthread_t thread, char *prefix)
{

    int s;

    pthread_attr_t attr;

    s = pthread_getattr_np(thread, &attr);

    if (s != 0)

        handle_error_en(s, "pthread_getattr_np");

    display_stack_related_attributes(&attr, prefix);

    s = pthread_attr_destroy(&attr);

    if (s != 0)

        handle_error_en(s, "pthread_attr_destroy");
}
static void *           /* Начальная функция создаваемой нити */
thread_start(void *arg)
{

    printf("Атрибуты созданной нити:\n");

    display_thread_attributes(pthread_self(), "\t");

    exit(EXIT_SUCCESS);         /* Завершить все нити */
}
static void
usage(char *pname, char *msg)
{

    if (msg != NULL)

        fputs(msg, stderr);

    fprintf(stderr, "Использование: %s [-s stack-size [-a]]"

            " [-g guard-size]\n", pname);

    fprintf(stderr, "\t\t-a означает, что программа выделяет стек\n");

    exit(EXIT_FAILURE);
}
static pthread_attr_t *   /* получить атрибуты нити из ком. строки */
get_thread_attributes_from_cl(int argc, char *argv[],

                              pthread_attr_t *attrp)
{

    int s, opt, allocate_stack;

    long stack_size, guard_size;

            void *stack_addr;

    pthread_attr_t *ret_attrp = NULL;   /* задаёт attrp, если мы

                                           инициализируем объект

                                           атрибутов нити */

    allocate_stack = 0;

    stack_size = -1;

    guard_size = -1;

    while ((opt = getopt(argc, argv, "ag:s:")) != -1) {

        switch (opt) {

        case 'a':   allocate_stack = 1;                     break;

        case 'g':   guard_size = strtoul(optarg, NULL, 0);  break;

        case 's':   stack_size = strtoul(optarg, NULL, 0);  break;

        default:    usage(argv[0], NULL);

        }

    }

    if (allocate_stack && stack_size == -1)

        usage(argv[0], "Указывать -a без -s не имеет смысла\n");

    if (argc > optind)

        usage(argv[0], "Посторонние аргументы в командной строке\n");

    if (stack_size >= 0 || guard_size > 0) {

        ret_attrp = attrp;

        s = pthread_attr_init(attrp);

        if (s != 0)

            handle_error_en(s, "pthread_attr_init");

    }

    if (stack_size >= 0) {

        if (!allocate_stack) {

            s = pthread_attr_setstacksize(attrp, stack_size);

            if (s != 0)

                handle_error_en(s, "pthread_attr_setstacksize");

        } else {

            s = posix_memalign(&stack_addr, sysconf(_SC_PAGESIZE),

                               stack_size);

            if (s != 0)

                handle_error_en(s, "posix_memalign");

            printf("Выделен стек нити по адресу %p\n\n", stack_addr);

            s = pthread_attr_setstack(attrp, stack_addr, stack_size);

            if (s != 0)

                handle_error_en(s, "pthread_attr_setstacksize");

        }

    }

    if (guard_size >= 0) {

        s = pthread_attr_setguardsize(attrp, guard_size);

        if (s != 0)

            handle_error_en(s, "pthread_attr_setstacksize");

    }

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

    int s;

    pthread_t thr;

    pthread_attr_t attr;

    pthread_attr_t *attrp = NULL;    /* задаёт &attr, если мы

                                        инициализируем объект

                                        атрибутов нити */

    attrp = get_thread_attributes_from_cl(argc, argv, &attr);

    if (attrp != NULL) {

        printf("Объект атрибутов нити после инициализации:\n");

        display_stack_related_attributes(attrp, "\t");

        printf("\n");

    }

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

    if (s != 0)

        handle_error_en(s, "pthread_create");

    if (attrp != NULL) {

        s = pthread_attr_destroy(attrp);

        if (s != 0)

            handle_error_en(s, "pthread_attr_destroy");

    }

    pause();    /* Завершается, когда другая нить вызывает exit() */
}