Blcoking I/O & NonBlocking I/O

最新推荐文章于 2023-07-06 14:37:41 发布
最新推荐文章于 2023-07-06 14:37:41 发布
阅读量581 收藏
点赞数
分类专栏： linux 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shun_fzll/article/details/50901014
版权

写在前面

以前在学校的时候，老想着要出来工作锻炼一下自己，等到真的出来了，才发现校园生活是最宝贵的。

出来快一年了，感慨很多，但却不知道如何说起，如果非要说有什么不一样，那大概就是变丑了吧。。。。

工作虽然忙，但是陆陆续续也有看一些书，我觉得学了知识就要学会把它整理出来，防止过段时间自己就忘了。

阻塞I/O （Blocking I/O）

什么是阻塞IO呢？？我引用很经典的一张图：


通常应用程序去调用recvfrom接收数据后，会进入阻塞状态。然后kernel会开始准备数据，等待网络数据包的到来，然后将数据包从kernel space 拷贝到 user space（即copy到用户进程的buffer），然后返回。这个时候应用程序才会解除阻塞，继续往下执行。


非阻塞I/O （NonBlocking I/O）

非阻塞I/O，简单来说就是进程发出了一个IO请求后，不会阻塞，而是立即会返回一个结果。再引用一张图来说明：


当用户进程发出read/write操作时，如果kernel中的数据还没有准备好或者缓冲区满了没法写，那么它并不会block用户进程，而是立刻返回一个EAGAIN或者EWOULDBLOCK的错误。这个时候就需要不断的轮询，读就一直读到返回0，写就一直写到数据发送完。


阻塞IO编程示例


// Blocking_IO_Server.cpp

#include <stdio.h>  
#include <stdlib.h>  
#include <errno.h>  
#include <string.h>  
#include <netinet/in.h>  
#include <sys/socket.h>  
#include <unistd.h>  
  
int main()  
{  
    int sockfd, new_fd;  
    int sin_size, numbytes;  
    struct sockaddr_in addr, cliaddr;  
      
    //创建socket  
    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)  
    {  
        perror("createSocket");  
        return -1;  
    }  
      
    //初始化socket结构  
    memset(&addr, 0, sizeof(addr));  
    addr.sin_family = AF_INET;  
    addr.sin_port = htons(8008);  
    addr.sin_addr.s_addr = htonl(INADDR_ANY);  
      
    //绑定套接口  
    if(bind(sockfd,(struct sockaddr *)&addr,sizeof(struct sockaddr))==-1)  
    {  
        perror("bind");  
        return -1;  
    }  
      
    //创建监听套接口  
    if(listen(sockfd,10)==-1)  
    {  
        perror("listen");  
        return -1;  
    }  
      
      
    printf("server is running!\n");  
      
    char buff[1024];  
    //等待连接  
    while(1)   
    {  
        sin_size = sizeof(struct sockaddr_in);  
          
        //接受连接  
        if((new_fd = accept(sockfd, (struct sockaddr *)&cliaddr, (socklen_t*)&sin_size))==-1)  
        {  
            perror("accept");  
            return -1;  
        }  
          
        //生成一个子进程来完成和客户端的会话，父进程继续监听  
        if(!fork())  
        {  
            //读取客户端发来的信息  
            memset(buff,0,sizeof(buff));  
            if((numbytes = recv(new_fd,buff,sizeof(buff),0))==-1)  
            {  
                perror("recv");  
                return -1;  
            }  
            printf("buff=%s\n",buff);  
              
            //将从客户端接收到的信息再发回客户端  
            if(send(new_fd,buff,strlen(buff),0)==-1)  
            {  
                perror("send");  
            }  
      
            close(new_fd);  
            return 0;  
        }  
        //父进程关闭new_fd  
        close(new_fd);  
    }  
    close(sockfd);  
}

// Blocking_IO_Client.cpp 

#include <stdio.h>  
#include <stdlib.h>  
#include <errno.h>  
#include <string.h>  
#include <netdb.h>  
#include <sys/types.h>  
#include <netinet/in.h>  
#include <sys/socket.h>  
#include <unistd.h>  
  
