封装的线程池

于 2024-10-10 16:16:27 发布
阅读量96 收藏
点赞数 1
文章标签： 服务器 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67677309/article/details/142823981
版权

1.首先写一个队列来存，线程

queue.c

#ifndef QUEUE_H
#define QUEUE_H
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
typedef struct Queue
{
    void **arr;
    int cap;
    int front;
    int rear;
} Queue;
//创建队列
Queue *create_queue(int cap);
//销毁队列
void destroy_queue(Queue *queue);
//入队
void push_queue(Queue *queue, void *arg);
//出队
void *pop_queue(Queue *queue);
//队空
bool empty_queue(Queue *queue);
//队满
bool full_queue(Queue *queue);
//队头
void *front_queue(Queue *queue);
//队尾
void *rear_queue(Queue *queue);

#endif//QUEUE_H

queue.c

#include "queue.h"
//创建队列
Queue *create_queue(int cap)
{
    Queue *queue = malloc(sizeof(Queue));
    //多开辟一一个空间
    queue->arr=malloc(cap*sizeof(void*)*cap+1);
    queue->cap=cap;
    queue->front=0;
    queue->rear=0;
    return queue;
}
//销毁队列
void destroy_queue(Queue *queue)
{
    free(queue->arr);
    free(queue);
}
//入队
void push_queue(Queue *queue, void *arg)
{
    //队尾入队
    queue->arr[queue->rear++]=arg;
    queue->rear%=queue->cap;

}
//出队
void *pop_queue(Queue *queue)
{
    queue->front=(queue->front+1)%queue->cap;
}
//队空
bool empty_queue(Queue *queue)
{
    return queue->front==queue->rear;
}

//队已满
bool full_queue(Queue *queue)
{
    return (queue->rear+1)%queue->cap==queue->front;
}
//队头
void *front_queue(Queue *queue)
{
    return queue->arr[queue->front];
}
//队尾
void *rear_queue(Queue *queue)
{
    return queue->arr[(queue->rear+queue->cap-1)%queue->cap];
}

2.利用队列，写一个线程池

thread_pool.h

#ifndef THREADPOOL_H
#define THREADPOOL_H
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include "queue.h"
typedef void (*EnterFP)(void *);//线程真正的业务逻辑函数格式
typedef struct ThreadPool {
    int thread_cnt;//线程数量
    pthread_t *tids;//创建线程id
    Queue *store;//队列仓库
    EnterFP enter;//线程真正的业务逻辑函数
    pthread_mutex_t hlock;//队头互斥锁
    pthread_mutex_t tlock;//队尾互斥锁
    pthread_cond_t empty;//空仓库条件变量
    pthread_cond_t full;//满仓库条件变量

} ThreadPool;

//创建线程池
ThreadPool *create_threadpool(int thread_cnt,int store_cap, EnterFP enter);

//启动线程池
void start_threadpool(ThreadPool *threadpool);
//生成数据
void push_threadpool(ThreadPool *threadpool, void *task);
//消费数据
void *pop_threadpool(ThreadPool *threadpool);
//销毁线程池
void destroy_threadpool(ThreadPool *threadpool);



#endif//THREADPOOL_H

pthread_pool.c

#include<stdlib.h>
#include "threadpool.h"

//线程池的线程的入口函数
static void *run(void *arg)
{
    ThreadPool *threadpool=(ThreadPool*)arg;
    while(1)
    {
        //线程就负责消费数据，能返回就意味着从仓库里拿到了数据
        void *task=pop_threadpool(threadpool);
        //拿到数据，去运行线程要执行的业务逻辑函数
        threadpool->enter(task);//？
    }
}
//消费数据



