C语言-多线程与内存池、多线程与队列、多线程与内存池与队列的结合使用

最新推荐文章于 2024-08-14 19:35:58 发布
最新推荐文章于 2024-08-14 19:35:58 发布
阅读量1.6k 收藏 14
点赞数 1
分类专栏： linux c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40203143/article/details/85631808
版权 
一、多线程与内存池的结合使用：

一个线程memorymalloc,另一个线程memoryfree,效率是malloc\free的1.3倍（单线程时是3倍，本来双线程应该是6倍，但因为使用了线程的同步，使线程地并发变为了串行，故效率也应是3倍，又线程切换时会遇到阻塞的情况、再加上切换时的消耗，最后得到1.3）

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>
#include "memorypool.h"
#include <time.h>

time_t start;
time_t end;
int* sum;
int count=0;
sem_t sem1;
sem_t sem2;
memorypool*mp=NULL;

void* fn_0(void* arg)
{
    start = time(NULL);
    while(1)
    {
        end = time(NULL);
        if(end == start +180)
            break;
        //sum = (int*)memory_malloc(mp,sizeof(int));
        sum = (int*)malloc(sizeof(int));
        *sum = 2333;
        sem_post(&sem2);
        sem_wait(&sem1);
    }

    return (void*)arg;
}
void* fn_1(void* arg)
{
    
    while (1)
    {
        end = time(NULL);
        if(end == start+180)
            break;
        sem_wait(&sem2);
        //memory_free((char**)&sum);
        free(sum);
        count +=1;
        sem_post(&sem1);
    
    }
    printf("count,%d\n",count);
    return (void*)arg;
}

int main()
{
    
    mp = memorypool_create(1024,3,1);
    pthread_t thread0;
    pthread_t thread1;
    sem_init(&sem1,0,0);
    sem_init(&sem2,0,0);
    pthread_create(&thread0, NULL, fn_0, (void*)mp);
    pthread_create(&thread1, NULL, fn_1, (void*)mp);

    pthread_join(thread0, NULL);
    pthread_join(thread1, NULL);

    sem_destroy(&sem1);
    sem_destroy(&sem2);

    return 0;
}
二、多线程与队列的结合：

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include "memorypoll.h"

#define SizeOfQueue 6

time_t start;
time_t end;
memorypool* mp=NULL;

typedef struct Queue
{
	int* data[SizeOfQueue];
	int head;
	int tail;
	int cnt;
}queue;
typedef struct Data
{
        queue* que;
        pthread_mutex_t mlock;
        int count;
}data;
//pthread_mutex_t mlock1;

queue* queue_init()
{
	queue* qe = (queue*)malloc(sizeof(queue));
	if (NULL == qe)
	{
		printf("Init queue error");
		exit(1);
	}
	memset(qe, 0, sizeof(queue));
	qe->head = 0;
	qe->tail = SizeOfQueue - 1;
	qe->cnt = 0;
	return qe;
};
int en_queue(queue* qe)
{
	if (qe->cnt == SizeOfQueue)//判断栈满；
	{
		return 0;
	}
	//pthread_mutex_lock(&mlock1);
	int* tem = (int*)malloc(sizeof(int));
      // int* tem = (int*)memory_malloc(mp,sizeof(int));
       *tem = 2333;
	//pthread_mutex_unlock(&mlock1);
	qe->tail = (qe->tail + 1) % SizeOfQueue;
	qe->data[qe->tail] = tem;
	qe->cnt += 1;
	return 0;
};
int de_queue(queue* qe)
{
	int* tmp=NULL;
	if (qe->cnt == 0)
	{
		return 0;
	}//判断栈空
	tmp = qe->data[qe->head];
	//pthread_mutex_lock(&mlock1);
	free(tmp);
       //memory_free((char**)&tmp);
       tmp=NULL;
       //pthread_mutex_unlock(&mlock1);
	qe->head = (qe->head + 1) % SizeOfQueue;
	qe->cnt -= 1;
	return 0;
};

void* fn_0(void* arg)
{
	data* da1 = (data*)arg;
	start = time(NULL);
	while(1)
	{
		end = time(NULL);
		if (end == start + 180)
			break;
		pthread_mutex_lock(&da1->mlock);
		en_queue(da1->que);
		pthread_mutex_unlock(&da1->mlock);
	}
	return (void*)da1;
}
void* fn_1(void* arg)
{
	data* da2 = (data*)arg;
	while (1)
	{
		end = time(NULL);
		if (end == start + 180)
			break;
		pthread_mutex_lock(&da2->mlock);
		de_queue(da2->que);
		da2->count +=1;
		pthread_mutex_unlock(&da2->mlock);

	}
	printf("count:%d\n",da2->count);
	return (void*)da2;
}

