實驗十六  執行緒技術

實驗時間 2017-12-8

一.理論知識部分

1.程式是一段靜態的程式碼，它應用程式執行藍 是一段靜態的程式碼，它應用程式執行藍 是一段靜態的程式碼，它應用程式執行藍本。

2.程序是程式的一次動態執行，它對應了從程式碼載入、執行至執行完畢的一個完整過程。

3.多執行緒是程序執行過中產生的多條線索。

4.執行緒是比程序執行更小的單位。

5.執行緒不能獨立存在，必須存在於程序中，同一進 程的各執行緒間共享程序空間的資料。

6.多執行緒意味著一個程式的多行語句可以看上去幾 乎在同一時間內同時執行。

7.用Thread類的子類建立執行緒：首先需從Thread類派生出一個子類，在該子類中 重寫run()方法。然後用建立該子類的物件。 最後用start()方法啟動執行緒。

8.用Runnable()介面實現執行緒：首先設計一個實現Runnable介面的類； 然後在類中根據需要重寫run方法； 再建立該類物件，以此物件為引數建立Thread 類的物件；  呼叫Thread類物件的start方法啟動執行緒，將 CPU執行權轉交到run方法。

9.執行緒的終止：當執行緒的run方法執行方法體中最後一條語句後， 或者出現了在run方法中沒有捕獲的異常時，線 程將終止，讓出CPU使用權。呼叫interrupt()方法也可終止執行緒。

10.執行緒的狀態：利用各執行緒的狀態變換，可以控制各個執行緒輪流 使用CPU，體現多執行緒的並行性特徵。執行緒有如下7種狀態： New (新建) 、Runnable (可執行) 、Running(執行) 、Blocked (被阻塞) 、Waiting (等待) 、Timed waiting (計時等待) 、Terminated (被終止)

11.呼叫setPriority(int a)重置當前執行緒的優先順序， a 取值可以是前述的三個靜態量。

     呼叫getPriority()獲得當前執行緒優先順序。

12.多執行緒併發執行中的問題：
多個執行緒相對執行的順序是不確定的。執行緒執行順序的不確定性會產生執行結果的不確定性。 在多執行緒對共享資料操作時常常會產生這種不確定性。

二.理論知識部分

1、實驗目的與要求

(1) 掌握執行緒概念；

(2) 掌握執行緒建立的兩種技術；

(3) 理解和掌握執行緒的優先順序屬性及排程方法；

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

2、實驗內容和步驟

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

測試程式1：

l 在elipse IDE中除錯執行ThreadTest，結合程式執行結果理解程式；

l 掌握執行緒概念；

l 掌握用Thread的擴充套件類實現執行緒的方法；

l 利用Runnable介面改造程式，掌握用Runnable介面建立執行緒的方法。

package qq;
class Lefthand implements Runnable {
    public void run() {
        for (int i = 0; i <= 5; i++) {
            System.out.println("You are Students!");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println("Lefthand error.");
            }
        }
    }
}

class Righthand implements Runnable {
    public void run() {
        for (int i = 0; i <= 5; i++) {
            System.out.println("I am a Teacher!");
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                System.out.println("Righthand error.");
            }
        }
    }
}

/*public class TheadTest {
    static Lefthand left;
    static Righthand right;

    public static void main(String[] args) {
        Righthand righthand = new Righthand();
        Lefthand lefthand = new Lefthand();
        Thread left = new Thread(lefthand);
        Thread right = new Thread(righthand);
        left.start();
        right.start();
    }
}*/
public class TheadTest {
    static Thread left;
    static Thread right;

    public static void main(String[] args) {
        Lefthand rleft = new Lefthand();
        Runnable rright=new Righthand();
        left = new Thread(rleft);
        right = new Thread(rright);
        left.start();
        right.start();
    
}

}

測試程式2：

l 在Elipse環境下除錯教材625頁程式14-1、14-2 、14-3，結合程式執行結果理解程式；

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

