Vermeidung Deadlock-Beispiel

Frage ich mich, was sind die alternativen Möglichkeiten zur Vermeidung von Deadlocks in dem folgenden Beispiel. Das folgende Beispiel ist eine typische bank-Konto übertragen deadlock-problem. Was sind einige bessere Ansätze, es zu lösen in der Praxis ?

class Account {
     double balance;
     int id;
     public Account(int id, double balance){
          this.balance = balance;
          this.id = id;
     }
     void withdraw(double amount){
          balance -= amount;
     } 
     void deposit(double amount){
          balance += amount;
     }
}
class Main{
     public static void main(String [] args){
           final Account a = new Account(1,1000);
           final Account b = new Account(2,300);
           Thread a = new Thread(){
                 public void run(){
                     transfer(a,b,200);
                 }
           };
           Thread b = new Thread(){
                 public void run(){
                     transfer(b,a,300);
                 }
           };
           a.start();
           b.start();
     }
     public static void transfer(Account from, Account to, double amount){
          synchronized(from){
               synchronized(to){
                    from.withdraw(amount);
                    to.deposit(amount);
               }
          }
     }
}

Frage ich mich, wird es lösen die deadlock-Problem, wenn ich trennen Sie das verschachtelte sperren in meiner transfer-Methode wie im folgenden

 synchronized(from){
      from.withdraw(amount);
 }
 synchronized(to){
      to.deposit(amount);
 }

Dein Beispiel ist nicht klassische deadlock-Beispiel. Es immer Schloss sowohl das Konto für den gleichen thread, so dass kein deadlock auftreten wird. Wollten Sie diesen code in Ihre transfer-Methode : static void überweisen(Konto von, Konto nach, double Betrag) { synchronized(from) { aus.abheben(Betrag); synchronized(to) { to.Kaution(Betrag); } } }

InformationsquelleAutor peter | 2012-11-10

28

Art der Konten. Die dead lock ist über die Reihenfolge der Konten (a,b vs b,a).

So versuchen:
```
 public static void transfer(Account from, Account to, double amount){
      Account first = from;
      Account second = to;
      if (first.compareTo(second) < 0) {
          //Swap them
          first = to;
          second = from;
      }
      synchronized(first){
           synchronized(second){
                from.withdraw(amount);
                to.deposit(amount);
           }
      }
 }
```
- Dies funktioniert beim Umgang mit mehr als zwei Konten, richtig ?
- Ich kann nicht verstehen, das Konzept gut, aber was über die situation, in der beide Konten die gleiche balance? Soweit ich das verstanden habe, werden Sie nicht getauscht werden, daher deadlock existiert noch.
- Nein, in diesem Fall die Sortierung der Konten auf etwas, was Sie einzigartig sind (beispielsweise eine Kontonummer, oder deren Primärschlüssel in der DB, etc.). Die eigentliche Bestellung ist egal, solange es stabil ist, die Bestellung über alle Teilnehmer (d.h. keine Duplikate, wie Sie vorgeschlagen).
- Danke, das klingt überzeugend!
InformationsquelleAutor Will Hartung
8

Dies ist eine klassische Frage. Ich sehe zwei mögliche Lösungen:
1. Zu Sortieren-Konten und Synchronisierung-Konto, welches über eine id verfügt, der niedriger als eine andere.
  Diese Methode, die in der Bibel erwähnt, Parallelität in Java Parallelität in der Praxis in Kapitel 10. In diesem Buch Autoren verwenden Sie die system-hash-code der Unterscheidung der Konten. Sehen java.lang.System#identityHashCode.
2. Die zweite Lösung ist die von dir erwähnte - ja, Sie können keine geschachtelten synchronized Blöcke und Ihr code wird nicht dazu führen, in die Sackgasse. In diesem Fall ist aber die Verarbeitung könnte einige Probleme haben, weil, wenn Sie Geld von dem ersten Konto, das der zweite account kann gesperrt werden für jede signifikante Zeit-und wahrscheinlich werden Sie brauchen, um Geld wieder zurück auf das erste Konto. Das ist nicht gut und da dieser geschachtelten Synchronisation und die Sperre von zwei Konten ist besser und häufiger verwendete Lösung.
InformationsquelleAutor BrownFurSeal

