李晓菁201771010114《面向对象程序设计（java）》第十七周学习总结

                package
                 synch;


                import java.util.*;
import java.util.concurrent.locks.*;

/**
 * A bank with a number of bank accounts that uses locks for serializing access.
 * @version 1.30 2004-08-01
 * @author Cay Horstmann
 */publicclass Bank
{
   privatefinaldouble[] accounts;
   private Lock bankLock;
   private Condition sufficientFunds;

   /**
    * Constructs the bank.
    * @param n the number of accounts
    * @param initialBalance the initial balance for each account
    */public Bank(int n, double initialBalance)
   {
      accounts = newdouble[n];
      Arrays.fill(accounts, initialBalance);
      bankLock = new ReentrantLock();
      sufficientFunds = bankLock.newCondition();//在等待条件前，锁必须由当前线程保持。   }

   /**
    * Transfers money from one account to another.
    * @param from the account to transfer from
    * @param to the account to transfer to
    * @param amount the amount to transfer
    */publicvoid transfer(int from, int to, double amount) throws InterruptedException
   {
      bankLock.lock();//获取锁try
      {
         while (accounts[from] < amount)
            sufficientFunds.await();//造成当前线程在接到信号或被中断之前一直处于等待状态。         System.out.print(Thread.currentThread());
         accounts[from] -= amount;
         System.out.printf(" %10.2f from %d to %d", amount, from, to);
         accounts[to] += amount;
         System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
         sufficientFunds.signalAll();//如果所有的线程都在等待此条件，则唤醒所有线程      }
      finally
      {
         bankLock.unlock();//释放锁。       }
   }

   /**
    * Gets the sum of all account balances.
    * @return the total balance
    */publicdouble getTotalBalance()
   {
      bankLock.lock();
      try
      {
         double sum = 0;

         for (double a : accounts)
            sum += a;

         return sum;
      }
      finally
      {
         bankLock.unlock();
      }
   }

   /**
    * Gets the number of accounts in the bank.
    * @return the number of accounts
    */publicint size()
   {
      return accounts.length;
   }
}

                package
                 synch;


                /**
                
 * This program shows how multiple threads can safely access a data structure.
 * 
                @version
                 1.31 2015-06-21
 * 
                @author
                 Cay Horstmann
 
                */
                public
                class
                 SynchBankTest
{
   
                public
                static
                final
                int NACCOUNTS = 100;
   publicstaticfinaldouble INITIAL_BALANCE = 1000;
   publicstaticfinaldouble MAX_AMOUNT = 1000;
   publicstaticfinalint DELAY = 10;
   
   publicstaticvoid main(String[] args)
   {
      Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
      for (int i = 0; i < NACCOUNTS; i++)
      {
         int fromAccount = i;
         Runnable r = () -> {
            try
            {
               while (true)
               {
                  int toAccount = (int) (bank.size() * Math.random());
                  double amount = MAX_AMOUNT * Math.random();
                  bank.transfer(fromAccount, toAccount, amount);
                  Thread.sleep((int) (DELAY * Math.random()));
               }
            }
            catch (InterruptedException e)
            {
            }            
         };
         Thread t = new Thread(r);
         t.start();
      }
   }
}

                package
                 synch2;


                import java.util.*;

/**
 * A bank with a number of bank accounts that uses synchronization primitives.
 * @version 1.30 2004-08-01
 * @author Cay Horstmann
 */publicclass Bank
{
   privatefinaldouble[] accounts;

   /**
    * Constructs the bank.
    * @param n the number of accounts
    * @param initialBalance the initial balance for each account
    */public Bank(int n, double initialBalance)
   {
      accounts = newdouble[n];
      Arrays.fill(accounts, initialBalance);
   }

   /**
    * Transfers money from one account to another.
    * @param from the account to transfer from
    * @param to the account to transfer to
    * @param amount the amount to transfer
    */publicsynchronizedvoid transfer(int from, int to, double amount) throws InterruptedException
   {
      while (accounts[from] < amount)
         wait();//在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待      System.out.print(Thread.currentThread());
      accounts[from] -= amount;
      System.out.printf(" %10.2f from %d to %d", amount, from, to);
      accounts[to] += amount;
      System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
      notifyAll();//唤醒在此对象监视器上等待的所有线程   }

   /**
    * Gets the sum of all account balances.
    * @return the total balance
    */publicsynchronizeddouble getTotalBalance()
   {
      double sum = 0;

      for (double a : accounts)
         sum += a;

      return sum;
   }

   /**
    * Gets the number of accounts in the bank.
    * @return the number of accounts
    */publicint size()
   {
      return accounts.length;
   }
}

                package
                 synch2;


                /**
                
 * This program shows how multiple threads can safely access a data structure,
 * using synchronized methods.
 * 
                @version
                 1.31 2015-06-21
 * 
                @author
                 Cay Horstmann
 
                */
                public
                class
                 SynchBankTest2
{
   
                public
                static
                final
                int NACCOUNTS = 100;
   publicstaticfinaldouble INITIAL_BALANCE = 1000;
   publicstaticfinaldouble MAX_AMOUNT = 1000;
   publicstaticfinalint DELAY = 10;

   publicstaticvoid main(String[] args)
   {
      Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
      for (int i = 0; i < NACCOUNTS; i++)
      {
         int fromAccount = i;
         Runnable r = () -> {
            try
            {
               while (true)
               {
                  int toAccount = (int) (bank.size() * Math.random());
                  double amount = MAX_AMOUNT * Math.random();
                  bank.transfer(fromAccount, toAccount, amount);
                  Thread.sleep((int) (DELAY * Math.random()));
               }
            }
            catch (InterruptedException e)
            {
            }
         };
         Thread t = new Thread(r);
         t.start();
      }
   }
}