l 對比兩個程式，理解執行緒的概念和用途；

l 掌握執行緒建立的兩種技術。

package bounceThread;

import java.awt.geom.*;

/**
   A ball that moves and bounces off the edges of a 
   rectangle
 * @version 1.33 2007-05-17
 * @author Cay Horstmann
*/
public class Ball
{
   private static final int XSIZE = 15;
   private static final int YSIZE = 15;
   private double x = 0;
   private double y = 0;
   private double dx = 1;
   private double dy = 1;

   /**
      Moves the ball to the next position, reversing direction
      if it hits one of the edges
   */
   //判斷球的邊界所處狀態的四個條件
   public void move(Rectangle2D bounds)
   {
      x += dx;
      y += dy;
      if (x < bounds.getMinX())
      { 
         x = bounds.getMinX();
         dx = -dx;
      }
      if (x + XSIZE >= bounds.getMaxX())
      {
         x = bounds.getMaxX() - XSIZE; 
         dx = -dx; 
      }
      if (y < bounds.getMinY())
      {
         y = bounds.getMinY(); 
         dy = -dy;
      }
      if (y + YSIZE >= bounds.getMaxY())
      {
         y = bounds.getMaxY() - YSIZE;
         dy = -dy; 
      }
   }

   /**
      Gets the shape of the ball at its current position.
   */
   public Ellipse2D getShape()
   {
      return new Ellipse2D.Double(x, y, XSIZE, YSIZE);
   }
}

package bounceThread;

import java.awt.*;
import java.util.*;
import javax.swing.*;

/**
 * The component that draws the balls.
 * @version 1.34 2012-01-26
 * @author Cay Horstmann
 */
public class BallComponent extends JComponent
{
   private static final int DEFAULT_WIDTH = 450;
   private static final int DEFAULT_HEIGHT = 350;

   private java.util.List<Ball> balls = new ArrayList<>();

   /**
    * Add a ball to the panel.
    * @param b the ball to add
    */
   public void add(Ball b)
   {
      balls.add(b);
   }

   public void paintComponent(Graphics g)
   {
      Graphics2D g2 = (Graphics2D) g;
      for (Ball b : balls)
      {
         g2.fill(b.getShape());
      }
   }
   
   public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }
}

package bounce;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

/**
 * Shows an animated bouncing ball.
 * @version 1.34 2015-06-21
 * @author Cay Horstmann
 */
public class Bounce
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame frame = new BounceFrame();
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

/**
 * The frame with ball component and buttons.
 */
class BounceFrame extends JFrame
{
   private BallComponent comp;
   public static final int STEPS = 1000;
   public static final int DELAY = 3;

   /**
    * Constructs the frame with the component for showing the bouncing ball and
    * Start and Close buttons
    */
   public BounceFrame()
   {
      setTitle("Bounce");
      comp = new BallComponent();
      add(comp, BorderLayout.CENTER);
      JPanel buttonPanel = new JPanel();
      addButton(buttonPanel, "Start", event -> addBall());
      addButton(buttonPanel, "Close", event -> System.exit(0));
      add(buttonPanel, BorderLayout.SOUTH);//將buttonPanel元件整體放在南端
      pack();
   }

   /**
    * Adds a button to a container.
    * @param c the container
    * @param title the button title
    * @param listener the action listener for the button
    */
   public void addButton(Container c, String title, ActionListener listener)
   {
      JButton button = new JButton(title);
      c.add(button);
      button.addActionListener(listener);
   }

   /**
    * Adds a bouncing ball to the panel and makes it bounce 1,000 times.
    */
   public void addBall()
   {
      try
      {
         Ball ball = new Ball();
         comp.add(ball);

         for (int i = 1; i <= STEPS; i++)
         {
            ball.move(comp.getBounds());//呼叫move方法
            comp.paint(comp.getGraphics());
            Thread.sleep(DELAY);//呼叫執行緒的sleep方法
         }
      }
      catch (InterruptedException e)
      {
      }
   }
}

