I'm only posting this (which is almost all C code, but so is pthreads, so a little slack is kindly requested) to demonstrate one way of doing what I think you're trying to accomplish. Obviously you would want to properly encapsulate most of this in proper classes etc. What this is hopefully going to show you is how condition variables, mutex, and their relationship with predicate management and notification works.
I hope you find it useful. Have a great day.
#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;
// our global condition variable and mutex
pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
// our predicate values.
bool finished = false;
int jobs_waiting = 0;
int jobs_completed = 0;
// our thread proc
static void *worker_proc(void* p)
{
intptr_t id = (intptr_t)p; // our id
size_t n_completed = 0; // our job completion count
// always latch prior to eval'ing predicate vars.
pthread_mutex_lock(&mtx);
while (!finished)
{
// wait for finish or work-waiting predicate
while (!finished && jobs_waiting == 0)
pthread_cond_wait(&cv, &mtx);
// we own the mutex, so we're free to look at, modify
// etc. the values(s) that we're using for our predicate
if (finished)
break;
// must be a job_waiting, reduce that number by one, then
// unlock the mutex and start our work. Note that we're
// changing the predicate (jobs_waiting is part of it) and
// we therefore need to let anyone that is monitoring know.
--jobs_waiting;
pthread_cond_broadcast(&cv);
pthread_mutex_unlock(&mtx);
// DO WORK HERE (this just runs a lame summation)
for (int i=0,x=0;i<1048576; x += ++i);
++n_completed;
// finished work latch mutex and setup changes
pthread_mutex_lock(&mtx);
++jobs_completed;
pthread_cond_broadcast(&cv);
}
// final report
cout << id << ": jobs completed = " << n_completed << endl;
// we always exit owning the mutex, so unlock it now. but
// let anyone else know they should be quitting as well.
pthread_cond_broadcast(&cv);
pthread_mutex_unlock(&mtx);
return p;
}
// sets up a batch of work and waits for it to finish.
void run_batch(int num)
{
pthread_mutex_lock(&mtx);
jobs_waiting = num;
jobs_completed = 0;
pthread_cond_broadcast(&cv);
// wait or all jobs to complete.
while (jobs_completed != num)
pthread_cond_wait(&cv, &mtx);
// we own this coming out, so let it go.
pthread_mutex_unlock(&mtx);
}
// main entry point.
int main()
{
// number of threads in our crew
static const size_t N = 7;
pthread_t thrds[N] = {0};
// startup thread crew.
intptr_t id = 0;
for (size_t i=0; i<N; ++i)
pthread_create(thrds + i, NULL, worker_proc, (void*)(++id));
// run through batches. each batch is one larger
// than the prior batch. this should result in some
// interesting job-counts per-thread.
for (int i=0; i<64; ++i)
run_batch(i);
// flag for shutdown state.
pthread_mutex_lock(&mtx);
finished = true;
pthread_cond_broadcast(&cv);
pthread_mutex_unlock(&mtx);
for (size_t i=0; i<N; pthread_join(thrds[i++], NULL));
return 0;
}
Sample Output #1
3: jobs completed = 256
6: jobs completed = 282
5: jobs completed = 292
2: jobs completed = 242
1: jobs completed = 339
4: jobs completed = 260
7: jobs completed = 409
Sample Output #2
6: jobs completed = 882
1: jobs completed = 210
4: jobs completed = 179
5: jobs completed = 178
2: jobs completed = 187
7: jobs completed = 186
3: jobs completed = 194
Sample Output #3
1: jobs completed = 268
6: jobs completed = 559
3: jobs completed = 279
5: jobs completed = 270
2: jobs completed = 164
4: jobs completed = 317
7: jobs completed = 159
Fixed Batch Sizes
The same code, but changing this:
for (int i=0; i<64; ++i)
run_batch(i);
to this:
for (int i=0; i<64; ++i)
run_batch(N);
gives the following, which is probably even closer to what you're really looking for.
Sample Output #1
4: jobs completed = 65
2: jobs completed = 63
5: jobs completed = 66
3: jobs completed = 63
1: jobs completed = 64
7: jobs completed = 63
6: jobs completed = 64
Sample Output #2
3: jobs completed = 65
5: jobs completed = 62
1: jobs completed = 67
7: jobs completed = 63
2: jobs completed = 65
6: jobs completed = 61
4: jobs completed = 65
Sample Output #3
2: jobs completed = 58
4: jobs completed = 61
5: jobs completed = 69
7: jobs completed = 68
3: jobs completed = 61
1: jobs completed = 64
6: jobs completed = 67
