Was sind die vier am häufigsten verwendeten Thread-Funktionen in Java?

1. wait()

bewirkt, dass der aktuelle Thread wartet, bis er geweckt wird, normalerweise durch Benachrichtigung oder Unterbrechung, oder bis eine bestimmte Echtzeitzeit abgelaufen ist.

Selbst gehört zu einer Object-Klasse. Sie können dem Quellcode entnehmen: public class Object {

Wenn Sie sich den Quellcode ansehen, sehen Sie, dass es drei überladene Methoden gibt:

//第一个重载函数
public final void wait() throws InterruptedException {
        wait(0L);
    }
    
//第二个重载函数
public final native void wait(long timeoutMillis) throws InterruptedException;


//第三个重载函数
public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
        if (timeoutMillis < 0) {
            throw new IllegalArgumentException("timeoutMillis value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0 && timeoutMillis < Long.MAX_VALUE) {
            timeoutMillis++;
        }

        wait(timeoutMillis);
    }

Der spezifische tatsächliche Aufrufcode lautet wie folgt:

Wenn die Wartefunktion innerhalb dieser 4 Sekunden ausgeführt wird, wird die Sperre aufgehoben und der Thread angehalten. Wenn Sie innerhalb dieser vier Sekunden mit notify() kooperieren, können Sie aufwachen und die Sperre erhalten. Wenn Sie nicht aufwachen, warten Sie, bis andere konkurrieren. Nach 4 Sekunden wird die Sperre standardmäßig automatisch aufgehoben

Während der aktuelle Thread auf Thread.wait() wartet, kann er, wenn Thread endet, automatisch aufwachen und die Sperre automatisch aufheben

@Override
public void run() {
       synchronized (a) {
           a.wait(4000);      
       }
}

2

join ist die Thread-Klassenmethode

Sehen Sie sich den Quellcode an. Die Hauptzeitparameterlogik der drei überladenen Methoden

//第一个重载函数
public final synchronized void join(final long millis)
    throws InterruptedException {
        if (millis > 0) {
            if (isAlive()) {
                final long startTime = System.nanoTime();
                long delay = millis;
                do {
                    wait(delay);
                } while (isAlive() && (delay = millis -
                        TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)) > 0);
            }
        } else if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            throw new IllegalArgumentException("timeout value is negative");
        }
    }


//第二个重载函数
/*等待该线程死亡的时间最多为毫秒加纳秒。 如果两个参数都为0，则意味着永远等待。  
这个实现使用了This的循环。 等待电话以this.isAlive为条件。 当一个线程终止this。 
调用notifyAll方法。 建议应用程序不要使用wait、notify或notifyAll on Thread实例。  */
public final synchronized void join(long millis, int nanos)
throws InterruptedException {

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos > 0 && millis < Long.MAX_VALUE) {
        millis++;
    }

    join(millis);
}


//第三个重载函数
/*等待线程死亡。  
此方法的调用与调用的行为完全相同  

InterruptedException—如果任何线程中断了当前线程。 当抛出此异常时，当前线程的中断状态将被清除。  */
public final void join() throws InterruptedException {
     join(0);
 }

ist wie folgt:

• ist kleiner als 0, eine Ausnahme geworfen

• ist gleich 0, verbinde(A), bestimme, ob A existiert, und führe die Operation nur aus, wenn es existiert. Dieser Thread führt den Wartevorgang (0) aus und wartet darauf, dass Thread A die Ausführung beendet, bevor er beendet werden kann Fahren Sie fort, nachdem die Wartezeit abgelaufen ist.

• 3. Sleep ()

wait(): CPU-Ressourcen aufgeben und Ressourcen sperren.

Sehen Sie sich den Quellcode der Funktion „sleep“ an. Es gibt zwei überladene Funktionen.

• Beide sind Funktionen der Thread-Klasse function
  both Es handelt sich um eine Funktion der Thread-Klasse, die dem Scheduler anzeigt, dass der aktuelle Thread bereit ist, seine aktuelle Nutzung des Prozessors aufzugeben. Der Planer kann diese Aufforderung ignorieren.
