一个ForkJoin并行任务的实际应用

原创 2016年05月31日 00:15:15

先交代背景,因为我有好多照片存在不同的电脑和移动硬盘备份,平时又喜欢摄影,有时候相机的照片和手机拍的需要同步到所有设备,保证所有设备上的照片都是一样的,但是有时候会各种原因导致图片不同步,人为查找排除很麻烦何况我有10000+照片(其实里面没有几张自己的。。),首先想到的是根据文件名判重,考虑到会有重名的文件,严谨起见采取对照片摘要MD5,再去判重。其次是对这些MD5的过滤找到设备各自独有的照片进行复制同步即可。(插一句,有想过用Git管理这些二进制文件,没有具体试过,哪天闲了就试试~若有大侠搞过望不吝赐教!)

今天主要进行的是给一个顶级目录,递归生成所有文件的MD5信息,采取的是Fork/Join并行框架+命令行的方式

下边这段可以略过,不过看看也没坏处~
至于为什么这样做,说说心路历程,刚开始想用Qt+C++的方式,考虑到开发效率(我想速成)再考虑之前Qt写的几个工具,果断放弃;后来想用Python无奈自己Python太弱,也放弃;再后来想用JavaFx,还需要边学边搞,win下编程C#MFC压根没搞过,这啥啥不会真捉急啊,总不能逼我在Linux上拿C||Shell写吧,好吧我承认我事儿倍多:);那就用控制台吧,写个Java这样还可以把几个步骤分开来写单独优化,操作起来几个命令行敲一下黑屏白字滚动起来。。。想想都有点酸爽。扯了这么多,最终就是实现一个Java工具类,给他一个顶级目录,他会自动生成一个清单文件,里面是MD5和对应的文件路径信息,当然是基于并行执行任务框架做的,接下来开始吧

并行执行核心思想是大的任务递归分解为粒度较小的任务,然后每个小的任务执行完返回执行结果,汇总成一个最终的结果

在本文中,遍历一个给定的顶级文件夹并输出所有内部文件的摘要,这就是最终的任务,这个任务要并行执行为了提高效率必须划分成小任务并行执行它们并收集执行结果,先看看整体的代码:

public class Filter {
    static ForkJoinPool mPool = null;
    static List<File> mList = new ArrayList<>();

    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            switch (args[i]) {
            /* 指定并行执行所需线程数量 eg (-j 8) 指定线程池有8个线程*/
                case "-j":
                    mPool = new ForkJoinPool(Integer.parseInt(args[++i]));
                    break;

            /* 指定顶级目录列表 */
                default:
                    mList.add(new File(args[i]));
                    break;
            }
        }

        /* 具体分配执行 */
        new Executor().invokeTask();
    }

/*
* 具体的顶级任务执行器
*/
    static class Executor {
        long start = 0;
        long end1 = 0;
        long end2 = 0;

        private List<GenMd5Task> mTasks = new ArrayList<>();
        private List<Map<String, String>> mapList = new ArrayList<>();

        public Executor() {
            if (mPool == null) {
                mPool = new ForkJoinPool();
            }
        }

        public List<Map<String, String>> invokeTask() {
            end1 = end2 = start = System.currentTimeMillis();

            for (File file : mList) {
                /* 划分的子任务*/ 
                GenMd5Task task = new GenMd5Task(file);
                mTasks.add(task);
                /* 调用任务并等待返回执行结果 */
                Map<String, String> map = mPool.invoke(task);
                mapList.add(map);

                end1 = System.currentTimeMillis();

                /* 把最终计算结果记录到文件中 */ 
                FileUtil.writeMapToFile(file.getName() + System.currentTimeMillis() + "-md5.txt",
                        map);

                end2 = System.currentTimeMillis();
            }

            /* 统计耗时 */
            System.out.println("computer time: " + (end1 - start) + "ms");
            System.out.println("write file time: " + (end2 - end1) + "ms");

            mPool.shutdown();

            return mapList;
        }
    }
}

上边代码是工具类主体,需要执行参数,比如java Filter -j 8 C:\Users\yy\xxx
主要的工作都在Executor的invokeTask中完成,里面有一个GenMd5Task的类,继承自RecursiveTask,表示一个又返回值的task,还有一个没有返回值的类RecursiveAction

public class GenMd5Task extends RecursiveTask<Map<String, String>> {
    private HashMap<String, String> mMap;
    private File mFile;
    private List<GenMd5Task> mTasks;

    public GenMd5Task(File file) {
        mFile = file;
    }

    @Override
    protected Map<String, String> compute() {
        mMap = new HashMap();
        File[] files = mFile.listFiles();
        mTasks = new ArrayList<>();

        for (File f : files) {
            System.out.println(f.getAbsoluteFile());
            if (f.isFile()) {
                mMap.put(DigestUtil.getMd5(FileUtil.getBytes(f)), f.getAbsolutePath());
            } else {
                /* 上边是文件直接计算MD5放进当前结果Map中 */
                /* 下边是当前目录一级子目录,再次创建一个子任务,添加进任务列表,一会并发执行这些任务 */ 
                GenMd5Task task = new GenMd5Task(f);
                mTasks.add(task);
            }
        }

        /* 执行所有任务 并汇总结果*/ 
        invokeAll(mTasks);
        for (GenMd5Task task : mTasks) {
            mMap.putAll(task.join());
        }

        return mMap;
    }
}

