Linux网络编程 | Socket编程：TCP服务器单执行流、多线程、多进程的实现

最新推荐文章于 2022-11-02 19:25:31 发布
最新推荐文章于 2022-11-02 19:25:31 发布
阅读量332 收藏 2
点赞数
分类专栏： Linux 文章标签： socket 网络 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45141313/article/details/118183005
版权

文章目录

TCP协议

TCP协议：传输控制协议
特性：面向连接，可靠传输，面向字节流
应用场景：安全性要求大于实时性要求的场景---文件传输

TCP通信流程

在这里插入图片描述

Socket相关接口

1.创建套接字
int socket(int domain, int type, int protocol);

2.绑定地址
int bind(int sockfd, struct sockaddr* addr, socklen_t len);

3.开始监听
int listen(int sockfd, int backlog);
   backlog:服务器能够在同一时间处理的最大连接数  

4.客户端发送连接请求
int connect(int sockfd, struct sockaddr* srvaddr, socklen_t len);
   sockfd:套接字描述符
   srvaddr:服务端地址信息
   len:地址长度
   返回值:成功返回0，失败返回-1

5.服务端获取新建连接
int accept(int sockfd, struct sockaddr* cliaddr, socklen_t* addrlen);
   sockfd:监听套接字，服务端最早创建的套接字，只用于接受新的连接请求
   cliaddr:新的连接的客户端地址信息
   addrlen:输入输出参数，指定地址信息长度，以及返回实际长度
   返回值:新建连接的描述符，往后与客户端的通信都通过这个描述符完成

6.收发数据:tcp通信因为socket结构体中包含完整五元组，因此不需要指定地址
ssize_t send(int sockfd, void* data, int len, int flag);
   sockfd:新建套接字描述符
   data:要发送的数据
   len:数据长度
   flag:默认0--阻塞发送
   返回值：成功返回实际发送的数据长度；失败返回1，连接断开会触发异常

ssize_t recv(int sockfd, void* buf, int len, int flag);
   sockfd:新建套接字描述符
   buf:接收数据的空间首地址
   len:要接收的数据长度
   flag:默认0--阻塞接收
   返回值:成功返回实际接收的数据长度；出错返回-1；连接断开返回0

7.关闭套接字
int close(int sockfd);

TCPSocket的封装

#include<iostream>
using namespace std;
#include<arpa/inet.h>
#include<unistd.h>
#include<cstdio>

#define BACKLOG_MAX 5
#define CHECK(p) if(p==false) {return -1;}

class TcpSocket
{
  public:

    TcpSocket()
      :_sockfd(-1)
    {}

    //创建套接字
    bool Socket()
    {
      _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
      if(_sockfd < 0)
      {
        perror("create socket error");
        return false;
      }
      return true;
    }


    //绑定地址信息
    bool Bind(const string& ip, const uint16_t& port)
    {
      sockaddr_in addr;
      addr.sin_family = AF_INET;
      addr.sin_port = htons(port);
      addr.sin_addr.s_addr = inet_addr(ip.c_str());
      socklen_t len = sizeof(addr);
      int ret = bind(_sockfd, (sockaddr*)&addr, len);
      if(ret < 0)
      {
        perror("bind error");
        return false;
      }
      return true;
    }

    //开始监听
    bool Listen(int backlog = BACKLOG_MAX)
    {
      int ret = listen(_sockfd, backlog);
      if(ret < 0)
      {
        perror("Listen error");
        return false;
      }
      return true;
    }

    //客户端发送连接请求
    bool Connect(const string& ip, const uint16_t& port)
    {
      sockaddr_in seraddr;//服务端地址信息
      seraddr.sin_family = AF_INET;
      seraddr.sin_port = htons(port);
      seraddr.sin_addr.s_addr = inet_addr(ip.c_str());
      socklen_t len = sizeof(sockaddr_in);
      int ret = connect(_sockfd, (sockaddr*)&seraddr, len);
      if(ret < 0)
      {
        perror("connect failed");
        return false;
      }
      return true;
    }

