- 使用 Spring Initializr 创建 Spring Boot 应用程序
- 在Spring Boot中配置Cassandra
- 在 Spring Boot 上配置 Tomcat 连接池
- 将Camel消息路由到嵌入WildFly的Artemis上
Java中用ThreadGroup来表示线程组,我们可以使用线程组对线程进行批量控制。
ThreadGroup和Thread的关系就如同他们的字面意思一样简单粗暴,每个Thread必然存在于一个ThreadGroup中,Thread不能独立于ThreadGroup存在。执行main()方法线程的名字是main,如果在new Thread时没有显式指定,那么默认将父线程(当前执行new Thread的线程)线程组设置为自己的线程组。
示例代码:
public class Demo {
public static void main(String[] args) {
Thread testThread = new Thread(() -> {
System.out.println("testThread当前线程组名字:" +
Thread.currentThread().getThreadGroup().getName());
System.out.println("testThread线程名字:" +
Thread.currentThread().getName());
});
testThread.start();
System.out.println("执行main所在线程的线程组名字: " + Thread.currentThread().getThreadGroup().getName());
System.out.println("执行main方法线程名字:" + Thread.currentThread().getName());
}
}
输出结果:
执行main所在线程的线程组名字: main
执行main方法线程名字:main
testThread当前线程组名字:main
testThread线程名字:Thread-0
ThreadGroup管理着它下面的Thread,ThreadGroup是一个标准的向下引用的树状结构,这样设计的原因是防止"上级"线程被"下级"线程引用而无法有效地被GC回收
。
Java中线程优先级可以指定,范围是1~10。但是并不是所有的操作系统都支持10级优先级的划分(比如有些操作系统只支持3级划分:低,中,高),Java只是给操作系统一个优先级的参考值,线程最终在操作系统的优先级是多少还是由操作系统决定。
Java默认的线程优先级为5,线程的执行顺序由调度程序来决定,线程的优先级会在线程被调用之前设定。
通常情况下,高优先级的线程将会比低优先级的线程有更高的几率得到执行。我们使用方法Thread类的setPriority()实例方法来设定线程的优先级。
public class Demo {
public static void main(String[] args) {
Thread a = new Thread();
System.out.println("我是默认线程优先级:"+a.getPriority());
Thread b = new Thread();
b.setPriority(10);
System.out.println("我是设置过的线程优先级:"+b.getPriority());
}
}
输出结果:
我是默认线程优先级:5
我是设置过的线程优先级:10
既然有1-10的级别来设定了线程的优先级,这时候可能有些读者会问,那么我是不是可以在业务实现的时候,采用这种方法来指定一些线程执行的先后顺序?
对于这个问题,我们的答案是:No!
Java中的优先级来说不是特别的可靠,Java程序中对线程所设置的优先级只是给操作系统一个建议,操作系统不一定会采纳。而真正的调用顺序,是由操作系统的线程调度算法决定的。
我们通过代码来验证一下:
public class Demo {
public static class T1 extends Thread {
@Override
public void run() {
super.run();
System.out.println(String.format("当前执行的线程是:%s,优先级:%d",
Thread.currentThread().getName(),
Thread.currentThread().getPriority()));
}
}
public static void main(String[] args) {
IntStream.range(1, 10).forEach(i -> {
Thread thread = new Thread(new T1());
thread.setPriority(i);
thread.start();
});
}
}
某次输出:
当前执行的线程是:Thread-17,优先级:9
当前执行的线程是:Thread-1,优先级:1
当前执行的线程是:Thread-13,优先级:7
当前执行的线程是:Thread-11,优先级:6
当前执行的线程是:Thread-15,优先级:8
当前执行的线程是:Thread-7,优先级:4
当前执行的线程是:Thread-9,优先级:5
当前执行的线程是:Thread-3,优先级:2
当前执行的线程是:Thread-5,优先级:3
Java提供一个线程调度器来监视和控制处于RUNNABLE状态的线程。线程的调度策略采用抢占式,优先级高的线程比优先级低的线程会有更大的几率优先执行。在优先级相同的情况下,按照“先到先得”的原则。每个Java程序都有一个默认的主线程,就是通过JVM启动的第一个线程main线程。
还有一种线程称为守护线程(Daemon),守护线程默认的优先级比较低。
如果某线程是守护线程,那如果所有的非守护线程都结束了,这个守护线程也会自动结束。
应用场景是:当所有非守护线程结束时,结束其余的子线程(守护线程)自动关闭,就免去了还要继续关闭子线程的麻烦。
一个线程默认是非守护线程,可以通过Thread类的setDaemon(boolean on)来设置。
在之前,我们有谈到一个线程必然存在于一个线程组中,那么当线程和线程组的优先级不一致
的时候将会怎样呢?我们用下面的案例来验证一下:
public static void main(String[] args) {
ThreadGroup threadGroup = new ThreadGroup("t1");
threadGroup.setMaxPriority(6);
Thread thread = new Thread(threadGroup,"thread");
thread.setPriority(9);
System.out.println("我是线程组的优先级"+threadGroup.getMaxPriority());
System.out.println("我是线程的优先级"+thread.getPriority());
}
输出:
我是线程组的优先级6
我是线程的优先级6
所以,如果某个线程优先级大于线程所在线程组的最大优先级,那么该线程的优先级将会失效,取而代之的是线程组的最大优先级。
线程组的常用方法及数据结构
线程组的常用方法
获取当前的线程组名字
Thread.currentThread().getThreadGroup().getName()
复制线程组
// 获取当前的线程组
ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
// 复制一个线程组到一个线程数组(获取Thread信息)
Thread[] threads = new Thread[threadGroup.activeCount()];
threadGroup.enumerate(threads);
线程组统一异常处理
package com.func.axc.threadgroup;
public class ThreadGroupDemo {
public static void main(String[] args) {
ThreadGroup threadGroup1 = new ThreadGroup("group1") {
// 继承ThreadGroup并重新定义以下方法
// 在线程成员抛出unchecked exception
// 会执行此方法
public void uncaughtException(Thread t, Throwable e) {
System.out.println(t.getName() + ": " + e.getMessage());
}
};
// 这个线程是threadGroup1的一员
Thread thread1 = new Thread(threadGroup1, new Runnable() {
public void run() {
// 抛出unchecked异常
throw new RuntimeException("测试异常");
}
});
thread1.start();
}
}
线程组还可以包含其他的线程组,不仅仅是线程。
首先看看 ThreadGroup源码中的成员变量
public class ThreadGroup implements Thread.UncaughtExceptionHandler {
private final ThreadGroup parent; // 父亲ThreadGroup
String name; // ThreadGroupr 的名称
int maxPriority; // 线程最大优先级
boolean destroyed; // 是否被销毁
boolean daemon; // 是否守护线程
boolean vmAllowSuspension; // 是否可以中断
int nUnstartedThreads = 0; // 还未启动的线程
int nthreads; // ThreadGroup中线程数目
Thread threads[]; // ThreadGroup中的线程
int ngroups; // 线程组数目
ThreadGroup groups[]; // 线程组数组
}
然后看看构造函数:
// 私有构造函数
private ThreadGroup() {
this.name = "system";
this.maxPriority = Thread.MAX_PRIORITY;
this.parent = null;
}
// 默认是以当前ThreadGroup传入作为parent ThreadGroup,新线程组的父线程组是目前正在运行线程的线程组。
public ThreadGroup(String name) {
this(Thread.currentThread().getThreadGroup(), name);
}
// 构造函数
public ThreadGroup(ThreadGroup parent, String name) {
this(checkParentAccess(parent), parent, name);
}
// 私有构造函数,主要的构造函数
private ThreadGroup(Void unused, ThreadGroup parent, String name) {
this.name = name;
this.maxPriority = parent.maxPriority;
this.daemon = parent.daemon;
this.vmAllowSuspension = parent.vmAllowSuspension;
this.parent = parent;
parent.add(this);
}
第三个构造函数里调用了checkParentAccess方法,这里看看这个方法的源码:
// 检查parent ThreadGroup
private static Void checkParentAccess(ThreadGroup parent) {
parent.checkAccess();
return null;
}
// 判断当前运行的线程是否具有修改线程组的权限
public final void checkAccess() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkAccess(this);
}
}
这里涉及到SecurityManager这个类,它是Java的安全管理器,它允许应用程序在执行一个可能不安全或敏感的操作前确定该操作是什么,以及是否是在允许执行该操作的安全上下文中执行它。应用程序可以允许或不允许该操作。
比如引入了第三方类库,但是并不能保证它的安全性。
其实Thread类也有一个checkAccess()方法,不过是用来当前运行的线程是否有权限修改被调用的这个线程实例。(Determines if the currently running thread has permission to modify this thread.)
总结来说,线程组是一个树状的结构,每个线程组下面可以有多个线程或者线程组。线程组可以起到统一控制线程的优先级和检查线程的权限的作用。
一 点睛 线程可以设置为守护线程,ThreadGroup 也可以设置为守护 ThreadGroup,但是若将一个 ThreadGroup 设置为 deamon,也并不会影响线程的 daemon 属性,
一 基本操作 public int activeCount():用于获取 group 中活跃的线程,这只是估计值,并不能百分百地保证数字一定正确。 public int activeGroupCoun
一 点睛 destroy 用于销毁 ThreadGroup,该方法只是针对一个没有任何 active 线程的 group 进行一次 destroy 标记,调用该方法的直接结果是在父 group 中将自
一 点睛 ThreadGroup 复制线程组的两个方法。 public int enumerate(ThreadGroup list[]) // 相对于 enumerate(list,true) pu
一 点睛 interrupt 一个 thread group 会导致该 group 中所有 active 线程全部 interrupt,也就是说该 group 中每一个线程的中断标识都被设置了。 二
1.概述 转载:线程组是什么?线程优先级如何设置? 2. 线程组(ThreadGroup) Java中用ThreadGroup来表示线程组,我们可以使用线程组对线程进行批量控制。 ThreadGrou
我知道当前使用 Executors 而不是 ThreadGroup 的做法: 处理线程的一般首选方式 从线程等中捕获异常... 但是,ThreadGroup 的固有缺陷 本身是什么(我听到了对该类的含
我有一些漂亮的样板 Java 代码,它使用 tg.getParent() 执行 while 循环来获取根线程组。它已经在四种不同的环境(一个 Windows 和三个 Linux)上运行了几个月。最近,
当我运行 pmd 检查时,我的代码出现避免线程组错误,但我不明白为什么。谁能给我解释一下吗? Timestamp currentTimestamp = new java.sql.Timestamp(C
ThreadGroup#activeCount() 的文档说:返回此线程组及其子组中 Activity 线程数量的估计值。 该计数是否包括处于 sleep 、 wait 和 join 模式的线程,还是
我正在学习多线程的概念,我试图找到数组中 Activity 线程的数量,但是 ThreadGroup.activeCount() 的方法> 仅返回零值。 这是代码: 线程对象类:- class th1
我开始为 Java 中已经存在的项目(非多线程项目)开发一些多线程平台,我需要性能增益,减少整个项目中复杂计算的时间。 我一直在使用 Executors,但我真的不知道与 ThreadGroup 或纯
Java 编程语言使用ThreadGroup 来管理线程之间的访问权限: A thread group represents a set of threads. In addition, a thre
我正在寻找最佳实践,并且正在将 PMD 应用到我的 Java EE 项目中,但一条规则表明我必须避免使用 java.lang.ThreadGroup,而我现在正在使用它。 规则说这是不安全的,我想知道
我已经为生产者和消费者实现了一个信号量类。 它工作正常,但我现在感觉我们使用 notifyAll 来通知唤醒的线程或通知所有线程。 我想知道是否有任何方法可以只通知一组特定的组:比如生产者只通知消费者
这个问题与我在 Java 并发主题中的作业有关。我的任务是生成新线程并通过给定的 concurrencyFactor 限制它们。也就是说,继续分派(dispatch)新线程,直到 Activity 线
Thread.activeCount() 和 ThreadGroup.activeCount() 有什么区别? oracle java 文档说这两种方法都会返回组(包括子组)中的估计线程数。当我得到列
我使用的是用于批处理的 ThreadPoolExecutor,但单个 JVM 上的单个线程池仅使用可用服务器的 CPU 之一。如果使用新线程池启动并行的第二个 JVM,我将使用另一个 CPU。 所以我
不使用任何令人讨厌的反射。有什么快速/简单的方法来做到这一点(无需复制和粘贴计时器代码)? 最佳答案 不要使用定时器,尝试ScheduledExecutorService反而。合并调用 Executo
java.lang.Thread 类有一个构造函数,它仅接受一个字符串参数作为线程名称。它有一个仅接受 Runnable 目标的构造函数。但它也有一个默认构造函数。这意味着名称或可运行目标不是强制性的
我是一名优秀的程序员,十分优秀!