算法优化 - 并行 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。 ->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);