電腦程式的思維邏輯 (65) - 線程的基本概念

来源:http://www.cnblogs.com/swiftma/archive/2017/02/14/6395477.html
-Advertisement-
Play Games

在之前的章節中，我們都是假設程式中只有一條執行流，程式從main方法的第一條語句逐條執行直到結束。從本節開始，我們討論併發，在程式中創建線程來啟動多條執行流，併發和線程是一個複雜的話題，本節，我們先來討論Java中線程的一些基本概念。 創建線程 線程表示一條單獨的執行流，它有自己的程式執行計數器，有 ...


在之前的章節中，我們都是假設程式中只有一條執行流，程式從main方法的第一條語句逐條執行直到結束。從本節開始，我們討論併發，在程式中創建線程來啟動多條執行流，併發和線程是一個複雜的話題，本節，我們先來討論Java中線程的一些基本概念。

創建線程

線程表示一條單獨的執行流，它有自己的程式執行計數器，有自己的棧。下麵，我們通過創建線程來對線程建立一個直觀感受，在Java中創建線程有兩種方式，一種是繼承Thread，另外一種是實現Runnable介面，我們先來看第一種。

繼承Thread

Java中java.lang.Thread這個類表示線程，一個類可以繼承Thread並重寫其run方法來實現一個線程，如下所示：

public class HelloThread extends Thread {
    
    @Override
    public void run() {
        System.out.println("hello");
    }
}

HelloThread這個類繼承了Thread，並重寫了run方法。run方法的方法簽名是固定的，public，沒有參數，沒有返回值，不能拋出受檢異常。run方法類似於單線程程式中的main方法，線程從run方法的第一條語句開始執行直到結束。

定義了這個類不代表代碼就會開始執行，線程需要被啟動，啟動需要先創建一個HelloThread對象，然後調用Thread的start方法，如下所示：

public static void main(String[] args) {
    Thread thread = new HelloThread();
    thread.start();
}

我們在main方法中創建了一個線程對象，並調用了其start方法，調用start方法後，HelloThread的run方法就會開始執行，屏幕輸出：

hello

為什麼調用的是start，執行的卻是run方法呢？start表示啟動該線程，使其成為一條單獨的執行流，背後，操作系統會分配線程相關的資源，每個線程會有單獨的程式執行計數器和棧，操作系統會把這個線程作為一個獨立的個體進行調度，分配時間片讓它執行，執行的起點就是run方法。

如果不調用start，而直接調用run方法呢？屏幕的輸出並不會發生變化，但並不會啟動一條單獨的執行流，run方法的代碼依然是在main線程中執行的，run方法只是main方法調用的一個普通方法。

怎麼確認代碼是在哪個線程中執行的呢？Thread有一個靜態方法currentThread，返回當前執行的線程對象：

public static native Thread currentThread();

每個Thread都有一個id和name：

public long getId()
public final String getName()

這樣，我們就可以判斷代碼是在哪個線程中執行的，我們在HelloThead的run方法中加一些代碼：

@Override
public void run() {
    System.out.println("thread name: "+ Thread.currentThread().getName());
    System.out.println("hello");
}

如果在main方法中通過start方法啟動線程，程式輸出為：

thread name: Thread-0
hello

如果在main方法中直接調用run方法，程式輸出為：

thread name: main
hello

調用start後，就有了兩條執行流，新的一條執行run方法，舊的一條繼續執行main方法，兩條執行流併發執行，操作系統負責調度，在單CPU的機器上，同一時刻只能有一個線程在執行，在多CPU的機器上，同一時刻可以有多個線程同時執行，但操作系統給我們屏蔽了這種差異，給程式員的感覺就是多個線程併發執行，但哪條語句先執行哪條後執行是不一定的。當所有線程都執行完畢的時候，程式退出。

實現Runnable介面

通過繼承Thread來實現線程雖然比較簡單，但我們知道，Java中只支持單繼承，每個類最多只能有一個父類，如果類已經有父類了，就不能再繼承Thread，這時，可以通過實現java.lang.Runnable介面來實現線程。

Runnable介面的定義很簡單，只有一個run方法，如下所示：

