01#IO概述

01#IO概述

01-I/O模型基本说明

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

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

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

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

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

02-BIO、NIO、AIO适用场景分析

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

2. NIO方式适用于连接数目多且连接比较短（轻操作）的架构,比如聊天服务器,弹幕系统,服务器间通讯等。编程比较复杂,JDK1.4开始支持。

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

02#BIO

01-BIO基本介绍

1. Java BIO就是传统的 java io编程,其相关的类和接口在java.io。

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

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

4. `BIO是面向流的`。

02-BIO工作机制


1. 服务器端启动一个ServerSocket

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

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

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

03-BIO应用实例

实例说明：

1)使用BIO模型编写一个服务器端,监听6666端口,当有客户端连接时,就启动一个线程与之通讯。

2)要求使用线程池机制改善,可以连接多个客户端。

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

 

 

 

xxxxxxxxxx

 

 

 

 

 

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 Exception {

        //线程池机制

        //思路

        //1. 创建一个线程池

        //2. 如果有客户端连接,就创建一个线程,与之通讯(单独写一个方法)

        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();

        //创建ServerSocket

        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("连接到一个客户端");

            //就创建一个线程,与之通讯(单独写一个方法)

            newCachedThreadPool.execute(new Runnable() {

                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 (Exception e) {

            e.printStackTrace();

        } finally {

            System.out.println("关闭和client的连接");

            try {

                socket.close();

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

    }

}

 

 

 

04-BIO问题分析

1. 每个请求都需要创建独立的线程,与对应的客户端进行数据Read,业务处理,数据Write。

2. 当并发数较大时,需要创建大量线程来处理连接,系统资源占用较大。

3. 连接建立后,如果当前线程暂时没有数据可读,则线程就阻塞在Read操作上,造成线程资源浪费。

03#NIO

01-NIO基本介绍

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

2. NIO相关类都被放在java.nio包及子包下,并且对原ava.io包中的很多类进行改写。

3. `NIO有三大核心部分：Channel(通道),Buffer(缓冲区),Selector(选择器)`

4. `NIO是面向缓冲区,或者面向块编程的`。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动,这就增加了处理过程中的灵活性,使用它可以提供非阻塞式的高伸缩性网络

5. Java NIO的非阻塞模式,使一个线程从某通道发送请求或者读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。非阻塞写也是如此,一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。

6. 通俗理解：`NIO是可以做到用一个线程来处理多个操作的`。假设有 10000个请求过来,根据实际情况,可以分配50或者 100个线程来处理。不像之前的阻塞 IO那样,非得分配 10000个。

7. HTTP2.0使用了多路复用的技术,做到同一个连接并发处理多个请求,而且并发请求的数量比HTTP1.1大了好几个数量级

02-NIO三大核心原理示意图


1. 每个channel 都会对应一个Buffer

2. Selector 对应一个线程, 一个线程对应多个channel(连接)

3. 程序切换到哪个channel 是有事件决定的, Event 就是一个重要的概念

4. Selector 会根据不同的事件,在各个Channel(通道)上切换

5. Buffer 就是一个内存块 , 底层是有一个数组

6. 数据的读取写入是通过Buffer, Buffer是双向的(可读可写),区别于BIO, 需要通过 flip()方法切换

7. channel 是双向的, 可以返回底层操作系统的情况, 比如Linux , 底层的操作系统通道就是双向的

04#Buffer

01-基本介绍

缓冲区（Buffer）：缓冲区本质上是一个`可以读写数据的内存块`,可以理解成是一个容器对象(含数组),该对象提供了一组方法,可以更轻松地使用内存块,缓冲区对象内置了一些机制,能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道,但是读取或写入的数据都必须经由 Buffer。


02-Buffer类及其子类

**1)**在NIO中,`Buffer是一个顶层父类,它是一个抽象类`,类的层级关系图:


 

**2)**常用Buffer子类一览

ByteBuffer,存储字节数据到缓冲区

ShortBuffer,存储字符串数据到缓冲区

CharBuffer,存储字符数据到缓冲区

IntBuffer,存储整数数据到缓冲区

LongBuffer,存储长整型数据到缓冲区

DoubleBuffer,存储小数到缓冲区

FloatBuffer,存储小数到缓冲区

**3)**Buffer类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息:

