Java Language Créer une instance java.lang.Thread


Exemple

Il existe deux approches principales pour créer un thread en Java. En résumé, créer un thread est aussi simple que d’écrire le code qui sera exécuté. Les deux approches diffèrent dans la définition de ce code.

En Java, un thread est représenté par un objet - une instance de java.lang.Thread ou de sa sous-classe. La première approche consiste donc à créer cette sous-classe et à remplacer la méthode run () .

Remarque : j'utiliserai Thread pour faire référence à la classe java.lang.Thread et au thread pour faire référence au concept logique des threads.

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread running!");
        }
    }
}

Maintenant que nous avons déjà défini le code à exécuter, le thread peut être créé simplement comme:

MyThread t = new MyThread();

La classe Thread contient également un constructeur acceptant une chaîne, qui sera utilisée comme nom du thread. Cela peut être particulièrement utile lors du débogage d'un programme multi-thread.

class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread running! ");
        }
    }
}

MyThread t = new MyThread("Greeting Producer");

La deuxième approche consiste à définir le code à l'aide de java.lang.Runnable et de sa seule méthode run () . La classe Thread vous permet alors d'exécuter cette méthode dans un thread séparé. Pour ce faire, créez le thread en utilisant un constructeur acceptant une instance de l'interface Runnable .

Thread t = new Thread(aRunnable);

Cela peut être très puissant lorsqu'il est combiné avec des références lambdas ou méthodes (Java 8 uniquement):

Thread t = new Thread(operator::hardWork);

Vous pouvez également spécifier le nom du thread.

Thread t = new Thread(operator::hardWork, "Pi operator");

Pratiquement parlant, vous pouvez utiliser les deux approches sans soucis. Cependant, la sagesse générale dit d'utiliser ce dernier.


Pour chacun des quatre constructeurs mentionnés, il existe également une alternative acceptant une instance de java.lang.ThreadGroup comme premier paramètre.

ThreadGroup tg = new ThreadGroup("Operators");
Thread t = new Thread(tg, operator::hardWork, "PI operator");

Le ThreadGroup représente un ensemble de threads. Vous ne pouvez ajouter un thread à un ThreadGroup qu'en utilisant le constructeur d'un thread . Le ThreadGroup peut alors être utilisé pour gérer tous ses threads ensemble, de même que le thread peut obtenir des informations à partir de son ThreadGroup .

Donc, pour résumer, le thread peut être créé avec l'un de ces constructeurs publics:

Thread()
Thread(String name)
Thread(Runnable target)
Thread(Runnable target, String name)
Thread(ThreadGroup group, String name)
Thread(ThreadGroup group, Runnable target)
Thread(ThreadGroup group, Runnable target, String name)
Thread(ThreadGroup group, Runnable target, String name, long stackSize)

Le dernier nous permet de définir la taille de pile souhaitée pour le nouveau thread.


Souvent, la lisibilité du code souffre lors de la création et de la configuration de nombreux threads avec les mêmes propriétés ou à partir du même modèle. C'est à ce moment que java.util.concurrent.ThreadFactory peut être utilisé. Cette interface vous permet d'encapsuler la procédure de création du thread via le modèle de fabrique et sa seule méthode newThread (Runnable) .

class WorkerFactory implements ThreadFactory {
    private int id = 0;

    @Override
    public Thread newThread(Runnable r) {
        return new Thread(r, "Worker " + id++);
    }
}