IO知识记录

IO知识记录

IO基础知识

IO流用来处理设备之间的数据传输，Java程序中，对于数据的输入/输出操作 都是以“流”的方式进行的。java.io包下提供了各种“流”类的接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
对于计算机来说，数据都是以二进制形式读出或写入的。我们可以把文件想象为一个桶，我们可以通过管道将桶里的水抽出来。这里的管道也就相当于Java中的流。流的本质是一种有序的数据集合，有数据源和目的地。

从数据传输方式或者说是运输方式角度看，可以将 IO 类分为：

• 1、字节流
• 2、字符流

字节流是以一个字节单位来运输的，比如一杯一杯的取水。而字符流是以多个字节来运输的，比如一桶一桶的取水，一桶水又可以分为几杯水。

InputStream 类

方法	方法介绍
public abstract int read()	读取数据
public int read(byte b[])	将读取到的数据放在 byte 数组中，该方法实际上是根据下面的方法实现的，off 为 0，len 为数组的长度
public int read(byte b[], int off, int len)	从第 off 位置读取 len 长度字节的数据放到 byte 数组中，流是以 -1 来判断是否读取结束的（注意这里读取的虽然是一个字节，但是返回的却是 int 类型 4 个字节，这里当然是有原因，这里就不再细说了，推荐这篇文章，链接）
public long skip(long n)	跳过指定个数的字节不读取，想想看电影跳过片头片尾
public int available()	返回可读的字节数量
public void close()	读取完，关闭流，释放资源
public synchronized void mark(int readlimit)	标记读取位置，下次还可以从这里开始读取，使用前要看当前流是否支持，可以使用 markSupport() 方法判断
public synchronized void reset()	重置读取位置为上次 mark 标记的位置
public boolean markSupported()	判断当前流是否支持标记流，和上面两个方法配套使用

OutputStream 类

方法	方法介绍
public abstract void write(int b)	写入一个字节，可以看到这里的参数是一个 int 类型，对应上面的读方法，int 类型的 32 位，只有低 8 位才写入，高 24 位将舍弃。
public void write(byte b[])	将数组中的所有字节写入，和上面对应的 read() 方法类似，实际调用的也是下面的方法。
public void write(byte b[], int off, int len)	将 byte 数组从 off 位置开始，len 长度的字节写入
public void flush()	强制刷新，将缓冲中的数据写入
public void close()	关闭输出流，流被关闭后就不能再输出数据了

Reader 类

方法	方法介绍
public int read(java.nio.CharBuffer target)	读取字节到字符缓存中
public int read()	读取单个字符
public int read(char cbuf[])	读取字符到指定的 char 数组中
abstract public int read(char cbuf[], int off, int len)	从 off 位置读取 len 长度的字符到 char 数组中
public long skip(long n)	跳过指定长度的字符数量
public boolean ready()	和上面的 available() 方法类似
public boolean markSupported()	判断当前流是否支持标记流
public void mark(int readAheadLimit)	标记读取位置，下次还可以从这里开始读取，使用前要看当前流是否支持，可以使用 markSupport() 方法判断
public void reset()	重置读取位置为上次 mark 标记的位置
abstract public void close()	关闭流释放相关资源

Writer 类

方法	方法介绍
public void write(int c)	写入一个字符
public void write(char cbuf[])	写入一个字符数组
abstract public void write(char cbuf[], int off, int len)	从字符数组的 off 位置写入 len 数量的字符
public void write(String str)	写入一个字符串
public void write(String str, int off, int len)	从字符串的 off 位置写入 len 数量的字符
public Writer append(CharSequence csq)	追加吸入一个字符序列
public Writer append(CharSequence csq, int start, int end)	追加写入一个字符序列的一部分，从 start 位置开始，end 位置结束
public Writer append(char c)	追加写入一个 16 位的字符
abstract public void flush()	强制刷新，将缓冲中的数据写入
abstract public void close()	关闭输出流，流被关闭后就不能再输出数据了

BIO NIO AIO

• BIO、NIO、AIO的区别

BIO 就是传统的 java.io 包，它是基于流模型实现的，交互的方式是同步、阻塞方式，也就是说在读入输入流或者输出流时，在读写动作完成之前，线程会一直阻塞在那里，它们之间的调用时可靠的线性顺序。它的有点就是代码比较简单、直观；缺点就是 IO 的效率和扩展性很低，容易成为应用性能瓶颈。

NIO 是 Java 1.4 引入的 java.nio 包，提供了 Channel、Selector、Buffer 等新的抽象，可以构建多路复用的、同步非阻塞 IO 程序，同时提供了更接近操作系统底层高性能的数据操作方式。

AIO 是 Java 1.7 之后引入的包，是 NIO 的升级版本，提供了异步非堵塞的 IO 操作方式，所以人们叫它 AIO（Asynchronous IO），异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。

• 同步和异步

同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要么成功都成功，失败都失败，两个任务的状态可以保持一致。而异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成，依赖它的任务无法确定，所以它是不可靠的任务序列。我们可以用打电话和发短信来很好的比喻同步与异步操作。

• 阻塞和非阻塞

