Linux 多线程的应用

最新推荐文章于 2022-09-20 17:00:52 发布

行孤、

最新推荐文章于 2022-09-20 17:00:52 发布

阅读量170

点赞数

分类专栏：网络编程

本文链接：https://blog.csdn.net/qq_43403759/article/details/114961835

版权

网络编程专栏收录该内容

23 篇文章 5 订阅

订阅专栏

前面的章节介绍socket通信的时候，socket的服务端在同一时间只能和一个客户端通信，并不是服务端有多忙，而是因为第单进程的程序在同一时间只能做一件事情，不能一边等待客户端的新连接一边与其他的客户端进行通信。
在这里插入图片描述

一.并发的服务端

如果把 socket 服务端改为多进程，在每次 accept 到一个客户端的连接后，生成一个子进程，让子进程负责和这个客户端通信，父进程继续 accept 客户端的连接。socket 的服务端在监听新客户端的同时，还可以与多个客户端进行通信。这就是并发，如下图

在这里插入图片描述

1.多进程的服务端代码

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
 
class CTcpServer
{
public:
  int m_listenfd;   // 服务端用于监听的socket
  int m_clientfd;   // 客户端连上来的socket
 
  CTcpServer();
 
  bool InitServer(int port);  // 初始化服务端
 
  bool Accept();  // 等待客户端的连接
 
  // 向对端发送报文
  int  Send(const void *buf,const int buflen);
  // 接收对端的报文
  int  Recv(void *buf,const int buflen);
 
  void CloseClient();    // 关闭客户端的socket
  void CloseListen();    // 关闭用于监听的socket
 
 ~CTcpServer();
};
 
CTcpServer TcpServer;
 
int main()
{
  // signal(SIGCHLD,SIG_IGN);  // 忽略子进程退出的信号，避免产生僵尸进程
 
  if (TcpServer.InitServer(5051)==false)
  { printf("服务端初始化失败，程序退出。\n"); return -1; }
 
  while (1)
  {
    if (TcpServer.Accept() == false) continue;
 
    if (fork()>0) { TcpServer.CloseClient(); continue; }  // 父进程回到while，继续Accept。
 
    // 子进程负责与客户端进行通信，直到客户端断开连接。
    TcpServer.CloseListen();
 
    printf("客户端已连接。\n");
 
    // 与客户端通信，接收客户端发过来的报文后，回复ok。
    char strbuffer[1024];
 
    while (1)
    {
      memset(strbuffer,0,sizeof(strbuffer));
      if (TcpServer.Recv(strbuffer,sizeof(strbuffer))<=0) break;
      printf("接收：%s\n",strbuffer);
 
      strcpy(strbuffer,"ok");
      if (TcpServer.Send(strbuffer,strlen(strbuffer))<=0) break;
      printf("发送：%s\n",strbuffer);
    }
 
    printf("客户端已断开连接。\n");
 
    return 0;  // 或者exit(0)，子进程退出。
  }
}
 
CTcpServer::CTcpServer()
{
  // 构造函数初始化socket
  m_listenfd=m_clientfd=0;
}
 
CTcpServer::~CTcpServer()
{
  if (m_listenfd!=0) close(m_listenfd);  // 析构函数关闭socket
  if (m_clientfd!=0) close(m_clientfd);  // 析构函数关闭socket
}
 
// 初始化服务端的socket，port为通信端口
bool CTcpServer::InitServer(int port)
{
  if (m_listenfd!=0) { close(m_listenfd); m_listenfd=0; }
 
  m_listenfd = socket(AF_INET,SOCK_STREAM,0);  // 创建服务端的socket
 
  // 把服务端用于通信的地址和端口绑定到socket上
  struct sockaddr_in servaddr;    // 服务端地址信息的数据结构
  memset(&servaddr,0,sizeof(servaddr));
  servaddr.sin_family = AF_INET;  // 协议族，在socket编程中只能是AF_INET
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  // 本主机的任意ip地址
  servaddr.sin_port = htons(port);  // 绑定通信端口
  if (bind(m_listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) != 0 )
  { close(m_listenfd); m_listenfd=0; return false; }
 
  // 把socket设置为监听模式
  if (listen(m_listenfd,5) != 0 ) { close(m_listenfd); m_listenfd=0; return false; }
 
  return true;
}
 
