Java-Thread-Priorität

Java-Thread-Priorität

In der Thread-Klasse werden die folgenden Attribute verwendet, um die Priorität darzustellen.

private int priority;

Wir können über setPriority(int newPriority) eine neue Priorität festlegen und über getPriority() die Priorität des Threads abrufen.

Einige Informationen lassen sich anhand des folgenden Beispiels zusammenfassen: Die Standardpriorität von Java-Threads ist 5.

public static void main(String[] args) {
    Thread thread = new Thread();
    System.out.println(thread.getPriority());
}
// 打印结果：5

Tatsächlich ist das völlig falsch. Schauen Sie sich das Beispiel unten an. Wir haben festgestellt, dass die Priorität des untergeordneten Threads ebenfalls 4 ist .

public static void main(String[] args) {
    Thread.currentThread().setPriority(4);
    Thread thread = new Thread();
    System.out.println(thread.getPriority());
}

// 打印结果：4

Das ist ein Schlag ins Gesicht. Wenn die Standardpriorität eines Threads 5 ist, hat unser neu erstellter Thread keine Priorität. Sie sollte 5 sein, aber tatsächlich ist sie 4. Werfen wir einen Blick auf den Quellcode der Thread-Initialisierungspriorität.

Thread parent = currentThread();
this.priority = parent.getPriority();

Es stellt sich heraus, dass die Standardpriorität eines Threads darin besteht, die Priorität des übergeordneten Threads zu erben. Im obigen Beispiel haben wir die Priorität des übergeordneten Threads auf 4 gesetzt, also die Priorität des untergeordneten Threads wird auch 4.

Genau genommen ist die Standardpriorität des untergeordneten Threads dieselbe wie die des übergeordneten Threads, und die Standardpriorität des Java-Hauptthreads ist 5.

In Java sind drei Prioritäten definiert, nämlich die niedrigste Priorität (1), die normale Priorität (5) und die höchste Priorität (10). Der Code lautet wie folgt. Der Java-Prioritätsbereich ist [1, 10]. Wenn Sie die Priorität anderer Zahlen festlegen, wird eine IllegalArgumentException-Ausnahme ausgelöst.

/**
 * The minimum priority that a thread can have.
 */
public final static int MIN_PRIORITY = 1;

/**
 * The default priority that is assigned to a thread.
 */
public final static int NORM_PRIORITY = 5;

/**
 * The maximum priority that a thread can have.
 */
public final static int MAX_PRIORITY = 10;

Als Nächstes sprechen wir über die Rolle der Thread-Priorität. Schauen wir uns zunächst den folgenden Code an. Die Codelogik besteht darin, 3000 Threads zu erstellen: 1000 Threads mit Priorität 1, 1000 Threads mit Priorität 5 und 1000 Threads mit Priorität 10. Verwenden Sie minTimes, um die Summe der Laufzeitzeitstempel von 1000 MIN_PRIORITY-Threads aufzuzeichnen, verwenden Sie normTimes, um die Summe der Laufzeitzeitstempel von 1000 NORM_PRIORITY-Threads aufzuzeichnen, und verwenden Sie maxTimes, um die Summe der Laufzeitzeitstempel von 1000 MAX_PRIORITY-Threads aufzuzeichnen. Durch Zählen der Summe der laufenden Zeitstempel jeder Prioritätsstufe gilt: Je kleiner der Wert, desto höher die Priorität. Lassen Sie es uns ausführen und sehen.

public class TestPriority {
    static AtomicLong minTimes = new AtomicLong(0);
    static AtomicLong normTimes = new AtomicLong(0);
    static AtomicLong maxTimes = new AtomicLong(0);

    public static void main(String[] args) {
        List<MyThread> minThreadList = new ArrayList<>();
        List<MyThread> normThreadList = new ArrayList<>();
        List<MyThread> maxThreadList = new ArrayList<>();

        int count = 1000;
        for (int i = 0; i < count; i++) {
            MyThread myThread = new MyThread("min----" + i);
            myThread.setPriority(Thread.MIN_PRIORITY);
            minThreadList.add(myThread);
        }
        for (int i = 0; i < count; i++) {
            MyThread myThread = new MyThread("norm---" + i);
            myThread.setPriority(Thread.NORM_PRIORITY);
            normThreadList.add(myThread);
        }
        for (int i = 0; i < count; i++) {
            MyThread myThread = new MyThread("max----" + i);
            myThread.setPriority(Thread.MAX_PRIORITY);
            maxThreadList.add(myThread);
        }

        for (int i = 0; i < count; i++) {
            maxThreadList.get(i).start();
            normThreadList.get(i).start();
            minThreadList.get(i).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("maxPriority 统计：" + maxTimes.get());
        System.out.println("normPriority 统计：" + normTimes.get());
        System.out.println("minPriority 统计：" + minTimes.get());
        System.out.println("普通优先级与最高优先级相差时间：" + (normTimes.get() - maxTimes.get()) + "ms");
        System.out.println("最低优先级与普通优先级相差时间：" + (minTimes.get() - normTimes.get()) + "ms");

    }

    static class MyThread extends Thread {

        public MyThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            System.out.println(this.getName() + " priority: " + this.getPriority());
            switch (this.getPriority()) {
                case Thread.MAX_PRIORITY :
                    maxTimes.getAndAdd(System.currentTimeMillis());
                    break;
                case Thread.NORM_PRIORITY :
                    normTimes.getAndAdd(System.currentTimeMillis());
                    break;
                case Thread.MIN_PRIORITY :
                    minTimes.getAndAdd(System.currentTimeMillis());
                    break;
                default:
                    break;
            }
        }
    }
}

