Was bedeutet Java-Multithreading?

Java-Multithreading ist ein Mechanismus, der die gleichzeitige Ausführung mehrerer Befehlsströme in einem Programm ermöglicht und alle Variablen in Java im Hauptspeicher speichert Von allen Threads geteilt.

Detaillierte Erklärung von Java Multi-Threading:

1. Multi-Threading verstehen

Multi-Threading ist ein Mechanismus, der die gleichzeitige Ausführung mehrerer Befehlsströme in einem Programm ermöglicht heißt Als Thread, unabhängig voneinander. Threads werden auch als Lightweight-Prozesse bezeichnet und verfügen über eine unabhängige Ausführungskontrolle, die vom Betriebssystem geplant wird. Der Unterschied besteht darin, dass Threads keinen unabhängigen Speicherplatz haben, sondern sich einen Speicherplatz mit anderen Threads in dem Prozess teilen, zu dem sie gehören. Dadurch ist die Kommunikation zwischen Threads viel einfacher als die von Prozessen.

Da Java speziell für das Java-Speichermodell als plattformübergreifende Sprache konzipiert ist, ist es offensichtlich, dass es hinsichtlich der Speicherverwaltung ein einheitliches Modell geben muss. Das System verfügt über einen Hauptspeicher (Main Memory). Alle Variablen in Java werden im Hauptspeicher gespeichert und von allen Threads gemeinsam genutzt. Jeder Thread verfügt über einen eigenen Arbeitsspeicher (Arbeitsspeicher). Im Arbeitsspeicher wird eine Kopie einiger Variablen im Hauptspeicher gespeichert. Alle Thread-Operationen an Variablen werden im Arbeitsspeicher ausgeführt, und Threads können nicht direkt aufeinander zugreifen. Die Übertragung der Variablen muss über den Hauptspeicher erfolgen.

Die Ausführung mehrerer Threads erfolgt gleichzeitig, also logisch „gleichzeitig“, unabhängig davon, ob es physisch „gleichzeitig“ ist. Wenn das System nur über eine CPU verfügt, ist echte „Gleichzeitigkeit“ unmöglich. Der größte Unterschied in der Programmierung zwischen Multithreading und herkömmlichem Singlethreading besteht darin, dass der Code zwischen den einzelnen Threads nicht in der richtigen Reihenfolge ausgeführt wird, da die Kontrollflüsse jedes Threads unabhängig voneinander sind, was zu Thread-Planung, Synchronisierung und anderen Problemen führt . Netzwerkverwaltungsnetzwerk bitsCN.com

Verwandte Lernempfehlungen: Java-Grundlagen-Tutorial

2. Multithreading in Java implementieren

Wir können uns genauso gut vorstellen, was wir tun müssen, um einen neuen Thread zu erstellen ? Natürlich müssen wir den Code angeben, der von diesem Thread ausgeführt werden soll, und das ist alles, was wir tun müssen, um Multithreading in Java zu implementieren!

Als vollständig objektorientierte Sprache stellt Java die Klasse java.lang.Thread zur Verfügung, um die Multi-Thread-Programmierung zu erleichtern. Diese Klasse stellt eine große Anzahl von Methoden bereit, die uns die Steuerung unserer eigenen Threads erleichtern.

Wie stellen wir Java also den Code zur Verfügung, den der Thread ausführen soll? Werfen wir einen Blick auf die Thread-Klasse. Die wichtigste Methode der Thread-Klasse ist run(), die von der Methode start() der Thread-Klasse aufgerufen wird und den von unserem Thread auszuführenden Code bereitstellt. Um unseren eigenen Code anzugeben, überschreiben Sie ihn einfach!

Methode 1: Erben Sie die Thread-Klasse und schreiben Sie die Methode run() neu. Wir schreiben run() in der Unterklasse der erstellten Thread-Klasse neu und fügen den vom Thread auszuführenden Code hinzu. Hier ist ein Beispiel:

public class TwoThread extends Thread {
    public void run() {
        for ( int i = 0; i < 10; i++ ) {
            System.out.println("New thread");
        }
    }
    public static void main(String[] args) {
        TwoThread tt = new TwoThread();
        tt.start();
        for ( int i = 0; i < 10; i++ ) {
            System.out.println("Main thread");
        }
    }
}

Diese Methode ist einfach und klar und entspricht den Gewohnheiten aller. Sie hat jedoch auch einen großen Nachteil: Wenn unsere Klasse von einer Klasse geerbt hat, kann sie die Thread-Klasse nicht erben.

Methode 2: Implementieren Sie die Runnable-Schnittstelle

Die Runnable-Schnittstelle hat nur eine Methode, run() Wir deklarieren, dass unsere Klasse die Runnable-Schnittstelle implementiert und diese Methode bereitstellt, unseren Thread-Code hineinschreibt und diesen Teil vervollständigt Aufgabe. Aber die Runnable-Schnittstelle bietet keine Unterstützung für Threads. Wir müssen auch eine Instanz der Thread-Klasse erstellen, was über den Konstruktor public Thread (Runnable-Ziel) erreicht wird. Hier ist ein Beispiel:

public class MyThread implements Runnable {
int count=1, number;
public MyThread(int num) {
number = num;
System.out.println("创建线程 " + number);
}
public void run() {
while(true) {
System.out.println("线程 " + number + ":计数 " + count);
if(++count== 6) return;
}
}
public static void main(String args[]) {
for(int i = 0; i < 5; i++)
new Thread(new MyThread(i+1)).start();
}
}

Durch die Verwendung der Runnable-Schnittstelle zur Implementierung von Multithreading können wir den gesamten Code in einer Klasse enthalten, was der Kapselung förderlich ist. Lassen Sie uns einige Probleme bei der Verwendung von Multithreading untersuchen.

3. Vier Zustände von Threads

1. Neuer Zustand: Der Thread wurde erstellt, aber noch nicht ausgeführt (start() wurde noch nicht aufgerufen).

2. Ausführbarer Zustand: Der Thread kann ausgeführt werden, obwohl er nicht unbedingt ausgeführt wird. Diesem Thread kann jederzeit CPU-Zeit zugewiesen werden, wodurch er ausgeführt wird.

3. Blockierter Zustand: Dem Thread wird keine CPU-Zeit zugewiesen und er kann nicht ausgeführt werden; er ist möglicherweise in E/A oder in einer Synchronisationssperre blockiert.

4. Todeszustand: Unter normalen Umständen führt die Rückkehr von run() zum Absterben des Threads. Der Aufruf von stop() oder destroy() hat ebenfalls den gleichen Effekt, wird jedoch nicht empfohlen. Ersteres erzeugt eine Ausnahme, letzteres ist eine erzwungene Beendigung und gibt die Sperre nicht frei.

4. Thread-Priorität

    线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。

    你可以调用 Thread 类的方法 getPriority（） 和 setPriority（）来存取线程的优先级，线程的优先级界于1（MIN_PRIORITY）和10（MAX_PRIORITY）之间，缺省是5（NORM_PRIORITY）。

五、线程的同步

    由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。

    我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

    1. synchronized 方法：通过在方法声明中加入synchronized关键字来声明 synchronized 方法。synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。

    在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized，以控制其对类的静态成员变量的访问。

    synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法run（）声明为synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何synchronized方法的调用都永远不会成功。

    2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：

synchronized(syncObject) {
//允许访问控制的代码
}

    synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject 的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

相关学习推荐：编程视频

Das obige ist der detaillierte Inhalt vonWas bedeutet Java-Multithreading?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!