public interface Runnable {
    public abstract void run();
}

一個類可以實現該介面，並實現run方法，如下所示：

public class HelloRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("hello");
    }
}

僅僅實現Runnable是不夠的，要啟動線程，還是要創建一個Thread對象，但傳遞一個Runnable對象，如下所示：

public static void main(String[] args) {
    Thread helloThread = new Thread(new HelloRunnable());
    helloThread.start();
}

無論是通過繼承Thead還是實現Runnable介面來實現線程，啟動線程都是調用Thread對象的start方法。

線程的基本屬性和方法

id和name

前面我們提到，每個線程都有一個id和name，id是一個遞增的整數，每創建一個線程就加一，name的預設值是"Thread-"後跟一個編號，name可以在Thread的構造方法中進行指定，也可以通過setName方法進行設置，給Thread設置一個友好的名字，可以方便調試。

優先順序

線程有一個優先順序的概念，在Java中，優先順序從1到10，預設為5，相關方法是：

public final void setPriority(int newPriority)
public final int getPriority()

這個優先順序會被映射到操作系統中線程的優先順序，不過，因為操作系統各不相同，不一定都是10個優先順序，Java中不同的優先順序可能會被映射到操作系統中相同的優先順序，另外，優先順序對操作系統而言更多的是一種建議和提示，而非強制，簡單的說，在編程中，不要過於依賴優先順序。

狀態

線程有一個狀態的概念，Thread有一個方法用於獲取線程的狀態：

public State getState()

返回值類型為Thread.State，它是一個枚舉類型，有如下值：

public enum State {
  NEW,
  RUNNABLE,
  BLOCKED,
  WAITING,
  TIMED_WAITING,
  TERMINATED;
}

關於這些狀態，我們簡單解釋下：

  • NEW: 沒有調用start的線程狀態為NEW
  • TERMINATED: 線程運行結束後狀態為TERMINATED
  • RUNNABLE: 調用start後線程在執行run方法且沒有阻塞時狀態為RUNNABLE，不過，RUNNABLE不代表CPU一定在執行該線程的代碼，可能正在執行也可能在等待操作系統分配時間片，只是它沒有在等待其他條件
  • BLOCKED、WAITING、TIMED_WAITING：都表示線程被阻塞了，在等待一些條件，其中的區別我們在後續章節再介紹 

Thread還有一個方法，返回線程是否活著：

public final native boolean isAlive()

線程被啟動後，run方法運行結束前，返回值都是true。

是否daemo線程

Thread有一個是否daemo線程的屬性，相關方法是：

public final void setDaemon(boolean on)
public final boolean isDaemon()

前面我們提到，啟動線程會啟動一條單獨的執行流，整個程式只有在所有線程都結束的時候才退出，但daemo線程是例外，當整個程式中剩下的都是daemo線程的時候，程式就會退出。

daemo線程有什麼用呢？它一般是其他線程的輔助線程，在它輔助的主線程退出的時候，它就沒有存在的意義了。在我們運行一個即使最簡單的"hello world"類型的程式時，實際上，Java也會創建多個線程，除了main線程外，至少還有一個負責垃圾回收的線程，這個線程就是daemo線程，在main線程結束的時候，垃圾回收線程也會退出。

sleep方法

Thread有一個靜態的sleep方法，調用該方法會讓當前線程睡眠指定的時間，單位是毫秒：

public static native void sleep(long millis) throws InterruptedException;

睡眠期間，該線程會讓出CPU，但睡眠的時間不一定是確切的給定毫秒數，可能有一定的偏差，偏差與系統定時器和操作系統調度器的準確度和精度有關。

睡眠期間，線程可以被中斷，如果被中斷，sleep會拋出InterruptedException，關於中斷以及中斷處理，我們後續章節再介紹。

yield方法

Thread還有一個讓出CPU的方法：

public static native void yield();

這也是一個靜態方法，調用該方法，是告訴操作系統的調度器，我現在不著急占用CPU，你可以先讓其他線程運行。不過，這對調度器也僅僅是建議，調度器如何處理是不一定的，它可能完全忽略該調用。

join方法

