多线程编程同步：互斥锁和条件变量

最新推荐文章于 2024-04-24 16:06:48 发布
最新推荐文章于 2024-04-24 16:06:48 发布
阅读量894 收藏 18
点赞数 23
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w18478272407/article/details/135167360
版权

多线程同步

怎样同步多个线程或多个进程的活动？

为允许在线程或进程间共享数据，同步通常是必需的。而互斥锁和条件变量是同步的基本组成部分。

互斥锁用于保护 临界区(critical region)，以保证任何时刻只有一个线程在执行其中的代码，或者任何时刻只有一个进程在执行其中的代码。

互斥锁用于上锁，条件变量则用于等待。这两种不同类型的同步都是需要的。

多生产者-单消费者（仅考虑多生产者之间的同步）

例子说明：多个生产者线程执行完毕，才开始消费者线程。故仅需考虑生产者线程之间的同步问题

目的：

1）测试互斥锁对于生产者线程的同步作用

2）测试互斥锁的性能开销(主要指时间开销)

MFC界面设计模拟生产者消费者的互斥操作

prodscons_mutex.c

//==============================================================================
// Include files
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>

//==============================================================================
// Constants
#define MAX_N_ITEMS     100000000
#define MAX_N_THREADS   100

#define MAX(a,b) ((a)>(b) ? (a):(b)) 
#define MIN(a,b) ((a)<(b) ? (a):(b))
//==============================================================================
// types
struct SHARED_ST
{
    pthread_mutex_t mutex;
    int buff[MAX_N_ITEMS];
    int nPut;
    int nVal;
};

//==============================================================================
// global varibles
static int g_nItems; // read-only by producer and consumer
static struct SHARED_ST g_shared = {PTHREAD_MUTEX_INITIALIZER};

//==============================================================================
// global functions

static void *produce(void *arg);
static void *consume(void *arg);

//==============================================================================
// The main entry-point function.

int main(int argc, char **argv)
{
    int i = 0, nThreads = 0;
    int count[MAX_N_THREADS] = {0};
    pthread_t tid_produce[MAX_N_THREADS] = {0};
    pthread_t tid_consume = 0;

    if (argc != 3)
    {
        printf("usage: %s <#item> <#threads>\n", argv[0]);
        exit(1);
    }
    g_nItems = MIN(atoi(argv[1]), MAX_N_ITEMS);
    nThreads = MIN(atoi(argv[2]), MAX_N_THREADS);

	if (pthread_setconcurrency(nThreads) != 0)
    {
        printf("set thread concurrency failed\n");
        exit(1);
    }

    time_t time1, time2;
    time1 = time((time_t *) NULL);
    /* start all the producer threads */
    for (i = 0; i < nThreads; i++)
    {
        count[i] = 0;
        pthread_create(&tid_produce[i], NULL, produce, &count[i]);
    }
   
    /* wait for all the producer threads */
    for (i = 0; i < nThreads; i++)
    {
        pthread_join(tid_produce[i], NULL);
        printf("count[%d] = %d\n", i, count[i]);
    }
    time2 = time((time_t *) NULL);
    printf("%d producer produce %d data, use %.2f s\n", nThreads, g_nItems, difftime(time2, time1));
    
    /* start, then wait for the consumer thread */
    pthread_create(&tid_consume, NULL, consume, NULL);
    pthread_join(tid_consume, NULL);


    exit(0);
}

static void *produce(void *arg)
{
    while (1)
    {
        pthread_mutex_lock (&g_shared.mutex);

        if (g_shared.nPut >= g_nItems)
        {
            pthread_mutex_unlock(&g_shared.mutex);
            
            return (NULL); // array is full, we are done
        }
        g_shared.buff[g_shared.nPut] = g_shared.nVal;
        g_shared.nPut++;
        g_shared.nVal++;

        pthread_mutex_unlock(&g_shared.mutex);
        *((int *) arg) += 1;
    }

}

static void *consume(void *arg)
{
    int i = 0;
    for (i = 0; i < g_nItems; i++)
    {
        if (g_shared.buff[i] != i)
        {
            printf("buff[%d] = %d\n", i, g_shared.buff[i]);
        }
    }

    return (NULL);
}

