【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 {

/**
start() :
它的作用是启动一个新线程。
通过start()方法来启动的新线程，处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行相应线程的run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，run方法运行结束，此线程随即终止。start()不能被重复调用。用start方法来启动线程，真正实现了多线程运行，即无需等待某个线程的run方法体代码执行完毕就直接继续执行下面的代码。这里无需等待run方法执行完毕，即可继续执行下面的代码，即进行了线程切换。

run() :
run()就和普通的成员方法一样，可以被重复调用。
如果直接调用run方法，并不会启动新线程！程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到多线程的目的。
总结：
调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。
start() 可以启动一个新线程，run()不能
start()不能被重复调用，run()可以
start()中的run代码可以不执行完就继续执行下面的代码，即进行了线程切换。直接调用run方法必须等待其代码全部执行完才能继续执行下面的代码。
start() 实现了多线程，run()没有实现多线程。
* @param args
*/
public static void main(String[] args) {
// 1、继承Thread类
startThread();
}

private static void startThread(){
/********** 第一种方法：继承Thread类，覆写run()方法 **************/
Thread thread1 = new Thread(){

@Override
public void run() {
try {
Thread.sleep(500);//让线程休息500毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("继承Thread-线程:"+Thread.currentThread().getName());//打印出当前线程名
}
};
thread1.run(); // 当前线程执行方法,查看执行结果
thread1.start();//开启线程
}

}

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

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

实现

Runnable

接口，并实现

run()

方法；

调用

start()

方法开启线程。

public class TraditionalThread {

/**
start() :
它的作用是启动一个新线程。
通过start()方法来启动的新线程，处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行相应线程的run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，run方法运行结束，此线程随即终止。start()不能被重复调用。用start方法来启动线程，真正实现了多线程运行，即无需等待某个线程的run方法体代码执行完毕就直接继续执行下面的代码。这里无需等待run方法执行完毕，即可继续执行下面的代码，即进行了线程切换。

run() :
run()就和普通的成员方法一样，可以被重复调用。
如果直接调用run方法，并不会启动新线程！程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到多线程的目的。
总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。

* @param args
*/
public static void main(String[] args) {
// 1、继承Thread类
startThread();
// 2、实现Runnable接口
runableThread();
}

private static void startThread(){
/********** 第一种方法：继承Thread类，覆写run()方法 **************/
Thread thread1 = new Thread(){

@Override
public void run() {
try {
Thread.sleep(500);//让线程休息500毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("继承Thread-线程:"+Thread.currentThread().getName());//打印出当前线程名
}
};
thread1.run(); // 当前线程执行方法,查看执行结果
thread1.start();//开启线程
}

private static void runableThread(){
/********** 第二种方法：实现Runnable接口，扔给Thread **************/
Thread thread2 = new Thread(new Runnable() {

@Override
public void run() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("实现Runnable-线程:"+Thread.currentThread().getName());

}
});
thread2.run();
thread2.start();
}

}

4. 两种方式同时使用

既实现了Thread类中的

run()

方法，又给Thread扔了一个实现了

run()

方法的Runnable。如下所示：

/**
* 既实现了Thread类中的run()方法，又给Thread扔了一个实现了run()方法的Runnable
* @author wugong
* @date 2018/3/7 9:40
* @modify if true,please enter your name or update time
* @param
*/
private static void doubleThreadWay(){
//这哥们的代码写的比较给力
new Thread(new Runnable() {

@Override
public void run() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("double Runnable-线程:" + Thread.currentThread().getName());
}
}){

@Override
public void run() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("double 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:出来。