//创建线程池
ThreadPool *create_threadpool(int thread_cnt,int store_cap, EnterFP enter)
{
    //申请线程池内存
    ThreadPool*threadpool=malloc(sizeof(ThreadPool));
    //申请线程内存
    threadpool->tids=malloc(sizeof(pthread_t)*thread_cnt);
    //创建仓库队列
    threadpool->store=create_queue(store_cap);
    //初始化线程容量
    threadpool->thread_cnt=thread_cnt;
    //初始化线程业务逻辑函数
    threadpool->enter=enter;
    //初始化互斥锁，条件变量
    pthread_mutex_init(&threadpool->hlock,NULL);
    pthread_mutex_init(&threadpool->tlock,NULL);
    pthread_cond_init(&threadpool->empty,NULL);
    pthread_cond_init(&threadpool->full,NULL);
    return threadpool;
}
//启动线程池
void start_threadpool(ThreadPool *threadpool)
{
    for(int i=0;i<threadpool->thread_cnt;i++)
    {
        //创建线程
        pthread_create(&threadpool->tids[i],NULL,run,threadpool);
    }
}
//生成数据
void push_threadpool(ThreadPool *threadpool, void *task)
{
    //队尾加锁
    pthread_mutex_lock(&threadpool->tlock);
    //如果队满，不生产
    while(full_queue(threadpool->store))
    {
        //唤醒消费者数据的线程
        pthread_cond_signal(&threadpool->empty);
        //睡眠并解锁队尾
        pthread_cond_wait(&threadpool->full,&threadpool->tlock);
    }
    //生产数据存入队尾
    push_queue(threadpool->store,task);
    //唤醒一个消费者数据的线程
    pthread_cond_signal(&threadpool->empty);
    //队尾解锁
    pthread_mutex_unlock(&threadpool->tlock);
}
//消费数据
void *pop_threadpool(ThreadPool *threadpool)
{
      //队头加锁
    pthread_mutex_lock(&threadpool->hlock);
    //如果一直队空，不消费
    while(empty_queue(threadpool->store))
    {
        //唤醒生产者数据的线程
        pthread_cond_signal(&threadpool->full);
        //睡眠并解锁队头
        pthread_cond_wait(&threadpool->empty,&threadpool->hlock);
    
    }
    //消费数据
    void *task=front_queue(threadpool->store);

    pop_queue(threadpool->store);
    //唤醒一个生产者者数据的线程
    pthread_cond_signal(&threadpool->full);
    //队头解锁
    pthread_mutex_unlock(&threadpool->hlock);

    return task;
}
//销毁线程池
void destroy_threadpool(ThreadPool *threadpool)
{
    //结束线程池中所有的消费者线程
    for(int i=0;i<threadpool->thread_cnt;i++)
    {
        pthread_cancel(threadpool->tids[i]);
    }
    pthread_cond_destroy(&threadpool->empty);
    pthread_cond_destroy(&threadpool->full);
    pthread_mutex_destroy(&threadpool->hlock);
    pthread_mutex_destroy(&threadpool->tlock);
    destroy_queue(threadpool->store);
    free(threadpool->tids);
    free(threadpool);


}

3.线程池已经封装好了，先在来写服务器，和客户端来测试

    tcp_s.c:服务端

#include <stdio.h>
#include <stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>

#include"threadpool.h"
//业务逻辑
void enter(void*arg)
{
    int cli_fd=*(int*)arg;
    char buf[4096];
    size_t buf_size=sizeof(buf);

    for(;;)
    {
        int ret=recv(cli_fd,buf,buf_size,0);
        if(ret<=0||0==strcmp(buf,"quit"))
        {
            //关闭套接字
           close(cli_fd);
           //释放资源
           free(arg);
           printf("客户端退出\n");
           return;
        }
        printf("recv:%s bits:%d \n",buf,ret);
        strcat(buf,"return");

        ret=send(cli_fd,buf,strlen(buf)+1,0);
        if(ret<=0)
        {
            close(cli_fd);
            free(arg);
            printf("客户端退出\n");
            return;
        }

    }
}




int main(int argc,char *argv[]) {

    int svr_fd=socket(AF_INET,SOCK_STREAM,0);
    if(svr_fd<0)
    {
    printf("socket error\n");
    return -1;
    }

    struct sockaddr_in addr={};
    addr.sin_family=AF_INET;
    //字符串转化为数字
    addr.sin_port=htons(atoi(argv[2]));
    addr.sin_addr.s_addr=inet_addr(argv[1]);
    socklen_t addrlen=sizeof(addr);

    if(bind(svr_fd,(struct sockaddr*)&addr,addrlen))
    {
    printf("bind error\n");
    return -1;
    }
    //监听
    if(listen(svr_fd,10))
    {
        perror("listen error");
        return -1;
    }
    
    ThreadPool*threadpool=create_threadpool(10,20,enter);
    start_threadpool(threadpool);
    while(1)
    {
        //主线程这边相当于生产者
        int *cli_fd_p=malloc(sizeof(int));
        *cli_fd_p=accept(svr_fd,(struct sockaddr*)&addr,&addrlen);
        push_threadpool(threadpool,cli_fd_p);
   
    }

    


}

