缓冲区不能为空。 参数名: buffer_为什么pthread_cond_wait需要互斥锁mutex作为参数...

最新推荐文章于 2021-11-05 14:43:02 发布
最新推荐文章于 2021-11-05 14:43:02 发布
阅读量419 收藏
点赞数 1
文章标签： 缓冲区不能为空。 参数名: buffer

通常的应用场景下，当前线程执行pthread_cond_wait时，一定是处于某个临界区，正在访问共享资源，存在一个mutex与该临界区相关联。因此，在阻塞前，必须释放mutex；被唤醒后，仍然处于临界区，因此需要再次获得mutex。

目录

  1. 为什么是pthread_cond_wait(cond, mutex)而不是pthread_cond_wait(cond)
  2. 生产者和消费者问题的介绍
  3. 用于同步和互斥的全局变量
  4. 使用pthread_cond_wait(cond)解决生产者和消费者问题(第一版)
  5. 使用pthread_cond_wait(cond)解决生产者和消费者问题(第二版)
  6. 使用pthread_cond_wait(cond, mutex)解决生产者和消费者问题
  7. 完整可编译运行的程序
  8. 程序运行结果

1. 为什么是pthread_cond_wait(cond, mutex)而不是pthread_cond_wait(cond)

我当初学习条件变量时，也有过和楼主相同的疑问，在上操作系统实践课程时，班上的个别学生也问过这个问题。相信这是一个初学者的共性问题，但很少有书籍仔细解释这个问题。

为什么pthread_cond_wait的api被设计为

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

而不是被设计为

int pthread_cond_wait(pthread_cond_t *cond);

pthread_cond_wait(cond, mutex)的功能有3个：

  • 调用者线程首先释放mutex
  • 然后阻塞，等待被别的线程唤醒
  • 当调用者线程被唤醒后，调用者线程会再次获取mutex

pthread_cond_wait(cond)的功能只有1个：

  • 调用者线程阻塞，等待被别的线程唤醒。

这里首先给一个简洁的回答：

  • 通常的应用场景下，当前线程执行pthread_cond_wait时，处于临界区访问共享资源，存在一个mutex与该临界区相关联，这是理解pthread_cond_wait带有mutex参数的关键
  • 当前线程执行pthread_cond_wait前，已经获得了和临界区相关联的mutex；执行pthread_cond_wait会阻塞，但是在进入阻塞状态前，必须释放已经获得的mutex，让其它线程能够进入临界区
  • 当前线程执行pthread_cond_wait后，阻塞等待的条件满足，条件满足时会被唤醒；被唤醒后，仍然处于临界区，因此被唤醒后必须再次获得和临界区相关联的mutex

综上，调用pthread_cond_wait时，线程总是位于某个临界区，该临界区与mutex相关，pthread_cond_wait需要带有一个参数mutex，用于释放和再次获取mutex。

本文的剩下部分将通过一个具体的应用场景来说明，为什么pthread_cond_wait需要一个看似多余的mutex参数。

2. 生产者和消费者问题的介绍

存在一个共享缓冲区，生产者向共享缓冲区写入数据，消费者从共享缓冲区中读取数据。

生产者和消费者存在同步关系：当共享缓冲区为满时，生产者需要等待，等待消费者从共享缓冲区取走数据；当共享缓冲区为空时，消费者需要等待，等待生产者向共享缓冲区中写入数据。

使用环形队列实现共享缓冲区，数据结构如下：

#define CAPACITY 8     // 缓冲区的最大容量
int buffer[CAPACITY];  // 缓冲区数组
int in;                // 缓冲区的写指针
int out;               // 缓冲区的读指针
int size;              // 缓冲区中的数据个数

缓冲区的相关代码如下

void buffer_init()
{
    in = 0;
    out = 0;
    size = 0;
}

// 判断缓冲区是否为空
int buffer_is_empty()
{
    return size == 0; 
}

// 判断缓冲区是否为满
int buffer_is_full()
{
    return size == CAPACITY; 
}

