Zusammenfassung der Java-Multithread-Programmiermethoden (mit Beispielen)

Der Inhalt dieses Artikels ist eine Zusammenfassung der Java-Multithreading-Implementierungsmethoden (mit Beispielen). Ich hoffe, dass er für Sie hilfreich ist.

1. Wann man Multithread-Programmierung verwenden sollte

Eine Aufgabe wird unter normalen Umständen sequentiell ausgeführt, wenn es jedoch mehrere ähnliche Prozessblöcke in der aktuellen Aufgabe gibt (z. B. for, while-Anweisungen) , wir können erwägen, diese Codeblöcke zu extrahieren, um sie parallel auszuführen, ohne sie zu blockieren

2 Mehrere Möglichkeiten, Multithreading zu implementieren

Eine besteht darin, die Thread-Klasse zu erben und die Ausführungsmethode neu zu schreiben andere Die erste besteht darin, die Runnable-Schnittstelle zu implementieren und die Ausführungsmethode zu überschreiben. In vielen Fällen dient das Starten von Multithreads der Verarbeitung gleichzeitiger Prozesse. Für einige Geschäftsanforderungen sind derzeit keine hohen Anforderungen erforderlich. Zeitleistung können wir auch eine asynchrone Implementierung implementieren.

3. Beispiel

Erbt Thread

/**
 * 
* @ClassName: ThreadByEx  
* @Description: TODO
* @author Mr.jqCheng
* @date 2018年9月26日  
* */public class ThreadByEx extends Thread{

    @Override    public void run() {        // TODO Auto-generated method stub
        System.out.println("我是继承线程");
    }

}

Implementiert Runnable

/**
 * 
* @ClassName: ThreadByRunnable  
* @Description: TODO
* @author Mr.jqCheng
* @date 2018年9月26日  
* */public class ThreadByRunnable implements Runnable{    /*public ThreadByRunnable() {
        this.run();
        // TODO Auto-generated constructor stub
    }*/

    public void run() {        // TODO Auto-generated method stub
        System.out.println("我是实现进程");
    }

}

Test:

/**
 * 
* @ClassName: Test  
* @Description: TODO
* @author Mr.jqCheng
* @date 2018年9月26日  
* */public class Test {    public static void main(String[] args) {        // 继承Thread启动的方法
        ThreadByEx t1 = new ThreadByEx();
        t1.start();// 启动线程        // 实现Runnable启动线程的方法
        ThreadByRunnable r = new ThreadByRunnable();
        Thread t2 = new Thread(r);
        t2.start();// 启动线程        //new ThreadByRunnable();    }

}

Laufendes Ergebnis:

Ich bin ein geerbter Thread

Ich bin ein Implementierungsprozess

ok, die einfache Multi-Thread-Implementierung ist abgeschlossen. Wenn start() aufgerufen wird, ist der Prozess in den ausführbaren Zustand eingetreten und wartet auf das System Ausführung.

Mehrere gängige Methoden der Thread-Verarbeitung:

void interrupt(): Senden Sie eine Interrupt-Anfrage an den Thread. Der Interrupt-Status des Threads wird auf „True“ gesetzt, wenn der aktuelle Thread blockiert ist Durch einen Sleep-Aufruf wird eine interruptedException ausgelöst.

static boolean interrupted(): Testen Sie, ob der aktuelle Thread (der Thread, der gerade den Befehl ausführt) unterbrochen ist. Beachten Sie, dass es sich um eine statische Methode handelt. Der Aufruf dieser Methode hat einen Nebeneffekt, d. h. der Interrupt-Status des aktuellen Threads wird auf „false“ zurückgesetzt.

boolean isInterrupted(): Bestimmen Sie, ob der Thread unterbrochen ist. Der Aufruf dieser Methode hat keine Nebenwirkungen und ändert nichts am aktuellen Unterbrechungsstatus des Threads.

statischer Thread currentThread(): Gibt das Thread-Objekt zurück, das den aktuellen Ausführungsthread darstellt.

Der Daemon-Prozess

wird verwendet, um alle Threads unter allen anderen aktuellen Prozessen zu bedienen, die keine Dienstprozesse sind.

Implementieren Sie einfach deamon.setDaemon(true) vor dem Thread gestartet Aktivieren

Beispiel

package com.orange.util;
/**
 * 
 * @ClassName: Test
 * @Description: TODO
 * @author Mr.jqCheng
 * @date 2018年9月26日
 *
 */
public class Test {
    public static void main(String[] args) {
        Thread deamon2 = new Thread(new DaemonRunner2(), "otherRunner");
        deamon2.start();// 启动线程
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Thread deamon = new Thread(new DaemonRunner(), "DaemonRunner");
        // 设置为守护线程
        deamon.setDaemon(true);
        deamon.start();// 启动线程
    }
    static class DaemonRunner implements Runnable {
        public void run() {
            // TODO Auto-generated method stub
            try {
                Thread.sleep(300);
                Thread t = Thread.currentThread();
                System.out.println(t);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.out.println("进入守护线程，说明现在还有其他线程在执行");
            }
        }
    }
    static class DaemonRunner2 implements Runnable {
        public void run() {
            // TODO Auto-generated method stub
            try {
                Thread.sleep(1500);
                System.out.println("我是其他线程");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Ausführungsergebnis:

Thread[DaemonRunner,5,main]

betritt den Daemon-Thread und zeigt an, dass andere Threads Ich bin ein anderer Thread

Starten Sie zuerst andere Threads, was 1500 ms dauert. Gleichzeitig beginnt der Hauptthread, in den Daemon-Thread einzutreten Wenn es um den Daemon-Thread geht, dauert es 300 ms, andere Threads werden noch ausgeführt, fahren Sie fort, der Daemon-Thread hat die Ausführung abgeschlossen

Aber wenn ich die 300 ms des Daemon-Threads auf 500 ms ändere, was wird passieren?

Beim kritischen Wert gab es immerhin zwei Situationen

1. Ich bin ein anderer Thread

2 Betritt den Daemon-Thread und zeigt an, dass andere Threads ausgeführt werden

Ich bin ein anderer Thread

Das obige ist der detaillierte Inhalt vonZusammenfassung der Java-Multithread-Programmiermethoden (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!