多线程（即基于线程池的）Java应用程序中的损坏结果

Question

我正在Java中尝试多线程，更具体地说是线程池。作为测试，我编写了一个应用程序，该应用程序使用多线程提高速度来简单地更改图像的颜色。但是，由于某种我不知道的原因，根据我如何设置此测试，我得到的结果是错误的。下面，我描述测试应用程序如何与完整的源代码一起工作。

任何帮助都非常欢迎！谢谢！

测试应用

我有一个用深蓝色初始化的400x300像素图像缓冲区，如下所示：

程序必须完全用红色填充它。

尽管我可以简单地遍历所有像素，并用红色依次为每个像素着色，但出于性能考虑，我还是决定利用并行性。因此，我决定用单独的线程填充每个图像行。由于行数（300行）比可用的CPU核心数大得多，因此我创建了一个线程池（包含4个线程），该线程池将消耗300个任务（每个任务负责填充一行）。

该计划的组织如下：

• RGB类：将像素颜色保留为三元组的两倍。
• RenderTask类：用红色填充图像缓冲区的给定行。
• 渲染器类：
  • 创建图像缓冲区。
  • 用“ newFixedThreadPool”创建线程池。
  • 创建300个线程池要使用的任务。
  • 完成线程池服务。
  • 将图像缓冲区写入PPM文件。

您可以在下面找到完整的源代码（我将将此代码称为Version 1）：

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.io.*;

class RGB {
    RGB() {}

    RGB(double r, double g, double b) {
        this.r = r;
        this.g = g;
        this.b = b;
    }

    double r;
    double g;
    double b;
}

class RenderTask implements Runnable {
    RenderTask(RGB[][] image_buffer, int row_width, int current_row) {
        this.image_buffer = image_buffer;       
        this.row_width = row_width;
        this.current_row = current_row; 
    }

    @Override
    public void run() {   
        for(int column = 0; column < row_width; ++column) {
            image_buffer[current_row][column] =  new RGB(1.0, 0.0, 0.0);
        }
    }

    RGB[][] image_buffer;
    int row_width;
    int current_row;
}

public class Renderer {
    public static void main(String[] str) {
        int image_width = 400;
        int image_height = 300;

        // Creates a 400x300 pixel image buffer, where each pixel is RGB triple of doubles,
        // and initializes the image buffer with a dark blue color.
        RGB[][] image_buffer = new RGB[image_height][image_width];
        for(int row = 0; row < image_height; ++row)
            for(int column = 0; column < image_width; ++column)
                image_buffer[row][column] = new RGB(0.0, 0.0, 0.2); // dark blue        

        // Creates a threadpool containing four threads
        ExecutorService executor_service = Executors.newFixedThreadPool(4);

        // Creates 300 tasks to be consumed by the threadpool:
        //     Each task will be in charge of filling one line of the image buffer.
        for(int row = 0; row < image_height; ++row)
            executor_service.submit(new RenderTask(image_buffer, image_width, row));

        executor_service.shutdown();

        // Saves the image buffer to a PPM file in ASCII format
        try (FileWriter fwriter = new FileWriter("image.ppm");
            BufferedWriter bwriter = new BufferedWriter(fwriter)) {

            bwriter.write("P3\n" + image_width + " " + image_height + "\n" + 255 + "\n");

            for(int row = 0; row < image_height; ++row)
                for(int column = 0; column < image_width; ++column) {
                    int r = (int) (image_buffer[row][column].r * 255.0);
                    int g = (int) (image_buffer[row][column].g * 255.0);
                    int b = (int) (image_buffer[row][column].b * 255.0);
                    bwriter.write(r + " " + g + " " + b + " ");
                }                
        } catch (IOException e) {
            System.err.format("IOException: %s%n", e);
        }
    }
}

一切似乎都在使用该代码，并且我得到了预期的红色图像缓冲区，如下所示：

问题

但是，如果我修改RenderTask.run（）方法，使得它顺序地多次重复设置相同缓冲区位置的颜色，如下所示（我将其称为Version 2）：

    @Override
    public void run() {   
        for(int column = 0; column < row_width; ++column) {
            for(int s = 0; s < 256; ++s) {

                image_buffer[current_row][column] =  new RGB(1.0, 0.0, 0.0);

            }
        }
    }

然后我得到以下损坏的图像缓冲区：

实际上，每次运行该程序的结果都是不同的，但总是会损坏。

据我了解，没有两个线程同时写入相同的内存位置，因此似乎看不到任何竞争情况。

即使在我不认为正在发生的“虚假共享”的情况下，我也希望只有较低的性能，而不会破坏结果。

因此，即使有多余的分配，我也希望能获得正确的结果（即完全红色的图像缓冲区）。

因此，我的问题是：如果与版本1唯一的不同是赋值操作在线程范围内冗余执行，那么为什么在程序的版本2中会发生这种情况？

某些线程在完成之前会被销毁吗？这会是JVM中的错误吗？还是我错过了一些琐碎的事情？（最强的假设：）

感谢大伙们！！

Answer 1

ExecutorService.shutdown（）不会等待其拥有的任务终止，它只会停止接受新任务。

调用shutdown后，如果要等待执行完成，则应在执行程序服务上调用awaitTermination。

因此，正在发生的事情是，当您开始将映像写入文件时，所有任务尚未完成执行。