Question

我打算在我的Java代码中使用线程优先级。应用程序应在我的Linux系统上运行：

>uname -a
Linux <host> 3.0.0-15-generic #26-Ubuntu SMP <date> x86_64 x86_64 x86_64 GNU/Linux

>java -version
java version "1.6.0_23"
OpenJDK Runtime Environment (IcedTea6 1.11pre) (6b23~pre11-0ubuntu1.11.10.1)
OpenJDK 64-Bit Server VM (build 20.0-b11, mixed mode)

在Web上阅读完毕后，我现在使用以下命令启动我的测试应用程序：

sudo java -XX:+UseThreadPriorities -XX:ThreadPriorityPolicy=1 -jar ThreadPriorityTest.jar

测试应用程序包含以下两个类：

package ch.mypackage;

public class CountingRunnable implements Runnable{

private long count=0;
private boolean goOn=true;

public long getCount() {
    return count;
}

public void stop(){
    goOn=false;
}

public void run() {
    for(long iteration=0;goOn&&iteration<Long.MAX_VALUE;++iteration){
        ++count;
    }
}

}




package ch.mypackage;

public class PriorizedCountingThreads {

private static final int NUM_MILLIS_TO_COUNT_FOR = 1*60*1000;
private static CountingRunnable[] runnables;
private static Thread[] threads;

/**
 * @param args
 */
public static void main(String[] args) { 
    Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
    System.out.println("MIN_PRIORITY: "+Thread.MIN_PRIORITY);
    System.out.println("MAX_PRIORITY: "+Thread.MAX_PRIORITY);
    int numPriorityLevels=(Thread.MAX_PRIORITY-Thread.MIN_PRIORITY)+1;
    init(numPriorityLevels);
    startThreads();
    try {
        Thread.sleep(NUM_MILLIS_TO_COUNT_FOR);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    stopRunnables();
    printCounts();
}

private static void printCounts() {
    for(int i=0;i<runnables.length;++i){
        System.out.println(threads[i].getName()+" has priority: "+threads[i].getPriority()+" and count:"+runnables[i].getCount());
    }
}

private static void stopRunnables() {
    for(int i=0;i<runnables.length;++i){
        runnables[i].stop();
    }
}

private static void startThreads() {
    for(int i=0;i<threads.length;++i){
        threads[i].start();
    }
}

private static void init(int numPriorityLevels) {
    runnables=new CountingRunnable[numPriorityLevels];
    threads=new Thread[runnables.length];
    for(int i=0;i<runnables.length;++i){
        int priority=i+1;
        runnables[i]=new CountingRunnable();
        threads[i]=new Thread(runnables[i]);
        threads[i].setPriority(priority);
        threads[i].setName("PriorityThread_"+priority);
    }
}

}

如果我让程序计数一分钟（NUM_MILLIS_TO_COUNT_FOR = 1 * 60 * 1000），那么我得到以下输出：

MIN_PRIORITY: 1
MAX_PRIORITY: 10
PriorityThread_1 has priority: 1 and count:12658044343
PriorityThread_2 has priority: 2 and count:19008431582
PriorityThread_3 has priority: 3 and count:30618946099
PriorityThread_4 has priority: 4 and count:34408365142
PriorityThread_5 has priority: 5 and count:36694025023
PriorityThread_6 has priority: 6 and count:40493710165
PriorityThread_7 has priority: 7 and count:42826305342
PriorityThread_8 has priority: 8 and count:42203891414
PriorityThread_9 has priority: 9 and count:43128747383
PriorityThread_10 has priority: 10 and count:43416371500

根据此输出，优先级似乎具有预期的影响！但是如果我使用“jstack”或“kill -s QUIT”生成一个线程转储，那么我得到以下输出，这意味着每个线程都具有相同的优先级（prio = 10）：

