linux进程间通信之msgq

最新推荐文章于 2023-11-02 17:13:41 发布
最新推荐文章于 2023-11-02 17:13:41 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： linux c linux 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaozhi0810/article/details/126630876
版权

这次项目中关于进程间通信的部分我一般都采用了msgq，一般信息数据量都不是很大。

一、简述一下项目的需求部分：

1. api与server端进行相互通信。

2. server对不同的api接口做出应答，并且api能够识别出是应答哪个接口。

3.api等待超时，这里考虑到server端故障或者已经退出等等异常情况，api应该采取一些措施，避免死等而造成假死现象。

4.代码原文，请翻到文末。

5.本代码在api端和server端都可以使用

项目完整代码，请参考github

二、代码分步讲解

1.  magq的数据组成，h文件中声明

typedef struct  //消息结构体
{
    long types;    //指定消息的类型
    int cmd;       //消息的命令
    int param1;    //参数1
    int param2;    //参数2
    int ret;       //参数3，可用于返回值
}msgq_t; 

由于我本身需要发送的信息并不是很多，就定义了一个这样的结构体，主要还是cmd其主要作用，我以此区分是什么api的请求（或者是什么样的功能）。 

注意：types是本身msgq的要求。必须为long类型。

2. 初始化

参数，无

返回值，0表示成功，其他表示失败

//返回值0表示成功，其他表示失败
int msgq_init(void)
{
    key_t key;
    
    key = ftok(KEY_PATH,KEY_ID);  //获取key值
    if(key < 0)
    {
        printf("ftok fail \n");
        fflush(stdout);
        return (-EAGAIN);
    }
    // 创建消息队列，如果消息队列存在，errno 会提示 eexist
    // 错误，此时只需要直接打开消息队列即可
    msgid = msgget(key,IPC_CREAT|IPC_EXCL|0666);
    if(msgid < 0)
    {
        if(errno == EEXIST) //文件存在错误提示
        {
            msgid = msgget(key,0666);//打开消息队列
            MsgClear();
        }
        else //其他错误退出
        {
            printf("msgget fail \n");
            return(-EAGAIN);
        }
    }
    //printf("msgget success!! msgid = %d\n",msgid);
    return 0;
}

进程间通信，系统中两个进程是互不可见的，那如何找到对方呢？那就是要使用唯一的口令key，来保障通信双方。

ftok 本身没有在内核（系统）中产生什么东西，只是根据传入的参数，计算了一个数据（使它尽量产生的数据是唯一的）。

msgget 将是使用ftok的数据去打开或者创建一个msgq的消息队列。IPC_EXCL存在时报错，但是我对错误进行了处理，EEXIST表示文件存在错误，这时再次尝试去打开就好。

打开成功，就返回0.

程序运行后，可以使用ipcs -q 命令查看系统中的msgq的信息。除非手动（命令或者调用函数）删除，直到系统关闭比之前，是会一直存在的。

3.发送

参数1：ack_types 表示接收（等待应答用）的消息类型

参数2：需要发送的消息

参数3：用于设置超时，0表示阻塞模式，非零则有超时时间

系统调用msgsnd 的第三个参数，消息的字节数应该要减去type的字节数。

//发送消息，并且要等待应答。
参数 timeout 大于0时，设置接收应答超时时间（50ms的整数倍），等于0表示阻塞模式
//     ack_types 指定应答的类型，之前是TYPE_RECV+cmd
//     msgbuf 发送消息的缓存，1次发送一条消息
//返回0表示成功，其他表示失败
//注意，函数使用时，需要指定msgbuf->types ！！！！
int msgq_send(long ack_types,msgq_t *msgbuf,int timeout)
{
    int ret = -EBUSY;  //初始值
//    int cmd = msgbuf->cmd;

    if(msgid == -1) //未初始化
    {
        printf("send error,msgq_init first!!!\n");
        fflush(stdout);
        return -EPERM;
    }

    //msgbuf->types = TYPE_SEND; //给消息结构赋值，发送的类型是固定的TYPE_SEND
    //printf("debug: send type = %ld cmd = %d b = %d c = %d rt = %d\n",msgbuf->types,msgbuf->cmd,msgbuf->param1,msgbuf->param2,msgbuf->ret);
    //发送消息
    if(msgsnd(msgid, msgbuf, sizeof(msgq_t)-sizeof(long),0) == 0)
    {
    //    printf("debug:msgsnd ok \n");
        //等待应答，等待的类型跟命令有关！！！！！
        ret =  msgq_recv(ack_types,msgbuf,timeout);
        if(ret == 0)    //正常在这返回0，仍然可能不是0. 
        {
    //        printf("msgq_send and recv ok!!msgbuf.ret = %d\n",msgbuf->ret);
            //用param1返回数据
            return 0;
        }
    }  
    printf("msgsnd error!\n"); //这条路应该还是有问题的。打印一下错误提示
    fflush(stdout);
    return ret;   // 返回错误值
}

