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

        // 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++) {

        // unlock the mutex

        // exit

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++) {

        // lock the mutex

        // 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)

        // wait for the threads to exit
        for (uint16_t k=0; k<5; k++) {
                int32_t tstatus=-1;
                stdoutput.printf("thread %d status: %d\n",k,tstatus);