面试官：聊聊BIO、NIO、AIO

我：emmm......我只知道IO

虽然IO流是Java基础部分学习的内容，而且用起来也是比较简单的；但是，如果让你系统的说一下IO，还是比较困难的。这篇博客通过各方面对比，来聊一聊这几个IO。

 

---

一些概念

在学习Java的IO流之前，我们必须要知道一些关键词。

同步与异步：（关注的是消息通信机制）

• 同步(Synchronous)：代码按顺序执行，执行到同步方法时，不管方法有没有返回值都要执行完，才能往下执行。

• 异步(Asynchronous)：代码按顺序执行，执行到异步方法时，会把该异步方法交给其他线程（返回结果是什么，原线程不管），原线程继续向下执行。

 

阻塞与非阻塞：（关注的是程序等待时的状态）

• 阻塞调用：阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。
• 非阻塞调用：在调用结果返回之前，当前线程不会被挂起，不会被阻塞。

 

IO对比（图表）

IO是用来实现输入和输出操作的，其下可以分为BIO、NIO、AIO

I/O	名称	适用领域	描述
BIO (Blocking I/O)	同步阻塞I/O模型	低负载、低并发	数据的读取写入必须阻塞在一个线程内等待其完成
NIO (New I/O)	同步非阻塞的I/O模型	高负载、高并发	Java 1.4 中引入，对应 java.nio 包
AIO (Asynchronous I/O)	异步非阻塞的IO模型	应用还不是很广泛	Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型

BIO

 JAVA IO流共涉及40多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系， Java IO流的40多个类都是从如下4个抽象类基类中派生出来的。

InputStream、OutputStream、Reader、Writer

按操作数据分为：字节流（InputStream、OutputStream）和字符流（Reader、Writer）

按流向分：输入流（Reader、InputStream）和输出流（Writer、OutputStream）

这么多类，属实有点头痛，我们这里也按功能分类一下。

分类	字节输入流	字节输出流	字符输入流	字符输入流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件	FileInputStream	FileOutStream	FilerReader	FileWriter
访问数组	ByteArrayInputSteam	ByteArrayOutStream	CharArrayReader	CharArrayWriter
访问管道	PipeInputStream	PipeOutputStream	PipeReader	PipeWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedInputSteam	BufferedOutputStream	BufferReader	BuffereWriter
转换流			InputStreamReader	OutputStreamWriter
对象流	ObjectInputStream	ObjectOutputStream
抽象基类	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter
打印流		PrintStream		PrintWriter
推回输入流	PushbackInputStream		PushBackReader
特殊流	DataInputStream	DataOutputStream

io包下的类还是非常多的，我们当然不用全部都记住，只需要知道几个常用类即可，不管是应付工作还是面试都足够。

1）文件输入流FileInputStream/FileReader

InputStream和Reader都是抽象类，本身不能创建实例，但它们分别有一个用于读取文件的输入流：FileInputStream和FileReader，它们都是节点流——会直接和指定文件关联。下面程序示范使用FileInputStream和FileReader。

使用FileInputStream读取文件：

public class MyClass {
  public  static void main(String[] args)throws IOException{
      FileInputStream fis=null;
      try {
          //创建字节输入流
          fis=new FileInputStream("C:\\Test.txt");
          //创建一个长度为1024的竹筒
          byte[] b=new byte[1024];
          //用于保存的实际字节数
          int hasRead=0;
          //使用循环来重复取水的过程
          while((hasRead=fis.read(b))>0){
              //取出竹筒中的水滴（字节），将字节数组转换成字符串进行输出
            System.out.print(new String(b,0,hasRead));
          }
      }catch (IOException e){
        e.printStackTrace();
      }finally {
          fis.close();
      }
  }
}

 注：上面程序最后使用了fis.close()来关闭该文件的输入流，与JDBC编程一样，程序里面打开的文件IO资源不属于内存的资源，垃圾回收机制无法回收该资源，所以应该显示的关闭打开的IO资源。Java 7改写了所有的IO资源类，它们都实现了AntoCloseable接口，因此都可以通过自动关闭资源的try语句来关闭这些Io流。

使用FileReader读取文件：

 public  static void main(String[] args)throws IOException{
        FileReader fr=null;
        try {
            //创建字节输入流
            fr=new FileReader("C:\\Test.txt");
            //创建一个长度为1024的竹筒
            char[] b=new char[1024];
            //用于保存的实际字节数
            int hasRead=0;
            //使用循环来重复取水的过程
            while((hasRead=fr.read(b))>0){
                //取出竹筒中的水滴（字节），将字节数组转换成字符串进行输出
                System.out.print(new String(b,0,hasRead));
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            fr.close();
        }
    }
}

