C++多线程通信（线程池）

最新推荐文章于 2025-03-31 11:41:48 发布
最新推荐文章于 2025-03-31 11:41:48 发布
阅读量787 收藏 2
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq1186351245/article/details/130475349
版权
该代码示例展示了如何使用线程池来处理客户端的并发连接。服务器端创建了一个监听套接字，接受客户端连接后将任务添加到线程池中进行处理。客户端则负责建立连接并进行数据收发。线程池管理包括动态增减工作线程，以适应任务负载变化。

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

server.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include "threadpool.h"

// 信息结构体
struct SockInfo
{
  struct sockaddr_in addr;
  int fd;
};

typedef struct PoolInfo
{
  ThreadPool *p;
  int fd;
} PoolInfo;

void working(void *arg);
void acceptConn(void *arg);

int main()
{

  // 1.创建监听的套接字
  int fd = socket(AF_INET, SOCK_STREAM, 0);
  if (fd == -1)
  {
    perror("socket");
    return -1;
  }

  // 2.绑定本地的IP port
  struct sockaddr_in saddr;
  saddr.sin_family = AF_INET;
  saddr.sin_port = htons(9999);
  saddr.sin_addr.s_addr = INADDR_ANY; // 0 = 0.0.0.0 对于0来说，大端和小端是没有区别的
  int ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));

  if (ret == -1)
  {
    perror("bind");
    return -1;
  }

  // 3.设置监听
  ret = listen(fd, 128);
  if (ret == -1)
  {
    perror("listen");
    return -1;
  }


  // 创建线程池
  ThreadPool *pool = threadPoolCreate(3, 8, 100);
  PoolInfo *info = (PoolInfo *)malloc(sizeof(PoolInfo));
  info->p = pool;
  info->fd = fd;
  threadPoolAdd(pool, acceptConn, info);

  pthread_exit(NULL);//主线程退出了，不会影响线程池里所有的线程运行

  return 0;
}

void acceptConn(void *arg)
{
  PoolInfo *poolInfo = (PoolInfo *)arg;
  // 4.阻塞并等待客户端的连接
  int addrlen = sizeof(struct sockaddr_in);
  while (1)
  {
    struct SockInfo *pinfo;
    pinfo = (struct SockInfo *)malloc(sizeof(struct SockInfo));
    pinfo->fd = accept(poolInfo->fd, (struct sockaddr *)&pinfo->addr, &addrlen); // caddr ip是大端，要看192的，需转换成小端

    if (pinfo->fd == -1)
    {
      perror("accept");
      break;
    }
    // 添加通信的任务
    threadPoolAdd(poolInfo->p, working, pinfo);
  }
  close(poolInfo->fd);
}

void working(void *arg)
{
  struct SockInfo *pinfo = (struct SockInfo *)arg;
  // 连接建立成功，打印客户端的IP和端口信息
  char ip[32];
  printf("客户端的IP：%s,端口：%d\n",
         inet_ntop(AF_INET, &pinfo->addr.sin_addr.s_addr, ip, sizeof(ip)),
         ntohs(pinfo->addr.sin_port));
  // 5.通信
  while (1)
  {
    // 接收数据
    char buff[1024];
    int len = recv(pinfo->fd, buff, sizeof(buff), 0);
    if (len > 0)
    {
      printf("client say: %s\n", buff);
      send(pinfo->fd, buff, len, 0);
    }
    else if (len == 0)
    {
      printf("客户端已经断开了连接...\n");
      break;
    }
    else
    {
      perror("recv");
      break;
    }
  }

  // 关闭文件描述符
  close(pinfo->fd);
}

client.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>

