Java：為什么/這些線程監控的是什么？

Question

我有一個多線程Java應用程序，它將圖像分成4個塊，然后4個線程（我有一個四核CPU），每個線程在圖像的單個塊上工作，將其轉換為灰度。

我發現由於某些原因它很慢，所以我使用NetBeans探查器發現線程正在“監視”（等待）相當多。 例如，

（綠色=跑步，紅色=監控）

我嘗試了不同數量的線程，例如2，並且發現這仍然發生（唯一沒有發生的是1個線程）。

在線程內部，我注釋掉了他們的代碼，直到我將“大延遲”縮小到這個語句：

newImage.setRGB(i,j,newColor.getRGB()); // Write the new value for that pixel

如果這被注釋掉，那么代碼運行得更快（差不多5倍），並且沒有線程監控：

那么為什么這一行導致如此多的延遲呢？ 它是Color庫（和BufferedImage一起）嗎？ 現在，我將嘗試獲取一組int作為RGB值，而不是使用Color對象，看看它是怎么回事。

這是源代碼：

PixelsManipulation.java（主類）：

public final class PixelsManipulation{

private static Sequential sequentialGrayscaler = new Sequential();  

public static void main(String[] args) throws FileNotFoundException, IOException, InterruptedException {  

    File file = new File("src/pixelsmanipulation/hiresimage.jpg");
    FileInputStream fis = new FileInputStream(file);  
    BufferedImage image = ImageIO.read(fis); //reading the image file  

    int rows = 2; // 2 rows and 2 cols will split the image into quarters
    int cols = 2;  
    int chunks = rows * cols; // 4 chunks, one for each quarter of the image  
    int chunkWidth = image.getWidth() / cols; // determines the chunk width and height  
    int chunkHeight = image.getHeight() / rows;  
    int count = 0;  
    BufferedImage imgs[] = new BufferedImage[chunks]; // Array to hold image chunks  

    for (int x = 0; x < rows; x++) {  
        for (int y = 0; y < cols; y++) {  
            //Initialize the image array with image chunks  
            imgs[count] = new BufferedImage(chunkWidth, chunkHeight, image.getType());  
            // draws the image chunk  

            Graphics2D gr = imgs[count++].createGraphics(); // Actually create an image for us to use
            gr.drawImage(image, 0, 0, chunkWidth, chunkHeight, chunkWidth * y, chunkHeight * x, chunkWidth * y + chunkWidth, chunkHeight * x + chunkHeight, null);  
            gr.dispose();

        }  
    } 

    //writing mini images into image files  
    for (int i = 0; i < imgs.length; i++) {  
        ImageIO.write(imgs[i], "jpg", new File("img" + i + ".jpg"));  
    }  
    System.out.println("Mini images created");  

    // Start threads with their respective quarters (chunks) of the image to work on
    // I have a quad-core machine, so I can only use 4 threads on my CPU
    Parallel parallelGrayscaler = new Parallel("thread-1", imgs[0]);
    Parallel parallelGrayscaler2 = new Parallel("thread-2", imgs[1]);
    Parallel parallelGrayscaler3 = new Parallel("thread-3", imgs[2]);
    Parallel parallelGrayscaler4 = new Parallel("thread-4", imgs[3]);

    // Sequential:
    long startTime = System.currentTimeMillis();

    sequentialGrayscaler.ConvertToGrayscale(image);

    long stopTime = System.currentTimeMillis();
    long elapsedTime = stopTime - startTime;
    System.out.println("Sequential code executed in " + elapsedTime + " ms.");

    // Multithreaded (parallel):
    startTime = System.currentTimeMillis();

    parallelGrayscaler.start();
    parallelGrayscaler2.start();
    parallelGrayscaler3.start();
    parallelGrayscaler4.start();

    // Main waits for threads to finish so that the program doesn't "end" (i.e. stop measuring time) before the threads finish
    parallelGrayscaler.join();
    parallelGrayscaler2.join();
    parallelGrayscaler3.join();
    parallelGrayscaler4.join();

    stopTime = System.currentTimeMillis();
    elapsedTime = stopTime - startTime;
    System.out.println("Multithreaded (parallel) code executed in " + elapsedTime + " ms.");
}
}

Parallel.java：

// Let each of the 4 threads work on a different quarter of the image
public class Parallel extends Thread{//implements Runnable{

private String threadName;
private static BufferedImage myImage; // Calling it "my" image because each thread will have its own unique quarter of the image to work on
private static int width, height; // Image params

Parallel(String name, BufferedImage image){
    threadName = name;
    System.out.println("Creating "+ threadName);
    myImage = image;
    width = myImage.getWidth();
    height = myImage.getHeight();

}

public void run(){
    System.out.println("Running " + threadName);

    // Pixel by pixel (for our quarter of the image)
    for (int j = 0; j < height; j++){
        for (int i = 0; i < width; i++){

            // Traversing the image and converting the RGB values (doing the same thing as the sequential code but on a smaller scale)
            Color c = new Color(myImage.getRGB(i,j));

            int red = (int)(c.getRed() * 0.299);
            int green = (int)(c.getGreen() * 0.587);
            int blue  = (int)(c.getBlue() * 0.114);

            Color newColor = new Color(red + green + blue, red + green + blue, red + green + blue);

            myImage.setRGB(i,j,newColor.getRGB()); // Write the new value for that pixel


        }
    }

    File output = new File("src/pixelsmanipulation/"+threadName+"grayscale.jpg"); // Put it in a "lower level" folder so we can see it in the project view
    try {
        ImageIO.write(newImage, "jpg", output);
    } catch (IOException ex) {
        Logger.getLogger(Parallel.class.getName()).log(Level.SEVERE, null, ex);
    }
    System.out.println("Thread " + threadName + " exiting. ---");
}
}

我是Java中的線程初學者（以及使用BufferedImage），只是好奇它為什么這么慢。

Answer 1

為什么Parallel.myImage是靜態的？ 這將導致所有線程共享相同的圖像。 這也許可以解釋為什么他們互相等待。