使用循环缓冲区和生产者/消费者设计模式时是否需要互斥锁

Question

我有两个线程通过循环缓冲区进行通信。

/* Initialize not_full semaphore to a count of BUFFER_SIZE */
sem_init(&not_full_semaphore, 0, BUFFER_SIZE);
/* Initialize not_empty semaphore to a count of 0 */
sem_init(&not_empty_semaphore, 0, 0);

void producer_thread (void) {
    int item
    int head = 0;

    while(true) {
        item = produce_item();

        sem_wait(&not_full_semaphore);
        mutex_lock(&circular_buffer_mutex);
        /* Insert item into the buffer */
        circular_buffer[head] = item;
        /* Increment head offset and wrap if necessary */
        head = (head == BUFFER_SIZE - 1) ? 0 : head + 1;
        mutex_unlock(&circular_buffer_mutex);
        sem_post(&not_empty_semaphore);
    }
}

void consumer_thread (void){
    int item;
    int tail = 0;

    while(true) {
        sem_wait(&not_empty_semaphore);
        mutex_lock(&circular_buffer_mutex);
        /* Remove item from the buffer */
        item = circular_buffer[tail];
        /* Increment tail offset and wrap if necessary */
        tail = (tail == BUFFER_SIZE - 1) ? 0 : tail + 1;
        mutex_unlock(&circular_buffer_mutex);
        sem_post(&not_full_semaphore);
        consume_item(item);
    }

我的问题是我真的需要互斥锁吗？在我看来，生产者和消费者不可能同时访问相同的内存。在生产者完成写入并通过 not_empty 信号量发出信号之前，消费者不会读取。 not_full 信号量将阻止生产者回绕并再次写入。所以在我看来我不需要互斥锁，但我发现的所有示例都使用了它。

Answer 1

我的问题是我真的需要互斥锁吗？

是的，你知道。

没有互斥锁，因为您将 not_full_semaphore 初始化为一个可能大于 1 的值，在此代码中：

while(true) {
    item = produce_item();

    sem_wait(&not_full_semaphore);

    // can reach here while the consumer thread is
    // accessing the circular buffer

    // but this mutex prevents both threads from
    // accessing the circular buffer simultaneously
    mutex_lock(&circular_buffer_mutex);

您的生产者线程在生产下一个项目之前不会等待消费者线程完成。

并且生产者将被 not_full 信号量阻止回绕和再次写入。

这是不正确的。如果 not_full_semaphore 被初始化为大于 1 的值，则生产者线程不必等待消费者线程。