（一）Thread类实现了Runnable接口吗？
在线程使用过程中，我们肯定会用到Runnable与Thread，前者的实现方式是实现其接口即可，后者的实现方式是继承其类。两者实现方式带来最明显的区别就是，由于Java不允许多继承，因此实现了Runnable接口可以再继承其他类，但是Thread明显不可以。
我们看看源码中对与Thread类的部分声明
public class Thread implements Runnable {
/* Make sure registerNatives is the first thing <clinit> does. */
private static native void registerNatives();
static {
registerNatives();
}
private volatile String name;
...
Thread 类是实现了Runnable接口的。
（二）实现多线程的两种方法
第一种方法：继承Thread类
方法步骤总结：
- 定义一个类继承Thread；
- 重写Thread类中的run方法，将需要被多线程执行的代码存储到该run方法当中。
- 建立Thread类的子类创建线程对象。
- 直接调用子类从Thread类继承的start方法，开启一个线程（调用该线程的run方法）。
第二种方法：实现Runable接口
Thread类有一个Thread(Runnable target)构造方法，在Runable接口类中只有一个run()方法。
当使用Thread(Runnable target)方法创建线程对象时，需要为该方法传递一个实现 Runnable接口的对象，这样创建的线程将调用那个实现了Runnable接口类对象中的run()方法作为其运行代码，而不再是调用Thread类中的run方法了。
方法步骤总结：
- 定义一个类实现Runnable接口，覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中；
- 通过Thread类建立线程对象，将Runnable接口的子类实例对象作为实际参数传递给Thread类的构造方法。
Thread readerThread = new Thread(new IncomingReader());
readerThread.start();
class IncomingReader implements Runnable{
...
}
两种方式区别
- 继承Thread: 线程代码存放Thread子类run方法中，且该run方法被调用。
- 实现Runnable：线程代码存在实现了Runnable类接口的对象的run方法中，且该run方法被调用。
注意：启动一个新的线程，不是直接调用Thread子类的对象的run方法，而是调用Thread子类对象的start方法。
start方法是从Thread类中继承的方法，Thread类对象的start方法将产生一个新的线程，并在该线程上运行该Thread类对象中的run方法。
根据面向对象的多态性可知，在该线程上实际运行的是我们编写的那个类（Thread的子类）对象中的run方法。
（三）Runnable和Thread比较
如上所述，Runnable相比Thread存在明显的优点，同时也是两者最大的区别。这点就不再做阐述，这里对于网络很多文章中存在的明显的错误文字总结进行一下论证：
Runnable可以实现多个相同的程序代码的线程去共享同一个资源，而Thread不可以？
我们以实际的代码样例来论证这个观点：
package test;
/**
* Thread 实现资源共享
* @author itbird
*
*/
public class Test2 {
public static void main(String[] args) {
MyThread t1 = new MyThread();
new Thread(t1, "线程1").start();
new Thread(t1, "线程2").start();
}
public static class MyThread extends Thread {
private int total = 10;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (this) {
if (total > 0) {
try {
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + "卖票---->" + (this.total--));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}
Thread实现共享同一个资源
package test;
/**
* Runnable 实现资源共享
* @author itbird
*
*/
public class Test3 {
public static void main(String[] args) {
MyRunable t1 = new MyRunable();
new Thread(t1, "线程1").start();
new Thread(t1, "线程2").start();
}
public static class MyRunable implements Runnable {
private int total = 10;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (this) {
if (total > 0) {
try {
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + "卖票---->" + (this.total--));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}
Runnable实现共享同一个资源
经过实际样例代码编写以及运行结果对比，我们知道很多人说的Thread类不能共享资源，其实并不是不能，只是不适合
其实我们从Thread源码中也可以看到，当以Thread方式去实现资源共享时，实际上源码内部是将thread向下转型为了Runnable，实际上内部依然是以Runnable形式去实现的资源共享
（四）Runnable为什么不可以直接run
多线程原理：相当于玩游戏机，只有一个游戏机（cpu），可是有很多人要玩，于是，start是排队！等CPU选中你就是轮到你，你就run（），当CPU的运行的时间片执行完，这个线程就继续排队，等待下一次的run（）。
调用start（）后，线程会被放到等待队列，等待CPU调度，并不一定要马上开始执行，只是将这个线程置于可动行状态。然后通过JVM，线程Thread会调用run（）方法，执行本线程的线程体。先调用start后调用run，这么麻烦，为了不直接调用run？就是为了实现多线程的优点，没这个start不行。
- start（）方法来启动线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码；通过调用Thread类的start()方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行。 然后通过此Thread类调用方法run()来完成其运行操作的， 这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程
- run（）方法当作普通方法的方式调用。程序还是要顺序执行，要等待run方法体执行完毕后，才可继续执行下面的代码； 程序中只有主线程——这一个线程， 其程序执行路径还是只有一条， 这样就没有达到写线程的目的
解释到这里，相信各位看官心里有种“了然大明白”的感觉，runnable其实相对于一个task，并不具有线程的概念，如果你直接去调用runnable的run，其实就是相当于直接在主线程中执行了一个函数而已，并未开启线程去执行，所以显而易见，如果你在代码中直接通过这种方式run了一个runnable，明显您的程序的主线程就直接悲催了，各种资源不足现象的崩溃日志会接踵而至，而且遇到这种问题的时候，如果没有一定的研发经验和坚持，很有可能采取错误的解决策略。
标签：Runnable,run,Thread,start,线程,方法,比较 From： https://www.cnblogs.com/imreW/p/17369637.html