1.服务端需要绑定，客户端不需要

1.1服务器为什么需要绑定

1.一般服务器端是固定的，是总所周知的，ip和port不需要也不能轻易的更改。比如：http对应的端口号是80 https:443 ssh:22

2.服务器面对的客户很多，服务器一旦改了，客户端立马找不到，就无法访问服务器了。比如在日常生活中110对应的就是报警，报警的第一反应就是110

3.服务器是一对多的，一旦发生变化，很多客户端都要做出相对的变动

1.2客户端为什么不需要绑定

1.客户有很多客户端，如果绑定，就需要让不同的公司商量一下,什么软件用什么端口，端口是标识进程的，一个端口只能对应一个进程，如果多个进程使用同一个端口，就会导致绑定是失败。并且这种让不同的公司进行沟通进行约定，是很不现实的。

如果进行了bind很容易发生端口冲突，导致客户端无法启动

2.客户端需要唯一性，不需要明确是那个端口，但是需要IP和port。

客户端使用udp服务器进行数据的交互之时，系统会自动进行Ip和端口号的绑定(OS最清楚端口号情况)。端口号是16位，是有限的，OS是需要管理它的，因此OS清楚哪些端口没有被使用。而自己去绑定是不确定的，只能是"碰运气"，看那个端口没有被绑定

2.什么是本地环回

IP：127.0.0.1 叫做本地环回 -> 通常用来进行网络通信代码的测试，一般本地跑通说明本地环境以及代码基本没有大问题

3.INADDR_ANY

**[注]**云服务器有些地方是不需要端口的，这是考虑到安全问题，因此在绑定公网IP的时候可能会失败

网络地址为INADDR_ANY，这个宏表示本地的任意ip地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个ip地址，这样设置可以在所有的IP地址上进行监听，直到与某个客户建立了链接时才确下来到底用哪个ip地址

绑定的是INADDR_ANY该主机的所有IP层收到的数据都会交给主机，否则只有绑定的IP才会将数据交给主机

4.四字节和点分十进制的相互转换

#include <iostream>
using namespace std;
#include <string>
#include <vector>


typedef union IP
{
  unsigned ip;//四字节ip
  struct{
    unsigned part1:8;
    unsigned part2:8;
    unsigned part3:8;
    unsigned part4:8;
  }ip_seg;
}IP;

void GetString(string & str,IP &ip)//从part之中读取1个个字节的整形转换成字符串
{
  str+=to_string(ip.ip_seg.part1);
  str+='.';
  str+=to_string(ip.ip_seg.part2);
  str+='.';
  str+=to_string(ip.ip_seg.part3);
  str+='.';
  str+=to_string(ip.ip_seg.part4);
}

void GetNum(string &str,IP &ip)//将字符串之中的内容填入ip，读取part
{
  string temp[4];
  int sub=0;
  for(int i=0;i<(int)str.size();i++)
  {
    if(str[i]!='.')
      temp[sub]+=str[i];
    else
    {
      sub++;
    }
  }
  ip.ip_seg.part1=stoi(temp[0]);
  ip.ip_seg.part2=stoi(temp[1]);
  ip.ip_seg.part3=stoi(temp[2]);
  ip.ip_seg.part4=stoi(temp[3]);
  
}

int main()
{
//将整形ip转换成点分十进制
  IP ip;//定义一个联合结构体，用来转换字符串
  ip.ip=987654321;
  string str;
  GetString(str,ip);
  cout<<ip.ip<<"->"<<str<<endl; 
 //将点分十进制转换成整形四字节ip
  cout<<"________________"<<endl;
  IP ip2;//定义一个联合结构体，用来转换成整形
  GetNum(str,ip2);
  cout<<str<<"->"<<ip2.ip<<endl;
  return 0;
  }

效果演示：

5.udp字典服务器

#pragma once

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <string>
using namespace std;
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <map>

class udpServer
{
  private:
    string ip;
    int port;
    int sock;
    map<string,string> dict;

  public:
    udpServer(int _port)
      :port(_port)
    {
      dict.insert(pair<string,string>("apple","苹果"));
      dict.insert(pair<string,string>("banana","香蕉"));
      dict.insert(pair<string,string>("school","学校"));
    }


