201771010101白玛次仁《2018面向对象程序设计（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
 */
public class Bank

   private final double[] 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 = new double[n];
      Arrays.fill(accounts, initialBalance);
      bankLock = new ReentrantLock();//锁对象初始化 
      sufficientFunds = bankLock.newCondition();//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
    */
   public void 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
    */
   public double 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
    */
   public int 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;
   public static final double INITIAL_BALANCE = 1000;
   public static final double MAX_AMOUNT = 1000;
   public static final int DELAY = 10;
   
   public static void 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
 */
public class Bank

   private final double[] 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 = new double[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
    */
   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 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
    */
   public synchronized double 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
    */
   public int 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;
   public static final double INITIAL_BALANCE = 1000;
   public static final double MAX_AMOUNT = 1000;
   public static final int DELAY = 10;

   public static void 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();
      
   

class Cbank 
    private static int s = 2000;

    public synchronized static void sub(int m) 
        int temp = s;
        temp = temp - m;
        try 
            Thread.sleep((int) (1000 * Math.random()));
         catch (InterruptedException e) 
        
        s = temp;
        System.out.println("s=" + s);
    


class Customer extends Thread 
    public void run() 
        for (int i = 1; i <= 4; i++)
            Cbank.sub(100);
    


public class Thread3 
    public static void main(String args[]) 
        Customer customer1 = new Customer();
        Customer customer2 = new Customer();
        customer1.start();
        customer2.start();
    

package DFDF;

public class DFDF 
    public class Demo 
        public void main(String[] args) 
            Mythread mythread = new Mythread();
            Thread t1 = new Thread(mythread);
            Thread t2 = new Thread(mythread);
            Thread t3 = new Thread(mythread);
            t1.start();
            t2.start();
            t3.start();
        
    

    class Mythread implements Runnable 
        int t = 1;
        boolean flag = true;

        @Override
        public void run() 
            // TODO Auto-generated method stub
            while (flag) 
                try 
                    Thread.sleep(500);
                 catch (Exception e) 
                    // TODO: handle exception
                    e.printStackTrace();
                

                synchronized (this) 
                    if (t <= 10) 
                        System.out.println(Thread.currentThread().getName() + "窗口售：第" + t + "张票");
                        t++;
                    
                    if (t > 10) 
                        flag = false;