Java 网络编程 - BIO，NIO和AIO

BIO

BIO 有的称之为 basic(基本) IO,有的称之为 block(阻塞) IO，主要应用于文件 IO 和网络 IO。

在 JDK1.4 之前，我们建立网络连接的时候只能采用 BIO，需要先在服务端启动一个 ServerSocket，然后在客户端启动 Socket 来对服务端进行通信，默认情况下服务端需要对每 个请求建立一个线程等待请求，而客户端发送请求后，先咨询服务端是否有线程响应，如果 没有则会一直等待或者遭到拒绝，如果有的话，客户端线程会等待请求结束后才继续执行， 这就是阻塞式 IO。

接下来通过一个例子复习回顾一下 BIO 的基本用法（基于 TCP）。

package com.tntxia.test.network.bio;

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

//BIO 服务器端程序
public class TCPServer {
    public static void main(String[] args) throws Exception {
        //1.创建 ServerSocket 对象
        ServerSocket ss = new ServerSocket(9999);
        while (true) {
            //2.监听客户端
            Socket s = ss.accept(); //阻塞
            //3.从连接中取出输入流来接收消息
            InputStream is = s.getInputStream(); //阻塞
            byte[] b = new byte[10];
            is.read(b);
            String clientIP = s.getInetAddress().getHostAddress();
            System.out.println(clientIP + "说:" + new String(b).trim());
            //4.从连接中取出输出流并回话
            OutputStream os = s.getOutputStream();
            os.write("没钱".getBytes());
            //5.关闭
            s.close();
        }
    }
}

上述代码编写了一个服务器端程序，绑定端口号 9999，accept 方法用来监听客户端连接，

如果没有客户端连接，就一直等待，程序会阻塞到这里。

NIO 编程

概述

java.nio 全称 java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)。新增了许多用于处理输入输出的类，这些类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写，新增了满足 NIO 的功能

NIO 和 BIO 有着相同的目的和作用，但是它们的实现方式完全不同，BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多。另外，NIO 是非阻塞式的， 这一点跟 BIO 也很不相同，使用它可以提供非阻塞式的高伸缩性网络。

NIO 主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器)。传统的 BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作，数据 总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通 道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。

文件 IO

概述和核心 API

缓冲区（Buffer）：实际上是一个容器，是一个特殊的数组，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道， 但是读取或写入的数据都必须经由 Buffer，如下图所示：

在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类，常用的 Buffer 子类有：

• ByteBuffer，存储字节数据到缓冲区
• ShortBuffer，存储字符串数据到缓冲区
• CharBuffer，存储字符数据到缓冲区
• IntBuffer，存储整数数据到缓冲区
• LongBuffer，存储长整型数据到缓冲区
• DoubleBuffer，存储小数到缓冲区
• FloatBuffer，存储小数到缓冲区

对于 Java 中的基本数据类型，都有一个 Buffer 类型与之相对应，最常用的自然是 ByteBuffer 类（二进制数据），该类的主要方法如下所示：

• public abstract ByteBuffer put(byte[] b); 存储字节数据到缓冲区
• public abstract byte[] get(); 从缓冲区获得字节数据
• public final byte[] array(); 把缓冲区数据转换成字节数组
• public static ByteBuffer allocate(int capacity); 设置缓冲区的初始容量
• public static ByteBuffer wrap(byte[] array); 把一个现成的数组放到缓冲区中使用
• public final Buffer flip(); 翻转缓冲区，重置位置到初始位置

通道（Channel）：类似于 BIO 中的 stream，例如 FileInputStream 对象，用来建立到目 标（文件，网络套接字，硬件设备等）的一个连接，但是需要注意：BIO 中的 stream 是单向 的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道(Channel)是双向的， 既可以用来进行读操作，也可以用来进行写操作。常用的 Channel 类有：FileChannel、 DatagramChannel、ServerSocketChannel 和 SocketChannel。FileChannel 用于文件的数据读写， DatagramChannel 用于 UDP 的数据读写，ServerSocketChannel 和 SocketChannel 用于 TCP 的 数据读写。

这里我们先讲解 FileChannel 类，该类主要用来对本地文件进行 IO 操作，主要方法如下所示：

• public int read(ByteBuffer dst) ，从通道读取数据并放到缓冲区中
• public int write(ByteBuffer src) ，把缓冲区的数据写到通道中
• public long transferFrom(ReadableByteChannel src, long position, long count)，从目标通道 中复制数据到当前通道
• public long transferTo(long position, long count, WritableByteChannel target)，把数据从当 前通道复制给目标通道

案例

接下来我们通过 NIO 实现几个案例，分别演示一下本地文件的读、写和复制操作，并和 BIO 做个对比。

往本地文件中写数据

package com.tntxia.test.network.nio;

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class Test1 {
    public static void main(String[] args) throws IOException {
        String str="hello,nio,我是博学谷";
        FileOutputStream fos=new FileOutputStream("basic.txt");
        FileChannel fc=fos.getChannel();
        ByteBuffer buffer=ByteBuffer.allocate(1024);
        buffer.put(str.getBytes());
        buffer.flip();
        fc.write(buffer);
        fos.close();
    }
}

NIO 中的通道是从输出流对象里通过 getChannel 方法获取到的，该通道是双向的，既可以读，又可以写。在往通道里写数据之前，必须通过 put 方法把数据存到 ByteBuffer 中，然 后通过通道的 write 方法写数据。在 write 之前，需要调用 flip 方法翻转缓冲区，把内部重置 到初始位置，这样在接下来写数据时才能把所有数据写到通道里。运行效果如下图所示：

从本地文件中读数据

package com.tntxia.test.network.nio;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class Test2 {

    public static void main(String[] args) throws IOException {
        File file=new File("basic.txt");
        FileInputStream fis=new FileInputStream(file);
        FileChannel fc=fis.getChannel();
        ByteBuffer buffer=ByteBuffer.allocate((int)file.length());
        fc.read(buffer);
        System.out.print(new String(buffer.array()));
        fis.close();
    }
}

上述代码从输入流中获得一个通道，然后提供 ByteBuffer 缓冲区，该缓冲区的初始容量和文件的大小一样，最后通过通道的 read 方法把数据读取出来并存储到了 ByteBuffer 中。 运行效果如下图所示：

复制文件

通过 BIO 复制一个视频文件

package com.tntxia.test.network.bio;


import java.io.FileInputStream;
import java.io.IOException;
import java.io.FileOutputStream;


public class Test3 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("C:\\Users\\OS\\Desktop\\HSEAlert.svg");
        FileOutputStream fos=new FileOutputStream("d:\\HSEAlert.svg");
        byte[] b=new byte[1024]; while (true) {
            int res=fis.read(b);
            if(res==-1){
                break;
            }
            fos.write(b,0,res);
        }
        fis.close();
        fos.close();
    }
}

上述代码分别通过输入流和输出流实现了文件的复制，这是通过传统的 BIO 实现的，大家都比较熟悉，不再多说。

通过 NIO 复制相同的视频文件，代码：

package com.tntxia.test.network.nio;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;

public class Test4 {

    public static void main(String[] args) throws IOException {
        String fromPath = "C:\\Users\\OS\\Desktop\\HSEAlert.svg";
        String toPath = "d:\\HSEAlert.svg";
        FileInputStream fis=new FileInputStream(fromPath);
        FileOutputStream fos=new FileOutputStream(toPath);
        FileChannel sourceCh = fis.getChannel();
        FileChannel destCh = fos.getChannel();
        destCh.transferFrom(sourceCh, 0, sourceCh.size()); sourceCh.close();
        destCh.close();
    }
}

上述代码分别从两个流中得到两个通道，sourceCh 负责读数据，destCh 负责写数据，然

后直接调用 transferFrom 方法一步到位实现了文件复制。

网络 IO

概述和核心 API

前面在进行文件 IO 时用到的 FileChannel 并不支持非阻塞操作，学习 NIO 主要就是进行网络 IO，Java NIO 中的网络通道是非阻塞 IO 的实现，基于事件驱动，非常适用于服务器需 要维持大量连接，但是数据交换量不大的情况，例如一些即时通信的服务等等....

在 Java 中编写 Socket 服务器，通常有以下几种模式：

• 一个客户端连接用一个线程，优点：程序编写简单；缺点：如果连接非常多，分配的线程也会非常多，服务器可能会因为资源耗尽而崩溃。
• 把每一个客户端连接交给一个拥有固定数量线程的连接池，优点：程序编写相对简单，可以处理大量的连接。确定：线程的开销非常大，连接如果非常多，排队现象会比较严重。
• 使用 Java 的 NIO，用非阻塞的 IO 方式处理。这种模式可以用一个线程，处理大量的客户端连接。

1. Selector(选择器)，能够检测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接。这样使得只有在连接真正有读写事件发生时，才会调用函数来进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程，并且避免了多线程之间的上下文切换导致的开销。

该类的常用方法如下所示：

• public static Selector open()，得到一个选择器对象
• public int select(long timeout)，监控所有注册的通道，当其中有 IO 操作可以进行时，将对应的 SelectionKey 加入到内部集合中并返回，参数用来设置超时时间
• public Set<SelectionKey> selectedKeys()，从内部集合中得到所有的 SelectionKey

SelectionKey，代表了 Selector 和网络通道的注册关系,一共四种：

• int OP_ACCEPT：有新的网络连接可以 accept，值为 16
• int OP_CONNECT：代表连接已经建立，值为 8
• int OP_READ 和 int OP_WRITE：代表了读、写操作，值为 1 和 4

该类的常用方法如下所示：

• public abstract Selector selector()，得到与之关联的 Selector 对象
• public abstract SelectableChannel channel()，得到与之关联的通道
• public final Object attachment()，得到与之关联的共享数据
• public abstract SelectionKey interestOps(int ops)，设置或改变监听事件
• public final boolean isAcceptable()，是否可以 accept
• public final boolean isReadable()，是否可以读
• public final boolean isWritable()，是否可以写

ServerSocketChannel，用来在服务器端监听新的客户端 Socket 连接，常用方法如下所示：

• public static ServerSocketChannel open()，得到一个 ServerSocketChannel 通道
• public final ServerSocketChannel bind(SocketAddress local)，设置服务器端端口号
• public final SelectableChannel configureBlocking(boolean block)，设置阻塞或非阻塞模式，
• 取值 false 表示采用非阻塞模式
• public SocketChannel accept()，接受一个连接，返回代表这个连接的通道对象
• public final SelectionKey register(Selector sel, int ops)，注册一个选择器并设置监听事件

SocketChannel，网络 IO 通道，具体负责进行读写操作。NIO 总是把缓冲区的数据写入通

道，或者把通道里的数据读到缓冲区。常用方法如下所示：

• public static SocketChannel open()，得到一个 SocketChannel 通道
• public final SelectableChannel configureBlocking(boolean block)，设置阻塞或非阻塞模式， 取值 false 表示采用非阻塞模式
• public boolean connect(SocketAddress remote)，连接服务器
• public boolean finishConnect()，如果上面的方法连接失败，接下来就要通过该方法完成连接操作
• public int write(ByteBuffer src)，往通道里写数据
• public int read(ByteBuffer dst)，从通道里读数据
• public final SelectionKey register(Selector sel, int ops, Object att)，注册一个选择器并设置监听事件，最后一个参数可以设置共享数据
• public final void close()，关闭通道

入门案例

API 学习完毕后，接下来我们使用 NIO 开发一个入门案例，实现服务器端和客户端之间的数据通信（非阻塞）。

package com.tntxia.test.network.nio;

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;

//网络服务器端程序
public class NIOServer {
    public static void main(String[] args) throws Exception{
        //1. 得到一个 ServerSocketChannel 对象 老大
        ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
        //2. 得到一个 Selector 对象 间谍
        Selector selector=Selector.open();
        //3. 绑定一个端口号
        serverSocketChannel.bind(new InetSocketAddress(9999));
        //4. 设置非阻塞方式
        serverSocketChannel.configureBlocking(false);
        //5. 把 ServerSocketChannel 对象注册给 Selector 对象
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        //6. 干活
        while(true){
            //6.1 监控客户端
            if(selector.select(2000)==0){ //nio 非阻塞式的优势
                System.out.println("Server:没有客户端搭理我，我就干点别的事"); continue;
            }
            //6.2 得到 SelectionKey,判断通道里的事件
            Iterator<SelectionKey> keyIterator=selector.selectedKeys().iterator(); while(keyIterator.hasNext()){
                SelectionKey key=keyIterator.next();
                if(key.isAcceptable()){ //客户端连接请求事件
                    System.out.println("OP_ACCEPT");
                    SocketChannel socketChannel=serverSocketChannel.accept(); socketChannel.configureBlocking(false); socketChannel.register(selector,SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                }
                if(key.isReadable()){ //读取客户端数据事件
                    SocketChannel channel=(SocketChannel) key.channel();
                    ByteBuffer buffer=(ByteBuffer) key.attachment(); channel.read(buffer);
                    System.out.println("客户端发来数据："+new String(buffer.array()));
                }
                // 6.3 手动从集合中移除当前 key,防止重
                keyIterator.remove();
            }
        }
    }
}

上面代码用 NIO 实现了一个服务器端程序，能不断接受客户端连接并读取客户端发过来的数据。

package com.tntxia.test.network.nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

//网络客户端程序
public class NIOClient {
    public static void main(String[] args) throws Exception {
        //1. 得到一个网络通道
        SocketChannel channel = SocketChannel.open();
        //2. 设置非阻塞方式
        channel.configureBlocking(false);
        //3. 提供服务器端的 IP 地址和端口号
        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 9999);
        //4. 连接服务器端
        if (!channel.connect(address)) {
            while (!channel.finishConnect()) { //nio 作为非阻塞式的优势
                System.out.println("Client:连接服务器端的同时，我还可以干别的一些事情");
            }
        }
//5. 得到一个缓冲区并存入数据
        String msg = "hello,Server";
        ByteBuffer writeBuf = ByteBuffer.wrap(msg.getBytes());
//6. 发送数据
        channel.write(writeBuf);
        System.in.read();
    }
}

上面代码通过 NIO 实现了一个客户端程序，连接上服务器端后发送了一条数据，运行效果

如下图所示：

网络聊天案例

刚才我们通过 NIO 实现了一个入门案例，基本了解了 NIO 的工作方式和运行流程，接下来我们用 NIO 实现一个多人聊天案例，具体代码如下所示：

package com.tntxia.test.network.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;

