Linux网络套接字编程(2)-TCP传输+多线程+多进程

TCP传输

TCP的三次握手

图解为TCP协议的传输过程。

客户端操作	服务端操作
1、创建套接字	1、创建套接字
2、向服务端发起连接	2、绑定地址信息
3、发送数据	3、监听(若有新的客户端，新建socket)
4、接收数据	4、接收已经连接成功的socket
5、关闭套接字

TCP传输-socket编程

通过C++实现一个类来封装tcp协议

//tcpsocket.hpp
#include <string>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define CHECK_RET(q) if((q) == false){return -1;}

class TcpSocket
{
    public:
        TcpSocket() : _sockfd(-1){
        }
        void SetSockFd(int fd){
            _sockfd = fd;
        }
        bool Socket() {
            _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
            if (_sockfd < 0) {
                perror("socket error");
                return false;
            }
            return true;
        }
        bool Bind(std::string &ip, uint16_t port){
            struct 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(struct sockaddr_in);
            int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
            if (ret < 0) {
                perror("bind error");
                return false;
            }
            return true;
        }
        bool Listen(int backlog = 10) {
            //int listen(int sockfd, int backlog);
            //backlog:最大并发连接数--内核中已完成连接队列的最大节点数
            int ret = listen(_sockfd, backlog);
            if (ret < 0) {
                perror("listen error");
                return false;
            }
            return  true;
        }
        bool Connect(std::string &ip, uint16_t port) {
            struct 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(struct sockaddr_in);

            int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
            if (ret < 0) {
                perror("connect error");
                return false;
            }
            return true;
        }
        bool Accept(TcpSocket &csock, struct sockaddr_in *addr = NULL){
            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;
            }
            if (addr != NULL) {
                memcpy(addr, &_addr, len);
            }
            csock.SetSockFd(newfd);
            //_sockfd--仅用于接收新客户端连接请求
            //newfd----专门用于与客户端进行通信
            return true;
        }
        bool Recv(std::string &buf) {
            char tmp[4096] = {0};
            int ret = recv(_sockfd, tmp, 4096, 0);
            if (ret < 0) {
                perror("recv error");
                return false;
            }else if (ret == 0) {
                printf("peer shutdown\n");
                return false;
            }
            buf.assign(tmp, ret);
            return true;
        }
        bool Send(std::string &buf) {
            int ret = send(_sockfd, buf.c_str(), buf.size(), 0);
            if (ret < 0) {
                perror("send error");
                return false;
            }
            return true;
        }
        bool Close() {
            close(_sockfd);
            _sockfd = -1;
        }
    private:
        int _sockfd;
};

tcp传输客户端

#include "tcpsocket.hpp"

int main(int argc, char *argv[])
{
    if (argc != 3 ) {
        std::cout<<"./tcp_cli ip port\n";
        return -1;
    }
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);

    TcpSocket sock;
    CHECK_RET(sock.Socket());
    CHECK_RET(sock.Connect(ip, port));

    while(1) {
        std::string buf;
        std::cout<<"client say:";
        fflush(stdout);
        std::cin>>buf;
        sock.Send(buf);

        buf.clear();
        sock.Recv(buf);
        std::cout<<"server say:"<<buf<<std::endl;
    }
    sock.Close();
    return 0;
}

tcp传输服务端

#include "tcpsocket.hpp"

int main(int argc, char *argv[])
{
    if (argc != 3) {
        printf("./tcp_srv ip  port\n");
        return -1;
    }
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);

    TcpSocket sock;
    CHECK_RET(sock.Socket());
    CHECK_RET(sock.Bind(ip, port));
    CHECK_RET(sock.Listen());

    while(1) {
        TcpSocket clisock;
        struct sockaddr_in cliaddr;
        //accept是阻塞获取已经完成的连接
        if (sock.Accept(clisock, &cliaddr) == false) {
            continue;
        }
        printf("new connect client:%s:%d\n", 
                inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
        std::string buf;
        clisock.Recv(buf);
        printf("client say:%s\n", buf.c_str());

        buf.clear();
        std::cout<<"server say:";
        fflush(stdout);
        std::cin>>buf;
        clisock.Send(buf);
    }
    sock.Close();
    return 0;
}

