Java基礎-線程

時間 2020-05-12

標籤 java 基礎線程欄目 Java 简体版

原文原文鏈接

2016-2-22 by Damon
java

爲何會排隊等待？

下面的這個簡單的java程序完成四項不相關的任務。這樣的程序有單個控制線程，控制在這四個任務之間線性地移動。此外。由於所需的資源-打印機、磁盤、數據庫和顯示屏--因爲硬件和軟件的限制都有內在的潛伏時間，因此每項任務都包含明顯的等待時間。所以，程序在訪問數據庫以前必須等待打印機完成打印文件的任務，等等。若是您正在等待程序的完成，則這是對計算機資源和您的時間的一種拙劣使用。改進此程序的一種方法是使它成爲多線程的。程序員

四項不相關的任務算法

class myclass {
    static public void main(String args[]) {
        print_a_file();
        manipulate_another_file();
        access_database();
        draw_picture_on_screen();
    }
}

在本例中，每項任務在開始以前必須等待前一項任務完成，即便所涉及的任務絕不相關也是這樣。可是，在現實生活中，咱們常用多線程模型。咱們在處理某些任務的同時也可讓孩子、配偶和父母完成別的任務。例如，我在寫信的同時可能打發個人兒子去郵局買郵票。用軟件術語來講，這稱爲多個控制（或執行）線程。數據庫

能夠用兩種不一樣的方法來得到多個控制線程：編程

多個進程安全

在大多數操做系統中均可以建立多個進程。當一個程序啓動時，它能夠爲即將開始的每項任務建立一個進程，並容許它們同時運行。當一個程序因等待網絡訪問或用戶輸入而被阻塞時，另外一個程序還能夠運行，這樣就增長了資源利用率。可是，按照這種方式建立每一個進程要付出必定的代價：設置一個進程要佔用至關一部分處理器時間和內存資源。並且，大多數操做系統不容許進程訪問其餘進程的內存空間。所以，進程間的通訊很不方便，而且也不會將它本身提供給容易的編程模型。服務器

線程網絡

線程也稱爲輕型進程 (LWP)。由於線程只能在單個進程的做用域內活動，因此建立線程比建立進程要廉價得多。這樣，由於線程容許協做和數據交換，而且在計算資源方面很是廉價，因此線程比進程更可取。線程須要操做系統的支持，所以不是全部的機器都提供線程。Java 編程語言，做爲至關新的一種語言，已將線程支持與語言自己合爲一體，這樣就對線程提供了強健的支持。多線程

使用java編程語言實現線程

Java 編程語言使多線程如此簡單有效，以至於某些程序員說它其實是天然的。儘管在 Java 中使用線程比在其餘語言中要容易得多，仍然有一些概念須要掌握。要記住的一件重要的事情是 main() 函數也是一個線程，並可用來作有用的工做。程序員只有在須要多個線程時才須要建立新的線程。併發

Thread 類

Thread 類是一個具體的類，即不是抽象類，該類封裝了線程的行爲。要建立一個線程，程序員必須建立一個從 Thread 類導出的新類。程序員必須覆蓋 Thread 的 run() 函數來完成有用的工做。用戶並不直接調用此函數；而是必須調用 Thread 的 start() 函數，該函數再調用 run()。下面的代碼說明了它的用法：

建立兩個新線程

import java.util.*;
class TimePrinter extends Thread {
    int pauseTime;
    String name;
    public TimePrinter(int x, String n) {
        pauseTime = x;
        name = n;
    }
    public void run() {
        while(true) {
            try {
                System.out.println(name + ":" + new 
                    Date(System.currentTimeMillis()));
                Thread.sleep(pauseTime);
            } catch(Exception e) {
                System.out.println(e);
            }
        }
    }
    static public void main(String args[]) {
        TimePrinter tp1 = new TimePrinter(1000, "Fast Guy");
        tp1.start();
        TimePrinter tp2 = new TimePrinter(3000, "Slow Guy");
        tp2.start();

    }
}

在本例中，咱們能夠看到一個簡單的程序，它按兩個不一樣的時間間隔（1 秒和 3 秒）在屏幕上顯示當前時間。這是經過建立兩個新線程來完成的，包括 main() 共三個線程。可是，由於有時要做爲線程運行的類可能已是某個類層次的一部分，因此就不能再按這種機制建立線程。雖然在同一個類中能夠實現任意數量的接口，但 Java 編程語言只容許一個類有一個父類。同時，某些程序員避免從 Thread 類導出，由於它強加了類層次。對於這種狀況，就要 runnable 接口。

Runnable 接口

此接口只有一個函數，run()，此函數必須由實現了此接口的類實現。可是，就運行這個類而論，其語義與前一個示例稍有不一樣。咱們能夠用 runnable 接口改寫前一個示例。（不一樣的部分用黑體表示。）

建立兩個新線程

import java.util.*;
class TimePrinter 
        implements Runnable {
    int pauseTime;
    String name;
    public TimePrinter(int x, String n) {
        pauseTime = x;
        name = n;
    }
    public void run() {
        while(true) {
            try {
                System.out.println(name + ":" + new 
                    Date(System.currentTimeMillis()));
                Thread.sleep(pauseTime);
            } catch(Exception e) {
                System.out.println(e);
            }
        }
    }
    static public void main(String args[]) {
        Thread t1 = new Thread (new TimePrinter(1000, "Fast Guy"));
        t1.start();
        Thread t2 = new Thread (new TimePrinter(3000, "Slow Guy"));
        t2.start();

    }
}

請注意，當使用 runnable 接口時，您不能直接建立所需類的對象並運行它；必須從 Thread 類的一個實例內部運行它。許多程序員更喜歡 runnable 接口，由於從 Thread 類繼承會強加類層次。

synchronized 關鍵字

到目前爲止，咱們看到的示例都只是以很是簡單的方式來利用線程。只有最小的數據流，並且不會出現兩個線程訪問同一個對象的狀況。可是，在大多數有用的程序中，線程之間一般有信息流。試考慮一個金融應用程序，它有一個 Account 對象，以下例中所示：

一個銀行中的多項活動

public class Account {
    String holderName;
    float amount;
    public Account(String name, float amt) {
        holderName = name;
        amount = amt;
    }
    public void deposit(float amt) {
        amount += amt;
    }
    public void withdraw(float amt) {
        amount -= amt;
    }
    public float checkBalance() {
        return amount;
    }
}

在此代碼樣例中潛伏着一個錯誤。若是此類用於單線程應用程序，不會有任何問題。可是，在多線程應用程序的狀況中，不一樣的線程就有可能同時訪問同一個 Account 對象，好比說一個聯合賬戶的全部者在不一樣的 ATM 上同時進行訪問。在這種狀況下，存入和支出就可能以這樣的方式發生：一個事務被另外一個事務覆蓋。這種狀況將是災難性的。可是，Java 編程語言提供了一種簡單的機制來防止發生這種覆蓋。每一個對象在運行時都有一個關聯的鎖。這個鎖可經過爲方法添加關鍵字 synchronized 來得到。這樣，修訂過的 Account 對象（以下所示）將不會遭受像數據損壞這樣的錯誤：

對一個銀行中的多項活動進行同步處理

public class Account {
    String holderName;
    float amount;
    public Account(String name, float amt) {
        holderName = name;
        amount = amt;
    }
    public 
        synchronized void deposit(float amt) {
        amount += amt;
    }
    public 
        synchronized void withdraw(float amt) {
        amount -= amt;
    }
    public float checkBalance() {
        return amount;
    }
}

deposit() 和 withdraw() 函數都須要這個鎖來進行操做，因此當一個函數運行時，另外一個函數就被阻塞。請注意， checkBalance() 未做更改，它嚴格是一個讀函數。由於 checkBalance() 未做同步處理，因此任何其餘方法都不會阻塞它，它也不會阻塞任何其餘方法，無論那些方法是否進行了同步處理。

