Deadlock in un programma java a thread singolo

Question

Leggi che il deadlock può verificarsi in un programma java a thread singolo. Mi chiedo come non ci sarà una competizione dopo tutto. Per quanto posso ricordare, i libri illustrano esempi con più di un thread. Puoi fare un esempio se può accadere con un singolo thread.

Answer 1

No.

stallo è il risultato di più thread (o processi) che tentano di acquisire blocchi in modo tale che nessuno dei due può continuare.

consideri una citazione dalla voce di Wikipedia: (http://en.wikipedia.org/wiki/Deadlock)

"Quando due treni si avvicinano ad un incrocio, entrambi verrà a un punto fermo e non si riattiva quando l'altro è andato."

Answer 2

No, mi sembra piuttosto impossibile.

Ma in teoria è possibile bloccare una risorsa di sistema mentre un'altra app ne blocca un'altra che verrà richiesta e l'app richiederà quella già bloccata. Bang Deadlock.

Ma il sistema operativo dovrebbe essere in grado di risolvere questo problema rilevandolo e assegnare entrambe le risorse a un'app al momento. Le probabilità che ciò accada sono ridotte a zero, ma ogni buon sistema operativo dovrebbe essere in grado di gestire questa possibilità su un miliardo di dollari.

Se si esegue la progettazione con attenzione e si blocca solo una risorsa alla volta, ciò non può avvenire.

Answer 3

È una questione di come si definisce esattamente "deadlock".

Ad esempio, questo scenario è in qualche modo realistico: un'applicazione a thread singolo che utilizza una coda con dimensioni limitate che blocca quando viene raggiunto il limite. Finché non viene raggiunto il limite, questo funzionerà correttamente con un singolo thread. Ma quando viene raggiunto il limite, il thread attenderà per sempre un (non esistente) altro thread per prendere qualcosa dalla coda in modo che possa continuare.

Answer 4

Beh oserei dire di sì

Se si tenta di acquisire lo stesso blocco all'interno dello stesso filo consecutivamente, dipende dal tipo di blocco o di bloccare l'attuazione se si controlla se il blocco viene acquisito dallo stesso thread. Se l'implementazione non verifica questo, hai un deadlock.

Per sincronizzato questo è controllato, ma non sono riuscito a trovare la garanzia per il semaforo.

Se si utilizza un altro tipo di blocco, è necessario verificare le specifiche come è garantito il comportamento!

Inoltre, come già indicato, è possibile bloccare (che è diverso dal deadlock) leggendo/scrivendo su un buffer limitato. Ad esempio, si scrivono le cose in un buffer a fessura e si legge solo da certe condizioni. Quando non puoi più inserire, attendi fino a quando uno slot non diventa libero, cosa che non accadrà dato che tu stesso fai la lettura.

Quindi oserei dire che la risposta dovrebbe essere sì, anche se non così facile e solitamente più facile da rilevare.

hth

Mario

Answer 5

Prima di processori multicore è diventato a buon mercato, tutti i computer desktop avevano processori single-core. I processori single-core funzionano solo su thread. Allora come funzionava il multithreading? L'implementazione più semplice per Java potrebbe essere: Codice

di Thread1:

doSomething(); 
yield(); // may switch to another thread 
doSomethingElse(); 

codice di Thread2:

doSomething2(); 
yield(); // may switch to another thread 
doSomethingElse2(); 

Questo è chiamato multithreading di cooperazione - tutto è fatto con appena 1 filo, e così multithreading era fatto in Windows 3.1.

Il multithreading di oggi chiamato multithreading preventivo è solo una leggera modifica del multithreading cooperativo in cui tale yield() viene chiamato automaticamente di volta in volta.

Tutto ciò che può ridurre alle seguenti intrecci:

doSomething(); 
doSomething2(); 
doSomethingElse2(); 
doSomethingElse(); 

o:

doSomething(); 
doSomething2(); 
doSomethingElse(); 
doSomethingElse2(); 

E così via ... Abbiamo convertito il codice multithreaded in codice single-threaded. Quindi sì, se un deadlock è possibile anche nei programmi multithreaded in single-threaded. Per esempio:

Thread1:

queue.put(x); 
yield(); 

Thread2:

x = queue.waitAndGet() 
yield(); 

E 'OK con questo intreccio:

queue.put(x); 
x = queue.waitAndGet() 

Ma qui arriviamo situazione di stallo:

x = queue.waitAndGet() 
queue.put(x); 

Quindi sì, i deadlock sono possibili nei programmi a thread singolo.

Answer 6

Anche se il materiale Java è a thread singolo, esistono ancora gestori di segnale, che vengono eseguiti in un thread/contesto diverso rispetto al thread principale.

Quindi, un deadlock può effettivamente verificarsi anche su soluzioni a thread singolo, se/quando java è in esecuzione su linux.

QED. -pbr

Answer 7

Esso è in realtà abbastanza semplice:

BlockingQueue bq = new ArrayBlockingQueue(1); 
bq.take(); 

sarà deadlock.