ScheduledExecutorService un thread di molte attività

Sono nuovo di ExecutorService e si chiedono il perché di codice riportato di seguito viene stampato correttamente “10 15”, anche se ho creato un solo thread per processo il timeout? Perché posso chiamare pianificazione molte volte senza precedenti compiti annullati su un singolo thread esecutore?

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


public class TestExecutorService implements Runnable {
    public static ScheduledExecutorService SERVICE = Executors.newSingleThreadScheduledExecutor();
    private int delay;


    public TestExecutorService(int delay) {
        this.delay = delay;
    }

    public void run () {
        System.out.println(delay);
    }

    public static void main (String[] args) {
        SERVICE.schedule(new TestExecutorService(10), 10, TimeUnit.SECONDS);
        SERVICE.schedule(new TestExecutorService(15), 15, TimeUnit.SECONDS);

        SERVICE.shutdown();
    }
}
un ulteriore leggere code.nomad-labs.com/2011/12/09/…

OriginaleL’autore Nikolay Kuznetsov | 2012-12-18

2 risposte

  1. 8

    Lettura del Javadoc sarebbe molto utile in questo caso. Spiega che se l’esecutore sarà creato con un unico filo conduttore, sarà operativo con un unbounded coda. Questo significa che è possibile inviare più attività all’esecutore e questi verranno messi in coda per eseguire uno dopo l’altro, fino al massimo dei limiti di coda (che in questo caso è infinito) o fino a quando la JVM esaurisce le risorse.

    Crea un Esecutore che utilizza un singolo thread di lavoro operativo-off di un
    sovrabbondanza di coda. (Nota però che, se questo singolo thread termina
    a causa di un errore durante l’esecuzione prima dell’arresto, uno nuovo
    prendere il suo posto, se necessario, ad eseguire le attività successive.) Le attività sono
    garantito per eseguire in sequenza, e non più di un compito
    attiva in un dato momento. A differenza degli equivalenti
    newFixedThreadPool(1) restituito esecutore è la garanzia di non essere
    riconfigurabili l’utilizzo di altri thread.

    Nel tuo esempio il due compiti ottenere in coda, ed eseguire in sequenza uno dopo l’altro, che è il motivo per cui si ottiene il (previsto) di uscita.

    quindi, se molti compiti con lo stesso ritardo presentati sono poi alcuni di loro sarebbe di stampa molto più tardi?
    Sì, supponendo che i compiti di prendere abbastanza a lungo per voi di preavviso.

    OriginaleL’autore Perception

  2. 8

    Dal Javadoc:

    Compiti sono garantiti per eseguire in sequenza, e non più di un compito sarà attiva in un dato momento.

    La differenza tra “elaborazione timeout” e “esecuzione di un task” è la chiave per la risposta. Si assume che “single-threaded” significa “l’elaborazione di un solo timeout in un tempo”, ma in realtà significa “eseguire un solo compito alla volta”. Tutti i timeout sono trattati simultaneamente, ma se uno viene raggiunto il timeout prima di un compito, interrompe l’esecuzione, si dovrà attendere per l’altro per finire prima dell’esecuzione.

    OriginaleL’autore Brian

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *