Java并发09:Thread的基本方法(6)-线程优先级priority相关说明与操作

本章主要对Java中Thread类的基本方法进行学习。

1.序言

Thread类作为线程的基类，提供了一系列方法，主要有：
        Thread.sleep(long)：强制线程睡眠一段时间。
        Thread.activeCount()：获取当前程序中存活的线程数。
        thread.start()：启动一个线程。
        Thread.currentThread()：获取当前正在运行的线程。
        thread.getThreadGroup()：获取线程所在线程组。
        thread.getName()：获取线程的名字。
        thread.getPriority()：获取线程的优先级。
        thread.setName(name)：设置线程的名字。
        thread.setPriority(priority)：设置线程的优先级。
        thread.isAlive()：判断线程是否还存活着。
        thread.isDaemon()：判断线程是否是守护线程。
        thread.setDaemon(true)：将指定线程设置为守护线程。
        thread.join()：在当前线程中加入指定线程，使得这个指定线程等待当前线程，并在当前线程结束前结束。
        thread.yield()：使得当前线程退让出CPU资源，把CPU调度机会分配给同样线程优先级的线程。
        thread.interrupt()：使得指定线程中断阻塞状态，并将阻塞标志位置为true。
        object.wai()、object.notify()、object.notifyAll()：Object类提供的线程等待和线程唤醒方法。
为了便于阅读，将以上所有方法，放在5篇文章中进行学习。

本章主要学习绿色字体标记的方法，其他方法请参加其他章节。

2.线程优先级简介

直接看Thread中的源码：

 /**
     * 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;

    /**
     * Returns this thread's priority.
     */
    public final int getPriority() {
        return priority;
    }

    /**
     * Changes the priority of this thread.
     * ...
     * @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>.
     * ...
     */
    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]
• 通过thread.setPriority(int)设置线程的优先级时，超出[1~10]的范围，会抛出一个IllegalArgumentException异常。
• 最大的线程优先级为Thread.MAX_PRIORITY = 10。
• 最小的线程优先级为Thread.MIN_PRIORITY = 1。
• 默认的线程优先级为Thread.NORM_PRIORITY = 5。
• 通过thread.getPriority()、thread.setPriority()分别能够获取和设置线程的优先级。
• 线程的优先级具有继承传递性。子线程的优先级与父线程优先级一致。
• 虽然线程优先级有10个级别，但是推荐只使用内置的三个等级。

3.实例代码与结果分析

那优先级的作用是什么呢？很多人以为：高优先级的线程会一定最先启动，高优先级的线程一定会最先运行完。其实我也一直很困惑，然后我就查了查JDK的源码注释，看到下面一段话：

/**
 * ...
 * <p>
 * Every thread has a priority. Threads with higher priority are
 * executed in preference to threads with lower priority. Each thread
 * may or may not also be marked as a daemon. When code running in
 * some thread creates a new <code>Thread</code> object, the new
 * thread has its priority initially set equal to the priority of the
 * creating thread, and is a daemon thread if and only if the
 * creating thread is a daemon.
 * <p>
 * ...
 * @since   JDK1.0
 */
public
class Thread implements Runnable {...}

这段话翻译过来就是：

• 每个线程都有一个优先级。
• 优先级较高的线程比优先级低的线程优先执行。
• 每个线程可能会与可能不会被标记为守护线程。
• 当运行中的某个线程，创建了一个新的线程时，这个新线程的初识优先级与创建它的线程一致。

综合上面的注释，我认为线程的优先级的作用如下：

• 在同一时刻，优先级高的线程优先启动。
• 在多线程运行中，优先级高的线程能得到更多的计算资源。
• 优先级高的线程并不一定最先运行结束，这取决于这个线程所处理的内容。
• 优先级低的线程并不是非要等到优先级高的线程运行完再运行，因为多线程本来指的就是线程之间的来回切换与调度。

