Comment appeler une méthode avec un thread séparé en Java?

disons que j'ai une méthode doWork(). Comment puis-je l'appeler à partir d'un thread séparé (pas le thread principal).

Créez une classe qui implémente l' Runnableinterface. Mettez le code que vous souhaitez exécuter dans la run()méthode - c'est la méthode que vous devez écrire pour vous conformer à l' Runnableinterface. Dans votre thread "principal", créez une nouvelle Threadclasse, en passant au constructeur une instance de votre Runnable, puis appelez start()-la. startindique à la JVM de faire la magie pour créer un nouveau thread, puis d'appeler votre runméthode dans ce nouveau 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();
    }    
}

Jetez un œil au didacticiel sur la concurrence de Java pour commencer.

Si votre méthode doit être appelée fréquemment, cela ne vaut peut-être pas la peine de créer un nouveau thread à chaque fois, car il s'agit d'une opération coûteuse. Il serait probablement préférable d'utiliser une sorte de pool de threads. Jetez un oeil à Future, Callable, les Executorclasses dans le java.util.concurrentpaquet.

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

ou

new Thread(new Runnable() {
     @Override
     public void run() {
          // code goes here.
     }
}).start();

ou

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

ou

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

ou

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

Dans Java 8, vous pouvez le faire avec une seule ligne de code.

Si votre méthode ne prend aucun paramètre, vous pouvez utiliser une référence de méthode:

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

Sinon, vous pouvez appeler la méthode dans une expression lambda:

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

Une autre option plus rapide pour appeler des choses (comme les DialogBoxes et MessageBoxes et la création de threads séparés pour les méthodes non thread-safe) serait d'utiliser l'expression Lamba

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

Il y a quelque temps, j'avais écrit une classe utilitaire simple qui utilise le service exécuteur JDK5 et exécute des processus spécifiques en arrière-plan. Étant donné que doWork () aurait généralement une valeur de retour void, vous souhaiterez peut-être utiliser cette classe d'utilitaire pour l'exécuter en arrière-plan.

Consultez cet article où j'avais documenté cet utilitaire.

Pour y parvenir avec RxJava 2.x, vous pouvez utiliser:

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

La subscribeOn()méthode spécifie sur quel planificateur exécuter l'action - RxJava a plusieurs planificateurs prédéfinis, y compris celui Schedulers.io()qui a un pool de threads destiné aux opérations d'E / S et celui Schedulers.computation()qui est destiné aux opérations gourmandes en CPU.

Si vous utilisez au moins Java 8, vous pouvez utiliser la méthode runAsyncde la classe CompletableFuture

CompletableFuture.runAsync(() -> {...});

Si vous devez renvoyer un résultat, utilisez à la supplyAsyncplace

CompletableFuture.supplyAsync(() -> 1);