13_epoll的 LT、ET-block socket 、ET-no-block socket

最新推荐文章于 2022-03-16 16:45:33 发布
最新推荐文章于 2022-03-16 16:45:33 发布
阅读量417 收藏 2
点赞数 1
分类专栏： Linux系统编程、网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangwenhao1108/article/details/109748017
版权

目录

代码： https://github.com/WHaoL/study/tree/master/00_06_Linux_SystemCode_and_SocketCode

代码： https://gitee.com/liangwenhao/study/tree/master/00_06_Linux_SystemCode_and_SocketCode

1. epoll

内核检测epoll传递的fd集合, 是以红黑树的形式遍历的
内核创建一块共享内存: 内核和用户区共享
如果内存1G, epoll就支持10万连接

1.1 epoll的使用

1.1.1epoll的函数

#include <sys/epoll.h>

// 1、创建epoll模型 -> 得到的是epoll树的根
int epoll_create(int size);
- 参数: size: 已经被废弃了, 没有实际意义, 指定大于0的数就可以
- 返回值: epoll树的根节点

 
typedef union epoll_data 
{
	void        *ptr;
	int          fd;	
	//fd：常用的一个变量, 对应epoll_ctl()函数的第三个参数fd(同一个)
	uint32_t     u32;
	uint64_t     u64;
} epoll_data_t;

struct epoll_event 
{
	uint32_t     events;      /* Epoll events */
     - EPOLLIN: 读事件 -> 检测fd的读缓冲区
     - EPOLLOUT: 写事件 -> 检测fd的写缓冲区, 检测写缓冲区是不是可用(是不是满了)
	epoll_data_t data;        /* User data variable */
};
//2、在epoll树上进行节点的操作 -> 添加, 删除, 修改
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
参数:
	- epfd: epoll_create()函数的返回值, 指定操作的是哪个epoll树
	- op: 要对epoll树进行的操作
		EPOLL_CTL_ADD: 添加节点
		EPOLL_CTL_MOD: 修改节点的属性
		EPOLL_CTL_DEL: 删除节点
	- fd: 要挂到epoll树上用于检测的文件描述符
	- event: 指定要检测的文件描述符的事件(read-EPOLLIN/write-EPOLLOUT)
            
// 3、使用epoll委托内核检测挂到epoll树上的节点的状态
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
参数: 
	- epfd: epoll_create()函数的返回值, 指定操作的是那个epoll树
	- events: 结构体数组的地址, 存储实际发送变化的fd的状态 -> 传出
	- maxevents: 修饰第二个参数, 描述数组的实际大小
	- timeout: epoll_wait阻塞时长, 单位: 毫秒
		- >0: 阻塞对应的毫秒数
		- -1: 一直阻塞
		- =0: 不阻塞
返回值: 树上的节点有多少fd状态发生变化

1.1.2代码

// 伪代码
int main()
{
    //1. 创建套接字 -> 监听
    int lfd = socket();
  // 2. 绑定
    bind();
    // 3. 监听
    listen();
    // 4. 使用epoll
    // 4.1 创建epoll模型
    int epfd = epoll_create(100);
    // 4.2 将唯一的这个监听的fd挂到树上, 检测读事件
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);	// 添加节点操作完成
    // 4.4 开始检测
    struct epoll_event evs[1024];
    int lenevs=sizeof(evs)/sizeof(evs[0])
    while(1)
    {
        // 持续检测
        int ret = epoll_wait(epfd, evs, lenevs, -1);
        for(int i=0; i<ret; ++i)
        {
            int fd = evs[i].data.fd;
            // 监听
            if(fd == lfd)
            {
                int cfd = accept();
                // 新的cfd挂到树上
                ev.events = EPOLLIN;
    			ev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);	// 添加节点操作完成
            }
            // 通信
            else
            {
                int num = read();
                if(num == 0)
                {
                    // client disconnect
                    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                    close(fd);
                }
                write();
            }
        }
    }
}

在这里插入图片描述

client.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <errno.h>
int main()
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == lfd)
    {
        perror("socket");
        exit(0);
    }

    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(8888);
    inet_pton(AF_INET, "192.168.184.134", &serverAddr.sin_addr.s_addr);
    int ret = connect(lfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
    if (ret == -1)
    {
        perror("accept");
        exit(0);
    }

    while (1)
    {
        char buf[1024] = {0};
        fgets(buf, sizeof(buf), stdin);
        write(lfd, buf, strlen(buf) + 1);

        read(lfd, buf, sizeof(buf));
        printf("server data: %s\n", buf);
        sleep(1);
    }
    close(lfd);
    return 0;
}
server.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <sys/epoll.h>

