2w字 + 40張圖帶你參透併發程式設計！
阿新 • • 發佈：2020-08-18
## 併發歷史
在計算機最早期的時候，沒有作業系統，執行程式只需要一種方式，那就是從頭到尾依次執行。任何資源都會為這個程式服務，在計算機使用某些資源時，其他資源就會空閒，就會存在 `浪費資源` 的情況。
>這裡說的浪費資源指的是資源空閒，沒有充分使用的情況。
作業系統的出現為我們的程式帶來了 `併發性`，作業系統使我們的程式能夠同時執行多個程式，一個程式就是一個程序，也就相當於同時執行多個程序。
作業系統是一個`併發系統`，併發性是作業系統非常重要的特徵，作業系統具有同時處理和排程多個程式的能力，比如多個 I/O 裝置同時在輸入輸出；裝置 I/O 和 CPU 計算同時進行；記憶體中同時有多個系統和使用者程式被啟動交替、穿插地執行。作業系統在協調和分配程序的同時，作業系統也會為不同程序分配不同的資源。
作業系統實現多個程式同時執行解決了單個程式無法做到的問題，主要有下面三點
* `資源利用率`，我們上面說到，單個程序存在資源浪費的情況，舉個例子，當你在為某個資料夾賦予許可權的時候，輸入程式無法接受外部的輸入字元，只有等到許可權賦予完畢後才能接受外部輸入。總的來講，就是在等待程式時無法執行其他工作。如果在等待程式時可以執行另一個程式，那麼將會大大提高資源的利用率。（資源並不會覺得累）因為它不會划水～
* `公平性`，不同的使用者和程式都能夠使用計算機上的資源。一種高效的執行方式是為不同的程式劃分時間片來使用資源，但是有一點需要注意，作業系統可以決定不同程序的優先順序。雖然每個程序都有能夠公平享有資源的權利，但是當有一個程序釋放資源後的同時有一個優先順序更高的程序搶奪資源，就會造成優先順序低的程序無法獲得資源，進而導致程序飢餓。
* `便利性`，單個程序是是不用通訊的，通訊的本質就是`資訊交換`，及時進行資訊交換能夠避免`資訊孤島`，做重複性的工作；任何併發能做的事情，單程序也能夠實現，只不過這種方式效率很低，它是一種`順序性`的。
但是，順序程式設計（也稱為`序列程式設計`）也不是`一無是處`的，序列程式設計的優勢在於其**直觀性和簡單性**，客觀來講，序列程式設計更適合我們人腦的思考方式，但是我們並不會滿足於順序程式設計，**we want it more!!!** 。資源利用率、公平性和便利性促使著程序出現的同時，也促使著`執行緒`的出現。
如果你還不是很理解程序和執行緒的區別的話，那麼我就以我多年作業系統的經驗（吹牛逼，實則半年）來為你解釋一下：**程序是一個應用程式，而執行緒是應用程式中的一條順序流**。
程序中會有多個執行緒來完成一些任務，這些任務有可能相同有可能不同。每個執行緒都有自己的執行順序。
每個執行緒都有自己的棧空間，這是執行緒私有的，還有一些其他執行緒內部的和執行緒共享的資源，如下所示。
>在計算機中，一般堆疊指的就是棧，而堆指的才是堆
執行緒會共享程序範圍內的資源，例如記憶體和檔案控制代碼，但是每個執行緒也有自己私有的內容，比如程式計數器、棧以及區域性變數。下面彙總了程序和執行緒共享資源的區別
執行緒是一種`輕量級`的程序，輕量級體現線上程的建立和銷燬要比程序的開銷小很多。
>注意：任何比較都是相對的。
在大多數現代作業系統中，都以執行緒為基本的排程單位，所以我們的視角著重放在對`執行緒`的探究。
## 執行緒
### 什麼是多執行緒
多執行緒意味著你能夠在同一個應用程式中執行多個執行緒，我們知道，指令是在 CPU 中執行的，多執行緒應用程式就像是具有多個 CPU 在同時執行應用程式的程式碼。
其實這是一種假象，執行緒數量並不等於 CPU 數量，單個 CPU 將在多個執行緒之間共享 CPU 的時間片，在給定的時間片內執行每個執行緒之間的切換，每個執行緒也可以由不同的 CPU 執行，如下圖所示
### 併發和並行的關係
`併發`意味著應用程式會執行多個的任務，但是如果計算機只有一個 CPU 的話，那麼應用程式無法同時執行多個的任務，但是應用程式又需要執行多個任務，所以計算機在開始執行下一個任務之前，它並沒有完成當前的任務，只是把狀態暫存，進行任務切換，CPU 在多個任務之間進行切換，直到任務完成。如下圖所示
`並行`是指應用程式將其任務分解為較小的子任務，這些子任務可以並行處理，例如在多個CPU上同時進行。
### 優勢和劣勢
合理使用執行緒是一門藝術，合理編寫一道準確無誤的多執行緒程式更是一門藝術，如果執行緒使用得當，能夠有效的降低程式的開發和維護成本。
Java 很好的在使用者空間實現了開發工具包，並在核心空間提供系統呼叫來支援多執行緒程式設計，Java 支援了豐富的類庫 `java.util.concurrent` 和跨平臺的`記憶體模型`，同時也提高了開發人員的門檻，併發一直以來是一個高階的主題，但是現在，併發也成為了主流開發人員的必備素質。
雖然執行緒帶來的好處很多，但是編寫正確的多執行緒（併發）程式是一件極困難的事情，併發程式的 Bug 往往會詭異地出現又詭異的消失，在當你認為沒有問題的時候它就出現了，`難以定位` 是併發程式的一個特徵，所以在此基礎上你需要有紮實的併發基本功。那麼，併發為什麼會出現呢？
### 併發為什麼會出現
計算機世界的快速發展離不開 CPU、記憶體和 I/O 裝置的高速發展，但是這三者一直存在速度差異性問題，我們可以從儲存器的層次結構可以看出
CPU 內部是暫存器的構造，暫存器的訪問速度要高於`快取記憶體`，快取記憶體的訪問速度要高於記憶體，最慢的是磁碟訪問。
程式是在記憶體中執行的，程式裡大部分語句都要訪問記憶體，有些還需要訪問 I/O 裝置，根據漏桶理論來說，程式整體的效能取決於最慢的操作也就是磁碟訪問速度。
因為 CPU 速度太快了，所以為了發揮 CPU 的速度優勢，平衡這三者的速度差異，計算機體系機構、作業系統、編譯程式都做出了貢獻，主要體現為：
* CPU 使用快取來中和和記憶體的訪問速度差異
* 作業系統提供程序和執行緒排程，讓 CPU 在執行指令的同時分時複用執行緒，讓記憶體和磁碟不斷互動，不同的 `CPU 時間片` 能夠執行不同的任務，從而均衡這三者的差異
* 編譯程式提供優化指令的執行順序，讓快取能夠合理的使用
我們在享受這些便利的同時，多執行緒也為我們帶來了挑戰，下面我們就來探討一下併發問題為什麼會出現以及多執行緒的源頭是什麼
### 執行緒帶來的安全性問題
執行緒安全性是非常複雜的，在沒有采用`同步機制`的情況下，多個執行緒中的執行操作往往是不可預測的，這也是多執行緒帶來的挑戰之一，下面我們給出一段程式碼，來看看安全性問題體現在哪
```java
public class TSynchronized implements Runnable{
static int i = 0;
public void increase(){
i++;
}
@Override
public void run() {
for(int i = 0;i < 1000;i++) {
increase();
}
}
public static void main(String[] args) throws InterruptedException {
TSynchronized tSynchronized = new TSynchronized();
Thread aThread = new Thread(tSynchronized);
Thread bThread = new Thread(tSynchronized);
aThread.start();
bThread.start();
System.out.println("i = " + i);
}
}
```
這段程式輸出後會發現，i 的值每次都不一樣，這不符合我們的預測，那麼為什麼會出現這種情況呢？我們先來分析一下程式的執行過程。
`TSynchronized` 實現了 Runnable 介面，並定義了一個靜態變數 `i`，然後在 `increase` 方法中每次都增加 i 的值，在其實現的 run 方法中進行迴圈呼叫，共執行 1000 次。
#### 可見性問題
在單核 CPU 時代，所有的執行緒共用一個 CPU，CPU 快取和記憶體的一致性問題容易解決，CPU 和 記憶體之間
如果用圖來表示的話我想會是下面這樣
在多核時代，因為有多核的存在，每個核都能夠獨立的執行一個執行緒，每顆 CPU 都有自己的快取，這時 CPU 快取與記憶體的資料一致性就沒那麼容易解決了，當多個執行緒在不同的 CPU 上執行時，這些執行緒操作的是不同的 CPU 快取
因為 i 是靜態變數，沒有經過任何執行緒安全措施的保護，多個執行緒會併發修改 i 的值，所以我們認為 i 不是執行緒安全的，導致這種結果的出現是由於 aThread 和 bThread 中讀取的 i 值彼此不可見，所以這是由於 `可見性` 導致的執行緒安全問題。
####原子性問題
看起來很普通的一段程式卻因為兩個執行緒 `aThread` 和 `bThread` 交替執行產生了不同的結果。但是根源不是因為建立了兩個執行緒導致的，多執行緒只是產生執行緒安全性的必要條件，最終的根源出現在 `i++` 這個操作上。
這個操作怎麼了？這不就是一個給 i 遞增的操作嗎？也就是 **i++ => task = new FutureTask((Callable) () -> {
for(int i = 0;i < 1000;i++){
count++;
}
return count;
});
Thread thread = new Thread(task);
thread.start();
Integer total = task.get();
System.out.println("total = " + total);
}
}
```
我想，使用 Callable 介面的好處你已經知道了吧，既能夠實現多個介面，也能夠得到執行結果的返回值。Callable 和 Runnable 介面還是有一些區別的，主要區別如下
* Callable 執行的任務有返回值，而 Runnable 執行的任務沒有返回值
* Callable（重寫）的方法是 call 方法，而 Runnable（重寫）的方法是 run 方法。
* call 方法可以丟擲異常，而 Runnable 方法不能丟擲異常
### 使用執行緒池來建立執行緒
首先先來認識一下頂級介面 `Executor`，Executor 雖然不是傳統執行緒建立的方式之一，但是它卻成為了建立執行緒的替代者，使用執行緒池的好處如下
* 利用執行緒池能夠複用執行緒、控制最大併發數。
* 實現任務執行緒佇列`快取策略`和`拒絕機制`。
* 實現某些與時間相關的功能，如定時執行、週期執行等。
* 隔離執行緒環境。比如，交易服務和搜尋服務在同一臺伺服器上，分別開啟兩個執行緒池，交易執行緒的資源消耗明顯要大；因此，通過配置獨立的執行緒池，將較慢的交易服務與搜尋服務隔開，避免個服務執行緒互相影響。
你可以使用如下操作來替換執行緒建立
```java
new Thread(new(RunnableTask())).start()
// 替換為
Executor executor = new ExecutorSubClass() // 執行緒池實現類;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());
```
`ExecutorService` 是 Executor 的預設實現，也是 Executor 的擴充套件介面，ThreadPoolExecutor 類提供了執行緒池的擴充套件實現。`Executors` 類為這些 Executor 提供了方便的工廠方法。下面是使用 ExecutorService 建立執行緒的幾種方式
#### CachedThreadPool
從而簡化了併發程式設計。Executor 在客戶端和任務之間提供了一個間接層；與客戶端直接執行任務不同，這個中介物件將執行任務。Executor 允許你管理`非同步`任務的執行，而無須顯示地管理執行緒的生命週期。
```java
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
for(int i = 0;i < 5;i++){
service.execute(new TestThread());
}
service.shutdown();
}
```
`CachedThreadPool` 會為每個任務都建立一個執行緒。
> 注意：ExecutorService 物件是使用靜態的 `Executors` 建立的，這個方法可以確定 Executor 型別。對 `shutDown` 的呼叫可以防止新任務提交給 ExecutorService ，這個執行緒在 Executor 中所有任務完成後退出。
#### FixedThreadPool
FixedThreadPool 使你可以使用`有限`的執行緒集來啟動多執行緒
```java
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(5);
for(int i = 0;i < 5;i++){
service.execute(new TestThread());
}
service.shutdown();
}
```
有了 FixedThreadPool 使你可以一次性的預先執行高昂的執行緒分配，因此也就可以限制執行緒的數量。這可以節省時間，因為你不必為每個任務都固定的付出建立執行緒的開銷。
#### SingleThreadExecutor
SingleThreadExecutor 就是`執行緒數量為 1 `的 FixedThreadPool，如果向 SingleThreadPool 一次性提交了多個任務，那麼這些任務將會排隊，每個任務都會在下一個任務開始前結束，所有的任務都將使用相同的執行緒。SingleThreadPool 會序列化所有提交給他的任務，並會維護它自己(隱藏)的懸掛佇列。
```java
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor();
for(int i = 0;i < 5;i++){
service.execute(new TestThread());
}
service.shutdown();
}
```
從輸出的結果就可以看到，任務都是挨著執行的。我為任務分配了五個執行緒，但是這五個執行緒不像是我們之前看到的有換進換出的效果，它每次都會先執行完自己的那個執行緒，然後餘下的執行緒繼續`走完`這條執行緒的執行路徑。你可以用 SingleThreadExecutor 來確保任意時刻都只有唯一一個任務在執行。
### 休眠
影響任務行為的一種簡單方式就是使執行緒 休眠，選定給定的休眠時間，呼叫它的 `sleep()` 方法， 一般使用的`TimeUnit` 這個時間類替換 `Thread.sleep()` 方法，示例如下：
```java
public class SuperclassThread extends TestThread{
@Override
public void run() {
System.out.println(Thread.currentThread() + "starting ..." );
try {
for(int i = 0;i < 5;i++){
if(i == 3){
System.out.println(Thread.currentThread() + "sleeping ...");
TimeUnit.MILLISECONDS.sleep(1000);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread() + "wakeup and end ...");
}
public static void main(String[] args) {
ExecutorService executors = Executors.newCachedThreadPool();
for(int i = 0;i < 5;i++){
executors.execute(new SuperclassThread());
}
executors.shutdown();
}
}
```
> 關於 TimeUnit 中的 sleep() 方法和 Thread.sleep() 方法的比較，請參考下面這篇部落格
>
> (https://www.cnblogs.com/xiadongqing/p/9925567.html)
### 優先順序
上面提到執行緒排程器對每個執行緒的執行都是不可預知的，隨機執行的，那麼有沒有辦法告訴執行緒排程器哪個任務想要優先被執行呢？你可以通過設定執行緒的優先順序狀態，告訴執行緒排程器哪個執行緒的執行優先順序比較高，**請給這個騎手馬上派單**，執行緒排程器傾向於讓優先順序較高的執行緒優先執行，然而，這並不意味著優先順序低的執行緒得不到執行，也就是說，優先順序不會導致死鎖的問題。優先順序較低的執行緒只是執行頻率較低。
```java
public class SimplePriorities implements Runnable{
private int priority;
public SimplePriorities(int priority) {
this.priority = priority;
}
@Override
public void run() {
Thread.currentThread().setPriority(priority);
for(int i = 0;i < 100;i++){
System.out.println(this);
if(i % 10 == 0){
Thread.yield();
}
}
}
@Override
public String toString() {
return Thread.currentThread() + " " + priority;
}
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
for(int i = 0;i < 5;i++){
service.execute(new SimplePriorities(Thread.MAX_PRIORITY));
}
service.execute(new SimplePriorities(Thread.MIN_PRIORITY));
}
}
```
toString() 方法被覆蓋，以便通過使用 `Thread.toString()` 方法來列印執行緒的名稱。你可以改寫執行緒的預設輸出，這裡採用了 **Thread[pool-1-thread-1,10,main]** 這種形式的輸出。
通過輸出，你可以看到，最後一個執行緒的優先順序最低，其餘的執行緒優先順序最高。注意，優先順序是在 run 開頭設定的，在構造器中設定它們不會有任何好處，因為這個時候執行緒還沒有執行任務。
儘管 JDK 有 10 個優先順序，但是一般只有**MAX_PRIORITY，NORM_PRIORITY，MIN_PRIORITY** 三種級別。
### 作出讓步
我們上面提過，如果知道一個執行緒已經在 run() 方法中執行的差不多了，那麼它就可以給執行緒排程器一個提示：我已經完成了任務中最重要的部分，可以讓給別的執行緒使用 CPU 了。這個暗示將通過 yield() 方法作出。
> 有一個很重要的點就是，Thread.yield() 是建議執行切換CPU，而不是強制執行CPU切換。
對於任何重要的控制或者在呼叫應用時，都不能依賴於 `yield() `方法，實際上， yield() 方法經常被濫用。
### 後臺執行緒
`後臺(daemon) `執行緒，是指執行時在後臺提供的一種服務執行緒，這種執行緒不是屬於必須的。當所有非後臺執行緒結束時，程式也就停止了，**同時會終止所有的後臺執行緒。**反過來說，只要有任何非後臺執行緒還在執行，程式就不會終止。
```java
public class SimpleDaemons implements Runnable{
@Override
public void run() {
while (true){
try {
TimeUnit.MILLISECONDS.sleep(100);
System.out.println(Thread.currentThread() + " " + this);
} catch (InterruptedException e) {
System.out.println("sleep() interrupted");
}
}
}
public static void main(String[] args) throws InterruptedException {
for(int i = 0;i < 10;i++){
Thread daemon = new Thread(new SimpleDaemons());
daemon.setDaemon(true);
daemon.start();
}
System.out.println("All Daemons started");
TimeUnit.MILLISECONDS.sleep(175);
}
}
```
在每次的迴圈中會建立 10 個執行緒，並把每個執行緒設定為後臺執行緒，然後開始執行，for 迴圈會進行十次，然後輸出資訊，隨後主執行緒睡眠一段時間後停止執行。在每次 run 迴圈中，都會列印當前執行緒的資訊，主執行緒執行完畢，程式就執行完畢了。因為 `daemon` 是後臺執行緒，無法影響主執行緒的執行。
但是當你把 `daemon.setDaemon(true)` 去掉時，while(true) 會進行無限迴圈，那麼主執行緒一直在執行最重要的任務，所以會一直迴圈下去無法停止。
### ThreadFactory
按需要建立執行緒的物件。使用執行緒工廠替換了 Thread 或者 Runnable 介面的硬連線，使程式能夠使用特殊的執行緒子類，優先順序等。一般的建立方式為
```java
class SimpleThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
return new Thread(r);
}
}
```
> Executors.defaultThreadFactory 方法提供了一個更有用的簡單實現，它在返回之前將建立的執行緒上下文設定為已知值
`ThreadFactory `是一個介面，它只有一個方法就是建立執行緒的方法
```java
public interface ThreadFactory {
// 構建一個新的執行緒。實現類可能初始化優先順序，名稱，後臺執行緒狀態和 執行緒組等
Thread newThread(Runnable r);
}
```
下面來看一個 ThreadFactory 的例子
```java
public class DaemonThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}
}
public class DaemonFromFactory implements Runnable{
@Override
public void run() {
while (true){
try {
TimeUnit.MILLISECONDS.sleep(100);
System.out.println(Thread.currentThread() + " " + this);
} catch (InterruptedException e) {
System.out.println("Interrupted");
}
}
}
public static void main(String[] args) throws InterruptedException {
ExecutorService service = Executors.newCachedThreadPool(new DaemonThreadFactory());
for(int i = 0;i < 10;i++){
service.execute(new DaemonFromFactory());
}
System.out.println("All daemons started");
TimeUnit.MILLISECONDS.sleep(500);
}
}
```
`Executors.newCachedThreadPool` 可以接受一個執行緒池物件，建立一個根據需要建立新執行緒的執行緒池，但會在它們可用時重用先前構造的執行緒，並在需要時使用提供的 ThreadFactory 建立新執行緒。
```java
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue(),
threadFactory);
}
```
### 加入一個執行緒
一個執行緒可以在其他執行緒上呼叫 `join()` 方法，其效果是等待一段時間直到第二個執行緒結束才正常執行。如果某個執行緒在另一個執行緒 t 上呼叫 t.join() 方法，此執行緒將被掛起，直到目標執行緒 t 結束才回復(可以用 t.isAlive() 返回為真假判斷)。
也可以在呼叫 join 時帶上一個超時引數，來設定到期時間，時間到期，join方法自動返回。
對 join 的呼叫也可以被中斷，做法是線上程上呼叫 `interrupted` 方法，這時需要用到 try...catch 子句
```java
public class TestJoinMethod extends Thread{
@Override
public void run() {
for(int i = 0;i < 5;i++){
try {
TimeUnit.MILLISECONDS.sleep(1000);
} catch (InterruptedException e) {
System.out.println("Interrupted sleep");
}
System.out.println(Thread.currentThread() + " " + i);
}
}
public static void main(String[] args) throws InterruptedException {
TestJoinMethod join1 = new TestJoinMethod();
TestJoinMethod join2 = new TestJoinMethod();
TestJoinMethod join3 = new TestJoinMethod();
join1.start();
// join1.join();
join2.start();
join3.start();
}
}
```
join() 方法等待執行緒死亡。 換句話說，它會導致當前執行的執行緒停止執行，直到它加入的執行緒完成其任務。
### 執行緒異常捕獲
由於執行緒的本質，使你不能捕獲從執行緒中逃逸的異常，一旦異常逃出任務的 run 方法，它就會向外傳播到控制檯，除非你採取特殊的步驟捕獲這種錯誤的異常，在 Java5 之前，你可以通過執行緒組來捕獲，但是在 Java 5 之後，就需要用 Executor 來解決問題，因為執行緒組不是一次好的嘗試。
下面的任務會在 run 方法的執行期間丟擲一個異常，並且這個異常會拋到 run 方法的外面，而且 main 方法無法對它進行捕獲
```java
public class ExceptionThread implements Runnable{
@Override
public void run() {
throw new RuntimeException();
}
public static void main(String[] args) {
try {
ExecutorService service = Executors.newCachedThreadPool();
service.execute(new ExceptionThread());
}catch (Exception e){
System.out.println("eeeee");
}
}
}
```
為了解決這個問題，我們需要修改 Executor 產生執行緒的方式，Java5 提供了一個新的介面 `Thread.UncaughtExceptionHandler` ，它允許你在每個 Thread 上都附著一個異常處理器。`Thread.UncaughtExceptionHandler.uncaughtException()` 會線上程因未捕獲臨近死亡時被呼叫。
```java
public class ExceptionThread2 implements Runnable{
@Override
public void run() {
Thread t = Thread.currentThread();
System.out.println("run() by " + t);
System.out.println("eh = " + t.getUncaughtExceptionHandler());
// 手動丟擲異常
throw new RuntimeException();
}
}
// 實現Thread.UncaughtExceptionHandler 介面，建立異常處理器
public class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler{
@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println("caught " + e);
}
}
public class HandlerThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable r) {
System.out.println(this + " creating new Thread");
Thread t = new Thread(r);
System.out.println("created " + t);
t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
System.out.println("ex = " + t.getUncaughtExceptionHandler());
return t;
}
}
public class CaptureUncaughtException {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool(new HandlerThreadFactory());
service.execute(new ExceptionThread2());
}
}
```
在程式中添加了額外的追蹤機制，用來驗證工廠建立的執行緒會傳遞給`UncaughtExceptionHandler`，你可以看到，未捕獲的異常是通過 `uncaughtException ` 來捕獲的。
你好，我是 cxuan，我自己手寫了四本 PDF，分別是 Java基礎總結、HTTP 核心總結、計算機基礎知識，作業系統核心總結，我已經整理成為 PDF，可以關注公眾號 Java建設者 回覆 PDF 領取優質資料。
