算法优化 - 并行AsyncTasks还是线程？

Question

我目前有一个AsyncTask ，它目前使用OpenCV使用bubble sort技术比较图像。 说，我必须比较400张图像。 这意味着400*401/2=80,200比较。 我们假设一次比较需要1秒钟。 那么，这是80,200 sec ，大约22.27 hours ，这是非常长的。 所以，我开发了这种类型的算法：

它将400图像分成5组。 所以每组有80图像。

算法的第一部分是在组成员中比较自己的图像。

因此， image1将自己与image2-80进行比较，这意味着有79比较。 image2将进行78比较，依此类推。 这使得3,160比较。 或3,160 sec 。 同样， image81将自己与image82-160进行比较，依此类推。 因此，所有“组比较”都在3,160 sec内完成，因为它们是并行运行的。

算法的第二部分将group 1元素与group 2元素进行比较， group 2与group 3 ， group 3与group 4 ，依此类推。 这将意味着将image1与image81-160进行比较，这是80比较，因此group 1和group 2之间的总比较将是80*80=6400比较。 是否可以将每个图像与组比较并行比较？ 也就是说，如果image1将自己与image81-160进行比较，那么image2应该做同样的事情，依此类推，而其他组也在做同样的事情。 所以，这个部分应该只需要6400 sec 。

现在， group1将与group3 ， group2与group4 ， group3与group5 。 - > 6400 sec

之后， group1 will be compared with group4和group2与group5 group1 will be compared with group4 。 - > 6400 sec

所以对所有群体进行比较。

总时间= 3160+6400+6400+6400=22,360sec 。 我意识到群体越多，花费的时间就越多。 所以，我必须增加团队规模以减少时间的增加。 无论哪种方式，它将时间减少到实际时间的近1/4th 。

这个算法不现实吗？ 如果是这样，为什么？ 有什么缺点？ 我该如何解决？ 是否有更好的算法来更快地比较图像列表？ 显然不是quick sort ，我不能按升序或降序排列图像。 或者我可以吗？

如果这个算法可行？ 实施它的最佳方法是什么？ Thread或AsyncTask ？

Answer 1

这是一个现实的算法，但理想情况下，您希望能够在整个程序中使用相同数量的工作线程。 为此，你需要使用偶数个线程，比如说8。

在Pass1上，Thread1处理图像1-50，Thread2处理图像51-100等。

在Pass2上，Thread1和Thread2都处理图像1-100。 Thread1处理图像1-25和50-75，Thread2处理图像26-50和图像76-100。 然后，Thread1处理图像1-25和76-100，并且Thread2处理图像26-75。

通过3到8遵循相同的模式 - 分配给正在处理的两个组的两个线程在它们之间拆分组。 这样你就可以保持所有线程的忙碌。 但是，为了简化组分区，您需要偶数个线程。

4个主题的示例代码

class ImageGroup {
    final int index1;
    final int index2;
}

class ImageComparer implements Runnable {
    final Image[] images;
    ImageGroup group1;
    ImageGroup group2;

    public ImageComparer(Image[] images, ImageGroup group1, ImageGroup group2) {
        ...
    }

    public void run() {
        if(group2 == null) { // Compare images within a single group
            for(int i = group1.index1; i < group1.index2; i++) {
                for(int j = i + 1; j < group1.inex2; j++) {
                    compare(images[i], images[j]);
                }
            }
        } else { // Compare images between two groups
            for(int i = group1.index1; i < group1.index2; i++) {
                for(int j = group2.index1; j < group2.index2; j++) {
                    compare(images[i], images[j]);
                }
            }
        }
    }
}

ExecutorService executor = new ThreadPoolExecutor(); // use a corePoolSize equal to the number of target threads
// for 4 threads we need 8 image groups
ImageGroup group1 = new ImageGroup(0, 50);
ImageGroup group2 = new ImageGroup(50, 100);
...
ImageGroup group8 = new ImageGroup(450, 500);

ImageComparer comparer1 = new ImageComparer(images, group1, null);
ImageComparer comparer2 = new ImageComparer(images, group3, null);
...
ImageComparer comparer4 = new ImageComparer(images, group7, null);

// submit comparers to executor service
Future future1 = executor.submit(comparer1);
Future future2 = executor.submit(comparer2);
Future future3 = executor.submit(comparer3);
Future future4 = executor.submit(comparer4);

// wait for threads to finish
future1.get();
future2.get();
future3.get();
future4.get();

comparer1 = new ImageComparer(images, group2, null);
...
comparer4 = new ImageComparer(images, group8, null);

// submit to executor, wait to finish

comparer1 = new ImageComparer(images, group1, group3);
...
comparer4 = new ImageComparer(images, group7, group6);

// submit to executor, wait to finish

comparer1 = new ImageComparer(images, group1, group4);
...
comparer4 = new ImageComparer(images, group7, group5);