    void initServer()//初始化服务器
    {
      sock=socket(AF_INET,SOCK_DGRAM,0);
      cout<<sock<<endl;

      //当前套接字文件里面只有文件信息
      //这个文件对应的是网络文件、因此需要加入ip、port信息->绑定
      
      //传入的ip、port是在用户层的，下面需要绑定在内核里面
      //因此需要填充结构体，sockaddr_in(ipv4)
      
      struct sockaddr_in local;
      local.sin_family=AF_INET;//填充协议
      local.sin_port=htons(port);//填充端口->转成网络字节序
      local.sin_addr.in_addr::s_addr = INADDR_ANY;//绑定本机上的任意IP

      if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
      {
        cerr<<"bind error"<<endl;//往显示器上打印，但是对应的文件描述符不一样
        exit(1);//绑定失败终止整个进程
      }
    }

    //服务器启动之后、永不退出
    //写一个回应服务器
    void start()
    {
      while(1)
      {
        struct sockaddr_in end_point;//保存是谁送人信息->ip 和port
        socklen_t len=sizeof(end_point);//发送人结构体大小

        char buff[88];//接收消息缓冲区
        buff[0]='\0';//清空缓冲区

        ssize_t size=recvfrom(sock,buff,sizeof(buff)-1,0,(struct sockaddr*)&end_point,&len);//接收消息
        
        if(size>0)//收到消息了
        {
          string cli=inet_ntoa(end_point.sin_addr);//,将整形转换成str,获取客户端的点分十进制ip
          cli+=":";
          cli+=to_string(ntohs(end_point.sin_port));//获取客户端的port，获得的是整形，需要转换成字符串
          cli+=':';


           buff[size]='\0';//在末尾添加\0
           cout<<cli<<buff<<endl;//打印客户端发送过来的消息
           
          // string echo_string = buff;//回显字符串
          // echo_string+="-> server echo";
          //
           
          string echo_string;
           map<string,string>::iterator it=dict.find(buff);//通过key值查找
           if(it==dict.end())//没找到
             echo_string+="not find";
           else
            echo_string+=it->second;

          sendto(sock,echo_string.c_str(),echo_string.size(),0,(struct sockaddr*)&end_point,len);

        }
      }
    }

    ~udpServer()
    {
      close(sock);//关闭文件描述符
    }

};

#include "udpServer.hpp"

void Usage()
{
  cout<<"Usage:"<<"please enter server ip and port"<<endl;
}

int main(int argc,char*argv[])
{
  if(argc!=2)
  {
    Usage();
    exit(1);
  }

  udpServer *up=new udpServer(atoi(argv[1]));
  up->initServer();//初始化
  up->start();//运行起来

  return 0;
}

#pragma once

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <string>
using namespace std;
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <arpa/inet.h>

class udpClient
{
  private:
    string ip;
    int port;
    int sock;

  public:
    //连接服务器->所以填写server的ip和端口-> 下载软件的时候就是下载客户端
    udpClient(string _ip,int _port)
      :ip(_ip)
       ,port(_port)
  {}


    void initClient()//初始化客户端
    {
      sock=socket(AF_INET,SOCK_DGRAM,0);
      cout<<sock<<endl;

      //客户端不需要绑定
    }

    //服务器启动之后、永不退出
    //写一个回应服务器
    void start()
    {
      string send_string;
      //发送给谁，填充信息
      struct sockaddr_in peer;
      peer.sin_family=AF_INET;
      peer.sin_port=htons(port);
      peer.sin_addr.s_addr=inet_addr(ip.c_str());//将字符串转成4字节再转成网络字节序

      
      
      char buff[88];

      while(1)
      {
        cout<<"please enter your message#"<<endl;
        getline(cin,send_string);

        sendto(sock,send_string.c_str(),send_string.size(),0,(struct sockaddr*)&peer,sizeof(peer));
        
        buff[0]='\0';
        ssize_t size=recvfrom(sock,buff,sizeof(buff)-1,0,nullptr,nullptr);
        if(size>0)
        {
          buff[size]='\0';
          cout<<"Serve:"<<buff<<endl;
        }

      }

    }

    ~udpClient()
    {
      close(sock);//关闭文件描述符
    }

};

#include "udpClient.hpp"

