线程的优先级
在操作系统中线程可以划分优先级，优先级较高的线程得到的CPU资源越多，也就是CPU优先执行优先级较高的线程对象中的任务。
设置线程优先级有助于“线程规划器”确定下一次选择哪个线程优先执行。
设置线程优先级使用setPriority()方法，源码如下：
public final void setPriority(int newPriority) {
ThreadGroup g;
checkAccess();
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
throw new IllegalArgumentException();
}
if((g = getThreadGroup()) != null) {
if (newPriority > g.getMaxPriority()) {
newPriority = g.getMaxPriority();
}
setPriority0(priority = newPriority);
}
}
Java中线程优先级分为1-10个等级。如果小于1或大于10就throw new IllegalArgumentException();
JDK中3个常量预置定义优先级的值：
public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;
1.10.1线程优先级的继承特性
Java中的线程优先级具有继承特性，如A线程继承了B线程，那么A、B线程优先级一样。
public class MyThread1 extends Thread {
@Override
public void run() {
super.run();
System.out.println("MyThread1 run priority="+this.getPriority());
MyThread2 thread2 = new MyThread2();
thread2.start();
}
}
public class MyThread2 extends Thread {
@Override
public void run() {
super.run();
System.out.println("MyThread2 run priority="+this.getPriority());
}
}
public class Run {
public static void main(String[] args) {
System.out.println("Main thread begin priority=" + Thread.currentThread().getPriority());
//Thread.currentThread().setPriority(6);
System.out.println("Main thread end priority=" + Thread.currentThread().getPriority());
MyThread1 thread1 = new MyThread1();
thread1.start();
}
}
程序运行结果如下，可见线程初始优先级是一样的。
Main thread begin priority=5
Main thread end priority=5
MyThread1 run priority=5
MyThread2 run priority=5
我们把以下注释代码去掉，
Thread.currentThread().setPriority(6);
程序运行结果为：
Main thread begin priority=5
Main thread end priority=6
MyThread1 run priority=6
MyThread2 run priority=6
1.10.2优先级具有规则性
上面例子没有看到设置优先级带来的效果，看以下例子：
public class MyThread1 extends Thread {
@Override
public void run() {
super.run();
long beginTime = System.currentTimeMillis();
long addResult = 0;
for (int j = 0; j < 10; j++) {
for (int i = 0; i < 50000; i++) {
Random random = new Random();
random.nextInt();
addResult = addResult+i;
}
}
long endTime = System.currentTimeMillis();
System.out.println("MyThread1*** useTime="+(endTime-beginTime));
}
}
public class MyThread2 extends Thread {
@Override
public void run() {
super.run();
long beginTime = System.currentTimeMillis();
long addResult = 0;
for (int j = 0; j < 10; j++) {
for (int i = 0; i < 50000; i++) {
Random random = new Random();
random.nextInt();
addResult = addResult+i;
}
}
long endTime = System.currentTimeMillis();
System.out.println("MyThread2 useTime="+(endTime-beginTime));
}
}
public class Run {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
MyThread1 thread1 = new MyThread1();
thread1.setPriority(10);
thread1.start();
MyThread2 thread2 = new MyThread2();
thread2.setPriority(1);
thread2.start();
}
}
}
程序运行结果如下：可以看到优先级高的thread1基本上都先于低优先级线程thread2完成，但不代表高优先级的线程必定全部先执行完。
MyThread1*** useTime=135
MyThread1*** useTime=141
MyThread1*** useTime=223
MyThread1*** useTime=189
MyThread1*** useTime=84
MyThread2 useTime=121
MyThread2 useTime=290
MyThread1*** useTime=89
MyThread2 useTime=103
MyThread1*** useTime=167
MyThread1*** useTime=141
MyThread1*** useTime=121
MyThread1*** useTime=161
MyThread2 useTime=167
MyThread2 useTime=163
MyThread2 useTime=417
MyThread2 useTime=228
MyThread2 useTime=286
MyThread2 useTime=117
MyThread2 useTime=649
当线程优先级差距很大时，谁先执行完和调用顺序无关。验证如下：
public class Run {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
MyThread2 thread2 = new MyThread2();
thread2.setPriority(1);
thread2.start();
MyThread1 thread1 = new MyThread1();
thread1.setPriority(10);
thread1.start();
}
}
}
结果为：
MyThread2 useTime=213
MyThread1*** useTime=290
MyThread2 useTime=289
MyThread1*** useTime=289
MyThread1*** useTime=322
MyThread1*** useTime=136
MyThread1*** useTime=175
MyThread1*** useTime=107
MyThread1*** useTime=471
MyThread2 useTime=527
MyThread1*** useTime=529
MyThread1*** useTime=345
MyThread2 useTime=578
MyThread1*** useTime=734
MyThread2 useTime=502
MyThread2 useTime=512
MyThread2 useTime=523
MyThread2 useTime=829
MyThread2 useTime=578
MyThread2 useTime=564
可以看到线程thread2先调用，但是执行结果依旧thread1大部分先执行完。验证了线程优先级与代码调用顺序无关。说明线程优先级具有一定规则性，CPU尽量将资源让给优先级高的线程。
1.10.3线程随机性
一般来说线程的优先级较高则优先执行完run()方法中的任务，但这个结果不是100%成立，因为线程的优先级具有“随机性”，也就是优先级高的线程不一定每一次都先执行完。
看代码：
public class MyThread1 extends Thread {
@Override
public void run() {
super.run();
long beginTime = System.currentTimeMillis();
for (int i = 0; i < 50000; i++) {
Random random = new Random();
random.nextInt();
}
long endTime = System.currentTimeMillis();
System.out.println("MyThread1*** useTime=" + (endTime - beginTime));
}
}
public class MyThread2 extends Thread {
@Override
public void run() {
super.run();
long beginTime = System.currentTimeMillis();
for (int i = 0; i < 50000; i++) {
Random random = new Random();
random.nextInt();
}
long endTime = System.currentTimeMillis();
System.out.println("MyThread2 useTime=" + (endTime - beginTime));
}
}
public class Run {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
MyThread2 thread2 = new MyThread2();
thread2.setPriority(5);
thread2.start();
MyThread1 thread1 = new MyThread1();
thread1.setPriority(6);
thread1.start();
}
}
}
为了体现随机性将优先级设置为相近，运行多次结果呈现随机性。
1.11守护线程
Java中有两种线程，一种是用户线程，另一种是守护线程。
守护线程是一种特殊的线程，它的特性有“陪伴”的含义，当进程中不存在非守护线程了，守护线程自动销毁。
典型的守护线程是(GC)垃圾回收线程。
public class MyThread extends Thread {
private int i = 0;
@Override
public void run() {
try {
while (true) {
i++;
System.out.println("i=" + (i));
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class Run {
public static void main(String[] args) throws InterruptedException {
MyThread daemonThread = new MyThread();
daemonThread.setDaemon(true);
daemonThread.start();
Thread.sleep(5000);
System.out.println("当main线程执行完毕，守护线程也停止了。");
}
}
i=1
i=2
i=3
i=4
i=5
当main线程执行完毕，守护线程也停止了。
