第十二题（线程）

选择E

考察start()和run()

1.start（）方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码：

通过调用Thread类的start()方法来启动一个线程，
这时此线程是处于就绪状态，
并没有运行。
然后通过此Thread类调用方法run()来完成其运行操作的，
这里方法run()称为线程体，
它包含了要执行的这个线程的内容，
Run方法运行结束，
此线程终止，
而CPU再运行其它线程，

 

2.run（）方法当作普通方法的方式调用，程序还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码：

而如果直接用Run方法，
这只是调用一个方法而已，
程序中依然只有主线程--这一个线程，
其程序执行路径还是只有一条，
这样就没有达到写线程的目的。

(以上参考自：http://blog.csdn.net/wangyangkobe/article/details/5839182)

import java.util.*;
public class MyThread implements Runnable{
        //Runnable 源码
        /*
        *public interface Runnable{
                public abstract void run();
        }
        */
        int number = 10;
        private static int count = 0;
        private final int id = count++;
        public MyThread(){}
        public MyThread(int number){
                number = number;
        }
        public String status(){
                return id + " " + (number > 0? number: "zero");
        }
        public void run(){
                while(number-- > 0){
                        System.out.println(status());
                        Thread.yield();
                }
        }
        //线程驱动任务
        /*public static void main(String[] args){
                MyThread m = new MyThread();
                m.run();
        }*/
        //Thread驱动
        public static void main(String[] args){
                Thread t = new Thread(new MyThread());
                //t.start();
                t.run();
                System.out.println("late");
        }
}
~                                                                                                                                                              
~                                                                                                                                                              
~                                                                                                                                                              
~          

体会Thread驱动下面的t.start()和t.run()执行的区别。

执行t.start

late
0 9
0 8
0 7
0 6
0 5
0 4
0 3
0 2
0 1
0 zero

执行t.run

0 9
0 8
0 7
0 6
0 5
0 4
0 3
0 2
0 1
0 zero
late

将Thread驱动里的代码改成：

public static void main(String[] args){
                Thread t = new Thread(new MyThread());
                Thread t1 = new Thread(new MyThread());
                t.start();
                t1.start();
                //t.run();
                System.out.println("late");
        }

结果：

第一次：

0 9
0 8
0 7
0 6
0 5
0 4
0 3
0 2
0 1
0 zero
late
1 9
1 8
1 7
1 6
1 5
1 4
1 3
1 2
1 1
1 zero

第二次

0 9
0 8
0 7
1 9
late
0 6
1 8
0 5
1 7
0 4
1 6
0 3
1 5
0 2
1 4
0 1
1 3
0 zero
1 2
1 1
1 zero

我们发现实现了三个进程的交替执行，“late“也没有在最后打印

将start改成run之后，发现，运行结果总是

0 9
0 8
0 7
0 6
0 5
0 4
0 3
0 2
0 1
0 zero
1 9
1 8
1 7
1 6
1 5
1 4
1 3
1 2
1 1
1 zero
late

结论：

run和start是不同的，两个线程使用start方法的时候，两个是同时运行的，结果是交错的。

两个线程使用run方法的时候，运行是顺序的，哪个在前，先运行哪个。所以看到的是t的输出先。

start方法会让线程运行是异步的（asynchronously），在启动的时候，其实start调用的是MyThread的run方法，但是此时执行的是其他线程，而执行main方法的线程继续，所以先打印了late，其余两个线程在交错运行中。

run方法是同步的（synchronously），只有等它运行完才进行下一步的操作，所以late在最后打印。

以上参考自：http://blog.csdn.net/iaiti/article/details/39339029