Java的BIO，NIO，AIO

　　Java中的IO操作可谓常见。在Java的IO体系中，常有些名词容易让人困惑不解。为此，先通俗地介绍下这些名词。　　

   1 什么是同步？
　　2 什么是异步？
　　3 什么是阻塞？
　　4 什么是非阻塞？
　　5 什么是同步阻塞？
　　6 什么是同步非阻塞？
　　7 什么是异步阻塞？
　　8 什么是异步非阻塞？

　　我们先来弄明白什么是同步，异步，阻塞，非阻塞，只有这几个概念理解清楚了，然后再组合起来理解，就相对比较容易了。

　　同步和异步是针对应用程序和内核的交互方式而言的。
　　阻塞和非阻塞是针对于进程在访问数据的时候，根据IO操作的就绪状态来采取的不同方式。其中，阻塞方式下读取或者写入函数将一直等待；而在非阻塞方式下，读取或者写入函数会立即返回一个状态值。

　　具体来说如下：

1.同步指的是用户进程触发IO操作并等待或者轮询地去查看IO操作是否就绪。
2.异步是指用户进程触发IO操作以后便开始做自己的事情，而当IO操作已经完成的时候会得到IO完成的通知（异步的特点就是通知）。
3.阻塞是指, 当试图对该文件描述符进行读写时, 如果当时没有东西可读,或者暂时不可写, 线程就进入等待状态, 直到有东西可读或者可写为止。
4.非阻塞是指，如果没有东西可读, 或者不可写, 读写函数马上返回, 而不会等待。

　　我们有了上述基础后，再接下来进一步学习。

　　Java中的IO方式通常分为几种，即：同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。

　　IO为同步阻塞形式，NIO为同步非阻塞形式，NIO并没有实现异步，在JDK1.7后升级NIO库包，开始支持异步非阻塞(AIO)。

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

　　在JDK1.4出来之前，我们建立网络连接的时候采用BIO模式，需要先在服务端启动一个ServerSocket，然后在客户端启动Socket来对服务端进行通信。默认情况下服务端需要对每个请求建立一堆线程等待请求，而客户端发送请求后，先咨询服务端是否有线程响应，如果没有则会一直等待或者遭到拒绝请求，如果有的话，客户端线程会在等待请求结束后继续执行。

　　2.NIO即non-blocking IO，是指jdk1.4 及以上版本里提供的新api（New IO），为所有的原始类型（boolean类型除外）提供缓存支持的数据容器。

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

　　NIO主要想解决的是BIO的大并发问题：在使用同步I/O的网络应用中，如果要同时处理多个客户端请求，或是在客户端要同时和多个服务器进行通讯，就必须使用多线程来处理。也就是说，将每一个客户端请求分配给一个线程来单独处理。这样做虽然可以达到我们的要求，但同时又会带来另外一个问题：由于每创建一个线程，就要为这个线程分配一定的内存空间（也叫工作存储器），而操作系统本身对线程的总数也会有一定的限制，如果客户端的请求过多，服务端程序可能会因为不堪重负而拒绝客户端的请求，服务器甚至也可能会因此而瘫痪。NIO基于Reactor，当socket有流可读或可写入socket时，操作系统会相应地通知应用程序进行处理，应用再将流读取到缓冲区或写入操作系统。

　　NIO的最重要的地方是当一个连接创建后，不需要对应一个线程，这个连接会被注册到多路复用器上面，所以所有的连接只需要一个线程就可以搞定，当这个线程中的多路复用器进行轮询的时候，发现连接上有请求的话，才开启一个线程进行处理，也就是一个请求一个线程模式。

　　NIO主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector。传统IO基于字节流和字符流进行操作，而NIO基于Channel和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个线程可以监听多个数据通道。

　　NIO和传统IO（一下简称IO）之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方；此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查该缓冲区中是否包含所有你需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。
　　IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。 NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

　　NIO中的Channel和BIO中的Stream(流)基本上是一个等级的。只不过Stream是单向的，如InputStream, OutputStream；而Channel是双向的，既可以用来进行读操作，又可以用来进行写操作。

　　NIO中的Channel的主要实现有：

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel

　　见名知义，上述Channel分别可以对应文件IO、UDP和TCP（Server和Client）。

　　NIO中的Buffer实现有：ByteBuffer, CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer，它们分别对应基本数据类型: byte, char, double, float, int, long, short。另外，NIO中还有MappedByteBuffer, HeapByteBuffer, DirectByteBuffer等。

　　NIO中的Selector运行单线程处理多个Channel，如果你的应用打开了多个通道，但每个连接的流量都很低，使用Selector就会很方便。例如在一个聊天服务器中。要使用Selector, 得向Selector注册Channel，然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件。

