当前位置： 首页 > article >正文

Java NIO之FileChannel 详解

article 2025/4/2 21:18:00

关键点说明

  1. 文件打开选项：

    • StandardOpenOption.CREATE - 文件不存在时创建

    • StandardOpenOption.READ/WRITE - 读写权限

    • StandardOpenOption.APPEND - 追加模式

    • StandardOpenOption.TRUNCATE_EXISTING - 清空已存在文件

  2. 缓冲区操作：

    • ByteBuffer.wrap() 包装现有字节数组

    • buffer.flip() 切换读写模式

    • 直接操作缓冲区提高性能

  3. 高效文件复制：

    • transferTo()/transferFrom() 方法比传统流复制更高效

  4. 资源管理：

    • 使用try-with-resources确保通道自动关闭

    • 文件锁需要显式释放

这些示例展示了FileChannel的基本读写操作、文件锁的使用以及内存映射文件的高效操作，可以根据实际需求进行调整和扩展。

1. 基本文件读写示例

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class FileChannelDemo {

    public static void main(String[] args) {
        String filePath = "test.txt";
        
        // 写入文件
        writeToFile(filePath, "Hello, FileChannel!");
        
        // 读取文件
        String content = readFromFile(filePath);
        System.out.println("文件内容: " + content);
        
        // 追加内容
        appendToFile(filePath, "\n这是追加的内容");
        
        // 再次读取
        System.out.println("追加后的内容: " + readFromFile(filePath));
        
        // 文件复制
        copyFile(filePath, "test_copy.txt");
        System.out.println("复制文件内容: " + readFromFile("test_copy.txt"));
    }

    // 写入文件（覆盖）
    public static void writeToFile(String filePath, String content) {
        try (FileChannel channel = FileChannel.open(
                Paths.get(filePath),
                StandardOpenOption.CREATE,
                StandardOpenOption.WRITE,
                StandardOpenOption.TRUNCATE_EXISTING)) {
            
            ByteBuffer buffer = ByteBuffer.wrap(content.getBytes());
            channel.write(buffer);
            System.out.println("写入文件成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 读取文件
    public static String readFromFile(String filePath) {
        try (FileChannel channel = FileChannel.open(
                Paths.get(filePath),
                StandardOpenOption.READ)) {
            
            ByteBuffer buffer = ByteBuffer.allocate((int) channel.size());
            channel.read(buffer);
            buffer.flip();
            return new String(buffer.array(), 0, buffer.limit());
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    // 追加内容到文件
    public static void appendToFile(String filePath, String content) {
        try (FileChannel channel = FileChannel.open(
                Paths.get(filePath),
                StandardOpenOption.WRITE,
                StandardOpenOption.APPEND)) {
            
            ByteBuffer buffer = ByteBuffer.wrap(content.getBytes());
            channel.write(buffer);
            System.out.println("追加内容成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 文件复制
    public static void copyFile(String sourcePath, String targetPath) {
        try (FileChannel source = FileChannel.open(
                Paths.get(sourcePath),
                StandardOpenOption.READ);
             FileChannel target = FileChannel.open(
                Paths.get(targetPath),
                StandardOpenOption.CREATE,
                StandardOpenOption.WRITE,
                StandardOpenOption.TRUNCATE_EXISTING)) {
            
            // 使用transferTo进行高效的文件复制
            source.transferTo(0, source.size(), target);
            System.out.println("文件复制成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 使用文件锁的读写示例

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class FileChannelWithLockDemo {

    public static void main(String[] args) {
        String filePath = "locked_file.txt";
        
        // 线程1 - 写入数据
        new Thread(() -> {
            writeWithLock(filePath, "线程1写入的数据");
        }).start();
        
        // 线程2 - 尝试写入
        new Thread(() -> {
            writeWithLock(filePath, "线程2写入的数据");
        }).start();
    }

    public static void writeWithLock(String filePath, String content) {
        try (FileChannel channel = FileChannel.open(
                Paths.get(filePath),
                StandardOpenOption.CREATE,
                StandardOpenOption.WRITE,
                StandardOpenOption.APPEND)) {
            
            // 尝试获取排他锁
            System.out.println(Thread.currentThread().getName() + " 尝试获取文件锁...");
            FileLock lock = channel.lock();
            
            try {
                System.out.println(Thread.currentThread().getName() + " 获取到文件锁");
                
                // 模拟耗时操作
                Thread.sleep(2000);
                
                // 写入数据
                ByteBuffer buffer = ByteBuffer.wrap((content + "\n").getBytes());
                channel.write(buffer);
                System.out.println(Thread.currentThread().getName() + " 写入完成");
            } finally {
                lock.release();
                System.out.println(Thread.currentThread().getName() + " 释放文件锁");
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3.内存映射文件示例

import java.io.IOException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class MemoryMappedFileDemo {

    public static void main(String[] args) {
        String filePath = "mapped_file.txt";
        
        // 写入内存映射文件
        writeMappedFile(filePath, "这是内存映射文件的内容");
        
        // 读取内存映射文件
        readMappedFile(filePath);
    }

    public static void writeMappedFile(String filePath, String content) {
        try (FileChannel channel = FileChannel.open(
                Paths.get(filePath),
                StandardOpenOption.READ,
                StandardOpenOption.WRITE,
                StandardOpenOption.CREATE)) {
            
            // 创建内存映射
            MappedByteBuffer buffer = channel.map(
                FileChannel.MapMode.READ_WRITE, 
                0, 
                content.getBytes().length);
            
            // 直接操作内存
            buffer.put(content.getBytes());
            System.out.println("内存映射文件写入完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void readMappedFile(String filePath) {
        try (FileChannel channel = FileChannel.open(
                Paths.get(filePath),
                StandardOpenOption.READ)) {
            
            MappedByteBuffer buffer = channel.map(
                FileChannel.MapMode.READ_ONLY, 
                0, 
                channel.size());
            
            byte[] bytes = new byte[(int) channel.size()];
            buffer.get(bytes);
            System.out.println("读取到的内容: " + new String(bytes));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileChannel的lock详解

一、文件锁的基本概念

文件锁分为两种类型：

  1. 排他锁（独占锁）：

    • 同一时间只能有一个进程持有

    • 其他进程无法获取任何类型的锁

  2. 共享锁（读锁）：

    • 可以被多个进程同时持有

    • 但只要有进程持有共享锁，就不能获取排他锁

二、lock()方法的使用

1. 基本锁定方式

FileChannel channel = FileChannel.open(Paths.get("test.txt"), 
    StandardOpenOption.READ, StandardOpenOption.WRITE);

// 获取排他锁（默认）
FileLock exclusiveLock = channel.lock();

// 获取共享锁（第三个参数为true）
FileLock sharedLock = channel.lock(0, Long.MAX_VALUE, true);

2. 方法参数说明

public final FileLock lock(long position, long size, boolean shared)

  • position：锁定区域的起始位置

  • size：锁定区域的大小(比特)

  • shared：是否为共享锁（true=共享锁，false=排他锁）

3.非阻塞尝试锁定

FileLock tryLock = channel.tryLock(); // 非阻塞版本
if (tryLock == null) {
    // 获取锁失败
}
tryLock.release()

四、注意事项

  1. 锁的有效性：

    • 文件锁是建议性的（advisory），不是强制性的

    • 只有遵守锁协议的进程才会受锁影响

    • 操作系统可能有不同的实现方式

  2. 性能考虑：

    • 频繁获取/释放锁会影响性能

    • 锁定大文件区域可能降低并发性

  3. 异常处理：

    • OverlappingFileLockException：当请求的锁区域与现有锁重叠时抛出

    • NonWritableChannelException：尝试在只读通道上获取排他锁

  4. 平台差异：

    • Windows系统上的实现与Unix-like系统不同

    • 某些网络文件系统可能不支持文件锁

五、适用场景

  1. 多进程共享文件访问控制

  2. 防止文件被多个写入者同时修改

  3. 实现简单的进程间同步机制

  4. 保护关键配置文件不被并发修改

正确使用FileChannel的锁机制可以有效地管理对共享文件的并发访问，保证数据的一致性和完整性。


http://www.kler.cn/a/614238.html

相关文章：

  • 每日一题之既约分数
  • 注入工具SQLMAPTamper 编写指纹修改高权限操作目录架构
  • 资产收益数据处理与分析
  • 蓝桥刷题note11(好数)
  • 嵌入式开发技术总结报告
  • 向量数据库学习笔记（2） —— pgvector 用法 与 最佳实践
  • YOLO基础知识
  • 金融市场中的时间序列预测：思考与方法
  • 【商城实战(102)】破局与进阶：商城系统的未来进化之路
  • hbuilderx打包iOS上传苹果商店的最简流程
  • 【Linux系统】—— 进程状态
  • LLaMA-Factory微调实操记录
  • 12款星光闪光污迹艺术绘画效果Clip Studio Paint笔刷画笔+闪光纹理图片 Clip Studio Glitter Texture Brushes
  • Linux中安装宝塔面板
  • 雨云云应用测评！内测持续进行中！
  • 全新版租赁商城小程序源码系统 源码开源支持二开+图文搭建教程
  • 人工智能之数学基础：实对称矩阵
  • Java项目实现幂等性方案总结
  • MOSN（Modular Open Smart Network）-03-流量劫持
  • LLMs Multi-agent 概述