Linux 多线程通信.全局变量，结构体，队列，项目模版（一）

原创 已于 2024-08-14 16:30:39 修改 · 186 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C语言 #队列 #linux

于 2021-10-28 15:15:38 首次发布
这是一个使用C语言实现的帧队列管理程序，包括打开、关闭、发送、接收、中止和清空队列的函数。通过互斥锁实现线程安全的帧数据通信，适用于多线程环境中的数据交换。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、使用全局变量，结构体，队列进行通信，

多线程共用地址空间，全局变量，定义一个大容器结构体，装所有数据，自定义一个队列，数据类型是结构体类型。

1、Frame_Queue.h

#ifndef QUEUE_Frame_H_
#define QUEUE_Frame_H_

#define MAX_PKT_NUM 1500

#pragma pack(1)
typedef struct Frame_Pkt
{
	SX_U16	u16SyncHead;		
	SX_U8		u8Cmd;
	SX_U8	data[1500];
} T_Frame_Pkt, *PT_Frame_Pkt;
#pragma pack()

typedef struct QUEUE_Frame{
	PT_Frame_Pkt 	PtFrame;	
	SX_S32			s32QueueDepth;
	SX_S32  		s32IndexR;
	SX_S32  		s32IndexW;
	SX_S32  		s32Count;
	SX_BOOL			bAbortRequest;
	pthread_mutex_t	mutex;
	pthread_cond_t 	cond;
}T_QUEUE_Frame, *PT_QUEUE_Frame;

extern	PT_QUEUE_Frame 	QUEUE_Frame_Creat( SX_S32 depth );
extern	void 			QUEUE_Frame_Destroy( PT_QUEUE_Frame handle );
extern	SX_S32 			QUEUE_Frame_Write(PT_QUEUE_Frame handle, PT_Frame_Pkt Frame, SX_BOOL block);
extern	SX_S32 			QUEUE_Frame_Read( PT_QUEUE_Frame handle, PT_Frame_Pkt Frame, SX_BOOL block);
extern	void 			QUEUE_Frame_Abort( PT_QUEUE_Frame handle );
extern	void 			QUEUE_Frame_Flush( PT_QUEUE_Frame handle );

#endif

2、Frame_Queue.c
//创建一个队列

#include"Frame_Queue.h"

PT_QUEUE_Frame QUEUE_Frame_Creat(SX_S32 size)
{
	PT_QUEUE_Frame handle = (PT_QUEUE_Frame)xine_xmalloc(sizeof(T_QUEUE_Frame));
	if( handle == NULL )
	{
		TRACE(DL_ERROR, "DL_ERROR\n");
		return NULL;
	}
	
	if (pthread_mutex_init( &handle->mutex, NULL ) != 0)
	{
		TRACE(DL_ERROR, "DL_ERROR\n");
		QUEUE_Frame_Close( handle );
		return NULL;
	}
	
	if( pthread_cond_init(&handle->cond, NULL) != 0 )
	{
		TRACE(DL_ERROR, "DL_ERROR\n");
		QUEUE_Frame_Close( handle );
		return NULL;
	}
	
	handle->PtFrame = (PT_Frame_Pkt)xine_xmalloc(sizeof(T_Frame_Pkt) * size);
	if( handle->PtFrame == NULL )
	{
		TRACE(DL_ERROR, "DL_ERROR\n");
		QUEUE_Frame_Close( handle );
		return NULL;
	}
	
	handle->s32QueueDepth = size;
	handle->s32IndexR = 0;
	handle->s32IndexW = 0;
	handle->s32Count = 0;
	handle->bAbortRequest = SX_FALSE;
	
	return handle;
}

//销毁队列

void QUEUE_Frame_Destroy( PT_QUEUE_Frame handle )
{
	if( handle )
	{
		if( handle->PtFrame )
		{
			xine_freep(  (void *)&(handle->PtFrame) );
		}
		
		pthread_mutex_destroy( &handle->mutex );
		pthread_cond_destroy(&handle->cond);
		
		xine_freep(  (void *)&handle);
	}
	return;
}

//使用互斥锁结合条件变量，实现同步，自定义一个队列，写队列

