java NIO之Pipe
1、简介
管道是 2 个线程之间的单向数据连接
一个 source 通道（读取）和一个sink 通道（写入）
1.1、常用方法
打开管道
Pipe pipe = Pipe.open();
写入管道
需要访问 sink 通道
Pipe.SinkChannel sinkChannel = pipe.sink();
读取数据
需要访问 source 通道
Pipe.SourceChannel sourceChannel = pipe.source();
实战代码
完整代码如下：
- 创建管道之后在创建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("码农研究僧".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();
}
}
2、FileLock
文件锁是进程级别的，不是线程级别的
具体分为两大类：
**排它锁：**又叫独占锁。对文件加排它锁后，该进程可以对此文件进行读写，该进程独占此文件，其他进程不能读写此文件，直到该进程释放文件锁。
**共享锁：**某个进程对文件加共享锁，其他进程也可以访问此文件，但这些进程都只能读此文件，不能写。线程是安全的。只要还有一个进程持有共享锁，此文件就只能读，不能写
//创建 FileChannel 对象，文件锁只能通过 FileChannel 对象来使用 FileChannel fileChannel=new FileOutputStream("./1.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 = "manongyanjiuseng"; System.out.println("input:"+input); ByteBuffer buffer = ByteBuffer.wrap(input.getBytes()); String filePath = "b//1.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、Java NIO（其他）
此处包括了path和files等
3.1、Path
- 一个路径可以指向一个文件或一个目录。路径可以是绝对路径，也可以是相对路径
- 使用 java.nio.file.Path 实例必须创建一个 Path 实例。可以使用 Paths 类(java.nio.file.Paths)中的静态方法 Paths.get()来创建路径实例
也是当前的绝对路径
Path path = Paths.get("b://1.txt");也可以创建相对路径，使用 Paths.get(basePath, relativePath)方法创建一个相对路径
Path path = Paths.get("b://txt”，“1.txt");
- 使路径标准化。标准化意味着它将移除所有在路径字符串的中间的.和…代码，并解析路径字符串所引用的路径
Path.normalize()
String originalPath = "b://projects//..//yygh-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("b://1");
try {
Path directory = Files.createDirectory(path);
} catch (IOException e) {
e.printStackTrace();
}
- 复制，一个路径拷贝一个文件到另外一个目录
- 第三个参数可加可不加，Files.copy()方法的第三个参数。如果目标文件已经存在，这个参数指示 copy()方法覆盖现有的文件
Path path1 = Paths.get("b://1.txt");
Path path2 = Paths.get("b://2.txt");
try {
Path copy = Files.copy(path1, path2, StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
e.printStackTrace();
}
- 移动文件既可以移动到不同的目录，也可以在相同的操作中更改它的名称
- Files.move()的第三个参数。这个参数告诉 Files.move()方法来覆盖目标路径上的任何现有文件
Path sourcePath = Paths.get("b://1.txt");
Path destinationPath = Paths.get("b://2.txt");
try {
Files.move(sourcePath, destinationPath,
StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
//移动文件失败
e.printStackTrace();
}
- 删除一个文件或者目录
Path path = Paths.get("b://1.txt");
try {
Files.delete(path);
} catch (IOException e) {
// 删除文件失败
e.printStackTrace();
}
3.3、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("b://1.txt");
AsynchronousFileChannel fileChannel =
AsynchronousFileChannel.open(path, StandardOpenOption.READ);
//2 创建Buffer
ByteBuffer buffer = ByteBuffer.allocate(1024);
//3 调用channel的read方法得到Future
Future 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("b://1.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() {
@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("b://1.txt");
AsynchronousFileChannel fileChannel =
AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);
//2 创建Buffer
ByteBuffer buffer = ByteBuffer.allocate(1024);
//3 write方法
buffer.put("atguigu ".getBytes());
buffer.flip();
Future 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("b://1.txt");
AsynchronousFileChannel fileChannel =
AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);
//2 创建Buffer
ByteBuffer buffer = ByteBuffer.allocate(1024);
//3 write方法
buffer.put("atguigujavajava".getBytes());
buffer.flip();
fileChannel.write(buffer, 0, buffer, new CompletionHandler() {
@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");
}