可以看出使用FileInputStream和FileReader进行文件的读写并没有什么区别，只是操作单元不同而且。

2）文件输出流FileOutputStream/FileWriter

FileOutputStream/FileWriter是Io中的文件输出流，下面介绍这两个类的用法。

FileOutputStream的用法：

public class FileOutputStreamTest {
    public  static void main(String[] args)throws IOException {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            //创建字节输入流
            fis=new FileInputStream("C:\\Test.txt");
            //创建字节输出流
            fos=new FileOutputStream("C:\\newTest.txt");

            byte[] b=new byte[1024];
            int hasRead=0;

            //循环从输入流中取出数据
            while((hasRead=fis.read(b))>0){
                //每读取一次，即写入文件输入流，读了多少，就写多少。
                fos.write(b,0,hasRead);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            fis.close();
            fos.close();
        }
    }
}

  运行程序可以看到输出流指定的目录下多了一个文件：newTest.txt, 该文件的内容和Test.txt文件的内容完全相同。FileWriter的使用方式和FileOutputStream基本类似，这里就带过。

注： 使用java的io流执行输出时，不要忘记关闭输出流，关闭输出流除了可以保证流的物理资源被回收之外，还可以将输出流缓冲区中的数据flush到物理节点中（因为在执行close（）方法之前，自动执行输出流的flush（）方法）。java很多输出流默认都提供了缓存功能，其实我们没有必要刻意去记忆哪些流有缓存功能，哪些流没有，只有正常关闭所有的输出流即可保证程序正常。

3)缓冲流

（BufferedInputStream/BufferedReader,BufferedOutputStream/BufferedWriter）：
  下面介绍字节缓存流的用法（字符缓存流的用法和字节缓存流一致就不介绍了）：