4.接收

参数1：ack_types 表示接收的消息类型

参数2：接收消息的缓存

参数3：用于设置超时，0表示阻塞模式，非零则有超时时间

//接收消息
//参数 timeout_50ms 大于0时，表示非阻塞模式，等待的时间为timeout_50ms*50ms的值，等于0表示阻塞模式
//     types 接收消息的类型
//     msgbuf 接收消息的缓存，1次接收一条消息
//返回0表示成功，其他表示失败
int msgq_recv(long types,msgq_t *msgbuf,unsigned int timeout_50ms)
{
    int recv_flg = 0;    
    int ret;
//    int retry = 0;

    if(msgid == -1) //未初始化
    {
        printf("recv error,msgq_init first!!!\n");
        fflush(stdout);
        return -EPERM;
    }

    if(timeout_50ms > 0)
        recv_flg = IPC_NOWAIT;

    //接收消息
    do{
        ret = msgrcv(msgid, msgbuf, sizeof(msgq_t)-sizeof(long),types,recv_flg);  //防止死循环
        if(ret >= 0)
            break;
        else if(0 == recv_flg) //阻塞堵塞模式出问题
        {
            if(errno == EINTR)
                continue;
            return -EINTR;
        }
        else if(errno != ENOMSG)
        {
            printf("msgrcv\n");
            fflush(stdout);
            return -ENOMSG;
        }    

        usleep(50000);   //休眠50ms       
    }while(--timeout_50ms);
    
    if(recv_flg && (0 == timeout_50ms))   //超时,可能设置为等待模式
    {
        printf("ERROR:msg recv wait timeout,recv type = %ld!!!\n",types);
        fflush(stdout);        
        return -EAGAIN;
    }
    
//    printf("type = %ld cmd = %d b = %d c = %d rt = %d\n",msgbuf->types,msgbuf->cmd,msgbuf->b,msgbuf->c,msgbuf->ret);
//    fflush(stdout);
    return 0;
}

5.应答，一般用于服务端对api的应答

参数：消息对应的缓存

//发送应答消息消息，不等待应答。
int msgq_send_ack(msgq_t *msgbuf)
{
    if(msgid == -1) //未初始化
    {
        printf("send error,msgq_init first!!!\n");
        fflush(stdout);
        return -1;
    }

    //msgbuf->types = TYPE_SEND; //给消息结构赋值，发送的类型是固定的TYPE_SEND
//    printf("send type = %ld cmd = %d b = %d c = %d rt = %d\n",msgbuf->types,msgbuf->cmd,msgbuf->b,msgbuf->c,msgbuf->ret);
    //发送消息
    if(msgsnd(msgid, msgbuf, sizeof(msgq_t)-sizeof(long),0) == 0)
    {        
        return 0;    
    }  

    printf("msgsnd error!\n"); //这条路应该还是有问题的。打印一下错误提示
    fflush(stdout);
    return -1; 
}

三、代码全文

c.的全文

