详细分析 Java 中实现多线程的方法有几种?(从本质上出发)

时间  2020-09-26 标签 详细 分析 java 中 实现 多线程 方法 几种 本质上 出发

目录

详细分析 Java 中实现多线程的方法有几种?(从本质上出发)

正确的说法(从本质上出发)

  • 实现多线程的官方正确方法: 2 种。java

  • Oracle 官网的文档说明面试

    在这里插入图片描述

  • 方法小结多线程

    • 方法一: 实现 Runnable 接口。架构

    • 方法二: 继承 Thread 类。ide

  • 代码示例工具

    /**
 * <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();
    }
}

  • 两种方式的对比线程

    • 方法一（实现 Runnable 接口）更好。code

    • 方法二的缺点:对象

      1. 从代码的架构去考虑，具体执行的任务也就是 run 方法中的内容，它应该和线程的建立、运行的机制也就是 Thread 类是解耦的。因此不该该把他们混为一谈。从解耦的角度，方法一更好。blog

      2. 该方法每次若是想新建一个任务，只能去新建一个独立的线程，而新建一个独立的线程这样的损耗是比较大的，它须要去建立、而后执行，执行完了还要销毁；而若是使用 Runnable 接口的方式，咱们就能够利用线程池之类的工具，利用这些工具就能够大大减少这些建立线程、销毁线程所带来的损耗。因此方法一相比于方法二的这一点，好在资源的节约上。

      3. 继承了 Thread 类以后，因为 Java 不支持双继承，那么这个类就没法继承其余的类了，这大大限制了咱们的可扩展性。

  • 两种方式的本质区别

    • 方法一: 最终调用 target.run; ，经过如下两图能够知道使用这个方法时其实是传递了一个 target 对象，执行了这个对象的 run 方法。

      在这里插入图片描述

      在这里插入图片描述

    • 方法二: run() 整个都被重写。一旦子类重写了父类的方法，原有方法会被覆盖被抛弃，即如下代码不会被此次调用所采纳。

      在这里插入图片描述

    • 综上，两种方法都是执行了 run 方法，只不过 run 方法的来源不一样。

  • 同时使用两种方法会怎样?

    • 代码演示

      /**
* <p>
* 同时使用 Runnable 和 Thread 两种实现线程的方式
* </p>
*
* @author 踏雪彡寻梅
* @version 1.0
* @date 2020/9/7 - 22:38
* @since JDK1.8
*/
@SuppressWarnings("all")
public class BothRunnableThread {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我来自 Runnable。。。");
            }
        }) {
            @Override
            public void run() {
                System.out.println("我来自 Thread。。。");
            }
        }.start();
    }
}

    • 运行结果
      在这里插入图片描述

    • 分析

      1. 首先建立了一个匿名内部类 Thread。传入了一个 Runnable 对象。

      2. 而后重写了 Thread 的 run 方法。最后启动线程。

      3. 由于重写了 Thread 的 run 方法，因此它父类的 run 方法就被覆盖掉了，因此即使传入了 Runnable 对象也不会执行它。

  • 总结

    • 从以上的分析中，准确的讲建立线程只有一种方式那就是构造 Thread 类，而实现线程的执行单元有两种方式（run 方法的两种不一样实现状况）。

      • 方法一: 实现 Runnable 接口的 run 方法，并把 Runnable 实例传给 Thread 类，再让 Thread 类去执行这个 run 方法。

      • 方法二: 重写 Thread 的 run 方法（继承 Thread 类）。

经典错误说法(从本质上出发)

  1. ”线程池建立线程也算是一种新建线程的方式。“

    • 线程池建立线程代码示例

      import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
* <p>
* 线程池建立线程的方法
* </p>
*
* @author 踏雪彡寻梅
* @version 1.0
* @date 2020/9/7 - 23:05
* @since JDK1.8
*/
public class ThreadPools {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 1000; i++) {
            // 添加任务
            executorService.submit(new Task() {});
        }
    }
}

class Task implements Runnable {
    @Override
    public void run() {
        try {
            Thread.sleep(500);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
    }
}

    • 线程池建立线程源码(DefaultThreadFactory 中)

      在这里插入图片描述

    • 分析

      • 经过线程池中的源码，能够知道线程池建立线程的方式本质上也是经过构造 Thread 的方式建立的。因此线程池建立线程的本质和上文中是同样的。因此不能简单的认为线程池也是一种新的建立线程的方式。

  2. ”经过 Callable 和 FutureTask 建立线程，也算是一种新建线程的方式。“

    • 类图展现

      image.png

      image.png

    • 分析

      • 从类图中能够知道这两个建立线程的本质也是和以前的同样的。

  3. ”无返回值是实现 Runnable 接口，有返回值是实现 Callable 接口，因此 Callable 是新的实现线程的方式。“

    • 和第 2 点差很少。

  4. 定时器是新的实现线程的方式。

    • 定时器实现线程代码示例

      import java.util.Timer;
import java.util.TimerTask;

/**
* <p>
* 定时器建立线程
* </p>
*
* @author 踏雪彡寻梅
* @version 1.0
* @date 2020/9/7 - 23:48
* @since JDK1.8
*/
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);
    }
}

    • 分析

      • 和前面几点同样，定时器建立线程的方法最终本质也离不开上文中的那两类方法。

  5. 匿名内部类和 Lambda 表达式的方式建立线程是新的建立线程方式。

    • 实际上也和前面几点同样是一个表面现象，本质上仍是那两种方法。

    • 使用方式代码示例

      /**
* <p>
* 匿名内部类建立线程
* </p>
*
* @author 踏雪彡寻梅
* @version 1.0
* @date 2020/9/7 - 23:54
* @since JDK1.8
*/
public class AnonymousInnerClassDemo {
    public static void main(String[] args) {
        // 第一种
        new Thread() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }.start();

        // 第二种
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();
    }
}
      /**
* <p>
* Lambda 表达式建立线程
* </p>
*
* @author 踏雪彡寻梅
* @version 1.0
* @date 2020/9/7 - 23:58
* @since JDK1.8
*/
public class LambdaDemo {
    public static void main(String[] args) {
        new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
    }
}

    • 运行结果

      image.png

      image.png

  • 总结
    • 多线程的实现方式，在代码中写法变幻无穷，但其本质万变不离其宗。

常见面试问题

  • 有多少种实现线程的方法?思路有 5 点。

    • 从不一样的角度看，会有不一样的答案。

    • 典型答案是两种。这两种方式的对比。

    • 从原理来看，两种本质都是同样的（都是实现 run 方法）。

    • 具体展开说其余方式（代码的实现上的不一样方式，原理仍是基于那两个本质）。

    • 将以上几点作结论。

  • 实现 Runnable 接口和继承 Thread 类哪一种方式更好?

    • 从代码架构角度。（应该去解耦，两件事情：1.具体的任务即 run 方法中的内容；2.和线程生命周期相关的如建立线程、运行线程、销毁线程即 Thread 类去作的事情）

    • 新建线程的损耗的角度。（继承 Thread 类，须要新建线程、执行完以后还要销毁，实现 Runnable 接口的方式能够反复的利用同一个线程，好比线程池就是这么作的，用于线程生命周期的损耗就减小了）

    • Java 不支持多继承的角度。（对于扩展性而言）

若有写的不足的，请见谅，请你们多多指教。

联系我们 沪ICP备2021010478号-7