Die Ausführungsergebnisse sind wie folgt:

# 第一部分
max----0 priority: 10
norm---0 priority: 5
max----1 priority: 10
max----2 priority: 10
norm---2 priority: 5
min----4 priority: 1
.......
max----899 priority: 10
min----912 priority: 1
min----847 priority: 5
min----883 priority: 1

# 第二部分
maxPriority 统计：1568986695523243
normPriority 统计：1568986695526080
minPriority 统计：1568986695545414
普通优先级与最高优先级相差时间：2837ms
最低优先级与普通优先级相差时间：19334ms

Lassen Sie uns die Ergebnisse gemeinsam analysieren. Schauen wir uns zunächst den ersten Teil an. Die am Anfang ausgeführten Threads haben eine hohe Priorität, eine normale Priorität und eine niedrige Priorität. Dies zeigt, dass Threads mit hoher Priorität nicht unbedingt eine höhere Priorität bedeuten als Threads mit höherer Priorität werden zuerst ausgeführt. Man kann es auch anders formulieren: Die Reihenfolge der Codeausführung hat nichts mit der Priorität des Threads zu tun. Wenn wir uns die Ergebnisse des zweiten Teils ansehen, können wir feststellen, dass die Summe der Ausführungszeitstempel der 1000 Threads mit der höchsten Priorität am kleinsten ist, während die Summe der Ausführungszeitstempel der 1000 Threads mit der niedrigsten Priorität am größten ist. Daher können wir wissen: Ein Stapel von Threads mit hoher Priorität wird zuerst ausgeführt als ein Stapel von Threads mit niedriger Priorität. Das heißt, Threads mit hoher Priorität erhalten mit größerer Wahrscheinlichkeit CPU-Ressourcen als Threads mit niedriger Priorität.

Gibt es wirklich 10 Thread-Ebenen in jedem Betriebssystem?

Als plattformübergreifende Sprache verfügt Java über 10 Thread-Ebenen, die den verschiedenen Betriebssystemen zugeordneten Thread-Prioritätswerte sind jedoch unterschiedlich. Als Nächstes zeige ich Ihnen, wie Sie den Wert der Thread-Prioritätszuordnung in jedem Betriebssystem im OpenJDK-Quellcode überprüfen.

Nachdem wir uns den Thread-Quellcode angesehen und die Thread-Priorität festgelegt haben, rufen wir schließlich die lokale Methode setPriority0() auf.

private native void setPriority0(int newPriority);

Dann haben wir die Methode JVM_SetThreadPriority gefunden, die setPriority0() im Thread.c-Code entspricht OpenJDK ;

static JNINativeMethod methods[] = {
    ...
    {"setPriority0",     "(I)V",       (void *)&JVM_SetThreadPriority},
    ...};

Wir finden das entsprechende Codesegment in jvm.cpp basierend auf JVM_SetThreadPriority;

JVM_ENTRY(void, JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio))
  JVMWrapper("JVM_SetThreadPriority");
  // Ensure that the C++ Thread and OSThread structures aren't freed before we operate
  MutexLocker ml(Threads_lock);
  oop java_thread = JNIHandles::resolve_non_null(jthread);
  java_lang_Thread::set_priority(java_thread, (ThreadPriority)prio);
  JavaThread* thr = java_lang_Thread::thread(java_thread);
  if (thr != NULL) {                  // Thread not yet started; priority pushed down when it is
    Thread::set_priority(thr, (ThreadPriority)prio);
  }
JVM_END

Basierend auf dem Code in Schritt 3 können wir feststellen, dass der Schlüssel der Code java_lang_Thread ist: set_Priority() , suchen Sie weiterhin nach der Methode set_Priority() im thread.cpp-Code;

Das obige ist der detaillierte Inhalt vonJava-Thread-Priorität. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!