　　案例1：传统IO方式读取文件：

static void bioMethod() {
        InputStream in = null;
        try {
            in = new BufferedInputStream(new FileInputStream("src/com/itszt/test6/io.txt"));
            byte[] buf = new byte[1024];
            int bytesRead = in.read(buf);
            while (bytesRead != -1) {
                for (int i = 0; i < bytesRead; i++){
                    System.out.print((char) buf[i]);
                }
                bytesRead = in.read(buf);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

　　案例2：通过NIO的方式来处理上述文件读取问题：

static void nioMethod() {
        RandomAccessFile aFile = null;
        try {
            aFile = new RandomAccessFile("src/com/itszt/test6/io.txt", "rw");
            FileChannel fileChannel = aFile.getChannel();
            ByteBuffer buf = ByteBuffer.allocate(1024);

            int bytesRead = fileChannel.read(buf);//返回字符的数量
            System.out.println(bytesRead);

            while (bytesRead != -1) {
                buf.flip();
                while (buf.hasRemaining()) {
                    System.out.print((char) buf.get());
                }

                buf.compact();
                bytesRead = fileChannel.read(buf);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (aFile != null) {
                    aFile.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

　　通过案例2，可以总结出使用Buffer时，一般遵循下面几个步骤：

分配空间（ByteBuffer buf = ByteBuffer.allocate(1024); ）
写入数据到Buffer(int bytesRead = fileChannel.read(buf);)
调用filp()方法（ buf.flip();）
从Buffer中读取数据（System.out.print((char)buf.get());）
调用clear()方法或者compact()方法

　　Buffer顾名思义是缓冲区的意思，它实际上是一个容器，相当于一个连续数组。Channel提供从文件、网络读取数据的渠道，但是读写的数据都必须经过Buffer。

　　向Buffer中写数据：

从Channel写到Buffer (fileChannel.read(buf))
通过Buffer的put()方法（buf.put(…)）

　　从Buffer中读取数据：

从Buffer读取到Channel (channel.write(buf))
使用get()方法从Buffer中读取数据（buf.get()）

　　可以把Buffer简单地理解为一组基本数据类型的元素列表，它通过几个变量来保存这个数据的当前位置状态：capacity, position, limit, mark：

索引	说明
capacity	缓冲区数组的总长度
position	下一个要操作的数据元素的位置
limit	缓冲区数组中不可操作的下一个元素的位置：limit<=capacity
mark	用于记录当前position的前一个位置或者默认是0

　　处理大文件，一般用BufferedReader,BufferedInputStream这类带缓冲的IO类，不过如果文件超大的话，更快的方式是采用MappedByteBuffer。

　　MappedByteBuffer是NIO引入的文件内存映射方案，读写性能极高。NIO最主要的就是实现了对异步操作的支持。其中一种通过把一个套接字通道(SocketChannel)注册到一个选择器(Selector)中，不时调用后者的选择(select)方法就能返回满足的选择键(SelectionKey)，键中包含了SOCKET事件信息。这就是select模型。

　　SocketChannel的读写是通过一个类叫ByteBuffer来操作的。ByteBuffer有两种模式：直接/间接。间接模式最典型的就是HeapByteBuffer，即操作堆内存 (byte[])，但是内存毕竟有限,如果发送一个超大空间的文件（如1GB)，这时就必须使用”直接”模式,即 MappedByteBuffer,文件映射。

　　我们先来看操作系统的内存管理。一般操作系统的内存分两部分：物理内存；虚拟内存。虚拟内存一般使用的是页面映像文件，即硬盘中的某个(某些)特殊文件。操作系统负责页面文件内容的读写，这个过程叫”页面中断/切换”。 MappedByteBuffer 是一种特殊的ByteBuffer，是ByteBuffer的子类。 MappedByteBuffer 将文件直接映射到内存（这里的内存指的是虚拟内存，并不是物理内存）。通常，可以映射整个文件，如果文件比较大的话可以分段进行映射，只要指定文件的哪个部分即可。

　　FileChannel提供了map方法把文件影射为内存映像文件：
　　MappedByteBuffer map(int mode,long position,long size); 可以把文件从position开始的size大小的区域映射为内存映像文件，mode指出了可访问该内存映像文件的方式：　　

READ_ONLY,（只读）：试图修改得到的缓冲区将导致抛出 ReadOnlyBufferException.(MapMode.READ_ONLY)
READ_WRITE（读/写）：对得到的缓冲区的更改最终将传播到文件；该更改对映射到同一文件的其他程序不一定是可见的。 (MapMode.READ_WRITE)
PRIVATE（专用）：对得到的缓冲区的更改不会传播到文件，并且该更改对映射到同一文件的其他程序也不是可见的；相反，会创建缓冲区已修改部分的专用副本。 (MapMode.PRIVATE)

　　MappedByteBuffer是ByteBuffer的子类，其扩充了三个方法：

force()：缓冲区是READ_WRITE模式下，此方法对缓冲区内容的修改强行写入文件；
load()：将缓冲区的内容载入内存，并返回该缓冲区的引用；
isLoaded()：如果缓冲区的内容在物理内存中，则返回真，否则返回假；

　　案例3：采用MappedByteBuffer读取文件：

static void mapNIOMethod() {
        RandomAccessFile aFile = null;
        FileChannel fc = null;
        try {
            aFile = new RandomAccessFile("src/com/itszt/test6/io.txt",
                    "rw");
            fc = aFile.getChannel();
            long timeBegin = System.currentTimeMillis();
            MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_ONLY, 0, aFile.length());
            long timeEnd = System.currentTimeMillis();
            System.out.println("Read time: " + (timeEnd - timeBegin) + "ms");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (aFile != null) {
                    aFile.close();
                }
                if (fc != null) {
                    fc.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

　　我们再看下scatter和gather。

　　分散（scatter）从Channel中读取是指在读操作时将读取的数据写入多个buffer中。因此，Channel将从Channel中读取的数据“分散（scatter）”到多个Buffer中。

　　聚集（gather）写入Channel是指在写操作时将多个buffer的数据写入同一个Channel。因此，Channel 将多个Buffer中的数据“聚集（gather）”后发送到Channel。

　　scatter / gather经常用于将需要传输的数据分开处理的场合，例如传输一个由消息头和消息体组成的消息，你可能会将消息体和消息头分散到不同的buffer中，这样你可以方便的处理消息头和消息体。

static void gather() {
        ByteBuffer header = ByteBuffer.allocate(10);
        ByteBuffer body = ByteBuffer.allocate(10);

        byte[] b1 = {'0', '1'};
        byte[] b2 = {'2', '3'};
        header.put(b1);
        body.put(b2);

        ByteBuffer[] buffs = {header, body};

        try {
            FileOutputStream os = new FileOutputStream("src/com/itszt/test6/io.txt");
            FileChannel channel = os.getChannel();
            channel.write(buffs);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

　　FileChannel的transferFrom()方法可以将数据从源通道传输到FileChannel中：

static void transferFrom() {
        RandomAccessFile fromFile = null;
        RandomAccessFile toFile = null;
        try {
            fromFile = new RandomAccessFile("src/com/itszt/test6/fromFile.xml", "rw");
            FileChannel fromChannel = fromFile.getChannel();
            toFile = new RandomAccessFile("src/com/itszt/test6/toFile.txt", "rw");
            FileChannel toChannel = toFile.getChannel();

            long position = 0;
            long count = fromChannel.size();
            System.out.println(count);
            toChannel.transferFrom(fromChannel, position, count);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fromFile != null) {
                    fromFile.close();
                }
                if (toFile != null) {
                    toFile.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

　　方法的输入参数position表示从position处开始向目标文件写入数据，count表示最多传输的字节数。如果源通道的剩余空间小于 count 个字节，则所传输的字节数要小于请求的字节数。此外要注意，在SoketChannel的实现中，SocketChannel只会传输此刻准备好的数据（可能不足count字节）。因此，SocketChannel可能不会将请求的所有数据(count个字节)全部传输到FileChannel中。

　　transferTo()方法将数据从FileChannel传输到其他的channel中：

static void transferTo() {
        RandomAccessFile fromFile = null;
        RandomAccessFile toFile = null;
        try {
            fromFile = new RandomAccessFile("src/com/itszt/test6/fromFile.xml", "rw");
            FileChannel fromChannel = fromFile.getChannel();
            toFile = new RandomAccessFile("src/com/itszt/test6/toFile.txt", "rw");
            FileChannel toChannel = toFile.getChannel();

            long position = 0;
            long count = fromChannel.size();
            System.out.println(count);
            fromChannel.transferTo(position, count, toChannel);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fromFile != null) {
                    fromFile.close();
                }
                if (toFile != null) {
                    toFile.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

　　NIO 管道Pipe是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。数据会被写到sink通道，从source通道读取。如下：

static void pipeMethod() {
        Pipe pipe = null;
        ExecutorService exec = Executors.newFixedThreadPool(2);
        try {
            pipe = Pipe.open();
            final Pipe pipeTemp = pipe;

            exec.submit(new Callable

Java的BIO，NIO，AIO

Java的BIO，NIO，AIO

你可能感兴趣的:(Java的BIO，NIO，AIO)