阻塞与非阻塞主要是从 CPU 的消耗上来说的，阻塞就是 CPU 停下来等待一个慢的操作完成 CPU 才接着完成其它的事。非阻塞就是在这个慢的操作在执行时 CPU 去干其它别的事，等这个慢的操作完成时，CPU 再接着完成后续的操作。虽然表面上看非阻塞的方式可以明显的提高 CPU 的利用率，但是也带了另外一种后果就是系统的线程切换增加。增加的 CPU 使用时间能不能补偿系统的切换成本需要好好评估。

• 传统IO（BIO）

int port = 4343; //端口号
// Socket 服务器端（简单的发送信息）
Thread sThread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            while (true) {
                // 等待连接
                Socket socket = serverSocket.accept();
                Thread sHandlerThread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try (PrintWriter printWriter = new PrintWriter(socket.getOutputStream())) {
                            printWriter.println("hello world！");
                            printWriter.flush();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
                sHandlerThread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});
sThread.start();

// Socket 客户端（接收信息并打印）
try (Socket cSocket = new Socket(InetAddress.getLocalHost(), port)) {
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(cSocket.getInputStream()));
    bufferedReader.lines().forEach(s -> System.out.println("客户端：" + s));
} catch (UnknownHostException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

(1) 调用 accept 方法，阻塞等待客户端连接；

(2) 利用 Socket 模拟了一个简单的客户端，只进行连接、读取和打印；

在 Java 中，线程的实现是比较重量级的，所以线程的启动或者销毁是很消耗服务器的资源的，即使使用线程池来实现，使用上述传统的 Socket 方式，当连接数极具上升也会带来性能瓶颈，原因是线程的上线文切换开销会在高并发的时候体现的很明显，并且以上操作方式还是同步阻塞式的编程，性能问题在高并发的时候就会体现的尤为明显。

以上的流程，如下图：

• NIO

介于以上高并发的问题，NIO 的多路复用功能就显得意义非凡了。

NIO 是利用了单线程轮询事件的机制，通过高效地定位就绪的 Channel，来决定做什么，仅仅 select 阶段是阻塞的，可以有效避免大量客户端连接时，频繁线程切换带来的问题，应用的扩展能力有了非常大的提高。

// NIO 多路复用
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(4, 4,
        60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
threadPool.execute(new Runnable() {
    @Override
    public void run() {
        try (Selector selector = Selector.open();
             ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();) {
            serverSocketChannel.bind(new InetSocketAddress(InetAddress.getLocalHost(), port));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            while (true) {
                selector.select(); // 阻塞等待就绪的Channel
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    try (SocketChannel channel = ((ServerSocketChannel) key.channel()).accept()) {
                        channel.write(Charset.defaultCharset().encode("你好，世界"));
                    }
                    iterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});

// Socket 客户端（接收信息并打印）
try (Socket cSocket = new Socket(InetAddress.getLocalHost(), port)) {
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(cSocket.getInputStream()));
    bufferedReader.lines().forEach(s -> System.out.println("NIO 客户端：" + s));
} catch (IOException e) {
    e.printStackTrace();
}

(1) 首先，通过 Selector.open() 创建一个 Selector，作为类似调度员的角色；

(2) 然后，创建一个 ServerSocketChannel，并且向 Selector 注册，通过指定 SelectionKey.OP_ACCEPT，告诉调度员，它关注的是新的连接请求；

(3) 为什么我们要明确配置非阻塞模式呢？这是因为阻塞模式下，注册操作是不允许的，会抛出 IllegalBlockingModeException 异常；

(4) Selector 阻塞在 select 操作，当有 Channel 发生接入请求，就会被唤醒；

下面的图，可以有效的说明 NIO 复用的流程：

• AIO

  // AIO线程复用版
  Thread sThread = new Thread(new Runnable() {
      @Override
      public void run() {
          AsynchronousChannelGroup group = null;
          try {
              group = AsynchronousChannelGroup.withThreadPool(Executors.newFixedThreadPool(4));
              AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(group).bind(new InetSocketAddress(InetAddress.getLocalHost(), port));
              server.accept(null, new CompletionHandler<AsynchronousSocketChannel, AsynchronousServerSocketChannel>() {
                  @Override
                  public void completed(AsynchronousSocketChannel result, AsynchronousServerSocketChannel attachment) {
                      server.accept(null, this); // 接收下一个请求
                      try {
                          Future<Integer> f = result.write(Charset.defaultCharset().encode("你好，世界"));
                          f.get();
                          System.out.println("服务端发送时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                          result.close();
                      } catch (InterruptedException | ExecutionException | IOException e) {
                          e.printStackTrace();
                      }
                  }
  
                  @Override
                  public void failed(Throwable exc, AsynchronousServerSocketChannel attachment) {
                  }
              });
              group.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
          } catch (IOException | InterruptedException e) {
              e.printStackTrace();
          }
      }
  });
  sThread.start();
  
  // Socket 客户端
  AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
  Future<Void> future = client.connect(new InetSocketAddress(InetAddress.getLocalHost(), port));
  future.get();
  ByteBuffer buffer = ByteBuffer.allocate(100);
  client.read(buffer, null, new CompletionHandler<Integer, Void>() {
      @Override
      public void completed(Integer result, Void attachment) {
          System.out.println("客户端打印：" + new String(buffer.array()));
      }
  
      @Override
      public void failed(Throwable exc, Void attachment) {
          exc.printStackTrace();
          try {
              client.close();
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  });
  Thread.sleep(10 * 1000);