为什么在C程序中调用线程数多于执行线程数？

Question

In the code below, I create a thread having a loop which will perform a full iteration when I invoke the condition. However, if i am invoking it 1000 times, the invoking_thread value is different than exec_thread at the end of main . What is happening, and how can I fix this issue? I do not want to exit the thread running threadfunc , because I may need to use it for further operations.

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

pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 
int invoking_thread = 0, exec_thread = 0; 
pthread_t pth; 

void *threadfunc(void *parm) 
{ 
    int x; 
    for (;;) { 
        pthread_mutex_lock(&mutex); 
        pthread_cond_wait(&cond, &mutex); 
        //printf("Inside the thread %d\n", ins); 
        exec_thread++; 
        pthread_mutex_unlock(&mutex); 
    } 
    return NULL; 
} 


void create_thread () { 
    pthread_create(&pth,NULL,threadfunc,"foo"); 
} 

int main(int argc, char **argv) 
{ 
    create_thread(); 
    int y = 0; 
    while (1) { 
        if (y == 1000) { 
            break; 
        } 
        y++; 
        invoking_thread++; 
        printf("Count: Invoked %d and Inside : %d\n", invoking_thread, exec_thread); 
        pthread_cond_signal( &cond ); 
        pthread_mutex_lock( &mutex ); 
        pthread_mutex_unlock( &mutex ); 
    } 
    printf("Count: Invoked %d and Inside : %d\n", invoking_thread, exec_thread); 
    printf("Main completed\n"); 
    return 0; 
} 

DETAILS of Further Explanation: I can tell you my whole situation: An array of 1000 size is initialized with 0 value. 1 thread is started with infinite loop. for 1000 iterations i pass the signal to thread to increment the value of each element of an array. After passing signal, these values are multiplied by 2 in a loop. In next step, again 1000 signals are passed to thread to increment the value of each element of an array. Then, same as previously, all the element values are multiplied by 2 in a loop. Then result is printed.

Now, adding some chunks, most of the time i am getting segmentation fault. and rest of the time i am not getting desired value.

  #include < pthread.h>

  #include < stdio.h>

   pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

   pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

   int invoking_thread = 0, exec_thread = 0, signal_count = 0;

   pthread_t pth;

   int res[1000];

 void *threadfunc(void *parm) { 

for (;;) { 

    pthread_mutex_lock(&mutex); 

    while (signal_count == 0)
        pthread_cond_wait(&cond, &mutex); 

    signal_count--; // consume a signal

//printf("Inside the thread res[%d]++\n", exec_thread);

    exec_thread++; 

res[exec_thread]++;

    pthread_mutex_unlock(&mutex); 

  }

  return NULL; 

  }


  void create_thread () {

      pthread_create(&pth,NULL,threadfunc,"foo");

  }


  int main(int argc, char **argv)
  {

create_thread();

int y;

for (y = 0;y<1000;y++) {
    res[y] = 0;
}
y = 0;
while (1) {
    if (y == 1000) {
        break;
    }
    y++;
    invoking_thread++;
    //printf("Count: Invoked %d and Inside : %d\n", invoking_thread, exec_thread);
    pthread_mutex_lock( &mutex ); 
        signal_count++;
        pthread_mutex_unlock( &mutex ); 
        pthread_cond_signal( &cond ); 
}
printf("Count: Invoked %d and Inside : %d\n", invoking_thread, exec_thread);

for (y = 0;y<1000;y++) {
    res[y] = res[y]*2;
}
exec_thread = 0;
y = 0;
while (1) {
    if (y == 1000) {
        break;
    }
    y++;
    invoking_thread++;
    //printf("Count: Invoked %d and Inside : %d\n", invoking_thread, exec_thread);
    pthread_mutex_lock( &mutex ); 
        signal_count++;
        pthread_mutex_unlock( &mutex ); 
        pthread_cond_signal( &cond ); 
}
printf("Count: Invoked %d and Inside : %d\n", invoking_thread, exec_thread);

for (y = 0;y<1000;y++) {
    res[y] = res[y]*2;
}

// result
for (y = 0;y<1000;y++) {
    printf("%d result for %d\n",res[y], y);
}

printf("Main completed\n");
return 0;
  } 

Hence my question is, thread invocation should have to wait after first 1000 signals, which it is not waiting and then let the code do the calculations and then it should be allowed to do the further 1000 invocations. and so on to get the desired result. Hope i am able to explain my situation.

Answer 1

The pthread_cond_signal() will wake any thread waiting on the condition if there is a thread waiting. If not, then that call will do nothing. This is most probably what happens in your case. There are several subsequent calls to pthread_cond_signal() , while the worker thread is not actually sleeping.

To ensure one invoke-one worker pass you will have to use two pthread_cond_t - one to signal starting of worker, second for notifying that the work has ended. Another is to busy wait until 1000 jobs have been done. Here's a modified code:

int main(int argc, char **argv)
{
    create_thread();
    int y = 0;
    int executed = 0;
    while (executed <1000) {
        invoking_thread++;
        printf("Count: Invoked %d and Inside : %d\n", invoking_thread, exec_thread);
        pthread_mutex_lock( &mutex );
        executed = exec_thread; // read inside mutex to ensure variable visibility
        pthread_cond_signal( &cond );
        pthread_mutex_unlock( &mutex );
    }
    printf("Count: Invoked %d and Inside : %d\n", invoking_thread, exec_thread);
    printf("Main completed\n");
    return 0;
}

Answer 2

Condition variables are stateless. You are expecting the condition variable to have a "signaled" state. It does not. If you want to associate state with the condition variable, you must do so. You can have a "signal_count" variable and then do this:

void *threadfunc(void *parm) 
{ 
    int x; 
    for (;;) { 
        pthread_mutex_lock(&mutex); 
        while (signal_count == 0)
            pthread_cond_wait(&cond, &mutex); 
        signal_count--; // consume a signal
        //printf("Inside the thread %d\n", ins); 
        exec_thread++; 
        pthread_mutex_unlock(&mutex); 
    } 
    return NULL; 
}

Similarly:

    pthread_mutex_lock( &mutex ); 
    signal_count++;
    pthread_mutex_unlock( &mutex ); 
    pthread_cond_signal( &cond ); 

Notice that the mutex protects the state, you must implement the state, you must not call pthread_cond_wait unless you know you need to wait, and you must not assume the state has any particular value when pthread_cond_wait returns. That is how you use a condition variable.

Answer 3

Are you forgetting to add pthread_join() in the main to wait until all threads are finished calculating?

[See here]