歡迎關注專欄《Java架構筑基》——專注于Java技術的研究與分享！

Java架構筑基?zhuanlan.zhihu.com

• Java架構筑基——專注于Java技術的研究與分享！
• 后續文章將首發此專欄！
• 歡迎各位Java工程師朋友投稿和關注
• Java架構師進階之路<常用資料分享>

---

一、理解多線程

多線程是這樣一種機制，它允許在程序中并發執行多個指令流，每個指令流都稱為一個線程，彼此間互相獨立。線程又稱為輕量級進程，它和進程一樣擁有獨立的執行控制，由操作系統負責調度，區別在于線程沒有獨立的存儲空間，而是和所屬進程中的其它線程共享一個存儲空間，這使得線程間的通信遠較進程簡單。

具體到java內存模型，由于Java被設計為跨平臺的語言，在內存管理上，顯然也要有一個統一的模型。系統存在一個主內存（Main Memory）， Java中所有變量都儲存在主存中，對于所有線程都是共享的。每條線程都有自己的工作內存（Working Memory），工作內存中保存的是主存中某些變量的拷貝，線程對所有變量的操作都是在工作內存中進行，線程之間無法相互直接訪問，變量傳遞均需要通過主存完成。

多個線程的執行是并發的，也就是在邏輯上“同時”，而不管是否是物理上的“同時”。如果系統只有一個CPU，那么真正的“同時”是不可能的。多線程和傳統的單線程在程序設計上最大的區別在于，由于各個線程的控制流彼此獨立，使得各個線程之間的代碼是亂序執行的，將會帶來線程調度，同步等問題。

二、在Java中實現多線程

我們不妨設想，為了創建一個新的線程，我們需要做些什么？很顯然，我們必須指明這個線程所要執行的代碼，而這就是在Java中實現多線程我們所需要做的一切！

作為一個完全面向對象的語言，Java提供了類 java.lang.Thread 來方便多線程編程，這個類提供了大量的方法來方便我們控制自己的各個線程。

那么如何提供給 Java 我們要線程執行的代碼呢？讓我們來看一看 Thread 類。Thread 類最重要的方法是 run（），它為Thread 類的方法 start（） 所調用，提供我們的線程所要執行的代碼。為了指定我們自己的代碼，只需要覆蓋它！

方法一：繼承 Thread 類，重寫方法 run（），我們在創建Thread 類的子類中重寫 run（） ，加入線程所要執行的代碼即可。下面是一個例子：

public class TwoThread extends Thread {public void run() {for ( int i = 0; i < 10; i++ ) {System.out.println("New thread");}}public static void main(String[] args) {TwoThread tt = new TwoThread();tt.start();for ( int i = 0; i < 10; i++ ) {System.out.println("Main thread");}} }

這種方法簡單明了，符合大家的習慣，但是，它也有一個很大的缺點，那就是如果我們的類已經從一個類繼承，則無法再繼承 Thread 類。

方法二：實現 Runnable 接口

Runnable 接口只有一個方法 run（），我們聲明自己的類實現 Runnable 接口并提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務。但是 Runnable 接口并沒有任何對線程的支持，我們還必須創建 Thread 類的實例，這一點通過 Thread 類的構造函數public Thread（Runnable target）；來實現。下面是一個例子：

