线程同步与条件变量

已于 2024-05-02 16:43:22 修改
阅读量839 收藏 16
点赞数 11
分类专栏： Linux系统编程 文章标签： linux
于 2024-05-02 16:39:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52484093/article/details/138392827
版权

再论生产消费者问题

问题

如果缓冲池为空，如何定义消费者的行为?

一种可能的解决方案

这种方案是可行的，但是如果生产者一直不生产，那么消费者会反复查看产品的数量为 0 并休眠，这样会浪费 cpu 的资源，并且生产者生产后，消费者并不能马上从休眠状态中被唤醒去取走产品，这种方案的效率并不高

需求:

消费者发现缓冲池为空的时候，主动让出互斥量，并进入等待状态

当缓冲池非空，即: 生产者更新缓冲池状态, 消费者再次竞争锁

关键:

消费者不需要反复多次竞争锁 (缓冲池为空, 直接等待)

生产者可通知消费者再次竞争锁 (生产者与消费者协同机制)

Linux 中的条件变量

条件变量的注意事项

条件变量之间不能相互初始化，也不能相互赋值 (行为未定义)

使用 pthread_cond_init() 初始化的条件变量，必须被销毁，且可以重新初始化

使用 PTHREAD_COND_INITIALIZER 初始化的条件变量不需要销毁

不能使用 未初始化 / 已销毁 的条件变量 (行为未定义)

pthread_cond_wait() 只能由拥有互斥量的线程调用

条件变量的使用

条件变量初体验

test1.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#define _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>


int g_count = 0;
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;

void* customer_thread(void* arg)
{     
    while( 1 )
    {
        pthread_mutex_lock(&g_mutex);
        
        if( g_count > 0 )
            printf("%s : %d\n", __FUNCTION__, --g_count);        
        else
            pthread_cond_wait(&g_cond, &g_mutex); // g_cond points to the queue, g_mutex needs to be unlocked
            
        pthread_mutex_unlock(&g_mutex);
        
        usleep(500 * 1000);
    }
        
    return NULL;
}

int main()
{
    pthread_t t = 0;  
    int pre = 0;

    pthread_create(&t, NULL, customer_thread, NULL);
    
    printf("Hello World!\n");
    
    while( 1 )
    {
        pthread_mutex_lock(&g_mutex);
        
        pre = g_count;
        
        printf("%s : %d\n", __FUNCTION__, ++g_count);  
        
        if( pre == 0 )
        {
            printf("%s : %s\n", __FUNCTION__, "signal customer to get product...");
            pthread_cond_signal(&g_cond);
        }
        
        pthread_mutex_unlock(&g_mutex);
        
        usleep(2000 * 1000); 
    }
    
    printf("End!\n");
  
    return 0;
}

主线程为生产者，负责生产产品；子线程 customer_thread 为消费者，负责取走产品

第 24 行，如果消费者发现没有产品，则调用 pthread_cond_wait(&g_cond, &g_mutex) 阻塞在 g_cond 这个条件变量上，并释放已获取到的互斥锁 g_mutex

第 54 行，如果生产者生产了产品后发现上一次的产品没了，则调用 pthread_cond_signal(&g_cond)，来唤醒阻塞在 g_cond 这个条件变量上的单个消费者线程来取产品，这样原先阻塞在 g_cond 这个条件变量上的某个线程就会被唤醒，重新抢夺互斥锁，取走产品，然后释放互斥锁

程序运行结果如下图所示：

进阶条件变量

int pthread_cond_signal(pthread_cond_t* cond);

  • 唤起一个等待目标条件变量的线程

int pthread_cond_broadcast(pthread_cond* cond);

  • 唤起所有等待目标条件变量的线程

一个生产者 vs 多个消费者

存在的问题

解决方案

条件变量深度实验

test2.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#define _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>


int g_count = 0;
pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;

void* customer_thread(void* arg)
{   
    int i = (long)arg;  
    
    // prepare to get product
    {
        pthread_mutex_lock(&g_mutex);
        
        if( g_count == 0 )
        // while( g_count == 0 )
            pthread_cond_wait(&g_cond, &g_mutex);
            
        // get product from buffer
        printf("customer %d : %d\n", i, g_count);
        
        g_count--;
            
        pthread_mutex_unlock(&g_mutex);
    }
        
    return NULL;
}

