Resolved: Printing in order with c threads

#include <stdio.h><br />
#include <pthread.h>
#include <semaphore.h></p>
<p>void *findPrimes(void *arg)<br />
{<br />
    int val = *(int *)arg;<br />
    for (int i = val * 1000; i < val * 1000 + 1000; i++)
    {
        int isPrime = 1;
        for (int j = 2; j < i; j++)
        {
            if (i % j == 0)
            {
                isPrime = 0;
                break;
            }
        }
        if (isPrime)
        {
            printf("%d\n", i);
        }
    }
    pthread_exit(NULL);
}
int main()
{
    pthread_t p[3];

    int val[3] = {0, 1, 2};
    for (int i = 0; i < 3; i++)
    {
        pthread_create(&p[i], NULL, findPrimes, &val[i]);
    }
    for (int i = 0; i < 3; i++)
    {
        pthread_join(p[i], NULL);
    }

    return 0;
}
[/code]

</p>



Who prints in 3 threads all the prime number between 0 and 3000.<br> 



I want to print them in order, how can i do it?
My professor suggest to use an array of semaphore.<br> 



<h2>Answer:</h2>



In order to synchronize the actions of all the threads I suggest using a <a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_mutex_lock.html" rel="nofollow noreferrer"><code>pthread_mutex_t</code></a> and a <a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_cond_timedwait.html" rel="nofollow noreferrer"><code>pthread_cond_t</code></a> (a <em>condition variable</em>). You also need a way to share data between threads, so I'd create a <code>struct</code> for that:<br> 


<p>[code]#include <pthread.h>
#include <stdbool.h><br />
#include <stdint.h><br />
#include <stdio.h></p>
<p>typedef struct {<br />
    unsigned whos_turn;<br />
    pthread_mutex_t mtx;<br />
    pthread_cond_t cv;<br />
} shared_data;

typedef struct {
    unsigned val;
    shared_data *sd; // will point to the one and only instance of `shared_data`
} work_order;

#define SEARCH_RANGE (1000ULL)

void *findPrimes(void *arg) {
    work_order *wo = arg;
    
    uintmax_t primes[SEARCH_RANGE]; // to store the found primes
    int found_count = 0;
    
    for (uintmax_t i = wo->val*SEARCH_RANGE+1; i <= (wo->val+1)*SEARCH_RANGE; i += 2) {
        bool isPrime = true;
        for (uintmax_t j = 3; j < i; j += 2) {
            if (i % j == 0) {    // note: both i and j are odd
                isPrime = false;
                break;
            }
        }
        if (isPrime) {
            primes[found_count++] = i;
        }
    }
    if(wo->val == 0) {  // special case for the first range
        primes[0] = 2;  // 1 is not a prime, but 2 is.
    }
    // ... to be continued below ...

    // ... continued from above ...

    // synchronize
    pthread_mutex_lock(&wo->sd->mtx);      // lock the mutex
    // only 1 thread at a time reaches here
    // check the predicate: That is's this thread's turn to print
    while(wo->val != wo->sd->whos_turn) {  // <- the predicate
        // if control enters here, it was not this thread's turn

        // cond_wait internally "unlocks" the mutex to let other threads
        // reach here and wait for the condition variable to get signalled
        pthread_cond_wait(&wo->sd->cv, &wo->sd->mtx);

        // and here the lock is only held by one thread at a time again
    }
    // only the thread whos turn it is reaches here

    // print the collected primes<br />
    for(int i = 0; i < found_count; ++i)
        printf("%ju\n", primes[i]);
[/code]

</p>



And hand over to the next thread in line to print the primes it has found:<br> 


<p>[code]    // step the "whos_turn" indicator<br />
    wo->sd->whos_turn++;</p>
<p>    pthread_mutex_unlock(&wo->sd->mtx);  // release the mutex<br />
    pthread_cond_broadcast(&wo->sd->cv); // signal all threads to check the predicate<br />
    pthread_exit(NULL);<br />
}