线程的优先级

　　在操作系统中，线程可以划分优先级，优先级较高的线程得到的CPU资源较多，也就是CPU优先执行优先级较高的线程对象中的任务。
　　设置线程优先级有助于帮助“线程规划器“确定在下一次选择哪个线程优先执行。
设置线程优先级使用setPriotity()方法，此方法具体如下：

public final void setPriority(int newPriority) {
        ThreadGroup g;
        checkAccess();
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
            throw new IllegalArgumentException();
        }
        if((g = getThreadGroup()) != null) {
            if (newPriority > g.getMaxPriority()) {
                newPriority = g.getMaxPriority();
            }
            setPriority0(priority = newPriority);
        }
}

　　在Java中，线程的优先级分为1~10这10个等级，如果小于1或者大于10，则JDK抛出异常IllegalArgumentException();
　　JDK中使用3个常量来预定义优先级的值，代码如下：
　　

  /**
    * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
      public final static int MAX_PRIORITY = 10;

线程优先级的继承特性

　　在Java中，线程的优先级具有继承性，比如A线程启动B线程，则B线程的优先级与A线程一样。创建如下代码：

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread run prioirty="+this.getPriority());
        MyThread2 t2 = new MyThread2();
        t2.start();
    }
}
public class MyThread2 extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread2 run prioirty="+this.getPriority());
    }
}
public class Run {
    public static void main(String[] args) {
        System.out.println("main thread begin priority="+Thread.currentThread().getPriority());
        //Thread.currentThread().setPriority(6);
        System.out.println("main thread end priority="+Thread.currentThread().getPriority());
        MyThread t = new MyThread();
        t.start();
    }
}

程序运行结果：

将下面代码注释去掉

//Thread.currentThread().setPriority(6);

再次运行，结果如下：

优先级具有规则性

　　虽然使用setPriority()方法可以设置线程的优先级，但是还没有看到设置优先级所带来的效果。创建如下示例代码：

public class MyThread extends Thread{

    @Override
    public void run() {
        long starTime = System.currentTimeMillis();
        long result = 0;
        for(int i=0;i<50000;i++){
            Random r = new Random();
            r.nextInt();
            result = result+ i;
        }

        long endTime = System.currentTimeMillis();

        System.out.println("****************thread 1 use time="+(endTime-starTime)+"*********************");
    }
}
public class MyThread2 extends Thread{

    @Override
    public void run() {
        long starTime = System.currentTimeMillis();
        long result = 0;
        for(int i=0;i<50000;i++){
            Random r = new Random();
            r.nextInt();
            result = result+ i;
        }

        long endTime = System.currentTimeMillis();

        System.out.println("****************thread 2 use time="+(endTime-starTime)+"*********************");
    }
}
public class Run {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {

            MyThread t1 = new MyThread();
            t1.setPriority(10);
            t1.start();

            MyThread2 t2 = new MyThread2();
            t2.setPriority(1);
            t2.start();


        }
    }
}

执行结果如下：

从执行结果来看，高优先级的线程总是大部分执行完，单不完全代表高优先级全部执行完。另外，不要以为thread1线程先被main线程调用就会先执行完，出现这样的结果全是因为thread1线程的优先级是最高的10造成的，当线程的优先等级差距很大时，谁先执行完和代码的调用顺序无关。为了验证这个结论，继续修改代码如下：

public class Run {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {

            MyThread2 t2 = new MyThread2();
            t2.setPriority(1);
            t2.start();

            MyThread t1 = new MyThread();
            t1.setPriority(10);
            t1.start();
        }
    }
}

执行结果如下：

从执行结果来看，还是thread1先执行完，也就是线程的优先级与代码执行顺序无关，出现这样的结果是因为thred1的优先级是最高的，说明线程的优先级具有一定的规则性，也就是CPU尽量将执行资源让给优先级比较高的线程。

优先级具有随机性：

　　前面讲了优先级较高则先执行完run()方法中的任务，但是这个结果不能说的太肯定，因为线程的优先级还具有”随机性“，也就是优先级高的线程不一定每一次都先执行完。创建如下示例代码：

public class MyThread extends Thread{

    @Override
    public void run() {
        long starTime = System.currentTimeMillis();
        long result = 0;
        for(int i=0;i<50000;i++){
            Random r = new Random();
            r.nextInt();
            result = result+ i;
        }

        long endTime = System.currentTimeMillis();

        System.out.println("****************thread 1 use time="+(endTime-starTime)+"*********************");
    }
}
public class MyThread2 extends Thread{

    @Override
    public void run() {
        long starTime = System.currentTimeMillis();
        long result = 0;
        for(int i=0;i<50000;i++){
            Random r = new Random();
            r.nextInt();
            result = result+ i;
        }

        long endTime = System.currentTimeMillis();

        System.out.println("****************thread 2 use time="+(endTime-starTime)+"*********************");
    }
}
public class Run {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {

            MyThread t1 = new MyThread();
            t1.setPriority(5);
            t1.start();

            MyThread2 t2 = new MyThread2();
            t2.setPriority(6);
            t2.start();


        }
    }
}

执行结果如下：

不要把线程的优先级与运行结果的顺序作为衡量的标准，优先级较高的线程不一定每一次都先执行完run()方法中的任务。