NIO

最新推荐文章于 2024-07-25 22:50:26 发布

冰凌寒梦

最新推荐文章于 2024-07-25 22:50:26 发布

阅读量120

点赞数

分类专栏： JAVA学习

本文链接：https://blog.csdn.net/weixin_43153155/article/details/99599026

版权

JAVA学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

NIO

1.NIO简介：

java.nio全称Java non-blocking IO或Java New IO，是从jdk1.4 开始引入的一套新的IO api（New IO），为所有的原始类型（boolean类型除外）提供缓存支持的数据容器，使用它可以提供非阻塞式的高伸缩性网络。

1.1 IO操作的模式：

PIO（Programing IO）: 所有的IO操作由CPU处理，CPU占用率比较高。

DMA(Direct Memory Access):CPU把IO操作控制权交给DMA控制器，只能以固定的方式读写，CPU空闲做其他工作。

通道方式(Channel)：能执行有限通道指令的IO控制器，代替CPU管理控制外设。通道有自己的指令系统，是一个协处理器，具有更强的独立处理数据输入和输出的能力。

1.2Java NIO 由以下几个核心部分组成：

1.通道（channel）:负责连接

java.nio.channels.Channel接口：
　　 |–SelectableChannel
　　　　 |–SocketChannel
　　　　 |–ServerSocketChannel
　　　　 |–DatagramChannel

|–Pipe.SinkChannel
　　　　 |–Pipe.SourceChannel
2、缓冲区（Buffer）:负责数据的存储
3、选择器（Selector）:是SelectableChannel的多路复用器。用于监控SelectableChannel的IO状况。

1.3NIO的新特性

总的来说java 中的IO 和NIO的区别主要有3点：

IO是面向流的，NIO是面向缓冲的；
IO是阻塞的，NIO是非阻塞的；
IO是单线程的，NIO 是通过选择器来模拟多线程的；

NIO在基础的IO流上发展处新的特点，分别是：内存映射技术，字符及编码，非阻塞I/O和文件锁定。

2.Buffer的使用

Java NIO中的Buffer用于和NIO通道进行交互。如你所知，数据是从通道读入缓冲区，从缓冲区写入到通道中的。

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

Java NIO里关键的Buffer实现：

ByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer

2.1Buffer的基本用法

使用Buffer进行读写数据操作一般遵循一下四个步骤：

（1）创建缓冲区，向缓冲区Buffer写入数据

（2）调用flip（）方法，切换读写模式

（3）从缓冲区读取数据

（4）调用clear（）或compact（）方法，清空数据

public class Demo1 {
    public static void main(String[] args) {
        //创建缓冲区，大小1024
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //写入数据
        buffer.put("HelloWorld".getBytes());

        //切换模式。将写入模式转换成读取模式
        buffer.flip();
        
        //读取数据
        //单个字节读取
//        byte b = buffer.get();
//        System.out.println((char) b);
        //读取多个字节
        byte[] data = new byte[buffer.limit()];
        buffer.get(data);
        System.out.println(new String(data));

        //清空
        buffer.clear();


    }
}

2.2Buffer的实现原理：

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

为了理解Buffer的工作原理，需要熟悉它的三个属性：

capacity
position
limit

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

capacity

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

position

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

当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0. 当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。

limit

在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。写模式下，limit等于Buffer的capacity。

当切换Buffer到读模式时， limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据（limit被设置成已写数据的数量，这个值在写模式下就是position）

Buffer的具体实现：

/**
 * buffer的实现原理
 * private int mark = -1;//标记
 * private int position = 0;//位置
 * private int limit;//限制
 * private int capacity;//容量
 */
public class Demo2 {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        System.out.println("------写入数据之前-----");
        System.out.println("容量："+buffer.capacity());
        System.out.println("限制："+buffer.limit());
        System.out.println("位置："+buffer.position());

        buffer.put("hello".getBytes());
        System.out.println("------写入数据之后-----");
        System.out.println("容量："+buffer.capacity());
        System.out.println("限制："+buffer.limit());
        System.out.println("位置："+buffer.position());

        //将写入切换成读取模式
        buffer.flip();
        System.out.println("------切换模式后-----");
        System.out.println("容量："+buffer.capacity());
        System.out.println("限制："+buffer.limit());
        System.out.println("位置："+buffer.position());

