拉勾教育详细分析Java中实现多线程的方法有几种
详细分析 Java 中实现多线程的方法有几种?(从本质上出发)
正确的说法(从本质上出发),拉勾IT课小编为大家分析，实现多线程的方法，以及如何应用线程代码。
• 实现多线程的正确方法: 2 种。
• Oracle 的文档说明
• 方法小结
o 方法一: 实现 Runnable 接口。
o 方法二: 继承 Thread 类。
• 代码示例
• /**
• * <p>
• * 实现 Runnable 接口的方式创建线程
• * </p>
• *
• * @author 踏雪彡寻梅
• * @version 1.0
• * @date 2020/9/7 - 00:34
• * @since JDK1.8
• */
• public class RunnableStyle implements Runnable {
• @Override
• public void run() {
• System.out.println("用 Runnable 方式实现线程~~~");
• }
•
• public static void main(String[] args) {
• Thread thread = new Thread(new RunnableStyle());
• thread.start();
• }
• }
• /**
• * <p>
• * 继承 Thread 类的方式创建线程
• * </p>
• *
• * @author 踏雪彡寻梅
• * @version 1.0
• * @date 2020/9/7 - 00:37
• * @since JDK1.8
• */
• public class ThreadStyle extends Thread {
• @Override
• public void run() {
• System.out.println("用 Thread 方式实现线程~~~");
• }
•
• public static void main(String[] args) {
• new ThreadStyle().start();
• }
• }
• 两种方式的对比
o 方法一（实现 Runnable 接口）更好。
o 方法二的缺点:
1. 从代码的架构去考虑，具体执行的任务也就是 run 方法中的内容，它应该和线程的创建、运行的机制也就是 Thread 类是解耦的。所以不应该把他们混为一谈。从解耦的角度，方法一更好。
2. 该方法每次如果想新建一个任务，只能去新建一个独立的线程，而新建一个独立的线程这样的损耗是比较大的，它需要去创建、然后执行，执行完了还要销毁；而如果使用 Runnable 接口的方式，我们就可以利用线程池之类的工具，利用这些工具就可以大大减小这些创建线程、销毁线程所带来的损耗。所以方法一相比于方法二的这一点，好在资源的节约上。
3. 继承了 Thread 类之后，由于 Java 不支持双继承，那么这个类就无法继承其他的类了，这大大限制了我们的可扩展性。
• 两种方式的本质区别
o 方法一: 终调用 target.run; ，通过以下两图可以知道使用这个方法时实际上是传递了一个 target 对象，执行了这个对象的 run 方法。
o 方法二: run() 整个都被重写。一旦子类重写了父类的方法，原有方法会被覆盖被抛弃，即以下代码不会被这次调用所采纳。
o 综上，两种方法都是执行了 run 方法，只不过 run 方法的来源不同。
• 同时使用两种方法会怎样?
o 代码演示
o /**
o * <p>
o * 同时使用 Runnable 和 Thread 两种实现线程的方式
o * </p>
o *
o * @author 踏雪彡寻梅
o * @version 1.0
o * @date 2020/9/7 - 22:38
o * @since JDK1.8
o */
o @SuppressWarnings("all")
o public class BothRunnableThread {
o public static void main(String[] args) {
o new Thread(new Runnable() {
o @Override
o public void run() {
o System.out.println("我来自 Runnable。。。");
o }
o }) {
o @Override
o public void run() {
o System.out.println("我来自 Thread。。。");
o }
o }.start();
o }
o }
o 运行结果
o 分析
1. 首先创建了一个匿名内部类 Thread。传入了一个 Runnable 对象。
2. 然后重写了 Thread 的 run 方法。后启动线程。
3. 因为重写了 Thread 的 run 方法，所以它父类的 run 方法就被覆盖掉了，所以即便传入了 Runnable 对象也不会执行它。
• 总结
o 从以上的分析中，准确的讲创建线程只有一种方式那就是构造 Thread 类，而实现线程的执行单元有两种方式（run 方法的两种不同实现情况）。
方法一: 实现 Runnable 接口的 run 方法，并把 Runnable 实例传给 Thread 类，再让 Thread 类去执行这个 run 方法。
方法二: 重写 Thread 的 run 方法（继承 Thread 类）。
经典错误说法(从本质上出发)
1. ”线程池创建线程也算是一种新建线程的方式。“
o 线程池创建线程代码示例
o import java.uti***ncurrent.ExecutorService;
o import java.uti***ncurrent.Executors;
o
o /**
o * <p>
o * 线程池创建线程的方法
o * </p>
o *
o * @author 踏雪彡寻梅
o * @version 1.0
o * @date 2020/9/7 - 23:05
o * @since JDK1.8
o */
o public class ThreadPools {
o public static void main(String[] args) {
o ExecutorService executorService = Executors.newCachedThreadPool();
o for (int i = 0; i < 1000; i++) {
o // 添加任务
o executorService.submit(new Task() {});
o }
o }
o }
o
o class Task implements Runnable {
o @Override
o public void run() {
o try {
o Thread.sleep(500);
o } catch (Exception e) {
o e.printStackTrace();
o }
o System.out.println(Thread.currentThread().getName());
o }
o }
o 线程池创建线程源码(DefaultThreadFactory 中)
o 分析
通过线程池中的源码，可以知道线程池创建线程的方式本质上也是通过构造 Thread 的方式创建的。所以线程池创建线程的本质和上文中是一样的。所以不能简单的认为线程池也是一种新的创建线程的方式。
2. ”通过 Callable 和 FutureTask 创建线程，也算是一种新建线程的方式。“
o 类图展示
o 分析
从类图中可以知道这两个创建线程的本质也是和之前的一样的。
3. ”无返回值是实现 Runnable 接口，有返回值是实现 Callable 接口，所以 Callable 是新的实现线程的方式。“
o 和第 2 点差不多。
4. 定时器是新的实现线程的方式。
o 定时器实现线程代码示例
o import java.util.Timer;
o import java.util.TimerTask;
o
o /**
o * <p>
o * 定时器创建线程
o * </p>
o *
o * @author 踏雪彡寻梅
o * @version 1.0
o * @date 2020/9/7 - 23:48
o * @since JDK1.8
o */
o public class DemoTimmerTask {
o public static void main(String[] args) {
o Timer timer = new Timer();
o timer.scheduleAtFixedRate(new TimerTask() {
o @Override
o public void run() {
o System.out.println(Thread.currentThread().getName());
o }
o }, 1000, 1000);
o }
o }
o 分析
和前面几点一样，定时器创建线程的方法终本质也离不开上文中的那两类方法。
5. 匿名内部类和 Lambda 表达式的方式创建线程是新的创建线程方式。
o 实际上也和前面几点一样是一个表面现象，本质上还是那两种方法。
o 使用方式代码示例
o /**
o * <p>
o * 匿名内部类创建线程
o * </p>
o *
o * @author 踏雪彡寻梅
o * @version 1.0
o * @date 2020/9/7 - 23:54
o * @since JDK1.8
o */
o public class AnonymousInnerClassDemo {
o public static void main(String[] args) {
o // 种
o new Thread() {
o @Override
o public void run() {
o System.out.println(Thread.currentThread().getName());
o }
o }.start();
o
o // 第二种
o new Thread(new Runnable() {
o @Override
o public void run() {
o System.out.println(Thread.currentThread().getName());
o }
o }).start();
o }
o }
o /**
o * <p>
o * Lambda 表达式创建线程
o * </p>
o *
o * @author 踏雪彡寻梅
o * @version 1.0
o * @date 2020/9/7 - 23:58
o * @since JDK1.8
o */
o public class LambdaDemo {
o public static void main(String[] args) {
o new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
o }
o }
o 运行结果
• 总结
o 多线程的实现方式，在代码中写法千变万化，但其本质万变不离其宗。
常见面试问题
• 有多少种实现线程的方法?思路有 5 点。
o 从不同的角度看，会有不同的答案。
o 典型答案是两种。这两种方式的对比。
o 从原理来看，两种本质都是一样的（都是实现 run 方法）。
o 具体展开说其他方式（代码的实现上的不同方式，原理还是基于那两个本质）。
o 将以上几点做结论。
• 实现 Runnable 接口和继承 Thread 类哪种方式更好?
o 从代码架构角度。（应该去解耦，两件事情：1.具体的任务即 run 方法中的内容；2.和线程生命周期相关的如创建线程、运行线程、销毁线程即 Thread 类去做的事情）
o 新建线程的损耗的角度。（继承 Thread 类，需要新建线程、执行完之后还要销毁，实现 Runnable 接口的方式可以反复的利用同一个线程，比如线程池就是这么做的，用于线程生命周期的损耗就减少了）
o Java 不支持多继承的角度。（对于扩展性而言）
正确的说法(从本质上出发),拉勾IT课小编为大家分析，实现多线程的方法，以及如何应用线程代码。
• 实现多线程的正确方法: 2 种。
• Oracle 的文档说明
• 方法小结
o 方法一: 实现 Runnable 接口。
o 方法二: 继承 Thread 类。
• 代码示例
• /**
• * <p>
• * 实现 Runnable 接口的方式创建线程
• * </p>
• *
• * @author 踏雪彡寻梅
• * @version 1.0
• * @date 2020/9/7 - 00:34
• * @since JDK1.8
• */
• public class RunnableStyle implements Runnable {
• @Override
• public void run() {
• System.out.println("用 Runnable 方式实现线程~~~");
• }
•
• public static void main(String[] args) {
• Thread thread = new Thread(new RunnableStyle());
• thread.start();
• }
• }
• /**
• * <p>
• * 继承 Thread 类的方式创建线程
• * </p>
• *
• * @author 踏雪彡寻梅
• * @version 1.0
• * @date 2020/9/7 - 00:37
• * @since JDK1.8
• */
• public class ThreadStyle extends Thread {
• @Override
• public void run() {
• System.out.println("用 Thread 方式实现线程~~~");
• }
•
• public static void main(String[] args) {
• new ThreadStyle().start();
• }
• }
• 两种方式的对比
o 方法一（实现 Runnable 接口）更好。
o 方法二的缺点:
1. 从代码的架构去考虑，具体执行的任务也就是 run 方法中的内容，它应该和线程的创建、运行的机制也就是 Thread 类是解耦的。所以不应该把他们混为一谈。从解耦的角度，方法一更好。
2. 该方法每次如果想新建一个任务，只能去新建一个独立的线程，而新建一个独立的线程这样的损耗是比较大的，它需要去创建、然后执行，执行完了还要销毁；而如果使用 Runnable 接口的方式，我们就可以利用线程池之类的工具，利用这些工具就可以大大减小这些创建线程、销毁线程所带来的损耗。所以方法一相比于方法二的这一点，好在资源的节约上。
3. 继承了 Thread 类之后，由于 Java 不支持双继承，那么这个类就无法继承其他的类了，这大大限制了我们的可扩展性。
• 两种方式的本质区别
o 方法一: 终调用 target.run; ，通过以下两图可以知道使用这个方法时实际上是传递了一个 target 对象，执行了这个对象的 run 方法。
o 方法二: run() 整个都被重写。一旦子类重写了父类的方法，原有方法会被覆盖被抛弃，即以下代码不会被这次调用所采纳。
o 综上，两种方法都是执行了 run 方法，只不过 run 方法的来源不同。
• 同时使用两种方法会怎样?
o 代码演示
o /**
o * <p>
o * 同时使用 Runnable 和 Thread 两种实现线程的方式
o * </p>
o *
o * @author 踏雪彡寻梅
o * @version 1.0
o * @date 2020/9/7 - 22:38
o * @since JDK1.8
o */
o @SuppressWarnings("all")
o public class BothRunnableThread {
o public static void main(String[] args) {
o new Thread(new Runnable() {
o @Override
o public void run() {
o System.out.println("我来自 Runnable。。。");
o }
o }) {
o @Override
o public void run() {
o System.out.println("我来自 Thread。。。");
o }
o }.start();
o }
o }
o 运行结果
o 分析
1. 首先创建了一个匿名内部类 Thread。传入了一个 Runnable 对象。
2. 然后重写了 Thread 的 run 方法。后启动线程。
3. 因为重写了 Thread 的 run 方法，所以它父类的 run 方法就被覆盖掉了，所以即便传入了 Runnable 对象也不会执行它。
• 总结
o 从以上的分析中，准确的讲创建线程只有一种方式那就是构造 Thread 类，而实现线程的执行单元有两种方式（run 方法的两种不同实现情况）。
方法一: 实现 Runnable 接口的 run 方法，并把 Runnable 实例传给 Thread 类，再让 Thread 类去执行这个 run 方法。
方法二: 重写 Thread 的 run 方法（继承 Thread 类）。
经典错误说法(从本质上出发)
1. ”线程池创建线程也算是一种新建线程的方式。“
o 线程池创建线程代码示例
o import java.uti***ncurrent.ExecutorService;
o import java.uti***ncurrent.Executors;
o
o /**
o * <p>
o * 线程池创建线程的方法
o * </p>
o *
o * @author 踏雪彡寻梅
o * @version 1.0
o * @date 2020/9/7 - 23:05
o * @since JDK1.8
o */
o public class ThreadPools {
o public static void main(String[] args) {
o ExecutorService executorService = Executors.newCachedThreadPool();
o for (int i = 0; i < 1000; i++) {
o // 添加任务
o executorService.submit(new Task() {});
o }
o }
o }
o
o class Task implements Runnable {
o @Override
o public void run() {
o try {
o Thread.sleep(500);
o } catch (Exception e) {
o e.printStackTrace();
o }
o System.out.println(Thread.currentThread().getName());
o }
o }
o 线程池创建线程源码(DefaultThreadFactory 中)
o 分析
通过线程池中的源码，可以知道线程池创建线程的方式本质上也是通过构造 Thread 的方式创建的。所以线程池创建线程的本质和上文中是一样的。所以不能简单的认为线程池也是一种新的创建线程的方式。
2. ”通过 Callable 和 FutureTask 创建线程，也算是一种新建线程的方式。“
o 类图展示
o 分析
从类图中可以知道这两个创建线程的本质也是和之前的一样的。
3. ”无返回值是实现 Runnable 接口，有返回值是实现 Callable 接口，所以 Callable 是新的实现线程的方式。“
o 和第 2 点差不多。
4. 定时器是新的实现线程的方式。
o 定时器实现线程代码示例
o import java.util.Timer;
o import java.util.TimerTask;
o
o /**
o * <p>
o * 定时器创建线程
o * </p>
o *
o * @author 踏雪彡寻梅
o * @version 1.0
o * @date 2020/9/7 - 23:48
o * @since JDK1.8
o */
o public class DemoTimmerTask {
o public static void main(String[] args) {
o Timer timer = new Timer();
o timer.scheduleAtFixedRate(new TimerTask() {
o @Override
o public void run() {
o System.out.println(Thread.currentThread().getName());
o }
o }, 1000, 1000);
o }
o }
o 分析
和前面几点一样，定时器创建线程的方法终本质也离不开上文中的那两类方法。
5. 匿名内部类和 Lambda 表达式的方式创建线程是新的创建线程方式。
o 实际上也和前面几点一样是一个表面现象，本质上还是那两种方法。
o 使用方式代码示例
o /**
o * <p>
o * 匿名内部类创建线程
o * </p>
o *
o * @author 踏雪彡寻梅
o * @version 1.0
o * @date 2020/9/7 - 23:54
o * @since JDK1.8
o */
o public class AnonymousInnerClassDemo {
o public static void main(String[] args) {
o // 种
o new Thread() {
o @Override
o public void run() {
o System.out.println(Thread.currentThread().getName());
o }
o }.start();
o
o // 第二种
o new Thread(new Runnable() {
o @Override
o public void run() {
o System.out.println(Thread.currentThread().getName());
o }
o }).start();
o }
o }
o /**
o * <p>
o * Lambda 表达式创建线程
o * </p>
o *
o * @author 踏雪彡寻梅
o * @version 1.0
o * @date 2020/9/7 - 23:58
o * @since JDK1.8
o */
o public class LambdaDemo {
o public static void main(String[] args) {
o new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
o }
o }
o 运行结果
• 总结
o 多线程的实现方式，在代码中写法千变万化，但其本质万变不离其宗。
常见面试问题
• 有多少种实现线程的方法?思路有 5 点。
o 从不同的角度看，会有不同的答案。
o 典型答案是两种。这两种方式的对比。
o 从原理来看，两种本质都是一样的（都是实现 run 方法）。
o 具体展开说其他方式（代码的实现上的不同方式，原理还是基于那两个本质）。
o 将以上几点做结论。
• 实现 Runnable 接口和继承 Thread 类哪种方式更好?
o 从代码架构角度。（应该去解耦，两件事情：1.具体的任务即 run 方法中的内容；2.和线程生命周期相关的如创建线程、运行线程、销毁线程即 Thread 类去做的事情）
o 新建线程的损耗的角度。（继承 Thread 类，需要新建线程、执行完之后还要销毁，实现 Runnable 接口的方式可以反复的利用同一个线程，比如线程池就是这么做的，用于线程生命周期的损耗就减少了）
o Java 不支持多继承的角度。（对于扩展性而言）
