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的執(zhí)行資格和執(zhí)行權(quán)釋放出去，不再運行此線程，當(dāng)定時事件結(jié)束再取回cpu資源，參與cpu的調(diào)度，獲取到cpu資源后就可以繼續(xù)運行了，而如果sleep時該線程有鎖，那么sleep不會釋放這個鎖，而是把鎖帶著進(jìn)入了凍結(jié)狀態(tài)，也就是說其它需要這個鎖的線程根本不可能獲取到這個鎖。也就是說無法執(zhí)行程序，如果在睡眠期間其它線程調(diào)用了這個線程的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("線程執(zhí)行完成");
    }

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!