hilos - scheduledexecutorservice java 8

ExecutorService vs Casual Thread Spawner

Question

Tengo una pregunta básica sobre cómo funciona ExecutorService en Java.

Es bastante difícil ver la diferencia entre simplemente crear Threads para realizar algunas tareas en paralelo y asignar cada tarea al ThreadPool .

El Servicio de ExecutorService también se ve muy simple y eficiente de usar, así que me preguntaba por qué no lo usamos todo el tiempo.

¿Es solo una forma de ejecutar su trabajo más rápido que la otra?

Aquí hay dos ejemplos muy simples para mostrar la diferencia entre las dos formas:

Utilizando el servicio ejecutor: Hello World (tarea)

static class HelloTask implements Runnable {
    String msg;

    public HelloTask(String msg) {
        this.msg = msg; 
    }
    public void run() {
        long id = Thread.currentThread().getId();
        System.out.println(msg + " from thread:" + id);
    }
}

Utilizando el servicio ejecutor: Hello World (creando ejecutor, enviando)

static class HelloTask {
    public static void main(String[] args) {
        int ntasks = 1000;
        ExecutorService exs = Executors.newFixedThreadPool(4);

        for (int i=0; i<ntasks; i++) { 
            HelloTask t = new HelloTask("Hello from task " + i);    
            exs.submit(t);
        }
        exs.shutdown();
    }
}

A continuación se muestra un ejemplo similar pero extendiendo la interfaz invocable, ¿podría decirme la diferencia entre los dos y en qué casos uno debería usar uno específico en lugar del otro?

Utilizando el servicio ejecutor: Contador (tarea)

static class HelloTaskRet implements Callable<Long> {
    String msg;

    public HelloTaskRet(String msg) {
        this.msg = msg; }

        public Long call() {
        long tid = Thread.currentThread().getId(); 
        System.out.println(msg + " from thread:" + tid); 
        return tid;
    } 
}

Utilizando el servicio ejecutor: (creando, enviando)

static class HelloTaskRet {
    public static void main(String[] args) {
        int ntasks = 1000;
        ExecutorService exs = Executors.newFixedThreadPool(4);

        Future<Long>[] futures = (Future<Long>[]) new Future[ntasks];

        for (int i=0; i<ntasks; i++) { 
            HelloTaskRet t = new HelloTaskRet("Hello from task " + i);
            futures[i] = exs.submit(t);
        }
        exs.shutdown();
    }
}

Answer 1

Mientras que la pregunta y el código de ejemplo no se correlacionan, intentaré aclarar ambos. La ventaja de ExecutorService sobre los subprocesos aleatorios es que se comporta de manera predecible y evita la sobrecarga de creación de subprocesos, que es relativamente grande en la JVM (por ejemplo, debe reservar memoria para cada subproceso). Por previsibilidad, al menos para el fixedThreadPool , me refiero a que conoce el número máximo de subprocesos simultáneos y sabe cuándo y cómo podrían crearse (por lo que su JVM no explotará en caso de picos repentinos).

Por Vince Emigh: ExecutorService también admite cachedThreadPool , que no tiene un máximo. La razón principal por la que la gente elige usar ExecutorService es para evitar la sobrecarga de crear múltiples subprocesos (mediante el uso de subprocesos de trabajo ). Se utiliza principalmente en los casos en que se deben ejecutar muchas tareas pequeñas en un hilo separado. Además, no te olvides de singleThreadExecutor .

Ahora, en el tema de Runnable vs Callable , es fácil de ver en sus ejemplos. Callable pueden devolver un valor de Callable posición ( Future ) que eventualmente se completará con un valor real en el futuro. Runnable s no puede devolver nada.

Por Vince Emigh: Runnable tampoco puede lanzar excepciones, mientras que Callable puede.

Answer 2

ExecutorService ofrece muchas ventajas en comparación con subprocesos simples

1. Puede crear / administrar / controlar el ciclo de vida de los subprocesos y optimizar los gastos generales de creación de subprocesos
2. Puede controlar el procesamiento de tareas (Work Stealing, ForkJoinPool, invokeAll) etc.
3. Puedes programar tareas en tiempo futuro
4. Puedes monitorear el progreso y la salud de los hilos.

Incluso para un solo subproceso, prefiero usar Executors.newFixedThreadPool(1);

Echa un vistazo a las preguntas relacionadas con la SE:

Java Fork / Join vs ExecutorService: ¿cuándo usar cuál?

¿Cuáles son las ventajas de usar un ExecutorService?