So führen Sie Threads in der von ihnen selbst angegebenen Reihenfolge in Java aus

So führen Sie Threads in der von ihnen angegebenen Reihenfolge aus

Bei der täglichen Multi-Thread-Entwicklung möchten wir manchmal jeden Thread in der von uns angegebenen Reihenfolge ausführen lassen, anstatt ihn von der CPU zufällig planen zu lassen unnötigen Ärger in der täglichen Entwicklungsarbeit.

Da nun diese Anforderung besteht, wird der Titel dieses Artikels eingeführt, um die Threads in der von ihnen angegebenen Reihenfolge laufen zu lassen.

Interessierte Schüler können die möglichen Ergebnisse der Ausführung des folgenden Codes erraten:

Nach dem normalen Verständnis sollte die Ausführungsreihenfolge des obigen Codes sein: t1 → t3, aber der tatsächliche Effekt ist kein idealer Zustand.

Das Bild unten zeigt den Laufeffekt:

Mitmachen kennen lernen

Mitmachen ist für einige Schüler vielleicht nicht unbekannt. Ich werde hier nicht im Detail vorstellen, was Beitreten ist Google.

Hier werde ich direkt vorstellen, wie man mit Join den gewünschten Effekt erzielt!

Hier nutzen wir hauptsächlich die blockierende Wirkung von Join, um unser Ziel zu erreichen. Wenn wir uns die Ausführungsergebnisse in der obigen Abbildung ansehen, können wir erkennen, dass das Programm in der von uns angegebenen Reihenfolge ausgeführt wurde und die gewünschten Ergebnisse erzielt hat.

Tatsächlich können wir tief darüber nachdenken, warum der Beitritt den gewünschten Effekt erzielen kann? Schauen wir uns als nächstes den Quellcode an:

Nach der Eingabe des Join-Quellcodes sehen Sie als Erstes eine Join-Methode, die 0 Parameter übergibt. Wählen Sie hier, um mit der Eingabe fortzufahren.

Erstens können Sie sehen, dass die Join-Methode threadsicher ist. Zweitens können Sie sehen, dass zusammen mit dem obigen Bild eine Wait(0)-Methode ausgeführt wird. Erfahrene Studierende sollten es direkt erkennen können, das bedeutet Warten.

Aber es sollte beachtet werden, dass das Warten hier definitiv nicht das Warten auf den Aufrufer ist, sondern dass die blockierten Hauptthreads nur Unterthreads sind .

Dies zeigt, wie die Teilnahme funktioniert, und beweist auch, dass die Teilnahme es uns ermöglichen kann, die gewünschten Ergebnisse im Programm zu erzielen.

Zusätzlich dazu, dass Join uns hilft, die Reihenfolge der Threads im Programm zu steuern, gibt es noch andere Möglichkeiten. Versuchen wir es beispielsweise mit dem Thread-Pool.

Verwenden des Executors-Thread-Pools

Executors ist die Thread-Pool-Operationsklasse unter dem Paket java.util.concurrent im JDK, die uns bequem Thread-Pool-Operationen bereitstellen kann.

Hier verwenden wir die Methode newSingleThreadExecutor() in Executors, um einen Single-Threaded-Thread-Pool zu erstellen.

Wie aus der obigen Abbildung ersichtlich ist, können mit der Methode newSingleThreadExecutor() immer noch die von uns erwarteten Ergebnisse erzielt werden. Das Prinzip der Methode ist eine FIFO-basierte Warteschlange Das heißt, wenn wir t1 und t2 nacheinander zur Warteschlange hinzufügen, befindet sich tatsächlich nur der Thread T2 im Bereitschaftszustand, und wenn t1 abgeschlossen ist, werden andere Threads in der Warteschlange hinzugefügt wird weiterhin ausgeführt.

Priorität und Ausführungsreihenfolge von Threads

Beim Erlernen von Operatoren wissen die Leser, dass es eine Priorität zwischen Operatoren gibt. Das Verständnis der Priorität von Operatoren hat einen guten Einfluss auf die Programmentwicklung. Dasselbe gilt für Threads. Die Java Virtual Machine bestimmt die Ausführungsreihenfolge der Threads basierend auf der Priorität des Threads, sodass mehrere Threads die CPU-Ressourcen sinnvollerweise ohne Konflikte teilen können.