    //服务端获取新建连接
    bool Accept(TcpSocket& tcpsocket, string* ip = NULL, uint16_t* port = NULL)
    {
      sockaddr_in cliaddr;
      socklen_t len = sizeof(sockaddr_in);
      int ret = accept(_sockfd, (sockaddr*)&cliaddr, &len);
      if(ret < 0)
      {
        perror("accept error");
        return false;
      }
      tcpsocket._sockfd = ret;
      if(ip != NULL)
        *ip = inet_ntoa(cliaddr.sin_addr);
      if(port != NULL)
        *port = ntohs(cliaddr.sin_port);
      return true;
    }

    //发送数据
    //要发送整条数据
    bool Send(string& buf)
    {
      int total = 0;
      while(total < buf.size())
      {

        int ret = send(_sockfd, buf.c_str() + total, buf.size() - total, 0);
        if(ret < 0)
        {
          perror("send data failed");
          return false;
        }
        total += ret;
      }
      return true;
    }

    //接收数据
    bool Recv(string& buf)
    {
      char tmp[4096] = {0};
      int ret = recv(_sockfd, tmp, 4095, 0);
      if(ret < 0)
      {
        perror("recv error");
        return false;
      }
      else if(ret == 0)
      {
        cout << "connect is broken" << endl;
        return false;
      }
      buf.assign(tmp, ret);
      return true;
    }

    //关闭套接字
    bool Close()
    {
      if(_sockfd != -1)
      {
        close(_sockfd);
        _sockfd = -1;
      }
      return true;
    }

  private:
    int _sockfd;
};

TCP客户端

1.创建套接字   socket()
2.为套接字绑定地址信息(不推荐主动绑定)  bind()
3.向服务端发起连接请求 connect()
4.发送数据  send()
5.接收数据 recv()
6.关闭套接字 close()

#include"tcp.hpp"

int main()
{
  TcpSocket cli_socket;

  //创建套接字
  CHECK(cli_socket.Socket());

  //绑定地址信息(不推荐)

  //向服务器发送连接请求
  CHECK(cli_socket.Connect("192.168.134.141", 9000));

  while(1)
  {
    //发送数据
    string buf;
    cout << "client say:" ;
    getline(cin, buf);
    
    //发送数据失败，直接结束通信
    CHECK(cli_socket.Send(buf));
  
    buf.clear();
    //接收数据
    //接收数据失败，直接结束通信
    CHECK(cli_socket.Recv(buf));
    cout << "serve say:" << buf << endl;
  }
  //关闭套接字
  cli_socket.Close();
  return 0;
}

TCP服务器

1.创建套接字  socket()
2.为套接字绑定地址信息  bind()
3.开始监听 listen()
4.获取新建连接   accept()
5.接收数据  recv()
6.发送数据  send()
7.关闭套接字 close()

单执行流TCP服务器

#include"tcp.hpp"

int main()
{
  TcpSocket lst_socket;
  //创建套接字
  CHECK(lst_socket.Socket());
  //绑定地址信息
  CHECK(lst_socket.Bind("192.168.134.141", 9000));
  //开始监听
  CHECK(lst_socket.Listen());
  while(1)
  {
    //获取新建连接
    TcpSocket newSocket;
    string ip;
    uint16_t port;
    bool ret = lst_socket.Accept(newSocket, &ip, &port);
    if(ret == false)
      continue;
    cout << "new connect  ip:" << ip << "  port:" << port << endl;

    //接收数据
    string buf;
    ret = newSocket.Recv(buf);
    if(ret == false)
    {
      newSocket.Close();
      continue;
    }
    cout << "client say:" << buf << endl;

    buf.clear();
    //发送数据
    cout << "server say:";
    getline(cin, buf);
    ret = newSocket.Send(buf);
    if(ret == false)
    {
      newSocket.Close();
    }
  }
  //关闭套接字
  lst_socket.Close();
  return 0;
}

测试结果：
在这里插入图片描述
根据测试结果来看，当客户端第一次发送数据给服务端时，服务端可以接收数据，并且回复客户端，但是客户端第二次发送数据给服务端时，服务端就收不到客户端的数据，也不能进行回复，这是为什么？