运行截图如上

TCP的传输运行结果与UDP的传输运行结果不同

这是因为在UDP的传输无连接，不可靠，面向数据报

但是TCP的传输不同是建立连接，可靠传输，面向字节流

所以基本的tcp服务端只能与一个客户端通信一次，无法实现同时与多个客户端多次通信

如何快速判断连接是否已经断开

tcp的连接管理中，内建有保活机制。当长时间没有数据来往的时候，每隔一段时间都会向对方发送一个保活探测包，要求对方回复，当多次发送保活探测包都没有响应，则认为连接断开。

若连接断开，则recv会返回0，send会触发异常SIGPIPE(导致进程退出)。recv返回0不是代表没有接收数据的意思，而是说明连接已经断开。

在TCP连接过程中，因为面向字节流，有可能接收到半条数据，因此一定要对返回值进行判断，判断数据是否已经完全接收或者完全发送。

多进程版本tcp服务端

通过使用多进程来完成多个客户端的请求处理

将之前的通用版本改为多线程版本即可

#include <signal.h>
#include <sys/wait.h>
#include "tcpsocket.hpp"

void sigcb(int no){
    while (waitpid(-1, NULL, WNOHANG) > 0);
}
int main(int argc, char *argv[])
{
    if (argc != 3) {
        printf("./tcp_srv ip  port\n");
        return -1;
    }

    signal(SIGCHLD, sigcb);
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);

    TcpSocket sock;
    CHECK_RET(sock.Socket());
    CHECK_RET(sock.Bind(ip, port));
    CHECK_RET(sock.Listen());

    while(1) {
        TcpSocket clisock;
        struct sockaddr_in cliaddr;
        //accept是阻塞获取已经完成的连接
        if (sock.Accept(clisock, &cliaddr) == false) {
            continue;
        }
        printf("new connect client:%s:%d\n", 
                inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));

        int pid = fork();
        if (pid == 0) {
            while(1){
                std::string buf;
                clisock.Recv(buf);
                printf("client say:%s\n", buf.c_str());

                buf.clear();
                std::cout<<"server say:";
                fflush(stdout);
                std::cin>>buf;
                clisock.Send(buf);
            }
        }
        clisock.Close();
    }
    sock.Close();
    return 0;
}

先进行多个客户端连接，在左上角的服务端可以看到有三个新的客户端进行了连接成功

这时候相继发送消息，服务端的回复顺序是根据接收客户端发送数据的顺序进行回复的

哪怕有其他客户端抢先回答了，服务端还是按照发送数据的顺序依次给客户端进行发送数据

多线程版本tcp服务端

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

void *thr_start(void *arg){
    TcpSocket *sock = (TcpSocket*)arg;
    while(1) {
        std::string buf;
        sock->Recv(buf);
        printf("client say:%s\n", buf.c_str());

        buf.clear();
        std::cout<<"server say:";
        fflush(stdout);
        std::cin>>buf;
        sock->Send(buf);
    }
    sock->Close();
    delete sock;
    return NULL;
}
int main(int argc, char *argv[])
{
    if (argc != 3) {
        printf("./tcp_srv ip  port\n");
        return -1;
    }
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);

    TcpSocket sock;
    CHECK_RET(sock.Socket());
    CHECK_RET(sock.Bind(ip, port));
    CHECK_RET(sock.Listen());

    while(1) {
        TcpSocket *clisock = new TcpSocket();
        struct sockaddr_in cliaddr;
        //accept是阻塞获取已经完成的连接
        if (sock.Accept(*clisock, &cliaddr) == false) {
            continue;
        }
        printf("new connect client:%s:%d\n", 
                inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));

        pthread_t tid;
        pthread_create(&tid, NULL, thr_start, (void*)clisock);
        pthread_detach(tid);
        //多线程中 ，主线程不能关闭socket，因为线程之间共享文件描述符表
        //如果在主线程中关闭了socket，其它线程中的这个描述符也就关闭了
    }
    sock.Close();
    return 0;
}

线程版本的服务端与进程版本的服务端操作大同小异，差距就是进程与线程的创建方式不同，在方式上可能有区别。能了解这两个知识就能掌握。