本文轉載自：阿里架構師實例講解——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 threads
				try {
					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多線程編程；詳細的不能再詳細了

阿里架構師實例講解——Java多線程編程；詳細的不能再詳細了

本文轉載自：阿里架構師實例講解——Java多線程編程；詳細的不能再詳細了

一、理解多線程

二、在Java中實現多線程

三、線程的四種狀態

四、線程的優先級

五、線程的同步

六、線程的阻塞

七、守護線程

八、一個應用：線程池

本文轉載自：阿里架構師實例講解——Java多線程編程；詳細的不能再詳細了

爲什麼要⽤ Foundry

【筆記】動手學深度學習-預備知識

py發送email

MySQL 分庫分表方案，總結太全了。。

Qt/C++音視頻開發71-指定mjpeg/h264格式採集本地攝像頭/存儲文件到mp4/設備推流/採集推流

WPF開源輕便、快速的桌面啓動器

公司來了個新同事，把 DDD 運用得爐火純青！

JVM深度剖析：一文詳解JVM是如何實現反射的？

面試官：有做過高可用的K8S集羣部署方案嗎？

如何迅速分析出系統I/O的瓶頸在哪裏？

進階分佈式架構:如何應對高併發的用戶請求

阿里面試官：RocketMQ與Kafka中如何實現事務？

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結