Added some work with PThreads

Author: Anton Yarkov

multithreading/05 - PThreads.c

@@ -0,0 +1,38 @@
+#include <pthread.h>
+
+#include "Defs.h"
+
+// Compilation:
+// gcc -std=gnu99 -pthread ErrorHandling.c LogF.c "05 - PThreads.c" -o pthreads
+
+// Task:
+// Simple example of a counter working in 2 threads.
+
+static long x = 0;
+
+static void* thread_func(void* arg)
+{
+    while (true)
+    {
+        printf("Thread 2, counter value %ld\n", ++x);
+        sleep(1);
+    }
+}
+
+int main(void)
+{
+    pthread_t tid;
+
+    ec_rv(pthread_create(&tid, NULL, thread_func, NULL))
+
+    while (x < 10)
+    {
+        printf("Thread 1, counter value %ld\n", ++x);
+        sleep(2);
+    }
+    return EXIT_SUCCESS;
+
+EC_CLEANUP_BGN
+    return EXIT_FAILURE;
+EC_CLEANUP_END
+}

multithreading/06 - PThreads Joinable BAD.c

@@ -0,0 +1,49 @@
+#include <pthread.h>
+
+#include "Defs.h"
+
+// Compilation:
+// gcc -std=gnu99 -pthread ErrorHandling.c LogF.c "06 - PThreads Joinable BAD.c" -o joinable_threads
+
+// Task:
+// Simple example of an application working with 2 threads, where parent waits results from child.
+// Thread 2 stops calculation if common value already more than limit.
+
+// WARNING! Code contains a problem marked with comment.
+
+static long x = 0;
+
+static void* thread_func(void* arg)
+{
+    while (x < (long)arg)
+    {
+        printf("Thread 2, counter value %ld\n", ++x); // !!! WARNING!!! 2 Threads use the same variable. But increment operation is not atomic.
+        sleep(1);
+    }
+    
+    return (void *)x;
+}
+
+int main(void)
+{
+    pthread_t tid;
+    void *status;
+    
+    assert(sizeof(long) <= sizeof(void *));
+    ec_rv( pthread_create(&tid, NULL, thread_func, (void *)6) )
+
+    while (x < 10)
+    {
+        printf("Thread 1, counter value %ld\n", ++x); // !!! WARNING!!! 2 Threads use the same variable. But increment operation is not atomic.
+        sleep(2);
+    }
+    
+    ec_rv( pthread_join(tid, &status) )
+    printf("Return code of a Thread 2: %ld\n", (long)status);
+    
+    return EXIT_SUCCESS;
+
+EC_CLEANUP_BGN
+    return EXIT_FAILURE;
+EC_CLEANUP_END
+}

multithreading/07 - PThreads Joinable with Sync.c

@@ -0,0 +1,72 @@
+#include <pthread.h>
+
+#include "Defs.h"
+
+// Compilation:
+// gcc -std=gnu99 -pthread ErrorHandling.c LogF.c "07 - PThreads Joinable with Sync.c" -o joinable_threads_synced
+
+// Task:
+// Simple example of an application working with 2 threads, where parent waits results from child.
+// Thread 2 stops calculation if common value already more than limit.
+
+// Access to variable is controlled with mutex.
+
+static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
+static long x = 0;
+
+static void* thread_func(void* arg)
+{
+    bool done;
+    
+    while (true)
+    {
+        ec_rv( pthread_mutex_lock(&mtx) )
+        done = x <= (long)arg;
+        ec_rv( pthread_mutex_unlock(&mtx) )
+        if (done)
+            break;
+        ec_rv( pthread_mutex_lock(&mtx) )
+        printf("Thread 2, counter value %ld\n", ++x);
+        ec_rv( pthread_mutex_unlock(&mtx) )
+        sleep(1);
+    }
+    
+    return (void *)x;
+
+EC_CLEANUP_BGN
+    EC_FLUSH("thread_func")
+    return NULL;
+EC_CLEANUP_END
+}
+
+int main(void)
+{
+    pthread_t tid;
+    void *status;
+    bool done;
+    
+    assert(sizeof(long) <= sizeof(void *));
+    ec_rv( pthread_create(&tid, NULL, thread_func, (void *)6) )
+
+    while (true)
+    {
+        ec_rv( pthread_mutex_lock(&mtx) )
+        done = x >= 10;
+        ec_rv( pthread_mutex_unlock(&mtx) )
+        if (done)
+            break;
+        ec_rv( pthread_mutex_lock(&mtx) )
+        printf("Thread 1, counter value %ld\n", ++x);
+        ec_rv( pthread_mutex_unlock(&mtx) )
+        sleep(2);
+    }
+    
+    ec_rv( pthread_join(tid, &status) )
+    printf("Return code of a Thread 2: %ld\n", (long)status);
+    
+    return EXIT_SUCCESS;
+
+EC_CLEANUP_BGN
+    return EXIT_FAILURE;
+EC_CLEANUP_END
+}

multithreading/08 - PThreads Joinable with Sync improved.c

@@ -0,0 +1,72 @@
+#include <pthread.h>
+
+#include "Defs.h"
+
+// Compilation:
+// gcc -std=gnu99 -pthread ErrorHandling.c LogF.c "08 - PThreads Joinable with Sync improved.c" -o joinable_threads_synced1
+
+// Task:
+// Simple example of an application working with 2 threads, where parent waits results from child.
+// Thread 2 stops calculation if common value already more than limit.
+
+// Access to variable is controlled with mutex, but located in the separate function.
+
+static long get_and_incr_x(long incr)
+{
+    static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; // Must be static, because initialization function maybe not thread-safe.
+                                                            // And C++ may even use lazy initialization for mutex.
+    static long x = 0;
+    
+    // rtn and incr variables are on stack - i.e. local
+    long rtn;
+    
+    ec_rv( pthread_mutex_lock(&mtx) )
+    rtn = x += incr;  // Static variable - i.e. global. Needs to be protected.
+    ec_rv( pthread_mutex_unlock(&mtx) )
+    
+    return rtn;
+
+EC_CLEANUP_BGN
+    exit(EXIT_FAILURE);
+EC_CLEANUP_END
+}
+
+static void* thread_func(void* arg)
+{
+    long val = 0;
+    while (val < (long)arg)
+    {
+        val = get_and_incr_x(1);
+        printf("Thread 2, counter value %ld\n", val);
+        sleep(1);
+    }
+    
+    return (void *)val;
+}
+
+int main(void)
+{
+    pthread_t tid;
+    void *status;
+    bool done;
+    
+    assert(sizeof(long) <= sizeof(void *));
+    ec_rv( pthread_create(&tid, NULL, thread_func, (void *)6) )
+
+    long val = 0;
+    while (val < 10)
+    {
+        val = get_and_incr_x(1);
+        printf("Thread 1, counter value %ld\n", val);
+        sleep(2);
+    }
+    
+    ec_rv( pthread_join(tid, &status) )
+    printf("Return code of a Thread 2: %ld\n", (long)status);
+    
+    return EXIT_SUCCESS;
+
+EC_CLEANUP_BGN
+    return EXIT_FAILURE;
+EC_CLEANUP_END
+}