标签搜索

目 录CONTENT

文章目录

网络编程套接字(四).md

小小城
2021-08-22 / 0 评论 / 0 点赞 / 6 阅读 / 4,941 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2022-05-02,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

网络编程套接字(四)

@[toc]

一、实现tcp服务器多用户版本(多进程、多线程、线程池版本)

  • tcp_process_server.hpp
#pragma once
#include "tcp_socket.hpp"
#include <functional>
#include <signal.h>

typedef std::function<void (const std::string& req,std::string* resp)> Handler;

class TcpProcessServer
{
  public:
    TcpProcessServer(const std::string& ip,uint16_t port)
      :ip_(ip)
       ,port_(port)
  {
    //对于多进程版本服务器,在请求到来时生成子进程处理请求,父进程继续accept。如果父进程不等待
    //子进程结束,子进程将成为僵尸进程(zombie)从而占用系统资源。如果父进程等待子进程结束
    //将增加父进程的负担,影响服务器进程的并发性能。在Linux下可以简单地将 SIGCHLD信号的操作设为SIG_IGN。
    //将SIGCHLD(子进程结束自动像父进程发送的信号)此信号设为忽略SIG_IGN
    signal(SIGCHLD,SIG_IGN);
  }

    void ProcessConnect(TcpSocket& new_sock,const std::string& ip,uint16_t port,Handler handler)
    {
      int ret = fork();
      if(ret > 0)
      {
        //father
        //父进程不需要做额外操作,只需要循环accept即可,就直接返回
        //此处如果采用wait操作,那么就达不到采用多进程的目的,采用多进程为了可以同时处理多个用户
        //如果在此处wait,那么父进程就会等待子进程处理客户端请求结束,特别耗费时间
        new_sock.Close();
        return;
      }
      else if(ret == 0)
      {
        //child
        //处理具体的链接过程即根据请求计算响应
        while(1)
        {
          std::string req;
          bool ret = new_sock.Recv(&req);
          if(!ret)
          {
            printf("[client %s : %d] disconnect!\n",ip.c_str(),port);
            exit(0);
          }

          std::string resp;
          handler(req,&resp);

          new_sock.Send(resp);

          printf("[client %s : %d ] req : %s, resp : %s\n",ip.c_str(),port,req.c_str(),resp.c_str());

        }
      }
      else
      {
        perror("fork is error");

      }
    }

    bool Start(Handler handler)
    {
      //1. 创建 socket;
      CHECK_RET(listen_sock_.Socket());

      // 2. 绑定端口号
      CHECK_RET(listen_sock_.Bind(ip_, port_));

      // 3. 进行监听
      CHECK_RET(listen_sock_.Listen(5));

      // 4. 进入事件循环
      for (;;) 
      {
        // 5. 进行 accept
        TcpSocket new_sock;
        std::string ip;
        uint16_t port = 0;
        if (!listen_sock_.Accept(&new_sock, &ip, &port)) 
        {
          continue;
        }

        printf("[client %s:%d] connect!\n", ip.c_str(), port);
        ProcessConnect(new_sock, ip, port, handler);
      }
      return true;
    }
  private:
    TcpSocket listen_sock_;
    std::string ip_;
    uint16_t port_;
};

  • tcp_pthread_server.hpp
#pragma once
#include <functional>
#include <pthread.h>
#include "tcp_socket.hpp"

typedef std::function<void (const std::string& req, std::string* resp)> Handler;

struct ThreadArg 
{
  TcpSocket new_sock;
  std::string ip;
  uint16_t port;
  Handler handler;
};

class TcpThreadServer 
{
  public:
    TcpThreadServer(const std::string& ip, uint16_t port) 
      : ip_(ip), port_(port) 
    {

    } 