14—4

package bounceThread;

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

/**
 * Shows animated bouncing balls.
 * @version 1.34 2015-06-21
 * @author Cay Horstmann
 */
public class BounceThread
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame frame = new BounceFrame();
         frame.setTitle("BounceThread");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

/**
 * The frame with panel and buttons.
 */
class BounceFrame extends JFrame
{
   private BallComponent comp;
   public static final int STEPS = 1000;
   public static final int DELAY = 5;


   /**
    * Constructs the frame with the component for showing the bouncing ball and
    * Start and Close buttons
    */
   public BounceFrame()
   {
      comp = new BallComponent();
      add(comp, BorderLayout.CENTER);
      JPanel buttonPanel = new JPanel();
      addButton(buttonPanel, "Start", event -> addBall());
      addButton(buttonPanel, "Close", event -> System.exit(0));
      add(buttonPanel, BorderLayout.SOUTH);
      pack();
   }

   /**
    * Adds a button to a container.
    * @param c the container
    * @param title the button title
    * @param listener the action listener for the button
    */
   public void addButton(Container c, String title, ActionListener listener)
   {
      JButton button = new JButton(title);
      c.add(button);
      button.addActionListener(listener);
   }

   /**
    * Adds a bouncing ball to the canvas and starts a thread to make it bounce
    */
   public void addBall()
   {
      Ball ball = new Ball();
      comp.add(ball);
      //引用實現了Runnable的方法
      Runnable r = () -> { 
         try
         {  
            for (int i = 1; i <= STEPS; i++)
            {
               ball.move(comp.getBounds());
               comp.repaint();
               Thread.sleep(DELAY);
            }
         }
         catch (InterruptedException e)
         {
         }
      };
      Thread t = new Thread(r);//用Runnable建立一個Thread物件
      t.start();//啟動執行緒
   }
}

實驗結果：

測試程式3：分析以下程式執行結果並理解程式。

class Race extends Thread {
    public static void main(String args[]) {
        Race[] runner = new Race[4];
        for (int i = 0; i < 4; i++)
            runner[i] = new Race();
        for (int i = 0; i < 4; i++)
            runner[i].start();
        runner[1].setPriority(MIN_PRIORITY);
        runner[3].setPriority(MAX_PRIORITY);
    }

    public void run() {
        for (int i = 0; i < 1000000; i++);//用來延時，相當於Sleep,但不會釋放CPU
        System.out.println(getName() + "執行緒的優先順序是" + getPriority() + "已計算完畢!");
    }
}

實驗結果：

測試程式4

