JAVA多线程读写文件如何做到线程安全？（文件锁，FileChannel）

最新推荐文章于 2024-05-27 09:36:49 发布
最新推荐文章于 2024-05-27 09:36:49 发布
阅读量1.7w 收藏 63
点赞数 10
分类专栏： JAVA多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/confusing_awakening/article/details/99687111
版权

文章目录

NIO提升性能

在JAVA的标准I/O中，提供了基于流的I/O实现，即InputStream和OutputStream。这种基于流的实现以字节为单位处理数据。NIO是New I/O的简称，表示一套新的JAVA I/O标准。在Jdk 1.4中开始引入，它具有以下特性：

  • 为所有的原始类型提供（Buffer）缓存支持；
  • 使用Java.nio.charset.Charset作为字符集编码解码解决方案；
  • 增加通道（Cahnnel）对象，作为新的原始I/O抽象；
  • 支持锁和内存映射文件的文件访问接口；
  • 提供了基于Selector的异步网络I/O。

与流式的I/O不容，NIO是基于块（Block）的，它以块为基本单位处理数据。在NIO中，最为重要的2个组件是缓冲Buffer和通道Channel。缓冲是一块连续的内存块，是NIO读写数据的中转地。通道表示缓冲数据的源头或者目的地，它用于向缓冲读取或者写入数据，是访问缓冲的接口。

在这里插入图片描述

多线程读写同一个文件有哪些场景需要同步处理？

  • 有线程正在读文件，另开辟线程写文件；
  • 有线程正在写文件，另开辟线程读文件；
  • 有线程正在写文件，另开辟线程写文件

总之，读写互斥，写读互斥，写写互斥，只有读读相容（可以异步）。

使用对文件加锁的方式做到线程安全

FileInputStream、FileOutputStream、RandomAccessFile均可得到FileChannel对象，对文件锁进行操作。
独占锁tryLock()

FileChannel的tryLock()是非阻塞的，也就是说，在发现文件被锁住的时候，直接返回null，并且抛出异常，如果没有锁住，直接返回该文件的文件锁。
它是独占锁，就是只能被一个线程持有，它能禁止其他线程获取共享锁，可用于写文件。

  while (true) {
                try {
                    fileLock = fileChannel.tryLock();//独占锁
                    break;
                } catch (Exception e) {
                    System.out.println("有其他线程正在操作该文件，当前线程" + Thread.currentThread().getName());
                }
            }

共享锁tryLock(0, Long.MAX_VALUE, true)

FileChannel的tryLock(0, Long.MAX_VALUE, true)是非阻塞的，在发现文件被锁住的时候，直接返回null，并且抛出异常，如果没有锁住，直接返回该文件的文件锁。
它是共享锁，能被多个线程同时持有，它能禁止其他线程获取独占锁，可用于读文件。

while (true) {
                try {
                    fileLock = fileChannel.tryLock(0, Long.MAX_VALUE, true);//共享锁
                    break;
                } catch (Exception e) {
                    System.out.println("有其他线程正在操作该文件，当前线程" + Thread.currentThread().getName());
                }
            }

独占锁lock()

而FileChannel的lock()是阻塞的，在文件被锁定的情况下，会保持阻塞，直到获得该锁为止。

fileLock = fileChannel.lock();

