线程的创建 — Thread与Runnable详解

一、实现多线程的两种基本方式

1、继承Thread方式 & 实现Runnable方式

//1、继承Thread方式
public class MyThread extends Thread{
    ...
    @Override
    public void run(){
        ...
    }
}
​
MyThread mt = new MyThread();//创建线程
mt.start();//启动线程,调用的是父类Thread类的start()方法 
​
//2、实现Runnable方式
public class MyThread implements Runnable {
    ...
    @Override
    public void run() {
       ...
    }
}
​
MyThread mt2 = new MyThread();
Thread td =  new Thread(mt2);//创建线程
td.start();//启动线程，调用Thread的start()方法

两种方式都是创建Thread 或者 Thread子类，通过Thread的start()方法启动。

唯一不同的是：一种run()方法实现在Thread子类中；一种是把run()方法的逻辑转移到Runnable的实现类中。

一般使用Runnable方式：

1、Java语言是单继承的，通过实现接口的方式，可以让实现类去继承其他类。而直接继承Thread就不能再继承其他类了。

2、线程控制逻辑在Thread中，业务运行逻辑在Runnable中，解耦更为彻底。

二、Thread 与 Runnable 的关联

Runnable接口源码：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Thread类定义：

public class Thread implements Runnable {...}

Thread是Runnable接口的实现类。

Thread部分源码：

public class Thread implements Runnable {
    ...
    @Override
    public void run() {
        if (target != null) { //target是什么?  => 是Runnable类型的引用，也可以看做线程的执行单元，target为Thread类的成员变量
            target.run();//执行target的run()方法（执行：Runnable实现类的实例化对象的run()方法）
        }
    }
    ...
    /* What will be run. */
    private Runnable target;//要运行的任务。 何处赋值 ？ 构造函数的init()中进行赋值 
​
    public Thread(Runnable target) { //Thread有多个重载构造函数，此为其中之一
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    
    private void init(ThreadGroup g, Runnable target, String name,long stackSize) {
        init(g, target, name, stackSize, null, true);
    }
    
    private void init(ThreadGroup g, Runnable target, String name,long stackSize, AccessControlContext acc,boolean inheritThreadLocals) {
        ...
        this.target = target; //此处赋值
        ...
    }
}

无论我们采用哪种方式创建线程，都必须实现或重写run()方法！！且该run()方法都是实现Runnable接口中的方法。

Thread也是实现了Runnable接口，继承Thread类实现多线程，其实也相当于实现Runnable接口的run()方法。只不过此时，不需要再传入一个Thread类去启动，它自己已具备了thread的功能，自己就可以运转起来。

run()方法中就是我们的逻辑代码。

总结 ：

1、Runnable只是一个普通的接口。

2、Thread类实现了Runnable接口，并且实现了接口的run方法。

3、Thread类提供了重载的构造函数，接收Runnable类型的参数。

4、Thread类重写的run方法中，调用了构造函数传入的Runnable实现类（target）的run方法。

三、start ()与 run() 的关联

Thread start()源码

/*start()方法主要逻辑：
1、检查线程状态
2、将线程加入线程组
3、调用native方法start0()通知JVM启动一个新线程
4、如果启动失败，从线程组中删除该线程*/
​
public synchronized void start() {
       //1、判断线程状态，若线程状态不为“NEW”，则抛出异常
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
    
        group.add(this);//2、加入线程组
​
        boolean started = false;//线程是否已经启动，启动后设置成true
        try {
            start0();//3、调用该方法启动一个新线程
            started = true;
        } finally {
            try {
                if (!started) {//4、若启动失败，把线程从线程组中删除
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then it will be passed up the call stack */
            }
        }
    }
​
    //真正的启动线程的方法（native方法）
    private native void start0();

        start()方法最终调用的是start0()方法，并不是run()方法。

        start0()是一个native方法，是与其他语言交互的方式，同样也是java代码与虚拟机交互的方式。虚拟机是由C语言和汇编编写的。“是Java函数，为了与操作系统打交道”

        start0()中的逻辑会调用run()方法。

native方法的注册：

        Thread 类有个 registerNatives（）本地方法，该方法主要的作用就是注册一些本地方法供 Thread 类使用，如start0()，stop0() 等等，基本所有操作本地线程的本地方法都是由它注册的。

        这个方法放在一个 static 语句块中，当该类被加载到JVM 中的时候，它就会被调用，进而注册相应的本地方法。

        本地方法 registerNatives 是定义在 Thread.c 文件中的。Thread.c 是个很小的文件，它定义了各个操作系统平台都要用到的关于线程的公用数据和操作。

public class Thread implements Runnable {
    /* Make sure registerNatives is the first thing <clinit> does. */
    private static native void registerNatives(); //注册一些本地方法供Thread使用：所有操作本地线程的本地方法都是由它注册
    static {//当该类被加载到JVM时，就会被调用，进而注册相应的本地方法
        registerNatives();
    }
    ...
}

        对比：start方法为线程的启动做了一系列准备，再去通知JVM启动一个新线程；而run方法仅仅是一个普通方法，所以不能启动一个新线程。

四、总结

本质：实例化Thread，并提供执行的run()方法。