NIO之bio、nio、多路复用器发展历程(一)

什么是BIO,NIO?他们和多路复用器有啥关系? 每天早上七点三十,准时推送干货Photo by Scott Evans on Unsplash阿粉第一次了解到io相关知识是在网上看面经的时候,平时只会写业务代码,面对bio,nio,多... 阅读详情

系列文章目录

NIO之bio、nio、多路复用器发展历程(一)
NIO之select、poll、epoll 内核触发模型对比(二)
NIO之epoll(三)



前言

ps:如果你是一个每天都在镜子面前给自己磕头硬核男人,可以忽略下面的建议

各位老表,如果是新来的,建议先看下,操作系统相关的知识:深层次详解同步IO、异步IO、阻塞IO、非阻塞IO

各位看官,这边看起。
那得从 long long ago谈起了,当时限于业务和pg智力,最开始流行的是BIO ,每次为新的连接分配一个线程,连接激增时会导致堆栈溢出、线程无法分配、系统崩溃现象。程序员一看,这是要背锅的节奏呀,三下五除二改成了伪异步IO(bio +线程池+任务队列),这下不用担心资源一直分配了,但是换汤不换药,进程阻塞、服务超时、系统崩溃等问题依然存在。dang dang dang 主角来了,NIO (非阻塞io)基于同步非阻塞io模型,在获取连接和从client 获取数据时实现了非阻塞(也可以设置为阻塞),虽然实现了非阻塞,但是还是需要程序循环连接(循环fds-文件描述符列表)一个个发生系统调用(会发生用户态、内核态切换),消耗资源、效率低。那怎么才能不一 一个循环的系统调用呢,你一次性给他1000个,内核自己去循环判断不得了,聪明,多路复用就是起到这个作用,多路复用是一种规则,实现方式有select>poll>epoll ,性能从低到高。

bio(阻塞,流操作)–>nio(只是非阻塞、块操作)–>多路复用器

在这里插入图片描述


一、BIO

包: java.io.*

类别

  • 传统的bio: 通常有一个独立的线程负责监听客户端的连接,会为每个新来的连接请求创建一个新的线程进行读写操作,由于jvm的资源有限,当访问量激增后,系统性能急剧下降,可能发生堆栈溢出、无法创建新线程等,最终导致进程宕机。
  • 伪异步io: 在bio基础上,采用了线程池+任务队列的方式,代替了为每个连接创建一个线程的方式。做到占用的资源可控,保证了服务的可用性。但底层依然采用的同步阻塞模型,由此导致的进程阻塞或者服务超时、系统崩溃等都无法破解。

特点

  • 同步堵塞io模型
  • accept()获取连接阻塞,方法返回值-1=无数据,只能等着有数据返回,所以抛到新的一个线程处理,耗资源
  • client.read() 读取数据阻塞,方法返回值-1=无数据,只能等着有数据返回,
  • 系统调用次数多,应用程序循环fds 一次次的调用内核,效率极低

BIO创建连接慢原因

> 三次握手,所有io模型是必走的,
> server端, 主线程,accept(系统调用)发生阻塞(没有连接进入一直阻塞),有连接请求,发生clone (系统调用)每次开启一个子线程,主要慢在clone阶段

在这里插入图片描述

例子:使用bio方式创建5W连接 可以观察创建的速度。
客户端代码


import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SocketChannel;
import java.util.LinkedList;

/**
 * @author: di
 * @create: 2020-06-06 15:12
 */
public class C10Kclient {

    public static void main(String[] args) {
        LinkedList<SocketChannel> clients = new LinkedList<>();
        InetSocketAddress serverAddr = new InetSocketAddress("192.168.150.11", 9090);

        for (int i = 10000; i < 65000; i++) {
            try {
                SocketChannel client1 = SocketChannel.open();
                client1.bind(new InetSocketAddress("192.168.150.1", i));
                //  192.168.150.1:10000   192.168.150.11:9090
                client1.connect(serverAddr);
                clients.add(client1);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("clients "+ clients.size());

        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务端代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketIO {

    public static void main(String[] args) throws Exception {
        ServerSocket server = new ServerSocket(9090,20);
        System.out.println("step1: new ServerSocket(9090) ");

        while (true) {
            Socket client = server.accept();  //阻塞1
            System.out.println("step2:client\t" + client.getPort());

            new Thread(() -> {
                InputStream in = null;
                try {
                    in = client.getInputStream();

                    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                    while(true){
                        String dataline = reader.readLine(); //阻塞2

                        if(null != dataline){
                        System.out.println(dataline);
                        }else{
                            client.close();
                            break;
                        }
                    }
                    System.out.println("客户端断开");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}


可以忽略这部分

/**
可以忽略这里,只是处理本地网卡和虚拟网卡网络互通问题 
window机器,本地会有一块网卡(例如ip:192.168.110.100),安装了vmware后,以后用一个虚拟网卡net8 
(例如,虚拟网络为:192.168.150.0,net网关服务为:192.168.150.2),在vm上安装虚拟机node1(ip为192.168.150.11),

创建11W 个连接,通过本地的两个ip(192.168.150.1、192.168.110.100)+port,循环5.5W次,
调用server端(192.168.150.11:9090)创建连接,需要增加一个route关系,不然client可以往虚拟机server发送,
server无法给192.169.110.100的发送ack,网络不通。

route -n:
*/

在这里插入图片描述


二、NIO

定义

  • NIO: 官方称为 New I/O,但称为非阻塞io,更能体现NIO的特点,同步非阻塞。
    包: java.nio.*

特点

  • 非阻塞 (可以设置阻塞或者非阻塞)
  • accept() 获取连接非阻塞。该方法立即返回,底层返回-1,方法返回null,无连接;有连接会返回连接 client
  • client.read(buffer),读取数据不阻塞,有数据返回正数,无数据返回非正数。
  • 可以在一个线程里面处理接收连接和读取数据,

在这里插入图片描述

缺点

  • 一个线程可以处理连接和数据读取等,假如10W连接,但是进行数据读取时,循环一次,无论有无数据都会进行10W次的系统调用,很多调用无意义,消耗很大。
  • read是没错的,但是无用无效的read 在被不断调用,用户态、内核态不断切换。
    在这里插入图片描述

NIO和传统IO(简称IO)之间最大的区别

  • IO是面向流的,Java IO面向流意味着每次从流中读一个或多个字节,直至读取所有字节,它们没有被缓存在任何地方,操作简单,但慢;NIO是面向缓冲区的。 NIO 以块的方式处理数据,可以前后移动的操作数据,每一个操作都在一步中产生或者消费一个数据块,按块处理数据比按(流式的)字节处理数据要快得多,但缺少IO的优雅性和简单性。
  • IO同步阻塞;NIO同步非阻塞

例子:同nio方式创建5W连接,注意观察速度
客服端代码


import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SocketChannel;
import java.util.LinkedList;

/**
 * @author: di
 * @create: 2020-06-06 15:12
 */
public class C10Kclient {

    public static void main(String[] args) {
        LinkedList<SocketChannel> clients = new LinkedList<>();
        InetSocketAddress serverAddr = new InetSocketAddress("192.168.150.11", 9090);

       
        for (int i = 10000; i < 65000; i++) {
            try {
                SocketChannel client1 = SocketChannel.open();
                client1.bind(new InetSocketAddress("192.168.150.1", i));
                //  192.168.150.1:10000   192.168.150.11:9090
                client1.connect(serverAddr);
                clients.add(client1);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("clients "+ clients.size());

        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务端代码

import java.net.InetSocketAddress;
import java.net.StandardSocketOptions;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.LinkedList;

public class SocketNIO {

    public static void main(String[] args) throws Exception {

        LinkedList<SocketChannel> clients = new LinkedList<>();

        ServerSocketChannel ss = ServerSocketChannel.open();// 相当于fd
        ss.bind(new InetSocketAddress(9090));// 绑定端口
        ss.configureBlocking(false); //重点  OS  NONBLOCKING!!!

        ss.setOption(StandardSocketOptions.TCP_NODELAY, false);

		/**
			主线程里面负责接收连接及遍历连接获取数据
		*/

        while (true) {
            Thread.sleep(1000);
            //不会阻塞,返回  -1 =null 以为着无连接
            // NONBLOCKING 的时候,非阻塞,没有连接返回为null;设置Blocking 为阻塞 ,直到有连接进来,accept() 才往下走
            SocketChannel client = ss.accept();
           /** accept 调用了内核,
           	1、没有客户端连接进来,返回值? BIO 的时候,一直卡着,但在NIO不卡着,内部返回0,accept返回null。
			2、如果有客户端的连接,内部是返回的是客服端的fd  ,该方法client 为 object
			3、NONBLOCKING 就是代码能往下走了,只不过有不同的情况
			*/
            if (client == null) {
                System.out.println("null.....");
            } else {
                client.configureBlocking(false);// 重点 socket(服务端的listen socket<双方三次握手后,往这里扔,我去通过accept得到后面的连接socket>,,连接的socket<连接后的数据传递使用> ),指的下面的c.read(buffer) 读取不阻塞
                int port = client.socket().getPort();
                System.out.println("client...port: " + port);
                clients.add(client);
            }

           // ByteBuffer buffer = ByteBuffer.allocateDirect(4096);  //可以在堆里   堆外

            for (SocketChannel c : clients) {   //串行化!!!!  or 多线程!!
                int num = c.read(buffer);  // >0  -1  0   //不会阻塞,有无数都会返回,但会发生系统态切换,影响速度
                if (num > 0) {
                    buffer.flip();
                    byte[] aaa = new byte[buffer.limit()];
                    buffer.get(aaa);

                    String b = new String(aaa);
                    System.out.println(c.socket().getPort() + " : " + b);
                    buffer.clear();
                }
            }
        }
    }
}

错误

1、Exception in thread “main” java.io.IOException:Too many open file
ulimit -a : 可以查看open files 等全部配置
ulimit -n : 只查看 open files 限制大小 (一般用户是根据这个限制来的,root会突破限制),1024 一个进程最大可以打开的fd数量。
ulimit -sha 50000 : 把openfiles 设置为5W
netstat -natp: 网络连接状态


三、多路复用器

定义

多条路(下方图中多个io链路):通过一个系统调用(就是复用),把一批fd 传给kernel,内核获取fds其中的io状态,然后由程序自己对有状态的io进行读写。

多路复用器是一种规范,会有select、poll、epoll (三者都是同步非阻塞模型)实现。三种方式体现到java就是selector<多路开关选择器>,一个选择器能够管理多个信道上的I/O操作,

nio:直接采用和bio一样的获取连接方式accept(),
nio+多路复用:也可以通过将socketChannel 注册到selector 上的方式,使用selector 多路复用器获取有状态连接,

与Selector一起使用时,Channel必须处于非阻塞模式下。这意味着不能将FileChannel与Selector一起使用,因为FileChannel不能切换到非阻塞模式。而套接字通道都可以。

在这里插入图片描述

**例子:**通过创建5W连接,可以看到速度明显快了很多。
客户端代码


import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SocketChannel;
import java.util.LinkedList;

/**
 * @author: di
 * @create: 2020-06-06 15:12
 */
public class C10Kclient {

    public static void main(String[] args) {
        LinkedList<SocketChannel> clients = new LinkedList<>();
        InetSocketAddress serverAddr = new InetSocketAddress("192.168.150.11", 9090);

       
        for (int i = 10000; i < 65000; i++) {
            try {
                SocketChannel client1 = SocketChannel.open();
                client1.bind(new InetSocketAddress("192.168.150.1", i));
                //  192.168.150.1:10000   192.168.150.11:9090
                client1.connect(serverAddr);
                clients.add(client1);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("clients "+ clients.size());

        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务端代码


import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class SocketMultiplexingSingleThread {
    private ServerSocketChannel server = null;
    //linux 多路复用器(select>poll>epoll)
    private Selector selector = null;   
    int port = 9090;

    public void initServer() {
        try {
            server = ServerSocketChannel.open();//fd4
            server.configureBlocking(false);
            server.bind(new InetSocketAddress(port));

            //如果在epoll模型下,open--》  epoll_create -> fd3
            //  select  poll  epoll  优先选择:epoll , 但是可以 -D修正指定使用哪个多路复用器
            selector = Selector.open();  

			//server 约等于 listen状态的fd4
            /*
            register
            如果:
            	select,poll:jvm里开辟一个数组 fd4 放进去
           	 	epoll:epoll_ctl(fd3,ADD,fd4,EPOLLIN) 红黑树
             */
            server.register(selector, SelectionKey.OP_ACCEPT);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void start() {
        initServer();
        System.out.println("服务器启动了。。。。。");
        try {
            while (true) {  //死循环
                Set<SelectionKey> keys = selector.keys();
                System.out.println(keys.size()+"   size");

                //1,调用多路复用器(select,poll  or  epoll  (epoll_wait))
                /*
                select()是啥意思:
                1,select、poll :其实是内核的select(fd4)、 poll(fd4)
                2,epoll: 其实内核的epoll_wait()
                    参数可以带时间:没有时间,0  :  阻塞,有时间设置一个超时
                selector.wakeup()  结果返回0

                懒加载:
                其实在触碰到selector.select()调用的时候才触发了epoll_ctl的调用
                 */
                while (selector.select() > 0) {
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();  //返回的有状态的fd集合
                    Iterator<SelectionKey> iter = selectionKeys.iterator();
                    //管你啥多路复用器,你只能给我状态,我还得一个一个的去处理他们的R/W。同步好辛苦!
                    //  NIO 自己对着每一个fd调用系统调用,浪费资源,那么你看,这里是不是调用了一次select方法,知道具体的那些可以R/W了?
                    //前边强调过,socket:  listen   通信 R/W
                    while (iter.hasNext()) {
                        SelectionKey key = iter.next();
                        iter.remove(); //set  不移除会重复循环处理
                        if (key.isAcceptable()) {
                            //看代码的时候,这里是重点,如果要去接受一个新的连接
                            //语义上,accept接受连接且返回新连接的FD对吧?
                            //那新的FD怎么办?
                            //select,poll,因为他们内核没有空间,那么在jvm中保存和前边的fd4那个listen的一起
                            //epoll: 我们希望通过epoll_ctl把新的客户端fd注册到内核空间
                            acceptHandler(key);
                        } else if (key.isReadable()) {
                            readHandler(key);  //连read 还有 write都处理了
                            //在当前线程,这个方法可能会阻塞  ,如果阻塞了十年,其他的IO早就没电了。。。
                            //所以,为什么提出了 IO THREADS
                            //redis  是不是用了epoll,redis是不是有个io threads的概念 ,redis是不是单线程的
                            //tomcat 8,9  异步的处理方式  IO  和   处理上  解耦
                        }
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void acceptHandler(SelectionKey key) {
        try {
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
            SocketChannel client = ssc.accept(); //来啦,目的是调用accept接受客户端  fd7
            client.configureBlocking(false);

            ByteBuffer buffer = ByteBuffer.allocate(8192);  //前边讲过了

            //你看,调用了register
            /*
            select,poll:jvm里开辟一个数组 fd7 放进去
            epoll:  epoll_ctl(fd3,ADD,fd7,EPOLLIN)
             */
            client.register(selector, SelectionKey.OP_READ, buffer);
            System.out.println("-------------------------------------------");
            System.out.println("新客户端:" + client.getRemoteAddress());
            System.out.println("-------------------------------------------");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void readHandler(SelectionKey key) {
        SocketChannel client = (SocketChannel) key.channel();
        ByteBuffer buffer = (ByteBuffer) key.attachment();
        buffer.clear();
        int read = 0;
        try {
            while (true) {
                read = client.read(buffer);
                if (read > 0) {
                    buffer.flip();
                    while (buffer.hasRemaining()) {
                        client.write(buffer);
                    }
                    buffer.clear();
                } else if (read == 0) {
                    break;
                } else {
                    client.close();
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();

        }
    }

    public static void main(String[] args) {
        SocketMultiplexingSingleThreadv1 service = new SocketMultiplexingSingleThreadv1();
        service.start();
    }
}

附加----------------------------------------------------------------
IO分两阶段:

  • 1.数据准备阶段:数据从网卡、磁盘复制到内核缓存区
  • 2.内核空间复制到用户进程缓冲区、

阻塞、非阻塞、同步、异步 只关注io,不关注io读写之后的事情

  • 同步: 强调io的第二步,需要程序自己去完成R/W
  • 异步: 强调io的第二步,需要kerner自己去完成R/W,不依赖程序
  • 阻塞: 程序执行没有等到结果,一直等着
  • 非阻塞: 无论有无数据都直接返回,不会让当前线程一直等着。有数据返回数据,没数据返回空。
    在这里插入图片描述

可以参考此文:[深层次详解同步IO、异步IO、阻塞IO、非阻塞IO]

网络编程-BIO和NIO的理解 1.BIO和NIO简介 BIO:同步阻塞式IO,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,当然可以通过线程池机制改善; NIO:同步非阻塞式IO,服务器实现模式为一个请求一个线程,即客户端发送连接请求都会注册到多路复用器上,多路复用器轮训到连接有I/O请求时才启动一个线程进行处理; AIO(NIO.2):异步非阻塞式IO,服务器实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器 阅读详情

相关推荐

BIO、NIO、AIO

目录 第一章 IO演进之路 第二章 JAVA BIO深入剖析 1、 Java BIO 基本介绍 2、 Java BIO 工作机制 3、BIO模式下多发和多收消息 4、BIO模式下伪异步IO编程 第三章 JAVA NIO深入剖析 1、介绍 2、NIO和BIO的比较 3、NIO 三大核心原理示意图 4、缓冲区(buffer) 5、通道(Channel) 6、 NIO核心三:选择器(Selector) 7、 NIO非阻塞式网络通信原理分析(流程) 8、 NIO非阻塞式网络通信入门案例

日积月累,水滴石穿 917

BIO、NIO、NIO(多路复用)、AIO 机制详解和发展历程

前言:本文用到的铺垫知识:TCP/IP、操作系统 用户态/内核态的切换、linux 系统 文件描述符概念(应还有点socket编程经验,起码手写过TCP/IP连接的服务端) 1.首先谈下客户端和服务端是怎么建立TCP连接的 1)服务端启动 首先服务端创建socket套接字 绑定监听端口 通过一个死循环来调用Accept不断监听客户端信息 如果有客户端连接则抛出一个新的线程去处理这个连接 一、BIO (blocking I/O)阻塞型IO 首先看下阻塞型IO,如果,我们的服务端接受到客户端请求并

荣荣的博客 801

MicroPython 开发ESP32应用教程 之 WIFI配网 Web页面配网 softAP 配网 web页面控制WS2812灯珠

MicroPython 开发ESP32应用教程 之 WIFI配网 Web页面配网 softAP 配网 web页面控制WS2812灯珠

weald2000的专栏 2084

关于BIO和NIO的理解

最近大概看了ZooKeeper和Mina的源码发现都是用Java NIO实现的,所以有必要搞清楚什么是NIO。下面是我结合网络资料自己总结的,为了节约时间图示随便画的,能达意就行。 简介: BIO:同步阻塞式IO,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启...

cihongmo6452的博客 217

模拟调制系统实战:从AM到FM的5种调制方式对比与选型指南

本文深度解析AM、DSB、SSB、VSB、FM五种经典模拟调制方式,从实现电路、频谱效率、抗噪性能及工程成本等维度进行实战对比。通过MATLAB/Simulink仿真案例,提供清晰的选型决策框架,帮助工程师在无人机图传、短波通信、广播系统等具体项目中,根据带宽、功耗和抗干扰需求选择最优方案。

study的专栏 935

多智能体强化学习中的Trust Region技术:HATRPO与HAPPO深度解析

本文深度解析多智能体强化学习中的Trust Region技术,重点探讨HATRPO(异质智能体信任区域策略优化)与HAPPO(异质智能体近端策略优化)两种先进算法。通过数学架构与工程实现细节,揭示其在解决联合策略空间爆炸、信用分配等挑战中的优势,并分享实际部署中的优化技巧与前沿进展。

weixin_29072299的博客 193

BIO、NIO 到多路复用的演进路径,你明白了吗?

从 NIO 到 Netty IO 是编程中一个重要的概念,不论是数据存储和网络通信,底层都是会用到,理解 IO 对面试和工作都有很大的帮助,也能从基础理论层面扎实基础,理解其上层应用就简单的多了。在常用的软件中,例如 Nginx、Redis、Dubbo、Kafka 都涉及到了 NIO 的一些基础知识,本文就从简单的 IO 开始剖析,从 BIO 到 NIO 再到 Netty,从理论到实践进行深入的理解。 计算机组成 计算机的组成包括 CPU、内存存储、网卡、磁盘存储和其它外部设备。在 Linux 操作系

weixin_68320784的博客 216

LTE网络下的SMS收发(SMS Over SGs方案的详细流程)

关键词: IMS,SMS, LTE, MSC, MME, EPS,eNodeB, SMS Over SGs, SMS Over IMS 2G时代由于采用了比较复杂的CS/PS域架构,所以SMS(短信)作为上个世纪的产物,一直寄居在2G的CS域架构下。看看核心网的配置,其实SMS的收发还是比较复杂的。 介绍下面的信息之前你需要去百度一下这些关键词,这里我只说明比较重要的三个单元 MS 移动终端...

kevin的博客 2万+

肝了一夜,一文说清BIO、NIO、AIO不同IO模型演进之路

Netty作为高性能的网络通信框架,它是IO模型演变过程中的产物。Netty以Java NIO为基础,是一个提供异步事件驱动的网络应用框架,用以快速开发高性能、高可靠的网络服务器和客户端程序。本文主要通过分析IO模型的演变之路,比较不同IO模型的异同,让大家对于Java IO模型有着更加深刻的理解。

1587

【OpenClaw从入门到精通】第48篇:企业“养虾”合规手册——审批备案+专网隔离+全流程管控(2026企业版)

随着OpenClaw在企业场景的规模化应用,“无审批部署、无备案运行、无隔离防护”已成为安全事件的主要诱因。本文基于启明星辰《OpenClaw类智能应用安全指引V0.1》,结合金融、能源行业头部企业落地实践,构建“审批-评估-备案-管控”全流程合规框架。核心内容包括四步审批备案流程、专网隔离部署规范、3套可直接复用的合规文档模板(使用申请单、安全评估报告、备案登记表),以及个人使用备案简化方案。通过本文,企业可建立“有据可依、有章可循”的OpenClaw管理体系,实现“专网部署、数据隔离、最小权限、全程监控

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 463

Allegro DXF板框导入及将元器件精准放置到特定位置操作

DXF板框导入 选择File-> import -> DXF 点开DXF file 查找文件 3. 选择需要导入的DXF文件 4. 通常结构文件使用的是米制单位,将单位选择为mm,如果不确定DXF 图纸坐标大小,建议勾选incremental addition,软件根据实际DXF图纸大小自动调整背景坐标尺寸以适应DXF图纸 5.打开Edit/View layers 6. 勾选 select all,选择DXF文件所有层;class 一栏选择BOARD GEOMETRY;subcla

sinat_15677011的博客 1万+

详细介绍BIO、NIO、IO多路复用(select、poll、epoll)

Rdis是跑在单线程中的,所有的操作都是按照顺序线性执行的,但是由于读写操作等待用户输入或输出都是阻塞的,所以I/O操作在一般情况下往往不能直接返回,这会导致某一文件的I/O阻塞导致整个进程无法对其它客户提供服务,而I/O多路复用就是为了解决这个问题而出现。比如read和write,通常IO操作都是阻塞I/O的,也就是说当你调用read时,如果没有数据收到,那么线程或者进程就会被挂起,直到收到数据。阻塞 I/O 是最简单的 I/O 模型,一般表现为进程或线程等待某个条件,如果条件不满足,则一直等下去。

qq_44373419的博客 1010

18、项目运行与调试全攻略

本文详细介绍了在IntelliJ IDEA中进行项目运行与调试的完整流程,涵盖运行配置的创建与管理、临时配置的使用与保存、运行窗口的控制台操作及多程序并行运行的处理。同时,讲解了如何通过调试器定位和修复语法错误、运行时错误及逻辑错误,并结合ACME项目演示了第三方库Log4J的集成方法和命令行客户端的功能改进。文章还提供了调试流程图,帮助开发者系统掌握IDEA的强大调试功能,提升开发效率与代码质量。

svm4gardener的博客 77

网络IO发展历程:BIO、NIO、多路复用器、epoll

网络侧IO,通过网络来通信(偏向内核方面) 画图工具:processon.com BIO NIO 多路复用器 NIO:操作系统角度:N表示非阻塞;JDK角度:N表示New IO(要掌握nonblocking,channel,buffer,selector),内存、文件系统 今天讲一些词汇:同步、异步、阻塞、非阻塞 1、OS 程序不能直接访问内核,用户程序想要调用内核的方法,需要使用int 80中...

寒泉 6万+

Python解答蓝桥杯省赛真题之从入门到真题

搜了很多历年蓝桥杯真题解答,大多都是Java,C++,C这些语言编写的代码解析。Python解析的几乎,甚至可以说没有。而当下Python又这么火热,蓝桥杯也出了Python组,所以打算写一个Python解答蓝桥杯真题的博客,供大家参考,也在这过程中和大家一起交流。

李波的blog,一名喜欢编程和分享技术的研究僧~ 10万+

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

BIO、NIO、AIO线程模型理解

NIO调用流程是通过操作系统内核函数来实现的。Java创建Socket后,获取该Socket的文件描述符,然后创建一个Selector对象。该Selector对象对应于操作系统中的Epoll描述符。接着,将Socket的文件描述符与Selector中的Epoll描述符关联,允许系统内核异步通知事件。这样,一条线程就可以高效地处理多个事件,而无需无效遍历。事件处理交由操作系统内核来管理,大大提高了效率。

weixin_49862903的博客 1182

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

Java网络IO系列-BIO、NIO、多路复用器详解(附代码)

BIO NIO Select Poll Epoll

Ives_WangShen的博客 1201

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

网络通信IO【BIO,NIO,多路复用器】

BIO,NIO,多路复用器 书中自有黄金屋,书中自有颜如玉 ———————————————————————————————————— 本文在《码出高效:Java开发手册》书本讲解内容的基础上,将和大家一起对JDK1.8版本中的LinkedList源代码进行分析学习,同时和ArrayList的实现代码进行对比说明,争取做到知其然,也知其所以然。 ...

菲林都已拆走 1086

关于IO、BIO、NIO的理解

IO、BIO、NIO理解 简介 BIO:同步阻塞式IO,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,当然可以通过线程池机制改善。 NIO:同步非阻塞式IO,服务器实现模式为一个请求一个线程,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。 AIO(NIO.2):异步非阻塞式IO,服务器实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服

wang_hahah的博客 1334

BIO、NIO、AIO、多路复用器

1、BIO(Blocking IO) 1.1 介绍 BIO是同步阻塞IO,当有客户端连接进来时,需要开辟一个线程给这个客户端,所以当连接过高时,会对服务器造成负载过高甚至卡死, 1.2 Java代码示例 public static void main(String[] args) throws Exception { ExecutorService threadPool = Executors.newCachedThreadPool(); ServerSocket

qq_35597828的博客 1158

NIO的流程以及与BIO的差别

NIO: 同步非阻塞,服务器实现模式为一个线程处理多个请求,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有IO请求就进行处理。 连接数目多,且连接比较短,用于聊天室,弹幕系统 NIO是JDK1.4 JAVA提供了一系列改进的输入/输出的新特性,被统称为NIO,同步非阻塞IO,相关的类都在java.nio包内 NIO的特性: NIO有三个核心部分: Channel(管道),Bu...

jym的博客 9860

BIO与NIO学习

想必大家一定发现bio的明显的弊端了吧,随着接入的客户端越来越多服务器创建的线程数也就越多,在提供服务时在不同线程间的切换(需要保护当前现场,恢复下个线程运行的环境)也会越频繁,这会造成cpu利用的极大浪费,且这种模式的接入量存在明显的上限。但是需要thread去不断轮询clients,当clients非常大的时候循环的事件开销就会很大,并且对于客户链来说需要执行读写操作的时间和数量只占很小的一部分,所以对于轮询操作不仅耗时而且大部分操作是无效的。所以根本问题就在阻塞上,阻塞导致原线程无法提供服务。

release_lonely的博客 927

BIO,NIO,AIO 的区别

BIO,NIO,AIO 有什么区别? 简答: BIO:Block IO 同步阻塞式 IO,就是我们平常使用的传统 IO,它的特点是模式简单、使用方便,并发处理能力低,数据的读取写入必须阻塞在一个线程内等待其完成。 NIO:Non IO 同步非阻塞 IO,是传统 IO 的升级,客户端和服务器端通过 Channel(通道)通讯,实现了多路复用。对于高负载、高并发的(网络)应用,应使用 NIO 的非阻塞模式。 AIO:Asynchronous IO 是 NIO 的升级,也叫 NIO2,实现了异步非堵塞 IO ,

weixin_38568503的博客 646

bio/aio/nio以及多路复用器

bio/nio/aio 先看一下这三种的名词解释。 bio:同步阻塞io; nio:同步非阻塞io; aio:异步非阻塞io; 通过解释之后,引申出几个概念,什么是同步与异步,什么是阻塞与非阻塞。 同步就是需要自己去监听事件是佛欧有返回结果,而异步是其他线程去做这件事。 阻塞的意思的,比如在bio中,我调用了accept方法,会一直阻塞在这里,直到有连接事件发生,这种酒属于阻塞事件,非阻塞就是在nio中我们调用accept方法,会马上返回结果,线程可以去处理其他事情,这就是非阻塞。 bio模型: nio模

程序员大航子 1154
上一篇: 学懂IO必备的TCP、socket知识(三)
下一篇: NIO之select、poll、epoll 内核触发模型对比(二)
you_are_the_one
博客等级 码龄15年 50粉丝 25原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值