/*
* @Author: dazhi
* @Date:   2022-07-27 09:57:14
* @Last Modified by:   dazhi
* @Last Modified time: 2022-08-16 15:02:16
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
//#include "drv_22134.h"
#include <utmp.h>
#include <time.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <errno.h>

#include "my_ipc_msgq.h"  //用于与串口程序通信！！
//用户创建消息队列的关键字
#define KEY_PATH "/proc/cpuinfo"
#define KEY_ID -123321




static int msgid = -1;  //消息队列的描述符


static int MsgClear(void)
{
	msgq_t msgbuf;

	if(msgid == -1)
		return -EPERM;

	while( msgrcv(msgid, &msgbuf, sizeof(msgbuf)-sizeof(long),0,IPC_NOWAIT) >0) ;  //关闭的时候把所有的消息都清除掉
    
	return 0;
}



//返回值0表示成功，其他表示失败
int msgq_init(void)
{
	key_t key;
    
    key = ftok(KEY_PATH,KEY_ID);  //获取key值
    if(key < 0)
    {
        printf("ftok fail \n");
        fflush(stdout);
        return (-EAGAIN);
    }
    // 创建消息队列，如果消息队列存在，errno 会提示 eexist
    // 错误，此时只需要直接打开消息队列即可
    msgid = msgget(key,IPC_CREAT|IPC_EXCL|0666);
    if(msgid < 0)
    {
        if(errno == EEXIST) //文件存在错误提示
        {
            msgid = msgget(key,0666);//打开消息队列
            MsgClear();
        }
        else //其他错误退出
        {
            printf("msgget fail \n");
            return(-EAGAIN);
        }
    }
    //printf("msgget success!! msgid = %d\n",msgid);
    return 0;
}



//返回值0表示成功，其他表示失败
int msgq_exit(void)
{
	MsgClear();   //清楚消息队列中的消息
	return 0;
}


//接收消息
//参数 timeout_50ms 大于0时，表示非阻塞模式，等待的时间为timeout_50ms*50ms的值，等于0表示阻塞模式
//     types 接收消息的类型
//     msgbuf 接收消息的缓存，1次接收一条消息
//返回0表示成功，其他表示失败
int msgq_recv(long types,msgq_t *msgbuf,unsigned int timeout_50ms)
{
	int recv_flg = 0;	
	int ret;
//	int retry = 0;

	if(msgid == -1) //未初始化
	{
		printf("recv error,msgq_init first!!!\n");
		fflush(stdout);
		return -EPERM;
	}

	if(timeout_50ms > 0)
		recv_flg = IPC_NOWAIT;

    //接收消息
    do{
	    ret = msgrcv(msgid, msgbuf, sizeof(msgq_t)-sizeof(long),types,recv_flg);  //防止死循环
	    if(ret >= 0)
	    	break;
	    else if(0 == recv_flg) //阻塞堵塞模式出问题
	    {
			if(errno == EINTR)
				continue;
			return -EINTR;
		}
	    else if(errno != ENOMSG)
	    {
	    	printf("msgrcv\n");
	    	fflush(stdout);
	    	return -ENOMSG;
	    }	

	    usleep(50000);   //休眠50ms	   
    }while(--timeout_50ms);
    
    if(recv_flg && (0 == timeout_50ms))   //超时,可能设置为等待模式
    {
    	printf("ERROR:msg recv wait timeout,recv type = %ld!!!\n",types);
		fflush(stdout);		
    	return -EAGAIN;
    }
    
//    printf("type = %ld cmd = %d b = %d c = %d rt = %d\n",msgbuf->types,msgbuf->cmd,msgbuf->b,msgbuf->c,msgbuf->ret);
//	fflush(stdout);
	return 0;
}



//发送消息，并且要等待应答。
参数 timeout 大于0时，设置接收应答超时时间（50ms的整数倍），等于0表示阻塞模式
//     ack_types 指定应答的类型，之前是TYPE_RECV+cmd
//     msgbuf 发送消息的缓存，1次发送一条消息
//返回0表示成功，其他表示失败
//注意，函数使用时，需要指定msgbuf->types ！！！！
int msgq_send(long ack_types,msgq_t *msgbuf,int timeout)
{
	int ret = -EBUSY;  //初始值
//	int cmd = msgbuf->cmd;

	if(msgid == -1) //未初始化
	{
		printf("send error,msgq_init first!!!\n");
		fflush(stdout);
		return -EPERM;
	}

	//msgbuf->types = TYPE_SEND; //给消息结构赋值，发送的类型是固定的TYPE_SEND
	//printf("debug: send type = %ld cmd = %d b = %d c = %d rt = %d\n",msgbuf->types,msgbuf->cmd,msgbuf->param1,msgbuf->param2,msgbuf->ret);
    //发送消息
    if(msgsnd(msgid, msgbuf, sizeof(msgq_t)-sizeof(long),0) == 0)
    {
    //	printf("debug:msgsnd ok \n");
    	//等待应答，等待的类型跟命令有关！！！！！
    	ret =  msgq_recv(ack_types,msgbuf,timeout);
    	if(ret == 0)    //正常在这返回0，仍然可能不是0. 
    	{
    //		printf("msgq_send and recv ok!!msgbuf.ret = %d\n",msgbuf->ret);
    		//用param1返回数据
			return 0;
		}
    }  
    printf("msgsnd error!\n"); //这条路应该还是有问题的。打印一下错误提示
    fflush(stdout);
    return ret;   // 返回错误值
}





//发送应答消息消息，不等待应答。
int msgq_send_ack(msgq_t *msgbuf)
{
	if(msgid == -1) //未初始化
	{
		printf("send error,msgq_init first!!!\n");
		fflush(stdout);
		return -1;
	}

	//msgbuf->types = TYPE_SEND; //给消息结构赋值，发送的类型是固定的TYPE_SEND
//	printf("send type = %ld cmd = %d b = %d c = %d rt = %d\n",msgbuf->types,msgbuf->cmd,msgbuf->b,msgbuf->c,msgbuf->ret);
    //发送消息
    if(msgsnd(msgid, msgbuf, sizeof(msgq_t)-sizeof(long),0) == 0)
    {    	
		return 0;	
    }  

    printf("msgsnd error!\n"); //这条路应该还是有问题的。打印一下错误提示
    fflush(stdout);
    return -1; 
}

h文件全文

/*
* @Author: dazhi
* @Date:   2022-07-27 09:57:14
* @Last Modified by:   dazhi
* @Last Modified time: 2022-07-27 10:19:48
*/


