深度解析多线程的创建方式和正确启动多线程（多线程）

一、创建多线程

Java 实现多线程的方式准确来说有两种（oracle官方文档说的）：

代码演示：

/***用Runnable方式创建线程*/publicclassRunnableStyleimplementsRunnable{@Overridepublicvoidrun(){System.out.println("我是一个Runnable");}publicstaticvoidmain(String[]args){newThread(newRunnableStyle()).start();}}

/***用Thread方式创建线程*每个线程只能操作当前线程类的对象变量，耦合性太强*/publicclassThreadStyleextendsThread{@Overridepublicvoidrun(){System.out.println("我是一个thread");}publicstaticvoidmain(String[]args){newThreadStyle().start();}}

方法1（实现Runnable接口）更好的三个优势：

表现1，这样创建不同的线程可以共享Runnable实例中的变量和方法，即多个线程可以操作同一资源，而Thread只能操作当前对象的业务,即每新建一个线程类，当前资源类变量都会初始化
代码实现区别
/***用Runnable方式创建线程*解耦，不同线程可以操作同一资源对象的变量，run业务与线程建立分离*/publicclassRunnableStyleimplementsRunnable{privateintcount=10;@Overridepublicvoidrun(){count--;System.out.println(Thread.currentThread().getName() ":count=" count);}publicstaticvoidmain(String[]args)throwsInterruptedException{RunnableStylerunnableStyle=newRunnableStyle();newThread(runnableStyle,"Runnable1").start();Thread.sleep(1000);newThread(runnableStyle,"Runnable2").start();}}
Runnable1:count=9Runnable2:count=8
/***用Thread方式创建线程*每个线程只能操共享当前线程类的对象变量，耦合性太强*/publicclassThreadStyleextendsThread{privateintcount=10;@Overridepublicvoidrun(){count--;System.out.println(Thread.currentThread().getName() ":count=" count);}publicstaticvoidmain(String[]args)throwsInterruptedException{ThreadStylethread1=newThreadStyle();thread1.setName("Thread1");thread1.start();Thread.sleep(1000);ThreadStylethread2=newThreadStyle();thread2.setName("Thread2");thread2.start();}}
Thread1:count=9Thread2:count=9

继承Thread类
实现Runnable接口

####（2）节约资源，每次新建任务无需每次都新建线程，例如线程池类使用继承Thread的方式的话，那么每次想新建一个任务，只能新建一个独立的线程，而这样做的损耗会比较大（比如重头开始创建一个线程、执行完毕以后再销毁等。如果线程的实际工作内容，也就是run()函数里只是简单的打印一行文字的话，那么可能线程的实际工作内容还不如损耗来的大）。如果使用Runnable的方式，只需要更换Runnable实例，不需要新建Thread类，就可以实现线程的重复利用，线程池就是基于这个原理，从而大大减小损耗。####（3）可扩展性好，可用实现多继承接口，不能实现多继承类继承Thread类以后，由于Java语言不支持双继承，这样就无法再继承其他的类，限制了可扩展性。###3.两种方法的本质对比方法一和方法二，也就是“实现Runnable接口并传入Thread类”和“继承Thread类然后重写run()”在实现多线程的本质上，并没有区别，都是最终调用了start()方法来新建线程。这两个方法的最主要区别在于run()方法的内容来源：```java...publicclassThreadimplementsRunnable{privateRunnabletarget;...@Overridepublicvoidrun(){if(target!=null){target.run();}}...}

方法一：最终调用Runnable实例的run()方法（target.run()）;

方法二：直接将Thread类的里整个 run() 方法重写

如果同时使用Runnable、Thread两种方法，那么只会执行 Thread 中重写的 run()方法，因为将父类中的run方法覆盖了：

...publicclassThreadimplementsRunnable{privateRunnabletarget;...//该run方法直接被重写了，便不再会执行target.run()方法了@Overridepublicvoidrun(){if(target!=null){target.run();}}...}

同时执行两种方式的测试：

/***同时执行两种方式的测试*匿名内部类*/publicclassDoubleStyle{publicstaticvoidmain(String[]args){newThread(()->{System.out.println("我是Runnable");}){@Overridepublicvoidrun(){System.out.println("我是Thread");}}.start();}}

执行结果：

我是Thread的run方法

准确的讲，创建线程只有一种方式那就是构造Thread类，而实现线程的执行单元有两种方式：一是实现Runnable接口的run方法，并把Runnable实例传给Thread类，二是重写Thread的run方法（继承Thread类）

其它创建线程的方式也有很多，但都是在代码的写法上的千变万化，本质上还是都基于 Thread 类和 Runnable 类的重写run()方法。比如以下几种方式：

线程池本质上，是创建有限个线程排队处理多于线程数量的业务，为了节省创建和销毁线程的时间
本质上还是实现Runnable接口创建线程类
源码片段：

Callable和FutureTask类同时继承了Future接口和Runnnable接口，本质还是实现Runnnable接口中的run方法

演示代码：

/***描述：定时器创建线程*/publicclassDemoTimmerTask{publicstaticvoidmain(String[]args){Timertimer=newTimer();timer.scheduleAtFixedRate(newTimerTask(){@Overridepublicvoidrun(){System.out.println(Thread.currentThread().getName());}},1000,1000);}}

其中 TimerTask 又是实现了 Runnable 接口的类。

所以，本质上，创建线程只有一种方式那就是构造Thread类，而实现线程的执行单元有两种方式：一是实现Runnable接口的run方法，并把Runnable实例传给Thread类，二是重写Thread的run方法（继承Thread类）。

代码测试：

publicclassStartAndRunMethod{publicstaticvoidmain(String[]args){Runnablerunnable=()->{System.out.println(Thread.currentThread().getName());};runnable.run();newThread(runnable).start();}}

测试结果：

mainThread-0

可见 run() 只是在主线程中调用了 run 方法，没有启动子线程，这显然不符合我们开启新线程的预期；而 start() 启动了一个子线程，并调用了线程中的run方法。

下面就这两种方法进行解析：

执行start方法是请求 JVM 开辟一个子线程，但线程具体什么时候开始执行，取决于CPU的调度，有可能立即执行，也有可能因为繁忙稍后执行或不执行。

start方法的执行流程：