Intervieweur : Pourriez-vous s'il vous plaît me dire les différences entre sleep(), wait(), join() et rendement()

Introduisons d'abord les concepts de pool de verrouillage et de pool d'attente.

Examinons d'abord le concept de pool de verrous

Tous les threads qui doivent rivaliser pour les verrous de synchronisation seront placés dans le pool de verrous. Par exemple, si le verrou de l'objet actuel a été. obtenu par l'un des threads, d'autres threads devront attendre dans ce pool de verrouillage, lorsque le thread précédent libère le verrou de synchronisation, les threads du pool de verrouillage se disputent le verrou de synchronisation. Lorsqu'un thread l'obtient, il entrera dans le prêt. file d'attente pour attendre l'allocation des ressources CPU.

Jetons un coup d'œil au concept de pool d'attente

Lorsque nous appelons la méthode wait(), le thread sera placé dans le pool d'attente, et les threads en attente dans le pool ne le seront pas rivaliser pour les verrous de synchronisation. Ce n'est qu'après avoir appelé notify() ou notifyAll() que les threads du pool d'attente commenceront à rivaliser pour le verrou. notify() sélectionne au hasard un thread dans le pool d'attente et le place dans le pool de verrouillage, tandis que notifyAll() place tous les threads. dans le pool d'attente Mettez-le dans le pool de verrouillage.

• sleep est une méthode locale statique de la classe Thread, et wait est une méthode locale de Object.

• La méthode sleep ne libérera pas le verrou, mais l'attente le libérera et l'ajoutera à la file d'attente.

sleep就是把cpu的执行资格和执行权释放出去，不再运行此线程，当定时事件结束再取回cpu资源，参与cpu的调度，获取到cpu资源后就可以继续运行了，而如果sleep时该线程有锁，那么sleep不会释放这个锁，而是把锁带着进入了冻结状态，也就是说其它需要这个锁的线程根本不可能获取到这个锁。也就是说无法执行程序，如果在睡眠期间其它线程调用了这个线程的interrupt方法，那么这个线程也会抛出interruptexception异常返回，这点和wait是一样的。

• La méthode sleep ne dépend pas du synchroniseur synchronisé, mais wait nécessite le mot-clé synchronisé.

• le sommeil n'a pas besoin d'être réveillé (les sorties se bloquent après avoir dormi), mais l'attente le fait (il n'a pas besoin d'être interrompu par d'autres à une heure précise).

• sleep est généralement utilisé pour mettre en veille le thread en cours, ou pour interroger et suspendre les opérations, tandis que wait est principalement utilisé pour la communication entre plusieurs threads.

• sleep abandonnera le temps d'exécution du processeur et forcera le changement de contexte, mais wait ne le fera pas nécessairement. Après l'attente, il peut encore y avoir une chance de concourir à nouveau pour le verrou et de poursuivre l'exécution. .

yield() Après exécution, le thread entre directement dans l'état prêt et libère immédiatement le droit d'exécution du processeur, mais la qualification d'exécution du processeur est toujours conservée, c'est donc possible que le processeur effectuera la planification des threads la prochaine fois. Ce thread sera autorisé à obtenir les droits d'exécution et à poursuivre l'exécution.

(Apprentissage du partage vidéo : tutoriel vidéo Java)

Après l'exécution de join(), le fil entre dans l'état de blocage, par exemple en appelant join() du fil A dans le thread B, puis le thread B entrera dans la file d'attente de blocage et demandera au thread A de terminer ou d'interrompre le thread.

public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            try {
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("休眠sleep线程");
        });
        t1.start();
        t1.join();
        System.out.println("线程执行完成");
    }

Lien original : https://blog.csdn.net/lxn1023143182/article/details/114134498

Recommandations associées : questions et réponses d'entretien Java

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!