使用 Java 以多线程模式处理图像

Question

我应该使用 Java 以多线程模式处理图像。我可能有不同数量的图像，因为我的线程数是固定的。我必须使用固定的线程集处理所有图像。

我只是不知道该怎么做，我看了一下 ThreadExecutor 和 BlockingQueues 等......我仍然不清楚。我正在做的是， - 获取图像并将它们添加到具有图像处理器可运行代码的 LinkedBlockingQueue 中。 - 创建一个线程池执行器，其中一个争论是之前的 LinkedBlockingQueue。 - 遍历 for 循环直到队列大小并执行 threadpoolexecutor.execute(linkedblockingqueue.poll)。 - 我所看到的是它只处理 100 个图像，这是在 LinkedBlockingQueue 大小中传递的最小线程大小。

我发现我在某处的理解严重错误，我如何处理 100 个（线程）中的所有图像，直到它们全部完成？任何示例或伪代码都会非常有帮助

谢谢！ J

Answer 1

这是我编写的示例类。整个过程独立运行，并从 ThreadPool 中打印一个从 1 到 100 的数字。您几乎需要做的就是更新 Request 类以传递您想要的内容并重新实现 ImageProcessor。

package com.rch.test;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class Executor
{
    /**
     * Class to encapsulate a request
     * 
     * @author romain
     */
    static class Request
    {
        String someText;

        Request(String someText)
        {
            this.someText = someText;
        }

        public String getSomeText()
        {
            return someText;
        }
    }

    /**
     * Creates a Thread that listens on a queue to process messages
     * 
     * @author romain
     */
    static class ServerThread implements Runnable
    {
        private BlockingQueue<Request> queue = new LinkedBlockingQueue<Request>();
        boolean stop = false;

        /**
         * Does all the work
         */
        @Override
        public void run()
        {
            ExecutorService pool = Executors.newFixedThreadPool(3);
            try
            {
                while (!stop)
                {
                    Request req = queue.poll(1000L, TimeUnit.MILLISECONDS);
                    if (req != null)
                    {
                        Runnable runnable = new Executor.ImageProcessor(req);
                        pool.execute(runnable);
                    }
                }
            }
            catch (InterruptedException ie)
            {
                System.out.println("Log something here");
            }
            finally
            {
                pool.shutdown();
            }
        }

        /**
         * Accepts a message on the queue
         * @param request
         */
        public void accept(Request request)
        {
            queue.add(request);
        }

        public void stopProcessing()
        {
            stop = true;
        }
    }

    /**
     * class to do the actual work
     * @author romain
     */
    static class ImageProcessor implements Runnable
    {
        String someText;

        ImageProcessor(Request req)
        {
            this.someText = req.getSomeText();
        }

        @Override
        public void run()
        {
            System.out.println(someText);
            // Process Image here
        }
    }

    /**
     * Test Harness
     * @param args
     */
    public static void main(String[] args)
    {
        // Initialize 
        ServerThread processor = new ServerThread();
        Thread aThread = new Thread(processor);
        aThread.start();

        // Wait for Thread to start
        try
        {
            Thread.sleep(500L);
        }
        catch (InterruptedException e1)
        {
            e1.printStackTrace();
        }

        for (int i = 0; i < 100; i++)
        {
            String text = "" + i;
            Request aRequest = new Request(text);
            processor.accept(aRequest);
        }

        // Give it enough time to finish
        try
        {
            Thread.sleep(500L);
        }
        catch (InterruptedException e1)
        {
            e1.printStackTrace();
        }

        // Tell the thread to finish processing
        processor.stopProcessing();

        // Wait for the Thread to complete
        try
        {
            aThread.join();
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

Answer 2

您可以将每个处理操作视为一个“任务”。将这些任务放在一个队列中，并让每个线程在每次完成任务时都使用该线程中的一个任务。

Answer 3

Sun 的教程真的很好，所以我将链接发布Defining and Starting a Thread

引用： 线程有时被称为轻量级进程。进程和线程都提供了一个执行环境，但是创建一个新线程比创建一个新进程需要更少的资源。 线程存在于进程中——每个进程至少有一个。线程共享进程的资源，包括内存和打开的文件。这有助于高效但可能存在问题的沟通。

while(que is not empty)
  start new set of image-processing-thread