java nio典型示例

NIO基础

Buffer

Buffer工作原理：capacity - 缓冲区容量，缓冲区满了以后，必须清空后才能继续写入数据。position - 写数据到缓冲区时，position代表写入数据的当前位置，初始值为0，当一个字节数据写入到缓冲区后，position会移动到写一个可插入数据的缓冲区单元；当从缓冲区中读取数据时，position表示读取数据的当前位置，调用flip方法切换到读模式时，position会被重置为零。limit - 写数据时表示最多可以写入多少个数据；读数据时，表示还有多少个数据可读取。

//IntBufferDemo.java
import java.nio.IntBuffer;

public class IntBufferDemo {
    public static void main(String[] args) {
    	//每个Buffer类都有一个allocate方法
        IntBuffer buffer = IntBuffer.allocate(8);
        for (int i = 0; i < buffer.capacity(); i++) {
            int j = 2 * (i+1);
            //可以使用通道或者put方法写入数据到缓冲区
            buffer.put(j);
        }
        //clear方法清空缓冲区，compact方法只清除已读取过的数据
        //mark方法可以标记缓冲区中的一个特定position，然后可以通过reset恢复到这个位置
        //rewind方法是把position设置为0，可以重读缓冲区中的数据
        //flip方法把缓冲区从写模式切换到读模式，把limit设置成position的当前值，然后把position清零
        buffer.flip();
        while(buffer.hasRemaining()) {
            //从缓冲区读取数据，可以使用通道读取或者使用get方法
            System.out.println(buffer.get() + ",");
        }
    }
}

//BufferDemo1.java
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class BufferDemo1 {
    public static void main(String[] args) throws Exception {
        RandomAccessFile file = new RandomAccessFile("01.txt", "rw");
        //文件通道从缓冲区读取数据
        FileChannel channel = file.getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = channel.read(buffer);
        while(bytesRead != -1){
            buffer.flip();
            while(buffer.hasRemaining()){
                System.out.print((char)buffer.get());
            }
            buffer.clear();
            bytesRead = channel.read(buffer);
        }
        file.close();
    }
}

//BufferDemo2.java
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class BufferDemo2 {
    public static void main(String[] args) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        for(int i=0;i<buffer.capacity();i++){
            buffer.put((byte)i);
        }

        //创建子缓冲区
        buffer.position(3);
        buffer.limit(7);
        ByteBuffer sliceBuffer = buffer.slice();
        for(int i=0;i<sliceBuffer.capacity();i++){
            byte b = sliceBuffer.get(i);
            b *= 10;
            sliceBuffer.put(i, b);
        }
        buffer.position(0);
        buffer.limit(buffer.capacity());
        while(buffer.hasRemaining()){
            System.out.println(buffer.get());
        }

        //创建只读缓冲区，只读缓冲区随着原缓冲区发生变化
        IntBuffer intBuffer = IntBuffer.allocate(10);
        for(int i=0;i<intBuffer.capacity();i++){
            intBuffer.put(i);
        }
        IntBuffer readOnlyBuffer = intBuffer.asReadOnlyBuffer();
        for(int i=0;i<intBuffer.capacity();i++){
            int b = intBuffer.get(i);
            b *= 10;
            intBuffer.put(i, b);
        }
        readOnlyBuffer.position(0);
        readOnlyBuffer.limit(intBuffer.capacity());
        while(readOnlyBuffer.hasRemaining()){
            System.out.println(readOnlyBuffer.get());
        }

        //直接缓冲区
        //ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);

        //内存映射文件I/O
        RandomAccessFile file = new RandomAccessFile("02.txt", "rw");
        FileChannel fileChannel = file.getChannel();
        MappedByteBuffer mbb = 
            fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
        mbb.put(0, (byte)97);
        mbb.put(1023, (byte)122);
        file.close();
    }
}

• 使用多线程的方式实现

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NioBufferInstance {

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        //获取流的位置
        service.submit(() -> {
            IntBuffer buffer = IntBuffer.allocate(10);
            System.out.println("The capacity of ints buffer:" + buffer.capacity());
            Arrays.asList(0, 1, 2, 3, 4)
                .forEach(p -> buffer.put(new SecureRandom().nextInt(20)));
            System.out.println("before flip limit:" + buffer.limit());
            buffer.flip();
            System.out.println("after flip limit:" + buffer.limit());
            while(buffer.hasRemaining()){
                System.out.println("position:" + buffer.position());
                System.out.println("limit:" + buffer.limit());
                System.out.println("capacity:" + buffer.capacity());
                System.out.println(buffer.get());
            }
        });

        //文件通道读写
        service.submit(() -> {
            try {
                FileOutputStream os = new FileOutputStream("output.txt");
                FileInputStream is = new FileInputStream("input.txt");
                FileChannel inputChannel = is.getChannel();
                FileChannel outputChannel = os.getChannel();
                ByteBuffer buffer = ByteBuffer.allocate(4);
                while(true){
                    buffer.clear();
                    int read = inputChannel.read(buffer);
                    System.out.println("read:" + read);
                    if(read == -1){
                        break;
                    }

                    buffer.flip();
                    outputChannel.write(buffer);
                }

                inputChannel.close();
                outputChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        //随机存取，使用堆外内存
        service.submit(() -> {
            try {
                RandomAccessFile file = new RandomAccessFile("test.txt", "rw");
                FileChannel channel = file.getChannel();
                MappedByteBuffer buffer = 
                    channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);
                buffer.put(0, (byte) 'a');
                buffer.put(3, (byte) 'b');
                file.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        //allocate wrap HeapByteBuffer 在JVM堆中创建缓冲区
        //directBuffer DirectByteBuffer 在堆外创建缓冲区，直接与IO设备交互，零拷贝
        service.submit(() -> {
            ByteBuffer buffer = ByteBuffer.allocate(64);
            buffer.putInt(15);
            buffer.putLong(500000000L);
            buffer.putChar('你');
            buffer.putShort((short) 2);
            buffer.putChar('我');
            buffer.flip();
            System.out.println(buffer.getInt() + ","
                               + buffer.getLong() + "," + buffer.getChar()
                    + ',' + buffer.getShort() + "," + buffer.getChar());
            //重置position、limit后重新赋值
            buffer.clear();
            for(int i=0; i<buffer.capacity(); i++){
                buffer.put((byte) i);
            }

            //指定position和limit
            buffer.position(2);
            buffer.limit(6);
            //slice创建一个新的ByteBuffer，新的ByteBuffer操作的结果影响原ByteBuffer
            ByteBuffer sliceBuffer = buffer.slice();
            for(int i=0;i<sliceBuffer.capacity();i++){
                byte b = sliceBuffer.get(i);
                b *= 2;
                sliceBuffer.put(i, b);
            }
            buffer.position(0);
            buffer.limit(buffer.capacity());
            while(buffer.hasRemaining()){
                System.out.print(buffer.get() + "\t");
            }
            System.out.println();
            buffer.clear();
            System.out.println(buffer.getClass());
            ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();
            System.out.println(readOnlyBuffer.getClass());
        });

        //通道写
        service.submit(() -> {
            try {
                FileOutputStream fos = new FileOutputStream("NioChannelDemo.txt");
                FileChannel channel = fos.getChannel();
                ByteBuffer buffer = ByteBuffer.allocate(512);
                byte[] message = "Hello world, welcome!".getBytes();
                for(byte b:message){
                    buffer.put(b);
                }
                buffer.flip();
                channel.write(buffer);
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        //通道读
        service.submit(() -> {
            try {
                FileInputStream fis = new FileInputStream("NioChannelDemo.txt");
                FileChannel fileChannel = fis.getChannel();
                ByteBuffer byteBuffer = ByteBuffer.allocate(512);
                fileChannel.read(byteBuffer);
                byteBuffer.flip();
                while(byteBuffer.remaining() > 0){
                    byte b = byteBuffer.get();
                    System.out.println("Character:" + (char)b);
                }

                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
    }

}

Channel

SocketChannel是用来连接到TCP网络套接字的通道，主要用来处理网络IO通道，基于TCP传输，实现了可选择通道，可以被多路复用。对于已经存在的套接字不能创建SocketChannel。没有进行连接的SocketChannel执行IO操作时会抛异常。SocketChannel的open方法创建的通道没有进行网络级联，需要使用connect方法连接到指定地址。SocketChannel支持异步关闭、设定参数。ServerSocketChannel是一个基于通道的socket监听器，调用accept方法返回SocketChannel。

//SocketChannelDemo.java
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class SocketChannelDemo {
    public static void main(String[] args) throws IOException {
        //创建SocketChannel
        SocketChannel socketChannel = 
            SocketChannel.open(new InetSocketAddress("www.baidu.com", 80));
        socketChannel.configureBlocking(false);
        ByteBuffer buffer = ByteBuffer.allocate(16);
        socketChannel.read(buffer);
        socketChannel.close();
        System.out.println("read over");
    }
}

//ServerSocketChannelDemo.java
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

public class ServerSocketChannelDemo {
    public static void main(String[] args) throws IOException {
        int port = 8888;
        //创建Buffer
        ByteBuffer buffer = ByteBuffer.wrap("hello world".getBytes());
        //打开ServerSocketChannel，绑定端口号
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress(port));
        //设置非阻塞模式
        ssc.configureBlocking(false);
        //监听新连接
        for(;;){
            System.out.println("Waiting for connecting...");
            SocketChannel sc = ssc.accept();
            if(sc == null){
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                System.out.println("Incoming connection from:" 
                                   + sc.socket().getRemoteSocketAddress());
                buffer.rewind();
                sc.write(buffer);
                sc.close();
            }
        }
    }
}

//PipeDemo.java
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;

//管道是两个线程之间的单项数据连接，数据会被写到sink通道，从source通道读取
public class PipeDemo {
    public static void main(String[] args) throws IOException {
 		//获取通道
        Pipe pipe = Pipe.open();
        Pipe.SinkChannel sinkChannel = pipe.sink();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put("hello".getBytes());
        buffer.flip();
        sinkChannel.write(buffer);
        Pipe.SourceChannel sourceChannel = pipe.source();
        buffer.flip();
        int len = sourceChannel.read(buffer);
        System.out.println(new String(buffer.array(), 0,len));
        sourceChannel.close();
        sinkChannel.close();
    }
}

//DatagramChannelDemo.java
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;

//DatagramChannel是无连接的
public class DatagramChannelDemo {

    public static void main(String[] args) throws IOException {
        System.out.println("程序启动...");
    }

    private void sendDatagram() throws IOException {
        DatagramChannel sendChannel = DatagramChannel.open();
        InetSocketAddress sendAddress = new InetSocketAddress("localhost", 9999);
        while(true){
            ByteBuffer buffer = ByteBuffer.wrap("Hello World".getBytes());
            sendChannel.send(buffer, sendAddress);
            System.out.println("已经发送成功");
        }
    }

    private void receiveDatagram() throws IOException {
        DatagramChannel receiveChannel = DatagramChannel.open();
        InetSocketAddress receiveAddress = new InetSocketAddress(9999);
        receiveChannel.bind(receiveAddress);
        ByteBuffer receiveBuffer = ByteBuffer.allocate(1024);
        while(true){
            receiveBuffer.clear();
            SocketAddress socketAddress = receiveChannel.receive(receiveBuffer);
            receiveBuffer.flip();
            System.out.println(socketAddress.toString());
            System.out.println(receiveBuffer);
        }
    }
}

//FileChannelDemo1.java
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * 通过FileChannel将数据写入缓冲区
 */
public class FileChannelDemo1 {
    public static void main(String[] args) throws IOException {
        //创建FileChannel
        RandomAccessFile file = 
            new RandomAccessFile("C:\\Mermaid使用.md", "rw");
        FileChannel channel = file.getChannel();
        //创建Buffer
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //读取数据到buffer中
        int bytesRead = channel.read(buffer);
        while(bytesRead != -1){
            System.out.println("读取了:" + bytesRead);
            //读写模式转换
            buffer.flip();
            while(buffer.hasRemaining()){
                System.out.println((char)buffer.get());
            }
            //清除缓冲区内容
            buffer.clear();
            bytesRead = channel.read(buffer);
        }
        file.close();
        System.out.println("程序结束");
    }
}

//FileChannelDemo2.java
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * 通过FileChannel从缓冲区读取数据
 */
public class FileChannelDemo2 {

    public static void main(String[] args) throws IOException {
        RandomAccessFile file = new RandomAccessFile("C:\\LICCD.txt", "rw");
        FileChannel channel = file.getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        String data = "Test 12345";
        buffer.clear();
        buffer.put(data.getBytes());
        buffer.flip();
        //需要循环写入
        while(buffer.hasRemaining()){
            channel.write(buffer);
        }
        channel.close();
    }

}

//FileChannelDemo3.java
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;

/**
 * 通道之间数据传输
 */
public class FileChannelDemo3 {
    public static void main(String[] args) throws IOException {
        RandomAccessFile aFile = new RandomAccessFile("C:\\01.txt", "rw");
        RandomAccessFile bFile = new RandomAccessFile("C:\\02.txt", "rw");
        FileChannel fromChannel = aFile.getChannel();
        FileChannel toChannel = bFile.getChannel();
        long position = 0;
        long size = fromChannel.size();
        //position() - 返回此通道文件位置， position(long) - 设置此通道的文件长度
        //transferFrom - 把数据从源通道传输到FileChannel中;
        //transferTo - 将数据从FileChannel传输到其他的FileChannel中
        toChannel.transferFrom(fromChannel, position, size);
        //fromChannel.transferTo(position, size, toChannel);
        aFile.close();
        bFile.close();
    }
}

//FileLockDemo.java
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
//文件锁的使用
public class FileLockDemo {
    public static void main(String[] args) throws IOException {
        String input = "Hello World!";
        ByteBuffer buffer = ByteBuffer.wrap(input.getBytes());
        String filePath = "01.txt";
        Path path = Paths.get(filePath);
        FileChannel channel = FileChannel.open(path, StandardOpenOption.WRITE,
                                               StandardOpenOption.APPEND);
        channel.position(channel.size() - 1);
        FileLock lock = channel.lock();
        System.out.println("是否共享锁:" + lock.isShared());
        channel.write(buffer);
        channel.close();

        FileReader fileReader = new FileReader(filePath);
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String line = bufferedReader.readLine();
        System.out.println("读取出内容：");
        while(line != null){
            System.out.println(line);
            line = bufferedReader.readLine();
        }
        fileReader.close();
        bufferedReader.close();
    }
}

//AsyncFileChannelDemo.java
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

/**
 * 文件通道异步读取
 */
public class AsyncFileChannelDemo {
    public static void main(String[] args) throws IOException {
        Path path = Paths.get("01.txt");
        AsynchronousFileChannel fileChannel = 
            AsynchronousFileChannel.open(path, StandardOpenOption.READ);
        ByteBuffer buffer  = ByteBuffer.allocate(1024);
//        使用Future处理结果集
//        Future future = fileChannel.read(buffer, 0);
//        //判断是否完成
//        while(!future.isDone());
//        buffer.flip();
//        while(buffer.hasRemaining()){
//            System.out.print((char)buffer.get());
//        }
//        buffer.clear();
        //使用CompletionHandler接口处理结果
        fileChannel.read(buffer, 0, buffer, 
                         new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                attachment.flip();
                byte[] data = new byte[attachment.limit()];
                attachment.get(data);
                System.out.print(new String(data));
                attachment.clear();
            }

            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                System.out.println(exc.getMessage());
            }
        });
    }
}

Selector

Selector选择器也叫做多路复用器，用于检查一个或多个通道的状态是否可读写。使用Selector的好处在于使用更少的线程处理通道，避免多线程上下文切换带来的开销。不是所有的Channel都可以被Selector复用的，继承可选择通道SelectableChannel就可以复用。一个通道可以被注册到多个选择器上，而每个选择器只能被注册一次。

//SelectorDemo.java
public class SelectorDemo {
    public static void main(String[] args) throws IOException {
        //与Selector多路复用器一起使用时，Channel必须是非阻塞的
        Selector selector = Selector.open();
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);
        ssc.bind(new InetSocketAddress(8000));
        ssc.register(selector, SelectionKey.OP_ACCEPT);
        Set<SelectionKey> selectionKeys = selector.selectedKeys();
        Iterator<SelectionKey> iterator = selectionKeys.iterator();
        while(iterator.hasNext()) {
            SelectionKey key = iterator.next();
            if (key.isAcceptable()) {
                System.out.println("accept");
            } else if (key.isConnectable()) {
                System.out.println("connect");
            } else if (key.isReadable()) {
                System.out.println("read");
            } else if (key.isWritable()) {
                System.out.println("write");
            }
            iterator.remove();
        }
    }
}

//SelectorTest.java
public class SelectorTest {
    @Test
    public void send() throws IOException {
        //获取通道、绑定主机和端口，切换到非阻塞模式，
        //创建Buffer写入数据，模式切换，写入通道，关闭
        SocketChannel sc = SocketChannel.open(new InetSocketAddress(8888));
        sc.configureBlocking(false);
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put(new Date().toString().getBytes());
        buffer.flip();
        sc.write(buffer);
        buffer.close();
    }
    
    @Test
    public void recevie() throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress(8888));
        ssc.configureBlocking(false);
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        Selector selector = Selector.open();
        ssc.register(selector, SelectionKey.OP_ACCEPT);
        while(selector.select() > 0) {
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while(iterator.hasNext()){
                SelectionKey key = iterator.next();
                if(key.isAcceptable()) {
                    //注册关心的事件
                    SocketChannel sc = ssc.accept();
                    sc.configureBlocking(false);
                    sc.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    SocketChannel channel = (SocketChannel) key.channel();
                    int len = 0;
                    while((len = channel.read(buffer)) > 0) {
                        buffer.flip();
                        System.out.println(new String(buffer.array(), 0, len));
                        buffer.clear();
                    }
                }
                iterator.remove();
            }
        }
    }
}

//CharsetDemo.java
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;

public class CharsetDemo {
    public static void main(String[] args) throws IOException {
        Charset charset = Charset.forName("UTF-8");
        CharsetEncoder encoder = charset.newEncoder();
        CharBuffer charBuffer = CharBuffer.allocate(1024);
        charBuffer.put("醉里挑灯看剑");
        charBuffer.flip();
        ByteBuffer buffer = encoder.encode(charBuffer);
        System.out.println("编码之后的结果:");
        for(int i=0;i<buffer.limit();i++){
            System.out.print(buffer.get());
        }
        System.out.println();
        buffer.flip();
        CharsetDecoder decoder = charset.newDecoder();
        System.out.println("解码之后的结果:");
        System.out.println(decoder.decode(buffer));
    }
}

//PathDemo.java
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class PathDemo {
    public static void main(String[] args) throws IOException {
        Path path = Paths.get("C:\\2022\\01.txt");
        System.out.println(path);
        path = Paths.get("C:\\2022", "01");
        System.out.println(path);
        System.out.println(path.normalize());
        Path directory = Files.createDirectory(path);
        System.out.println(directory);
        Files.copy(path, directory);
    }
}