Java的IO模型详解-BIO,NIO,AIO

于 2024-08-29 23:52:58 发布
阅读量619 收藏 15
点赞数 9
分类专栏： Java开发 文章标签： java nio 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wendao76/article/details/141689901
版权

一、BIO相关知识

Java 的 BIO (Blocking I/O) 模型是基于传统的同步阻塞 I/O 操作。在这种模型中，每个客户端连接都需要一个独立的线程来处理请求。当线程正在执行 I/O 操作时（如读取或写入），它会被阻塞，直到操作完成。

读写模型

在这里插入图片描述

BIO 概述

BIO 是 Java 中最简单的 I/O 模型之一，它使用 java.io 包中的类来实现，例如 InputStream, OutputStream, Reader, 和 Writer。在 BIO 模型中，每当有客户端连接到来时，服务器就会创建一个新的线程来处理这个连接上的所有读写操作。

BIO 特点

  • 同步：读写操作是同步进行的，即必须等待一个操作完成后才能继续下一步操作。
  • 阻塞：当线程调用 I/O 方法时，如果数据没有准备好，线程就会被阻塞，直到数据准备好为止。
  • 每连接一线程：对于每一个客户端连接，服务器都会分配一个线程来处理该连接的所有 I/O 操作。
  • 简单易用：BIO 的实现比较简单，易于理解和使用。
  • 低效：在高并发的情况下，由于每个连接都需要一个线程，因此线程的创建和管理成本较高，可能导致服务器资源耗尽。

BIO 实现示例

下面是一个简单的 BIO 服务器端实现示例，该服务器接收客户端的连接，并打印出客户端发送的消息。

