java实现文件比较5，判断文件是否新增减少修改(多线程)

最新推荐文章于 2022-11-20 22:24:11 发布
最新推荐文章于 2022-11-20 22:24:11 发布
阅读量217 收藏
点赞数
分类专栏： 文件对比 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54765221/article/details/125545319
版权 
package com.taiyusoft.thread2;

import com.taiyusoft.Fc;

import java.io.File;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;

public class LinklistRunnable1 implements Runnable {
    private CountDownLatch count;  //次数
    private CyclicBarrier barrier;
    private LinkedList<Fc> linkedList1 = new LinkedList<Fc>();//读取路径1中的所有的文件
    private LinkedList<Fc> linkedList2 = new LinkedList<Fc>();//读取路径2中的所有的文件

    private List listoneNot1 = new ArrayList<Fc>(); //存放数据一缺失的数据
    private List listoneNot2 = new ArrayList<Fc>(); //存放数据二缺失的数据


    private LinkedHashSet<Fc> setOne1;
    private LinkedHashSet<Fc> setOne2;

    private int setOneSize1;
    private int setOneSize2;

    private int num1;
    private int num2;

    private int a;
    private int b;


    public LinklistRunnable1(CountDownLatch count, CyclicBarrier barrier,
                             List<Fc> listoneNot1, List<Fc> listoneNot2,
                             LinkedList<Fc> linkedList1, LinkedList<Fc> linkedList2,
                             LinkedHashSet<Fc> setOne1, LinkedHashSet<Fc> setOne2,
                             int setOneSize1, int setOneSize2,
                             int num1, int num2,
                             int a, int b
    ) {
        this.count = count;
        this.barrier = barrier;
        this.listoneNot1 = listoneNot1;
        this.listoneNot2 = listoneNot2;
        this.linkedList1 = linkedList1;
        this.linkedList2 = linkedList2;
        this.setOne1 = setOne1;
        this.setOne2 = setOne2;
        this.setOneSize1 = setOneSize1;
        this.setOneSize2 = setOneSize2;
        this.num1 = num1;
        this.num2 = num2;
        this.a = a;
        this.b = b;

    }

    // 总数
    Object lock = new Object();

    @Override
    public void run() {
        try {
            barrier.await();    // 此处阻塞
        } catch (Exception e) {
        }
        while (num1 > a) {
            //开始调用方法
            fileCompare1();
        }
        count.countDown();  //当前线程结束后，计数器-1
    }


    public void fileCompare1() {
        synchronized (lock) {
            if (num1 > a) {
                setOne1.add(linkedList2.get(a));
                if (setOne1.size() != setOneSize1) {  //判断大小是否改变 ，改变表示数据缺失
                    listoneNot1.add(linkedList2.get(a)); //存放缺失了哪些数据
                    setOne1.remove(linkedList2.get(a));
                    setOneSize1 = setOne1.size(); //更新基础集合大小
                }
                a++;
//                if (num != i) {
//                    System.out.println("数据源1中剩余检测" + (num-i) + "个文件");
//                }
            }
        }
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }



}





package com.taiyusoft.thread2;

import com.taiyusoft.Fc;

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;

public class LinklistRunnable2 implements Runnable {
    private CountDownLatch count;  //次数
    private CyclicBarrier barrier;
    private LinkedList<Fc> linkedList1 = new LinkedList<Fc>();//读取路径1中的所有的文件
    private LinkedList<Fc> linkedList2 = new LinkedList<Fc>();//读取路径2中的所有的文件

    private List listoneNot1 = new ArrayList<Fc>(); //存放数据一缺失的数据
    private List listoneNot2 = new ArrayList<Fc>(); //存放数据二缺失的数据


    private LinkedHashSet<Fc> setOne1;
    private LinkedHashSet<Fc> setOne2;

    private int setOneSize1;
    private int setOneSize2;

    private int num1;
    private int num2;

    private int a;
    private int b;


    public LinklistRunnable2(CountDownLatch count, CyclicBarrier barrier,
                             List<Fc> listoneNot1, List<Fc> listoneNot2,
                             LinkedList<Fc> linkedList1, LinkedList<Fc> linkedList2,
                             LinkedHashSet<Fc> setOne1, LinkedHashSet<Fc> setOne2,
                             int setOneSize1, int setOneSize2,
                             int num1, int num2,
                             int a, int b
    ) {
        this.count = count;
        this.barrier = barrier;
        this.listoneNot1 = listoneNot1;
        this.listoneNot2 = listoneNot2;
        this.linkedList1 = linkedList1;
        this.linkedList2 = linkedList2;
        this.setOne1 = setOne1;
        this.setOne2 = setOne2;
        this.setOneSize1 = setOneSize1;
        this.setOneSize2 = setOneSize2;
        this.num1 = num1;
        this.num2 = num2;
        this.a = a;
        this.b = b;

    }

