The primary interface for spawning a new execution flow within a process is pthread_create. The function signature defines the thread identifier, configuration attributes, the entry routine, and an argument pointer past to that routine.

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
                   void *(*start_routine)(void *), void *arg);

Managing Thread Configuration Objects

The type pthread_attr_t serves as an opaque object for defining thread characteristics such as stack size, scheduling policy, and detachment state. Because the internal structure of this type varies across implementations, direct member access is prohibited. Instead, developers must utilize the provided accessor and mutator functions to initialize, configure, and destroy these objects.

Inspecting and Modifying Thread Attributes

The following example demonstrates how to initialize an attribute object, modify the stack size, and verify the configuration both before and after thread execution. It utilizes non-standard GNU extensions to inspect the attributes of runing threads.

#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

static void dump_thread_config(const char *label, pthread_attr_t *config)
{
    int state = 0;
    int scope = 0;
    int policy = 0;
    size_t stack_sz = 0;
    void *stack_base = NULL;
    struct sched_param param = {0};
    int ret = 0;

    ret = pthread_attr_getdetachstate(config, &state);
    printf("[%s] Detach State: %s\n", label, 
           (state == PTHREAD_CREATE_DETACHED) ? "DETACHED" : "JOINABLE");

    ret = pthread_attr_getstack(config, &stack_base, &stack_sz);
    printf("[%s] Stack Size: %zu bytes\n", label, stack_sz);
    printf("[%s] Stack Base: %p\n", label, stack_base);

    ret = pthread_attr_getschedpolicy(config, &policy);
    printf("[%s] Policy: %s\n", label, 
           (policy == SCHED_FIFO) ? "FIFO" : 
           (policy == SCHED_RR) ? "RR" : "OTHER");
}

void *worker_routine(void *arg)
{
    pthread_attr_t self_config;
    pthread_getattr_np(pthread_self(), &self_config);
    dump_thread_config("WORKER", &self_config);
    pthread_attr_destroy(&self_config);
    return NULL;
}

int main(void)
{
    pthread_t tid;
    pthread_attr_t config;
    
    pthread_attr_init(&config);
    dump_thread_config("DEFAULT", &config);

    // Set custom stack size to 4MB
    pthread_attr_setstacksize(&config, 4 * 1024 * 1024);
    
    pthread_create(&tid, &config, worker_routine, NULL);
    pthread_join(tid, NULL);

    pthread_attr_destroy(&config);
    return 0;
}

In this implementation, the stack size is explicitly set to 4MB before spawning the worker. The pthread_getattr_np function allows introspection of the currently running thread's properties, requiring the _GNU_SOURCE feature test macro.

Lifecycle and Termination Strategies

A thread may cease execution through three primary mechanisms:

1. Implicit Return: The start routine executes a return statement, passing a value back to the joiner.
2. Explicit Exit: The routine calls pthread_exit(void *retval), which terminates the caller immediately.
3. Cancellation: Another thread invokes pthread_cancel(target_tid), requesting termination (subject to cancellation points and state).

Handling Return Data

When using pthread_join(pthread_t tid, void **retval), the retval argument captures the pointer returned by the target thread. Care must be taken regarding the lifetime of the data pointed to.

• Primitives: Can be cast directly to void * if they fit within a pointer width.
• Complex Data: Should be allocated on the heap or stored in static memory. Returning addresses of local stack variables leads to undefined behavior as the stack frame is invalidated upon return.
• Argument Mutation: Data can be passed by reference in the arg parameter, allowing the thread to modify existing structures.

Return Value Patterns Experiment

The code below illustrates safe and unsafe methods for returning data from a thread.

#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Unsafe: Returns address of local variable
void *unsafe_stack_return(void *arg)
{
    char buffer[] = "temporary data";
    return (void *)buffer; 
}

// Safe: Bitwise copy of double into pointer storage
void *encoded_double_return(void *arg)
{
    double value = 3.14159;
    void *encoded = NULL;
    memcpy(&encoded, &value, sizeof(encoded));
    return encoded;
}

// Safe: Heap allocated array
void *heap_array_return(void *arg)
{
    int *data = malloc(4 * sizeof(int));
    for(int i = 0; i < 4; i++) data[i] = i * 10;
    return (void *)data;
}

// Safe: Modifying argument pointer
void *modify_arg_return(void *arg)
{
    double *input = (double *)arg;
    *input = *input * 2.0;
    return NULL;
}

int main(void)
{
    pthread_t tid;
    void *result = NULL;
    double pi_val = 0;
    int *numbers = NULL;
    double factor = 5.0;

    // Test encoded double
    pthread_create(&tid, NULL, encoded_double_return, NULL);
    pthread_join(tid, &result);
    memcpy(&pi_val, &result, sizeof(pi_val));
    printf("Decoded Pi: %f\n", pi_val);

    // Test heap array
    pthread_create(&tid, NULL, heap_array_return, NULL);
    pthread_join(tid, (void **)&numbers);
    printf("Array[2]: %d\n", numbers[2]);
    free(numbers);

    // Test argument modification
    pthread_create(&tid, NULL, modify_arg_return, (void *)&factor);
    pthread_join(tid, NULL);
    printf("Modified Factor: %f\n", factor);

    return 0;
}

Note that unsafe_stack_return is commented out in execution logic because accessing the returned pointer after the thread exits results in memory corruption. The encoded_double_return works on 64-bit systems where sizeof(void *) equals sizeof(double).

Concurrency Pattern: Parallel Recursive Calculation

Recursive algorithms like Fibonacci calculation can be parallelized by spawning threads for sub-problems. To prevent exponential thread explosion and redundant calculations, a shared cache array is used for memoization.

#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

typedef struct {
    int index;
    int *cache;
} FibTask;

void *compute_fib_task(void *arg)
{
    FibTask *task = (FibTask *)arg;
    int n = task->index;
    
    // Check if already computed (memoization)
    if (task->cache[n] == 0 && n > 1) 
    {
        pthread_t t_left, t_right;
        FibTask left_ctx = { n - 1, task->cache };
        FibTask right_ctx = { n - 2, task->cache };

        // Spawn sub-tasks
        pthread_create(&t_left, NULL, compute_fib_task, &left_ctx);
        usleep(100); // Throttle thread creation
        pthread_create(&t_right, NULL, compute_fib_task, &right_ctx);

        pthread_join(t_left, NULL);
        pthread_join(t_right, NULL);

        // Aggregate results
        task->cache[n] = task->cache[n - 1] + task->cache[n - 2];
    }
    else if (n <= 1)
    {
        task->cache[n] = 1;
    }

    return NULL;
}

long long calculate_fibonacci(int n)
{
    int *memo = calloc(n + 1, sizeof(int));
    pthread_t main_thread;
    long long result = 0;

    if (!memo) return 0;

    FibTask root = { n, memo };
    
    // Base cases initialization
    memo[0] = 1;
    memo[1] = 1;

    pthread_create(&main_thread, NULL, compute_fib_task, &root);
    pthread_join(main_thread, NULL);

    result = memo[n];
    free(memo);
    return result;
}

int main(void)
{
    printf("Fibonacci(20) = %lld\n", calculate_fibonacci(20));
    return 0;
}

The FibTask structure encapsulates the current index and the shared memory array. Before spawning new threads, the routine checks if the value at the current index is non-zero. This prevents re-computation. A small delay (usleep) is introduced during thread creation to mitigate resource exhaustion caused by rapid spawning of too many concurrent threads.