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