    // 总数
    Object lock = new Object();

    @Override
    public void run() {
//        try {
//            barrier.await();    // 此处阻塞
//        } catch (Exception e) {
//        }
//        while (num1 > a) {
//            //开始调用方法
//            fileCompare1();
//        }

        try {
            barrier.await();
        } catch (Exception e) {
        }
        while (num2 > b) {
            //开始调用方法
            fileCompare2();
        }
        count.countDown();  //当前线程结束后，计数器-1
    }


    public void fileCompare1() {
        synchronized (lock) {
            if (num1 > a) {
                setOne1.add(linkedList2.get(a));
                if (setOne1.size() != setOneSize1) {  //判断大小是否改变 ，改变表示数据缺失
                    listoneNot1.add(linkedList2.get(a)); //存放缺失了哪些数据
                    setOne1.remove(linkedList2.get(a));
                    setOneSize1 = setOne1.size(); //更新基础集合大小
                }
                a++;
//                if (num != i) {
//                    System.out.println("数据源1中剩余检测" + (num-i) + "个文件");
//                }
            }
        }
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void fileCompare2() {
        synchronized (lock) {
            if (num2 > b) {
                setOne2.add(linkedList1.get(b));
                if (setOne2.size() != setOneSize2) {  //判断大小是否改变 ，改变表示数据缺失
                    listoneNot2.add(linkedList1.get(b)); //存放缺失了哪些数据
                    setOne2.remove(linkedList1.get(b));
                    setOneSize2 = setOne2.size(); //更新基础集合大小
                }
                b++;
            }
        }
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


}




package com.taiyusoft.thread2;

import com.taiyusoft.Fc;


import java.io.File;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class main {

    private static List listoneNot1 = new ArrayList<Fc>(); //存放数据一缺失的数据
    private static List listoneNot2 = new ArrayList<Fc>(); //存放数据二缺失的数据

    private static LinkedList<Fc> linkedList1 = new LinkedList<Fc>();//读取路径1中的所有的文件
    private static LinkedList<Fc> linkedList2 = new LinkedList<Fc>();//读取路径2中的所有的文件

    static int num1;
    static int num2;

    static int a;
    static int b;

    private static LinkedHashSet<Fc> setOne1 = new LinkedHashSet<>();;
    private static LinkedHashSet<Fc> setOne2 = new LinkedHashSet<>();;

    private static int setOneSize1;
    private static int setOneSize2;


    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        String dirName1 = "C:\\Users\\taiyu\\Desktop\\4444\\file1";
        File file = new File(dirName1);
        readFileSum1(file, dirName1);

        String dirName2 = "C:\\Users\\taiyu\\Desktop\\file2";
        File file1 = new File(dirName2);
        readFileSum2(file1, dirName2);

        num1 = linkedList2.size();  // 总数
        a = 0;

        setOne1.addAll(linkedList1);  //可以通过addAll把list集合转换为set集合
        setOneSize1 = setOne1.size(); //数据一大小


        num2 = linkedList1.size();  // 总数
        b = 0;
        setOne2.addAll(linkedList2);  //可以通过addAll把list集合转换为set集合
        setOneSize2 = setOne2.size(); //数据二大小


        int threadNum = 500;    //
        final CyclicBarrier barrier = new CyclicBarrier(threadNum);//阻塞
        final CountDownLatch count = new CountDownLatch(threadNum);  // 用于统计 执行时长

        System.out.println("数据源1开始进行对比");
        LinklistRunnable1 th1 = new LinklistRunnable1(
                count, barrier,
                listoneNot1, listoneNot2,
                linkedList1, linkedList2,
                setOne1, setOne2,
                setOneSize1, setOneSize2,
                num1, num2,
                a,b
        );
        ExecutorService executorService1 = Executors.newFixedThreadPool(threadNum);
        for (int i = 0; i < threadNum; i++) {   //此处 设置数值  受限于 线程池中的数量
            executorService1.submit(th1);
        }
        try {
            count.await();
            executorService1.shutdown();
        }catch(Exception e){

        }
        System.out.println("数据源2开始进行对比");
        LinklistRunnable2 th2 = new LinklistRunnable2(
                count, barrier,
                listoneNot1, listoneNot2,
                linkedList1, linkedList2,
                setOne1, setOne2,
                setOneSize1, setOneSize2,
                num1, num2,
                a,b
        );
        ExecutorService executorService2 = Executors.newFixedThreadPool(threadNum);
        for (int i = 0; i < threadNum; i++) {   //此处 设置数值  受限于 线程池中的数量
            executorService2.submit(th2);
        }


        try {
            count.await();
            executorService2.shutdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
            List listoneNot3 = new ArrayList<Fc>(); //存放两者都缺失的文件(即发生修改的文件)
            for (int i = 0; i < listoneNot1.size(); i++) {
                String path1 = ((Fc) listoneNot1.get(i)).getPath();
                for (int j = 0; j < listoneNot2.size(); j++) {
                    String path2 = ((Fc) listoneNot2.get(j)).getPath();
                    if (path1.equals(path2)) {
                        listoneNot3.add(listoneNot2.get(j));
                        listoneNot2.remove(listoneNot2.get(j));
                        listoneNot1.remove(listoneNot1.get(i));
                    }
                }
            }

            if (listoneNot1.size() > 0) {
                System.out.println("**********************************************");
                System.out.println("数据源1与数据源2相比,发生删除或者新增操作的文件...");
                for (int i = 0; i < listoneNot1.size(); i++) {
                    System.out.println(dirName1 + ((Fc) listoneNot1.get(0)).getPath());
                }
                System.out.println("**********************************************");
            } else {
                System.out.println("**********************************************");
                System.out.println("数据源1与数据源2相比,未检测到发生删除或者新增操作的文件...");
                System.out.println("**********************************************");
            }


            if (listoneNot2.size() > 0) {
                System.out.println("__________________________________________________");
                System.out.println("数据源2中排除的文件...");
                for (int i = 0; i < listoneNot2.size(); i++) {
                    System.out.println(dirName2 + ((Fc) listoneNot2.get(0)).getPath());
                }
                System.out.println("__________________________________________________");
            } else {
                System.out.println("__________________________________________________");
                System.out.println("数据源2与数据源1相比,未检测到发生删除或者新增操作的文件...");
                System.out.println("__________________________________________________");
            }


            //打印数据3缺失数据
            if (listoneNot3.size() > 0) {
                System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
                System.out.println("两者之间发生修改的文件");
                for (int i = 0; i < listoneNot3.size(); i++) {
                    System.out.println(((Fc) listoneNot3.get(i)).getPath());
                }
                System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
            } else {
                System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
                System.out.println("数据源2与数据源1,未检测到发生修改的文件...");
                System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
            }


        //结束时间
        long endTime = System.currentTimeMillis();
        //打印
        System.out.println("程序运行时间：" + (double) (endTime - startTime) / 1000 + "s");

    }

    public static void readFileSum1(File root, String dirName1) {
        if (root.exists()) {
            if (root.isDirectory()) {
                File[] files = root.listFiles();
                if (files != null) {
                    for (int i = 0; i < files.length; i++) {
                        if (files[i].isFile()) {
//                             linkedList1.add(files[i].toString().replace(dirName1, ""));
                            Fc fc = new Fc();
                            fc.setPath(files[i].toString().replace(dirName1, ""));
                            fc.setLastmodified(String.valueOf(files[i].lastModified()));
                            linkedList1.add(fc);

                        } else if (files[i].isDirectory()) {
                            readFileSum1(files[i], dirName1);
                        }
                        files[i] = null;
                    }
                }
                files = null;
            } else if (root.isFile()) {
                Fc fc = new Fc();
                fc.setPath(root.toString().replace(dirName1, ""));
                fc.setLastmodified(String.valueOf(root.lastModified()));
                linkedList1.add(fc);
//                linkedList1.add(root.toString().replace(dirName1, ""));
            }
        }
    }

    public static void readFileSum2(File root, String dirName2) {

        if (root.exists()) {
            if (root.isDirectory()) {
                File[] files = root.listFiles();
                if (files != null) {
                    for (int i = 0; i < files.length; i++) {
                        if (files[i].isFile()) {
                            Fc fc = new Fc();
                            fc.setPath(files[i].toString().replace(dirName2, ""));
                            fc.setLastmodified(String.valueOf(files[i].lastModified()));
                            linkedList2.add(fc);
//                            linkedList2.add(files[i].toString().replace(dirName2, ""));
                        } else if (files[i].isDirectory()) {
                            readFileSum2(files[i], dirName2);
                        }
                        files[i] = null;
                    }
                }
                files = null;
            } else if (root.isFile()) {
                Fc fc = new Fc();
                fc.setPath(root.toString().replace(dirName2, ""));
                fc.setLastmodified(String.valueOf(root.lastModified()));
                linkedList2.add(fc);
//                linkedList2.add(root.toString().replace(dirName2, ""));
            }
        }
    }
}


package com.taiyusoft;

public class Fc {
    String path;
    String lastmodified;

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public String getLastmodified() {
        return lastmodified;
    }

    public void setLastmodified(String lastmodified) {
        this.lastmodified = lastmodified;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Fc fc = (Fc) o;

        if (path != null ? !path.equals(fc.path) : fc.path != null) return false;
        return lastmodified != null ? lastmodified.equals(fc.lastmodified) : fc.lastmodified == null;
    }

    @Override
    public int hashCode() {
        int result = path != null ? path.hashCode() : 0;
        result = 31 * result + (lastmodified != null ? lastmodified.hashCode() : 0);
        return result;
    }
}
my是个攻城诗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA中如何判断两个路径_Java判断两个路径对应的文件是否相同
weixin_30100295的博客
02-28 1020
今天遇到一个bug，查了一个小时才发现是文件路径比较出了问题：比如有两个路径：D:\dir\..\a.txt和D:\a.txt。这两个路径写法虽然不同，但是很容易知道这两个路径指向的是同一个文件。如果我们使用Java的File去判断两个路径是否相同,判断如下：Filef1=newFile("D:\\dir\\..\\a.txt");Filef2=newFile("D:\\a.txt...
Java(新增不成功)
qq_44543430的博客
06-08 893
作者：杨裙 本次任务完成时间：2019年6月5日 开发工具与关键技术：MyEclipse 10、Java 1、在JAVA中刚开始做新增的时候，经常会因为自己的一个小小的疏忽，就写错新增语句，也有可能是获取不到值，这些都会犯的错。 2、首先，我们新增的时候第一步应该创建需要新增的那张表的po实体类，然后在Dao写一个新增的方法，然后去实现它。 3、如下图例：是我在新增数据到数据库的时候没有新增成功，...
Java使用多线程监控文件改动，并重新载入资源。
malei2551712的专栏
04-29 1810
最近做的一个项目用到了很多配置文件，当一个wen
java多线程
lumaomao_的专栏
04-17 291
Volatile关键字 Volatile主要使用的场合是在多个线程之间感知实例变量的修改，并且可以获得最新值使用，当线程想要访问volatile修饰的变量时强制从公共堆栈中进行读取。 Volatile可以保证每次线程从主内存中刷新到最新的变量值，但是不能保证变量值被加载到线程内存之后对该变量做的修改操作是原子性的。Volatile变量在线程内存中被修改之后要立即同步回主内存中，以保证其他线程使...
Java多线程实现快速切分文件的程序
03-06
在Java编程中，多线程可以提高程序的执行效率，特别是在处理大文件或者需要大量并发操作的任务时。本文将深入探讨如何使用Java多线程来快速切分大文件，以解决大数据导入时遇到的性能问题。 首先，我们来看标题中的...
Java 利用多线程实现文件的分片下载
最新发布
01-15
刚学完多线程和线程池，以及线程爱好者。 使用场景及目标： 大文件的快速下载，经测试在100M带宽的网络下，下载一个40M的文件，不超过两秒钟，当然还得根据自己电脑的配置来讲。 其他说明： 文件如果特别小，而...
java多线程实现文件下载
08-25
以下将详细介绍如何利用Java实现多线程文件下载。 首先，我们需要创建一个`DownloadManager`类，它实现了`Runnable`接口，这意味着它可以被线程执行。`DownloadManager`类的主要职责是管理下载过程，包括初始化下载...
java多线程实现文件下载功能
08-31
在Java编程中，多线程实现文件下载是一种提高下载效率的有效方法，特别是在处理大文件时。下面我们将深入探讨如何利用Java实现多线程文件下载功能。 1. **获取文件总大小**： 在开始下载之前，我们需要知道文件的...
Java多线程下载文件实现案例详解
08-19
Java多线程下载文件实现案例详解是一种常见的应用场景，使用多线程下载文件可以提高下载速度、提高下载效率、减少下载时间。本文通过示例代码对Java多线程下载文件实现案例进行了详细的解释，对大家的学习或者工作...
java实现监视文件修改变更
04-08
NULL 博文链接：https://zhaoningbo.iteye.com/blog/1591655
java常用类（Timer、TimerTask、File）简单监测文件夹的增加文件
qq_48650491的博客
07-24 286
简单监测文件夹的增加文件 我的想法是检测文件夹里面的每一个文件的修改时间，通过跟当前时间进行比较，如果修改时间在当前之后，便把这个文件遍历出来。 import java.io.File; import java.util.*; /** * 2021/7/23 */ public class Work2 { static int n = 0;//计数文件个数 static Date d=new Date();//存储比较的时间 public static void clear(D
Java 读取文件夹检查是否新增文件 文件监听器
lbyd2016的博客
12-26 3561
创建一个文件监听器 监听文件夹下文件的变化  使用 commons-io 中的文件监控  import java.util.concurrent.TimeUnit; import org.apache.commons.io.filefilter.FileFilterUtils; import org.apache.commons.io.monitor.FileAlterationMo...
【File类】监听判断指定的某个文件是否被修改，如果被修改， 就在控制台打印出“File changed…”...
梦幻衣园
09-28 455
每1秒钟一次，判断指定的某个目录下的某个文件是否被修改，如果被修改， 就在Console上打印出“File changed…” 这题调用了File类的lastModified()方法获得文件最后一次修改的时间； Thread的sleep(1000)方法让该线程睡1秒。  import java.io.File; import java.util.Date; /** * @auth...
java实时监控文件，如果文件被修改，每次按行获取文件更新内容
热门推荐
qq_56044050的博客
04-16 1万+
一、概述： 使用java实现对文件的监控功能，当文件发生修改，实时获取更新内容。 1.要求对目标文件实时监控 2.按行读取文件更行内容 3.将获取内容进行落库 二、使用技术： 2.1 commons-io 使用Commons-io的monitor下的相关类可以处理对文件进行监控，它采用的是观察者模式来实现的 （1）可以监控文件夹的创建、删除和修改 （2）可以监控文件的创建、删除和修改 （3）采用的是观察者模式来实现的 （4）采用线程去定时去刷新检测文件的变化情况 2.2 Rand
Java_题目_添加用户对象并判断是否存在
SisinRyu的博客
11-20 987
Java_题目_添加用户对象并判断是否存在
java实现批量对比文件
weixin_43495390的博客
04-28 1095
还在苦恼文本对比困难？接下来带你不使用对比工具实现文本对比，领略系统黑科技的强大，哈哈哈 1.首先准备两个需要对比的文档，a.txt和b.txt。 a.txt b.txt 2.打开cmd，输入fc 后边跟需要对比的文件路径。 3.轻敲回车，结果清晰的展现在你眼前，哈哈哈。 4.拓展：利用java调用bat脚本，结合bat脚本后边拼接->,即可打印输出，实现批量对比文件。 public static void mvnInstall(){ String springClass
Java如何监控一个文件目录，当作出新增，删除，修改文件等操作时，第一时间对文件作出响应
Fanx繁星
12-03 2972
前言 最近在开发制药lims的数据采集程序，因为一些硬件设备，没有和lims直连的方式，而且将数据存放到了数据库中，也不知道数据库的账号密码，只能拿到他们的备份文件或者在软件内导出excel，pdf，xml，txt等一些文件，所以想到的办法就是，让操作员将文件导出到一个指定的目录，数采程序通过监听这个目录，来判断是否是新添加的文件。 准备工作 环境 Maven 3.6.3 SpringBoot 现成的轮子 commons-io ApacheCommons IO库包含实用程序类、流实现、文件过滤器、文件比
Java实现监听文件变化的三种方法，推荐第三种
程序新视界
05-30 5515
背景 在研究规则引擎时，如果规则以文件的形式存储，那么就需要监听指定的目录或文件来感知规则是否变化，进而进行加载。当然，在其他业务场景下，比如想实现配置文件的动态加载、日志文件的监听、FTP文件变动监听等都会遇到类似的场景。 本文给大家提供三种解决方案，并分析其中的利弊，建议收藏，以备不时之需。 方案一：定时任务 + File#lastModified 这个方案是最简单，最能直接想到的解决方案。通过定时任务，轮训查询文件的最后修改时间，与上一次进行对比。如果发生变化，则说明文件已经修改，进行重新加载或对应的

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值