    bool Start(Handler handler) 
    {
      // 1. 创建 socket;
      CHECK_RET(listen_sock_.Socket());

      // // 2. 绑定端口号
      CHECK_RET(listen_sock_.Bind(ip_, port_));

      // // 3. 进行监听
      CHECK_RET(listen_sock_.Listen(5));

      // 4. 进入循环
      for (;;) 
      {
        // 5. 进行 accept
        ThreadArg* arg = new ThreadArg();
        arg->handler = handler;

        bool ret = listen_sock_.Accept(&arg->new_sock, &arg->ip, &arg->port);
        if (!ret) 
        {
          continue;
        }

        printf("[client %s:%d] connect\n", arg->ip.c_str(), arg->port);

        // 6. 创建新的线程完成具体操作
        pthread_t tid;
        pthread_create(&tid, NULL, ThreadEntry, arg);
        pthread_detach(tid);
      }
      return true;
    }

    static void* ThreadEntry(void* arg) 
    {
      ThreadArg* p = reinterpret_cast<ThreadArg*>(arg);
      PthreadConnect(p);
      // 一定要记得释放内存!!! 也要记得关闭文件描述符
      p->new_sock.Close();
      delete p;
      return NULL;
    }

    static void PthreadConnect(ThreadArg* arg) 
    {
      // 1. 循环进行读写
      for (;;) 
      {
        std::string req;

        // 2. 读取请求
        bool ret = arg->new_sock.Recv(&req);
        if (!ret) 
        {
          printf("[client %s:%d] disconnected!\n", arg->ip.c_str(), arg->port);
          break;
        }

        std::string resp;
        // 3. 根据请求计算响应
        arg->handler(req, &resp);

        // 4. 发送响应
        arg->new_sock.Send(resp);
        printf("[client %s:%d] req: %s, resp: %s\n", arg->ip.c_str(),
            arg->port, req.c_str(), resp.c_str());
      }
    }

  private:
    TcpSocket listen_sock_;
    std::string ip_;
    uint16_t port_;
};

  • tcp_threadpool_server.hpp
#pragma once
#include"tcp_socket.hpp"
#include<pthread.h>
#include"threadpool.hpp"
#include<sys/syscall.h>
#include<unistd.h>
#include<stdio.h>
#include <functional>

typedef std::function<void (const std::string& req,std::string* resp)> Handler;

struct Arg
{
  TcpSocket sock_;
  std::string _ip;
  uint16_t _port;
  Handler _handler;
};

class MyTask:public Task
{
  public:
    MyTask(void* arg)
      :arg_(arg)
    {}

    virtual void Run()override
    {
      Arg *arg = (Arg*)arg_;
      TcpSocket newsock_ = arg->sock_;
      std::string ArgIp = arg->_ip;
      int ArgPort = arg->_port;
      Handler ArgHandler = arg->_handler;

      while(1)
      {
        std::string msg;
        int n = newsock_.Recv(&msg);
        if(n < 0)
        {
          continue;

        }
        else if(n == 0)
        {
          printf("[%s:%d]客户端已经关闭!\n",ArgIp.c_str(),ArgPort);
          break;

        }

        printf("[%s:%d]客户端输入:%s\n",ArgIp.c_str(),ArgPort,msg.c_str());

        std::string resp;
        ArgHandler(msg,&resp);

        if(newsock_.Send(resp) == false)
          continue;
      }
      newsock_.Close();
      delete arg;
    }

  private:
    void* arg_;
};


class TcpThreadPoolServer
{
  public:
    TcpThreadPoolServer(const std::string ip,uint16_t port)
      :pool(10)
       ,ip_(ip)
       ,port_(port)
    {}

    ~TcpThreadPoolServer()
    {
      sock_.Close();

    }

    bool Start(Handler handler)
    {
      if(sock_.Socket() == false)
        return false;
      
      cout<<__LINE__<<endl;
      if(sock_.Bind(ip_,port_) == false)
        return false;
      cout<<__LINE__<<endl;

      if(sock_.Listen() == false)
        return false;

      while(1)
      {
        Arg *NewArg = new Arg;
        NewArg->_handler = handler;
        if(sock_.Accept(&(NewArg->sock_),&NewArg->_ip,&NewArg->_port) == false)
          continue;

        printf("[%s:%d]客户端已连接!\n",NewArg->_ip.c_str(),NewArg->_port);
        pool.AddTask(new MyTask((void*)NewArg));
      }
    }

  private:
    TcpSocket sock_;
    ThreadPool pool;
    std::string ip_;
    uint16_t port_;
};
0

评论区