提示：這是我學完執行緒的部分理解，對執行緒有興趣的小伙伴可以查看“JDK 11 API中文幫助檔案”，

JDK 11 API幫助檔案

提示：以下是本篇文章正文內容，下面案例可供參考

一、執行緒是什么？

Java 給多執行緒編程提供了內置的支持， 一條執行緒指的是行程中一個單一順序的控制流，一個行程中可以并發多個執行緒，每條執行緒并行執行不同的任務，

多執行緒是多任務的一種特別的形式，但多執行緒使用了更小的資源開銷，

這里定義和執行緒相關的另一個術語 - 行程：一個行程包括由作業系統分配的記憶體空間，包含一個或多個執行緒，一個執行緒不能獨立的存在，它必須是行程的一部分，一個行程一直運行，直到所有的非守護執行緒都結束運行后才能結束，

多執行緒能滿足程式員撰寫高效率的程式來達到充分利用 CPU 的目的，

執行緒是一個動態執行的程序，它也有一個從產生到死亡的程序，

二、使用步驟

1. 通過實作 Runnable 介面；
2. 通過繼承 Thread 類本身；
3. 通過 Callable 和 Future 創建執行緒，

1.Thread常用的方法

代碼如下（示例）：

1. Thread，在方法體上和類上需要繼承Tread父類，然后需要重寫父類的run（）方法，下面分別是用主方法實作的主執行緒和另一個類實作的子執行緒，

package Thread;
public class Main1 {
    public static void main(String[] args) throws InterruptedException {
        myThread m=new myThread();
        m.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("我是主方法!"+i);
            Thread.sleep(1000);
        }
    }
}

package Thread;

public class myThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我是子執行緒！"+i);
        }
    }
}

運行結果為： 主執行緒和子執行緒會交替運行，每次的運行的結果都不相同，

2.Runnbale介面的實作

代碼如下（示例）：

package Thread;

public class myRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我是Runnable方法"+i);
        }
    }
}

package Thread;

public class MainRunnable {
    public static void main(String[] args) {
        myRunnable m=new myRunnable();
        Thread m1=new Thread(m);
        m1.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("我是主方法!"+i);
        }
    }
}

運行結果和上面的Thread的運行結果一樣，都會交替執行，

3.通過 Callable 和 Future 創建執行緒

1. 創建 Callable 介面的實作類，并實作 call() 方法，該 call() 方法將作為執行緒執行體，并且有回傳值，

2. 創建 Callable 實作類的實體，使用 FutureTask 類來包裝 Callable 物件，該 FutureTask 物件封裝了該 Callable 物件的 call() 方法的回傳值，

3. 使用 FutureTask 物件作為 Thread 物件的 target 創建并啟動新執行緒，

4. 呼叫 FutureTask 物件的 get() 方法來獲得子執行緒執行結束后的回傳值，

4.對比Thread和Runnable

提示：這里對兩種實作進行總結：

繼承Thread父類和實作Runnable介面效果一樣，不過考慮到Java是單繼承多實作，如果只有一個子執行緒，兩種方法都可以，但是在后期實作的時候，可能會有多個執行緒一起執行，這個時候就需要實作Runable介面來實作，

5.安全問題

大家都知道執行緒會交替執行，但是其中就會出現一個新的問題，就是執行緒的安全問題，這樣才能保證執行緒有序并且按照我們的意愿去執行，這就需要一把“鎖”來實作，

原理為：需要一把公共的鎖，在一個執行緒執行的時候，把鎖給這個執行緒，同時其他的執行緒排隊等待執行執行緒解開鎖，注意：排隊是隨機的，不是先到先得，是按照優先級來獲取的，

下面用代碼來體現：賣票系統

package ThreadSafe;

public class Demo1 {
    public static void main(String[] args) {
       Runnable r=new myRunnable();
        //創建三個執行緒代表賣票的視窗
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }
    static  class  myRunnable implements  Runnable{
         private  Object o=new Object();//鎖
         private  int count=10;//票數
        //重寫run方法
        @Override
        public void run() {
               while (true){//用while回圈 一直回圈直到票被賣完
                   synchronized (o){//把鎖 o 傳入  代表誰執行誰拿到鎖
                       if(count>0){
                           System.out.println("準備賣票！");
                           try {
                               Thread.sleep(1000);//讓執行緒睡眠一秒   1秒=1000毫秒
                           } catch (InterruptedException e) {
                               e.printStackTrace();
                           }
                           count--;
                           System.out.println(Thread.currentThread().getName()+"正在賣票，余票為："+count);
                       }else {
                           break;
                       }
                   }
               }
        }
    }
}

這里是另一種實作方式：在方法上注明這個方法是鎖方法，public static synchronized boolean sale()效果也可以達到，

 /**
           * 賣票方法
           * @return
           */
        public static synchronized boolean sale() {

            if (count > 0) {
                System.out.println("準備賣票！");
                try {
                    Thread.sleep(1000);//讓執行緒睡眠一秒   1秒=1000毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                //Thread.currentThread().getName() ：得到當前執行執行緒的名字
                System.out.println(Thread.currentThread().getName() + "正在賣票，余票為：" + count);
                return true;
            }
            return false;

        }

三、執行緒池

執行緒池的優勢

（1）、降低系統資源消耗，通過重用已存在的執行緒，降低執行緒創建和銷毀造成的消耗；
（2）、提高系統回應速度，當有任務到達時，通過復用已存在的執行緒，無需等待新執行緒的創建便能立即執行；
（3）方便執行緒并發數的管控，因為執行緒若是無限制的創建，可能會導致記憶體占用過多而產生OOM，并且會造成cpu過度切換（cpu切換執行緒是有時間成本的（需要保持當前執行執行緒的現場，并恢復要執行執行緒的現場）），
（4）提供更強大的功能，延時定時執行緒池，

提供了四種執行緒方法

Executors類提供了4種不同的執行緒池：

• newCachedThreadPool—快取執行緒池
• newFixedThreadPool—定長執行緒池
• newScheduledThreadPool—周期執行緒執行緒池
• newSingleThreadExecutor–單執行緒執行緒池

總結

執行緒是非常重要的，同時對于的安全問題也是需要重視的，在創建多個執行緒時，盡量使用執行緒池來創建執行緒，如果考慮到多個執行緒，這個時候就必須需要用“鎖”來保護執行緒穩定，從而讓程式有序的走完，