tcp_c.c 客户端

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/un.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <netinet/in.h>

typedef struct sockaddr *SP;

int main(int argc,const char* argv[])
{
    //创建socket
    int cli_fd=socket(AF_INET,SOCK_STREAM,0);
    if(cli_fd<0)
    {
        perror("socket");
        return -1;
    }
    //准备通信地址
    struct sockaddr_in addr={};
    addr.sin_family=AF_INET;
    addr.sin_port=htons(8888);
    addr.sin_addr.s_addr=inet_addr("127.0.0.1");
    socklen_t addrlen=sizeof(addr);
    //连接服务器
    if(connect(cli_fd,(SP)&addr,addrlen))
    {
        perror("connect");
        return -1;
    }

    char buf[4096];
    size_t buf_size=sizeof(buf);
    while(1)
    {
        //发送请求
        printf(">>>>>");
        scanf("%s",buf);
        int ret=send(cli_fd,buf,strlen(buf)+1,0);
        //ret=write(cli_fd,buf,strlen(buf)+1);
        if(ret<=0)
        {
            printf("服务器正在升级，请稍后重试\n");
            break;
        }
        if(0==strcmp("quit",buf))
        {
            printf("通信结束\n");
            break;
        }
        //接收请求
        //int ret=read(cli_fd,buf,buf_size);
        ret=recv(cli_fd,buf,buf_size,0);
        if(ret<=0)
        {
            printf("服务器正在维护，请稍候重试\n");
            break;
        }
        printf("read:%s bits:%d\n",buf,ret);
    }
        
    return 0;
}

4.下面看测试结果

我用了两个客户端

客户端1

客户端2

封装的线程成功！！！

