Java基础之线程——管理线程同步代码块（BankOperation4）

控制台程序。

除了同步类对象的方法之外，还可以把程序中的语句或代码块制定为synchronized，这种方式更强大，因为可以指定哪个对象从语句或代码块的同步中获益，而不像同步方法那样仅仅是包含代码的对象能获益。这里可以对给定代码块的任何对象设置锁。当对给定对象执行同步的代码块时，就不能执行对相同对象同步的其他代码或方法。

 // 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: " + account + ": $" + amount;
   }
 
   private Account account;
   private int amount;
   private TransactionType type;
 }

 // Define the bank
 
 public class Bank {
   // Perform a transaction
   public void doTransaction(Transaction transaction) {
     switch(transaction.getTransactionType()) {
       case CREDIT:
         synchronized(transaction.getAccount()) {
         System.out.println("Start credit of " +
                 transaction.getAccount() + " amount: " +
                 transaction.getAmount());
 
           // Get current balance
           int 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:
         synchronized(transaction.getAccount()) {
           System.out.println("Start debit of " +
                   transaction.getAccount() + " amount: " +
                   transaction.getAmount());
 
           // Get current balance
           int 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);
     }
   }
 }

 public class Clerk implements Runnable {
   // Constructor
   public Clerk(Bank theBank) {
     this.theBank = theBank;                                            // Who the clerk works for
     inTray = null;                                                     // No transaction initially
   }
 
   // Receive a transaction
   public void doTransaction(Transaction transaction) {
     inTray = transaction;
   }
 
   // The working clerk...
   public void run() {
     while(true) {                                                      // Non-stop work...
       while(inTray == null) {                                          // No transaction waiting?
         try {
           Thread.sleep(150);                                           // Then take a break...
 
         } catch(InterruptedException e) {
           System.out.println(e);
         }
       }
 
       theBank.doTransaction(inTray);
       inTray = null;                                                   // In-tray is empty
     }
   }
 
   // Busy check
   public boolean isBusy() {
     return inTray != null;                                             // A full in-tray means busy!
   }
 
   private Bank theBank;                                                // The employer - an electronic marvel
   private Transaction inTray;                                          // The in-tray holding a transaction
 }

 import java.util.Random;
 
 public class BankOperation4 {
   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
 
     // Create the account, the bank, and the clerks...
     Bank theBank = new Bank();                                         // Create a bank
     Clerk clerk1 = new Clerk(theBank);                                 // Create the first clerk
     Clerk clerk2 = new Clerk(theBank);                                 // Create the second clerk
 
     // Create the accounts, and initialize total credits and debits
     Account[] accounts = new Account[initialBalance.length];
     for(int i = 0 ; i < initialBalance.length ; ++i) {
       accounts[i] = new Account(i+1, initialBalance[i]);               // Create accounts
       totalCredits[i] = totalDebits[i] = 0;
     }
     // Create the threads for the clerks as daemon, and start them off
     Thread clerk1Thread = new Thread(clerk1);
     Thread clerk2Thread = new Thread(clerk2);
     clerk1Thread.setDaemon(true);                                      // Set first as daemon
     clerk2Thread.setDaemon(true);                                      // Set second as daemon
     clerk1Thread.start();                                              // Start the first
     clerk2Thread.start();                                              // Start the second
 
     // Create transactions randomly distributed between the accounts
     Random rand = new Random();
     Transaction transaction;                                           // Stores a transaction
     int amount = 0;                                                    // Stores an amount of money
     int select = 0;                                                    // Selects an account
     for(int i = 1; i <= transactionCount; i++) {
       // Choose an account at random for credit operation
       select = rand.nextInt(accounts.length);
       amount = 50 + rand.nextInt(26);                                  // Generate amount of $50 to $75
       transaction = new Transaction(accounts[select],                  // Account
                               TransactionType.CREDIT,                  // Credit transaction
                                     amount);                           //  of amount
       totalCredits[select] += amount;                                  // Keep total credit tally
 
       // Wait until the first clerk is free
       while(clerk1.isBusy()) {
         try {
           Thread.sleep(25);                                            // Busy so try later
         } catch(InterruptedException e) {
           System.out.println(e);
         }
       }
       clerk1.doTransaction(transaction);                               // Now do the credit
 
       // choose an account at random for debit operation
       select = rand.nextInt(accounts.length);
       amount = 30 + rand.nextInt(31);                                  // Generate amount of $30 to $60
       transaction = new Transaction(accounts[select],                  // Account
                               TransactionType.DEBIT,                   // Debit transaction
                                     amount);                           //  of amount
       totalDebits[select] += amount;                                   // Keep total debit tally
 
       // Wait until the second clerk is free
       while(clerk2.isBusy()) {
         try {
           Thread.sleep(25);                                            // Busy so try later
         } catch(InterruptedException e) {
           System.out.println(e);
         }
       }
       clerk2.doTransaction(transaction);                               // Now do the debit
     }
 
     // Wait until both clerks are done
     while(clerk1.isBusy() || clerk2.isBusy()) {
       try {
         Thread.sleep(25);
 
       } catch(InterruptedException e) {
         System.out.println(e);
       }
     }
 
     // Now output the results
     for(int i = 0; i < accounts.length; ++i) {
       System.out.println("Account Number:"+accounts[i].getAccountNumber()+"\n"+
          "Original balance    : $" + initialBalance[i] + "\n" +
          "Total credits       : $" + totalCredits[i] + "\n" +
          "Total debits        : $" + totalDebits[i] + "\n" +
          "Final balance       : $" + accounts[i].getBalance() + "\n" +
          "Should be           : $" + (initialBalance[i]
                                    + totalCredits[i]
                                    - totalDebits[i]) + "\n");
     }
   }
 }

synchronized关键字后面圆括号中的表达式用来指定要同步的对象。一旦执行到给定账户对象的同步代码块，就不能再执行为这个账户对象同步的其他代码块或方法。例如，如果用事务的getAccount()方法返回的account[1]对象来引用进行贷款处理的代码块，就不能再执行这个对象的借款处理代码块，但可以执行其他对象的借款处理代码块。