// 向缓冲区中追加一个数据
void buffer_put(int item)
{
    buffer[in] = item;
    in = (in + 1) % CAPACITY;
    size++;
}

// 从缓冲区中取走一个数据
int buffer_get()
{
    int item;

    item = buffer[out];
    out = (out + 1) % CAPACITY;
    size--;

    return item;
}

如果存在多个生产者和多个消费者，变量in、out和size会被它们共享访问，因此生产者和消费者还存在互斥关系：

  • 当某个生产者执行buffer_is_full、buffer_put时，访问了变量in、out和size，只能允许该生产者独占访问这三个变量，禁止其他生产者和消费者访问这些共享变量。
  • 当某个消费者执行buffer_is_empty、buffer_get时，访问了变量in、out和size，只能允许该消费者独占访问这三个变量，禁止其他生产者和消费者访问这些共享变量。

3. 用于同步和互斥的全局变量

总结以上

  • 生产者和消费者中存在有同步关系，需要使用pthread_cond_wait和pthread_cond_signal解决
  • 生产者和消费者中存在有互斥关系，需要使用pthread_mutex_lock和pthread_mutex_unlock解决

程序中需要引入两个全局变量cond和mutex用于同步和互斥

pthread_cond_t cond;
pthread_mutex_t mutex;

4. 使用pthread_cond_wait(cond)解决生产者和消费者问题(第一版)

下面我们尝试使用没有mutex参数的pthread_cond_wait来模拟生产者消费者，假想中没有mutex参数的pthread_cond_wait原型如下：

int pthread_cond_wait(pthread_cond_t *cond);

pthread_cond_wait(cond)的功能非常简单，仅仅阻塞当前线程。在生产者消费者这个应用场景中，很快就能发现pthread_cond_wait(cond)的问题。

使用pthread_cond_wait(cond)解决生产者和消费者问题的代码如下：

// 生产者线程执行的流程
void producer_loop()
{
    int i;

    // 生产CAPACITY*2个数据
    for (i = 0; i < CAPACITY*2; i++) {  
        pthread_mutex_lock(&mutex);

        // 当缓冲区为满时，生产者需要等待
        while (buffer_is_full()) {   
            // 当前线程已经持有了mutex，调用pthread_cond_wait阻塞，必然导致死锁
            pthread_cond_wait(&cond);
        }

        // 此时，缓冲区肯定不是满的，向缓冲区写数据
        buffer_put(i);

        pthread_mutex_unlock(&mutex);        

        // 缓冲区的状态发生了变化，唤醒其它的生产者或消费者
        pthread_cond_signal(&cond);
    }
}

// 消费者线程执行的流程
void consumer_loop()
{
    int i;

    // 消费CAPACITY*2个数据
    for (i = 0; i < CAPACITY*2; i++) {  
        pthread_mutex_lock(&mutex);

        // 当缓冲区为空时，消费者需要等待
        while (buffer_is_empty()) {   
            // 当前线程已经持有了mutex，调用pthread_cond_wait阻塞，必然导致死锁
            pthread_cond_wait(&cond);
        }

        // 此时，缓冲区肯定不是空的，从缓冲区取数据
        int item = buffer_get();

        pthread_mutex_unlock(&mutex);        

        // 缓冲区的状态发生了变化，唤醒其它的生产者或消费者
        pthread_cond_signal(&cond);
    }
}

以上程序存在一个会导致死锁的严重错误，以生产者为例：

  • 当前缓冲区已经满了，生产者运行，首先获取mutex
  • 然后检测buffer_is_full为真，生产者无法放入数据
  • 调用pthread_cond_wait，该生产者进入阻塞状态，等待被消费者唤醒
  • 消费者试图获取mutex，由于mutex已经被占用了，消费者将进入阻塞状态
  • 生产者和消费者均进入阻塞状态，系统死锁

5. 使用pthread_cond_wait(cond)解决生产者和消费者问题(第二版)