晨曦丿
关注
java线程池封装j
08-13
Java线程池封装是Java并发编程中重要的一环，合理的线程池配置和封装能显著提升程序的性能和稳定性。理解线程池的工作原理，根据业务需求选择合适的参数，以及正确处理拒绝策略，都是实现高效并发处理的关键。在实际...
java线程池封装
05-24
java线程池封装，可自定义线程优先级，使用方便。。。
java多线程，对多线程，线程池进行封装，方便使用
05-16
总之，通过合理地封装和使用线程池，开发者可以更好地控制多线程环境，提高系统的稳定性和性能。在实际项目中，我们应该根据具体的需求选择合适的线程池配置，并对其进行监控和调优，确保系统的高效运行。
安卓，线程池的使用 ，封装
10-24
封装线程池时，建议创建一个工具类或单例模式的类，提供简单的接口供其他组件调用，如`execute(Runnable task)`、`submit(Callable<T> task)`等，以降低使用难度。 在实际开发中，线程池的封装和使用能够帮助我们更...
java常用工具类封装
09-14
"java常用工具类封装"是指将常见的功能如线程管理、数据解析、第三方库集成等进行封装，以提高代码的可重用性和可维护性。下面我们将深入探讨这些知识点： 1. **线程池**： Java中的线程池是由`java.util....
Javascript客户端时间与服务器时间
weixin_45740473的博客
10-06 372
这样，就可能会出现一个问题：我的电脑时间比正常时间要快，我访问一个页面，初始化打开时，默认 make_date 在 js 中使用 new Date() 生成，值是我电脑的时间。等页面提交，使用 Java 代码new Date() 生成 check_date，值是服务器时间。但是在Javascript 中使用new Date()，获取的却是访问该页面的客户端时间。在Java代码中使用new Date()，获取的是本机时间；为了解决这个问题，在js中使用如下代码获取服务器时间。
Linux的基本指令（3）
shylyly_的博客
10-04 1155
Linux的基本指令（3）date cal find whereis grep sort uniq zip unzip tar uname
[Linux]从零开始的网站搭建教程
c858845275的博客
10-02 1403
讲解了如何搭建运维面板安装web服务器和搭建一个自己的网站。
【Linux】进程地址空间(初步了解)
weixin_69380220的博客
10-04 1457
进程虚拟地址空间相关内容
黑马linux笔记（转载）
pscool的博客
10-01 2067
我们所熟知的计算机是由硬件和软件组成的。计算机系统中由电子、机械和光电元件等组成的各种物理装置的总称。（看的见、摸得着的东西：CPU、内存硬盘、显示屏、鼠标等）是用户和计算机硬件之间的接口和桥梁，用户通过软件和计算机进行交流。（操作系统，就是软件的一类）学习Linux系统，就需要有一个可用的Linux系统。由于Linux系统并不适合日常办公使用，所以我们需要借助虚拟机来获得可用的Linux系统环境进行学习。借助虚拟化技术，我们可以在系统中，通过软件：模拟计算机硬件，并给虚拟硬件安装真实的操作系统。
（Linux和数据库）1.Linux操作系统和常用命令
2301_79144798的博客
10-09 348
除了办公和玩游戏之外不用Linux，其他地方都要使用Linux（it相关）iOS的本质是unix（unix是付费版本的操作系统）unix和Linux之间很相似命令 选项 参数由这三部分组成 可以只有命令目录就是文件夹。
Linux中定时删除10天前的日志文件
pcj_888的博客
10-09 282
如题
Linux软硬链接
2301_76197086的博客
10-09 366
详解Linux系统软硬链接
Linux中设置cd命令后直接显示当前目录下的所有文件
IChen.的博客
10-08 280
Linux中cd命令后默认是不显示该目录下的文件的，略微不方便。换个环境经常遇到需要重新设置的情况，网上已有很多发帖了，这里主要汇总下比较简单且常见的bash与csh下的设置方法。
【Linux】进程第三弹（虚拟地址空间）
m0_73470633的博客
10-06 1086
Linux地址空间！
Linux之进程概念
bhbcdxb123的博客
09-30 2403
1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。正所谓：君子可内敛不可懦弱，面不公可起而论之。3.成年人的世界，只筛选，不教育。4.自律不是6点起床，7点准时学习，而是不管别人怎么说怎么看，你也会坚持去做，绝不打乱自己的节奏，是一种自我的恒心。5.你开始炫耀自己，往往都是灾难的开始，就像老子在《道德经》里写到：光而不耀，静水流深。
Linux 安装 yum
于高山之巅，方见大河奔涌；于群峰之上，更觉长风浩荡。
10-02 536
这里以 CentOS 7 为例在终端依次执行上述三条命令，下载 yum 的安装包。
03. prometheus 监控 Linux 主机
最新发布
kezhou的博客
10-09 362
这里监控的是本机主机；如果要监控远程主机，还需要打开远程主机的 9100 端口才可以访问收集到的信息，可参考后文内容——二、防火墙打开端口。官网：https://prometheus.io/download/上述添加的规则重启后会失效，还需持久化。如：127.0.0.1:9100/metrics。
Linux中的多线程
2301_77479435的博客
10-05 1016
Linux中的多线程
spring封装的线程池
05-23
Spring框架中提供了一个ThreadPoolTaskExecutor类，用于封装线程池。使用该类可以很方便地创建线程池并管理线程池中的线程。 下面是一个简单的例子： ```java @Configuration @EnableAsync public class MyConfig implements AsyncConfigurer { @Override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(10); // 核心线程数 executor.setMaxPoolSize(20); // 最大线程数 executor.setQueueCapacity(200); // 队列容量 executor.setThreadNamePrefix("MyExecutor-"); // 线程前缀 executor.initialize(); return executor; } @Override public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { return (throwable, method, objects) -> { // 异常处理逻辑 }; } } ``` 在上面的例子中，我们使用了@Configuration和@EnableAsync注解来开启异步处理功能。然后实现了AsyncConfigurer接口，重写了getAsyncExecutor()方法来创建一个线程池。 ThreadPoolTaskExecutor类有很多属性可以配置，比如核心线程数、最大线程数、队列容量、线程前缀等。最后需要调用initialize()方法来初始化线程池。 除了线程池的配置外，我们还可以通过重写getAsyncUncaughtExceptionHandler()方法来设置异步任务的异常处理器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值