Co to jest impas?

Pozwól, że wyjaśnię prawdziwy świat (nie w rzeczywistości prawdziwy) przykład sytuacji impasu z filmów kryminalnych. Wyobraź sobie, że przestępca trzyma zakładnika, A przeciwko temu, policjant trzyma również zakładnika, który jest przyjacielem przestępcy. W tym przypadku przestępca nie wypuści zakładnika, jeśli gliniarz nie pozwoli odejść swojemu przyjacielowi. Również policjant nie pozwoli przyjacielowi przestępcy puścić, chyba że przestępca uwolni zakładnika. Jest to niekończąca się sytuacja niegodna zaufania, ponieważ obie strony są nalegając na pierwszy krok od siebie.

Criminal & Cop Scene

Tak po prostu, gdy dwa wątki potrzebują dwóch różnych zasobów i każdy z nich ma blokadę zasobu, którego drugi potrzebuje, jest to impas.

Kolejny wysoki poziom wyjaśnienia impas: złamane serca

Spotykasz się z dziewczyną i pewnego dnia po kłótni obie strony są sobie złamane serce i czekają na I-am-sorry-and-I-missed-you sprawdzam. W tej sytuacji obie strony chcą się komunikować wtedy i tylko wtedy, gdy jedna z nich otrzyma telefon I-am-sorry od drugiej. Ponieważ żaden z nich nie rozpocznie komunikacji i nie będzie czekał w stanie pasywnym, obaj będą czekać, aż drugi rozpocznie komunikację, która zakończy się w sytuacji impasu.

Blokady pojawią się tylko wtedy, gdy masz dwa lub więcej zamków, które można uzyskać w tym samym czasie i są chwytane w innej kolejności.

Sposoby na uniknięcie deadlocków to:

• unikaj zamków (jeśli to możliwe),
• unikaj posiadania więcej niż jednego zamka
• zawsze przyjmuj zamki w tej samej kolejności.

Aby zdefiniować impas, najpierw zdefiniowałbym proces.

Proces : Jak wiemy Proces jest niczym innym jak program w wykonaniu.

Zasób : aby wykonać proces programu wymaga pewnych zasobów. Kategorie zasobów mogą obejmować pamięć, drukarki, Procesory, otwarte pliki, napędy taśmowe, płyty CD-ROM itp.

Deadlock : impas to sytuacja lub stan, w którym dwa lub więcej procesów trzyma pewne zasoby i próbuje zdobyć niektóre więcej zasobów, i nie mogą zwolnić zasobów, dopóki nie zakończą tam wykonanie.

Stan Lub sytuacja impasu

Na powyższym diagramie znajdują się dwa procesy P1 i p2 oraz dwa zasoby R1 i R2 .

Zasób R1 jest alokowany do procesu P1 , a zasób R2 jest alokowany do procesu p2 . Aby zakończyć realizację procesu P1 potrzebuje zasoby R2, więc P1 Prośba o R2, ale R2 jest już przypisany do P2 .

W ten sam sposób proces P2 aby zakończyć jego wykonanie potrzebuje R1 , ale R1 jest już przypisany do P1 .

Oba procesy nie mogą zwolnić swoich zasobów, dopóki nie zakończą ich wykonywania. Więc obaj czekają na inne zasoby i będą czekać w nieskończoność. Więc to jest impas Warunek.

1. wzajemne wykluczenie - każdy zasób jest obecnie przypisany do dokładnie jednego procesu lub jest dostępny. (Dwa procesy nie mogą jednocześnie kontrolować ten sam zasób lub być w ich krytycznym sekcji).
2. Hold and Wait - procesy aktualnie posiadające zasoby mogą żądać nowych zasobów.
3. No preemption - gdy proces posiada zasób, to nie może zostać odebrany przez inny proces lub jądro.
4. Circular wait - każdy proces czeka na uzyskanie zasobu, który jest przechowywany przez inny proces.

I wszystkie te warunki są spełnione na powyższym diagramie.

Impas ma miejsce, gdy wątek czeka na coś, co nigdy się nie wydarzy.

Zazwyczaj dzieje się tak, gdy wątek czeka na mutex lub SEMAFOR, który nigdy nie został wydany przez poprzedniego właściciela.

Zdarza się to również często, gdy masz sytuację obejmującą dwa wątki i dwa zamki w ten sposób:

Thread 1               Thread 2

Lock1->Lock();         Lock2->Lock();
WaitForLock2();        WaitForLock1();   <-- Oops!

Zazwyczaj je wykrywasz, ponieważ rzeczy, których oczekujesz, nigdy nie robią, lub aplikacja zawiesza się całkowicie.