为了解决死锁的问题，需要对上一节的程序进行如下改进

  • 调用线程调用pthread_cond_wait(cond)前，已经持有了mutex
  • 执行pthread_cond_wait(cond)前，调用pthread_unlock(mutex)释放mutex
  • 执行pthread_cond_wait(cond)后，调用pthread_lock(mutex)再次获得mutex
// 生产者线程执行的流程
void producer_loop()
{
    int i;

    // 生产CAPACITY*2个数据
    for (i = 0; i < CAPACITY*2; i++) {  
        pthread_mutex_lock(&mutex);

        // 当缓冲区为满时，生产者需要等待
        while (buffer_is_full()) {   
            pthread_mutex_unlock(&mutex);
            pthread_cond_wait(&cond);
            pthread_mutex_lock(&mutex);
        }

        // 此时，缓冲区肯定不是满的，向缓冲区写数据
        buffer_put(i);

        pthread_mutex_unlock(&mutex);        

        // 缓冲区的状态发生了变化，唤醒其它的生产者或消费者
        pthread_cond_signal(&cond);
    }
}

// 消费者线程执行的流程
void consumer_loop()
{
    int i;

    // 消费CAPACITY*2个数据
    for (i = 0; i < CAPACITY*2; i++) {  
        pthread_mutex_lock(&mutex);

        // 当缓冲区为空时，消费者需要等待
        while (buffer_is_empty()) {   
            pthread_mutex_unlock(&mutex);
            pthread_cond_wait(&cond);
            pthread_mutex_lock(&mutex);            
        }

        // 此时，缓冲区肯定不是空的，从缓冲区取数据
        int item = buffer_get();

        pthread_mutex_unlock(&mutex);        

        // 缓冲区的状态发生了变化，唤醒其它的生产者或消费者
        pthread_cond_signal(&cond);
    }
}

这里解释一下为什么线程调用pthread_cond_wait返回后，需要再次调用pthread_mutex_lock获取锁。以生产者为例，以下为生产者向buffer中追加数据的代码段：

// 生产者向buffer中追加数据
pthread_mutex_lock(&mutex);
while (buffer_is_full()) {   
    pthread_mutex_unlock(&mutex);
    pthread_cond_wait(&cond);
    pthread_mutex_lock(&mutex);
}
buffer_put(i);
pthread_mutex_unlock(&mutex);

在上面这段代码中，生产者线程会调用buffer_is_full和buffer_put，访问共享变量in、out和size。必须保证线程以独占的方式访问这些共享变量，即线程在调用buffer_is_full和buffer_put前必须持有锁。线程从pthread_cond_wait返回后，调用pthread_mutex_lock再次获得锁，然后执行语句while (buffer_is_full())时，因为已经拥有了锁，所以通过buffer_is_full访问共享变量是安全的。

6. 使用pthread_cond_wait(cond, mutex)解决生产者和消费者问题

在上一个版本的程序中，生产者和消费者中存在如下代码段

// 先释放mutex、再阻塞、最后再次获取mutex
pthread_mutex_unlock(&mutex);
pthread_cond_wait(&cond);
pthread_mutex_lock(&mutex);

从这个应用场景来看，pthread_cond_wait被设计为带有mutex参数，用一次函数调用pthread_cond_wait(cond, mtex)即可实现以上三条语句的功能。

使用pthread_cond_wait(cond, mutex)解决生产者和消费者问题的代码如下：

// 生产者线程执行的流程
void producer_loop()
{
    int i;

    // 生产CAPACITY*2个数据
    for (i = 0; i < CAPACITY*2; i++) {  
        pthread_mutex_lock(&mutex);

        // 当缓冲区为满时，生产者需要等待
        while (buffer_is_full()) {   
            // 当前线程已经持有了mutex，首先释放mutex，然后阻塞，醒来后再次获取mutex            
            pthread_cond_wait(&cond, &mutex);
        }

        // 此时，缓冲区肯定不是满的，向缓冲区写数据
        buffer_put(i);

        pthread_mutex_unlock(&mutex);        

        // 缓冲区的状态发生了变化，唤醒其它的生产者或消费者
        pthread_cond_signal(&cond);
    }
}