int main()
{
    pthread_t t[10] = {0};
    int len = sizeof(t)/sizeof(*t);
    long i = 0;

    for(i=0; i<len; i++)
    {
        pthread_create(&t[i], NULL, customer_thread, (void*)i);
    }
    
    printf("Hello World!\n");
    
    sleep(1);
    
    {
    
        // prepare to make product
        pthread_mutex_lock(&g_mutex);
        
        int v = g_count;  
        
        g_count += 10;
        
        if( v == 0 )
            pthread_cond_signal(&g_cond); 
            // pthread_cond_broadcast(&g_cond);
        
        pthread_mutex_unlock(&g_mutex);
    }
    
    for(i=0; i<len; i++)
    {
        pthread_join(t[i], NULL);
    }
    
    printf("End!\n");
  
    return 0;
}

第 46 行，主线程创建 10 个消费者线程 customer_thread，随后主线程休眠 1s，由于产品数量为 0，10 个消费者线程会阻塞在 g_cond 这个条件变量上

第 63 行，主线程生产了 10 个产品后，通过 pthread_cond_signal 来通知阻塞在 g_cond 这个条件变量上的单个线程，这样就会导致 10 个被阻塞的线程只有 1 个线程被唤醒，取走产品，其他线程依旧被阻塞

程序运行结果如下图所示：

pthread_cond_signal(cond) 函数只会唤醒单个阻塞在 cond 条件变量上的单个线程，我们将这个函数替换为 pthread_cond_broadcast(cond)，而这个函数会唤醒所有阻塞在 cond 条件变量上的所有线程，这样 10 个消费者线程都会被唤醒，然后取走产品

替换后的程序

test2.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#define _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>


int g_count = 0;
pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;

void* customer_thread(void* arg)
{   
    int i = (long)arg;  
    
    // prepare to get product
    {
        pthread_mutex_lock(&g_mutex);
        
        if( g_count == 0 )
        // while( g_count == 0 )
            pthread_cond_wait(&g_cond, &g_mutex);
            
        // get product from buffer
        printf("customer %d : %d\n", i, g_count);
        
        g_count--;
            
        pthread_mutex_unlock(&g_mutex);
    }
        
    return NULL;
}

int main()
{
    pthread_t t[10] = {0};
    int len = sizeof(t)/sizeof(*t);
    long i = 0;

    for(i=0; i<len; i++)
    {
        pthread_create(&t[i], NULL, customer_thread, (void*)i);
    }
    
    printf("Hello World!\n");
    
    sleep(1);
    
    {
    
        // prepare to make product
        pthread_mutex_lock(&g_mutex);
        
        int v = g_count;  
        
        g_count += 10;
        
        if( v == 0 )
            // pthread_cond_signal(&g_cond); 
            pthread_cond_broadcast(&g_cond);
        
        pthread_mutex_unlock(&g_mutex);
    }
    
    for(i=0; i<len; i++)
    {
        pthread_join(t[i], NULL);
    }
    
    printf("End!\n");
  
    return 0;
}

程序运行结果如下图所示：

pthread_cond_broadcast() 使得 10 个消费者线程都被唤醒

test3.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#define _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>


int g_count = 0;
pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;

void* customer_thread(void* arg)
{   
    int i = (long)arg;  
    
    // prepare to get product
    {
        pthread_mutex_lock(&g_mutex);
        
        if( g_count == 0 )
        // while( g_count == 0 )
            pthread_cond_wait(&g_cond, &g_mutex);
            
        // get product from buffer
        printf("customer %d : %d\n", i, g_count);
        
        g_count--;
            
        pthread_mutex_unlock(&g_mutex);
    }
        
    return NULL;
}

int main()
{
    pthread_t t[10] = {0};
    int len = sizeof(t)/sizeof(*t);
    long i = 0;

    for(i=0; i<len; i++)
    {
        pthread_create(&t[i], NULL, customer_thread, (void*)i);
    }
    
    printf("Hello World!\n");
    
    sleep(1);
    
    {
    
        // prepare to make product
        pthread_mutex_lock(&g_mutex);
        
        int v = g_count;  
        
        g_count += 5;
        
        if( v == 0 )
            pthread_cond_broadcast(&g_cond);
        
        pthread_mutex_unlock(&g_mutex);
    }
    
    for(i=0; i<len; i++)
    {
        pthread_join(t[i], NULL);
    }
    
    printf("End!\n");
  
    return 0;
}

生产者为 1 个，消费者为 10 个，生产者一次生产 5 个产品

首先，10 个生产者会阻塞在 g_cond 这个条件变量上，生产者生产了 5 个产品后，调用 pthread_cond_broadcast()，唤醒了阻塞在 g_cond 这个条件变量上的 10 个消费者线程，但是消费者线程被唤醒后没有再次进行产品数量判断，而是直接取走了产品，这样就会出现问题

程序运行结果如下图所示：

产品数量出现了负数，我们将 23 行的 if 改为 while 即可解决这个问题

替换后的程序

test3.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#define _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200809L
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>


int g_count = 0;
pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;

