徐思 201771010132

時間 2019-11-11

原文原文鏈接

1、理論知識部分：java

程序是一段靜態的代碼，它是應用程序執行的藍本。進程是程序的一次動態執行，它對應了從代碼加載、執行至執行完畢的一個完整過程。操做系統爲每一個進程分配一段獨立的內存空間和系統資源，包括：代碼數據以及堆棧等資源。每個進程的內部數據和狀態都是徹底獨立的。多任務操做系統中，進程切換對CPU資源消耗較大。編程

多線程是進程執行過程當中產生的多條執行線索。線程是比進程執行更小的單位。線程不能獨立存在，必須存在於進程中，同一進程的各線程間共享進程空間的數據。每一個線程有它自身的產生、存在和消亡的過程，是一個動態的概念。多線程意味着一個程序的多行語句能夠看上去幾乎在同一時間內同時運行。線程建立、銷燬和切換的負荷遠小於進程，又稱爲輕量級進程。多線程

Java實現多線程有兩種途徑：建立Thread類的子類；在程序中定義實現Runnable接口的類。併發

用Thread類的子類建立線程：首先需從Thread類派生出一個子類，在該子類中重寫run()方法。而後用建立該子類的對象Lefthand left=new Lefthand(); Righthand right=new Righthand();最後用start()方法啓動線程 left.start(); right.start();dom

用Thread類的子類建立多線程的關鍵性操做：定義Thread類的子類並實現用戶線程操做，即run()方法的實現。在適當的時候啓動線程。因爲Java只支持單重繼承，用這種方法定義的類不可再繼承其餘父類。ide

用Runnable()接口實現線程：首先設計一個實現Runnable接口的類；而後在類中根據須要重寫run方法；再建立該類對象，以此對象爲參數創建Thread 類的對象；調用Thread類對象的start方法啓動線程，將 CPU執行權轉交到run方法。測試

Thread(Runnable r)：建立一個新線程，它調用r的run(), r是一個實現了Runnable接口的類的實例。this

線程兩種建立方法比較：實現Runnable接口的優點：符合OO設計的思想；便於用extends繼承其它類。採用繼承Thread類方法的優勢：代碼簡單。spa

線程的終止：當線程的run方法執行方法體中最後一條語句後，或者出現了在run方法中沒有捕獲的異常時，線程將終止，讓出CPU使用權。調用interrupt()方法也可終止線程。 void interrupt() ：向一個線程發送一箇中斷請求，同時把這個線程的「interrupted」狀態置爲true。若該線程處於 blocked 狀態，會拋出 InterruptedException。操作系統

測試線程是否被中斷的方法：static boolean interrupted() ：檢測當前線程是否已被中斷，並重置狀態「interrupted」值爲false。 boolean isInterrupted() ：檢測當前線程是否已被中斷，不改變狀態「interrupted」值。

利用各線程的狀態變換，能夠控制各個線程輪流使用CPU，體現多線程的並行性特徵。

線程有以下7種狀態：New (新建)；Runnable (可運行)；Running(運行) ；Blocked (被阻塞) ；Waiting (等待) ；Timed waiting (計時等待) ； Terminated (被終止)。

new（新建）：線程對象剛剛建立，尚未啓動，此時線程還處於不可運行狀態。例如: Thread thread=new Thread(r); 此時線程thread處於新建狀態，有了相應的內存空間以及其它資源。

runnable（可運行狀態)：此時線程已經啓動，處於線程的run()方法之中。此時的線程可能運行，也可能不運行，只要 CPU一空閒，立刻就會運行。調用線程的start()方法可以使線程處於「可運行」狀態。例如： thread.start();

blocked (被阻塞)：一個正在執行的線程因特殊緣由，被暫停執行，進入阻塞狀態。阻塞時線程不能進入隊列排隊，必須等到引發阻塞的緣由消除，纔可從新進入排隊隊列。引發阻塞的緣由不少，不一樣緣由要用不一樣的方法解除。sleep(),wait()是兩個經常使用引發線程阻塞的方法。

線程阻塞的三種狀況：等待阻塞：經過調用線程的wait()方法，讓線程等待某工做的完成。同步阻塞:線程在獲取synchronized同步鎖失敗(由於鎖被其它線程所佔用)，它會進入同步阻塞狀態。其餘阻塞:經過調用線程的sleep()或join() 或發出了I/O請求時，線程會進入到阻塞狀態。當 sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程從新轉入就緒狀態。

