Come decidere se utilizzare newCachedThreadPool o newFixedThreadPool?

Question

Sto lavorando a un progetto in cui è necessario verificare che ogni thread funzioni su un determinato intervallo. Ad esempio:

NO_OF_THREADS: 2 
NO_OF_TASKS: 10 

Se number of threads is 2 e number of tasks is 10 poi ciascun filo si esibirà 10 tasks. Ciò significa che 2 thread eseguiranno 20 tasks.

Nello scenario attuale questi numeri (numero di attività e numero di thread) saranno molto alti in quanto entrambi sono configurabili nel mio codice.

Nell'esempio precedente, first thread dovrebbe usare id tra 1 and 10 e second thread dovrebbe usare id tra 11 and 20 ecc se qualsiasi più fili. E dopo che ogni thread farà una connessione al database e quindi inserirà nel database.

Quindi ho il mio codice qui sotto che funziona bene.

public static void main(String[] args) { 

    final int noOfThreads = 2; 
    final int noOfTasks = 10; 

    //create thread pool with given size 
    ExecutorService service = Executors.newFixedThreadPool(noOfThreads); 

    // queue some tasks 
    for (int i = 0, int nextId = 1; i < noOfThreads; i++, nextId += noOfTasks) { 
     service.submit(new ThreadTask(nextId, noOfTasks)); 
    } 
} 

class ThreadTask implements Runnable { 
    private final int id; 
    private int noOfTasks; 

    public ThreadTask(int nextId, int noOfTasks) { 
     this.id = nextId; 
     this.noOfTasks = noOfTasks; 
    } 

    public void run() { 

    //make a database connection 

     for (int i = id; i < id + noOfTasks; i++) { 

     //insert into database 
     } 
    } 
} 

La mia domanda: -

stavo attraversando vari articolo su internet e ho letto su newCachedThreadPool. Così ora mi chiedo è - Dovrei usare newFixedThreadPool o newCachedThreadPool nel mio codice? Come al momento sto usando nexFixedThreadPool. Non sono in grado di decidere su quali fattori scegliere newCachedThreadPool o newFixedThreadPool. Questa è la ragione per cui ho postato il mio scenario su ciò che sto per fare con il mio codice.

Qualcuno può darmi una mano che cosa dovrei scegliere qui? E per favore spiegami in dettaglio perché lo stiamo scegliendo su quali fattori in modo che io possa capirlo molto bene. Ho già utilizzato i documenti java ma non sono in grado di decidere cosa scegliere qui.

Grazie per l'aiuto.

Answer 1

Così ora mi chiedo è - Devo utilizzare newFixedThreadPool o newCachedThreadPool nel mio codice?

Per citare dal Javadocs, il newFixedThreadPool():

di creare un pool di thread che riutilizza un numero fisso di thread ...

Questo significa che se si chiede per 2 filetti , inizia 2 thread e non inizia mai 3. D'altra parte, lo newCachedThreadPool():

Crea una minaccia d pool che crea nuovi thread in base alle esigenze, ma riutilizzerà i thread creati in precedenza quando sono disponibili.

Nel vostro caso, se avete solo 2 thread da eseguire, o funzionerà bene poiché invierete solo 2 lavori alla vostra piscina. Tuttavia, se si desidera inviare tutti i 20 lavori contemporaneamente ma solo due processi in esecuzione contemporaneamente, è necessario utilizzare uno newFixedThreadPool(2). Se si è utilizzato un pool memorizzato nella cache, ciascuno dei 20 lavori avvia un thread che verrà eseguito nello stesso momento, il che potrebbe non essere ottimale a seconda del numero di CPU in uso.

In genere utilizzo newCachedThreadPool() quando I è necessario il thread da generare immediatamente, anche se tutti i thread attualmente in esecuzione sono occupati. L'ho usato di recente quando stavo deponendo le attività del timer. Il numero di lavori simultanei è irrilevante perché non ne ho mai generati molti ma voglio che vengano eseguiti quando sono richiesti e voglio che riutilizzino i thread dormienti.

Ho utilizzato newFixedThreadPool() quando si desidera limitare il numero di attività simultanee in esecuzione in un punto qualsiasi per ottimizzare le prestazioni e non inondare il mio server. Ad esempio, se sto elaborando 100k linee da un file, una riga alla volta, non voglio che ogni riga inizi un nuovo thread ma voglio un certo livello di concorrenza in modo da allocare (ad esempio) 10 thread fissi per eseguire il attività fino a quando il pool è esaurito.