三、Java NIO编程

已于 2024-05-06 08:00:40 修改
阅读量333 收藏
点赞数
分类专栏： Netty 文章标签： nio
于 2023-08-03 22:37:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hc1285653662/article/details/132012597
版权

目录

3.1 Java NIO基本介绍

在这里插入图片描述

3.2 BIO 和 NIO的比较

  • bio以流的方式处理数据，而NIO以块的方式处理数据，块IO的效率比流IO高很多
  • BIO是阻塞的，NIO是非阻塞的
  • 对于BIO，服务器中的一个线程对应一个client；对于NIO，服务器中的一个线程对应多个客户端

3.3 NIO三大核心 selector、channel、buffer之间的关系

一张图描述 NIO 的 Selector 、 Channel 和 Buffer 的关系：
在这里插入图片描述
在这里插入图片描述

3.4 缓冲区（Buffer）

1 基本介绍

Buffer（缓冲区）： 缓冲区本质上是一个可以读写数据的内存块，可以理解成一个容器，该容器提供了一组方法，可以更轻松的使用内存块。缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变换。

Channel提供从文件、网络读取数据的渠道，但是读取或者写入的数据都必须经过Buffer
在这里插入图片描述

2 Buffer类及其子类

在nio中，Buffer是一个顶层父类，他是一个抽象类，类的层级关系如下：
在这里插入图片描述

buffer类中定义了四个属性来表示其包含的数据元素的信息
在这里插入图片描述

3.5 通道

0、 channel基本介绍

  • NIO的通道类似于流，但又有些区别

    • 通道可以同时进行读写，而流只能读或者写
    • 通道可以从缓冲读数据，也可以写数据到缓冲

  • Channel 是 NIO中的一个接口 public interface Channel extends Closeable 、

  • 常用的channel类有：FileChannel，DatagramChannel，ServerSocketChannel，SocketChannel。【FileChannel用于文件数据的读写，DatagramChannel用于UDP数据的读写，ServerScoketChannel SocketChannel用于TCP数据的读写】

1 FileChannel 类

FileChannel 主要是用来对本地文件进行IO操作，常见的方法有：
在这里插入图片描述

2 应用实例1 - 本地文件写数据

【实例要求】
1、使用前面学习的ByteBuffer，FileChannel 将“hello，尚硅谷” 写入到file01.txt中
2、文件不存在则创建文件

在这里插入图片描述

public class NIOFileChannel01 {
    public static void main(String[] args) throws IOException {
        String str= "hello,尚硅谷";
        FileOutputStream fileOutputStream = new FileOutputStream("E://file01.txt");
        // channel的真是类型是 FileChannelImpl
        FileChannel channel = fileOutputStream.getChannel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        // 将str扔到byteBuffer中
        byteBuffer.put(str.getBytes());
        // 对 byteBuffer 进行反转
        byteBuffer.flip();
        // 对于channel 来说是将 buffer中的数据写入到channel中
        channel.write(byteBuffer);
        // 关闭流
        fileOutputStream.close();
    }
}

3 应用实例2 - 本地文件读数据

使用前面学习到的ByteBuffer（缓冲）和 FileChannel（通道），将file01.txt中的数据读入到程序中，并显示在控制台上
在这里插入图片描述

public class NIOFileChannel02 {
    public static void main(String[] args) throws IOException {
        File file = new File("E://file01.txt");
        FileInputStream fileInputStream = new FileInputStream(file);
        // channel的真是类型是 FileChannelImpl
        FileChannel channel = fileInputStream.getChannel();
        ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());
        channel.read(byteBuffer);
        System.out.println(new String(byteBuffer.array()));
        // 关闭流
        fileInputStream.close();
    }
}

3.5.4 应用实例3 - 使用一个buffer完成文件的读取写入

在这里插入图片描述

public class NIOFileChannel03 {

    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("1.txt");
        FileChannel fileChannel01 = fileInputStream.getChannel();

        FileOutputStream fileOutputStream = new FileOutputStream("2.txt");
        FileChannel fileChannel02 = fileOutputStream.getChannel();

        ByteBuffer byteBuffer = ByteBuffer.allocate(512);

        while (true) { //循环读取

            //这里有一个重要的操作，一定不要忘了
            /*
             public final Buffer clear() {
                position = 0;
                limit = capacity;
                mark = -1;
                return this;
            }
             */
            byteBuffer.clear(); //清空buffer
            int read = fileChannel01.read(byteBuffer);
            System.out.println("read =" + read);
            if(read == -1) { //表示读完
                break;
            }
            //将buffer 中的数据写入到 fileChannel02 -- 2.txt
            byteBuffer.flip();
            fileChannel02.write(byteBuffer);
        }