int main()
{

	mp = memorypool_create(sizeof(int),7,1);
	pthread_t thread0;
	pthread_t thread1;
	data da;
	da.count = 0;
	pthread_mutex_init(&da.mlock, NULL);
	//pthread_mutex_init(&mlock1, NULL);
	da.que = queue_init();
	pthread_create(&thread0, NULL, fn_0, (void*)&da);
	pthread_create(&thread1, NULL, fn_1, (void*)&da);

	pthread_join(thread0, NULL);
	pthread_join(thread1, NULL);

	pthread_mutex_destroy(&da.mlock);
	//pthread_mutex_destroy(&mlock1);

	return 0;
}

三、多线程与队列与内存池的结合：

构思是：一个线程memorymalloc,另一个线程memoryfree，使用队列作为缓冲，互斥锁用来保护

但目前有个BUG尚未解决，看了两天未果，以后再回头来看吧，具体现象如下：

多线程时，内存池初始化时的大小是sizeof(int)时，mp->free_list->mp的值会无故被改成0x91D，导致segmentation fault

单线程时，内存池初始化时的大小是sizeof(int)时，运行正常

多线程时，内存池初始化时的大小是1024时，运行正常





memorypool.h：



#ifndef _MEMORYPOOL_H_
#define _MEMORYPOOL_H_


#include <stdlib.h>
#include <string.h>
#include <stdio.h>


typedef struct Memorypool
{
    int mempool_size;
    int memory_size;//block_size + sizeof(manager information) = mem_size
    int block_size;
    int total_memory_cnt;
    int used_memory_cnt;
    int auto_extend;
    struct Memory* free_list;
    struct Memory* used_list;
}memorypool;

typedef struct Memory 
{
    int memory_size;
    int block_size;
    struct Memory* prev;
    struct Memory* next;
    struct Memorypool* mp;
    char* block;
}memory;


memorypool* memorypool_create(int block_request_size, int memory_init_quantity, bool memory_extend);
char* memory_malloc(memorypool* mp,int data_size);
int memorypool_info_get(memorypool* mp);
int memory_free(char** p_bk);
int memorypool_destroy(memorypool* mp);
memory* memory_creat(int memory_size, memorypool* mp);

#endif






memorypool.c：

#include "memorypool.h"

memorypool* memorypool_create(int block_request_size, int memory_init_quantity, bool memory_extend)
{
    memorypool* mp = NULL;
    mp = (memorypool*)malloc(sizeof(memorypool));
    memset(mp, 0, sizeof(memorypool));
    mp->block_size = block_request_size;
    mp->memory_size = block_request_size + sizeof(memory); 
    mp->auto_extend = memory_extend;

    for (int i = memory_init_quantity; i > 0; i--)
    {
        memory* mm = NULL;
        mm = memory_creat(mp->memory_size , mp);
    }
    return mp;
    
};

char* memory_malloc(memorypool* mp, int data_size)
{
    memory* p_memory = NULL;
    if (mp->block_size < data_size)
    {
        return NULL;
    }
    if (NULL == mp->free_list)
    {
        if (mp->auto_extend == 1)
            memory_creat(mp->memory_size, mp);
        else
            return NULL;
    }
    
    p_memory = mp->free_list;
    mp->free_list = mp->free_list->next;
    p_memory->next = NULL;

    if (mp->used_list)
    {
        mp->used_list->prev->next = p_memory;
        p_memory->prev = mp->used_list->prev;
    }
    else
    {
        mp->used_list = p_memory;
    }
    p_memory->next = mp->used_list;
    mp->used_list->prev = p_memory;
    mp->used_list = p_memory;
    mp->used_memory_cnt += 1;
    
  
    return p_memory->block;
};


int memorypool_info_get(memorypool* mp) 
{
    printf("current mempool_size:%d\n\
current memory_size:%d\n\
current block_size:%d\n\
total_memory_cnt:%d\n\
used_memory_cnt:%d\n",mp->mempool_size,mp->memory_size,mp->block_size, \
mp->total_memory_cnt,mp->used_memory_cnt);
    return 0;
};


