网络编程复习3tcp通信代码实现（多进程版本+多线程版本）

已于 2023-03-13 20:44:34 修改
阅读量125 收藏
点赞数
文章标签： 网络 c++ 网络协议 linux
于 2023-02-06 17:57:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hou19975418/article/details/128905639
版权
文章展示了如何使用C++实现一个TCP套接字类，包括创建、绑定、监听、连接、接受、发送和接收数据。接着，通过tcp_srv.cpp展示了一个简单的服务器处理客户端连接的过程，然后逐步演进到多进程(process_tcp_srv.cpp)和多线程(pthread_tcp_srv.cpp)版本，以处理并发连接。
摘要由CSDN通过智能技术生成

tcpsocket.hpp

#include<cstdio>
#include<iostream>
#include<string>
#include<unistd.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/socket.h>
#include<cstring>

#define MAX_LISTEN 5
#define CHECK_RET(q) if((q)==false){return false;}

typedef struct
{
 int num1;
 int num2;
 char op;
}tmp_t;

class TcpSocket
{
  public:
    TcpSocket():_sockfd(-1){}

    bool Socket()
    {
      this->_sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
      if(this->_sockfd <0)
      {
        perror("socket perror");
        return false;
      }

      return true;
    }

    int GetFd()
    {
      return _sockfd;
    }

    void Addr(struct sockaddr_in* addr, const std::string& ip, uint16_t port)
    {
      addr->sin_family = AF_INET;
      addr->sin_port = htons(port);
      addr->sin_addr.s_addr = inet_addr(ip.c_str());
      return;
    }

    bool Bind(const std::string &ip, uint16_t port)
    {
      struct sockaddr_in addr;
      Addr(&addr,ip,port);
      socklen_t len = sizeof(struct sockaddr_in);
      int ret = bind(_sockfd, (sockaddr*)&addr, len);
      if(ret<0)
      {
        perror("bind error");
        return false;
      }
        return true;
    }

    bool Listen(int backlog = MAX_LISTEN)
    {
      //int listen(描述符，同一时间最大连接数)
      int ret =listen(_sockfd,backlog);
      if(ret<0)
      {
        perror("listen error");
        return false;
      }
      return true;
    }

    bool Connect(const std::string &ip, u_int16_t port)
    {
      //connect(描述符，服务端地址，服务端地址长度)
      struct sockaddr_in addr;
      Addr(&addr,ip,port);

      socklen_t  len = sizeof(struct sockaddr_in); 
      
      int ret = connect(_sockfd,(struct sockaddr*)&addr, len);
      if(ret<0)
       {
        perror("connect error");
        return false;
      }
      return true;
    }

    bool Accpet(TcpSocket* sock, std::string *ip=NULL, uint16_t *port = NULL)
    {
      //accept(监听描述符，客户端地址，地址长度)
     struct sockaddr_in addr;
     
     socklen_t len = sizeof(struct sockaddr_in);
    int newfd = accept(_sockfd,(struct sockaddr*)&addr, &len);

    if(newfd<0)
    {
      perror("accept error");
      return false;
    }

    sock->_sockfd = newfd;
   
    if(ip != NULL)
    {
      *ip = inet_ntoa(addr.sin_addr);
    }

    if(port != NULL)
    {
      *port = ntohs(addr.sin_port);
    }

    return true;
    }

    bool Send(const std::string &data)
    {
      //ssize_t send(描述符，数据，长度，标志)
      int total =0;
      while(total <(int)data.size())
      {
      int ret = send(_sockfd, &data[0]+total,data.size()-total,0); 

      if(ret <0)
      {
        printf("发送失败\n");
        perror("send error");
        return false;
      }
      total+=ret;
      }
      return true;

    }

    bool Recv(std::string *buf)
    {
     //ssize_t recv(描述符，缓冲区，长度，标志);
     
     char tmp[4096]={0};
     int ret = recv(_sockfd,tmp,4096,0);
     if(ret<0)
     {
       perror("recv error");
       return false;
     }

     if(ret ==0)
     {
       std::cout<<"peer shutdown"<<std::endl;
       return false;
     }

      buf->assign(tmp,ret);//申请空间拷贝指定长度数据
      return true;
    }

    bool Close()
    {
      if(_sockfd != -1)
      {
        close(_sockfd);
      }
      return true;
    }

 private:
   int _sockfd;
};

tcp_srv.cpp（存在accept阻塞和recv阻塞，功能不完善）

#include"tcpsocket.hpp"
#include<string>
#include<cstring>