SX_S32 QUEUE_Frame__Write( PT_QUEUE_Frame handle, PT_Frame_Pkt Frame，, SX_BOOL block)
{
	if( handle == NULL || Frame == NULL )
	{
		TRACE(DL_ERROR, "DL_ERROR\n");
		return -1;
	}
	pthread_mutex_lock( &(handle->mutex) );
	
	if( (handle->s32IndexW + 1) % handle->s32QueueDepth == handle->s32IndexR )//队列被写满了，如果要换成循环队列，看我别的文章
	{
		pthread_mutex_unlock( &(handle->mutex) );
		//TRACE(DL_WARNING, "queue full\n");		//tx bus_send_cmd fifo is always full in working phase
		return 0;
	}
	
	PT_Frame_Pkt PtFrame = handle->PtFrame + handle->s32IndexW;	//获取队列的首地址，写偏移量，进行偏移，下一个要的位移地址
	#if	1
	*PtFrame = *Frame;//第一种方法是通过指针，速度很快
	#else
	memcpy( ptCmd->szSync, cmd->szSync, sizeof(ptCmd->szSync) );//第二种方法是通过memcopy的方式，将数据写入队列

	ptCmd->s8ChNo		= cmd->s8ChNo;
	ptCmd->s8CmdIndex	= cmd->s8CmdIndex;
	ptCmd->s16CmdPeriod	= cmd->s16CmdPeriod;
	ptCmd->s8LibIndex	= cmd->s8LibIndex;
	ptCmd->u8CmdLength	= cmd->u8CmdLength;
	ptCmd->s8CmdFormat	= cmd->s8CmdFormat;
	memcpy( ptCmd->szReserved1, cmd->szReserved1, sizeof(cmd->szReserved1) );
	memcpy( ptCmd->szCmd, cmd->szCmd, MIN(ptCmd->u8CmdLength, sizeof(ptCmd->szCmd)) );
	
	ptCmd->s32StatusLength = cmd->s32StatusLength;
	memcpy( ptCmd->szStatus, cmd->szStatus, MIN(ptCmd->s32StatusLength, sizeof(ptCmd->szStatus)) );
	ptCmd->s32LastTime	= cmd->s32LastTime;
	ptCmd->s32Sn		= cmd->s32Sn;
	ptCmd->ptBk			= cmd->ptBk;
	ptCmd->ptCh			= cmd->ptCh;
	ptCmd->ptCmd_Myself = cmd->ptCmd_Myself;
	ptCmd->next			= cmd->next;
	#endif
	
	handle->s32IndexW = (handle->s32IndexW+1) % handle->s32QueueDepth;//队列写偏移指针，位移加1
	handle->s32Count++;//通过这个值，很容易判断，队列是否写满s32Count ？= size
	
	if ( !block)	// 阻塞标记，1(阻塞模式)，0(非阻塞模式)
	{
	}
	else
	{
		pthread_cond_signal( &handle->cond );
	}
	
	pthread_mutex_unlock( &handle->mutex );
	return 1;
}

//使用互斥锁结合条件变量，实现同步，自定义一个队列，读队列