void Usage()
{
  cout<<"Usage:"<<"please enter Server ip and port"<<endl;
}

int main(int argc,char *argv[])
{
  if(argc!=3)
  {
    Usage();
    exit(2);
  }

  udpClient *uc =new udpClient(argv[1],atoi(argv[2]));
  uc->initClient();
  uc->start();

  return 0;
}

6.TCP协议

6.1监听套接字 1listen

让套接字处理监听状态listen：允许任何时刻客户端来链接我(udp可以不链接，ip+port是表示发给谁)

什么是监听状态呢？
好比餐馆，老板就处于监听你的状态，只要你去了就有饭吃

6.2建立链接accpet

此时的返回值也是一个文件描述符，它和socket的返回值有什么区别呢？

sock：专注于底层获取链接(监听套接字)

accept返回值：专注于进程之间的通信

比如：一个餐馆，有在外面迎宾的和在里面招待客人的，他们就是两种套接字。迎宾的只负责将客人(链接)带进餐馆，带进餐馆之后他就不管了，之后与客人进行沟通，则是在里面的服务员了 -> 类比 sock(迎宾，负责获取链接)、accept返回值(服务员，负责进程之间的通信)

6.3 文件和流的概念

一般的文件都是基于流的 -> 比如通过open、fopen、pipe等方式打开的文件都有对应的概念 stream -> 在c/c++之中打开一个文件都叫做打开一个文件流。

tcp sock也是流的概念，因此读取sock文件时，也可以用read和write，但是常用的是recv

6.4代码实现tcp服务器和客户端

6.4.1服务器

#ifndef _TCPSERVER_HPP_
#define _TCPSERVER_HPP_

#include <iostream>
using namespace std;
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/types.h>
#endif
#define BACKLOCK 5

class tcpServer
{
  private:
    int port;
    int lsock;//监听套接字
  public:
    tcpServer(int _port)
      :port(_port)
       ,lsock(-1)
    {}

    void initServer()
    {
      lsock=socket(AF_INET,SOCK_STREAM,0);
      if(lsock<0)
      {
        cerr<<"socket fail"<<endl;
        exit(2);
      }
      
      struct sockaddr_in local;
      local.sin_family=AF_INET;//填充协议
      local.sin_port=htons(port);//填充端口，转换成网网络字节序
      local.sin_addr.s_addr=INADDR_ANY;//填写ip
    
      if(bind(lsock,(struct sockaddr*)&local,sizeof(local))<0)//进行绑定
      {
        cerr<<"bind error"<<endl;
        exit(3);
      }
      if(listen(lsock,BACKLOCK)<0)
      {
        cerr<<"listen error"<<endl;
        exit(4);
      }
    }

    void service(int sock)
    {
      char buff[200];
      while(true)
      {
        size_t size=recv (sock,buff,sizeof(buff)-1,0);
        if(size>0)//读取到了
        {
          buff[size]='\0';//末尾添加\0
          cout<<"client:"<<buff<<endl;

          send(sock,buff,strlen(buff),0);//不需要+1，\0是语言的标准，文件不认识
        }
      }
    }

    void stat()
    {
      sockaddr_in end_point;//获取客户结构体信息，和udp作用一样
      while(true)
      {
        //udp直接通信，tcp第一件事是获取链接
        socklen_t len=sizeof(end_point);
        int sock=accept(lsock,(struct sockaddr*)&end_point,&len);
        if(sock<0)
        {
          cerr<<"accpet error"<<endl;
          continue;
        }
        cout<<"get a new accept"<<endl;
        service(sock);//封装一个服务接口
        
      }
    }
  ~tcpServer()
  {
	  close(lsock);
  }
};


#include "tcpServer.hpp"

void Usage()
{
  cout<<"please enter your port"<<endl;
}
int main(int argc,char *argv[])
{
  if(argc!=2)
  {
    Usage();
    exit(1);
  }
      tcpServer *tp=new tcpServer(stoi(argv[1]));//传输的是字符串 -> int
      tp->initServer();
      tp->stat();

    delete tp;
    return 0;
  }
 

6.4.2客户端

知识点预知：

1.客户端链接服务器接口：

2.服务器如何知道客户端退出了：

3.将一个进程放置后台，拿到前台：



4.效果展示：

5.代码：

