了解Java线程优先级，更要知道对应操作系统的优先级，不然会踩坑

java 多线程系列第 6 篇。

这篇我们来看看 java 线程的优先级。

java 线程优先级

thread 类中，使用如下属性来代表优先级。

private int priority;

我们可以通过 setpriority(int newpriority) 来设置新的优先级，通过 getpriority() 来获取线程的优先级。

有些资料通过下面的例子就得出了一个结论：java 线程默认优先级是 5。

public static void main(string[] args) {
    thread thread = new thread();
    system.out.println(thread.getpriority());
}

// 打印结果：5

其实这是大错特错的，只是看到了表面，看看下面的例子，我们把当前线程的优先级改为 4，发现子线程 thread 的优先级也是 4。

public static void main(string[] args) {
    thread.currentthread().setpriority(4);
    thread thread = new thread();
    system.out.println(thread.getpriority());
}

// 打印结果：4

这啪啪啪打脸了，如果是线程默认优先级是 5，我们新创建的 thread 线程，没设置优先级，理应是 5，但实际是 4。我们看看 thread 初始化 priority 的源代码。

thread parent = currentthread();
this.priority = parent.getpriority();

原来，线程默认的优先级是继承父线程的优先级，上面例子我们把父线程的优先级设置为 4，所以导致子线程的优先级也变成 4。

严谨一点说，子线程默认优先级和父线程一样，java 主线程默认的优先级是 5。

java 中定义了 3 种优先级，分别是最低优先级（1）、正常优先级（5）、最高优先级（10），代码如下所示。java 优先级范围是 [1, 10]，设置其他数字的优先级都会抛出 illegalargumentexception 异常。

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

接下来说说线程优先级的作用。先看下面代码，代码逻辑是创建了 3000 个线程，分别是： 1000 个优先级为 1 的线程， 1000 个优先级为 5 的线程，1000 个优先级为 10 的线程。用 mintimes 来记录 1000 个 min_priority 线程运行时时间戳之和，用 normtimes 来记录 1000 个 norm_priority 线程运行时时间戳之和，用 maxtimes 来记录 1000 个 max_priority 线程运行时时间戳之和。通过统计每个优先级的运行的时间戳之和，值越小代表的就是越优先执行。我们运行看看。

public class testpriority {
    static atomiclong mintimes = new atomiclong(0);
    static atomiclong normtimes = new atomiclong(0);
    static atomiclong maxtimes = new atomiclong(0);

    public static void main(string[] args) {
        list<mythread> minthreadlist = new arraylist<>();
        list<mythread> normthreadlist = new arraylist<>();
        list<mythread> maxthreadlist = new arraylist<>();

        int count = 1000;
        for (int i = 0; i < count; i++) {
            mythread mythread = new mythread("min----" + i);
            mythread.setpriority(thread.min_priority);
            minthreadlist.add(mythread);
        }
        for (int i = 0; i < count; i++) {
            mythread mythread = new mythread("norm---" + i);
            mythread.setpriority(thread.norm_priority);
            normthreadlist.add(mythread);
        }
        for (int i = 0; i < count; i++) {
            mythread mythread = new mythread("max----" + i);
            mythread.setpriority(thread.max_priority);
            maxthreadlist.add(mythread);
        }

        for (int i = 0; i < count; i++) {
            maxthreadlist.get(i).start();
            normthreadlist.get(i).start();
            minthreadlist.get(i).start();
        }

        try {
            thread.sleep(3000);
        } catch (interruptedexception e) {
            e.printstacktrace();
        }

        system.out.println("maxpriority 统计：" + maxtimes.get());
        system.out.println("normpriority 统计：" + normtimes.get());
        system.out.println("minpriority 统计：" + mintimes.get());
        system.out.println("普通优先级与最高优先级相差时间：" + (normtimes.get() - maxtimes.get()) + "ms");
        system.out.println("最低优先级与普通优先级相差时间：" + (mintimes.get() - normtimes.get()) + "ms");

    }

    static class mythread extends thread {

        public mythread(string name) {
            super(name);
        }

        @override
        public void run() {
            system.out.println(this.getname() + " priority: " + this.getpriority());
            switch (this.getpriority()) {
                case thread.max_priority :
                    maxtimes.getandadd(system.currenttimemillis());
                    break;
                case thread.norm_priority :
                    normtimes.getandadd(system.currenttimemillis());
                    break;
                case thread.min_priority :
                    mintimes.getandadd(system.currenttimemillis());
                    break;
                default:
                    break;
            }
        }
    }
}

执行结果如下：

# 第一部分
max----0 priority: 10
norm---0 priority: 5
max----1 priority: 10
max----2 priority: 10
norm---2 priority: 5
min----4 priority: 1
.......
max----899 priority: 10
min----912 priority: 1
min----847 priority: 5
min----883 priority: 1

# 第二部分
maxpriority 统计：1568986695523243
normpriority 统计：1568986695526080
minpriority 统计：1568986695545414
普通优先级与最高优先级相差时间：2837ms
最低优先级与普通优先级相差时间：19334ms

我们一起来分析一下结果。先看看第一部分，最开始执行的线程高优先级、普通优先级、低优先级都有，最后执行的线程也都有各个优先级的，这说明了：优先级高的线程不代表一定比优先级低的线程优先执行。也可以换另一种说法：代码执行顺序跟线程的优先级无关。看看第二部分的结果，我们可以发现最高优先级的 1000 个线程执行时间戳之和最小，而最低优先级的 1000 个线程执行时间戳之和最大，因此可以得知：一批高优先级的线程会比一批低优先级的线程优先执行，即高优先级的线程大概率比低优先的线程优先获得 cpu 资源。

各操作系统中真有 10 个线程等级么？

java 作为跨平台语言，线程有 10 个等级，但是映射到不同操作系统的线程优先级值不一样。接下来教大家怎么在 openjdk 源码中查各个操作系统中线程优先级映射的值。

1. 看到 thread 源代码，设置线程优先级最终调用了本地方法 setpriority0()；

private native void setpriority0(int newpriority);

1. 接着我们在 openjdk 的 thread.c 代码中找到 setpriority0() 对应的方法 jvm_setthreadpriority；

static jninativemethod methods[] = {
    ...
    {"setpriority0",     "(i)v",       (void *)&jvm_setthreadpriority},
    ...
};

1. 我们根据 jvm_setthreadpriority 找到 jvm.cpp 中对应的代码段；

jvm_entry(void, jvm_setthreadpriority(jnienv* env, jobject jthread, jint prio))
  jvmwrapper("jvm_setthreadpriority");
  // ensure that the c++ thread and osthread structures aren't freed before we operate
  mutexlocker ml(threads_lock);
  oop java_thread = jnihandles::resolve_non_null(jthread);
  java_lang_thread::set_priority(java_thread, (threadpriority)prio);
  javathread* thr = java_lang_thread::thread(java_thread);
  if (thr != null) {                  // thread not yet started; priority pushed down when it is
    thread::set_priority(thr, (threadpriority)prio);
  }
jvm_end

1. 根据第 3 步中的代码，我们可以发现关键是 java_lang_thread::set_priority() 这段代码，继续找 thread.cpp 代码中的 set_priority() 方法；

void thread::set_priority(thread* thread, threadpriority priority) {
  trace("set priority", thread);
  debug_only(check_for_dangling_thread_pointer(thread);)
  // can return an error!
  (void)os::set_priority(thread, priority);
}

1. 发现上面代码最终调用的是 os::set_priority()，接着继续找出 os.cpp 的 set_priority() 方法；

osreturn os::set_priority(thread* thread, threadpriority p) {
#ifdef assert
  if (!(!thread->is_java_thread() ||
         thread::current() == thread  ||
         threads_lock->owned_by_self()
         || thread->is_compiler_thread()
        )) {
    assert(false, "possibility of dangling thread pointer");
  }
#endif

  if (p >= minpriority && p <= maxpriority) {
    int priority = java_to_os_priority[p];
    return set_native_priority(thread, priority);
  } else {
    assert(false, "should not happen");
    return os_err;
  }
}

1. 终于发现了最终转换为各操作系统的优先级代码 java_to_os_priority[p]，接下来就是找各个操作系统下的该数组的值。比如下面是 linux 系统的优先级值。

int os::java_to_os_priority[criticalpriority + 1] = {
  19,              // 0 entry should never be used

   4,              // 1 minpriority
   3,              // 2
   2,              // 3

   1,              // 4
   0,              // 5 normpriority
  -1,              // 6

  -2,              // 7
  -3,              // 8
  -4,              // 9 nearmaxpriority

  -5,              // 10 maxpriority

  -5               // 11 criticalpriority
};

好了，大家应该知道怎么找出 java 线程优先级 [1,10] 一一对应各个操作系统中的优先级值。下面给大家统计一下。

java 线程优先级	linux	windows	apple	bsd	solaris
1	4	thread_priority_lowest(-2)	27	0	0
2	3	thread_priority_lowest(-2)	28	3	32
3	2	thread_priority_below_normal(-1)	29	6	64
4	1	thread_priority_below_normal(-1)	30	10	96
5	0	thread_priority_normal(0)	31	15	127
6	-1	thread_priority_normal(0)	32	18	127
7	-2	thread_priority_above_normal(1)	33	21	127
8	-3	thread_priority_above_normal(1)	34	25	127
9	-4	thread_priority_highest(2)	35	28	127
10	-5	thread_priority_highest(2)	36	31	127

windows 系统的在 openjdk 源码中只找到上面的常量，值是通过微软提供的函数接口文档查到的，链接在这：setthreadpriority

我们从这个表格中也可以发现一些问题，即使我们在 java 代码中设置了比较高的优先级，其实映射到操作系统的线程里面，并不一定比设置了低优先级的线程高，很有可能是相同的优先级。看看 solaris 操作系统 这个极端的例子，优先级 5 到 10 映射的是相同的线程等级。

回头想想上面的例子为什么 3000 个线程，max_priority 优先级的 1000 个线程会优先执行呢？因为我们的 3 个优先级分别映射到 windows 操作系统线程的 3 个不同的等级，所以才会生效。假设将 1、5、10 改成 5、6、7，运行结果那就不大一样了。

最后记住：切莫把线程优先级当做银弹，优先级高的线程不一定比优先级低的线程优先执行。

这篇线程优先级文章也告段落了，朋友们看完觉得有用麻烦帮点个在看，推荐给身边朋友看看，原创不易。

推荐阅读

了解java线程优先级，更要知道对应操作系统的优先级，不然会踩坑

线程最最基础的知识

老板叫你别阻塞了

吃个快餐都能学到串行、并行、并发

泡一杯茶，学一学同异步

进程知多少？

设计模式看了又忘，忘了又看？

后台回复『设计模式』可以获取《一故事一设计模式》电子书

觉得文章有用帮忙转发&点赞，多谢朋友们！