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

2024-06-14 05:58
文章标签 java 线程 优先级 操作系统 了解 对应 知道 更要

本文主要是介绍了解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);}@Overridepublic 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 operateMutexLocker 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 isThread::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 ASSERTif (!(!thread->is_Java_thread() ||Thread::current() == thread  ||Threads_lock->owned_by_self()|| thread->is_Compiler_thread())) {assert(false, "possibility of dangling Thread pointer");}
#endifif (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 used4,              // 1 MinPriority3,              // 22,              // 31,              // 40,              // 5 NormPriority-1,              // 6-2,              // 7-3,              // 8-4,              // 9 NearMaxPriority-5,              // 10 MaxPriority-5               // 11 CriticalPriority
};

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

Java 线程优先级LinuxWindowsAppleBsdSolaris
14THREAD_PRIORITY_LOWEST(-2)2700
23THREAD_PRIORITY_LOWEST(-2)28332
32THREAD_PRIORITY_BELOW_NORMAL(-1)29664
41THREAD_PRIORITY_BELOW_NORMAL(-1)301096
50THREAD_PRIORITY_NORMAL(0)3115127
6-1THREAD_PRIORITY_NORMAL(0)3218127
7-2THREAD_PRIORITY_ABOVE_NORMAL(1)3321127
8-3THREAD_PRIORITY_ABOVE_NORMAL(1)3425127
9-4THREAD_PRIORITY_HIGHEST(2)3528127
10-5THREAD_PRIORITY_HIGHEST(2)3631127

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

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

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

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

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

推荐阅读

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

线程最最基础的知识

老板叫你别阻塞了

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

泡一杯茶，学一学同异步

进程知多少？

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

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

觉得文章有用帮忙转发&点赞，多谢朋友们！
在这里插入图片描述

这篇关于了解Java线程优先级，更要知道对应操作系统的优先级，不然会踩坑的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1059565。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
关于数据埋点，你需要了解这些基本知识

关于数据埋点，你需要了解这些基本知识

产品汪每天都在和数据打交道，你知道数据来自哪里吗？ 移动app端内的用户行为数据大多来自埋点，了解一些埋点知识，能和数据分析师、技术侃大山，参与到前期的数据采集，更重要是让最终的埋点数据能为我所用，否则可怜巴巴等上几个月是常有的事。   埋点类型 根据埋点方式，可以区分为： 手动埋点半自动埋点全自动埋点 秉承“任何事物都有两面性”的道理：自动程度高的，能解决通用统计，便于统一化管理，但个性化定
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2