/**
   @version 1.30 2004-08-01
   @author Cay Horstmann
*/

/** 
   Program ilustruje bezpieczny dostęp wielu wątków do tej samej struktury danych
   przy użyciu metod zadeklarowanych jako synchronized.
*/
public class SynchBankTest2
{  
   public static void main(String[] args)
   {  
      Bank b = new Bank(NACCOUNTS, INITIAL_BALANCE);
      int i;
      for (i = 0; i < NACCOUNTS; i++)
      {  
         TransferRunnable r = new TransferRunnable(b, i, INITIAL_BALANCE);
         Thread t = new Thread(r);
         t.start();
      }
   }

   public static final int NACCOUNTS = 100;
   public static final double INITIAL_BALANCE = 1000;
}

/**
   Bank o pewnej liczbie kont.
*/
class Bank
{ 
   /**
      Tworzy bank.
      @param n liczba kont
      @param initialBalance początkowy stan każdego konta
   */
   public Bank(int n, double initialBalance)
   {  
      accounts = new double[n];
      for (int i = 0; i < accounts.length; i++)
         accounts[i] = initialBalance;
   }

   /**
      Przelewa pieniądze z jednego konta na drugie.
      @param from konto nadawcy
      @param to konto odbiorcy
      @param amount kwota przelewu
   */
   public synchronized void transfer(int from, int to, double amount)
      throws InterruptedException
   {  
      while (accounts[from] < amount)
         wait();
      System.out.print(Thread.currentThread());      
      accounts[from] -= amount;
      System.out.printf(" %10.2f z konta %d na konto %d", amount, from, to);
      accounts[to] += amount;
      System.out.printf(" Saldo banku: %10.2f%n", getTotalBalance());
      notifyAll();
   }

   /**
      Zwraca saldo banku.
      @return saldo banku
   */
   public synchronized double getTotalBalance()
   {  
      double sum = 0;
      
      for (double a : accounts)
         sum += a;
      
      return sum;
   }

   /**
      Zwraca liczbę kont w banku.
      @return liczba kont
   */
   public int size()
   {
      return accounts.length;
   }

   private final double[] accounts;
}

/**
   Klasa wykonująca przelewy pomiędzy kontami w osobnych wątkach.
*/
class TransferRunnable implements Runnable
{ 
   /**
      Konstruktor.
      @param b bank pomiędzy kontami którego dokonywane są przelewy
      @param from konto nadawcy
      @param max maksymalna kwota przelewu
   */
   public TransferRunnable(Bank b, int from, double max)
   {  
      bank = b;
      fromAccount = from;
      maxAmount = max;
   }

   public void run()
   {  
      try
      {  
         while (true)
         {  
            int toAccount = (int) (bank.size() * Math.random());
            double amount = maxAmount * Math.random();
            bank.transfer(fromAccount, toAccount, amount);
            Thread.sleep((int) (DELAY * Math.random()));
         }
      }
      catch (InterruptedException e) {}
   }

   private Bank bank;
   private int fromAccount;
   private double maxAmount;
   private int repetitions;
   private int DELAY = 10;
}

