Java NIO笔记

左手的ㄟ右手 2021-11-17 00:01 177阅读 0赞

**内容来源于尚硅谷网课**

*  传统IO是面向流的，单向，阻塞
 *  NIO (NEW IO | NO BLOCKING IO)是面向缓冲区，双向，非阻塞，具有选择器

## 1、缓存区（Buffer 火车），容纳数据，传输数据 ##

### 1.1 创建指定大小的Buffer ###

ByteBuffer buf=ByteBuffer.allocate(1024);

### 1.2 两个核心方法 ###

put() 方法存入数据到缓冲区  
get() 方法读取缓冲区中数据

### 1.3 四个核心属性 ###

capacity 缓冲区中最大存储容量  
limit 缓冲区中可以操作数据的容量  
position 缓冲区中正在操作数据的位置  
mark 记录当前position值，通过reset()恢复到mark位置  
mark<=position<=limit<=capacity

String str="abcde";
    buf.put(str.getBytes());
    System.out.println(buf.position()); //5
    System.out.println(buf.limit()); //1024
    System.out.println(buf.capacity()); //1024

### 1.4 读写操作 ###

flip() 写模式->读模式 limit=position ; position=0;

buf.flip();
    System.out.println(buf.position()); //0
    System.out.println(buf.limit()); //5
    System.out.println(buf.capacity()); //1024
    
    byte[] dst=new byte[buf.limit()];
    buf.get(dst,0,2);
        
    System.out.println(buf.position()); //2
    System.out.println(buf.limit()); //5
    System.out.println(buf.capacity()); //1024
    
    buf.mark();
    buf.get(dst,2,2);
    System.out.println(buf.position()); //4
    buf.reset();
    System.out.println(buf.position()); //2

rewind() 重读 limit=position ; position=0;

buf.rewind();
    
    System.out.println(buf.position()); //0
    System.out.println(buf.limit()); //5
    System.out.println(buf.capacity()); //1024

clear() 清空缓冲区，数据依然存在，只是处于“被遗忘“状态

buf.clear();
    
    System.out.println(buf.position()); //0
    System.out.println(buf.limit()); //1024
    System.out.println(buf.capacity()); //1024

hasRemaining() 判断缓冲区是否有可操作数据

remaining() 返回可操作数据量

### 1.5 直接缓冲区和非直接缓冲区 ###

*  非直接缓冲区：通过allocate() 方法分配缓冲区，将缓冲区建立在JVM的内存中

物理磁盘->read(将数据读取到内核地址空间缓冲区中)->copy(将数据复制到用户地址空间缓冲区中)->read(将复制数据读到应用程序中)

应用程序->write(将数据写入用户地址空间缓冲区中)->copy(将数据复制到内核地址空间缓冲区中)->write(将复制数据写入物理磁盘)

*  直接缓冲区：通过allocateDirect()方法分配缓冲区，将缓冲区直接建立在物理内存中（提高效率）  
    直接在操作系统的物理内存中建立映射文件，勉去中间copy过程（资源消耗大，不安全，不易控制）

isDirect() 判断是否为直接缓冲区

## 2、通道（Channel 铁路），连接数据源节点和目标节点 ##

传统方式：DMA向CPU申请权限，全权操作IO接口

NIO方式：Channel作为一个完全独立的处理器，专门用于IO操作，不用向CPU申请权限

### 2.1 主要实现类 ###

java.nio.channel.Channel 接口

|--FileChannel
    |--SocketChannel
    |--ServerSocketChannel
    |--DatagramChannel

### 2.2 获取通道 ###

JAVA针对支持通道的类提供了getChannel()方法

本地IO：
    	FileInputStream/FileOutputStream
    	RandimAccessFile
    网络IO：
    	Socket
    	ServerSocket
    	DatagramSocket
    
    /*文件复制示例代码*/
    import org.junit.Test;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.nio.ByteBuffer;
    import java.nio.MappedByteBuffer;
    import java.nio.channels.FileChannel;
    import java.nio.file.Paths;
    import java.nio.file.StandardOpenOption;
    
    public class NIOTest {
        @Test
        public void noDirectTest() throws Exception {
            /*非直接缓冲区复制文件*/
            try(
                    FileInputStream inputStream=new FileInputStream(new File("source.png"));
                    FileOutputStream outputStream=new FileOutputStream(new File("target.png"))
            ){
                FileChannel inChannel=inputStream.getChannel();
                FileChannel outChannel=outputStream.getChannel();
                ByteBuffer buf=ByteBuffer.allocate(1024);
                while (((inChannel).read(buf))!=-1) {
                    buf.flip();
                    outChannel.write(buf);
                    buf.clear();
                }
            }
        }
        @Test
        public void directTest() throws Exception {
            /*直接缓冲区复制文件*/
            FileChannel inChannel=FileChannel.open(Paths.get("source.png"),StandardOpenOption.READ);
            FileChannel outChannel=FileChannel.open(Paths.get("Target.png"),StandardOpenOption.READ,
                    StandardOpenOption.WRITE,StandardOpenOption.CREATE);
            /*
            ByteBuffer buf=ByteBuffer.allocateDirect(1024);
            while (((inChannel).read(buf))!=-1) {
                buf.flip();
                outChannel.write(buf);
                buf.clear();
            }*/
            MappedByteBuffer inMappedByteBuffer=inChannel.map(FileChannel.MapMode.READ_ONLY,0,inChannel.size());
            MappedByteBuffer outMappedByteBuffer=outChannel.map(FileChannel.MapMode.READ_WRITE,0,inChannel.size());
            byte[] dst=new byte[inMappedByteBuffer.limit()];
            inMappedByteBuffer.get(dst);
            outMappedByteBuffer.put(dst);
            inChannel.close();
            outChannel.close();
        }
    }