int main()
{

  // 1.创建通信的套接字
  int fd = socket(AF_INET, SOCK_STREAM, 0);
  if (fd == -1)
  {
    perror("socket");
    return -1;
  }

  // 2.绑定服务器的IP port
  struct sockaddr_in saddr;
  saddr.sin_family = AF_INET;
  saddr.sin_port = htons(9999);
  inet_pton(AF_INET, "192.168.31.128", &saddr.sin_addr.s_addr); // 绑定服务器的ip
  int ret = connect(fd, (struct sockadddr *)&saddr, sizeof(saddr));
  if (ret == -1)
  {
    perror("connect");
    return -1;
  }

  // 3.通信
  int number = 0;
  while (1)
  {
    // 发送数据
    char buff[1024];
    sprintf(buff, "你好，hello,world,%d...\n", number++);
    send(fd, buff, strlen(buff) + 1, 0);

    //接收数据
    memset(buff,0,sizeof(buff));
    int len = recv(fd, buff, sizeof(buff), 0);
    if (len > 0)
    {
      printf("server say: %s\n", buff);
    }
    else if (len == 0)
    {
      printf("服务器已经断开了连接...\n");
      break;
    }
    else
    {
      perror("recv");
      break;
    }
    sleep(1);
  }

  // 关闭文件描述符
  close(fd);

  return 0;
}

threadpool.h

#ifndef _THREADPOOL_H
#define _THREADPOOL_H

typedef struct ThreadPool ThreadPool;
// 创建线程池并初始化
ThreadPool *threadPoolCreate(int min, int max, int queueSize);

// 销毁线程池
int threadPoolDestroy(ThreadPool* pool);

// 给线程池添加任务
void threadPoolAdd(ThreadPool* pool, void(*func)(void*), void* arg);

// 获取线程池中工作的线程的个数
int threadPoolBusyNum(ThreadPool* pool);

// 获取线程池中活着的线程的个数
int threadPoolAliveNum(ThreadPool* pool);

//
// 工作的线程(消费者线程)任务函数
void* worker(void* arg);
// 管理者线程任务函数
void* manager(void* arg);
// 单个线程退出
void threadExit(ThreadPool* pool);
#endif  // _THREADPOOL_H

threadpool.c

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

const int NUMBER = 2;
// 任务结构体
typedef struct Task
{
    void (*function)(void *arg);
    void *arg;
} Task;

// 线程池结构体
struct ThreadPool
{
    // 任务队列
    Task *taskQ;
    int queueCapacity; // 容量
    int queueSize;     // 当前任务个数
    int queueFront;    // 队头 -> 取数据
    int queueRear;     // 队尾 -> 放数据

    pthread_t managerID;       // 管理者线程ID
    pthread_t *threadIDs;      // 工作的线程ID
    int minNum;                // 最小线程数量
    int maxNum;                // 最大线程数量
    int busyNum;               // 忙的线程的个数
    int liveNum;               // 存活的线程的个数
    int exitNum;               // 要销毁的线程个数
    pthread_mutex_t mutexPool; // 锁整个的线程池
    pthread_mutex_t mutexBusy; // 锁busyNum变量
    pthread_cond_t notFull;    // 任务队列是不是满了
    pthread_cond_t notEmpty;   // 任务队列是不是空了

    int shutdown; // 是不是要销毁线程池, 销毁为1, 不销毁为0
};

ThreadPool *threadPoolCreate(int min, int max, int queueSize)
{
    ThreadPool *pool = (ThreadPool *)malloc(sizeof(ThreadPool));
    do
    {
        if (pool == NULL)
        {
            printf("malloc threadpool fail...\n");
            break;
        }

        pool->threadIDs = (pthread_t *)malloc(sizeof(pthread_t) * max);
        if (pool->threadIDs == NULL)
        {
            printf("malloc threadIDs fail...\n");
            break;
        }
        memset(pool->threadIDs, 0, sizeof(pthread_t) * max);
        pool->minNum = min;
        pool->maxNum = max;
        pool->busyNum = 0;
        pool->liveNum = min; // 和最小个数相等
        pool->exitNum = 0;

        if (pthread_mutex_init(&pool->mutexPool, NULL) != 0 ||
            pthread_mutex_init(&pool->mutexBusy, NULL) != 0 ||
            pthread_cond_init(&pool->notEmpty, NULL) != 0 ||
            pthread_cond_init(&pool->notFull, NULL) != 0)
        {
            printf("mutex or condition init fail...\n");
            break;
        }

        // 任务队列
        pool->taskQ = (Task *)malloc(sizeof(Task) * queueSize);
        pool->queueCapacity = queueSize;
        pool->queueSize = 0;
        pool->queueFront = 0;
        pool->queueRear = 0;

        pool->shutdown = 0;

        // 创建线程
        pthread_create(&pool->managerID, NULL, manager, pool);
        for (int i = 0; i < min; ++i)
        {
            pthread_create(&pool->threadIDs[i], NULL, worker, pool);
        }
        return pool;
    } while (0);

    // 释放资源
    if (pool && pool->threadIDs)
        free(pool->threadIDs);
    if (pool && pool->taskQ)
        free(pool->taskQ);
    if (pool)
        free(pool);

    return NULL;
}