        //关闭相关的流
        fileInputStream.close();
        fileOutputStream.close();
    }
}

3.5.5 应用实例4 - 拷贝文件 transferFrom方法

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

        //创建相关流
        FileInputStream fileInputStream = new FileInputStream("d:\\a.jpg");
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\a2.jpg");

        //获取各个流对应的filechannel
        FileChannel sourceCh = fileInputStream.getChannel();
        FileChannel destCh = fileOutputStream.getChannel();

        //使用transferForm完成拷贝
        destCh.transferFrom(sourceCh,0,sourceCh.size());
        //关闭相关通道和流
        sourceCh.close();
        destCh.close();
        fileInputStream.close();
        fileOutputStream.close();
    }
}

3.5.6 Buffer和Channel的注意事项和细节

1）ByteBuffer支持类型化的put和get，put放入的是什么数据类型，get就需要使用相应的数据类型来取出，否则就可能有 BufferUnderflowException 异常
2）可以将一个普通Buffer转换成只读Buffer

//得到一个只读的Buffer
ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();

在这里插入图片描述
3）NIO还提供了MapperedByteBuffer，可以让文件直接在内存中（堆外的内存）进行修改，而如何同步到文件由NIO来完成

4）前面我们讲的读写操作，都是通过一个Buffer完成的，NIO还支持通过多个Buffer（即Buffer数组）来完成读写操作，即Scattering 和 Gathering 【分散和聚合】

3.6 Selector（选择器）

3.6.1 Selector 基本介绍

1）Java的NIO，用的非阻塞的IO方式。可以用一个线程来处理多个客户端的连接，此时就会用到Selector选择器
2）多个Channel以事件的方式注册到同一个Selector，Selector可以检测到多个注册的channel上是否有事件发生， 如如果有事件发生，便去获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道。
3）只有在连接真正有读写事件发生时，才会进行读写，大大减少了系统的开销。并且不会为每一个连接都创建一个线程，不用去维护多个线程
4）避免了多线程之间的上下文切换导致的开销

【总结】多个Channel以事件的方式注册到同一个Selector，Selector可以检测到多个注册的channel上是否有事件发生
在这里插入图片描述

3.6.2 Selector的特点

在这里插入图片描述


3.6.3 Selector的常用方法

在这里插入图片描述


3.7 NIO 非阻塞编程原理分析

Selector，SelectionKey，ServerSocketChannel，SocketChannel之间的关系
在这里插入图片描述

  • 服务器ServerSocketChannel注册到selector
  • Selector进行监听，select()方法返回有事件发生的通道的个数
  • 当客户端连接时，Selector会监听到，通过ServerSocketChannel得到SocketChannel
  • 将SocketChannel注册到selector，并监听read事件,一个selector上可以注册多个Socketchannel
  • 当有read事件发生时，通过selector获取 SelectionKey，通过SelectionKey反向获取到channel，接收传来的message

3.8 NIO非阻塞网络编程demo

【案例要求】
编写一个NIO入门程序，实现服务器和客户端之间的数据简单通讯（非阻塞）

代码

public class NIOServer {
    public static void main(String[] args) throws IOException {

        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 绑定一个端口，在服务器端进行监听
        serverSocketChannel.socket().bind(new InetSocketAddress(6666));
        // 设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        Selector selector = Selector.open();
        // serverSocketChannel 注册到selector, 关心事件为 OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 循环等待客户端进行连接
        while (true) {
            if (selector.select(1000) == 0) {
               // System.out.println("服务器端等待了一秒，无连接");
                continue;
            }
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                // selector监听到 OP_ACCEPT事件，表示有新的客户端连接
                if (key.isAcceptable()) {
                    System.out.println("监听到客户端的注册事件，将客户端注册到server =======> ");
                    // 给该客户端生成一个socketChannel
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    // 将socketChannel设置成非阻塞
                    socketChannel.configureBlocking(false);
                    // 将SocketChannel注册到selector,关注事件设置为 op_read
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                } else if (key.isReadable()) {
                    // 通过key反向获取到channel
                    SocketChannel channel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = (ByteBuffer) key.attachment();
                    channel.read(byteBuffer);
                    System.out.println("收到客户端传递过来的消息：" + new String(byteBuffer.array()));
                }
                iterator.remove();
            }
        }
    }
}

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

        //得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //提供服务器端的ip 和 端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
        //连接服务器
        if (!socketChannel.connect(inetSocketAddress)) {

            while (!socketChannel.finishConnect()) {
                System.out.println("因为连接需要时间，客户端不会阻塞，可以做其它工作..");
            }
        }

        while (true) {
            //...如果连接成功，就发送数据
            Scanner scanner = new Scanner(System.in);
            String in = scanner.nextLine();
            //Wraps a byte array into a buffer
            ByteBuffer buffer = ByteBuffer.wrap(in.getBytes());
            //发送数据，将 buffer 数据写入 channel
            socketChannel.write(buffer);
        }
    }
}