### 2.3 通道间进行数据传输（直接缓冲区） ###

transferFrom()  
transferTo()

/*文件复制示例代码*/
    FileChannel inChannel=FileChannel.open(Paths.get("source.png"),StandardOpenOption.READ);
    FileChannel outChannel=FileChannel.open(Paths.get("Target.png"),StandardOpenOption.READ,
                    StandardOpenOption.WRITE,StandardOpenOption.CREATE);
    inChannel.transferTo(0,inChannel.size(),outChannel);
    //outChannel.transferFrom(inChannel,0,inChannel.size());
    inChannel.close();
    outChannel.close();

### 2.4 分散与聚集 ###

*  分散读取（Scattering Reads）:将一个通道数据分散到多个缓冲区
 *  聚集写入（Gathering Writes）:将多个缓冲区数据聚集到一个通道
    
        //分散读取
          RandomAccessFile raf1=new RandomAccessFile("source.txt","rw");
          FileChannel channel1=raf.getChannel();
          ByteBuffer buf1=ByteBuffer.allocate(1024);
          ByteBuffer buf2=ByteBuffer.allocate(1024);
          ByteBuffer[] bufs={buf1,buf2};
          channel1.read(bufs);
          
          for(ByteBuffer buf:bufs)
          	buf,flip();
          System.out.println(new String(bufs[0].array(),0,bufs[0].limit()));
          System.out.println(new String(bufs[1].array(),0,bufs[1].limit()));
          //聚集写入
          RandomAccessFile raf2=new RandomAccessFile("target.txt","rw");
          FileChannel channel2=raf.getChannel();
          channel2.write(bufs);

## 3、选择器（Selector） ##

所有通道都注册在选择器上，选择器监控通道中IO状况，当通道中数据完全就绪后，选择器才会将其分配到各个线程，所以能做到非阻塞

使用NIO进行网络通信的三个核心

//阻塞模式

import org.junit.Test;
    
    import java.io.IOException;
    import java.net.*;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    import java.nio.channels.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.nio.file.Paths;
    import java.nio.file.StandardOpenOption;
    
    public class BlockingNIOTest {
        @Test
        public void server(){
            ServerSocketChannel serverSocketChannel=null;
            FileChannel fileChannel=null;
            SocketChannel socketChannel=null;
            try {
                serverSocketChannel=ServerSocketChannel.open();
                serverSocketChannel.bind(new InetSocketAddress(8888));
                fileChannel=FileChannel.open(Paths.get("target.png"),StandardOpenOption.WRITE,
                        StandardOpenOption.CREATE);
                ByteBuffer buf=ByteBuffer.allocate(1024);
                socketChannel=serverSocketChannel.accept();
                while((socketChannel.read(buf))!=-1){
                    buf.flip();
                    fileChannel.write(buf);
                    buf.clear();
                }
                buf.put("Server已成功接收数据".getBytes());
                buf.flip();
                socketChannel.write(buf);
                buf.clear();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(serverSocketChannel!=null){
                    try {
                        serverSocketChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(socketChannel!=null){
                    try {
                        socketChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(fileChannel!=null){
                    try {
                        fileChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        @Test
        public void client(){
            SocketChannel socketChannel=null;
            FileChannel fileChannel=null;
            try {
                socketChannel=SocketChannel.open(
                        new InetSocketAddress("127.0.0.1",8888));
                fileChannel=FileChannel.open(Paths.get("source.png"),StandardOpenOption.READ);
                ByteBuffer buf=ByteBuffer.allocate(1024);
                while ((fileChannel.read(buf))!=-1){
                    buf.flip();
                    socketChannel.write(buf);
                    buf.clear();
                }
                socketChannel.shutdownOutput();
                while((socketChannel.read(buf))!=-1){
                    buf.flip();
                    System.out.println(new String(buf.array(),0,buf.limit()));
                    buf.clear();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(socketChannel!=null) {
                    try {
                        socketChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(fileChannel!=null){
                    try {
                        fileChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

channel.configureBlocking(false) 切换为非阻塞模式

import org.junit.Test;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.SelectionKey;
    import java.nio.channels.Selector;
    import java.nio.channels.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.util.Date;
    import java.util.Iterator;
    
    public class NonBlockingNIOTest {
        @Test
        public void client() throws IOException {
            SocketChannel socketChannel=SocketChannel.open(
                    new InetSocketAddress("127.0.0.1",8888));
            socketChannel.configureBlocking(false);
            ByteBuffer buf=ByteBuffer.allocate(1024);
            buf.put(new Date().toString().getBytes());
            buf.flip();
            socketChannel.write(buf);
            buf.clear();
            socketChannel.close();
        }
        @Test
        public void server() throws IOException {
            ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.bind(new InetSocketAddress(8888));
            Selector selector=Selector.open();
            serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
            while (selector.select()>0){
                Iterator<SelectionKey> iterator =selector.selectedKeys().iterator();
                while (iterator.hasNext()){
                    SelectionKey selectionKey=iterator.next();
                    if(selectionKey.isAcceptable()){
                        SocketChannel socketChannel=serverSocketChannel.accept();
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector,SelectionKey.OP_READ);
                    }else if(selectionKey.isReadable()){
                        SocketChannel socketChannel= (SocketChannel) selectionKey.channel();
                        ByteBuffer buf=ByteBuffer.allocate(1024);
                        while((socketChannel.read(buf))!=-1){
                            buf.flip();
                            System.out.println(new String(buf.array(),0,buf.limit()));
                            buf.clear();
                        }
                    }
                    iterator.remove();
                }
            }
        }
    }