int main(int argc, char *argv[])
{
  //argc是程序运行参数个数
  //argv存放程序运行参数 ./tcp_srv 10.0.4.7 9000
  if(argc !=3)
  {
    printf("useage: ./tcp_srv 10.0.4.7 9000");
    return -1;
  }

  std::string ip = argv[1];
  uint16_t port = std::stoi(argv[2]);

  TcpSocket lst_sock;

  //1.创建套接字
  CHECK_RET(lst_sock.Socket());
  //2.绑定地址信息
  CHECK_RET(lst_sock.Bind(ip,port));
  //3.开始监听
  CHECK_RET(lst_sock.Listen());
  while(1)
  {
    //4.获取新建连接
    TcpSocket new_sock;
    bool ret = lst_sock.Accpet(&new_sock,&ip,&port);
    if(ret ==false)
    {
      usleep(1000);
      continue;
    }
    std::cout<<"new conn- "<<ip<<":"<<port<<std::endl;
    //5.通过新建链接与客户端通信
    std::string buf;
    ret = new_sock.Recv(&buf);
    if(ret ==false)
    {
      new_sock.Close();
      continue;
    }
    std::cout<<"client say: "<<buf<<std::endl;

    buf.clear();
    std::cout<<"server say: ";
    std::cin>>buf;
    ret = new_sock.Send(buf);
    if(ret ==false)
    {
      new_sock.Close();
      continue;

    }
    //6.关闭套接字
  }
    lst_sock.Close();
    return 0;
}

process_tcp_srv.cpp（多进程版本）

#include"tcpsocket.hpp"
#include<string>
#include<cstring>
#include<signal.h>

void worker(TcpSocket &new_sock)
{
  bool ret;
  while(1)
  {
    //5.通过新建链接与客户端通信
    std::string buf;
    ret = new_sock.Recv(&buf);
    if(ret ==false)
    {
      new_sock.Close();
      return;
    }
    std::cout<<"client say: "<<buf<<std::endl;

    buf.clear();
    std::cout<<"server say: ";
    std::cin>>buf;
    ret = new_sock.Send(buf);
    if(ret ==false)
    {
      new_sock.Close();
      return;
    }
  }
}
  int main(int argc, char *argv[])
  {
    //argc是程序运行参数个数
    //argv存放程序运行参数 ./tcp_srv 10.0.4.7 9000
    if(argc !=3)
    {
      printf("useage: ./tcp_srv 10.0.4.7 9000");
      return -1;
    }

    signal(SIGCHLD, SIG_IGN);//避免产生僵尸进程

    std::string ip = argv[1];
    uint16_t port = std::stoi(argv[2]);

    TcpSocket lst_sock;

    //1.创建套接字
    CHECK_RET(lst_sock.Socket());
    //2.绑定地址信息
    CHECK_RET(lst_sock.Bind(ip,port));
    //3.开始监听
    CHECK_RET(lst_sock.Listen());
    while(1)
    {
      //4.获取新建连接
      TcpSocket new_sock;
      bool ret = lst_sock.Accpet(&new_sock,&ip,&port);
      if(ret ==false)
      {
        usleep(1000);
        continue;
      }
      std::cout<<"new conn- "<<ip<<":"<<port<<std::endl;
      //创建一个新的子进程与客户端进行通信
      pid_t pid = fork();
      if(pid ==0)
      {
        worker(new_sock);
       new_sock.Close();
        exit(0);
      }
      //反而如果不关闭，会造成资源泄露
      new_sock.Close();//这个关闭不会影响客户端-父子进程数据独有

    }
    //6.关闭套接字
    lst_sock.Close();
    return 0;
  }

pthread_tcp_srv.cpp(多线程版本)

#include"tcpsocket.hpp"
#include<string>
#include<cstring>
#include<pthread.h>

void* worker(void* arg)
{
  TcpSocket* new_sock = (TcpSocket*)arg;
  while(1)
  {
   int ret =0;
    //5.通过新建链接与客户端通信
    std::string buf;
    ret = new_sock->Recv(&buf);
    if(ret ==false)
    {
      new_sock->Close();
      continue;
    }
    std::cout<<"client say: "<<buf<<std::endl;

    buf.clear();
    std::cout<<"server say: ";
    std::cin>>buf;
    ret = new_sock->Send(buf);
    if(ret ==false)
    {
      new_sock->Close();
     delete new_sock;
     return NULL;
    }    
  }
  return NULL;
}
int main(int argc, char *argv[])
{
  //argc是程序运行参数个数
  //argv存放程序运行参数 ./tcp_srv 10.0.4.7 9000
  if(argc !=3)
  {
    printf("useage: ./tcp_srv 10.0.4.7 9000");
    return -1;
  }

  std::string ip = argv[1];
  uint16_t port = std::stoi(argv[2]);

  TcpSocket lst_sock;

  //1.创建套接字
  CHECK_RET(lst_sock.Socket());
  //2.绑定地址信息
  CHECK_RET(lst_sock.Bind(ip,port));
  //3.开始监听
  CHECK_RET(lst_sock.Listen());
  while(1)
  {
    //4.获取新建连接
    TcpSocket* new_sock=new TcpSocket();
    bool ret = lst_sock.Accpet(new_sock,&ip,&port);
    if(ret ==false)
    {
      usleep(1000);
      continue;
    }
    std::cout<<"new conn- "<<ip<<":"<<port<<std::endl;
    pthread_t tid;
    pthread_create(&tid,NULL,worker,(void*)new_sock);
    pthread_detach(tid);
    //new通_sock.Close();//线程之间共享文件描述符表
    //6.关闭套接字
  }
    lst_sock.Close();
    return 0;
}

tcp_cli.cpp

#include"tcpsocket.hpp"
#include<string>

int main(int argc, char* argv[])
{
  if(argc !=3)
  {
    printf("useage: ./tcp_cli srvip srvport\n");
    return -1;
  }

  std::string srv_ip = argv[1];
  int16_t srv_port = std::stoi(argv[2]);

  TcpSocket cli_sock;

  //1.创建套接字
  CHECK_RET(cli_sock.Socket());
  //2.绑定地址信息
  //3.向服务端发起连接请求
  CHECK_RET(cli_sock.Connect(srv_ip,srv_port));
  while(1)
  {
  //4.与服务端进行通信
  std::string buf;
  std::cout<<"client say:";
  std::cin>>buf;
  CHECK_RET(cli_sock.Send(buf));

  buf.clear();
  CHECK_RET(cli_sock.Recv(&buf));
  std::cout<<"server say: "<<buf<<std::endl;
  }
  //5.关闭套接字
  cli_sock.Close();
  return 0;
}

