Java基础之线程——使用执行器（UsingExecutors)

控制台程序。

在这个版本的银行示例中，把借款和贷款事务创建为在不同线程中执行的任务，它们把事务提交给职员。创建事务的任务是Callable<>任务，因为它们需要返回已为每个账户创建的借款或贷款事务的总额。

// Defines a customer account
public class Account {
  // Constructor
  public Account(int accountNumber, int balance) {
    this.accountNumber = accountNumber;                                // Set the account number
    this.balance = balance;                                            // Set the initial balance
  }

  // Return the current balance
  public int getBalance() {
    return balance;
  }

  // Set the current balance
  public void setBalance(int balance) {
    this.balance = balance;
  }

  public int getAccountNumber() {
    return accountNumber;
  }

  @Override
  public String toString() {
    return "A/C No. " + accountNumber + " : $" + balance;
  }

  private int balance;                                                 // The current account balance
  private int accountNumber;                                           // Identifies this account
}

// Bank account transaction types
public enum TransactionType {DEBIT, CREDIT }

public class Transaction {
  // Constructor
  public Transaction(Account account, TransactionType type, int amount) {
    this.account = account;
    this.type = type;
    this.amount = amount;
  }

  public Account getAccount() {
    return account;
  }

  public TransactionType getTransactionType() {
    return type;
  }

  public int getAmount() {
    return amount;
  }
  @Override
  public String toString() {
    return type + " A//C: " + ": $" + amount;
  }

  private Account account;
  private int amount;
  private TransactionType type;
}

// Define the bank

public class Bank {
  // Perform a transaction
  public void doTransaction(Transaction transaction) {
    synchronized(transaction.getAccount()) {
      int balance = 0;
      switch(transaction.getTransactionType()) {
        case CREDIT:
          System.out.println("Start credit of " +
                  transaction.getAccount() + " amount: " +
                  transaction.getAmount());

            // Get current balance
            balance = transaction.getAccount().getBalance();

            // Credits require a lot of checks...
            try {
              Thread.sleep(100);

            } catch(InterruptedException e) {
              System.out.println(e);
            }
            balance += transaction.getAmount();                        // Increment the balance
            transaction.getAccount().setBalance(balance);              // Restore account balance
            System.out.println("  End credit of " +
                    transaction.getAccount() + " amount: " +
                    transaction.getAmount());
            break;
        case DEBIT:
            System.out.println("Start debit of " +
                    transaction.getAccount() + " amount: " +
                    transaction.getAmount());

            // Get current balance
            balance = transaction.getAccount().getBalance();

            // Debits require even more checks...
            try {
              Thread.sleep(150);

            } catch(InterruptedException e) {
              System.out.println(e);
            }
            balance -= transaction.getAmount();                        // Decrement the balance...
            transaction.getAccount().setBalance(balance);              // Restore account balance

            System.out.println("  End debit of " +
                    transaction.getAccount() + " amount: " +
                    transaction.getAmount());
            break;

        default:                                                       // We should never get here
          System.out.println("Invalid transaction");
          System.exit(1);
      }
    }
  }
}

import java.util.List;
import java.util.Collections;
import java.util.LinkedList;

public class Clerk implements Runnable {
  // Constructor
  public Clerk(int ID, Bank theBank) {
    this.ID = ID;
    this.theBank = theBank;                                            // Who the clerk works for
  }

  // Receive a transaction
  synchronized public boolean doTransaction(Transaction transaction) {
    if(inTray.size() >= maxTransactions)
      return false;
    inTray.add(transaction);                                           // Add transaction to the list
    return true;
  }

  // The working clerk...
   public void run() {
    while(true) {
      while(inTray.size() == 0) {                                      // No transaction waiting?
        try {
          Thread.sleep(200);                                           // then take a break
          if(inTray.size() != 0) {
            break;
          } else {
            return;
          }
        } catch(InterruptedException e) {
          System.out.println("Clerk "+ ID + "
" + e);
          return;
        }
      }
      theBank.doTransaction(inTray.remove(0));
      if(Thread.interrupted()) {
        System.out.println("Interrupt flag for Clerk " + ID + " set. Terminating.");
        return;
      }
    }
  }

  int ID;
  private Bank theBank;
  private List<Transaction> inTray =                                   // The in-tray holding transactions
                   Collections.synchronizedList(new LinkedList<Transaction>());
  private int maxTransactions = 8;                                     // Maximum transactions in the in-tray
}

// Generates transactions for clerks
import java.util.Random;
import java.util.Vector;
import java.util.concurrent.Callable;

public class TransactionSource implements Callable<int[]> {

