线程生命周期
线程状态
New: 线程创建(new Thread())
Runnable: 线程可运行(thread.start()), 注: 调用start并不一定是运行状态, 可能在等待CPU调度
Running: 线程进入运行状态
Blocked: 阻塞状态(object.wait, Thread.sleep)
Terminal: 死亡状态(线程正常/非正常结束运行)
thread.start()方法分析线程状态
start源码:
public synchronized void start() {
//使用if判断thread状态, threadStatus为0表示当前线程处于new状态
if (threadStatus != 0)
throw new IllegalThreadStateException();
//将线程添加到对应线程组中
group.add(this);
boolean started = false;
try {
//native方法
start0();
started = true;
} finally {
try {
//根据线程是否启动成功, 来决定是否添加threadStartFailed中
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
Thread使用threadStatus判断线程状态, 当线程启动后, 再次启动, 或者线程处于死亡状态, 还对线程进行start, 就会因为threadStatus抛出IllegalThreadStateException
Thread中的模板设计模式
模板设计模式: 接口定义算法骨架, 在不同的子类中, 对其算法骨架具有不同的实现方式
由于Thread实现了Runnable接口, 在Runnable中定义了算法骨架(run方法的定义), 因此创建线程一般都是重新run方法(继承Thread, 或者实现Runnable)
Thread中的run方法:
@Override
public void run() {
//target代表new Thread(Runnable target)中传入的Runnable对象
if (target != null) {
target.run();
}
}
从上面的run方法得出, 创建线程的2中常用方式:
1. new Thread(){
@Override
public void run() {
//.........
}
};
2.new Thread(new Runnable() {
@Override
public void run() {
//.......
}
});
二者的区别:
方式1中, 不能做到run方法重用, 方式2中, 可以做到run方法重用(一个runnable对象能给多个thread使用)
这里一定要注意共享资源的使用, 这里很容易让人误解: 多个线程共享一个资源的时候, 必须保证这样的资源只有一份, 解决方式有: 当多个runnable对象时, 多个thread, 可以设置共享变量是static类型, 当只存在一份runnbable对象, 可以设置共享变量是普通成员变量, 其实这两种方式都是类似的, 只是取决于使用哪种方式创建线程, 使用多个Runnable对象, 还是一个Runnable对象.
Thread的init
调用线程的构造方法的时候, 就会自动调用Thread的init方法
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
//线程初始化操作
//stackSize: 设置线程内递归深度
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
//此时获取的线程是main线程, main线程执行子线程的初始化操作, 只有当子线程
//执行run操作的时候, 才意味着子线程启动
Thread parent = currentThread();
SecurityManager security = System.getSecurityManager();
//设置当当前线程的group
if (g == null) {
if (security != null) {
g = security.getThreadGroup();
}
if (g == null) {
g = parent.getThreadGroup();
}
}
g.checkAccess();
if (security != null) {
if (isCCLOverridden(getClass())) {
security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
}
}
g.addUnstarted();
//根据父线程属性, 设置当前线程的状态
this.group = g;
this.daemon = parent.isDaemon();
this.priority = parent.getPriority();
if (security == null || isCCLOverridden(parent.getClass()))
this.contextClassLoader = parent.getContextClassLoader();
else
this.contextClassLoader = parent.contextClassLoader;
this.inheritedAccessControlContext =
acc != null ? acc : AccessController.getContext();
this.target = target;
setPriority(priority);
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
this.stackSize = stackSize;
tid = nextThreadID();
}
从init可以看出
当线程创建的时候, 如果不指定group, priority等属性的时候, 默认使用父线程(例如: main线程创建一个新的线程)的值
一个线程的创建, 依赖与另外一个线程(注: main线程的创建依赖于JVM)
当创建线程的时候, 没有指定线程的Group, 默认使用父线程所在的Group
ThreadGroup测试
思考引发: 能否使用ThreadGroup进行线程通信
/**
* 测试ThreadGroup
* @author regotto
*/
public class ThreadGroupTest1 {
public static void main(String[] args) {
ThreadGroup group = new ThreadGroup("g1");
System.out.println(group.getParent().getName());
new Thread(group, "t1"){
@Override
public void run(){
//当前线程组可以对父类线程组或父类线程组中线程进行只读操作, 写操作将会出现异常
System.out.println(Thread.currentThread().getThreadGroup().getParent().getName());
}
}.start();
try {
Thread.sleep(2_000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//当线程组内线程(不是守护线程)都没有存活, 线程组不会destroy, 需要主动destroy
System.out.println("group.isDestroyed()" + group.isDestroyed());
group.destroy();
System.out.println("group.isDestroyed()" + group.isDestroyed());
//将中断group中所有线程
// group.interrupt();
//将group中线程copy到线程数组中
// group.enumerate(new Thread[10]);
}
}
结论:
可以使用ThreadGroup进行线程通信, 但是这种通信存在局限性, 可以使用ChildThreadGroup获取ParentThreadGroup信息, 但是反过来就不行, 并且Child只能读取Parent的信息, 不能进行写操作
守护线程
用通俗的话来描述, 守护线程就是后台线程, 处理后台任务, 当前台任务执行完, 守护线程自动销毁, 例如JVM就是守护线程
守护线程一般用于垃圾清理, 监控
/**
* 测试Daemon线程
* 结论: 只有当JVM中所有线程结束,Daemon才会结束, 即使线程组不同
* @author regotto
*/
public class DaemonThreadTest {
public static void main(String[] args) {
Thread T = new Thread(new ThreadGroup("group1"), () -> {
Thread t1 = new Thread(() -> {
System.out.println(Thread.currentThread().getThreadGroup() + "心跳线程开始");
while (Thread.currentThread().isAlive()) {
System.out.println(Thread.currentThread().getThreadGroup() + "心跳线程存活");
}
});
t1.setDaemon(true);
t1.start();
System.out.println(Thread.currentThread().getThreadGroup() + "I/O操作线程");
try {
TimeUnit.MILLISECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getThreadGroup() + "I/O线程结束");
}).start();
try {
TimeUnit.MILLISECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getThreadGroup() + "main thread dead");
}
}
T线程启动, 启动一个守护线程t1开始心跳, 当T线程死亡, 守护线程自动退出心跳结束
ThreadHook
ThreadHook: 线程钩子, 功能类似于守护线程(守护线程在前台线程运行中, 也都一直运行, 但是线程钩子只有最后程序结束,时 才执行thread.start操作), 当程序退出时, 负责垃圾清理或执行最后处理工作
ThreadHook测试
/**
* Hook在接收到程序退出信号的时候才会退出, 当直接kill进程且等级为10, Hook不会执行
* Hook可以负责资源释放操作(一定不要在Hook中执行很耗时的操作, 会导致程序不能退出)
* @author regotto
*/
public class ThreadHook {
public static void main(String[] args) {
//Hook可以注册多个, 在JVM进程将要退出, 执行Hook中线程(多个Hook, 则并行执行)
Runtime.getRuntime().addShutdownHook(new Thread(() -> System.out.println("Hook1 running")));
Runtime.getRuntime().addShutdownHook(new Thread(){
@Override
public void run() {
System.out.println("Hook2 running");
}
});
}
}
从JVM内存结构看多线程下的共享资源
各个模块的简单描述
1.方法区: 存放.class文件, 类信息, 常量, 静态变量
2.程序计数器: 当.class文件加载JVM的方法区中时, 当前线程利用程序计数器执行方法区中的字节码指令
由于不同的线程执行指令不能相互影响, 因此设置程序计数器为线程私有
3.Java虚拟机栈: Java虚拟机栈是一个栈结构, 存放栈帧,
每一个栈帧就是一次方法调用(栈帧中存放方法局部变量表, 操作栈, 动态链接, 方法出口等),
不同线程执行过程调用的方法顺序不同, 因此Java虚拟机栈就是线程私有的
每一个线程的Java虚拟机栈生命期与线程相同
4.本地方法栈: 与Java虚拟机栈类似, 只是本地方法栈存放线程调用native方法的栈帧情况
5.堆内存: 存放公共资源, JVM运行过程中存放所有生成的对象, 被所有线程共享
7.直接内存: 此块区域归属于native方法(C/C++)执行时用的堆空间
注: 由于Java虚拟机栈属于线程私有, 当每个线程的Java虚拟机空间越大, 那么能创建的线程就越少