Java并发-线程优先级

线程的优先级表示当前线程的重要程度，是客户端代码对操作系统任务调度器的一种简易，理论上，优先级越高的线程，cpu时钟的机会越大。

线程优先级取之从1-10，优先级一次递增，但查阅相关资料后发现，多数线程调度器会忽略指定但优先级，而使用默认统一的线程优先级 5。

下面看一个代码实例（摘自《Java编程思想》第四版）：

PriorityDemo(int priority) {
        this.priority = priority;
    }

    @Override
    public String toString() {
    //打印线程名称，优先级以及countDown
        return Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + " : " + countDown;
    }

    @Override
    public void run() {
        //设置线程优先级
        Thread.currentThread().setPriority(priority);
        while (true) {
            //进行10万次浮点运算
            for(int i = 0;i < 100000;i ++) {
                result += (Math.PI + Math.E) / (double)i;
                if(i%1000 == 0) {
                    //建议释放cpu时间片
                    Thread.yield();
                }
            }
            System.out.println(this);
            if(--countDown == 0)
                return;
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        //提交5个优先级最小的线程任务
        for(int i = 0;i < 5;i ++) {
            executorService.execute(new PriorityDemo(Thread.MIN_PRIORITY));
        }
        //提交1个优先级最大的任务
        executorService.execute(new PriorityDemo(Thread.MAX_PRIORITY));

        executorService.shutdown();
    }

}

执行结果

pool-1-thread-1:1 : 5
pool-1-thread-4:1 : 5
pool-1-thread-2:1 : 5
pool-1-thread-6:10 : 5
pool-1-thread-3:1 : 5
pool-1-thread-5:1 : 5
pool-1-thread-1:1 : 4
pool-1-thread-4:1 : 4
pool-1-thread-6:10 : 4
pool-1-thread-2:1 : 4
pool-1-thread-3:1 : 4
pool-1-thread-5:1 : 4
pool-1-thread-1:1 : 3
pool-1-thread-2:1 : 3
pool-1-thread-6:10 : 3
pool-1-thread-4:1 : 3
pool-1-thread-3:1 : 3
pool-1-thread-5:1 : 3
pool-1-thread-1:1 : 2
pool-1-thread-6:10 : 2
pool-1-thread-2:1 : 2
pool-1-thread-3:1 : 2
pool-1-thread-4:1 : 2
pool-1-thread-5:1 : 2
pool-1-thread-1:1 : 1
pool-1-thread-6:10 : 1
pool-1-thread-2:1 : 1
pool-1-thread-4:1 : 1
pool-1-thread-3:1 : 1
pool-1-thread-5:1 : 1

可以从结果中明显的看到，优先级高的线程并没有真正活着更多的执行机会，所以在实际开发中，一定不要让最终计算结果依赖于线程优先级，线程优先级具有不确定性。