在线服务之socket编程科普

2022-10-20 08:38:15

简介

本篇文章是介绍一个典型的在线C++服务的最底层socket管理是如何实现的。

文章会从一个最简单的利用socket编程基础API的一个小程序开始，逐步引入现在典型的select,epoll机制，并附上相关demo代码。

socket编程

基于TCP协议的网络程序

TCP协议通讯流程如下图:

在线服务之socket编程科普

最简单的TCP网络程序

服务端:

/*server.c*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/socket.h>

#include <netinet/in.h>

#define MAXLINE 80

#define SERV_PORT 8000

int main(void) {

    struct sockaddr_in servaddr, cliaddr;

    socklen_t cliaddr_len;

    int listenfd, connfd;

    char buf[MAXLINE];

    char str[INET_ADDRSTRLEN];

    int i, n;

    // 第一个系统调用, 建立监听句柄

    // 第一个参数, AF_INET代表IPv4, AF_INET6代表IPv6, AF_UNIX代表Unix Domain Socket(本地文件)

    // 第二个参数,  SOCK_STREAM代表TCP, SOCK_DGRAM代表UDP

    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));

    // 同socket()系统调用第一个参数

    servaddr.sin_family = AF_INET;

    // 同一台机器可能有多个网卡, 一个网卡也可以绑定多个IP, 代表所有IP都绑定

    servaddr.sin_addr.s_addr = htol(INADDR_ANY);

    // 端口, 网络协议都是小端序, 要用这个htons系列函数将host编码转为net编码,

    // intel机器都是小端, 所以一般都直接返回

    servaddr.sin_port = htons(SERV_PORT);

    // 第二个系统调用, 将句柄跟对应端口绑定起来

    // 第一个参数, 刚刚同构socket建立的句柄

    // 第二个&第三个参数, 需要绑定的端口信息

    bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    // 开始监听, 20代表如果一个socket还没有被accept走的话, 可以临时挂着等待被处理的状态

    listen(listenfd, 20);

    printf("Acceptin connections ...\n");

    while(1) {

        cliaddr_len = sizeof(cliaddr);

        // 获取客户端的连接句柄, 如果没链接, 会阻塞等待客户端链接

        // 传出客户端句柄, 客户端连接相关信息

        connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

        n = read(connfd, buf, MAX_LINE);

        printf("received from %s at PORT %d\n",

            inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),

            ntohs(cliaddr.sin_port));

        for (i=0; i<n; ++i) {

            buf[i] = toupper(buf[i]);

        }

        write(connfd, buf, n);

        close(connfd);

    }

}

客户端:

/* client.c */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/socket.h>

#include <netinet/in.h>

#define MAXLINE 80

#define SERV_PORT 8000

int main(int argc, char *argv[])

{

    struct sockaddr_in servaddr;

    char buf[MAXLINE];

    int sockfd, n;

    char *str;

    if (argc != 2) {

        fputs("usage: ./client message\n", stderr);

        exit(1);

    }

    str = argv[1];

    // 跟服务器一样, 建立socket句柄

    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;

    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);

    servaddr.sin_port = htons(SERV_PORT);

    // 跟服务器对应的地址和端口号建立连接

    // connect()和bind()函数的参数是一样的, 只是connect是连接别人, bind是绑定自己

    // 客户端对应的socket不需要分配端口, 内核会自动为该句柄分配端口

    connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    // 发送数据

    write(sockfd, str, strlen(str));

    // 读取数据

    n = read(sockfd, buf, MAXLINE);

    printf("Response from server:\n");

    write(STDOUT_FILENO, buf, n);

    close(sockfd);

    return 0;

}

简单程序逐步优化

假设在如上的client.c中, 将write到close这一段修改为:

while (fgets(buf, MAXLINE, stdin) != NULL) {

	Write(sockfd, buf, strlen(buf));

	n = Read(sockfd, buf, MAXLINE);

	if (n == 0)

		printf("the other side has been closed.\n");

	else

		Write(STDOUT_FILENO, buf, n);

}

