你離不開的一些線程小知識

Java中的線程

進程與線程

進程

進程是資源（CPU、內存等）分配的基本單位，它是程序執行時的一個實例。程序運行時系統就會創建一個進程，併爲它分配資源，然後把該進程放入進程就緒隊列，進程調度器選中它的時候就會爲它分配CPU時間，程序開始真正運行。

線程

線程是一條執行路徑，是程序執行時的最小單位，它是進程的一個執行流，是CPU調度和分派的基本單位，一個進程可以由很多個線程組成，線程間共享進程的所有資源，每個線程有自己的堆棧和局部變量。線程由CPU獨立調度執行，在多CPU環境下就允許多個線程同時運行。同樣多線程也可以實現併發操作，每個請求分配一個線程來處理。

一個正在運行的軟件(如迅雷)就是一個進程，一個進程可以同時運行多個任務( 迅雷軟件可以同時下載多個文件，每個下載任務就是一個線程), 可以簡單的認爲進程是線程的集合。

線程是一條可以執行的路徑。多線程就是同時有多條執行路徑在同時(並行)執行。

進程與線程的關係

一個程序就是一個進程，而一個程序中的多個任務則被稱爲線程。進程是表示資源分配的基本單位，又是調度運行的基本單位。，亦即執行處理機調度的基本單位。 進程和線程的關係：

一個線程只能屬於一個進程，而一個進程可以有多個線程，但至少有一個線程。線程是操作系統可識別的最小執行和調度單位。

資源分配給進程，同一進程的所有線程共享該進程的所有資源。同一進程中的多個線程共享代碼段(代碼和常量)，數據段(全局變量和靜態變量)，擴展段(堆存儲)。但是每個線程擁有自己的棧段，棧段又叫運行時段，用來存放所有局部變量和臨時變量，即每個線程都有自己的堆棧和局部變量。

處理機分給線程，即真正在處理機上運行的是線程。

線程在執行過程中，需要協作同步。不同進程的線程間要利用消息通信的辦法實現同步。

如果把上課的過程比作進程，把老師比作CPU，那麼可以把每個學生比作每個線程，所有學生共享這個教室(也就是所有線程共享進程的資源)，上課時學生A向老師提出問題，老師對A進行解答，此時可能會有學生B對老師的解答不懂會提出B的疑問(注意：此時可能老師還沒有對A同學的問題解答完畢)，此時老師又向學生B解惑，解釋完之後又繼續回答學生A的問題，同一時刻老師只能向一個學生回答問題(即：當多個線程在運行時，同一個CPU在某一個時刻只能服務於一個線程，可能一個線程分配一點時間，時間到了就輪到其它線程執行了，這樣多個線程在來回的切換)

java多線程

Java 給多線程編程提供了內置的支持。 一條線程指的是進程中一個單一順序的控制流，一個進程中可以併發多個線程，每條線程並行執行不同的任務。

多線程是多任務的一種特別的形式，但多線程使用了更小的資源開銷。

這裏定義和線程相關的另一個術語 - 進程：一個進程包括由操作系統分配的內存空間，包含一個或多個線程。一個線程不能獨立的存在，它必須是進程的一部分。一個進程一直運行，直到所有的非守護線程都結束運行後才能結束。

多線程能滿足程序員編寫高效率的程序來達到充分利用 CPU 的目的。

什麼是單線程和多線程？

單線程

顧名思義即是隻有一條線程在執行任務，這種情況在我們日常的工作學習中很少遇到，所以我們只是簡單做一下了解

多線程

創建多條線程同時執行任務，這種方式在我們的日常生活中比較常見。但是，在多線程的使用過程中，還有許多需要我們瞭解的概念。比如，在理解上並行和併發的區別，以及在實際應用的過程中多線程的安全問題，對此，我們需要進行詳細的瞭解。

並行和併發：在我們看來，都是可以同時執行多種任務，那麼，到底他們二者有什麼區別呢？

併發，從宏觀方面來說，併發就是同時進行多種時間，實際上，這幾種時間，並不是同時進行的，而是交替進行的，而由於CPU的運算速度非常的快，會造成我們的一種錯覺，就是在同一時間內進行了多種事情

而併發，則是真正意義上的同時進行多種事情。這種只可以在多核CPU的基礎下完成。

還有就是多線程的安全問題？爲什麼會造成多線程的安全問題呢？我們可以想象一下，如果多個線程同時執行一個任務，name意味着他們共享同一種資源，由於線程CPU的資源不一定可以被誰搶佔到，這是，第一條線程先搶佔到CPU資源，他剛剛進行了第一次操作，而此時第二條線程搶佔到了CPU的資源，name，共享資源還來不及發生變化，就同時有兩條數據使用了同一條資源，具體請參考多線程買票問題。這個問題我們應該如何解決那？

有造成問題的原因我們可以看出，這個問題主要的矛盾在於，CPU的使用權搶佔和資源的共享發生了衝突，解決時，我們只需要讓一條線程戰歌了CPU的資源時，阻止第二條線程同時搶佔CPU的執行權，在代碼中，我們只需要在方法中使用同步代碼塊即可。在這裏，同步代碼塊不多進行贅述，可以自行了解。

線程池

又以上介紹我們可以看出，在一個應用程序中，我們需要多次使用線程，也就意味着，我們需要多次創建並銷燬線程。而創建並銷燬線程的過程勢必會消耗內存。而在Java中，內存資源是及其寶貴的，所以，我們就提出了線程池的概念。

線程池：Java中開闢出了一種管理線程的概念，這個概念叫做線程池，從概念以及應用場景中，我們可以看出，線程池的好處，就是可以方便的管理線程，也可以減少內存的消耗。

那麼，我們應該如何創建一個線程池那?Java中已經提供了創建線程池的一個類：Executor

而我們創建時，一般使用它的子類：ThreadPoolExecutor.

public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
這是其中最重要的一個構造方法，這個方法決定了創建出來的線程池的各種屬性，下面依靠一張圖來更好的理解線程池和這幾個參數：

線程池中的corePoolSize就是線程池中的核心線程數量，這幾個核心線程，只是在沒有用的時候，也不會被回收，maximumPoolSize就是線程池中可以容納的最大線程的數量，而keepAliveTime，就是線程池中除了核心線程之外的其他的最長可以保留的時間，因爲在線程池中，除了核心線程即使在無任務的情況下也不能被清除，其餘的都是有存活時間的，意思就是非核心線程可以保留的最長的空閒時間，而util，就是計算這個時間的一個單位，workQueue，就是等待隊列，任務可以儲存在任務隊列中等待被執行，執行的是FIFIO原則（先進先出）。threadFactory，就是創建線程的線程工廠，最後一個handler,是一種拒絕策略，我們可以在任務滿了知乎，拒絕執行某些任務。

線程池的執行流程又是怎樣的呢？

當任務進來時，首先執行判斷，判斷核心線程是否處於空閒狀態，如果不是，核心線程就先就執行任務，如果核心線程已滿，則判斷任務隊列是否有地方存放該任務，若果有，就將任務保存在任務隊列中，等待執行，如果滿了，在判斷最大可容納的線程數，如果沒有超出這個數量，就開創非核心線程執行任務，如果超出了，就調用handler實現拒絕策略。

handler的拒絕策略：

有四種：第一種AbortPolicy:不執行新任務，直接拋出異常，提示線程池已滿

         第二種DisCardPolicy:不執行新任務，也不拋出異常

         第三種DisCardOldSetPolicy:將消息隊列中的第一個任務替換爲當前新進來的任務執行

         第四種CallerRunsPolicy:直接調用execute來執行當前任務

四種常見的線程池

CachedThreadPool:可緩存的線程池，該線程池中沒有核心線程，非核心線程的數量爲Integer.max_value，就是無限大，當有需要時創建線程來執行任務，沒有需要時回收線程，適用於耗時少，任務量大的情況。

SecudleThreadPool:週期性執行任務的線程池，按照某種特定的計劃執行線程中的任務，有核心線程，但也有非核心線程，非核心線程的大小也爲無限大。適用於執行週期性的任務。

SingleThreadPool:只有一條線程來執行任務，適用於有順序的任務的應用場景。

FixedThreadPool:定長的線程池，有核心線程，核心線程的即爲最大的線程數量，沒有非核心線程

一個線程的生命週期

線程是一個動態執行的過程，它也有一個從產生到死亡的過程。

