Quando si scrivono applicazioni multi-thread, uno dei problemi più comuni riscontrati sono i deadlock.
Le mie domande alla community sono:
Che cos'è un deadlock?
Come li rilevi?
Li gestisci?
E infine, come evitare che si verifichino?
Risposte:
Si verifica un blocco quando più processi tentano di accedere alla stessa risorsa contemporaneamente.
Un processo si perde e deve attendere il completamento dell'altro.
Si verifica un deadlock quando il processo di attesa è ancora bloccato su un'altra risorsa di cui il primo ha bisogno prima che possa terminare.
Quindi, un esempio:
La risorsa A e la risorsa B sono utilizzate dal processo X e dal processo Y
Il modo migliore per evitare deadlock è evitare che i processi si incrociano in questo modo. Riduci la necessità di bloccare tutto il più possibile.
Nei database evita di apportare molte modifiche a diverse tabelle in una singola transazione, evita i trigger e passa a letture ottimistiche / sporche / nolock il più possibile.
Lasciatemi spiegare un esempio del mondo reale (non proprio reale) per una situazione di stallo nei film polizieschi. Immagina che un criminale detenga un ostaggio e, al contrario, un poliziotto detiene anche un ostaggio amico del criminale. In questo caso, il criminale non lascerà andare l'ostaggio se il poliziotto non lascerà andare il suo amico. Inoltre il poliziotto non lascerà andare l'amico criminale, a meno che il criminale non rilasci l'ostaggio. Questa è una situazione infinita inaffidabile, perché entrambe le parti insistono il primo passo l'una dall'altra.
Quindi, semplicemente, quando due thread hanno bisogno di due risorse diverse e ognuna di esse ha il blocco della risorsa di cui l'altra ha bisogno, si tratta di un deadlock.
Stai uscendo con una ragazza e un giorno dopo una discussione, entrambe le parti sono spezzate il cuore l'una dall'altra e aspettano una telefonata che mi dispiace e mi manchi . In questa situazione, entrambe le parti vogliono comunicare tra loro se e solo se una di loro riceve una chiamata di scusa dall'altra. Poiché nessuno dei due inizierà la comunicazione e attenderà in uno stato passivo, entrambi aspetteranno che l'altro inizi la comunicazione che finisce in una situazione di stallo.
I deadlock si verificano solo quando si hanno due o più lock che possono essere acquisiti contemporaneamente e vengono catturati in un ordine diverso.
I modi per evitare di avere deadlock sono:
Per definire il deadlock, per prima cosa definirei il processo.
Processo : come sappiamo, il processo non è altro che programun'esecuzione.
Risorsa : per eseguire un processo del programma sono necessarie alcune risorse. Le categorie di risorse possono includere memoria, stampanti, CPU, file aperti, unità nastro, CD-ROM, ecc.
Deadlock : deadlock è una situazione o condizione in cui due o più processi trattengono alcune risorse e provano ad acquisire altre risorse e non possono rilasciare le risorse fino al termine dell'esecuzione.
Condizione o situazione di deadlock
Nel diagramma sopra ci sono due processi P1 e p2 e ci sono due risorse R1 e R2 .
La risorsa R1 è allocata al processo P1 e la risorsa R2 è allocata al processo p2 . Per completare l'esecuzione del processo P1 è necessaria la risorsa R2 , quindi P1 richiede R2 , ma R2 è già assegnato a P2 .
Allo stesso modo il processo P2 per completare la sua esecuzione richiede R1 , ma R1 è già assegnato a P1 .
entrambi i processi non possono rilasciare le loro risorse fino a quando non completano la loro esecuzione. Quindi entrambi stanno aspettando un'altra risorsa e aspetteranno per sempre. Quindi questa è una condizione DEADLOCK .
Affinché si verifichi deadlock, devono essere vere quattro condizioni.
e tutte queste condizioni sono soddisfatte nel diagramma sopra.
Un deadlock si verifica quando un thread è in attesa di qualcosa che non si verifica mai.
In genere, accade quando un thread è in attesa di un mutex o semaforo che non è mai stato rilasciato dal precedente proprietario.
Succede spesso anche quando hai una situazione che coinvolge due thread e due blocchi in questo modo:
Thread 1 Thread 2
Lock1->Lock(); Lock2->Lock();
WaitForLock2(); WaitForLock1(); <-- Oops!
Generalmente li rilevi perché le cose che ti aspetti non succedano mai, o l'applicazione si blocca completamente.
Puoi dare un'occhiata a questi meravigliosi articoli , nella sezione Deadlock . È in C # ma l'idea è sempre la stessa per altre piattaforme. Cito qui per una facile lettura
Un deadlock si verifica quando due thread attendono ciascuno una risorsa trattenuta dall'altro, quindi nessuno dei due può procedere. Il modo più semplice per illustrarlo è con due blocchi:
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
}
Il deadlock è un problema comune nei problemi di multiprocessing / multiprogrammazione nel sistema operativo. Supponiamo che ci siano due processi P1, P2 e due risorse globalmente condivisibili R1, R2 e nella sezione critica sia necessario accedere a entrambe le risorse
Inizialmente, il sistema operativo assegna R1 per elaborare P1 e R2 per elaborare P2. Poiché entrambi i processi sono in esecuzione contemporaneamente, possono iniziare l'esecuzione del loro codice ma il PROBLEMA si presenta quando un processo raggiunge la sezione critica. Quindi il processo R1 attenderà che il processo P2 rilasci R2 e viceversa ... Quindi aspetteranno per sempre (DEADLOCK CONDITION).
Una piccola ANALOGIA ...
Tua madre (OS),
Tu (P1),
Tuo fratello (P2),
Mela (R1),
Coltello (R2),
sezione critica (tagliare la mela con un coltello).Tua madre ti dà la mela e il coltello a tuo fratello all'inizio.
Entrambi sono felici e giocano (eseguendo i loro codici).
Chiunque di voi vuole tagliare la mela (sezione critica) ad un certo punto.
Non vuoi dare la mela a tuo fratello.
Tuo fratello non vuole darti il coltello.
Quindi entrambi aspetterete per molto, molto tempo :)
Il deadlock si verifica quando due thread acquisiscono blocchi che impediscono a uno di essi di progredire. Il modo migliore per evitarli è con uno sviluppo attento. Molti sistemi embedded proteggono contro di loro usando un timer watchdog (un timer che reimposta il sistema ogni volta che si blocca per un certo periodo di tempo).
Un deadlock si verifica quando esiste una catena circolare di thread o processi che contengono ciascuno una risorsa bloccata e tentano di bloccare una risorsa trattenuta dall'elemento successivo nella catena. Ad esempio, due thread che contengono rispettivamente il blocco A e il blocco B e stanno entrambi cercando di acquisire l'altro blocco.
Un programma classico e molto semplice per comprendere la situazione di Deadlock : -
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);
}
}
Quando il thread principale richiama Lazy.main, controlla se la classe Lazy è stata inizializzata e inizia a inizializzare la classe. Il thread principale ora imposta inizializzato su false, crea e avvia un thread in background il cui metodo run viene inizializzato su true e attende il completamento del thread in background.
Questa volta, la classe è attualmente inizializzata da un altro thread. In queste circostanze, il thread corrente, che è il thread in background, attende l'oggetto Class fino al completamento dell'inizializzazione. Sfortunatamente, il thread che sta eseguendo l'inizializzazione, il thread principale, è in attesa del completamento del thread in background. Poiché i due thread sono ora in attesa l'uno dell'altro, il programma è DEADLOCKED.
Un deadlock è uno stato di un sistema in cui nessun singolo processo / thread è in grado di eseguire un'azione. Come menzionato da altri, un deadlock è in genere il risultato di una situazione in cui ogni processo / thread desidera acquisire un blocco per una risorsa che è già bloccata da un altro (o anche lo stesso) processo / thread.
Esistono vari metodi per trovarli ed evitarli. Uno sta pensando molto e / o sta provando molte cose. Tuttavia, affrontare il parallelismo è notoriamente difficile e la maggior parte (se non tutte) le persone non saranno in grado di evitare completamente i problemi.
Alcuni metodi più formali possono essere utili se si prende sul serio questo tipo di problemi. Il metodo più pratico di cui sono a conoscenza è utilizzare l'approccio teorico del processo. Qui modelli il tuo sistema in un linguaggio di processo (ad es. CCS, CSP, ACP, mCRL2, LOTOS) e usi gli strumenti disponibili per (modello-) verificare i deadlock (e forse anche alcune altre proprietà). Esempi di set di strumenti da utilizzare sono FDR, mCRL2, CADP e Uppaal. Alcune anime coraggiose potrebbero persino liberare i loro sistemi da un punto morto usando metodi puramente simbolici (dimostrazione del teorema; cerca Owicki-Gries).
Tuttavia, questi metodi formali richiedono in genere alcuni sforzi (ad esempio, apprendere le basi della teoria dei processi). Ma immagino che sia semplicemente una conseguenza del fatto che questi problemi sono difficili.
Deadlock è una situazione che si verifica quando c'è meno numero di risorse disponibili come richiesto dal diverso processo. Ciò significa che quando il numero di risorse disponibili diventa inferiore a quello richiesto dall'utente, in quel momento il processo passa in condizione di attesa. Alcuni tempi di attesa aumentano di più e non vi è alcuna possibilità di verificare il problema della mancanza di risorse questa situazione è nota come deadlock. In realtà, deadlock è un grosso problema per noi e si verifica solo nel sistema operativo multitasking .deadlock non può verificarsi nel singolo sistema operativo di tasking perché tutte le risorse sono presenti solo per quell'attività che è attualmente in esecuzione ......
Sopra alcune spiegazioni sono belle. Spero che questo possa anche essere utile: https://ora-data.blogspot.in/2017/04/deadlock-in-oracle.html
In un database, quando una sessione (ad es. Ora) desidera una risorsa trattenuta da un'altra sessione (ad es. Dati), ma quella sessione (dati) desidera anche una risorsa che è trattenuta dalla prima sessione (ora). Possono essere coinvolte anche più di 2 sessioni, ma l'idea sarà la stessa. In realtà, i deadlock impediscono ad alcune transazioni di continuare a funzionare. Ad esempio: supponiamo che ORA-DATA mantenga il blocco A e richieda il blocco B e SKU mantenga il blocco B e richieda il blocco A.
Grazie,
Il deadlock si verifica quando un thread è in attesa del completamento dell'altro thread e viceversa.
Come evitare?
- Evita blocchi nidificati
- Evita blocchi non necessari
- Usa thread join ()
Come lo rilevi?
eseguire questo comando in cmd:
jcmd $PID Thread.print
riferimento : geeksforgeeks
I deadlock non si verificano solo con i blocchi, anche se questa è la causa più frequente. In C ++, è possibile creare deadlock con due thread e senza blocchi semplicemente avendo ogni thread che chiama join () sull'oggetto std :: thread per l'altro.
L'uso del blocco per il controllo dell'accesso alle risorse condivise è soggetto a deadlock e il solo pianificatore delle transazioni non può impedirne il verificarsi.
Ad esempio, i sistemi di database relazionali utilizzano vari blocchi per garantire le proprietà ACID delle transazioni .
Indipendentemente dal sistema di database relazionale in uso, i blocchi verranno sempre acquisiti durante la modifica (ad es. UPDATEO DELETE) di un determinato record di tabella. Senza bloccare una riga modificata da una transazione attualmente in esecuzione, Atomicity sarebbe compromessa .
Come ho spiegato in questo articolo , si verifica un deadlock quando due transazioni simultanee non possono fare progressi perché ognuna attende che l'altro rilasci un blocco, come illustrato nel diagramma seguente.
Poiché entrambe le transazioni sono in fase di acquisizione dei blocchi, nessuno dei due rilascia un blocco prima di acquisire quello successivo.
Se stai usando un algoritmo di controllo della concorrenza che si basa sui blocchi, c'è sempre il rischio di correre in una situazione di deadlock. I deadlock possono verificarsi in qualsiasi ambiente di concorrenza, non solo in un sistema di database.
Ad esempio, un programma multithreading può eseguire il deadlock se due o più thread sono in attesa di blocchi acquisiti in precedenza in modo che nessun thread possa fare alcun progresso. Se ciò accade in un'applicazione Java, JVM non può semplicemente forzare un thread a interrompere la sua esecuzione e rilasciare i suoi blocchi.
Anche se la Threadclasse espone un stopmetodo, tale metodo è stato deprecato a partire da Java 1.1 perché può causare la restituzione di oggetti in uno stato incoerente dopo l'arresto di un thread. Invece, Java definisce un interruptmetodo, che funge da suggerimento come un thread che viene interrotto può semplicemente ignorare l'interruzione e continuare la sua esecuzione.
Per questo motivo, un'applicazione Java non può recuperare da una situazione di deadlock ed è responsabilità dello sviluppatore dell'applicazione ordinare le richieste di acquisizione dei blocchi in modo tale che i deadlock non possano mai verificarsi.
Tuttavia, un sistema di database non può applicare un determinato ordine di acquisizione dei blocchi poiché è impossibile prevedere quali altri blocchi una determinata transazione vorrà acquisire ulteriormente. La conservazione dell'ordine di blocco diventa responsabilità del livello di accesso ai dati e il database può solo aiutare a recuperare da una situazione di deadlock.
Il motore di database esegue un processo separato che esegue la scansione del grafico di conflitto corrente alla ricerca di cicli di blocco (che sono causati da deadlock). Quando viene rilevato un ciclo, il motore di database seleziona una transazione e la interrompe, causando il rilascio dei suoi blocchi, in modo che l'altra transazione possa fare progressi.
A differenza della JVM, una transazione di database è progettata come unità di lavoro atomica. Quindi, un rollback lascia il database in uno stato coerente.
Per maggiori dettagli su questo argomento, consulta anche questo articolo .
Il mutex in sostanza è un blocco che fornisce accesso protetto alle risorse condivise. In Linux, il tipo di dati thread mutex è pthread_mutex_t. Prima dell'uso, inizializzalo.
Per accedere alle risorse condivise, devi bloccare il mutex. Se il mutex è già sul blocco, la chiamata bloccherà il thread fino a quando il mutex non viene sbloccato. Al completamento della visita alle risorse condivise, è necessario sbloccarle.
Nel complesso, ci sono alcuni principi di base non scritti:
Ottenere il blocco prima di utilizzare le risorse condivise.
Tenendo il lucchetto il più breve tempo possibile.
Rilascia il blocco se il thread restituisce un errore.