Możesz zajrzeć do tego wspaniałych artykułów , w sekcji . Jest w C# , ale pomysł jest nadal taki sam dla innych platform. Cytuję tutaj dla łatwego czytania

Impas ma miejsce, gdy dwa wątki czekają na zasób trzymany przez drugi, więc żaden nie może kontynuować. Najprostszym sposobem zilustrowania tego jest z dwoma zamkami:

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
}

Impas jest częstym problemem w problemach wieloprocesorowych/wieloprogramowych w systemie operacyjnym. Powiedzmy, że istnieją dwa procesy P1, P2 i dwa globalnie udostępniane zasoby R1, R2 i w sekcji krytycznej oba zasoby muszą być dostępne

Początkowo system operacyjny przypisuje R1 do przetwarzania P1 i R2 do przetwarzania P2. Ponieważ oba procesy działają jednocześnie, mogą zacząć wykonywać swój kod, ale problem pojawia się, gdy proces uderzy w sekcję krytyczną. Tak więc proces R1 będzie czekał aż proces P2 wyda R2 i vice versa... Więc będą czekać na wieczność(stan impasu).

Mała analogia...

Twoja matka (OS),
Ty (P1),
Twój brat (P2),
Apple (R1),
Nóż (R2),
sekcja krytyczna (cięcie jabłka nożem).

Twoja matka daje Ci jabłko i nóż twojemu bratu na początku.
Obaj są szczęśliwi i grają (wykonując swoje kody).
Ktoś z was chce wyciąć jabłko (sekcja krytyczna) w w pewnym sensie.
Nie chcesz dać jabłka bratu.
Twój brat nie chce ci dać noża.
Więc oboje będziecie długo czekać:)

Impas występuje, gdy istnieje okrągły łańcuch wątków lub procesów, z których każdy utrzymuje zablokowany zasób i próbuje zablokować zasób utrzymywany przez następny element w łańcuchu. Na przykład dwa wątki, które trzymają odpowiednio blokadę a i blokadę B, i oba próbują zdobyć drugi blokadę.

Impas pojawia się, gdy dwa wątki zdobywają blokady, które uniemożliwiają ich postęp. Najlepszym sposobem na ich uniknięcie jest staranny rozwój. Wiele wbudowanych systemów chroni przed nimi za pomocą timera watchdog (timera, który resetuje system, gdy zawiesi się przez pewien czas).

Blokada może być zdefiniowana formalnie jako: zbiór procesów jest zablokowany, jeśli każdy proces w zestawie czeka na zdarzenie, które może spowodować tylko inny proces w zestawie. Ponieważ wszystkie procesy czekają, żaden z nich nigdy nie spowoduje żadnych zdarzeń, które mogłyby obudzić pozostałych członków zestawu, a wszystkie procesy nadal czekają w nieskończoność. Poniżej znajdują się cztery warunki, które muszą być obecne, aby doszło do impasu. Jeśli jeden z nich jest nieobecny, żaden impas nie jest możliwy.

Warunek wzajemnego wykluczenia: każdy zasób jest obecnie przypisany do dokładnie jednego procesu lub jest dostępny.

Warunek wstrzymania i oczekiwania: procesy posiadające zasoby przyznane wcześniej mogą żądać nowych zasobów.

Warunek bez uprzedzenia: zasoby wcześniej przyznane nie mogą być siłą odebrane procesowi. Muszą być wyraźnie zwolnione przez proces, który je przechowuje.

Warunek oczekiwania Okrągłego: musi istnieć okrągły łańcuch dwa lub więcej procesów, z których każdy czeka na zasób utrzymywany przez następnego członka łańcucha. Ogólnie rzecz biorąc, cztery strategie są używane do radzenia sobie z impasami. Są to: Po prostu całkowicie zignoruj problem. Może jeśli to zignorujesz, to zignoruje Ciebie. Wykrywanie i odzyskiwanie: niech pojawią się impasy, wykryją je i podejmą działania. Dynamiczne unikanie przez ostrożną alokację zasobów. Prewencji: poprzez strukturalną negację jednego z czterech warunków niezbędnych do spowodowania impas.

Impas to stan systemu, w którym żaden proces/wątek nie jest w stanie wykonać akcji. Jak wspomniano przez innych, Impas jest zazwyczaj wynikiem sytuacji,w której każdy proces / wątek chce uzyskać blokadę do zasobu, który jest już zablokowany przez inny (lub nawet ten sam) proces/wątek.

