Multithreading in C

1#include <stdio.h>
2#include <pthread.h>
3#include <unistd.h>
4
5// Thread function - must return void* and take void*
6void* print_numbers(void* arg) {
7    int id = *(int*)arg;
8    
9    for (int i = 1; i <= 5; i++) {
10        printf("Thread %d: %d\n", id, i);
11        sleep(1);  // Sleep 1 second
12    }
13    
14    return NULL;
15}
16
17int main() {
18    pthread_t thread1, thread2;
19    int id1 = 1, id2 = 2;
20    
21    // Create threads
22    pthread_create(&thread1, NULL, print_numbers, &id1);
23    pthread_create(&thread2, NULL, print_numbers, &id2);
24    
25    printf("Main: Both threads started\n");
26    
27    // Wait for threads to finish
28    pthread_join(thread1, NULL);
29    pthread_join(thread2, NULL);
30    
31    printf("Main: Both threads finished\n");
32    return 0;
33}

1#include <stdio.h>
2#include <pthread.h>
3#include <stdlib.h>
4
5// Struct to pass multiple arguments
6typedef struct {
7    int start;
8    int end;
9    long result;
10} SumArgs;
11
12void* sum_range(void* arg) {
13    SumArgs* args = (SumArgs*)arg;
14    args->result = 0;
15    
16    for (int i = args->start; i <= args->end; i++) {
17        args->result += i;
18    }
19    
20    printf("Sum from %d to %d = %ld\n", 
21           args->start, args->end, args->result);
22    return NULL;
23}
24
25int main() {
26    pthread_t t1, t2;
27    SumArgs args1 = {1, 50000000, 0};
28    SumArgs args2 = {50000001, 100000000, 0};
29    
30    // Calculate in parallel
31    pthread_create(&t1, NULL, sum_range, &args1);
32    pthread_create(&t2, NULL, sum_range, &args2);
33    
34    pthread_join(t1, NULL);
35    pthread_join(t2, NULL);
36    
37    long total = args1.result + args2.result;
38    printf("Total sum: %ld\n", total);
39    
40    return 0;
41}

1#include <stdio.h>
2#include <pthread.h>
3
4int counter = 0;
5pthread_mutex_t lock;
6
7void* increment(void* arg) {
8    for (int i = 0; i < 1000000; i++) {
9        pthread_mutex_lock(&lock);    // Lock
10        counter++;                     // Critical section
11        pthread_mutex_unlock(&lock);  // Unlock
12    }
13    return NULL;
14}
15
16int main() {
17    pthread_t t1, t2;
18    
19    // Initialize mutex
20    pthread_mutex_init(&lock, NULL);
21    
22    pthread_create(&t1, NULL, increment, NULL);
23    pthread_create(&t2, NULL, increment, NULL);
24    
25    pthread_join(t1, NULL);
26    pthread_join(t2, NULL);
27    
28    // Destroy mutex
29    pthread_mutex_destroy(&lock);
30    
31    // Without mutex: unpredictable value < 2000000
32    // With mutex: always 2000000
33    printf("Counter: %d (expected: 2000000)\n", counter);
34    
35    return 0;
36}

1#include <stdio.h>
2#include <pthread.h>
3#include <stdbool.h>
4
5int data = 0;
6bool ready = false;
7pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
8pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
9
10void* producer(void* arg) {
11    pthread_mutex_lock(&lock);
12    
13    data = 42;
14    ready = true;
15    printf("Producer: Data is ready!\n");
16    
17    pthread_cond_signal(&cond);  // Wake up consumer
18    pthread_mutex_unlock(&lock);
19    
20    return NULL;
21}
22
23void* consumer(void* arg) {
24    pthread_mutex_lock(&lock);
25    
26    while (!ready) {  // Wait for data
27        printf("Consumer: Waiting...\n");
28        pthread_cond_wait(&cond, &lock);
29    }
30    
31    printf("Consumer: Got data = %d\n", data);
32    pthread_mutex_unlock(&lock);
33    
34    return NULL;
35}
36
37int main() {
38    pthread_t prod, cons;
39    
40    pthread_create(&cons, NULL, consumer, NULL);
41    sleep(1);  // Let consumer start waiting
42    pthread_create(&prod, NULL, producer, NULL);
43    
44    pthread_join(prod, NULL);
45    pthread_join(cons, NULL);
46    
47    return 0;
48}

1#include <stdio.h>
2#include <threads.h>
3#include <stdatomic.h>
4
5// Shared data
6int counter = 0;
7mtx_t lock;
8cnd_t done_cond;
9int threads_done = 0;
10
11// Thread function - must return int (not void*)
12int increment(void* arg) {
13    int id = *(int*)arg;
14    
15    for (int i = 0; i < 1000000; i++) {
16        mtx_lock(&lock);
17        counter++;
18        mtx_unlock(&lock);
19    }
20    
21    // Signal that this thread is done
22    mtx_lock(&lock);
23    threads_done++;
24    printf("Thread %d finished. Total done: %d\n", id, threads_done);
25    cnd_signal(&done_cond);
26    mtx_unlock(&lock);
27    
28    return 0;  // Return value (can be retrieved via thrd_join)
29}
30
31int main() {
32    thrd_t t1, t2;
33    int id1 = 1, id2 = 2;
34    
35    // Initialize mutex and condition variable
36    if (mtx_init(&lock, mtx_plain) != thrd_success) {
37        printf("Failed to create mutex\n");
38        return 1;
39    }
40    if (cnd_init(&done_cond) != thrd_success) {
41        printf("Failed to create condition variable\n");
42        return 1;
43    }
44    
45    // Create threads
46    if (thrd_create(&t1, increment, &id1) != thrd_success) {
47        printf("Failed to create thread 1\n");
48        return 1;
49    }
50    if (thrd_create(&t2, increment, &id2) != thrd_success) {
51        printf("Failed to create thread 2\n");
52        return 1;
53    }
54    
55    // Wait for both threads using condition variable
56    mtx_lock(&lock);
57    while (threads_done < 2) {
58        cnd_wait(&done_cond, &lock);
59    }
60    mtx_unlock(&lock);
61    
62    // Or simply join (wait for completion)
63    int result1, result2;
64    thrd_join(t1, &result1);
65    thrd_join(t2, &result2);
66    
67    printf("Thread 1 returned: %d\n", result1);
68    printf("Thread 2 returned: %d\n", result2);
69    printf("Final counter: %d (expected: 2000000)\n", counter);
70    
71    // Cleanup
72    mtx_destroy(&lock);
73    cnd_destroy(&done_cond);
74    
75    return 0;
76}