#ifndef __MY_IPC_SMGQ_H__
#define __MY_IPC_SMGQ_H__


//用户创建消息队列的关键字
#define KEY_PATH "/proc/cpuinfo"
#define KEY_ID -123321

typedef struct  //消息结构体
{
    long types;    //指定消息的类型
    int cmd;       //消息的命令
    int param1;    //参数1
    int param2;    //参数2
    int ret;       //参数3，可用于返回值
}msgq_t; 



enum API_CMD_types{
	eAPI_LEDSET_CMD = 0,   //设置led
	eAPI_LEDGET_CMD,         //获取led状态
	eAPI_LEDSETALL_CMD,      //设置所有的led
	eAPI_LEDGETALL_CMD,      //获取所有的led
	eAPI_BTNGET_CMD,         //获取按键（没有使用）
	eAPI_BTNEVENT_CMD,       //等待按键事件（没有使用）
	eAPI_LCDONOFF_CMD,       //lcd开启关闭事件
	eAPI_LEDSETPWM_CMD,      //led设置亮度
	eAPI_BOART_TEMP_GET_CMD,  //获得单片机的温度
	eAPI_CHECK_APIRUN_CMD,  //检测api是否已经运行
	eAPI_HWTD_SETONOFF_CMD,   //开门狗设置开关
	eAPI_HWTD_FEED_CMD ,      //看门狗喂狗
	eAPI_HWTD_SETTIMEOUT_CMD,    //设置看门狗喂狗时间
	eAPI_HWTD_GETTIMEOUT_CMD,    //获取看门狗喂狗时间
	eAPI_RESET_COREBOARD_CMD,  //复位核心板
	eAPI_RESET_LCD_CMD,        //复位lcd 9211（复位引脚没有连通）
	eAPI_RESET_LFBOARD_CMD,    //复位底板，好像没有这个功能！！！
	eAPI_MICCTRL_SETONOFF_CMD//,    //控制底板mic_ctrl引脚的电平
};





//返回值0表示成功，其他表示失败
int msgq_init(void);


//返回值0表示成功，其他表示失败
int msgq_exit(void);

//接收消息
//参数 timeout_50ms 大于0时，表示非阻塞模式，等待的时间为timeout_50ms*50ms的值，等于0表示阻塞模式
//     types 接收消息的类型
//     msgbuf 接收消息的缓存，1次接收一条消息
//返回0表示成功，其他表示失败
int msgq_recv(long types,msgq_t *msgbuf,unsigned int timeout_50ms);



//发送消息，并且要等待应答。
参数 timeout 大于0时，设置接收应答超时时间，等于0表示阻塞模式
//     ack_types 指定应答的类型，之前是TYPE_RECV+cmd
//     msgbuf 发送消息的缓存，1次发送一条消息
//返回0表示成功，其他表示失败
//注意，函数使用时，需要指定msgbuf->types ！！！！
int msgq_send(long ack_types,msgq_t *msgbuf,int timeout);