int main()
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == lfd)
    {
        perror("socket");
        exit(0);
    }

    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(8888);
    inet_pton(AF_INET, "192.168.184.134", &serverAddr.sin_addr.s_addr);
    int ret = bind(lfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
    if (-1 == ret)
    {
        perror("bind");
        exit(0);
    }

    ret = listen(lfd, 5);
    if (-1 == ret)
    {
        perror("listen");
        exit(0);
    }

    int epfd = epoll_create(1);
    if (-1 == epfd)
    {
        perror("epoll_create");
        exit(0);
    }

    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);

    struct epoll_event evs[128];
    int lenevs = sizeof(evs) / sizeof(evs[0]);

    while (1)
    {
        int num = epoll_wait(epfd, evs, lenevs, -1);
        for (int i = 0; i < num; ++i)
        {
            int curfd = evs[i].data.fd;
            if (lfd == curfd)
            {
                struct sockaddr_in clientAddr;
                int lencli = sizeof(clientAddr);
                int cfd = accept(lfd, (struct sockaddr *)&clientAddr, (socklen_t*)&lencli);
                ev.events = EPOLLIN;
                ev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
            }
            else
            {
                char buf[1024] = {0};
                int num = read(curfd, buf, sizeof(buf));
                if (num > 0)
                {
                    printf("client data: %s\n", buf);
                    write(curfd, buf, num);
                }
                else if (num == 0)
                {
                    printf("客户端已经关闭连接...\n");
                    epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL);
                    close(curfd);
                }
                else
                {
                    perror("read");
                    exit(0);
                }
            }
        }
    }
    close(lfd);

    return 0;
}

1.2 epoll 的工作模式

1.2.1LT模式

LT模式：水平触发模式, 这是epoll()默认的工作模式
特点:
1.委托内核检测读操作 
  --> 检测读缓存区是不是有数据
  --> 只要读缓存区有数据，就通知我们
    1.1.没数据->有数据,epoll通知(解除阻塞返回)
    1.2.有数据,读走一部分,剩下一部分, epoll通知(解除阻塞返回)
    1.3.有数据->全部读出,没数据, epoll不通知(阻塞)
2.委托内核检测写操作 
  --> 检测写缓冲区是不是可用(不可用：已经满了)
  --> 只要写缓冲区不满就一直通知)
    2.1.没有满,epoll通知(解除阻塞返回)-> 检测一次通知一次
    2.2.满了,epoll不通知(阻塞)
    2.3.满->不满(发送出去一部分),epoll通知(解除阻塞返回)->检测一次通知一次

水平模式总结：
	​只要读缓存区有数据，就通知我们
	​只要写缓冲区可用，就通知我们
	​epoll通知：解除阻塞直接返回

概念：LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的。
clinet.c
同上
server.c
/*
 * 测试epoll()的LT模式
 * 因为epoll()默认情况下就是LT模式。
 * 所以源代码不需要修改，只需添加printf()
 * 即可测试
 * */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <sys/epoll.h>

int main()
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == lfd)
    {
        perror("socket");
        exit(0);
    }

    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(8888);
    inet_pton(AF_INET, "192.168.184.134", &serverAddr.sin_addr.s_addr);
    int ret = bind(lfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
    if (-1 == ret)
    {
        perror("bind");
        exit(0);
    }

    ret = listen(lfd, 5);
    if (-1 == ret)
    {
        perror("listen");
        exit(0);
    }

    int epfd = epoll_create(1);
    if (-1 == epfd)
    {
        perror("epoll_create");
        exit(0);
    }

    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);

    struct epoll_event evs[128];
    int lenevs = sizeof(evs) / sizeof(evs[0]);

    int NNN = 1;
    while (1)
    {
        int num = epoll_wait(epfd, evs, lenevs, -1);

        //测试epoll的LT模式
        //epoll每返回一次，下面的输出语句就被调用一次
        printf("epoll 返回第：%d次\n", NNN++);

        for (int i = 0; i < num; ++i)
        {
            int curfd = evs[i].data.fd;
            if (lfd == curfd)
            {
                struct sockaddr_in clientAddr;
                int lencli = sizeof(clientAddr);
                int cfd = accept(lfd, (struct sockaddr *)&clientAddr, (socklen_t *)&lencli);
                ev.events = EPOLLIN;
                ev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
            }
            else
            {
                char buf[5] = {0};
                int num = read(curfd, buf, sizeof(buf));
                if (num > 0)
                {
                    printf("client data: %s\n", buf);
                    write(curfd, buf, num);
                }
                else if (num == 0)
                {
                    printf("客户端已经关闭连接...\n");
                    epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL);
                    close(curfd);
                }
                else
                {
                    perror("read");
                    exit(0);
                }
            }
        }
    }
    close(lfd);

    return 0;
}

