我有一个带有“管理器”线程的简单应用程序，它产生十个简单的“工作者”线程。我希望所有“工作”线程都阻塞同一个条件变量（即：condvar），并且我想通过 pthread_cond_broadcast 调用手动通知所有十个线程同时唤醒。
在我的应用程序中，线程可能会遇到错误情况并提前终止，因此可能并非所有十个线程都到达同步点。
一种简单的机制是创建一个 pthread_barrier_t 并让所有 10 个线程调用 pthread_barrier_wait，当所有 10 个线程完成此调用时，它们都可以自由地继续执行。但是，这将要求线程能够修改屏障需要解除阻塞的线程数。我不知道这是否可以安全地修改。
此外，我想保证所有仍在工作的线程不会像使用屏障那样自动启动，我想用 pthread_cond_broadcast 调用手动启动它们。在我进行广播调用之前，我如何保证所有还活着的线程（最好是十个）都阻塞在 condvar 上？
谢谢！
下面显示了一种方法，使用条件变量和其他一些变量；虽然可能有更好的方法。评论应该显示它是如何工作的。当然，您必须修改内容以适应您的实际情况；例如可能涉及循环等。
int activeThreads = 0; /* number of threads currently going */
int waitingThreads = 0; /* number of threads waiting on the condition */
int readyFlag = 0; /* flag to tell the threads to proceed when signaled */
pthread_cond_t cond; /* condition to wait on / signal */
pthread_mutex_t mtx; /* mutex for the above */
pthread_cond_t condWaiting; /* EDIT: additional condition variable to signal
* when each thread starts waiting */
void *threadFunc(void *arg)
{
/* Edit: Rather than incrementing 'activeThreads' here, it should be done
* in the main thread when each thread is created (to avoid a race) */
/* ...do stuff... */
/* When the threads should wait, do this (they wait for 'readyFlag' to be
* set, but also adjust the waiting thread count so the main thread can
* determine whether to broadcast) */
pthread_mutex_lock(&mtx);
if (readyFlag == 0) {
waitingThreads++;
do {
pthread_cond_signal(&condWaiting); /* EDIT: signal the main thread when
* a thread begins waiting */
pthread_cond_wait(&cond,&mtx);
} while (readyFlag == 0);
waitingThreads--;
}
pthread_mutex_unlock(&mtx);
/* ...more stuff... */
/* When threads terminate, they decrement the active thread count */
pthread_mutex_lock(&mtx);
activeThreads--;
pthread_cond_signal(&condWaiting); /* EDIT: also signal the main thread
* when a thread exits to make it
* recheck the waiting thread count if
* waiting for all threads to wait */
pthread_mutex_unlock(&mtx);
return NULL;
}
int main(int argc, char *argv[])
{
/* Edit: Showing some code to initialize the mutex, condition variable(s),
* etc., and create some threads -- modify as needed */
pthread_mutex_init(&mtx,NULL);
pthread_cond_init(&cond,NULL);
pthread_cond_init(&condWaiting,NULL); /* EDIT: if main thread should block
* until all threads are waiting */
activeThreads = waitingThreads = readyFlag = 0;
/* Edit: Increment 'activeThreads' here rather than in the thread function,
* to avoid a race (if the main thread started waiting for the others
* when not all had incremented the count yet, the main thread might end
* up waiting for fewer threads to be ready -- though it's unlikely */
#define NUM_THREADS 10
pthread_t workers[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) {
/* should use appropriate thread attributes */
if (pthread_create(&workers[i],NULL,threadFunc,NULL) == 0)
activeThreads++;
}
/* ...do stuff... */
/* Set 'readyFlag' and do condition broadcast IF all threads are waiting,
* or just carry on if they aren't */
pthread_mutex_lock(&mtx);
if ((activeThreads != 0) && (activeThreads == waitingThreads)) {
readyFlag = 1;
pthread_cond_broadcast(&cond);
}
pthread_mutex_unlock(&mtx);
/* EDIT: OR.. to wait until all threads are waiting and then broadcast, do
* this instead: */
pthread_mutex_lock(&mtx);
while (waitingThreads < activeThreads) { /* wait on 'condWaiting' until all
* active threads are waiting */
pthread_cond_wait(&condWaiting,&mtx);
}
if (waitingThreads != 0) {
readyFlag = 1;
pthread_cond_broadcast(&cond);
}
pthread_mutex_unlock(&mtx);
/* ...more stuff... */
/* If needed, you can clear the flag when NO threads are waiting.. */
pthread_mutex_lock(&mtx);
if (waitingThreads == 0)
readyFlag = 0;
pthread_mutex_unlock(&mtx);
/* ...even more stuff... */
return 0;
}
不过，我要补充一点，我看不出什么时候有充分的理由这样做，而不仅仅是以更直接的方式保护资源。
编辑：在代码中添加了一些东西，显示了第二个条件变量，用于让主线程等待所有工作人员准备好。更改的部分在注释中标有“EDIT：”，如果不需要，可以省略。我还通过将增量activeThreads移出线程函数来纠正竞争条件，并显示互斥锁的初始化等（没有错误处理）。
一般来说，您应该在工作准备就绪时设置条件变量（及其相关标志） - 通常无需等待线程阻塞条件变量。如果他们'迟到'，他们只会注意到标志已经设置并且不会打扰阻塞。
但是，如果您确实需要等到所有工作线程都在条件变量上阻塞，您可以使用条件变量的组合 - 一个跟踪有多少线程“准备就绪”，另一个触发他们开始工作。一些伪代码：
// manager thread thread
pthread_cond_t pseudo_barrier;
pthread_cond_t pseudo_barrier_complete_cond;
pthread_mutex_t pseudo_barrier_mux;
int pseudo_barrier_counter = NUM_THREADS;
int pseudo_barrier_complete_flag = 0;
void thread_manager(void)
{
pthread_cond_init( &pseudo_barrier, NULL);
pthread_cond_init( &pseudo_barrier_complete_cond, NULL);
pthread_mutex_init( &pseudo_barrier_mux, NULL);
for (int i = 0 ; i < NUM_THREADS; ++i) {
pthread_create( /*... */);
}
// wait for threads to 'stage'
pthread_mutex_lock( &pseudo_barrier_mux);
while (pseudo_barrier_counter != 0) {
pthread_cond_wait( &pseudo_barrier, &pseudo_barrier_mux);
}
pthread_mutex_unlock( &pseudo_barrier_mux);
// at this point, all threads have either bailed out or are waiting to go
// let 'em rip
pthread_mutex_lock( &pseudo_barrier_mux);
pseudo_barrier_complete_flag = 1;
pthread_mutex_unlock( &pseudo_barrier_mux);
pthread_cond_broadcast( &pseudo_barrier_complete_cond);
// do whatever else the manager thread needs to do...
}
// worker threads
void* worker_thread(void* context)
{
int error_result = 0;
// whatever initialization...
// if this thread is going to bail out due to an error, it needs to
// set the `error_result` value appropriately and still drop into the
// following code
// let the manager know that this thread is waiting (or isn't going to participate)
pthread_mutex_lock( &pseudo_barrier_mux);
--pseudo_barrier_counter;
if (pseudo_barrier_counter == 0) {
// all other threads are accounted for, let the manager know we're ready
pthread_cond_signal( &pseudo_barrier);
}
// if this thread isn't going to contine because of some error, it's already
// accounted for that fact in the `my_barrier_count`, so we can return here
// without preventing the pseudo-barrier from being met.
if (some_error_occurred) {
pthread_mutex_lock( &pseudo_barrier_mux);
return NULL;
}
// NOTE: we're still holding pseudo_barrier_mux, so the master thread is still
// blocked, even if we've signaled it - it'll jhave to wait until this
// thread is blocking on `pseudo_barrier_complete_cond`
while (!pseudo_barrier_complete_flag) {
pthread_cond_wait( &pseudo_barrier_complete_cond, &pseudo_barrier_mux);
}
pthread_mutex_unlock( &pseudo_barrier_mux);
// do the work...
}
当然，所呈现的伪代码应该被清理以供任何实际使用（包括错误处理），可能将所有支持的条件变量、互斥体和标志打包到一个结构中