多线程运行机制 概要

    1.多线程运行特点
    同一段Java程序，在不同虚拟机(JVM)的实现可能会有不同，尤其Java线程。学习线程时，最令我印象深刻的就是那种不确定性、没有保障性，各个线程的运行完全是以不可预料的方式和速度推进，有的一个程序运行了N次，其结果差异性很大，这全要归咎于JVM。
    所谓的多任务是通过周期性地将CPU时间片切换到不同的子任务，虽然从微观上看来，单核的CPU上同时只运行一个子任务，但是从宏观来看，每个子任务似乎是同时连续运行的(但是JAVA的线程不是按时间片分配的。
   
    2.解释：引用一段网友翻译的国外某Java原著中对线程的理解。
    Thread Scheduling
    In Java technology,threads are usually preemptive,but not necessarily Time-sliced(the process of giving each thread an equal amount of CPU time).It is common mistake to believe that "preemptive" is a fancy word for "does time-slicing".
    For the runtime on a Solaris Operating Environment platform,Java technology does not preempt threads of the same priority.However,the runtime on Microsoft Windows platforms uses time-slicing,so it preempts threads of the same priority and even threads of higher priority.Preemption is not guaranteed;however,most JVM implementations result in behavior that appears to be strictly preemptive.Across JVM implementations,there is no absolute guarantee of preemption or time-slicing.The only guarantees lie in the coder’s use of wait and sleep.
    The model of a preemptive scheduler is that many threads might be runnable,but only one thread is actually running.This thread continues to run until it ceases to be runnable or another thread of higher priority becomes runnable.In the latter case,the lower priority thread is preempted by the thread of higher priority,which gets a chance to run instead.
    A thread might cease to runnable (that is,because blocked) for a variety of reasons.The thread’s code can execute a Thread.sleep() call,deliberately asking the thread to pause for a fixed period of time.The thread might have to wait to access a resource and cannot continue until that resource become available.
    All thread that are runnable are kept in pools according to priority.When a blocked thread becomes runnable,it is placed back into the appropriate runnable pool.Threads from the highest priority nonempty pool are given CPU time.
    The last sentence is worded loosed because:
    (1) In most JVM implementations,priorities seem to work in a preemptive manner,although there is no guarantee that priorities have any meaning at all;
    (2) Microsoft Window’s values affect thread behavior so that it is possible that a Java Priority 4 thread might be running,in spite of the fact that a runnable Java Priority 5 thread is waiting for the CPU.
In reality,many JVMs implement pool as queues,but this is not guaranteed hehavior.

    热心网友翻译的版本：
    在java技术中，线程通常是抢占式的而不需要时间片分配进程（分配给每个线程相等的cpu时间的进程）。一个经常犯的错误是认为“抢占”就是“分配时间片”。
    在Solaris平台上的运行环境中，相同优先级的线程不能相互抢占对方的cpu时间。但是，在使用时间片的windows平台运行环境中，可以抢占相同甚至更高优先级的线程的cpu时间。抢占并不是绝对的，可是大多数的JVM的实现结果在行为上表现出了严格的抢占。纵观JVM的实现，并没有绝对的抢占或是时间片，而是依赖于编码者对wait和sleep这两个方法的使用。
    抢占式调度模型就是许多线程属于可以运行状态（等待状态），但实际上只有一个线程在运行。该线程一直运行到它终止进入可运行状态（等待状态）或是另一个具有更高优先级的线程变成可运行状态。在后一种情况下，低优先级的线程被高优先级的线程抢占，高优先级的线程获得运行的机会。
    线程可以因为各种各样的原因终止并进入可运行状态（因为堵塞）。例如，线程的代码可以在适当时候执行Thread.sleep()方法，故意让线程中止；线程可能为了访问资源而不得不等待直到该资源可用为止。所有可运行的线程根据优先级保持在不同的池中。一旦被堵塞的线程进入可运行状态，它将会被放回适当的可运行池中。非空最高优先级的池中的线程将获得cpu时间。
    上一段最后一个句子是不精确的，因为：
    (1)在大多数的JVM实现中，虽然不能保证说优先级有任何意义，但优先级看起来象是用抢占方式工作。
    (2)微软windows的评价影响线程的行为，以至尽管一个处于可运行状态的优先级为5的java线程正在等待cpu时间，但是一个优先级为4的java线程却可能正在运行。
    实际上，许多JVM用队列来实现池，但没有保证行为。

    3.另一种解释
    原稿：jvm是在底层用os实现thread的，所以线程问题在java中反而容易呈现因平台而异的现象，java能不能充分利用双核的硬件资源，是看对应的操作系统的实现的。
    抢占和时间片，可以同时作为调度策略，所谓抢占，也不是优先执行，根据实现不同，可以是时间片加长，或者轮替几率加大。原来是依赖于具体的平台。这是java的平台无关性的一个例外吧，还有一处就是浮点数据类型的精度依赖于具体的芯片。

    回复：java线程实现是基于平台特点的没错，但同样可以保证跨平台的线程设计准确可靠地运行（前提是你设计得对），毕竟多核模拟出的是和单核相似的不确定性的线程执行情况，而确定性的编程设计才是基于这个之上的。关于浮点数和芯片是否有关，你可以看看core java2里面的论述，他用intel的芯片表达浮点数的与众不同说明了浮点数的精度问题。
    线程部分，上面已经有了“我们必须了解到什么是有保障的操作，什么是无保障的操作，以便设计的程序在各种jvm上都能很好地工作。”和你说的跨平台是一个意思，不同平台对应不同的jvm，同样的平台也有不同的jvm。
    我们运行java程序时有一个入口函数main()函数，它对应的线程被称为主线程。一个新线程一旦被创建，就产生一个新调用栈，从原主线程中脱离，也就是与主线程并发执行。
    当提到线程时，很少是有保障的。我们必须了解到什么是有保障的操作，什么是无保障的操作，以便设计的程序在各种jvm上都能很好地工作。比如，在某些jvm实现中，把java线程映射为本地操作系统的线程。这是java核心的一部分。

1. package edu.hust.test;
3. public class ThreadPriority implements Runnable {
4.     
5.     /*
6.      * 大多数JVM都有基于Thread Priority的抢先调度机制，但是不是当前运行Thread的Priority一定比其他Thread的Priority高呢？不是的。
7.      * 当所有Thread的Priority都相同时，JVM的调度实现会选择它喜欢的线程。也许是选择一个去运行，直至其完成；或者用分配时间片的方式，为每个线程提供均等的机会。
8.      * 所以不能依赖Thread Priority来保证程序执行的顺序，而只能把其作为一种提高程序效率的手段。
9.      * Thread Priority默认为5：Thread类具有三个静态常量：Thread.MIN_PRIORITY(1) Thread.NORM_PRIORITY(5) Thread.MAX_PRIORITY(10)
10.      * */
11.     
12.     public void run() {
13.         System.out.println("My name is " + Thread.currentThread().getName() + " and My priority is " + Thread.currentThread().getPriority());
14.     }
15.     
16.     public static void main(String[] args) {
17.         ThreadPriority threadPriority = new ThreadPriority();
18.         Thread[] threads = new Thread[10];
19.         int i = 0;
20.         for (Thread thread : threads) {
21.             thread = new Thread(threadPriority);
22.             thread.setPriority(++i);
23.             thread.start();
24.         }
25.     }
26.     /*
27.      * 运行结果：
28.      * My name is Thread-7 and My priority is 8
29.      * My name is Thread-8 and My priority is 9
30.      * My name is Thread-6 and My priority is 7
31.      * My name is Thread-0 and My priority is 1
32.      * My name is Thread-4 and My priority is 5
33.      * My name is Thread-9 and My priority is 10
34.      * My name is Thread-5 and My priority is 6
35.      * My name is Thread-3 and My priority is 4
36.      * My name is Thread-2 and My priority is 3
37.      * My name is Thread-1 and My priority is 2
38.      * 
39.      * 线程是从Thread-0 --> Thread-9依次启动的, 而优先启动Thread的优先级是最低的. 这样二者结合, 打印出以上不确定结果.
40.      * 如果优先启动的Thread又可以获得最高的优先级, 则打印结果是基本有序的.
41.      * 
42.      * 但这种输出结果是没有保障的，Java线程的执行和JVM有关，而JVM又是依赖于OS的。Windows线程是依靠抢占的方式获得cpu时间片的，所以有时候会出现低级别后运行的Thread抢占到cpu时间片的现象。
43.      * 
44.      * */
45. }

1. package edu.hust.test;
3. public class ThreadSeq {
4.     
5.     public void run() {
6.         System.out.println("普通打印语句1");
7.         System.out.println("普通打印语句2");
8.     }
9.     
10.     public static void main(String[] args) {
11.         Thread t = new Thread() {
12.             public void run() {
13.                 System.out.println("线程：" + Thread.currentThread().getName() + " 启动了");
14.             }
15.         };
16.         //这两个运行结果不同
17.         t.start();
18.         new ThreadSeq().run();
19.     }
20.     
21.     /*
22.      * 运行结果比较有趣：
23.      * 普通打印语句1
24.      * 线程：Thread-0 启动了
25.      * 普通打印语句2
26.      * 
27.      * 注意输出的顺序，好像跟我们想象的不太一致，为什么呢？一旦调用start()方法，必须给JVM点时间，让它配置进程。而在它配置完成之前，main线程调用了ThreadSeq中的run()方法(注意：只是普通调用，而不是启动)，
28.      * 所以print"普通打印语句1"，此时进程配置完毕，t进程开始执行，所以print"线程：Thread-0 启动了"，然后main线程再次得到时间片，print"普通打印语句2"。
29.      * 
30.      * 然而这个例子的输出顺序是没有保障的。原因见ThreadPriority类。
31.      * 
32.      * 补充：线程的启动要调用start()方法，只有这样才能创建新的调用栈。而直接调用run()方法的话，就不会创建新的调用栈，也就不会创建新的线程，run()方法就与普通的方法没什么两样了！
33.      * 
34.      * */
35. }

1. package edu.hust.test;
3. public class ThreadOrder implements Runnable {
4.     public void execute() {
5.         synchronized(this) {
6.             System.out.println(Thread.currentThread().getName() + ", 第一步");
7.             System.out.println(Thread.currentThread().getName() + ", 第二步");
8.             System.err.println(Thread.currentThread().getName() + ", 第三步");
9.             System.out.println(Thread.currentThread().getName() + ", 第四步");
10.             System.out.println("========================================================");
11.         }
12.     }
13.     
14.     public void run() {
15.         execute();
16.     }
17.     
18.     public static void main(String[] args) {
19.         ThreadOrder threadOrder = new ThreadOrder();
20.         Thread[] threads = new Thread[5];
21.         
22.         System.out.println(Thread.currentThread().getName() + "线程的状态为：" + Thread.currentThread().getState());
23.         
24.         for (Thread thread : threads) {
25.             thread = new Thread(threadOrder);
26.             thread.start();
27.         }
28.     }
29.     
30. }

1. package edu.hust.test;
4. public class SynchronizedTest1 implements Runnable {
5.     
6.     //当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
7.     public void execute() {
8.         synchronized (this) {
9.             for (int i = 0; i < 5; i++) 
10.                 System.out.println(Thread.currentThread().getName() + " is running, the loop num is " + i);
11.         }
12.     }
13.     
14.     public void run() {
15.         execute();
16.     }
18.     public static void main(String[] args) {
19.         SynchronizedTest1 synchronizedTest1 = new SynchronizedTest1();
20.         Thread threadA = new Thread(synchronizedTest1, "红薯Thread");
21.         Thread threadB = new Thread(synchronizedTest1, "土豆Thread");
22.         threadA.start();
23.         threadB.start();
24.     }
25.     
26.     /*
27.      * 运行结果：
28.      * 红薯Thread is running, the loop num is 0
29.      * 红薯Thread is running, the loop num is 1
30.      * 红薯Thread is running, the loop num is 2
31.      * 红薯Thread is running, the loop num is 3
32.      * 红薯Thread is running, the loop num is 4
33.      * 土豆Thread is running, the loop num is 0
34.      * 土豆Thread is running, the loop num is 1
35.      * 土豆Thread is running, the loop num is 2
36.      * 土豆Thread is running, the loop num is 3
37.      * 土豆Thread is running, the loop num is 4
38.      * 
39.      * 结果分析：只有"红薯Thread"全部执行完毕, 释放了同步锁后, "土豆Thread"才可以执行.
40.      * 
41.      * */
42.     
43. }

1. package edu.hust.test;
3. public class SynchronizedTest2 {
4.     //当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
5.     //当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对该object中所有其它synchronized(this)同步代码块的访问将被阻塞。
7.     public void execute_synchronized1() {
8.         synchronized (this) {
9.             for (int i = 0; i < 5; i++)
10.                 System.out.println(Thread.currentThread().getName() + " 位于/"同步块/"中 " + i);
11.         }
12.     }
13.     
14.     public void execute_synchronized2() {
15.         synchronized (this) {
16.             for (int i = 0; i < 5; i++)
17.                 System.out.println(Thread.currentThread().getName() + " 位于/"同步块/"中 " + i);
18.         }
19.     }
20.     
21.     public void execute_none_synchronized() {
22.         for (int i = 0; i < 5; i++)
23.             System.out.println(Thread.currentThread().getName() + " 位于/"非同步块/"中 " + i);
24.     }
25.     
26.     public static void main(String[] args) {
27.         final SynchronizedTest2 synchronizedTest2 = new SynchronizedTest2();
28.         
29.         //利用匿名内部类创建Thread
30.         Thread thread1 = new Thread(new Runnable() {
31.             public void run() {
32.                 synchronizedTest2.execute_synchronized1();
33.             }
34.         }, "红薯Thread");
35.         
36.         Thread thread2 = new Thread(new Runnable() {
37.             public void run() {
38.                 synchronizedTest2.execute_none_synchronized();
39.             }
40.         }, "土豆Thread");
41.         
42.         Thread thread3 = new Thread(new Runnable() {
43.             public void run() {
44.                 synchronizedTest2.execute_synchronized2();
45.             }
46.         }, "红薯土豆Thread");
47.         
48.         thread1.start();
49.         thread2.start();
50.         thread3.start();
51.     }
52.     
53.     /*
54.      * 运行结果：
55.      * 土豆Thread 位于"非同步块"中 0
56.      * 红薯Thread 位于"同步块"中 0
57.      * 土豆Thread 位于"非同步块"中 1
58.      * 红薯Thread 位于"同步块"中 1
59.      * 红薯Thread 位于"同步块"中 2
60.      * 红薯Thread 位于"同步块"中 3
61.      * 红薯Thread 位于"同步块"中 4
62.      * 土豆Thread 位于"非同步块"中 2
63.      * 
64.      * 红薯土豆Thread 位于"同步块"中 0
65.      * 红薯土豆Thread 位于"同步块"中 1
66.      * 红薯土豆Thread 位于"同步块"中 2
67.      * 红薯土豆Thread 位于"同步块"中 3
68.      * 红薯土豆Thread 位于"同步块"中 4
69.      * 
70.      * 土豆Thread 位于"非同步块"中 3
71.      * 土豆Thread 位于"非同步块"中 4
72.      * 
73.      * 结果分析：
74.      * 土豆Thread和红薯Thread可以交替打印 说明 --> 当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块
75.      * 红薯土豆Thread和红薯Thread不可能出现交替打印 说明 --> 当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对该object中所有其它synchronized(this)同步代码块的访问将被阻塞
76.      * */
77.     
78. }