服务器网络模型（一）基本的tcp套接字函数、阻塞与非阻塞IO

bigtree712

已于 2023-04-12 15:48:42 修改

阅读量396

点赞数

分类专栏： linux网络编程文章标签：网络服务器 tcp/ip linux 后端

于 2023-04-12 12:03:25 首次发布

本文链接：https://blog.csdn.net/Big_Tree712/article/details/130086319

版权

linux网络编程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

基本TCP客户端服务器套接字函数

基本TCP客户端服务器函数
如图所示，是最基本的网络模型，对于服务器来说。socket()函数创建套接字， bind绑定端口， accept等待三次握手建立连接。然后通过recv()/send()收发数据。结束之后close()释放资源。

socket()

// 原型
int socket(int family, int type, int protocol);
// 示例
int sockfd = socket(AF_INET, SOCK_STREAM, 0);

执行网络IO的第一步就是代用socket函数，指定使用通信类型。family指明协议族，type指定套接字类型，protocol参数指摸个协议类型的常值，或设置0使用family以及type组合的默认值。成功时返回一个非负的整数，类似文件描述符，后续操作都要通过sockfd来指定对应的套接字。
示例中就是创建了一个ipv4协议的字节流套接字。

bind()

int bind(int sockfd, const struct sockaddr *myaddr, sockelen_t addrlen);

bind函数把一个本地协议地址赋予一个套接字。如果未来指定地址，在调用connect或listen时内核会选择一个临时端口，这个对于客户端来说比较常见，单对于TCP服务器来说一般是指定一个端口来提供服务。

listen()

int listen(int sockfd, int backlog);

socket()创建的套接字，初始设定为主动套接字，listen()把未连接的主动套接字转化为一个被动的套接字，从CLOSED状态转化到LISTEN状态。backlog参数规定内核为对应套接字排队的最大连接数。
关于backlog，内核会为监听状态的套接字维护两个队列，未完成连接队列和已完成连接队列。未完成连接队列是客户端的连接请求到达服务器后，也就是三次握手第一次到达服务器。内核会创建一个套接字记录客户端地址然后保存到未完成队列。在三次握手成功后，会把对应套接字转移到完成队列，accept就是从完成队列中获得。而backlog就是未完成队列和完成队列之和的最大长度。

accept()

int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);

accept()用于从已完成连接队列头部返回一个已完成连接，如果队列为空，进程会休眠(默认是阻塞的)，直到有连接完成。accept的返回值代表客户端的套接字连接。

recv()/send()

每个TCP socket在内核中都有发送和接受缓冲区，recv()就是从接收缓冲区中读数据，send()是把数据写入发送缓冲区。实际的数据接受与发送是内核操作这两个缓冲区完成的，缓冲区已满，recv()和send()可能失败。

close()

标记套接字为CLOSED然后返回

最基本的IO模型

阻塞IO

下面是一个基本的echo服务器示例。

这个例子中sockfd的都是阻塞的
阻塞意味着等待，等待资源就绪才能进行下一步操作，并不是高效的做法
使用多进程多线程可以一定程度缓解这个问题，比如在accept()之后新起一个线程或进程来处理socket，主线程继续accept()。但是这个方案开销过大。

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>

#define LISTEN_PORT 9999
#define BUFF_LENGTH 1024

int main()
{
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);

    if (listenfd == -1)
    {
        perror("create listenfd failed.");
        return -1;
    }

    // 创建套接字
    struct sockaddr_in server_addr, client_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(LISTEN_PORT);
	// 绑定
    if (0 != bind(listenfd, (struct sockaddr*)& server_addr, sizeof(server_addr)))
    {
        perror("connect failed.");
        return -1;
    }
    // 监听
    if (0 != listen(listenfd, 1))
    {
        perror("listen failed.");
        return -1;
    }

    socklen_t len;
    while(1)
    {
        len = sizeof(client_addr);
        // 获取一个链接
        int clientfd = accept(listenfd, (struct sockaddr*)&client_addr, &len);
        printf("clientfd: %d \n", clientfd);
		// 收数据
        unsigned char buffer[BUFF_LENGTH] = {0};
        int recv_len = recv(clientfd, buffer, BUFF_LENGTH, 0);
		// 发数据
        printf("recv:%s, recv_length:%d \n", buffer, recv_len);
        send(clientfd, buffer, recv_len, 0);
		// 释放
        close(clientfd);
    }
}

