Linux网络套接字（二）

山雾隐藏的黄昏

已于 2023-04-19 21:18:18 修改

阅读量411

点赞数 1

分类专栏： Linux 文章标签： linux 网络服务器

于 2023-04-19 13:11:05 首次发布

本文链接：https://blog.csdn.net/wjmhlh/article/details/130068159

版权

Linux 专栏收录该内容

34 篇文章 1 订阅

订阅专栏

本文介绍了TCP套接字编程的基础接口，包括socket、bind、listen、accept和connect等，并通过逐步讲解展示了如何实现单进程、多进程、多线程以及线程池版本的TCP服务器和客户端。文章强调了TCP连接的建立、数据传输和断开流程，并提到了进程和线程管理在服务器设计中的重要性。

摘要由CSDN通过智能技术生成

学习任务：

继网络套接字（一），继续学习套接字socket编程接口（已经学习了socket和bind），实现TCP客户端/服务器(单连接版本, 多进程版本, 多线程版本，进程或线程池版本)，并且理解tcp服务器建立连接, 发送数据, 断开连接的流程。

1.socket编程接口

// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
int socket(int domain, int type, int protocol);

// 绑定端口号 (TCP/UDP, 服务器)
int bind(int socket, const struct sockaddr *address,socklen_t address_len);

// 开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);

// 接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address,socklen_t* address_len);

// 建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

接口解析

// 开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);

函数功能：由于服务器需要周而复始地等待客户端和自己建立连接，因此该函数由服务器使用，功能是等待用户连接，进行系统侦听请求。

第一个参数sockefd：由socket接口创建的套接字fd，不过需要注意

第二个参数backlog：套接字排队的最大连接个数(建议5~10)，即申请连接的客户端的个数。

返回值：成功返回0，错误返回-1。

// 接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address,socklen_t* address_len);

函数功能：接收用户连接请求，并返回一个新的套接字描述符用于与客户端通信。

第一个参数sockfd：由socket接口创建的套接字fd。

第二个参数addr：用于保存客户端的进程协议地址的结构体。

第三个参数addrlen：addr的大小。

返回值：返回一个新的套接字描述符。

// 建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

函数功能：建立连接。

第一个参数sockfd：由accept接口创建的套接字描述符。

第二个参数addr：套接字地址结构的指针。

第三个参数addrlen：addr的大小。

返回值：成功返回0。

单进程版本TCP（客户端/服务器）

单进程版本没有人会去使用，因为这种版本只能是一对一的连接，很明显不能符合业务要求的，就好比我们打开一个学习软件去学习，同学A先打开了，那么同学B、C和更多的其他同学都不能打开了。这里我们借助单进程版本来学习。

首先是写出服务器的代码，代码的思路是这样的：

①首先为服务器创建套接字，因为这个是TCP协议，TCP是面向连接的，因此服务器是需要进入监听状态才能让客户端连接，所以使用socket接口创建出来的套接字是属于监听套接字，负责绑定IP和端口号，负责监听的。

②创建完监听套接字后，开始绑定IP和端口号。先创建出服务器的sockaddr_in结构（因为使用AF_INET协议），然后填充结构体，填充的是使用何种协议域，IP和端口号。在填充IP的时候，选择任意绑定IP。

③设置监听状态，监听状态的服务器，通俗地来解释就是服务器进入监听状态，就是告诉客户端我可以被连接了，来吧！

④使用accept接口，创建出提供服务的套接字。这里需要建立另外一个sockaddr_in结构体，这个结构体是保存客户端的ip和端口号。

⑤最后就是提供服务，由于TCP是面向字节流的，跟文件操作一样，因此我们可以使用文件操作进行读写。

注意：

在bind方法中的sockaddr结构体里面填充的是服务端的ip地址和端口号，bind就把服务器的ip地址和端口号和前面的监听套接字结合起来了。而accept方法中的socketaddr结构体保存的是客户端的ip地址和端口号信息。

代码如下：

#include<iostream>
#include<sys/socket.h> 
#include<sys/types.h>
#include<cerrno>
#include<cstring>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<signal.h>
void Usage(std::string proc)
{
  std::cout<<"Usage: "<<proc<<" port"<<std::endl;
}

