Java基础_IO流（BIO和NIO）

最新推荐文章于 2024-04-29 19:18:22 发布
最新推荐文章于 2024-04-29 19:18:22 发布
阅读量357 收藏 1
点赞数 2
分类专栏： Java基础 文章标签： java nio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huyiju/article/details/120024207
版权

目录

1：写在文章之前

2：什么是BIO（Block IO-阻塞IO）

2.1：代码案例（多个客户端对1个服务端）

2.2：代码案例（多个客户端对应多个服务端）

3：什么是NIO（New IO-非阻塞IO）

3.1：Buffers（缓冲区）

3.2：Channels（通道）

3.3：Selector（选择器）

1：写在文章之前

上一张的IO了解了IO流的字节流和字符流,主要操作读写文件。

我们在网络通信中经常会用到BIO和NIO，主要处理网络数据，以下就是BIO和NIO的特征。

BIONIO
面向流面向缓冲
阻塞IO非阻塞IO
无选择器

2：什么是BIO（Block IO-阻塞IO）

BIO:同步阻塞IO

同步：客户端跟服务器经过TCP链接后。客户端发数据后服务端立马能接受数据。

阻塞：1个客户端线程都会对应1个服务端线程。客户端线程发数据服务端线程接收数据。如果客户端线程还没有发送数据呢，服务端的对应的接受线程会阻塞。适合连接数目较小的框架。

结构如下：

2.1：代码案例（多个客户端对1个服务端）

客户端可以启动多个，但是服务端只有一个线程。只会处理连接到的第一个客户端，其他的客户端发送的数据服务端不会接受。

/**
 * @date :8/30/21 4:16 PM
 * 服务端只有一个线程提供服务
 * 只能处理一个客户端
 * 服务端代码
 */
public class Service1 {
    public static void main(String[] args) {

        try {
            System.out.println("服务端启动");
            //补充：端口范围0-65535，0-1023为系统占用端口
            //服务端指定端口

            //1:建立连接
            ServerSocket serverSocket = new ServerSocket(9998);
            //2:监听客户端
            Socket socket = serverSocket.accept();

            //3:获取IO流，通过scoket获取IO流
            InputStream inputStream = socket.getInputStream();
            byte[] bytes = new byte[1024];
            int a=0;

            //4：输出数据
            while ((a = inputStream.read(bytes)) != -1) {
                String string = new String(bytes, 0, a, "UTF-8");
                System.out.println("服务端获取信息：" + string);
            }

            System.out.println("结束");

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //此处不关闭
        }


    }
}


=====================以下是客户端代码===================


/**
 * @author :huyiju
 * @date :8/30/21 4:12 PM
 * 客户端代码 发送数据
 */
public class BIO2 {
    public static void main(String[] args) throws IOException {
        System.out.println("客户端多发启动13");
        String host = "127.0.0.1";
        int port = 9998;

        Socket socket = new Socket(host, port);
        OutputStream outputStream = socket.getOutputStream();
        Scanner scanner=new Scanner(System.in);
        
        while (true){
            System.out.print("请说：");
            String msg=scanner.nextLine();
            outputStream.write(msg.getBytes("UTF-8"));
            outputStream.flush();//此处刷新流 便于下次重新写数据
            //socket.close();//不要关闭 模拟多次请求
        }
    }
}

结果分析：客户端1和2都发送数据，但是服务端只能接收到第一个客户端的数据。验证了阻塞同步是BIO的特性

2.2：代码案例（多个客户端对应多个服务端）

在上边的案例。知道了BIO的同步。我们要是处理多个客户端的话，服务端可以自己手写，也可以使用线程池。此处手写代码，不是用线程池。

/**
 * @author :huyiju
 * @date :8/30/21 4:16 PM
 * 服务端代码
 * 实现多对多
 * 线程的1对1
 * 缺点客户端有多少请求，服务端就会有多少线程的响应
 * 通信密集的时候 线程太多会崩的
 */
public class ServiceDuo {
    public static void main(String[] args) {

        try {
            System.out.println("多个服务端启动");
            //补充：端口范围0-65535，0-1023为系统占用端口
            //服务端指定端口

            //1:建立连接,接受多个客户端信息。
            ServerSocket serverSocket = new ServerSocket(9998);
            //2:监听客户端,多个客户端就有多个服务端
            while (true){
                Socket socket = serverSocket.accept();
                new ScoketThreadRun(socket).start();//多线程传递scoket
            }


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


    }
}

class ScoketThreadRun extends Thread {

    Socket socket;
    public ScoketThreadRun(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        //3:获取IO流
        InputStream inputStream = null;
        try {
            inputStream = socket.getInputStream();
            byte[] bytes = new byte[1024];
            int a;
            //4：输出数据
            while ((a = inputStream.read(bytes)) != -1) {
                String string = new String(bytes, 0, a, "UTF-8");
                System.out.println("服务端获取信息：" + string);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


=====================以下是客户端代码===================


/**
 * @author :huyiju
 * @date :8/30/21 4:12 PM
 * 客户端代码 发送数据
 */
public class BIO2 {
    public static void main(String[] args) throws IOException {
        System.out.println("客户端多发启动13");
        String host = "127.0.0.1";
        int port = 9998;

        Socket socket = new Socket(host, port);
        OutputStream outputStream = socket.getOutputStream();
        Scanner scanner=new Scanner(System.in);
        
        while (true){
            System.out.print("请说：");
            String msg=scanner.nextLine();
            outputStream.write(msg.getBytes("UTF-8"));
            outputStream.flush();//此处刷新流 便于下次重新写数据
            //socket.close();//不要关闭 模拟多次请求
        }
    }
}

结果展示可以看到服务端通过Socket socket = serverSocket.accept();创建多个socket,然后交给不同的线程处理。

 

3：什么是NIO（New IO-非阻塞IO）

NIO:同步非阻塞IO

同步：客户端跟服务器经过TCP链接后。客户端发数据后服务端立马能接受数据。

阻塞：多个个客户端线程都会对应1个服务端选择器（selector）。客户端可以有很多通过缓冲区（buffer）发送数据到通道（channel）。说人话就是客户端不管多少个线程，数据都是先用缓冲区封装，通过指定的通道发送到选择器。如果选择器看到有数据，才会创建服务端线程处理数据。没有数据线程不阻塞，只要一个人看着就行。这个人就是选择器。有数据的时候。选择器摇人。

Java NIO 由以下几个核心部分组成：

Channels（客户端通过通道给服务器传递数据，相当于高速公路）

Buffers（缓冲区是货车，负责按容量运送数据）

Selectors（收费站，看看那个高速公路的有货车发送数据，就指定线程处理数据）

结构如下

3.1：Buffers（缓冲区）

作用：相当于货车按照指定的容量装数据，并且能够读取数据。

以下是Java NIO里关键的Buffer实现：

ByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer

这些Buffer覆盖了你能通过IO发送的基本数据类型：byte, short, int, long, float, double 和 char。

代码案例：

public class Buffer1 {
    @Test
    public  void ByteBUffer1(){
        //1:创建缓冲区byte 长度是10
        ByteBuffer byteBuffered=ByteBuffer.allocate(10);

        System.out.println(byteBuffered.put("123456".getBytes()));
        System.out.println(byteBuffered.put("b".getBytes()));
        System.out.println(byteBuffered.put("a".getBytes()));

        System.out.println("position位置："+byteBuffered.position());//随着读取数据 数据下标
        System.out.println("界限："+byteBuffered.limit());//数据实际长度不变  position<=limit<=capacity
        System.out.println("容量："+byteBuffered.capacity());
        System.out.println("没有flip获取第一个数据会乱码："+(char) byteBuffered.get());

        System.out.println("----------------flip让数据可读------------------------");
        byteBuffered.flip();
        System.out.println("位置："+byteBuffered.position());
        System.out.println("界限："+byteBuffered.limit());
        System.out.println("容量："+byteBuffered.capacity());
        System.out.println("flip获取第一个数据："+(char) byteBuffered.get());
        System.out.println("flip获取第一个数据："+(char) byteBuffered.get());
        System.out.println("flip获取第一个数据："+(char) byteBuffered.get());
        System.out.println("position位置："+byteBuffered.position());//随着读取数据 数据下标
        System.out.println("界限："+byteBuffered.limit());//数据实际长度不变  position<=limit<=capacity
        System.out.println("容量："+byteBuffered.capacity());


        System.out.println("---------------清除数据-----------------");
        System.out.println(byteBuffered.clear());
        System.out.println(byteBuffered.put("jj".getBytes()));

        System.out.println(byteBuffered.position());//2
        System.out.println(byteBuffered.limit());//10
        System.out.println(byteBuffered.capacity());//10
        byteBuffered.flip();
        System.out.println("位置："+byteBuffered.position());//0
        System.out.println("界限："+byteBuffered.limit());//2
        System.out.println("容量："+byteBuffered.capacity());//10

    }


    @Test
    public  void ByteBUffer2(){
        //1:创建缓冲区byte 长度是10
        ByteBuffer byteBuffered=ByteBuffer.allocate(10);

        System.out.println(byteBuffered.isDirect());

        ByteBuffer byteBuffered1=ByteBuffer.allocateDirect(10);

        System.out.println(byteBuffered1.isDirect());

    }
}

3.2：Channels（通道）

作用：将数据放到channel。然后通过buffer运送数据。

Channel和Buffer有好几种类型。下面是JAVA NIO中的一些主要Channel的实现：

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel

代码案例

/**
 * @author :huyiju
 * @date :8/30/21 9:38 PM
 * 通过channel
 * 读文件 写文件 等操作
 */
public class Channel1 {
    public static void main(String[] args) {

    }

    /**
     * 用文件缓冲区把数据写入文件
     */
    @Test
    public void write() {
        try {
            int size = 2;
            //1:输出流 写入文件
            FileOutputStream outputStream = new FileOutputStream("/Users/huyiju/Desktop/log/huyiju.txt");
            //2:字节流得到通道
            FileChannel channel = outputStream.getChannel();
            //3:分配缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(size);
            //4:讲述数据写入缓冲区
            String msg = "1234567890";
            byte[] b = msg.getBytes();

            int num = 0;

            System.out.println("数据长度" + b.length + "  缓冲区长度：" + size);
            if (b.length < size) {

                byteBuffer.put(b);
                byteBuffer.flip();
                //将数据写入缓冲区
                channel.write(byteBuffer);
                System.out.println("写入结束1");

            } else {
                while (num < b.length) {
                    System.out.println("起始位置" + num + "  数据长度：" + size);
                    byteBuffer.clear();

                    if (b.length-num<size){
                        byteBuffer.put(b, num, (b.length-num));
                        byteBuffer.flip();
                        //将数据写入缓冲区
                        channel.write(byteBuffer);
                        System.out.println("写入结束22");
                        break;
                    }else {
                        byteBuffer.put(b, num, size);
                        num = num + 2;
                        byteBuffer.flip();
                        //将数据写入缓冲区
                        channel.write(byteBuffer);
                        System.out.println("写入结束2");
                    }

                }
            }
            channel.close();


            //System.out.println(byteBuffer.put("hello word".getBytes()));

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

    }


    /**
     * 从文件读取数据
     */
    @Test
    public void read() {
        try {
            //1:输出流 写入文件
            FileInputStream fileInputStream = new FileInputStream("/Users/huyiju/Desktop/log/huyiju.txt");
            //2:字节流得到通道
            FileChannel channel = fileInputStream.getChannel();
            //3:分配缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(8);
            //4:讲述数据写入缓冲区

            //将数据写入缓冲区
            while (true) {
                byteBuffer.clear();//先清空缓冲区

                int flag = channel.read(byteBuffer);
                if (flag == -1) {
                    break;
                }
                byteBuffer.flip();
                String string = new String(byteBuffer.array(), 0, byteBuffer.limit());
                System.out.println(string);
            }

            channel.close();
            System.out.println("读取结束");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }


    /**
     * 从文件读取数据 然后写入文件
     */
    @Test
    public void readAndWrite() {
        try {
            //1:输出流 写入文件
            FileInputStream fileInputStream = new FileInputStream("/Users/huyiju/Desktop/log/huyiju.txt");
            FileOutputStream fileOutputStream = new FileOutputStream("/Users/huyiju/Desktop/log/huyiju_new.txt");

            //2:字节输入数据流得到不同的通道
            FileChannel channelin = fileInputStream.getChannel();
            FileChannel channelout = fileOutputStream.getChannel();

            //3:分配缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(4);
            //4:讲述数据写入缓冲区


            //将数据写入缓冲区
            while (true) {
                byteBuffer.clear();//先清空缓冲区

                int flag = channelin.read(byteBuffer);//数据量大 按照缓冲区读 然后写
                if (flag == -1) {
                    break;
                }
                byteBuffer.flip();
                channelout.write(byteBuffer);
            }


            channelin.close();
            channelout.close();
            System.out.println("先读数据 在写数据");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }


    /**
     * 从文件读取数据 然后写入文件
     */
    @Test
    public void transTo() {
        try {
            //1:原通道
            FileInputStream fileInputStream = new FileInputStream("/Users/huyiju/Desktop/log/huyiju.txt");
            FileChannel fileChannelIn = fileInputStream.getChannel();

            //2:复制通道
            FileOutputStream fileOutputStream = new FileOutputStream("/Users/huyiju/Desktop/log/huyiju_new1.txt");
            FileChannel fileChannelOut = fileOutputStream.getChannel();


            //3:复制通道
            FileOutputStream fileOutputStream2 = new FileOutputStream("/Users/huyiju/Desktop/log/huyiju_new2.txt");
            FileChannel fileChannelOut2 = fileOutputStream2.getChannel();


            //3:复制数据 transferFrom（来源通道）
            //fileChannelOut.transferFrom(fileChannelIn,fileChannelIn.position(),fileChannelIn.size());

            //3.1:复制数据 transferTo（来源通道，目标通道）
            fileChannelIn.transferTo(fileChannelIn.position(), fileChannelIn.size(), fileChannelOut2);

            fileChannelIn.close();
            fileChannelOut.close();
            fileChannelOut2.close();
            System.out.println("复制数据");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }


}

3.3：Selector(选择器)

作用：Selector可以根据不同的事件选择不同的选择器，要使用selector必须将channel注册到选择器上。采用多路复用。

此处代码采用，bytebuffer（缓冲区）、ServerSocketChannel（网络通道）、Selector实现网络通信。

此处代码采用多个客户端启动，服务端一个，然后查看运行结果

/**
 * @date :8/31/21 12:09 AM
 * NIO 非阻塞通信 服务端开发
 * 可以应对多客户端，非阻塞模式
 */
public class ServiceHu {
    public static void main(String[] args) throws IOException {
        //1:获取服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        //2:切换非阻塞模式
        serverSocketChannel.configureBlocking(false);
        //3:绑定端口
        serverSocketChannel.bind(new InetSocketAddress(9997));

        //4:获取选择器
        Selector selector = Selector.open();

        //5:将服务端通道注册到选择器

        //OP_READ = 1 << 0; 读
        //OP_WRITE = 1 << 2; 写
        //OP_CONNECT = 1 << 3;链接
        //OP_ACCEPT = 1 << 4; 接收
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("1:服务端启动");

        //6:使用selector 轮循环事件>0
        while (selector.select() > 0) {
            System.out.println("2:客户端启动会进入选择器");
            //迭代所有的事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                System.out.println("进入迭代事件");
                //7:提取当期事件
                SelectionKey selectionKey = iterator.next();
                //8:判断事件是否是接收事件
                if (selectionKey.isAcceptable()) {
                    System.out.println("3:客户端启动会进入接受事件");
                    //9：获取客户端通道
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    //10：将客户端注入选择器 读事件
                    socketChannel.register(selector, SelectionKey.OP_READ);

                } else if (selectionKey.isReadable()) {
                    System.out.println("4:进入可读事件");

                    //11:如果是读事件 获取客户端通道
                    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                    //12：读取数据
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    int len;
                    while ((len = socketChannel.read(byteBuffer)) > 0) {
                        byteBuffer.flip();
                        System.out.println("服务端获取数据输出：" + new String(byteBuffer.array(), 0, len));
                        byteBuffer.clear();
                    }


                } else if (selectionKey.isWritable()) {

                }
                iterator.remove();//处理完毕 移除当前事件
            }

        }


    }
}


======================以下是客户端代码==================

/**
 * @date :8/30/21 11:56 PM
 * 客户端发送数据
 */
public class Client1 {
    public static void main(String[] args) throws IOException {
        //1：获取客户端通道
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",9997));
        //2：设置通道是否堵塞false 非阻塞
        socketChannel.configureBlocking(false);
        //3：设置缓冲区容量
        ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
        //4：得到输入
        Scanner scanner=new Scanner(System.in);
        //5：循环
        while (true){
            System.out.println("输入要发送数据");
            String msg=scanner.nextLine();

            byteBuffer.put(msg.getBytes());
            byteBuffer.flip();//通道可读

            socketChannel.write(byteBuffer);

            byteBuffer.clear();//重置缓冲区

        }


    }

}

运行结果省略

浅水壁虎
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础-->IO流
wenxiaohua1994的专栏
10-07 480
概述： 1、IO流：即Input Output的缩写。 2、特点： 1）IO流用来处理设备间的数据传输。 2）Java对数据的操作是通过流的方式。 3）Java用于操作流的对象都在IO包中。 4）流按操作数据分为两种：字节流和字符流。 5）流按流向分为：输入流和输出流。 注意：流只能操作数据，而不能操作文件。 3、IO流的常用基类： 1）
Java_IO:你不知道的那些Java网络IO（BIO、NIO、AIO）
05-18
本文将深入探讨Java中的三种网络IO模型：同步阻塞IO（BIO）、同步非阻塞IO（NIO）和异步非阻塞IO（AIO），以及它们在实际应用中的差异和应用场景。 1. **同步阻塞IO（BIO）** BIO是Java最初提供的IO模型，它基于...
详解Java中的BIO、NIO、AIO
Java鱼仔的博客
06-16 4080
IO流是Java中比较难理解的一个知识点，但是IO流在实际的开发场景中经常会使用到，比如Dubbo底层就是NIO进行通讯
Java中三种I/O模型 BIO,NIO,AIO
weixin_47414034的博客
12-07 518
UNIX 系统下， IO 模型一共有 5 种： 同步阻塞 I/O、同步非阻塞 I/O、I/O 多路复用、信号驱动 I/O 和异步 I/O。这也是我们经常提到的 5 种 IO 模型（1）同步阻塞I/O模型 应用程序发起read调用后，一直处于阻塞状态内核开始准备数据，直到把数据拷贝到应用程序，应用程序才被唤醒（2）同步非阻塞 IO 模型 应用程序会一直发起 read 调用，避免了一直阻塞直到数据就绪了，应用程序再次发起调用的时候，应用程序才进入阻塞状态，当数据拷贝完成，应用程序才被唤醒相比于同步阻塞 IO
Java网络编程IO模型 --- BIO、NIO、AIO详解
2301_82242988的博客
04-29 665
金三银四马上就到了，希望大家能好好学习一下这些技术点学习视频：大厂面试真题：金三银四马上就到了，希望大家能好好学习一下这些技术点学习视频：[外链图片转存中…(img-3ST7KdL7-1714389491204)]大厂面试真题：[外链图片转存中…(img-wIJZpwVt-1714389491205)]本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录。
Java中的三种I/O模型：BIO、NIO和AIO
搬砖农民工的博客
10-30 636
Java提供了三种不同的I/O模型：AIO、BIO和NIO。以及tomcat和netty使用的是什么IO模型
Java中IO流类的体系中BIO与NIO
赵广陆
02-15 1274
目录 1 BIO同步阻塞IO 2 NIO同步非阻塞IO 3 select机制 3.1 poll机制　 3.2 epoll机制　 4 Java中的IO模型 4.1 BIO模型 4.2 NIO模型 4.3 AIO模型 1 BIO同步阻塞IO 1.1 特性：同步阻塞IO 1.2 特点：一个请求对应一个线程，上下文切换占用的资源很重。 1.3 缺点：无用的请求也会占用一个线程，没有数据达到，也会阻塞。 1.4 改进：通过线程池机制。 但是还是未能解决一个请求一个线程的本质问题，只
一文彻底理解Java中IO的BIO、NIO、AIO
最新发布
05-23
在Java的发展历程中，IO模型经历了三个主要阶段：BIO（Blocking IO）、NIO（Non-blocking IO）和AIO（Asynchronous IO），这三种模型各自有其特性和适用场景，下面将详细解析它们的工作原理和区别。 **1. BIO（阻塞...
Java使用BIO和NIO进行文件操作对比代码示例
08-19
Java BIO和NIO是两种不同的输入/输出（IO）模型，在文件操作中发挥着重要作用。BIO（Blocking I/O）是一种同步阻塞IO模式，而NIO（Non-Blocking I/O）是一种同步非阻塞IO模式。下面我们将详细介绍Java使用BIO和NIO...
Java 中IO流分为哪几种？ BIO、NIO、AIO有什么区别？
01-07
Java中的流分为两种，一种是字节流，另一种是字符流，分别由四个抽象类来表示（每种流包括输入和输出两种所以一共四个）:InputStream，OutputStream，Reader，Writer。Java中其他多种多样变化的流均是由它们派生出来...
《初入JavaIO之门BIO、NIO、AIO实战练习》源码
10-11
netty案例，netty4.1基础入门篇零《初入JavaIO之门BIO、NIO、AIO实战练习》 https://mp.weixin.qq.com/s?__biz=MzIxMDAwMDAxMw==&mid=2650724988&idx=1&sn=99a4f3677d2c5a9499cb06eba2cd37fe&scene=19#wechat_redirect
java的IO模式(BIO,NIO,AIO).emmx
07-18
使用mindmaster打开
Java-----IO流（BIO）
chenyun1997的博客
08-19 142
一、IO的定义 我们经常会操作磁盘上的资源，这个过程中实现了数据的输入和输出操作，磁盘上的文件和内存进行交互，数据的 交互需要有一个媒介或者管道，我们把这个媒介或者管道就称之为IO流，或者输入、输出流。 输入：从外部设备到内存称为输入（读数据）； ...
Java IO 模型之 BIO、NIO、AIO 详解
流华追梦的专栏
12-15 1373
在 Java 编程中，IO（Input/Output）操作是非常常见的操作，它涉及到文件读写、网络通信等方面。Java 提供了各种类来支持这些操作。本文将从 IO 的基础知识讲起，逐步深入，介绍 Java IO 的各个方面。Java IO（Input/Output）是 Java 语言中用于读写数据的 API，它提供了一系列类和接口，用于读取和写入各种类型的数据。
【无标题】
flightfish的博客
07-04 267
I/O 模型简单理解为：就是使用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能。Java 支持 3 种网络编程模型：BIO、NIO、AIO。Java BIO：（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不作任何事情会造成不必要的线程开销。Java NIO：，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求会被注册到多路复用器上，多路复用器轮询到有 I/O 请求就会进行处理。Java AIO：，AI
Java中处理I/O操作的不同方式：BIO，NIO，AIO
IT小辉同学
02-07 1230
总的来说，BIO适用于连接数较少且连接时间较长的场景，NIO适用于连接数较多但每个连接的交互时间短的场景，而AIO适用于连接数较多且每个连接的交互时间不确定的场景。在非阻塞I/O中，一个线程可以管理多个通道，通过选择器监视这些通道的状态，当一个通道可读或可写时，线程可以切换到其他任务，而不需要等待I/O操作完成。BIO、NIO和AIO是Java中处理I/O操作的三种不同方式，它们分别代表阻塞I/O、非阻塞I/O和异步I/O。在阻塞I/O中，当一个线程在进行I/O操作时，它会被阻塞，直到操作完成。
Java基础-IO流（BIO）
qq_44007780的博客
06-07 211
文件 什么是文件？ 文件可认为是相关记录或放在一起的数据集合 文件一般存储在哪里？ 机械硬盘，固态硬盘，光盘，软盘等 Java程序如何访问文件属性 从磁盘中读取文件是以页为单位的，单位大小是可能4kb，也可能是4kb的N倍，电脑配置不一样大小不一样，但是都是以页为单位的，并不是说你想读取多大字节就读多大的字节，这样效率太低了。 磁盘预读（预读的长度一般为页（page）的整数倍）：页是存储器的逻辑块，操作系统往往将主存和磁盘存储区分割为连续的大小相等的块，每个存储块称为一页（在许多操作系统中，一页的
网络I/O 模型
weixin_44582492的博客
07-24 300
一：I/O 模型简单的理解 io模型就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能
Java网络面试必备：BIO、NIO、AIO与Netty详解
Java网络通信面试中，常常会涉及到BIO（Blocking I/O）、NIO（Non-blocking I/O）、AIO（Asynchronous I/O）以及Netty这几个概念。它们是Java中处理网络通信的不同方式，理解它们有助于提升网络编程的效率和性能。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值