在前面HelloThread的例子中，HelloThread沒執行完，main線程可能就執行完了，Thread有一個join方法，可以讓調用join的線程等待該線程結束，join方法的聲明為：

 public final void join() throws InterruptedException

在等待線程結束的過程中，這個等待可能被中斷，如果被中斷，會拋出InterruptedException。

join方法還有一個變體，可以限定等待的最長時間，單位為毫秒，如果為0，表示無期限等待：

public final synchronized void join(long millis) throws InterruptedException

在前面的HelloThread示例中，如果希望main線程在子線程結束後再退出，main方法可以改為：

public static void main(String[] args) throws InterruptedException {
    Thread thread = new HelloThread();
    thread.start();
    thread.join();
}     

過時方法

Thread類中還有一些看上去可以控制線程生命周期的方法，如：

public final void stop()
public final void suspend()
public final void resume()

這些方法因為各種原因已被標記為了過時，我們不應該在程式中使用它們。

共用記憶體及問題

共用記憶體

前面我們提到，每個線程表示一條單獨的執行流，有自己的程式計數器，有自己的棧，但線程之間可以共用記憶體，它們可以訪問和操作相同的對象。我們看個例子，代碼如下：

public class ShareMemoryDemo {
    private static int shared = 0;
    
    private static void incrShared(){
        shared ++;
    }
    
    static class ChildThread extends Thread {
        List<String> list;
        
        public ChildThread(List<String> list) {
            this.list = list;
        }

        @Override
        public void run() {
            incrShared();
            list.add(Thread.currentThread().getName());
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        Thread t1 = new ChildThread(list);
        Thread t2 = new ChildThread(list);
        t1.start();
        t2.start();
        
        t1.join();
        t2.join();
        
        System.out.println(shared);
        System.out.println(list);
    }
}

在代碼中，定義了一個靜態變數shared和靜態內部類ChildThread，在main方法中，創建並啟動了兩個ChildThread對象，傳遞了相同的list對象，ChildThread的run方法訪問了共用的變數shared和list，main方法最後輸出了共用的shared和list的值，大部分情況下，會輸出期望的值：

2
[Thread-0, Thread-1]

通過這個例子，我們想強調說明執行流、記憶體和程式代碼之間的關係。

  • 該例中有三條執行流，一條執行main方法，另外兩條執行ChildThread的run方法。
  • 不同執行流可以訪問和操作相同的變數，如本例中的shared和list變數。
  • 不同執行流可以執行相同的程式代碼，如本例中incrShared方法，ChildThread的run方法，被兩條ChildThread執行流執行，incrShared方法是在外部定義的，但被ChildThread的執行流執行，在分析代碼執行過程時，理解代碼在被哪個線程執行是很重要的。
  • 當多條執行流執行相同的程式代碼時，每條執行流都有單獨的棧，方法中的參數和局部變數都有自己的一份。 

當多條執行流可以操作相同的變數時，可能會出現一些意料之外的結果，我們來看下。

競態條件

所謂競態條件(race condition)是指，當多個線程訪問和操作同一個對象時，最終執行結果與執行時序有關，可能正確也可能不正確，我們看一個例子：

public class CounterThread extends Thread {
    private static int counter = 0;
    
    @Override
    public void run() {
        try {
            Thread.sleep((int)(Math.random()*100));
        } catch (InterruptedException e) {
        }
        counter ++;
    }


    public static void main(String[] args) throws InterruptedException {
        int num = 1000;
        Thread[] threads = new Thread[num];
        for(int i=0; i<num; i++){
            threads[i] = new CounterThread();
            threads[i].start();
        }
        
        for(int i=0; i<num; i++){
            threads[i].join();
        }
        
        System.out.println(counter);
    }
}

這段代碼容易理解，有一個共用靜態變數counter，初始值為0，在main方法中創建了1000個線程，每個線程就是隨機睡一會，然後對counter加1，main線程等待所有線程結束後輸出counter的值。

期望的結果是1000，但實際執行，發現每次輸出的結果都不一樣，一般都不是1000，經常是900多。為什麼會這樣呢？因為counter++這個操作不是原子操作，它分為三個步驟：

