BIO、NIO、AIO

Benjamin Cheung

已于 2022-12-14 23:44:04 修改

阅读量278

点赞数

分类专栏： Java基础文章标签： nio java 服务器

于 2022-12-11 22:04:11 首次发布

本文链接：https://blog.csdn.net/weixin_43732943/article/details/128279487

版权

Java基础专栏收录该内容

32 篇文章 0 订阅

订阅专栏

Java BIO

同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就
需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销
在这里插入图片描述

Java BIO基本介绍

.Java BlO就是传统的Java IO编程，其相关的类和接口在Java.io 包中
BIO(blocking I/O)同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器
端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过
线程池机制改善（实现多个客户连接服务器）.
在这里插入图片描述

传统的BIO编程实例回顾

网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信
（绑定IP地址和端口），客户端通过连接操作向服务端监听的端口地址发起连接请求，基于TCP协议下
进行三次握手连接，连接成功后，双方通过网络套接字（Socket）进行通信。
传统的同步阻塞模型开发中，服务端ServerSocket负责绑定IP地址，启动监听端口；客户端Socket负责
发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。
基于BIO模式下的通信，客户端-服务端是完全同步，完全藕合的。
1，客户端案例如下

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

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        try {
            //1.创建Socket对象请求服务端的连接
            Socket socket = new Socket("127.0.0.1",9999);
            //2.从Socket对象中获取一个字节输出流
            OutputStream os = socket.getOutputStream();
            //3.把字节输出流包装成一个打印流
            PrintStream ps = new PrintStream(os);
            //ps.print("hello World! 服务端，你好");
            ps.println("hello World! 服务端，你好");
            ps.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2，服务端案例如下

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 客户端发送消息，服务端接收消息
 */
public class Server {
    public static void main(String[] args) throws IOException {
        System.out.println("===服务端启动===");
        //1.定义一个ServerSocket对象进行服务端的端口注册
        ServerSocket ss = new ServerSocket(9999);
        //2. 监听客户端的Socket连接请求
        Socket socket = ss.accept();
        //3.从socket管道中得到一个字节输入流对象
        InputStream is = socket.getInputStream();
        //4.把字节输入流包装成一个缓存字符输入流
        //字节流-->字符流
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        String msg;
        if ((msg = br.readLine()) != null){
            System.out.println("服务端接收到：" + msg);
        }
    }
}

3，输出

===服务端启动===
服务端接收到：hello World! 服务端，你好

小结
在以上通信中，服务端会一直等待客户端的消息，如果客户端没有进行消息的发送，服务端将一直
进入阻塞状态
同时服务端是按照行获取消息的，这意味育客户端也必须按照行进行消息的发送，否则服务端将进
入等待消息的阻塞状态！

BIO模式下一个客户端多发和一个客户端多收消息

在上面的案例中，只能实现客户端发送消息，服务端接收消息，并不能实现反复的收消息和反复的发消
息，我们只需要在客户端案例中，加上反复按照行发送消息的逻辑即可！案例代码如下：
1，客户端代码如下

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;
/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        try {
            //1.创建Socket对象请求服务端的连接
            Socket socket = new Socket("127.0.0.1",9999);
            //2.从Socket对象中获取一个字节输出流
            OutputStream os = socket.getOutputStream();
            //3.把字节输出流包装成一个打印流
            PrintStream ps = new PrintStream(os);

            Scanner sc = new Scanner(System.in);
            while (true){
                System.out.print("请说：");
                String msg = sc.nextLine();
                ps.println(msg);
                ps.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2，服务端代码如下

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * 客户端发送消息，服务端接收消息
 */
public class Server {
    public static void main(String[] args) throws IOException {
        System.out.println("===服务端启动===");
        //1.定义一个ServerSocket对象进行服务端的端口注册
        ServerSocket ss = new ServerSocket(9999);
        //2. 监听客户端的Socket连接请求
        Socket socket = ss.accept();
        //3.从socket管道中得到一个字节输入流对象
        InputStream is = socket.getInputStream();
        //4.把字节输入流包装成一个缓存字符输入流
        //字节流-->字符流
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        String msg;
        while ((msg = br.readLine()) != null){
            System.out.println("服务端接收到：" + msg);
        }
    }
}

3，输出

客户端：
请说：hello
请说：what are you doing?
请说：
服务端：
===服务端启动===
服务端接收到：hello
服务端接收到：what are you doing?

BIO模式下接收多个客户端

在上述的案例中，一个服务端只能接收一个客户端的通信请求，那么如果服务端需要处理很多个客户端
的消息通信请求应该如何处理呢，此时我们就需要在服务端引入线程了，也就是说客户端每发起一个请
求，服务端就创建一个新的线程来处理这个客户端的请求，这样就实现了一个客户端一个线程的模型，
图解模式如下：
在这里插入图片描述
1，客户端案例代码

import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        try {
            //1.请求与服务端的Socket对象连接
            Socket socket = new Socket("127.0.0.1",9999);
            //2. 得到一个打印流
            PrintStream ps = new PrintStream(socket.getOutputStream());
            //3. 使用循环不断的发送消息给服务端接收
            Scanner sc = new Scanner(System.in);
            while (true){
                System.out.println("请说：");
                String msg =sc.nextLine();
                ps.println(msg);
                ps.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2，服务端案例代码

import java.net.ServerSocket;
import java.net.Socket;

/**
 * 目标：服务端可以实现同时接收多个客户端的Socket通信需求
 * 思路：服务端没接收到一个客户端socket请求对象之后都交给一个独立的线程来处理客户端的数据交互需
 求
 */
public class Server {
    public static void main(String[] args) {
        try {
            //1.注册端口
            ServerSocket ss = new ServerSocket(9999);
            //2.定义一个死循环，负责不断的接收客户端的Socket的连接请求
            while(true){
                Socket socket = ss.accept();
                //3.创建一个独立的线程来处理与这个客户端的socket通信需求
                new ServerThreadReader(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3，线程类

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class ServerThreadReader extends Thread{

    private Socket socket;
    public ServerThreadReader(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //从socket对象中得到一个字节输入流
            InputStream is = socket.getInputStream();
            //使用缓存字符输入流包装字节输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println(msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4，输出

===client1:
请说：
ppp
请说：
你在干嘛？
请说：
我是第一个client
请说：
===client2:
请说：
lll
请说：
还钱！！！
请说：
我是第二个client
请说：
===client3:
请说：
我是第三个client
请说：
===server:
lll
ppp
你在干嘛？
还钱！！！
我是第二个client
我是第一个client
我是第三个client

小结
每个Socket接收到，都会创建一个线程，线程的竞争、切换上下文影响性能；
每个线程都会占用栈空间和CPU资源；
并不是每个socket都进行lO操作，无意义的线程处理；
客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，
线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

伪异步I/O编程

概述
在上述案例中：客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程
栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。
接下来我们采用一个伪异步I/O的通信框架，采用线程池和任务队列实现，当客户端接入时，将客户端的
Socket封装成一个Task(该任务实现Java. lang. Runnable(线程任务接口）交给后端的线程池中进行处
理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息队列中Socket任务进行处理，由于线程池
可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，
都不会导致资源的耗尽和宕机。
如下图所示：
在这里插入图片描述
1，客户端

import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        try {
            //1.请求与服务端的Socket对象连接
            Socket socket = new Socket("127.0.0.1",9999);
            //2. 得到一个打印流
            PrintStream ps = new PrintStream(socket.getOutputStream());
            //3. 使用循环不断的发送消息给服务端接收
            Scanner sc = new Scanner(System.in);
            while (true){
                System.out.println("请说：");
                String msg =sc.nextLine();
                ps.println(msg);
                ps.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2，线程池处理类

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class HandlerSocketServerPool {
    //1. 创建一个线程池的成员变量用于存储一个线程池对象
    private ExecutorService executorService;
    /**
     * 2.创建这个类的的对象的时候就需要初始化线程池对象
     * public ThreadPoolExecutor(int corePoolSize,
     * int maximumPoolSize,
     * long keepAliveTime,
     * TimeUnit unit,
     * BlockingQueue<Runnable> workQueue)
     */
    public HandlerSocketServerPool(int maxThreadNum, int queueSize){
        executorService = new ThreadPoolExecutor(3,maxThreadNum,120,
                TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
    }
    /**
     * 3.提供一个方法来提交任务给线程池的任务队列来暂存，等待线程池来处理
     */
    public void execute(Runnable target){
        executorService.execute(target);
    }
}

3，Socket任务类

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class ServerRunnableTarget implements Runnable {
    private Socket socket;
    public ServerRunnableTarget(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        //处理接收到的客户端socket通信需求
        try {
            //1.从socket管道中得到一个字节输入流对象
            InputStream is = socket.getInputStream();
            //2.把字节输入流包装成一个缓存字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while((msg = br.readLine()) != null){
                System.out.println("服务端收到：" + msg);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

4，服务端

import java.net.ServerSocket;
import java.net.Socket;

/**
 * 目标：开发实现伪异步通讯架构
 * 思路：服务端没接收到一个客户端socket请求对象之后都交给一个独立的线程来处理客户端的数据交互需
 求
 */
public class Server {
    public static void main(String[] args) {
        try {
            //1.注册端口
            ServerSocket ss = new ServerSocket(9999);
            //2.定义一个死循环，负责不断的接收客户端的Socket的连接请求
            //初始化一个线程池对象
            HandlerSocketServerPool pool = new HandlerSocketServerPool(3,10);
            while(true){
                Socket socket = ss.accept();
                //3.把socket对象交给一个线程池进行处理
                //把socket封装成一个任务对象交给线程池处理
                Runnable target = new ServerRunnableTarget(socket);
                pool.execute(target);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5，输出

服务端收到：client1
服务端收到：client2
服务端收到：client3
服务端收到：client4
java.net.SocketException: Connection reset
at java.base/java.net.SocketInputStream.read(SocketInputStream.java:186)
at java.base/java.net.SocketInputStream.read(SocketInputStream.java:140)
at java.base/sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
at java.base/sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
at java.base/sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
at java.base/java.io.InputStreamReader.read(InputStreamReader.java:185)
at java.base/java.io.BufferedReader.fill(BufferedReader.java:161)
at java.base/java.io.BufferedReader.readLine(BufferedReader.java:326)
at java.base/java.io.BufferedReader.readLine(BufferedReader.java:392)
at com.zhangxudong.ServerRunnableTarget.run(ServerRunnableTarget.java:23)
at
java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.j
ava:1128)
at
java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.
java:628)
at java.base/java.lang.Thread.run(Thread.java:834)
服务端收到：client5

小结
伪异步旧采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但由于底层依然是采用的同步阻塞模型，因此无法从根采上解决问题。
如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的I/O消息都将在队列中排队。新的Socket请求将被拒绝，客户端会发生大量连接超时。

基于BIO形式下的文件上传

1，客户端开发

import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.Socket;

/**
 * 目标：实现客户端上传任意类型的文件数据给服务端保存起来
 */
public class Client {
    public static void main(String[] args) {
        try(InputStream is = new FileInputStream("D:\\Doc\\java\\dozer.PNG");){
            //1.请求与服务端的Socket连接
            Socket socket = new Socket("127.0.0.1", 8888);
            //2.把字节输出流包装成一个数据输出流(DataOutputStream可以做分段数据发送)
            DataOutputStream dos = new
            DataOutputStream(socket.getOutputStream());
            //3.先发送上传文件的后缀给服务器
            dos.writeUTF(".jpg");
            //4.把文件数据发送给服务端进行接收
            //InputStream is = new FileInputStream("D:\Doc\java\dozer.PNG");
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) > 0){
                dos.write(buffer,0,len);
            }
            dos.flush();
            socket.shutdownOutput();//通知服务端，我客户端这边的数据已经发送完毕了
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

2，服务端开发

import java.net.ServerSocket;
import java.net.Socket;

/**
 * 目标：服务端开发，可以实现接收客户端的任意类型文件，并保存到服务器端磁盘
 */
public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(8888);
            while(true){
                Socket socket = ss.accept();
                //交给一个独立的线程来处理与这个客户端的文件通信需求
                new ServerReadThread(socket).start();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

3，Socket线程处理类

import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.UUID;

public class ServerReadThread extends Thread {

    private Socket socket;
    public ServerReadThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //1.得到一个数据输入流来读取客户端发送过来的数据
            DataInputStream dis = new DataInputStream(socket.getInputStream());
            //2.读取客户端发送过来的文件类型
            String suffix = dis.readUTF();
            System.out.println("服务端已经成功接收到了文件类型：" + suffix);
            //3.定义一个字节输出管道，负责把客户端发来的文件数据写出去
            OutputStream os = new
                    FileOutputStream("D:\\Doc\\java\\server\\"
                    + UUID.randomUUID().toString() + suffix);
            //4.从数据输入流中读取文件数据，写出到字节输出流中去
            byte[] buffer = new byte[1024];
            int len;
            while ((len = dis.read(buffer)) > 0){
                os.write(buffer,0,len);
            }
            os.close();//应该写到finally中
            System.out.println("服务端接收文件保存成功！");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

4，输出

服务端已经成功接收到了文件类型：.jpg
服务端接收文件保存成功！

小结
同步阻塞模式下（BIO)，客户端怎么发，服务端就必须对应的怎么收。如客户端用的是
DataOutputStream，那么服务端就该用DataInputStream，客户端dos.writeUTF(“.jpg”);服务端就该String suffix = dis.readUTF();
客户端发完数据后必须通知服务端自己已经发完socket.shutdownOutput()，否则服务端会一直等待。

Java BIO模式下的端口转发思想

需要实现一个客户端的消息可以发送给所有的客户端去接收。（群聊实现）
在这里插入图片描述
1，客户端开发

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args){
        try {
            //1.请求与服务端的Socket对象连接
            Socket socket = new Socket("127.0.0.1", 9999);
            //收消息
            Thread clientThread = new ClientReaderThread(socket);
            clientThread.start();
            while (true){
                //发消息
                OutputStream os = socket.getOutputStream();
                PrintStream ps = new PrintStream(os);
                //3. 使用循环不断的发送消息给服务端接收
                Scanner sc = new Scanner(System.in);
                //System.out.print("client send message：");
                String msg =sc.nextLine();
                ps.println(msg);
                ps.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

2，客户端线程处理类

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class ClientReaderThread extends Thread {
    private Socket socket;
    public ClientReaderThread(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try{
            while (true){
                InputStream is = socket.getInputStream();
                //4.把字节输入流包装成一个缓存字符输入流
                BufferedReader br = new BufferedReader(new
                        InputStreamReader(is));
                String msg;
                /* while ((msg = br.readLine()) != null){
                System.out.println("client recive message：" + msg);
                }*/
                if((msg = br.readLine()) != null){
                    //System.out.println("client recive message：" + msg);
                    System.out.println(msg);
                }
            }
        }catch (Exception e){
        }
    }
}

3，服务端开发

import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 * 目标：BIO模式下的端口转发思想-服务端实现
 * 服务端实现需求：
 * 1.注册端口
 * 2.接收客户端的socket连接，交给一个独立的线程来处理
 * 3.把当前连接的客户端socket存入到一个所谓的在线socket集合中保存
 * 4.接收客户端的消息，然后推动给当前所有的在线socket接收
 */
public class Server {
    //定义一个静态集合
    public static List<Socket> allSocketOnLine = new ArrayList<>();
    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(9999);
            while (true){
                Socket socket = ss.accept();
                //把登录的客户端socket存入到一个在线集合中去
                allSocketOnLine.add(socket);
                //为当前登录成功的socket分配一个独立的线程来处理与之通信
                new ServerReaderThread(socket).start();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

4，服务端线程处理类

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;

public class ServerReaderThread extends Thread{
    private Socket socket;
    public ServerReaderThread(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            //1.从socket中去获取当前客户端的输入流
            BufferedReader br = new BufferedReader(new
                    InputStreamReader(socket.getInputStream()));
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println("服务器收到消息：" + msg);
                //2.服务端接收到了客户端的消息后，需要推送给所有的当前在线的socket
                sendMsgToAllClient(msg,socket);
            }
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("当前有人下线了！");
            //从在线socket集合中移除本socket
            Server.allSocketOnLine.remove(socket);
        }
    }
    /**
     * 把当前客户端发送来的消息推送给全部在线的socket
     * @param msg
     */
    private void sendMsgToAllClient(String msg,Socket socket) throws Exception {
        for(Socket sk : Server.allSocketOnLine){
            //只发送给除自己以外的其他客户端
            if(socket != sk){
                PrintStream ps = new PrintStream(sk.getOutputStream());
                ps.println(msg);
                ps.flush();
            }
        }
    }
}

5，输出

# 服务端
服务器收到消息：大家好，我是客户端一
服务器收到消息：哈哈哈哈
服务器收到消息：大家好，我是client2
服务器收到消息：嘻嘻嘻嘻
服务器收到消息：hello everyone
服务器收到消息：i am client3
#客户端一
大家好，我是客户端一 --发送
哈哈哈哈 --发送
大家好，我是client2 --接收
嘻嘻嘻嘻 --接收
hello everyone --接收
i am client3 --接收
#客户端二
大家好，我是客户端一 --接收
哈哈哈哈 --接收
大家好，我是client2 --发送
嘻嘻嘻嘻 --发送
hello everyone --接收
i am client3 --接收
#客户端三
大家好，我是客户端一 --接收
哈哈哈哈 --接收
大家好，我是client2 --接收
嘻嘻嘻嘻 --接收
hello everyone --发送
i am client3 --发送

JAVA NIO

java NIO基本介绍

java NlO (New lO）也有人称之为java non-blocking IO是Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java lO API。 NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。
NIO可以理解为非阻塞IO，传统的IO 的read和write只能阻塞执行，线程在读写期间不能干其他事情，比如调用socket. read(）时，如果服务器一直没有数据传输过来，线程就一直阻塞，而NIO中可以配置socket为非阻塞模式。
NIO相关类都被放在java.nio包及子包下，并且对原Java.io包中的很多类进行改写。
NIO有三大核心部分：Channel（通道）,Buffer(缓冲区）,Selector（选择器）
Java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据；如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。
通俗理解：NIO是可以做到用一个线程来处理多个操作的。假设有1000个请求过来，根据实际情况，可以分配20或者80个线程来处理。不像之前的阻塞IO那样，非得分配1000个。

NIO和BIO的比较

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

NIO	BIO
面向缓存区（Buffer)	面向流（Stream)
非阻塞（Non Blocking IO)	阻塞IO(Blocking IO)
选择器（Selector)

NIO三大核心原理示意图

NIO有三大核心部分：Channel(通道)，Buufer(缓存区)，Selector(选择器)
Buffer缓存区
缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。相比较直接对数组的操作，Buffer API更加容易操作和管理。

Channel通道
Java NIO的通道类似流，但又有些不同：既可以从通道中读取数据，又可以写数据到通道。但流的（(input或 output)读写通常是单向的。通道可以非阻塞读取和写入通道，通道可以支持读取或写入缓冲区，也支持异步地读写。

Selector选择器
Selector是一个ava NIO组件，可以能够检查一个或多个NIO通道，并确定哪些通道已经准备好进行读取或写入。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接，提高效率
在这里插入图片描述
每个channel都会对应一个Buffer
一个线程对应Selector，一个Selector对应多个channel（连接）
程序切换到哪个channel是由事件决定的
Selector会根据不同的事件，在各个通道上切换
Buffer就是一个内存块，底层是一个数组
数据的读取写入是通过Buffer完成的，BIO中要么是输入流，或者是输出流，不能双向，但是NIO的Buffer是可以读也可以写。
Java NIO系统的核心在于：通道（Channel）和缓存区（Buffer)。通道表示打开到IO设备（例如：文件、套接字）的连接。若需要使用NlO系统，需要获取用于连接IO设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。简而言之，Channel负责传输，Buffer负责存取数据

NIO核心一：缓存区（Buffer)

容量（capacity)：作为一个内存块，Buffer具有一定的固定大小，也称为”容量”，缓冲区容量不能为负，并且创建后不能更改。
限制（limit)：表示缓冲区中可以操作数据的大小（limit后数据不能进行读写）。缓冲区的限制不能为负，并且不能大于其容量。写入模式，限制等于buffer的容量。读取模式下，limit等于写入的数据量。
位置(position)：下一个要读取或写入的数据的索引。缓’中区的位置不能为负，并且不能大于其限制
标记（mark）与重置（reset)：标记是一个索引，通过Buffer中的mark(）方法指定Buffer中一个特定的 position，之后可以通过调用reset(）方法恢复到这个position。标记、位置、限制、容量遵守以T不变式：0<=mark<=position<=limit<=capacity

使用Buffer读写数据一般遵循以下四个步骤：
1.写入数据到Buffer
2.调用flip()方法，转换为读取模式
3.从Buffer中读取数据
4.调用buffer.clear()方法或则buffer.compact()方法清除缓存区

import org.junit.Test;
import java.nio.ByteBuffer;

/**
 目标：对缓存区Buffer的常用API进行案例实现

 Buffer clear(）清空缓冲区并返回对缓冲区的引用
 Buffer flip(）为将缓冲区的界限设置为当前位置，并将当前位置重置为0
 int capacity(）返回Buffer的容量大小
 boolean hasRemaining(）判断缓冲区中是否还有元素
 int limit(）返回Buffer的界限（limit）的位置
 Buffer limit(int n）将设置缓冲区界限为n，并返回一个具有新limit的缓冲区对象
 Buffer mark(）对缓冲区设置标记
 int position(）返回缓冲区的当前位置position
 Buffer position(int n）将设置缓冲区的当前位置为n，并返回修改后的Buffer对象
 int remaining()返回position和limit之间的元素个数
 Buffer reset(）将位置position转到以前设置的mark所在的位置
 Buffer rewind();将位置设为为0．取消设置的mark
 */
public class BufferTest {
    @Test
    public void test01(){
        //1.分配一个缓存区，容量设置为10
        ByteBuffer buffer = ByteBuffer.allocate(10);
        System.out.println(buffer.position());//0
        System.out.println(buffer.limit());//10
        System.out.println(buffer.capacity());//10
        System.out.println("-----------------------");
        //put 往缓存区中添加数据
        String name = "ben";
        buffer.put(name.getBytes());
        System.out.println(buffer.position());//当前位置是3
        System.out.println(buffer.limit());//界限10
        System.out.println(buffer.capacity());//容量10
        System.out.println("-----------------------");
        //3.flip() 为 将缓存区的界限设置为当前位置，并将当前位置设置为 0 可读模式
        buffer.flip();
        System.out.println(buffer.position());//0
        System.out.println(buffer.limit());//3
        System.out.println(buffer.capacity());//10
        System.out.println("-----------------------");
        //4. get数据的读取
        char ch = (char) buffer.get();
        System.out.println(ch);//b
        System.out.println(buffer.position());//当前位置是1
        System.out.println(buffer.limit());//界限3
        System.out.println(buffer.capacity());//容量10
    }
    @Test
    public void test02(){
        //1.分配一个缓存区，容量设置为10
        ByteBuffer buffer = ByteBuffer.allocate(10);
        System.out.println(buffer.position());//0
        System.out.println(buffer.limit());//10
        System.out.println(buffer.capacity());//10
        System.out.println("-----------------------");
        String name = "ben";
        buffer.put(name.getBytes());
        System.out.println(buffer.position());//3
        System.out.println(buffer.limit());//10
        System.out.println(buffer.capacity());//10
        System.out.println("-----------------------");
        //2.clear 清楚缓存区中的数据
        buffer.clear();
        System.out.println(buffer.position());//0
        System.out.println(buffer.limit());//10
        System.out.println(buffer.capacity());//10
        System.out.println((char)buffer.get());//b 表明数据并没有清除 只是恢复了position的位置
        System.out.println("-----------------------");
        //3.定义一个缓存区
        ByteBuffer buf = ByteBuffer.allocate(10);
        String n = "benjamin";
        buf.put(n.getBytes());
        buf.flip();
        //读取数据
        byte[] b = new byte[2];
        buf.get(b);
        String rs = new String(b);
        System.out.println(rs);//be
        System.out.println(buf.position());//2
        System.out.println(buf.limit());//8
        System.out.println(buf.capacity());//10
        System.out.println("-----------------------");
        buf.mark();//标记此刻这个位置：2
        byte[] b2 = new byte[3];
        buf.get(b2);
        System.out.println(new String(b2));//nja
        System.out.println(buf.position());//5
        System.out.println(buf.limit());//8
        System.out.println(buf.capacity());//10
        System.out.println("-----------------------");
        buf.reset();//回到标记位置 2
        if(buf.hasRemaining()){//是否有剩余数据
            System.out.println(buf.remaining());//6
        }
    }
    @Test
    public void test03(){
        //创建一个非直接内存的缓存区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //buffer.isDirect()用于判断是否为直接内存
        System.out.println(buffer.isDirect());//false
        System.out.println("----------------");
        //创建一个直接内存的缓存区
        ByteBuffer buffer2 = ByteBuffer.allocateDirect(1024);
        System.out.println(buffer2.isDirect());//true
    }
}

直接与非直接缓存区
直接内存（也就是非堆内存）；另一种是非直接内存（也就是堆内存）。对于直接内存来说，JVM将会在IO操作上具有更高的性能，因为它直接作用于本地系统的IO操作。而非直接内存，也就是堆内存中的数据，如果要作IO操作，会先从本进程内存复制到直接内存，再利用本地IO处理。
使用场景
1 有很大的数据需要存储，他的生命周期又很长
2 适合频繁的IO操作，比如网络并发场景

BIO核心二：通道（Channel）

通道（Channel)：由java.nio.channels包定义的。Channel表示IO源与目标打开的连接。Channel类似于传统的“流”。只不过Channel本身不能直接访问数据，Channel只能与Buffer进行交互。
1、NIO的通道类似于流，但有些区别如下
通道可以同时进行读写，而流只能读或者只能写
通道可以实现异步读写数据
通道可以从缓冲读数据，也可以写数据到缓冲
2、BlO中的stream是单向的，例如FilelnputStream对象只能进行读取数据的操作，而NIO中的通道（Channel)是双向的，可以读操作，也可以写操作。
3、Channel在NIO中是一个接口

import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class ChannelTest {
    /**
     本地文件写数据
     */
    @Test
    public void write(){
        try{
            //1.字节输出流通向目标文件
            FileOutputStream fos = new FileOutputStream("data01_txt");
            //2.得到字节输出流对应的通道Channel
            FileChannel channel = fos.getChannel();
            //3.分配缓存区
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put("hello，java程序员！".getBytes());
            //4.把缓存区切换为写模式
            buffer.flip();
            channel.write(buffer);
            channel.close();
            System.out.println("写数据到文件中！");
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     本地文件读数据
     */
    @Test
    public void read() throws Exception {
        //1.定义一个文件字节输入流与源文件接通
        FileInputStream is = new FileInputStream("data01_txt");
        //2.需要得到文件字节输入流的文件通道
        FileChannel channel = is.getChannel();
        //3.定义一个缓存区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //4.读取数据到缓存区
        channel.read(buffer);
        buffer.flip();//归位
        //5.读取出缓存区中的数据并输出即可
        String rs = new String(buffer.array(),0,buffer.remaining());
        System.out.println(rs);//hello，java程序员！
    }

    /**
     使用Buffer完成文件复制
     */
    @Test
    public void copy() throws Exception {
        //源文件
        File srcFile = new File("D:\\Building\\5建高新一中\\张佳晨资料.docx");
        File destFile = new File("D:\\Building\\5建高新一中\\张佳晨资料1.docx");
        //得到一个字节输出流、字节输入流
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);
        //得到文件通道
        FileChannel fisChannel = fis.getChannel();
        FileChannel fosChannel = fos.getChannel();
        //分配缓存区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        while (true){
            //必须先清空缓存区然后再写入数据到缓存区
            buffer.clear();
            //开始读取一次数据
            int flag = fisChannel.read(buffer);
            if(flag == -1){
                break;
            }
            //已经读取了数据，把缓存区的模式切换为可读模式
            buffer.flip();
            //把数据写出到
            fosChannel.write(buffer);
        }
        fisChannel.close();
        fosChannel.close();
        System.out.println("复制完成");
    }

    /**
     分散（Scatter)和聚集（Gatter)
     分散读取（Scatter)：是指把Channel通道的数据读取入到多个缓存区中去
     聚集写入（Gathering)：是指将多个Buffer中的数据聚集到Channel。
     */
    @Test
    public void test() throws Exception{
        //1.字节输入管道
        FileInputStream is = new FileInputStream("data01_txt");
        FileChannel isChannel = is.getChannel();
        //2.字节输出管道
        FileOutputStream os = new FileOutputStream("data02_txt");
        FileChannel osChannel = os.getChannel();
        //3.定义多个缓存区做数据分散
        ByteBuffer buffer1 = ByteBuffer.allocate(4);
        ByteBuffer buffer2 = ByteBuffer.allocate(1024);
        ByteBuffer[] buffers = {buffer1,buffer2};
        //4.从通道中读取数据分散到各个缓存区
        isChannel.read(buffers);
        //5.从每个缓存区中查询是否有数据读取到了
        for(ByteBuffer buffer : buffers){
            buffer.flip();//切换到读数据模式
            System.out.println(new String(buffer.array(),0,buffer.remaining()));
        }
        //6.聚集写入到通道
        osChannel.write(buffers);
        isChannel.close();
        osChannel.close();
        System.out.println("文件复制~");
    }

    /**
     * transferFrom从目标通道中去复制原通道数据
     */
    @Test
    public void test02() throws Exception{
        //1.字节输入管道
        FileInputStream is = new FileInputStream("data01_txt");
        FileChannel isChannel = is.getChannel();//原通道
        //2.字节输出管道
        FileOutputStream os = new FileOutputStream("data03_txt");
        FileChannel osChannel = os.getChannel();//目标通道
        //3.复制数据
        osChannel.transferFrom(isChannel,isChannel.position(),isChannel.size());
        isChannel.close();
        osChannel.close();
        System.out.println("复制完成！");
    }

    /**
     * transferTo把原通道数据复制到目标通道
     */
    @Test
    public void test03() throws Exception{
        //1.字节输入管道
        FileInputStream is = new FileInputStream("data01_txt");
        FileChannel isChannel = is.getChannel();
        //2.字节输出管道
        FileOutputStream os = new FileOutputStream("data04_txt");
        FileChannel osChannel = os.getChannel();
        //3.复制数据
        //osChannel.transferFrom(isChannel,isChannel.position(),isChannel.size());
        isChannel.transferTo(isChannel.position(),isChannel.size(),osChannel);
        isChannel.close();
        osChannel.close();
        System.out.println("复制完成！");
    }
}

NIO核心三：选择器（Selector)

选择器（Selector）是SeIectabIeChannIe对象的多路复用器，Selector可以同时监控多个
SelectableChannel 的IO状况，也就是说，利用Selector可使一个单独的线程管理多个Channel。
Selector是非阻塞IO的核心
java的NIO，用非阻塞的IO方式。可以用一个线程，处理多个的客户端连接，就会使用到Selector（选择器）
Selector能够检测多个注册的通道上是否有事件发生（注意：多个Channel以事件的方式可以注册到同一个 Selector)，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。
只有在连接／通道真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程避免了多线程之间的上下文切换导致的开销
在这里插入图片描述

NIO非阻塞式网络通信入门案例

需求：服务端接收客户端的连接请求，并接收多个客户端发送过来的事件
1，客户端

package com.ben.one;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Scanner;

/**
 * 目标：客户端案例实现-基于NIO非阻塞通信
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //1.获取通道
        SocketChannel sChannel = SocketChannel.open(new
                InetSocketAddress("127.0.0.1",9999));
        //2.切换为非阻塞模式
        sChannel.configureBlocking(false);
        //3.分配指定缓存区大小
        ByteBuffer buf = ByteBuffer.allocate(1024);
        //4.发送数据给服务端
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请输入：");
            String msg = sc.nextLine();
            buf.put(("波仔：" + msg).getBytes());
            buf.flip();
            //通道将数据写出去
            sChannel.write(buf);
            buf.clear();
        }
    }
}

2，服务端

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;

/**
 * 目标：NIO非阻塞通信下的入门案例：服务端开发
 */
public class Server {
    public static void main(String[] args) throws IOException {
        System.out.println("---服务端启动---");
        //1.获取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        //2.切换为非阻塞模式
        ssChannel.configureBlocking(false);
        //3.绑定连接的端口
        ssChannel.bind(new InetSocketAddress(9999));
        //4.获取选择器
        Selector selector = Selector.open();
        //5.将通道都注册到选择器上去，并且开始指定监听接收事件
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        //6.使用Selector选择器轮询已经就绪好的事件
        while(selector.select() > 0){
            //System.out.println("开始一轮事件处理~~~");
            //7.获取选择器中的所有注册的通道中已经就序好的事件
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            //8.开始遍历这些准备好的事件
            while(it.hasNext()){
                //提取当前这个事件
                SelectionKey sk = it.next();
                //9.判断这个事件具体是什么事件
                if(sk.isAcceptable()){ //接入事件
                    System.out.println("接入事件处理~~~");
                    //10.直接获取当前接入的客户端通道
                    SocketChannel schannel = ssChannel.accept();
                    //11.将客户端通道也设置为非阻塞式的
                    schannel.configureBlocking(false);
                    //12.将客户端通道也注册到选择器Selector上
                    schannel.register(selector,SelectionKey.OP_READ);
                }else if(sk.isReadable()){ //读事件
                    System.out.println("读就绪事件处理~~~");
                    //13.获取当前选择器上的"读就绪事件"
                    SocketChannel sChannel = (SocketChannel) sk.channel();
                    //14.开始读取数据
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    int len = 0;
                    while ((len = sChannel.read(buf)) > 0){
                        buf.flip();
                        System.out.println(new String(buf.array(),0,len));
                        buf.clear();//"清除"之前的数据
                    }
                }
                //处理完毕当前事件后，需要移除掉当前事件.否则会重复处理
                it.remove();
            }
        }
    }
}

3，运行结果

---服务端启动---
接入事件处理~~~
读就绪事件处理~~~
波波：hi
接入事件处理~~~
读就绪事件处理~~~
波仔：hi

NIO网络编程应用实例-群聊系统

需求：进一步理解NIO非阻塞网络编程机制，实现多人群聊
编写一个NIO群聊系统，实现客户端与客户端的通信需求（非阻塞）
服务器端：可以监测用户上线，离线，并实现消息转发功能
客户端：通过channel可以无阻塞发送消息给其他所有客户端用户，同时可以接受其它客户端用户
通过服务端转发来的消息
1，服务端代码实现

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

/**
 * 目标：服务端群聊系统实现
 */
public class Server {
    //定义属性
    private Selector selector;
    private ServerSocketChannel ssChannel;
    private static final int PORT = 9999;
    //构造器
    //初始化工作
    public Server() {
        try {
            //1.创建选择器
            selector = Selector.open();
            //2.获取通道
            ssChannel = ServerSocketChannel.open();
            //3.切换为非阻塞模式
            ssChannel.configureBlocking(false);
            //4.绑定连接的端口
            ssChannel.bind(new InetSocketAddress(PORT));
            //5.将通道都注册到选择器上去，并且开始指定下轮监听接收事件
            ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        //创建服务端对象,加载服务端需要的对象
        Server server = new Server();
        //开始监听客户端的各种消息事件：连接、群聊消息、离线消息
        server.listen();
    }
    //监听
    public void listen() {
        //System.out.println("监听线程：" + Thread.currentThread().getName());
        try {
            while (selector.select() > 0){
                //a.获取选择器中所有注册通道的就绪事件
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                //b.开始遍历这个事件
                while (it.hasNext()){
                    //提取这个事件
                    SelectionKey sk = it.next();
                    //c.判断这个事件
                    if(sk.isAcceptable()) {
                        //客户端接入请求
                        //获取当前客户端通道
                        SocketChannel schannel = ssChannel.accept();
                        //注册成非阻塞模式
                        schannel.configureBlocking(false);
                        //注册给选择器，监听读数据的事件
                        //现在监听到接收事件了，把客户端事件注册为读事件下次轮询就可以识别是读事件了
                        schannel.register(selector,SelectionKey.OP_READ);
                    }else if(sk.isReadable()){
                        //处理这个客户端的消息，接收它，然后实现转发逻辑
                        readClientData(sk);
                    }
                    it.remove();//处理完毕之后，需要移除当前事件
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    //接收当前客户端的信息，转发给其他全部客户端通道
    private void readClientData(SelectionKey sk) {
        SocketChannel sChannel = null;
        try {
            //直接得到当前客户端通道
            sChannel = (SocketChannel) sk.channel();
            //创建缓存区对象，开始接收客户端通道的数据
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int count = sChannel.read(buffer);
            if(count > 0) {
                buffer.flip();
                //提取读取到的信息
                String msg = new String(buffer.array(),0,buffer.remaining());
                System.out.println("接收到了客户端的消息：" + msg);
                //把这个消息推送给全部客户端接收
                sendMsgToAllClient(msg,sChannel);
            }
        }catch (Exception e){
            try {
                System.out.println("有人离线了：" + sChannel.getRemoteAddress());
                //当前客户端离线
                sk.cancel();//取消注册
                sChannel.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
    //把当前客户端的消息推送给当前全部在线注册的channel
    private void sendMsgToAllClient(String msg, SocketChannel sChannel) throws
            IOException {
        System.out.println("服务端开始转发这个消息，当前处理的线程" +
                Thread.currentThread().getName());
        for(SelectionKey key : selector.keys()) {
            Channel channel = key.channel();
            //不要把消息发给自己
            if(channel instanceof SocketChannel && channel != sChannel){
                //消息封装到缓冲区中
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                //从buffer中写给别的通道
                ((SocketChannel)channel).write(buffer);
            }
        }
    }
}

2，客户端代码实现

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;

/**
 * 目标：客户端代码逻辑的实现
 */
public class Client {
    //1.定义客户端相关属性
    private Selector selector;
    private static int PORT = 9999;
    private SocketChannel socketChannel;
    //2.初始化客户端信息
    public Client(){
        try {
            //a.创建选择器
            selector = Selector.open();
            //b.连接服务器
            socketChannel = SocketChannel.open(new
                    InetSocketAddress("127.0.0.1",PORT));
            //c.设置非阻塞模式
            socketChannel.configureBlocking(false);
            //因为当客户端将消息发出去后，就静静等待服务端回复也就是读事件
            socketChannel.register(selector, SelectionKey.OP_READ);
            System.out.println("当前客户端准备完成");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        final Client client = new Client();
        //定义一个线程，专门负责监听服务端发送过来的读消息事件
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    client.readInfo();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }).start();
        //发消息
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()){
            System.out.println("------------------");
            String s = sc.nextLine();
            client.sendToServer(s);
        }
    }
    private void sendToServer(String s) {
        try {
            socketChannel.write(ByteBuffer.wrap(("波仔说：" + s).getBytes()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //
    private void readInfo() throws IOException {
        //if(selector.select() > 0){
        while(selector.select() > 0){
            Iterator<SelectionKey> iterator =
                    selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                if(key.isReadable()){
                    SocketChannel sc = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    sc.read(buffer);
                    System.out.println(new String(buffer.array()).trim());
                    System.out.println("-dsd------------------------");
                }
                iterator.remove();
            }
        }
    }
}

3，输出

===========server端输出===============
接收到了客户端的消息：波仔说：你好
服务端开始转发这个消息，当前处理的线程main
接收到了客户端的消息：波仔说：你好
服务端开始转发这个消息，当前处理的线程main

===========client端1输出===============
当前客户端准备完成
你好
------------------
波仔说：你好
-dsd------------------------

===========client端2输出===============
当前客户端准备完成
波仔说：你好
-dsd------------------------
你好
------------------

JAVA AIO

Java AIO(NIO.2)：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是
由OS先完成了再通知服务器应用去启动线程进行处理。
AIO是异步非阻塞，基于NIO，可以称之为NIO2.0

BIO	NIO	AIO
Socket	SocketChannel	AsynchronousSocketChannel
ServerSocket	ServerSocketChannel	AsynchronousServerSocketChannel

与NIO不同，当进行读写操作时，只须直接调用API的read或write方法即可，这两种方法均为异步的，对于读操作而言，当有流可读时，操作系统会将可读的流传入read方法的缓冲区，对于写操作而言，当操作系统将 write方法传递的流写入完毕时，操作系统主动通知应用程序。
即可以理解为，read/write方法都是异步的，完成后会主动调用回调函数。在JDK1.7中，这部分内容被称作NIO.2，主要在java.nio.channel包下增加了下面四个异步通道：
AsynchronousSocketChannel
AsynchronousServerSocketChannel
AsynchronousFileChannel
AsynchronousDatagramChannel

BIO、NIO、AIO课程总结

BIO、NIO、AIO：

Java BlO：同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
Java NIO：同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册
到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
Java AIO(NIO.2)：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是
由OS先完成了再通知服务器应用去启动线程进行处理。

BIO、NIO、AIO适用场景分析：

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

Benjamin Cheung

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
BIO、NIO、AIO

Java BlO就是传统的Java IO编程，其相关的类和接口在Java.io 包中BIO(blocking I/O)同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善（实现多个客户连接服务器）.java NlO (New lO）也有人称之为java non-blocking IO是Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java lO API。
复制链接

扫一扫