Terminated (被終止) :線程被終止的緣由有二：一是run()方法中最後一個語句執行完畢而自然死亡。二是由於一個沒有捕獲的異常終止了run方法而意外死亡。能夠調用線程的 stop 方法殺死一個線程（thread.stop();)，可是，stop方法已過期，不要在本身的代碼中調用它。

線程的掛起和恢復: suspend() 和 resume() 方法：兩個方法可配套使用，suspend()使得線程進入阻塞狀態，而且不會自動恢復，必須其對應的 resume()被調用，才能使得線程從新進入可執行狀態。但這種方法很容易引發線程死鎖問題，已不推薦使用。

其餘判斷和影響線程狀態的方法：join()：等待指定線程的終止。 join(long millis)：通過指定時間等待終止指定的線程。 isAlive()：測試當前線程是否在活動。 yield()：讓當前線程由「運行狀態」進入到「就緒狀態」，從而讓其它具備相同優先級的等待線程獲取執行權。

Java 的線程調度採用優先級策略:優先級高的先執行，優先級低的後執行；多線程系統會自動爲每一個線程分配一個優先級，缺省時，繼承其父類的優先級；任務緊急的線程，其優先級較高；同優先級的線程按「先進先出」的隊列原則。

Thread類有三個與線程優先級有關的靜態量： MAX_PRIORITY：最大優先權,值爲10； MIN_PRIORITY：最小優先權,值爲1； NORM _PRIORITY：默認優先權,值爲5。

調用setPriority(int a)重置當前線程的優先級，a取值能夠是前述的三個靜態量。調用getPriority()得到當前線程優先級。

下面幾種狀況下，當前運行線程會放棄CPU：線程調用了yield() 或sleep() 方法；搶先式系統下，有高優先級的線程參與調度；因爲當前線程進行I/O訪問、外存讀寫、等待用戶輸入等操做致使線程阻塞；或者是爲等候一個條件變量，以及線程調用wait() 方法。

守護線程的唯一用途是爲其餘線程提供服務。例如計時線程。在一個線程啓動以前，調用setDaemon方法可將線程轉換爲守護線程。例如：setDaemon(true);

多線程併發執行中的問題：多個線程相對執行的順序是不肯定的。線程執行順序的不肯定性會產生執行結果的不肯定性。在多線程對共享數據操做時經常會產生這種不肯定性

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

在Java中解決多線程同步問題的方法有兩種：J ava SE 5.0中引入ReentrantLock類。在共享內存的類方法前加synchronized修飾符。

有關鎖對象和條件對象的關鍵要點:鎖用來保護代碼片斷，保證任什麼時候刻只能有一個線程執行被保護的代碼。鎖管理試圖進入被保護代碼段的線程。鎖可擁有一個或多個相關條件對象。每一個條件對象管理那些已經進入被保護的代碼段但還不能運行的線程。

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

在同步方法中使用wait()、notify 和notifyAll()方法：一個線程在使用的同步方法中時，可能根據問題的須要，必須使用wait()方法使本線程等待，暫時讓出CPU的使用權，並容許其它線程使用這個同步方法。線程若是用完同步方法，應當執行notifyAll()方法通知全部因爲使用這個同步方法而處於等待的線程結束等待。

2、實驗部分：

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);// 分配新的 Thread 對象
            t.start();// 開始線程
        }
    }
}

SynchBankTest

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

Bank

測試程序2：

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

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

package synch2;

/**
 * This program shows how multiple threads can safely access a data structure,
 * using synchronized methods.
 * 
 * @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);// 分配新的 Thread 對象
            t.start();// 使線程開始執行
        }
    }
}

SynchBankTest2

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();// 解除等待線程的阻塞狀態
    }

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

Bank

測試程序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();

}

運行結果：

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 t1 = new Thread(mythread);
        Thread t2 = new Thread(mythread);
        Thread t3 = new Thread(mythread);
        t1.start();
        t2.start();
        t3.start();
    }
}

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

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (flag) {
            try {
                Thread.sleep(500);
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }

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

        }

    }
}

3、實驗總結：

此次實驗比較簡單，編程須要多加練習，知識點也需好好複習，爲期末作準備。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。