  1. 取counter的當前值
  2. 在當前值基礎上加1
  3. 將新值重新賦值給counter

兩個線程可能同時執行第一步，取到了相同的counter值，比如都取到了100，第一個線程執行完後counter變為101，而第二個線程執行完後還是101，最終的結果就與期望不符。

怎麼解決這個問題呢？有多種方法：

  • 使用synchronized關鍵字
  • 使用顯式鎖
  • 使用原子變數 

關於這些方法，我們在後續章節再介紹。

記憶體可見性

多個線程可以共用訪問和操作相同的變數，但一個線程對一個共用變數的修改，另一個線程不一定馬上就能看到，甚至永遠也看不到，這可能有悖直覺，我們來看一個例子。

public class VisibilityDemo {
    private static boolean shutdown = false;
    
    static class HelloThread extends Thread {
        @Override
        public void run() {
            while(!shutdown){
                // do nothing
            }
            System.out.println("exit hello");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new HelloThread().start();
        Thread.sleep(1000);
        shutdown = true;
        System.out.println("exit main");
    }
}

在這個程式中，有一個共用的boolean變數shutdown，初始為false，HelloThread在shutdown不為true的情況下一直死迴圈，當shutdown為true時退出並輸出"exit hello"，main線程啟動HelloThread後睡了一會，然後設置shutdown為true，最後輸出"exit main"。

期望的結果是兩個線程都退出，但實際執行，很可能會發現HelloThread永遠都不會退出，也就是說，在HelloThread執行流看來，shutdown永遠為false，即使main線程已經更改為了true。

這是怎麼回事呢？這就是記憶體可見性問題。在電腦系統中，除了記憶體，數據還會被緩存在CPU的寄存器以及各級緩存中，當訪問一個變數時，可能直接從寄存器或CPU緩存中獲取，而不一定到記憶體中去取，當修改一個變數時，也可能是先寫到緩存中，而稍後才會同步更新到記憶體中。在單線程的程式中，這一般不是個問題，但在多線程的程式中，尤其是在有多CPU的情況下，這就是個嚴重的問題。一個線程對記憶體的修改，另一個線程看不到，一是修改沒有及時同步到記憶體，二是另一個線程根本就沒從記憶體讀。

怎麼解決這個問題呢？有多種方法：

  • 使用volatile關鍵字
  • 使用synchronized關鍵字或顯式鎖同步 

關於這些方法，我們在後續章節再介紹。

線程的優點及成本

優點

為什麼要創建單獨的執行流？或者說線程有什麼優點呢？至少有以下幾點：

