Java并发编程:什么是线程优先级?

开发 前端
Java只是为操作系统提供了一个线程优先级的参考值。线程在操作系统中的最终优先级仍然由操作系统决定。线程的执行顺序最终由操作系统中的调度器决定,线程的优先级肯定是在线程被调用之前设置的。

线程优先级是操作系统在调度线程时为每个线程分配的执行顺序优先级。优先级较高的线程会先于优先级较低的线程执行。

在Java中,线程的优先级可以设置为1到10之间的值,默认的线程优先级是5。

源码:

图片图片

  • MIN_PRIORITY:线程的最低优先级,值为1。
  • NORM_PRIORITY:线程的默认优先级,值为5。
  • MAX_PRIORITY:线程的最高优先级,值为10。

然而,并非所有操作系统都支持10个级别的优先级(例如,有些操作系统只支持3个级别:)。

Java只是为操作系统提供了一个线程优先级的参考值。线程在操作系统中的最终优先级仍然由操作系统决定。

线程的执行顺序最终由操作系统中的调度器决定,线程的优先级肯定是在线程被调用之前设置的。

一般来说,优先级较高的线程比优先级较低的线程有更高的机会被执行。我们可以使用Thread类的setPriority()方法来设置线程的优先级。

public class Demo {
    public static void main(String[] args) {
        Thread a = new Thread();
        System.out.println("默认线程优先级: " + a.getPriority());
        Thread b = new Thread();
        b.setPriority(9);
        System.out.println("设置线程优先级: " + b.getPriority());
    }
}

输出:

默认线程优先级: 5
设置线程优先级: 9

为什么不推荐使用线程优先级?

既然有1到10的级别来设置线程的优先级,你可能会问:我可以在业务代码中使用这个方法来指定某些线程的执行顺序吗?

我的回答是:不行!

Java中的优先级并不可靠,在Java程序中设置的线程优先级只是对操作系统的一个建议,操作系统不一定会采纳。实际的执行顺序由操作系统的线程调度算法决定

让我们用代码来验证一下:

public class TestExecuteOrder {
    staticclass MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.printf("当前执行的线程是: %s, 优先级: %d%n",
                    Thread.currentThread().getName(),
                    Thread.currentThread().getPriority());
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.setPriority(1);
        Thread t2 = new Thread(new MyRunnable());
        t2.setPriority(5);
        Thread t3 = new Thread(new MyRunnable());
        t3.setPriority(10);
        t3.start();
        t2.start();
        t1.start();
    }
}

如果按顺序执行,这个程序应该按照10、5、1的顺序输出。

但看看某个特定的输出:

当前执行的线程是: Thread-1, 优先级: 5
当前执行的线程是: Thread-2, 优先级: 10
当前执行的线程是: Thread-0, 优先级: 1

优先级为5的线程实际上在优先级为10的线程之前输出了结果,所以看起来这个优先级设置确实不可靠 。

线程优先级与线程组优先级的关系

在前一篇文章中,我们讨论过线程必须存在于一个线程组中。那么,当线程的优先级与线程组的优先级不同时会发生什么呢?让我们用以下代码来验证:

public class ThreadGroupOrder {
    public static void main(String[] args) {
        ThreadGroup myThreadGroup = new ThreadGroup("myThreadGroup");
        myThreadGroup.setMaxPriority(6);
        Thread myThread = new Thread(myThreadGroup, "myThread");
        myThread.setPriority(8);
        System.out.println("线程组优先级: " + myThreadGroup.getMaxPriority());
        System.out.println("线程优先级: " + myThread.getPriority());
    }
}

输出:

线程组优先级: 6
线程优先级: 6

所以,如果线程的优先级高于它所在的线程组的优先级,那么该线程的优先级将失效,并被替换为线程组的最大优先级。

责任编辑:武晓燕 来源: 程序猿技术充电站
相关推荐

2010-03-18 14:09:20

Java线程同步

2009-08-28 17:10:59

C#线程优先级

2024-04-30 11:00:10

数据中心

2025-02-03 00:40:00

线程组Java并发编程

2012-08-14 09:38:29

WAN优化

2020-06-04 08:36:55

Linux内核线程

2022-12-23 09:41:14

优先级反转

2023-06-30 19:44:56

CPU调频线程

2024-05-20 10:03:15

线程池优先级队列排序方法

2022-06-02 09:29:55

线程组线程树状结构

2010-09-01 14:10:36

CSS优先级

2010-08-31 11:04:48

CSS优先级

2010-09-13 17:30:07

CSS优先级

2011-12-29 13:31:15

Java

2024-12-03 00:44:50

2021-04-06 10:45:18

React前端优先级

2020-09-30 09:07:37

DevOps

2012-06-27 10:59:05

WAN优化应用交付

2023-11-03 08:22:09

Android系统算法

2024-04-15 08:37:35

点赞
收藏

51CTO技术栈公众号