[Java] Traitement multi-thread

Conclusion

• La différence entre les processus et les threads est importante
• L'importance du multithreading est qu'il peut être exploité indépendamment et partager l'espace mémoire au sein du même processus **.

Qu'est-ce qu'un fil

• La plus petite unité de traitement pour exécuter un programme **
• L'application fonctionne sur un seul thread appelé ** thread principal **
• Cependant, avec ** thread unique **, l'utilisateur de l'application doit attendre l'opération suivante jusqu'à la fin de la communication, par exemple pendant la communication réseau.
• S'il y a plusieurs threads (= ** multi-thread **), la communication réseau
  sera exécutée par d'autres threads en arrière-plan, et ** le traitement peut être exécuté en parallèle par le thread principal même pendant la communication * *

Qu'est-ce qu'un processus

• ** Instance de programme elle-même **
• Nouvelle ** allocation de CPU et de mémoire requise pour démarrer le processus **
• Process ** a un ou plusieurs threads **
• 1 à 1..n (1 ou plus n) relation
• En notation UML, il y a 1… n threads lorsqu'ils sont visualisés du côté processus.

Processus 1 　　　| Fil 1..n

Configuration de la mémoire

• ** Process **: programme en cours d'exécution sur la fonction principale
• Il y a un ** thread ** dans une grande boîte appelée processus
• La fonction principale fonctionne dans 1 fil
• Un processus doit avoir un ou plusieurs threads (** thread principal **)

Partage de l'espace mémoire indépendant des fonctionnalités de thread

• Les fils bougent ** indépendamment les uns des autres **
• Les threads qui s'exécutent en arrière-plan fonctionnent indépendamment même si on s'arrête
• Si le traitement de la communication est effectué sur le thread principal, il s'arrêtera pendant la communication et la réponse est renvoyée, de sorte qu'un traitement parallèle est également effectué pendant ce temps.
• La raison pour laquelle il s'agit d'un processus lorsque 3 threads sont lancés avec le multithreading est ** parce qu'il partage l'espace mémoire **
• Une fois la variable définie dans le thread principal ** Tous les threads peuvent accéder **

public class Main {
    String hoge = "hoge"; //Cette variable est partagée
    public static void main(String[] args) {
        new Main().run();
    }
    private void run(){
        while (true) {
            System.out.println("1"); //Fil principal
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("2");
        }
    }
}

Création / exécution de threads

• Hériter de la classe Thread
• Implémentation d'interface exécutable

Hériter de la classe Thread

• Remplacer la méthode d'exécution absolue (appelant le point de terminaison) ** dans les classes dérivées de Thread
• Méthodes de classe dérivées de thread
• ** currentThread **: Obtenez le thread en cours d'exécution
• ** getId **: Obtenir l'ID de thread
• ** isAlive **: confirmation de la survie du thread
• ** join **: attendez ms jusqu'à la fin du thread
• ** setPriority **: réglage de priorité
• ** sleep **: pause d'exécution du thread

public class MyThread extends Thread {
//Le traitement réel du thread est une classe dérivée de Thread
  @Override
  public void run() {
    for (var i = 0; i < 30; i++) {
      //Obtenir le nom du thread avec getName
      System.out.println(this.getName() + ": " + i);
    }
  }
}

public class ThreadBasic {

  public static void main(String[] args) {
    //Instantanez et créez des threads
    var th1 = new MyThread();
    var th2 = new MyThread();
    var th3 = new MyThread();
    //Démarrer le fil avec la méthode de démarrage
    th1.start();
    th2.start();
    th3.start();
  }
}

Implémentation d'interface exécutable

• Implémentations ** (implémente Runnable), pas d'héritage
• Interface fonctionnelle
• Puisque le nom du thread n'est pas accessible directement, récupérez le thread actuel avec la méthode statique Thread.currentThread () et accédez à la méthode getName.
• Passez une instance de la classe d'implémentation Runnable au constructeur Thread pour instanciation

public class MyRunner implements Runnable {
  //Traitement réel du fil
  @Override
  public void run() {
    for (var i = 0; i < 30; i++) {
      System.out.println(Thread.currentThread().getName() + ": " + i);
    }
  }
}

public class RunnableBasic {

  public static void main(String[] args) {
    //Création de fil
    var th1 = new Thread(new MyRunner());
    var th2 = new Thread(new MyRunner());
    var th3 = new Thread(new MyRunner());
    //Début du fil
    th1.start();
    th2.start();
    th3.start();
  }
}