int memory_free(char** p_bk)
{
    memory* p_memory = (memory* )(*p_bk + sizeof(memory));//错误
    memory* p_memory = (memory* )(*p_bk - sizeof(memory)/(sizeof(char)));//正确
    p_memory->next->prev = p_memory->prev;
    p_memory->prev->next = p_memory->next;
    p_memory->next = NULL;
    p_memory->prev = NULL;
    if (p_memory->mp->used_memory_cnt == 1)
        p_memory->mp->used_list = NULL;
    p_memory->next = p_memory->mp->free_list;
    p_memory->mp->free_list = p_memory;
    p_memory->mp->used_memory_cnt -= 1;
    *p_bk = NULL;
    return 0;
};

int memorypool_destroy(memorypool* mp) 
{
    memory* mm = NULL;
    if (mp->free_list)
    {
        mm = mp->free_list;
        mp->free_list = mp->free_list->next;
        free(mm);
        mm = NULL;
    }
    if (mp->used_list)
    {
        mp->used_list->prev->next = NULL;
        mm = mp->used_list;
        mp->used_list = mp->used_list->next;
        free(mm);
        mm = NULL;
    }
    free(mp);

    return 0;

}

memory* memory_creat(int memory_size, memorypool* mp)
{
    memory* mm = NULL;
    char* bk = NULL;
    char* memory_start = (char*)malloc(memory_size);
    memset(memory_start, 0, memory_size);
    mm = (memory*)memory_start;
    memset(mm, 0, sizeof(memory));
    bk = memory_start - sizeof(memory);//错误
    bk =memory_start +sizeof(memory)/(sizeof(char));//正确
    mm->memory_size = memory_size;
    mm->block_size = memory_size - sizeof(memory);
    mm->mp = mp;
    printf("mp:%p\n",mp);
    printf("mm_mp:%p\n",mm->mp);
    mm->block = bk;
    mm->next = mp->free_list;
    mp->free_list = mm;
    mp->total_memory_cnt += 1;
    mp->mempool_size += mp->memory_size;

    return mm;

};




queue.c：

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include "memorypool.h"

#define SizeOfQueue 6

time_t start;
time_t end;
memorypool* mp=NULL;

typedef struct Queue
{
    int* data[SizeOfQueue];
    int head;
    int tail;
    int cnt;
}queue;
typedef struct Data
{
        queue* que;
        pthread_mutex_t mlock;
        int count;
}data;

queue* queue_init()
{
    queue* qe = (queue*)malloc(sizeof(queue));
    if (NULL == qe)
    {
        printf("Init queue error");
        exit(1);
    }
    memset(qe, 0, sizeof(queue));
    qe->head = 0;
    qe->tail = SizeOfQueue - 1;
    qe->cnt = 0;
    return qe;
};
int en_queue(queue* qe)
{
    if (qe->cnt == SizeOfQueue)//判断队列满；
    {
        return 0;
    }
    //int* tem = (int*)malloc(sizeof(int));
        int* tem = (int*)memory_malloc(mp,sizeof(int));
        *tem = 2333;
    qe->tail = (qe->tail + 1) % SizeOfQueue;
    qe->data[qe->tail] = tem;
    qe->cnt += 1;
    return 0;
};
int de_queue(queue* qe)
{
    int* tmp=NULL;
    if (qe->cnt == 0)
    {
        return 0;
    }//判断队列空；
    printf("qe->cnt:%d\n",qe->cnt);
    tmp = qe->data[qe->head];
    //free(tmp);
        memory_free((char**)&tmp);
        //tmp=NULL;
    qe->head = (qe->head + 1) % SizeOfQueue;
    qe->cnt -= 1;
    return 0;
};

void* fn_0(void* arg)
{
    data* da1 = (data*)arg;
    start = time(NULL);
    while(1)
    {
        end = time(NULL);
        if (end == start + 180)
            break;
        pthread_mutex_lock(&da1->mlock);
        en_queue(da1->que);
        pthread_mutex_unlock(&da1->mlock);
    }
    return (void*)da1;
}
void* fn_1(void* arg)
{
    data* da2 = (data*)arg;
    while (1)
    {
        end = time(NULL);
        if (end == start + 180)
            break;
        pthread_mutex_lock(&da2->mlock);
        //en_queue(da2->que);
        de_queue(da2->que);
        da2->count +=1;
        pthread_mutex_unlock(&da2->mlock);

    }
    printf("count:%d\n",da2->count);
    return (void*)da2;
}