写一本我们家的书
关注
TCP通信程序代码实现
weixin_51492999的博客
11-17 1183
文章目录TCP通信程序概述 TCP通信程序 概述 面向连接的通信，客户端和服务器端必须经过三次握手，建立逻辑连接，才能通信 通信的步骤 服务器端先启动 服务器端不会主动请求客户端 必须使用客户端请求服务器端 客户端和服务器端就会建立一个逻辑连接 而这个连接中包含一个对象，这个对象就是IO对象 客户端和服务器端就可以使用IO进行通信 通信的数据不仅仅是字符 所以IO对象是字节流对象 客户端和服务器端进行一个数据交互，需要四个IO流对象（2对InputStream OutputStream） 在java中，提供
TCP通信的代码实现
weixin_54012233的博客
04-11 221
TCP通信的客户端代码实现 代码： public class TCPClient { public static void main(String[] args) throws IOException { Socket socket = new Socket("127.0.0.1",8888); OutputStream os = socket.getOutputStream(); os.write("你好服务器".getBytes());
多进程tcp通信
yj
04-10 144
【代码】多进程tcp通信。
TCP实现代码TCP实现代码
08-06
TCP实现代码TCP实现代码TCP实现代码TCP实现代码
TCP通信的实现代码
V的博客
03-30 2864
传输控制协议（TCP，Transmission Control Protocol）是一种面向**连接的**、可靠的、**基于字节流的**传输层通信协议。
TCP网络编程.zip
08-04
4. **多线程/多进程编程**：当有多个客户端同时连接服务器时，如何有效地处理并发连接，提高服务器的处理能力。 5. **TCP性能分析**：通过实验数据，分析TCP连接建立的时间成本，数据传输的速率，以及不同网络条件...
网络编程（一）TCP单进程服务器编程详解
weixin_42445051的博客
03-28 5284
一，单进程处理服务器 1，基本概念 想要学习socket网络编程的读者一定要首先学好计算机网络的理论知识，包括 1）osi网络七层模型与ip四层模型 2）套接字含义 3）局域网通信过程 4）广域网通信过程 5）tcp，udp通信协议，在这两个协议中的数据封装，传输过程，传输中可能遇到的问题的处理（差错控制，拥塞控制） 6）ip网络层协议，以太网帧协议 7）数据的封装 以上的知识点是个人觉得学习计算机网络必须要理解透彻的一些知识点，接下来要介绍的socket网络编程便是基于以上知识点学习的。 socket网络
海南大学《TCP IP网络编程》复习题.pdf
01-22
为了提高网络服务的并发能力，通常会采用多线程或多进程的方式处理多个客户端的请求。 - **多线程**：在同一进程中创建多个线程来处理不同的任务。 - **多进程**：创建多个子进程，每个子进程处理一个客户端的请求...
计算机网络课程设计--基于TCP协议网上聊天程序--python实现带图形界面--socket--多线程
热门推荐
hello.尘心
08-05 1万+
在科学技术飞速发展的时代，计算机网络显示了它蓬勃发展的生命力，越来越多的人已经离不开网络了，无论是工作、学习还是休闲娱乐，这些都已经和网络息息相关。本次计算机网络课程设计是基于TCP协议网上聊天程序，程序中用到了套接字socket、多线程thread和Python自带的图形界面库Tkinter，在密码保存和传递方面用到了MD5算法，该程序的功能：用户注册、用户登录、显示在线用户和支持多人聊天。
TCP/IP网络编程复习（下）
j15941558855的博客
11-05 553
边缘触发方式可以分离接收数据和处理数据的时间点，即使输入缓冲收到数据（注册相应事件），服务器端也能决定读取和处理这些数据的时间点，给服务器端的实现带来巨大的灵活性；而条件触发因为每次事件数的累加，服务器端无法承受，所以是不可能的。
TCP/IP协议实现源代码
05-30
TCP/IP协议实现源代码(C++)，网上找来的，分享一下
服务端多进程同过同一个tcp套接字与客户端通信
07-30
服务端多进程同过同一个tcp套接字与客户端通信， 打破思维定式
练习：TCP多进程通信
Jan___的博客
02-27 221
1.客户端： socket()-connect()-read()/write()/send()/recv()-close() 2.服务器： socket()-bind()-listen()-accept()-read()/write()/send()/recv()-close() 3.socket的填充内容，注意其中一个地址信息结构体：struct sockaddr 我们一般不对这个结构体操作。而...
TCP 登录实现代码
weixin_34260991的博客
04-30 408
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java....
TCP客户端代码实现及其详解
walle被注册了的博客
11-12 1026
"""tcp客户端""" import socket 采用Internet通信方式,创建tcp协议的套接字tcp_socket tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 服务器地址 far_ip_port = ("127.0.0.1", 8888) 输入用户需要发送的数据 send_data = inp...
TCP通信的客户端代码实现
weixin_38914772的博客
10-11 137
/** @author 许泽鑫 @data 2019/10/11 - 14:47 TCP通信的客户端：向服务器发送连接请求，给服务器发送数据，读取服务器回写的数据 表示客户端的类： java.net.Socket:此类实现客户端套接字.套接字是两台机器间通信的端点 套接字：包含了IP地址和端口号的网络单位 构造方法： Socket(String host,int port):创建一个流套接字并...
网络协议
qq_43661841的博客
12-12 170
TCP通信的客户端：向服务器发送连接请求，给服务器发送数据，读取服务器回写的数据 表示客户端的类： java.net.Socket：此类实现客户端套接字，套接字是辽台机器间通信的端点 套接字：包含了IP地址和端口号的网络单位 ...
TCP通信（单进程/多进程/多线程/线程池）
最新发布
m0_61780496的博客
04-25 1061
介绍了linux环境下TCP通信的接口，telnet工具的使用，实现了5个版本的服务器。1、单进程循环监听；2、多进程+忽略SIGCHLD信号；3、多进程+子进程再fork；4、多线程+pthread_detach；5、多线程+线程池
TCP实现网络通信(多进程与多线程版本)
分享学习的知识，记录我的技术成长道路
08-17 770
第一个参数代表用于监听的套接字文件的文件描述符，第二个参数为服务端的协议地址空间，第三个参数为该协议地址空间的大小。●获取新连接到应用层：accept()，返回值为一个新的套接字的文件描述符，参数为监听套接字的文件描述符。● 创建网络套接字：socket()，协议族为AF_INET，套接字类型为SOCK_STREAM。●创建网络套接字：socket()，协议族为AF_INET，套接字类型为SOCK_STREAM。● 监听网络连接：listen()，参数为套接字的文件描述符。●关闭套接字文件：close().
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值