bool CTcpServer::Accept()
{
  if ( (m_clientfd=accept(m_listenfd,0,0)) <= 0) return false;
 
  return true;
}
 
int CTcpServer::Send(const void *buf,const int buflen)
{
  return send(m_clientfd,buf,buflen,0);
}
 
int CTcpServer::Recv(void *buf,const int buflen)
{
  return recv(m_clientfd,buf,buflen,0);
}
 
void CTcpServer::CloseClient()    // 关闭客户端的socket
{
  if (m_clientfd!=0) { close(m_clientfd); m_clientfd=0; }
}
 
void CTcpServer::CloseListen()    // 关闭用于监听的socket
{
  if (m_listenfd!=0) { close(m_listenfd); m_listenfd=0; }
}

1.1 代码解析

（1）在CTcpServer 中增加了两个成员函数

void CloseClient();    // 关闭客户端的socket
void CloseListen();    // 关闭用于监听的socket

（2）当有客户端连接上来的时候，主进程执行 fork() ,这时候客户端的 socket（m_clientfd）,也就是用于通信的socket，被赋值了一份。但是对于父进程来说，只负责监听客户端的连接，不需要与客户端通信，所以父进程要关闭通信的 socket，关闭了对子进程的通信 socket 没有影响。

在这里插入图片描述

if (TcpServer.Accept() == false) continue;
 
    if (fork()>0) { TcpServer.CloseClient(); continue; }  // 父进程回到while，继续Accept。

（3）当有客户端连接上来，主进程执行 fork(),这时候用于监听的 socket（m_listentfd）也会被复制一份。但是对于子进程来说,它不需要监听客户端的连接，只需要与客户端进行通信。关闭了对父进程没有影响。

在这里插入图片描述

  // 子进程负责与客户端进行通信，直到客户端断开连接。
    TcpServer.CloseListen();

（4）当一个子进程执行完任务后，要跳出循环——调用 return 或 exit(0) 退出，如果没有调用 return 或 exit(0)，子进程将又回到 while() 循环的首部，又继续生成子进程。
在这里插入图片描述
（5）什么时候 fork(),也就是说什么时候去产生一个子进程。当有一个客户端连接了，与服务端形成了用于通信的socket，就产生一个子进程。让这个子进程和这个客户端使用这个socket通信。就像是酒店，当有一个客人来了，就派一个服务员过去接待，派服务员员过去的前提是客人来了。所以什么时候fork 出一个子进程也是这个道理。

if (TcpServer.Accept() == false) continue;
 
    if (fork()>0) { TcpServer.CloseClient(); continue; }  // 父进程回到while，继续Accept。

1.2 自己写的代码

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

class CTcpServer
{
public:
    int m_listenSocket;  //服务端用于监听的socket
    int m_comuSocket;   //客户端连接上来的socket，也就是用于通信的socket

    CTcpServer();      //构造函数

    bool InitServer(int port);     //初始化服务端的地址信息```
 bool Accept();             //等待客户端的连接；从等待连接的队列中获取连接请求

    int Send(const void *buf ,const int buflen);  //发送数据的函数

    int Recv( void *buf, const int buflen);  //接收数据的函数

    ~CTcpServer();   //析构函数

     void CloseClient();   //关闭客户端的socket

     void CloseListen();   //关闭用于监听的socket

};

