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

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

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
关注
C++ 多进程多线程间通信
wy749929317的博客
07-05 1688
请注意，这里的互斥锁是在全局命名空间中创建的（通过前缀"Global\\"），这意味着它可以在系统范围内的任何进程中访问。这是必需的，因为我们的目标是让多个不同的进程能够识别并访问同一个互斥锁。请注意，我们使用了全局命名的信号量（通过前缀Global\），这意味着信号量在整个系统中都是可见的，可以被任何进程访问。特点：它是最快的进程间通信方式，避免了数据的拷贝，但共享内存需要解决并发访问和同步问题，常用的同步机制包括互斥锁（Mutexes）、信号量（Semaphores）和事件（Events）等。
C++多线程常用的几种实现方式
最新发布
qq_41920323的博客
08-01 1166
C++多线程常用的几种实现方式
C++实现多线程通信
11-17
C++实现多线程通信
多线程编程之三——线程间通讯
抓狂的石头
06-28 3233
作者：韩耀旭七、线程间通讯　　一般而言,应用程序中的一个次要线程总是为主线程执行特定的任务,这样,主线程和次要线程间必定有一个信息传递的渠道,也就是主线程和次要线程间要进行通信。这种线程间的通信不但是难以避免的，而且在多线程编程中也是复杂和频繁的，下面将进行说明。 使用全局变量进行通信由于属于同一个进程的各个线程共享操作系统分配该进程的资源，故解决线程间通信最简单的一种方法
10分钟，带你掌握C++多线程同步！
weixin_34018202的博客
04-25 1424
摘要：本文介绍了C++11中如何开启新线程，并详细讲解了线程的基础同步原语：mutex, lock_guard, unique_lock, condition variable和semaphore等。如何采用async, packaged_task和promise实现future同步机制？怎样处理spurious wakeup?本文以质数判定服务为例...
C++多线程通信
a22025340的博客
04-11 3100
条件变量condition_variable wait()是condition_variable的成员函数 void wait (unique_lock& lck)会无条件的阻塞当前线程然后等待通知，前提是此时对象lck已经成功获取了锁。等待时会调用lck.unlock()释放锁，使其它线程可以获取锁。一旦得到通知(由其他线程显式地通知)，函数就会释放阻塞并调用lck.lock()，使lck保持与调用函数时相同的状态。然后函数返回，注意，最后一次lck.lock()的调用可能会在返回前再次阻塞线
c++ 线程间通信方式
weixin_30527423的博客
04-28 475
一：两个进程间的两个线程通信，相当于进程间通信 二：一个进程中的两个线程间通信 　　通信方式： 1.互斥锁 　　mutex; 　　lock_guard (在构造函数里加锁，在析构函数里解锁） 　　unique_lock自动加锁、解锁 2.读写锁 　　shared_lock 3.信号量 　　c++11中未实现，可以自己使用mutex和conditon_varia...
c++ 多线程线程池 demo
03-02
在C++编程中，多线程技术是一种提升程序性能的有效手段，特别是在处理大量并发任务时。线程池是多线程编程中一个重要的概念，它能够优化系统资源的...这有助于我们更好地理解和应用线程池，优化我们的C++多线程程序。
c++11线程与线程池Demo 完整vs2013工程
12-09
总的来说，这个压缩包中的内容涵盖了C++11的多线程编程基础，特别是线程池的实现，这对于学习和理解并发编程以及提升程序效率具有很高的价值。通过分析和运行这个示例工程，开发者不仅可以深化对C++11线程API的理解...
c++多线程线程池服务端和客户端例子
09-13
在给定的"C++多线程线程池服务端和客户端例子"中，我们可以深入探讨以下几个关键知识点： 1. **C++11多线程库**: C++11标准引入了`<thread>`库，提供了对多线程的支持。在这个例子中，我们可能会看到如何创建和管理...
VS2017实现Tcp socket多线程通信（C++）
05-01
包括TCP服务器客户端多线程通信程序（用select实现），基于Visual Studio2017实现，已编译测试过，用到的朋友记得关闭SDL检查
C++ 多线程通信方式简介并结合生产者-消费者模式代码实现
10-15
C++ 多线程通信方式简介并结合生产者-消费者模式代码实现
Pool_Thread.rar_C 线程池_thread pool_多线程 队列_控制台多线程_线程池 队列
09-21
在多线程编程中，线程池通常会维护一个工作队列，用于存储待处理的任务。当线程完成一个任务后，它不会立即终止，而是检查队列中是否有其他任务可执行。如果有，线程会取下一个任务并继续执行；如果没有，线程可能...
c++中的多线程通信
LW_12345的博客
09-09 612
【代码】c++中的多线程通信。
C++线程通信
weixin_43803780的博客
05-03 1047
通常与互斥锁配合使用，通过`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()`手动控制加锁和解锁。
【5】c++多线程技术之线程间通信
以道御术
04-12 287
线程间通信是多线程编程中的一个重要概念，它指的是在一个程序中的多个线程之间传递信息或者同步执行的过程。在C++中，有多种方式可以实现线程间的通信。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值