void ServerceIO(int new_sock)
{
  while(true)
    {
      //tcp是面向字节流的，如同文件一样，可以进行正常的读写
      char buffer[1024];
      memset(buffer,0,sizeof(buffer));
      //将读到的数据放入buffer中
      ssize_t s = read(new_sock,buffer,sizeof(buffer)-1);
      if(s > 0)//读取成功
      {
          buffer[s] = 0;//将获取的内容当成字符串
          std::cout<<"client#  "<<buffer<<std::endl;
          std::string echo_string =">>>server<<<, ";
          echo_string += buffer;

          write(new_sock,echo_string.c_str(),echo_string.size());
      }
      else if(s==0)
      {
        std::cout<<"client quit..."<<std::endl;
        break;
      }   
      else
      {
        std::cerr<<"read err"<<std::endl;
        break;
      }
    }
}

// ./tcp_server port
int main(int argc,char *argv[])
{
  if(argc!=2)
  {
    Usage(argv[0]);
    return 1;
  }

  //tcp_server
 //1.创建套接字,此套接字为监听套接字，用于绑定和监听
  int listen_sock = socket(AF_INET,SOCK_STREAM,0);
  if(listen_sock < 0)
  {
    std::cerr<<"socket error"<<std::endl;
    return 2;
  }
  //tcp是流式的，与文件强相关，因此与文件操作接口一起使用
  //2.bind绑定IP和端口号
  //填充结构体
  struct sockaddr_in local;
  memset(&local,0,sizeof(local));//初始化为0
  local.sin_family = AF_INET;//协议域
  local.sin_port =htons(atoi(argv[1])); //端口号
  local.sin_addr.s_addr = INADDR_ANY;//IP,不能指的IP，需要任意绑定IP；
  //绑定
  if(bind(listen_sock,(struct sockaddr*)&local,sizeof(local))<0)
  {
    
    std::cerr<<"bind error" <<std::endl;
    return 3;  
  }


  // 3.因为tcp是面向连接的，因此在通信前需要建立连接。UDP是不需要连接的。
  //建立连接的时候，就一定有人会主动建立连接，有人被动接受连接
  //而主动建立连接的是客户端，就是需要服务的一方
  //而被动接受连接的是服务器，就是提供服务的一方
  //这里的是server，被动接受连接的一方,需要周而复始地不间断地等待客户到来，比如我们半夜打开某app看剧一样
  //因此作为服务器，需要给用户提供一个建立连接的功能
  //因此，设置服务器的套接字为Listen监听状态，本质是允许用户连接
  
  const int back_log = 5;
  if(listen(listen_sock,back_log)<0)
  {
    std::cerr<<"listen error"<<std::endl;
    return 4;
  }

  signal(SIGCHLD,SIG_IGN);//父进程忽略子进程的SIGCHLD信号，子进程会自动退出释放资源

  //提供服务
  //使用accept接口，该接口会返回一个套接字，提供服务的套接字
  for(;;)
  {
    struct sockaddr_in peer;
    socklen_t len = sizeof(peer);
    int new_sock = accept(listen_sock,(struct sockaddr*)&peer,&len);
    if(new_sock<0)
    {
      continue;
    }

    std::cout<<"get a new link..."<<new_sock<<std::endl;

    
    // //单进程版，是没有人会去使用的。
    // //这里提供服务是死循环，只能对一个客户进行连接，因为其它客户端无法进行循环
    // //只能串行了
    ServerceIO(new_sock);
    
  }
  return 0;
}

客户端代码，代码思路如下：

①创建套接字。

②客户端不需要显示绑定ip和端口号。注意，是不需要显示绑定，并非不需要绑定，因为在客户端连接服务器的时候，操作系统会自动地绑定ip和端口号。如果固定地绑定，如果其它客户端随机绑定，随机到了我这个客户端的端口号此时我这个客户端就不能启动了。客户端关心的是连接处于监听状态的服务器。

③发起连接。先创建保存服务器ip地址和端口号信息的socketaddr结构体，然后使用connect方法进行连接。

④连接成功就可以开始通信了。

#include <iostream>
#include <string>
#include <cstring>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <strings.h>

