Java NIO系列教程四【完】-管道-文件锁-异步写入

一、Pipe管道

管道是 2 个线程之间的单向数据连接一个 source 通道（读取）和一个sink 通道（写入）

1.1 核心的方法

1. 打开管道

   Pipe pipe = Pipe.open();
   

2. 写入管道-需要访问 sink 通道

   Pipe.SinkChannel sinkChannel = pipe.sink();
   

3. 读取数据-需要访问 source 通道

   Pipe.SourceChannel sourceChannel = pipe.source();
   

1.2 案例演示使用

• 创建管道之后在创建sink管道
• 并且设置缓冲区将其写入
• 获取source管道并且读取数据

public class PipeDemo {
   

    public static void main(String[] args) throws IOException {
   
        //1 获取管道
        Pipe pipe = Pipe.open();
        //2 获取sink通道
        Pipe.SinkChannel sinkChannel = pipe.sink();
        //3 创建缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        byteBuffer.put("opencoder".getBytes());
        byteBuffer.flip();
        //4 写入数据
        sinkChannel.write(byteBuffer);
        //5 获取source通道
        Pipe.SourceChannel sourceChannel = pipe.source();
        //6 读取数据
        ByteBuffer byteBuffer2 = ByteBuffer.allocate(1024);
        //byteBuffer.flip();
        int length = sourceChannel.read(byteBuffer2);
        System.out.println(new String(byteBuffer2.array(),0,length));
        //7 关闭通道
        sourceChannel.close();
        sinkChannel.close();
    }

}

二、FileLock-文件锁

文件锁是进程级别的，不是线程级别的

具体分为两大类：

排它锁：又叫独占锁。对文件加排它锁后，该进程可以对此文件进行读写，该进程独占此文件，其他进程不能读写此文件，直到该进程释放文件锁。

共享锁：某个进程对文件加共享锁，其他进程也可以访问此文件，但这些进程都只能读此文件，不能写。线程是安全的。只要还有一个进程持有共享锁，此文件就只能读，不能写。

//创建 FileChannel 对象，文件锁只能通过 FileChannel 对象来使用
FileChannel fileChannel=new FileOutputStream("./opencoder.txt").getChannel();
//对文件加锁
FileLock lock=fileChannel.lock();
//对此文件进行一些读写操作。
//.......
//释放锁
lock.release();

2.1 核心方法

lock是阻塞，trylock是非阻塞获取文件锁的方法有如下：

• lock() //对整个文件加锁，默认为排它锁。
• lock(long position, long size, booean shared) //自定义加锁方式。
  前 2 个参数指定要加锁的部分（可以只对此文件的部分内容加锁），第三个参数值指定是否是共享锁
• tryLock() //对整个文件加锁，默认为排它锁。
• tryLock(long position, long size, booean shared) //自定义加锁方式。
  如果指定为共享锁，则其它进程可读此文件，所有进程均不能写此文件，如果某进程试图对此文件进行写操作，会抛出异常。

FileLock另外两个方法：

• boolean isShared() //此文件锁是否是共享锁
• boolean isValid() //此文件锁是否还有效

2.2 案例演示使用

​ path,StandardOpenOption.WRITE,StandardOpenOption.APPEND分别是路径，读写数据，追加数据

public class FileLockDemo1 {
   

    public static void main(String[] args) throws Exception {
   
        String input = "opencoder";
        System.out.println("input:"+input);

        ByteBuffer buffer = ByteBuffer.wrap(input.getBytes());

        String filePath = "d//opencoder.txt";
        Path path = Paths.get(filePath);

        FileChannel channel =
                FileChannel.open(path,
                        StandardOpenOption.WRITE,StandardOpenOption.APPEND);
        channel.position(channel.size()-1);

        //加锁
        FileLock lock = channel.lock(0L,Long.MAX_VALUE,true);
        System.out.println("是否共享锁："+lock.isShared());

        channel.write(buffer);
        channel.close();

        //读文件
        readFile(filePath);
    }

    private static void readFile(String filePath) throws Exception {
   
        FileReader fileReader = new FileReader(filePath);
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String tr = bufferedReader.readLine();
        System.out.println("读取出内容：");
        while(tr != null) {
   
            System.out.println(" "+tr);
            tr = bufferedReader.readLine();
        }
        fileReader.close();
        bufferedReader.close();
    }
}

三、文件和目录

3.1 Path

• 一个路径可以指向一个文件或一个目录。路径可以是绝对路径，也可以是相对路径
• 使用 java.nio.file.Path 实例必须创建一个 Path 实例。可以使用 Paths 类(java.nio.file.Paths)中的静态方法 Paths.get()来创建路径实例

使用绝对路径：

Path path = Paths.get("d://opencoder.txt");

创建相对路径，使用 Paths.get(basePath, relativePath)方法创建一个相对路径:

Path path = Paths.get("d://txt”，“opencoder.txt");

使路径标准化:

​ 标准化意味着它将移除所有在路径字符串的中间的.和…代码，并解析路径字符串所引用的路径Path.normalize()

String originalPath = "d://myprojects//..//opencoder-project";

Path path1 = Paths.get(originalPath);
System.out.println("path1 = " + path1);

Path path2 = path1.normalize();
System.out.println("path2 = " + path2);

3.2 Files

Files.createDirectory()根据 Path 实例创建一个新目录

Path path = Paths.get("d://opencoder");
try {
   
    Path directory = Files.createDirectory(path);
} catch (IOException e) {
   
    e.printStackTrace();
}