    "PriorityThread_10" prio=10 tid=0x00007ff7e406f800 nid=0x12e6 runnable [0x00007ff7e2562000]
   java.lang.Thread.State: RUNNABLE
    at ch.mypackage.CountingRunnable.run(CountingRunnable.java:17)
    at java.lang.Thread.run(Thread.java:679)

"PriorityThread_9" prio=10 tid=0x00007ff7e406d800 nid=0x12e5 runnable [0x00007ff7e2663000]
   java.lang.Thread.State: RUNNABLE
    at ch.mypackage.CountingRunnable.run(CountingRunnable.java:17)
    at java.lang.Thread.run(Thread.java:679)

"PriorityThread_8" prio=10 tid=0x00007ff7e406b000 nid=0x12e4 runnable [0x00007ff7e2764000]
   java.lang.Thread.State: RUNNABLE
    at ch.mypackage.CountingRunnable.run(CountingRunnable.java:17)
    at java.lang.Thread.run(Thread.java:679)

"PriorityThread_7" prio=10 tid=0x00007ff7e4069000 nid=0x12e3 runnable [0x00007ff7e2865000]
   java.lang.Thread.State: RUNNABLE
    at ch.mypackage.CountingRunnable.run(CountingRunnable.java:17)
    at java.lang.Thread.run(Thread.java:679)

"PriorityThread_6" prio=10 tid=0x00007ff7e4067000 nid=0x12e2 runnable [0x00007ff7e2966000]
   java.lang.Thread.State: RUNNABLE
    at ch.mypackage.CountingRunnable.run(CountingRunnable.java:17)
    at java.lang.Thread.run(Thread.java:679)

"PriorityThread_5" prio=10 tid=0x00007ff7e4065000 nid=0x12e1 runnable [0x00007ff7e2a67000]
   java.lang.Thread.State: RUNNABLE
    at ch.mypackage.CountingRunnable.run(CountingRunnable.java:17)
    at java.lang.Thread.run(Thread.java:679)

"PriorityThread_4" prio=10 tid=0x00007ff7e4063000 nid=0x12e0 runnable [0x00007ff7e2b68000]
   java.lang.Thread.State: RUNNABLE
    at ch.mypackage.CountingRunnable.run(CountingRunnable.java:17)
    at java.lang.Thread.run(Thread.java:679)

"PriorityThread_3" prio=10 tid=0x00007ff7e4061000 nid=0x12df runnable [0x00007ff7e2c69000]
   java.lang.Thread.State: RUNNABLE
    at ch.mypackage.CountingRunnable.run(CountingRunnable.java:17)
    at java.lang.Thread.run(Thread.java:679)

"PriorityThread_2" prio=10 tid=0x00007ff7e405d000 nid=0x12de runnable [0x00007ff7e2d6a000]
   java.lang.Thread.State: RUNNABLE
    at ch.mypackage.CountingRunnable.run(CountingRunnable.java:17)
    at java.lang.Thread.run(Thread.java:679)

"PriorityThread_1" prio=10 tid=0x00007ff7e4049800 nid=0x12dd runnable [0x00007ff7e2e6b000]
   java.lang.Thread.State: RUNNABLE
    at ch.mypackage.CountingRunnable.run(CountingRunnable.java:17)
    at java.lang.Thread.run(Thread.java:679)

如果我在Windows机器上执行相同的操作，根据我找到here的优先级映射，prio值是正确的值。

那么，这是jstack中的错误，还是我做错了什么？

如果我执行“top | grep java”，我会得到以下结果：

PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
3394 root      20   0 4444m  15m 8376 S  789  0.1   0:47.52 java

这意味着主线程的优先级为20，而“top -H | grep java”会产生以下输出：

 PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND     

 3457 root      15  -5 4444m  15m 8384 R   99  0.1   0:08.60 java
 3456 root      16  -4 4444m  15m 8384 R   97  0.1   0:08.41 java
 3455 root      17  -3 4444m  15m 8384 R   93  0.1   0:08.42 java
 3454 root      18  -2 4444m  15m 8384 R   97  0.1   0:08.27 java
 3453 root      19  -1 4444m  15m 8384 R   97  0.1   0:07.50 java
 3452 root      20   0 4444m  15m 8384 R   51  0.1   0:07.44 java
 3451 root      21   1 4444m  15m 8384 R   35  0.1   0:04.83 java
 3450 root      22   2 4444m  15m 8384 R   99  0.1   0:04.78 java
 3449 root      23   3 4444m  15m 8384 R   95  0.1   0:07.47 java
 3448 root      24   4 4444m  15m 8384 R   18  0.1   0:02.85 java

表明java线程优先级确实会影响OS线程的优先级。

但是jstack在prio = 10中的值是10？它只是一个随意的值吗？

Answer 1

Java中的线程优先级是一个非常敏感的主题...... 您可以在此处找到StackOverlow上的帖子：https://stackoverflow.com/a/2170304/1343096

基本上尝试将优先级政策更改为42：

-XX:ThreadPriorityPolicy=42

让我们知道它是否适合您！

您可以通过以下链接找到所有解释。

Answer 2

Java 7 docs州

注意 - 此实用程序不受支持，可能会或可能不会在JDK的未来版本中提供。

所以我认为jstack的输出可能不准确，因为linux上的实现细节可能已经改变。

htop -H报告的值与您在问题中包含的this article一致，并且是在Linux内核中编写java进程的值。

如果您需要将jstack的输出映射到top -H报告的线程，您只需将nid从jstack转换为十进制或pid从{ {1}}到十六进制。 See this article

关于你的源代码：当我运行它时，程序不会终止。编写生产多任务代码时有三个提示：

如果你知道一切都已完成（如从top -H调用printCounts()后），请毫不犹豫地使用main确保所有线程都被终止。
如果要在并行执行期间测试代码的行为，通常最好先创建所有System.exit(0);并使它们同步工作。在共享CountDownLatch或CyclicBarrier上呼叫Thread作为工作人员的第一个声明通常会做得很好。
虽然await()读取和写入是Java tutorial的原子，但我建议将boolean字段之类的触发器变量声明为易失性，因为这也会影响编译器的编译方式优化您的代码。

使用goOn或volatile您的基准正常终止。

Java线程转储prio值与linux上的实际线程优先级不对应？

2 个答案: