Programming thread

Question

I created 5 threads in the program and assign ID 1,2,3,4,5 to them respectively. Each thread will try to access the Next_ID. When a thread acquires Next_ID it compares its ID with the Next_ID. If it matches I print my turn and others print not my turn. And increments Next_ID by 1. If Next_ID reaches 6 it resets back to 1. However my code prints the following:

My Turn: 1
Not My Turn: 3
My Turn: 4
My Turn: 5
Not My Turn: 2
Not My Turn: 1
Not My Turn: 3
My Turn: 4
My Turn: 5
Not My Turn: 2
Not My Turn: 1
Not My Turn: 3
My Turn: 4
My Turn: 5
Not My Turn: 2
Not My Turn: 1
Not My Turn: 3
My Turn: 4
My Turn: 5
Not My Turn: 2
Not My Turn: 1
Not My Turn: 3
My Turn: 4
My Turn: 5

The expected output should be:

My Turn: 1
not my Turn: 2
not my Turn: 3
not my Turn: 4
not my Turn: 5
not my Turn: 1
My Turn: 2
not my Turn: 3
not my Turn: 4
not my Turn: 5

My code:

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

#define NUM_THREADS 5 

int Next_ID = 1; 

pthread_t threads[NUM_THREADS];
pthread_mutex_t mutex;

typedef struct threadArgs { 
    int threadId;
    int numOfCalls;
} ThreadArgs;

ThreadArgs threadArgsArray[NUM_THREADS]; 

void * printThread(void *pThreadArgs) {
    ThreadArgs *threadArgs = (ThreadArgs *) pThreadArgs; 
    int *threadId = &threadArgs->threadId; 

    for(int i = 0; i < 20; i++) { 
        pthread_mutex_lock(&mutex); 
        if (Next_ID == *threadID) {
            printf("My Turn: %d\n", *threadId);
        } else {
            printf("Not My Turn: %d\n", *threadId);
        }

        Next_ID = (*threadId == 5) ? 1 : *threadId + 1;
        pthread_mutex_unlock (&mutex);
    }
    pthread_exit(NULL);
}


void * printThread(void *); 

int main(int argc, char const *argv[]) {
    pthread_attr_t attr;
    void *status;

    pthread_mutex_init(&mutex, NULL); 
    pthread_attr_init(&attr); 
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    for (int i = 0; i < NUM_THREADS; i++) {
        threadArgsArray[i].threadId = i + 1;

        int rc = pthread_create(&threads[i], &attr, printThread,
                                &threadArgsArray[i]);
    }

    for (int i = 0; i < NUM_THREADS; i++) {
        int rc = pthread_join(threads[i], &status);
    }

    pthread_attr_destroy(&attr);
    pthread_mutex_destroy(&mutex);

    pthread_exit(NULL);
}

Are you sure that is your real and exact output? It seems too regular to be real and doesn't seem to match how your code as shown would behave. — kaylum, Mar 08 '17 at 02:16
That's better. The reason is because your assumptions are wrong. There is nothing in your code that guarantees thread 2 will execute immediately after thread 1 and so on. That is, you have mutual exclusion but you have no sequencing. — kaylum, Mar 08 '17 at 02:33
I've had the same problem and apparently it's not possible to code a completely fair mutex system - see http://stackoverflow.com/questions/5385777/implementing-a-fifo-mutex-in-pthreads. — Marco, Mar 08 '17 at 04:26

score 0 · Answer 1 · answered Mar 08 '17 at 05:53

in order to run sequentially from thread 1 to thread 5, you can use conditional variable(pthread_cond_t). variable current to specify which thread can run.

another obvious way to do the job, is using pipe.

code below is using conditional variable:

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

#define NUM_THREADS 5

int Next_ID = 1;

pthread_t threads[NUM_THREADS];
pthread_mutex_t mutex;
pthread_cond_t cond;
int current;

typedef struct threadArgs {
    int threadId;
    int numOfCalls;
} ThreadArgs;

ThreadArgs threadArgsArray[NUM_THREADS];

void * printThread(void *pThreadArgs) {
    ThreadArgs *threadArgs = (ThreadArgs *) pThreadArgs;
    int *threadId = &threadArgs->threadId;

    for(int i = 0; i < 20; i++) {
        pthread_mutex_lock(&mutex);
        while (current+1!=*threadId){
            pthread_cond_wait(&cond, &mutex);
        }
        if (Next_ID == *threadId) {
            printf("My Turn: %d\n", *threadId);
        } else {
            printf("Not My Turn: %d\n", *threadId);
        }

        if (*threadId==5){
            Next_ID++;
            if (Next_ID==6){
                Next_ID=1;
            }
        }
        current=(current+1)%NUM_THREADS;
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(NULL);
}


void * printThread(void *);

int main(int argc, char const *argv[]) {
    pthread_attr_t attr;
    void *status;

    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    current=0;
    for (int i = 0; i < NUM_THREADS; i++) {
        threadArgsArray[i].threadId = i + 1;

        int rc = pthread_create(&threads[i], &attr, printThread,
                    &threadArgsArray[i]);
    }

    for (int i = 0; i < NUM_THREADS; i++) {
        int rc = pthread_join(threads[i], &status);
    }

    pthread_attr_destroy(&attr);
    pthread_mutex_destroy(&mutex);

    pthread_exit(NULL);
}

Programming thread

1 Answers1