写文件线程安全

 /**
     * 将str写入文件,同步操作,独占锁
     */
    public void writeStr2ReplaceFileSync(String str, String pathFile, IOListener ioListener) {
        File file;
        try {
            file = FileUtils.createFile(pathFile);
        } catch (IOException e) {
            e.printStackTrace();
            ioListener.onFail("文件创建失败，请检查路径是否合法以及读写权限");
            return;
        }
        FileOutputStream fileOutputStream = null;
        FileChannel fileChannel = null;
        FileLock fileLock = null;//文件锁
        try {

            /**
             * 写文件
             */
            fileOutputStream = new FileOutputStream(file);
            fileChannel = fileOutputStream.getChannel();
            while (true) {
                try {
                    fileLock = fileChannel.tryLock();//独占锁
                    break;
                } catch (Exception e) {
                    System.out.println("有其他线程正在操作该文件，当前线程" + Thread.currentThread().getName());
                }
            }
            if (fileLock != null) {
                int len = 0;
                long current = file.length();
                if (isRunning ) {
                    fileChannel.write(ByteBuffer.wrap(str.getBytes()));
                    current += len;
                    LogUtils.log("当前线程" + Thread.currentThread().getName());
                    ioListener.onLoading(str.getBytes(), current, str.length());
                }else {
                    //中断
                    ioListener.onInterrupted();
                }
                if (fileLock != null && fileLock.isValid()) {
                    LogUtils.log("release-write-lock");
                    fileLock.release();
                }
                close(fileChannel);
                close(fileOutputStream);
                if (file.length() == str.getBytes().length) {
                    ioListener.onCompleted(file);
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
        } finally {
        }
    }

读文件线程安全

  /**
     * 同步读取，共享锁，但无法同时进行写操作
     *
     * @param ioListener
     */
    public void read2StrSync(String pathFile, IOListener ioListener) {
        FileInputStream fileInputStream = null;
        FileChannel fileChannel = null;
        FileLock fileLock = null;//文件锁

        ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream();
        try {

            /**
             * 读文件
             */

            fileInputStream = new FileInputStream(pathFile);
            fileChannel = fileInputStream.getChannel();
            while (true) {
                try {
                    fileLock = fileChannel.tryLock(0, Long.MAX_VALUE, true);//共享锁
                    break;
                } catch (Exception e) {
                    System.out.println("有其他线程正在操作该文件，当前线程" + Thread.currentThread().getName());
                }
            }
            if (fileLock != null) {

                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                int len = 0;
                long current = 0;
                while (isRunning && (len = fileChannel.read(byteBuffer)) != -1) {
                    //0,byteBuffer.position()，必须写这个，否则GG，读取文件错乱
                    byteArrayOutputStream.write(byteBuffer.array(),0,byteBuffer.position());
                    current += len;
                    ioListener.onLoading("", current, fileChannel.size());
                    byteBuffer.clear();
                }
                if (fileLock != null && fileLock.isValid()) {
                LogUtils.log("release-read-lock");
                    fileLock.release();
                }
                close(fileChannel);
                close(fileInputStream);
                //中断
                if (len != -1) {
                    ioListener.onInterrupted();
                } else {
                    ioListener.onCompleted(byteArrayOutputStream.toString("utf-8"));

                }
            }


        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
        } catch (IOException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());

        } finally {


        }
    }

小编写的IOListener接口，用于回调

public interface IOListener<T> {
    public void onCompleted(T result);
    public void onLoading(T readedPart, long current, long length);
    public void onInterrupted();
    public void onFail(String errorMsg);
}

小编写的IOUtils工具类，专门用于文件读写，流的读写

public class IOUtils {
    private boolean isRunning = true;

    private long contentLength = 0;
    private String encodeType = "utf-8";

    public IOUtils() {
        isRunning = true;
    }

    public IOUtils setContentLength(long contentLength) {
        this.contentLength = contentLength;
        return this;
    }

    public IOUtils setEncodeType(String encodeType) {
        this.encodeType = encodeType;
        return this;

    }

    public static void close(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void stop() {
        this.isRunning = false;
    }

    public void read(boolean isLine, InputStream inputStream, IOListener ioListener) {
        if (isLine) {
            readLine2String(inputStream, ioListener);
        } else {
            read2String(inputStream, ioListener);

        }
    }

    /**
     * @param ioListener
     */

    public void read2String(String pathFile, IOListener ioListener) {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(pathFile);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
            return;
        }
        read2String(fileInputStream, ioListener);
    }

    public void read2String(InputStream inputStream, IOListener ioListener) {

        if (!(inputStream instanceof BufferedInputStream)) {
            inputStream = new BufferedInputStream(inputStream);
        }
        BufferedReader bufferedReader = null;
        InputStreamReader inputStreamReader = null;
        try {
            inputStreamReader = new InputStreamReader(inputStream, encodeType);
            bufferedReader = new BufferedReader(inputStreamReader);

            StringBuilder sb = new StringBuilder();

            char[] buf = new char[1024];
            int len = 0;
            long current = 0;

            while (isRunning && (len = bufferedReader.read(buf)) != -1) {
                sb.append(buf, 0, len);
                current += len;
                ioListener.onLoading("", current, contentLength);
            }

            //中断
            if (len != -1) {
                ioListener.onInterrupted();
            } else {

                ioListener.onCompleted(sb.toString());

            }

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
        } catch (IOException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());

        } finally {
            close(bufferedReader);
            close(inputStreamReader);
            close(inputStream);
        }
    }

    /**
     * 同步读取，共享锁，但无法同时进行写操作
     *
     * @param ioListener
     */
    public void read2StrSync(String pathFile, IOListener ioListener) {
        FileInputStream fileInputStream = null;
        FileChannel fileChannel = null;
        FileLock fileLock = null;//文件锁

        ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream();
        try {

            /**
             * 读文件
             */

            fileInputStream = new FileInputStream(pathFile);
            fileChannel = fileInputStream.getChannel();
            while (true) {
                try {
                    fileLock = fileChannel.tryLock(0, Long.MAX_VALUE, true);//共享锁
                    break;
                } catch (Exception e) {
                    System.out.println("有其他线程正在操作该文件，当前线程" + Thread.currentThread().getName());
                }
            }
            if (fileLock != null) {

                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                int len = 0;
                long current = 0;
                while (isRunning && (len = fileChannel.read(byteBuffer)) != -1) {
                    //0,byteBuffer.position()，必须写这个，否则GG，读取文件错乱
                    byteArrayOutputStream.write(byteBuffer.array(),0,byteBuffer.position());
                    current += len;
                    ioListener.onLoading("", current, fileChannel.size());
                    byteBuffer.clear();
                }
                if (fileLock != null && fileLock.isValid()) {
                LogUtils.log("release-read-lock");
                    fileLock.release();
                }
                close(fileChannel);
                close(fileInputStream);
                //中断
                if (len != -1) {
                    ioListener.onInterrupted();
                } else {
                    ioListener.onCompleted(byteArrayOutputStream.toString("utf-8"));

                }
            }


        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
        } catch (IOException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());

        } finally {


        }
    }

    /**
     * @param ioListener
     */

    public void readLine2String(String pathFile, IOListener ioListener) {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(pathFile);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
            return;
        }
        readLine2String(fileInputStream, ioListener);
    }

    /**
     * 一行一行地读
     *
     * @param inputStream
     * @param ioListener
     */
    public void readLine2String(InputStream inputStream, IOListener ioListener) {

        BufferedReader bufferedReader = null;
        InputStreamReader inputStreamReader = null;
        try {
            inputStreamReader = new InputStreamReader(inputStream, encodeType);
            bufferedReader = new BufferedReader(inputStreamReader);

            StringBuilder sb = new StringBuilder();
            long current = 0;

            String str;
            while (isRunning && (str = bufferedReader.readLine()) != null) {
                sb.append(str);
                current += str.length();

                ioListener.onLoading(str, current, contentLength);

            }

            //中断
            if ((str = bufferedReader.readLine()) != null) {
                ioListener.onInterrupted();
            } else {

                ioListener.onCompleted(sb.toString());

            }

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
        } catch (IOException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());

        } finally {
            close(bufferedReader);
            close(inputStreamReader);
            close(inputStream);
        }
    }

    public void readL2StrNoBuffer(String pathFile, IOListener ioListener) {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(pathFile);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
            return;
        }
        readL2StrNoBuffer(fileInputStream, ioListener);
    }

    /**
     * 一行一行地读，不拼接
     *
     * @param inputStream
     * @param ioListener
     */
    public void readL2StrNoBuffer(InputStream inputStream, IOListener ioListener) {

        BufferedReader bufferedReader = null;
        InputStreamReader inputStreamReader = null;
        try {
            inputStreamReader = new InputStreamReader(inputStream, encodeType);
            bufferedReader = new BufferedReader(inputStreamReader);

            long current = 0;

            String str;
            while (isRunning && (str = bufferedReader.readLine()) != null) {
                current += str.length();

                ioListener.onLoading(str, current, contentLength);

            }

            //中断
            if ((str = bufferedReader.readLine()) != null) {
                ioListener.onInterrupted();
            } else {

                ioListener.onCompleted("");

            }

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
        } catch (IOException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());

        } finally {
            close(bufferedReader);
            close(inputStreamReader);
            close(inputStream);
        }
    }

    public void readL_N2String(String pathFile, IOListener ioListener) {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(pathFile);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
            return;
        }
        readL_N2String(fileInputStream, ioListener);
    }

    /**
     * 一行一行地读，\n拼接
     *
     * @param inputStream
     * @param ioListener
     */
    public void readL_N2String(InputStream inputStream, IOListener ioListener) {

        BufferedReader bufferedReader = null;
        InputStreamReader inputStreamReader = null;
        try {
            inputStreamReader = new InputStreamReader(inputStream, encodeType);
            bufferedReader = new BufferedReader(inputStreamReader);

            StringBuilder sb = new StringBuilder();
            long current = 0;

            String str;
            while (isRunning && (str = bufferedReader.readLine()) != null) {
                sb.append(str);
                sb.append("\n");
                current += str.length();

                ioListener.onLoading(str, current, contentLength);

            }

            //中断
            if ((str = bufferedReader.readLine()) != null) {
                ioListener.onInterrupted();
            } else {

                ioListener.onCompleted(sb.toString());

            }

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
        } catch (IOException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());

        } finally {
            close(bufferedReader);
            close(inputStreamReader);
            close(inputStream);
        }
    }

    /**
     * 读取到文件
     *
     * @param inputStream
     * @param outputStream
     * @param ioListener
     */
    public void read2File(InputStream inputStream, OutputStream outputStream, IOListener ioListener) {

        try {

            byte[] buffer = new byte[1024];
            int len = 0;
            long current = 0;

            while (isRunning && (len = inputStream.read(buffer)) != -1) {

                outputStream.write(buffer, 0, len);
                current += len;
                ioListener.onLoading(new String(buffer), current, contentLength);
            }

            outputStream.flush();
            //中断
            if (len != -1) {
                ioListener.onInterrupted();
            } else {

                ioListener.onCompleted(null);

            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            close(outputStream);
            close(inputStream);
        }
    }

    /**
     * 将str写入文件
     */
    public void writeStr2File(String str, String pathFile, IOListener ioListener) {
        BufferedWriter bufferedWriter = null;
        OutputStreamWriter outputStreamWriter = null;
        OutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream(pathFile);
            outputStreamWriter = new OutputStreamWriter(outputStream);
            bufferedWriter = new BufferedWriter(outputStreamWriter);
            bufferedWriter.write(str);
            ioListener.onCompleted("");
        } catch (IOException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
        } finally {
            close(bufferedWriter);
            close(outputStreamWriter);
            close(outputStream);
        }
    }

    /**
     * 将str写入文件,同步操作,独占锁
     */
    public void writeStr2ReplaceFileSync(String str, String pathFile, IOListener ioListener) {
        File file;
        try {
            file = FileUtils.createFile(pathFile);
        } catch (IOException e) {
            e.printStackTrace();
            ioListener.onFail("文件创建失败，请检查路径是否合法以及读写权限");
            return;
        }
        FileOutputStream fileOutputStream = null;
        FileChannel fileChannel = null;
        FileLock fileLock = null;//文件锁
        try {

            /**
             * 写文件
             */
            fileOutputStream = new FileOutputStream(file);
            fileChannel = fileOutputStream.getChannel();
            while (true) {
                try {
                    fileLock = fileChannel.tryLock();//独占锁
                    break;
                } catch (Exception e) {
                    System.out.println("有其他线程正在操作该文件，当前线程" + Thread.currentThread().getName());
                }
            }
            if (fileLock != null) {
                int len = 0;
                long current = file.length();
                if (isRunning ) {
                    fileChannel.write(ByteBuffer.wrap(str.getBytes()));
                    current += len;
                    LogUtils.log("当前线程" + Thread.currentThread().getName());
                    ioListener.onLoading(str.getBytes(), current, str.length());
                }else {
                    //中断
                    ioListener.onInterrupted();
                }
                if (fileLock != null && fileLock.isValid()) {
                    LogUtils.log("release-write-lock");
                    fileLock.release();
                }
                close(fileChannel);
                close(fileOutputStream);
                if (file.length() == str.getBytes().length) {
                    ioListener.onCompleted(file);
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
            ioListener.onFail(e.getMessage());
        } finally {
        }
    }

  

}

写文件使用示例

 new IOUtils().writeStr2ReplaceFileSync(jsonObjectOld.toJSONString(), Constants.PATH_GAME_JSON, new IOListener() {
                            @Override
                            public void onCompleted(Object result) {
                                
                            }

                            @Override
                            public void onLoading(Object readedPart, long current, long length) {

                            }

                            @Override
                            public void onInterrupted() {

                            }

                            @Override
                            public void onFail(String errorMsg) {

                            }
                        });

读文件使用示例

new IOUtils().read2StrSync(Constants.PATH_CONFIG_APPLICATION_JSON, new IOListener<String>() {
            @Override
            public void onCompleted(String result) {
                
            }

            @Override
            public void onLoading(String readedPart, long current, long length) {

            }

            @Override
            public void onInterrupted() {

            }

            @Override
            public void onFail(String errorMsg) {

            }
        });

欢迎联系、指正、批评

Github:https://github.com/AnJiaoDe

CSDN：https://blog.csdn.net/confusing_awakening

OpenCV入门教程：https://blog.csdn.net/confusing_awakening/article/details/113372425

ffmpeg入门教程:https://blog.csdn.net/confusing_awakening/article/details/102007792

微信公众号
这里写图片描述

QQ群

这里写图片描述

安娇德
关注
  • 10
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
多线程向一个文件中写数据
c_wangbin的博客
09-04 2万+
最近被问到Log4j如何通过多个线程向一个文件中写入数据,当时没有一点头绪，　因为用过windows记事本的小伙伴都知道，当一个记事本文件被同时打开多次，并且每个都修改，那么只会保留第一次打开的内容，这就是互斥锁的机制吧。  具体场景：三个线程分别读取三个文件a,b,c 并向d文件中写入 现在想起来两个方案给小伙伴分享一下： 第一种（不可行）使用IO流复用，就是多个线程共用一个IO流
Java实现文件的多线程下载
12-21
为了协调各个线程并合并它们下载的数据，你可以使用`java.nio`包中的类，如`java.nio.channels.FileChannel`，它可以高效地进行文件的随机读写。当所有线程完成后，再将它们各自下载的部分合并到一个完整的文件中。 ...
【Java 多线程】多线程带来的的风险-线程安全、多线程五个经典案例
1226
04-01 1万+
日常开发中如果用到多线程编程，也一定会涉及到线程安全问题 线程安全这个问题就不太好理解 正因为如此，程序猿们才尝试发明出更多的编程模型来处理并发编程的任务 例如：多进程、多线程、actor、csp、async+await、定时器+回调 操作系统，调度线程的时候，是随机的 (抢占式执行) 正式因为这样的随机性，就可能导致程序的执行出现一些 bug 如果因为这样的调度随机性引入了 bug，就认为代码是线程不安全的，如果是因为这样的调度随机性，也没有带来 bug，就认为代码是线程安全的 这里的线程安全指的是有.
java线程安全问题
qq_43555873的博客
11-13 3526
当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程只有读操作，那么不会发生线程安全问题，但是如果多个线程中对资源有读和写的操作，就容易出现线程安全问题。 1 同一个资源问题 1、局部变量不能共享 public class SaleTicketDemo1 { public static void main(String[] args) { Window w1 = new Window(); Window w2 = ne...
java nio FileChannel堆内堆外数据读写全流程分析及使用(附详细流程图)
最新发布
念念不忘，必有回响
05-27 423
这里是小奏,觉得文章不错可以关注公众号小奏技术。
FILE对象线程安全
Focus·Flying
09-12 1014
根据apue讲述： 标准的IO例程可能从它们各自的内部数据结构的角度出发，是以线程安全的方式实现的！但在线程中，如果标准 IO例程都获取它们各自的锁，那么在做一次一个字符的IO时就会出现严重的性能下降！在这种情况下，需要对每 一个字符的读写操作进行读取锁和释放锁的动作！而如果使用flockfile和ftrylockfile函数获得给定FILE 对象关联的锁，并在fl
NIO的非阻塞式实现
qq_41184055的博客
08-13 1877
首先解释一下阻塞和非阻塞 对于传统的BIO，线程在同一时间只能等待数据的发送和接收，在此期间不能做其他的事 用图来表示 所以对于这种io，我们应该使用多线程的方式完成io通信 多线程虽然能完成同时接收和发送，但是本质上也是多个阻塞的单线程，多个线程中某个陷入阻塞，该线程还是不能做其他的事，造成资源的浪费。 NIO非阻塞模式，将每一个用于传输数据的通道都注册到选择器上，选择器监控通道的io状况...
用FileInputStream和FileOutPutStream读写文件
伏虎游侠的博客
05-04 6099
用FileInputStream和FileOutPutStream读写文件   用FileInputStream和FileOutPutStream读写文件 package io; import java.io.BufferedOutputStream; import java.io.DataOutputStream; import java.io.Fil
多线程随机读取文件
08-13
3. **Channel与Selector**：Java NIO提供了`FileChannel`，配合`Selector`，可以实现高效的多线程并发读写。每个线程都可以注册到Selector，当文件通道准备好读写时，Selector会通知相应的线程。 三、优化策略 1. ...
nio.rar_FastCopyFile.java_NIO_UseFloatBuffer.java_java nio_文件锁
09-24
在多线程或者网络环境下，有时我们需要确保文件在同一时刻只被一个线程或进程访问，这就需要用到文件锁。Java NIO提供了FileLock接口来实现这一功能。你可以通过FileChannel的lock()和tryLock()方法获取文件锁。锁...
5种解决Java独占写文件的方法
09-03
Java NIO提供了FileChannel接口，它支持文件锁。通过调用`tryLock()`方法尝试获取文件锁，如果失败，可以设置循环等待，直到获取到独占锁。文件锁可以指定锁定的字节范围，这里使用0到Long.MAX_VALUE表示整个文件。...
在Java里处理文件的技巧Java开发Java经验技巧共5
11-22
Java的`FileLock`接口可以实现文件锁。 11. **临时文件**：`java.io.TempFile`类可以帮助创建临时文件，它们在程序结束或特定条件下会被自动删除。 12. **文件编码**：处理文本文件时，需要明确文件的字符编码。...
java多线程写文件_Java 多线程写文件
weixin_36290287的博客
02-15 554
不废话，上马。import java.io.File;import java.io.IOException;import java.io.RandomAccessFile;import java.nio.channels.FileChannel;import java.nio.channels.FileLock;/*** @author DBJ**/public class MyThreadInf...
Java Filelock(文件锁)
这就是快乐嘛
01-08 2387
如何获得锁： 首先获得问的channel，然后对channel进行上锁 FileChannel fileChannel=new FileOutputStream("XX").getChannel(); FileLock lock=fileChannel.lock(); ... lock.release(); 文件锁可分为两类：独占锁(排他锁)、共享锁。共享锁可允许其他线程进行读操作 独占锁：创建...
java filechanel_FileChannel文件通道
weixin_42519497的博客
02-24 497
FileChannelFileChannel 可以通过 RandomAccessFile、FileInputStream、FileOutStream也可以通过FileChannel.open 获取。其中方法write 和 read 都是通过 ByteBuffer 对象进行操作(读写)。如果使用FileChannel.open打开文件通道时可以提供 OpenOption 来定义行为，如果需要写的话可...
java+lock+trylock_java – FileChannel tryLock()方法是检查锁还是只是破坏它们？
weixin_33418394的博客
02-25 367
我有两个进程可以查看相同的文件,并希望实现文件锁定.问题似乎是一个进程用java编写而另一个进程用C编写,并且不清楚java端如何实现低级锁定.该平台是Solaris 10.我尝试在文件上引入锁定,以防止在C进程读取文件时Java进程进行更新.我的想法是尝试从java代码中获取一次锁定10次,然后才无条件地写入文件(我假设锁定类型是一个咨询锁定).但是,java tryLock()会在第二次尝试时...
Java基础~Java线程同步
feizuiku0116的博客
03-15 355
一、线程同步的核心思想 加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。 二、方式一：同步代码块 作用：把出现线程安全问题的核心代码给上锁。 原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。 synchronized(同步锁对象) { 操作共享资源的代码(核心代码) } 锁对象要求：理论上，锁对象只要对于当前同时执行的线程来说是同一个对象即可 三、方式二：同步方法 一、介绍 作用：把出现线程安全问题的核心方法给上锁。
使用多线程往同一个文件写入数据的线程安全的例子(java实现)
热门推荐
lhever_的博客
08-01 2万+
本文给出了一个如何利用java提供的类MappedByteBuffer对文件进行并发写入的例子。具体实现思路就举个列子说明吧： 假设有10000个字节需要写入某个文件，为了加快写入速度，可以开启2个线程，第一个线程将前5000个字节写入文件0~4999的位置，另外一个线程将后5000个字节写入文件5000~9999的位置，等2个线程都写入完成后。我们就成功的将10000个字节完整的写入到了文件中。...
FileChannel的深入理解
jiangfullll的专栏
07-12 8660
FileChannel的深入理解
java 多线程拷贝文件
08-13
### 回答1： 以下是Java多线程拷贝文件的示例代码： ```java import java.io.*; public class MultiThreadFileCopy { public static void main(String[] args) { String srcFile = "source_file_path"; String destFile = "destination_file_path"; int threadNum = 5; File src = new File(srcFile); long startTime = System.currentTimeMillis(); if (src.exists()) { long fileSize = src.length(); long blockSize = fileSize / threadNum; for (int i = 0; i < threadNum; i++) { long startIndex = i * blockSize; long endIndex = (i == threadNum - 1) ? fileSize - 1 : (i + 1) * blockSize - 1; new CopyThread(srcFile, destFile, startIndex, endIndex).start(); } } long endTime = System.currentTimeMillis(); System.out.println("Total time taken: " + (endTime - startTime) + "ms"); } static class CopyThread extends Thread { private String srcFile; private String destFile; private long startIndex; private long endIndex; public CopyThread(String srcFile, String destFile, long startIndex, long endIndex) { this.srcFile = srcFile; this.destFile = destFile; this.startIndex = startIndex; this.endIndex = endIndex; } @Override public void run() { try (RandomAccessFile src = new RandomAccessFile(srcFile, "r"); RandomAccessFile dest = new RandomAccessFile(destFile, "rw")) { src.seek(startIndex); dest.seek(startIndex); byte[] buffer = new byte[1024]; int length; while ((length = src.read(buffer)) > 0) { if (startIndex + length > endIndex) { length = (int) (endIndex - startIndex + 1); } dest.write(buffer, 0, length); startIndex += length; if (startIndex > endIndex) { break; } } System.out.println(Thread.currentThread().getName() + " finished copying."); } catch (IOException e) { e.printStackTrace(); } } } } ``` 该示例代码首先将源文件路径、目标文件路径和线程数作为参数传入，然后计算出每个线程需要拷贝的文件块的起始位置和结束位置。接下来，该示例代码启动多个线程来拷贝文件块。每个线程使用RandomAccessFile类来读取源文件和写入目标文件。在拷贝过程中，每个线程都会更新自己的起始位置，并在拷贝完成后打印出自己的线程名称。最后，该示例代码计算并输出整个拷贝操作的总耗时。 ### 回答2： 在Java中，可以使用多线程进行文件拷贝操作。以下是一个简单的示例代码，用于演示如何使用多线程拷贝文件。 ```java import java.io.*; public class FileCopyWithThreads { public static void main(String[] args) { String sourcePath = "C:\\path\\to\\source\\file.txt"; String destPath = "C:\\path\\to\\destination\\file.txt"; int numberOfThreads = 4; try { // 创建输入流和输出流 FileInputStream fis = new FileInputStream(sourcePath); FileOutputStream fos = new FileOutputStream(destPath); // 获取源文件的大小 File sourceFile = new File(sourcePath); long fileSize = sourceFile.length(); // 计算每个线程需要拷贝的字节数 long chunkSize = fileSize / numberOfThreads; // 创建线程数组 CopyThread[] threads = new CopyThread[numberOfThreads]; // 启动线程 for (int i = 0; i < numberOfThreads; i++) { long startPos = i * chunkSize; long endPos = (i == numberOfThreads - 1) ? fileSize - 1 : (i + 1) * chunkSize - 1; threads[i] = new CopyThread(fis, fos, startPos, endPos); threads[i].start(); } // 等待所有线程完成 for (int i = 0; i < numberOfThreads; i++) { threads[i].join(); } // 关闭输入流和输出流 fis.close(); fos.close(); System.out.println("文件拷贝完成！"); } catch (Exception e) { e.printStackTrace(); } } public static class CopyThread extends Thread { private FileInputStream fis; private FileOutputStream fos; private long startPos; private long endPos; public CopyThread(FileInputStream fis, FileOutputStream fos, long startPos, long endPos) { this.fis = fis; this.fos = fos; this.startPos = startPos; this.endPos = endPos; } @Override public void run() { try { // 设置输入流的起始位置 fis.getChannel().position(startPos); // 定义缓冲区 byte[] buffer = new byte[1024]; int bytesRead; // 从输入流读取数据，写入输出流 while ((bytesRead = fis.read(buffer)) != -1) { fos.write(buffer, 0, bytesRead); // 检查是否超过了该线程的结束位置 if (fis.getChannel().position() > endPos) { break; } } } catch (Exception e) { e.printStackTrace(); } } } } ``` 在上述示例中，我们通过将文件分割成多个块，并为每个线程分配一个块来实现多线程拷贝文件。每个线程负责读取指定块的数据，并将数据写入目标文件中。最后，等待所有线程完成后，关闭输入流和输出流，完成文件拷贝操作。 注意：在实际应用中，需要根据具体情况对代码进行适当的修改，并添加必要的异常处理和错误检查。另外，文件拷贝过程中可能涉及到文件的锁定和同步问题，需要根据具体需求采取适当的措施来解决。 ### 回答3： 在Java中实现多线程拷贝文件可以通过使用线程池和线程等待的方式来实现。 首先，我们需要创建一个FixedThreadPool线程池，用于控制并发执行的线程数量，并且创建一个计数器来追踪文件复制的进度。然后，我们可以遍历要拷贝的文件列表，为每个文件创建一个任务，并将其提交给线程池执行。 文件拷贝的任务可以定义为一个Runnable接口的实现类，其中包含拷贝文件的逻辑。在拷贝的过程中，我们可以使用FileChannel来读取源文件，并用FileChannel来写入新文件，以提高拷贝的效率。每个任务执行完毕后，计数器加一，表示一个文件已经完成拷贝。 在所有的文件拷贝任务提交给线程池之后，我们可以调用线程池的awaitTermination方法，等待所有任务执行完毕，然后关闭线程池。同时，可以将计数器的值与文件列表的长度进行比较，如果相等则表示所有文件都已经拷贝完成。 在整个过程中，使用多线程可以充分利用CPU资源并提高文件拷贝的速度。然而，需要注意的是在进行文件拷贝的时候要确保对共享资源的正确访问，避免出现并发问题，常见的方法是使用同步锁或者使用线程安全的类。 总的来说，通过使用多线程拷贝文件可以有效提高文件拷贝的效率，在大量文件需要拷贝的情况下尤为适用。同时，我们还应该注意对线程安全的处理，保证拷贝过程的正确性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值