Sto cercando di scrivere molto semplice programma che imitano semplice situazione di stallo, in cui infilare un attende Resource Un bloccati da thread B e filettatura B attende per la risorsa B bloccato da Discussione A.Java per i neofiti - imitazione DeadLock
Qui è il mio codice:
//it will be my Shared resource
public class Account {
private float amount;
public void debit(double amount){
this.amount-=amount;
}
public void credit(double amount){
this.amount+=amount;
}
}
Questo è il mio eseguibile che esegue operazione sulla risorsa di cui sopra:
public class BankTransaction implements Runnable {
Account fromAccount,toAccount;
float ammount;
public BankTransaction(Account fromAccount, Account toAccount,float ammount){
this.fromAccount = fromAccount;
this.toAccount = toAccount;
this.ammount = ammount;
}
private void transferMoney(){
synchronized(fromAccount){
synchronized(toAccount){
fromAccount.debit(ammount);
toAccount.credit(ammount);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Current Transaction Completed!!!");
}
}
}
@Override
public void run() {
transferMoney();
}
}
e, infine, la mia classe principale:
public static void main(String[] args) {
Account a = new Account();
Account b = new Account();
Thread thread1 = new Thread(new BankTransaction(a,b,500));
Thread thread2 = new Thread(new BankTransaction(b,a,500));
thread1.start();
thread2.start();
System.out.println("Transactions Completed!!!");
}
}
Perché questo codice viene eseguito correttamente e non ho e deadLock?
Il sonno può introdurre non determinismo. Puoi renderlo deterministico; vedi la mia risposta qui sotto. – Toby
@Toby: Sì, è possibile renderlo deterministico, ma 'sleep' è un buon modo per mostrare come può * verificarsi * il deadlock, come puoi sempre immaginare un programma senza sleep in esecuzione in modo simile a uno che * fa * usa sleeps, semplicemente in virtù del fatto che il thread non è pianificato. In altre parole, un programma che fallisce quando si inserisce il sonno è intrinsecamente imperfetto perché si potrebbe vedere lo stesso "accidentalmente" nella vita reale. Lo stesso non è vero con l'inserimento di notifiche. –