201771010124 王海珍 《面向對象設計 java》第十七週實驗總結

時間  2020-08-30
標籤 面向對象設計 java 第十七 實驗 總結 欄目 軟件設計 简体版
原文   原文鏈接

1、理論部分java

一、多線程併發執行中的問題sql

◆多個線程相對執行的順序是不肯定的。編程

◆線程執行順序的不肯定性會產生執行結果的不肯定性。安全

◆在多線程對共享數據操做時經常會產生這種不肯定性。數據結構

二、線程的同步多線程

-多線程併發運行不肯定性問題解決方案：引入線程同步機制，使得另外一線程要使用該方法，就只能等待。併發

- 在Java中解決多線程同步問題的方法有兩種：dom

- Java SE 5.0中引入ReentrantLock類ide

- 在共享內存的類方法前加synchronized修飾符。學習

……

public synchronized static void sub(int m)

……

（1）解決方案一：鎖對象與條件對象

用ReentrantLock保護代碼塊的基本結構以下：

myLock.lock();

try {

     critical section

}

finally

{

     myLock.unlock(); 

}

有關鎖對象和條件對象的關鍵要點:

➢ 鎖用來保護代碼片斷，保證任什麼時候刻只能有一個線程執行被保護的代碼。

➢ 鎖管理試圖進入被保護代碼段的線程。

➢ 鎖可擁有一個或多個相關條件對象。 ➢ 每一個條件對象管理那些已經進入被保護的代碼段但還不能運行的線程。

（2）解決方案二： synchronized關鍵字

synchronized關鍵字做用：

➢某個類內方法用synchronized 修飾後，該方法被稱爲同步方法； ➢只要某個線程正在訪問同步方法，其餘線程欲要訪問同步方法就被阻塞，直至線程從同步方法返回前喚醒被阻塞線程，其餘線程方可能進入同步方法。

三、在同步方法中使用wait()、notify 和notifyAll()方法

➢ 一個線程在使用的同步方法中時，可能根據問題的須要，必須使用wait()方法使本線程等待，暫時讓出CPU的使用權，並容許其它線程使用這個同步方法。

➢ 線程若是用完同步方法，應當執行notifyAll()方法通知全部因爲使用這個同步方法而處於等待的線程結束等待。

2、實驗部分

1、實驗目的與要求

(1) 掌握線程同步的概念及實現技術； 

(2) 線程綜合編程練習

2、實驗內容和步驟

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

測試程序1：

l 在Elipse環境下調試教材651頁程序14-7，結合程序運行結果理解程序；

l 掌握利用鎖對象和條件對象實現的多線程同步技術。

package synch;

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

/**
 * 一種擁有許多銀行賬戶的銀行，它使用鎖來序列化訪問。
 * @version 1.30 2004-08-01
 * @author Cay Horstmann
 */
public class Bank
{
   private final double[] accounts;
   private Lock bankLock;
   private Condition sufficientFunds;

   /**
    *構建了銀行。
    * @param 帳戶數量
    * @param 每一個帳戶的初始餘額
    */
   public Bank(int n, double initialBalance)
   {
      accounts = new double[n];
      Arrays.fill(accounts, initialBalance);
      bankLock = new ReentrantLock();
      sufficientFunds = bankLock.newCondition();
   }

   /**
    * 把錢從一個帳戶轉到另外一個帳戶。
    * @param 從帳戶轉出
    * @param 到帳轉到
    * @param 轉賬金額
    */
   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();
      }
   }

   /**
    *獲取全部賬戶餘額的總和。
    * @return 總平衡
    */
   public double getTotalBalance()//爲何只須要加鎖不須要設置對象？沒有任何執行不下去的緣由，就不須要條件對象。
   {
      bankLock.lock();
      try
      {
         double sum = 0;

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

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

   /**
    * 獲取銀行中的賬戶編號。
    * @return 帳戶數量
    */
   public int size()
   {
      return accounts.length;
   }
}

 

package synch;
/**
 * 這個程序展現了多線程如何安全地訪問數據結構。
 * @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();
      }
   }
}

 測試結果以下所示

測試程序2：

l 在Elipse環境下調試教材655頁程序14-8，結合程序運行結果理解程序；

l 掌握synchronized在多線程同步中的應用。

 

package synch2;

import java.util.*;

/**
 * 使用同步原語的具備多個銀行賬戶的銀行
 * @version 1.30 2004-08-01
 * @author Cay Horstmann
 */
public class Bank
{
   private final double[] accounts;

   /**
    * 構建了銀行。
    * @param  帳戶數量
    * @param 每一個帳戶的初始餘額
    */
   public Bank(int n, double initialBalance)
   {
      accounts = new double[n];
      Arrays.fill(accounts, initialBalance);
   }

   /**
    * 把錢從一個帳戶轉到另外一個帳戶。
    * @param 從帳戶轉出
    * @param 到帳轉到
    * @param 轉賬金額
    */
   public synchronized void transfer(int from, int to, double amount) throws InterruptedException
   {
      while (accounts[from] < amount)
         wait();//Object類
      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();
   }
   /**
    *獲取全部賬戶餘額的總和。
    * @return 總平衡
    */
   public synchronized double getTotalBalance()
   {
      double sum = 0;

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

      return sum;
   }

   /**
    * 獲取銀行中的賬戶編號。
    * @return 帳戶數量
    */
   public int size()
   {
      return accounts.length;
   }
}

 

package synch2;

/**
 * 這個程序展現了多線程如何安全地訪問一個數據結構，使用同步方法。
 * @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();
      }
   }
}

 測試結果以下所示

測試程序3：

l 在Elipse環境下運行如下程序，結合程序運行結果分析程序存在問題；

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

class Cbank

{

     private static int s=2000;

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

  }

}

存在問題：兩個線程各作各的

實驗結果以下圖所示：

 

修改以後以下

import javax.sql.rowset.spi.SyncFactory;

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張票

 

public class Demo {
    public static void main(String[] args) {
        Mythread mythread = new Mythread();
        Thread ticket1 = new Thread(mythread);
        Thread ticket2 = new Thread(mythread);
        Thread ticket3 = new Thread(mythread);
        ticket1.start();
        ticket2.start();
        ticket3.start();
    }
}

class Mythread implements Runnable {
    int ticket = 1;
    boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

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

}

 

 結果以下所示

第三部分   實驗總結

   本次實驗是java的最後一次實驗，相比來講比前面的實驗相對簡單，並且牛百泉學長也將最後一個編程題給咱們演示了一遍，因此此次的實驗作起來也是較爲簡單的。本學期的java實驗課也就此結束了，叢中也學習到了好多，牛學長真的是至關的優秀，也給咱們教了不少的東西，在此謝謝他不厭其煩的爲咱們答疑解惑。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程