  public TransactionSource(TransactionType type, int maxTrans, Vector<Account> accounts, Vector<Clerk> clerks) {
    this.type = type;
    this.maxTrans = maxTrans;
    this.accounts = accounts;
    this.clerks = clerks;
    totals = new int[accounts.size()];
  }

  // The source of transactions
  public int[] call() {
    // Create transactions randomly distributed between the accounts
    Random rand = new Random();
    Transaction transaction = null;                                    // Stores a transaction
    int amount = 0;                                                    // Stores an amount of money
    int select = 0;                                                    // Selects an account
    boolean done = false;
    for(int i = 1 ; i <= maxTrans ; ++i) {
      // Generate a random account index for  operation
      select = rand.nextInt(accounts.size());
      amount = 50 + rand.nextInt(26);                                  // Generate amount of $50 to $75
      transaction = new Transaction(accounts.get(select),              // Account
                                    type,                              // Transaction type
                                    amount);                           //  of amount
      totals[select] += amount;                                        // Keep total tally for account
      done = false;
      while(true) {
        // Find a clerk to do the transaction
        for(Clerk clerk : clerks) {
          if(done = clerk.doTransaction(transaction))
            break;
        }
        if(done) {
          break;
        }

        // No clerk was free so wait a while
        try {
          Thread.sleep(10);
        } catch(InterruptedException e) {
          System.out.println(" TransactionSource
" + e);
          return totals;
        }
      }
      if(Thread.interrupted()) {
        System.out.println("Interrupt flag for "+ type + " transaction source set. Terminating.");
        return totals;
      }
    }
    return totals;
  }

  private TransactionType type;
  private int maxTrans;
  private Vector<Account> accounts;
  private Vector<Clerk> clerks;
  private int[] totals;
}

import java.util.Vector;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class UsingExecutors {

    public static void main(String[] args) {
      int[] initialBalance = {500, 800};                               // The initial account balances
      int[] totalCredits = new int[initialBalance.length];             // Two different cr totals
      int[] totalDebits = new int[initialBalance.length];              // Two different db totals
      int transactionCount = 20;                                       // Number of debits and of credits
      int clerkCount = 2;

      // Create the account, the bank, and the clerks...
      Bank theBank = new Bank();                                       // Create a bank
      Vector<Clerk> clerks = new Vector<Clerk>();                      // Stores the clerk
      Vector<Account> accounts = new Vector<Account>();                // Stores the accounts

      for(int i = 0 ; i < clerkCount ; ++i) {
        clerks.add(new Clerk(i+1, theBank));                           // Create the clerks
      }

      for(int i = 0 ; i < initialBalance.length; ++i) {
        accounts.add(new Account(i+1, initialBalance[i]));             // Create accounts
        totalCredits[i] = totalDebits[i] = 0;
      }

      ExecutorService threadPool = Executors.newCachedThreadPool();

      // Create and start the transaction source threads
      Future<int[]> credits = threadPool.submit(new TransactionSource(TransactionType.CREDIT, transactionCount, accounts, clerks));
      Future<int[]> debits = threadPool.submit(new TransactionSource(TransactionType.DEBIT, transactionCount, accounts, clerks));

      // Create and start the clerk threads
      for(Clerk clerk : clerks) {
        threadPool.submit(clerk);
      }
      try {
        totalCredits = credits.get();
        totalDebits = debits.get();
      } catch(ExecutionException e) {
        System.out.println(e.getCause());
      } catch(InterruptedException e) {
        System.out.println(e);
      }

    // Orderly shutdown when all threads have ended
    threadPool.shutdown();
    try {
      threadPool.awaitTermination(10L, TimeUnit.SECONDS);
    } catch(InterruptedException e) {
      System.out.println(e);
    }

    if(threadPool.isTerminated()) {
      System.out.println("
All clerks have completed their tasks.
");
    } else {
      System.out.println("
Clerks still running - shutting down anyway.
");
      threadPool.shutdownNow();
    }

    // Now output the results
    for(int i = 0 ; i < accounts.size() ; ++i) {
      System.out.println("Account Number:"+accounts.get(i).getAccountNumber()+"
"+
         "Original balance    : $" + initialBalance[i] + "
" +
         "Total credits       : $" + totalCredits[i] + "
" +
         "Total debits        : $" + totalDebits[i] + "
" +
         "Final balance       : $" + accounts.get(i).getBalance() + "
" +
         "Should be           : $" + (initialBalance[i]
                                   + totalCredits[i]
                                   - totalDebits[i]) + "
");
    }
  }
}