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

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

1. 揭秘Thread中run()

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

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

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

private Runnable target;

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

@FunctionalInterfacepublic 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，传统的创建线程的两种方式就总结这么多~

作者：云享专家倪升武

来源：微信公众号

原文链接：link