Quelle est la différence entre java wait et sleep

Donc, la plus grande différence entre les méthodes sleep() et wait() est :

·Lorsque sleep() dort, le verrou de l'objet est conservé et le verrou est toujours occupé ;

 ·Mais wait() et sleep() peuvent interrompre l'état de pause du thread via la méthode interrompu(), ce qui amène le thread à lancer immédiatement InterruptedException (mais cette méthode n'est pas recommandée).

/**
 * Created by jiankunking on 2018/4/5.
 */
public class ThreadTest implements Runnable {
    int number = 10;
    public void addHundred() throws Exception {
        System.out.println("addHundred  begin");
        synchronized (this) {
            number += 100;
            System.out.println("addHundred:" + number);
        }
        System.out.println("addHundred  end");
    }
    public void wait2Seconds() throws Exception {
        System.out.println("wait2Seconds begin ");
        synchronized (this) {
            /**
             * (休息2S,阻塞线程)
             * 以验证当前线程对象的机锁被占用时,
             * 是否被可以访问其他同步代码块
             */
            System.out.println(".............wait begin..................");
            this.wait(2000);
            number *= 200;
            System.out.println(".............wait end..................");
        }
        System.out.println("wait2Seconds end ");
    }
    public void sleep2Seconds() throws Exception {
        System.out.println("sleep2Seconds begin ");
        synchronized (this) {
            /**
             * (休息2S,阻塞线程)
             * 以验证当前线程对象的机锁被占用时,
             * 是否被可以访问其他同步代码块
             */
            System.out.println("............sleep begin...................");
            Thread.sleep(2000);
            number *= 200;
            System.out.println(".............sleep end..................");
        }
        System.out.println("sleep2Seconds end ");
    }
    @Override
    public void run() {
        try {
            addHundred();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws Exception {
        ThreadTest threadTest = new ThreadTest();
        Thread thread = new Thread(threadTest);
        thread.start();
        //threadTest.sleep2Seconds();
        //threadTest.wait2Seconds();
    }
}

Lorsque threadTest.sleep2Seconds(), le résultat de sortie est le suivant :

Lorsque threadTest.wait2Seconds(), le résultat de sortie est le suivant :

sleep2Seconds()/wait2Seconds() est représenté par secondMethod() :

Analysons brièvement ce code, instancions ThreadTest dans la méthode main() et démarrez le thread, puis appelez une méthode (secondMethod()) du thread. Comme la méthode est appelée dans le thread principal, la méthode ordinaire appelée secondMethod()) sera exécutée en premier (mais ce n'est pas la méthode thread du thread). objet qui termine l'exécution de la méthode ordinaire. Exécution, lors de l'exécution des méthodes ordinaires, les méthodes du thread seront également exécutées en alternance, sauf que les méthodes ordinaires du thread principal seront exécutées en premier), donc. lorsque le programme est en cours d'exécution, secondMethod() sera exécuté en premier, et secondMethod Il y a un bloc synchronisé dans le fragment de code de la méthode (), donc après l'exécution de la méthode secondMethod, la méthode occupera le verrou machine de l'objet, provoquant le thread de l'objet méthode à bloquer et ne peut pas être exécutée jusqu'à ce que secondeMethod libère le verrou ;

Lors de l'utilisation de la méthode Thread.sleep(2000), parce que sleep bloque le thread et maintient le verrou de l'objet, d'autres threads synchronisés (secondMethod()) de l'objet ne peut pas être exécuté tant que le bloc synchronisé n'est pas exécuté (la veille est terminée), la méthode secondMethod() peut être exécutée, donc le résultat de sortie est :

number*200+100；

Lors de l'utilisation de la méthode this.wait(2000), la méthode secondMethod() verrouille également le verrou machine de l'objet après son exécution et s'exécute sur ce .wait(2000), la méthode dormira pendant 2S et libérera le verrou actuellement détenu. À ce moment, la méthode de synchronisation du. thread sera exécuté (car le verrou détenu par secondMethod a été libéré par wait()), donc la sortie Le résultat est :

number+100;

Plusieurs points à noter sur la méthode sleep en Java :

1. La méthode Thread.sleep() est utilisée pour suspendre l'exécution du thread et placer le CPU sur le planificateur de thread.

2. La méthode Thread.sleep() est une méthode statique, qui met en pause le thread en cours d'exécution. 3. Java a deux méthodes de veille, l'une n'a qu'un seul paramètre milliseconde et l'autre a deux paramètres, millisecondes et nanosecondes.

4. Contrairement à la méthode wait, la méthode sleep ne libère pas le verrou.

5. Si un autre thread interrompt un thread en veille, la méthode sleep lancera une exception interrompue.

6. Il n'est pas garanti qu'un thread dormant obtienne le CPU après son réveil. Il entrera d'abord dans l'état prêt et entrera en compétition avec d'autres threads pour le CPU.

7. Il y a un endroit sujet aux erreurs Lorsque t.sleep() est appelé, le thread t sera mis en pause. C'est faux car Thread.sleep est une méthode statique qui met le thread actuel en veille au lieu du thread t.

8. La méthode d'attente doit être utilisée dans un environnement synchronisé, tel qu'une méthode synchronisée ou un bloc de code synchronisé. Si vous ne l'utilisez pas dans des conditions synchronisées, une IllegalMonitorStateException sera levée. De plus, la méthode sleep n'a pas besoin d'être appelée dans des conditions synchrones, vous pouvez l'utiliser normalement.

9. La méthode wait est utilisée et définie dans la classe Object, tandis que la méthode sleep fonctionne sur le thread actuel et est définie dans la classe java.lang.Thread.

Le site Web PHP chinois propose un grand nombre de

tutoriels d'introduction au JAVA

gratuits, tout le monde est invité à apprendre !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!