Dies ist definitiv die ausführlichste Erklärung des Java-Multithreadings

Multithreading in Java

In den vorherigen Betriebssystemprozessen und Threads wurde die Thread-Implementierung ausführlich erläutert. In diesem Artikel werden einige davon erläutert mehr Einführung.

Thread-Status

Für den Thread-Status in Java können wir ein Fünf-Zustands-Modell verwenden, um ihn darzustellen:

Erstellen, Bereit, Ausführen, Blockiert, Beenden fünf Zustände

Erstellungsstatus: JVM ruft die Methode main() auf, um einen Hauptthread zu erstellen. Der Hauptthread startet einen untergeordneten Thread, indem er die Methode start() des Thread-Objekts aufruft Wenn die Bedingungen erfüllt sind, wird der Thread in die Bereitschaftswarteschlange eingefügt.

Für andere verschiedene Zustände beachten Sie bitte die Erläuterungen in Prozessen und Threads.

Thread-Implementierung (Tread-Klasse und Runnable-Schnittstelle)

Es gibt zwei Möglichkeiten, einen Thread in Java zu erstellen, nämlich durch die Erbung der Thread-Klasse und die Implementierung der Runnable-Schnittstelle. Die spezifische Einführung lautet wie folgt:

Multithreading kann in Java über die Thread-Klasse und ihre Unterklassen sowie die Runnable-Schnittstelle implementiert werden.

Die Thread-Klasse kann Thread-Objekte direkt definieren. Im Allgemeinen ist es jedoch erforderlich, eine Unterklasse der Thread-Klasse zu definieren, um Multithreading zu implementieren und den besonderen Anforderungen der Programmierung gerecht zu werden. Eingeschränkt durch die Einzelvererbung von Java implementieren in praktischen Anwendungen fast alle Multithread-Anwendungen Multithreading durch Implementierung der ausführbaren Schnittstelle.

Mit anderen Worten: Wenn die neu erstellte Klasse andere Klassen erben möchte, können Multithread-Aufgaben nur durch die Implementierung der java.lang.Runnable-Schnittstelle ausgeführt werden, da die Mehrfachvererbung in Java nicht unterstützt wird Geeignet für mehrere identische Programmcodes. Threads werden zur Verarbeitung derselben Ressource verwendet, wodurch die virtuelle CPU (Thread) effektiv vom Code und den Daten des Programms getrennt wird.

Die Codes für die Implementierung der beiden Threads lauten wie folgt:

public class ThreadDemo extends Thread {
     int i = 0;
     public void run(){
         while (i<10){
             System.out.println("实现Thread类继承的线程，正在占有处理机运行……"+i);
             try{
                 sleep(1000);
                 i++;
             }catch (InterruptedException e){
                 e.printStackTrace();
             }
         }
     }
}

In der Hauptfunktion müssen wir nur die Klasse instanziieren und die start()-Methode aufrufen, um einen Thread zu erstellen.

public class RunnableDemo implements Runnable {
    int i = 0;

    @Override
    public void run(){
        while (i<10) {
            System.out.println("实现Runnable接口的线程，正在占有处理机运行……" + i);
            try {
                Thread.sleep(1000);
                i++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Implementierungsmethode in der Hauptfunktion:

Thread thread = new Thread(RunnableDemo );
Thread.start();

Grundlegende Steuerung von Threads

Anfang des Threads: thread.start()

Ende des Threads: Set Legen Sie eine Markierungsvariable fest, um die entsprechende Schleife und Methode

zu beenden, um die Ausführung des Threads vorübergehend zu verhindern: Try{Thread.sleep(1000);}catch(InterruptedException e){ }

Set die Thread-Priorität: Methode setPriority(int Priority)

Max_priority Die höchste Priorität, die ein Thread haben kann (normalerweise 10)

Min_priority Die höchste Priorität, die ein Thread haben kann (normalerweise 1)

Normale_Priorität ist die Standardpriorität, die Threads zugewiesen wird (normalerweise 5)

Klassifizierung von Threads

In Java gibt es zwei Arten von Threads: Benutzer-Thread (Benutzer-Thread) und Daemon-Thread (Daemon-Thread). ) ) besteht die Rolle des Daemon-Threads darin, Dienste für die Ausführung anderer Threads bereitzustellen, z. B. Garbage-Collection-Threads. Wenn in einem Java-Programm Nicht-Daemon-Threads vorhanden sind, wird das gesamte Programm nicht beendet.

通过setDaemon（true）方法设定守护线程

Thread-Planung

Jvm ist für die Zuweisung von CPU zu Threads verantwortlich, was als Thread-Planung bezeichnet wird: Threads mit hoher Priorität werden zuerst mit Gleichheit ausgeführt Priorität. Threads weisen CPU-Ressourcen direkt entsprechend der Zeitscheibenrotation zu.

Vorhandene Probleme

Unsicherheit von Threads: Eine einfache Anweisung in Java entspricht mehreren Anweisungen in der CPU, wenn ein Thread direkt nach einer Anweisung ausgeführt wird ausgeführt und geplant wird, rufen nachfolgende Threads wiederholt die Originaldaten auf, was zu Thread-Unsicherheit führt (nicht atomar)

Thread-Synchronisation

Thread-Synchronisation: gleichzeitig ausgeführt Wenn Threads Daten teilen müssen, müssen sie dies tun Berücksichtigen Sie den Status und das Verhalten anderer Threads. Zu diesem Zeitpunkt muss Java das Konzept der Objekt-Mutex-Sperre implementieren, um die Integrität gemeinsam genutzter Datenoperationen sicherzustellen. Jedes Objekt entspricht einem Monitor (Monitor), der über eine Markierung verfügt, die als „Mutex-Sperre (Sperre, Mutex)“ bezeichnet wird. Diese Markierung wird verwendet, um sicherzustellen, dass jeweils nur ein Thread auf das Objekt zugreifen kann. Das Schlüsselwort synchronisiert wird verwendet, um die Mutex-Sperre des Objekts zu kontaktieren

Verwendung von synchronisiert:

Für synchronisiertes Codefragment (Objekt) {}

Für eine Methode: synchronisiert In Die Methodendeklaration „Public synchronisiert void push (char c) {}“ entspricht „synced (this)“ und zeigt an, dass die gesamte Methode eine synchronisierte Methode ist.

Thread-Synchronisationssteuerung:

Sie können verwenden die Methode „wait()“ hebt die Objektsperre auf

Verwenden Sie notify() oder notifyAll(), um einen oder alle wartenden Threads in den Bereitschaftszustand zu versetzen

In Java können „wait“ und „notify“ platziert werden synchronisiert, während der synchronisierten Ausführung: Wenn ein Thread die Wartemethode eines Objekts aufruft, gibt er die Objektsperrkennung frei und wechselt dann in den Wartezustand. Anschließend rufen andere Threads die Methode notify() oder notify() auf, um den wartenden Thread zu benachrichtigen.

Der spezifische Code lautet wie folgt:

  class CubbyHole {
        private int index = 0;
        private int[] data = new int[3];

        public synchronized void put(int value){
            while (index == data.length){
                try{
                    this.wait();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            data[index++] = value;
            this.notify();
        }

        public synchronized int get(){
            while (index <=0) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            int value = data[index--];
            this.notify();
            return value;
        }
}

Andere Probleme

Bei der einfachen Synchronisierung kann das Sperren und Entsperren leicht zu Deadlock-Problemen führen, dh zum gegenseitigen Warten. Java hat nach 1.5 einige Methoden eingeführt, um Multithreading-Probleme zu lösen.

Parallelitäts-API (java.util.concurrent)

Seit JDK1.5 wurde eine Reihe nützlicherer APIs wie einzelne Variablen, Sammlungen, Timer und Thread-Pools bereitgestellt.

Atomvariable java.util.concurrent.atomic-Paket AtomicInteger-Klasse

GetAndIncrement()-Methode stellt sicher, dass der Thread-Zugriff sicher ist

Gleichzeitige Sammlungsklasse Java.util.concurrent Fügen Sie einige hinzu Fügen Sie dem Paket die Klassen CopyOnWriteArrayList und CopyOnWriteSet

hinzu, die für Objekte geeignet sind, die selten geschrieben, aber häufig gelesen werden

ConcurrentHashMap

ArrayBlockingQueue-Produzenten und -Konsumenten verwenden Put und Get

Thread-Pools verwenden

Thread-Pool-bezogene Klasse ExecutorService-Schnittstelle, ThreadPoolExecutor-Klasse Executors-Toolklasse

Allgemeine Verwendung ExecutorService-Pool = Executors .newCachedThreadPool();

Verwenden Sie die Methodeexecute(Runnable r)

Das obige ist der detaillierte Inhalt vonDies ist definitiv die ausführlichste Erklärung des Java-Multithreadings. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!