八、Java NIO（Pipe 和 FileLock）

NIO 目录

---

---

八、Java NIO（Pipe 和 FileLock）

1、Pipe

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

1.1、创建管道

通过 Pipe.open()方法打开管道。

Pipe pipe = Pipe.open();

1.2、写入管道

要向管道写数据，需要访问 sink 通道。

Pipe.SinkChannel sinkChannel = pipe.sink();

通过调用 SinkChannel 的 write()方法，将数据写入 SinkChannel：

String newData = "New String to write to file..." + System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
    sinkChannel.write(buf);
}

1.3、从管道读取数据

从读取管道的数据，需要访问 source 通道，像这样：

Pipe.SourceChannel sourceChannel = pipe.source();

调用 source 通道的 read()方法来读取数据：

ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = sourceChannel.read(buf);

read()方法返回的 int 值会告诉我们多少字节被读进了缓冲区。

1.4、示例代码

package com.wlw.nio.pipe;

import org.junit.Test;

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

/**
* Pipe 示例
*/
public class PipeDemo1 {

   @Test
   public void testPipe() throws IOException {
       // 1、获取管道
       Pipe pipe = Pipe.open();
       // 2、获取 sink 管道，用来传送数据
       Pipe.SinkChannel sinkChannel = pipe.sink();
       // 3、创建一定大小的缓冲区
       ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
       byteBuffer.put("wlw".getBytes());
       byteBuffer.flip();
       // 4、向管道写数据，需要访问 sink 通道
       sinkChannel.write(byteBuffer);

       // 5、从管道读取数据 ，需要访问 source 管道
       Pipe.SourceChannel sourceChannel = pipe.source();
       // 6、创建缓冲区 接收数据，
       ByteBuffer byteBuffer2 = ByteBuffer.allocate(1024);
       int length = sourceChannel.read(byteBuffer2);

       System.out.println(new String(byteBuffer2.array(), 0, length));

       // 7、关闭管道
       sourceChannel.close();
       sinkChannel.close();
   }
}

2、FileLock

2.1、FileLock 简介

文件锁在 OS 中很常见，如果多个程序同时访问、修改同一个文件，很容易因为文件数据不同步而出现问题。给文件加一个锁，同一时间，只能有一个程序修改此文件，或者程序都只能读此文件，这就解决了同步问题。

文件锁是进程级别的，不是线程级别的。文件锁可以解决多个进程并发访问、修改同一个文件的问题，但不能解决多线程并发访问、修改同一文件的问题。使用文件锁时，同一进程内的多个线程，可以同时访问、修改此文件。

文件锁是当前程序所属的 JVM 实例持有的，一旦获取到文件锁（对文件加锁），要调用 release()，或者关闭对应的 FileChannel 对象，或者当前 JVM 退出，才会释放这个锁。

一旦某个进程（比如说 JVM 实例）对某个文件加锁，则在释放这个锁之前，此进程不能再对此文件加锁，就是说 JVM 实例在同一文件上的文件锁是不重叠的（进程级别不能重复在同一文件上获取锁）。

2.2、文件锁分类：

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

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

2.3、使用示例：

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

文件锁要通过 FileChannel 对象使用。

2.4、获取文件锁方法

有 4 种获取文件锁的方法：

• lock() //对整个文件加锁，默认为排它锁。
• lock(long position, long size, booean shared) //自定义加锁方式。前 2 个参数指定要加锁的部分（可以只对此文件的部分内容加锁），第三个参数值指定是否是共享锁：true为共享锁。
• tryLock() //对整个文件加锁，默认为排它锁。
• tryLock(long position, long size, booean shared) //自定义加锁方式。

如果指定为共享锁，则其它进程可读此文件，所有进程均不能写此文件，如果某进程试图对此文件进行写操作，会抛出异常。

2.5、lock 与 tryLock 的区别：

lock 是阻塞式的，如果未获取到文件锁，会一直阻塞当前线程，直到获取文件锁

tryLock 和 lock 的作用相同，只不过 tryLock 是非阻塞式的，tryLock 是尝试获取文件锁，获取成功就返回锁对象，否则返回 null，不会阻塞当前线程。

2.6、FileLock 两个方法：

boolean isShared() //此文件锁是否是共享锁

boolean isValid() //此文件锁是否还有效

在某些 OS 上，对某个文件加锁后，不能对此文件使用通道映射。

2.7、完整例子

package com.wlw.nio.fileLock;

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 FileLockDemo1 {
    public static void main(String[] args) throws IOException {
        String input = "wlw";
        System.out.println("输入 :" + input);

        ByteBuffer buf = ByteBuffer.wrap(input.getBytes());
        String filePath = "D:\\Program Files\\IDEAworkspace4\\IOFiles\\01.txt";
        Path path = Paths.get(filePath);
        FileChannel channel = FileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.APPEND);
        channel.position(channel.size() - 1); // position of a cursor at the end of

        // 获得锁方法一：lock()，阻塞方法，当文件锁不可用时，当前进程会被挂起
        // lock = channel.lock();  // 无参 lock()为独占锁
        // lock = channel.lock(0L, Long.MAX_VALUE, true);//有参 lock()为共享锁，有写操作会报异常
        // 获得锁方法二：trylock()，非阻塞的方法，当文件锁不可用时，tryLock()会得到 null 值
        FileLock lock = channel.tryLock(0, Long.MAX_VALUE, false);
        System.out.println("共享锁 shared: " + lock.isShared());
        // 写操作，往通道内写数据
        channel.write(buf);
        channel.close(); // Releases the Lock
        System.out.println("写操作完成.");

        //读取数据
        readPrint(filePath);
    }
    public static void readPrint(String path) throws IOException {
        FileReader filereader = new FileReader(path);

        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();
    }
}


// 不为共享锁的结果：
输入 :wlw
共享锁 shared: false
写操作完成.
读取内容: 
 我的01wlwwlw

// 为共享锁的结果：
输入 :wlw
Exception in thread "main" java.nio.channels.NonReadableChannelException
	at sun.nio.ch.FileChannelImpl.tryLock(FileChannelImpl.java:1103)
	at com.wlw.nio.fileLock.FileLockDemo1.main(FileLockDemo1.java:34)