Executor service in java -> come convertire il codice single thread per utilizzare executor

Question

Perdonami se la domanda sembra sciocca - Sto solo iniziando a usare Executor.

Ho un app java esistente che utilizza i thread in questo manner-- fondamentalmente le discussioni standalone sono used--

private Thread spawnThread() 
    { 

     Thread t = new Thread() 
     { 
      String taskSnap = task.toString(); 
      public void run() 
      { 
       try 
       { 
        println(task.run(null)); 
       }catch(InterruptedException e) 
       { 
        println("ITC - " + taskSnap + " interrupted "); 
       } 
      } 
     }; 
     return t; 
    } 

Come si può vedere da sopra, la funzione restituisce un nuovo thread.

Ora nella funzione main() del programma, un nuovo thread viene creato in questo manner--

taskThread = spawnThread(); 

    taskThread.start(); 

Quello che voglio fare è, creare un servizio di esecutore (con il numero fisso di thread) -> e quindi passare la creazione di nuovo thread/esecuzione di attività dal nuovo thread a quell'esecutore.

Dato che sono molto nuovo per Executor, quello che desidero sapere è, come cambio il codice precedente in modo che invece di un nuovo thread separato venga creato, un nuovo thread viene invece creato all'interno del pool di thread. Non riesco a visualizzare alcun comando per creare un thread (all'interno del pool di thread) -> distribuisci l'attività precedente su quel thread (e non su un thread autonomo come sopra).

Per favore fatemi sapere come risolvere questo problema.

Answer 1

Nel vostro principale, è possibile scrivere qualcosa del genere:

ExecutorService executor = Executors.newFixedThreadPool(nThreads); 
executor.submit(new Runnable() { 
    String taskSnap = task.toString(); 
    public void run() { 
      try { 
       println(task.run(null)); 
      } catch(InterruptedException e) { 
       println("ITC - " + taskSnap + " interrupted "); 
      } 
    } 
}); 

Il metodo di invio eseguirà il Runnable su uno dei fili all'interno del servizio esecutore.

Nota: non dimenticare di arrestare il servizio executor quando non è più necessario o impedirà l'uscita del programma.

Answer 2

Fai la tua ricerca prima di chiedere. L'idea è di creare una classe che implementa Runnable ed eseguirla usando il servizio executor.

Esempio da: Java Concurrency (Multithreading) - Tutorial

Attuazione del lavoratore (che implementa Runnable):

package de.vogella.concurrency.threadpools; 

/** * MyRunnable will count the sum of the number from 1 to the parameter * countUntil and then write the result to the console. * <p> * MyRunnable is the task which will be performed * * @author Lars Vogel * */ 

public class MyRunnable implements Runnable { 
    private final long countUntil; 

    MyRunnable(long countUntil) { 
    this.countUntil = countUntil; 
    } 

    @Override 
    public void run() { 
    long sum = 0; 
    for (long i = 1; i < countUntil; i++) { 
     sum += i; 
    } 
    System.out.println(sum); 
    } 
} 

Come utilizzare il servizio esecutore di eseguire innescare il thread di lavoro.

package de.vogella.concurrency.threadpools; 

import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 

public class Main { 
    private static final int NTHREDS = 10; 

    public static void main(String[] args) { 
    //You can also use Executors.newSingleThreadExecutor() if you just need 1 thread 
    ExecutorService executor = Executors.newFixedThreadPool(NTHREDS); 
    for (int i = 0; i < 500; i++) { 
     Runnable worker = new MyRunnable(10000000L + i); 
     executor.execute(worker); 
    } 
    // This will make the executor accept no new threads 
    // and finish all existing threads in the queue. 
    executor.shutdown(); 
    // Wait until all threads are finish 
    //while (!executor.isTerminated()) { 
    //} 
    //System.out.println("Finished all threads"); 
    //All the threads might not be finished at this point of time. Thread endtime purely depends on the time taken by the processing logic inside your thread. 
    } 
} 

Answer 3

Vuoi dire qualcosa del genere?

class Parallel { 
    private ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()); 

    public void shutdown() { 
     pool.shutdown(); 
    } 

    public void foo() { 
     pool.submit(new Runnable() { 
      @Override 
      public void run() { 
       // put your code here 
      } 
     }); 
    } 
}