面试官：有了解过线程组和线程优先级吗？

什么是线程组

public class ThreadGroupTest {
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println(Thread.currentThread().getThreadGroup().getName());
        }).start();
        System.out.println(Thread.currentThread().getThreadGroup().getName());
    }
}

输出:

main
main

可以发现在main线程组下；

ThreadGroup是一个标准的「向下引用」的树状结构，这样设计的原因是「防止"上级"线程被"下级"线程引用而无法有效地被GC回收」。

线程优先级

线程的优先级级别由操作系统决定，不同的操作系统级别是不一样的，在Java中，提供了一个级别范围1~10,方便我们去参考。Java默认的线程优先级为5，线程的执行顺序由调度程序来决定，线程的优先级会在线程被调用之前设定。

源码描述:

/**
     * 最低级别
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * 默认级别
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * 最高级别
     */
    public final static int MAX_PRIORITY = 10;

获取线程优先级别

public static void main(String[] args) {
    new Thread(() -> {
        System.out.println("default level: {}" + Thread.currentThread().getPriority());
    }).start();
}

输出: default level: {}5

设置级别

public static void main(String[] args) {
    Thread t = new Thread(() -> {
        System.out.println("default level: {}" + Thread.currentThread().getPriority());
    });
    t.start();
    t.setPriority(10);
}

输出: default level: {}10

通常来讲，高级别的优先级往往会更高几率的执行，注意这里是概率性问题，下面我们测试一下：

public static void main(String[] args) {
    Thread t = new Thread(() -> {
        System.out.println("hello " +  Thread.currentThread().getPriority());
        System.out.println("default level: {}" + Thread.currentThread().getPriority());
    });
    t.setPriority(3);

    Thread t1 = new Thread(() -> {
        System.out.println("hello " +  Thread.currentThread().getPriority());
        System.out.println("default level: {}" + Thread.currentThread().getPriority());
    });
    t1.setPriority(7);

    Thread t2 = new Thread(() -> {
        System.out.println("hello " +  Thread.currentThread().getPriority());
        System.out.println("default level: {}" + Thread.currentThread().getPriority());
    });
    t2.setPriority(10);


    t.start();
    t1.start();
    t2.start();
}

第一次输出:

hello 7
default level: {}7
hello 10
default level: {}10
hello 3
default level: {}3

第二次：

hello 3
default level: {}3
hello 7
default level: {}7
hello 10
default level: {}10

第三次

hello 10
default level: {}10
hello 7
default level: {}7
hello 3
default level: {}3

...

发现，不断的尝试之后，高级别出现的概率会比较靠前一点, 所以想要借助它来完成一些特定业务的同学注意了，不建议使用，不靠谱,之前也讲到，底层还是由操作系统调度完成

Java提供一个「线程调度器」来监视和控制处于「RUNNABLE状态」的线程。线程的调度策略采用「抢占式」，优先级高的线程比优先级低的线程会有更大的几率优先执行。在优先级相同的情况下，按照“先到先得”的原则。每个Java程序都有一个默认的主线程，就是通过JVM启动的第一个线程main线程。

除了主线程之外，还有一个线程是守护线程,它的优先级比较低。如果所有的非守护线程都结束了，这个守护线程也会自动结束。可以借助它实现一些特定场景，比如手动关闭线程的场景,某些场景下不关闭，会造成资源浪费，手动关闭又很麻烦。这里我们可以通过setDaemon(true)指定。

public static void main(String[] args) {
    Thread t = new Thread(() -> {
        System.out.println("hello " +  Thread.currentThread().getPriority());
        System.out.println("default level: {}" + Thread.currentThread().getPriority());
    });
    t.setDaemon(true); // 默认为false
    t.setPriority(10);

    Thread t1 = new Thread(() -> {
        System.out.println("hello " +  Thread.currentThread().getPriority());
        System.out.println("default level: {}" + Thread.currentThread().getPriority());
    });
    t1.setPriority(7);

    t.start();
    t1.start();
}

输出:

hello 7
default level: {}7
hello 10
default level: {}10

发现即使指定了高级别，执行的优先级仍然是最低的

线程组下的优先级

刚刚我们都是在main线程组下，举一反三，线程组下的优先级又是怎么样的呢下面，测试一下：

