02-Java BIO编程

I/O 模型

I/O 模型基本说明

1. I/O 模型简单的理解: 就是用什么样的通道进行数据的发送和接收,很大程度上决定了程序通信的性能
2. Java共支持三种网络编程模型 I/O模式: BIO NIO AIO

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

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

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

BIO NIO AIO 适用场景分析

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

3. AIO方式适用于链接数目多且连接比较长,(重操作)的架构,比如相册服务器, 充分调用OS参与并发操作,编程比较复杂,JDK7开始支持

Java BIO基本操作

1. Java BIO 就是传统的JavaIO编程, 其相关的类和接口在 Java.io
2. BIO(blocking I/O): 同步阻塞, 服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,可以通过线程池机制改善(实现多个客户端连接服务器) [后有应用案例]

3. BIO方式适用于连接数目比较小且固定的架构, 这种方式对服务器资源要求比较高, 并发局限于应用中, JDK1.4以前的唯一选择,但程序简单易理解

Java BIO 工作机制

对BIO编程流程的梳理

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

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

Java BIO应用实例

实例说明

1. 使用BIO模型编写一个服务器端,监听6666端口, 当有客户端连接时,就启动一个线程与之通讯
2. 要求使用线程池机制改善, 可以链接多个客户端

3. 服务器可以接收客户端发送的数据(Telnet 方式即可)

创建项目

创建Maven项目

代码演示

编写代码

package com.dance.netty.bio;

import com.sun.istack.internal.NotNull;

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

public class BIOServer {

    public static void main(String[] args) throws IOException {

        // 创建一个线程池
        // 参数 0 max 60 s syncQueue<Runnable>
        ExecutorService executorService = Executors.newCachedThreadPool();

        // 创建服务器 绑定 6666 端口
        ServerSocket serverSocket = new ServerSocket(6666);

        System.out.println("服务器在6666端口开始监听......");

        while(true) {

            // 阻塞 等待客户端连接
            final Socket accept = serverSocket.accept();

            // 获取到一个客户端连接
            System.out.println(accept.getInetAddress().getHostAddress() + " 连接成功");

            // 创建一个线程与之通讯(单独写一个方法)
            executorService.execute(() -> {
                System.out.println("线程信息: { id: "+Thread.currentThread().getId() +", name: " +Thread.currentThread().getName() +" }");
                // 可以和客户端通讯
                handler(accept);
            });
        }
    }

    /**
     * 处理和客户端通讯
     */
    public static void handler(@NotNull final Socket socket){
        try {
            byte[] bytes = new byte[1024];
            // 获取输入流
            InputStream inputStream = socket.getInputStream();

            // 读取客户端数据
            while (true){
                int read = inputStream.read(bytes);
                if (read != -1){
                    System.out.println(new String(bytes,0,read));
                }else{
                    break;
                }
            }


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                System.out.println(socket.getInetAddress().getHostAddress() + " 连接关闭");
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

启动程序

服务器在6666端口开始监听......

通过Telnet连接

启动cmd

通过命令连接

telnet 127.0.0.1 6666

按下回车开始连接

控制台展示

127.0.0.1 连接成功
线程信息: { id: 12, name: pool-1-thread-1 }

按一下 ctrl+] 开始发送字符串

控制台会有响应的展示

可以再启动一个cmd 来测试多线程,应为我们已经将线程的名称打印了

又启动了一个线程..ok

理解和问题分析

理解

在调用的过程中,我们的main主线程用于监听客户端的连接, 每次在在accept方法出阻塞,等待,在有客户端连接的时候通过线程池创建一个新的线程用于处理当前的客户端连接,而main线程继续循环阻塞在accept方法

新创建的线程用户和客户端打交道,执行过程中会阻塞在inputStream的read方法,等待客户端输入

问题分析

1. 每个请求都需要创建独立的线程,与对应的客户端进行数据的read,业务处理,数据write
2. 当并发数较大时,如果当前线程暂时没有数据可读,则线程就阻塞在Read操作上,造成线程资源浪费