Java线程的优先级

“黄梅时节家家雨,青草池塘处处蛙”
线程是有优先级的,也就是线程的执行顺序;先来看下对于设置线程优先级的源码:
这里写图片描述
其中:MAX_PRIORITY和MIN_PRIORITY分别是最高级10和最低级1,当然还有默认级别是5;

接着看下线程优先级的一些特性:

线程优先级的继承特性:也就是如果线程A启动线程B,那么线程A和B的优先级是一样的;
线程优先级的规则性:即线程会优先级的大小顺序执行,但是不一定是优先级较大的先执行完,因为线程的优先级还有下面第三个特性:
线程优先级的随机特性;

验证线程优先级的继承特性:

public class ThreadPriority {
    public static void main(String[] args) {
        System.out.println("once Main Thread Priority = " + Thread.currentThread().getPriority());
        //待会打开下面注释再看结果
//        Thread.currentThread().setPriority(8);
        System.out.println("twice Main Thread Priority = " + Thread.currentThread().getPriority());
        MyThread1 myThread1 = new MyThread1();
        myThread1.start();
    }
}

class MyThread1 extends Thread {
    @Override
    public void run() {
        super.run();
        //输出线程级别
        System.out.println("MyThread1 Priority = " + this.getPriority());
        //启动线程MyThread2
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();
    }
}
class MyThread2 extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("MyThread2 Priority = " + this.getPriority());
    }
}

打开设置线程优先级之前的结果:
这里写图片描述
打开设置线程优先级之后的结果:

因此证明线程的优先级是具有继承性的;
验证线程具有规则性:


import java.util.Random;


public class ThreadPriority {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            MyThread1 myThread1 = new MyThread1();
            myThread1.setPriority(10);
            myThread1.start();
            MyThread2 myThread2 = new MyThread2();
            myThread2.setPriority(1);
            myThread2.start();
        }
    }
}

class MyThread1 extends Thread {
    @Override
    public void run() {
        long start = System.currentTimeMillis();
        long count = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 50000; j++) {
                Random random = new Random();
                random.nextInt();
                count = count + i;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("############# thread 1 use time = " + (end - start));
    }
}
class MyThread2 extends Thread {
    @Override
    public void run() {
        long start = System.currentTimeMillis();
        long count = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 50000; j++) {
                Random random = new Random();
                random.nextInt();
                count = count + i;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("$$$$$$$$$$$$$thread 2 use time = " + (end - start));
    }
}

这里写图片描述
从运行结果中可以发现,MyThread1总是大部分先执行完(可以多次运行看结果,会发现线程1都是先全部执行完).并不是说要等线程1全部执行完才执行线程2;
而且,你可以把线程1和2的优先级换一下,线程1设置为1,线程2设置为10,再看结果:

    MyThread1 myThread1 = new MyThread1();
    myThread1.setPriority(1);
    myThread1.start();
    MyThread2 myThread2 = new MyThread2();
    myThread2.setPriority(10);
    myThread2.start();

这里写图片描述
由此可以证明并不是按照在代码的中顺序执行的.而是根据线程的优先级;
再看线程的随机性:
直接把刚才证明线程规则性的代码中,分别设置两个线程优先级为5和6,比较接近的两个值:

 MyThread1 myThread1 = new MyThread1();
 myThread1.setPriority(5);
 myThread1.start();
 MyThread2 myThread2 = new MyThread2();
 myThread2.setPriority(6);
 myThread2.start();

这里写图片描述
由此可以得出,线程的优先级和打印顺序无关,不能将这两者相关联,它们的关系具有不确定性和随机性;

猜你喜欢