上边看到是直接按照所有子目录对应一个子任务的方式去分配的,这样可能并不是性能最优,留待以后解决,同时还需要注意一点的是,这儿是在任务计算过程中动态添加任务的,每一个上级任务都在等待其所有的子任务执行完毕返回结果,像一个倒立的树状结构,每一个叶子节点都是一个最小粒度的任务,在这里是当前目录下只包含文件没有其它目录的时候

其中用到的两个工具类附上代码:

public class FileUtil {
    public static byte[] getBytes(File f) {
        ByteArrayOutputStream bos = new ByteArrayOutputStream((int) f.length());
        BufferedInputStream in = null;

        try {
            in = new BufferedInputStream(new FileInputStream(f));
            int buf_size = 4096;
            byte[] buffer = new byte[buf_size];
            int len;
            while (-1 != (len = in.read(buffer, 0, buf_size))) {
                bos.write(buffer, 0, len);
            }
            return bos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /* 把一个Map写入文件中 */
    public static <K, V> void writeMapToFile(String fileName, Map<K, V> map) {
        File f = new File(fileName);
        try {
            FileWriter fw = new FileWriter(f);
            for (Map.Entry<K, V> entry : map.entrySet())
                fw.write(entry.getKey().toString() + ":" + entry.getValue().toString() + "\n");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
public class DigestUtil {
    /**
     * 计算字符串MD5值
     *
     * @param str 需要计算的字符串
     * @return String
     */
    public static String getMd5(String str) {
        try {
            return getMd5(str.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String getMd5(byte[] bytes) {
        try {
            byte[] hash = MessageDigest.getInstance("MD5").digest(bytes);
            StringBuilder hex = new StringBuilder(hash.length * 2);
            for (byte b : hash) {
                if ((b & 0xFF) < 0x10)
                    hex.append("0");
                hex.append(Integer.toHexString(b & 0xFF));
            }
            return hex.toString();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

这只是完成了第一步生成摘要,有些地方仍然需要优化,比如怎么最大限度喂饱每一个线程的问题,比如当文件读取遇到IO瓶颈,CPU利用率一直比较低的问题,甚至过程打断的处理等等,并且还需要完成查重同步的部分~

有不妥的地方,欢迎指正,一起进步~

版权声明:本文为博主原创文章,转载请注明出处。

相关文章推荐

Fork/Join框架之Fork、Join操作

Fork Fork就是一个不断分枝的过程,在当前任务的基础上长出n多个子任务。 当一个ForkJoinTask任务调用fork()方法时,当前线程会把这个任务放入到queue数组的queueTop位置...

《Java并发编程的艺术》读书笔记:Fork/Join框架

JDK1.7提供的Fork/Join框架,用于把大任务拆解成小任务,多线程运行这些小任务,最后把小任务的结果求和。看到这个思想,是否觉得很熟悉?这个和算法里的分治算法如出一辙,Divide and C...

Java8新特性教程

欢迎阅读我的java8新特性介绍教程。本教程将一步一步的引领你浏览所有新的语言特性。伴随着一些简单且简短的代码示例,你将学习如何使用默认接口方法,lambda表示式,方法引用和可重复的annotati...

Java8新特性——并行流parallelStream

今天是高考的日子,是大四师兄师姐答辩毕业的日子。一代又来,一代又去。好久没写博客,借此特殊日子整理一下前不久学java8新特性时写的代码,留下痕迹。(本博客的代码根据 java8新特性教程 学习整理,...

ForkJoin并发框架—样例及实现分析

1. JDK中ForkJoin实现概述在JavaSE7的API和JDK1.7中,分别集成了支持ForkJoin的五个类: ForkJoinPool 实现ForkJoin的线程池 ForkJoinWor...

使用Java7提供的Fork/Join框架

在Java7中,JDK提供对多线程开发提供了一个非常强大的框架,就是Fork/Join框架。这个是对原来的Executors更 进一步,在原来的基础上增加了并行分治计算中的一种Work-steali...

Fork/Join个人小结

主要的类: 1、RecursiveTask: 1)  RecursiveTask:表示一个“任务”,重写他的T  compute()方法,计算返回值; 2)  RecursiveTask有个fo...

浅谈 Fork/Join

fork/join的java7新增加的功能,可以把它理解成一个并发框架。我们通过fork/join能将一个可分解的大任务,分解成多个子任务同步执行,执行完毕后,在将各子任务的结果进行合并,得到最终的结...

Fork/Join框架及其性能介绍

Fork/Join框架介绍Fork/Join框架是Java 7提供了的一个用于并行执行任务的框架, 大概是怎样子的呢,就是一个把大任务分割成若干个小任务,最终把每个小任务结果汇总起来得到大任务结果的框...

Java并发编程--Fork/Join框架使用

上篇博客我们介绍了通过CyclicBarrier使线程同步,但是上述方法存在一个问题,那就是如果一个大任务跑了2个线程去完成,如果线程2耗时比线程1多2倍,线程1完成后必须等待线程2完成,等待的过程线...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)