• Yield ist ein heuristischer Versuch, den relativen Fortschritt zwischen Threads zu verbessern, die andernfalls die CPU überlasten würden. Der Einsatz sollte mit einer detaillierten Analyse und einem Benchmarking gekoppelt werden, um sicherzustellen, dass es tatsächlich die beabsichtigte Wirkung erzielt.
  Die Verwendung dieser Methode ist selten angemessen. Es kann zu Debug- oder Testzwecken verwendet werden, wo es dabei helfen kann, Fehler aufgrund von Rennbedingungen zu reproduzieren. Es kann auch nützlich sein, wenn Konstrukte zur Parallelitätskontrolle entworfen werden, wie beispielsweise diejenigen im Paket java.util.concurrent.locks.

/*根据系统计时器和调度器的精度和准确性，
使当前执行的线程在指定的毫秒数内处于睡眠状态(暂时停止执行)。 
线程不会失去任何监视器的所有权。*/
public static native void sleep(long millis) throws InterruptedException;



/*导致当前执行的线程在指定的毫秒数加上指定的纳秒数
(取决于系统计时器和调度器的精度和准确性)内休眠(暂时停止执行)。 
线程不会失去任何监视器的所有权。  */
public static void sleep(long millis, int nanos)
    throws InterruptedException {
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0 && millis < Long.MAX_VALUE) {
            millis++;
        }

        sleep(millis);
    }

Im Allgemeinen sind die Hauptfunktionen der Yield-Funktion:
CPU-Planung aufgeben und Threads anhalten, aber die Zeit kann vom Benutzer nicht angegeben werden
Es können nur Ausführungsmöglichkeiten mit derselben Priorität zugelassen werden
5 . Zusammenfassung
Warten Sie den Thread an, geben Sie die CPU auf und geben Sie die Sperre frei. (Objektklasse)
join hält den Thread an und kann erst nach der Ausführung des Threads zu seinem eigenen Thread zurückkehren. (Thread-Klasse)
sleep pausiert den Thread und gibt die CPU frei, ohne die Sperre aufzuheben. (Thread-Klasse)
yield pausiert den Thread, kann jedoch nicht vom Benutzer angegeben werden. Es kann nur der gleichen Priorität die Möglichkeit zur Ausführung gegeben werden. (Thread-Klasse)
5.1 Der Unterschied zwischen Warten und Beitreten
Nachdem wir den obigen Quellcode und Logikcode gelesen haben, sprechen wir über die Ähnlichkeiten und Unterschiede zwischen den beiden.
Allgemein
Wartefunktion: Stellt den aktuellen Thread ein In einen Wartezustand wird wait() zusammen mit den Methoden notify() und notifyAll() verwendet. notify ist die Weckfunktion.
Join-Funktion: Warten Sie, bis dieser Thread endet, bevor Sie Ihren eigenen Thread ausführen. Seine Hauptfunktion besteht darin, zu synchronisieren und die Ausführung zwischen Threads von „parallel“ in „seriell“ zu ändern. Wenn die join()-Methode von Thread B in Thread A aufgerufen wird, ändert sich der Ausführungsprozess von Thread
: Thread A muss warten, bis Thread B die Ausführung abgeschlossen hat, bevor er mit der Ausführung fortfahren kann
Gemeinsame Punkte:
Pause Der aktuelle Thread

• kann durch Interrupt aufgeweckt werden

• Der Unterschied ist:

Der Unterschied

warten

• beitreten

• Klasse Objekt

Thread-Klasse
Zweck Kommunikation zwischen ThreadsSortieren, seriell passieren lassenSynchronisationMuss synchronisiert seinSie können synchronisiert nicht verwenden5.2 Der Unterschied zwischen Warten und Schlafen Der Unterschied berücksichtigt hauptsächlich zwei Punkte: 1. Ob die CPU weiterhin ausgeführt wird, 2. Ob die Sperre aufgehoben wird. Aber beide geben CPU-Ressourcen auf

warte( ): Geben Sie CPU-Ressourcen auf und sperren Sie Ressourcen.	sleep(long mills): Geben Sie CPU-Ressourcen auf, geben Sie jedoch keine Sperrressourcen frei.	Der Unterschied hängt hauptsächlich vom Betriebsmechanismus der CPU ab:
In der letzten Analyse:	wait, notify, notifyall sind alle Methoden des Object-Objekts. Sie werden zusammen verwendet und für den Sperrmechanismus verwendet, sodass die Sperre aufgehoben wird.	Und Sleep ist eine Thread-Klasse, die hat nichts mit der Sperre zu tun und gibt die Sperre nicht frei

Das obige ist der detaillierte Inhalt vonWas sind die vier am häufigsten verwendeten Thread-Funktionen in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!