使用3个线程生产1千万条数据：

使用1个线程生产1千万条数据：

取消互斥锁

在代码中注释互斥锁语句，重新编译运行。

使用3个线程生产100条数据：

count[i]的所有元素的值之和不等于100，生产数据出错。
buff[i] != i，意味着消费者线程消费数据时检测到生产者线程之间生产数据出错（正确的数据要求：buff[i] == i）。

互斥锁开销

生产者线程数量生产数据数量耗时(s)
11亿2s
21亿18s
31亿9s
41亿15s
51亿16s

由上述结果可以得出结论：生产同样量的数据，为保证数据同步，使用多线程的互斥锁会产生额外的开销。

多生产者-单消费者（考虑多生产者之间的同步、生产者和消费者的同步）

例子说明：在所有生产者线程都启动后，立即启动消费者线程。不仅要考虑生产者线程之间的同步，而且还要考虑生产者线程和消费者线程之间的同步。

prodscons_mutex2.c

/*
 * @Description: consider between producer threads and consumer synchronization.
 * when producer threads started, the consumer start right now.
 * @Author: caojun
 * @version: 
 * @Date: 2023-10-13 10:01:24
 * @LastEditors: caojun
 * @LastEditTime: 2023-10-13 10:31:11
 */

//==============================================================================
// Include files
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>

//==============================================================================
// Constants
#define MAX_N_ITEMS     100000000
#define MAX_N_THREADS   100

#define MAX(a,b) ((a)>(b) ? (a):(b)) 
#define MIN(a,b) ((a)<(b) ? (a):(b))
//==============================================================================
// types
struct SHARED_ST
{
    pthread_mutex_t mutex;
    int buff[MAX_N_ITEMS];
    int nPut;
    int nVal;
};

//==============================================================================
// global varibles
static int g_nItems; // read-only by producer and consumer
static struct SHARED_ST g_shared = {PTHREAD_MUTEX_INITIALIZER};

//==============================================================================
// global functions

static void *produce(void *arg);
static void *consume(void *arg);

//==============================================================================
// The main entry-point function.

int main(int argc, char **argv)
{
    int i = 0, nThreads = 0;
    int count[MAX_N_THREADS] = {0};
    pthread_t tid_produce[MAX_N_THREADS] = {0};
    pthread_t tid_consume = 0;

    if (argc != 3)
    {
        printf("usage: %s <#item> <#threads>\n", argv[0]);
        exit(1);
    }
    g_nItems = MIN(atoi(argv[1]), MAX_N_ITEMS);
    nThreads = MIN(atoi(argv[2]), MAX_N_THREADS);

	if (pthread_setconcurrency(nThreads + 1) != 0)
    {
        printf("set thread concurrency failed\n");
        exit(1);
    }

    time_t time1, time2;
    time1 = time((time_t *) NULL);
    /* start all the producer threads and one consumer thread */
    for (i = 0; i < nThreads; i++)
    {
        count[i] = 0;
        pthread_create(&tid_produce[i], NULL, produce, &count[i]);
    }
    pthread_create(&tid_consume, NULL, consume, NULL);
   
    /* wait for all the producer threads and the consumer */
    for (i = 0; i < nThreads; i++)
    {
        pthread_join(tid_produce[i], NULL);
        printf("count[%d] = %d\n", i, count[i]);
    }
    pthread_join(tid_consume, NULL);

    time2 = time((time_t *) NULL);
    printf("%d producer and 1 consumer handle %d data, use %.2f s\n", nThreads, g_nItems, difftime(time2, time1));

    exit(0);
}

static void *produce(void *arg)
{
    while (1)
    {
        pthread_mutex_lock (&g_shared.mutex);

        if (g_shared.nPut >= g_nItems)
        {
            pthread_mutex_unlock(&g_shared.mutex);
            
            return (NULL); // array is full, we are done
        }
        g_shared.buff[g_shared.nPut] = g_shared.nVal;
        g_shared.nPut++;
        g_shared.nVal++;

        pthread_mutex_unlock(&g_shared.mutex);
        *((int *) arg) += 1;
    }

}