服务器端
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class BioServer {
    public static void main(String[] args) {
        int port = 8080; // 服务器监听端口
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("Server started on port " + port);

            while (true) {
                Socket clientSocket = serverSocket.accept();
                new Thread(new ClientHandler(clientSocket)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static class ClientHandler implements Runnable {
        private final Socket socket;

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

        @Override
        public void run() {
            try (BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                 PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    System.out.println("Received from client: " + inputLine);
                    if ("bye".equalsIgnoreCase(inputLine)) {
                        break;
                    }
                    out.println("Echo: " + inputLine);
                }
                System.out.println("Client disconnected.");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
客户端

接下来是一个简单的 BIO 客户端实现示例，该客户端向服务器发送消息并接收服务器的响应。

import java.io.*;
import java.net.Socket;

public class BioClient {
    public static void main(String[] args) {
        String serverAddress = "localhost";
        int port = 8080;

        try (Socket socket = new Socket(serverAddress, port);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
            out.println("Hello, server!");
            out.println("Another message.");
            out.println("bye");

            String response;
            while ((response = in.readLine()) != null) {
                System.out.println("Received from server: " + response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

二、NIO相关知识点

Java 的 NIO (New I/O) 模型是在 Java 1.4 中引入的，它提供了一种新的方式来处理输入输出操作，相比于传统的 BIO (Blocking I/O) 模型，NIO 提供了更高的性能和更灵活的编程模型。NIO 主要包括三个核心组件：缓冲区(Buffer)、通道(Channel) 和选择器(Selector)。

读写模型

在这里插入图片描述

NIO 核心概念

  • 缓冲区(Buffer)：缓冲区用于存储不同类型的二进制数据。与流不同的是，缓冲区可以保存数据，可以对数据进行读写操作，也可以在缓冲区之间复制数据。在 NIO 中，所有数据都是通过缓冲区进行操作的。

  • 通道(Channel)：通道类似于流，但是它可以双向读写数据。通道可以从文件系统、网络等地方获取或发送数据。与流不同的是，通道可以与缓冲区交互，也就是说数据可以被读取到缓冲区中，或者从缓冲区写入到通道中。

  • 选择器(Selector)：选择器允许单个线程监控多个通道的状态，比如哪些通道是可读的、哪些是可写的。这使得一个线程可以同时处理多个客户端连接，大大提高了并发处理能力。

NIO 特点

  • 非阻塞：NIO 允许非阻塞 I/O 操作，即使没有数据可用，线程也不会被阻塞，而是可以继续执行其他任务。
  • 高效：由于使用了缓冲区和选择器，NIO 可以在一个线程中处理多个连接，减少了线程的创建和销毁所带来的开销。
  • 复杂性：相比于 BIO，NIO 的编程模型更为复杂，需要更深入地理解缓冲区和通道的概念。

NIO 实现示例

下面是一个简单的 NIO 服务器端实现示例，该服务器接收客户端的连接，并打印出客户端发送的消息。

服务器端
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 NioServer {
    public static void main(String[] args) {
        int port = 8080; // 服务器监听端口
        try (Selector selector = Selector.open();
             ServerSocketChannel serverSocketChannel = ServerSocketChannel.open()) {
            serverSocketChannel.bind(new InetSocketAddress(port));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            System.out.println("Server started on port " + port);

            while (true) {
                selector.select();

                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectedKeys.iterator();

                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    iterator.remove();

                    if (key.isAcceptable()) {
                        acceptConnection(serverSocketChannel, selector);
                    } else if (key.isReadable()) {
                        readData(key);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void acceptConnection(ServerSocketChannel serverSocketChannel, Selector selector) throws IOException {
        SocketChannel clientChannel = serverSocketChannel.accept();
        clientChannel.configureBlocking(false);
        clientChannel.register(selector, SelectionKey.OP_READ);
        System.out.println("Client connected: " + clientChannel.getRemoteAddress());
    }

    private static void readData(SelectionKey key) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        int numRead;
        while ((numRead = clientChannel.read(buffer)) > 0) {
            buffer.flip();
            byte[] data = new byte[numRead];
            buffer.get(data);
            String received = new String(data, "UTF-8");
            System.out.println("Received from client: " + received);
            buffer.clear();
        }

        if (numRead == -1) { // 如果客户端关闭了连接
            clientChannel.close();
            key.cancel();
        }
    }
}
客户端

下面是一个简单的 NIO 客户端实现示例，该客户端向服务器发送消息并接收服务器的响应。

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

public class NioClient {
    public static void main(String[] args) {
        String serverAddress = "localhost";
        int port = 8080;

        try (SocketChannel socketChannel = SocketChannel.open()) {
            socketChannel.connect(new InetSocketAddress(serverAddress, port));
            socketChannel.configureBlocking(false);

            ByteBuffer buffer = ByteBuffer.allocate(1024);

            buffer.put("Hello, server!".getBytes(StandardCharsets.UTF_8));
            buffer.flip();
            socketChannel.write(buffer);
            buffer.clear();

            buffer.put("Another message.".getBytes(StandardCharsets.UTF_8));
            buffer.flip();
            socketChannel.write(buffer);
            buffer.clear();

            buffer.put("bye".getBytes(StandardCharsets.UTF_8));
            buffer.flip();
            socketChannel.write(buffer);
            buffer.clear();

            while (socketChannel.isOpen()) {
                buffer.clear();
                int numRead = socketChannel.read(buffer);
                if (numRead == -1) {
                    break;
                }

                buffer.flip();
                byte[] data = new byte[numRead];
                buffer.get(data);
                System.out.println("Received from server: " + new String(data, StandardCharsets.UTF_8));
                buffer.clear();
            }

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

三、AIO相关知识

Java 的 AIO (Asynchronous I/O) 模型是在 Java 7 中引入的，它是 NIO 的扩展，支持真正的异步 I/O 操作。AIO 有时也被称作 NIO 2，因为它是 NIO 的后续版本，增强了 NIO 的功能。

读写模型

在这里插入图片描述

AIO 概念

AIO 的关键概念是异步非阻塞 I/O。在 AIO 中，应用程序发起一个 I/O 请求后，可以立即返回并继续执行其他任务，而不需要等待 I/O 操作完成。当 I/O 操作完成后，应用程序会被通知。

AIO 组件

AIO 主要涉及以下组件：

  • AsynchronousFileChannel：用于异步地读取、写入和映射文件。
  • AsynchronousSocketChannel：用于异步地处理网络连接。
  • AsynchronousServerSocketChannel：用于异步地接受新的连接。
  • CompletionHandler：用于处理异步 I/O 操作完成时的回调。

AIO 特点

  • 异步性：AIO 支持真正的异步 I/O 操作，这意味着线程可以在发起 I/O 操作后立即返回，而不是等待操作完成。
  • 非阻塞：线程不会因为等待 I/O 操作而被阻塞，可以继续执行其他任务。
  • 高并发：AIO 适合处理高并发的场景，因为它可以有效地利用少量线程处理大量的 I/O 操作。
  • 复杂性：相比 BIO 和 NIO，AIO 的编程模型更为复杂，需要熟悉异步编程的概念。

AIO 实现示例

下面是一个简单的 AIO 服务器端实现示例，该服务器接收客户端的连接，并打印出客户端发送的消息。

服务器端
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class AioServer {
    public static void main(String[] args) {
        int port = 8080; // 服务器监听端口
        try (AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(port))) {
            System.out.println("Server started on port " + port);

            serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
                @Override
                public void completed(AsynchronousSocketChannel result, Void attachment) {
                    serverChannel.accept(null, this);

                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    result.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                        @Override
                        public void completed(Integer result, ByteBuffer attachment) {
                            attachment.flip();
                            byte[] data = new byte[attachment.remaining()];
                            attachment.get(data);
                            System.out.println("Received from client: " + new String(data));
                            result.write(ByteBuffer.wrap("Echo: ".getBytes()), ByteBuffer.wrap(data), new CompletionHandler<Integer, ByteBuffer>() {
                                @Override
                                public void completed(Integer result, ByteBuffer attachment) {
                                    attachment.flip();
                                    result.read(attachment, attachment, this);
                                }

                                @Override
                                public void failed(Throwable exc, ByteBuffer attachment) {
                                    exc.printStackTrace();
                                }
                            });
                        }

                        @Override
                        public void failed(Throwable exc, ByteBuffer attachment) {
                            exc.printStackTrace();
                        }
                    });
                }

                @Override
                public void failed(Throwable exc, Void attachment) {
                    exc.printStackTrace();
                }
            });

            while (true) {
                Thread.sleep(1000); // 让服务器运行
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}
客户端

下面是一个简单的 AIO 客户端实现示例，该客户端向服务器发送消息并接收服务器的响应。

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class AioClient {
    public static void main(String[] args) {
        String serverAddress = "localhost";
        int port = 8080;

        try (AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open()) {
            socketChannel.connect(new InetSocketAddress(serverAddress, port), null, new CompletionHandler<Void, Void>() {
                @Override
                public void completed(Void result, Void attachment) {
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    buffer.put("Hello, server!".getBytes());
                    buffer.flip();
                    socketChannel.write(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                        @Override
                        public void completed(Integer result, ByteBuffer attachment) {
                            attachment.clear();
                            buffer.put("Another message.".getBytes());
                            buffer.flip();
                            socketChannel.write(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                                @Override
                                public void completed(Integer result, ByteBuffer attachment) {
                                    attachment.clear();
                                    buffer.put("bye".getBytes());
                                    buffer.flip();
                                    socketChannel.write(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                                        @Override
                                        public void completed(Integer result, ByteBuffer attachment) {
                                            buffer.clear();
                                            socketChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                                                @Override
                                                public void completed(Integer result, ByteBuffer attachment) {
                                                    attachment.flip();
                                                    byte[] data = new byte[attachment.remaining()];
                                                    attachment.get(data);
                                                    System.out.println("Received from server: " + new String(data));
                                                    socketChannel.close();
                                                }

                                                @Override
                                                public void failed(Throwable exc, ByteBuffer attachment) {
                                                    exc.printStackTrace();
                                                }
                                            });
                                        }

                                        @Override
                                        public void failed(Throwable exc, ByteBuffer attachment) {
                                            exc.printStackTrace();
                                        }
                                    });
                                }

                                @Override
                                public void failed(Throwable exc, ByteBuffer attachment) {
                                    exc.printStackTrace();
                                }
                            });
                        }

                        @Override
                        public void failed(Throwable exc, ByteBuffer attachment) {
                            exc.printStackTrace();
                        }
                    });
                }

                @Override
                public void failed(Throwable exc, Void attachment) {
                    exc.printStackTrace();
                }
            });

            while (true) {
                Thread.sleep(1000); // 让客户端运行
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

总结

为了便于类比，所以样例代码都是使用了客户端和服务端的交互代码实现。通过比对不难发现一下特点：

  • BIO：简单，易于理解，但在高并发情况下效率较低。
  1. 发起读请求
  2. 等待数据(阻塞)
  3. 返回(数据已经准备好了)
  • NIO：提高了效率，支持非阻塞 I/O，但编程复杂度增加。
  1. 发起读请求
  2. 请求返回，可以继续做自己的事情
  3. 问一下数据好了没?
  4. 没好， 直接返回
  5. 哈了， 等待数据拷贝好， 返回
  • AIO：进一步提高了效率，支持真正的异步 I/O，但编程复杂度最高。
  1. 发起读请求
  2. 请求返回，做自己的事情
  3. 数据准好了， 提醒请求方数据可以用了
  • 其他说明
  1. 实际编程中， 使用较多的是bio， 因为其代码简单，易于理解。
  2. nio则一般用于框架核心级别的代码， 编程难度介于BIO和AIO之间， 且有如netty之类的较为成熟的框架面世
  3. aio 是三种IO当中效率最高的， 但是因其编程难度极高， 目前的使用案例较少。而一般开发过程更是很少用到aio.
问道飞鱼
关注
  • 9
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java IO模型：BIO、NIO、AIO讲解
流楚丶格念的博客
10-17 1943
IO，Input/Output 简写，是指内存和外设之间的数据复制的过程。输入是指数据从外设复制到内存中， 输出则是指数据从内存复制到外设。目前，IO 可以通过数据流、序列化和文件系统为系统提供输入和输出而Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。Java IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。
Java网络编程IO模型 --- BIO、NIO、AIO详解
2301_82242988的博客
04-29 688
金三银四马上就到了，希望大家能好好学习一下这些技术点学习视频：大厂面试真题：金三银四马上就到了，希望大家能好好学习一下这些技术点学习视频：[外链图片转存中…(img-3ST7KdL7-1714389491204)]大厂面试真题：[外链图片转存中…(img-wIJZpwVt-1714389491205)]本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录。
Java网络编程IO模型 --- BIO、NIO、AIO详解(1)
2401_84102653的博客
05-01 490
作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料通过本文能加固你对BIO、NIO、AIO的理解作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料[外链图片转存中…(img-AZDmB8fc-1714500658587)][外链图片转存中…(img-3JMkjzjH-1714500658588)]本文已被。
Java IO 模型之 BIO、NIO、AIO 详解
流华追梦的专栏
12-15 1421
在 Java 编程中，IO（Input/Output）操作是非常常见的操作，它涉及到文件读写、网络通信等方面。Java 提供了各种类来支持这些操作。本文将从 IO 的基础知识讲起，逐步深入，介绍 Java IO 的各个方面。Java IO（Input/Output）是 Java 语言中用于读写数据的 API，它提供了一系列类和接口，用于读取和写入各种类型的数据。
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析
01-04
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析 IO模型在计算机编程中扮演着至关重要的角色，特别是在网络通信中。Java提供了三种主要的IO模型：BIO（Blocking IO），NIO（Non-blocking IO），...
2024年Java常见的-BIO,NIO,AIO,Netty面试题
04-20
### 2024年Java常见BIO、NIO、AIO、Netty面试题解析 #### 一、基础知识概述 1. **IO概念**： - Java中的I/O（Input/Output）指的是输入输出操作，它以流为基础进行数据的输入输出。所有的数据在Java中都是以流的...
详解Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
08-28
本篇文章主要介绍了 Java 网络IO编程总结，包括 BIO、NIO 和 AIO 三种模型，并提供了完整的实例代码。 BIO（Blocking I/O） BIO 是传统的同步阻塞模型，服务器端使用 ServerSocket 监听客户端的连接请求，客户端...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 2272
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 2119
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
《深入理解 Java 中的适配器模式》
最新发布
面团到油条的成长日记
08-29 870
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
操作系统原子操作
zzt_is_me的博客
08-28 1163
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 792
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 562
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 1340
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
JVM 内存参数
iOS逆向与安全
08-29 55
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
Java面试宝典-java基础02
杜盟恩的博客
08-27 651
机器语言是一种指令集的体系，是最早出现的计算机语言。机器语言从属于硬件设备。不同的计算机设备有不同的机器语言．所以机器语言是一种面向机器的语言。计算机指令系统中的指令是由“0”和“1”两种符号组成的代码，并且能被机器直接理解执行，它们被称为机器指令。一个计算机的机器指令的集，就构成了该计算机的机器语言，即计算机可以直接接受、理解的语言。机器语言能利用机器指令精准地描述算法、且编程质量高、所占存储空间小，执行速度快。但是这种程序直观性很差，容易出错，阅读检查和修改调试非常困难。
Java 入门指南：Java IO 模型
Zachyy的博客
08-26 1109
Java中的 IO（Input/Output）模型是管理计算机与外部设备（如磁盘、网络等）之间数据交换的重要机制。它定义了数据如何在应用程序和操作系统之间流动，以及如何处理这些流动过程中的阻塞、非阻塞、同步和异步等问题。Java中常见的IO模型包括 BIO（Blocking I/O，阻塞IO）、NIO（Non-Blocking I/O，非阻塞IO）、AIO（Asynchronous I/O，异步IO）等。
Linux系统（centos7）增加一个开机自启任务
唯有热爱 可抵万难
08-28 626
现在，需要他在启动的时候，自动加载这个脚本，完成服务自动启动！此处的start.sh需要有可执行权限！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

问道飞鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值