• 复制，一个路径拷贝一个文件到另外一个目录
• 第三个参数可加可不加，Files.copy()方法的第三个参数。如果目标文件已经存在，这个参数指示 copy()方法覆盖现有的文件

Path path1 = Paths.get("d://opencoder1.txt");
Path path2 = Paths.get("d://opencoder.txt");
try {
   
    Path copy = Files.copy(path1, path2, StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
   
    e.printStackTrace();
}

• 移动文件既可以移动到不同的目录，也可以在相同的操作中更改它的名称
• Files.move()的第三个参数。这个参数告诉 Files.move()方法来覆盖目标路径上的任何现有文件

Path sourcePath = Paths.get("d://opencoder1.txt");
Path destinationPath = Paths.get("d://opencoder2.txt");

try {
   
    Files.move(sourcePath, destinationPath,
            StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
   
    //移动文件失败
    e.printStackTrace();
}

• 删除一个文件或者目录

Path path = Paths.get("d://opencoder.txt");
try {
   
    Files.delete(path);
} catch (IOException e) {
   
    // 删除文件失败
    e.printStackTrace();
}

四、AsynchronousFileChannel

异步地将数据写入文件

• 静态方法 open()创建
  第二个参数是一个或多个打开选项，它告诉 AsynchronousFileChannel 在文件上执行什么操作。在本例中，我们使用StandardOpenOption.READ 选项，表示该文件将被打开阅读
• 读取数据
  第一种方式是调用返回Future 的 read()方法
  第二种方法是调用 read()方法，该方法将一个 CompletionHandler 作为参数

（1）创建了一个 AsynchronousFileChannel
（2）创建一个 ByteBuffer，它被传递给 read()方法作为参数，以及一个 0 的位置。
（3）在调用 read()之后，循环，直到返回的 isDone()方法返回 true。
（4）读取操作完成后，数据读取到 ByteBuffer 中，然后打印到 System.out 中

@Test
public void readAsyncFileChannelFuture() throws Exception {
   
    //1 创建AsynchronousFileChannel
    Path path = Paths.get("d://opencoder.txt");
    AsynchronousFileChannel fileChannel =
            AsynchronousFileChannel.open(path, StandardOpenOption.READ);
    //2 创建Buffer
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    //3 调用channel的read方法得到Future
    Future<Integer> future = fileChannel.read(buffer, 0);
    //4 判断是否完成 isDone,返回true
    while(!future.isDone());
    //5 读取数据到buffer里面
    buffer.flip();
//        while(buffer.remaining()>0) {
   
//            System.out.println(buffer.get());
//        }
    byte[] data = new byte[buffer.limit()];
    buffer.get(data);
    System.out.println(new String(data));
    buffer.clear();

}

（1）读取操作完成，将调用 CompletionHandler 的 completed()方法。

（2）对于 completed()方法的参数传递一个整数，它告诉我们读取了多少字节，以及传递给 read()方法的“附件”。“附件”是 read()方法的第三个参数。在本代码中，它是 ByteBuffer，数据也被读取。

（3）如果读取操作失败，则将调用 CompletionHandler 的 failed()方法

@Test
public void readAsyncFileChannelComplate() throws Exception {
   
    //1 创建AsynchronousFileChannel
    Path path = Paths.get("d://opencoder.txt");
    AsynchronousFileChannel fileChannel =
            AsynchronousFileChannel.open(path, StandardOpenOption.READ);

    //2 创建Buffer
    ByteBuffer buffer = ByteBuffer.allocate(1024);

    //3 调用channel的read方法得到Future
    fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
   
        @Override
        public void completed(Integer result, ByteBuffer attachment) {
   
            System.out.println("result: "+result);

            attachment.flip();
            byte[] data = new byte[attachment.limit()];
            attachment.get(data);
            System.out.println(new String(data));
            attachment.clear();
        }

        @Override
        public void failed(Throwable exc, ByteBuffer attachment) {
   

        }
    });
}

通过 Future 写数据

@Test
public void writeAsyncFileFuture() throws IOException {
   
    //1 创建AsynchronousFileChannel
    Path path = Paths.get("d://opencoder.txt");
    AsynchronousFileChannel fileChannel =
            AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);

    //2 创建Buffer
    ByteBuffer buffer = ByteBuffer.allocate(1024);

    //3 write方法
    buffer.put("opencoder".getBytes());
    buffer.flip();
    Future<Integer> future = fileChannel.write(buffer, 0);

    while(!future.isDone());

    buffer.clear();
    System.out.println("write over");
}

通过 CompletionHandler 写数据

@Test
public void writeAsyncFileComplate() throws IOException {
   
    //1 创建AsynchronousFileChannel
    Path path = Paths.get("d://opencoder.txt");
    AsynchronousFileChannel fileChannel =
            AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);

    //2 创建Buffer
    ByteBuffer buffer = ByteBuffer.allocate(1024);

    //3 write方法
    buffer.put("opencoder very nice".getBytes());
    buffer.flip();

    fileChannel.write(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
   
        @Override
        public void completed(Integer result, ByteBuffer attachment) {
   
            System.out.println("bytes written: " + result);
        }

        @Override
        public void failed(Throwable exc, ByteBuffer attachment) {
   

        }
    });

    System.out.println("write over");
}

总结

​ 到此位置NIO的所有的内容都结束了，对于NIO来说主要是各种概念需要大家去理解然后有很多的用法和api也需要大家去熟悉所以想把NIO学懂学好其实并不容易一定要多写案例去测试巩固，也预祝大家能把NIO的知识看懂理顺！！！