// 消费者线程执行的流程
void consumer_loop()
{
    int i;

    // 消费CAPACITY*2个数据
    for (i = 0; i < CAPACITY*2; i++) {  
        pthread_mutex_lock(&mutex);

        // 当缓冲区为空时，消费者需要等待
        while (buffer_is_empty()) {  
            // 当前线程已经持有了mutex，首先释放mutex，然后阻塞，醒来后再次获取mutex 
            pthread_cond_wait(&cond, &mutex);
        }

        // 此时，缓冲区肯定不是空的，从缓冲区取数据
        int item = buffer_get();

        pthread_mutex_unlock(&mutex);        

        // 缓冲区的状态发生了变化，唤醒其它的生产者或消费者
        pthread_cond_signal(&cond);
    }
}

7. 完整可编译运行的程序

#include <stdio.h>
#include <pthread.h>

#define CAPACITY 8     // 缓冲区的最大容量
int buffer[CAPACITY];  // 缓冲区数组
int in;                // 缓冲区的写指针
int out;               // 缓冲区的读指针
int size;              // 缓冲区中的数据个数

void buffer_init()
{
    in = 0;
    out = 0;
    size = 0;
}

// 判断缓冲区是否为空
int buffer_is_empty()
{
    return size == 0; 
}

// 判断缓冲区是否为满
int buffer_is_full()
{
    return size == CAPACITY; 
}

// 向缓冲区中追加一个数据
void buffer_put(int item)
{
    buffer[in] = item;
    in = (in + 1) % CAPACITY;
    size++;
}

// 从缓冲区中取走一个数据
int buffer_get()
{
    int item;

    item = buffer[out];
    out = (out + 1) % CAPACITY;
    size--;

    return item;
}

pthread_cond_t cond;
pthread_mutex_t mutex;

// 生产者线程执行的流程
void *producer_loop(void *arg)
{
    int i;

    // 生产CAPACITY*2个数据
    for (i = 0; i < CAPACITY*2; i++) {       
    printf("produce %dn", i);
        pthread_mutex_lock(&mutex);

        // 当缓冲区为满时，生产者需要等待
        while (buffer_is_full()) {   
            // 当前线程已经持有了mutex，首先释放mutex，然后阻塞，醒来后再次获取mutex
            pthread_cond_wait(&cond, &mutex);
        }

        // 此时，缓冲区肯定不是满的，向缓冲区写数据
        buffer_put(i);
        pthread_mutex_unlock(&mutex);        

        // 缓冲区的状态发生了变化，唤醒其它的生产者或消费者
        pthread_cond_signal(&cond);
    }

    return NULL;
}

// 消费者线程执行的流程
void *consumer_loop(void *arg)
{
    int i;

    // 消费CAPACITY*2个数据
    for (i = 0; i < CAPACITY*2; i++) {  
        pthread_mutex_lock(&mutex);

        // 当缓冲区为空时，消费者需要等待
        while (buffer_is_empty()) {   
            // 当前线程已经持有了mutex，首先释放mutex，然后阻塞，醒来后再次获取mutex
            pthread_cond_wait(&cond, &mutex);
        }

        // 此时，缓冲区肯定不是空的，从缓冲区取数据
        int item = buffer_get();
        pthread_mutex_unlock(&mutex);        

        // 缓冲区的状态发生了变化，唤醒其它的生产者或消费者
        pthread_cond_signal(&cond);

    printf("tconsume %dn", item);
    }

    return NULL;
}

int main()
{
    pthread_t producer;
    pthread_t consumer;

    buffer_init();
    pthread_create(&producer, NULL, producer_loop, NULL);
    pthread_create(&consumer, NULL, consumer_loop, NULL);

    pthread_join(producer, NULL);
    pthread_join(consumer, NULL);
    return 0;
}

8. 程序运行结果

root@linuxmooc:~# cc -o thread thread.c -lpthread
root@linuxmooc:~# ./thread
produce 0
produce 1
produce 2
produce 3
produce 4
produce 5
produce 6
produce 7
produce 8
produce 9
        consume 0
        consume 1
        consume 2
        consume 3
        consume 4
        consume 5
        consume 6
        consume 7
        consume 8
