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

传统的线程技术中有两种创建线程的方式：一是继承

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的[code]run()

方法，知道结论了，但是为啥呢？ [/code]

　　从面向对象的思想去考虑：上面一段代码其实是新new了一个对象（子对象）继承了Thread对象（父对象），在子对象里重写了父类的

run()

方法，父对象中扔了个Runnable进去，父对象中的

run()

方法就是最初的带有

if

判断的

run()

方法。
　　好了，现在执行

start()

后，肯定先在子类中找

run()

方法，找到了，父类的

run()

方法自然就被干掉了，所以会打印出Thread:，如果我们现在假设子类中没有重写

run()

方法，那么必然要去父类找

run()

方法，父类的

run()

方法中就得判断是否有Runnable传进来，现在有一个，所以执行Runnable中的

run()

方法，那么就会打印Runnable:出来。
传统的创建线程的两种方式就总结这么多

转自csdn eson_15