static void consume_wait(int i)
{
    while (1)
    {
        pthread_mutex_lock(&g_shared.mutex);
        if (i < g_shared.nPut)
        {
            pthread_mutex_unlock(&g_shared.mutex);
            return ; // an item is ready
        }
        pthread_mutex_unlock(&g_shared.mutex);
    }
}

static void *consume(void *arg)
{
    int i = 0;
    for (i = 0; i < g_nItems; i++)
    {
        consume_wait(i);
        if (g_shared.buff[i] != i)
        {
            printf("buff[%d] = %d\n", i, g_shared.buff[i]);
        }
    }

    return (NULL);
}

启动3个生产者线程生产一千万条数据：

对于消费者线程来说，每次消费一条数据都要取询问数据是否准备好，若数据还在准备，就要不停的询问。这种轮询方式比较耗费cpu资源，应该修改为数据准备好后，唤醒消费者线程（引入条件变量）。

多生产者-单消费者 (条件变量)

例子说明：将生产者相关的变量和互斥锁组合到一个结构体中，把计数器、条件变量和互斥锁组合到另一个结构体中。
生产者每生产一条数据后，检查计数器nready是否为0，若nready==0，则唤醒消费者线程，然后将计数器nready加1。
消费者每消费一条数据前，都要检查计数器nready是否为0，若nready==0，则线程投入睡眠并等待唤醒信号。

prodscons_mutex_cond.c

/*
 * @Description: consider between producer threads and consumer synchronization.
 * when producer threads started, the consumer start right now.
 * @Author: caojun
 * @version: 
 * @Date: 2023-10-13 10:01:24
 * @LastEditors: caojun
 * @LastEditTime: 2023-10-13 10:31:11
 */

//==============================================================================
// Include files
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>

//==============================================================================
// Constants
#define MAX_N_ITEMS     100000000
#define MAX_N_THREADS   100

#define MAX(a,b) ((a)>(b) ? (a):(b)) 
#define MIN(a,b) ((a)<(b) ? (a):(b))
//==============================================================================
// types
struct PUT_ST
{
    pthread_mutex_t mutex;
    int nPut; // next index to store
    int nVal; // next value to store
};

struct READY_ST
{
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    int nready; // number ready for consumer
};
//==============================================================================
// global varibles

static int g_nItems; // read-only by producer and consumer
static int g_buff[MAX_N_ITEMS];
static struct PUT_ST g_put = {PTHREAD_MUTEX_INITIALIZER};
static struct READY_ST g_ready = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER};

//==============================================================================
// global functions

static void *produce(void *arg);
static void *consume(void *arg);

//==============================================================================
// The main entry-point function.

int main(int argc, char **argv)
{
    int i = 0, nThreads = 0;
    int count[MAX_N_THREADS] = {0};
    pthread_t tid_produce[MAX_N_THREADS] = {0};
    pthread_t tid_consume = 0;

    if (argc != 3)
    {
        printf("usage: %s <#item> <#threads>\n", argv[0]);
        exit(1);
    }
    g_nItems = MIN(atoi(argv[1]), MAX_N_ITEMS);
    nThreads = MIN(atoi(argv[2]), MAX_N_THREADS);

	if (pthread_setconcurrency(nThreads + 1) != 0)
    {
        printf("set thread concurrency failed\n");
        exit(1);
    }

    time_t time1, time2;
    time1 = time((time_t *) NULL);
    /* start all the producer threads and one consumer thread */
    for (i = 0; i < nThreads; i++)
    {
        count[i] = 0;
        pthread_create(&tid_produce[i], NULL, produce, &count[i]);
    }
    pthread_create(&tid_consume, NULL, consume, NULL);
   
    /* wait for all the producer threads and the consumer */
    for (i = 0; i < nThreads; i++)
    {
        pthread_join(tid_produce[i], NULL);
        printf("count[%d] = %d\n", i, count[i]);
    }
    pthread_join(tid_consume, NULL);

    time2 = time((time_t *) NULL);
    printf("%d producer and 1 consumer handle %d data, use %.2f s\n", nThreads, g_nItems, difftime(time2, time1));

    exit(0);
}

