-1

我需要从服务器检索一张巨大的图片，但服务器不能这样做，因为图片太大了。我可以给出“坐标”，以便检索那张图片的一小部分。因此，我将图片分成 100 个图块，然后将 10 个图块附加到一行，然后附加每一行。当我按顺序执行时，效果很好。现在我下载 10 个图块 -> 将它们附加到一行 -> 下载接下来的 10 个图块 -> 将它们附加到一行 -> 将第二行附加到第一个 -> 下载接下来的 10 个图块等（简化）：

public static void downloadWholeImage(){
   int xcoord=0;
   int ycoord=0;
   //outer loop for each row
   for(int i = 0; i<10; i++){
      //all tiles of a row are stored here
      BufferedImage[] tilesForRow = new BufferedImage[10];
      //inner loop for each tile of a row
      for(int j = 0; j<10; j++){
         //downloads the image
         BufferedImage tile = downloadImage(xcoord,ycoord);
         //removes all black pixels of the image
         BufferedImage[j] = removeBlackColor(tile);
         //increments xcoord so the next tile
         xcoord++;
      }
      //each row gets appended on top of the first row
      if(i==0){
         BufferedImage firstRow = appendTilesToRow(tilesForRow)
      } else{
         BufferedImage actualRow = appendTilesToRow(tilesForRow)
      }

      firstRow = appendActualToFirst(firstRow, actualRow); 
      //incrementing ycoord for next tile
      ycoord++;
   }
   writeImage(path,firstRow);
}

但是由于这些行非常大，因此将它们相互附加需要很长时间。当它们被附加时，我认为我可以创建一个下载其他图块的线程。这就是问题所在。我不习惯同时编程。我知道它在技术上是如何完成的（实现 Runnable 等），但我应该如何设计它？我有在另一个线程中运行的想法，downloadImage(xcoord, ycoord)但这导致了将removeBlackColor(tile). 还是在线程中或线程完成后？..谁应该等待什么（加入）？我希望它没有那么混乱。如果您在某处需要更多说明，请告诉我。

4

4 回答 4

2

你可以这样做：为每个下载操作创建一个新线程，下载发生在 run() 方法中。然后每个线程使用 join() 等待下一次下载完成并附加图块。

可以使用类似的方法来下载和附加每一行。

public class Download extends Thread {
    public static void main(String[] args) throws InterruptedException {
        Download[] download = new Download[10];
        for (int i = 0; i < 10; i++) {
            download[i] = (new Download(i));
            download[i].start();
        }
        for(int i = 0; i < 10; i++) {
            (download[i]).join();
            append(i);
        }
    }
    int val;
    Download(int val) {
        this.val = val;
    }
    @Override
    public void run() {
            System.out.println("Downloading tile " + val);
    }

编辑

如果您更喜欢实现 Runnable，则语法如下

public class Download implements Runnable {
...
        Thread[] download = new Thread[10];
        for (int i = 0; i < 10; i++) {
            download[i] = new Thread(new Download(i));

这与第一个示例的工作方式完全相同，因此选择扩展 Thread 或实现 Runnable 是个人喜好问题。

于 2015-03-03T12:40:09.443 回答
1

在我看来，您仍然需要按顺序下载行，并在每行内确保下载所有 10 个图块，然后再移动到下一行。

看一下java.util.concurrent包，特别是CountDownLatch.

这是一个代码片段。注意：它可能无法编译正确，但给出了一个想法。

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

    CountDownLatch countLatch = new CountDownLatch(10);
    ExecutorService threadPool = Executors.newFixedThreadPool(10);
    ArrayList<SampleImageDownload> list = new ArrayList<SampleImageDownload>();
    int row =1;

    while (row <=10) {
        int tileno = 1;
        while(tileno <=10) {
         SampleImageDownload sample = new SampleImageDownload(countLatch, tileno);
         list.add(sample);
         threadPool.submit(sample); 
         tileno++;

        } 
            row++;
            countLatch.await(); // wait for all 10 tiles to download.
        //apendline
    }




}


class SampleImageDownload implements Runnable {

    int tileno;
    private CountDownLatch countLatch = null;
    BufferedImage tile = null;


    public SampleImageDownload(CountDownLatch countLatch, int tileno) {
        super();
        this.countLatch = countLatch;
        this.tileno = tileno;
    }


    @Override
    public void run() {

        // download and removeBlacktile
        // tile is ready
        countLatch.countDown();

    }

}
于 2015-03-03T13:01:00.850 回答
1

看起来您想要异步下载其他图块，而您的图块正在附加。

为此，您的答案似乎可以在这里找到： 如何实现真正的异步 java 线程

注意：您无需等待。只需让一个进程完成异步，而另一个进程正在运行。

编辑：您还可以使用同步块来定义，每次成功下载后，都应该执行特定的附加。

于 2015-03-03T12:12:09.837 回答
0

一种可能性是创建将运行 N 个下载线程的主线程。每个下载线程都会从服务器获取图块，然后它可以将大图片的片段与图块交换。至于交换它可能可以由许多线程同时完成，只要每个线程都在大图的自己的部分上操作，这样它们就不会“冲突”。想象一个数组，其中一个线程使用索引 0 到 X，另一个线程使用索引 X+1 到数组末尾。要使其工作，您必须事先知道大图的大小并对其进行初始化。但我认为你已经这样做了。主线程将等待所有小线程结束，这意味着工作已完成。

于 2015-03-03T12:18:41.437 回答