---恢復內容開始---

實驗十七  執行緒同步控制

實驗時間 2018-12-10

1、實驗目的與要求

(1) 掌握執行緒同步的概念及實現技術；

(2) 執行緒綜合程式設計練習

2、實驗內容和步驟

實驗1：測試程式並進行程式碼註釋。

測試程式1：

l  在Elipse環境下除錯教材651頁程式14-7，結合程式執行結果理解程式；

l  掌握利用鎖物件和條件物件實現的多執行緒同步技術。

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 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();
   }

   /**
    * 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;
   }
}

測試程式2：

l  在Elipse環境下除錯教材655頁程式14-8，結合程式執行結果理解程式；

l  掌握synchronized在多執行緒同步中的應用。

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();
   }
//與加鎖過程基本相同，此時只需對方法體用 synchronized關鍵字修飾即可，無需在建立條件物件，其中notifyAll();與signalAll();作用一致
   /**
    * 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;
   }
}

　　執行結果與測試一相同

測試程式3：

l  在Elipse環境下執行以下程式，結合程式執行結果分析程式存在問題；

l  嘗試解決程式中存在問題。

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();

  }

}

實驗2 程式設計練習

利用多執行緒及同步方法，編寫一個程式模擬火車票售票系統，共3個視窗，賣10張票，程式輸出結果類似（程式輸出不唯一，可以是其他類似結果）。

Thread-0視窗售：第1張票

Thread-0視窗售：第2張票

Thread-1視窗售：第3張票

Thread-2視窗售：第4張票

Thread-2視窗售：第5張票

Thread-1視窗售：第6張票

Thread-0視窗售：第7張票

Thread-2視窗售：第8張票

Thread-1視窗售：第9張票

Thread-0視窗售：第10張票

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo1{
    public static void main(String[] args) {
        demo d = new demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        Thread t3 = new Thread(d);
        t1.start();
        t2.start();
        t3.start();
        
    }
}
class demo implements Runnable{
  int t=1;
  Lock lock = new ReentrantLock();
    @Override
    public void run() {
        // TODO Auto-generated method stub
         
        while(true) {
            
            try {
                Thread.sleep(500);
                
            }catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            lock.lock();
            
        
            if(t<=10)
            {
            
                System.out.println(Thread.currentThread().getName()+"視窗售：第"+t+"張票");
                t++;
            }
            
            
            
            
            
            lock.unlock();
        }
         
            
        }
        
    }
    


 

為何要使用同步？ 
    java允許多執行緒併發控制，當多個執行緒同時操作一個可共享的資源變數時（如資料的增刪改查）， 
    將會導致資料不準確，相互之間產生衝突，因此加入同步鎖以避免在該執行緒沒有完成操作之前，被其他執行緒的呼叫， 
    從而保證了該變數的唯一性和準確性。

1.同步方法 
    即有synchronized關鍵字修飾的方法。 
    由於java的每個物件都有一個內建鎖，當用此關鍵字修飾方法時， 
    內建鎖會保護整個方法。在呼叫該方法前，需要獲得內建鎖，否則就處於阻塞狀態。

    程式碼如： 
    public synchronized void save(){}

   注： synchronized關鍵字也可以修飾靜態方法，此時如果呼叫該靜態方法，將會鎖住整個類

2.同步程式碼塊 
    即有synchronized關鍵字修飾的語句塊。 
    被該關鍵字修飾的語句塊會自動被加上內建鎖，從而實現同步

    程式碼如： 
    synchronized(object){ 
    }

3.使用重入鎖實現執行緒同步

    
    ReentrantLock類是可重入、互斥、實現了Lock介面的鎖， 
    它與使用synchronized方法和快具有相同的基本行為和語義，並且擴充套件了其能力

    ReenreantLock類的常用方法有：

        ReentrantLock() : 建立一個ReentrantLock例項 
        lock() : 獲得鎖 
        unlock() : 釋放鎖