// Invariants: mark <= position <= limit <= capacity

private int mark = -1;

private int position = 0;

private int limit;

private int capacity;

 

position 和 limit 的含义取决于 Buffer 处在读模式还是写模式。不管 Buffer 处在什么 模式，capacity 的含义总是一样的。

这里有一个关于 capacity，position 和 limit 在读写模式中的说明

➽capacity

作为一个内存块，Buffer 有一个固定的大小值，也叫“capacity”.你只能往里写 capacity 个 byte、long，char 等类型。一旦 Buffer 满了，需要将其清空（通过读数 据或者清除数据）才能继续写数据往里写数据。

➽position

1）`写数据到 Buffer 中时`，position 表示写入数据的当前位置，position 的初始值为 0。当一个 byte、long 等数据写到 Buffer 后， position 会向下移动到下一个可插入 数据的 Buffer 单元。position 最大可为 capacity – 1（因为 position 的初始值为 0）.

2）`读数据到 Buffer 中时`，position 表示读入数据的当前位置，如 position=2 时表 示已开始读入了 3 个 byte，或从第 3 个 byte 开始读取。通过 ByteBuffer.flip()切换 到读模式时 position 会被重置为 0，当 Buffer 从 position 读入数据后，position 会 下移到下一个可读入的数据 Buffer 单元。

➽limit

1）`写数据时`，limit 表示可对 Buffer 最多写入多少个数据。写模式下，limit 等于 Buffer 的 capacity。

2）`读数据时`，limit 表示 Buffer 里有多少可读数据（not null 的数据），因此能读到 之前写入的所有数据（limit 被设置成已写数据的数量，这个值在写模式下就是 position）。

 

**4)**Buffer类相关方法一览

 

 

 

 

 

 

 

 

 

public abstract class Buffer {

//JDK1.4时,引入的api

    public final int capacity( )//返回此缓冲区的容量

    public final int position( )//返回此缓冲区的位置

    public final Buffer position (int newPositio)//设置此缓冲区的位置

    public final int limit( )//返回此缓冲区的限制

    public final Buffer limit (int newLimit)//设置此缓冲区的限制

    public final Buffer mark( )//在此缓冲区的位置设置标记

    public final Buffer reset( )//将此缓冲区的位置重置为以前标记的位置

    public final Buffer clear( )//清除此缓冲区, 即将各个标记恢复到初始状态,但是数据并没有真正擦除, 后面操作会覆盖

    public final Buffer flip( )//反转此缓冲区

    public final Buffer rewind( )//重绕此缓冲区

    public final int remaining( )//返回当前位置与限制之间的元素数

    public final boolean hasRemaining( )//告知在当前位置和限制之间是否有元素

    public abstract boolean isReadOnly( );//告知此缓冲区是否为只读缓冲区

​

    //JDK1.6时引入的api

    public abstract boolean hasArray();//告知此缓冲区是否具有可访问的底层实现数组

    public abstract Object array();//返回此缓冲区的底层实现数组

    public abstract int arrayOffset();//返回此缓冲区的底层实现数组中第一个缓冲区元素的偏移量

    public abstract boolean isDirect();//告知此缓冲区是否为直接缓冲区

}

 

 

 

 

 

 

 

Buffer 的基本用法

1、使用 Buffer 读写数据，一般遵循以下四个步骤：

（1）写入数据到 Buffer

（2）调用 flip()方法

（3）从 Buffer 中读取数据

（4）调用 clear()方法或者 compact()方法

当向 buffer 写入数据时，buffer 会记录下写了多少数据。一旦要读取数据，需要通过 flip()方法将 Buffer 从写模式切换到读模式。在读模式下，可以读取之前写入到 buffer 的所有数据。一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有 两种方式能清空缓冲区：调用 clear()或 compact()方法。clear()方法会清空整个缓冲 区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起 始处，新写入的数据将放到缓冲区未读数据的后面。

 

 

 

 

 

05#Channel

 

01-FileChannel

 

02-ServerSocketChannel

 

03-SocketChannel

 

04-DatagramChannel

 

 

 

06#Selector

 

07#Pipe 和 FileLock

08#其他

（1）Path 和 Files

（3）AsynchronousFileChanne