java IO编程详解

一、Socket

1. Sock概述

Socket，套接字就是两台主机之间逻辑连接的端点。TCP/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP协议是应用层协议，主要解决如何包装数据。Socket是通信的基石，是支持TCP/IP协议网络通信的基本单元。他是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议、本地主机的IP地址、本地进程的协议端口、远程主机的IP地址、远程进程的协议端口。

2. Socket整体流程

Socket主要涉及到客户端和服务器端两个方面，首先是在服务器端创建一个服务器套接字（ServerSocket），并把它附加到一个端口上，服务器从这个端口监听连接。端口号的范围是0-65535，但是0-1024是特权服务的保留端口号，可以选择任意一个当前没有被其他进程使用的端口。

客户端请求与服务器进行连接的时候，根据服务器的域名或者IP地址，加上端口号打开一个套接字。当服务器接收连接后，服务器和客户端之间的连接就像输入输出流一样进行操作。

在这里插入图片描述

3. 服务端实现

package com.myf.socket;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author myf
 * @Date 2021/3/23 21:15
 * @Version 1.0
 */
public class serverSocket {

    public static void main(String[] args) throws IOException {
        // 创建一个线程池，如果有客户端与服务器连接就与其建立连接
        final ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        final ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器已经启动");
        while (true){
            final Socket accept = serverSocket.accept();
            System.out.println("有客户端连接");
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    hadler(accept);
                }
            });
        }
    }

    private static void hadler(Socket accept) {
        try {
            System.out.println("线程ID："+Thread.currentThread().getId()+"线程名称："+Thread.currentThread().getName());
            final InputStream inputStream = accept.getInputStream();
            byte[] bytes = new byte[1024];
            final int read = inputStream.read(bytes);
            final String s = new String(bytes, 0, read);
            System.out.println("客户端消息："+s);
            final OutputStream outputStream = accept.getOutputStream();
            outputStream.write("hello".getBytes());
            outputStream.flush();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                accept.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

4. 客户端实现

package com.myf.socket;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * @Author myf
 * @Date 2021/3/24 13:34
 * @Version 1.0
 */
public class ClientSocket {
    public static void main(String[] args) {
        try {
            while (true){
                Socket socket = new Socket("127.0.0.1",9999);
                final OutputStream outputStream = socket.getOutputStream();
                outputStream.write("你好".getBytes());
                final InputStream inputStream = socket.getInputStream();
                byte[] bytes = new byte[1024];
                final int read = inputStream.read(bytes);
                final String s = new String(bytes, 0, read);
                System.out.println(s);
                socket.close();
                Thread.sleep(1000);
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

二、IO模型

IO模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能。
java共支持三种网络IO模型：BIO（同步阻塞）、NIO（同步非阻塞）、AIO（异步非阻塞）

阻塞与非阻塞

主要是访问IO的线程是否会阻塞（或处于等待）
线程访问资源，该资源是否准备就绪的一种处理方式（主要是在未就绪的情况下的处理方式）

在这里插入图片描述

同步和异步

主要是指数据的请求方式
同步和异步是指访问数据的一种机制

在这里插入图片描述

1. BIO（同步并阻塞）

java BIO就是传统的Socket编程。

BIO（blocking IO）：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有一个连接请求时，服务端就需要启动一个线程进行处理，如果这个线程不做任何事情会造成不必要的线程开销，可以通过线程池机制改善。

在这里插入图片描述

BIO问题分析

每个请求都需要创建独立的线程，与对应的客户端进行数据Read，业务处理，数据Write。
并发数较大时，需要建立大量的线程来处理连接，系统资源占用较大。
连接建立后，如果当前线程暂时没有数据可读，线程就回阻塞在Read上，造成线程资源浪费。

2. NIO（同步非阻塞）

同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有IO请求就进行处理。

在这里插入图片描述

3. AIO（异步非阻塞）

AIO引入异步通道的概念，采用了Proactor模式，简化了程序编写，有效的请求才启动线程。它的特点是先由操作系统完成后才通知服务器程序启动线程去处理，一般适用于连接较多且连接时间较长的应用。

Proactor模式是一个消息异步通知的设计模式，Proactor通知的不是就绪事件，而是操作完成事件，这也就是操作系统异步IO的主要模型。

4. BIO、NIO、AIO适用场景分析

BIO(同步并阻塞)方式适用于连接数目较小且固定的架构，这种方式对服务器资源要求较高，并发局限于应用中，JDK1.4之前的唯一选择，但程序简单易理解。
NIO(同步非阻塞)方式适用于连接比较多且连接比较短的架构，比如聊天服务器、弹幕系统、服务器间通信等。编程比较复杂，JDK1.4开始支持。
AIO(异步非阻塞)方式适用于连接比较多且连接比较长的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK1.7开始支持。

三、NIO编程

1. NIO介绍

java NIO全称java non-blocking IO，是指java提供的新的API。从JDK1.4开始，java提供了一系列改进的输入\输出的新特性，被统称为NIO(New IO)，是同步非阻塞的。

NIO有三大核心部件：Channel（通道），Buffer（缓冲区），Selector（选择器）。
NIO是面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区前后移动，这就增加了处理过程的灵活性，使用它可以提供非阻塞式的高伸缩网络。
java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是他仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以做其他的事情。非阻塞写也是这样，一个线程请求写入一些数据到某个通道，但不需要等待他完全写入，这个线程同时可以去做别的事情。通俗理解：NIO可以做到用一个线程来处理多个操作。假设有10000个请求过来，可以分配50或者100个线程来处理。不想之前的阻塞IO那样非得分配10000个线程。

2. NIO和BIO的比较

BIO是以流的方式处理数据，而NIO是以缓冲区的方式处理数据，缓冲区IO的效率比流IO的效率高很多。
BIO是阻塞的，NIO是非阻塞的。
BIO是基于字节流和字符流进行操作的，而NIO基于Channel（通道）和Buffer（缓冲区）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector（选择器）用于监听多个通道事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。

3. NIO三大核心原理示意图

一张图描述NIO的Selector、Channel和Buffer的关系

在这里插入图片描述

每个Channel都会对应一个Buffer。
Selector对应一个线程，一个线程对应多个channel。
每个channel都注册到Selector选择器上。
Selector不断轮询查看channel上的事件，事件是通道channel非常重要的概念。
Selector会根据不同的事件，完成不同的处理操作。
Buffer就是一个内存块，底层就是一个数组。
数据的读取写入是通过Buffer，这个和BIO不同，BIO要么是输入流，或者是输出流，不能双向。但是NIO的Buffer是可以读也可以写，channel是双向的。

4. 缓冲区（Buffer）

4.1 基本介绍

缓冲区（Buffer）：本质上是一个可以读写数据的内存块。可以理解成一个数组，该对象提供了一组方法，可以轻松的使用内存块。缓冲区内置了一些机制，能够跟踪和记录缓冲区的状态变化情况，Channel提供从网络读取数据的通道，但是读取和写入数据都必须经过Buffer。

在这里插入图片描述

4.2 Buffer常用API介绍

Buffer类及其子类

在这里插入图片描述

在NIO中，Buffer是一个顶层父类，他是一个抽象类，以上是类的层次关系图，常见的缓冲区分别对应7中基本数据类型，byte、short、int、long、float、double、char。

缓冲区对象的创建

方法名	说明
static ByteBuffer allocate(长度)	创建byte类型的指定长度的缓冲区
static ByteBuffer wrap(byte[] array)	创建一个有内容的byte类型缓冲区

示例代码：

public class CreateBufferDemo {
    public static void main(String[] args) {
        // 创建指定长度的缓冲区 ByteBuffer为例
        final ByteBuffer allocate = ByteBuffer.allocate(5);
        for (int i = 0; i < 5; i++) {
            System.out.println(allocate.get());
        }
        //System.out.println(allocate.get());

        // 创建一个有内容的缓冲区
        final ByteBuffer wrap = ByteBuffer.wrap("myfff".getBytes());
        for (int i = 0; i < 5; i++) {
            System.out.println(wrap.get());
        }
    }
}

缓冲区对象添加数据

方法名	说明
int position()/position(int newPosition)	获取当前要操作的索引/修改当前要操作索引的位置
int limit()/limit(int newLimit)	最多能操作到哪个索引/修改最多能够操作的索引位置
int capacity()	返回缓冲区总长度
int remaining()/boolean hasRemaining()	还有多少能够操作索引的个数/是否还能操作
put(byte b)/put(byte[] src)	添加一个字节/添加字节数组

图解：

在这里插入图片描述

示例代码：

/**
 * 向缓冲区添加数据
 * @Author myf
 * @Date 2021/3/31 1:17
 * @Version 1.0
 */
public class PutBufferDemo {
    public static void main(String[] args) {
        // 创建一个缓冲区
        final ByteBuffer allocate = ByteBuffer.allocate(10);
        // 当前索引的位置
        System.out.println(allocate.position());
        // 最多能操作到哪个索引
        System.out.println(allocate.limit());
        // 返回缓冲区总长度
        System.out.println(allocate.capacity());
        // 还有多少能操作的个数
        System.out.println(allocate.remaining());

        // 修改当前索引所在的位置
        allocate.position(1);
        // 修改最多能够操作的索引的位置
        allocate.limit(9);
        System.out.println("======================");
        // 当前索引的位置
        System.out.println(allocate.position());
        // 最多能操作到哪个索引
        System.out.println(allocate.limit());
        // 返回缓冲区总长度
        System.out.println(allocate.capacity());
        // 还有多少能操作的个数
        System.out.println(allocate.remaining());

        // 添加一个字节
        allocate.put((byte) 97);
        System.out.println("======================");
        // 当前索引的位置
        System.out.println(allocate.position());
        // 最多能操作到哪个索引
        System.out.println(allocate.limit());
        // 返回缓冲区总长度
        System.out.println(allocate.capacity());
        // 还有多少能操作的个数
        System.out.println(allocate.remaining());

        // 添加一个数组
        allocate.put("myf".getBytes());
        System.out.println("======================");
        // 当前索引的位置
        System.out.println(allocate.position());
        // 最多能操作到哪个索引
        System.out.println(allocate.limit());
        // 返回缓冲区总长度
        System.out.println(allocate.capacity());
        // 还有多少能操作的个数
        System.out.println(allocate.remaining());

        // 如果缓冲区满了，可以调整position位置，就可以重复写了，会覆盖之前索引位置的值
        allocate.position(0);
        allocate.put("myf".getBytes());
        System.out.println("======================");
        // 当前索引的位置
        System.out.println(allocate.position());
        // 最多能操作到哪个索引
        System.out.println(allocate.limit());
        // 返回缓冲区总长度
        System.out.println(allocate.capacity());
        // 还有多少能操作的个数
        System.out.println(allocate.remaining());
    }
}

缓冲区对象读取数据

方法名	介绍
flip()	写切换读模式 limit设置position位置, position设置0
get()	读一个字节
get(byte[] dst)	读多个字节
get(int index)	读指定索引的字节
rewind()	将position设置为0，可以重复读
clear()	切换写模式 position设置为0 , limit 设置为 capacity
array()	将缓冲区转换成字节数组返回

图解:flip()方法

在这里插入图片描述

图解:clear()方法

在这里插入图片描述

实例代码：

/**
 * 从缓冲区读取数据
 * @Author myf
 * @Date 2021/3/31 2:03
 * @Version 1.0
 */
public class GetBufferDemo {
    public static void main(String[] args) {
        // 创建指定长度的缓冲区
        final ByteBuffer allocate = ByteBuffer.allocate(10);
        allocate.put("0123".getBytes());
        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        System.out.println(allocate.capacity());
        System.out.println(allocate.remaining());

        // 切换读模式
        System.out.println("=======================");
        allocate.flip();
        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        for (int i = 0; i < allocate.limit(); i++) {
            System.out.println(allocate.get());
        }

        System.out.println("读取指定位置数据");
        System.out.println(allocate.get(1));
        System.out.println("读取多个字节数据");
        // 重复读取
        allocate.rewind();
        byte[] bytes = new byte[4];
        System.out.println(allocate.get(bytes));
        for (byte aByte : bytes) {
            System.out.println(aByte);
        }

        System.out.println("将缓冲区转换成字节数组返回");
        final byte[] array = allocate.array();
        System.out.println(new String(array));

        // 切换写模式
        allocate.clear();
        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        allocate.put("987".getBytes());
        final byte[] array2 = allocate.array();
        System.out.println(new String(array2));
    }
}

capacity：容量（长度）limit：界限（最多能读/写到哪里）position：位置（读/写哪个索引）

读取缓冲区里面数据之前，需要调用flip方法

再次写数据之前，需要调用clear方法，但是数据还未消失，等再次写入数据，被覆盖了才会消失。

5.通道（Channel）

5.1 基本介绍

通常来说NIO中所有IO都是从Channel（通道）开始的。NIO通道类似于流，但有些区别如下：

通道可以读也可以写，流一般是单向的（只能读或写）
通道可以异步读写
通道总是基于缓冲区Buffer来读写

在这里插入图片描述

5.2 Channel常用类介绍

Channel接口
常用的Channel实现类有：FileChannel，DatagramChannel，ServerSocketChannel和SocketChannel。FileChannel用于文件数据的读写，DatagremChannel用于UDP数据的读写，ServerSocketChannel和SocketChannel用于TCP数据的读写
SocketChannel与ServerSocketChannel
类似Socket与ServerSocket可以完成客户端与服务器端数据的通信工作。

5.3 ServerSocketChannel

服务端实现步骤：

打开一个服务端通道。
绑定对应的端口号。
通道默认为阻塞的，设置为非阻塞。
检查是否有客户端连接，有客户端连接会返回对应的通道。
获取客户端传递过来的数据，并把数据放在ByteBuffer这个缓冲区中。
给客户端回写数据。
释放资源。

代码实现：

public class NioServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        //1. 打开一个服务端通道。
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //2. 绑定对应的端口号。
        serverSocketChannel.bind(new InetSocketAddress(9999));
        //3. 通道默认为阻塞的，设置为非阻塞。
        serverSocketChannel.configureBlocking(false);
        System.out.println("服务端启动成功。。。。");
        //4. 检查是否有客户端连接，有客户端连接会返回对应的通道。
        while (true){
            // 不会阻塞在这里
            final SocketChannel socketChannel = serverSocketChannel.accept();
            if (socketChannel==null){
                System.out.println("没有客户端连接。。。我去做别的事情");
                Thread.sleep(1000);
                continue;
            }
            //5. 获取客户端传递过来的数据，并把数据放在ByteBuffer这个缓冲区中。
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            // 返回值
            // 正数：表示本次读到的字节数
            // 0:表示本次没有读到数据
            // 1:表示读到末尾
            final int read = socketChannel.read(byteBuffer);
            System.out.println("客户端消息" + new String(byteBuffer.array(),0,read, StandardCharsets.UTF_8));
            //6. 给客户端回写数据。
            socketChannel.write(ByteBuffer.wrap("没钱".getBytes(StandardCharsets.UTF_8)));
            //7. 释放资源。
            socketChannel.close();
        }
    }
}

5.4 SocketChannel

客户端实现步骤：

打开通道
设置连接IP和端口号
写出数据
读取服务器写回的数据
释放资源

代码实现：

public class NioClient {
    public static void main(String[] args) throws IOException {
        //1. 打开通道
        final SocketChannel socketChannel = SocketChannel.open();
        //2. 设置连接IP和端口号
        socketChannel.connect(new InetSocketAddress("127.0.0.1",9999));
        //3. 写出数据
        socketChannel.write(ByteBuffer.wrap("老板还钱吧".getBytes(StandardCharsets.UTF_8)));
        //4. 读取服务器写回的数据
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        final int read = socketChannel.read(byteBuffer);
        System.out.println("服务端消息:" + new String(byteBuffer.array(),0,read,StandardCharsets.UTF_8));
        //5. 释放资源
        socketChannel.close();
    }
}

6.选择器（Selector）

可以用一个线程，处理多个的客户端连接，就会使用到NIO的Selector(选择器). Selector 能够检测多个注册的服务端通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。

在这里插入图片描述

在这种没有选择器的情况下，每个连接对应一个处理线程，但是线程并不会马上发出消息，会造成资源浪费

在这里插入图片描述

只有在通道读写事件真正发生时，才会进行读写，就大大减少了系统开销，并且不必为每个连接都创建一个连接，不用去维护多个线程，避免了多线程之间上下文切换造成的开销

6.1 常用API介绍

Selecter类是一个抽象类
常用方法
- Selector.open() : //得到一个选择器对象
- selector.select() : //阻塞监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入集合内部并返回事件数量
- selector.select(1000): //阻塞 1000 毫秒，监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入集合内部并返回
- selector.selectedKeys() : // 返回存有SelectionKey的集合
SelectionKey
常用方法
- SelectionKey.isAcceptable(): 是否是连接继续事件
- SelectionKey.isConnectable(): 是否是连接就绪事件
- SelectionKey.isReadable(): 是否是读就绪事件
- SelectionKey.isWritable(): 是否是写就绪事件
SelectionKey中定义的4种事件:
- SelectionKey.OP_ACCEPT —— 接收连接继续事件，表示服务器监听到了客户连接，服务器可以接收这个连接了
- SelectionKey.OP_CONNECT —— 连接就绪事件，表示客户端与服务器的连接已经建立成功
- SelectionKey.OP_READ —— 读就绪事件，表示通道中已经有了可读的数据，可以执行读操作了（通道目前有数据，可以进行读操作了）
- SelectionKey.OP_WRITE —— 写就绪事件，表示已经可以向通道写数据了（通道目前可以用于写操作）

6.2 Selecter编码

服务端实现步骤

打开一个服务端通道
绑定对应的端口号
通道默认是阻塞的，需要设置为非阻塞
创建选择器
将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT
检查选择器是否有事件
获取事件集合
判断事件是否是客户端连接事件SelectionKey.isAcceptable()
得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
判断是否是客户端读就绪事件SelectionKey.isReadable()
得到客户端通道,读取数据到缓冲区
给客户端回写数据
从集合中删除对应的事件, 因为防止二次处理

代码实现：

public class NIOSelectorServer {
    public static void main(String[] args) throws IOException {
        // 1. 打开一个服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 2. 绑定对应的端口号
        serverSocketChannel.bind(new InetSocketAddress(9999));
        // 3. 通道默认是阻塞的，需要设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        // 4. 创建选择器
        Selector selector = Selector.open();
        // 5. 将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.printf("服务端启动成功");

        while (true){
            // 6. 检查选择器是否有事件
            int select = selector.select(2000);
            if (select==0){
                System.out.println("没有事件发生");
                continue;
            }
            // 7. 获取事件集合
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            // 8. 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
            for (SelectionKey selectionKey : selectionKeys) {
                if (selectionKey.isAcceptable()){
                    // 9. 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    System.out.println("有客户端连接");
                    // 将通道设置未非阻塞的状态，因为Selector需要轮训监听每个通道
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector,SelectionKey.OP_READ);
                }
                // 10. 判断是否是客户端读就绪事件SelectionKey.isReadable()
                if (selectionKey.isReadable()){
                    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                    ByteBuffer allocate = ByteBuffer.allocate(1024);
                    // 11. 得到客户端通道,读取数据到缓冲区
                    int read = socketChannel.read(allocate);
                    if (read>0){
                        System.out.printf("客户端消息："+new String(allocate.array(),0,read));
                        // 12. 给客户端回写数据
                        socketChannel.write(ByteBuffer.wrap("没钱".getBytes(StandardCharsets.UTF_8)));
                        socketChannel.close();
                    }
                }
                // 13. 从集合中删除对应的事件, 因为防止二次处理
                selectionKeys.remove(selectionKey);
            }
        }
    }
}

public class NIOClient {
    public static void main(String[] args) throws IOException {
        // 打开通道
        SocketChannel socketChannel = SocketChannel.open();
        // 绑定端口
        socketChannel.connect(new InetSocketAddress("127.0.0.1",9999));
        // 发送数据
        socketChannel.write(ByteBuffer.wrap("老板还钱".getBytes(StandardCharsets.UTF_8)));
        // 读取服务端数据
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        int read = socketChannel.read(byteBuffer);
        System.out.println("服务端返回数据" + new String(byteBuffer.array(),0,read));
        socketChannel.close();
    }
}

java IO编程详解

java IO编程详解

一、Socket

1. Sock概述

2. Socket整体流程

3. 服务端实现

4. 客户端实现

二、IO模型

1. BIO（同步并阻塞）

2. NIO（同步非阻塞）

3. AIO（异步非阻塞）

4. BIO、NIO、AIO适用场景分析

三、NIO编程

1. NIO介绍

2. NIO和BIO的比较

3. NIO三大核心原理示意图

4. 缓冲区（Buffer）

4.1 基本介绍

4.2 Buffer常用API介绍

5.通道（Channel）

5.1 基本介绍

5.2 Channel常用类介绍

5.3 ServerSocketChannel

5.4 SocketChannel

6.选择器（Selector）

6.1 常用API介绍

6.2 Selecter编码

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

java IO编程详解

java IO编程详解

一、Socket

1. Sock概述

2. Socket整体流程

3. 服务端实现

4. 客户端实现

二、IO模型

1. BIO（同步并阻塞）

2. NIO（同步非阻塞）

3. AIO（异步非阻塞）

4. BIO、NIO、AIO适用场景分析

三、NIO编程

1. NIO介绍

2. NIO和BIO的比较

3. NIO三大核心原理示意图

4. 缓冲区（Buffer）

4.1 基本介绍

4.2 Buffer常用API介绍

5.通道（Channel）

5.1 基本介绍

5.2 Channel常用类介绍

5.3 ServerSocketChannel

5.4 SocketChannel

6.选择器（Selector）

6.1 常用API介绍

6.2 Selecter编码

热门文章

最新文章

相关课程

相关电子书

相关实验场景