pthread_attr_t is an opaque object (like pthread_t) that bundles together all the configurable properties of a thread before it is created. You cannot inspect its internals directly — you use dedicated API functions to set and get each attribute.

The typical workflow is:

Step ④ is important even though pthread_attr_destroy() may be a no-op on some implementations. On others it frees memory. Always call it for correctness and portability. The attribute object can be destroyed immediately after pthread_create() — modifying it afterwards has no effect on already-created threads.

The default stack size on Linux is typically 8 MB per thread. For most threads this is more than enough. However, there are two scenarios where you would want to change it:

By default all threads use the SCHED_OTHER (normal time-sharing) policy. For realtime or high-priority work you can set SCHED_FIFO (first-in first-out) or SCHED_RR (round-robin).

This example creates a thread with a small stack (256 KB instead of the default 8 MB). Useful when spawning many threads in a memory-constrained environment.

/* compile: gcc -pthread -o custom_stack custom_stack.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>    /* PTHREAD_STACK_MIN */
#include <pthread.h>

#define STACK_SIZE  (256 * 1024)   /* 256 KB */

static void *worker(void *arg)
{
    printf("Thread running with custom stack size\n");

    /* Demonstrate: allocating a local array of 64 KB — fits in 256 KB stack */
    char buf[64 * 1024];
    buf[0] = 'A';
    buf[(64*1024) - 1] = 'Z';
    printf("Local buffer: first=%c last=%c\n", buf[0], buf[(64*1024)-1]);

    return NULL;
}

int main(void)
{
    pthread_t      tid;
    pthread_attr_t attr;
    int            s;

    /* Verify our desired size is at least the minimum */
    if (STACK_SIZE < PTHREAD_STACK_MIN) {
        fprintf(stderr, "Stack size too small! Minimum is %d bytes.\n",
                (int)PTHREAD_STACK_MIN);
        exit(1);
    }

    s = pthread_attr_init(&attr);
    if (s != 0) { fprintf(stderr, "attr_init: %s\n", strerror(s)); exit(1); }

    /* Set custom stack size */
    s = pthread_attr_setstacksize(&attr, STACK_SIZE);
    if (s != 0) { fprintf(stderr, "setstacksize: %s\n", strerror(s)); exit(1); }

    /* Verify the size was set correctly */
    size_t actual_size;
    pthread_attr_getstacksize(&attr, &actual_size);
    printf("Requested stack: %d bytes, actual: %zu bytes\n",
           STACK_SIZE, actual_size);

    s = pthread_create(&tid, &attr, worker, NULL);
    if (s != 0) { fprintf(stderr, "create: %s\n", strerror(s)); exit(1); }

    pthread_attr_destroy(&attr);   /* safe to destroy after create */

    pthread_join(tid, NULL);
    printf("Done.\n");
    return 0;
}

You can set several attributes on a single pthread_attr_t object before calling pthread_create(). This example sets both a custom stack size and the detached state.

/* compile: gcc -pthread -o multi_attr multi_attr.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <pthread.h>

#define STACK_SIZE  (512 * 1024)   /* 512 KB */

static void *background_task(void *arg)
{
    int task_id = (int)(intptr_t) arg;
    printf("BG Task %d: running (detached, 512KB stack)\n", task_id);
    /* simulate some work */
    for (volatile int i = 0; i < 100000000; i++);
    printf("BG Task %d: complete\n", task_id);
    return NULL;
}

int main(void)
{
    pthread_t      tids[3];
    pthread_attr_t attr;
    int            s;

    s = pthread_attr_init(&attr);
    if (s) { fprintf(stderr, "attr_init: %s\n", strerror(s)); exit(1); }

    /* Attribute 1: detached — no join needed */
    s = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    if (s) { fprintf(stderr, "setdetachstate: %s\n", strerror(s)); exit(1); }

    /* Attribute 2: custom stack size */
    s = pthread_attr_setstacksize(&attr, STACK_SIZE);
    if (s) { fprintf(stderr, "setstacksize: %s\n", strerror(s)); exit(1); }

    /* Create 3 threads that all share the same attribute set */
    for (int i = 0; i < 3; i++) {
        s = pthread_create(&tids[i], &attr, background_task,
                           (void *)(intptr_t)(i + 1));
        if (s) { fprintf(stderr, "create %d: %s\n", i, strerror(s)); exit(1); }
        printf("Main: launched background task %d\n", i + 1);
    }

    /* Attribute object no longer needed after all creates */
    pthread_attr_destroy(&attr);

    printf("Main: all tasks launched. Exiting via pthread_exit.\n");
    pthread_exit(NULL);   /* let detached threads finish */
    return 0;
}

All three threads share the same attribute configuration (detached + 512 KB stack). The attribute object is destroyed after all three pthread_create() calls — this is safe because the attributes are copied into each thread at creation.

Every pthread_attr_set*() function has a corresponding pthread_attr_get*() function. These are useful for verifying that attributes were set correctly, or for reading the default values before modifying them.

pthread_attr_t attr;
pthread_attr_init(&attr);

/* Read detach state */
int detach_state;
pthread_attr_getdetachstate(&attr, &detach_state);
printf("Detach state: %s\n",
       detach_state == PTHREAD_CREATE_JOINABLE ? "JOINABLE" : "DETACHED");

/* Read stack size */
size_t stack_size;
pthread_attr_getstacksize(&attr, &stack_size);
printf("Default stack size: %zu bytes (%zu MB)\n",
       stack_size, stack_size / (1024 * 1024));

pthread_attr_destroy(&attr);