这样企图达到通过命令行交互输入字符串, 并且可以多次跟服务器交互, 但运行下来却发现, 不work, 如下图:

$ ./client

// 第一次输入, 正常返回结果

haha1

HAHA1

// 第二次输入, 无法正常返回结果

haha2

the other side has been closed.

// 第三次输入, 程序自动退出

haha3

$

原因是, 看看server.c里面针对每个连接的处理, 是应答一次之后就把连接关闭了, 所以发生了如上现象, 那么具体发生了什么呢:

  1. 在第二次输入的时候, client再次调用该句柄执行write操作, 但是write操作只是把数据写入TCP发送缓冲区就算完事儿, 所以能成功返回不会出错。而server收到该请求之后发现连接已经被关闭, 所以会返回一个RST段, client收到RST段后无法立刻通知应用层, 只是把这个状态保存在TCP协议层。
  2. 在第三次输入的时候, client再次调用循环给server写数据, 这个时候TCP协议层已经处于RST状态, 知道了这个socket连接的对方已经关闭掉了连接, 所以会发出一个SIGPIPE信号给应用层, 而SIGPIPE信号默认是终止程序, 所以看到上面的现象

在真实线上服务, 因为一些网络异常可能会出现SIGPIPE的信号, 所以我们一般都会在服务端/客户端的程序里加上:

signal (SIGPIPE, SIG_IGN);

来避免被这种异常误杀了程序。

那么, 我们如何才能客户端可以跟服务器端多次交互呢, 一种解决方案如下, 在服务端的处理请求的时候也加一下死循环:

while(1) {

    ...

    accept();

    while(1) {

        n = read();

        if(n == 0) {

            break;

        }

        ...

        write();

    }

    close();

}

但是这样的修改会导致, 服务器只能串行处理每个请求, 在上一个客户端进程未终止之前, 另外一个客户端的请求服务器是不能处理的。

那么要达到多个客户端并发处理请求的话, 一种可行的办法是每次请求来了就fork一个进程出来处理这个请求相关的逻辑, 但是这样耗费太大, 于是早些年, 先辈们提出了用select这种系统调用来解决这个问题。

select的原理是同时监听多个阻塞的fd(网络/文件都可), 哪个有数据到达了就处理哪个, 这样就不用fork和多进程也能搞定了。

其伪代码大概如下:

listen_fd = socket();

bind();

listen();

// select需要用到的句柄集合

fd_set all_set;

// 将listen_fd加进该集合

FD_SET(listen_fd, &all_set);

while(1) {

    // 核心系统调用, 第一个参数是需要监听的所有系统句柄中最大整数值再+1

    // 第二个参数是要监听读事件的set

    // 第三个参数是要监听写事件的set

    // 第四个参数是要监听错误事件的set

    // 第五个参数是超时事件, 如果是NULL, 则一直要阻塞到发生事件, 如果是0, 则变成非阻塞函数, 不管是否有变化都立即返回

    select(maxfd+1, &all_set, NULL, NULL, NULL);

    // 判断该socket是否事件发生

    if(FD_ISSET(listen_fd, &all_set)) {

        // 有新请求到来

        conn_fd = accept(...);

        // 将请求连接也加到all_set当中

        FD_SET(conn_fd, &all_set);

        // 代码省略, 因为select无法返回有事件触发的具体fd, 所以需要将conn_fd加入另外一个数组,

        // 假设该数组名为all_clients

        ...

    }

    for(i=0; i<max_clients_num; i++) {

        if(FD_ISSET(all_clients[i], &all_set)) {

            read(...)

            write(...)

        }

    }

}

这样就能做到多个客户端同时跟该服务器打交道, 也能同时得到响应了。

虽然select能满足要求了, 但是先辈们仍然觉得其效率不高, 主要有如下几个原因:

  1. 每次调用select函数, 就得把装有所有fd的fdset都得从用户态传入内核态, 如果fd较多的时候, 开销会很大
  2. 每次调用select的时候, 都需要遍历一遍fdset的所有句柄, 这个开销在fd较多的时候也很大
  3. select支持的文件描述符太小了, 最多只能有1024