l 教材642頁程式模擬一個有若干賬戶的銀行，隨機地生成在這些賬戶之間轉移錢款的交易。每一個賬戶有一個執行緒。在每一筆交易中，會從執行緒所服務的賬戶中隨機轉移一定數目的錢款到另一個隨機賬戶。

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

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);//將指定的 double 值分配給指定 double 型陣列的每個元素
      bankLock = new ReentrantLock();
      sufficientFunds = bankLock.newCondition();//返回繫結到此 Lock 例項的新 Condition 例項
   }

   /**
    * 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 = () -> {//用Lambda表示式簡化程式碼
            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();
      }
   }
}

實驗結果：

綜合程式設計練習

程式設計練習1

1. 設計一個使用者資訊採集程式，要求如下：

（1） 使用者資訊輸入介面如下圖所示:

（2） 使用者點選提交按鈕時，使用者輸入資訊顯示控制檯介面；

（3） 使用者點選重置按鈕後，清空使用者已輸入資訊；

（4） 點選視窗關閉，程式退出。

package qq;

import java.awt.EventQueue;

import javax.swing.JFrame;

public class Mian {
    public static void main(String[] args) {
        EventQueue.invokeLater(() -> {
            DemoJFrame page = new DemoJFrame();
        });
    }
}

package qq;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.Window;

public class WinCenter {
    public static void center(Window win){
        Toolkit tkit = Toolkit.getDefaultToolkit();//獲取預設工具包
        Dimension sSize = tkit.getScreenSize();//獲取螢幕的大小
        Dimension wSize = win.getSize();
        if(wSize.height > sSize.height){
            wSize.height = sSize.height;
        }
        if(wSize.width > sSize.width){
            wSize.width = sSize.width;
        }
        win.setLocation((sSize.width - wSize.width)/ 2, (sSize.height - wSize.height)/ 2);//將元件移到新的位置
    }
}

package qq;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.LayoutManager;
import java.awt.Panel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Timer;
import java.util.TimerTask;

import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.ButtonModel;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTextField;

public class DemoJFrame extends JFrame {
    private JPanel jPanel1;
    private JPanel jPanel2;
    private JPanel jPanel3;
    private JPanel jPanel4;
    private JTextField fieldname;
    private JComboBox comboBox;
    private JTextField fieldadress;
    private ButtonGroup bg;
    private JRadioButton nan;
    private JRadioButton nv;
    private JCheckBox sing;
    private JCheckBox dance;
    private JCheckBox draw;

    public DemoJFrame() {
        // 設定視窗大小
        this.setSize(800, 400);
        // 設定可見性
        this.setVisible(true);
        // 設定標題
        this.setTitle("Student Detail");
        // 設定關閉操作
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        // 設定視窗居中
        WinCenter.center(this);
        // 建立四個面板物件
        jPanel1 = new JPanel();
        setJPanel1(jPanel1);
        jPanel2 = new JPanel();
        setJPanel2(jPanel2);
        jPanel3 = new JPanel();
        setJPanel3(jPanel3);
        jPanel4 = new JPanel();
        setJPanel4(jPanel4);
        // 設定容器為流式佈局
        FlowLayout flowLayout = new FlowLayout();
        this.setLayout(flowLayout);
        // 將四個面板新增到容器中
        this.add(jPanel1);
        this.add(jPanel2);
        this.add(jPanel3);
        this.add(jPanel4);

    }

    /*
     * 設定面一
     */
    private void setJPanel1(JPanel jPanel) {
        jPanel.setPreferredSize(new Dimension(700, 45));//設定此元件的首選大小
        // 給面板的佈局設定為網格佈局 一行4列
        jPanel.setLayout(new GridLayout(1, 4));
        JLabel name = new JLabel("Name:");
        name.setSize(100, 50);
        fieldname = new JTextField("");
        fieldname.setSize(80, 20);
        JLabel study = new JLabel("Qualification:");
        comboBox = new JComboBox();
        comboBox.addItem("Graduate");
        comboBox.addItem("senior");
        comboBox.addItem("Undergraduate");
        jPanel.add(name);
        jPanel.add(fieldname);
        jPanel.add(study);
        jPanel.add(comboBox);

    }

    /*
     * 設定面板二
     */
    private void setJPanel2(JPanel jPanel) {
        jPanel.setPreferredSize(new Dimension(700, 50));
        // 給面板的佈局設定為網格佈局 一行4列
        jPanel.setLayout(new GridLayout(1, 4));
        JLabel name = new JLabel("Address:");
        fieldadress = new JTextField();
        fieldadress.setPreferredSize(new Dimension(150, 50));
        JLabel study = new JLabel("Hobby:");
        JPanel selectBox = new JPanel();
        selectBox.setBorder(BorderFactory.createTitledBorder(""));
        selectBox.setLayout(new GridLayout(3, 1));
        sing = new JCheckBox("Singing");
        dance = new JCheckBox("Dancing");
        draw = new JCheckBox("Reading");
        selectBox.add(sing);
        selectBox.add(dance);
        selectBox.add(draw);
        jPanel.add(name);
        jPanel.add(fieldadress);
        jPanel.add(study);
        jPanel.add(selectBox);
    }

    /*
     * 設定面板三
     */
    private void setJPanel3(JPanel jPanel) {
        jPanel.setPreferredSize(new Dimension(700, 150));
        FlowLayout flowLayout = new FlowLayout(FlowLayout.LEFT);
        jPanel.setLayout(flowLayout);
        JLabel sex = new JLabel("Sex:");
        JPanel selectBox = new JPanel();
        selectBox.setBorder(BorderFactory.createTitledBorder(""));
        selectBox.setLayout(new GridLayout(2, 1));
        bg = new ButtonGroup();
        nan = new JRadioButton("Male");
        nv = new JRadioButton("Female");
        bg.add(nan);
        bg.add(nv);
        selectBox.add(nan);
        selectBox.add(nv);
        jPanel.add(sex);
        jPanel.add(selectBox);

    }

    /*
     * 設定面板四
     */
    private void setJPanel4(JPanel jPanel) {
        // TODO 自動生成的方法存根
        jPanel.setPreferredSize(new Dimension(700, 150));
        FlowLayout flowLayout = new FlowLayout(FlowLayout.CENTER, 50, 10);
        jPanel.setLayout(flowLayout);
        jPanel.setLayout(flowLayout);
        JButton sublite = new JButton("Validate");
        JButton reset = new JButton("Reset");
        sublite.addActionListener((e) -> valiData());
        reset.addActionListener((e) -> Reset());
        jPanel.add(sublite);
        jPanel.add(reset);
    }

    /*
     * 提交資料
     */
    private void valiData() {
        // 拿到資料
        String name = fieldname.getText().toString().trim();
        String xueli = comboBox.getSelectedItem().toString().trim();
        String address = fieldadress.getText().toString().trim();
        System.out.println(name);
        System.out.println(xueli);
        String hobbystring="";
        if (sing.isSelected()) {
            hobbystring+="Singing   ";
        }
        if (dance.isSelected()) {
            hobbystring+="Dancing   ";
        }
        if (draw.isSelected()) {
            hobbystring+="Reading  ";
        }
        System.out.println(address);
        if (nan.isSelected()) {
            System.out.println("Male");
        }
        if (nv.isSelected()) {
            System.out.println("Female");
        }
        System.out.println(hobbystring);
    }

    /*
     * 重置
     */
    private void Reset() {
        fieldadress.setText(null);
        fieldname.setText(null);
        comboBox.setSelectedIndex(0);
        sing.setSelected(false);
        dance.setSelected(false);
        draw.setSelected(false);
        bg.clearSelection();
    }
}

實驗結果：

2．建立兩個執行緒，每個執行緒按順序輸出5次“你好”，每個“你好”要標明來自哪個執行緒及其順序號。

class Lefthand extends Thread { 

   public void run()

   {

       for(int i=0;i<=4;i++)

       {  System.out.println("1.你好");

           try{   sleep(500);   }

           catch(InterruptedException e)

           { System.out.println("Lefthand error.");}    

       } 

  } 

}

class Righthand extends Thread {

    public void run()

    {

         for(int i=0;i<=4;i++)

         {   System.out.println("2.你好");

             try{  sleep(300);  }

             catch(InterruptedException e)

             { System.out.println("Righthand error.");}

         }

    }

}

public class ThreadTest 

{

     static Lefthand left;

     static Righthand right;

     public static void main(String[] args)

     {     left=new Lefthand();

           right=new Righthand();

           left.start();

           right.start();

     }

}

實驗總結：

       本章我們主要學習了有關線路程的知識，通過本章的學習我學習了很多關於關於執行緒的用法，在實驗課上老師和我們學習了一些有關執行緒的語句，總的來說本章的知識也是很重要的，同樣也是有點難度的。我會繼續努力，努力敲程式碼，希望程式設計水平會有提高。