两个线程从相同的 function RT Linux 给出不同的 output

Question

i have a 2 threads and a function, im calling the same function "no_elements()" from two threads the function is

int front = -1, rear = -1;
int no_elements()
{

int q_size = 0;

if (front == 0)
{
    
    q_size = rear + 1;

    return q_size;
}
else if (front != 0 && rear != 0)
{
    
    q_size = (rear - front) + 1;
    return q_size;
}
else if (rear == 0 && front != 0)
{
    
    q_size = (SIZE - front)+1;
    return q_size;
}
else if (rear == -1 || front == -1 )
    {
        q_size = 0;
        printf("empty---- ---------------------------------------------------------------------");
        return q_size;
    }

}

and the two threads call the same function

iret1 = pthread_create(&thread1, NULL, producer,(void*) message1);
iret2 = pthread_create(&thread2, NULL, consumer,(void*) message2);

Producer and consumer functions are

void *producer(void *ptr) // enque function
{
char *message;
printf("%s \n", message);
enQueue(data);
printf("No of elements%d\n",no_elements());
}

second function is

void *consumer(void *ptr) // enque function
{
char *message;
printf("%s \n", message);
printf("No of elements%d\n",no_elements());
}

and enqueue function is

void enQueue(double *element)
{

 if (isFull())
 printf("\n Queue is full!! \n");
 else
 {

     int i=0;
    if (front == -1)
{
    front = 0;
}
rear = (rear + 1) % SIZE;

memcpy(items[rear].value, element, sizeof (items[rear].value)); // better: sizeof struct

printf("front is  %d--",front);
printf("rear is  %d\n",rear);


 }
}

but the first thread gives correct result and second one gives the initialized value of front and rear.

here front and rear are global variables, they are manipulated in first thread by enqueue function, then i call the function no_elements() which returns a value which is correct.

but at the same time the second thread returns the initialized values of front and rear

what can be wrong?

can this be done?

   void enQueue(double *element)
   {
    pthread_mutex_lock(&lock);

   if (isFull())
    printf("\n Queue is full!! \n");
    else
   {

   int i=0;
   if (front == -1)
   {
  front = 0;
  }
  rear = (rear + 1) % SIZE;

 memcpy(items[rear].value, element, sizeof (items[rear].value)); // better: 
 sizeof struct

printf("front is  %d--",front);
printf("rear is  %d\n",rear);


 }
 pthread_mutex_unlock(&lock);
}

Answer 1

Calling your no_elements() function and / or your enqueue() function from multiple threads that are concurrently alive produces several data races, therefore the behavior of your program is undefined. The data races arise from those functions accessing shared variables front , rear , and items (at least) without any kind of synchronization, given that some of the accesses are writes. You must protect shared variables against concurrent access, typically by creating a mutex that each thread must successfully lock before accessing those variables. Threads must also be sure to unlock the mutex at some point after access in order to afford other threads the opportunity to lock it.

Answer 2

The results of accessing an object while another thread is, or might be, accessing it are undefined. You have this problem with both front and read . So the results of your program are undefined and may be totally unpredictable.

It is the responsibility of the programmer to ensure that threads do not access the same object at the same time. There are lots of tools for this purpose and the first version of enQueue uses none of them.

Answer 3

When you call pthread_create, what actually executes next is indeterminate. From the pthread_create man page:

Unless real-time scheduling policies are being employed, after a call to pthread_create(), it is indeterminate which thread—the caller or the new thread—will next execute.

If you extend this to your scenario, where you are creating two threads, it's even more indeterminate what the order of execution is. In other words, you have no way of knowing whether producer or consumer will start executing first.

You can fix this by rewriting the pthread code like this:

iret1 = pthread_create(&thread1, NULL, producer,(void*) message1);
pthread_join(&thread1, NULL);
iret2 = pthread_create(&thread2, NULL, consumer,(void*) message2);
pthread_join(&thread2, NULL);

EDIT: additional note - if you need the threads to be created and run simultaneously, then you can use a mechanism like a semaphore to delay the consumer thread before the producer thread. I don't think that a mutex, while absolutely correct in protecting the sanity of your variables, will still gaurantee the order of thread execution. The only other way is by assigning priorities to the tasks..