#ifndef _TCP_CLIENT_CPP_
#define _TCP_CLIENT_CPP_

#include <stdio.h>
using namespace std;
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#endif

class tcpClient
{
  private:
    string ip;
    int port;
    int sock;

  public:
    tcpClient(string _ip,int _port)
    :ip(_ip)
     ,port(_port)
     ,sock(-1)
    {}

    void initClient()
    {
      sock =socket(AF_INET,SOCK_STREAM,0);//绑定套接字
      if(sock==-1)
      {
        cerr<<"client sock error"<<endl;
        exit(1);
      }

    //链接服务器 -> udp不需要连接诶
      struct sockaddr_in peer;
      peer.sin_family=AF_INET;
      peer.sin_port=htons(port);//主机转成网络序列
      peer.sin_addr.s_addr=inet_addr(ip.c_str());//将字符串转成网络整形

      if(connect(sock,(struct sockaddr*)&peer,sizeof(peer))!=0)//链接服务器
      {
        cerr<<"connect fail"<<endl;
        exit(2);
      }

    }

  //链接成功...... 
  
    void start()
    {
      char msg[100];
      while(true)
      {
        cout<<"please your message"<<endl;
        size_t s=read(0,msg,sizeof(msg)-1);//从标准输入读取
       if(s>0)
       {
         msg[s-1]=0;//read会将换行读进去
         send(sock,msg,s,0);//给服务器发送信息
       
         size_t ss=recv(sock,msg,sizeof(msg)-1,0);
         if(ss>0)//表示读取到了信息
         {
           msg[ss]=0;
           cout<<"server:"<<msg<<endl;
         }
       }
      }
    }

    ~tcpClient()
    {
      close(sock);
    }
};


#include "tcpClient.hpp"
#include <stdio.h>
using namespace std;
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>

void Usage(char *arg)
{
  cout<<"usage:"<<arg<<":"<<"please enter yout ip and port"<<endl;
}

int main(int argc,char* argv[])
{
  if(argc!=3)
  {
    Usage(argv[0]);
    exit(-1);
  }
  tcpClient *tc=new tcpClient(argv[1],atoi(argv[2]));
  tc->initClient();
  tc->start();
  delete tc;

  return 0;
}

6.4tcp服务器优化

6.4.1多进程版本

#ifndef _TCPSERVER_HPP_
#define _TCPSERVER_HPP_

#include <iostream>
using namespace std;
#include <stdlib.h>
#include <signal.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <unistd.h>

#endif

#define BACKLOCK 5


class tcpServer
{
  private:
    int port;
    int lsock;//监听套接字
  public:
    tcpServer(int _port)
      :port(_port)
       ,lsock(-1)
    {}

    void initServer()//初始化，创建套接字
    {
      signal(SIGCHLD,SIG_IGN);//父进程忽略子进程发送过来的信号，即子进程自己清理资源

      lsock=socket(AF_INET,SOCK_STREAM,0);
      if(lsock<0)
      {
        cerr<<"socket fail"<<endl;
        exit(2);
      }
      
      struct sockaddr_in local;
      local.sin_family=AF_INET;//填充协议
      local.sin_port=htons(port);//填充端口，转换成网网络字节序
      local.sin_addr.s_addr=INADDR_ANY;//填写ip
    
      if(bind(lsock,(struct sockaddr*)&local,sizeof(local))<0)//进行绑定
      {
        cerr<<"bind error"<<endl;
        exit(3);
      }
      if(listen(lsock,BACKLOCK)<0)
      {
        cerr<<"listen error"<<endl;
        exit(4);
      }
    }

    void service(int sock)//执行任务函数
    {
      char buff[200];
      while(true)
      {
        size_t size=recv (sock,buff,sizeof(buff)-1,0);
        if(size>0)//读取到了
        {
          buff[size]='\0';//末尾添加\0
          cout<<"client:"<<buff<<endl;

          send(sock,buff,strlen(buff),0);//不需要+1，\0是语言的标准，文件不认识
        }
        else if(size==0)
        {
          cout<<"client quit..."<<endl;
          close(sock);//关闭对应的套接字
          break;
        }
        else//读取错误
        {
          cerr<<"read error"<<endl;
          close(sock);
          break;
        }
      }
    }

