创建线程的方法

从操作系统的角度来看，线程是CPU调度的最小单位——可以理解为一种资源、权利，即能够获得CPU的使用权

网上很多文章中说Java创建线程的方法有两种（Thread Runnable）或三种（外加Callable Future），这种说法不能说是错误的，但是很容易误导人，实际上，创建线程（拥有CPU使用权的线程）只有一种方法，那就是继承Thread类。实现Runnable（包括Callable Future）准确地说，不是线程，而是任务，站在操作系统的角度来看，一个类实现类Runnable，并没有立刻获得能够使用CPU的权利，来看一下Runnable和Thread的源码

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Thread implements Runnable {
    private ThreadGroup group;

    public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

    private native void start0();

    /**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * @see     #start()
     */
    @Override
    public void run() {
        if (target != null) {
            target.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
 
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

注释我去掉了一些，从Thread.run()方法来看，Runnable要是能运行的话——获得CPU的使用权，那么要放在Thread的构造函数中，否则不执行，然后看Thread.start()方法，其中调用了start0()方法，该方法是个本地方法，本地方法的实现要去看源码，openjdk8的源码下载地址，因为最终是要看cpp的，而我不会cpp，引用另外两篇博文：调用Thread.start()方法，JVM（Hotspot）会调用操作系统的API来创建一个操作系统线程，此时一个Java线程对象就与一个操作系统线程一一对应。

那么为什么需要Runnable接口呢？只有Thread不就够类么，重写run()方法就行了，网上很多都说Runnable是接口，而Thread是类，实现Runnable能够避免Java单根继承带来的局限，且实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享

我认为都没说到点子上，重点是：调用Thread.start()时，是通过操作系统来创建线程的，而创建线程必然是运行在内核态，那么就一定有上下文切换，从而带来额外的时间和空间开销。如果将线程（Thread对象）看作插槽，它代表了资源——能够使用CPU（其实还有寄存器等存储资源），Runnable对象看作插头——要运行的任务，因为创建、撤销插槽开销很大，那么可以先创建一组插槽，什么任务需要运行，就插入相应的插头，就能够避免频繁的创建、撤销，避免上下文切换，从而提高性能，没错，就是线程池的思想

很多地方的线程和任务并没有分清楚，比如这里，若是站在java程序员的角度，Runnable就是一个线程，为啥？我要在执行多个任务，实现Runnable接口，不就是线程么

1.1实现Runnable接口

public class MyRunnable{

    public static void main(String[] args) {
        Thread[] ths = new Thread[3];
        for (int i = 0; i < 3; i++) {
            ths[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 5; j++)
                        System.out.print(j);
                    System.out.print(" ");
                }
            });
        }
        for (Thread th: ths)
            th.start();
    }
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

注意Runnable使用了匿名内部类，

1.2继承自Thread类

public class MyThread extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 5; i++)
            System.out.print(i);
        System.out.print(" ");
    }

    public static void main(String[] args){
        MyThread[] thx = {
                new MyThread(),
                new MyThread(),
                new MyThread(),
        };
        for (MyThread th: thx){
            th.start();
        }
    }
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

需要注意的是，以上两个程序中，线程的启动顺序是确定的，但是执行顺序是不确定的，因为是并发执行而不是顺序执行的，JVM和操作系统一起决定了线程的执行顺序，下图分别为Runnable在windown7+jdk1.7.0_67和ubuntu16.04+jdk1.8.0_101上运行的结果