• 【并发技术01】传统线程技术中创建线程的两种方式


    传统的线程技术中有两种创建线程的方式:一是继承 Thread 类,并重写 run() 方法;二是实现 Runnable 接口,覆盖接口中的 run() 方法,并把 Runnable 接口的实现扔给 Thread。这两种方式大部分人可能都知道,但是为什么这样玩就可以呢?下面我们来详细分析一下这两种方法的来龙去脉。

    1. 揭秘Thread中run()

    上面我们看到这两种方式都跟 run() 方法有关,所以我们来看一下 Thread 的源码中 run() 方法到底都干了什么:

    1. @Override

    2. public void run() {

    3.    if (target != null) {

    4.        target.run();

    5.    }

    6. }

    我们可以看出, run() 方法中很简单,只有一个 if 语句,如果 target 不为空就执行 target 的 run() 方法,否则什么也不干,那么这 target 到底是何方神圣呢?我们点击进去可以看到:

    private Runnable target;

    原来 target 就是 Runnable 接口,我们再点进 Runnable 看看:

    1. @FunctionalInterface

    2. public interface Runnable {

    3.    public abstract void run();

    4. }

    Runnable 中就一个方法,也是 run() 方法!好了,现在再回到 Thread 类的 run() 方法中,如果 target 不为空,即实现了 Runnable 接口,也即实现了 Runnable 中的 run() 方法,那么我们就使用该接口中的 run() 方法;如果 target 为空,即没有实现 Runnable 接口,那我们什么也不做,即线程创建后立马就消失了。
    所以到这里,大家就明白了为什么创建线程有上面两种方式了。第一种:你不是要先进行 if 判断么?我现在不判断了,我把你的 if 干掉,我在 run() 方法中自己写代码,想干啥就干啥,即重写 Thread 中的 run() 方法,;第二种:你不是要先进行 if 判断么?行,给你一个 Runnable 接口让你判断,但你还是得调用我 Runnable 中的 run() 方法啊,那我重写我 Runnable 中的 run() 方法不就行了! 知道了来龙去脉后,下面就针对这两种传统的方式写个实例。

    2. 创建方式1:继承 Thread 类

    只要两步即可创建并开启一个线程:

    • 继承 Thread 类,并实现 run() 方法;

    • 调用 start() 方法开启线程。

    由于只要实现一个 run() 方法即可,所以我们可以使用 Java 中的匿名内部类来实现,如下:

    1. public class TraditionalThread {

    2.    public static void main(String[] args) {

    3.    /********** 第一种方法:继承Thread类,覆写run()方法 **************/

    4.    Thread thread1 = new Thread(){

    5.        @Override

    6.        public void run() {

    7.            try {

    8.                    Thread.sleep(500);//让线程休息500毫秒

    9.            } catch (InterruptedException e) {

    10.                e.printStackTrace();

    11.            }

    12.            System.out.println(Thread.currentThread().getName());//打印出当前线程名

    13.        }

    14.    };

    15.    thread1.start();//开启线程

    16.    }

    17. }

    ​​​​​​​

    3. 创建方式2:实现 Runnable 接口

    只要两步即可创建并开启一个线程:

    • 实现 Runnable 接口,并实现 run() 方法;

    • 调用 start() 方法开启线程。

    由于只要实现一个 run() 方法即可,所以我们也可以使用 Java 中的匿名内部类来实现,如下:

    1. public class TraditionalThread {

    2.    public static void main(String[] args) {

    3.        /********** 第二种方法:实现Runnable接口,扔给Thread **************/

    4.        Thread thread2 = new Thread(new Runnable() {        

    5.            @Override

    6.            public void run() {

    7.                try {

    8.                    Thread.sleep(500);

    9.                } catch (InterruptedException e) {

    10.                    e.printStackTrace();

    11.                }

    12.                System.out.println(Thread.currentThread().getName());          

    13.            }

    14.        });

    15.        thread2.start();

    16.    }

    17. }

    ​​​​​​​

    4. 两种方式同时使用

    如果有个哥们比较给力,他两种方式同时使用了,即:既实现了 Thread 类中的 run() 方法,又给 Thread 扔了一个实现了 run() 方法的 Runnable。如下所示:

    1. public class TraditionalThread {

    2.    public static void main(String[] args) {

    3.        //这哥们的代码写的比较给力

    4.        new Thread(new Runnable() {

    5.            @Override

    6.            public void run() {

    7.                try {

    8.                    Thread.sleep(500);

    9.                } catch (InterruptedException e) {

    10.                    e.printStackTrace();

    11.                }

    12.                System.out.println("Runnable:" + Thread.currentThread().getName());

    13.            }

    14.        }){

    15.            @Override

    16.            public void run() {

    17.                try {

    18.                    Thread.sleep(500);

    19.                } catch (InterruptedException e) {

    20.                    e.printStackTrace();

    21.                }

    22.                System.out.println("Thread:" + Thread.currentThread().getName());

    23.            }

    24.        }.start();

    25.    }

    26. }

    ​​​​​​​现在又会执行哪个呢?我们运行一下上面的程序就会发现,它会打印出 Thread 的信息,所以运行的是 Thread 的 run() 方法,知道结论了,但是为啥呢?

    从面向对象的思想去考虑:上面一段代码其实是新 new 了一个对象(子对象)继承了 Thread 对象(父对象),在子对象里重写了父类的 run() 方法,父对象中扔了个 Runnable 进去,父对象中的 run() 方法就是最初的带有 if 判断的 run() 方法。

    好了,现在执行 start() 后,肯定先在子类中找 run() 方法,找到了,父类的 run() 方法自然就被干掉了,所以会打印出 Thread:,如果我们现在假设子类中没有重写 run() 方法,那么必然要去父类找 run() 方法,父类的 run() 方法中就得判断是否有 Runnable 传进来,现在有一个,所以执行 Runnable 中的 run() 方法,那么就会打印 Runnable: 出来。

    OK,传统的创建线程的两种方式就总结这么多~

    作者:华为云云享专家倪升武​​​​​​​

  • 相关阅读:
    linux试题
    linux常用脚本
    nagios
    lvs/nginx/haproxy 负载均衡优缺点分析讲解
    一次SSLPeerUnverifiedException,SSLHandshakeException问题的分析
    [转]【安卓笔记】AsyncTask源码剖析
    linux下查看进程占用端口和端口占用进程命令
    which framework or library is best to use WebRTC
    [转]svn diff 替代工具
    [转]使用Subversion进行版本控制
  • 原文地址:https://www.cnblogs.com/2020-zhy-jzoj/p/13165364.html
Copyright © 2020-2023  润新知