// ./tcp_client server_ip  server_port 
void Usage(std::string proc)
{
  std::cout<<"Usage: "<<proc<<" server_ip  server_port"<<std::endl;
}
int main(int argc,char *argv[])
{
  if(argc!=3)
  {
    Usage(argv[0]);
    return 1;
  }

  //ip和端口号
  std::string server_ip = argv[1];
  uint16_t server_port = (uint16_t)(atoi(argv[2]));

  //1.创建套接字
  int sock = socket(AF_INET,SOCK_STREAM,0);
  if(sock<0)
  {
    std::cerr<<"socket err"<<std::endl;
    return 2;
  }
  //2.绑定bind
  //客户端需要绑定，但是客户端不需要显示绑定，TCP和UDP都一样，操作系统会自动绑定端口号和ip
  //因为不能固定地绑，如果其它客户端随机绑定，随机到了我这个客户端的端口号
  //此时我这个客户端就不能启动了
  //客户端关心的是连接处于监听状态的服务器

  //创建服务器的结构并且填充信息
  struct sockaddr_in server;
  memset(&server,0,sizeof(server));
  server.sin_family = AF_INET;
  //填完，不需要显示绑定，需要连接

  //inet_addr 该函数做两件事情
  //1.将点分十进制的字符串风格的ip转化为4字节IP
  //2. 将四字节IP由主机序列转化为网络序列
  server.sin_addr.s_addr = inet_addr(server_ip.c_str());
  server.sin_port = htons(server_port);
  //发起连接
  if(connect(sock,(struct sockaddr*)&server,sizeof(server))<0)
  {
    std::cerr<<"connect err"<<std::endl;
    return 3;
  }

  std::cout<<"connect success!"<<std::endl;

  //进行业务请求,开始通信
  while(true)
  {
    std::cout<<"Please Enter# ";
    char buffer[1024];
    //先将数据写到buffer中
    fgets(buffer,sizeof(buffer)-1,stdin);
    //然后将buffer中的数据发出去
    write(sock,buffer,strlen(buffer));

    //信息返回
    ssize_t s = read(sock,buffer,sizeof(buffer)-1);
    if(s>0)
    {
      buffer[s]=0;
      std::cout<<"server echo# "<<buffer<<std::endl;
    }
  }

  return 0;
}

多进程版本TCP（客户端/服务器）

由于单进程版没有人会去使用，所以我们通过单进程版本来学习一下简单的代码实现操作，接着我们对单进程版本改造（服务器的代码），变成多进程版本。

代码思路：让父进程创建子进程，子进程去执行网络通信，执行完后就把fd关掉。同时，进入到父进程，表示了子进程已经拿到了用于通信的套接字，那么父进程就可以它关闭掉。为了避免产生僵尸进程，使用自定义信号，让父进程忽略子进程退出的信号，让子进程自动退出并释放资源。

#include<iostream>
#include<sys/socket.h> 
#include<sys/types.h>
#include<cerrno>
#include<cstring>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<signal.h>
void Usage(std::string proc)
{
  std::cout<<"Usage: "<<proc<<" port"<<std::endl;
}

void ServerceIO(int new_sock)
{
  while(true)
    {
      //tcp是面向字节流的，如同文件一样，可以进行正常的读写
      char buffer[1024];
      memset(buffer,0,sizeof(buffer));
      //将读到的数据放入buffer中
      ssize_t s = read(new_sock,buffer,sizeof(buffer)-1);
      if(s > 0)//读取成功
      {
          buffer[s] = 0;//将获取的内容当成字符串
          std::cout<<"client#  "<<buffer<<std::endl;
          std::string echo_string =">>>server<<<, ";
          echo_string += buffer;

          write(new_sock,echo_string.c_str(),echo_string.size());
      }
      else if(s==0)
      {
        std::cout<<"client quit..."<<std::endl;
        break;
      }   
      else
      {
        std::cerr<<"read err"<<std::endl;
        break;
      }
    }
}