int main(int argc,char *argv[])
{
  if(argc!=2)
   {
 printf("Using: ./server port\n");
      printf("Example: ./C++封装服务端 5005\n");
      return -1;
   }

  CTcpServer TcpServer;

  //监听的socket已经建立，但是还没有绑定，要先绑定服务器的端口,这个属于初始化的
  if (TcpServer.InitServer(atoi(argv[1])) == false)
    {
      printf("连接服务器失败\n");
      return -1;
    }
  while(1)
    {

  if(TcpServer.Accept() == false)
    {
       printf("TcpServer.Accept\n");
       while(1)
    {

  if(TcpServer.Accept() == false)
    {
       printf("TcpServer.Accept\n");
       continue;   //如果失败的话，继续监听
    }
   //sleep(30);

    if( fork()>0) { TcpServer.CloseClient(); continue;}

    TcpServer.CloseListen();
    //子进程与客户端进行通信，知道客户端断开连接。
    //因为建立连接后，子进程的监听socket就不需要了，需要关闭。
    //当父进程回到循环的开始时，监听的socket会再次打开。

   printf("客户端已连接.\n");
   char buffer[1024];
   while(1)
     {
        memset(buffer,0,sizeof(buffer));
        if( TcpServer.Recv(buffer,sizeof(buffer))<=0) break;

        printf("接收：%s\n",buffer);

        strcpy(buffer,"ok");
        if ( TcpServer.Send(buffer,sizeof(buffer))<=0) break;
        printf("发送：%s\n",buffer);
     }


   printf("客户端已经断开连接\n");

   return 0;   //子进程完成通信，就退出循环
  }
}

CTcpServer::CTcpServer()
{
   //构造函数，初始化成员变量
   m_listenSocket=0;
   m_comuSocket=0;
}

CTcpServer::~CTcpServer()
{
   //析构函数释放资源
   if( m_listenSocket !=0)  close(m_listenSocket);
   if( m_comuSocket !=0)    close(m_comuSocket);
}

bool CTcpServer::InitServer(int port)
{
   //初始化函数，初始化服务端的地址信息
   m_listenSocket = socket(AF_INET,SOCK_STREAM,0);  //创建监听的socket
    //将监听的socket和服务端的地址信息绑定前，先填写服务端的地址信息
   struct sockaddr_in servaddr;
   memset(&servaddr,0,sizeof(servaddr));
   servaddr.sin_family = AF_INET ;
   servaddr.sin_port = htons(port);
   servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

   //服务端的地址信息有了，就可以将m_listenSocket 与服务端绑定。
   if( (bind(m_listenSocket,(struct sockaddr *)&servaddr,sizeof(servaddr)) ) !=0)
     { close(m_listenSocket); m_listenSocket=0; return false; }

    //将监听socket设置为监听状态
    if ( listen(m_listenSocket,5) != 0 )
      { close(m_listenSocket); m_listenSocket=0; return false; }

    return true;

}

bool CTcpServer::Accept()
{
  //accept函数将监听的socket与客户端连接起来，形成通信的socket。
  //accept函数，从准备好连接的队列中取出一个客户端，与m_listenSocket连接
  //客户端的信息用结构体存放
  struct sockaddr_in clientaddr;
  memset(&clientaddr,0,sizeof(clientaddr));
  //这里其实你只要设一个结构体就行了，不用再写客户端用什么协议等等
  //因为accept函数从等待队列里面提取出来就包含了客户端的地址信息，你在写的话就画蛇添足了
  int socklen = sizeof(struct sockaddr_in);
  if((m_comuSocket=accept(m_listenSocket,(struct sockaddr *)&clientaddr,(socklen_t *)&socklen))<=0)
   return false;

   return true;
}

int CTcpServer::Send(const void *buf,const int buflen)
{
return send(m_comuSocket,buf,buflen,0);
}

int CTcpServer::Recv(void *buf,const int buflen)
{
  return recv(m_comuSocket,buf,buflen,0);
}

void CTcpServer::CloseClient()
{
  if(m_comuSocket!=0)  { close(m_comuSocket) ; m_comuSocket=0; }
}

void CTcpServer::CloseListen()
{
  if(m_listenSocket!=0) { close(m_listenSocket); m_listenSocket=0; }
}

2.客户端代码

2.1示例

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
 
// TCP客户端类
class CTcpClient
{
public:
  int m_sockfd;
 
  CTcpClient();
 
  // 向服务器发起连接，serverip-服务端ip，port通信端口
  bool ConnectToServer(const char *serverip,const int port);
  // 向对端发送报文
  int  Send(const void *buf,const int buflen);
  // 接收对端的报文
  int  Recv(void *buf,const int buflen);
 
 ~CTcpClient();
};
 
int main()
{
  CTcpClient TcpClient;
 
  // 向服务器发起连接请求
  if (TcpClient.ConnectToServer("172.16.0.15",5051)==false)
  { printf("TcpClient.ConnectToServer(\"172.16.0.15\",5051) failed,exit...\n"); return -1; }
 
  char strbuffer[1024];
 
  for (int ii=0;ii<50;ii++)
  {
    memset(strbuffer,0,sizeof(strbuffer));
    sprintf(strbuffer,"这是第%d个超级女生，编号%03d。",ii+1,ii+1);
    if (TcpClient.Send(strbuffer,strlen(strbuffer))<=0) break;
    printf("发送：%s\n",strbuffer);
   
    memset(strbuffer,0,sizeof(strbuffer));
    if (TcpClient.Recv(strbuffer,sizeof(strbuffer))<=0) break;
    printf("接收：%s\n",strbuffer);
 
    sleep(1);  // sleep一秒，方便观察程序的运行。
  }
}
 
CTcpClient::CTcpClient()
{
  m_sockfd=0;  // 构造函数初始化m_sockfd
}
 
CTcpClient::~CTcpClient()
{
  if (m_sockfd!=0) close(m_sockfd);  // 析构函数关闭m_sockfd
}
 
// 向服务器发起连接，serverip-服务端ip，port通信端口
bool CTcpClient::ConnectToServer(const char *serverip,const int port)
{
  m_sockfd = socket(AF_INET,SOCK_STREAM,0); // 创建客户端的socket
 
  struct hostent* h; // ip地址信息的数据结构
  if ( (h=gethostbyname(serverip))==0 )
  { close(m_sockfd); m_sockfd=0; return false; }
 
  // 把服务器的地址和端口转换为数据结构
  struct sockaddr_in servaddr;
  memset(&servaddr,0,sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_port = htons(port);
  memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
 
  // 向服务器发起连接请求
  if (connect(m_sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr))!=0)
  { close(m_sockfd); m_sockfd=0; return false; }
 
  return true;
}
 
int CTcpClient::Send(const void *buf,const int buflen)
{
  return send(m_sockfd,buf,buflen,0);
}
 
int CTcpClient::Recv(void *buf,const int buflen)
{
  return recv(m_sockfd,buf,buflen,0);
}

2.2 自己写的代码

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

class CTcpClient
{
public:
  int m_comuSocket;

  CTcpClient();
  ~CTcpClient();

  int ConnectToServer(const char *Serverip,const int port);
  int Send(const void * buffer,const int bufferLen);
 int Recv(void * buffer,const int bufferLen);

};

int main(int argc ,char *argv[])
{
   if(argc != 3)
     {
        printf("Example: ./C++封装客户端 8.131.80.81 5005\n");
        return -1;
     }
   CTcpClient TcpClient;
   int port=atoi(argv[2]);

   if( ( TcpClient.ConnectToServer(argv[1],port) ) == -1)
     {
        printf("连接服务器失败、\n");
        return -1;
         }

   char buffer[1024];

   while(1)
     {
        memset(buffer,0,sizeof(buffer));
        printf("请输入要发送的内容：");

        scanf("%s",buffer);

        if( (TcpClient.Send(buffer,sizeof(buffer)))<=0)  break;
        printf("发送：%s\n",buffer);

        memset(buffer,0,sizeof(buffer));
        if( ( TcpClient.Recv(buffer,sizeof(buffer))) <=0) break;
        printf("接收：%s\n",buffer);

        sleep(1);   //方便观察
        }
}
CTcpClient::CTcpClient()
{
   m_comuSocket=0;
}
int CTcpClient::ConnectToServer(const char *Serverip,const int port)
{
  //连接服务端要用到服务端的地址信息，这个地址信息可以从ip地址中解析，用结构体来存放
  //解析IP地址的函数，ip地址有时候是给域名，所以用gethostbyname函数来解析，它可以解析ip
   //也可以解析域名。
   //gethostbyname函数返回的是 hostent 结构体的地址
   //但是connect 函数中服务端的地址是 sockaddr，
   //所以要定义一个结构体（sockaddr） 来存放，解析后的服务端的地址信息

  m_comuSocket = socket (AF_INET,SOCK_STREAM,0);
  struct sockaddr_in servaddr;  //这个结构体用来存放解析后的服务端信息
  memset(&servaddr,0,sizeof(servaddr));
   servaddr.sin_family = AF_INET;
  servaddr.sin_port = htons(port);

  struct hostent * h;
  if( (h=gethostbyname(Serverip)) ==0)

    { close(m_comuSocket); return -1; }


  memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
  //向服务端发起连接请求
  if( connect(m_comuSocket,(struct sockaddr *)&servaddr,sizeof(servaddr))!=0)
    {
       close(m_comuSocket); m_comuSocket=0; return -1;
    }

  return 0;

}
int CTcpClient::Send(const void * buffer,const int bufferLen)
{
  return send(m_comuSocket,buffer,bufferLen,0);

}

int CTcpClient::Recv(void * buffer,const int bufferLen)
{
  return recv(m_comuSocket,buffer,bufferLen,0);
}

CTcpClient::~CTcpClient()
{
  if(m_comuSocket !=0)  close(m_comuSocket);
}

3.运行效果

3.1 服务端与多个客户端通信

先启动服务端，然后启动多个客户端。服务端同时与多个客户端通信。
在这里插入图片描述

3.2 用 ps -ef|grep C++ 命令查看

在这里插入图片描述
注意：服务端的 main() 的 while() 是死循环，没有退出机制，可以按 Ctrl+c 强制中止它，但这不是正确的方法。

二.僵尸进程（zombie）

在这里插入图片描述

1.僵尸进程产生的原因

僵尸进程是当子进程比父进程先结束，而父进程又没有回收子进程，释放子进程占用的资源，此时子进程将成为一个僵尸进程。

一个子进程在调用 return 或 exit(0) 结束自己的声明的时候，其实它并没有真正的被销毁，而是留下一个僵尸进程。

在这里插入图片描述

1.2 生成僵尸进程

（1）先启动服务端程序，然后多次启动客户端程序，马上查看服务端的进程。
在这里插入图片描述

（2）所有的客户端程序运行完成之后，再查看服务端的进程。
这几个进程的状态就有的标志，这就是僵尸进程。
在这里插入图片描述
（3）如果按 Ctrl+c 终止服务端程序后，父进程退出，僵尸进程随之消失。

2.僵尸进程的危害

僵尸进程是子进程结束时，父进程还没有结束，没有回收子进程占用的资源。僵尸进程在消失之前会继续占用系统资源。这就是白发人送黑发人，肯定是不正常的。
在这里插入图片描述

如果父进程先退出，子进程被系统接管，子进程退出后系统会回收其占用的相关资源，不会成为僵尸进程。
在这里插入图片描述

3.如何解决僵尸进程

解决僵尸进程有两种方法。

3.1 第一种方法：父进程调用 waid()

子进程在退出之前，会向父进程发送一个信号，父进程调用 waid() 函数等待这个信号，只要等到了就不会产生僵尸进程。这看起来很简单，但在并发的服务程序中是不可能得。因为父进程还要做其他的事情，例如等待客户端的新连接，不可能去等待子进程的退出信号，这方法就不介绍了。

这就好比餐厅，当有客人来的时候肯定会有服务员去接待，但是客人吃完了之后，要走了的时候，餐厅不会专门再派个服务员去伺候你离开。餐厅是分清轻重缓急的，系统也是一样。

3.2 第二种方法：调用 signal ()

这种方法是父进程直接忽略子进程的退出信号，

在这里插入图片描述
具体做法就是在主程序（main）中启用一下代码：

signal(SIGCHLD,SIG_IGN);   //忽略子进程的退出信号，避免产生僵尸进程

在这里插入图片描述

3.3 测试调用 signal(SIGCHLD,SIG_IGN)效果

（1）先启动服务端程序，然后启动多个客户端程序，查看服务端的进程。红框的为父进程
在这里插入图片描述
（2）客户端都运行完毕，再次查看服务端的进程。没有出现僵尸进程了（< defunct >）

三.单进程和多进程

在学习了多进程的基础知识之后，可能会认为多进程是一个高大上的技术，认为多进程处理数据肯定比单进程快其实不是。在实际开发中，采用多进程的主要目的是处理多个并发的任务，而不是为了提高程序的效率。

从效率方面来说，某些场景下多进程的效率比单进程低，原因很简单，因为在有限的硬件资源中，多进程程序的内存开销更大，还会产生资源的竞争。就像一个人同时只做一件事，比同时做多件事快。

四.补充

4.1 父子进程都没有关闭通信socket 的问题

当父子进程都没有关闭 socket 的时候回发生什么？前面的服务端程序，父进程是关闭用于通信的 socket 的，只是子进程的通信 socket 是打开的，所以只是子进程能与客户端进行通信（能接收到客户端所发的报文）。

那现在我把父子进程用于通信的 socket 都打开，那么客户端所发的报文，会被哪个进程用于通信的socket 接收。

4.1.1 修改服务端主程序的代码

（1）就是不关闭父进程的通信 socket，关闭子进程的监听socket。

 //监听的socket已经建立，但是还没有绑定，要先绑定服务器的端口,这个属于初始化的
  if (TcpServer.InitServer(atoi(argv[1])) == false)
    {
      printf("连接服务器失败\n");
      return -1;
    }
   
   char buffer[1024];
  while(1)
    {

  if(TcpServer.Accept() == false)
    {
       printf("TcpServer.Accept\n");
       continue;   //如果失败的话，继续监听
    }

    if( fork()>0) //{ TcpServer.CloseClient(); continue;}
      {
    while(1)
     {
        memset(buffer,0,sizeof(buffer));
        if( TcpServer.Recv(buffer,sizeof(buffer))<=0) break;

        printf("父进程接收：%s\n",buffer);
 }
      sleep(1);
      }

     else
       {
    TcpServer.CloseListen();

   char buffer[1024];
   while(1)
     {
        memset(buffer,0,sizeof(buffer));
        if( TcpServer.Recv(buffer,sizeof(buffer))<=0) break;

        printf("儿子接收：%s\n",buffer);
        }
        }
        }
        }

4.1.2 客户端主程序的测试代码

while(1)
  {
       strcpy(buffer,"香香，我爱你");

        int bufferlen=strlen(buffer);
        if( (TcpClient.Send(buffer,bufferlen))<=0)  break;
        printf("发送：%s\n",buffer);
        sleep(1);
  }

4.1.3 运行效果

在这里插入图片描述
会发现当客户端发送过来时，由谁来接收时不一定的。

行孤、

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Linux 多线程的应用

前面的章节介绍socket通信的时候，socket的服务端在同一时间只能和一个客户端通信，并不是服务端有多忙，而是因为第单进程的程序在同一时间只能做一件事情，不能一边等待客户端的新连接一边与其他的客户端进行通信。一.并发的服务端如果把 socket 服务端改为多进程，在每次 accept 到一个客户端的连接后，生成一个子进程，让子进程负责和这个客户端通信，父进程继续 accept 客户端的连接。socket 的服务端在监听新客户端的同时，还可以与多个客户端进行通信。这就是并发，如下图1.
复制链接

扫一扫