  • 充分利用多CPU的計算能力，單線程只能利用一個CPU，使用多線程可以利用多CPU的計算能力。
  • 充分利用硬體資源，CPU和硬碟、網路是可以同時工作的，一個線程在等待網路IO的同時，另一個線程完全可以利用CPU，對於多個獨立的網路請求，完全可以使用多個線程同時請求。
  • 在用戶界面(GUI)應用程式中，保持程式的響應性，界面和後臺任務通常是不同的線程，否則，如果所有事情都是一個線程來執行，當執行一個很慢的任務時，整個界面將停止響應，也無法取消該任務。
  • 簡化建模及IO處理，比如，在伺服器應用程式中，對每個用戶請求使用一個單獨的線程進行處理，相比使用一個線程，處理來自各種用戶的各種請求，以及各種網路和文件IO事件，建模和編寫程式要容易的多。

成本

關於線程，我們需要知道，它是有成本的。創建線程需要消耗操作系統的資源，操作系統會為每個線程創建必要的數據結構、棧、程式計數器等，創建也需要一定的時間。

此外，線程調度和切換也是有成本的，當有當量可運行線程的時候，操作系統會忙於調度，為一個線程分配一段時間，執行完後，再讓另一個線程執行，一個線程被切換出去後，操作系統需要保存它的當前上下文狀態到記憶體，上下文狀態包括當前CPU寄存器的值、程式計數器的值等，而一個線程被切換回來後，操作系統需要恢復它原來的上下文狀態，整個過程被稱為上下文切換，這個切換不僅耗時，而且使CPU中的很多緩存失效，是有成本的。

當然，這些成本是相對而言的，如果線程中實際執行的事情比較多，這些成本是可以接受的，但如果只是執行本節示例中的counter++，那相對成本就太高了。

另外，如果執行的任務都是CPU密集型的，即主要消耗的都是CPU，那創建超過CPU數量的線程就是沒有必要的，並不會加快程式的執行。

小結

本節，我們介紹了Java中線程的一些基本概念，包括如何創建線程，線程的一些基本屬性和方法，多個線程可以共用記憶體，但共用記憶體也有兩個重要問題，一個是競態條件，另一個是記憶體可見性，最後，我們討論了線程的一些優點和成本。

針對共用記憶體的兩個問題，下一節，我們討論Java的一個解決方案 - synchronized關鍵字。

(與其他章節一樣，本節所有代碼位於 https://github.com/swiftma/program-logic)

----------------

未完待續，查看最新文章，敬請關註微信公眾號“老馬說編程”(掃描下方二維碼)，從入門到高級，深入淺出，老馬和你一起探索Java編程及電腦技術的本質。用心原創，保留所有版權。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • nifi安裝說明
    系統環境： vmware安裝的centos6.7虛擬機 jdk1.8版本 maven庫3.3.9版本（在使用源碼編譯啟動的時候需要修改配置文件與當前使用的maven版本匹配，最低使用版本好像是3.1.5，記不清了） 其他的一些ssh工具隨意。 1、二進位工程 ①NIFI下載地址：http://nif ...
  • PHP靜態成員變數
    靜態成員：靜態類中的成員加入static修飾符,即是靜態成員.可以直接使用類名+靜態成員名訪問此靜態成員,因為靜態成員存在於記憶體,非靜態成員需要實例化才會分配記憶體,所以靜態成員不能訪問非靜態的成員..因為靜態成員存在於記憶體,所以非靜態成員可以直接訪問類中靜態的成員. 1、靜態全局變數 定義：在全局變 ...
  • C++學習筆記（From慕課網）
    （慕課網視頻學習--C++離港篇的學習memo）1: 函數的參數預設值，只能在最右邊。 如果有三個參數，只有中間一個有預設值，這是錯誤的。 函數聲明的時候寫預設值，定義的時候不要寫。（有些編譯器會出錯。）2：內聯函數：編譯時，將函數體實參和代碼替換掉調用語句。 關聯字 inline 內聯函數是建議性 ...
  • 靜態，抽象類、介面、類庫
    1.普通成員普通成員都是屬於對象的用對象調用 2.靜態成員靜態成員是屬於類的用類名調用 stactic 靜態關鍵字 靜態方法裡面不能包含普通成員普通方法裡面可以包含靜態成員 抽象類： 1.關鍵字：abstract2.抽象類可以包含抽象方法和普通方法3.abstract關鍵字可以定義方法為抽象方法，抽 ...
  • Hibernate原理及應用
    Hibernate工作原理及為什麼要用? 原理：1.通過Configuration().configure();讀取並解析hibernate.cfg.xml配置文件2.由hibernate.cfg.xml中的<mapping resource="com/xx/User.hbm.xml"/>讀取並解析 ...
  • STL str replace
    #include #include using namespace std; void main() { string s="Hello Lucy!"; //s.replace(5,1,"Lily"); //"Lucy" -> "Lily" int indexStart=s.find("Lucy")... ...
  • Java中Runnable和Thread的區別
    在java中可有兩種方式實現多線程，一種是繼承Thread類，一種是實現Runnable介面；Thread類是在java.lang包中定義的。一個類只要繼承了Thread類同時覆寫了本類中的run()方法就可以實現多線程操作了，但是一個類只能繼承一個父類，這是此方法的局限。 下麵看例子： 但是，此時 ...
  • bzoj3238--尾碼自動機
    顯然只需求LCP(i,j)就可以了。 將s反轉，然後插入尾碼自動機。由於尾碼自動機的link指針構成了一棵尾碼樹，而字元串又反轉過，所以兩個結點的LCP就是LCA。 樹形DP，求出以每個結點為LCA的個數就可以了。 代碼： 1 #include<iostream> 2 #include<cstdio ...
一周排行
    -Advertisement-
    Play Games
  • WPF 已知問題 監聽 WMI 事件導致觸摸失效
    示例項目結構 在 Visual Studio 中創建一個 WinForms 應用程式後，項目結構如下所示： MyWinFormsApp/ │ ├───Properties/ │ └───Settings.settings │ ├───bin/ │ ├───Debug/ │ └───Release/ ...
  • [STAThread]特性
    [STAThread] 特性用於需要與 COM 組件交互的應用程式，尤其是依賴單線程模型（如 Windows Forms 應用程式）的組件。在 STA 模式下，線程擁有自己的消息迴圈，這對於處理用戶界面和某些 COM 組件是必要的。 [STAThread] static void Main(stri ...
  • UWP WinUI3 傳入 AddHandler 的 RoutedEventHandler 類型與事件所需不匹配將拋出參數異常
    在WinForm中使用全局異常捕獲處理 在WinForm應用程式中，全局異常捕獲是確保程式穩定性的關鍵。通過在Program類的Main方法中設置全局異常處理，可以有效地捕獲並處理未預見的異常，從而避免程式崩潰。 註冊全局異常事件 [STAThread] static void Main() { / ...
  • .NET 多版本 WinForm 開源控制項庫 SunnyUI
    前言 給大家推薦一款開源的 Winform 控制項庫，可以幫助我們開發更加美觀、漂亮的 WinForm 界面。 項目介紹 SunnyUI.NET 是一個基於 .NET Framework 4.0+、.NET 6、.NET 7 和 .NET 8 的 WinForm 開源控制項庫，同時也提供了工具類庫、擴展 ...
  • .net core8 使用Swagger（附當前源碼）
    說明 該文章是屬於OverallAuth2.0系列文章，每周更新一篇該系列文章（從0到1完成系統開發）。 該系統文章，我會儘量說的非常詳細，做到不管新手、老手都能看懂。 說明：OverallAuth2.0 是一個簡單、易懂、功能強大的許可權+可視化流程管理系統。 有興趣的朋友，請關註我吧(*^▽^*) ...
  • WPF 什麼時候 VisualTreeHelper.GetDescendantBounds 將返回無窮大
    一、下載安裝 1.下載git 必須先下載並安裝git，再TortoiseGit下載安裝 git安裝參考教程：https://blog.csdn.net/mukes/article/details/115693833 2.TortoiseGit下載與安裝 TortoiseGit，Git客戶端，32/6 ...
  • C# 開源教程帶你輕鬆掌握數據結構與演算法
    前言 在項目開發過程中，理解數據結構和演算法如同掌握蓋房子的秘訣。演算法不僅能幫助我們編寫高效、優質的代碼，還能解決項目中遇到的各種難題。 給大家推薦一個支持C#的開源免費、新手友好的數據結構與演算法入門教程：Hello演算法。 項目介紹 《Hello Algo》是一本開源免費、新手友好的數據結構與演算法入門 ...
  • 第22篇 生成proto文件bat腳本
    1.生成單個Proto.bat內容 @rem Copyright 2016, Google Inc. @rem All rights reserved. @rem @rem Redistribution and use in source and binary forms, with or with ...
  • 記一次 .NET某上位機視覺程式 卡死分析
    一：背景 1. 講故事 前段時間有位朋友找到我，說他的窗體程式在客戶這邊出現了卡死，讓我幫忙看下怎麼回事？dump也生成了，既然有dump了那就上 windbg 分析吧。 二：WinDbg 分析 1. 為什麼會卡死 窗體程式的卡死，入口門檻很低，後續往下分析就不一定了，不管怎麼說先用 !clrsta ...
  • 醫學DICOM文件與PACS系統進行數據傳輸
    前言 人工智慧時代，人臉識別技術已成為安全驗證、身份識別和用戶交互的關鍵工具。 給大家推薦一款.NET 開源提供了強大的人臉識別 API，工具不僅易於集成，還具備高效處理能力。 本文將介紹一款如何利用這些API，為我們的項目添加智能識別的亮點。 項目介紹 GitHub 上擁有 1.2k 星標的 C# ...
所有分類