// ./tcp_server port
int main(int argc,char *argv[])
{
  if(argc!=2)
  {
    Usage(argv[0]);
    return 1;
  }

  //tcp_server
 //1.创建套接字,此套接字为监听套接字，用于绑定和监听
  int listen_sock = socket(AF_INET,SOCK_STREAM,0);
  if(listen_sock < 0)
  {
    std::cerr<<"socket error"<<std::endl;
    return 2;
  }
  //tcp是流式的，与文件强相关，因此与文件操作接口一起使用
  //2.bind绑定IP和端口号
  //填充结构体
  struct sockaddr_in local;
  memset(&local,0,sizeof(local));//初始化为0
  local.sin_family = AF_INET;//协议域
  local.sin_port =htons(atoi(argv[1])); //端口号
  local.sin_addr.s_addr = INADDR_ANY;//IP,不能指的IP，需要任意绑定IP；
  //绑定
  if(bind(listen_sock,(struct sockaddr*)&local,sizeof(local))<0)
  {
    
    std::cerr<<"bind error" <<std::endl;
    return 3;  
  }


  // 3.因为tcp是面向连接的，因此在通信前需要建立连接。UDP是不需要连接的。
  //建立连接的时候，就一定有人会主动建立连接，有人被动接受连接
  //而主动建立连接的是客户端，就是需要服务的一方
  //而被动接受连接的是服务器，就是提供服务的一方
  //这里的是server，被动接受连接的一方,需要周而复始地不间断地等待客户到来，比如我们半夜打开某app看剧一样
  //因此作为服务器，需要给用户提供一个建立连接的功能
  //因此，设置服务器的套接字为Listen监听状态，本质是允许用户连接
  
  const int back_log = 5;
  if(listen(listen_sock,back_log)<0)
  {
    std::cerr<<"listen error"<<std::endl;
    return 4;
  }

  signal(SIGCHLD,SIG_IGN);//父进程忽略子进程的SIGCHLD信号，子进程会自动退出释放资源

  //提供服务
  //使用accept接口，该接口会返回一个套接字，提供服务的套接字
  for(;;)
  {
    struct sockaddr_in peer;
    socklen_t len = sizeof(peer);
    int new_sock = accept(listen_sock,(struct sockaddr*)&peer,&len);
    if(new_sock<0)
    {
      continue;
    }
    //显示是哪给客户端连接了服务器:ip和端口号
    //ntohs：由网络字节序转为主机序列
    uint16_t cli_port = ntohs(peer.sin_port);//端口号
    //inet_ntoa:将四字节转化为点分十进制的字符串风格，并且把网络序列转化为主机序列
    std::string cli_ip = inet_ntoa(peer.sin_addr);//ip

    std::cout<<"get a new link -> : ["<<cli_ip<<":"<<cli_port<<"]# "<<new_sock<<std::endl;

    //版本二：
    //来一个客户端的一个新连接，那就创建一个子进程，子进程进行客户端的通信
    //通信完子进程退出，父进程不管
    pid_t id = fork();
    if(id < 0)
    {
      continue;
    }
    else if(id == 0)//子进程会继承父进程的文件描述符：代码共享，数据写时拷贝
    {//子进程
      //为了不让子进程对监听套接字进行不小心的操作，要在子进程中将其关掉
      close(listen_sock);
      //当子进程退出的时候，会给父进程发送信号
      ServerceIO(new_sock);
      //关闭套接字，也就是关闭fd
      //如果忘记关闭不需要的文件描述符，导致文件描述符泄漏
      close(new_sock);
      exit(0);
    }
    else
    {
      //父进程
      //因为这个用于通信的套接字已经被子进程拿过去了，因此这个套接字对父进程来说没有用了
      //可以把它关掉
      close(new_sock);
    }
  }
  return 0;
}

多线程版本TCP（客户端/服务器）

代码思路：让主线程创建新线程，然后让新线程分离，这样就可以不用线程等待，并且分离出去的线程带着用于通信的套接字去进行通信，通信完后就关闭fd。

#include<iostream>
#include<sys/socket.h> 
#include<sys/types.h>
#include<cerrno>
#include<cstring>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<signal.h>
#include<pthread.h>
void Usage(std::string proc)
{
  std::cout<<"Usage: "<<proc<<" port"<<std::endl;
}