int main(int argc,char *argv[])  
{  
    int sockfd,numbytes;  
    char buf[100] = "hello world";  
    struct hostent *he;  
    struct sockaddr_in their_addr;  
      
    //建立一个TCP套接口  
    if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1)  
    {  
        perror("socket");  
        exit(1);  
    }  
      
    //初始化结构体  
    their_addr.sin_family = AF_INET;  
    their_addr.sin_port = htons(8008);  
    their_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bzero(&(their_addr.sin_zero),8);  
      
    //和服务器建立连接  
    if(connect(sockfd,(struct sockaddr *)&their_addr,sizeof(struct sockaddr))==-1)  
    {  
        perror("connect");  
        exit(1);  
    }  
      
    //向服务器发送字符串  
    if(send(sockfd,buf,strlen(buf),0)==-1)  
    {  
        perror("send");  
        exit(1);  
    }  
    memset(buf,0,sizeof(buf));  
      
    //接受从服务器返回的信息  
    if((numbytes = recv(sockfd,buf,100,0))==-1)  
    {  
        perror("recv");  
        exit(1);  
    }  
      
    close(sockfd);  
    return 0;  
}  
运行：
$ ./server 
server is running!
buff=hello world
buff=hello world

$ ./client
$ ./client


非阻塞I/O编程示例


// NonBlocking_IO_Server.cpp

#include <stdio.h>  
#include <stdlib.h>  
#include <errno.h>  
#include <string.h>  
#include <netinet/in.h>  
#include <sys/socket.h>  
#include <unistd.h>  
#include <fcntl.h>  
  
int main()  
{  
    int sockfd, new_fd;  
    int sin_size;  
    struct sockaddr_in addr, cliaddr;  
      
    //创建socket  
    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)  
    {  
        perror("createSocket");  
        return -1;  
    }  
      
    //初始化socket结构  
    memset(&addr, 0, sizeof(addr));  
    addr.sin_family = AF_INET;  
    addr.sin_port = htons(8008);  
    addr.sin_addr.s_addr = htonl(INADDR_ANY);  
      
    //绑定套接口  
    if(bind(sockfd,(struct sockaddr *)&addr,sizeof(struct sockaddr))==-1)  
    {  
        perror("bind");  
        return -1;  
    }  
      
    //创建监听套接口  
    if(listen(sockfd,10)==-1)  
    {  
        perror("listen");  
        return -1;  
    }  
      
    printf("server is running!\n");  
      
    char buff[1024];  
    //等待连接  
    while(1)   
    {  
        sin_size = sizeof(struct sockaddr_in);  
          
        //接受连接  
        if((new_fd = accept(sockfd, (struct sockaddr *)&cliaddr, (socklen_t*)&sin_size))==-1)  
        {  
            perror("accept");  
            return -1;  
        }  
              
        //生成一个子进程来完成和客户端的会话，父进程继续监听  
        if(!fork())  
        {  
            //设置new_fd无阻塞属性  
            int flags;  
            if((flags=fcntl(new_fd, F_GETFL, 0))<0)    
            {  
                perror("fcntl F_GETFL");    
            }  
            flags |= O_NONBLOCK;    
            if(fcntl(new_fd, F_SETFL,flags)<0)    
            {  
                perror("fcntl F_SETFL");    
            }  
              
            //读取客户端发来的信息  
            memset(buff,0,sizeof(buff));  
            while(1)  
            {  
                if((recv(new_fd,buff,sizeof(buff),0)) < 0)  
                {  
                    if(errno==EWOULDBLOCK)  
                    {  
                        perror("recv error, wait....");  
                        sleep(1);  
                        continue;  
                    }  
                }  
                else  
                {  
                    printf("buff=%s\n",buff);  
                }     
                break;  
            }  
  
            //发送数据  
            while(1)  
            {  
                if(send(new_fd,buff,strlen(buff),0) < 0)  
                {  
                    if(errno==EWOULDBLOCK)  
                    {  
                        perror("send error, wait....");  
                        sleep(1);  
                        continue;  
                    }  
                }  
                else  
                {  
                    printf("buff=%s\n",buff);  
                }     
                break;  
            }  
      
            close(new_fd);  
            return 0;  
        }  
        //父进程关闭new_fd  
        close(new_fd);  
    }  
    close(sockfd);  
}

