为什么这样启动线程，线程执行是有序的？

Question

这种是有序的，我试过很多次。

这种是无序的。
想问下有什么区别么？为什么？

Answer 1

关于线程的问题，不能看到什么就相信什么。文档没有说明这种情况的执行顺序，开发者也不应该认定某种顺序。顺序与jdk版本，操作系统环境等都有关系。使用你上面的代码，我在windows上，jdk1.8版本，跑出来确实是上面你说的顺序，但是同样的jdk版本，在ubuntu18.04上，第一种写法运行多次，结果如下：

不仅和windows上的结果不同，与它之前运行的结果也可能不同。

Answer 2

其实第一种情况也是无需的，只是第一个线程启动后主线程还要创建第二个线程，创建线程耗时时间已经够第一个线程执行完了，所以开起来是有序的。你可以在第一个线程里sleep(1000)，你会发现第一个线程最后才输出。

public static void main(String[] args) {
        new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("A");
        }).start();
        new Thread(() -> System.out.println("B")).start();
        new Thread(() -> System.out.println("C")).start();
        new Thread(() -> System.out.println("D")).start();
    }

输出结果：
B
C
D
A

Answer 3

巧合。不要面向巧合编程。

Answer 4

请参考这个:
JVM之Java线程启动流程 - 知乎
https://zhuanlan.zhihu.com/p/...

Answer 5

创建线程需要时间，相对于第二种直接new start创建线程时间更少，因为不需要赋值
可以参考这个回答：
https://segmentfault.com/q/10...

我自己做的测试：

package test;

public class Test2 {
    public static void main(String[] args) {
//        new Thread(()->{System.out.println("A");}).start();
//        new Thread(()->{System.out.println("B");}).start();
//        new Thread(()->{System.out.println("C");}).start();
//        new Thread(()->{System.out.println("D");}).start();
        final int k=50;
        new Thread() {
        public void run() {
            //System.out.println("A");
            int a=0;
            for (int i = 0; i < k; i++) {
                a++;
                System.out.println("A:"+i);
            }
        }    
        }.start();
        
        new Thread() {
            public void run() {
                //System.out.println("B");
                for (int i = 0; i < k; i++) {
                    System.out.println("B:"+i);
                }
            }    
            }.start();
            
            new Thread() {
                public void run() {
                    //System.out.println("C");
                    for (int i = 0; i < k; i++) {
                        System.out.println("C:"+i);
                    }
                }    
                }.start();    
                
                new Thread() {
                    public void run() {
                        //System.out.println("D");
                        for (int i = 0; i < k; i++) {
                            System.out.println("D:"+i);
                        }
                    }    
                    }.start();
        
        
        
        
    }
    
}
//测试结果
A:0
A:1
A:2
A:3
A:4
A:5
A:6
A:7
A:8
A:9
A:10
A:11
A:12
A:13
A:14
A:15
A:16
A:17
A:18
A:19
A:20
A:21
A:22
A:23
A:24
B:0
B:1
B:2
B:3
B:4
B:5
A:25
A:26
A:27
A:28
A:29
A:30
A:31
A:32
A:33
A:34
A:35
A:36
B:6
B:7
B:8
A:37
A:38
B:9
C:0
C:1
C:2
C:3
C:4
C:5
C:6
C:7
C:8
C:9
C:10
C:11
C:12
C:13
C:14
C:15
C:16
C:17
C:18
C:19
C:20
B:10
B:11
B:12
B:13
B:14
B:15
B:16
B:17
B:18
B:19
B:20
B:21
B:22
B:23
B:24
B:25
B:26
B:27
B:28
B:29
B:30
B:31
B:32
B:33
B:34
B:35
B:36
B:37
B:38
B:39
B:40
B:41
B:42
B:43
B:44
B:45
B:46
B:47
B:48
B:49
A:39
A:40
C:21
C:22
C:23
C:24
C:25
C:26
C:27
C:28
C:29
D:0
D:1
D:2
D:3
D:4
D:5
D:6
D:7
D:8
D:9
D:10
D:11
D:12
D:13
D:14
C:30
C:31
C:32
C:33
C:34
C:35
C:36
C:37
C:38
A:41
A:42
A:43
A:44
C:39
C:40
C:41
C:42
C:43
C:44
C:45
C:46
C:47
C:48
C:49
D:15
D:16
A:45
A:46
A:47
A:48
A:49
D:17
D:18
D:19
D:20
D:21
D:22
D:23
D:24
D:25
D:26
D:27
D:28
D:29
D:30
D:31
D:32
D:33
D:34
D:35
D:36
D:37
D:38
D:39
D:40
D:41
D:42
D:43
D:44
D:45
D:46
D:47
D:48
D:49

当我将k设置为50时是能看出来的线程并不是按顺序执行的，而是线程启动需要时间，所以说在第二个线程启动的时候，第一个线程已经执行了一段时间