一.多執行緒

1.1多執行緒概述

????在了解學習多執行緒之前，我們先要熟悉了解幾個關于多執行緒有關的概念，
行程：行程指正在運行的程式，確切的來說，當一個程式進入記憶體運行，即變成一個行程，行程是處于運行程序中的程式，并且具有一定獨立功能，

執行緒：執行緒是行程中的一個執行單元，負責當前行程中程式的執行，一個行程中至少有一個執行緒，一個行程中是可以有多個執行緒的，這個應用程式也可以稱之為多執行緒程式，

????簡而言之：一個程式運行后至少有一個行程，一個行程中可以包含多個執行緒，什么是多執行緒呢？ 多執行緒定義:在一個程式中,這些獨立運行的程式片段叫作“執行緒”，即就是一個程式中有多個執行緒在同時執行，

????我們可以通程序式執行流程，來區分單執行緒程式與多執行緒程式的不同：
單執行緒程式：即，若有多個任務只能依次執行，當上一個任務執行結束后，下一個任務開始執行，如接水，有一個水龍頭，一個人接完，下一個人才能開始接水，
多執行緒程式：即，若有多個任務可以同時執行，如在飲水機處接水，溫水處與熱水處可以同時放水，

1.2 程式運行原理

分時調度：所有執行緒輪流使用 CPU 的使用權，平均分配每個執行緒占用 CPU 的時間，分時調度可以在分時調度類中公平地分布處理資源，內核的其他部分可以在短時間內獨占處理器，而不會縮短用戶察覺的回應時間，在Java中可以設定一個或多個行程的優先級級別，優先級的級別范圍通常為 0 到 +10（不指定的話，java默認創建為5），值越低，優先級越高，
搶占式調度：這里有必要說明一下，搶占式調度是實時調度的一種，優先讓優先級高的執行緒使用 CPU，如果執行緒的優先級相同，那么會隨機選擇一個(執行緒隨機性)，Java使用的為搶占式調度，

1.2.1 搶占式調度詳解

????現在大部分電腦作業系統都支持多行程并發運行，即支持多個軟體同時運行，比如打開了微信，并且同時聽著某易音樂，然后在CSDN上撰寫分享博客，“感覺上，這些運用在同時進行，”實際上，CPU(中央處理器)使用搶占式調度模式在多個執行緒間進行著高速的切換（針對于某一個核來說），我們根本就沒有察覺到，對于CPU的一個核而言，某個時刻，只能執行一個執行緒，而 CPU的在多個執行緒間切換速度相對我們的感覺要快，看上去就是在同一時刻運行，所以，仔細想想就會發現，多執行緒程式并不能提高程式的運行速度，但能夠提高程式運行效率，讓CPU的使用率更高，

1.3 主執行緒

????再來看看我們最開始之前，學習常用的場景，當我們在dos命令列中輸入java空格類名回車后，啟動JVM，并且加載對應的class檔案，虛擬機并會從main方法開始執行我們的程式代碼，一直把main方法的代碼執行完成，如果在執行程序遇到回圈時間比較長的代碼，那么在回圈之后的其他代碼是不會被馬上執行的，如下代碼演示：

class Demo{
	String name;
	Demo(String name){	
		this.name = name;
	}

	void show() {
		for (int i=1;i<=10000 ;i++ ) {
			System.out.println("name="+name+",i="+i);
		}
	}
}
class ThreadDemo {
	public static void main(String[] args) {
    	Demo demo = new Demo("CSDN");
		Demo demo2 = new Demo("NDSC");
		demo.show();
		demo2.show();
	}
}

????若在上述代碼中show方法中的回圈執行次數很多，這時在demo.show();下面的代碼是不會馬上執行的，并且在dos視窗會看到不停的輸出name=CSDN,i=++，這樣的陳述句，是因為：jvm啟動后，必然有一個執行路徑(執行緒)從main方法開始的，一直執行到main方法結束，這個執行緒在java中稱之為主執行緒，當程式的主執行緒執行時，如果遇到了回圈而導致程式在指定位置停留時間過長，則無法馬上執行下面的程式，需要等待回圈結束后能夠執行，
????那么，能否實作一個主執行緒負責執行其中一個回圈，再由另一個執行緒負責其他代碼的執行，最終實作多部分代碼同時執行的效果？當然可以，Java中的多執行緒技術能夠實作同時執行，

1.4 Thread類

????該如何創建執行緒呢？通過API中搜索，查到Thread類，通過閱讀Thread類中的描述，我們能夠了解到Thread是程式中的執行執行緒，并且Java 虛擬機是支持并允許應用程式并發地運行多個執行執行緒，
構造方法

常用方法

1.5 創建執行緒

????創建新執行執行緒有兩種方法，
繼承Thread：將類宣告為 Thread 的子類，該子類應重寫 Thread 類的 run 方法，創建物件，開啟執行緒，run方法相當于其他執行緒的main方法，
繼承Thread創建執行緒的步驟：
1 定義一個類繼承Thread，
2 重寫run方法，
3 創建子類物件，就是創建執行緒物件，
4 呼叫start方法，開啟執行緒并讓執行緒執行，此時jvm會去呼叫run方法，

實作Runnable：宣告一個實作 Runnable 介面的類，該類會實作 run 方法，然后創建Runnable的子類物件，傳入到某個執行緒的構造方法中，開啟執行緒，

main

//測驗類
public class Demo {
	public static void main(String[] args) {
		ThreadDemo td = new ThreadDemo("執行緒Demo！");
		//開啟新執行緒
		td.start();
		//在主方法中執行for回圈
		for (int i = 0; i < 10; i++) {
			System.out.println("main執行緒！"+i);
		}
	}
}

新建執行緒類

//新建執行緒類
public class ThreadDemo extends ThreadDemo {
	public ThreadDemo (String name) {
	//呼叫父類的String引數的構造方法，指定執行緒的名稱
		super(name);
	}
	//重寫run方法
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName()+"：正在執行！"+i);
		}
	}
}

1.5.1 run()與start()

注意：執行緒物件呼叫 run方法和呼叫start方法區別？
????在理解這個問題之前，我們應該清楚什么是run()方法，什么是start()方法；
run()：就是繼承Thread類，或者實作runnable要實作的方法，本質上是一個成員函式，但并不是多執行緒的方式，就是一個普通的方法，我們從原始碼就能看出就是簡單的普通方法的呼叫，
run()原始碼

    @Override
    public void run() {
     // 簡單的運行，不會新起執行緒，target 是 Runnable
        if (target != null) {
            target.run();
        }
    }

start()：要理解start方法，我們最好從原始碼入手，start 方法的原始碼也沒幾行代碼，注釋也比較詳細，最主要的是 start0() 方法，
start()原始碼

public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
     // 沒有初始化，拋出例外
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);
	// 是否啟動的識別符號
    boolean started = false;
    try {
     // start0() 是啟動多執行緒的關鍵
     // 這里會創建一個新的執行緒，是一個 native 方法
     // 執行完成之后，新的執行緒已經在運行了
        start0();
        // 主執行緒執行
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

start0()原始碼

private native void start0();

????start0()的原始碼只有一行，為了方便理解start執行程序以及日后的學習，總結了start0的每一步呼叫執行程序，

• Step1:：start0方法實際上呼叫的是jvm.cpp檔案的JVM_StartThread方法，（是否創建執行緒，以及能否創建執行緒，比如記憶體已滿，無法繼續創建新的執行緒，都是在這一步進行判斷的）；
• Step2：如果能創建，則呼叫JavaThread方法創建執行緒（包括初始化相關變數），就在創建執行緒的時候，傳入了java_start,做為執行緒運行函式的初始地址；
• Step3：當子執行緒完成初始化之后，父執行緒會執行Thread::start方法，設定執行緒狀態為RUNNABLE；
• Step4：這時候子執行緒就可以開始執行thread->run()方法了，
  

????補充：start0為什么會被標記成native本地方法，眾所周知，Java其最大的優點之一就是跨平臺性，start() 方法呼叫 start0() 方法后，該執行緒并不一定會立馬執行，只是將執行緒變成了可運行狀態（NEW —> RUNNABLE），具體什么時候執行，取決于 CPU ，由 CPU 統一調度，可以在不同系統上運行，每個系統的 CPU 調度演算法不一樣，所以就需要做不同的處理，這件事情就只能交給 JVM 來實作了，start0() 方法自然就表標記成了 native，
????所以綜上，執行緒物件呼叫run方法不開啟執行緒，僅是物件呼叫方法，執行緒物件呼叫start開啟執行緒，并讓jvm呼叫run方法在開啟的執行緒中執行，

1.5.2 繼承Thread類原理

????我們為什么要繼承Thread類，并呼叫其的start方法才能開啟執行緒呢？繼承Thread類：因為Thread類用來描述執行緒，具備執行緒應該有的功能，那為什么不直接創建Thread類的物件呢？如下代碼：

Thread t1 = new Thread();
//這樣做沒有錯，但是該start呼叫的是Thread類中的run方法
//這個run方法沒有做什么事情，更重要的是這個run方法中并沒有定義我們需要讓執行緒執行的代碼，
t1.start();

????創建執行緒是為了建立程式單獨的執行路徑，讓多部分代碼實作同時執行，也就是說執行緒創建并執行需要給定執行緒要執行的任務，對于之前所講的主執行緒，它的任務定義在main函式中，自定義執行緒需要執行的任務都定義在run方法中，Thread類run方法中的任務并不是我們所需要的，只有重寫這個run方法，既然Thread類已經定義了執行緒任務的撰寫位置（run方法），那么只要在撰寫位置（run方法）中定義任務代碼即可，所以進行了重寫run方法動作，

1.5.3 多執行緒的記憶體圖解

????多執行緒執行時，在記憶體中的運行方式其實很簡單：多執行緒執行時，在堆疊記憶體中，其實每一個執行執行緒都有一片自己所屬的堆疊記憶體空間，進行方法的壓堆疊和彈堆疊，當執行執行緒的任務結束了，執行緒自動在堆疊記憶體中釋放了，但是當所有的執行執行緒都結束了，那么行程就結束了，

1.5.4 獲取執行緒名稱

????開啟的執行緒都會有自己的獨立運行堆疊記憶體，而這些執行緒都是有其默認的名字的，當然也可以自定義執行緒名，根據Thread類的API檔案整理如下，

class MyThread extends Thread { 
   MyThread(String name){
   	super(name);
   }
   //復寫其中的run方法
   public void run(){
   	for (int i=1;i<=100 ;i++ ){
   		System.out.println(Thread.currentThread().getName()+",i="+i);
   	}
   }
}

class ThreadDemo {
   public static void main(String[] args) {
   	//創建兩個執行緒任務
   	MyThread d = new MyThread();
   	MyThread d2 = new MyThread();
   	//沒有開啟新執行緒, 在主執行緒呼叫run方法
   	d.run();
   	//開啟一個新執行緒，新執行緒呼叫run方法
   	d2.start();
   }
}

????通過結果觀察，原來主執行緒的名稱：main；自定義的執行緒：Thread-0，執行緒多個時，數字順延，如Thread-1…注意：進行多執行緒編程時，不要忘記了Java程式運行是從主執行緒開始，main方法就是主執行緒的執行緒執行內容，

1.6 創建執行緒方式—實作Runnable介面

????創建執行緒的另一種方法是宣告實作 Runnable 介面的類，該類然后實作 run 方法，然后創建Runnable的子類物件，傳入到某個執行緒的構造方法中，開啟執行緒，查看Runnable介面說明檔案：Runnable介面用來指定每個執行緒要執行的任務，包含了一個 run 的無引數抽象方法，需要由介面實作類重寫該方法，
實作Runnable介面，創建執行緒的步驟：

• 1、定義類實作Runnable介面，
• 2、覆寫介面中的run方法，，
• 3、創建Thread類的物件
• 4、將Runnable介面的子類物件作為引數傳遞給Thread類的建構式，
• 5、呼叫Thread類的start方法開啟執行緒，

示例

public class RunnableDemo {
	public static void main(String[] args) {
		//創建執行緒執行目標類物件
		Runnable runnable = new MyRunnable();
		//將Runnable介面的子類物件作為引數傳遞給Thread類的建構式
		Thread thread = new Thread(runn);
		Thread thread2 = new Thread(runn);
		//開啟執行緒
		thread.start();
		thread2.start();
		for (int i = 0; i < 10; i++) {
			System.out.println("main執行緒：正在執行！"+i);
		}
	}
}

執行緒執行類示例

public class MyRunnable implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("執行緒！"+i);
		}
	}
}

1.6.1 Runnable的優點

????第二種方式實作Runnable介面避免了單繼承的局限性，所以較為常用，實現Runnable介面的方式，更加的符合面向物件，執行緒分為兩部分，一部分執行緒物件，一部分執行緒任務，繼承Thread類，執行緒物件和執行緒任務耦合在一起，一旦創建Thread類的子類物件，既是執行緒物件，有又有執行緒任務，實作runnable介面，將執行緒任務單獨分離出來封裝成物件，型別就是Runnable介面型別，Runnable介面對執行緒物件和執行緒任務進行解耦，

1.7 執行緒的匿名內部類使用

????使用執行緒的內匿名內部類方式，可以方便的實作每個執行緒執行不同的執行緒任務操作，

• 方式1：創建執行緒物件時，直接重寫Thread類中的run方法

new Thread() {
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+ ">>>>" + i);
		}
	}
}.start();

• 方式2：使用匿名內部類的方式實作Runnable介面，重新Runnable介面中的run方法

Runnable runnable = new Runnable() {
	public void run() {
		for (int i = 0; i < 100; 1x++) {
			System.out.println(Thread.currentThread().getName()+ ">>>>" + i);
		}
	}
};
new Thread(runnable ).start();

二、執行緒池

2.1 執行緒池概念

????執行緒池，其實就是一個容納多個執行緒的容器，其中的執行緒可以反復使用，省去了頻繁創建執行緒物件的操作，無需反復創建執行緒而消耗過多資源，
????在java中，如果每個請求到達就創建一個新執行緒，開銷是相當大的，在實際使用中，創建和銷毀執行緒花費的時間和消耗的系統資源都相當大，甚至可能要比在處理實際的用戶請求的時間和資源要多的多，除了創建和銷毀執行緒的開銷之外，活動的執行緒也需要消耗系統資源，如果在一個jvm里創建太多的執行緒，可能會使系統由于過度消耗記憶體或“切換過度”而導致系統資源不足，為了防止資源不足，需要采取一些辦法來限制任何給定時刻處理的請求數目，盡可能減少創建和銷毀執行緒的次數，特別是一些資源耗費比較大的執行緒的創建和銷毀，盡量利用已有物件來進行服務，
????執行緒池主要用來解決執行緒生命周期開銷問題和資源不足問題，通過對多個任務重復使用執行緒，執行緒創建的開銷就被分攤到了多個任務上了，而且由于在請求到達時執行緒已經存在，所以消除了執行緒創建所帶來的延遲，這樣，就可以立即為請求服務，使用應用程式回應更快，另外，通過適當的調整執行緒中的執行緒數目可以防止出現資源不足的情況，

2.2 使用執行緒池方式–Runnable介面

????通常，執行緒池都是通過執行緒池工廠創建，再呼叫執行緒池中的方法獲取執行緒，再通過執行緒去執行任務方法，
Executors：執行緒池創建工廠類

• public static ExecutorService newFixedThreadPool(int nThreads)：回傳執行緒池物件
• ExecutorService：執行緒池類
• Future<?> submit(Runnable task)：獲取執行緒池中的某一個執行緒物件，并執行
• Future介面：用來記錄執行緒任務執行完畢后產生的結果，執行緒池創建與使用

使用執行緒池中執行緒物件的步驟，代碼示例：

public class ThreadPoolDemo {
	public static void main(String[] args) {
	//創建執行緒池，包含10個執行緒
	ExecutorService service = Executors.newFixedThreadPool(10);
	RunnableDemo rd = new RunnableDemo ();
	//從執行緒池中獲取執行緒物件,然后呼叫RunnableDemo 中的run()
	service.submit(rd);
	//注意：submit方法呼叫結束后，程式并不終止，是因為執行緒池控制了執行緒的關閉，將使用完的執行緒又歸還到了執行緒池中
	//關閉執行緒池
	//service.shutdown();
	}
}

Runnable介面實作類

public class RunnableDemo implements Runnable {
	@Override
	public void run() {
		System.out.println("執行緒示例啟動");
		System.out.println("執行緒： " +Thread.currentThread().getName());
		System.out.println("執行緒關閉"+Thread.currentThread().getName());
	}
}

2.3 使用執行緒池方式—Callable介面

lCallable介面：與Runnable介面功能相似，用來指定執行緒的任務，其中的call()方法，用來回傳執行緒任務執行完畢后的結果，call方法可拋出例外，

• Future submit(Callable task)：獲取執行緒池中的某一個執行緒物件，并執行執行緒中的call()方法
• Future介面：用來記錄執行緒任務執行完畢后產生的結果，
  代碼示例：

public class ThreadPoolDemo {
	public static void main(String[] args) {
		//創建執行緒池,包含10個執行緒
		ExecutorService service = Executors.newFixedThreadPool(2);//包含2個執行緒物件
		//創建Callable物件
		CallableDemo cd = new CallableDemo ();
		service.submit(c);
		service.submit(c);		
	}
}

Callable介面實作類,call方法可拋出例外、回傳執行緒任務執行完畢后的結果

public class CallableDemo implements Callable {
@Override
public Object call() throws Exception {
	System.out.println("執行緒示例:call");
	System.out.println("執行緒： " +Thread.currentThread().getName());
	System.out.println("執行緒結束："+Thread.currentThread().getName());
	return null;
	}
}