        //读取
        byte [] bytes = new byte[buffer.limit()];
        buffer.get(bytes);
        System.out.println("------读取数据之后-----");
        System.out.println("容量："+buffer.capacity());
        System.out.println("限制："+buffer.limit());
        System.out.println("位置："+buffer.position());

        //rewind();返回
        buffer.rewind();
        System.out.println("------rewind数据之后-----");
        System.out.println("容量："+buffer.capacity());
        System.out.println("限制："+buffer.limit());
        System.out.println("位置："+buffer.position());

        byte b1 = buffer.get();
        byte b2 =buffer.get();
        byte b3 =buffer.get();
        System.out.println("------读取三个数据之后-----");
        System.out.println("容量："+buffer.capacity());
        System.out.println("限制："+buffer.limit());
        System.out.println("位置："+buffer.position());

        buffer.compact();
        System.out.println("------compact()数据之后-----");
        System.out.println("容量："+buffer.capacity());
        System.out.println("限制："+buffer.limit());
        System.out.println("位置："+buffer.position());

        buffer.flip();
        byte b4 = buffer.get();
        byte b5 = buffer.get();
        System.out.println((char)b4);
        System.out.println((char)b5);



        buffer.clear();
        System.out.println("------清空数据之后-----");
        System.out.println("容量："+buffer.capacity());
        System.out.println("限制："+buffer.limit());
        System.out.println("位置："+buffer.position());

        System.out.println(bytes.length);//清空之后，数据还在


    }
}

public class Demo3 {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put("hello".getBytes());
        buffer.flip();
        byte[] bytes = new byte[2];
        buffer.get(bytes);
        System.out.println("第一次读取");
        System.out.println(new String(bytes));

        buffer.mark();//标记
        buffer.get(bytes);
        System.out.println("第二次读取");
        System.out.println(new String(bytes));

        buffer.reset();//回到上一个标记位置
        System.out.println("第三次读取");
        System.out.println(new String(bytes));

    }
}

通过运行以上代码，可以直观地看出方法的具体功能和部分作用相近方法的不同之处，比如：

**flip()方法**
	flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，
并将limit设置成之前position的值。
	换句话说，position现在用于标记读的位置，limit表示之前写进了多少个
byte、char等现在能读取多少个byte、char等。
	
**rewind()方法**
	Buffer.rewind()将position设回0，所以你可以重读Buffer中的所有数据。
limit保持不变，仍然表示能从Buffer中读取多少个元素（byte、char等）。

**clear()与compact()方法**
 	一旦读完Buffer中的数据，需要让Buffer准备好再次被写入。
 可以通过clear()或compact()方法来完成。
	如果调用的是clear()方法，position将被设回0，limit被设置成 capacity的值。
换句话说，Buffer 被清空了。Buffer中的数据并未清除，只是这些标记告诉我们
可以从哪里开始往Buffer里写数据。如果Buffer中有一些未读的数据，调用clear()方法，
数据将“被遗忘”，意味着不再有任何标记会告诉你哪些数据被读过，哪些还没有。
	如果Buffer中仍有未读的数据，且后续还需要这些数据，但是此时想要先写些数据，
那么使用compact()方法。compact()方法将所有未读的数据拷贝到Buffer起始处。
然后将position设到最后一个未读元素正后面。limit属性依然像clear()方法一样，
设置成capacity。现在Buffer准备好写数据了，但是不会覆盖未读的数据。
	
**mark()与reset()方法**
	通过调用Buffer.mark()方法，可以标记Buffer中的一个特定position。
之后可以通过调用Buffer.reset()方法恢复到这个position

3.Channel的使用

基本上，所有的 IO 在NIO 中都从一个Channel 开始。Channel 有点象流。数据可以从Channel读到Buffer中，也可以从Buffer 写到Channel中。

Java NIO中的一些主要Channel的实现：

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel

3.1Channel基本功能展示：