void ServerceIO(int new_sock)
{
  while(true)
    {
      //tcp是面向字节流的，如同文件一样，可以进行正常的读写
      char buffer[1024];
      memset(buffer,0,sizeof(buffer));
      //将读到的数据放入buffer中
      ssize_t s = read(new_sock,buffer,sizeof(buffer)-1);
      if(s > 0)//读取成功
      {
          buffer[s] = 0;//将获取的内容当成字符串
          std::cout<<"client#  "<<buffer<<std::endl;
          std::string echo_string =">>>server<<<, ";
          echo_string += buffer;

          write(new_sock,echo_string.c_str(),echo_string.size());
      }
      else if(s==0)
      {
        std::cout<<"client quit..."<<std::endl;
        break;
      }   
      else
      {
        std::cerr<<"read err"<<std::endl;
        break;
      }
    }
}

void* HandlerRequest(void* args)
{
  pthread_detach(pthread_self());//线程脱离
  int sock = *(int*)args;
  delete (int*)args;

  ServerceIO(sock);//进行通信
  close(sock);//通信结束后关闭文件描述符
}

// ./tcp_server port
int main(int argc,char *argv[])
{
  if(argc!=2)
  {
    Usage(argv[0]);
    return 1;
  }

  //tcp_server
 //1.创建套接字,此套接字为监听套接字，用于绑定和监听
  int listen_sock = socket(AF_INET,SOCK_STREAM,0);
  if(listen_sock < 0)
  {
    std::cerr<<"socket error"<<std::endl;
    return 2;
  }
  //tcp是流式的，与文件强相关，因此与文件操作接口一起使用
  //2.bind绑定IP和端口号
  //填充结构体
  struct sockaddr_in local;
  memset(&local,0,sizeof(local));//初始化为0
  local.sin_family = AF_INET;//协议域
  local.sin_port =htons(atoi(argv[1])); //端口号
  local.sin_addr.s_addr = INADDR_ANY;//IP,不能指的IP，需要任意绑定IP；
  //绑定
  if(bind(listen_sock,(struct sockaddr*)&local,sizeof(local))<0)
  {
    
    std::cerr<<"bind error" <<std::endl;
    return 3;  
  }


  // 3.因为tcp是面向连接的，因此在通信前需要建立连接。UDP是不需要连接的。
  //建立连接的时候，就一定有人会主动建立连接，有人被动接受连接
  //而主动建立连接的是客户端，就是需要服务的一方
  //而被动接受连接的是服务器，就是提供服务的一方
  //这里的是server，被动接受连接的一方,需要周而复始地不间断地等待客户到来，比如我们半夜打开某app看剧一样
  //因此作为服务器，需要给用户提供一个建立连接的功能
  //因此，设置服务器的套接字为Listen监听状态，本质是允许用户连接
  
  const int back_log = 5;
  if(listen(listen_sock,back_log)<0)
  {
    std::cerr<<"listen error"<<std::endl;
    return 4;
  }

  
  //提供服务
  //使用accept接口，该接口会返回一个套接字，提供服务的套接字
  for(;;)
  {
    struct sockaddr_in peer;
    socklen_t len = sizeof(peer);
    int new_sock = accept(listen_sock,(struct sockaddr*)&peer,&len);
    if(new_sock<0)
    {
      continue;
    }
    //显示是哪给客户端连接了服务器:ip和端口号
    //ntohs：由网络字节序转为主机序列
    uint16_t cli_port = ntohs(peer.sin_port);//端口号
    //inet_ntoa:将四字节转化为点分十进制的字符串风格，并且把网络序列转化为主机序列
    std::string cli_ip = inet_ntoa(peer.sin_addr);//ip

    std::cout<<"get a new link -> : ["<<cli_ip<<":"<<cli_port<<"]# "<<new_sock<<std::endl;
    //版本3  多线程版本
    //新线程会跟主线程的文件描述符共享，因此不需要关闭监听套接字
    //选择新线程分离，就不需要等待了
    //新线程分离后，就拿着提供服务的套接字走，去进行通信， 通信完毕关闭这个套接字即可
    pthread_t tid;
    int * pram = new int(new_sock);
    pthread_create(&tid,nullptr,HandlerRequest,pram);
  }
  return 0;
}

警告：

在上面两个版本（多线程和多进程版本）的写法中看，有两个弊端：

