一、執行緒的基本概念

　　執行緒是行程中執行運算的最小單位，是行程中的一個物體，是被系統獨立調度和分派的基本單位，執行緒自己不擁有系統資源，只擁有一點在運行中必不可少的資源，但它可與同屬一個行程的其它執行緒共享行程所擁有的全部資源，一個執行緒可以創建和撤消另一個執行緒，同一行程中的多個執行緒之間可以并發執行，

好處 ：（1）易于調度，

（2）提高并發性，通過執行緒可方便有效地實作并發性，行程可創建多個執行緒來執行同一程式的不同部分，

（3）開銷少，創建執行緒比創建行程要快，所需開銷很少，，

（4）利于充分發揮多處理器的功能，通過創建多執行緒行程，每個執行緒在一個處理器上運行，從而實作應用程式的并發性，使每個處理器都得到充分運行

二、行程與執行緒

行程：每個行程都有獨立的代碼和資料空間（行程背景關系），行程間的切換會有較大的開銷，一個行程包含1--n個執行緒，（行程是資源分配的最小單位）

執行緒：同一類執行緒共享代碼和資料空間，每個執行緒有獨立的運行堆疊和程式計數器(PC)，執行緒切換開銷小，（執行緒是cpu調度的最小單位

執行緒和行程一樣分為五個階段：創建、就緒、運行、阻塞、終止，

多行程是指作業系統能同時運行多個任務（程式），

多執行緒是指在同一程式中有多個順序流在執行，

每個正在系統上運行的程式都是一個行程，每個行程包含一到多個執行緒，行程也可能是整個程式或者是部分程式的動態執行，執行緒是一組指令的集合，或者是程式的特殊段，它可以在程式里獨立執行，也可以把它理解為代碼運行的背景關系，所以執行緒基本上是輕量級的行程，它負責在單個程式里執行多任務，通常由作業系統負責多個執行緒的調度和執行，

在Java中，一個應用程式可以包含多個執行緒，每個執行緒執行特定的任務，并可與其他執行緒并發執行多執行緒使系統的空轉時間最少，提高CPU利用率、多執行緒編程環境用方便的模型隱藏CPU在任務間切換的事實在Java程式啟動時，一個執行緒立刻運行，該執行緒通常稱為程式的主執行緒，

主執行緒的重要性體現在兩個方面：

1、它是產生其他子執行緒的執行緒，

2、通常它必須最后完成執行，因為它執行各種關閉動作，

三、行程與執行緒的區別：

（1）調度：執行緒作為調度和分配的基本單位，行程作為擁有資源的基本單位

（2）并發性：不僅行程之間可以并發執行，同一個行程的多個執行緒之間也可并發執行

（3）擁有資源：行程是擁有資源的一個獨立單位，執行緒不擁有系統資源，但可以訪問隸屬于行程的資源.

（4）系統開銷：在創建或撤消行程時，由于系統都要為之分配和回收資源，導致系統的開銷明顯大于創建或撤消執行緒時的開銷，

四、同步和互斥的區別：

當有多個執行緒的時候，經常需要去同步這些執行緒以訪問同一個資料或資源，例如，假設有一個程式，其中一個執行緒用于把檔案讀到記憶體，而另一個執行緒用于統計檔案中的字符數，當然，在把整個檔案調入記憶體之前，統計它的計數是沒有意義的，但是，由于每個操作都有自己的執行緒，作業系統會把兩個執行緒當作是互不相干的任務分別執行，這樣就可能在沒有把整個檔案裝入記憶體時統計字數，為解決此問題，你必須使兩個執行緒同步作業，

所謂同步，是指散步在不同行程之間的若干程式片斷，它們的運行必須嚴格按照規定的某種先后次序來運行，這種先后次序依賴于要完成的特定的任務，如果用對資源的訪問來定義的話，同步是指在互斥的基礎上（大多數情況），通過其它機制實作訪問者對資源的有序訪問，在大多數情況下，同步已經實作了互斥，特別是所有寫入資源的情況必定是互斥的，少數情況是指可以允許多個訪問者同時訪問資源，

所謂互斥，是指散布在不同行程之間的若干程式片斷，當某個行程運行其中一個程式片段時，其它行程就不能運行它們之中的任一程式片段，只能等到該行程運行完這個程式片段后才可以運行，如果用對資源的訪問來定義的話，互斥某一資源同時只允許一個訪問者對其進行訪問，具有唯一性和排它性，但互斥無法限制訪問者對資源的訪問順序，即訪問是無序的，