//发送应答消息消息，不等待应答。
int msgq_send_ack(msgq_t *msgbuf);



#endif

大智兄
关注
专栏目录
【Linux】进程间通信（IPC）之消息队列详解及测试用例
chuoxi9418的博客
07-23 633
操作系统内的并发执行进程可以是独立的也可以是协作的： 如果一个进程不能影响其他进程或受其他进程影响，那么该进程是独立的，换句话说，不与任何其他进程共享数据的进程是独立的； 如果一个进程能影响其他进程或受其他进程所影响，那么该进程是协作的。换句话说，与其他进程共享数据的进程为协...
进程间通信之消息队列
南极熊club的博客
11-09 437
进程间通信之消息队列概述特性消息队列API创建与打开关闭删除属性消息接收与发送消息通知编程示例结束语推荐阅读 自信、冷静、专注。 —— TM熊的自我勉励 本文只对POSIX标准的消息队列进行介绍，相对常用一些。 概述 不同于前两章介绍的管道和FIFO，消息队列更加灵活，功能更丰富一些，因此在实际应用中，消息队列的使用频率高得多。 特性 可用于任意进程之间通信； 消息队列和它的名称一样，类似一个队列，任意的进程都可以往其中写入，也可以读出，而管道只能一端读，一端写； 生命周期更长，对于管道
linux进程间通信之Msgq
lc的大脑备份
03-18 4876
消息队列是进程间通信方式之一，该文章讲解如何使用消息队列。
msgq:System V消息队列（IPC）Python扩展
05-15
msgq：系统V IPC消息队列Python扩展模块 此扩展包装和使与System V消息队列相关的系统调用可用于Python应用程序。 公开了以下系统调用： ftok：将路径名和项目标识符转换为System V IPC密钥 msgget：获取消息队列标识符 msgsnd：将消息发送到队列 msgrcv：从队列接收消息 msgctl：消息控制操作 有关系统调用的更多信息，请访问您的手册页。 这个想法是Python对象通过消息队列在进程之间传递。 您希望传递的对象必须支持“腌制”。 这是一个例子： >>> import msgq >>> key = msgq.ftok("msgq.so", 42) >>> ID = msgq.msgget(key, 0666 | msgq.IPC_CREAT) >>> msgq.msgsnd(ID, 0, (1,2, {'foo' : 'bar'}))
linux IPC机制之msg q学习
04-08 549
回顾一下，linux系统的IPC机制有： pipe/FIFO/signal/temp file/semaphore/shared memeory以及message queue等。 本文要讲的是其中的一种IPC机制：message queue。 message queue就是两个进程之间创建的一个消息队列用于发送和接受消息。 发送者和接收者通过message queue通信时，无需同时运行。
【消息队列】消息队列（Message Queues)与进程通信
crr411422的博客
06-29 1342
消息队列作为一种IPC机制，它提供了进程间发送和接收消息的强大功能。通过使用消息队列，可以构建复杂的多进程应用程序，实现数据的安全传输和有序交流，从而极大地提高了系统的并发处理能力。但，也要意识到消息队列的限制，比如队列的大小、存储消息的总数量等，它们都可能会对应用程序的性能产生影响。 因此，在使用消息队列时，我们需要权衡其优点和潜在的挑战，确保在满足业务需求的同时，能保持高效的性能和稳定的运行。
进程间通信之消息队列msg queue
yilonglucky
04-13 1580
消息message是一个格式化的可变长信息单位。消息机制允许一个进程向任何其他进程发送一个消息。本质上，消息队列很像是内核维护的一个信箱，任何进程都可以向内核发送一封信，这个信包括消息的类型（用long型表示），和消息的内容（char型数组）。任何进程通过IPC对象标识符，就可以向指定的信箱发送消息。类似的，任何进程可以通过IPC对象标识符，来从信箱中收取指定类型的消息。这里的任何进程，是指具有访问
MsgQ机制，实现H5游戏的模块彻底分离
syfolen的博客
12-21 550
这是绝对是个好东西！！！ 做捕鱼时，有种心得，就是感觉puremvc真的只适合用来开发表现层，做做界面之类的东西，想以它作为整个游戏架构的支撑，是行不通的，因为会存在很多诟病。所以在项目接近收尾的时候，我就一直在思考如何对H5游戏中的模块进行彻底解耦。 在另一篇博文中我己提到了项目的三层结构，但层归层，分层不等于分模块，如果想要降低项目维护的风险，除了分层，合理的模块化也很重要，尤其在一个多人...
linux下进程间通信--消息队列
02-20
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是多个进程之间共享数据、交换信息的关键技术。其中，消息队列是一种高效且灵活的IPC机制，它允许进程将固定大小的消息发送到一个公共队列，其他...
linux进程间通信之消息队列
renrenhappy的专栏
09-03 6921
<br />        上周因课题的需要，写了一个进程间使用消息队列通信的程序。之所以，用因为消息队列是随内核存在的，即使进程退出它仍然存在 。消息队列的这种特点正适合我的需要。下面是来自CSDN博客上的一篇文章，转自http://blog.csdn.net/liranke/archive/2010/05/19/5608686.aspx<br />1. 基本概念<br />消息队列的最佳定义是：内核地址空间中的内部链表。消息可以顺序地发送到队列中，<br />并以几种不同的方式从队列中获取。当然，每个
进程间通信之消息队列和共享内存
Beginner_zero的博客
03-23 2324
消息队列之前我们解析了一下进程间通信的管道通信，今天我们来看一下另外俩种通信方式：消息队列和共享内存。那什么是消息队列呢？之前我们说管道在进程间通信的时候是基于字节流的，而消息队列在进程间通信的时候是基于数据块的，并且是有类型的数据块。消息队列提供了一个从一个进程向另外一个进程发送一个有不同类型值的数据块的方法。每个消息队列都有一个msqid_ds 结构与其相关联，在/usr/include/li...
进程（三）：进程间通讯：消息队列
Linux
08-15 318
消息对列
DSP- 6678---------messageQ的使用
阳光非宅男的博客
07-02 3623
MessageQ模块：主核（核0）在将图像文件输入共享内存后，需要将输入图像缓存和输出图像缓存的地址打包成消息，传递给从核。总之，MessageQ是用来传递少量信息的，一般是地址，标志位之类的参数，不是传递大规模数组用的。对于大规模的数组，可以利用messageQ传递其首地址。 MessageQ模块的主要特点： 1. 实现了处理期间变长消息的传递，所需要传递的消息一般超过32bi...
Linux进程间通信：消息队列
m0_51707118的博客
04-27 96
【代码】Linux进程间通信：消息队列。
linux进程间通信-----System V消息队列总结实例
Be The Best！
12-17 2992
linux进程间通信-----消息队列总结实例
FreeRTOS 队列
APTCHIP的博客
11-02 108
freeRTOS 队列管理，API函数
进度条——fflush(stdout)理解使用
poison_biti的博客
09-19 2867
运行结果展示 “test.c” #include #include void proc() { int i = 0; char proc_buf[102]; const char* latle = "|/-\\"; memset(proc_buf,'\0',sizeof(proc_buf)); while(i <= 100) { printf("[%-100s][
Redhat Linux---rpm 命令详解
编程语言小筑
03-23 206
转载1 什么是rpm？rpm是RPM package manager的缩写，最早由RedHat公司提出的软件包标准，后来随着rpm的不断发展而又增加许多功能，逐渐的成为linux公认的软件包管理标准。支持该格式的厂商有RedHat linux、suse linux、Mandriva linux。 rpm命令十分强大，那么rpm命令究竟有什么功能呢？ 1 查询已安装在linux系统中的rp...
记录fork子进程执行execl阻塞卡死的问题
duapple的博客
09-18 710
上面的函数是一个线程执行函数，调用这个函数，有概率会出现阻塞的情况。网上翻了一下资料，造成这个的原因是产生了死锁。因为我使用了自己的日志库，日志库里面有互斥锁用来保证输入数据的一致性。当父进程中的线程有调用日志打印函数时，会对互斥锁上锁，在还未解锁的情况，如果这时刚好fork子进程成功，并在子进程中执行日志打印函数的话，这个时候就会发生上面的所说的情况。
Linux进程通信实验
最新发布
06-20
在Linux中，进程通信是一种让不同进程之间交换数据或协调操作的方式。常见的进程间通信（Inter-Process Communication, IPC）方法包括： 1. **管道（Pipes）**：通过文件描述符在父进程和子进程间创建无名管道，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大智兄

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值