3

这就是我想要做的：有一个主线程产生数字并将它们放入队列中，它触发一个消耗队列中数字的子线程。

如果队列的大小增长超过 10，主线程应该停止生成数字，如果队列的大小小于 5，它应该恢复数字生成。

queue<int> qu;

void *num_consumer(void *arg)
{
    while(1) {
        //lock qu
        int num = qu.pop();
        //unlock qu
        do_something_with(num);
    }
}

int main()
{
    pthread_create(&tid, NULL, num_consumer, NULL);
    while(1) {
        int num;
        produce(&num);
        //lock qu
        queue.push(num);
        //unlock qu
        if(qu.size() >= 10) {
            //how to block and how to resume the main thread?
        }
    }
}

我可能会semaphore用来做这项工作，但还有其他想法吗？

4

1 回答 1

5

条件变量在这里是合适的——实际上是一对条件变量，因为如果队列为空，消费者也需要阻塞：

pthread_cond_t qu_empty_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t qu_full_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qu_mutex = PTHREAD_MUTEX_INITIALIZER;

void *num_consumer(void *arg)
{
    while(1) {        
        int num;

        pthread_mutex_lock(&qu_mutex);
        while (qu.size() < 1)
            pthread_cond_wait(&qu_empty_cond, &qu_mutex);
        num = qu.pop();
        if (qu.size() < 5)
            pthread_cond_signal(&qu_full_cond);
        pthread_mutex_unlock(&qu_mutex);
        do_something_with(num);
    }
}

int main()
{
    pthread_create(&tid, NULL, num_consumer, NULL);
    while(1) {
        int num;

        produce(&num);

        pthread_mutex_lock(&qu_mutex);
        queue.push(num);
        pthread_cond_signal(&qu_empty_cond);
        if (qu.size() >= 10)
             do {
                pthread_cond_wait(&qu_full_cond, &qu_mutex);
             } while (qu.size() >= 5);
        pthread_mutex_unlock(&qu_mutex);
    }
}

请注意，当生产者等待条件变量时，队列互斥锁会自动释放。

于 2012-07-24T10:21:41.740 回答