    void stat()
    {
      sockaddr_in end_point;//获取客户结构体信息，和udp作用一样
      while(true)
      {
        //udp直接通信，tcp第一件事是获取链接
        socklen_t len=sizeof(end_point);
        int sock=accept(lsock,(struct sockaddr*)&end_point,&len);
        if(sock<0)
        {
          cerr<<"accpet error"<<endl;
          continue;
        }

        string cl;//客户端信息
        cl+=inet_ntoa(end_point.sin_addr);//网->主，整->字符串
        cl+=':';
        cl+=to_string(ntohs(end_point.sin_port));


        cout<<"get a new accept:"<<cl<<"-"<<"sock:"<<sock<<endl;
        
        //创建多进程，可以有多个执行流
        pid_t id=fork();

        if(id==0)//子进程提供服务
        {
          //子进程不关心lsock
          close(lsock);//子进程拷贝了父进程的文件描述表
          service(sock);//封装一个服务接口
          exit(0);//执行完任务退出
        }
        //父进程的主要任务是获取链接
        //然后链接越多，对应的为服务创建的sock文件描述符也越多
        //父进程可用的资源就少了，因此不如关闭
        close(sock);//父进程不关心后面的服务
      }
    }
  ~tcpServer()
  {
  	close(lsock);
  }

};

另外一种写法___________________________________
pid_t id=fork();
if(id==0)
{
if(fork()>0)//子进程退出
	exit(0);
}
	//接下来的这一段是孙子进行在运行
          close(lsock);//子进程拷贝了父进程的文件描述表
          service(sock);//封装一个服务接口
          exit(0);//执行完任务退出

wait(id,null,0);//父进程立马可以等待子进程
-> 不推荐这样写，fork是有成本的，创建进程越多，代价越大

效果展示：

6.4.2多线程版本

#ifndef _TCPSERVER_HPP_
#define _TCPSERVER_HPP_

#include <iostream>
using namespace std;
#include <stdlib.h>
#include <pthread.h>
#include <signal.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <unistd.h>

#endif

#define BACKLOCK 5


class tcpServer
{
  private:
    int port;
    int lsock;//监听套接字
  public:
    tcpServer(int _port)
      :port(_port)
       ,lsock(-1)
    {}

    void initServer()
    {
      signal(SIGCHLD,SIG_IGN);//父进程忽略子进程发送过来的信号，即子进程自己清理资源

      lsock=socket(AF_INET,SOCK_STREAM,0);
      if(lsock<0)
      {
        cerr<<"socket fail"<<endl;
        exit(2);
      }
      
      struct sockaddr_in local;
      local.sin_family=AF_INET;//填充协议
      local.sin_port=htons(port);//填充端口，转换成网网络字节序
      local.sin_addr.s_addr=INADDR_ANY;//填写ip
    
      if(bind(lsock,(struct sockaddr*)&local,sizeof(local))<0)//进行绑定
      {
        cerr<<"bind error"<<endl;
        exit(3);
      }
      if(listen(lsock,BACKLOCK)<0)
      {
        cerr<<"listen error"<<endl;
        exit(4);
      }
    }

    static void service(int sock)
    {
      char buff[200];
      while(true)
      {
        size_t size=recv (sock,buff,sizeof(buff)-1,0);
        if(size>0)//读取到了
        {
          buff[size]='\0';//末尾添加\0
          cout<<"client:"<<buff<<endl;

          send(sock,buff,strlen(buff),0);//不需要+1，\0是语言的标准，文件不认识
        }
        else if(size==0)
        {
          cout<<"client quit..."<<endl;
          close(sock);//关闭对应的套接字
          break;
        }
        else//读取错误
        {
          cerr<<"read error"<<endl;
          close(sock);
          break;
        }
      }
    }


    static void *sevrun(void *arg)//只能有一个参数，因此必须是static
    {
      pthread_detach(pthread_self());//线程分离,不用再进行等待
      cout<<"create a new prhread"<<endl;
      int *p=(int*)arg;
      int sock=*p;
      service(sock);//执行任务
      delete p;
      return NULL;
    }