我们先来看下代码中服务端流程：
在这里插入图片描述
accept是阻塞接口，当服务器完成一次接收与发送数据，就会继续到获取新连接接口，此时若没有新的连接，就会一直等待，直到有新的连接到来。所以上面所出现的问题就是因为没有新的连接到来，进入阻塞状态。

recv与send都是阻塞接口，若没有接收到数据或者没有数据发送，就会一直等待，直到能接收到数据或者有数据可以发送。所以，它们三个接口，任意一个接口的调用，都有可能导致服务端流程阻塞。

如果服务端流程阻塞，那么其他客户端也不能进行正常的收发数据，为了解决这个问题，我们提出了多执行流并发处理，为每个客户端都创建一个执行流负责与这个客户端进行通信，这样做的好处就是：

1.主线程卡在获取新建连接这里，但是不影响客户端的通信
2.某个客户端的通信阻塞，也不会影响主线程以及其他线程

实际在代码中的处理：在主线程中，获取新建连接，一旦获取到了则创建一个执行流，通过这个新建连接与客户端进行通信。

两种具体的解决方法：多线程、多进程。

多线程TCP服务器

#include"tcp.hpp"
#include<pthread.h>

void* pthread_comm(void* newSocket)
{
  TcpSocket* Socket = (TcpSocket*)newSocket;
  while(1)
  {
    bool ret;
    //接收数据
    string buf;
    ret = Socket->Recv(buf);
    if(ret == false)
    {
      Socket->Close();
      delete Socket;
      return NULL;
    }
    cout << "client say:" << buf << endl;

    buf.clear();
    //发送数据
    cout << "server say:";
    getline(cin, buf);
    ret = Socket->Send(buf);
    if(ret == false)
    {
      Socket->Close();
      delete Socket;
      return NULL;
    }
  }
  Socket->Close();
  delete Socket;
  return NULL;
}

int main()
{
  TcpSocket lst_socket;
  //创建套接字
  CHECK(lst_socket.Socket());
  //绑定地址信息
  CHECK(lst_socket.Bind("192.168.134.141", 9000));
  //开始监听
  CHECK(lst_socket.Listen());
  while(1)
  {
    //获取新建连接
    TcpSocket* newSocket = new TcpSocket;
    string ip;
    uint16_t port;
    bool ret = lst_socket.Accept(*newSocket, &ip, &port);
    if(ret == false)
      continue;
    cout << "new connect-->ip:" << ip << " port:" << port << endl;

    //获取新建连接之后，创建线程负责与客户端进行通信
    pthread_t tid;
    int res = pthread_create(&tid, NULL, pthread_comm, (void*)newSocket);
    if(res != 0)
    {
      perror("create pthread failed");
      continue;
    }
    //线程分离
    pthread_detach(tid);
  }
  //关闭套接字
  lst_socket.Close();
  return 0;
}

注意：

普通线程与主线程数据共享，主线程不能随意释放套接字，一旦释放其他线程无法使用。

测试：
在这里插入图片描述

多进程TCP服务器

#include"tcp.hpp"
#include<stdlib.h>
#include<signal.h>

void work(TcpSocket& newSocket)
{
  //接收数据
  while(1)
  {
    bool ret;
    string buf;
    ret = newSocket.Recv(buf);
    if(ret == false)
    {
     //获取数据失败，关闭通信套接字，退出子进程 
      newSocket.Close();
      exit(0);
    }
    cout << "client say:" << buf << endl;

    buf.clear();
    //发送数据
    cout << "server say:";
    getline(cin, buf);
    ret = newSocket.Send(buf);
    if(ret == false)
    {
      // 发送数据失败，关闭通信套接字，退出子进程
      newSocket.Close();
      exit(0);
    }
  }
  newSocket.Close();
  return;
}