五、行程間通信的方式？

（1）管道（pipe）及有名管道（named pipe）：管道可用于具有親緣關系的父子行程間的通信，有名管道除了具有管道所具有的功能外，它還允許無親緣關系行程間的通信，

（2）信號（signal）：信號是在軟體層次上對中斷機制的一種模擬，它是比較復雜的通信方式，用于通知行程有某事件發生，一個行程收到一個信號與處理器收到一個中斷請求效果上可以說是一致的，

（3）訊息佇列（message queue）：訊息佇列是訊息的鏈接表，它克服了上兩種通信方式中信號量有限的缺點，具有寫權限得行程可以按照一定得規則向訊息佇列中添加新資訊；對訊息佇列有讀權限得行程則可以從訊息佇列中讀取資訊，

（4）共享記憶體（shared memory）：可以說這是最有用的行程間通信方式，它使得多個行程可以訪問同一塊記憶體空間，不同行程可以及時看到對方行程中對共享記憶體中資料得更新，這種方式需要依靠某種同步操作，如互斥鎖和信號量等，

（5）信號量（semaphore）：主要作為行程之間及同一種行程的不同執行緒之間得同步和互斥手段，

（6）套接字（socket）：這是一種更為一般得行程間通信機制，它可用于網路中不同機器之間的行程間通信，應用非常廣泛，

六、行程和執行緒的關系：

　 （1）一個執行緒只能屬于一個行程，而一個行程可以有多個執行緒，但至少有一個執行緒，

（2）資源分配給行程，同一行程的所有執行緒共享該行程的所有資源，

（3）處理機分給執行緒，即真正在處理機上運行的是執行緒，

（4）執行緒在執行程序中，需要協作同步，不同行程的執行緒間要利用訊息通信的辦法實作同步，執行緒是指行程內的一個執行單元,也是行程內的可調度物體.

七、多執行緒的優點

• 使用執行緒可以把占據時間長的程式中的任務放到后臺去處理
• 用戶界面可以更加吸引人，這樣比如用戶點擊了一個按鈕去觸發某些事件的處理，可以彈出一個進度條來顯示處理的進度
• 程式的運行速度可能加快
• 在一些等待的任務實作上如用戶輸入、檔案讀寫和網路收發資料等，執行緒就比較有用了，在這種情況下可以釋放一些珍貴的資源如記憶體占用等等，
• 多執行緒技術在IOS軟體開發中也有舉足輕重的位置，

八、多執行緒的缺點

• 如果有大量的執行緒,會影響性能,因為作業系統需要在它們之間切換，
• 更多的執行緒需要更多的記憶體空間，
• 執行緒可能會給程式帶來更多“bug”，因此要小心使用，
• 執行緒的中止需要考慮其對程式運行的影響，
• 通常塊模型資料是在多個執行緒間共享的，需要防止執行緒死鎖情況的發生，

總結:

執行緒和行程的區別在于,子行程和父行程有不同的代碼和資料空間,而多個執行緒則共享資料空間,每個執行緒有自己的執行堆疊和程式計數器為其執行背景關系.多執行緒主要是為了節約CPU時間,發揮利用,根據具體情況而定. 執行緒的運行中需要使用計算機的記憶體資源和CPU，

執行緒是java獨有的嗎，作業系統本身有沒有執行緒？

當然有啦！

作業系統里面會有很多個程式，比如QQ，你打開QQ，QQ又會有很多個執行緒，所以，執行緒可不是java獨有的東西啊，

在JVM的設定中Java的執行緒和作業系統的執行緒是一一對應的：

Java如何開啟執行緒？ 方式1：繼承Thread類

告訴你這個秘密，Java開啟執行緒只有一種方式，就是Thread類的start方法！

JDK看似提供了很多和多執行緒相關的類，可實際上有且僅有Thread類能通過start0()方法向作業系統申請執行緒資源（本地方法），

下面我們演示一下如何用Java開啟一個執行緒，

public class MyThread extends Thread{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "執行了！");
    }


    public static void main(String[] args) {
        new MyThread().start();
    }
}

你也可以直接new一個Thread類，并且臨時重寫run方法（少寫一個類）

public static void main(String[] args) {
    //new MyThread().start();
    new Thread(){
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "執行了！");
        }
    }.start();
}