[root@lwh testcpp]# ./ser 
epoll 返回第：1次
epoll 返回第：2次
client data: aksdh
epoll 返回第：3次
client data: gjkah
epoll 返回第：4次
client data: djfgh
epoll 返回第：5次
client data: ajkdf
epoll 返回第：6次
client data: hgkj

epoll 返回第：7次
client data: 
epoll 返回第：8次
客户端已经关闭连接...
^C
[root@lwh testcpp]# 


[root@lwh testcpp]# ./cli 
aksdhgjkahdjfghajkdfhgkj
server data: aksdh
^C
[root@lwh testcpp]#

1.2.2ET模式

ET模式：(效率最高) 边沿触发模式 -> 需要设置
特点:
1.读操作: (检测到数据变化, 只通知一次, 不管缓冲区是否读完)
  1.1.从没数据 -> 有数据, epoll通知(解除阻塞返回)
  1.2.读数据, 读了一部分,剩下一部分,epoll不通知(阻塞)->读不完也不会继续通知
  1.3.有数据->全部读出,没数据,epoll不通知(阻塞)
2.写操作:
  - 写缓冲区没有满 -> epoll通知(解除阻塞返回) -> 一次
  - 满了, epoll不通知(阻塞)
  - 满 -> 不满(发送出去一部分) , epoll通知( 解除阻塞返回) -> 一次

--> epoll的边沿非阻塞模式下，效率是最高的

概念：
  'ET(edge-triggered)是高速工作方式，只支持no-block socket'。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了。'但是请注意，如果一直不对这个fd作IO操作（从而导致它再次变成未就绪)，内核不会发送更多的通知(only once）'。
  'ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高'。epoll工作在ET模式的时候，'必须使用非阻塞套接口'，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

1.2.3如何设置epoll的边沿模式

struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET;//设置边沿模式：使用边沿模式检测读缓冲区
ev.data.fd = fd;
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
client.c 同上
servic.c ET&&阻塞
/*
 * 测试epoll()的ET模式
 * */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <sys/epoll.h>

int main()
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == lfd)
    {
        perror("socket");
        exit(0);
    }

    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(8888);
    inet_pton(AF_INET, "192.168.184.134", &serverAddr.sin_addr.s_addr);
    int ret = bind(lfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
    if (-1 == ret)
    {
        perror("bind");
        exit(0);
    }

    ret = listen(lfd, 5);
    if (-1 == ret)
    {
        perror("listen");
        exit(0);
    }

    int epfd = epoll_create(1);
    if (-1 == epfd)
    {
        perror("epoll_create");
        exit(0);
    }

    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);

    struct epoll_event evs[128];
    int lenevs = sizeof(evs) / sizeof(evs[0]);

    int NNN = 1;
    while (1)
    {
        int num = epoll_wait(epfd, evs, lenevs, -1);

        //测试epoll的LT模式
        //epoll每返回一次，下面的输出语句就被调用一次
        printf("epoll 返回第：%d次\n", NNN++);

        for (int i = 0; i < num; ++i)
        {
            int curfd = evs[i].data.fd;
            if (lfd == curfd)
            {
                struct sockaddr_in clientAddr;
                int lencli = sizeof(clientAddr);
                int cfd = accept(lfd, (struct sockaddr *)&clientAddr, (socklen_t *)&lencli);
                ev.events = EPOLLIN | EPOLLET;//改为了ET模式！！！
                ev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
            }
            else
            {
                char buf[5] = {0};
                int num = read(curfd, buf, sizeof(buf));
                if (num > 0)
                {
                    printf("client data: %s\n", buf);
                    write(curfd, buf, num);
                }
                else if (num == 0)
                {
                    printf("客户端已经关闭连接...\n");
                    epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL);
                    close(curfd);
                }
                else
                {
                    perror("read");
                    exit(0);
                }
            }
        }
    }
    close(lfd);

    return 0;
}

