hilos - thread java 8

Grupo de subprocesos de Java con una cola limitada

Question

Estoy usando la clase Executors java.util.concurrent para crear un grupo de subprocesos fijos para ejecutar los manejadores 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 en una cola compartida ilimitada .

Sin embargo, estoy buscando la implementación del grupo de subprocesos que hará exactamente lo mismo, excepto con una cola limitada . ¿Existe tal implementación? ¿O necesito implementar mi propio contenedor para el grupo de subprocesos fijos?

Answer 1

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

Answer 2

Cuando creas un ThreadPoolExecutor, puedes asignarle un BlockingQueue limitado 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 hilos para controlar los nombres de los hilos y convertirlos en hilos de demonio.

Answer 3

Lo que quieres hacer es ThreadPoolExecutor tu propio ExecutorService, probablemente usando ThreadPoolExecutor . ThreadPoolExecutor tiene un constructor que toma un BlockingQueue y para obtener una cola delimitada que usas, por ejemplo, ArrayBlockingQueue se construyó correctamente para delimitar. También puede incluir un RejectedExecutionHandler para determinar qué hacer cuando su cola está llena, o quedarse en 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());

Answer 4

Resolví esto con un Semaphore que utilizo para acelerar las tareas que se envían al Servicio de ExecutorService .

P.ej:

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);