java多線程系列8-線程的優先級，多線程8-

java多線程系列8-線程的優先級，多線程8-

在java中設置線程優先級使用setPriority，在jdk中的源代碼如下：

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這10個等級，小於1或大於10，則會拋出IllegalArgumentException異常

在JDK中使用3個常量來預定義優先級：

  /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;
 
   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;
 
    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

線程優先級的繼承性

在java中，線程的優先級具有繼承性，例如A線程啟動B線程，則A和B的優先級是一樣的。舉個例子：

public class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread1 run priority=" + this.getPriority());
        MyThread2 thread2 = new MyThread2();
        thread2.start();
    }
}
public class MyThread2 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread2 run priority=" + this.getPriority());
    }
}
public class Run {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("main thread begin priority="
                + Thread.currentThread().getPriority());
        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

優先級具有規則性

雖然setPriority()方法可以設置線程的優先級，但是沒有看到設置優先級所帶來的效果

舉例如下：

public class MyThread1 extends Thread {
    @Override
    public void run() {
        long beginTime = System.currentTimeMillis();
        long addResult = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 50000; j++) {
                Random random = new Random();
                random.nextInt();
                addResult += j;
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("* * * * * thread 1 use time=" + (endTime - beginTime));
    }
}
public class MyThread2 extends Thread {
    @Override
    public void run() {
        long beginTime = System.currentTimeMillis();
        long addResult = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 50000; j++) {
                Random random = new Random();
                random.nextInt();
                addResult += j;
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("* * * * * thread 2 use time=" + (endTime - beginTime));
    }
}
public class Run {
    public static void main(String[] args) throws InterruptedException {
        
        for(int i=0;i<5;i++){
            MyThread1 thread1=new MyThread1();
            thread1.setPriority(10);
            thread1.start();
            MyThread2 thread2 =new MyThread2();
            thread2.setPriority(1);
            thread2.start();
        }
    }
}

運行結果如下：

* * * * * thread 1 use time=174
* * * * * thread 1 use time=221
* * * * * thread 1 use time=224
* * * * * thread 2 use time=360
* * * * * thread 1 use time=202
* * * * * thread 2 use time=185
* * * * * thread 1 use time=169
* * * * * thread 2 use time=466
* * * * * thread 2 use time=425
* * * * * thread 2 use time=98

從上面的結果可以看出，高優先級的線程總是大部分先執行完，但是不是所有的先執行完。先執行完也不是因為先調用，如果更改優先級，先執行完和和代碼的調用順序無關。

優先級具有一定的規則性，CPU總是盡量將執行資源讓給優先級比較高的線程

優先級具有隨機性

優先級較高的線程不一定每一次都先執行完，舉個例子：

public class MyThread1 extends Thread {
    @Override
    public void run() {
        long beginTime = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            Random random = new Random();
            random.nextInt();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("* * * * * thread 1 use time="
                + (endTime - beginTime));
    }
}
public class MyThread2 extends Thread {
    @Override
    public void run() {
        long beginTime = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            Random random = new Random();
            random.nextInt();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("* * * * * thread 2 use time="
                + (endTime - beginTime));
    }
}
public class Run {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            MyThread1 thread1 = new MyThread1();
            thread1.setPriority(5);
            thread1.start();
            MyThread2 thread2 = new MyThread2();
            thread2.setPriority(6);
            thread2.start();
        }
    }
}

運行結果如下：

* * * * * thread 1 use time=5
* * * * * thread 2 use time=4
* * * * * thread 1 use time=5
* * * * * thread 1 use time=4
* * * * * thread 1 use time=4
* * * * * thread 2 use time=6
* * * * * thread 2 use time=3
* * * * * thread 2 use time=5
* * * * * thread 1 use time=2
* * * * * thread 2 use time=6

線程的優先級與打印順序無關，它們的關系具有不確定性和隨機性

相關文章
java多線程系列8-線程的優先級
java多線程系列7-停止線程
java多線程系列6-阻塞隊列
java多線程系列5-死鎖與線程間通信
java多線程系列4-線程池
java多線程系列3-線程同步
java多線程系列2-線程控制
java多線程系列1--線程實現與調度