于是内核发明了epoll来取代select, 解决如上几个问题, epoll提供了如下几个接口:

  1. epoll_create: 创建epoll句柄
  2. epoll_ctl: 将要监听的fd加入epoll
  3. epoll_wait: 查看epoll中监听的fd的事件

那么他是如何解决如上几个问题的呢

  1. 因为用户是每次调用epoll_ctl将句柄加入epoll, 这样在内核态自身就保存有所有fd句柄信息了, 不用来回从用户态到内核态了
  2. epoll内部采用了回调机制, 每次有新事件来的时候就触发对应回调函数, 将句柄加入就绪队列, 这样其实每次epoll_wait就是从就绪队列里读句柄就好
  3. epoll没有这个限制, 他支持的FD上限就是最大可以打开文件的数目

用epoll来实现服务器端的伪代码大概如下:

listen_fd = socket();

bind();

listen();

// 创建epoll句柄, 告诉内核这个epoll句柄要监听句柄数量

epfd=epoll_create(256);

// epoll需要用到的结构

epoll_event ev,events[20];

// 设置要加入epoll要监听的事件的信息

ev.data.fd=listenfd;

ev.events=EPOLLIN|EPOLLET;

// 将主要的listen_fd加入epoll当中

// 第一个参数是epoll句柄

// 第二个参数是控制指令, 包括增删更新等

// 第三个和第四个参数是要加入epoll监听的句柄信息

epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);

while(1) {

    // 第一个参数是epoll句柄

    // 第二个参数是放有事件的句柄信息

    // 第三个参数是每次能处理的事件

    // 第四个参数是类似select的超时, -1代表阻塞, 0代表非阻塞

    int nfds = epoll_wait(epfd,events,20,-1);

    for(int i=0; i<nfds; ++i) {

        if(events[i].data.fd == listenfd) {

            conn_fd = accept(...);

            epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);

        } else(events[i].events & EPOLLIN) {

            conn_fd = events[i].data.fd;

            read(...)

            write(...)

        }

    }

}

epoll核心的控制核心就在epoll_event.events这个数据结构上, 该字段支持如下值:

  1. EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）

  2. EPOLLOUT：表示对应的文件描述符可以写

  3. EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）

  4. EPOLLERR：表示对应的文件描述符发生错误

  5. EPOLLHUP：表示对应的文件描述符被挂断

  6. EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的

    这里单独说明一下ET模式和LT模式, 默认是LT模式。ET模式就是epoll_wait读到该句柄之后, 应用程序必须立即处理该事件, 即触发后面的读取或者写入操作, 如果不处理的话, 那么下次调用epoll_wait的时候将不会返回该句柄。LT则反之, 如果应用层不处理, 下次依然会告诉应用层。

  7. EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里

在现在实际的线上服务中, 一般都是用的epoll来进行连接管理和事件监听。

但是如上的实例代码中, server端始终都是只有一个主进程在处理客户端的请求, 也就是说服务器处理是串行的, 即使并行请求, 在上一个请求处理完毕之前, 下一个请求是得不到响应的。

所以一般服务器都会采用多线程来处理, 多线程比如上请求会复杂一些, 一般会有一个主线程(监听线程), 多个工作线程。监听线程和工作线程之间通过一个本地队列来同步信息。

当监听线程发现有新的读请求到了之后, 就把该请求放到本地队列中, 多个工作线程就死循环check本地队列, 如果发现本地队列有新请求, 就从里面读取句柄并处理。本地队列处理读取和写入的时候, 需要考虑线程安全的问题。

参考

  1. Linux C编程一站式学习. http://docs.linuxtone.org/ebooks/C&CPP/c/index.html
上一篇：【struts 报错】 No action config found for the specified url


下一篇：cocos2dx 跨平台编译遇到的几个问题