前言

按照今年的学习计划，并发学习是一个关键内容，之前参考过很多讲Java并发的书籍，感觉国内的相关数据，讲的好的好像并不多，学了一些后来觉得甚是枯燥，没有相关实例就放弃了，但是没有针对这些进行总结，这次打算从头归零，从头开始学习，并做好总结。之前的并发总结文档过于混乱，已将其置为私密。这次的学习几乎参考了所有Java并发编程的书籍

实现多线程的方法

如果说对Java多线程稍微有一点了解的大佬，针对Java中实现多线程的方式有几种这个问题很熟悉，之前网上也讨论过很多，到底有几种实现多线程的方式，有的说1种，有的说2种，有的说4种。百度一下也答案各异

到底有几种实现多线程的方式，这个还是需要好好说道说道

正确答案——2种，这个是基于Oracle官网的结果，既然官网给出的答案是两种，我们就不要再被各种3种，4种，6种这种花里胡哨的结果给误导了，给出一张官网的截图。

有两种方法可以创建新的执行线程，一种是继承Thread类，另一种是实现Runnable接口，这是官网给的答案。

实现Runnable接口

/**
 * autor:liman
 * createtime:2021/9/7
 * comment:runnable创建线程
 */
@Slf4j
public class RunnableStyle implements Runnable {

    public static void main(String[] args) {
        //将当前实现了Runnable接口的类交给Thread
        Thread thread = new Thread(new RunnableStyle());
        thread.start();
    }

    @Override
    public void run() {
        log.info("用runnable的方式实现线程");
    }
}

继承Thread类

/**
 * autor:liman
 * createtime:2021/9/7
 * comment:继承thread创建线程
 */
@Slf4j
public class ThreadStyle extends Thread{

    public static void main(String[] args) {
        //使用的是Thread不带任何参数的构造函数
        Thread thread = new ThreadStyle();
        thread.start();
    }
    @Override
    public void run() {
        log.info("继承Thread类的方式实现线程");
    }
}

两种方式的对比

一般推荐使用Runnable接口的方式创建线程。主要原因有以下几点：

1、从架构的角度来考虑，Runnable中的逻辑只是具体的实现，而Thread类中其实还做了线程的启动，暂停等操作。具体的实现应该需要独立出来，所以实现Runnable接口从某种层度上来说是解耦了。

2、继承Thread类，每次如果想新建一个任务，其实就是重新新建一个线程，即使很多线程执行的逻辑一样，也都是重新建立一个线程，这样CPU的性能损耗是很大的，而实现Runnable接口则不同，实现了Runnable接口可以利用线程池等工具，一定程度上降低这种损耗。

3、Java不支持多继承，如果一个类继承了Thread类，则无法再继承其他类，这在一定程度上限制了其可扩展性。

综合上述原因考虑，推荐采用实现Runnable接口。

关于Thread类中run方法的源码如下：

/**
 * If this thread was constructed using a separate
 * <code>Runnable</code> run object, then that
 * <code>Runnable</code> object's <code>run</code> method is called;
 * otherwise, this method does nothing and returns.
 * <p>
 * Subclasses of <code>Thread</code> should override this method.
 *
 * @see     #start()
 * @see     #stop()
 * @see     #Thread(ThreadGroup, Runnable, String)
 */
@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

其实run方法中底层调用的是target的run，而这个target其实就是一个Runnable接口类型的。会在构造函数的时候被传入，当我们实现Runnable接口启动线程的时候，实质是传入了一个Runnable接口的引用。采用实现Runnable接口的方式，Thread最终会执行target.run()方法，而我们集成Thread类，则是覆盖了Thread类中的整个run方法。

可以通过如下实例说明这一问题

/**
 * autor:liman
 * createtime:2021/9/7
 * comment:同时使用两种方式实现线程
 */
@Slf4j
public class BothRunnableThread  {

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("这是Runnable方式创建的线程");
            }
        }){
            //由于本身的run方法被重写过，因此通过runnable对象创建的时候，父类Thread中的run方法已经被重写了,这里是重写run方法
            @Override
            public void run() {
                System.out.println("这是继承Thread创建的线程");//输出这一行
            }
        }.start();
    }
}

重写了run方法之后，并不会执行Runnable接口中的逻辑。

到这里，如果后续遇到Java中正常有几种这种问题，我们可以如下回答:

Java中创建线程的方式通常我们可以分为两类，Oracle官网也是这么介绍的。准确的讲，创建线程只有一种方式，就是构造Thread类，而实现线程的执行单元有两种方式：

1、实现Runnable接口的run方法，并把Runnable实例传递给Thread类。

2、重写Thread的run方法（继承Thread类）

至于网上说的其他实现线程的方式，都只不过是在这些方法的基础上，代码的写法不同，或者通过各种各样类的包装而成的，本质与上面两者并没有什么不同。

启动线程的方法

启动线程其实比较简单并不复杂，正确的就是调用start方法，但是还是深入到原理进行一个小小的总结。

正确启动线程的方法

正确的方式，当然是调用Thread中的start方法，即可启动线程，关于start的源码，内容如下：

/**
 * Causes this thread to begin execution; the Java Virtual Machine
 * calls the <code>run</code> method of this thread.
 * <p>
 * The result is that two threads are running concurrently: the
 * current thread (which returns from the call to the
 * <code>start</code> method) and the other thread (which executes its
 * <code>run</code> method).
 * <p>
 * It is never legal to start a thread more than once.
 * In particular, a thread may not be restarted once it has completed
 * execution.
 *
 * @exception  IllegalThreadStateException  if the thread was already
 *               started.
 * @see        #run()
 * @see        #stop()
 */
public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

可以看到，其最先判断的，就是线程状态，之后将其加入到一个线程组中，然后调用一个native的start0方法，只有调用这个方法，才会让线程经历所有的生命状态周期，如果直接调用run方法，线程是不会经历所有的线程生命周期的。

错误启动线程的方法

1、不能直接调用Runnable的run方法，如果直接调用run方法，则会当成一个普通方法进行执行

/**
 * autor:liman
 * createtime:2021/9/8
 * comment:对比start和run两种启动线程的方式
 */
@Slf4j
public class StartAndRunMethod {

    public static void main(String[] args) {
        //初始化一个Runnable
        Runnable runnable = ()->{
            log.info("当前线程的线程名为:{}",Thread.currentThread().getName());
        };
        //直接调用run方法，会当成一个普通方式执行
        runnable.run();

        //单独启动一个线程
        new Thread(runnable).start();
    }
}

运行结果：

可以看到，同一行代码，直接调用run和调用start输出的并不一样

2、start方法不能重复调用，因为线程状态已经改变

/**
 * autor:liman
 * createtime:2021/10/7
 * comment:启动两次的线程
 */
@Slf4j
public class StartTwiceDemo {

    public static void main(String[] args) {
        Thread thread = new Thread();
        thread.start();
        thread.start();
    }
    
}

线程状态已经改变，重复调用start会抛错

总结

线程学习的开篇，只是总结到线程正常的启动方法。