Java 編程語言中的高級多線程支持

線程組

線程是被個別建立的，但能夠將它們歸類到線程組中，以便於調試和監視。只能在建立線程的同時將它與一個線程組相關聯。在使用大量線程的程序中，使用線程組組織線程可能頗有幫助。能夠將它們看做是計算機上的目錄和文件結構。

線程間發信

當線程在繼續執行前須要等待一個條件時，僅有 synchronized 關鍵字是不夠的。雖然 synchronized 關鍵字阻止併發更新一個對象，但它沒有實現線程間發信。Object 類爲此提供了三個函數：wait()、notify() 和 notifyAll()。以全球氣候預測程序爲例。這些程序經過將地球分爲許多單元，在每一個循環中，每一個單元的計算都是隔離進行的，直到這些值趨於穩定，而後相鄰單元之間就會交換一些數據。因此，從本質上講，在每一個循環中各個線程都必須等待全部線程完成各自的任務之後才能進入下一個循環。這個模型稱爲屏蔽同步，下例說明了這個模型：

屏蔽同步

public class BSync {
    int totalThreads;
    int currentThreads;
    public BSync(int x) {
        totalThreads = x;
        currentThreads = 0;
    }
    public synchronized void waitForAll() {
        currentThreads++;
        if(currentThreads < totalThreads) {
            try {
                wait();
            } catch (Exception e) {}
        }
        else {
            currentThreads = 0;
            notifyAll();
        }
    }
}

當對一個線程調用 wait() 時，該線程就被有效阻塞，只到另外一個線程對同一個對象調用 notify() 或 notifyAll() 爲止。所以，在前一個示例中，不一樣的線程在完成它們的工做之後將調用 waitForAll() 函數，最後一個線程將觸發 notifyAll() 函數，該函數將釋放全部的線程。第三個函數 notify() 只通知一個正在等待的線程，當對每次只能由一個線程使用的資源進行訪問限制時，這個函數頗有用。可是，不可能預知哪一個線程會得到這個通知，由於這取決於 Java 虛擬機 (JVM) 調度算法。

將 CPU 讓給另外一個線程

當線程放棄某個稀有的資源（如數據庫鏈接或網絡端口）時，它可能調用 yield() 函數臨時下降本身的優先級，以便某個其餘線程可以運行。

守護線程

有兩類線程：用戶線程和守護線程。用戶線程是那些完成有用工做的線程。守護線程是那些僅提供輔助功能的線程。Thread 類提供了 setDaemon() 函數。Java 程序將運行到全部用戶線程終止，而後它將破壞全部的守護線程。在 Java 虛擬機 (JVM) 中，即便在 main 結束之後，若是另外一個用戶線程仍在運行，則程序仍然能夠繼續運行。

避免不提倡使用的方法

不提倡使用的方法是爲支持向後兼容性而保留的那些方法，它們在之後的版本中可能出現，也可能不出現。Java 多線程支持在版本 1.1 和版本 1.2 中作了重大修訂，stop()、suspend() 和 resume() 函數已不提倡使用。這些函數在 JVM 中可能引入微妙的錯誤。雖然函數名可能聽起來很誘人，但請抵制誘惑不要使用它們。

調試線程化的程序

在線程化的程序中，可能發生的某些常見而討厭的狀況是死鎖、活鎖、內存損壞和資源耗盡。

死鎖

死鎖多是多線程程序最多見的問題。當一個線程須要一個資源而另外一個線程持有該資源的鎖時，就會發生死鎖。這種狀況一般很難檢測。可是，解決方案卻至關好：在全部的線程中按相同的次序獲取全部資源鎖。例如，若是有四個資源 ―A、B、C 和 D ― 而且一個線程可能要獲取四個資源中任何一個資源的鎖，則請確保在獲取對 B 的鎖以前首先獲取對 A 的鎖，依此類推。若是「線程 1」但願獲取對 B 和 C 的鎖，而「線程 2」獲取了 A、C 和 D 的鎖，則這一技術可能致使阻塞，但它永遠不會在這四個鎖上形成死鎖。

活鎖

當一個線程忙於接受新任務以至它永遠沒有機會完成任何任務時，就會發生活鎖。這個線程最終將超出緩衝區並致使程序崩潰。試想一個祕書須要錄入一封信，但她一直在忙於接電話，因此這封信永遠不會被錄入。

內存損壞

若是明智地使用 synchronized 關鍵字，則徹底能夠避免內存錯誤這種氣死人的問題。

資源耗盡

某些系統資源是有限的，如文件描述符。多線程程序可能耗盡資源，由於每一個線程均可能但願有一個這樣的資源。若是線程數至關大，或者某個資源的侯選線程數遠遠超過了可用的資源數，則最好使用資源池。一個最好的示例是數據庫鏈接池。只要線程須要使用一個數據庫鏈接，它就從池中取出一個，使用之後再將它返回池中。資源池也稱爲資源庫。

調試大量的線程

有時一個程序由於有大量的線程在運行而極難調試。在這種狀況下，下面的這個類可能會派上用場：

public class Probe extends Thread {
    public Probe() {}
    public void run() {
        while(true) {
            Thread[] x = new Thread[100];
            Thread.enumerate(x);
            for(int i=0; i<100; i++) {
            Thread t = x[i];
            if(t == null)
                break;
            else
                System.out.println(t.getName() + "\t" + t.getPriority()
                + "\t" + t.isAlive() + "\t" + t.isDaemon());
            }
        }
    }
}

限制線程優先級和調度

Java 線程模型涉及能夠動態更改的線程優先級。本質上，線程的優先級是從 1 到 10 之間的一個數字，數字越大代表任務越緊急。JVM 標準首先調用優先級較高的線程，而後才調用優先級較低的線程。可是，該標準對具備相同優先級的線程的處理是隨機的。如何處理這些線程取決於基層的操做系統策略。在某些狀況下，優先級相同的線程分時運行；在另外一些狀況下，線程將一直運行到結束。請記住，Java 支持 10 個優先級，基層操做系統支持的優先級可能要少得多，這樣會形成一些混亂。所以，只能將優先級做爲一種很粗略的工具使用。最後的控制能夠經過明智地使用 yield() 函數來完成。一般狀況下，請不要依靠線程優先級來控制線程的狀態。

小結

本文說明了在 Java 程序中如何使用線程。像是否應該使用線程這樣的更重要的問題在很大程序上取決於手頭的應用程序。決定是否在應用程序中使用多線程的一種方法是，估計能夠並行運行的代碼量。並記住如下幾點：

使用多線程不會增長 CPU 的能力。可是若是使用 JVM 的本地線程實現，則不一樣的線程能夠在不一樣的處理器上同時運行（在多 CPU 的機器中），從而使多 CPU 機器獲得充分利用。
若是應用程序是計算密集型的，並受 CPU 功能的制約，則只有多 CPU 機器可以從更多的線程中受益。
當應用程序必須等待緩慢的資源（如網絡鏈接或數據庫鏈接）時，或者當應用程序是非交互式的時，多線程一般是有利的。

基於 Internet 的軟件有必要是多線程的；不然，用戶將感受應用程序反映遲鈍。例如，當開發要支持大量客戶機的服務器時，多線程可使編程較爲容易。在這種狀況下，每一個線程能夠爲不一樣的客戶或客戶組服務，從而縮短了響應時間。

線程模型類型設計

協做式模型

容許線程本身決定何時放棄處理器來等待其餘的線程。程序開發員能夠精確地決定某個線程什麼時候會被其餘線程掛起，容許它們與對方有效地合做。缺點在於某些惡意或是寫得很差的線程會消耗全部可得到的 CPU 時間，致使其餘線程「飢餓」。

搶佔式模型

