Fork me on GitHub

java并发之实现多线程的方法

阅读数：3072次
字数统计: 1.2k字   |   阅读时长≈ 5分

一锤定音

Oracle官网的文档中：
实现多线程的方式一共有两种：

  • 方法一：实现Runnable接口
  • 方法二：继承Thread类
    官方文档
    docs

方法一：实现Runnable接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * @author xcz
 * @ClassName RunnableStyle.java
 * @createTime 2020年02月28日 11:25:00
 * @Description: 用Runnable方式创建线程
 */
public class RunnableStyle implements Runnable {
    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableStyle());
        thread.start();
    }


    public void run() {
        System.out.println("用Runnable方法实现线程");
    }
}

输出结果：

1
用Runnable方法实现线程

方法二：继承Thread类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * @author xcz
 * @ClassName ThreadStyle.java
 * @createTime 2020年02月28日 11:28:00
 * @Description: 用Thread方式实现线程
 */
public class ThreadStyle extends Thread {
    @Override
    public void run() {
        System.out.println("用Thread类实现线程");
    }

    public static void main(String[] args) {
        new ThreadStyle().start();
    }
}

输出结果：

1
"用Thread类实现线程"

两种方法的比较

  • 实现Runnable接口的方式更好
    • 方法1的解耦效果好
    • 实现Thread，创建、销毁线程损耗大，实现Runnable可以使用线程池的技术减少损耗
    • java只支持单一继承，继承Thread类占据了继承
  • 本质区别
    • 方法一：最终调用了target.run()
    • 假设A类实现了Runnable接口，然后实现了run方法。
    • 在使用 new Thread(new A())进行创建线程的时候，A类是作为Runnable类型的参数被传入的，根据Thread源码，Thread的run()方法，有一个Runnable类型的参数，就是在new Thread时传入的，如果这个参数不为空，就直接使用这个参数（A类）的run方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
//Thread类使用Runnable接口初始化线程方法，调用init方法
public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
}
//init方法，调用另一个init方法
private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
        init(g, target, name, stackSize, null, true);
}
//最终的init方法，将传入的Runnable类对象赋值给了Thread类的target变量
private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;

        Thread parent = currentThread();
        SecurityManager security = System.getSecurityManager();
        if (g == null) {
            /* Determine if it's an applet or not */

            /* If there is a security manager, ask the security manager
               what to do. */
            if (security != null) {
                g = security.getThreadGroup();
            }

            /* If the security doesn't have a strong opinion of the matter
               use the parent thread group. */
            if (g == null) {
                g = parent.getThreadGroup();
            }
        }

        /* checkAccess regardless of whether or not threadgroup is
           explicitly passed in. */
        g.checkAccess();

        /*
         * Do we have the required permissions?
         */
        if (security != null) {
            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }

        g.addUnstarted();

        this.group = g;
        this.daemon = parent.isDaemon();
        this.priority = parent.getPriority();
        if (security == null || isCCLOverridden(parent.getClass()))
            this.contextClassLoader = parent.getContextClassLoader();
        else
            this.contextClassLoader = parent.contextClassLoader;
        this.inheritedAccessControlContext =
                acc != null ? acc : AccessController.getContext();



        //这就是关键点，将传入的Runnable类对象赋值给了Thread类的target变量
        this.target = target;










        setPriority(priority);
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;

        /* Set thread ID */
        tid = nextThreadID();
}

//Thread类的执行方法run()方法，可以看见，run方法直接使用了传入的Runnable类对象的run方法，这个run方法就是我们创建的Runnable接口实现类中重写的run方法
@Override
public void run() {
    if (target != null) {
        target.run();
    }
}
  • 方法二：run()方法整个都被重写
    • 继承Thread类的方式，会重写run()方法，就直接覆盖了上面源码中Thread类的run方法，相当于抛弃了Thread类自带的run方法，就只是执行自己写的run方法了。

同时使用两种办法会怎么样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class BothRunnableThread {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            public void run() {
                System.out.println("我来自Runnable");
            }
        }){
            @Override
            public void run() {
                System.out.println("我来自Thread，重写Thread的run方法");
            }
        }.start();
    }
}

最终结果：

1
我来自Thread，重写Thread的run方法

原因：

  • 在new Thread的时候，传入了Runnable对象，并同时重写了Thread的run方法，重写了run方法后，就没有Thread的这三行代码了，那么Runnable对象的run方法就自然不会执行了
    1
    2
    3
    4
    5
    public void run() {
        if (target != null) {
            target.run();
        }
    }

总结

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

典型错误观点

  • 线程池创建线程也算是一种新建线程的方式
    • 线程池本质也是传入的Runnable方式创建的线程
  • 通过Clallable和FutureTask创建线程，也算是一种新建线程的方式
    • 根据UML图，它们也都是使用了两种方式实现的

参考

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

来发评论吧~
Powered By Valine
v1.5.2
本站总访问量3240次 | 本站访客数2616人