传统的线程技术中有两种创建线程的方式：一是继承Thread类，并重写run()方法；二是实现Runnable接口，覆盖接口中的run()方法，并把Runnable接口的实现扔给Thread。这两种方式大部分人可能都知道，但是为什么这样玩就可以呢？下面我们来详细分析一下这两种方法的来龙去脉。
1. 揭秘Thread中run() |
上面我们看到这两种方式都跟`run()`方法有关，所以我们来看一下`Thread`的源码中`run()`方法到底都干了什么：
```java
@Override
public void run() {
if (target != null) {
target.run();
}
}
```
我们可以看出，`run()`方法中很简单，只有一个`if`语句，如果target不为空就执行target的`run()`方法，否则什么也不干，那么这target到底是何方神圣呢？我们点击进去可以看到：
```java
private Runnable target;
```
原来target就是Runnable接口，我们再点进Runnable看看：
```java
@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。如下所示：
```java
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，传统的创建线程的两种方式就总结这么多~如有错误之处，欢迎留言指正~