Ce qui est une impasse?

Laissez-moi vous expliquer un monde réel (et non pas réel) exemple pour une situation de blocage de la criminalité films. Imaginez un criminel détient un otage et contre qui, un flic est également titulaire d'un otage qui est un ami du criminel. Dans ce cas, pénale est a pas l'intention de laisser l'otage aller si cop de ne pas laisser son ami se laisser aller. Aussi le flic ne va pas laisser l'ami du criminel de laisser aller, à moins que le criminel libère les otages. C'est sans fin situation indigne de confiance, parce que les deux parties ont insisté sur le fait que la première étape les uns des autres.

Pénale & Cop Scène

Donc, tout simplement, lorsque deux threads besoin de deux ressources différentes et chacun d'eux a le verrou de la ressource que les autres ont besoin, c'est une impasse.

Un autre de Haut Niveau de l'Explication de l'Impasse : le Cœur Brisé

Vous sortez avec une fille et un jour, après une dispute, les deux côtés sont cœur brisé, les uns aux autres et en attente d'une je-suis-excusez-moi-et-je-raté-vous appel. Dans ce cas, les deux côtés veulent communiquer entre eux si et seulement si l'un d'eux reçoit un je-suis-désolé appel de l'autre. Parce qu'aucun de chaque va commencer la communication et de l'attente dans un état passif, les deux vont attendre que l'autre pour démarrer la communication, qui se retrouve dans une situation de blocage.

Pour définir l'impasse, je souhaite tout d'abord définir les processus.

Processus : Comme nous le savons, le processus n'en est rien, mais un program dans l'exécution.

Ressources : Pour exécuter un programme, le processus a besoin de quelques ressources. Catégories de ressources peuvent inclure la mémoire, imprimantes, unités centrales, ouvrir des fichiers, lecteurs de bande, CD-ROM, etc.

Impasse : Blocage est une situation ou une condition lorsque deux ou plusieurs processus sont la tenue de certaines ressources et d'essayer d'acquérir certains de plus de ressources, et ils ne peuvent pas libérer les ressources jusqu'à la fin il y a exécution.

Condition de blocage ou de la situation

Dans le diagramme ci-dessus, il existe deux processus de P1 et p2 et il y a deux ressources R1 et R2.

Ressources R1 est affecté à traiter P1 et des ressources R2 est affecté à traiter p2.
Pour achever l'exécution de processus P1 besoins de ressources R2, donc P1 demande de R2, mais R2 est déjà affecté à P2.

De la même façon le Processus de P2 pour terminer son exécution doit R1, mais R1 est déjà affecté à P1.

à la fois les processus ne peuvent pas se libérer de leurs ressources jusqu'à ce que et à moins qu'ils ont terminé leur exécution. Donc les deux sont en attente pour un autre ressources et ils vont attendre pour toujours. C'est donc un IMPASSE Condition.

Afin de blocage de se produire, quatre conditions doivent être remplies.

1. Exclusion mutuelle - Chaque ressource est actuellement alloués à un seul processus ou il est disponible. (Deux processus ne peuvent pas
   contrôler simultanément la même ressource ou être dans leur critique
   la section).
2. Tenir et Attendre - processus actuellement en possession de ressources peut demander de nouvelles ressources.
3. Pas de droit de préemption - une Fois qu'un processus est titulaire d'une ressource, il ne peut pas être enlevé par un autre processus ou le noyau.
4. Circulaire attendre - Chaque processus est en attente pour obtenir une ressource qui est tenu par un autre processus.

et toutes ces conditions sont remplies dans le schéma ci-dessus.

Vous pouvez prendre un coup d'oeil à ce merveilleux articles, en vertu de l'article Impasse. Il est en C#, mais l'idée est toujours la même pour les autres plate-forme. Je cite ici pour faciliter la lecture

Un blocage se produit lorsque les deux fils de chaque attendez une ressource détenue par
les autres, afin que personne ne puisse continuer. La façon la plus simple pour illustrer cette
est avec deux serrures:

object locker1 = new object();
object locker2 = new object();