SX_S32 QUEUE_FrameRead(PT_QUEUE_Frame handle, PT_Frame_Pkt Frame, SX_BOOL block)
{
	if( handle == NULL || Frame == NULL )
	{
		TRACE(DL_ERROR, "DL_ERROR\n");
		return -1;
	}
	SX_S32  	ret = 1;
	pthread_mutex_lock( &(handle->mutex) );

	for (;;)
	{
		if (handle->bAbortRequest) // 异常
		{
			ret = -1;							
			break;
		}

		if( handle->s32IndexW == handle->s32IndexR)			//empty		//if( _s32Count == 0 )
		{
			if ( !block)						// 阻塞标记，1(阻塞模式)，0(非阻塞模式)
			{
				ret = 0; 						// 非阻塞模式，没东西直接返回0
				break;
			}
			else
			{
				pthread_cond_wait(&handle->cond, &handle->mutex);
			}
		}
		else//队列有数据
		{
			PT_Frame_Pkt PtFrame = handle->PtFrame + handle->s32IndexR;//获取队列的首地址，读偏移量，进行偏移，下一个要的位移地址
			
			#if 1//第一种方法是通过指针，速度很快
			*Frame = *PtFrame;
			#else//第二种方法是通过memcopy的方式，将数据写入队列
			
			memcpy( cmd->szSync, ptCmd->szSync, sizeof(cmd->szSync) );
			cmd->s8ChNo			= ptCmd->s8ChNo;
			cmd->s8CmdIndex		= ptCmd->s8CmdIndex;
			cmd->s16CmdPeriod	= ptCmd->s16CmdPeriod;
			cmd->s8LibIndex		= ptCmd->s8LibIndex;
			cmd->u8CmdLength	= ptCmd->u8CmdLength;
			cmd->s8CmdFormat	= ptCmd->s8CmdFormat;
			memcpy( cmd->szReserved1, ptCmd->szReserved1, sizeof(ptCmd->szReserved1) );
			memcpy( cmd->szCmd, ptCmd->szCmd, MIN(cmd->u8CmdLength, sizeof(cmd->szCmd)) );
			
			cmd->s32StatusLength = ptCmd->s32StatusLength;
			memcpy( cmd->szStatus, ptCmd->szStatus, MIN(cmd->s32StatusLength, sizeof(cmd->szStatus)) );
			cmd->s32LastTime	= ptCmd->s32LastTime;
			cmd->s32Sn		= ptCmd->s32Sn;
			cmd->ptBk			= ptCmd->ptBk;
			cmd->ptCh			= ptCmd->ptCh;
			cmd->ptCmd_Myself 	= ptCmd->ptCmd_Myself;
			cmd->next		= ptCmd->next;
			#endif		
			
			//队列指针往后移走	
			handle->s32IndexR = (handle->s32IndexR + 1) % handle->s32QueueDepth;//队列读偏移指针，位移加1
			if( handle->s32Count > 0 )
			{
				handle->s32Count--;
			}
			ret = 1;
			break;
		}
	}
	
	pthread_mutex_unlock( &(handle->mutex)  );
	return ret;
}

异常终止，退出

void QUEUE_Frame_Abort(PT_QUEUE_Frame handle) 
{
	if( handle == NULL )
	{
		TRACE(DL_ERROR, "DL_ERROR\n");
		return;
	}
	
	pthread_mutex_lock( &(handle->mutex) );
	handle->bAbortRequest = SX_TRUE;
	pthread_cond_signal(&handle->cond);
	pthread_mutex_unlock( &handle->mutex);
	
	return;
}

清除，重置

void QUEUE_Frame_Flush(PT_QUEUE_Frame handle)
{
	if( handle == NULL )
	{
		TRACE(DL_ERROR, "DL_ERROR\n");
		return;
	}
	
	pthread_mutex_lock( &(handle->mutex) );

	handle->s32IndexR	= 0;
	handle->s32IndexW	= 0;
	handle->s32Count	= 0;
	
	handle->bAbortRequest = 0;
	
	pthread_mutex_unlock( &(handle->mutex)  );
	return;
}

3、main.c，调用模版，例子

1、线程A，通过网络接收大量的数据，并写入队列


PT_QUEUE_Frame	ptFrameQueue;
T_Frame_Pkt		FrameRcvQueue;
T_Frame_Pkt		FrameSendQueue;
//static SX_U32 cnt  = 0;
SX_S32  QUEUE_Frame_WriteData(PT_Receiver handle, void *buf, SX_S32 timeoutMs )
{
	if( handle == NULL )
	{
		TRACE(DL_ERROR, "DL_ERROR\n");
		return 0;
	}
	SX_U8 *pDst = NULL;
	SX_S32 ret, sret, retval;
	SX_S64 max_fd;
	fd_set readfds;
	struct timeval tv;
	int i  = 0;
	FD_ZERO(&readfds);	
	FD_SET( handle->sockfd, &readfds );

	max_fd = handle->sockfd;	
	tv.tv_sec  = timeoutMs/1000;	
	tv.tv_usec = (timeoutMs%1000)*1000;	
	
	retval = select( max_fd + 1, &readfds, NULL, NULL, &tv );
	if ( retval > 0 )
	{
		
		sret = recvfrom( handle->sockfd, (SX_S8 *)buf, UDP_MAX_LEN, 0, (struct sockaddr *)&(handle->cliaddr), 
		&(handle->cliaddr_len) );
	
		if ( sret > 0 )
		{
			SX_U8 * pDst = (SX_U8 *)malloc(UDP_MAX_LEN);
			pDst = (SX_U8 *)&handle->FrameSendQueue.data;
			memcpy( (SX_S8 *)pDst, (SX_S8 *)buf,sret);

			if(handle->ptFrameQueue == NULL || &(handle->FrameSendQueue) == NULL)
				return -1;
			QUEUE_Frame_Write(handle->ptFrameQueue,&(handle->FrameSendQueue，1));

			return	sret ;
		}
		else
		{
			ret = 0;  // no data;
		}
	}
	else if ( retval == 0 )
	{
		// timeout		
		ret = 0;
	}
	else
	{
		// error		
		ret = -1;
	}
	
	return	ret;
}

