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

心已赠人 2023-09-28 12:53 21阅读 0赞

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;
        }
    }