一、创建多线程
1. 实现多线程
java 实现多线程的方式准确来说有两种（oracle官方文档说的）：
（1）实现 Runnable 接口， 重写run()函数，运行start()方法
代码演示：
/**
* 用Runnable方式创建线程
*/
public class RunnableStyle implements Runnable {
@Override
public void run() {
System.out.println("我是一个Runnable");
}
public static void main(String[] args) {
new Thread(new RunnableStyle()).start();
}
}
（2）继承 Thread 类，重写run()函数，运行start()方法
/**
* 用Thread方式创建线程
* 每个线程只能操作当前线程类的对象变量，耦合性太强
*/
public class ThreadStyle extends Thread {
@Override
public void run() {
System.out.println("我是一个 Thread");
}
public static void main(String[] args) {
new ThreadStyle().start();
}
}
2. 两种实现多线程方法的对比
方法1（实现Runnable接口）更好的三个优势：
（1）解耦性好，run方法业务与线程建立逻辑分离
表现1，这样创建不同的线程可以共享Runnable实例中的变量和方法，即多个线程可以操作同一资源，而Thread只能操作当前对象的业务,即每新建一个线程类，当前资源类变量都会初始化
代码实现区别
实现Runnable接口
/**
* 用Runnable方式创建线程
* 解耦，不同线程可以操作同一资源对象的变量，run业务与线程建立分离
*/
public class RunnableStyle implements Runnable {
private int count = 10;
@Override
public void run() {
count--;
System.out.println(Thread.currentThread().getName() + " : count=" + count);
}
public static void main(String[] args) throws InterruptedException {
RunnableStyle runnableStyle = new RunnableStyle();
new Thread(runnableStyle,"Runnable1").start();
Thread.sleep(1000);
new Thread(runnableStyle, "Runnable2").start();
}
}
Runnable1 : count=9
Runnable2 : count=8
继承Thread类
/**
* 用Thread方式创建线程
* 每个线程只能操共享当前线程类的对象变量，耦合性太强
*/
public class ThreadStyle extends Thread {
private int count = 10;
@Override
public void run() {
count--;
System.out.println(Thread.currentThread().getName() + " : count=" + count);
}
public static void main(String[] args) throws InterruptedException {
ThreadStyle thread1 = new ThreadStyle();
thread1.setName("Thread1");
thread1.start();
Thread.sleep(1000);
ThreadStyle thread2 = new ThreadStyle();
thread2.setName("Thread2");
thread2.start();
}
}
Thread1 : count=9
Thread2 : count=9
#### （2）节约资源，每次新建任务无需每次都新建线程，例如线程池类
使用继承Thread的方式的话，那么每次想新建一个任务，只能新建一个独立的线程，而这样做的损耗会比较大（比如重头开始创建一个线程、执行完毕以后再销毁等。如果线程的实际工作内容，也就是run()函数里只是简单的打印一行文字的话，那么可能线程的实际工作内容还不如损耗来的大）。如果使用Runnable的方式，只需要更换Runnable实例，不需要新建Thread类，就可以实现线程的重复利用，线程池就是基于这个原理，从而大大减小损耗。
#### （3）可扩展性好，可用实现多继承接口，不能实现多继承类
继承Thread类以后，由于Java语言不支持双继承，这样就无法再继承其他的类，限制了可扩展性。
### 3. 两种方法的本质对比
方法一和方法二，也就是“实现Runnable接口并传入Thread类”和“继承Thread类然后重写run()”在实现多线程的本质上，并没有区别，都是最终调用了start()方法来新建线程。这两个方法的最主要区别在于run()方法的内容来源：
```java
...
public class Thread implements Runnable {
private Runnable target;
...
@Override
public void run() {
if (target != null) {
target.run();
}
}
...
}
方法一：最终调用Runnable实例的run()方法（target.run()）;
方法二：直接将Thread类的里整个 run() 方法重写
4. 创建线程时同时使用Runnable、Thread两种方法会发生什么？
如果 同时使用Runnable、Thread两种方法，那么只会执行 Thread 中重写的 run()方法，因为将父类中的run方法覆盖了：
...
public class Thread implements Runnable {
private Runnable target;
...
// 该 run 方法直接被重写了，便不再会执行 target.run()方法了
@Override
public void run() {
if (target != null) {
target.run();
}
}
...
}
同时执行两种方式的测试：
/**
* 同时执行两种方式的测试
* 匿名内部类
*/
public class DoubleStyle {
public static void main(String[] args) {
new Thread(() -> {
System.out.println("我是 Runnable");
}) {
@Override
public void run() {
System.out.println("我是 Thread");
}
}.start();
}
}
执行结果：
我是 Thread 的 run方法
准确的讲，创建线程只有一种方式那就是构造Thread类，而实现线程的执行单元有两种方式：一是实现Runnable接口的run方法，并把Runnable实例传给Thread类，二是重写Thread的run方法（继承Thread类）
5. 其它创建线程的方式
其它创建线程的方式也有很多，但都是在代码的写法上的千变万化，本质上还是都基于 Thread 类和 Runnable 类的重写run()方法。比如以下几种方式：
（1）线程池创建线程
线程池本质上，是创建有限个线程排队处理多于线程数量的业务，为了节省创建和销毁线程的时间
本质上还是实现Runnable接口创建线程类
源码片段：
（2）通过Callable和FutureTask创建线程
Callable和FutureTask类同时继承了Future接口和Runnnable接口，本质还是实现Runnnable接口中的run方法
（3）定时器也可以创建线程
演示代码：
/**
* 描述： 定时器创建线程
*/
public class DemoTimmerTask {
public static void main(String[] args) {
Timer timer = new Timer();
timer.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}, 1000, 1000);
}
}
其中 TimerTask 又是实现了 Runnable 接口 的类。
所以，本质上，创建线程只有一种方式那就是构造Thread类，而实现线程的执行单元有两种方式：一是实现Runnable接口的run方法，并把Runnable实例传给Thread类，二是重写Thread的run方法（继承Thread类）。
二、启动多线程
1. start()和run()对比
代码测试：
public class StartAndRunMethod {
public static void main(String[] args) {
Runnable runnable = () -> {
System.out.println(Thread.currentThread().getName());
};
runnable.run();
new Thread(runnable).start();
}
}
测试结果：
main
Thread-0
可见 run() 只是在主线程中调用了 run 方法，没有启动子线程，这显然不符合我们开启新线程的预期；而 start() 启动了一个子线程，并调用了线程中的run方法。
下面就这两种方法进行解析：
2. start()方法
执行start方法是请求 JVM 开辟一个子线程，但线程具体什么时候开始执行，取决于CPU的调度，有可能立即执行，也有可能因为繁忙稍后执行或不执行。
start方法的执行流程：
检查线程状态，只有NEW状态下的线程才能继续，否则会抛出IllegalThreadStateException（在运行中或者已结束的线程，都不能再次启动）
加入线程组
调用 start0() 方法启动线程，这是一个 native 方法，用 c++ 写的。
注意点：
start方法是被synchronized修饰的方法，可以保证线程安全；
start()方法不能执行两次，因为会有“检查线程状态”这一步，见上图；
由JVM创建的main方法线程和system组线程，并不会通过start来启动。
3. run()方法
源码：
run()方法重写的两种方式：
实现Runnable接口，重写Runnable接口的run()方法，注入到Thread类，执行target.run()。
继承Thread类，重写Thread类中的run()，这时原run()中的if(target != null){ target.run(); }，这部分就会被覆盖重写。
文章来源：深度解析多线程的创建方式和正确启动多线程
微信公众号名称：Java知者
微信公众号id：JavaZhiZhe
欢迎关注，谢谢！