[root@lwh testcpp]# ./ser 
epoll 返回第：1次
epoll 返回第：2次
client data: 12345
epoll 返回第：3次
client data: 67890
epoll 返回第：4次
client data: 

epoll 返回第：5次
client data: 
epoll 返回第：6次
客户端已经关闭连接...
^C
[root@lwh testcpp]# 




[root@lwh testcpp]# ./cli 
1234567890     
server data: 12345

server data: 67890

server data: 


server data: 
^C
[root@lwh testcpp]#

1.2.4边沿模式下-通信的fd必须设置为非阻塞

// 边沿模式，非阻塞情况下：服务器和客户端通信的部分代码
            else
            {
                char buf[512];
                int len;
                // 
                while((len= recv(curfd, buf, sizeof(buf), 0)) > 0)
                {
                    printf("recv buf: %s", buf);
                    send(curfd, buf, strlen(buf)+1, 0);
                }
                if(len == 0)
                {
                    printf("client disconnect ...\n");
                    // 将curfd从epoll树删除
                    epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL);
                    close(curfd);
                }
                else
                {
                    perror("recv");
                    exit(0);
                }
            }
#上边代码的问题:
当客户端和服务器没有断开连接的时候: 
接收数据使用的函数 read() / recv() 默认是阻塞的(缓冲区没数据的时候阻塞), 当前
通过 while 循环读数据的时候, 当数据被读完了进程会阻塞在 recv() / read() 函数上
#解决方案: 设置fd为非阻塞
// 1. 得到文件描述符的默认flag属性
int flag = fcntl(fd, F_GETFL);
// 2. 在默认属性基础上添加非阻塞属性 -> O_NONBLOCK
flag |= O_NONBLOCK;
// 3. 将新 的属性设置给文件描述符
fcntl(fd, F_SETFL, flag);

1.没断开连接时，当读缓冲区内没数据可读取时
 1.1.不管fd阻塞还是非阻塞，read都不返回0
 1.2.fd阻塞，此时进程会阻塞在read这儿，无法处理其他操作，
     等到有数据时，才解除阻塞
 1.3.fd非阻塞，进程不阻塞，可以去处理进程内的其他操作
2.当断开时，不管fd阻塞非阻塞，read都返回0
client.c 同上
servic.c ET&&非阻塞
/*
 * 测试epoll()的LT模式
 * 因为epoll()默认情况下就是LT模式。
 * 所以源代码不需要修改，只需添加printf()
 * 即可测试
 * */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <errno.h>

int main()
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == lfd)
    {
        perror("socket");
        exit(0);
    }

    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(8888);
    inet_pton(AF_INET, "192.168.184.134", &serverAddr.sin_addr.s_addr);
    int ret = bind(lfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
    if (-1 == ret)
    {
        perror("bind");
        exit(0);
    }

    ret = listen(lfd, 5);
    if (-1 == ret)
    {
        perror("listen");
        exit(0);
    }

    int epfd = epoll_create(1);
    if (-1 == epfd)
    {
        perror("epoll_create");
        exit(0);
    }

    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);

    struct epoll_event evs[128];
    int lenevs = sizeof(evs) / sizeof(evs[0]);

    int NNN = 1;
    while (1)
    {
        int num = epoll_wait(epfd, evs, lenevs, -1);

        //测试epoll的LT模式
        //epoll每返回一次，下面的输出语句就被调用一次
        printf("epoll 返回第：%d次\n", NNN++);

        for (int i = 0; i < num; ++i)
        {
            int curfd = evs[i].data.fd;
            if (lfd == curfd)
            {
                struct sockaddr_in clientAddr;
                int lencli = sizeof(clientAddr);
                int cfd = accept(lfd, (struct sockaddr *)&clientAddr, (socklen_t *)&lencli);

                int flag = fcntl(curfd, F_GETFL); //将cfd设置为非阻塞
                flag |= O_NONBLOCK;
                fcntl(curfd, F_SETFL, flag);

                ev.events = EPOLLIN | EPOLLET; //ET模式！！！
                ev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
            }
            else
            {

                char buf[5] = {0};
                int num = 0;
                while ((num = read(curfd, buf, sizeof(buf))) > 0)
                {
                    write(STDOUT_FILENO, buf, num); //1. 显示到自己的终端上
                    write(curfd, buf, num);         //2. 回发给client
                }
                if (num == 0)
                {
                    printf("客户端已经关闭连接...\n");
                    epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL);
                    close(curfd);
                }
                else
                {
                    if (errno == EAGAIN || errno == EWOULDBLOCK)
                    {
                        printf("数据已经读完...\n");
                    }
                    else
                    {
                        perror("read");
                        exit(0);
                    }
                }
            }
        }
    }
    close(lfd);

    return 0;
}