2、线程B读取队列数据，给其他模块使用
ret = QUEUE_Frame_ReadData(handle->ptFrameQueue,&(handle->FrameRcvQueue),1);
if(ret < 0)
{
	usleep(1000);
	continue;
}
else
{
	.......
	解读数据
	.......
}

总结
代码中有一个，*PtFrame = *Frame，方法是通过指针，速度很快
通过指针指向一个结构体，便可以，实现快速赋值，复制数据

struct data1，data2
struct pdata1，pdata2
pdata1 = data1；
pdata2 = data2；
*pdata1 = *pdata2;

我的另一篇，有分析这块的用法，https://editor.csdn.net/md/?articleId=141191634

C语言——结构体、局部变量和全局变量、枚举
Megatron的专栏
08-04 9689
局部变量与全局变量    按照作用域不同将变量分为 局部变量和全局变量    局部变量：定义在函数内部变量    作用域：从定义的那一行开始直到所在代码结束    生命周期：从定义的那一行开始只直到其所在代码结束    注意点：内部代码块中定义与外部代码块中的同名变量，那么内部代码中变量会覆盖外部代码块中定义的变量    局部变量只有定义没有声明      全局变量：定在函数外部变
全局结构体变量
透明果冻
01-03 6248
1.在.h头文件中定义struct:     struct   JCB   {   //   定义作业控制块JCB         char   name[10]; //作业名     char   *state;   //作业状态     int   time; //估计运行时间     int   Wtime; //等待时间     int   arrive; //到达时间     int  
c中全局变量，全局结构体使用
热门推荐
ymangu的专栏
03-27 3万+
1)在A中定义的函数，如何在B中调用？ 如果有头文件，在头文件中声明，在B文件中#include头文件就可以了。 如果是在.c文件中声明的，在B中加extent声明：extern void timer_hw_init(void); 2）在A中定义的结构体及变量，如何在B中调用？ 1> 对于全局结构体定义，首先在Globals.h头文件中构造结构体，用typedef方式，如： typede
c++通过结构体(struct)全局变量在多线程中传递参数
weixin_43134049的博客
02-18 5156
编程语言: c++ 运行运行环境:Linux version 4.19.42-v7+ (dom@dom-XPS-13-9370) (gcc version 4.9.3 (crosstool-NG crosstool-ng-1.22.0-88-g8460611)) #1219 SMP Tue May 14 21:20:58 BST 2019 目标:在一个线程运行的时候,主程序或者另一个线程,通过改...
C++、Linux多线程编程
weixin_45853844的博客
03-19 1225
在Linux系统上，可以使用POSIX线程库（pthread库）进行多线程编程。pthread库提供了一系列线程相关的函数，可以用于创建和管理线程、同步和互斥等操作。
【Linux操作系统】--多线程（二）--条件变量
qq_53413129的博客
09-01 1867
Linux线程同步 条件变量 条件变量的作用： 条件变量的用法： 条件变量简单案例： 为什么pthread_cond_wait需要互斥量？ 生产者消费者模型 为何要使用生产者消费者模型 生产者消费者模型优点 基于BlockingQueue的生产者消费者模型 C++ queue模拟阻塞队列的生产消费模型 复盘生产者消费者问题 POSIX信号量 1.回顾信号量的概念 2.认识信号量对应的操作函数 3.认识环形队列 4.结合sem+环形队列编写生产消费模型...
Linux：多线程（三.POSIX信号量、生产消费模型、线程池、其他常见的锁）
qq_74415153的博客
08-12 926
1.POSIX信号量 1.1引入 1.2回顾加深理解信号量 1.3信号量的操作接口 2.基于循环队列的生产消费模型 2.1循环队列 2.2整个项目 3.线程池 可变参数的处理 项目内容 单例模式(线程安全的懒汉线程池) 4.STL、智能指针是否线程安全 5.其他,常见的各种锁 自旋锁 读者写者问题 逻辑过程 接口介绍
Linux中的线程
zsffzb的博客
11-04 1917
1.线程的基本概念 2.线程和进程的区别 *线程的同步 线程的调度 线程的通信编程思想之多线程与多进程(1)——以操作系统的角度述说线程与进程_阳光日志-CSDN博客_多线程和多进程编程线程是什么？要理解这个概念，须要先了解一下操作系统的一些相关概念。大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。任务执行的一小段时间叫做时间片，任务正在执行时的状态叫运行状态，任务执行一段时间后强制
【Linux】用5万字满足你对线程的所有♥幻想♥——【线程概念】【线程安全】【多线程并发】【互斥量】【条件变量】【信号量】【锁的原理】【各种锁】【生产者消费者模型】【读者写者问题】
2301_79796701的博客
07-26 1569
【Linux】用10万字满足你对线程的所有♥幻想♥——【线程概念】【线程安全】【多线程并发】【互斥量】【条件变量】【信号量】【锁的原理】【各种锁】【生产者消费者模型】【读者写者问题】
Linux中 信号量、消息队列和全局变量的区别！！！
weixin_54036711的博客
08-23 1777
我们在操作系统任务编程中，解决任务间通信问题，可以使用、信号量或者消息队列来完成。那么它们有什么区别，在遇到任务间通讯时，该怎样选择用哪一种方式呢？
结构体最好作为全局变量
ppsddw123的博客
01-15 5532
结构体最好作为全局变量，这样在跨文件函数传参时不会提示“不允许使用不完整的类型”——因为没有在每一个文件定义过。
全局变量 静态本地变量 结构体
weixin_52292443的博客
11-28 2003
全局变量 1、全局变量的定义与注意点 1、定义在函数外面的变量是全局变量 2、全局变量具有全局的生存期和作用域 3、它们与任何函数都无关 4、在任何函数内部都可以使用它们 上代码 #include<stdio.h> int f(void); int gAll = 12; int main() { printf("in main gAll=%d\n",gAll); f(); printf("now in main gAll=%d\n",gAll); return 0; } int
全局结构体的使用方法
Sirius_007的博客
12-07 1万+
1. 对于全局结构体定义，首先在Globals.h头文件中构造结构体，用typedef方式，如： typedef struct Parameter { int OK; string No; }PARAM; 2.在Globals.cpp文件中： PARAM*parameter= NULL；    // 注意，在这里初始化，这是初始的指针类型 3.再回到Globals.h头文件...
C语言学习强化篇—结构体
abobchek的博客
12-31 958
/结构体变量的创建方式1：struct Peoint high;p3,p4;以上都是全局变量//结构体变量的初始化int main()struct Peo p1 = { "zhangsan","15874215698","男", 181};//局部结构体变量的创建并初始化return 0;嵌套结构体的初始化struct Peoint high;float f;
C语言初级篇-----结构体基础内容详解
.很冷的博客
12-26 956
C语言结构体基础内容详解！
【C语言 -结构体 结构体声明、定义、初始化、结构体成员访问、结构体传参】
weixin_73833411的博客
04-16 2918
C语言结构体初识。
【C语言】结构体
FishC的博客
01-01 1492
【C语言】结构体
13.消息队列
扬帆起航
04-01 1189
消息队列
C++开发创建一个队列，并写一个方法一直往队列塞入BufferDesc & buffer，使用pthread_create创建一个线程，线程中循环获取队列中的数据并操作
最新发布
03-21
用户提到的是C++开发，所以应该使用标准的C++库，但同时也提到了pthread，这意味着可能是在Linux或类似环境下，需要多线程的支持。队列的数据结构，可能需要线程安全，因为会有生产者和消费者同时操作队列。 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值