【并发技术01】传统线程技术中创建线程的两种方式

传统的线程技术中有两种创建线程的方式：一是继承 Thread 类，并重写 run() 方法；二是实现 Runnable 接口，覆盖接口中的 run() 方法，并把 Runnable 接口的实现扔给 Thread。这两种方式大部分人可能都知道，但是为什么这样玩就可以呢？下面我们来详细分析一下这两种方法的来龙去脉。

1. 揭秘Thread中run()

上面我们看到这两种方式都跟 run() 方法有关，所以我们来看一下 Thread 的源码中 run() 方法到底都干了什么：

1. @Override

2. public void run() {

3.    if (target != null) {

4.        target.run();

5.    }

6. }

我们可以看出， run() 方法中很简单，只有一个 if 语句，如果 target 不为空就执行 target 的 run() 方法，否则什么也不干，那么这 target 到底是何方神圣呢？我们点击进去可以看到：

1. private Runnable target;

原来 target 就是 Runnable 接口，我们再点进 Runnable 看看：

1. @FunctionalInterface

2. public interface Runnable {

3.    public abstract void run();

4. }

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 中的匿名内部类来实现，如下：

1. public class TraditionalThread {

2.    public static void main(String[] args) {

3.    /********** 第一种方法：继承Thread类，覆写run()方法 **************/

4.    Thread thread1 = new Thread(){

5.        @Override

6.        public void run() {

7.            try {

8.                    Thread.sleep(500);//让线程休息500毫秒

9.            } catch (InterruptedException e) {

10.                e.printStackTrace();

11.            }

12.            System.out.println(Thread.currentThread().getName());//打印出当前线程名

13.        }

14.    };

15.    thread1.start();//开启线程

16.    }

17. }

3. 创建方式2：实现 Runnable 接口

只要两步即可创建并开启一个线程：

• 实现 Runnable 接口，并实现 run() 方法；

• 调用 start() 方法开启线程。

由于只要实现一个 run() 方法即可，所以我们也可以使用 Java 中的匿名内部类来实现，如下：

1. public class TraditionalThread {

2.    public static void main(String[] args) {

3.        /********** 第二种方法：实现Runnable接口，扔给Thread **************/

4.        Thread thread2 = new Thread(new Runnable() {        

5.            @Override

6.            public void run() {

7.                try {

8.                    Thread.sleep(500);

9.                } catch (InterruptedException e) {

10.                    e.printStackTrace();

11.                }

12.                System.out.println(Thread.currentThread().getName());          

13.            }

14.        });

15.        thread2.start();

16.    }

17. }

4. 两种方式同时使用

如果有个哥们比较给力，他两种方式同时使用了，即：既实现了 Thread 类中的 run() 方法，又给 Thread 扔了一个实现了 run() 方法的 Runnable。如下所示：

1. public class TraditionalThread {

2.    public static void main(String[] args) {

3.        //这哥们的代码写的比较给力

4.        new Thread(new Runnable() {

5.            @Override

6.            public void run() {

7.                try {

8.                    Thread.sleep(500);

9.                } catch (InterruptedException e) {

10.                    e.printStackTrace();

11.                }

12.                System.out.println("Runnable:" + Thread.currentThread().getName());

13.            }

14.        }){

15.            @Override

16.            public void run() {

17.                try {

18.                    Thread.sleep(500);

19.                } catch (InterruptedException e) {

20.                    e.printStackTrace();

21.                }

22.                System.out.println("Thread:" + Thread.currentThread().getName());

23.            }

24.        }.start();

25.    }

26. }

现在又会执行哪个呢？我们运行一下上面的程序就会发现，它会打印出 Thread 的信息，所以运行的是 Thread 的 run() 方法，知道结论了，但是为啥呢？
从面向对象的思想去考虑：上面一段代码其实是新 new 了一个对象（子对象）继承了 Thread 对象（父对象），在子对象里重写了父类的 run() 方法，父对象中扔了个 Runnable 进去，父对象中的 run() 方法就是最初的带有 if 判断的 run() 方法。
好了，现在执行 start() 后，肯定先在子类中找 run() 方法，找到了，父类的 run() 方法自然就被干掉了，所以会打印出 Thread:，如果我们现在假设子类中没有重写 run() 方法，那么必然要去父类找 run() 方法，父类的 run() 方法中就得判断是否有 Runnable 传进来，现在有一个，所以执行 Runnable 中的 run() 方法，那么就会打印 Runnable: 出来。
OK，传统的创建线程的两种方式就总结这么多~

如果觉得对您有帮助，转发给更多人吧~