Java はファイル比較 5 を実装し、ファイルが新規に追加されたか、縮小されたか、変更されたかを判断します (マルチスレッド)

情報 2023-08-19 04:25:33 訪問数: null 
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;
    }
}

おすすめ

転載: blog.csdn.net/m0_54765221/article/details/125545319
おすすめ
GitHub のホットリストに急上昇 — オープンソースのプログラミング言語とフレームワークは、どうしてこんなにも魅力的なのでしょうか?
北京ヒューマノイドロボットイノベーションセンターが、擬人化走行用の純粋な電気駆動を備えた世界初のフルサイズヒューマノイドロボット「Tiangong」を発売
ランキング
アリクラウドサーバ_ubuntu ECSシステムディスク拡張システム_
ボタンをクリックしてクリップボードにコピーします
脅威ハンティングを使用してサイバー セキュリティを強化する
ライン画像やコンテナnginxのの建設
Python での try の使用について書く
リアルタイムのデータウェアハウスを構築する方法高速データ時代、MySQLのAnalyticDBはあなたを教えて
Docker でのネットワークおよびデータ管理 (Docker Swarm クラスターおよび Docker データ管理を含む)
Java ループの比較: 従来の for ループ、拡張された for ループ、および forEach ループ
浙江大学版「C言語プログラミング（第3版）」演習2-18
Gestion du temps RTOS - Utilisation de la fonction de crochet SysTick pour réaliser l'échantillonnage de synchronisation et les sous-sections de ce chapitre
アーカイブ
もっと
2024-04-27(29)
2024-04-26(22)
2024-04-25(31)
2024-04-24(30)
2024-04-23(31)
2024-04-22(5)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

コードワールド

© 2018 codetd.com