static void *produce(void *arg)
{
    while (1)
    {
        pthread_mutex_lock (&g_put.mutex);
        if (g_put.nPut >= g_nItems)
        {
            pthread_mutex_unlock(&g_put.mutex);
            
            return (NULL); // array is full, we are done
        }
        g_buff[g_put.nPut] = g_put.nVal;
        g_put.nPut++;
        g_put.nVal++;
        pthread_mutex_unlock(&g_put.mutex);

        pthread_mutex_lock(&g_ready.mutex);
        if (g_ready.nready == 0)
        {
            pthread_cond_signal(&g_ready.cond);
        }
        g_ready.nready++;
        pthread_mutex_unlock(&g_ready.mutex);

        *((int *) arg) += 1;
    }
}

static void *consume(void *arg)
{
    int i = 0;
    for (i = 0; i < g_nItems; i++)
    {
        pthread_mutex_lock(&g_ready.mutex);
        while (g_ready.nready == 0)
        {
            pthread_cond_wait(&g_ready.cond, &g_ready.mutex);
        }
        g_ready.nready--;
        pthread_mutex_unlock(&g_ready.mutex);
        if (g_buff[i] != i)
        {
            printf("buff[%d] = %d\n", i, g_buff[i]);
        }
    }

    return (NULL);
}

启动3个生产者，生产1千万条数据：

参考引用

UNIX网络编程 卷2 进程间通信 第2版 【Richard Stevens】

