Thread, Beispiel-Tutorial zur Thread-Erstellung

Hauptthread: Der Thread, der die Hauptmethode ausführt, wird als Hauptthread bezeichnet.

Single-Threaded-Programm: Das Programm wird sequentiell von oben nach unten ausgeführt von mani

Das Programm startet von der Hauptmethode aus. Wenn die JVM die Hauptmethode ausführt, findet sie das Betriebssystem
und öffnet einen Ausführungspfad zur CPU. Die CPU kann die Hauptmethode ausführen über diesen Pfad.
Dieser Pfad hat einen Der Name ist der Hauptthread

Methode zum Erstellen von Thread 1: Thread-Klasse erben
Implementierungsschritte:
1. Erstellen eine Unterklasse der Thread-Klasse
2. Schreiben Sie die Ausführungsmethode in der Thread-Klasse neu. Legen Sie die Aufgabe des Threads fest
3. Erstellen Sie ein Unterklassenobjekt der Thread-Klasse
4. Rufen Sie die Startmethode in der Thread-Klasse auf um einen neuen Thread zu starten und die Ausführungsmethode
auszuführen, damit der Thread die Ausführung startet; die Java Virtual Machine ruft die Ausführungsmethode des Threads auf.
Das Ergebnis ist, dass zwei Threads gleichzeitig ausgeführt werden; der aktuelle Thread (der Hauptthread) und der andere Thread (der Thread, der die Ausführungsmethode ausführt).
Das mehrfache Starten eines Threads ist illegal. Insbesondere wenn die Ausführung eines Threads abgeschlossen ist, kann er nicht neu gestartet werden.

Die gedruckten Ergebnisse erscheinen zufällig:
Öffnen Sie zwei Threads und wählen Sie den richtigen für die CPU aus
Führen Sie aus, wen Sie möchten, sodass zufällige Ergebnisse angezeigt werden

 1 public class MyThread extends Thread{ 2     /* 3      * 2.重写Thread类中的run方法,设置线程的任务 4      * 开启这个线程要干什么事情 5      */ 6     @Override 7     public void run() { 8         for (int i = 0; i < 50; i++) { 9             System.out.println("run..."+i);10         }11     }12 }13     public static void main(String[] args) {14         //3.创建Thread类的子类对象15         MyThread mt = new MyThread();16         //mt.run();//不会开启线程,还是单线程程序17         //4.调用Thread类中的start方法开启一个新的线程,执行run方法18         mt.start();19         20         new MyThread().start();21         22         for (int i = 0; i < 50; i++) {23             System.out.println("main..."+i);24         }25     }

Thread-Name:
Haupt-Thread: „main“
Name anderer geöffneter Threads: „Thread-0“, „Thread-1“....

Den Namen des Threads abrufen
1. Die Methode getName in der Thread-Klasse
String getName() gibt den Namen des Threads zurück.
2. Statische Methode in der Thread-Klasse zum Abrufen des aktuell ausgeführten Threads
static Thread currentThread() gibt einen Verweis auf das aktuell ausgeführte Thread-Objekt zurück.
Legen Sie den Namen des Threads fest:
1. Die Methode setName(String name) in der Thread-Klasse
void setName(String name) ändert den Thread-Namen so, dass er mit dem Parameternamen übereinstimmt.
2. Fügen Sie der Unterklasse ein parametrisiertes Konstrukt hinzu, rufen Sie den parametrisierten Konstruktor der Thread-Klasse der übergeordneten Klasse auf, übergeben Sie den Namen des Threads und lassen Sie die übergeordnete Klasse den Thread benennen (lassen Sie den Vater seinen Sohn benennen)
Thread(String name) weist ein neues Thread-Objekt zu.


Thread-Modus erstellen – Runnable-Schnittstelle implementieren

Implementierungsschritte:
1. Erstellen Sie eine Implementierungsklasse der Runnable-Schnittstelle
2. Schreiben Sie die Ausführungsmethode im um Ausführbare Schnittstelle, Thread-Aufgaben festlegen
3. Erstellen Sie ein Implementierungsklassenobjekt der ausführbaren Schnittstelle
4. Erstellen Sie ein Thread-Klassenobjekt und übergeben Sie die Implementierungsklasse der ausführbaren Schnittstelle im Konstruktor
Thread(Runnable target) weist ein neues Thread-Objekt zu.
5. Rufen Sie die Startmethode in der Thread-Klasse auf, um den Thread zu starten und die Ausführungsmethode auszuführen

Vorteile der Implementierung von Runnable
1. Es wird verhindert, dass eine Klasse die Thread-Klasse erbt andere Klassen erben (Einschränkungen der Einzelvererbung)
2. Entkoppeln Sie das Festlegen von Thread-Aufgaben und das Starten von Threads, um die Skalierbarkeit zu verbessern
Die Rolle der Implementierungsklasse: Festlegen von Thread-Aufgaben
Die Rolle der Thread-Klasse: Starten von Threads
Vorteile: Übergeben Sie verschiedene Implementierungsklassen, die Methode zum Umschreiben der Implementierungsklasse ist unterschiedlich, Sie können verschiedene Methoden aufrufen

Anonyme interne Klasse von Thread-Verwendungen

Anonym: kein Name
Interne Klasse: eine innerhalb anderer Klassen geschriebene Klasse (Mitgliedsposition: innere Mitgliedsklasse, lokale Position (in der Methode): lokale innere Klasse)

Format der anonymen inneren Klasse:
neue übergeordnete Klasse/Schnittstelle () {
Methoden in übergeordneter Klasse/Schnittstelle überschreiben;
};

Multithreaded übergeordnete Klasse:
Thread
Ausführbar

1  new Thread(){2             //重写run方法,设置线程任务3             @Override4             public void run() {5                 for (int i = 0; i < 20; i++) {6                     System.out.println(Thread.currentThread().getName()+":"+i);7                 }8             }9         }

The Der obige Codehaufen ist ein Prozess zum Erstellen einer Unterklasse und zum Überschreiben der Methode der übergeordneten Klasse
Äquivalent zu: new MyThread().start();

Das Programm hat ein Thread-Sicherheitsproblem: Doppelte Tickets verkauft und nicht vorhandene Tickets

Lösung:
Erster Weg: Sie können einen synchronisierten Codeblock verwenden

synchronisiert (Objekt sperren) {
Code, der Sicherheitsprobleme verursacht ;
Code, der greift auf gemeinsam genutzte Daten zu;
}

Hinweis:
Es muss sichergestellt werden, dass mehrere Threads dasselbe Sperrobjekt verwenden
//Erstellen Sie ein Sperrobjekt an der Mitgliedsposition Sperrobjekt (garantiert). einzigartig sein)

 1 Object obj = new Object(); 2      3     @Override 4     public void run() { 5         //让卖票重复执行 6         while(true){ 7          8              * 同步代码块 9              * 程序会频繁的判断锁,获取锁,释放锁,所以会降低速度10              11             synchronized (obj) {12                 if(ticket>0){13                     //为了提高安全问题的概率,让程序睡眠14                     try {15                         Thread.sleep(10);16                     } catch (InterruptedException e) {17                         e.printStackTrace();18                     }19                     //卖票ticket--20                     System.out.println(Thread.currentThread().getName()+"...卖第"+ticket--+"张票");21                 }22             }23         }24     }

Das Programm hat ein Thread-Sicherheitsproblem: Es werden doppelte und nicht vorhandene Tickets verkauft

Lösung:
Der zweite Weg: Synchronisierte Methode

Verwendungsschritte:
1. Extrahieren Sie den Code, der Sicherheitsprobleme verursachen kann, in eine Methode
2. Fügen Sie einen Schlüsselwort-synchronisierten
-Modifikator zum Methodennamen des synchronisierten Rückgabewerttyps der Methode hinzu ( Parameter) {
Code, der Sicherheitsprobleme haben kann;
Code, der auf gemeinsam genutzte Daten zugreift;
}

Was ist das Sperrobjekt, das von der synchronisierten Methode verwendet wird?
Was wird verwendet? dieses Klassenobjekt new RunnableImpl()-->Nennen Sie dies

Statische Synchronisationsmethode, welches Sperrobjekt wird verwendet?
Was verwendet wird, ist das Klassenattribut (Reflexion) dieses Klassenobjekts
RunnableImpl .class

 1 *@Override 2     public void run() { 3         //让卖票重复执行 4         while(true){ 5             payTicket2(); 6         } 7     } 8      9     10      * 静态的同步方法11      12     public static synchronized void payTicket2(){13         synchronized (RunnableImpl.class) {14             if(ticket>0){15                 //为了提高安全问题的概率,让程序睡眠16                 try {17                     Thread.sleep(10);18                 } catch (InterruptedException e) {19                     e.printStackTrace();20                 }21                 //卖票ticket--22                 System.out.println(Thread.currentThread().getName()+"...卖第"+ticket--+"张票");23             }24         }25     }26     27     28     29      * 抽取出一个同步方法30      * 快捷键:alt+shift+m31      32     public ynchronized void payTicket1() {33         synchronized (this) {34             //System.out.println(this);//cn.itcsat.demo10.RunnableImpl@6706435             if(ticket>0){36                 //为了提高安全问题的概率,让程序睡眠37                 try {38                     Thread.sleep(10);39                 } catch (InterruptedException e) {40                     e.printStackTrace();41                 }42                 //卖票ticket--43                 System.out.println(Thread.currentThread().getName()+"...卖第"+ticket--+"张票");44             }45         }46     }

程序出现了线程安全问题:卖了重复的票和不存在的票
*
* 解决方案:
* 第三种方式:使用Lock接口,JDK1.5之后出现的
*
* java.util.concurrent.locks.Lock接口
* 方法:
* void lock() 获取锁。
* void unlock() 释放锁。  
*  接口的实现类:ReentrantLock
*  
* 实现步骤:
* 1.在成员位置创建一个Lock接口的实现类对象ReentrantLock
* 2.在可能出现线程安全问题的代码前,调用lock方法获取锁
* 3.在可能出现线程安全问题的代码后,调用unlock方法释放锁
*
*1.在成员位置创建一个Lock接口的实现类对象ReentrantLock
Lock l = new ReentrantLock();

 1 @Override 2     public void run() { 3         //让卖票重复执行 4         while(true){ 5             //2.在可能出现线程安全问题的代码前,调用lock方法获取锁 6             l.lock(); 7                 if(ticket>0){ 8                     //为了提高安全问题的概率,让程序睡眠 9                     try {10                         Thread.sleep(10);11                         //卖票ticket--12                         System.out.println(Thread.currentThread().getName()+"...卖第"+ticket--+"张票");13                     } catch (InterruptedException e) {14                         e.printStackTrace();15                     }finally {16                         //3.在可能出现线程安全问题的代码后,调用unlock方法释放锁17                         l.unlock();    
18                     }19                 }20         }

 

Das obige ist der detaillierte Inhalt vonThread, Beispiel-Tutorial zur Thread-Erstellung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!