public class Demo1 {
    public static void main(String[] args) throws IOException {
        /*
        使用一个InputStream、OutputStream或RandomAccessFile来获取一个FileChannel实例。
         */
//        创建RandomAccessFile
//        RandomAccessFile raf = new RandomAccessFile("info.txt","r" );
//        获取通道
//        FileChannel channel = raf.getChannel();

        /*
        JDK1.7后可以使用 FileChannel.open()方法
         */
        FileChannel channel = FileChannel.open(Paths.get("info.txt"), StandardOpenOption.READ);
        //读取
        ByteBuffer buf = ByteBuffer.allocate(1024);

        while(channel.read(buf)>0){
            //切换读取模式
            buf.flip();
            String  data = new String(buf.array(),0,buf.limit());
            System.out.println(data);
            buf.clear();
        }

        //关闭
        channel.close();
//        raf.close();
    }
}

3.2创建FileChannel

在使用FileChannel之前，必须先创建它。创建方式有两种：

第一种：使用一个InputStream、OutputStream或RandomAccessFile来获取一个FileChannel实例。

第二种：JDK1.7之后可以使用FileChannel.open()方法。

3.3从FileChannel读取数据

调用多个read()方法之一从FileChannel中读取数据。

首先，分配一个Buffer。从FileChannel中读取的数据将被读到Buffer中。然后，调用FileChannel.read()方法。该方法将数据从FileChannel读取到Buffer中。read()方法返回的int值表示了有多少字节被读到了Buffer中。如果返回-1，表示到了文件末尾。

3.4向FileChannel写数据

使用FileChannel.write()方法向FileChannel写数据，该方法的参数是一个Buffer。

注意FileChannel.write()是在while循环中调用的。因为无法保证write()方法一次能向FileChannel写完所有字节，因此需要重复调用write()方法，直到Buffer中已经没有尚未写入通道的字节。

3.5关闭FileChannel

用完FileChannel后必须将其关闭

3.6Channel的其他应用

写入文本文件

//使用FileChannel写入文件
public class Demo2 {
    public static void main(String[] args) throws IOException {
        //创建FileChannel
        FileChannel fileChannel = FileChannel.open(Paths.get("hello.txt"), StandardOpenOption.WRITE,
                StandardOpenOption.CREATE, StandardOpenOption.APPEND);
        //创建缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        //处理数据
        for (int i = 0; i < 10; i++) {
            buf.put("好好学习".getBytes());
            buf.flip();
            fileChannel.write(buf);
            buf.clear();
        }
        //关闭
        fileChannel.close();

    }
}

读取文本文件

public class Demo2 {
    public static void main(String[] args) throws IOException {
       //1创建FileInputStream
		FileInputStream fis=new 		FileInputStream("d:\\out.txt");
		//2创建通道
		FileChannel inChannel = fis.getChannel();
		//3创建缓冲区
		ByteBuffer buffer=ByteBuffer.allocate(1024);
		int len=inChannel.read(buffer);
		System.out.println(len);
		//4处理数据
		buffer.flip();
		String data=new String(buffer.array(),0,len);
		System.out.println(data);

		//5关闭
		inChannel.close(); 

    }
}

复制图片

public class Demo3 {
    public static void main(String[] args) throws IOException {
        FileChannel readChannel = FileChannel.open(Paths.get("nadou.jpg"), StandardOpenOption.READ);
        FileChannel writeChannel = FileChannel.open(Paths.get("nadou1.jpg"), StandardOpenOption.WRITE,StandardOpenOption.CREATE);

        ByteBuffer buf = ByteBuffer.allocate(1024);
        while(readChannel.read(buf)>0){
            buf.flip();
            writeChannel.write(buf);
            buf.clear();
        }
        readChannel.close();
        writeChannel.close();
        System.out.println("复制完毕");
    }
}

使用内存映射文件复制大文件

注意：如果文件超过2G,需要分多个文件映射。

public class Demo4 {
    public static void main(String[] args) throws IOException {
        FileChannel readChannel = FileChannel.open(Paths.get("001.wmv"), StandardOpenOption.READ);
        FileChannel writeChannel = FileChannel.open(Paths.get("002.wmv"), StandardOpenOption.WRITE,StandardOpenOption.CREATE);

        MappedByteBuffer map = readChannel.map(FileChannel.MapMode.READ_ONLY, 0, readChannel.size());
        writeChannel.write(map);
        readChannel.close();
        writeChannel.close();
        System.out.println("复制完成");
    }

}

4.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 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。