w18478272407
关注
  • 23
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux下多线程编程的互斥与同步
07-31
本文将说明如何使用信号量实现线程之间的互斥与同步。互斥锁只有0，1两中状态，适合于线程对共享资源的独占访问，很多时候每个资源可以同时被有限的线程访问，此时互斥锁将无法满足；条件变量同步也同样存在这种问题。信号量实际是一种非负整型计数器，可以很好的控制线程之间资源访问，互斥锁能实现的功能，信号量同样可以。
MFC多线程 信号量CSemaphore 临界区与互斥 事件
chenhao0568的专栏
06-23 580
CMutex, CCriticalSection用于对资源的互斥访问。 CMutex可以跨进程使用, CCriticalSection只可以在进程内部使用。 创建CMutex需要更多的资源，只用于进程内部时使用CCriticalSection获得更高的效率。
C++多线程中的锁和条件变量使用教程
08-26
主要介绍了C++多线程中的锁和条件变量使用,非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下
多线程并发编程-同步与互斥-原⼦变量-并发和⽆锁 数据结构
12-30
多线程并发编程-同步与互斥-原⼦变量-并发和⽆锁 数据结构
VC++如何使用互斥量创建进程
11-05
VC如何使用互斥量创建进程,教你如何使用互斥量,新手学习可下载参考.VC如何使用互斥量创建进程,教你如何使用互斥量,新手学习可下载参考.
MFC 实现的进程的互斥与同步
06-10
MFC 实现的进程的互斥与同步
MFC多线程互斥锁的使用
phenixyf的专栏
04-04 869
这是未加互斥锁的情况下，程序中，我们在线程1将n赋值为1并在EDIT1显示；理论上控件上应分别显示1和-1，但实际上，会出现同时显示1，或同时显示-1或显示-1和1的情况。这是由于线程间同时调用同一变量造成的（严格来讲并不是同时，而是比如线程1赋值为1后还没打印出来就被线程2赋值为-1了，所以造成最后打印出来都是-1，其他情况同理）。这样在一个线程的运行周期内，其他线程就无法更改变量。8.修改后编译运行，可以看到使用互斥锁后，程序按预想的形式运行，EDIT1稳定的显示1，EDIT2稳定的显示-1。
MFC线程(三):线程同步事件(event)与互斥(mutex)
沐 白
01-02 1059
前面讲了临界区可以用来达到线程同步.而事件(event)与互斥(mutex)也同样可以做到.   Win32 API中的线程事件 HANDLE hEvent = NULL;   void MainTestFun{ hEvent = CreateEvent(NULL,FALSE,FALSE,NULL); SetEvent(hEvent);   char g_charArray[4];...
一个多进程互斥的例子
10-23
多进程互斥，使用CreatMutex创建互斥量啦实现的例子。
VC++ 利用MFC类创建互斥对象
03-15
内容索引:VC/C++源码,其它分类,MFC,互斥　　VC++ 使用MFC类创建互斥对象，通过这个小程序，你可以了解到声明线程函数、定义全局互斥对象、定义线程句柄、创建线程、程序睡眠、锁定互斥对象、变量自加、线程睡眠、释放互斥对象、线程正常退出等相关基础知识。
多线程编程-使用同步对象编程
03-02
1、互斥锁（mutex）2、条件变量(conditionvariable)3、多读单写锁(multi-read,single-writelock)4、信号量(semophore)5、进程间同步(processsynchronization)6、同步原语的比较(compareprimitive)同步对象是内存中的...
如何实现一个百万并发量的TCP服务器
Hensonli的博客
09-07 1031
朋友问我：你现在年薪百万吗？我说：我没有，倒是并发量超百万的服务器可以有（坏笑）。实现一个并发量超一百万的TCP服务器使用epoll获取请求+线程池处理请求四台虚拟机（一个服务端以及三个服务端） 服务端硬件配置要求：双核处理器，4G运行内存 客服端硬件配置要求：单核处理器，2G运行内存 虚拟机运行操作系统：ubuntu server 64位 虚拟机软件：VMware Fusion 操作系统：macOS
C++之线程同步之条件变量和互斥锁的使用
FairLikeSnow的博客
05-04 534
对于多线程的使用可以看看我以前的文章： 这篇文章主要说说线程同步的条件变量和互斥锁在线程中结合的使用，先看看几个概念 条件变量：是一种线程同步机制，条件变量允许线程睡眠，直到满足条件，当满足条件时，可以向该线程发信号，通知唤醒。 互斥锁: 互斥锁用于控制多个线程对他们之间共享资源互斥访问的一个信号量。也就是说是为了避免多个线程在某一时刻同时操作一个共享资源。 为了防止竞争，条件变量的使用总是和一个...
Boost条件变量condition_variable_any的notify_one和wait与mfc中CEvent和WaitForSingleObject区别
12-10 3577
假设有两个线程，一个线程等待事件，一个线程触发事件。 使用CEvent类，我们可以在WaitForSingleObject执行前触发事件,  WaitForSingleObject都会立即返回。 而使用条件变量的notify_one在wait执行前触发事件触发事件是没有效果的，当执行到wait时仍然会阻塞。 主要区别在于对状态的保存，CEvent会保存状态，条件变量不会，但可以通过对
【译】剖析MFC多线程程序的同步机制
weixin_33924312的博客
06-27 104
  原文链接：Synchronization in Multithreaded Applications with MFC     简介 本文探讨基本的同步概念，并实际动手帮助新手掌握多线程编程。本文的重点在各种同步技巧。 基本概念 在线程执行过程中，或多或少都需要彼此交互，这种交互行为有多种形式和类型。例如，一个线程在执行完它被赋予的任务后，通知另一个线程任务已经完成。然后第二个...
守护进程，进程的互斥锁，进程间的通信，生产者消费者模型
boteman123的博客
07-12 173
一：守护进程        1，守护进程介绍：                    守护进程其实就是一个子进程                    守护====》》伴随                    守护进程会伴随主进程的代码运行完毕后而自动死掉        2，为何用守护模型，关键子就两个进程和守护                    进程：当父进程需要将一个任务并发出去执行，需...
C++教学——从入门到精通 10.循环
最新发布
QIPABOSHI的博客
04-24 368
一些事嘛，需要重复做，这就是循环在开始学之前我提一个事，最好先学Python再学C++，不然就会像我和piaojunhe_0825一样有C++后遗症，在Python里写了一个for(int i=0;i
【C】 初识C语言
努力学习C/C++
04-21 770
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
多线程编程解决进程间同步和互斥问题
06-09
在多线程编程中，多个线程可以同时运行，但是它们可能需要访问...总之，使用信号量、互斥锁和条件变量等方法可以有效地解决多线程编程中的同步和互斥问题。但是，在使用这些方法时，需要注意避免死锁和竞态条件等问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值