面试C/C++岗位的时候，避免不了讨论多线程的问题。什么时候该使用多线程，通过几个案例来彻底搞明白。

1、多线程的处理效率一定高？

真不一定！

以TCP服务器处理客户端的数量为例（并发量），操作系统是安装Redhat的虚拟机，单核1G内存，很明显，硬件的性能一般。

方案一：为每个客户端启动一个线程

server.c

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

void *client_handler(void *arg)
{
  int fd = (int)arg;
  char buf[1024] = {0};
  while (1)
  {
    if (recv(fd, buf, 1024, 0) <= 0)
    {
      break;
    }
    printf("%s from %d\n", buf, fd);
    memset(buf, 0, 1024);
  }
}

int main()
{
  int sockfd = socket(PF_INET, SOCK_STREAM, 0);
  if (-1 == sockfd)
  {
    perror("socket");
    exit(1);
  }

  struct sockaddr_in server_info;    
  server_info.sin_family = PF_INET;   
  server_info.sin_port   = htons(5000);   
  server_info.sin_addr.s_addr = inet_addr("127.0.0.1"); 
  if (bind(sockfd, (struct sockaddr *)&server_info, sizeof(server_info)) < 0)
  {
    perror("bind");
    exit(1);
  }

  if (listen(sockfd, 10) < 0)   
  {
    perror("listen");
    exit(1);
  }

  printf("等待客户端的连接\n");

  struct sockaddr_in client_info;   
  int length = sizeof(client_info);
  while (1)
  {
    int fd = accept(sockfd, (struct sockaddr *)&client_info, &length);
    if (-1 == fd)
    {
      perror("accept");
      exit(1);
    }

    printf("接受客户端的连接 fd = %d\n", fd);

    //为每一个客户端启动一个线程
    pthread_t tid;
    if (pthread_create(&tid, NULL, client_handler, (void *)fd) != 0)
    {
      perror("pthread_create");
      exit(1);
    }

    pthread_detach(tid);
  }

  return 0;
}

在其他设备上通过脚本启动多个客户端，测试服务器的并发量。

测试结果如下：

接受客户端的连接 fd = 303
接受客户端的连接 fd = 304
接受客户端的连接 fd = 305
接受客户端的连接 fd = 306
接受客户端的连接 fd = 307
pthread_create: Cannot allocate memory
[root@turbo net]#

当接受304个客户端（客户端对应的文件描述符从4开始）连接的时候，服务器程序退出，退出原因是创建线程的的时候内存用尽。

同样的服务器程序，放在云服务器（单核2G内存）上运行，测试结果如下：

接受客户端的连接 fd = 1614
接受客户端的连接 fd = 1615
接受客户端的连接 fd = 1616
接受客户端的连接 fd = 1617
接受客户端的连接 fd = 1618
接受客户端的连接 fd = 1619
...

虽然越往后越慢，但是程序依然在运行，能接受的客户端数量明显大于虚拟机的测试结果。

可以得出结论：

多线程对系统性能要求比较高（包括内存和核心数），随着线程数量越来越多，系统性能逐渐下降。

方案二：使用多路IO复用（select）处理多个客户端（单线程），测试环境还是虚拟机。多路IO复用可以理解成是一个循环，不断检测是否有任务发生。

server.c

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

int main()
{
  int sockfd = socket(PF_INET, SOCK_STREAM, 0);
  if (-1 == sockfd)
  {
    perror("socket");
    exit(1);
  }

  struct sockaddr_in server_addr;
  memset(&server_addr, 0, sizeof(server_addr));
  server_addr.sin_family = PF_INET;    
  server_addr.sin_port = htons(5000);        
  server_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); 


  if(bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
  {
    perror("bind");
    exit(1);
  }

  if (listen(sockfd, 10) < 0)
  {
    perror("listen");
    exit(1);
  }
  
  fd_set ReadSet, tmpSet;
  FD_ZERO(&ReadSet);
  FD_ZERO(&tmpSet);

  FD_SET(sockfd, &ReadSet);

  int maxfd = sockfd;
  int fd[1024] = {0}, i = 0;
  char buf[32] = {0};

  struct sockaddr_in client_addr;   
  int length = sizeof(client_addr);

  while (1)
  {
    tmpSet = ReadSet;
    ret = select(maxfd + 1, &tmpSet, NULL, NULL, NULL);  
    if (-1 == ret)
    {
      perror("select");
    }
  
    if (FD_ISSET(sockfd, &tmpSet))   //有客户端发起连接
    {                                
      //接受客户端的连接   
      for (i = 0; i < 1024; i++)
      {
        if (fd[i] == 0)
        {
          break;
        }
      }
      fd[i] = accept(sockfd, (struct sockaddr *)&client_addr, &length);
      if (-1 == fd[i])
      {
        perror("accept");
        exit(1);
      }

      printf("接受客户端的连接 fd = %d\n", fd[i]);

      //把新的文件描述符加到集合中
      FD_SET(fd[i], &ReadSet);

      //更新maxfd
      if (fd[i] > maxfd)
      {
        maxfd = fd[i];
      }
    }
    else                 //处理客户端发送来的数据
    {
      int i;
      for (i = 0; i < 1024; i++)
      {
        if (FD_ISSET(fd[i], &tmpSet))
        {
          if (recv(fd[i], buf, sizeof(buf), 0) < 0)
          {
            //把文件描述符从集合中踢掉
            FD_CLR(fd[i], &ReadSet);
            close(fd[i]);
            fd[i] = 0;
            break;
          }
          printf("收到客户端的数据 %s\n", buf);
          memset(buf, 0, sizeof(buf));
          break;
        }
      }
    }
  }

  return 0;
}

