2

我正在尝试 Java ForkJoin 框架并编写了一个简单的测试程序，将图像的像素设置为随机颜色。例如，它会产生伪噪声。

但是在测试性能时，我发现运行单线程实际上比使用多线程运行更快。我通过一个高阈值让它运行单线程。

这是阶级工人阶级：

public class Noise extends RecursiveAction {

    private BufferedImage image;
    private int xMin;
    private int yMin;
    private int xMax;
    private int yMax;
    private int threshold = 2000000; // max pixels per thread

    public Noise(BufferedImage image, int xMin, int yMin, int xMax, int yMax, int threshold) {
        this.image = image;
        this.xMin = xMin;
        this.yMin = yMin;
        this.xMax = xMax;
        this.yMax = yMax;
        this.threshold = threshold;
    }

    public Noise(BufferedImage image, int xMin, int yMin, int xMax, int yMax) {
        this.image = image;
        this.xMin = xMin;
        this.yMin = yMin;
        this.xMax = xMax;
        this.yMax = yMax;
    }

    @Override
    protected void compute() {
        int ppt = (xMax - xMin) * (yMax - yMin); // pixels pet thread
        if(ppt > threshold) {
            // split
            int verdeling = ((xMax - xMin) / 2) + xMin;
            invokeAll(new Noise(image, xMin, yMin, verdeling, yMax),
                    new Noise(image, verdeling+1, yMin, xMax, yMax));
        }
        else {
            // execute!
            computeDirectly(xMin, yMin, xMax, yMax);
        }
    }

    private void computeDirectly(int xMin, int yMin, int xMax, int yMax) {
        Random generator = new Random();
        for (int x = xMin; x < xMax; x++) {
            for (int y = yMin; y < yMax; y++) {
                //image.setPaint(new Color(generator.nextInt()));
                int rgb = generator.nextInt();
                int red = (rgb >> 16) & 0xFF;
                int green = (rgb >> 8) & 0xFF;
                int blue = rgb & 0xFF;

                red = (int) Math.round((Math.log(255L) / Math.log((double) red)) * 255);
                green = (int) Math.round((Math.log(255L) / Math.log((double) green)) * 255);
                blue = (int) Math.round((Math.log(255L) / Math.log((double) blue)) * 255);

                int rgbSat = red;
                rgbSat = (rgbSat << 8) + green;
                rgbSat = (rgbSat << 8) + blue;

                image.setRGB(x, y, rgbSat);
            }

        }
        Graphics2D g2D = image.createGraphics();
        g2D.setPaint(Color.RED);
        g2D.drawRect(xMin, yMin, xMax-xMin, yMax-yMin);
    }
}

生成 6000 * 6000 图像时，结果为：
单线程：9.4 秒 @ 25% CPU 负载
多线程：16.5 秒 @ 80%-90% CPU 负载
(Core2quad Q9450)

为什么多线程版本比较慢？
我该如何解决？

4

4 回答 4

2

首先，F/J是小众产品。如果您没有 HUGE 数组并将其作为 DAG 处理，那么您使用的是错误的产品。当然，F/J 可以使用多个处理器，但也可以只使用简单的多线程方法，而无需 F/J 的所有开销。

尝试使用四个线程，然后直接给每个线程四分之一的工作。

这就是 F/J 的使用方式：

Sum left  = new Sum(array, low, mid);
Sum right = new Sum(array, mid, high);
left.fork();
long rightAns = right.compute();
long leftAns   = left.join();
return leftAns + rightAns;

当你不走下结构化树的叶子时，所有的赌注都没有了。

于 2012-12-22T14:28:47.080 回答
2

我认为您发现的问题与您的代码直接无关，罪魁祸首是BufferedImage#setRGB()方法：

public synchronized void setRGB(int x, int y, int rgb) {...}

因此，由于对这种方法的争用，测试用例变得如此缓慢。

作为 JDK 8 中的一种解决方法，您可以使用类似的方法：

public void setRGB(int startX, int startY, int w, int h,
                   int[] rgbArray, int offset, int scansize) {...}

由于 JDK 10 这不再是问题，已删除同步关键字：https ://bugs.openjdk.java.net/browse/JDK-8183576

这是我的执行时间：

JDK 8 JDK 17
单线程 3 秒 3 秒
多线程 7 秒 1秒
于 2021-10-05T04:08:50.797 回答
1

我认为您想使用 ThreadLocalRandom 而不是 Random。

http://docs.oracle.com/javase/tutorial/essential/concurrency/threadlocalrandom.html

于 2013-04-10T17:47:54.647 回答
0

因为开销？分叉和连接也需要时间。也许您需要更大的测试集？或者在线程本身中做更多的工作？

于 2012-12-22T18:59:01.093 回答