public class ChatServer {
    private Selector selector;
    private ServerSocketChannel listenerChannel;
    private static final int PORT = 9999; //服务器端口
    public ChatServer() {
        try {
// 得到选择器
            selector = Selector.open();
// 打开监听通道
            listenerChannel = ServerSocketChannel.open();
// 绑定端口
            listenerChannel.bind(new InetSocketAddress(PORT));
// 设置为非阻塞模式
            listenerChannel.configureBlocking(false);
// 将选择器绑定到监听通道并监听 accept 事件
            listenerChannel.register(selector, SelectionKey.OP_ACCEPT);
            printInfo("Chat Server is ready.......");
        } catch (IOException e) { e.printStackTrace();
        }
    }
    public void start() {
        try { while (true) { //不停轮询
            int count = selector.select();//获取就绪 channel
            if (count > 0) {
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator(); while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
// 监听到 accept
                    if (key.isAcceptable()) {
                        SocketChannel sc = listenerChannel.accept();
//非阻塞模式
                        sc.configureBlocking(false);
//注册到选择器上并监听 read
                        sc.register(selector, SelectionKey.OP_READ);
                        System.out.println(sc.getRemoteAddress().toString().substring(1)+"上线了...");
//将此对应的 channel 设置为 accept,接着准备接受其他客
                        key.interestOps(SelectionKey.OP_ACCEPT);
                    }
//监听到 read
                    if (key.isReadable()) { readMsg(key); //读取客户端发来的数据
                    }
//一定要把当前 key 删掉，防止重复处理
                    iterator.remove();
                }
            } else {
                System.out.println("独自在寒风中等候...");
            }
        }
        } catch (IOException e) { e.printStackTrace();
        }
    }
    private void readMsg(SelectionKey key) {
        SocketChannel channel = null;
        try {
// 得到关联的通道
            channel = (SocketChannel) key.channel();
//设置 buffer 缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(1024);
//从通道中读取数据并存储到缓冲区中
            int count = channel.read(buffer);
//如果读取到了数据
            if (count > 0) {
//把缓冲区数据转换为字符串
                String msg = new String(buffer.array());
                printInfo(msg);
//将关联的 channel 设置为 read，继续准备接受数据
                key.interestOps(SelectionKey.OP_READ);
                BroadCast(channel, msg); //向所有客户端广播数据
            }
            buffer.clear();
        } catch (IOException e) {
            try {
//当客户端关闭 channel 时，进行异常如理
                printInfo(channel.getRemoteAddress().toString().substring(1) + "下线了...");
                key.cancel(); //取消注册
                channel.close(); //关闭通道
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
    public void BroadCast(SocketChannel except, String msg) throws IOException {
        System.out.println("发送广播...");
        //广播数据到所有的 SocketChannel 中
        for (SelectionKey key : selector.keys()) {
            Channel targetchannel = key.channel();
//排除自身
            if (targetchannel instanceof SocketChannel && targetchannel != except) {
                SocketChannel dest = (SocketChannel) targetchannel;
//把数据存储到缓冲区中
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
//往通道中写数据
                dest.write(buffer);
            }
        }
    }
    private void printInfo(String str) { //往控制台打印消息
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("[" + sdf.format(new Date()) + "] -> " + str);
    }
    public static void main(String[] args) {
        ChatServer server = new ChatServer(); server.start();
    }
}

上述代码使用 NIO 编写了一个聊天程序的服务器端，可以接受客户端发来的数据，并能把数据广播给所有客户端。

package com.tntxia.test.network.nio;

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 ChatClient {
    private final String HOST = "127.0.0.1"; //服务器地址
    private int PORT = 9999; //服务器端口
    private Selector selector;
    private SocketChannel socketChannel;
    private String userName;
    public ChatClient() throws IOException {
//得到选择器
        selector = Selector.open();
//连接远程服务器
        socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", PORT));
//设置非阻塞
        socketChannel.configureBlocking(false);
//注册选择器并设置为 read
        socketChannel.register(selector, SelectionKey.OP_READ);
//得到客户端 IP 地址和端口信息，作为聊天用户名使用
        userName = socketChannel.getLocalAddress().toString().substring(1);
        System.out.println("---------------Client(" + userName + ") is ready---------------");
    }
    //向服务器端发送数据
    public void sendMsg(String msg) throws Exception {
//如果控制台输入 bye 就关闭通道，结束聊天
        if (msg.equalsIgnoreCase("bye")) { socketChannel.close(); socketChannel = null; return;
        }msg = userName + "说: " + msg;
        try {
//往通道中写数据
            socketChannel.write(ByteBuffer.wrap(msg.getBytes()));
        } catch (IOException e) { e.printStackTrace();
        }
    }
    //从服务器端接收数据
    public void receiveMsg() {
        try {
            int readyChannels = selector.select();
            if (readyChannels > 0) { //有可用通道
                Set selectedKeys = selector.selectedKeys();
                Iterator keyIterator = selectedKeys.iterator(); while (keyIterator.hasNext()) {
                    SelectionKey sk = (SelectionKey) keyIterator.next();
                    if (sk.isReadable()) {
//得到关联的通道
                        SocketChannel sc = (SocketChannel) sk.channel();
//得到一个缓冲区
                        ByteBuffer buff = ByteBuffer.allocate(1024);
//读取数据并存储到缓冲区
                        sc.read(buff);
//把缓冲区数据转换成字符串
                        String msg = new String(buff.array());
                        System.out.println(msg.trim());
                    }
                    keyIterator.remove(); //删除当前 SelectionKey，防止重复处理
                }
            } else {
                System.out.println("人呢？都去哪儿了？没人聊天啊...");
            }
        } catch (IOException e) { e.printStackTrace();
        }
    }
}

上述代码通过 NIO 编写了一个聊天程序的客户端，可以向服务器端发送数据，并能接收服务器广播的数据

package com.tntxia.test.network.nio;

import java.util.Scanner;

public class TestChat {
    public static void main(String[] args) throws Exception {
//创建一个聊天客户端对象
        ChatClient chatClient = new ChatClient(); new Thread() { //单独开一个线程不断的接收服务器端广播的数据
            public void run() { while (true) { chatClient.receiveMsg();
                try { //间隔 3 秒
                    Thread.currentThread().sleep(3000);
                } catch (InterruptedException e) { e.printStackTrace();
                }
            }
            }
        }.start();
        Scanner scanner = new Scanner(System.in);
//在控制台输入数据并发送到服务器端
        while (scanner.hasNextLine()) {
            String msg = scanner.nextLine(); chatClient.sendMsg(msg);
        }
    }
}

上述代码运行了聊天程序的客户端，并在主线程中发送数据，在另一个线程中不断接收服务

器端的广播数据，该代码运行一次就是一个聊天客户端，可以同时运行多个聊天客户端，聊 天效果如下图所示：

AIO 编程

JDK 7 引入了 Asynchronous I/O，即 AIO。在进行 I/O 编程中，常用到两种模式：Reactor

和 Proactor。Java 的 NIO 就是 Reactor，当有事件触发时，服务器端得到通知，进行相应的 处理。 AIO 即 NIO2.0，叫做异步不阻塞的 IO。AIO 引入异步通道的概念，采用了 Proactor 模式， 简化了程序编写，一个有效的请求才启动一个线程，它的特点是先由操作系统完成后才通知 服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。

对比总结

IO 对比总结

IO 的方式通常分为几种：同步阻塞的 BIO、同步非阻塞的 NIO、异步非阻塞的 AIO。

• BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并 发局限于应用中，JDK1.4 以前的唯一选择，但程序直观简单易理解。
• NIO 方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局 限于应用中，编程比较复杂，JDK1.4 开始支持。
• AIO 方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调 用 OS 参与并发操作，编程比较复杂，JDK7 开始支持。

举个例子再理解一下：

• 同步阻塞：你到饭馆点餐，然后在那等着，啥都干不了，饭馆没做好，你就必须等着！
• 同步非阻塞：你在饭馆点完餐，就去玩儿了。不过玩一会儿，就回饭馆问一声：好了没啊！
• 异步非阻塞：饭馆打电话说，我们知道您的位置，一会给你送过来，安心玩儿就可以了，类似于现在的外卖。

对比总结	BIO	NIO	AIO
IO 方式	同步阻塞	同步非阻塞（多路复用）	异步非阻塞
API 使用难	简单	复杂	复杂
可靠性	差	好	好
吞吐量	低	高	高