Java线程： 线程调度

　　线程调度是Java多线程的核心，只有好的调度，才能充分发挥系统的性能，提高程序的执行效率。

一、休眠

　　休眠的目的是使线程让出CPU的最简单做法，线程休眠的时候，会将CPU交给其他线程，以便轮换执行，休眠一定时间后，线程会苏醒，进入准备状态等待执行。线程的休眠方法是Thread.sleep(long millis)和Thread.sleep(long millis,int nanos)，均为静态方法，调用sleep休眠的哪个线程呢？哪个线程调用sleep，哪个线程休眠。例子：

　　线程1休眠后，让出CPU，线程2执行，线程2执行完后，线程2休眠，让出CPU供线程1执行，(此时线程1已经休眠结束，在等待状态)，如此循环执行，直到结束。

　　SleepTest.java

 package Thread;

 public class SleepTest {
     public static void main(String[] args){
         Thread t1=new MyThread_1();
         Thread t2=new Thread(new MyRunnable1());
         t1.start();
         t2.start();
     }
 }
 class MyThread_1 extends Thread{
     public void run(){
         for(int i=0;i<3;i++){
             System.out.println("线程1第"+i+"次执行！");
             try{
                 Thread.sleep(500);//影响的是执行速度。
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
         }
     }
 }
 class MyRunnable1 implements Runnable{
     public void run(){
         for(int i=0;i<3;i++){
             System.out.println("线程2第"+i+"次执行！");
             try{
                 Thread.sleep(500);
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
         }
     }
 }

　　结果为：

 线程1第0次执行！
 线程2第0次执行！
 线程1第1次执行！
 线程2第1次执行！
 线程2第2次执行！
 线程1第2次执行！

二、线程优先级

　　可以用setPriority方法提高或降低任何一个线程的优先级，具体为1-10之间的数，默认优先级为5。并非优先级低的线程没有机会执行，优先级高低只是代表了执行机会的大小。每一个线程都有一个优先级。一个线程继承它父线程的优先级，它们的优先级相同。例子：

　　PriorityTest.java

 package Thread;
 public class PriorityTest {
     public static void main(String[] args){
         Thread t1=new MyThread_2();
         Thread t2=new Thread(new MyRunnable2());
         t1.setPriority(10);
         t2.setPriority(1);
         t2.start();
         t1.start();

     }
 }
 class MyThread_2 extends Thread{
     public void run(){
         for(int i=0;i<10;i++){
             System.out.println("线程1第"+i+"次执行！");
             try{
                 Thread.sleep(100);//影响的是执行速度。
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
         }
     }
 }
 class MyRunnable2 implements Runnable{
     public void run(){
         for(int i=0;i<10;i++){
             System.out.println("线程2第"+i+"次执行！");
             try{
                 Thread.sleep(100);
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
         }
     }
 }

　　结果为：

 线程1第0次执行！
 线程2第0次执行！
 线程1第1次执行！
 线程2第1次执行！
 线程1第2次执行！
 线程2第2次执行！
 线程1第3次执行！
 线程2第3次执行！
 线程1第4次执行！
 线程2第4次执行！
 线程1第5次执行！
 线程2第5次执行！
 线程2第6次执行！
 线程1第6次执行！
 线程1第7次执行！
 线程2第7次执行！
 线程1第8次执行！
 线程2第8次执行！
 线程1第9次执行！
 线程2第9次执行！

 三、守护线程

　　调用t.setDaemon(true)将线程转换成守护线程。守护线程的唯一用途是为其他线程提供服务。比如说，JVM的垃圾回收、内存管理等线程都是守护线程。计时线程就是一个例子，它定时的发送“计时器滴答”信号给其他线程或清空过时的高速缓存项的线程，最后只剩下守护线程时，JVM就退出了。

　　setDaemon方法的详细说明：

 public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，JVM退出。
     该方法首先调用该线程的checkAccess方法，不带任何参数，可能抛出SecurityException(在当前线程中)。

     参数：
         on-如果为true，则将该线程标记为守护线程。
     抛出：
         IllegalThreadStateException-如果该线程处于活动状态。
         SecrurityException-如果当前无法修改该线程。
     另请参见：
         isDaemon(),checkAccess()

　　具体例子：当最后只剩下守护线程在运行时，JVM退出。

　　DaemonTest.java

 package Thread;
 public class PriorityTest {
     public static void main(String[] args){
         Thread t1=new MyThread_2();
         Thread t2=new Thread(new MyRunnable2());
         t2.setDaemon(true);//设置为守护线程
         t2.start();
         t1.start();

     }
 }
 class MyThread_2 extends Thread{
     public void run(){
         for(int i=0;i<5;i++){
             System.out.println("线程1第"+i+"次执行！");
             try{
                 Thread.sleep(7);//影响的是执行速度。
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
         }
     }
 }
 class MyRunnable2 implements Runnable{
     public void run(){
         for(int i=0;i<99999L;i++){
             System.out.println("线程2第"+i+"次执行！");
             try{
                 Thread.sleep(7);
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
         }
     }
 }

　　结果为：

 线程2第0次执行！
 线程1第0次执行！
 线程1第1次执行！
 线程2第1次执行！
 线程1第2次执行！
 线程2第2次执行！
 线程1第3次执行！
 线程2第3次执行！
 线程1第4次执行！
 线程2第4次执行！
 线程2第5次执行！

四、未捕获异常处理器

　　run方法不能抛出任何被检测的异常，但是，不被检测的异常就会导致线程的终止。但是不需要任何catch字句来处理被传播的异常。相反，死亡之前，异常被传递到一个用于未捕获异常处理器。该处理器实现一个Thread.UncaughtExceptionHandler接口的类。这个接口只有一个方法即：void uncaughtException(Thread t，Throwable e)

　　用setUncaughtaExceptionHandler方法为任何线程安装一个处理器。但是如果不为此独立的线程安装处理器，则ThreadGroup类对象即为此时的处理器。

　　ThreadGroup类实现了Thread.UncaughtExceptionHandler接口。它的uncaughtException方法做如下操作：

　　　　1) 如果该线程组有父线程组，那么父线程组的uncaughtException方法被调用。

　　　　2) 否则，如果Thread.getDefaultExceptionHandler方法返回一个非空的处理器，则调用该处理器。

　　　　3) 否则，如果Throwable是ThreadDeath的一个实例，什么都不做。

　　　　4) 否则，线程的名字以及Throwable的栈轨迹被输出到System.err上。此时可以看到多次的栈轨迹。

五、让步

　　让步就是使当前运行的线程让出CPU资源，虽然不知道给谁，仅仅是让出，线程状态回到可运行状态。其中让步使用Thread.yield()方法，yield方法为静态方法，功能是暂停当前执行的线程对象，并执行其他线程。例子：一个线程先让步，让另一个线程先执行，然后再执行该线程。

　　YieldTest.java

 package Thread;
 public class PriorityTest {
     public static void main(String[] args){
         Thread t1=new MyThread_2();
         Thread t2=new Thread(new MyRunnable2());
         t2.start();
         t1.start();

     }
 }
 class MyThread_2 extends Thread{
     public void run(){
         for(int i=0;i<10;i++){
             System.out.println("线程1第"+i+"次执行！");
             /*try{
                 Thread.sleep(7);//影响的是执行速度。
             }catch(InterruptedException e){
                 e.printStackTrace();
             }*/
         }
     }
 }
 class MyRunnable2 implements Runnable{
     public void run(){
         for(int i=0;i<10;i++){
             System.out.println("线程2第"+i+"次执行！");
             Thread.yield();
             /*try{
                 Thread.sleep(7);
             }catch(InterruptedException e){
                 e.printStackTrace();
             }*/
         }
     }
 }

　　结果为：

 线程1第0次执行！
 线程1第1次执行！
 线程1第2次执行！
 线程1第3次执行！
 线程1第4次执行！
 线程1第5次执行！
 线程1第6次执行！
 线程1第7次执行！
 线程1第8次执行！
 线程1第9次执行！
 线程2第0次执行！
 线程2第1次执行！
 线程2第2次执行！
 线程2第3次执行！
 线程2第4次执行！
 线程2第5次执行！
 线程2第6次执行！
 线程2第7次执行！
 线程2第8次执行！
 线程2第9次执行！

 六、合并

　　合并就是将几个并行线程的线程合并为一个单线程执行，应用场景就是当一个线程等待另一个线程执行完毕后才能执行，可以使用join方法。思想是当执行join方法后，主线程暂停，转而执行新加入的线程，等到新加入的线程执行完毕后，才能继续执行主线程。

 void join()
     等待该线程终止。
 void join(long millis)
     等待该线程终止的时间最长为millis
 void join(long millis,int nanos)
     等待该线程终止的最长时间为millis+nanos纳秒

　　JoinTest.java

 package Thread;
 public class PriorityTest {
     public static void main(String[] args){
         Thread t1=new MyThread_2();
         //Thread t2=new Thread(new MyRunnable2());
         //t2.start();
         t1.start();
         for(int i=0;i<20;i++){
             System.out.println("主线程第"+i+"次执行！");
             if(i>2)
                 try{
                     t1.join();//t1线程合并到主线程中，主线程停止执行过程，转而执行t1线程，直到t1执行完毕后继续。
                     //Thread.sleep(7);//影响的是执行速度。
                 }catch(InterruptedException e){
                     e.printStackTrace();
                 }
         }
     }
 }
 class MyThread_2 extends Thread{
     public void run(){
         for(int i=0;i<10;i++){
             System.out.println("线程1第"+i+"次执行！");
             /*if(i>2)
                 try{
                     Thread.sleep(7);//影响的是执行速度。
                 }catch(InterruptedException e){
                     e.printStackTrace();
                 }*/
         }
     }
 }
 /*class MyRunnable2 implements Runnable{
     public void run(){
         for(int i=0;i<10;i++){
             System.out.println("线程2第"+i+"次执行！");
             Thread.yield();
             /*try{
                 Thread.sleep(7);
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
         }
     }
 }*/

　　结果为：

 主线程第0次执行！
 主线程第1次执行！
 主线程第2次执行！
 线程1第0次执行！
 线程1第1次执行！
 线程1第2次执行！
 线程1第3次执行！
 线程1第4次执行！
 线程1第5次执行！
 线程1第6次执行！
 线程1第7次执行！
 线程1第8次执行！
 线程1第9次执行！
 主线程第3次执行！
 主线程第4次执行！
 主线程第5次执行！
 主线程第6次执行！
 主线程第7次执行！
 主线程第8次执行！
 主线程第9次执行！
 主线程第10次执行！
 主线程第11次执行！
 主线程第12次执行！
 主线程第13次执行！
 主线程第14次执行！
 主线程第15次执行！
 主线程第16次执行！
 主线程第17次执行！
 主线程第18次执行！
 主线程第19次执行！