【併發技術01】傳統執行緒技術中建立執行緒的兩種方式

傳統的執行緒技術中有兩種建立執行緒的方式：一是繼承  Thread  類，並重寫  run ()  方法；二是實現  Runnable  介面，覆蓋介面中的  run ()  方法，並把  Runnable  介面的實現扔給  Thread 。這兩種方式大部分人可能都知道，但是為什麼這樣玩就可以呢？下面我們來詳細分析一下這兩種方法的來龍去脈。

1. 揭秘Thread中run()

上面我們看到這兩種方式都跟  run ()  方法有關，所以我們來看一下  Thread  的原始碼中  run ()  方法到底都幹了什麼：

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

我們可以看出，  run ()  方法中很簡單，只有一個  if  語句，如果 target 不為空就執行 target 的  run ()  方法，否則什麼也不幹，那麼這 target 到底是何方神聖呢？我們點選進去可以看到：

private Runnable target;

原來 target 就是 Runnable 介面，我們再點進 Runnable 看看：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Runnable 中就一個方法，也是  run ()  方法！好了，現在再回到 Thread 類的  run ()  方法中，如果 target 不為空，即實現了 Runnable 介面，也即實現了 Runnable 中的  run ()  方法，那麼我們就使用該介面中的  run ()  方法；如果 target 為空，即沒有實現 Runnable 介面，那我們什麼也不做，即執行緒建立後立馬就消失了。
所以到這裡，大家就明白了為什麼建立執行緒有上面兩種方式了。第一種：你不是要先進行  if  判斷麼？我現在不判斷了，我把你的  if  幹掉，我在  run ()  方法中自己寫程式碼，想幹啥就幹啥，即重寫 Thread 中的  run ()  方法，；第二種：你不是要先進行  if  判斷麼？行，給你一個 Runnable 介面讓你判斷，但你還是得呼叫我 Runnable 中的  run ()  方法啊，那我重寫我 Runnable 中的  run ()  方法不就行了！ 知道了來龍去脈後，下面就針對這兩種傳統的方式寫個例項。

2. 建立方式1：繼承 Thread 類

只要兩步即可建立並開啟一個執行緒：

• 繼承  Thread  類，並實現  run ()  方法；

• 呼叫  start ()  方法開啟執行緒。

由於只要實現一個  run ()  方法即可，所以我們可以使用 Java 中的匿名內部類來實現，如下：

public class TraditionalThread {
    public static void main(String[] args) {
    /********** 第一種方法：繼承Thread類，覆寫run()方法 **************/
    Thread thread1 = new Thread(){
        @Override
        public void run() {
            try {
                    Thread.sleep(500);//讓執行緒休息500毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());//列印出當前執行緒名
        }
    };
    thread1.start();//開啟執行緒
    }
}

3. 建立方式2：實現 Runnable 介面

只要兩步即可建立並開啟一個執行緒：

• 實現  Runnable  介面，並實現  run ()  方法；

• 呼叫  start ()  方法開啟執行緒。

由於只要實現一個  run ()  方法即可，所以我們也可以使用 Java 中的匿名內部類來實現，如下：

public class TraditionalThread {
    public static void main(String[] args) {
        /********** 第二種方法：實現Runnable介面，扔給Thread **************/
        Thread thread2 = new Thread(new Runnable() {        
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());           
            }
        });
        thread2.start();
    }
}

4. 兩種方式同時使用

如果有個哥們比較給力，他兩種方式同時使用了，即：既實現了 Thread 類中的  run ()  方法，又給 Thread 扔了一個實現了  run ()  方法的 Runnable。如下所示：

public class TraditionalThread {
    public static void main(String[] args) {
        //這哥們的程式碼寫的比較給力
        new Thread(new Runnable() { 
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Runnable:" + Thread.currentThread().getName());
            }
        }){
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread:" + Thread.currentThread().getName());
            }
        }.start();
    }
}

現在又會執行哪個呢？我們執行一下上面的程式就會發現，它會列印出 Thread 的資訊，所以執行的是 Thread 的  run ()  方法，知道結論了，但是為啥呢？
從物件導向的思想去考慮：上面一段程式碼其實是新 new 了一個物件（子物件）繼承了 Thread 物件（父物件），在子物件裡重寫了父類的  run ()  方法，父物件中扔了個 Runnable 進去，父物件中的  run ()  方法就是最初的帶有  if  判斷的  run ()  方法。
好了，現在執行  start ()  後，肯定先在子類中找  run ()  方法，找到了，父類的  run ()  方法自然就被幹掉了，所以會列印出 Thread:，如果我們現在假設子類中沒有重寫  run ()  方法，那麼必然要去父類找  run ()  方法，父類的  run ()  方法中就得判斷是否有 Runnable 傳進來，現在有一個，所以執行 Runnable 中的  run ()  方法，那麼就會列印 Runnable: 出來。
OK，傳統的建立執行緒的兩種方式就總結這麼多~

如果覺得對您有幫助，轉發給更多人吧~