[root@lwh testcpp]# ./ser 
epoll 返回第：1次
epoll 返回第：2次
kkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllfffffffffffffffffdddddddddddddd
read: Connection reset by peer
[root@lwh testcpp]#  




[root@lwh testcpp]# ./cli 
kkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllfffffffffffffffffdddddddddddddd
server data: kkkkkkkkkkkkkkkkkkkkkkkkkllllllllllllllllllllllfffffffffffffffffdddddddddddddd

^C
[root@lwh testcpp]#  

“Connection reset by peer”表示当前服务器接受到了通信对端发送的TCP RST信号，即通信对端已经关闭了连接，通过RST信号希望接收方关闭连接。

参看：https://www.cnblogs.com/toSeeMyDream/p/9890024.html

2. epoll总结

  • 是什么?

    • epoll -> IO转接模型

  • 干什么?

    • 使用epoll委托内核, 检测一系列的有效的fd 对应的读写缓冲区状态
      • 读: 有没有数据到达
      • 写: 是不是可写
      • 提高了程序的执行效率

  • 怎么使用?

    • epoll_create
    • epoll_ctl
    • epoll_wait

  • 工作模式:

    • 水平 -> 默认
      • 只要满足条件就不停的通知
    • 边沿 -> 在事件中添加 EPOLLET
      • 只要满足条件只通知一次
        • 循环读数据
        • 设置为非阻塞模式 -> fd的属性