Istnieją różne metody ich znajdowania i unikania. Człowiek myśli bardzo ciężko i / lub próbuje wielu rzeczy. Jednak radzenie sobie z paralelizmem jest notorycznie trudne a większość (jeśli nie wszyscy) ludzi nie będzie w stanie całkowicie uniknąć problemów.

Niektóre bardziej formalne metody mogą być przydatne, jeśli poważnie myślisz o radzeniu sobie z tego rodzaju problemami. Najbardziej praktyczną metodą, jaką znam, jest wykorzystanie podejścia teoretycznego procesu. CCS, CSP, ACP, mCRL2, LOTOS) i użyj dostępnych narzędzi, aby (model-)sprawdzić blokady (i być może niektóre inne właściwości). Przykładami narzędzi do użycia są FDR, mCRL2, CADP i Uppaal. Niektóre odważne dusze mogą nawet udowodnić, że ich systemy są wolne od impasu, używając metod czysto symbolicznych (twierdzenie udowodnienia; poszukaj Owicki-Gries).

Jednak te metody formalne zazwyczaj wymagają pewnego wysiłku(np. poznanie podstaw teorii procesów). Ale myślę, że jest to po prostu konsekwencja faktu, że te problemy są trudne.

Impas to sytuacja, w której istnieje mniejsza liczba dostępnych zasobów, ponieważ jest to wymagane przez inny proces. Oznacza to, że gdy liczba dostępnych zasobów staje się mniejsza niż żądana przez użytkownika, wówczas proces przechodzi w stan oczekiwania .Czasami czekanie zwiększa się i nie ma szans, aby sprawdzić problem braku zasobów, wtedy ta sytuacja jest znana jako impas . Właściwie impas to poważny problem dla nas i występuje tylko w wielozadaniowym systemie operacyjnym .impas nie może wystąpić w pojedynczym systemie operacyjnym, ponieważ wszystkie zasoby są obecne tylko dla tego zadania, które jest obecnie uruchomione......

Powyżej niektóre wyjaśnienia są ładne. Mam nadzieję, że może to również przydatne: https://ora-data.blogspot.in/2017/04/deadlock-in-oracle.html

W bazie danych, gdy sesja (np. ora) chce zasobu posiadanego przez inną sesję (np. data), ale ta sesja (data) również chce zasobu posiadanego przez pierwszą sesję (ora). Może być więcej niż 2 sesje zaangażowane również, ale pomysł będzie taki sam. W rzeczywistości impas uniemożliwia niektórym transakcjom kontynuowanie pracy. Na przykład: Załóżmy, że ORA-DATA posiada blokadę a i żąda blokady B I SKU posiada blokadę B i żąda blokady A.

Dzięki,

Impas występuje, gdy wątek czeka na zakończenie innego wątku i odwrotnie.

Jak unikać?
- Unikaj Zagnieżdżonych Zamków
- Unikaj Zbędnych Zamków
- Use thread join ()

Jak to wykrywasz?
uruchom to polecenie w cmd:

jcmd $PID Thread.print

Indeks : geeksforgeeks

Klasyczny i bardzo prosty program do zrozumienia sytuacji :-

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);
    }
}

Gdy główny wątek wywołuje Lazy.main, sprawdza czy klasa Lazy została zainicjalizowana i zaczyna inicjalizować klasę. Na główny wątek ustawia teraz initialized na false, tworzy i uruchamia tło wątek, którego metoda run ustawia initialized na true i czeka na zakończenie wątku w tle.

Tym razem klasa jest obecnie inicjowana przez innego nić. W tych okolicznościach aktualny wątek, który jest wątkiem tła, oczekuje na obiekcie klasy aż do zakończenia inicjalizacji. Niestety wątek to robi inicjalizację, główny wątek, czeka na tło wątek do zakończenia. Ponieważ dwa wątki czekają teraz na siebie, program jest Zablokowany.

Mutex w istocie jest blokadą, zapewniającą chroniony dostęp do współdzielonych zasobów. Pod Linuksem typ danych mutex wątku to pthread_mutex_t. przed użyciem należy go zainicjować.

Aby uzyskać dostęp do współdzielonych zasobów, musisz zablokować mutex. Jeśli mutex jest już zablokowany, wywołanie zablokuje wątek, dopóki mutex nie zostanie odblokowany. Po zakończeniu wizyty w udostępnionych zasobach musisz je odblokować.

Ogólnie rzecz biorąc, istnieje kilka niepisanych podstawowych zasady:

• Uzyskaj blokadę przed użyciem współdzielonych zasobów.

• Trzymanie zamka w jak najkrótszym czasie.

• Zwolnij blokadę, jeśli wątek zwróci błąd.