Question

对于学校项目，我们需要对图像处理算法进行多线程处理。我决定将图像的高度除以线程数。每个线程都会在高度和宽度之间循环，并更改像素的颜色。奇怪的是，顺序版本总是快得多。我在做什么错了？

线程执行的方法：

<script type="text/javascript">
function ShowSelected()
{

var cod = document.getElementById("serv").value;



var combo = document.getElementById("serv");
var selected = combo.options[combo.selectedIndex].text;


document.getElementById("serv2").value=selected;
}
</script>

运行程序的代码：

public synchronized void applyGrayScale(int numberOfThreads) {
    int heightPerThread = imageHeight / numberOfThreads;
    //Set the thread counter
    int threadCounter = this.getCount();
    this.setCount(count + 1);

    /*The height per thread is calculated by the number of threads. We first start at 0. For the next thread we start at heightPerThread * [current thread number]
    So for example; first thread runs from 0 to 80 pixels. The second thread runs from 81 to 160 pixels.
     */
    for (int j = ((heightPerThread - 2) * threadCounter); j < (heightPerThread * (threadCounter + 1) - 1); j++) {
        for (int i = 0; i < imageInput.getWidth() - 1; i++) {
            //Get the RGB value and set it to grayscale
            int rgb;
            int p = RGB.getRGBW(imageInput, i, j);
            rgb = (int) ((((p >> 16) & 0xFF) * 0.2125) + (((p >> 8) & 0xFF) * 0.7154) + ((p & 0xFF) * 0.0721));
            rgb = (rgb << 16) | (rgb << 8) | (rgb);
            //Set the new RGB value per pixel
            imageOutput.setRGB(i, j, rgb);
        }
    }
}

输出为：平行0.897秒连续0.798秒

顺序算法：

   int threadsAmount = 5;
   final Thread[] threads = new Thread[threadsAmount];

   BufferedImage image = null;
    try {
        image = ImageIO.read(new File("C:/Cat03.jpg"));
    } catch (IOException e) {
        e.printStackTrace();
    }

    //Define the starting time
    long start = System.currentTimeMillis();

    //Create a new grayscale object and set the image
    final GrayscaleParallel grayscaleParallel = new GrayscaleParallel(image);

    //Thread to apply the grayscale with the number of threads
    class grayScaleThread extends Thread {
        @Override
        public void run() {
            grayscaleParallel.applyGrayScale(threadsAmount);
        }
    }

    //Start all threads
    for (int i = 0; i < threadsAmount; i++) {
        threads[i] = new grayScaleThread();
        threads[i].start();
    }

    //Wait for all threads to finish
    for (int i = 0; i < threadsAmount; i++) {
        try {
            threads[i].join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //save result to file
    grayscaleParallel.createImage();

    //Define how long it took
    long end = System.currentTimeMillis();
    float sec = (end - start) / 1000F;
    System.out.println(sec + " seconds parallel");

当我使用非常大的图像时，并行时间似乎比顺序图像改善了0.5秒，但是当我不保存结果时，并行算法又变慢了。

Answer 1

问题在于您的applyGrayScale()方法是synchronized-当所有线程都在同一对象上运行时，只有一个线程可以同时执行它。您的代码中没有任何部分可以并行运行。因此，基本上该过程与顺序变体大致相同，但是您为上下文切换和跟踪哪个线程进入该方法添加了一些额外的开销。

相反，您必须先将图像拆分-创建线程“告诉”它们应该修改的部分。然后将方法从synchronized更改为普通方法，让他们并行完成工作。

Answer 2

您没有做错任何事！

转换图像的瓶颈不是计算，而是内存访问。

使用一个线程（=顺序），您可以按顺序访问内存。计算机针对此类顺序访问进行了优化。例如。通过访问地址（内存总线比32或64位宽得多）预加载下一个内存地址，而且CPU的缓存可以预测顺序访问，因为它们在编程中很常见。

由于您所做的计算非常简单，因此算法最慢的部分是从RAM中读取数据或将数据写入RAM。如果使用多个线程并以不同的地址（非顺序地址）访问内存，则会遇到很多缓存丢失，并且无法从CPU /内存总线完成的缓存和预加载中受益。这就是性能比代码的顺序版本差的原因。

（在多线程版本中同时读取/写入不同线程可能还会有一些开销，这可能会进一步降低性能）

如评论中所述：

正如 Amongalen 所指出的那样（请参阅评论/答案），除了我上面提到的事情之外，还有另一个很简单的原因，那就是在您的实现中不能进行任何并行执行。

applyGrayScale()是synchronized，因此不能在同一类实例上并行调用。因此，如果您所有的线程共享它们调用applyGrayScale()的相同实例，那么当一个人执行该方法时，所有其他线程都将死机。

但是我敢肯定，即使在解决了这个问题之后，由于我上面在回答中提到的原因，多线程版本仍会比顺序版本慢。

多线程时灰度图像算法比顺序算法慢

2 个答案: