博客分类：
Java的每个线程都有一个优先级，当有多个线程处于就绪状态时，线程调度程序根据线程的优先级调度线程运行。可以用下面方法设置和返回线程的优先级。
public final void setPriority(int newPriority) 设置线程的优先级。
public final int getPriority() 返回线程的优先级。
newPriority为线程的优先级，其取值为1到10之间的整数，也可以使用Thread类定义的常量来设置线程的优先级，这些常量分别为：Thread.MIN_PRIORITY、Thread.NORM_PRIORITY、Thread.MAX_PRIORITY，它们分别对应于线程优先级的1、5和10，数值越大优先级越高。当创建Java线程时，如果没有指定它的优先级，则它从创建该线程那里继承优先级。
不过设置优先级后有没有效果呢？
有人讲有，有人讲没有。如果是底层操作系统不支持优先级，那估计JVM也没办法；通常的Window系统和Linux系统还是支持优先级的，设置后是不是有效果呢？光是理论分析，难以有直观的认识，还是做个实验来看看吧。
操作系统是Windows XP SP3，CPU是AMD FX-5000四核 2.21GHz，内存2G。
import java.util.R
public class HardJob extends Thread {
private volatile boolean running =
public HardJob(String name) {
super(name);
public void shutdown() {
public void run() {
double result = 0;
int cnt = 0;
Random randGen = new Random();
System.out.println(this.getName() + "(Priority " + this.getPriority() + "), begin to run.");
while (running) {
result += Math.sin(randGen.nextDouble() * 2 * Math.PI);
System.out.println(this.getName() + "(Priority " + this.getPriority() + "), run " + cnt + " times.");
线程启动后，会不断执行正弦运算，直到被shutdown，最后输出执行的运算次数。
public class HardJobTest {
* @param args
public static void main(String[] args) {
//给主线程设置最高优先级，以保证shutdown命令能按时发出去。
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
//创建一个线程数组
HardJob arrJob[] = new HardJob[2];
for (int i = 0; i & arrJob. i++) {
arrJob[i] = new HardJob("job" + String.valueOf(i + 1));
//给各个线程分别设置优先级，可根据需要进行修改。
arrJob[i].setPriority(i + 2);
for (int i = 0; i & arrJob. i++) {
arrJob[i].start();
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
for (int i = 0; i & arrJob. i++) {
arrJob[i].shutdown();
测试程序刚开始启动若干个子线程，设置优先级，然后主线程休眠10秒钟，醒来后，关掉所有子线程；子线程接到指令后停止循环，输出执行的运算次数。
1. 只启动一个子线程，优先级分别设置为1, 5, 10。
三次的测试结果分别为：
job1(Priority 1), run
job1(Priority 5), run
job1(Priority 10), run
三次执行次数差不多，都是四千多万次；CPU使用率为25-27%，我的机器为四核CPU，可以认为这个线程占用了一个CPU。
2. 启动两个子线程
优先级都设置为5，测试结果为：
job1(Priority 5), run
times.job2(Priority 5), run
CPU使用率为50-52%。
优先级分别设置为1和10，测试结果为：
job2(Priority 10), run
times.job1(Priority 1), run
CPU使用率为50-52%。
执行次数差不多，都是四千多万次，可以认为这两个线程各占用了一个CPU。
3. 启动四个子线程
优先级都设置为5，测试结果为：
job3(Priority 5), run
times.job1(Priority 5), run
times.job2(Priority 5), run
times.job4(Priority 5), run
CPU使用率为100%。
优先级分别设置为2、4、6、8，测试结果为：
job3(Priority 6), run
times.job1(Priority 2), run
times.job4(Priority 8), run
times.job2(Priority 4), run
CPU使用率为100%。
执行次数差不多，都是四千多万次，优先级为8的线程比优先级为2的线程略微多执行了些。
从结果上来看，可以认为这四个线程各占用了一个CPU。
4. 启动八个子线程
优先级都设置为5，测试结果为：
job1(Priority 5), run
times.job3(Priority 5), run
times.job5(Priority 5), run
times.job8(Priority 5), run
times.job2(Priority 5), run
times.job6(Priority 5), run
times.job4(Priority 5), run
times.job7(Priority 5), run
CPU使用率为100%。
执行次数只有之前的一半左右，可以近似认为每两个线程平分一个CPU。
优先级分别设置为2到9，测试结果为：
job7(Priority 8), run
times.job8(Priority 9), run
times.job6(Priority 7), run
times.job4(Priority 5), run
times.job5(Priority 6), run
times.job2(Priority 3), run 526607 times.job3(Priority 4), run 185692 times.job1(Priority 2), run 230829 times.
CPU使用率为100%。
优先级为2、3、4的线程只执行了不到六十万次运算；优先级为5、6的线程执行了约两千万次，优先级为7、8、9的线程都执行了四千多万次，属于满负荷运行；
看来线程优先级还是有用的。
5. 启动16个子线程
优先级分别设置为2到9，测试结果为：
job8(Priority 9), run
times.job6(Priority 7), run
times.job7(Priority 8), run
times.job15(Priority 8), run
times.job14(Priority 7), run
times.job16(Priority 9), run
times.job5(Priority 6), run 206322 times.job4(Priority 5), run 174672 times.job2(Priority 3), run 282183 times.job13(Priority 6), run 0 times.job11(Priority 4), run 0 times.job3(Priority 4), run 547 times.job9(Priority 2), run 0 times.job12(Priority 5), run 0 times.job10(Priority 3), run 0 times.job1(Priority 2), run 233635 times.
CPU使用率为100%。
优先级为9的线程执行了四千多万次，属于满负荷运行；
优先级为7、8的线程执行了二千多万次；
其他线程执行了不到三十万次。
从实验结果来看，如果CPU有空闲，即使是低优先级的线程，也可以得到足够的执行时间，接近满负荷执行。
如果CPU比较繁忙，优先级的作用就体现出来了，优先级高的线程能得到比较多的执行时间，优先级比较低的线程也能得到一些执行时间，但会少一些；CPU越繁忙，差异通常越明显。
浏览: 193749 次
来自: 上海
不错，学习了。
http://blog.csdn.net/huang_xw/a ...
理解了，我还以为是同时支持的连接数呢
楼主可以去看看一个jvm的连载，公众号 ITmenghuo
不同操作系统会有些差异，window XP下是的，linux
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'Java 实例 - 查看线程优先级
以下实例演示了如何使用 getThreadId() 方法获取线程id：
Main.java 文件
public class Main extends Object {
private static Runnable makeRunnable() {
Runnable r = new Runnable() {
public void run() {
for (int i = 0; i & 5; i++) {
Thread t = Thread.currentThread();
System.out.println(&in run() - priority=&
+ t.getPriority()+ &, name=& + t.getName());
Thread.sleep(2000);
catch (InterruptedException x) {
public static void main(String[] args) {
System.out.println(&in main() - Thread.currentThread().getPriority()=& + Thread.currentThread().getPriority());
System.out.println(&in main() - Thread.currentThread().getName()=&+ Thread.currentThread().getName());
Thread threadA = new Thread(makeRunnable(), &threadA&);
threadA.start();
Thread.sleep(3000);
catch (InterruptedException x) {
System.out.println(&in main() - threadA.getPriority()=&+ threadA.getPriority());
以上代码运行输出结果为：
in main() - Thread.currentThread().getPriority()=5
in main() - Thread.currentThread().getName()=main
in run() - priority=5, name=threadA
in run() - priority=5, name=threadA
in main() - threadA.getPriority()=5
in run() - priority=5, name=threadA
in run() - priority=5, name=threadA
in run() - priority=5, name=threadA
记住登录状态
重复输入密码在 SegmentFault，解决技术问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
一线的工程师、著名开源项目的作者们，都在这里：
获取验证码
已有账号？
标签：至少1个，最多5个
一、线程优先级
线程优先级的范围是1~10，默认优先级是5，线程优先级的主要作用是让调度器优先调度高优先级线程，但这不意味着低优先级线程得不到执行，通常情况不需要修改线程优先级，Thread类中有3个优先级的常量：
二、源码分析
public final void setPriority(int newPriority) {
ThreadG//线程所属的线程组
checkAccess();
//设置的级别不能大于10且不能小于1
if (newPriority & MAX_PRIORITY || newPriority & MIN_PRIORITY) {
throw new IllegalArgumentException();
if((g = getThreadGroup()) != null) {
//设置的级别不能大于所属线程组的最大级别
if (newPriority & g.getMaxPriority()) {
newPriority = g.getMaxPriority();
setPriority0(priority = newPriority);//本地方法
三、线程优先级示例
public class ThreadPrioritiesDemo extends Thread {
public ThreadPrioritiesDemo(String name, int priority) {
super(name);
this.priority =
public static void main(String[] args) {
Thread t1 = new ThreadPrioritiesDemo("thread1", 1);
Thread t2 = new ThreadPrioritiesDemo("thread2", 10);
t1.start();
t2.start();
public void run() {
Thread.currentThread().setPriority(priority);
for (int i = 0; i & 1000; i++) {
System.out.println(this + ":" + i);
if (i % 2 == 0)
Thread.yield();
输出结果（截取部分）：
Thread[thread1,1,main]:670
Thread[thread2,10,main]:293
Thread[thread2,10,main]:294
Thread[thread1,1,main]:671
Thread[thread1,1,main]:672
Thread[thread2,10,main]:295
Thread[thread2,10,main]:296
Thread[thread1,1,main]:673
Thread[thread1,1,main]:674
Thread[thread2,10,main]:297
Thread[thread2,10,main]:298
Thread[thread1,1,main]:675
Thread[thread1,1,main]:676
Thread[thread2,10,main]:299
3.1、结果说明
新开启2个线程，线程1优先级为1，线程2优先级为10，两个线程交替执行，高优先级线程（t2）并不是一直优先于t1执行
高优先级线程并不是一直优于低优先级线程执行
欢迎加入学习交流群，大家一起学习交流。
0 收藏&&|&&0
你可能感兴趣的文章
1 收藏，391
29 收藏，358
3 收藏，422
分享到微博？
我要该，理由是：