Neben der Lösung der Sperre angeordnet, Sie können auch vermeiden, die deadlock durch Synchronisierung auf ein private static final lock-Objekt vor der Ausführung jedes Konto überträgt.

 class Account{
 double balance;
 int id;
 private static final Object lock = new Object();
  ....




 public static void transfer(Account from, Account to, double amount){
          synchronized(lock)
          {
                    from.withdraw(amount);
                    to.deposit(amount);
          }
     }

Diese Lösung hat das problem, dass eine private, statische lock beschränkt das system zu leistenden transfers "sequenziell".

Kann eine andere sein, wenn jedes Konto hat ein ReentrantLock:

private final Lock lock = new ReentrantLock();




public static void transfer(Account from, Account to, double amount)
{
       while(true)
        {
          if(from.lock.tryLock()){
            try { 
                if (to.lock.tryLock()){
                   try{
                       from.withdraw(amount);
                       to.deposit(amount);
                       break;
                   } 
                   finally {
                       to.lock.unlock();
                   }
                }
           }
           finally {
                from.lock.unlock();
           }

           int n = number.nextInt(1000);
           int TIME = 1000 + n; //1 second + random delay to prevent livelock
           Thread.sleep(TIME);
        }

 }

Deadlock nicht auftreten, in diesem Ansatz, weil diese sperren werden nie auf unbestimmte Zeit festgehalten. Wenn das aktuelle Objekt Sperre erworben, aber die zweite Sperre nicht verfügbar ist, wird der erste lock wird freigegeben, und der thread schläft für einige angegebene Zeit, bevor Sie versuchen, erneut das lock.

Ich erfand diese Lösung auf ein interview wusste nicht die richtige Antwort )
Was meinst du mit 'nacheinander' im 1. Fall ?
Ein Faden hält die Sperre computing und der andere wartet. Nach dem ersten hatte, den job zu beenden, den anderen tun die Arbeit. Beide nicht arbeiteten parallel.
zweites Beispiel kann livelock situation richardbarabe.wordpress.com/2014/02/21/...
Danke, ich werde schauen, wenn ich mehr freie Zeit haben

InformationsquelleAutor dreamcrash

Können Sie auch erstellen Sie separate Sperre für jedes Konto (im Konto-Klasse) und dann vor der Transaktion erwerben die beiden Schlösser. Werfen Sie einen Blick:

private boolean acquireLocks(Account anotherAccount) {
        boolean fromAccountLock = false;
        boolean toAccountLock = false;
        try {
            fromAccountLock = getLock().tryLock();
            toAccountLock = anotherAccount.getLock().tryLock();
        } finally {
            if (!(fromAccountLock && toAccountLock)) {
                if (fromAccountLock) {
                    getLock().unlock();
                }
                if (toAccountLock) {
                    anotherAccount.getLock().unlock();
                }
            }
        }
        return fromAccountLock && toAccountLock;
    }

Nach zwei sperren, die Sie tun können, zu übertragen, ohne sich Gedanken über die sichere.

    public static void transfer(Acc from, Acc to, double amount) {
        if (from.acquireLocks(to)) {
            try {
                from.withdraw(amount);
                to.deposit(amount);
            } finally {
                from.getLock().unlock();
                to.getLock().unlock();
            }
        } else {
            System.out.println(threadName + " cant get Lock, try again!");
            //sleep here for random amount of time and try do it again
            transfer(from, to, amount);
        }
    }

InformationsquelleAutor Mafias

Hier ist die Lösung für das problem angegeben.

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class FixDeadLock1 {

    private class Account {

        private final Lock lock = new ReentrantLock();

        @SuppressWarnings("unused")
        double balance;
        @SuppressWarnings("unused")
        int id;

        public Account(int id, double balance) {
            this.balance = balance;
            this.id = id;
        }

        void withdraw(double amount) {
            this.balance -= amount;
        }

        void deposit(double amount) {
            balance += amount;
        }
    }

    private class Transfer {

        void transfer(Account fromAccount, Account toAccount, double amount) {
            /*
             * synchronized (fromAccount) { synchronized (toAccount) {
             * fromAccount.withdraw(amount); toAccount.deposit(amount); } }
             */

            if (impendingTransaction(fromAccount, toAccount)) {
                try {
                    System.out.format("Transaction Begins from:%d to:%d\n",
                            fromAccount.id, toAccount.id);
                    fromAccount.withdraw(amount);
                    toAccount.deposit(amount);
                } finally {
                    fromAccount.lock.unlock();
                    toAccount.lock.unlock();
                }

            } else {
                 System.out.println("Unable to begin transaction");
            }

        }

        boolean impendingTransaction(Account fromAccount, Account toAccount) {

            Boolean fromAccountLock = false;
            Boolean toAccountLock = false;

            try {
                fromAccountLock = fromAccount.lock.tryLock();
                toAccountLock = toAccount.lock.tryLock();
            } finally {
                if (!(fromAccountLock && toAccountLock)) {
                    if (fromAccountLock) {
                        fromAccount.lock.unlock();
                    }
                    if (toAccountLock) {
                        toAccount.lock.unlock();
                    }
                }
            }

            return fromAccountLock && toAccountLock;
        }

    }

    private class WrapperTransfer implements Runnable {
        private Account fromAccount;
        private Account toAccount;
        private double amount;

        public WrapperTransfer(Account fromAccount,Account toAccount,double amount){
            this.fromAccount = fromAccount;
            this.toAccount = toAccount; 
            this.amount = amount;
        }

        public void run(){
            Random random = new Random();
            try {
                int n = random.nextInt(1000);
                int TIME = 1000 + n; //1 second + random delay to prevent livelock
                Thread.sleep(TIME);
            } catch (InterruptedException e) {}
            new Transfer().transfer(fromAccount, toAccount, amount);
        }

    }

    public void initiateDeadLockTransfer() {
        Account from = new Account(1, 1000);
        Account to = new Account(2, 300);       
        new Thread(new WrapperTransfer(from,to,200)).start();
        new Thread(new WrapperTransfer(to,from,300)).start();
    }

    public static void main(String[] args) {
        new FixDeadLock1().initiateDeadLockTransfer();
    }

}

InformationsquelleAutor Shaan

-1

Gibt es drei Voraussetzungen müssen Sie erfüllen:
1. Konsequent zu senken, ist der Inhalt von einem Konto, um die angegebene Menge.
2. Konsequent erhöhen den Inhalt des anderen Konto den angegebenen Betrag.
3. Wenn eine der oben genannten erfolgreich ist, muss der andere auch erfolgreich sein.
Können Sie erreichen 1. und 2. durch die Verwendung Atomics, aber Sie haben etwas anderes, dass double da es keine AtomicDouble. AtomicLong würde wahrscheinlich Ihre beste Wette.

Also du bist Links mit Ihrem Dritten Voraussetzung - gelingt es, die anderen muss gelingen. Es ist eine einfache Technik, die funktioniert hervorragend mit atomics und das ist mit der getAndAdd Methoden.
```
class Account {
  AtomicLong balance = new AtomicLong ();
}

...
Long oldDebtor = null;
Long oldCreditor = null;
try {
  //Increase one.
  oldDebtor = debtor.balance.getAndAdd(value);
  //Decrease the other.
  oldCreditor = creditor.balance.gtAndAdd(-value);
} catch (Exception e) {
  //Most likely (but still incredibly unlikely) InterruptedException but theoretically anything.
  //Roll back
  if ( oldDebtor != null ) {
    debtor.getAndAdd(-value);
  }
  if ( oldCreditor != null ) {
    creditor.getAndAdd(value);
  }
  //Re-throw after cleanup.
  throw (e);
}
```
- Atomics dont throw Ausnahme unterbrochen.
- Richtig!!!! Aber ich Wette Account.credit/debit werfen, wenn etwas OP herum zu dass.
InformationsquelleAutor OldCurmudgeon

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.