// NonBlcoking_IO_Client.cpp 

#include <stdio.h>  
#include <stdlib.h>  
#include <errno.h>  
#include <string.h>  
#include <netdb.h>  
#include <sys/types.h>  
#include <netinet/in.h>  
#include <sys/socket.h>  
#include <unistd.h>  
  
int main(int argc,char *argv[])  
{  
    if(argc!=3)  
    {  
        printf("%s: input IP & port\n",argv[0]);  
        return 1;  
    }  
    int sockfd,numbytes;  
    char buf[100] = "hello world";  
    struct hostent *he;  
    struct sockaddr_in their_addr;  
      
    //将基本名字和地址转换  
    he = gethostbyname(argv[1]);  
      
    //建立一个TCP套接口  
    if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1)  
    {  
        perror("socket");  
        exit(1);  
    }  
      
    //初始化结构体  
    their_addr.sin_family = AF_INET;  
    their_addr.sin_port = htons(atoi(argv[2]));  
    their_addr.sin_addr = *((struct in_addr *)he->h_addr);  
    bzero(&(their_addr.sin_zero),8);  
      
    //和服务器建立连接  
    if(connect(sockfd,(struct sockaddr *)&their_addr,sizeof(struct sockaddr))==-1)  
    {  
        perror("connect");  
        exit(1);  
    }  
  
    sleep(5);  
      
    //向服务器发送字符串  
    if(send(sockfd,buf,strlen(buf),0)==-1)  
    {  
        perror("send");  
        exit(1);  
    }  
    memset(buf,0,sizeof(buf));  
      
      
    sleep(5);  
      
    //接受从服务器返回的信息  
    if((numbytes = recv(sockfd,buf,100,0))==-1)  
    {  
        perror("recv");  
        exit(1);  
    }  
      
    close(sockfd);  
    return 0;  
}  
运行：
$ ./server 
server is running!
recv error, wait....: Resource temporarily unavailable
recv error, wait....: Resource temporarily unavailable
recv error, wait....: Resource temporarily unavailable
recv error, wait....: Resource temporarily unavailable
recv error, wait....: Resource temporarily unavailable
buff=hello world
buff=hello world

$ ./client


引用：

https://segmentfault.com/a/1190000003063859

http://blog.csdn.net/yfkiss/article/details/7516589