public class BufferedStreamTest {
    public  static void main(String[] args)throws IOException {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        try {
            //创建字节输入流
            fis=new FileInputStream("C:\\Test.txt");
            //创建字节输出流
            fos=new FileOutputStream("C:\\newTest.txt");
            //创建字节缓存输入流
            bis=new BufferedInputStream(fis);
            //创建字节缓存输出流
            bos=new BufferedOutputStream(fos);

            byte[] b=new byte[1024];
            int hasRead=0;
            //循环从缓存流中读取数据
            while((hasRead=bis.read(b))>0){
                //向缓存流中写入数据，读取多少写入多少
                bos.write(b,0,hasRead);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            bis.close();
            bos.close();
        }
    }
}

可以看到使用字节缓存流读取和写入数据的方式和文件流（FileInputStream,FileOutputStream）并没有什么不同，只是把处理流套接到文件流上进行读写。

上面代码中我们使用了缓存流和文件流，但是我们只关闭了缓存流。这个需要注意一下，当我们使用处理流套接到节点流上的使用的时候，只需要关闭最上层的处理就可以了。java会自动帮我们关闭下层的节点流。

4）转换流（InputStreamReader/OutputStreamWriter）:

下面以获取键盘输入为例来介绍转换流的用法。java使用System.in代表输入。即键盘输入，但这个标准输入流是InputStream类的实例，使用不太方便，而且键盘输入内容都是文本内容，所以可以使用InputStreamReader将其包装成BufferedReader,利用BufferedReader的readLine()方法可以一次读取一行内容，如下代码所示:

public class InputStreamReaderTest {
    public  static void main(String[] args)throws IOException {
        try {
            // 将System.in对象转化为Reader对象
            InputStreamReader reader=new InputStreamReader(System.in);
            //将普通的Reader包装成BufferedReader
            BufferedReader bufferedReader=new BufferedReader(reader);
            String buffer=null;
            while ((buffer=bufferedReader.readLine())!=null){
            // 如果读取到的字符串为“exit”,则程序退出
               if(buffer.equals("exit")){
                   System.exit(1);
               }
               //打印读取的内容
               System.out.print("输入内容："+buffer);
           }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
        }
    }
}

上面程序将System.in包装成BufferedReader,BufferedReader流具有缓存功能，它可以一次读取一行文本——以换行符为标志，如果它没有读到换行符，则程序堵塞。等到读到换行符为止。运行上面程序可以发现这个特征，当我们在控制台执行输入时，只有按下回车键，程序才会打印出刚刚输入的内容。

5）对象流（ObjectInputStream/ObjectOutputStream）：
写入对象：

public static void writeObject(){
        OutputStream outputStream=null;
        BufferedOutputStream buf=null;
        ObjectOutputStream obj=null;
        try {
            //序列化文件輸出流
            outputStream=new FileOutputStream("C:\\myfile.tmp");
            //构建缓冲流
            buf=new BufferedOutputStream(outputStream);
            //构建字符输出的对象流
            obj=new ObjectOutputStream(buf);
            //序列化数据写入
            obj.writeObject(new Person("A", 21));//Person对象
            //关闭流
            obj.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

读取对象

  public static void readObject() throws IOException {
        try {
            InputStream inputStream=new FileInputStream("C:\\myfile.tmp");
            //构建缓冲流
            BufferedInputStream buf=new BufferedInputStream(inputStream);
            //构建字符输入的对象流
            ObjectInputStream obj=new ObjectInputStream(buf);
            Person tempPerson=(Person)obj.readObject();
            System.out.println("Person对象为："+tempPerson);
            //关闭流
            obj.close();
            buf.close();
            inputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

 

NIO

背景
从JDk1.4开始，java提供了一系列改进的输入和输出处理的新功能，这些功能被统称为New IO或者Non Blocking IO(NIO)。新增了许多用于处理输入和输出的类，这些类都被放在java.nio包及其子包下；并且对原io的很多类都以NIO为基础进行了改写，新增了满足NIO的功能。
JDk1.4使用NIO改写了传统Io后，传统Io的读写速度和NIO差不了太多。

主要区别

Java中I/O相关的两个包是java.io和java.nio，它们的最重要的区别就是java.io里面的类是面向流的（stream oriented），java.nio里面的类是面向缓存的（buffer oriented）。
面向流意味着一次读取一个或者一些字节，然后处理这些字节，在读取和处理这些字节时当前线程是阻塞的，不能干其他事情。面向缓存意味着把一些字节读到缓存里面，选择了读取的字节之后当前线程可以去做其他事情，以后再去处理缓存里面的字节也可以，也就是线程非阻塞。

IO	NIO
面向流（Stream Oriented）	面向缓冲区（Buffer Oriented）
阻塞IO（Blocking IO）	非阻塞IO（Non Blocking IO）
（无）	选择器（Selectors）

    

 

概念：

缓冲区（火车），负责数据的存储

通道（火车道），负责数据的连接

选择器

代码

缓冲区（Buffer）：

Buffer下有四个重要的属性

private int mark = -1;        标记，表示当前position的位置。可以通过reset()恢复到mark的位置
private int position = 0;     位置，表示缓冲区中正在操作数据的位置
private int limit;                 界限，表示缓冲区中可以操作数据的大小。（limit 后面的数据不能进行读写
private int capacity;           容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变
0 <= mark <= position <= limit  <=  capacity

 public void test01(){

            String str = "abcde";
            // 分配缓冲区大小
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            System.out.println("---------allocate()-----------");
            System.out.println(buffer.position());
            System.out.println(buffer.limit());
            System.out.println(buffer.capacity());


            //2、利用put()方法，存入数据到缓冲区
            buffer.put(str.getBytes());
            System.out.println("---------put()-----------");
            System.out.println(buffer.position());
            System.out.println(buffer.limit());
            System.out.println(buffer.capacity());

            //3、使用flip()方法，切换到读模式
            buffer.flip();
            System.out.println("---------flip()-----------");
            System.out.println(buffer.position());
            System.out.println(buffer.limit());
            System.out.println(buffer.capacity());

            //4、利用get()方法读取缓冲区中的数据
            byte[] dst = new byte[buffer.limit()];
            buffer.get(dst);
            System.out.println(new String(dst,0,dst.length));
            System.out.println("------------get()---------------");
            System.out.println(buffer.position());
            System.out.println(buffer.limit());
            System.out.println(buffer.capacity());

            //5、rewind()，可重复读数据
            buffer.rewind();
            System.out.println("------------rewind()---------------");
            System.out.println(buffer.position());
            System.out.println(buffer.limit());
            System.out.println(buffer.capacity());

            //6、clear()，清空缓冲区。但是缓冲区中的数据依然存在，但是出于“被遗忘”状态
            buffer.clear();
            System.out.println("------------clear()---------------");
            System.out.println(buffer.position());
            System.out.println(buffer.limit());
            System.out.println(buffer.capacity());

    }

public void test02(){
        String str = "abcde";
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        buffer.put(str.getBytes());

        buffer.flip();

        byte[] dst = new byte[buffer.limit()];
        buffer.get(dst,0,2);
        System.out.println(buffer.position());

        buffer.mark();

        buffer.get(dst,2,2);
        System.out.println(buffer.position());

        // reset() ，恢复到mark的位置
        buffer.reset();

        System.out.println(buffer.position());

        //判断缓冲区中是否还有数据
        if(buffer.hasRemaining()){
            //输出缓冲区中剩余数据的数量
            System.out.println(buffer.remaining());
        }
    }

 

面试题：

直接缓冲区与非直接缓冲区：

 

直接缓冲区，效率虽然高，但是不稳定