void* customer_thread(void* arg)
{   
    int i = (long)arg;  
    
    // prepare to get product
    {
        pthread_mutex_lock(&g_mutex);
        
        while( g_count == 0 )
            pthread_cond_wait(&g_cond, &g_mutex);
            
        // get product from buffer
        printf("customer %d : %d\n", i, g_count);
        
        g_count--;
            
        pthread_mutex_unlock(&g_mutex);
    }
        
    return NULL;
}

int main()
{
    pthread_t t[10] = {0};
    int len = sizeof(t)/sizeof(*t);
    long i = 0;

    for(i=0; i<len; i++)
    {
        pthread_create(&t[i], NULL, customer_thread, (void*)i);
    }
    
    printf("Hello World!\n");
    
    sleep(1);
    
    {
    
        // prepare to make product
        pthread_mutex_lock(&g_mutex);
        
        int v = g_count;  
        
        g_count += 5;
        
        if( v == 0 )
            pthread_cond_broadcast(&g_cond);
        
        pthread_mutex_unlock(&g_mutex);
    }
    
    for(i=0; i<len; i++)
    {
        pthread_join(t[i], NULL);
    }
    
    printf("End!\n");
  
    return 0;
}

 程序运行结果如下图所示：

只有 5 个消费者线程取走了产品