Java如何開啟執行緒？ 方式2：實作Runnable介面！（詳細講解）

這種方式的本質還是第一種，即Thread類實體呼叫start方法，從而去呼叫本地執行緒資源，因為有且僅有Thread類能通過start0()方法向作業系統申請執行緒資源（本地方法）！

?JVM對于作業系統來說就是一個程式，是一個行程，JVM行程中可以有很多個執行緒，我們呼叫start方法其實就是去申請這個執行緒資源，

Runnable介面：

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

看上面的注釋就知道怎么用了，當一個物件實作Runnable介面，你就去創建一個Thread，啟動這個Thread，會導致run方法被呼叫，

我們按照官方的指導來做：

public class MyThread02 implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "執行了！");
    }


    public static void main(String[] args) {
        new Thread(new MyThread02()).start();
    }
}

看到了吧，這種方式其實還是第一種，不同點在于，第一種方式是直接在Thread子類中重寫的Run方法，而這種方式是你自己弄個類，里面有個run方法，傳到Thread類中去，最后在Thread類啟動的時候，會去呼叫那個類的run方法，換句話說，如果沒有Thread類，這個Runnable實作類是沒法自己跑起來的，

所有的秘密就在Thread類的建構式里面，

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

調了init方法

private void init(ThreadGroup g, Runnable target, String name,long stackSize) {
    init(g, target, name, stackSize, null);
}

又是多載，繼續找：

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
    //省略其他代碼...
    this.target = target;
}

原來，傳入的Runnable物件是放到屬性target中了，

/* What will be run. */
private Runnable target;

我們再看下Thread類中的run方法：

@Override
public void run() {
   if (target != null) {
        target.run();
   }
}

如果是方式1，這個run方法被重寫了，啟動start方法的時候就直接呼叫那個被重寫后的run方法了，現在使用方式2的話，就還是呼叫Thread原生的run方法，做了一個中介，又去呼叫target的run方法，而target是我們自己傳進去的，相當于把具體run的邏輯寫到外部一個類里面去了，

以上就是第二種方式的原理，下面介紹一下如何簡寫代碼？

比如，我們可以直接把Runnable實作類用匿名的方式new出來（少些一個類）：

public static void main(String[] args) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "執行了！");
        }
    }).start();
}

因為Runnable介面只有一個抽象方法，所以還可以直接用Lamda運算式：

new Thread(() -> {
    System.out.println(Thread.currentThread().getName() + "執行了！");
}).start();

如果還不明白原理，可以看下這張圖，安排的明明白白啦，

Java如何開啟執行緒？ 方式3：用執行緒池Executor

什么是執行緒池： java.util.concurrent.Executors 提供了一個 java.util.concurrent.Executor 介面的實作用于創建執行緒池，

一個執行緒池包括以下四個基本組成部分：
1、執行緒池管理器（ThreadPool）：用于創建并管理執行緒池，包括 創建執行緒池，銷毀執行緒池，添加新任務；
2、作業執行緒（PoolWorker）：執行緒池中執行緒，在沒有任務時處于等待狀態，可以回圈的執行任務；
3、任務介面（Task）：每個任務必須實作的介面，以供作業執行緒調度任務的執行，它主要規定了任務的入口，任務執行完后的收尾作業，任務的執行狀態等；
4、任務佇列（taskQueue）：用于存放沒有處理的任務，提供一種緩沖機制，

執行緒池的作用：

執行緒池作用就是限制系統中執行執行緒的數量，
根據系統的環境情況，可以自動或手動設定執行緒數量，達到運行的最佳效果；少了浪費了系統資源，多了造成系統擁擠效率不高，用執行緒池控制執行緒數量，其他執行緒排隊等候，一個任務執行完畢，再從佇列的中取最前面的任務開始執行，若佇列中沒有等待行程，執行緒池的這一資源處于等待，當一個新任務需要運行時，如果執行緒池中有等待的作業執行緒，就可以開始運行了；否則進入等待佇列，

為什么要用執行緒池:

1.減少了創建和銷毀執行緒的次數，每個作業執行緒都可以被重復利用，可執行多個任務，

2.可以根據系統的承受能力，調整執行緒池中作業線執行緒的數目，防止因為消耗過多的記憶體，而把服務器累趴下(每個執行緒需要大約1MB記憶體，執行緒開的越多，消耗的記憶體也就越大，最后死機)，

