Using the threadmutex class

The threadmutex class provides mutual exclusion locks between separate threads of a single process.

Intances of threadmutex can be used to protect critical sections of code or synchronize threads.

In this example, five threads are spawned. Each counts from 0 to 4, ten times. A threadmutex is used to synchronize the threads so that each thread is able to finish its count without being interrupted by another thread.

> #include <rudiments/thread.h>
> #include <rudiments/threadmutex.h>
> #include <rudiments/stdio.h>
> // struct for passing arguments into the thread
> struct args {
> thread *th;
> threadmutex *tm;
> int32_t id;
> };
> // function that will be spawned as a thread
> void count(void *args) {
> struct args *a=(struct args *)args;
> // lock the mutex
> a->tm->lock();
> // count to 5, ten times
> stdoutput.printf("thread %d: ",a->id);
> for (uint16_t oc=0; oc<10; oc++) {
> for (uint16_t ic=0; ic<5; ic++) {
> stdoutput.printf("%d",ic);
> }
> }
> stdoutput.printf("\n");
> // unlock the mutex
> a->tm->unlock();
> // exit
> a->th->exit(&(a->id));
> }
> int main(int argc, const char **argv) {
> // create 5 threads
> thread t[5];
> // create a mutex to synchronize them
> threadmutex tm;
> // initialize threads
> struct args a[5];
> for (uint16_t i=0; i<5; i++) {
> a[i].th=&t[i];
> a[i].tm=&tm;
> a[i].id=i;
> }
> // lock the mutex
> tm.lock();
> // spawn threads (each will block on the mutex)
> for (uint16_t j=0; j<5; j++) {
> if (!t[j].spawn((void*(*)(void*))count,(void *)&a[j],false)) {
> stdoutput.printf(" %d: spawn failed\n",j);
> }
> }
> // unlock the mutex (allows the threads to proceed)
> tm.unlock();
> // wait for the threads to exit
> for (uint16_t k=0; k<5; k++) {
> int32_t tstatus=-1;
> t[k].wait(&tstatus);
> stdoutput.printf("thread %d status: %d\n",k,tstatus);
> }
> }