Netty之JAVA BIO模型

一、JAVA BIO模型

1、I/O模型

1. I/O 模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能

2. Java 共支持 3 种网络编程模型/IO 模式：BIO、NIO、AIO

3. Java BIO ： 同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销 。
   
   
   
   BIO通讯流程:

   首先服务器启动,ServerSocket进行监控接收,此时若客户端想与之通讯的话,需要先启动Socket,然后建立一个线程,进行通讯,如若没有Socket连接ServerSocket连接的话,那么ServerSocket会一直进行等待Read。
   
   客户端发出请求后, 先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝
   
   如果有响应，客户端线程会等待请求结束后，在继续执行

   BIO通讯存在的问题:

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

4. Java NIO ： 同步非阻塞，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求都会注
   
   册到多路复用器上，多路复用器轮询到连接有 I/O 请求就进行处理 。
   
   

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

2、BIO、NIO、AIO适用场景

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

3、BIO基本介绍

1. Java BIO 就是传统的 java IO 编程，其相关的类和接口在 java.io
2. BIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需
   
   要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器)。
3. BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，程序简单易理解

4、BIO工作机制

1. 服务器端启动一个 ServerSocket

2. 客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户 建立一个线程与之通讯

3. 客户端发出请求后, 先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝

4. 如果有响应，客户端线程会等待请求结束后，在继续执行

5、BIO应用实例

实例说明：

1. 使用 BIO 模型编写一个服务器端，监听 6666 端口，当有客户端连接时，就启动一个线程与之通讯。
2. 要求使用线程池机制改善，可以连接多个客户端.
3. 服务器端可以接收客户端发送的数据(telnet 方式即可)。

public class BIOServer {
    public static void main(String[] args) throws Exception{
        int corePoolSize = 2;
        int maximumPoolSize = 4;
        long keepAliveTime = 10;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);
        ThreadFactory threadFactory = new NameTreadFactory();
        RejectedExecutionHandler handler = new MyIgnorePolicy();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,threadFactory,handler);
        executor.prestartAllCoreThreads(); // 预启动所有核心线程
        ServerSocket serverSocket = new ServerSocket(6666);
        System.out.println("服务器启动了");;
        while(true){
            System.out.println("线程信息 id = "+Thread.currentThread().getId()+ " 名字=" + Thread.currentThread().getName());
            System.out.println("等待链接......");
            final Socket socket = serverSocket.accept();
            System.out.println("接受到一个客户端");
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    handler(socket);
                }
            });
        }
    }
    //编写handler方法,和客户端通讯
    public static void handler(Socket socket){
        try {
            System.out.println("线程信息 id = "+Thread.currentThread().getId()+ " 名字=" + Thread.currentThread().getName());
            byte[] bytes = new byte[1024];
            //通过socket获取输入流
            InputStream inputStream = socket.getInputStream();
            //循环读取客户端发送的数据
            while(true){
                System.out.println("线程信息 id = "+Thread.currentThread().getId()+ " 名字=" + Thread.currentThread().getName());
                System.out.println("read");
                int read = inputStream.read(bytes);
                if (read != -1){
                    System.out.println(new String(bytes,0,read));
                } else {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    static class NameTreadFactory implements ThreadFactory {
        private final AtomicInteger mThreadNum = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }
    public static class MyIgnorePolicy implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            doLog(r, e);
        }
        private void doLog(Runnable r, ThreadPoolExecutor e) {
            // 可做日志记录等
            System.err.println( r.toString() + " rejected");
        }
    }
}

6、BIO问题分析

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