Grupo de Subprocesos Java con una Cola Delimitada

Question

Grupo de Subprocesos Java con una Cola Delimitada

Estoy usando java.util.concurrentExecutors clase para crear un grupo de subprocesos fijo para ejecutar controladores de solicitudes para un servidor web:

static ExecutorService  newFixedThreadPool(int nThreads)

Y la descripción es:

Crea un grupo de subprocesos que reutiliza un conjunto fijo de subprocesos que operan desde una cola compartida sin límites.

Sin embargo, estoy buscando una implementación de grupo de subprocesos que haga exactamente lo mismo, excepto con una cola limitada. ¿Existe tal implementación? O necesito ¿implementar mi propia envoltura para el grupo de subprocesos fijo?

28

java multithreading threadpool

Author: Amir Rachum, 2011-06-10

Source

4 answers

Cree un ThreadPoolExecutor y pase la implementación de BlockingQueue adecuada en él. por ejemplo, puede pasar un ArrayBlockingQueue en el constructor ThreadPoolExecutor para obtener el efecto deseado.

6

Author: Suraj Chandran,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2011-06-10 12:16:44

Cuando creas un ThreadPoolExecutor puedes darle un BlockingQueue acotado y un RejectedExecutionHandler para que puedas controlar lo que sucede cuando se alcanza el límite. El comportamiento predeterminado es lanzar una excepción RejectedExecutionException.

También puede definir su propia fábrica de subprocesos para controlar los nombres de subprocesos y convertirlos en subprocesos demonio.

3

Author: Peter Lawrey,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2011-06-10 12:13:51

He resuelto esto con un Semáforo que uso para acelerar las tareas que se envían a la ExecutorService.

Eg:

int threadCount = 10;
ExecutorService producerPool = Executors.newSingleThreadedExecutor();
ExecutorService consumerPool = Executors.newFixedThreadPool(threadCount);

// set the permit count greater than thread count so that we 
// build up a limited buffer of waiting consumers
Semaphore semaphore = new Semaphore(threadCount * 100); 

Runnable producer = () -> {
    for (int i = 0; i < 1000000; ++i) {
        semaphore.acquire();
        Runnable consumer = () -> {
           try {
              doSomeWork(i);
           } finally {
              semaphore.release();
           }
        };
        consumerPool.submit(consumer);
    }
}

Future<Void> future = producerPool.submit(producer);

// all consumers added to the pool when this returns
future.get();

producerPool.shutdown();
producerPool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
consumerPool.shutdown();

// all consumers finished when this returns
consumerPool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);

1

Author: lance-java,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2017-08-01 10:14:24

score 37 · Accepted Answer

Lo que quieres hacer es crear tu propio ExecutorService, probablemente usando ThreadPoolExecutor. ThreadPoolExecutor tiene un constructor que toma un BlockingQueue y para obtener una cola acotada se usa por ejemplo ArrayBlockingQueue correctamente construido para delimitar. También puede incluir un RejectedExecutionHandler para determinar qué hacer cuando su cola está llena, o aferrarse a una referencia a la cola de bloqueo y usar los métodos de oferta.

Aquí hay un mini ejemplo:

BlockingQueue<Runnable> linkedBlockingDeque = new LinkedBlockingDeque<Runnable>(
    100);
ExecutorService executorService = new ThreadPoolExecutor(1, 10, 30,
    TimeUnit.SECONDS, linkedBlockingDeque,
    new ThreadPoolExecutor.CallerRunsPolicy());