public class MyThread implements Runnable {int count=1, number;public MyThread(int num) {number = num;System.out.println("創建線程 " + number);}public void run() {//實現了接口的run()方法while(true) {System.out.println("線程 " + number + ":計數 " + count);if(++count== 6) return;}}public static void main(String args[]) {for (int i = 0; i < 5; i++)new Thread(new MyThread(i+1)).start();} }

使用 Runnable 接口來實現多線程使得我們能夠在一個類中包容所有的代碼，有利于封裝下面讓我們一起來研究一下多線程使用中的一些問題。

三、線程的四種狀態

新狀態：線程已被創建但尚未執行（start（） 尚未被調用）。

可執行狀態：線程可以執行，雖然不一定正在執行。CPU 時間隨時可能被分配給該線程，從而使得它執行。

阻塞狀態：線程不會被分配 CPU 時間，無法執行；可能阻塞于I/O，或者阻塞于同步鎖。

死亡狀態：正常情況下run（） 返回使得線程死亡。調用 stop（）或 destroy（） 亦有同樣效果，但是不被推薦，前者會產生異常，后者是強制終止，不會釋放鎖。

四、線程的優先級

線程的優先級代表該線程的重要程度，當有多個線程同時處于可執行狀態并等待獲得 CPU 時間時，線程調度系統根據各個線程的優先級來決定給誰分配 CPU 時間，優先級高的線程有更大的機會獲得 CPU 時間，優先級低的線程也不是沒有機會，只是機會要小一些罷了。

你可以調用 Thread 類的方法 getPriority（） 和 setPriority（）來存取線程的優先級，線程的優先級界于1（MIN_PRIORITY）和10（MAX_PRIORITY）之間，缺省是5（NORM_PRIORITY）。

五、線程的同步

由于同一進程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴重的問題。Java語言提供了專門機制以解決這種沖突，有效避免了同一個數據對象被多個線程同時訪問。

我們只需針對方法提出一套機制，這套機制就是 synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。

①. synchronized 方法：通過在方法聲明中加入synchronized關鍵字來聲明 synchronized 方法。synchronized 方法控制對類成員變量的訪問：每個類實例對應一把鎖，每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執行，否則所屬線程阻塞，方法一旦執行，就獨占該鎖，直到從該方法返回時才將鎖釋放，此后被阻塞的線程方能獲得該鎖，重新進入可執行狀態。這種機制確保了同一時刻對于每一個類實例，其所有聲明為 synchronized 的成員函數中至多只有一個處于可執行狀態（因為至多只有一個能夠獲得該類實例對應的鎖），從而有效避免了類成員變量的訪問沖突（只要所有可能訪問類成員變量的方法均被聲明為 synchronized）。

在 Java 中，不光是類實例，每一個類也對應一把鎖，這樣我們也可將類的靜態成員函數聲明為 synchronized，以控制其對類的靜態成員變量的訪問。

synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法run（）聲明為synchronized ，由于在線程的整個生命期內它一直在運行，因此將導致它對本類任何synchronized方法的調用都永遠不會成功。

②. synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。語法如下：

synchronized(syncObject) {//允許訪問控制的代碼 }

synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject 的鎖方能執行，具體機制同前所述。由于可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。

六、線程的阻塞

為了解決對共享存儲區的訪問沖突，Java 引入了同步機制，現在讓我們來考察多個線程對共享資源的訪問，顯然同步機制已經不夠了，因為在任意時刻所要求的資源不一定已經準備好了被訪問，反過來，同一時刻準備好了的資源也可能不止一個。為了解決這種情況下的訪問控制問題，Java 引入了對阻塞機制的支持。

阻塞指的是暫停一個線程的執行以等待某個條件發生（如某資源就緒）。Java 提供了大量方法來支持阻塞，下面讓對它們逐一分析。

①.sleep（）方法：sleep（）允許指定以毫秒為單位的一段時間作為參數，它使得線程在指定的時間內進入阻塞狀態，不能得到CPU 時間，指定的時間一過，線程重新進入可執行狀態。

典型地，sleep（） 被用在等待某個資源就緒的情形：測試發現條件不滿足后，讓線程阻塞一段時間后重新測試，直到條件滿足為止。

②.suspend（）和resume（）方法：兩個方法配套使用，suspend（）使得線程進入阻塞狀態，并且不會自動恢復，必須其對應的 resume（） 被調用，才能使得線程重新進入可執行狀態。典型地，suspend（） 和 resume（）被用在等待另一個線程產生的結果的情形：測試發現結果還沒有產生后，讓線程阻塞，另一個線程產生了結果后，調用resume（）使其恢復。

③.yield（） 方法：yield（） 使得線程放棄當前分得的 CPU 時間，但是不使線程阻塞，即線程仍處于可執行狀態，隨時可能再次分得 CPU 時間。調用 yield（） 的效果等價于調度程序認為該線程已執行了足夠的時間從而轉到另一個線程。

④.wait（） 和 notify（） 方法：兩個方法配套使用，wait（）使得線程進入阻塞狀態，它有兩種形式，一種允許指定以毫秒為單位的一段時間作為參數，另一種沒有參數，前者當對應的 notify（）被調用或者超出指定時間時線程重新進入可執行狀態，后者則必須對應的 notify（） 被調用。

2和4區別的核心在于，前面敘述的所有方法，阻塞時都不會釋放占用的鎖（如果占用了的話），而這一對方法則相反。上述的核心區別導致了一系列的細節上的區別。

首先，前面敘述的所有方法都隸屬于Thread 類，但是這一對卻直接隸屬于 Object 類，也就是說，所有對象都擁有這一對方法。因為這一對方法阻塞時要釋放占用的鎖，而鎖是任何對象都具有的，調用任意對象的 wait（）方法導致線程阻塞，并且該對象上的鎖被釋放。而調用任意對象的notify（）方法則導致因調用該對象的 wait（）方法而阻塞的線程中隨機選擇的一個解除阻塞（但要等到獲得鎖后才真正可執行）。

其次，前面敘述的所有方法都可在任何位置調用，但是這一對方法卻必須在 synchronized 方法或塊中調用，理由也很簡單，只有在synchronized 方法或塊中當前線程才占有鎖，才有鎖可以釋放。同樣的道理，調用這一對方法的對象上的鎖必須為當前線程所擁有，這樣才有鎖可以釋放。因此，這一對方法調用必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖對象就是調用這一對方法的對象。若不滿足這一條件，則程序雖然仍能編譯，但在運行時會出現 IllegalMonitorStateException 異常。

wait（）和notify（）方法的上述特性決定了它們經常和synchronized 方法或塊一起使用，將它們和操作系統的進程間通信機制作一個比較就會發現它們的相似性：synchronized方法或塊提供了類似于操作系統原語的功能，它們的結合用于解決各種復雜的線程間通信問題。

關于 wait（） 和 notify（） 方法最后再說明兩點：

• 第一：調用 notify（） 方法導致解除阻塞的線程是從因調用該對象的 wait（） 方法而阻塞的線程中隨機選取的，我們無法預料哪一個線程將會被選擇，所以編程時要特別小心，避免因這種不確定性而產生問題。
• 第二：除了 notify（），還有一個方法 notifyAll（） 也可起到類似作用，唯一的區別在于，調用 notifyAll（）方法將把因調用該對象的wait（）方法而阻塞的所有線程一次性全部解除阻塞。當然，只有獲得鎖的那一個線程才能進入可執行狀態。

談到阻塞，就不能不談一談死鎖，略一分析就能發現，suspend（） 方法和不指定超時期限的 wait（） 方法的調用都可能產生死鎖。遺憾的是，Java 并不在語言級別上支持死鎖的避免，我們在編程中必須小心地避免死鎖。

以上我們對 Java 中實現線程阻塞的各種方法作了一番分析，我們重點分析了 wait（） 和 notify（）方法，因為它們的功能最強大，使用也最靈活，但是這也導致了它們的效率較低，較容易出錯。實際使用中我們應該靈活使用各種方法，以便更好地達到我們的目的。

還有一個方法比較有用，Thread的join（）方法可用于讓當前線程阻塞，以等待特定線程的消亡。

package cn.test.first.thread; import java.lang.Runnable; import java.lang.Thread; public class DemoThread implements Runnable {public DemoThread() {TestThread testthread1 = new TestThread(this, "1");TestThread testthread2 = new TestThread(this, "2");testthread2.start();testthread1.start();}public static void main(String[] args) {DemoThread demoThread1 = new DemoThread();}public void run() {TestThread t = (TestThread) Thread.currentThread();try {if (!t.getName().equalsIgnoreCase("1")) {synchronized (this) {wait();}}while (true) {System.out.println("@time in thread" + t.getName() + "=" + t.increaseTime());if (t.getTime() % 2 == 0) {synchronized (this) {System.out.println("****************************************");notify();if (t.getTime() == 10) {break;}wait();}}}}catch (Exception e) {e.printStackTrace();}} } class TestThread extends Thread {private int time = 0;public TestThread(Runnable r, String name) {super(r, name);}public int getTime() {return time;}public int increaseTime() {return ++time;} }

運行結

@time in thread1=1 @time in thread1=2 **************************************** @time in thread2=1 @time in thread2=2 **************************************** @time in thread1=3 @time in thread1=4 **************************************** @time in thread2=3 @time in thread2=4 **************************************** …… @time in thread1=9 @time in thread1=10 **************************************** @time in thread2=9 @time in thread2=10 ****************************************

七、守護線程

守護線程是一類特殊的線程，它和普通線程的區別在于它并不是應用程序的核心部分，當一個應用程序的所有非守護線程終止運行時，即使仍然有守護線程在運行，應用程序也將終止，反之，只要有一個非守護線程在運行，應用程序就不會終止。守護線程一般被用于在后臺為其它線程提供服務。調用方法 isDaemon（） 來判斷一個線程是否是守護線程，也可以調用方法setDaemon（）將一個線程設為守護線程。

八、一個應用：線程池

1. 背景

諸如 Web 服務器、數據庫服務器、文件服務器或郵件服務器之類的許多服務器應用程序都面向處理來自某些遠程來源的大量短小的任務。 服務器應用程序中經常出現的情況是：單個任務處理的時間很短而請求的數目卻是巨大的。

2. 解決方法

構建服務器應用程序的一個過于簡單的模型應該是：每當一個請求到達就創建一個新線程，然后在新線程中為請求服務。

那么這種方法的嚴重不足就很明顯。每個請求對應一個線程（thread-per-request）方法的不足之一是：為每個請求創建一個新線程的開銷很大；在一個 JVM 里創建太多的線程可能會導致系統由于過度消耗內存而用完內存或“切換過度”。為了防止資源不足，服務器應用程序需要一些辦法來限制任何給定時刻處理的請求數目。

我們可以實現一個線程池類，其中客戶機類等待一個可用線程、將任務傳遞給該線程以便執行、然后在任務完成時將線程歸還給池，一般一個簡單線程池至少包含下列組成部分：

• 線程池管理器（ThreadPoolManager）：用于創建并管理線程池
• 工作線程（WorkThread）： 線程池中線程
• 任務接口（Task）：每個任務必須實現的接口，以供工作線程調度任務的執行。
• 任務隊列：用于存放沒有處理的任務。提供一種緩沖機制。

public class WorkQueue {private final int nThreads;private final PoolWorker[] threads;private final LinkedList queue;public WorkQueue(int nThreads) {this.nThreads = nThreads;queue = new LinkedList();threads = new PoolWorker[nThreads];for (int i = 0; i < nThreads; i++) {threads[i] = new PoolWorker();threads[i].start();}}public void execute(Runnable r) {synchronized (queue) {queue.addLast(r);queue.notify();}}private class PoolWorker extends Thread {public void run() {Runnable r;while (true) {synchronized (queue) {while (queue.isEmpty()) {try {queue.wait();}catch (InterruptedException ignored) {}}r = (Runnable) queue.removeFirst();}// If we don't catch RuntimeException,// the pool could leak threadstry {r.run();}catch (RuntimeException e) {// You might want to log something here}}}}public static void main(String args[]) {WorkQueue wq = new WorkQueue(3);wq.execute(new Runnable() {public void run() {for (int i = 0; i < 10; i++) {try {Thread.sleep(1000);}catch (Exception e) {}System.out.println("this is a thread");}}});} }

鏈接 Java程序員福利"常用資料分享"

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的fusion 360安装程序的多个实例正在同时运行。_阿里架构师实例讲解——Java多线程编程；详细的不能再详细了...的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。