qq_52484093
关注
  • 11
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Qt 多线程同步之条件变量
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
03-15 1086
1.QWaitCondition QWaitCondition与QMutex结合，可以使一个线程在满足一定条件时通知其他多个线程，使它们及时作出响应，这样比只使用互斥量效率要高一些。 常用API wait(QMutex *lockedMutex, unsigned long time = ULONG_MAX)：解锁互斥量lockedMutex，并阻塞等待唤醒条件，被唤醒后锁定lockedMutex并退出函数。 wakeAll()：唤醒所有处于等待状态的线程，线程唤醒的顺序不确定，由操作系统的调度策略
C++多线程并发（三）---线程同步之条件变量
热门推荐
流云
05-03 1万+
一、何为条件变量 在前一篇文章《C++多线程并发编程（二）—线程同步之互斥锁》中解释了线程同步的原理和实现，使用互斥锁解决数据竞争访问问题，算是线程同步的加锁原语，用于排他性的访问共享数据。我们在使用mutex时，一般都会期望加锁不要阻塞，总是能立刻拿到锁，然后尽快访问数据，用完之后尽快解锁，这样才能不影响并发性和性能。 如果需要等待某个条件的成立，我们就该使用条件变量(condition var...
Linux线程同步之条件变量
anonymalias的专栏
06-25 8113
条件变量变量也是出自POSIX线程标准，另一种线程同步机制，。主要用来等待某个条件的发生。可以用来同步同一进程中的各个线程。当然如果一个条件变量存放在多个进程共享的某个内存区中，那么还可以通过条件变量来进行进程间的同步。 每个条件变量总是和一个互斥量相关联，条件本身是由互斥量保护的，线程在改变条件状态之间必须要锁住互斥量。条件变量相对于互斥量最大的优点在于允许线程以无竞争的方式等待条件的发生。当
C语言学习之线程同步——mutex锁、条件变量
u013511885的博客
11-17 6287
(一)mutex锁 #include <pthread.h> //静态初始化一个mutex类型的变量 pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;   int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mute...
线程同步—条件变量和信号量
zjwson的博客
03-24 1797
上一节提到了线程互斥和同步的概念，并且给出了两种用于解决共享资源互斥的利器：互斥锁和读写锁。那么本节将介绍两种用于解决线程同步的概念：条件变量和信号量。 一. 条件变量 1.基本概念 互斥锁的缺点是它只有两种状态：锁定和非锁定。而条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足。条件变量的内部实质上是一个等待队列，放置等待（阻塞）的线程，线程在条件变量上等待和
[Linux]条件变量：实现线程同步（什么是条件变量、为什么需要条件变量，怎么使用条件变量（接口）、例子，代码演示（生产者消费者模型））
2202_75305885的博客
03-21 1736
在保证数据安全的前提下，让线程能够按照某种特定的顺序访问临界资源，从而有效避免饥饿问题，叫做同步。饥饿问题饥饿问题指的是某些线程由于某种原因无法获得它们所需要的资源或执行机会，导致它们长时间得不到处理，甚至永远得不到处理的现象。这种情况通常发生在多个线程竞争有限资源时，其中一些线程可能因为优先级过低、调度算法的不公平性、同步机制使用不当或其他原因而无法获得足够的执行时间。
多线程——条件变量的概念和实现
glory的博客
09-16 1207
概念 条件变量，也称条件锁，是利用线程间共享的全局变量进行同步的一种机制， 主要包括两个动作： 1）一个线程等待"条件变量的条件成立"而挂起； 2）另一个线程使"条件成立"（给出条件成立信号）条件的检测是在互斥锁的保护下进行的如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。 如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。 如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步 函数API
linux线程同步之条件变量condition
野生猿-群号1025127672
07-12 2028
参考：https://blog.csdn.net/i_love_blog/article/details/72630121   条件变量使我们可以睡眠等待某种条件出现。 条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。 条件...
【探索Linux】P.21（多线程 | 线程同步 | 条件变量 | 线程安全）
Yawesh的博客
12-10 2173
这篇文章主要介绍了一些与多线程编程相关的概念，包括线程同步、条件变量、线程安全等。在多线程编程中，为了避免竞态条件和数据竞争等问题，需要使用锁定机制来保证共享资源的同步和互斥访问，从而实现线程安全。而条件变量则可以作为一种高级的同步机制，用于线程之间的通信和同步。此外，还介绍了可重入性和线程安全性之间的关系，以及全局变量对线程安全性的影响等问题。总之，本文为读者提供了一些基础的多线程编程知识和技巧，有助于更好地理解和应用多线程编程。
Linux多线程之条件变量
delongwang520的博客
03-19 3582
上一节中，Linux多线程之互斥锁最后遗留了一个问题，consumewait函数会一直轮询检查生产者是否生产好了条目，这样很浪费CPU的时间，因此，需要有另外一种类型的同步，它允许一个线程（或进程）睡眠到发生某个事件为止。互斥锁用于上锁，条件变量则用于等待。这两种不同类型的同步都是需要的。条件变量是类型为pthread_cond_t的变量，以下两个函数使用了这些#include &lt;pthre...
线程同步 条件变量
06-02
pthread 条件变量，线程同步
Java 理论与实践: 正确使用 volatile 变量 线程同步
12-22
Java语言规范中指出：为了获得佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。 　这样当多个线程同时与某个对象交互时，必须要注意到要让线程...
Python线程条件变量Condition原理解析
09-18
当调用`acquire()`方法时，线程会获取与条件变量关联的锁，而`release()`方法则会释放该锁。其他如`wait()`, `notify()`, 和 `notify_all()`等方法必须在线程已经持有锁的情况下使用。 `wait()`方法的作用是释放...
互斥锁与条件变量详解 疑问全解
08-11
互斥锁与条件变量详解 互斥锁（Mutex）是多线程编程中最基本的同步机制之一，它用于保护共享资源免受多个线程同时访问的干扰。条件变量（Condition Variable）则是另一个重要的同步机制，它允许线程在满足特定条件...
【Linux】Xshell和Xftp简介_安装_VMware虚拟机使用
wosixiaokeai的博客
06-19 1364
Xftp是一个功能强大的SFTP、FTP文件传输软件，它允许MS Windows用户安全地在UNIX/Linux和Windows PC之间传输文件。Xftp支持SFTP协议，确保所有通过该软件的网络流量都是加密的。它采用了标准的Windows风格的向导，用户界面直观易用，可以很好地与其他Windows应用程序协同工作。Xftp的特色功能包括同步功能、直接编辑远程文件、多窗格支持、文件交换协议（FXP）支持等，这些功能使得文件传输更加容易和快捷。
【Linux】如何创建yum 组(yum groups)
zclinux的博客
06-19 578
在yum中创建组信息需要手动编辑并创建一个组文件，然后使用createrepo工具生成组信息。
SUSE linux的快照和恢复
大龄IT民工
06-19 1199
openSUSE默认提供了通用场景下的快照设置，你也可以根据需要进行修改。
Linux开发讲课7---Linux sysfs文件系统
最新发布
qq_42837317的博客
06-21 1080
Sysfs通过文件和目录的方式组织信息，其中每个文件或目录对应于系统中的一个设备、驱动程序或者其他内核对象。当内核中的设备、驱动程序等对象被创建时，相应的Kobject也会被创建，然后通过Sysfs将其信息暴露给用户空间。Sysfs通常被挂载在/sys目录下，它提供了一种方便的方式，让用户空间的程序可以动态地获取和管理系统中的设备信息，而无需直接访问内核数据结构。（2）创建sysfs文件。其中attr表示将要创建的文件（属性），而show和store分别表示对应的sysfs文件在读和写操作时的回调函数。
如何使用条件变量实现线程同步？
03-26
使用条件变量实现线程同步的步骤如下： 1. 创建条件变量和互斥锁：首先，需要创建一个条件变量和一个互斥锁。条件变量用于线程之间的通信，互斥锁用于保护共享资源。 2. 加锁：在访问共享资源之前，需要先获取互斥...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值