①创建进程或线程是无上限的，这给了一些带有恶意的用户一个搞破坏的机会！

②每次都是要等待客户连接来了，才会去创建子进程或者是线程。这毫无疑问浪费了不必要的时间。

因此针对这两个问题，我们可以采用进程池或者是线程池来解决！下面使用线程池版本！

线程池版本TCP（客户端/服务器）

#pragma once

#include <iostream>
#include <string>
#include <queue>
#include <unistd.h>
#include <pthread.h>

namespace ns_threadpool
{
    const int g_num = 5;

    template <class T>
    class ThreadPool
    {
    private:
        int num_;
        std::queue<T> task_queue_; //该成员是一个临界资源

        pthread_mutex_t mtx_;
        pthread_cond_t cond_;

        static ThreadPool<T> *ins;

    private:
        // 构造函数必须得实现，但是必须的私有化
        ThreadPool(int num = g_num) : num_(num)
        {
            pthread_mutex_init(&mtx_, nullptr);
            pthread_cond_init(&cond_, nullptr);
        }
        ThreadPool(const ThreadPool<T> &tp) = delete;
        //赋值语句
        ThreadPool<T> &operator=(ThreadPool<T> &tp) = delete;

    public:
        static ThreadPool<T> *GetInstance()
        {
            static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
            // 当前单例对象还没有被创建
            if (ins == nullptr) //双判定，减少锁的争用，提高获取单例的效率！
            {
                pthread_mutex_lock(&lock);
                if (ins == nullptr)
                {
                    ins = new ThreadPool<T>();
                    ins->InitThreadPool();
                    std::cout << "首次加载对象" << std::endl;
                }
                pthread_mutex_unlock(&lock);
            }

            return ins;
        }

        void Lock()
        {
            pthread_mutex_lock(&mtx_);
        }
        void Unlock()
        {
            pthread_mutex_unlock(&mtx_);
        }
        void Wait()
        {
            pthread_cond_wait(&cond_, &mtx_);
        }
        void Wakeup()
        {
            pthread_cond_signal(&cond_);
        }
        bool IsEmpey()
        {
            return task_queue_.empty();
        }

    public:
        // 在类中要让线程执行类内成员方法，是不可行的！
        // 必须让线程执行静态方法
        static void *Rountine(void *args)
        {
            pthread_detach(pthread_self());
            ThreadPool<T> *tp = (ThreadPool<T> *)args;

            while (true)
            {
                tp->Lock();
                while (tp->IsEmpey())
                {
                    //任务队列为空，线程该做什么呢？？
                    tp->Wait();
                }
                //该任务队列中一定有任务了
                T t;
                tp->PopTask(&t);
                tp->Unlock();

                t.Run();
            }
        }
        void InitThreadPool()
        {
            pthread_t tid;
            for (int i = 0; i < num_; i++)
            {
                pthread_create(&tid, nullptr, Rountine, (void *)this /*?*/);
            }
        }
        void PushTask(const T &in)
        {
            Lock();
            task_queue_.push(in);
            Unlock();
            Wakeup();
        }
        void PopTask(T *out)
        {
            *out = task_queue_.front();
            task_queue_.pop();
        }
        ~ThreadPool()
        {
            pthread_mutex_destroy(&mtx_);
            pthread_cond_destroy(&cond_);
        }
    };

    template <class T>
    ThreadPool<T> *ThreadPool<T>::ins = nullptr;
} // namespace ns_threadpool

#pragma once

#include <iostream>
#include <cstring>
#include <unistd.h>

namespace ns_task
{
    class Task
    {
    private:
        int sock;

    public:
        Task() : sock(-1) {}

        Task(int _sock) : sock(_sock) {}

        int Run()
        {
            //提供服务，短服务
            char buffer[1024];
            memset(buffer, 0, sizeof(buffer));
            ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
            if (s > 0)
            {
                buffer[s] = 0; //将获取的内容当成字符串
                std::cout << "client# " << buffer << std::endl;
                std::string echo_string = ">>>server<<<, ";
                echo_string += buffer;
                write(sock, echo_string.c_str(), echo_string.size());
            }
            else if (s == 0)
            {
                std::cout << "client quit ..." << std::endl;
            }
            else
            {
                std::cerr << "read error" << std::endl;
            }
            //服务提供完就关闭文件描述符
            close(sock);
        }
        ~Task() {}
    };
}