int threadPoolDestroy(ThreadPool *pool)
{
    if (pool == NULL)
    {
        return -1;
    }

    // 关闭线程池
    pool->shutdown = 1;
    // 阻塞回收管理者线程
    pthread_join(pool->managerID, NULL);
    // 唤醒阻塞的消费者线程
    for (int i = 0; i < pool->liveNum; ++i)
    {
        pthread_cond_signal(&pool->notEmpty);
    }
    // 释放堆内存
    if (pool->taskQ)
    {
        free(pool->taskQ);
    }
    if (pool->threadIDs)
    {
        free(pool->threadIDs);
    }

    pthread_mutex_destroy(&pool->mutexPool);
    pthread_mutex_destroy(&pool->mutexBusy);
    pthread_cond_destroy(&pool->notEmpty);
    pthread_cond_destroy(&pool->notFull);

    free(pool);
    pool = NULL;

    return 0;
}

void threadPoolAdd(ThreadPool *pool, void (*func)(void *), void *arg)
{
    pthread_mutex_lock(&pool->mutexPool);
    while (pool->queueSize == pool->queueCapacity && !pool->shutdown)
    {
        // 阻塞生产者线程
        pthread_cond_wait(&pool->notFull, &pool->mutexPool);
    }
    if (pool->shutdown)
    {
        pthread_mutex_unlock(&pool->mutexPool);
        return;
    }
    // 添加任务
    pool->taskQ[pool->queueRear].function = func;
    pool->taskQ[pool->queueRear].arg = arg;
    pool->queueRear = (pool->queueRear + 1) % pool->queueCapacity;
    pool->queueSize++;

    pthread_cond_signal(&pool->notEmpty);
    pthread_mutex_unlock(&pool->mutexPool);
}

int threadPoolBusyNum(ThreadPool *pool)
{
    pthread_mutex_lock(&pool->mutexBusy);
    int busyNum = pool->busyNum;
    pthread_mutex_unlock(&pool->mutexBusy);
    return busyNum;
}

int threadPoolAliveNum(ThreadPool *pool)
{
    pthread_mutex_lock(&pool->mutexPool);
    int aliveNum = pool->liveNum;
    pthread_mutex_unlock(&pool->mutexPool);
    return aliveNum;
}

void *worker(void *arg)
{
    ThreadPool *pool = (ThreadPool *)arg;

    while (1)
    {
        pthread_mutex_lock(&pool->mutexPool);
        // 当前任务队列是否为空
        while (pool->queueSize == 0 && !pool->shutdown)
        {
            // 阻塞工作线程
            pthread_cond_wait(&pool->notEmpty, &pool->mutexPool);

            // 判断是不是要销毁线程
            if (pool->exitNum > 0)
            {
                pool->exitNum--;
                if (pool->liveNum > pool->minNum)
                {
                    pool->liveNum--;
                    pthread_mutex_unlock(&pool->mutexPool);
                    threadExit(pool);
                }
            }
        }

        // 判断线程池是否被关闭了
        if (pool->shutdown)
        {
            pthread_mutex_unlock(&pool->mutexPool);
            threadExit(pool);
        }

        // 从任务队列中取出一个任务
        Task task;
        task.function = pool->taskQ[pool->queueFront].function;
        task.arg = pool->taskQ[pool->queueFront].arg;
        // 移动头结点
        pool->queueFront = (pool->queueFront + 1) % pool->queueCapacity;
        pool->queueSize--;
        // 解锁
        pthread_cond_signal(&pool->notFull);
        pthread_mutex_unlock(&pool->mutexPool);

        printf("thread %ld start working...\n", pthread_self());
        pthread_mutex_lock(&pool->mutexBusy);
        pool->busyNum++;
        pthread_mutex_unlock(&pool->mutexBusy);
        task.function(task.arg);
        free(task.arg);
        task.arg = NULL;

        printf("thread %ld end working...\n", pthread_self());
        pthread_mutex_lock(&pool->mutexBusy);
        pool->busyNum--;
        pthread_mutex_unlock(&pool->mutexBusy);
    }
    return NULL;
}

