POSIX Concurrency in C - Complete Guide

Table of Contents
1. Multithreaded Programming Basics
2. Basic Thread Creation Example

3. Thread Synchronization
4. Debugging Multithreaded Applications

5. Best Practices and Coding Guidelines

6. Complete Examples

1. Multithreaded Programming Basics {#basics}

Thread vs Process
Aspect Process Thread

Memory Space Separate address space Shared address space

Creation Overhead High (fork system call) Low (pthread_create)

Communication IPC mechanisms required Direct memory sharing

Context Switching Expensive Cheaper

Crash Impact Isolated Can affect entire process

Thread Attributes
Detached vs Joinable: Joinable threads must be joined; detached threads clean up automatically
Stack Size: Can be configured (default varies by system)

Scheduling Policy: SCHED_FIFO, SCHED_RR, SCHED_OTHER

Priority: Thread scheduling priority

Shared Resources
Threads within a process share:

Global variables

Heap memory
File descriptors
Signal handlers

Process ID

Each thread has its own:

 Stack
Registers

Program counter

Thread Standards
POSIX Threads (pthreads): IEEE POSIX 1003.1c standard

System V Threads: Older Solaris/SVR4 standard (largely obsolete)

2. Basic Thread Creation Example {#basic-example}

c
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

// Thread parameter structure (heap-allocated)

typedef struct {
int thread_id;
char message[100];
} thread_data_t;

// Thread function
void* worker_thread(void* arg) {
thread_data_t* data = (thread_data_t*)arg;

printf("Thread %d started: %s\n", data->thread_id, data->message);

// Simulate work
sleep(2);

// Allocate return value on heap

int* result = malloc(sizeof(int));
if (!result) {
pthread_exit(NULL);
}
*result = data->thread_id * 10;

printf("Thread %d finished\n", data->thread_id);

pthread_exit(result); // Use pthread_exit instead of return
}

int main() {
const int NUM_THREADS = 3;
pthread_t threads[NUM_THREADS];
thread_data_t* thread_data[NUM_THREADS];
int rc;

// Create threads
for (int i = 0; i < NUM_THREADS; i++) {
// Allocate thread data on heap (not stack)
thread_data[i] = malloc(sizeof(thread_data_t));
if (!thread_data[i]) {
fprintf(stderr, "Failed to allocate memory for thread data\n");
exit(1);
}
 thread_data[i]->thread_id = i;
snprintf(thread_data[i]->message, sizeof(thread_data[i]->message),
"Hello from thread %d", i);

rc = pthread_create(&threads[i], NULL, worker_thread, thread_data[i]);

if (rc) {
fprintf(stderr, "Error creating thread %d: %s\n", i, strerror(rc));
exit(1);
}
}

// Wait for all threads to complete

for (int i = 0; i < NUM_THREADS; i++) {
void* result;
rc = pthread_join(threads[i], &result);
if (rc) {
fprintf(stderr, "Error joining thread %d: %s\n", i, strerror(rc));
} else if (result) {
printf("Thread %d returned: %d\n", i, *(int*)result);
free(result); // Free the result allocated by thread
}

// Free thread data

free(thread_data[i]);
}

printf("All threads completed\n");

return 0;
}

3. Thread Synchronization {#synchronization}

Race Conditions and Critical Sections

A race condition occurs when multiple threads access shared data simultaneously, and the final result
depends on the timing of their execution.

A critical section is a code segment that accesses shared resources and must be executed atomically.

Synchronization Mechanisms

Mutex (Mutual Exclusion)

c
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

// Global shared resource

int global_counter = 0;
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;

typedef struct {
int thread_id;
int iterations;
} thread_param_t;

void* increment_counter(void* arg) {

thread_param_t* param = (thread_param_t*)arg;

for (int i = 0; i < param->iterations; i++) {

// Lock mutex before accessing shared resource
int rc = pthread_mutex_lock(&counter_mutex);
if (rc) {
fprintf(stderr, "Mutex lock failed: %s\n", strerror(rc));
pthread_exit(NULL);
}

// Critical section - keep it short

int temp = global_counter;
usleep(1); // Simulate some processing
global_counter = temp + 1;

// Always unlock mutex

rc = pthread_mutex_unlock(&counter_mutex);
if (rc) {
fprintf(stderr, "Mutex unlock failed: %s\n", strerror(rc));
pthread_exit(NULL);
}

// Some work outside critical section

usleep(10);
}

printf("Thread %d completed %d increments\n",

param->thread_id, param->iterations);

pthread_exit(NULL);
}

int main() {
const int NUM_THREADS = 5;
const int ITERATIONS_PER_THREAD = 1000;

pthread_t threads[NUM_THREADS];
thread_param_t* params[NUM_THREADS];
int rc;

printf("Initial counter value: %d\n", global_counter);

// Create threads
for (int i = 0; i < NUM_THREADS; i++) {
params[i] = malloc(sizeof(thread_param_t));
if (!params[i]) {
fprintf(stderr, "Memory allocation failed\n");
exit(1);
}

params[i]->thread_id = i;
params[i]->iterations = ITERATIONS_PER_THREAD;

rc = pthread_create(&threads[i], NULL, increment_counter, params[i]);

if (rc) {
fprintf(stderr, "Thread creation failed: %s\n", strerror(rc));
exit(1);
}
}

// Wait for all threads

for (int i = 0; i < NUM_THREADS; i++) {
rc = pthread_join(threads[i], NULL);
if (rc) {
fprintf(stderr, "Thread join failed: %s\n", strerror(rc));
}
free(params[i]);
}

printf("Final counter value: %d\n", global_counter);

printf("Expected value: %d\n", NUM_THREADS * ITERATIONS_PER_THREAD);

// Cleanup mutex
pthread_mutex_destroy(&counter_mutex);
 return 0;
}

Semaphores
c
#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define BUFFER_SIZE 5
#define NUM_PRODUCERS 2
#define NUM_CONSUMERS 2
#define ITEMS_TO_PRODUCE 10

// Shared buffer
int buffer[BUFFER_SIZE];
int buffer_index = 0;

// Semaphores and mutex

sem_t empty_slots; // Number of empty slots
sem_t full_slots; // Number of full slots
pthread_mutex_t buffer_mutex = PTHREAD_MUTEX_INITIALIZER;

typedef struct {
int id;
int items_to_process;
} worker_param_t;

void* producer(void* arg) {

worker_param_t* param = (worker_param_t*)arg;

for (int i = 0; i < param->items_to_process; i++) {

int item = param->id * 100 + i; // Unique item ID

// Wait for empty slot

if (sem_wait(&empty_slots) != 0) {
perror("sem_wait(empty_slots)");
pthread_exit(NULL);
}

// Lock buffer
if (pthread_mutex_lock(&buffer_mutex) != 0) {
perror("pthread_mutex_lock");
pthread_exit(NULL);
}

// Add item to buffer

buffer[buffer_index] = item;
 printf("Producer %d produced item %d at index %d\n",
param->id, item, buffer_index);
buffer_index++;

// Unlock buffer
if (pthread_mutex_unlock(&buffer_mutex) != 0) {
perror("pthread_mutex_unlock");
pthread_exit(NULL);
}

// Signal full slot

if (sem_post(&full_slots) != 0) {
perror("sem_post(full_slots)");
pthread_exit(NULL);
}

usleep(100000); // 100ms delay

}

pthread_exit(NULL);
}

void* consumer(void* arg) {

worker_param_t* param = (worker_param_t*)arg;

for (int i = 0; i < param->items_to_process; i++) {

// Wait for full slot
if (sem_wait(&full_slots) != 0) {
perror("sem_wait(full_slots)");
pthread_exit(NULL);
}

// Lock buffer
if (pthread_mutex_lock(&buffer_mutex) != 0) {
perror("pthread_mutex_lock");
pthread_exit(NULL);
}

// Remove item from buffer

buffer_index--;
int item = buffer[buffer_index];
printf("Consumer %d consumed item %d from index %d\n",
param->id, item, buffer_index);

// Unlock buffer
if (pthread_mutex_unlock(&buffer_mutex) != 0) {
perror("pthread_mutex_unlock");
 pthread_exit(NULL);
}

// Signal empty slot

if (sem_post(&empty_slots) != 0) {
perror("sem_post(empty_slots)");
pthread_exit(NULL);
}

usleep(150000); // 150ms delay

}

pthread_exit(NULL);
}

int main() {
pthread_t producers[NUM_PRODUCERS];
pthread_t consumers[NUM_CONSUMERS];
worker_param_t* producer_params[NUM_PRODUCERS];
worker_param_t* consumer_params[NUM_CONSUMERS];

// Initialize semaphores
if (sem_init(&empty_slots, 0, BUFFER_SIZE) != 0) {
perror("sem_init(empty_slots)");
exit(1);
}
if (sem_init(&full_slots, 0, 0) != 0) {
perror("sem_init(full_slots)");
exit(1);
}

// Create producers
for (int i = 0; i < NUM_PRODUCERS; i++) {
producer_params[i] = malloc(sizeof(worker_param_t));
producer_params[i]->id = i;
producer_params[i]->items_to_process = ITEMS_TO_PRODUCE;

if (pthread_create(&producers[i], NULL, producer, producer_params[i]) != 0) {

perror("pthread_create(producer)");
exit(1);
}
}

// Create consumers
for (int i = 0; i < NUM_CONSUMERS; i++) {
consumer_params[i] = malloc(sizeof(worker_param_t));
consumer_params[i]->id = i;
 consumer_params[i]->items_to_process = ITEMS_TO_PRODUCE;

if (pthread_create(&consumers[i], NULL, consumer, consumer_params[i]) != 0) {

perror("pthread_create(consumer)");
exit(1);
}
}

// Wait for all threads

for (int i = 0; i < NUM_PRODUCERS; i++) {
pthread_join(producers[i], NULL);
free(producer_params[i]);
}

for (int i = 0; i < NUM_CONSUMERS; i++) {

pthread_join(consumers[i], NULL);
free(consumer_params[i]);
}

// Cleanup
sem_destroy(&empty_slots);
sem_destroy(&full_slots);
pthread_mutex_destroy(&buffer_mutex);

printf("Program completed successfully\n");

return 0;
}

4. Debugging Multithreaded Applications {#debugging}

Using GDB for Thread Debugging

Compilation for Debugging

bash

gcc -g -pthread -o myprogram myprogram.c

Key GDB Commands for Threads

 bash

# List all threads

(gdb) info threads

# Switch to specific thread

(gdb) thread 2

# Apply command to all threads

(gdb) thread apply all bt

# Set breakpoint in specific thread

(gdb) break function_name thread 2

# Continue only current thread

(gdb) continue

# Step only current thread

(gdb) set scheduler-locking step

Using Valgrind for Memory Issues

Helgrind - Race Condition Detection

bash

valgrind --tool=helgrind ./myprogram

DRD - Data Race Detection

bash

valgrind --tool=drd ./myprogram

Memcheck - Memory Leak Detection

bash

valgrind --leak-check=full --track-origins=yes ./myprogram

Common Issues and Solutions

1. Deadlock Detection Example

 c

// Problematic code that can cause deadlock

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;

void* thread1_func(void* arg) {

pthread_mutex_lock(&mutex1);
sleep(1);
pthread_mutex_lock(&mutex2); // Potential deadlock

// Critical section

pthread_mutex_unlock(&mutex2);
pthread_mutex_unlock(&mutex1);
return NULL;
}

void* thread2_func(void* arg) {

pthread_mutex_lock(&mutex2);
sleep(1);
pthread_mutex_lock(&mutex1); // Potential deadlock

// Critical section

pthread_mutex_unlock(&mutex1);
pthread_mutex_unlock(&mutex2);
return NULL;
}

// Solution: Always acquire locks in the same order

void* thread1_func_fixed(void* arg) {
pthread_mutex_lock(&mutex1); // Always lock mutex1 first
pthread_mutex_lock(&mutex2);

// Critical section

pthread_mutex_unlock(&mutex2);
pthread_mutex_unlock(&mutex1);
return NULL;
}

5. Best Practices and Coding Guidelines {#guidelines}

Error Handling
 c

// Always check return values

int rc = pthread_create(&thread, NULL, thread_func, arg);
if (rc) {
fprintf(stderr, "pthread_create failed: %s\n", strerror(rc));
exit(1);
}

rc = pthread_join(thread, NULL);
if (rc) {
fprintf(stderr, "pthread_join failed: %s\n", strerror(rc));
}

Memory Management
 c

// ✅ CORRECT: Pass heap-allocated data

typedef struct {
int data;
} thread_param_t;

void* correct_thread(void* arg) {

thread_param_t* param = (thread_param_t*)arg;
// Use param->data

// Return heap-allocated or static data

int* result = malloc(sizeof(int));
*result = 42;
pthread_exit(result);
}

int main() {
pthread_t thread;
thread_param_t* param = malloc(sizeof(thread_param_t));
param->data = 100;

pthread_create(&thread, NULL, correct_thread, param);

void* result;
pthread_join(thread, &result);

printf("Result: %d\n", *(int*)result);

free(result); // Free thread's return value
free(param); // Free parameter
}

// ❌ WRONG: Passing stack variables

void wrong_example() {
pthread_t thread;
int stack_var = 100; // Stack variable

// DON'T DO THIS - stack_var may be invalid when thread runs

pthread_create(&thread, NULL, some_thread, &stack_var);
}

Mutex Best Practices

c

// ✅ CORRECT: Short critical sections

void good_mutex_usage() {
pthread_mutex_lock(&mutex);

// Short critical section

shared_variable++;

pthread_mutex_unlock(&mutex);

// Do expensive work outside critical section

expensive_computation();
}

// ❌ WRONG: Long critical sections

void bad_mutex_usage() {
pthread_mutex_lock(&mutex);

shared_variable++;
expensive_computation(); // Don't do this inside lock
file_operations(); // Don't do this inside lock

pthread_mutex_unlock(&mutex);
}

// ✅ CORRECT: Proper error handling and cleanup

int safe_mutex_operation() {
int rc = pthread_mutex_lock(&mutex);
if (rc) {
fprintf(stderr, "Mutex lock failed: %s\n", strerror(rc));
return -1;
}

// Critical section
shared_variable++;

rc = pthread_mutex_unlock(&mutex);
if (rc) {
fprintf(stderr, "Mutex unlock failed: %s\n", strerror(rc));
return -1;
}

return 0;
}
Thread Lifecycle Management

void proper_thread_management() {
const int NUM_THREADS = 5;
pthread_t threads[NUM_THREADS];

// Create all threads

for (int i = 0; i < NUM_THREADS; i++) {
// ... create threads with error checking
}

// Wait for ALL threads before exiting

for (int i = 0; i < NUM_THREADS; i++) {
int rc = pthread_join(threads[i], NULL);
if (rc) {
fprintf(stderr, "Failed to join thread %d: %s\n", i, strerror(rc));
}
}

// Cleanup resources
pthread_mutex_destroy(&mutex);
}

6. Complete Examples {#examples}

Producer-Consumer with Error Handling

c
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

#define QUEUE_SIZE 10
#define NUM_ITEMS 50

typedef struct {
int* items;
int front;
int rear;
int count;
int size;
pthread_mutex_t mutex;
pthread_cond_t not_full;
pthread_cond_t not_empty;
} queue_t;

typedef struct {
int id;
queue_t* queue;
int items_to_process;
} worker_t;

// Initialize queue
int queue_init(queue_t* q, int size) {
q->items = malloc(size * sizeof(int));
if (!q->items) {
return -1;
}

q->front = 0;
q->rear = 0;
q->count = 0;
q->size = size;

if (pthread_mutex_init(&q->mutex, NULL) != 0) {
free(q->items);
return -1;
}

if (pthread_cond_init(&q->not_full, NULL) != 0) {
pthread_mutex_destroy(&q->mutex);
 free(q->items);
return -1;
}

if (pthread_cond_init(&q->not_empty, NULL) != 0) {
pthread_cond_destroy(&q->not_full);
pthread_mutex_destroy(&q->mutex);
free(q->items);
return -1;
}

return 0;
}

// Destroy queue
void queue_destroy(queue_t* q) {
pthread_cond_destroy(&q->not_empty);
pthread_cond_destroy(&q->not_full);
pthread_mutex_destroy(&q->mutex);
free(q->items);
}

// Add item to queue

int queue_put(queue_t* q, int item) {
if (pthread_mutex_lock(&q->mutex) != 0) {
return -1;
}

// Wait while queue is full

while (q->count == q->size) {
if (pthread_cond_wait(&q->not_full, &q->mutex) != 0) {
pthread_mutex_unlock(&q->mutex);
return -1;
}
}

// Add item
q->items[q->rear] = item;
q->rear = (q->rear + 1) % q->size;
q->count++;

// Signal that queue is not empty

pthread_cond_signal(&q->not_empty);

if (pthread_mutex_unlock(&q->mutex) != 0) {
return -1;
}
 return 0;
}

// Get item from queue

int queue_get(queue_t* q, int* item) {
if (pthread_mutex_lock(&q->mutex) != 0) {
return -1;
}

// Wait while queue is empty

while (q->count == 0) {
if (pthread_cond_wait(&q->not_empty, &q->mutex) != 0) {
pthread_mutex_unlock(&q->mutex);
return -1;
}
}

// Get item
*item = q->items[q->front];
q->front = (q->front + 1) % q->size;
q->count--;

// Signal that queue is not full

pthread_cond_signal(&q->not_full);

if (pthread_mutex_unlock(&q->mutex) != 0) {
return -1;
}

return 0;
}

void* producer(void* arg) {

worker_t* worker = (worker_t*)arg;

for (int i = 0; i < worker->items_to_process; i++) {

int item = worker->id * 1000 + i;

if (queue_put(worker->queue, item) != 0) {
fprintf(stderr, "Producer %d: Failed to put item %d\n",
worker->id, item);
pthread_exit(NULL);
}

printf("Producer %d produced item %d\n", worker->id, item);

usleep(rand() % 100000); // Random delay 0-100ms
 }

printf("Producer %d finished\n", worker->id);

pthread_exit(NULL);
}

void* consumer(void* arg) {

worker_t* worker = (worker_t*)arg;

for (int i = 0; i < worker->items_to_process; i++) {

int item;

if (queue_get(worker->queue, &item) != 0) {
fprintf(stderr, "Consumer %d: Failed to get item\n", worker->id);
pthread_exit(NULL);
}

printf("Consumer %d consumed item %d\n", worker->id, item);

usleep(rand() % 150000); // Random delay 0-150ms
}

printf("Consumer %d finished\n", worker->id);

pthread_exit(NULL);
}

int main() {
queue_t queue;
const int NUM_PRODUCERS = 2;
const int NUM_CONSUMERS = 2;

pthread_t producers[NUM_PRODUCERS];
pthread_t consumers[NUM_CONSUMERS];
worker_t* producer_workers[NUM_PRODUCERS];
worker_t* consumer_workers[NUM_CONSUMERS];

// Initialize queue
if (queue_init(&queue, QUEUE_SIZE) != 0) {
fprintf(stderr, "Failed to initialize queue\n");
exit(1);
}

// Create producer workers

for (int i = 0; i < NUM_PRODUCERS; i++) {
producer_workers[i] = malloc(sizeof(worker_t));
if (!producer_workers[i]) {
fprintf(stderr, "Memory allocation failed\n");
exit(1);
 }

producer_workers[i]->id = i;
producer_workers[i]->queue = &queue;
producer_workers[i]->items_to_process = NUM_ITEMS / NUM_PRODUCERS;

if (pthread_create(&producers[i], NULL, producer, producer_workers[i]) != 0) {

fprintf(stderr, "Failed to create producer thread %d\n", i);
exit(1);
}
}

// Create consumer workers

for (int i = 0; i < NUM_CONSUMERS; i++) {
consumer_workers[i] = malloc(sizeof(worker_t));
if (!consumer_workers[i]) {
fprintf(stderr, "Memory allocation failed\n");
exit(1);
}

consumer_workers[i]->id = i;
consumer_workers[i]->queue = &queue;
consumer_workers[i]->items_to_process = NUM_ITEMS / NUM_CONSUMERS;

if (pthread_create(&consumers[i], NULL, consumer, consumer_workers[i]) != 0) {

fprintf(stderr, "Failed to create consumer thread %d\n", i);
exit(1);
}
}

// Wait for all producers

for (int i = 0; i < NUM_PRODUCERS; i++) {
if (pthread_join(producers[i], NULL) != 0) {
fprintf(stderr, "Failed to join producer thread %d\n", i);
}
free(producer_workers[i]);
}

// Wait for all consumers

for (int i = 0; i < NUM_CONSUMERS; i++) {
if (pthread_join(consumers[i], NULL) != 0) {
fprintf(stderr, "Failed to join consumer thread %d\n", i);
}
free(consumer_workers[i]);
}

// Cleanup
 queue_destroy(&queue);

printf("Program completed successfully\n");

return 0;
}

Compilation Commands

bash

# Basic compilation
gcc -pthread -o program program.c

# With debugging symbols

gcc -g -pthread -o program program.c

# With all warnings

gcc -Wall -Wextra -pthread -o program program.c

# For production (optimized)

gcc -O2 -pthread -o program program.c

# Link with semaphore library (if needed)

gcc -pthread -lrt -o program program.c

Key Takeaways
1. Always handle errors after pthread function calls

2. Use heap allocation for thread parameters and return values

3. Keep critical sections short to minimize lock contention
4. Always join with joinable threads before program exit

5. Use proper synchronization to avoid race conditions

6. Test thoroughly with tools like Valgrind and GDB

7. Follow consistent lock ordering to prevent deadlocks

8. Free allocated memory in the correct thread context