Java里面執行緒池的頂級介面是Executor，但是嚴格意義上講Executor并不是一個執行緒池，而只是一個執行執行緒的工具，真正的執行緒池介面是ExecutorService，

要配置一個執行緒池是比較復雜的，尤其是對于執行緒池的原理不是很清楚的情況下，很有可能配置的執行緒池不是較優的，因此在Executors類里面提供了一些靜態工廠，生成一些常用的執行緒池，

1. newSingleThreadExecutor

創建一個單執行緒的執行緒池，這個執行緒池只有一個執行緒在作業，也就是相當于單執行緒串行執行所有任務，如果這個唯一的執行緒因為例外結束，那么會有一個新的執行緒來替代它，此執行緒池保證所有任務的執行順序按照任務的提交順序執行，

2.newFixedThreadPool

創建固定大小的執行緒池，每次提交一個任務就創建一個執行緒，直到執行緒達到執行緒池的最大大小，執行緒池的大小一旦達到最大值就會保持不變，如果某個執行緒因為執行例外而結束，那么執行緒池會補充一個新執行緒，

3. newCachedThreadPool

創建一個可快取的執行緒池，如果執行緒池的大小超過了處理任務所需要的執行緒，

那么就會回收部分空閑（60秒不執行任務）的執行緒，當任務數增加時，此執行緒池又可以智能的添加新執行緒來處理任務，此執行緒池不會對執行緒池大小做限制，執行緒池大小完全依賴于作業系統（或者說JVM）能夠創建的最大執行緒大小，

4.newScheduledThreadPool

創建一個大小無限的執行緒池，此執行緒池支持定時以及周期性執行任務的需求，

為了方便演示，我們就創建只有一個執行緒的執行緒池：

package com.javaxbfs.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MyThread03 implements Runnable{

    public static void main(String[] args) throws InterruptedException {
        //創建執行緒池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //提交執行緒任務-Runnable物件
        Future<?> future = executorService.submit(new MyThread03());

        while(!future.isDone()){
           Thread.sleep(200);
        }

        // 關閉執行緒池
        executorService.shutdown();
        System.out.println("執行緒池關閉");
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "========>正在執行！");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "========>執行成功！");
    }
}

效果：

pool-1-thread-1========>正在執行！
pool-1-thread-1========>執行成功！
執行緒池關閉

這邊我們使用的是Runnable物件，執行緒池還可以接受Callable物件，

package com.javaxbfs.thread;

import java.util.concurrent.*;

public class MyThread04 implements Callable {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //創建執行緒池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //提交執行緒任務-Runnable物件
        Future<String> future = executorService.submit(new MyThread04());

        while(!future.isDone()){
           Thread.sleep(200);
        }
        String result = future.get();
        System.out.println("這里拿到執行緒任務的回傳值：" + result);
        // 關閉執行緒池
        executorService.shutdown();
        System.out.println("執行緒池關閉");
    }

    @Override
    public String call() {
        System.out.println(Thread.currentThread().getName() + "========>正在執行！");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "========>執行成功！");
        return "SUCCESS";
    }
}

效果：

pool-1-thread-1========>正在執行！
pool-1-thread-1========>執行成功！
這里拿到執行緒任務的回傳值：SUCCESS
執行緒池關閉

兩種方式我都寫了例子，關于這個后面還會細說，

總結

1. 不管你是用上面介紹的三種方法的哪一種，都繞不開Thread類，因為只有Thread類的start方法可以去申請本地執行緒資源！

2. 用Runnable可以把任務代碼寫在Thread類外面，降低耦合度，更加靈活，

3.Callable一般配合執行緒池使用，重寫的call方法可以添加回傳值，

4.執行緒執行入口永遠是Thread類的run方法，這個run方法要么被你重寫，要么呼叫target的run方法，target就是實作runnable介面的物件，

封裝Thread類的start方法（經典技巧）

Thread類的start方法是去請求本地資源的，很多原始碼喜歡把這個細節封裝掉，現在讓我們來模仿一下這種技巧，

package com.javaxbfs.thread;

public class MyThread05 implements Runnable{

    public void begin(){
        new Thread(this).start();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "執行了！");
    }


    public static void main(String[] args) {
        MyThread05 myThread05 = new MyThread05();
        myThread05.begin();
    }
}

思路特別簡單，不需要你手動去new Thread類了，而是直接在Runnable類中添加begin方法，把這個事情給做了，