void *manager(void *arg)
{
    ThreadPool *pool = (ThreadPool *)arg;
    while (!pool->shutdown)
    {
        // 每隔3s检测一次
        sleep(3);

        // 取出线程池中任务的数量和当前线程的数量
        pthread_mutex_lock(&pool->mutexPool);
        int queueSize = pool->queueSize;
        int liveNum = pool->liveNum;
        pthread_mutex_unlock(&pool->mutexPool);

        // 取出忙的线程的数量
        pthread_mutex_lock(&pool->mutexBusy);
        int busyNum = pool->busyNum;
        pthread_mutex_unlock(&pool->mutexBusy);

        // 添加线程
        // 任务的个数>存活的线程个数 && 存活的线程数<最大线程数
        if (queueSize > liveNum - busyNum && liveNum < pool->maxNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            int counter = 0;
            for (int i = 0; i < pool->maxNum && counter < NUMBER && pool->liveNum < pool->maxNum; ++i)
            {
                if (pool->threadIDs[i] == 0)
                {
                    pthread_create(&pool->threadIDs[i], NULL, worker, pool);
                    counter++;
                    pool->liveNum++;
                }
            }
            pthread_mutex_unlock(&pool->mutexPool);
        }
        // 销毁线程
        // 忙的线程*2 < 存活的线程数 && 存活的线程>最小线程数
        if (busyNum * 2 < liveNum && liveNum > pool->minNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            pool->exitNum = NUMBER;
            pthread_mutex_unlock(&pool->mutexPool);
            // 让工作的线程自杀
            for (int i = 0; i < NUMBER; ++i)
            {
                pthread_cond_signal(&pool->notEmpty);
            }
        }
    }
    return NULL;
}

void threadExit(ThreadPool *pool)
{
    pthread_t tid = pthread_self();
    for (int i = 0; i < pool->maxNum; ++i)
    {
        if (pool->threadIDs[i] == tid)
        {
            pool->threadIDs[i] = 0;
            printf("threadExit() called, %ld exiting...\n", tid);
            break;
        }
    }
    pthread_exit(NULL);
}

线程池：

任务队列；

 

工作流程；

管理者线程。