非阻塞IO

sockfd属性可以通过fcntl设置为非阻塞，非阻塞IO在资源未就绪时调用accpet(),recv()等接口等待，而是直接返回。
下边是一个非阻塞IO的例子

示例中listenfd设置为非阻塞的，所以accpet在调用后无论是否有就绪的连接都会直接返回。所以需要用循环的方式反复检查是否有就绪的连接，在收到连接后启动一个线程来处理这个连接的收发。
在建立连接后，新的sockfd是默认阻塞的，recv()只有在有结果或者出错后返回。
设置为非阻塞后，需要检查返回结果errno为EAGAIN时表示没有数据可读，需要等待下次检查。
非阻塞io可以让服务在没有连接需要处理时完成其他任务，不会一直等待。
但是非阻塞IO任然需要循环去检查是否有fd需要处理，会大幅提高cpu占用。

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

#define LISTEN_PORT 9999
#define BUFF_LENGTH 1024

void *routine(void* arg)
{
	int clientfd = *(int*)arg;

    // 设置为非阻塞
    /*
	int flag = fcntl(clientfd, F_GETFL, 0);
	flag |= O_NONBLOCK;
	fcntl(clientfd, F_SETFL, flag);
    */

	unsigned char buffer[BUFF_LENGTH] = {0};
	while(1)
	{
		int recv_len = recv(clientfd, buffer, BUFF_LENGTH, 0);
        // recv 大于0表示接受完毕，0表示正常断开，-1 表示错误或未读完
        if (recv_len == -1)
        {
            if (errno == EAGAIN)
            {
                //printf("no data read. clientfd:%d \n", clientfd);
                continue;
            }
            else
            {
                printf("recv errro. clientfd:%d errno:%d\n", clientfd, errno);
                close(clientfd);
                break;
            }
        }
        else if (recv_len == 0)
		{
            printf("remote close. clientfd:%d \n", clientfd);
			close(clientfd);
			break;
		}
        else
        {
            printf("clientfd: %d recv:%s, recv_length:%d \n", clientfd, buffer, recv_len);
            send(clientfd, buffer, recv_len, 0);
            memset(buffer, 0, sizeof(char)*BUFF_LENGTH);
        }
    }
	return NULL;
}

int main()
{
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);

    if (listenfd == -1)
    {
        perror("create listenfd failed.");
        return -1;
    }

    // 创建套接字
    struct sockaddr_in server_addr, client_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(LISTEN_PORT);

    if (0 != bind(listenfd, (struct sockaddr*)& server_addr, sizeof(server_addr)))
    {
        perror("connect failed.");
        return -1;
    }

    // 设置为非阻塞
	int flag = fcntl(listenfd, F_GETFL, 0);
	flag |= O_NONBLOCK;
	fcntl(listenfd, F_SETFL, flag);

    // 监听
    if (0 != listen(listenfd, 1))
    {
        perror("listen failed.");
        return -1;
    }

    socklen_t len;
    while(1)
    {
        len = sizeof(client_addr);
        int clientfd = accept(listenfd, (struct sockaddr*)&client_addr, &len);
        if (clientfd != -1)
        {
            int32_t connectfd = clientfd;
            printf("clientfd: %d\n", clientfd);
            pthread_t threadid;
            pthread_create(&threadid, NULL, routine, &connectfd);
        }
    }
}