int main()
{

    mp = memorypool_create(sizeof(int),7,1);
    pthread_t thread0;
    pthread_t thread1;
    data da;
    da.count = 0;
    pthread_mutex_init(&da.mlock, NULL);
    da.que = queue_init();
    pthread_create(&thread0, NULL, fn_0, (void*)&da);
    pthread_create(&thread1, NULL, fn_1, (void*)&da);

    pthread_join(thread0, NULL);
    pthread_join(thread1, NULL);
    pthread_mutex_destroy(&da.mlock);
   

    return 0;
}





四、遗留BUG的解决
2019/2/17：

在两个线程分别向内存池申请内存块、释放内存块到内存池时，出现了mp指针的指向错误，

经解决，是内存池在memory_creat和memory_free时，对p_memory->block指针赋值错误造成的。

该bug将在上面代码中标记出来。

犯这样的错误是因为没有搞清楚：1.地址+size，想得到地址，因注意size的进制、量度；

2.堆是从低地址开始分配的，栈是从高地址开始分配的。没有区分地址分配的方向。见下图。

 

欢欢喜欢欢欢喜喜
关注
专栏目录
c语言多线程收发数据,c语言多线程队列读写
weixin_30905039的博客
05-23 950
最近用c语言写了个简单的队列服务，记录一下，文件结构为 main.c queue.c queue.h,代码如下:主函数#define NUM_THREADS 200#include #include #include #include #include #include #include struct threadArgs{struct queue *q;char *c ;};void* putA...
C例子：多线程
02-18
该程序是我写的博客“一起talk C栗子吧（第一百二十二回：C语言实例--多线程）”的配套程序，共享给大家使用
C语言： 队列与多线程
C++++ ++
12-17 1237
队列： 头文件：queue.h #pragma once #include<stdio.h> #include<stdlib.h> #include<memory.h> #define LEN 100 // 队列长度 /*线性队列*/ struct queue { int data[LEN]; int head; //头 int back; //...
C++多线程详解 | 线程创建 | 互斥锁 | 条件变量 | 线程池
最新发布
weixin_45754224的博客
08-14 1411
C++多线程详解 | 线程创建 | 互斥锁 | 条件变量 | 线程池
C语言中的多线程简介
Hemingway_Hoo的博客
08-17 1万+
线程 Thread 专业术语称之为程序执行流的最小单元。线程是不会执行程序的，可以理解成线程就是一个载体，将 要执行的代码 运送到CPU进行处理。 多线程就是多个线程同时并发执行。 （注意并发与并行的区别，并行同时执行不同的任务，并行是交替执行不同的任务。） 1，为什么要用多线程？ 1）避免阻塞 单个线程中的程序，是按照顺序执行的，排在前面的程序如果发生异常卡住（阻塞），会影响到后面......
多线程高并发内存池c语言实现,高并发内存池的实现
weixin_32042959的博客
05-22 757
第一层:Thread Cache(线程缓存)1.thread cache是内存池中的第一层缓存，这一层缓存主要解决的问题就是并发状态下锁竞争的效率问题。线程在这里申请不需要加锁，每一个线程都有自己独立的cache，这也就是这个项目并发高效的地方。怎么实现每个线程都拥有自己唯一的线程缓存呢？为了避免加锁带来的效率，在Thread Cache中使用(tls)thread local storage保存...
c语言数据结构应用-数组队列（无锁队列）在多线程中的使用
staticnetwind的专栏
12-24 3596
上篇文章《c语言数据结构实现-数组队列/环形队列》讲述了数组队列的原理与实现，本文编写一个双线程进行速度测试 线程的工作方式分别也有三种：线程完全异步的机制、使用sem保证实时线程同步、使用条件变量保持同步 数组队列在三种工作方式下均能成功执行，速度上为无锁的情况为最快，CPU占用也是最大（usleep轮询） 综合结果考虑来说使用条件变量正好可以避免 子线程过多地占用CPU进行轮询操作，速度也仅为无锁的一半
c语言多进程多线程编程
07-21
C语言作为一门底层且强大的编程语言，提供了丰富的系统调用接口来实现多进程和多线程编程。 **多进程（Multiprocessing）** 1. **进程定义**：进程是程序的一次执行实例，每个进程都有自己的独立内存空间，包括...
Linux下使用EPoll+队列+多线程的C++实现
12-24
综上所述，这个项目结合了`epoll`的高性能I/O复用，队列的缓冲机制以及多线程的并行处理，构建了一个能够高效处理高并发TCP连接的服务器模型。这样的设计思路对于开发大规模、高并发的网络服务有着重要的实践意义。
Objective-C高级编程 iOS与OS X多线程和内存管理_Objective-C_ios_
10-02
《Objective-C高级编程：iOS与OS X多线程和内存管理》是一本深入探讨Apple平台开发中的关键技术的书籍。本书主要围绕Objective-C语言在iOS和OS X操作系统上的应用，特别是针对多线程和内存管理这两个核心主题进行...
c语言多线程消息队列,简单的消息队列（C语言实现）
weixin_29424607的博客
05-24 1832
#define ADV_DATA_DEPTH 10 //10帧数据深度#define ADV_DATA_LENGTH_MAX 128 //每帧数据最大长度为128字节//结构体声明typedef struct{U8 ucHeadPtr; //头指针U8 ucTailPtr; //尾指针U8 ucAdvData[ADV_DATA_DEPTH][ADV_DATA_LENGTH_MAX];}ADV_DA...
c语言多线程队列读写
weixin_34153893的博客
03-05 1032
最近用c语言写了个简单的队列服务，记录一下，文件结构为 main.c queue.c queue.h,代码如下: 主函数 #define NUM_THREADS 200 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <queue.h&gt...
C多线程
Asa_Glory的博客
04-20 115
C多线程操作 Linux 操作系统使用符合 POSIX1 线程作为系统标准线程，该 POSIX 线程标准定义了一整套操作线程的 API。Pthread 是 POSIX threads 的简称，是 POSIX 的线程标准 线程创建 代码如下: #include <pthread.h> int pthread_create(pthread_t *thread, const pthread_attr_t * attr,
C 多线程
Do
02-26 204
代码： #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <pthread.h> #include <unistd.h> #define NUM_THREADS 5 void *perform_work(void *arguments){ int index = *((int *)arguments); int sleep_time = 1 + r
C 多线程编程
Yohann丶blog
01-24 708
6361642989056_.pic.jpg 操作线程的函数 线程的创建 #include <pthread.h> int pthread_create( pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg ...
秒杀多线程第二篇 多线程第一次亲密接触 CreateThread与_beginthreadex本质区别
huobengluantiao8
04-05 3415
本文将带领你与多线程作第一次亲密接触，并深入分析CreateThread与_beginthreadex的本质区别，相信阅读本文后你能轻松的使用多线程并能流畅准确的回答CreateThread与_beginthreadex到底有什么区别，在实际的编程中到底应该使用CreateThread还是_beginthreadex？ 使用多线程其实是非常容易的，下面这个程序的主线程会创建了一个子线程并等待...
C语言——多线程
Leechee的博客
02-27 2999
不会打目录 先挂链接： https://www.cnblogs.com/xiehongfeng100/p/4620852.html "进程——资源分配的最小单位，线程——程序执行的最小单位" 1. 线程概述 父进程创建子进程会复制一份空间，类似于代码段->数据段->栈->堆-> 参数。 一个进程在同一时刻只做一件事情。有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。　　 　　进程是程序执行时的一个实例，是担当分配系统资源（CP
c语言 多线程(详)
热门推荐
疯
03-02 6万+
什么是线程，线程的优点是什么 线程在Unix系统下，通常被称为轻量级的进程，线程虽然不是进程，但却可以看作是Unix进程的表亲，同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器环境（register context)，自己的线程本地存储(thread-local storage)。...
多线程内存池
guanxunmeng8928的博客
03-29 157
1.实现多线程创建和delete内存池 2.加速存取速度 3.创建速度和系统new，delete开辟内存趋近一致。 4.防止内存碎片 一.main /* * Setup the memory pool */ #include"Alloctor.h" #include<iostream> #include<thread> #include<mutex> #include"CELLTimestamp.hpp" using namespace std; mutex m; c
C语言多线程编程实战与指南
"C语言并发编程，讲解C语言的多线程编程，帮助理解并发环境下的程序设计" 在C语言中进行并发编程，主要是通过多线程技术来实现。多线程允许程序同时执行多个任务，提高了计算效率和响应速度，尤其在处理I/O密集型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值