Infinite loop multi-threading

Question

I have written this Producer/Consumer Problem solution. It seems to be working, other than the infinite loop. I was under the impression that pthread_exit(NULL); would make it stop, but honestly, I've become lost and confused. Could someone point me in the right direction of how to stop the loop?

#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
#include<iostream>
#include<semaphore.h>

#define BUFFSIZE 10

using namespace std;

int buffer[BUFFSIZE];
int size; //current buffer size
int n = 0, m = 0;

pthread_mutex_t Mutex = PTHREAD_MUTEX_INITIALIZER;

sem_t Available;
sem_t Buffer; //indicates if buffer is full

//----------------------------------------------------------------//

void *Consumers(void *argument)
{
    int con_id = *((int *) argument);
    while(1)
    {
        if(size == 0)
        {
            cout << "Queue is empty." << endl;
        }

        sem_wait(&Available);
        pthread_mutex_lock(&Mutex);

        size--;
        cout << "Con " << con_id << ": Product removed from buffer" << endl;
        //for(int i = 0; i < size; i++)
        //{
        //  cout << Buffer[i] << " ";
        //}
        cout << endl;
        pthread_mutex_unlock(&Mutex);
        sem_post(&Buffer);
    }
    return(NULL);
}

//----------------------------------------------------------------//

void *Producers(void *argument)
{
    int item = 8;
    int pro_id = *((int *) argument);

    while(1)
    {
        sem_wait(&Buffer);
        pthread_mutex_lock(&Mutex);
        //Buffer[size] = item;
        cout << "Item added" << endl;
        size++;
        pthread_mutex_unlock(&Mutex);
        sem_post(&Available);
    }
    return(NULL);
}

//----------------------------------------------------------------//

int main()
{

    cout << "Enter number of producers: " << endl;
    scanf("%d", &n);
    cout << "Enter number of consumers: " << endl;
    scanf("%d", &m);
    //get number of producers(int n), and consumers(int m)
    sem_init(&Available, 0, 0);
    sem_init(&Buffer, 0, BUFFSIZE);

    pthread_t *con = new pthread_t[m];
    int *thread_args_c = new int[m];
    for(int i = 0; i < n; i++)
    {
        thread_args_c[i] = i;
        pthread_create(&con[i], NULL, Consumers, (void*) &i);
    }

    pthread_t *pro = new pthread_t[n];
    int *thread_args_p = new int[n];
    for(int i = 0; i < n; i++)
    {
        thread_args_p[i] = i;
        pthread_create(&pro[i], NULL, Producers, (void*) &i);
        pthread_join(con[i], NULL);
    }

    pthread_exit(NULL);

}

Answer 1

Not sure what you are expecting. pthread_exit appears in the end of the main (and completely not needed there, since main is exiting anyways), but your enless loops inside thread will never let main reach this point (since you are joining the consumers thread).

Also, your creation and joining model makes litle sense - what's the point of joining consumer thread after you've created a producer?

And last, but not the lease, you fail to join producer thread.

Answer 2

The loops will not stop because there is no logic in the code to actually exit the loop.

The process is stuck because pthread_join suspends the calling thread till the target exits. See documentation for pthread_join

If you don't care about actually terminating the threads and returning to the main thread, just remove the call to pthread_join. The process should terminate because the main thread exited.

To actually properly terminate the loops, you need to set an internal or external trigger. You could internally have the loops exit after a set number of iterations. For this, you will do while(x<=y) instead of while(1).

You could also make it more complicated and have the main thread signal the other threads externally that it wants the other threads to shut down. You can have the main thread set a (volatile) boolean when you are ready to exit and have the other threads break the loop based on it. If you care about the Atomicity of the exit, you will need to protect the boolean with a lock.