Los ejecutores de Java no encolan alguna tarea.

Answer

1. 

   davy.ai

   July 12, 2023 at 2:36 pm

   Para este requisito específico, la implementación estándar del ThreadPoolExecutor puede no ser suficiente. Sin embargo, es posible crear una implementación personalizada mediante la extensión de la clase ThreadPoolExecutor y la anulación del método execute() para especificar el comportamiento deseado.

   En primer lugar, los hilos principales pueden ser utilizados por defecto utilizando el método super.execute(). Si los hilos principales están en uso, la tarea puede ser colocada en la cola de bloqueo utilizando el método offer(). Si la cola está llena, se puede crear un nuevo hilo utilizando de nuevo el método super.execute().

   Para implementar la segunda parte del requisito, se puede utilizar un contador para realizar un seguimiento del número de hilos en ejecución. Cuando el contador es igual o superior a máximoTamañoDelPool, las tareas pueden ser colocadas en la cola utilizando el método put(). Si no, se puede crear un nuevo hilo utilizando el método super.execute().

   Aquí hay un ejemplo de implementación:

   public class CustomThreadPoolExecutor extends ThreadPoolExecutor {
   
       private AtomicLong threadsCount = new AtomicLong(0);
       private int maxSize = Integer.MAX_VALUE;
       private BlockingQueue<runnable> customQueue;
   
       public CustomThreadPoolExecutor(int corePoolSize, int maxPoolSize, BlockingQueue<runnable> queue) {
           super(corePoolSize, maxPoolSize, 0L, TimeUnit.MILLISECONDS, queue);
           this.customQueue = queue;
           this.maxSize = maxPoolSize;
       }
   
       @Override
       public void execute(Runnable task) {
           if (threadsCount.get() < getCorePoolSize()) {
               super.execute(task);
               threadsCount.incrementAndGet();
           } else if (!customQueue.offer(task)) {
               if (threadsCount.get() < maxSize) {
                   super.execute(task);
                   threadsCount.incrementAndGet();
               } else {
                   try {
                       customQueue.put(task);
                   } catch (InterruptedException e) {
                       Thread.currentThread().interrupt();
                   }
               }
           }
       }
   
       @Override
       protected void afterExecute(Runnable r, Throwable t) {
           super.afterExecute(r, t);
           threadsCount.decrementAndGet();
       }
   }
   

   En esta implementación, una variable AtomicLong se utiliza para llevar un seguimiento del número de hilos en ejecución. También se especifica el número máximo de hilos. Si el número de hilos en ejecución es inferior al tamaño del grupo principal, la tarea se puede ejecutar utilizando el método super.execute(). De lo contrario, la tarea se ofrece a la cola de bloqueo. Si el método offer() devuelve false, se verifica el número de hilos en ejecución. Si es menor que el tamaño máximo del grupo, se crea un nuevo hilo utilizando el método super.execute(). Si se alcanza el tamaño máximo del grupo, la tarea se coloca en la cola utilizando el método put().

   El método afterExecute() se anula para disminuir la variable threadsCount cuando una tarea se completa.

   En general, esta implementación personalizada debería cumplir con los requisitos especificados en la pregunta.

Comments are closed.