Обработка изображений в многопоточном режиме с использованием Java

Question

Я должен обрабатывать изображения в многопоточном режиме с использованием Java. У меня может быть различное количество изображений, где количество моих потоков зафиксировано. Я должен обработать все изображения, используя фиксированный набор потоков.

Я просто застрял на том, как это сделать, я посмотрел ThreadExecutor, BlockingQueues и т. Д. ... Я до сих пор не ясно. Что я делаю, - Получите изображения и добавьте их в LinkedBlockingQueue, в котором есть исполняемый код процессора изображений. - Создайте threadpoolexecutor, для которого одним из аргументов является LinkedBlockingQueue ранее. - Выполните итерацию цикла for до размера очереди и выполните threadpoolexecutor.execute (connectedblockingqueue.poll). - все, что я вижу, это то, что он обрабатывает только 100 изображений, что является минимальным размером потока, передаваемого в размере LinkedBlockingQueue.

Я вижу, что где-то серьезно ошибаюсь в своем понимании. Как мне обработать все изображения в наборах по 100 (потоков), пока все они не будут завершены? Любые примеры или псевдокоды были бы очень полезны

Спасибо! J * +1007 *

Answer 1

Вот пример класса, который я написал.Все это работает автономно и печатает число от 1 до 100 каждый из ThreadPool.Практически все, что вам нужно сделать, это обновить класс 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 действительно хороши, поэтому я просто опубликую ссылку Определение и запуск темы

Цитата: Потоки иногда называют легкими процессами. И процессы, и потоки обеспечивают среду выполнения, но для создания нового потока требуется меньше ресурсов, чем для создания нового процесса. Внутри процесса существуют потоки - у каждого процесса есть хотя бы один. Потоки совместно используют ресурсы процесса, включая память и открытые файлы. Это обеспечивает эффективное, но потенциально проблематичное общение.

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