Prioritätsübersicht

In der Java-Sprache liegt der Prioritätsbereich eines Threads zwischen 1 und 10, und der Wert muss zwischen 1 und 10 liegen, andernfalls tritt eine Ausnahme auf. Threads mit höherer Priorität werden zuerst ausgeführt, und wenn die Ausführung abgeschlossen ist, sind Threads mit niedrigerer Priorität an der Reihe. Wenn die Prioritäten gleich sind, werden sie der Reihe nach ausgeführt.

Sie können die Methode setPriority() in der Thread-Klasse verwenden, um die Priorität des Threads festzulegen. Die Syntax lautet wie folgt:

public final void setPriority(int newPriority);

Wenn Sie die Priorität des aktuellen Threads erhalten möchten, können Sie die Methode getPriority() direkt aufrufen. Die Syntax lautet wie folgt:

public final int getPriority();

Prioritäten verwenden

Nachdem wir die Prioritäten kurz verstanden haben, wollen wir anhand eines einfachen Beispiels demonstrieren, wie Prioritäten verwendet werden.

Beispiel 1

Erstellen Sie Threads mithilfe der Thread-Klasse bzw. der Runnable-Schnittstelle und weisen Sie ihnen Prioritäten zu.

public class FirstThreadInput extends Thread
{
    public void run()
    {
        System.out.println("调用FirstThreadInput类的run()重写方法");    //输出字符串
        for(int i=0;i<5;i++)
        {
            System.out.println("FirstThreadInput线程中i="+i);    //输出信息
            try
            {
                Thread.sleep((int) Math.random()*100);    //线程休眠
            }
            catch(Exception e){}
        }
    }
}

(2) Erstellen Sie eine SecondThreadInput-Klasse, die die Runnable-Schnittstelle und die run()-Methode implementiert. Der Code lautet wie folgt:

public class SecondThreadInput implements Runnable
{
    public void run()
    {
        System.out.println("调用SecondThreadInput类的run()重写方法");    //输出字符串
        for(int i=0;i<5;i++)
        {
            System.out.println("SecondThreadInput线程中i="+i);    //输出信息
            try
            {
                Thread.sleep((int) Math.random()*100);    //线程休眠
            }
            catch(Exception e){}
        }
    }
}

(3) 创建 TestThreadInput 测试类，分别使用 Thread 类的子类和 Runnable 接口的对象创建线程，然后调用 setPriority() 方法将这两个线程的优先级设置为 4，最后启动线程。代码如下：

public class TestThreadInput
{
    public static void main(String[] args)
    {
        FirstThreadInput fti=new FirstThreadInput();
        Thread sti=new Thread(new SecondThreadInput());
        fti.setPriority(4);
        sti.setPriority(4);
        fti.start();
        sti.start();
    }
}

(4) 运行上述代码，运行结果如下所示。

调用FirstThreadInput类的run()重写方法
调用SecondThreadInput类的run()重写方法
FirstThreadInput线程中i=0
SecondThreadInput线程中i=0
FirstThreadInput线程中i=1
FirstThreadInput线程中i=2
SecondThreadInput线程中i=1
FirstThreadInput线程中i=3
SecondThreadInput线程中i=2
FirstThreadInput线程中i=4
SecondThreadInput线程中i=3
SecondThreadInput线程中i=4

由于该例子将两个线程的优先级都设置为 4，因此它们交互占用 CPU ，宏观上处于并行运行状态。

重新更改 ThreadInput 类的代码、设置优先级。代码如下：

fti.setPriority(1);
sti.setPriority(10);

重新运行上述代码，如下所示。

调用FirstThreadInput类的run()重写方法
调用SecondThreadInput类的run()重写方法
FirstThreadInput线程中i=0
SecondThreadInput线程中i=0
SecondThreadInput线程中i=1
SecondThreadInput线程中i=2
SecondThreadInput线程中i=3
SecondThreadInput线程中i=4
FirstThreadInput线程中i=1
FirstThreadInput线程中i=2
FirstThreadInput线程中i=3
FirstThreadInput线程中i=4

Das obige ist der detaillierte Inhalt vonSo führen Sie Threads in der von ihnen selbst angegebenen Reihenfolge in Java aus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!