Liang-Wen-Hao
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从linux源码看socket的阻塞和非阻塞
weixin_34401479的博客
04-08 292
2019独角兽企业重金招聘Python工程师标准>>> ...
BlockSock
09-06 1077
<br />// blocksock.h typedef const struct sockaddr* LPCSOCKADDR; //CSockAddress和CMyBlockSocketException辅助类 //CMyBlockSocketException异常类 //所有CMyBlockSocket函数在WinSock返回错误时都会陷入异常，产生一个CMyBlockException对象 //CMyBlockException类从MFC的CException类派生，并重载了
Blocking vs. Non-Blocking Sockets
左超
07-21 1736
One of the first issues that you’ll encounter when developing your Windows Sockets applications is the difference between blocking and non-blocking sockets. Whenever you perform some operation on a so
block_socket_server
u011429899的专栏
03-06 371
import socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind(('192.168.1.178', 9200)) sock.listen(5) while True: soc...
为何 epoll 的 ET 模式一定要设置为非阻塞IO
yangshuzhi21的博客
03-29 3178
ET模式下 即 边沿触发模式 ET模式只有当socket描述符状态发生改变时才会触发事件，如果一次性没有读取完，即使内核缓冲区留有部分数据,仍然不进行触发读取。 LT模式下 即 水平触发模式 LT模式为默认的工作方式，当socket描述符发生改变时触发事件，即使内核缓冲区中的数据未读完，第二次调用时仍然会读取数据。 个人的理解是 第一次调用epoll_wait后 是否将 socket描述符 从 r...
linux-xia-epoll-socket.rar_epoll_epoll socket_socket_windows soc
09-22
linux下epoll模式的socket,可支持多用户同时向服务器发送请求。
epoll-lib-0.111.rar_epoll lib_epoll source_epoll-lib_linux epoll
07-15
linux epoll源码，支持大型服务器，适合高手研究
C_epoll_server-threadpool-linkpooll-main.zip
04-21
epoll_server，多线程，数据库
rn-0.4.tar.gz_epoll_epoll 封装_linux_linux epo_rn-0.4.tar
09-23
linux平台epoll封装，完成socket事件回调功能
epoll_threadpool-master.zip_epoll_epoll 多线程_linux 多线程_linux 多线程
07-15
epoll多线程的例子. 使用这个例子来解释下epoll多线程的设计方法和解决方案。
epoll方法实现non-blocking socket
PlayerL的专栏
01-02 1822
epoll方法实现non-blocking socket event-based方法和epoll epoll是event-based的方法实现异步io/non-blocking io。从Linux kernel 2.5.44之后epoll加入Linux kernel中，代替loop style方法的select和poll，比后者更加高效更适用于高并发多client的应用。loop
浅谈 non-blocking I/O Multiplexing + poll/epoll 的正确使用
weixin_30781631的博客
07-28 124
在前面的文章中曾经粗略讲过poll，那时是用阻塞IO实现，在发送和接收数据量都较小情况下和网络状况良好的情况下是基本没有问题的，read 不会只接收部分数据，write 也不会一直阻塞。但实际上poll IO复用经常是跟非阻塞IO一起使用的，想想如果现在内核接收缓冲区一点数据没有，read 阻塞了，或者内核发送缓冲区不够空间存放数据，write 阻塞了，那整个事件循环就会延迟响应，比如现在又有一个...
socket的O_NONBLOCK以及TCP_NODELAY
手边笔记
04-07 5474
设置socket的O_NONBLOCK以及TCP_NODELAY 1. no-blocking 将socket设置为no-blocking意味着socket收发数据都是非阻塞的，相比于阻塞方式，需要特殊处理这个错误码：EWOULDBLOCK or EAGAIN（这两个错误码是一样的，都是35），进行重试或者重新调度。 将socket设置非阻塞有多种方法，下面会一一汇总。 1.1 fcntl设置O_NONBLOCK POSIX的fcntl用的比较广泛，兼容性也比较好，优先推荐使用fcntl来设置，缺点是需要两
Socket Block Non-Block Python描述
eye_water的博客
01-01 516
本文的图片均非原创，均来源自于： java Selector is asynchronous or non-blocking architecture 阻塞模式下1 一段话描述阻塞与非阻塞的区别：2 假设我们在设计一个浏览器，用它来进行网页服务器的访问，如果设计为阻塞模式，那么当我们浏览一个网页长时间未响应时，按下了关闭按钮，会发生什么呢？关闭不掉！因为我们使用的阻塞模式来进行网页服务器的访问...
socket编程 —— 非阻塞socket
热门推荐
marken
01-21 3万+
在上一篇文章 《socket编程——一个简单的例子》 http://blog.csdn.net/wind19/archive/2011/01/21/6156339.aspx 中写了一个简单的tcp socket通信程序，可以进行数据的交互，但有一个问题是这个程序是阻塞的，任何socket函数都要等返回后才能进行下一步动作，如果recv一直没有数据，那么就一直不会返回，整个进程就阻塞在那。所以我们要进行改造一下，让程序不再阻塞在那，而是在有数据到来的时候读一下数据，有数据要写的时候发送一下数据。
socket编程中的阻塞和非阻塞 以及 I/O复用总结
qi_700的博客
03-06 1131
socket编程中的阻塞和非阻塞 以及 I/O复用总结 一、阻塞及非阻塞        阻塞：一般的I/O操作可以在新建的流中运用.在服务器回应前它等待客户端发送一个空白的行.当会话结束时,服务器关闭流和客户端socket.如果在队列中没有请示将
非阻塞式socket建立以及如何判断对方断开
chuanhehuan1的专栏
04-18 3193
最近写的程序要求的是在控制线程中使用非阻塞的socket，
Linux下各种锁地理解和使用以及总结解决一下epoll惊群问题(面试常考)
小杰312的博客
03-16 5359
Linux下各种锁地理解和使用以及总结解决一下epoll惊群问题(面试常考)
Epoll检测事件： - EPOLLIN - EPOLLOUT - EPOLLERR - EPOLLET
最新发布
03-14
Epoll检测事件包括：EPOLLIN、EPOLLOUT、EPOLLERR和EPOLLET。其中，EPOLLIN表示可读事件，EPOLLOUT表示可写事件，EPOLLERR表示错误事件，EPOLLET表示边缘触发模式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值