new Thread (() => {
                    lock (locker1)
                    {
                      Thread.Sleep (1000);
                      lock (locker2);      //Deadlock
                    }
                  }).Start();
lock (locker2)
{
  Thread.Sleep (1000);
  lock (locker1);                          //Deadlock
}

Un blocage se produit quand il ya une chaîne circulaire de threads ou processus qui détiennent chacun une ressource verrouillée et tentent de verrouiller une ressource détenue par l'élément suivant dans la chaîne. Par exemple, les deux fils qui détiennent respectivement Une serrure et verrou B, et sont tous les deux en train d'acquérir le verrouillage de l'autre.

Un blocage est un état d'un système dans lequel aucun processus/thread est capable d'exécuter une action. Comme mentionné par d'autres, un blocage est généralement le résultat d'une situation où chaque processus/thread souhaite acquérir un verrou sur une ressource qui est déjà verrouillé par un autre (ou le même) processus/thread.

Il existe différentes méthodes pour les trouver et de les éviter. On pense très dur et/ou d'essayer beaucoup de choses. Cependant, en traitant avec le parallélisme est notoirement difficile et la plupart (si pas tous) les gens ne seront pas en mesure d'éviter complètement les problèmes.

Certaines des méthodes plus formelles peuvent être utiles si vous êtes sérieux à propos de la gestion de ces types de problèmes. La méthode la plus pratique que j'en suis conscient, c'est d'utiliser le processus de l'approche de la théorie. Ici le modèle de votre système dans certains processus de la langue (p. ex. CCS, CSP, ACP, mCRL2, LOTOS) et utiliser les outils disponibles pour (modèle)vérifier les blocages (et peut être quelques autres propriétés). Des exemples de l'ensemble d'outils à utiliser sont FDR, mCRL2, PCA et Uppaal. Quelques âmes courageuses peut même se révéler leurs systèmes de blocage gratuitement en utilisant uniquement des méthodes symboliques (théorème de prouver, regardez pour Owicki-Gries).

Cependant, ces méthodes formelles en général ne nécessitent un certain effort (par exemple pour apprendre les bases de la théorie des processus). Mais je suppose que c'est simplement une conséquence du fait que ces problèmes sont difficiles.

Au-dessus de certaines explications sont gentils. Espérons que ce peut aussi utile:
https://ora-data.blogspot.in/2017/04/deadlock-in-oracle.html

Dans une base de données, lors d'une session (par exemple, ora) veut une ressource détenue par une autre session (par exemple, données), mais cette session (données) veut aussi une ressource qui est tenue par la première session (ora). Il peut y avoir plus de 2 sessions impliqués aussi mais l'idée sera la même.
En fait, les Blocages, de prévenir certaines transactions de continuer à travailler.
Par exemple:
Supposons que, ORA-DONNÉES est titulaire d'Une serrure et des demandes de verrouillage B
Et le SKU est titulaire de verrouillage B et demandes de verrouillage A.

Merci,

Un classique et très simple pour la compréhension de Impasse situation :-

public class Lazy {

    private static boolean initialized = false;

    static {
        Thread t = new Thread(new Runnable() {
            public void run() {
                initialized = true;
            }
        });

        t.start();

        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        System.out.println(initialized);
    }
}

Lorsque le thread principal invoque Paresseux.principal, il vérifie si la classe Paresseux
a été initialisé et commence à initialiser la classe. L'
thread principal définit maintenant initialisé à false , il crée et démarre un arrière-plan
fil dont la méthode run jeux initialisé à true , et attend que le thread d'arrière-plan au complet.

Ce temps, la classe est actuellement en cours d'initialisation par un autre thread.
Dans ces circonstances, le thread actuel, qui est le thread d'arrière-plan,
attend sur la Classe de l'objet jusqu'à ce que l'initialisation est terminée. Malheureusement, le fil
qui est en train de faire l'initialisation, le thread principal, est en attente pour le fond
thread terminer. Parce que les deux fils sont maintenant attendre les uns les autres, la
le programme est dans l'IMPASSE.