使用同样的客户端，测试的结果如下：

接受客户端的连接 fd = 414
接受客户端的连接 fd = 415
接受客户端的连接 fd = 416
接受客户端的连接 fd = 417
接受客户端的连接 fd = 418
...

由于越往后运行越慢，没有继续等，不过已经超过多线程方案的并发量。

可以得出结论：

系统性能一般的情况下，多路IO复用（单线程）的并发量高于多线程的并发量。因为单线程消耗的资源更少。但是能不能认为多线程处理的速度更快？也不一定，因为线程之间切换也需要时间。

相关视频推荐

epoll实战揭秘-支撑亿级io的底层基石【c++后台开发】

为什么不推荐做mcu与qt开发，c++后台开发很香吗？

学习地址：C/C++Linux服务器开发/后台架构师【零声教育】-学习视频教程-腾讯课堂

需要C/C++ Linux服务器架构师学习资料加qun812855908获取（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享

2、什么时候需要使用多线程？

情景1：TCP客户端既能向服务器发送数据，也能从服务器接收数据，即一个程序要同时完成两件事情。

void *send_thread(void *arg)
{
}
void *recv_thread(void *arg)
{
}
int main()
{
  /*向服务器发起连接*/
  
  pthread_t tid[2];
  pthread_create(&tid[0], NULL, send_thread, NULL);
  pthread_create(&tid[1], NULL, recv_thread, NULL);
  
  void *status;
  pthread_join(tid[0], &status);
  pthread_join(tid[1], &status);
  
  return 0;
}

情景2：处理费时的任务。如果把费时的任务交给主线程来完成，要等到主线程处理完成才能处理其他任务。很明显用起来会有一种卡顿的感觉。

int main()
{
  while (1)
  {
    tmpSet = ReadSet;
    ret = select(maxfd + 1, &tmpSet, NULL, NULL, NULL);  
    if (-1 == ret)
    {
      perror("select");
    }
  
    if (FD_ISSET(sockfd, &tmpSet))   //有客户端发起连接
    {                                
      //接受客户端的连接
    }
    else                 //处理客户端发送来的数据
    {
      int i;
      for (i = 0; i < 1024; i++)
      {
        if (FD_ISSET(fd[i], &tmpSet))
        {
          //处理费时的任务 可以交给线程
          pthread_create();
        }
      }
    }
  }

  return 0;
}

情景3：处理阻塞的操作，比如IO，主线程要等到条件满足才能继续向下走，这段时间纯属浪费。

int main()
{
  while (1)
  {
    tmpSet = ReadSet;
    ret = select(maxfd + 1, &tmpSet, NULL, NULL, NULL);  
    if (-1 == ret)
    {
      perror("select");
    }
  
    if (FD_ISSET(sockfd, &tmpSet))   //有客户端发起连接
    {                                
      //接受客户端的连接
    }
    else                 //处理客户端发送来的数据
    {
      int i;
      for (i = 0; i < 1024; i++)
      {
        if (FD_ISSET(fd[i], &tmpSet))
        {
          //处理阻塞的任务 可以交给线程
          pthread_create();
        }
      }
    }
  }

  return 0;
}

3、多线程有哪些缺点？

1. 如果有大量的线程，会影响性能，因为操作系统需要在它们之间切换；
2. 更多的线程需要更多的内存空间；
3. 多线程访问共享数据往往需要加锁来实现线程的同步，这就得考虑死锁情况的发生。

总结：

多线程不一定是最佳的解决方案，使用多线程还需要考虑服务器本身性能，比如内存、核心数；如果只是单核的CPU，能用单线程，就不必使用多线程。