#include<iostream>
#include<sys/socket.h> 
#include<sys/types.h>
#include<cerrno>
#include<cstring>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<signal.h>
#include<pthread.h>
#include"thread_pool.hpp"
#include"Task.hpp"
using namespace ns_threadpool;
using namespace ns_task;
void Usage(std::string proc)
{
  std::cout<<"Usage: "<<proc<<" port"<<std::endl;
}
// ./tcp_server port
int main(int argc,char *argv[])
{
  if(argc!=2)
  {
    Usage(argv[0]);
    return 1;
  }

  int listen_sock = socket(AF_INET,SOCK_STREAM,0);
  if(listen_sock < 0)
  {
    std::cerr<<"socket error"<<std::endl;
    return 2;
  }

  struct sockaddr_in local;
  memset(&local,0,sizeof(local));
  local.sin_family = AF_INET;
  local.sin_port =htons(atoi(argv[1])); 
  local.sin_addr.s_addr = INADDR_ANY;
  if(bind(listen_sock,(struct sockaddr*)&local,sizeof(local))<0)
  {
    
    std::cerr<<"bind error" <<std::endl;
    return 3;  
  }
  const int back_log = 5;
  if(listen(listen_sock,back_log)<0)
  {
    std::cerr<<"listen error"<<std::endl;
    return 4;
  }
  for(;;)
  {
    struct sockaddr_in peer;
    socklen_t len = sizeof(peer);
    int new_sock = accept(listen_sock,(struct sockaddr*)&peer,&len);
    if(new_sock<0)
    {
      continue;
    }
    uint16_t cli_port = ntohs(peer.sin_port);
    
    std::string cli_ip = inet_ntoa(peer.sin_addr);//ip

    std::cout<<"get a new link -> : ["<<cli_ip<<":"<<cli_port<<"]# "<<new_sock<<std::endl;
    //版本4:线程池
    //构建任务
    Task t(new_sock);
    //将任务push到后端的线程池
    //获取单例即可
    ThreadPool<Task>::GetInstance()->PushTask(t);

  }
  return 0;
}

TCP协议通信流程

通过上面的代码，我们来总结一下流程：

①创建监听套接字sock。socket()方法本质是打开文件，这是跟系统相关的。

②绑定ip和端口号，使用bind()方法，本质是ip+port+文件信息进行关联。

③服务端设置为监听状态，使用listen()方法，本质是设置该socket文件的状态，允许客户端来连接。

④获取连接，使用accept()方法，连接的本质是描述连接的结构体，由操作系统管理着。

⑤发起链接，使用connect()方法，本质是发起链接，在系统层面就是构建一个申请报文发送过去，在网络层面，发起tcp链接的三次握手！

⑥进行网络通信，使用文件读写的方式，read/wirte的方法。关

⑦闭监听套接字close(fd),本质：a、在系统层面，释放曾经申请的文件资源和连接资源等待。b、在网络层面，通知对方服务端的连接已经关闭。

⑧关闭用于通信的套接字close() && server/client，本质是在网络层面进行四次挥手！

三次握手：

在服务器建立连接的时候：

调用socket, 创建文件描述符。
调用connect, 向服务器发起连接请求。
connect会发出SYN段并阻塞等待服务器应答(第一次)。
服务器收到客户端的SYN, 会应答一个SYN-ACK段表示"同意建立连接"(第二次)。
客户端收到SYN-ACK后会从connect()返回, 同时应答一个ACK段(第三次)。

四次挥手：

如果客户端没有更多的请求了, 就调用close()关闭连接, 客户端会向服务器发送FIN段(第一次);此时服务器收到FIN后, 会回应一个ACK, 同时read会返回0 (第二次);read返回之后, 服务器就知道客户端关闭了连接, 也调用close关闭连接, 这个时候服务器会向客户端发送一个FIN; (第三次)客户端收到FIN, 再返回一个ACK给服务器; (第四次)。

在上面写的代码中，不管是在单进程、多进程多线程还是线程池，我们其实都是在使用系统调用，从零开始编写网络层，而非在使用网络层！