    void stat()
    {
      sockaddr_in end_point;//获取客户结构体信息，和udp作用一样
      while(true)
      {
        //udp直接通信，tcp第一件事是获取链接
        socklen_t len=sizeof(end_point);
        int sock=accept(lsock,(struct sockaddr*)&end_point,&len);
        if(sock<0)
        {
          cerr<<"accpet error"<<endl;
          continue;
        }

        string cl;//客户端信息
        cl+=inet_ntoa(end_point.sin_addr);//网->主，整->字符串
        cl+=':';
        cl+=to_string(ntohs(end_point.sin_port));

        cout<<"get a new accept:"<<cl<<"-"<<"sock:"<<sock<<endl;

        pthread_t tid;
        
        //防止新线程还未执行，老线程又创建了新的链接,sock就被改变了
        //new出来一段空间，只要传参就发生了拷贝，所以不会有影响
        int *p=new int(sock);

        pthread_create(&tid,nullptr,sevrun,(void*)p);//创建线程
      }
    }

  ~tcpServer()
  {
    close(lsock);
  }

};

//makefile
FLAG= -lpthread

.PHONY:all 
all:tcpClient tcpServer  -lpthread

tcpClient:tcpClient.cpp
	g++ -o $@ $^ $(FLAG)

tcpServer:tcpServer.cpp
	g++ -o $@ $^ $(FLAG)

.PHONY:clean
clean:
	rm -rf tcpClient tcpServer

效果展示：

6.4.3线程池版本

#pragma once
#include <iostream>
#include <math.h>
#include <pthread.h>
#include <queue>
#include <unistd.h>
#include <map>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>

using namespace std;
#define NUM 5

class Task
{
  private:
    int sock;
    map<string,string>dict;
  public:
    Task()
    {}

    Task(int _sock)
       :sock(_sock)
    {
      dict.insert(make_pair("banana","香蕉"));
      dict.insert(make_pair("apple","苹果"));
    }

    void Run()//来一个链接，执行一个任务(打印语句)
    {
      cout<<"Task is run....."<<endl;
      
      char buff[100];
      size_t size=recv (sock,buff,sizeof(buff)-1,0);
      if(size>0)//读取到了
      {
        buff[size]='\0';//末尾添加\0
        string key=buff;

        send(sock,dict[key].c_str(),dict[key].size(),0);//不需要+1，\0是语言的标准，文件不认识
      }
      else if(size==0)
      {
        cout<<"client quit..."<<endl;
        close(sock);//关闭对应的套接字
      }
      else//读取错误
      {
        cerr<<"read error"<<endl;
        close(sock);  
      }
    }

    ~Task()
    {
      close(sock);
    }
};

class Pool
{
  private:
    int _max;//线程个数
    queue<Task*> q;//存指针，减少数据拷贝消耗
    pthread_mutex_t lock;
    pthread_cond_t cond;

  public:
    
    Pool(int max=NUM)
      :_max(max)
    {}

    void TaskLock()
    {
      pthread_mutex_lock(&lock);
    }

    void TaskUnlock()
    {
      pthread_mutex_unlock(&lock);
     }

    void ThreadWait()
    {
      pthread_cond_wait(&cond,&lock);
    }

    void ThreadWakeUp()
    {
      pthread_cond_signal(&cond);//一次唤醒一个
    }

    void AllWakeUp()
    {
      pthread_cond_broadcast(&cond);//全部唤醒
    }


    bool IsEmpty()
    {
      return q.size()==0;
    }

    void Put(Task &data)//外部放入数据
    {
      TaskLock();
      q.push(&data);
      TaskUnlock();
      ThreadWakeUp();//唤醒一个线程
    }

    void Get(Task **data)//内部线程池完成任务
    {
      Task *t=q.front();
      q.pop();
      *data=t;
    }

public:

    //必须设置为静态的，因为成员函数会有this形参
    static void *RunTask(void *arg)//处理任务函数
    {
      Pool* p_this=(Pool*)arg;
      pthread_detach(pthread_self());//分离

      while(true)
      {
         p_this->TaskLock();
         //不退出才进行判断
         while(p_this->IsEmpty())//没有任务则挂起
         {
           p_this->ThreadWait();
         }

         //在这里一定不为空，将任务拿出来
         Task *t;
         p_this->Get(&t);

         p_this->TaskUnlock();
         t->Run();
         delete t;
      }
    }
    