produce 10
produce 11
produce 12
produce 13
produce 14
produce 15
        consume 9
        consume 10
        consume 11
        consume 12
        consume 13
        consume 14
        consume 15
weixin_39618730
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux条件变量pthread_cond_wait函数为什么需要一个互斥锁
why_so_hot的博客
08-24 375
将线程放入等待队列之后，wait函数内部会进行一次解锁（不能先解锁再放入等待队列，万一锁被人抢走了又还没放入等待队列那么就会忽视这次执行信号），因为线程已经进入了等待队列，所以一定会去进行执行，然后直到第二次竞争到锁，竞争到锁之后去执行，执行完之后不会再去释放锁，所以说在wait函数外面也需要主动进行一次加锁解锁。• pthread_cond_wait函数，用于等待目标条件变量。外部加锁-wait内部解锁-wait内部加锁-外部解锁。
条件变量，pthread_cond_wait()用法分析
非正经研究生的猪圈
11-30 4673
前言 无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait()（或pthread_cond_timedwait()，下同）的竞争条件（Race Condition）。mutex互斥锁必须是普通锁（PTHREAD_MUTEX_TIMED_NP）或者适应锁（PTHREAD_MUTEX_ADAPTIVE_NP），且在调用pthread_cond_wai...
浅析pthread_cond_wait
android菜鸟的专栏
09-11 273
[b][size=large][align=center]浅析pthread_cond_wait[/align][/size][/b] 条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。 一 pthread_cond_wa...
线程学习--pthread--锁链及条件变量
薛定谔的程序喵的博客
11-05 351
pthread_cond_wait函数的使用，一般跟lock一起用 pthread_mutex_lock(&mutex); pthread_cond_wait(&cond,&mutex); 等待条件变量满足； 把获得的锁释放掉；（注意：1，2两步是一个原子操作） 当然如果条件满足了，那么就不需要释放锁。所以释放锁这一步和等待条件满足一定是一起执行（指原子操作）。--很重要。 pthread_cond_wait()被唤醒时，它解除阻塞，并且尝试获取锁（不一定拿到锁）。因此，一
pthread_cond_wait() 用法深入分析
09-05
以下是对pthread_cond_wait的用法进行了详细的分析介绍，需要的朋友可以过来参考下
多线程编程——互斥锁使用（Jack_pthread_mutex_test.rar）
08-19
多线程编程：互斥锁使用。 打包文件包含两个文件：c文件源代码、Makefile文件，运行环境在Ubuntu14.04下，使用自带的gcc编译器，同学们只需将文件夹复制到某一目录下之后在终端执行：1.“make”生成“test”可执行...
udt_test.rar_UDT.rar_UDT_Examp_Udt te_pthread_pthread win32
09-20
udt的一个例子和 pthread for win32平台的例子
为什么在pthread_cond_wait()前要加一个while循环来判断条件是否为假呢？.Linux 多线程
01-19
为什么在pthread_cond_wait()前要加一个while循环来判断条件是否为假呢？.zip
pthread-primer.rar_Pthread Primer pdf_pthread_pthread primer
09-21
另外的一个phread的教学文档，大家可以参照学习
C#缓冲区分析代码
08-15
这是一个关于缓冲区分析的C#实现代码，很好用！
pthread_cond_wait和pthread_cond_signal
wangkai6666的博客
06-20 879
参考原文：https://www.zhihu.com/question/24116967/answer/576056958 bool ready = false; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER pthread_cond_t cond = PTHREAD_COND_INITIALIZER; Thread A1: pthread_mutex_lock(&mutex); while (false == ready) { pth
线程加锁与同步，pthread_mutex_lock，pthread_mutex_unlock，pthread_cond_wait，pthread_cond_signal
lightrour的博客
03-23 505
线程加锁与同步，pthread_mutex_lock，pthread_mutex_unlock，pthread_cond_wait，pthread_cond_signal 线程之间的同步是通过临界资源来实现的，简言之，临界资源就是全局变量，而同步就是一个线程使另一个线程的条件成立，唤醒阻塞的线程，然后将CPU控制权给它，此时为了防止线程混乱，最好将自己的条件变为假，等待另一个线程使自己的条件为真。 注意事项： 一个线程调用pthread_cond_wait()阻塞等待时，后面的代码不会再执行。而当另一
缓冲区不能为空。 参数名: buffer_图解PostgreSQL--buffer管理
weixin_39930252的博客
12-03 1070
一、共享缓冲区数据结构1、Buffer由数组BufferDescriptor[]数组进行管理。该数组由函数InitBufferPool创建，大小为NBuffers个成员即BufferDesc。该数组创建后由StrategyControl进行管理，firstFreeBuffer为链表头，指向链表第一个成员；lastFreeBuffer指向链表尾；所有free list中成员由freeNext串起来，...
缓冲区不能为空。 参数名: buffer_深入理解NIO系列 - Buffer详解
weixin_39809140的博客
12-09 727
Buffer简介在Java NIO中，主要有三大基本的组件：Buffer、Channel和Selector，上一篇文章我们具体介绍了Selector,现在让我们深入理解下在实际编程中使用的最多的Buffer。定义首先先让我们来认识一下Buffer：A container for data of a specific primitive type.A buffer is a linear, fini...
缓冲区不能为空。 参数名: buffer_Java NIO2：缓冲区
weixin_39600331的博客
12-04 649
什么是缓冲区一个缓冲区对象是固定数量的数据的容器，其作用是一个存储器，或者分段运输区，在这里数据可被存储并在之后用于检索。缓冲区像前篇文章讨论的那样被写满和释放，对于每个非布尔原始数据类型都有一个缓冲区类，尽管缓冲区作用于它们存储的原始数据类型，但缓冲区十分倾向于处理字节，非字节缓冲区可以再后台执行从字节或到字节的转换，这取决于缓冲区是如何创建的。缓冲区的工作与通道紧密联系。通道是I/O传输发生时...
NIO 看破也说破（五）： 搞，今天就搞，搞懂Buffer
小眼睛的博客
06-07 331
Java NIO 中的三件法宝：Channel 、Selector 和 Buffer 。前面几节中，我们花了很大篇幅讲过 Selector ，咱们今天只搞 Buffer 。希望能通过本文搞明白 Buffer 的基本用法和原理。掌握重点：两个重要指针不停变换；一块 Buffer 可读可写；基本操作的 api 用法；ByteBuffer 可以在 JVM 堆外分配直接内存
缓冲区不能为空。 参数名: buffer_Java Nio 之Buffer
weixin_39673051的博客
12-02 301
了解历史在 java1.4之前java io ,最核心的点是在"流"上；java io 的两大基石InputStream和OutputStream 也就是大家耳熟能祥的输入流和输出流,通过这个两个基石可以实现从外界读取数据到内存，以及将内存中数据写到外界；但是输入流和输出流有个弊端就是单向只能输入或者输出，而在java1.4提供的FileChannel不仅仅可以输入也同样可以输出，是一个双向的通道...
常见安全漏洞
justtaste的博客
04-10 267
常见安全漏洞SQL注入解决方法跨站脚本攻击解决方法不安全的HTTP methods解决方法URL重定向解决方法用户名枚举解决方法信息泄露shiro反序列化解决方法弱口令 SQL注入 解决方法 通过拦截过滤的方式，示例代码如下 //SQL注入效验 public static boolean sqlValidate(String str) { str = str.toLowerCase();/...
为什么使用pthread_cond_wait前需要调用pthread_mutex_lock?
最新发布
02-22
在使用pthread_cond_wait函数之前，需要先调用pthread_mutex_lock函数来获取互斥锁。这是因为pthread_cond_wait函数的工作机制需要依赖互斥锁来保证线程的同步和互斥。 pthread_cond_wait函数用于线程的条件等待，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值