田一一er
关注
【5】c++多线程技术之线程间通信
以道御术
04-12 524
线程间通信是多线程编程中的一个重要概念，它指的是在一个程序中的多个线程之间传递信息或者同步执行的过程。在C++中，有多种方式可以实现线程间的通信。
C++实现多线程通信
11-17
C++实现多线程通信
多线程编程之三——线程间通讯
抓狂的石头
06-28 3284
作者：韩耀旭七、线程间通讯　　一般而言,应用程序中的一个次要线程总是为主线程执行特定的任务,这样,主线程和次要线程间必定有一个信息传递的渠道,也就是主线程和次要线程间要进行通信。这种线程间的通信不但是难以避免的，而且在多线程编程中也是复杂和频繁的，下面将进行说明。 使用全局变量进行通信由于属于同一个进程的各个线程共享操作系统分配该进程的资源，故解决线程间通信最简单的一种方法
线程与进程编程：C++中的五种通信方式、死锁及Win32多线程详解
最新发布
re1ife的博客
03-31 1177
线程与进程编程：C++中的五种通信方式及Win32多线程详解
C++多线程通信
a22025340的博客
04-11 3178
条件变量condition_variable wait()是condition_variable的成员函数 void wait (unique_lock& lck)会无条件的阻塞当前线程然后等待通知，前提是此时对象lck已经成功获取了锁。等待时会调用lck.unlock()释放锁，使其它线程可以获取锁。一旦得到通知(由其他线程显式地通知)，函数就会释放阻塞并调用lck.lock()，使lck保持与调用函数时相同的状态。然后函数返回，注意，最后一次lck.lock()的调用可能会在返回前再次阻塞线
10分钟，带你掌握C++多线程同步！
weixin_34018202的博客
04-25 1478
摘要：本文介绍了C++11中如何开启新线程，并详细讲解了线程的基础同步原语：mutex, lock_guard, unique_lock, condition variable和semaphore等。如何采用async, packaged_task和promise实现future同步机制？怎样处理spurious wakeup?本文以质数判定服务为例...
c++ 线程间通信方式
weixin_30527423的博客
04-28 530
一：两个进程间的两个线程通信，相当于进程间通信 二：一个进程中的两个线程间通信 　　通信方式： 1.互斥锁 　　mutex; 　　lock_guard (在构造函数里加锁，在析构函数里解锁） 　　unique_lock自动加锁、解锁 2.读写锁 　　shared_lock 3.信号量 　　c++11中未实现，可以自己使用mutex和conditon_varia...
c++ 多线程线程池 demo
03-02
在C++编程中，多线程技术是一种提升程序性能的有效手段，特别是在处理大量并发任务时。线程池是多线程编程中一个重要的概念，它能够优化系统资源的...这有助于我们更好地理解和应用线程池，优化我们的C++多线程程序。
C++之线程、线程池
专注
03-16 770
std::thread 在 <thread> 头文件中声明，因此使用 std::thread 时需要包含 <thread> 头文件。
C++多线程与线程池实战案例解析
VC++（Visual C++）作为微软提供的一个集成开发环境（IDE），对C++语言有着强大的支持，包括多线程的开发。 ### 知识点一：多线程概念与实现 #### 1. 多线程基本概念 多线程指的是在一个程序中同时运行多个线程来...
c++11线程与线程池Demo 完整vs2013工程
12-09
总的来说，这个压缩包中的内容涵盖了C++11的多线程编程基础，特别是线程池的实现，这对于学习和理解并发编程以及提升程序效率具有很高的价值。通过分析和运行这个示例工程，开发者不仅可以深化对C++11线程API的理解...
QT多线程（线程池）的使用
10-31
在QT中，线程池是一种有效的多线程管理机制，它可以帮助开发者简化多线程的管理和任务调度。本文将详细介绍QT中多线程以及线程池的使用方法，希望能够帮助开发者在实际项目中更好地应用这一技术。 QT的多线程模型...
VS2017实现Tcp socket多线程通信（C++）
05-01
包括TCP服务器客户端多线程通信程序（用select实现），基于Visual Studio2017实现，已编译测试过，用到的朋友记得关闭SDL检查
C++ 多线程通信方式简介并结合生产者-消费者模式代码实现
10-15
C++ 多线程通信方式简介并结合生产者-消费者模式代码实现
C++线程通信
weixin_43803780的博客
05-03 1469
通常与互斥锁配合使用，通过`std::condition_variable::wait()`、`std::condition_variable::notify_one()`和`std::condition_variable::notify_all()`进行线程间的同步与唤醒。- 使用`std::lock_guard`或`std::unique_lock`自动管理锁的生命周期，或者直接使用`std::mutex::lock()`和`std::mutex::unlock()`手动控制加锁和解锁。
c++中的多线程通信
LW_12345的博客
09-09 671
【代码】c++中的多线程通信。
C++ 多线程之间的通信方式(windows下实现)
热门推荐
lizhenwei0219的博客
07-18 2万+
最近学习了C++ 多线程之间的通信方式,记录一下。 参考原文:https://blog.youkuaiyun.com/eulb/article/details/2177500 C++线程的通信方式有很多种,这里记录一下常用的几种: 1.全局变量 2.互斥量 3.信号量 4.事件 5.临界区 1.全局变量 通过全局变量进行通信,要对该变量加关键字volatile volatile(易变的):每...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值