线程的优先级

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

/** * Changes the priority of this thread. * <p> * First the <code>checkAccess</code> method of this thread is called * with no arguments. This may result in throwing a * <code>SecurityException</code>. * <p> * Otherwise, the priority of this thread is set to the smaller of * the specified <code>newPriority</code> and the maximum permitted * priority of the thread's thread group. * * @param newPriority priority to set this thread to * @exception  IllegalArgumentException  If the priority is not in the *               range <code>MIN_PRIORITY</code> to *               <code>MAX_PRIORITY</code>. * @exception  SecurityException  if the current thread cannot modify *               this thread. * @see        #getPriority * @see        #checkAccess() * @see        #getThreadGroup() * @see        #MAX_PRIORITY * @see        #MIN_PRIORITY * @see        ThreadGroup#getMaxPriority() */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中使用三个常量来预置定义优先级的值，代码如下：

/** * 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是一样的。

// class Bpublic class ThreadB extends Thread {    @Override    public void run() {        System.out.println("ThreadB run priority=" + this.getPriority());    }}// class Apublic class ThreadA extends Thread {    @Override    public void run() {        System.out.println("ThreadA run priority=" + this.getPriority());        ThreadB threadB = new ThreadB();        threadB.start();    }}// mainpublic static void main(String[] args) {    threadA();}private static void threadA() {    System.out.println("Main begin priority=" + Thread.currentThread().getPriority());//  Thread.currentThread().setPriority(6);    System.out.println("Main end priority=" + Thread.currentThread().getPriority());    ThreadA threadA = new ThreadA();    threadA.start();}

输出结果：

Main begin priority=5Main end priority=5ThreadA run priority=5ThreadB run priority=5

解开注释Thread.currentThread().setPriority(6);后运行结果如下：

Main begin priority=5Main end priority=6ThreadA run priority=6ThreadB run priority=6

线程的优先级具有规则性，即优先级越高的线程分配的cpu执行时间越多。

线程的优先级具有随机性，即优先级差距不大的两个线程获取的cpu执行时间是随机的。

综上所述：不要把线程的优先级与运行结果的顺序作为衡量的标准，优先级较高的线程并不一定每一次都要先执行完run()方法中的任务，也就是说，线程的优先级具有随机性和不确定性。