# Threads?



## Delv.. (19. Aug 2007)

Hallo!

kann mir bitte jemand weiterhelfen??

Die frage war: 

Ändern Sie die Methode überweisen so ab, dass keine Verklemmungen mehr möglich sind! Die
ineinander geschachtelten synchronized-Blöcke sollen dabei erhalten bleiben.


```
class Konto
{
     private float stand; //Kontostand

  public Konto()
 {
    stand = 1000.0;
 }
 public void ändern(float betrag)
 {
     stand += betrag;
 }
}


class Bank
{
    private Konto[] konten;

    public Bank()
   {
       konten = new Konto[1000];

       for(int i = 0; i < konten.length; i++)
               konten[i] = new Konto();
   }
    public void überweisen(int vonKontoNr, int nachKontoNr, float betrag)
 {
             synchronized(konten[vonKontoNr])
             {
                  synchronized(konten[nachKontoNr])
                   { 
                       konten[vonKontoNr].ändern(-betrag);
                       konten[nachKontoNr].ändern(betrag);
                     }
   }
 }
}
```

_[Edit by Beni: Codetags, verschoben]_


----------



## SlaterB (19. Aug 2007)

eine Patentlösung gibts da nicht,
mache z.B. die überweisen-Operation synchronized


----------



## Guest (19. Aug 2007)

SlaterB hat gesagt.:
			
		

> eine Patentlösung gibts da nicht,
> mache z.B. die überweisen-Operation synchronized




Danke für die Antwort,

bei der vorgeschlagene Idee, wird Das Problem der unnötige Einschränkung der Parallelität: also statt die Sperre der

Konto-Objekte die Sperre des Bank-Objekts.


----------

