Le concept et la solution du blocage en Java

1. Processus de blocage et solutions

1. Points clés

(1) Maîtriser la notion de blocage et l'apparition d'un blocage La cause première du blocage.

(2) Comprendre les conditions nécessaires à l'impasse - les quatre conditions suivantes doivent être remplies en même temps : condition d'exclusion mutuelle, condition de non-préemption, condition de possession et d'application et condition d'attente de boucle.

(3) Rappelez-vous les méthodes générales de résolution des blocages et maîtrisez les idées de base de la prévention des blocages et de l'évitement des blocages.

(4) Maîtriser la stratégie d'allocation ordonnée des ressources dans la stratégie de prévention des impasses.

(5) Comprendre le concept de séquence de sécurité des processus et la relation entre l'impasse et la séquence de sécurité.

(6) Comprendre l’algorithme du banquier.

(7) Comprendre le diagramme d'allocation des ressources.

(8) Comprendre les idées de détection et de récupération des impasses.

2. Concernant l'impasse, ma compréhension personnelle :

Après une période d'étude, la notion d'impasse que je comprends est que, par exemple, il y a deux processus , chaque processus A est verrouillé par deux verrous (Lock 1, Lock 2). La différence est que les emplacements d'application du verrou sont différents dans les deux processus. Par conséquent, le démarrage complet d’un processus nécessite un verrou interne, et ce verrou se trouve dans un autre processus. Le verrou dont un autre processus a besoin pour démarrer (ou exécuter) complètement le processus interne se trouve dans un autre programme. De cette façon, ils sont liés les uns aux autres, et ils sont tous en état de préparation mais incapables d'exécuter. A provoqué un état de blocage. J'ai dessiné un diagramme schématique basé sur ma compréhension :

3. Un code simple sur l'impasse :

public class Test15 {public static void main(String[] args) throws InterruptedException {new Thread(new DeadLockThread(true)).start();//Thread.sleep(10);在中间用上它可以使结果交替出现，我是为了看死锁的效果，用它对比一下。new Thread(new DeadLockThread(false)).start();
    }
}class DeadLockThread implements Runnable {static Object o1 = new Object();static Object o2 = new Object();private boolean flag;

    DeadLockThread(boolean flag) {this.flag = flag;
    }public void run() {if (flag == true) {while (true) {synchronized (o1) {
                    System.out.println("这是锁o1");synchronized (o2) {
                        System.out.println("这是锁o2");
                    }

Résultats d'impression :

4 Supplément :

Concernant l'impasse, j'ai cherché Based. sur certaines informations, j'ai l'impression que les problèmes ici sont assez compliqués. A ce stade, seuls ces principes simples sont compris. Nous pouvons également comprendre grossièrement que quatre conditions doivent être remplies pour qu’une impasse se produise.

1) Conditions d'exclusion mutuelle :

signifie qu'un processus utilise exclusivement les ressources allouées, c'est-à-dire qu'une certaine ressource n'est occupée que par un seul processus sur une période de temps. S'il existe d'autres processus demandant des ressources à ce moment-là, le demandeur ne peut qu'attendre que le processus occupant les ressources soit épuisé et libéré.

2) Conditions de demande et de maintien :

signifie que le processus a détenu au moins une ressource, mais a fait une nouvelle demande de ressource et que la ressource a été occupée par d'autres processus. le temps, le processus de demande est bloqué, mais conserve les autres ressources qu’ils ont obtenues.

3) Conditions de non-privation :

fait référence aux ressources que le processus a obtenues. Il ne peut être privé avant d'être épuisé, et ne peut être libéré par lui-même qu'au moment de son utilisation. en haut.

4) Condition d'attente de boucle :

signifie que lorsqu'une impasse se produit, il doit y avoir un processus - une chaîne circulaire de ressources, c'est-à-dire l'ensemble de processus {P0, P1, P2, ... , P0 dans Pn} attend une ressource occupée par P1 ; P1 attend une ressource occupée par P2,..., Pn attend une ressource occupée par P0.

Pièce jointe :

1) L'appel de la méthode sleep() ne permettra pas au thread de libérer le verrou de synchronisation qu'il détient et pendant cette période, il n'empêchera pas les autres ; threads de l'exécution

2) Appelez la méthode wait(), et le thread en cours d'exécution entrera dans l'état d'attente, attendant que d'autres threads appellent à nouveau la méthode notify() ou notifyAll() de cet objet pour se réveiller ou lorsque le temps d'attente spécifié est atteint, le fil se réveille automatiquement.

Si un thread possède un verrou de synchronisation sur un ou plusieurs objets, alors après avoir appelé wait(), le thread libérera toutes les ressources de synchronisation qu'il détient, sans se limiter à celle qui a appelé l'objet de méthode wait() . .

3) Dans le développement réel, les blocages sont généralement profondément cachés et difficiles à détecter. Une fois qu'un blocage se produit, cela entraînera inévitablement une paralysie du programme. Il faut donc l’éviter.

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!