public static void main(String[] args) {
        // 指定 name 为 g1的线程组
        ThreadGroup group = new ThreadGroup("g1");
        group.setMaxPriority(4);

        Thread t = new Thread(group, () -> {
            System.out.println("hello " +  Thread.currentThread().getPriority());
            System.out.println("default level: {}" + Thread.currentThread().getPriority());
        }, "t0");
        t.setPriority(10);
        t.start();
    }

输出:

hello 4
default level: {}4

发现，在g1线程组下指定了最大优先级后，线程t0的优先级最大级别只能是4, 所以这也是使用线程组的好处。

我们可以通过如下方式复制线程组, ThreadGroup提供了enumerate方法：

public static void main(String[] args) throws InterruptedException {
        // 指定 name 为 g1的线程组
        ThreadGroup group = new ThreadGroup("g1");
        group.setMaxPriority(4);

        Thread t = new Thread(group, () -> {
            System.out.println("hello " +  Thread.currentThread().getPriority());
            System.out.println("default level: {}" + Thread.currentThread().getPriority());
        }, "t0");
        t.setPriority(10);
        t.start();

        // 复制线程组
        System.out.println(group.activeCount()); // 1
        Thread[] list = new Thread[group.activeCount()];
        group.enumerate(list);

        Thread.sleep(3000);
        System.out.println(list[0].getName()); // 输出 t0

    }

统一异常捕获

public static void main(String[] args) {
        // 指定 name 为 g1的线程组
        ThreadGroup group = new ThreadGroup("g1") {
            // 统一异常捕获
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println(t.getName() + ": " + e.getMessage()); // t0: 我出错了
            }
        };
        group.setMaxPriority(4);

        Thread t = new Thread(group, () -> {
            System.out.println("hello " +  Thread.currentThread().getPriority());
            System.out.println("default level: {}" + Thread.currentThread().getPriority());
            throw new RuntimeException("我出错了");
        }, "t0");
        t.setPriority(10);
        t.start();
    }

向下引用的树状数据结构

线程组的内部其实不单单可以放线程，其实也可以放其它线程组,我们看下源码定义

 public static void main(String[] args) {
        // 指定 name 为 g1的线程组
        ThreadGroup group = new ThreadGroup("g1") {
            // 统一异常捕获
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println(t.getName() + ": " + e.getMessage()); // t0: 我出错了
            }
        };
        group.setMaxPriority(4);

        Thread t = new Thread(group, () -> {
            System.out.println("hello " +  Thread.currentThread().getPriority());
            System.out.println("default level: {}" + Thread.currentThread().getPriority());
            throw new RuntimeException("我出错了");
        }, "t0");
        t.setPriority(10);
        t.start();
    }

这里大家可以大胆去猜测一下，为什么要采用这种数据结构其实你通过源码发现，它的内部很多地方都调用了checkAccess方法，特别是在set操作,字面意思是检查是否有权限,我看下这个方法。

public final void checkAccess() {
    SecurityManager security = System.getSecurityManager();
    if (security != null) {
        security.checkAccess(this);
    }
}

它调用了一个SecurityManager, 它是Java的安全管理器，它允许应用程序在执行一个可能不安全或敏感的操作前确定该操作是什么，以及是否是在允许执行该操作的安全上下文中执行它。应用程序可以允许或不允许该操作。总的来说就是保证安全性。

通过上面的了解，我们应该知道为什么要用这种树状结构了。它都是一层一层级别的控制，这么做方便去管理，提高安全性，出了问题也能很快的定位到。就像公司的人员组织架构一样，一切都是为了管理好公司。

结束语

本篇内容到这里就结束了, 大家自己一定要多去理解，不要去背,。

当前名称：面试官：有了解过线程组和线程优先级吗？
网站URL：http://www.shufengxianlan.com/qtweb/news48/336698.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站设计知识

同城分类信息

宜宾做网站　　 　成都微信小程序　　 　雅安电信机房　　 　成都营销型网站建设　　 　成都学生服定制　　 　成都铁科精智测控　　 　Google外贸推广　　 　成都网站设计　　 　成都服务器租用　　 　瑞杰管理　　 　内江服务器托管　　 　资中网站建设　　 　成都外贸网站优化　　 　成都定制网站　　 　成都网站安全运维　　 　品牌网站建设　　 　铁科精智测控　　 　四川瑞杰　　 　四川晃众门窗　　 　全网品牌营销