Come chiamare un metodo con un thread separato in Java?

Diciamo che ho un metodo doWork() . Come posso chiamarlo da un thread separato (non il thread principale).

Crea una class che implementa l’interfaccia Runnable . Inserisci il codice che vuoi eseguire nel metodo run() : questo è il metodo che devi scrivere per essere conforms all’interfaccia Runnable . Nel tuo thread “principale”, crea una nuova class Thread , passando al costruttore un’istanza del Runnable , quindi chiama start() su di esso. start dice alla JVM di fare la magia per creare un nuovo thread, quindi chiama il metodo run in quel nuovo thread.

 public class MyRunnable implements Runnable { private int var; public MyRunnable(int var) { this.var = var; } public void run() { // code in the other thread, can reference "var" variable } } public class MainThreadClass { public static void main(String args[]) { MyRunnable myRunnable = new MyRunnable(10); Thread t = new Thread(myRunnable) t.start(); } } 

Dai un’occhiata al tutorial sulla concorrenza di Java per iniziare.

Se il metodo verrà chiamato frequentemente, potrebbe non valere la pena creare ogni volta un nuovo thread, poiché si tratta di un’operazione costosa. Probabilmente sarebbe meglio usare un pool di thread di qualche tipo. Dai un’occhiata alle classi Future , Callable , Executor nel pacchetto java.util.concurrent .

Che ne dite di :

  Thread t1 = new Thread(new Runnable() { public void run() { // code goes here. } }); t1.start(); OR new Thread(new Runnable() { public void run() { // code goes here. } }).start(); 

Un’altra opzione:

 Executors.newSingleThreadExecutor().execute(new Runnable() { @Override public void run() { myCustomMethod(); } }); 

o

 Executors.newCachedThreadPool().execute(new Runnable() { @Override public void run() { myCustomMethod(); } }); 

In Java 8 puoi farlo con una riga di codice.

Se il tuo metodo non accetta parametri, puoi utilizzare un riferimento al metodo:

 new Thread(MyClass::doWork).start(); 

Altrimenti, puoi chiamare il metodo in un’espressione lambda:

 new Thread(() -> doWork(someParam)).start(); 

Qualche tempo fa, avevo scritto una semplice class di utilità che utilizza il servizio di esecuzione JDK5 ed esegue processi specifici in background. Dal momento che doWork () normalmente ha un valore di ritorno vuoto, potresti voler usare questa class di utilità per eseguirla in background.

Vedi questo articolo in cui avevo documentato questa utility.

Un’altra opzione più rapida per chiamare le cose (come DialogBoxes e MessageBoxes e creare thread separati per i metodi non thread-safe) sarebbe usare l’espressione Lamba

  new Thread(() -> { "code here" }).start(); 

Per ottenere questo risultato con RxJava 2.x puoi usare:

 Completable.fromAction(this::dowork).subscribeOn(Schedulers.io().subscribe(); 

Il metodo subscribeOn() specifica su quale scheduler eseguire l’azione – RxJava ha diversi programmatori predefiniti, incluso Schedulers.io() che ha un pool di thread destinato alle operazioni di I / O e Schedulers.computation() che è destinato a CPU intensive operazioni.