int main()
{
  signal(SIGCHLD, SIG_IGN);//信号函数，如果有子进程退出，忽略它的退出原因
  TcpSocket lst_socket;
  //创建套接字
  CHECK(lst_socket.Socket());
  //绑定地址信息
  CHECK(lst_socket.Bind("192.168.134.141", 9000));
  //开始监听
  CHECK(lst_socket.Listen());
  while(1)
  {
    //获取新建连接
    TcpSocket newSocket;
    string ip;
    uint16_t port;
    bool ret = lst_socket.Accept(newSocket, &ip, &port);
    if(ret == false)
      continue;
    cout << "new connect  ip:" << ip << "  port:" << port << endl;

    //创建子进程，子进程与客户端进行通信
    pid_t pid = fork();
    if(pid < 0)
    {
      perror("create fork failed");
      //创建子进程失败，关闭的是父进程的通信套接字
      newSocket.Close();
      continue;
    }
    else if(pid == 0) //子进程
    {
      work(newSocket);
    }
    //父进程
    //子进程用来通信，父进程的通信套接字就可以关闭了，防止资源泄漏
    //父子进程数据独有，父进程关闭不会对子进程造成影响
    newSocket.Close();
  }
  //关闭套接字
  lst_socket.Close();
  return 0;
}

注意：

父子进程数据各自独有，父进程用不到新建套接字因此创建子进程之后直接释放掉，否则会造成资源泄漏。同时也要注意僵尸进程的问题，我们在这里采用信号的方式，一旦有子进程退出的信号，我们就忽略处理，不去在意子进程的退出原因。

测试：
在这里插入图片描述

Reset。
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
socket，多线程和单线程
liuchang186的博客
09-07 626
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.Reader; import java.io.Wr
socket编程（TCP多进程客户与服务器）
shine_zyd_way的博客
08-24 922
能够实现一个服务器与多个客户端之间通信 server.c#include <stdio.h> #include <string.h> #include <arpa/inet.h> #include <netinet/in.h> #include <sys/socket.h> #include <stdlib.h>void Usage(char* proc) { printf("usage:
linux下 socket tcp Server c语言编写（分别实现单进程，多进程，多线程）
wejack的专栏
09-28 1875
linux下socket tcp server c语言编写单进程、多进程、多线程三种实现
Linux C/TCP多线程网络聊天室
u011937684的博客
11-02 2117
Linux C/TCP 网络聊天室
网络编程 多人聊天 TCP多线程
最新发布
01-09
在这个"网络编程多人聊天TCP多线程"项目中，开发者利用TCP协议和多线程技术创建了一个支持私聊、群聊、文件传输以及成员管理功能的聊天程序，主要涵盖了以下几个关键知识点： 1. **TCP协议**：TCP是一种面向连接的...
多线程与socket网络编程-内附视频链接-新手入门资料
12-14
在IT领域，多线程和Socket网络编程是两个至关重要的概念，它们对于开发高效、可靠的分布式系统至关重要。这里我们将深入探讨这两个主题。 1. **进程** - **进程的定义**：进程是操作系统中资源分配的基本单位，它...
Python实现多线程/多进程的TCP服务器
12-25
多线程的TCP服务器，供大家参考，具体内容如下 背景：同学公司的传感器设备需要将收集的数据发到服务器上，前期想写一个简单的服务器来测试下使用效果，设备收集的数据非常的重要，所以考虑使用TCP协议来实现。 因为...
Linux下基于socket的网络编程（包含多线程和Select机制）
02-16
综上所述，"Linux下基于socket的网络编程（包含多线程和Select机制）"是一个综合性的项目，涵盖了从基本的TCP和UDP套接字编程，到更高级的Select机制和多线程并发处理。这个程序对于学习如何在Linux环境中编写高效、...
tcp+udp.rar_TCP/IP_linux udp socket_linux 网络编程_socket linux udp
09-20
至于"socket linux udp"，则意味着这个资源可能特别关注Linux环境下的UDP套接字编程，可能涉及多线程、多进程处理、异步I/O或者网络并发等高级主题。 根据压缩包内的文件名"udp2"和"tcp"，我们可以推测，"udp2"可能...
Linux下socket实现TCP网络通讯（多个客户端之间的通讯）
06-10
在学习《UNIX网络编程》基础上自己动手实现TCP服务器和客户端通讯，这个版本是进阶版程序——实现多个客户端的之间的通讯。程序包含了常规网络通讯的主要步骤，除此之外还运用了select()和poll()等技术，具有一定难度，程序思路清晰，代码注释详细，适合有一定基础的人学习。代码已经无误通过测试。初学者可以休息我的入门版程序——实现单个客户端的之间的通讯，可见我的其他资源。
网络编程 多线程 Linux,Linux网络编程——tcp并发服务器（多线程）
weixin_35718537的博客
05-06 281
tcp多线程并发服务器多线程服务器是对多进程服务器的改进，由于多进程服务器在创建进程时要消耗较大的系统资源，所以用线程来取代进程，这样服务处理程序可以较快的创建。据统计，创建线程与创建进程要快 10100 倍，所以又把线程称为“轻量级”进程。线程与进程不同的是：一个进程内的所有线程共享相同的全局内存、全局变量等信息，这种机制又带来了同步问题。tcp多线程并发服务器框架:我们在使用多线程并发服务器时...
LINUX利用socket多线程文件传输,Linux C TCPSocket 传输文件简单实例-多线程实现
weixin_29721821的博客
05-09 741
在Linux下使用C语言TCPSocket实现简单文件传输，包括客户端和服务器端，其中，服务器端使用多线程实现同时接收多个客户端发送的文件。发送文件内容之前，首先需要将文件名和长度信息发送到服务器，为了便于区分，采用发送结构体的方式，设置标志位，1标识数据域为文件名，2标识数据域为文件内容，3标识发送结束，4标识发送文件长度。这样便可区分发送的内容。服务器端代码如下：/*多线程实现接收多个客户端的...
Linux下c语言TCP多线程聊天室
weixin_30511107的博客
08-21 395
开发环境：Linux，GCC 相关知识：TCP（博客：传送门），线程 附加：项目可能还有写不足之处，有些bug没调出来（如：对在线人数的控制），希望大佬赐教。 那么话不多说，放码过来： 码云：传送门，GitHub：传送门 服务端：server.c #include <stdio.h> #include <unistd.h> #include...
linux++tcp+多线程,多线程TCP的socket通信
weixin_39624097的博客
05-06 180
应用多线程来实现服务器与多客户端之间的通信。基本步骤：1.服务器端创建ServerSocket，循环调用accept()等待客户端的连接2.客户端创建一个socket并请求和服务器端的连接3.服务器端接收客户端的请求，创建socket与该客户端建立专线连接4.建立连接的两个socket在一个单独的线程上对话5.服务器端继续等待新的客户端的连接Server.javapublicclassServ...
Linux下socket编程之多线程TCP服务器
lishitao_578的博客
06-03 1033
代码如下： thread_server.c#include<string.h> #include<stdlib.h> #include<stdio.h> #include<sys/types.h> #include<sys/socket.h> #include<netinet/in.h> #include<pthread.h> #include<arpa/inet.h> #include<unis
Linux网络编程——tcp并发服务器（多线程）
热门推荐
每天积累一点点
06-15 2万+
tcp多线程并发服务器 多线程服务器是对多进程服务器的改进，由于多进程服务器在创建进程时要消耗较大的系统资源，所以用线程来取代进程，这样服务处理程序可以较快的创建。据统计，创建线程与创建进程要快 10100 倍，所以又把线程称为“轻量级”进程。线程与进程不同的是：一个进程内的所有线程共享相同的全局内存、全局变量等信息，这种机制又带来了同步问题。 tcp多线程并发服务
ubuntu环境下实现 多线程的socket(tcp) 通信
weixin_34198762的博客
03-11 509
改改就是个小型局域网聊天 服务器端： 1 // File Name: process_server.c 2 // Author: jiujue 3 // Created Time: 2019年03月10日 星期日 20时29分18秒 4 5 #include<stdio.h> 6 #include<string.h> 7...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值