线程基础知识_线程生命周期_从JVM内存结构看多线程下的共享资源

线程生命周期

在这里插入图片描述

线程状态

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方法:

@Overridepublic void run() {//target代表new Thread(Runnable target)中传入的Runnable对象if (target != null) {target.run();}}

从上面的run方法得出, 创建线程的2中常用方式:

1. new Thread(){@Overridepublic void run() {//.........}};
2.new Thread(new Runnable() {@Overridepublic 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();//设置当当前线程的groupif (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();elsethis.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"){@Overridepublic void run(){//当前线程组可以对父类线程组或父类线程组中线程进行只读操作, 写操作将会出现异常System.out.println(Thread.currentThread().getThreadGroup().getParent().getName());}}.start();try {Thread.sleep(2_000);} catch (InterruptedException e) {e.printStackTrace();}//当线程组内线程(不是守护线程)都没有存活, 线程组不会destroy, 需要主动destroySystem.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(){@Overridepublic 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虚拟机空间越大, 那么能创建的线程就越少