Every thread needs its own private stack. The stack holds:

• Local variables declared inside functions
• Function call return addresses
• Function arguments (depending on architecture calling convention)
• Saved registers during context switches

Because each thread runs independently, they must each have their own stack. If two threads shared a stack, their local variables would collide and corrupt each other.

The default per-thread stack size (for threads other than the main thread) depends on the architecture:

On x86-32 with a 3 GB user virtual address space:

You can query the minimum stack size supported by the current threading implementation using sysconf():

#include <unistd.h>   /* sysconf */
#include <stdio.h>

int main(void)
{
    long min_stack = sysconf(_SC_THREAD_STACK_MIN);
    printf("Minimum thread stack size: %ld bytes (%ld KB)\n",
           min_stack, min_stack / 1024);
    return 0;
}
/* On NPTL / x86-32: prints 16384 bytes = 16 KB */

Use pthread_attr_setstacksize() to set the stack size in a thread attributes object before creating the thread.

This example creates a thread with a reduced 512 KB stack. Useful for embedded systems or when you need many threads in a constrained address space.

/*
 * ep_stack_size.c — Create a thread with a custom stack size
 * Compile: gcc -o ep_stack_size ep_stack_size.c -lpthread
 */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

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

void *thread_func(void *arg)
{
    /* Local array to demonstrate stack usage */
    char local_buf[1024];
    local_buf[0] = 'A';  /* touch the memory */
    printf("[Thread %lu] Running with custom 512 KB stack\n",
           (unsigned long)pthread_self());
    printf("[Thread %lu] local_buf is at %p\n",
           (unsigned long)pthread_self(), (void *)local_buf);
    return NULL;
}

int main(void)
{
    pthread_t tid;
    pthread_attr_t attr;
    size_t stack_size;
    int ret;

    /* Step 1: Initialise attributes object */
    ret = pthread_attr_init(&attr);
    if (ret != 0) { perror("pthread_attr_init"); exit(EXIT_FAILURE); }

    /* Step 2: Set the stack size */
    ret = pthread_attr_setstacksize(&attr, STACK_SIZE);
    if (ret != 0) { perror("pthread_attr_setstacksize"); exit(EXIT_FAILURE); }

    /* Step 3: Verify what was set */
    pthread_attr_getstacksize(&attr, &stack_size);
    printf("[Main] Thread stack size will be: %zu KB\n", stack_size / 1024);

    /* Step 4: Create thread with the attribute */
    ret = pthread_create(&tid, &attr, thread_func, NULL);
    if (ret != 0) { perror("pthread_create"); exit(EXIT_FAILURE); }

    /* Step 5: Destroy attributes (no longer needed after create) */
    pthread_attr_destroy(&attr);

    pthread_join(tid, NULL);
    printf("[Main] Thread finished. Program exiting.\n");
    return 0;
}

Expected output:

[Main] Thread stack size will be: 512 KB
[Thread 140234567890] Running with custom 512 KB stack
[Thread 140234567890] local_buf is at 0x7f3a40007a00
[Main] Thread finished. Program exiting.

This example demonstrates querying stack limits, checking RLIMIT_STACK, and estimating the theoretical maximum thread count based on virtual address space.

/*
 * ep_stack_limits.c — Explore stack size limits
 * Compile: gcc -o ep_stack_limits ep_stack_limits.c -lpthread
 */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/resource.h>

int main(void)
{
    struct rlimit rl;
    long min_stack;
    size_t default_stack;
    pthread_attr_t attr;

    /* Query minimum stack size for this implementation */
    min_stack = sysconf(_SC_THREAD_STACK_MIN);
    printf("sysconf(_SC_THREAD_STACK_MIN) = %ld bytes (%ld KB)\n",
           min_stack, min_stack / 1024);

    /* Query RLIMIT_STACK — affects NPTL default stack size */
    if (getrlimit(RLIMIT_STACK, &rl) == 0) {
        if (rl.rlim_cur == RLIM_INFINITY)
            printf("RLIMIT_STACK = unlimited\n");
        else
            printf("RLIMIT_STACK = %lu KB\n",
                   (unsigned long)rl.rlim_cur / 1024);
    }

    /* Get the default stack size from a default attr object */
    pthread_attr_init(&attr);
    pthread_attr_getstacksize(&attr, &default_stack);
    printf("Default thread stack size (attr) = %zu KB\n",
           default_stack / 1024);
    pthread_attr_destroy(&attr);

    /* Calculate theoretical max threads on x86-32 (3 GB user space) */
    unsigned long user_space = 3UL * 1024 * 1024 * 1024; /* 3 GB */
    unsigned long max_threads = user_space / default_stack;
    printf("\nTheoretical max threads (x86-32, 3GB user space): ~%lu\n",
           max_threads);
    printf("(Real limit lower due to text/data/heap/libs overhead)\n");

    /* Show how reducing stack size increases max thread count */
    printf("\nWith 256 KB stack:  ~%lu threads\n",
           user_space / (256 * 1024));
    printf("With 512 KB stack:  ~%lu threads\n",
           user_space / (512 * 1024));
    printf("With 2048 KB stack: ~%lu threads\n",
           user_space / (2048 * 1024));

    return 0;
}
/* NOTE: Under NPTL, if RLIMIT_STACK != unlimited, it becomes
 * the default stack size for new threads. Set it BEFORE exec()
 * using:  ulimit -s 512   (in shell, before running the program)
 * Calling setrlimit() inside main() is too late for NPTL. */