操做系統能夠在任什麼時候候打斷線程。一般會在它運行了一段時間（就是所謂的一個時間片）後纔打斷它。這樣的結果天然是沒有線程可以不公平地長時間霸佔處理器。然而，隨時可能打斷線程就會給程序開發員帶來其餘麻煩。一樣使用辦公室的例子，假設某個職員搶在另外一人前使用複印機，但打印工做在未完成的時候離開了，另外一人接着使用複印機時，該複印機上可能就還有先前那名職員留下來的資料。搶佔式線程模型要求線程正確共享資源，協做式模型卻要求線程共享執行時間。因爲 JVM 規範並無特別規定線程模型，Java 開發員必須編寫可在兩種模型上正確運行的程序。在瞭解線程以及線程間通信的一些方面以後，咱們能夠看到如何爲這兩種模型設計程序。

常見的上鎖問題

死鎖

死鎖是一個經典的多線程問題，由於不一樣的線程都在等待那些根本不可能被釋放的鎖，從而致使全部的工做都沒法完成。假設有兩個線程，分別表明兩個飢餓的人，他們必須共享刀叉並輪流吃飯。他們都須要得到兩個鎖：共享刀和共享叉的鎖。假如線程 "A" 得到了刀，而線程 "B" 得到了叉。線程 A 就會進入阻塞狀態來等待得到叉，而線程 B 則阻塞來等待 A 所擁有的刀。這只是人爲設計的例子，但儘管在運行時很難探測到，這類狀況卻時常發生。雖然要探測或推敲各類狀況是很是困難的，但只要按照下面幾條規則去設計系統，就可以避免死鎖問題：

讓全部的線程按照一樣的順序得到一組鎖。這種方法消除了 X 和 Y 的擁有者分別等待對方的資源的問題。

將多個鎖組成一組並放到同一個鎖下。前面死鎖的例子中，能夠建立一個銀器對象的鎖。因而在得到刀或叉以前都必須得到這個銀器的鎖。

將那些不會阻塞的可得到資源用變量標誌出來。當某個線程得到銀器對象的鎖時，就能夠經過檢查變量來判斷是否整個銀器集合中的對象鎖均可得到。若是是，它就能夠得到相關的鎖，不然，就要釋放掉銀器這個鎖並稍後再嘗試。

最重要的是，在編寫代碼前認真仔細地設計整個系統。多線程是困難的，在開始編程以前詳細設計系統可以幫助你避免難以發現死鎖的問題。

Volatile 變量

volatile 關鍵字是 Java 語言爲優化編譯器設計的。如下面的代碼爲例：

class VolatileTest {
   public void foo() {
      boolean flag = false;
      if(flag) {
         //this could happen
      }
   }
}

一個優化的編譯器可能會判斷出 if 部分的語句永遠不會被執行，就根本不會編譯這部分的代碼。若是這個類被多線程訪問， flag 被前面某個線程設置以後，在它被 if 語句測試以前，能夠被其餘線程從新設置。用 volatile 關鍵字來聲明變量，就能夠告訴編譯器在編譯的時候，不須要經過預測變量值來優化這部分的代碼。

沒法訪問的線程

有時候雖然獲取對象鎖沒有問題，線程依然有可能進入阻塞狀態。在 Java 編程中 IO 就是這類問題最好的例子。當線程由於對象內的 IO 調用而阻塞時，此對象應當仍能被其餘線程訪問。該對象一般有責任取消這個阻塞的 IO 操做。形成阻塞調用的線程經常會令同步任務失敗。若是該對象的其餘方法也是同步的，當線程被阻塞時，此對象也就至關於被冷凍住了。其餘的線程因爲不能得到對象的鎖，就不能給此對象發消息（例如，取消 IO 操做）。必須確保不在同步代碼中包含那些阻塞調用，或確認在一個用同步阻塞代碼的對象中存在非同步方法。儘管這種方法須要花費一些注意力來保證結果代碼安全運行，但它容許在擁有對象的線程發生阻塞後，該對象仍可以響應其餘線程。