    //尽量不要在构造函数内做有风险的事情
    void Init()
    {
      //锁和环境变量初始化
      pthread_mutex_init(&lock,nullptr);
      pthread_cond_init(&cond,nullptr);

      //线程池的创建
      pthread_t tid;
      for(int i=0;i<_max;i++)
      {
        pthread_create(&tid,nullptr,RunTask,this);//每个线程都去处理任务,不关心线程ID
      }
    }

      ~Pool()
      {
        pthread_mutex_destroy(&lock);
        pthread_cond_destroy(&cond);
      }

};


#ifndef _TCPSERVER_HPP_
#define _TCPSERVER_HPP_

#include "pool.hpp"
#include <iostream>
using namespace std;
#include <stdlib.h>
#include <pthread.h>
#include <signal.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <unistd.h>

#endif

#define BACKLOCK 5

class tcpServer
{
  private:
    int port;
    int lsock;//监听套接字
    Pool *pl;
  
  public:
    tcpServer(int _port)
      :port(_port)
       ,lsock(-1)
       ,pl(nullptr)
    {}

    void initServer()
    {
      signal(SIGCHLD,SIG_IGN);//父进程忽略子进程发送过来的信号，即子进程自己清理资源

      lsock=socket(AF_INET,SOCK_STREAM,0);
      if(lsock<0)
      {
        cerr<<"socket fail"<<endl;
        exit(2);
      }
      
      struct sockaddr_in local;
      local.sin_family=AF_INET;//填充协议
      local.sin_port=htons(port);//填充端口，转换成网网络字节序
      local.sin_addr.s_addr=INADDR_ANY;//填写ip
    
      if(bind(lsock,(struct sockaddr*)&local,sizeof(local))<0)//进行绑定
      {
        cerr<<"bind error"<<endl;
        exit(3);
      }
      if(listen(lsock,BACKLOCK)<0)
      {
        cerr<<"listen error"<<endl;
        exit(4);
      }
      pl=new Pool();
      pl->Init();//初始化线程池
    }

    static void service(int sock)
    {
      char buff[200];
      while(true)
      {
        size_t size=recv (sock,buff,sizeof(buff)-1,0);
        if(size>0)//读取到了
        {
          buff[size]='\0';//末尾添加\0
          cout<<"client:"<<buff<<endl;

          send(sock,buff,strlen(buff),0);//不需要+1，\0是语言的标准，文件不认识
        }
        else if(size==0)
        {
          cout<<"client quit..."<<endl;
          close(sock);//关闭对应的套接字
          break;
        }
        else//读取错误
        {
          cerr<<"read error"<<endl;
          close(sock);
          break;
        }
      }
    }


    static void *sevrun(void *arg)//只能有一个参数，因此必须是static
    {
      pthread_detach(pthread_self());//线程分离
      cout<<"create a new prhread"<<endl;
      int *p=(int*)arg;
      int sock=*p;
      service(sock);//执行任务
      delete p;
      return NULL;
    }

    void stat()
    {
      sockaddr_in end_point;//获取客户结构体信息，和udp作用一样
      while(true)
      {
        //udp直接通信，tcp第一件事是获取链接
        socklen_t len=sizeof(end_point);
        int sock=accept(lsock,(struct sockaddr*)&end_point,&len);
        if(sock<0)
        {
          cerr<<"accpet error"<<endl;
          continue;
        }

        string cl;//客户端信息
        cl+=inet_ntoa(end_point.sin_addr);//网->主，整->字符串
        cl+=':';
        cl+=to_string(ntohs(end_point.sin_port));

        cout<<"get a new accept:"<<cl<<"-"<<"sock:"<<sock<<endl;
      
      //此时获得了新的连接 -> 将任务put至线程池
        Task *t= new Task(sock);
        pl->Put(*t);//将任务put进去

      }
    }

  ~tcpServer()
  {
    close(lsock);
  }

};

效果展示：

6.4.4版本特点

1.单进程版本：只有一个执行流，一般不使用，多进程/多线程版本通常小型应用(局域网，少量机)
2.多进程版本：进程之间是独立的，健壮性强，但是比较吃资源，效率低下
3.多线程版本：健壮性不强，较吃资源，效率相对较高
大量的客户端：系统会存在大量的执行流，切换有可能称为效率低下的原因