2

我正在使用互斥锁来尝试将对代码的某些部分的访问限制为一个线程，但不是锁定一次并阻止其他线程，它似乎允许所有线程“锁定”。以下是我的代码，然后是显示代码不起作用的输出部分。

//headers defined, etc

pthread_mutex_t queuemutex = PTHREAD_MUTEX_INITIALIZER;

// other code with various functions

int main(void) {

    //unrelated code

    threadinformation **threadArray = (threadinformation **)malloc( POOLSIZE * sizeof(threadinformation) );

    int k;
    for (k = 0; k < POOLSIZE; k++) {
        pthread_t thread;
        threadinformation *currentThread = (threadinformation *)malloc(sizeof(threadinformation));
        currentThread->state = (int *)malloc(sizeof(int));
        currentThread->state[0] = 0;
        currentThread->currentWaiting = currentWaiting;
        currentThread->number = k;
        threadArray[k] = currentThread;
        pthread_create(&thread, NULL, readWriteToClient, threadArray[k]); //thread is created here
        currentThread->thread = thread;
        joinArray[k] = thread;
    }

    //unrelated code

}

static void* readWriteToClient(void *inputcontent) {

    while(1){

        //unrelated code

        pthread_mutex_lock(&queuemutex); //problem happens here

        fprintf(stderr,"Thread %d got locked \n",threadInput->number);

        while((threadInput->currentWaiting->status) == 0){
            pthread_cond_wait(&cond, &queuemutex);
            fprintf(stderr,"Thread %d got signalled \n",threadInput->number);
        }

        connfd = threadInput->currentWaiting->fd;
        threadInput->currentWaiting->status = 0;
        pthread_cond_signal(&conncond);
        pthread_mutex_unlock(&queuemutex);

        //unrelated code

    }

}

输出。

Thread 0 got locked 
Thread 7 got locked 
Thread 25 got locked 
Thread 97 got locked 
Thread 6 got locked 
Thread 5 got locked 
Thread 4 got locked 
Thread 3 got locked 
Thread 8 got locked 
Thread 9 got locked 
Thread 10 got locked 
Thread 11 got locked 
Thread 12 got locked 
Thread 13 got locked 
Thread 14 got locked 
Thread 15 got locked 
Thread 16 got locked 
Thread 17 got locked 
Thread 18 got locked 
Thread 19 got locked 
Thread 20 got locked 
    And so on...
4

2 回答 2

3

没有问题。

pthread_cond_wait(&cond, &queuemutex);

等待条件变量释放互斥锁。

于 2013-02-26T21:58:54.383 回答
1

fceller 所说的更长的版本是， pthread_cond_wait(&cond, &mutex) 在返回之前做了三件事：它释放锁，然后等待信号，然后等待（如果需要）重新获取锁.

您的示例没有显示什么（如果有的话）发送了第一个信号，也没有显示什么（如果有的话）设置了工作线程正在等待的状态。

这是 pthread_cond_wait() 和 pthread_cond_signal() 的更典型用例。

void producer() {
    pthread_mutex_lock(&mutex);
    push_something_on_the_queue();
    ptherad_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);
}

void consumer() {
    pthread_mutex_lock(&mutex);
    while (! time_to_quit) {
        if (queue_is_empty) {
            pthread_cond_wait(&cond, &mutex);
        } else {
            thing = take_something_from_the_queue();

            pthread_mutex_unlock(&mutex);
            do_something_with(thing);
            pthread_mutex_lock(&mutex);
        }
    }
    pthread_mutex_unlock(&mutex);
}

生产者线程将事物放入队列中。消费者线程等待事物出现在队列中，然后将它们弹出并处理它们。消费者在循环中等待，每次唤醒时都会检查队列的状态（即使队列中没有任何内容，线程也可能被“错误地”发出信号）。

当消费者检查队列时，互斥锁被锁定，并且它保持锁定状态，直到消费者睡眠或从队列中弹出一个东西。当消费者睡觉时互斥锁没有被锁定，当消费者对事物做任何事情时它也没有被锁定。

任意数量的消费者可以同时在 consumer() 方法中。他们可能正在对不同的事物进行操作，或者他们可能正在睡觉；但是互斥锁确保在任何给定时间不超过一个线程（生产者或消费者）可以访问队列。

于 2013-12-12T21:12:00.227 回答