线程基础知识_线程生命周期_从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方法:

@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虚拟机空间越大, 那么能创建的线程就越少