下圖顯示了一個線程完整的生命週期。

• 新建狀態:

  使用 new 關鍵字和 Thread 類或其子類建立一個線程對象後，該線程對象就處於新建狀態。它保持這個狀態直到程序 start() 這個線程。

• 就緒狀態:

  當線程對象調用了start()方法之後，該線程就進入就緒狀態。就緒狀態的線程處於就緒隊列中，要等待JVM裏線程調度器的調度。

• 運行狀態:

  如果就緒狀態的線程獲取 CPU 資源，就可以執行 run()，此時線程便處於運行狀態。處於運行狀態的線程最爲複雜，它可以變爲阻塞狀態、就緒狀態和死亡狀態。

• 阻塞狀態:

  如果一個線程執行了sleep（睡眠）、suspend（掛起）等方法，失去所佔用資源之後，該線程就從運行狀態進入阻塞狀態。在睡眠時間已到或獲得設備資源後可以重新進入就緒狀態。可以分爲三種：

  • 等待阻塞：運行狀態中的線程執行 wait() 方法，使線程進入到等待阻塞狀態。
  • 同步阻塞：線程在獲取 synchronized 同步鎖失敗(因爲同步鎖被其他線程佔用)。
  • 其他阻塞：通過調用線程的 sleep() 或 join() 發出了 I/O 請求時，線程就會進入到阻塞狀態。當sleep() 狀態超時，join() 等待線程終止或超時，或者 I/O 處理完畢，線程重新轉入就緒狀態。

• 死亡狀態:

  一個運行狀態的線程完成任務或者其他終止條件發生時，該線程就切換到終止狀態。

---

線程的優先級

每一個 Java 線程都有一個優先級，這樣有助於操作系統確定線程的調度順序。

Java 線程的優先級是一個整數，其取值範圍是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。

默認情況下，每一個線程都會分配一個優先級 NORM_PRIORITY（5）。

具有較高優先級的線程對程序更重要，並且應該在低優先級的線程之前分配處理器資源。但是，線程優先級不能保證線程執行的順序，而且非常依賴於平臺。

---

創建一個線程

Java 提供了三種創建線程的方法：

• 通過實現 Runnable 接口；
• 通過繼承 Thread 類本身；
• 通過 Callable 和 Future 創建線程。

---

通過實現 Runnable 接口來創建線程

創建一個線程，最簡單的方法是創建一個實現 Runnable 接口的類。

爲了實現 Runnable，一個類只需要執行一個方法調用 run()，聲明如下：

public void run()

你可以重寫該方法，重要的是理解的 run() 可以調用其他方法，使用其他類，並聲明變量，就像主線程一樣。

在創建一個實現 Runnable 接口的類之後，你可以在類中實例化一個線程對象。

Thread 定義了幾個構造方法，下面的這個是我們經常使用的：

Thread(Runnable threadOb,String threadName);

這裏，threadOb 是一個實現 Runnable 接口的類的實例，並且 threadName 指定新線程的名字。

新線程創建之後，你調用它的 start() 方法它纔會運行。

void start();

下面是一個創建線程並開始讓它執行的實例：

實例

class RunnableDemo implements Runnable {
    private Thread t;
    private String threadName;
    RunnableDemo( String name) { 
        threadName = name;
        System.out.println("Creating " +  threadName );
    }
    public void run() {
        System.out.println("Running " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                // 讓線程睡眠一會
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }
    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }} 
public class TestThread {
    public static void main(String args[]) {
        RunnableDemo R1 = new RunnableDemo( "Thread-1");
        R1.start();
        RunnableDemo R2 = new RunnableDemo( "Thread-2");
        R2.start();
    }
}

編譯以上程序運行結果如下：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

---

通過繼承Thread來創建線程

創建一個線程的第二種方法是創建一個新的類，該類繼承 Thread 類，然後創建一個該類的實例。

繼承類必須重寫 run() 方法，該方法是新線程的入口點。它也必須調用 start() 方法才能執行。

該方法儘管被列爲一種多線程實現方式，但是本質上也是實現了 Runnable 接口的一個實例。

實例

class ThreadDemo extends Thread {
    private Thread t;
    private String threadName;
    ThreadDemo( String name) {
        threadName = name; 
        System.out.println("Creating " +  threadName );
    }
    public void run() {
        System.out.println("Running " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i); 
                // 讓線程睡眠一會 
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }
    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }} 
public class TestThread {
    public static void main(String args[]) {
        ThreadDemo T1 = new ThreadDemo( "Thread-1");
        T1.start();
        ThreadDemo T2 = new ThreadDemo( "Thread-2");
        T2.start();
    }
}

編譯以上程序運行結果如下：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

---

Thread 方法

下表列出了Thread類的一些重要方法：

序號	方法描述
1	**public void start()**使該線程開始執行；Java 虛擬機調用該線程的 run 方法。
2	**public void run()**如果該線程是使用獨立的 Runnable 運行對象構造的，則調用該 Runnable 對象的 run 方法；否則，該方法不執行任何操作並返回。
3	**public final void setName(String name)**改變線程名稱，使之與參數 name 相同。
4	public final void setPriority(int priority) 更改線程的優先級。
5	**public final void setDaemon(boolean on)**將該線程標記爲守護線程或用戶線程。
6	**public final void join(long millisec)**等待該線程終止的時間最長爲 millis 毫秒。
7	**public void interrupt()**中斷線程。
8	**public final boolean isAlive()**測試線程是否處於活動狀態。

測試線程是否處於活動狀態。 上述方法是被Thread對象調用的。下面的方法是Thread類的靜態方法。

序號	方法描述
1	**public static void yield()**暫停當前正在執行的線程對象，並執行其他線程。
2	**public static void sleep(long millisec)**在指定的毫秒數內讓當前正在執行的線程休眠（暫停執行），此操作受到系統計時器和調度程序精度和準確性的影響。
3	**public static boolean holdsLock(Object x)**當且僅當當前線程在指定的對象上保持監視器鎖時，才返回 true。
4	**public static Thread currentThread()**返回對當前正在執行的線程對象的引用。
5	**public static void dumpStack()**將當前線程的堆棧跟蹤打印至標準錯誤流。

實例

如下的ThreadClassDemo 程序演示了Thread類的一些方法：

DisplayMessage.java 文件代碼：

// 文件名 : DisplayMessage.java// 通過實現 Runnable 接口創建線程
public class DisplayMessage implements Runnable {
    private String message;
    public DisplayMessage(String message) {
        this.message = message;
    }
    public void run() {
        while(true) {
            System.out.println(message);
        }
    }}

GuessANumber.java 文件代碼：

// 文件名 : GuessANumber.java// 通過繼承 Thread 類創建線程
public class GuessANumber extends Thread {
    private int number;
    public GuessANumber(int number) {
        this.number = number;
    }
    public void run() {
        int counter = 0;
        int guess = 0;
        do {
            guess = (int) (Math.random() * 100 + 1);
    System.out.println(this.getName() + " guesses " + guess);
    counter++;
    } while(guess != number);
      System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
}}

ThreadClassDemo.java 文件代碼：

// 文件名 : ThreadClassDemo.javapublic 
class ThreadClassDemo {
    public static void main(String [] args) {
        Runnable hello = new DisplayMessage("Hello");
        Thread thread1 = new Thread(hello);
        thread1.setDaemon(true);
        thread1.setName("hello");
        System.out.println("Starting hello thread...");
        thread1.start();
        Runnable bye = new DisplayMessage("Goodbye");
        Thread thread2 = new Thread(bye);
        thread2.setPriority(Thread.MIN_PRIORITY);
        thread2.setDaemon(true);
        System.out.println("Starting goodbye thread...");
        thread2.start();
        System.out.println("Starting thread3...");
        Thread thread3 = new GuessANumber(27);
        thread3.start();
        try {
            thread3.join();
        }catch(InterruptedException e) {
            System.out.println("Thread interrupted.");
        }
        System.out.println("Starting thread4...");
        Thread thread4 = new GuessANumber(75);
        thread4.start();
        System.out.println("main() is ending...");
    }}

運行結果如下，每一次運行的結果都不一樣。

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

---

通過 Callable 和 Future 創建線程

• \1. 創建 Callable 接口的實現類，並實現 call() 方法，該 call() 方法將作爲線程執行體，並且有返回值。
• \2. 創建 Callable 實現類的實例，使用 FutureTask 類來包裝 Callable 對象，該 FutureTask 對象封裝了該 Callable 對象的 call() 方法的返回值。
• \3. 使用 FutureTask 對象作爲 Thread 對象的 target 創建並啓動新線程。
• \4. 調用 FutureTask 對象的 get() 方法來獲得子線程執行結束後的返回值。

實例

public class CallableThreadTest implements Callable<Integer> {    
public static void main(String[] args)      {          
CallableThreadTest ctt = new CallableThreadTest();          
FutureTask<Integer> ft = new FutureTask<>(ctt);          
for(int i = 0;i < 100;i++)          {              System.out.println(Thread.currentThread().getName()+" 的循環變量i的值"+i);
if(i==20) 
{                  
    new Thread(ft,"有返回值的線程").start();
}
                                    }
    try
    { 
        System.out.println("子線程的返回值："+ft.get());
    } catch (InterruptedException e)          {
        e.printStackTrace();
    } catch (ExecutionException e)          {
        e.printStackTrace();          }
}
    @Override      public Integer call() throws Exception      {
        int i = 0; 
        for(;i<100;i++)          {              System.out.println(Thread.currentThread().getName()+" "+i);
                                 } 
        return i;
    }  }

---

創建線程的三種方式的對比

• \1. 採用實現 Runnable、Callable 接口的方式創建多線程時，線程類只是實現了 Runnable 接口或 Callable 接口，還可以繼承其他類。
• \2. 使用繼承 Thread 類的方式創建多線程時，編寫簡單，如果需要訪問當前線程，則無需使用 Thread.currentThread() 方法，直接使用 this 即可獲得當前線程。

---

線程的幾個主要概念

在多線程編程時，你需要了解以下幾個概念：

• 線程同步
• 線程間通信
• 線程死鎖
• 線程控制：掛起、停止和恢復

---

多線程的使用

有效利用多線程的關鍵是理解程序是併發執行而不是串行執行的。例如：程序中有兩個子系統需要併發執行，這時候就需要利用多線程編程。

通過對多線程的使用，可以編寫出非常高效的程序。不過請注意，如果你創建太多的線程，程序執行的效率實際上是降低了，而不是提升了。

請記住，上下文的切換開銷也很重要，如果你創建了太多的線程，CPU 花費在上下文的切換的時間將多於執行程序的時間！

1. 多線程可以提高程序的效率。

實際生活案例：村長要求喜洋洋在一個小時內打100桶水，可以喜洋洋一個小時只能打25桶水，如果這樣就需要4個小時才能完成任務，爲了在一個小時能夠完成，喜洋洋就請美洋洋、懶洋洋、沸洋洋，來幫忙，這樣4只羊同時幹活，在一小時內完成了任務。原本用4個小時完成的任務現在只需要1個小時就完成了，如果把每隻羊看做一個線程，多隻羊即多線程可以提高程序的效率。

1. 多線程應用場景
   一般線程之間比較獨立，互不影響
   一個線程發生問題，一般不影響其它線程
   在多線程編程時，你需要了解以下幾個概念：

• 線程同步
• 線程間通信
• 線程死鎖
• 線程控制：掛起、停止和恢復

---

多線程的使用

有效利用多線程的關鍵是理解程序是併發執行而不是串行執行的。例如：程序中有兩個子系統需要併發執行，這時候就需要利用多線程編程。

通過對多線程的使用，可以編寫出非常高效的程序。不過請注意，如果你創建太多的線程，程序執行的效率實際上是降低了，而不是提升了。

請記住，上下文的切換開銷也很重要，如果你創建了太多的線程，CPU 花費在上下文的切換的時間將多於執行程序的時間！

多線程可以提高程序的效率。

實際生活案例：村長要求喜洋洋在一個小時內打100桶水，可以喜洋洋一個小時只能打25桶水，如果這樣就需要4個小時才能完成任務，爲了在一個小時能夠完成，喜洋洋就請美洋洋、懶洋洋、沸洋洋，來幫忙，這樣4只羊同時幹活，在一小時內完成了任務。原本用4個小時完成的任務現在只需要1個小時就完成了，如果把每隻羊看做一個線程，多隻羊即多線程可以提高程序的效率。

多線程應用場景
一般線程之間比較獨立，互不影響
一個線程發生問題，一般不影響其它線程