3.1.实例代码与运行结果
下面编写代码验证一下：

线程类：

static class SleepThread extends Thread {
    /**
     * <p>重写Thread类的构造器，用以给线程命名</br>
     * 此种方式无需定义name变量以指定线程名，因为父类Thread中已有。</p>
     * @author hanchao 2018/3/8 22:59
     **/
    public SleepThread(String name) {
        super(name);
    }

    /**
     * <p>业务代码写在run()方法中，此方法无返回值</p>
     * @author hanchao 2018/3/8 22:55
     **/
    @Override
    public void run(){
        Integer interval = RandomUtils.nextInt(100000,2000000);
        System.out.println(System.nanoTime() + " : 线程[" + super.getName() + "]正在运行，预计运行" + interval + "...");
        try {
            Thread.sleep(interval);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            System.out.println(System.nanoTime() + " : 线程[" + super.getName() + "]运行结束");
        }
    }
}

 

测试方法：

int num = 9;
Thread[] threads = new Thread[num];
//优先级与线程的执行顺序
//注意多核CPU与单核CPU
for (int i = 0; i < num; i++) {
    //部分线程设置为高级线程
    if ( i < (num / 3)){
        threads[i] = new SleepThread("高优先级线程-" + i);
        threads[i].setPriority(Thread.MAX_PRIORITY);
    }else if(i >= (num / 3) && i < (num / 3) * 2){//部分线程设置为中级线程
        threads[i] = new SleepThread("中优先级线程-" + i);
        threads[i].setPriority(Thread.NORM_PRIORITY);
    }else{//其余线程设置为低级线程
        threads[i] = new SleepThread("低优先级线程-" + i);
        threads[i].setPriority(Thread.MIN_PRIORITY);
    }
}
//统一运行线程
for(int i = 0; i < num; i++) {
    threads[i].start();
}
System.out.println("=====================================");

结果分析：

=====================================
8848521183215 : 线程[高优先级线程-2]正在运行，预计运行327224...
8848521300084 : 线程[高优先级线程-0]正在运行，预计运行281455...
8848521177918 : 线程[高优先级线程-1]正在运行，预计运行252035...
8848522412158 : 线程[中优先级线程-4]正在运行，预计运行474837...
8848521330211 : 线程[中优先级线程-3]正在运行，预计运行442771...
8848523015705 : 线程[中优先级线程-5]正在运行，预计运行310583...
8848524692921 : 线程[低优先级线程-6]正在运行，预计运行457768...
8848530180789 : 线程[低优先级线程-7]正在运行，预计运行152680...
8848530739971 : 线程[低优先级线程-8]正在运行，预计运行338034...
9001210393973 : 线程[低优先级线程-7]运行结束
9100557081471 : 线程[高优先级线程-1]运行结束
9129977265872 : 线程[高优先级线程-0]运行结束
9159106026490 : 线程[中优先级线程-5]运行结束
9175745463719 : 线程[高优先级线程-2]运行结束
9186564876256 : 线程[低优先级线程-8]运行结束
9291293550927 : 线程[中优先级线程-3]运行结束
9306292909308 : 线程[低优先级线程-6]运行结束
9323360172767 : 线程[中优先级线程-4]运行结束

这个结果显示：高优先级的线程会优先运行，但是高优先级的线程未必会最先运行完。

3.3.其他结果
其实，在验证线程优先级作用的过程中，产生过各种各样的结果，很多结果看起来与优先级的作用相违背。产生这些结果可能的原因有：

运行日志无法完美展示JVM的运行过程，写日志也会消耗资源。
多核处理器的影响。在多核处理器上运行多线程，不仅会产生并发效果，也会产生并行效果。
线程进入JVM的时间不同。JVM并不是在同一时刻启动所有的线程，线程本身的启动也有先后顺序。
4.总结
关于多线程优先级的作用，我总认为自己理解不够透彻。如果谁有更好的见解，请多指教，谢谢！