《Java多线程编程核心技术》——1.10节线程的优先级

1.10　线程的优先级
在操作系统中，线程可以划分优先级，优先级较高的线程得到的CPU资源较多，也就是CPU优先执行优先级较高的线程对象中的任务。
设置线程优先级有助于帮“线程规划器”确定在下一次选择哪一个线程来优先执行。
设置线程的优先级使用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，则JDK抛出异常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线程，则B线程的优先级与A是一样的。
创建t18项目，创建MyThread1.java文件，代码如下：

package extthread;
public class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread1 run priority=" + this.getPriority());
        MyThread2 thread2 = new MyThread2();
        thread2.start();
    }
}
创建MyThread2.java文件，代码如下：
package extthread;
public class MyThread2 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread2 run priority=" + this.getPriority());
    }
}
文件Run.java代码如下：
package test;
import extthread.MyThread1;
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();
    }
}
程序运行后的效果如图1-53所示。
将代码：
// Thread.currentThread().setPriority(6);

前的注释符号去掉，再次运行Run.java文件，显示结果如图1-54所示。

1.10.2　优先级具有规则性
虽然使用setPriority()方法可以设置线程的优先级，但还没有看到设置优先级所带来的效果。
创建名称为t19的项目，文件MyThread1.java代码如下：

package extthread;
import java.util.Random;
public class MyThread1 extends Thread {
    @Override
    public void 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("thread 1 use time=" + (endTime - beginTime));
    }
}
文件MyThread2.java代码如下：
package extthread;
import java.util.Random;
public class MyThread2 extends Thread {
    @Override
    public void 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("thread 2 use time=" + (endTime - beginTime));
    }
}
文件Run.java代码如下。
package test;
import extthread.MyThread1;
import extthread.MyThread2;
public class Run {
    public static void main(String[] args) {
        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();
        }
    }
}

文件Run.java在运行3次后的打印结果如图1-55所示。

从图1-56中可以发现，大部分的thread2先执行完，也就验证了线程的优先级与代码执行顺序无关，出现这样的结果是因为MyThread2的优先级是最高的，说明线程的优先级具有一定的规则性，也就是CPU尽量将执行资源让给优先级比较高的线程。

1.10.3　优先级具有随机性
前面案例介绍了线程的优先级较高则优先执行完run()方法中的任务，但这个结果不能说的太肯定，因为线程的优先级还具有“随机性”，也就是优先级较高的线程不一定每一次都先执行完。
创建名称为t20的项目，文件MyThread1.java代码如下：

package extthread;
import java.util.Random;
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));
    }
}
文件MyThread2.java代码如下：
package extthread;
import java.util.Random;
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));
    }
}
文件Run.java代码如下：
package test;
import extthread.MyThread1;
import extthread.MyThread2;
public class Run {
    public static void main(String[] args) {
        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();
        }
    }
}

为了让结果体现“随机性”，所以两个线程的优先级一个设置为5，另一个设置为6，让优先级接近一些。
文件Run.java在运行6次后的打印结果如图1-57所示。

那么，根据此实验可以得出一个结论，不要把线程的优先级与运行结果的顺序作为衡量的标准，优先级较高的线程并不一定每一次都先执行完run()方法中的任务，也就是说，线程优先级与打印顺序无关，不要将这两者的关系相关联，它们的关系具有不确定性和随机性。

1.10.4　看谁运行得快
创建实验用的项目countPriority，创建两个线程类，代码如图1-58所示。

时间： 2024-10-14 17:48:40

《Java多线程编程核心技术》——1.10节线程的优先级的相关文章

读《Java多线程编程核心技术》一些问题

读<Java多线程编程核心技术>一些问题 1.suspend resume虽然不推荐使用,但是书中还是介绍了,实例中的1-48图 println()方法是同步锁的,当在线程中调用println()方法,线程被suspend()暂停的话, 那么println()的锁也被锁住了.

《Java多线程编程核心技术》——1.2节使用多线程

1.2 使用多线程想学习一个技术就要"接近"它,所以在本节,首先用一个示例来接触一下线程.一个进程正在运行时至少会有1个线程在运行,这种情况在Java中也是存在的.这些线程在后台默默地执行,比如调用public static void main()方法的线程就是这样的,而且它是由JVM创建的.创建示例项目callMainMethodMainThread,创建Test.java类.代码如下: package test; public class Test { public static

《Java多线程编程核心技术》——导读

前 言为什么要写这本书早在几年前笔者就曾想过整理一份与Java多线程有关的稿件,因为市面上所有的Java书籍都是以一章或两章的篇幅介绍多线程技术,并没有完整地覆盖该技术的知识点,但可惜,苦于当时的时间及精力有限,一直没有达成所愿.也许是注定的安排,我目前所在的单位是集技术与教育为一体的软件类企业.我在工作中发现很多学员在学习完JavaSE/JavaEE之后想对更深入的技术进行探索,比如在对大数据.分布式.高并发类的专题进行攻克时,立即遇到针对java.lang包中Thread类的学习,但Thre

《Java多线程编程核心技术》——1.8节暂停线程

1.8 暂停线程 暂停线程意味着此线程还可以恢复运行.在Java多线程中,可以使用suspend()方法暂停线程,使用resume()方法恢复线程的执行. 1.8.1 suspend与resume方法的使用 本节将讲述如何使用suspend与resume方法. 创建测试用的项目suspend_resume_test,文件MyThread.java代码如下: package mythread; public class MyThread extends Thread { private long

《Java多线程编程核心技术》——第2章对象及变量的并发访问

第2章对象及变量的并发访问本章主要介绍Java多线程中的同步,也就是如何在Java语言中写出线程安全的程序,如何在Java语言中解决非线程安全的相关问题.多线程中的同步问题是学习多线程的重中之重,这个技术在其他的编程语言中也涉及,如C++或C#.本章应该着重掌握如下技术点:synchronized对象监视器为Object时的使用.synchronized对象监视器为Class时的使用.非线程安全是如何出现的.关键字volatile的主要作用.关键字volatile与synchronized的区别

《Java多线程编程核心技术》——第1章Java多线程技能

第1章Java多线程技能作为本书的第1章,一定要引导读者快速进入Java多线程的学习,所以本章中主要介绍Thread类中的核心方法.Thread类的核心方法较多,读者应该着重掌握如下关键技术点:线程的启动如何使线程暂停如何使线程停止线程的优先级线程安全相关的问题上面的5点也是本章学习的重点与思路,掌握这些内容是学习Java多线程的必经之路.

《Java多线程编程核心技术》——1.1节进程和多线程的概念及线程的优点

1.1 进程和多线程的概念及线程的优点 本节主要介绍在Java语言中使用多线程技术.但讲到多线程这个技术时不得不提及"进程"这个概念,"百度百科"里对"进程"的解释如图1-1所示. 初看这段文字会觉得十分的抽象,难以理解,但如果你看到图1-2所示的内容,那么你对进程还不能理解吗? 难道可以将一个正在操作系统中运行的exe程序理解成一个"进程"吗?没错! 通过查看"Windows任务管理器"中的列表,完全可以

《Java多线程编程核心技术》——2.1节synchronized同步方法

2.1 synchronized同步方法在第1章中已经接触"线程安全"与"非线程安全"相关的技术点,它们是学习多线程技术时一定会遇到的经典问题."非线程安全"其实会在多个线程对同一个对象中的实例变量进行并发访问时发生,产生的后果就是"脏读",也就是取到的数据其实是被更改过的.而"线程安全"就是以获得的实例变量的值是经过同步处理的,不会出现脏读的现象.此知识点在第1章也介绍,但本章将细化线程并发访问的内容,在

《Java多线程编程核心技术》——1.7节停止线程

1.7 停止线程停止线程是在多线程开发时很重要的技术点,掌握此技术可以对线程的停止进行有效的处理.停止线程在Java语言中并不像break语句那样干脆,需要一些技巧性的处理.使用Java内置支持多线程的类设计多线程应用是很常见的事情,然而,多线程给开发人员带来了一些新的挑战,如果处理不好就会导致超出预期的行为并且难以定位错误.本节将讨论如何更好地停止一个线程.停止一个线程意味着在线程处理完任务之前停掉正在做的操作,也就是放弃当前的操作.虽然这看起来非常简单,但是必须做好防范措施,以便达到预期的效