1.10线程的优先级

在操作系统中,线程是有优先级划分的,优先级较高的线程会得到相对较多的资源。

也就是说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抛出异常IllegalArgumentException()。

JDK常用下面三个量来预置定义优先级的值。

1.10.1线程优先级的继承特性

在java中线程的优先级具有继承性,比如A线程启动B线程,则B线程的优先级与A是一样的。

线程代码1:

public class Thread1 extends Thread {
    @Override
    public void run() {
        System.out.println("Thread1 run priority = " + this.getPriority());
        Thread2 thread = new Thread2();
        thread.start();
    }
}

线程代码2:

public class Thread2 extends Thread {
    @Override
    public void run() {
        System.out.println("Thread2 run priority = " + this.getPriority());
    }
}

执行代码:

public class Main {
    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());
        Thread1 thread1 = new Thread1();
        thread1.start();
    }
}

执行结果(左为有注释,右为没注释):

1.10.2优先级具有规则性:

线程代码1:

public class Thread3 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 = addResult + j;
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("thread 3 use time = " + (endTime - beginTime));
    }
}

线程代码2:

public class Thread4 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 = addResult + j;
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("thread 4 use time = " + (endTime - beginTime));
    }
}

执行代码:

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Thread3 thread3 = new Thread3();
            thread3.setPriority(10);
            thread3.start();
            Thread4 thread4 = new Thread4();
            thread4.setPriority(1);
            thread4.start();
        }
    }
}

执行结果:

跑了多次后,会发现优先的线程会先执行完。

 实际上线程的执行顺序与线程代码的执行顺序无关,与线程的优先级有关,优先级越高越先执行。

1.10.3优先级具有随机性:

随机性意味着优先级高的线程不一定总是能优先执行完。

线程代码1:

public class Thread5 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 5 use time = " + (endTime - beginTime));
    }
}

线程代码2:

public class Thread6 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 6 use time = " + (endTime - beginTime));
    }
}

执行代码:

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Thread5 thread5 = new Thread5();
            thread5.setPriority(5);
            thread5.start();
            Thread6 thread6 = new Thread6();
            thread6.setPriority(6);
            thread6.start();
        }
    }
}

 执行结果:

从这个结果来看线程的优先级具有随机性,不一定优先级高的就一定先执行完。

 1.10.4看谁运行的快:

线程代码1:

public class ThreadA extends Thread {
    private int count = 0;

    public int getCount() {
        return count;
    }

    @Override
    public void run() {
        while (true) {
            count++;
        }
    }
}

线程代码2:

public class ThreadB extends Thread {
    private int count = 0;

    public int getCount() {
        return count;
    }

    @Override
    public void run() {
        while (true) {
            count++;
        }
    }
}

执行线程:

public class Main {
    public static void main(String[] args) {
        try {
            ThreadA a = new ThreadA();
            a.setPriority(Thread.NORM_PRIORITY - 3);
            a.start();
            ThreadB b = new ThreadB();
            b.setPriority(Thread.NORM_PRIORITY + 3);
            b.start();
            Thread.sleep(10000);
            a.stop();
            b.stop();
            System.out.println("a = " + a.getCount());
            System.out.println("b = " + b.getCount());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 执行结果:

优先级高的线程,执行速度更快。

源码地址:https://github.com/lilinzhiyu/threadLearning

本文内容是书中内容兼具自己的个人看法所成。可能在个人看法上会有诸多问题(毕竟知识量有限,导致认知也有限),如果读者觉得有问题请大胆提出,我们可以相互交流、相互学习,欢迎你们的到来,心成意足,等待您的评价。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏IMWeb前端团队

jQuery中的remove和empty区别

说道dom中移出节点,这两个都可以完成。但也有写差别: empty()是只移除了 指定元素中的所有子节点,拿$(“div”).empty()来说,他只是把 移...

2035
来自专栏深度学习之tensorflow实战篇

Python--学习旅程5

一、数据结构 Python中存在三种重要的数据结构,即列表、元组和字典,下面将一一介绍这三种数据结构。 列表: 列表是处理一组有序项目的数据结构,每个项目之间...

2886
来自专栏华仔的技术笔记

iOS中的正则表达式,一篇就够了

37410
来自专栏大闲人柴毛毛

Java8新特性——StreamAPI(二)

1. 收集器简介 收集器用来将经过筛选、映射的流进行最后的整理,可以使得最后的结果以不同的形式展现。 collect方法即为收集器,它接收Collector接...

2855
来自专栏微信公众号:Java团长

JavaSE入门篇:变量

图片上的各种餐具,就是变量,因为同一个盘子可以在不同的时间装不同的菜,在这一桌可以装土豆肉丝,在下一桌可以装清炒黄瓜(当然,这个盘子还是要洗洗干净滴)。

942
来自专栏云瓣

JS家的排序算法

由于浏览器的原生支持(无需安装任何插件),用JS来学习数据结构和算法也许比c更加便捷些。因为只需一个浏览器就能啪啪啪的调试了。比如下图我学习归并排序算法时,只看...

3628
来自专栏我就是马云飞

设计模式二十四章经之解释器模式

993
来自专栏TechBox

为什么不能在init和dealloc函数中使用accessor方法前言为什么不能在init中调用accessor为什么不能在dealloc中调用accessor结尾

1383
来自专栏Android群英传

Kotlin Primer·类与对象(上)

872
来自专栏云霄雨霁

词法分析程序

1560

扫码关注云+社区