风中老狼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
阻塞（Blocking）和非阻塞（Non-Blocking）
面朝大海
08-16 1万+
阻塞和非阻塞通常用来形容多线程间的相互影响。比如一个线程占用临界区资源，那么其它所有需要这个资源的线程就必须在这个临界区中进行等待，等待会导致线程挂起。这种情况就是阻塞。此时，如果占用资源的线程一直不愿意释放资源，那么其它所有阻塞在这个临界区上的线程都不能工作。         非阻塞允许多个线程同时进入临界区
Linux IO模式(阻塞/非阻塞)及 select详解
qq_41796226的博客
08-13 770
blocking和non-blocking的区别调用blocking IO会一直block住对应的进程直到操作完成，而non-blocking IO在kernel还准备数据的情况下会立刻返回。synchronous IO和asynchronous IO的区别在说明synchronous IO和asynchronous IO的区别之前，需要先给出两者的定义。两者的区别就在于synchronous IO做”IO operation”的时候会将process阻塞。...
Nonblocking I/O
nessofblade的专栏
04-01 793
在Nonblocking I/O中最重要的也就是三个类 引用java.nio.channels.SelectableChannel java.nio.channels.Selector java.nio.channels.SelectionKey1 SelectableChannel 默认情况下channels是阻塞的.我们可以设置一个channel为nonblock的,可是并不是
Node.js官方文档：到底什么是阻塞(Blocking)与非阻塞(Non-Blocking)？
weixin_33896726的博客
06-12 317
译者按： Node.js文档阅读系列之一。 原文: Overview of Blocking vs Non-Blocking 译者: Fundebug 为了保证可读性，本文采用意译而非直译。 这篇博客将介绍Node.js的阻塞(Blocking)与非阻塞(Non-Blocking)。我会提到Event Loop与libuv，但是不了解它们也不会影响阅读。读者只需要有一定的JavaScript基...
BIO、NIO、AIO的区别，IO多路复用 和 信号驱动IO
最新发布
qq120631157的博客
07-06 339
BIO、NIO、AIO的区别？IO多路复用 和 信号驱动IO。
NoC（Network on Chip）基础 (4)：Non-Blocking(Circuit Switch)Network——Crossbar 和 Clos
yang1573的博客
01-09 2061
介绍 NoC（Network on chip）中的 Non-Blocking 网络，即 Circuit-Switch 网络。并介绍了其中 Crossbar 和 Clos 两个 Non-Blocking 网络的例子。
非阻塞IO模型 nonblocking IO
weixin_30725467的博客
11-14 127
非阻塞IO模型 非阻塞IO模型的就是将原来的阻塞操作变成非阻塞的，当原来阻塞操作编程操作后就会有信号，没有信号的就就干其他事情，循环询问，循环执行其他事情，直到操作系统返回正确的信号就会继续执行。 import socket server = socket.socket() #重用端口 server.setsockopt(socket.SOL_SOCKET...
non-blocking I/O 和 blocking I/O 区别
baidu_27856405的博客
08-18 3318
在应用中，客户端连接到服务端，服务器处理请求并响应。在这个过程中，客户端和服务端通过socket连接，绑定到socket中，服务端等待着监听来自client的请求。 客户端与服务端连接后，相互读写数据通过socket。 Blocking I/O – 堵塞 I/O 通过Blocking I/O，客户端发送请求到服务端，线程处理这个连接，这是一个堵塞，直到数据读取或者写入完成。相关操作在完成之前...
java NIO(non-blocking I/O) 非阻塞式io
mrchen的博客
11-19 993
一:NIO (non-blocking i/o) 非阻塞式I/O 1.为所有的原始类型（boolean类型除外）提供缓存支持的数据容器，使用它可以提供非阻塞式的高伸缩性网络。 2.通道与流的不同之处在于通道是双向的。 3.因为它们是双向的，所以通道可以比流更好地反映底层操作系统的真实情况。特别是在 UNIX 模型中，底层操作系统通道是双向的。 4.flip()：Buffer有两种模式，
关于Blocking IO, Non-Blocking IO 和 Asynchronous I/O的理解
weixin_34204057的博客
03-04 201
概括来说，一个IO操作可以分为两个部分：发出请求、结果完成。如果从发出请求到结果返回，一直Block，那就是Blocking IO；如果发出请求就可以返回（结果完成不考虑），就是non-blocking IO；如果发出请求就返回，结果返回是Block在select或者poll上的，则其只能称为IO multiplexing；如果发出请求就返回，结果返回通过Call Back的方式被处理，就是AIO...
非阻塞IO（nonblocking I/O）
一条路走下去
10-08 848
非阻塞IO（nonblocking I/O）非阻塞IOnonblocking IO介绍 IO程序 Reactor模式 通道和选择器 Channel类功能 创建一个非阻塞的通道 Selector类功能 Channel和Selector 注册服务 代码介绍服务器的并发能力取决于它们如何有效的使用IO。同时处理数百个客户端请求需要数百个线程。直到JDK1.4，java平台都不支持非阻塞IO调用。JDK1.
非阻塞I / O ( Nonblocking I/O ) 与 Linux 内核 Epoll 原理详解
禅与计算机程序设计艺术
08-30 8906
非阻塞I / O ( Nonblocking I/O ) 与 Linux 内核 Epoll 原理详解 Kotlin 开发者社区 什么是文件描述符？ Unix中所有I / O的基本构建块是一个字节序列。大多数程序使用更简单的抽象 - 字节流或I / O流。 一种方法引用I / O流的帮助下描述，也被称为文件描述。管道，文件，FIFO，POSIX IPC（消息队列，信号量，...
cuda()和cuda(non_blocking=True)的区别
weixin_44655383的博客
08-30 1907
数据增广CPU运行cuda()和cuda(non_blocking=True)的区别二级目录三级目录 cuda()和cuda(non_blocking=True)的区别 .cuda()是为了将模型放在GPU上进行训练。 non_blocking默认值为False 通常加载数据时，将DataLoader的参数pin_memory设置为True（pin_memory的作用：将生成的Tensor数据存放在哪里），值为True意味着生成的Tensor数据存放在锁页内存中，这样内存中的Tensor转义到GPU的显存
Pytorch的cuda non_blocking (pin_memory)
hxxjxw的博客
03-18 3697
non_blocking经常与DataLoader的pin_memory搭配使用 PyTorch的DataLoader有一个参数pin_memory，使用固定内存，并使用non_blocking=True来并行处理数据传输。 先来看一下过程吧： 1. x = x.cuda(non_blocking=True) 2. 进行一些和x无关的操作 3. 执行和x有关的操作 在non_blocking=true下，1不会阻塞2，1和2并行。 .cuda()是为了将模型放在GPU上进行训练。 n.
non_blocking参数的设置。
AI浩
05-29 4088
问题： images.cuda(non_blocking=True)，target.cuda(non_blocking=True)把数据迁移到GPU里面； nn.DataParallel(model.to(device), device_ids=gpus, output_device=gpus[0])包装模型。 images.cuda(non_blocking=True)为何要设置参数non_blocking=True呢？ 解释：non_blocking默认值为False, 通常我们会在加载数据时，将Dat
什么是阻塞（Blocking）和非阻塞（Non-Blocking）？
Java
03-02 3527
阻塞和非阻塞通常用来形容多线程间的相互影响。比如一个线程占用了临界区资源，那么其他所有需要 这个而资源的线程就必须在这个临界区中进行等待。等待会导致线程挂起，这种情况就是阻塞。此时， 如果占用资源的线程一直不愿意释放资源，那么其他所有阻塞在这个临界区上的线程都不能工作。 非阻塞的意思与之相反，它强调没有一个线程可以妨碍其他线程执行。所有的线程都会尝试不断前向执 行。 ...
Verilog之blocking（阻塞） & nonblocking（非阻塞） assignments（赋值）
隔壁old余的博客
04-28 4086
Verilog中的阻塞与非阻塞赋值是一对十分难理解的概念，没有之一！本文展开说明，望解开难理解之谜。 1、阻塞赋值，很明显，具有阻塞之意，即在always块中，它要阻值其他语句的进行（在阻塞赋值语句LHS的赋值完成之前），然后才接着执行其他语句。而阻塞赋值本身，RHS的计算和LHS的赋值是同时完成的。整体是分前后顺序的，但内部是同时进行的。（整体是指每一条阻塞赋值语句本身，内部是指RHS的计算和...
non-blocking,blocking
weixin_30405421的博客
05-20 129
1.non-blocking是时序逻辑; 一般三要素: always; 变量对时钟边沿敏感posedge,negedge; 语句中使用<=赋值; 2.blocking是组合逻辑; 三要素: always; 变量对电平敏感posedge,negedge; 语句中使用=赋值; 真哦哦无双总结的好,blocking相当于软件,如51中的语句一行一行依序執行;而Non-blocking相当于硬...
浅谈5种IO模型——阻塞式IO、非阻塞式IO、信号驱动IO、多路复用IO及异步IO
JMW1407的博客
08-09 2606
5种IO模型5种IO模型1、背景2、IO模型2.1、阻塞式IO（blocking IO）2.2、非阻塞式IO(nonblocking IO)2.3、多路复用IO(IO multiplexing)2.4、信号驱动IO(signal driven IO)2.5、异步IO( asynchronous IO)参考 5种IO模型 1、背景 从TCP发送数据的流程说起 要深入的理解各种IO模型，那么必须先了解下产生各种IO的原因是什么，要知道这其中的本质问题那么我们就必须要知一条消息是如何从过一个人发送到另外一个人的；

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值