Pthreads

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

// Link with -lpthread

typedef struct {
    int   id;
    float value;
} SensorArgs;

static void* sensor_thread(void* arg) {
    SensorArgs* a = (SensorArgs*)arg;

    printf("Thread %d: reading sensor, value=%.2f\n", a->id, a->value);

    // Return a value through heap allocation (caller must free)
    float* result = malloc(sizeof(float));
    *result = a->value * 2.0f;
    return result;   // returned as void* via pthread_join
}

int main(void) {
    pthread_t tid;
    SensorArgs args = { .id = 1, .value = 23.5f };

    // Create thread
    int err = pthread_create(&tid, NULL, sensor_thread, &args);
    if (err) {
        fprintf(stderr, "pthread_create: %s\n", strerror(err));
        return 1;
    }

    // Wait for thread to finish and get return value
    void* retval;
    pthread_join(tid, &retval);

    float* result = (float*)retval;
    printf("Thread returned: %.2f\n", *result);
    free(result);

    return 0;
}

// Detach immediately (fire-and-forget)
pthread_detach(tid);

// Or create as detached from the start
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&tid, &attr, thread_func, NULL);
pthread_attr_destroy(&attr);

pthread_attr_t attr;
pthread_attr_init(&attr);

// Stack size (default is usually 8MB per thread)
pthread_attr_setstacksize(&attr, 64 * 1024);  // 64KB for small embedded threads

// Scheduling policy (needs root or CAP_SYS_NICE)
struct sched_param sp = { .sched_priority = 50 };
pthread_attr_setschedpolicy(&attr, SCHED_FIFO);    // real-time FIFO
pthread_attr_setschedparam(&attr, &sp);
pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);

pthread_create(&tid, &attr, thread_func, NULL);
pthread_attr_destroy(&attr);  // always destroy after use

#define _GNU_SOURCE
#include <sched.h>
#include <pthread.h>

// Bind the current thread to CPU 0
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(0, &cpuset);

int err = pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
if (err) fprintf(stderr, "setaffinity: %s\n", strerror(err));

// Verify
CPU_ZERO(&cpuset);
pthread_getaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
for (int i = 0; i < CPU_SETSIZE; i++)
    if (CPU_ISSET(i, &cpuset))
        printf("Bound to CPU %d\n", i);

// Using sched_setaffinity for the process
pid_t tid = gettid();
sched_setaffinity(tid, sizeof(cpuset), &cpuset);

// C11 thread-local storage
_Thread_local int errno_copy;
_Thread_local char last_error[256];

// GCC extension (older code)
__thread int tls_var = 0;

// POSIX keys — dynamic TLS (useful in libraries)
static pthread_key_t tls_key;

static void tls_destructor(void* val) {
    free(val);
}

void init_tls(void) {
    pthread_key_create(&tls_key, tls_destructor);
}

void* get_thread_buffer(void) {
    void* buf = pthread_getspecific(tls_key);
    if (!buf) {
        buf = malloc(1024);
        pthread_setspecific(tls_key, buf);
    }
    return buf;
}

// Request cancellation of a thread
pthread_cancel(tid);   // asynchronous request

// Thread should have cancellation points (blocking syscalls)
// OR set cancellation type to PTHREAD_CANCEL_ASYNCHRONOUS (dangerous)

// Control cancellation
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);  // disable in critical section
// ... critical work ...
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);   // re-enable

// Cancellation cleanup handlers
pthread_cleanup_push(cleanup_func, arg);
// ... code that might be cancelled ...
pthread_cleanup_pop(1);   // 1 = execute handler; 0 = pop without executing

#include <pthread.h>
#include <semaphore.h>

#define POOL_SIZE 4
#define QUEUE_SIZE 64

typedef void (*task_fn)(void* arg);

typedef struct { task_fn fn; void* arg; } Task;
typedef struct {
    pthread_t   threads[POOL_SIZE];
    Task        queue[QUEUE_SIZE];
    int         head, tail, count;
    pthread_mutex_t lock;
    pthread_cond_t  not_empty;
    int         running;
} ThreadPool;

static void* worker(void* p) {
    ThreadPool* pool = p;
    while (1) {
        pthread_mutex_lock(&pool->lock);
        while (pool->count == 0 && pool->running)
            pthread_cond_wait(&pool->not_empty, &pool->lock);
        if (!pool->running && pool->count == 0) {
            pthread_mutex_unlock(&pool->lock);
            return NULL;
        }
        Task t = pool->queue[pool->head++];
        pool->head %= QUEUE_SIZE;
        pool->count--;
        pthread_mutex_unlock(&pool->lock);
        t.fn(t.arg);
    }
}

void pool_submit(ThreadPool* pool, task_fn fn, void* arg) {
    pthread_mutex_lock(&pool->lock);
    pool->queue[pool->tail++] = (Task){ fn, arg };
    pool->tail %= QUEUE_SIZE;
    pool->count++;
    pthread_cond_signal(&pool->not_empty);
    pthread_mutex_unlock(&pool->lock);
}