3.9 SelectionKey

1、SelectionKey 表示 Selector和网络通道之间的注册关系
在这里插入图片描述
selector.selectedKeys()： 表示当前有哪些注册到selector的通道发生了事件
selector.keys() ： 表示当前有注册到selector的所有通道

2、SelectionKey 的相关方法
在这里插入图片描述

3.10 ServerSocketChannel 和 SocketChannel的相关api

1、ServerSocketChannel 在服务器端监听先的客户端 Socket连接

在这里插入图片描述

2、SocketChannel

网络IO通道，具体负责进行读写操作。NIO将buffer中的内容写入channel，或者将channel中的内容读到buffer
在这里插入图片描述

3.11 简单群聊系统的实现

package com.atgui.nio.qunliao;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

public class GroupChatServer {


    private Selector selector;
    private ServerSocketChannel listenChannel;

    private static final int PORT = 6667;


    public GroupChatServer() {
        try {
            selector = Selector.open();
            listenChannel = ServerSocketChannel.open();
            listenChannel.socket().bind(new InetSocketAddress(PORT));
            listenChannel.configureBlocking(false);
            listenChannel.register(selector, SelectionKey.OP_ACCEPT);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void listen() {
        try {
            // chat服务器线程一直循环进行监听
            while (true) {
                int count = selector.select(2000);
                if (count > 0) {
                    // 取出当前有事件的集合
                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                    while (iterator.hasNext()) {
                        SelectionKey key = iterator.next();
                        // 监听到有客户端进行连接
                        if (key.isAcceptable()) {
                            SocketChannel socketChannel = listenChannel.accept();
                            socketChannel.configureBlocking(false);
                            // 将 socketChannel 也注册到 selector上
                            socketChannel.register(selector, SelectionKey.OP_READ);
                            System.out.println(socketChannel.getRemoteAddress() + "上线");
                        }
                        // 发生了事件的通道是可读的状态
                        if (key.isReadable()) {
                            readData(key);
                        }
                        // 把当前的SelectionKey删除
                        iterator.remove();
                    }
                } else {
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

        }
    }

    //
    private void readData(SelectionKey key) {
        SocketChannel channel = null;
        try {
            // 由 SelectionKey 反向得到 channel
            channel = (SocketChannel) key.channel();
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            // 返回读取到的长度
            int count = channel.read(byteBuffer);
            if (count > 0) {
                String message = new String(byteBuffer.array());
                System.out.println("from 客户端： " + message);
                // 向其他客户端转发消息
                broadMessage(message, channel);
            }
        } catch (IOException e) {
            try {
                System.out.println(channel.getRemoteAddress() + "离线");
                // 用户离线了，取消注册、关闭通道
                key.cancel();
                channel.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    // 转发消息给所有通道，【注意】去掉自己
    private void broadMessage(String message, SocketChannel self) throws IOException {
        System.out.println("服务器开始转发消息");
        // 获取所有注册到selector的 SocketChannel，并排除自己
        for (SelectionKey key : selector.keys()) {
            SelectableChannel targetChannel = key.channel();
            if (targetChannel instanceof SocketChannel && targetChannel != self) {
                ByteBuffer byteBuffer = ByteBuffer.wrap(message.getBytes());
                ((SocketChannel) targetChannel).write(byteBuffer);
            }
        }
    }

    public static void main(String[] args) {
        //创建服务器对象
        GroupChatServer groupChatServer = new GroupChatServer();
        groupChatServer.listen();
    }

}


package com.atgui.nio.qunliao;

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.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

public class GroupChatClient {

    //定义相关的属性
    private final String HOST = "127.0.0.1"; // 服务器的ip
    private final int PORT = 6667; //服务器端口
    private Selector selector;
    private SocketChannel socketChannel;
    private String username;

    //构造器, 完成初始化工作
    public GroupChatClient() throws IOException {

        selector = Selector.open();
        //连接服务器
        socketChannel = socketChannel.open(new InetSocketAddress("127.0.0.1", PORT));
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //将channel 注册到selector
        socketChannel.register(selector, SelectionKey.OP_READ);
        //得到username
        username = socketChannel.getLocalAddress().toString().substring(1);
        System.out.println(username + " is ok...");

    }

    //向服务器发送消息
    public void sendInfo(String info) {

        info = username + " 说：" + info;

        try {
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
        }catch (IOException e) {
            e.printStackTrace();
        }
    }

    //读取从服务器端回复的消息
    public void readInfo() {

        try {

            int readChannels = selector.select();
            if(readChannels > 0) {//有可以用的通道

                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {

                    SelectionKey key = iterator.next();
                    if(key.isReadable()) {
                        //得到相关的通道
                       SocketChannel sc = (SocketChannel) key.channel();
                       //得到一个Buffer
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        //读取
                        sc.read(buffer);
                        //把读到的缓冲区的数据转成字符串
                        String msg = new String(buffer.array());
                        System.out.println(msg.trim());
                    }
                }
                iterator.remove(); //删除当前的selectionKey, 防止重复操作
            } else {
                //System.out.println("没有可以用的通道...");

            }

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

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

        //启动我们客户端
        GroupChatClient chatClient = new GroupChatClient();

        //启动一个线程, 每个3秒，读取从服务器发送数据
        new Thread() {
            public void run() {

                while (true) {
                    chatClient.readInfo();
                    try {
                        Thread.currentThread().sleep(1000);
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        //发送数据给服务器端
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            chatClient.sendInfo(s);
        }
    }


}

3.12 零拷贝

  • mmap：通过内存映射，将文件映射到内核缓冲区，同时，用户空间可以共享内核空间的数据。这样，在进行网络传输时就可以减少内核空间搭到用户空间的拷贝次数

  • sendFile 优化
    在这里插入图片描述

坚持每天学习一点
关注
专栏目录
Java NIO 网络编程初探
12-22
Java NIO 网络编程初探 1. Java NIO Java 1.4 版本添加了一个新的IO API，称为NIO（New IO）。NIO拥有所有IO的功能，但是操作方法却完全不一样。NIO支持面向缓冲区的、基于通道的IO操作。能够更加高效的进行IO操作。...
Java NIO英文高清原版
11-15
Java NIO，全称为Non-Blocking Input/Output（非阻塞输入/输出），是Java平台中用于替代标准I/O（BIO）模型的一种新机制。...学习和理解Java NIO以及Netty的使用，对于提升Java网络编程的能力至关重要。
java之NIO编程
敲代码的小小酥的博客
12-03 1560
java NIO详解
Java网络编程——NIO编程
weixin_62017112的博客
07-16 1979
JavaNIO全称javanon-blockingIO，是指JDK提供的新API。从JDK1.4开始，Java提供了一系列改进的输入/输出的新特性，被统称为NIO(即NewIO)，是同步非阻塞的.缓冲区（Buffer）缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个数组，该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel提供从网络读取数据的渠道，但是读取或写入的数据都必须经由Buffer.......
NIO编程
swadian2008的博客
06-02 1326
NIO（New I/O）是Java中一种提供了非阻塞式I/O操作的编程模型。它引入了一组新的Java类，用于取代传统的Java I/O类（如InputStream和OutputStream），以提供更高效、更灵活的I/O操作。// 部分NIO API实际上是阻塞的，例如File APIJava NIO允许执行非阻塞的IO。例如，线程可以请求通道将数据读入缓冲区。当通道将数据读入缓冲区时，线程可以做其他事情。一旦数据被读入缓冲区，线程就可以继续处理它。将数据写入通道也是如此。
Java NIO编程实例
qq_45596525的博客
11-03 925
文章目录前言一、NIO与BIO的比较二、Buffer的机制及其子类1.Buffer的使用2.Buffer的四个基本类型三、Channel的使用1. Channel的特征2. Channel的子类(1) FileChannel实例:(2) 拷贝文件四、Buffer类型化和只读1. 类型化2. Buffer的分散和聚合五、MappedByteBuffer六、Selector1. SelectionKey在NIO体系中的作用七、NIO非阻塞网络编程的快速入门服务器端客户端 前言 基于NIO的网络编程实例 提
Java中的NIO编程详解
微赚淘客开发者博客
07-03 404
NIO（New I/O）是Java提供的一种非阻塞的IO（输入输出）操作方式，引入了Channel、Buffer和Selector等新概念，相较于传统的IO操作更为高效和灵活。传统的IO模型是阻塞式的，每个连接都需要独立的线程来处理，而NIO模型使用单线程管理多个连接，通过Selector实现了非阻塞IO，提升了系统的性能和吞吐量。通过NIO可以实现高效的事件驱动的网络编程。Selector是NIO编程的核心组件之一，它提供了一种可以检测多个通道上事件的机制，从而使一个单独的线程可以管理多个通道。
Java网络编程系列之NIO
lesliewongjie
04-24 1385
Java网络编程系列之NIO1.Java NIO概述1.1 阻塞IO1.2 非阻塞IO1.3 NIO概述1.3.1 Channels1.3.2 Buffer1.3.3 Selector2.Java NIO(Channel)2.1Channel概述2.2 Channel实现2.3 FileChannel 介绍与示例2.4 FileChannel 操作详解2.4.1 打开FileChannel2.4.2 从FileChannel读取数据2.4.3 向FileChannel写数据2.4.4 关闭FileChan
Java NIO 快速入门：Java 非阻塞 IO 编程详解
m0_64516972的博客
07-17 1587
Java NIO（New Input/Output）是一套从Java 1.4开始引入的高效IO库，旨在替代传统的阻塞式IO。它通过非阻塞模式和多路复用技术，极大地提升了并发性能，非常适合高并发场景。本文将以简单易懂的方式带你入门Java NIO，轻松掌握其核心概念和实际应用。
java网络编程——NIO架构
tang_seven的博客
04-26 2374
简单叙述java NIO架构，并基于NIO架构下实现聊天系统的代码编写
三、Java NIO 编程
weixin_43676950的博客
01-26 1031
3.1、Java NIO 基本介绍 Java NIO 全称java non-blocking IO，是指JDK提供的新API。从JDK1.4开始，Java提供了一系列改进的输入/输出的新特性，被统称为NIO（即New IO），是同步非阻塞的 NIO相关类都被放在java.nio包及子包下，并且对原java.io包中的很多类进行改写。 NIO有三大核心部分：Channel（通道），Buffer（缓存区），Selector（选择器） NIO是面向缓冲区，或者面向块编程的，数据读取到一个它稍后处理
了解Java中的NIO编程
技术研究中心
06-25 346
通过本文的介绍，读者应该对Java中的NIO编程有了初步的了解。NIO提供了一种高效、灵活的I/O操作方式，适用于高并发的网络编程和文件操作场景。掌握NIO编程技术可以提高系统的性能和稳定性，适用于各种需要高效I/O操作的应用场景。
基于Java NIO的网络编程框架.zip
08-31
# 基于Java NIO的网络编程框架 ## 项目概述 本项目深入探讨了Java网络编程中的多种模式，包括BIO（阻塞IO）、NIO（非阻塞IO）、IO多路复用（select、poll、epoll）、Reactor模式，以及零拷贝技术。通过这些实现，...
java网络编程NIO视频教程
09-12
### Java网络编程NIO视频教程知识点汇总 #### 1. Java NIO-课程简介 - **主要内容**：简述...通过以上内容的学习，开发者可以全面掌握Java NIO编程的相关技术和最佳实践，为开发高性能网络应用程序打下坚实的基础。
UNION ALL函数用法
猫敷雪
10-14 1126
UNION ALL用于将两个或多个SELECT查询的结果集合并在一起。与UNION不同，UNION ALL不会去除重复的记录。这意味着即使结果集中有相同的行，它们也会被保留。语法UNION ALL示例employees和，我们想要获取所有员工和承包商的名字。UNION ALL这条查询将返回employees表和表中所有名字的组合，包括重复的名字。
JNI（Java Native Interface）和NIO（New Input/Output）是什么？
项目git同名HuYaochao，未入职
10-14 559
JNI：用于在Java程序中调用本地代码，通常用于系统级操作或性能优化。NIO：是一种高效的I/O方式，支持非阻塞模式、缓冲区和多路复用，适合处理大规模I/O操作，如网络通信和文件操作。这两者都涉及到较底层的操作，因此使用不当时，可能引发OOM或其他资源耗尽问题，特别是在大量使用直接内存或系统资源时。
companion-关于kotlin中的Static
有兴趣深入交流
10-15 255
这些成员可以在不创建类实例的情况下直接通过类名访问。，其作用是在 Kotlin 类中创建静态成员，即。
numcodecs-0.10.0-cp39-cp39-win_amd64.whl
最新发布
10-19
numcodecs-0.10.0-cp39-cp39-win_amd64.whl
Java NIO编程入门与实践：教程与示例
3. **Java NIO与Socket编程**: - 传统Java Socket与NIO的非阻塞SocketChannel进行了对比，演示了如何创建和使用非阻塞SocketChannel进行客户端和服务器之间的通信。 - 包括服务器代码、客户端代码以及运行结果分析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值