[Java] Multithread-Verarbeitung

Fazit

• Der Unterschied zwischen Prozessen und Threads ist wichtig
• Die Bedeutung von Multithreading besteht darin, dass es unabhängig betrieben werden kann und Speicherplatz innerhalb desselben Prozesses gemeinsam nutzt **.

Was ist ein Thread?

• Die kleinste Verarbeitungseinheit zum Ausführen eines Programms **
• Die App läuft auf einem einzelnen Thread namens ** Hauptthread **
• Bei ** Single Thread ** muss der App-Benutzer jedoch bis zum Ende der Kommunikation auf den nächsten Vorgang warten, z. B. während der Netzwerkkommunikation.
• Wenn mehrere Threads vorhanden sind (= ** Multithread **), wird die Netzwerkkommunikation von anderen Threads im Hintergrund ausgeführt, und die ** Verarbeitung kann vom Hauptthread auch während der Kommunikation parallel ausgeführt werden. * * *

Was ist ein Prozess?

• ** Programminstanz selbst **
• Neue ** CPU- und Speicherzuordnung erforderlich, um den Prozess zu starten **
• Prozess ** hat einen oder mehrere Threads **
• 1 bis 1..n (1 oder mehr n) Beziehung
• In der UML-Notation gibt es 1… n Threads, wenn man sie von der Prozessseite betrachtet.

Prozess 1 　　　| Thread 1..n

Speicherkonfiguration

• ** Prozess **: Programm läuft auf der Hauptfunktion
• In einer großen Box befindet sich ein ** Thread **, der als Prozess bezeichnet wird
• Hauptfunktion funktioniert in 1 Thread
• Ein Prozess muss einen oder mehrere Threads haben (** Haupt-Thread **)

Thread Features-Independent / Memory Space Sharing

• Threads bewegen sich ** unabhängig voneinander **
• Threads, die im Hintergrund ausgeführt werden, werden unabhängig voneinander ausgeführt, auch wenn sie angehalten werden
• Wenn die Kommunikationsverarbeitung für den Hauptthread ausgeführt wird, wird sie während der Kommunikation gestoppt und die Antwort wird zurückgegeben, sodass auch während dieser Zeit eine parallele Verarbeitung für die Verarbeitung durchgeführt wird.
• Der Grund, warum es in einem Prozess ist, wenn 3 Threads mit Multithreading gestartet werden, ist **, weil es Speicherplatz teilt **
• Sobald die Variable im Hauptthread definiert ist ** Alle Threads können darauf zugreifen **

public class Main {
    String hoge = "hoge"; //Diese Variable wird gemeinsam genutzt
    public static void main(String[] args) {
        new Main().run();
    }
    private void run(){
        while (true) {
            System.out.println("1"); //Haupt-Bedroung
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("2");
        }
    }
}

Thread-Erstellung / Ausführung

• Thread-Klasse erben
• Ausführung der ausführbaren Schnittstelle

Thread-Klasse erben

• Überschreiben Sie die absolute Ausführungsmethode (aufrufender Endpunkt) ** in von Thread abgeleiteten Klassen
• Von Thread abgeleitete Klassenmethoden
• ** currentThread **: Laufender Thread abrufen
• ** getId **: Thread-ID abrufen
• ** isAlive **: Bestätigung des Thread-Überlebens
• ** join **: Warten Sie ms, bis der Thread endet
• ** setPriority **: Prioritätseinstellung
• ** sleep **: Pause für die Thread-Ausführung

public class MyThread extends Thread {
//Die eigentliche Thread-Verarbeitung ist eine vom Thread abgeleitete Klasse
  @Override
  public void run() {
    for (var i = 0; i < 30; i++) {
      //Holen Sie sich den Thread-Namen mit getName
      System.out.println(this.getName() + ": " + i);
    }
  }
}

public class ThreadBasic {

  public static void main(String[] args) {
    //Threads instanziieren und erstellen
    var th1 = new MyThread();
    var th2 = new MyThread();
    var th3 = new MyThread();
    //Thread mit Startmethode starten
    th1.start();
    th2.start();
    th3.start();
  }
}

Ausführung der ausführbaren Schnittstelle

• Implementierungen ** (implementiert Runnable), keine Vererbung
• Funktionsschnittstelle
• Da auf den Threadnamen nicht direkt zugegriffen werden kann, rufen Sie den aktuellen Thread mit der statischen Methode Thread.currentThread () ab und greifen Sie auf die Methode getName zu.
• Übergeben Sie eine Instanz der Runnable-Implementierungsklasse zur Instanziierung an den Thread-Konstruktor

public class MyRunner implements Runnable {
  //Tatsächliche Thread-Verarbeitung
  @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) {
    //Thread-Erstellung
    var th1 = new Thread(new MyRunner());
    var th2 = new Thread(new MyRunner());
    var th3 = new Thread(new MyRunner());
    //Fadenstart
    th1.start();
    th2.start();
    th3.start();
  }
}