Java高并发编程详解系列-深入理解Thread构造

阳光穿透心脏的1/2处 2022-02-12 12:29 239阅读 0赞

> 上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。  
> 这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。

这里首先提供一个JDK1.6的ThreadAPI截图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70]

### 线程命名规范 ###

从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个名方式跟上篇文章中的查看的结果是一样的效果。通过Thread-数字的组合来为线程命名，而这个命名也会在JVM自动增加。

public Thread(Runnable target) { 
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

private static synchronized int nextThreadNum() { 
           return threadInitNumber++;
     }

当然除了通过默认的命名方式Thread还提供了一个构造函数，但是这几个构造函数统统都实现了一个方法,作为线程初始化的方法，该方法给我们提供了几个参数

*  第一个参数表示线程组
 *  第二个参数表示线程的Runable接口实现类
 *  第三个参数表示线程名称
 *  第四个参数表示栈大小
 *  第五个参数表示上下文 用于基于它所封装的上下文作出系统资源访问决定。
 *  第六个参数表示如果为true, 则从构造线程继承的线程局部变量，继承的初始值;

private void init(ThreadGroup g, Runnable target, String name,
                          long stackSize, AccessControlContext acc,
                          boolean inheritThreadLocals) { 
            //如果名字为空则会抛出异常，所以说在使用的时候为了方便起见需要自己定义一个线程的名称
            if (name == null) { 
                throw new NullPointerException("name cannot be null");
            }
    
            this.name = name;
    
    		//获取到父线程的值
            Thread parent = currentThread();
           	//调用系统安全管理器
            SecurityManager security = System.getSecurityManager();
            //如果线程组为空
            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);
            //继承构造函数的初始变量，这里使用到了一个ThreadLocal在以后会遇到
            if (inheritThreadLocals && parent.inheritableThreadLocals != null)
                this.inheritableThreadLocals =
                    ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
             //指定的堆栈大小
            this.stackSize = stackSize;
    
            //获取到线程命名的ID号
            tid = nextThreadID();
        }

可以根据上面的注释理解一下线程初始化方法的执行的流程。当然，既然有既然线程的名称是作为一个成员变量来实现的，所以线程应该有对应的独立的设置线程名称的方法。

public final synchronized void setName(String name) { 
            checkAccess();
            if (name == null) { 
                throw new NullPointerException("name cannot be null");
            }
    
            this.name = name;
            if (threadStatus != 0) { 
                setNativeName(name);
            }
        }

private native void setNativeName(String name);

/* Java thread status for tools, * initialized to indicate thread 'not yet started' */
    
        private volatile int threadStatus = 0;

通过上面源码的分析，可以得到一个结论，就是说当我们线程没有启动的时候我们是可以调用底层的方法对线程进行命名操作。但是如果线程是启动的话就不可以进行这个操作。

### 线程之间的父子关系 ###

在之前的分析中，我们知道所有的线程构造函数最后都调用了一个私有的方法init()当然在这个方法中也实现了很多的功能，在这个方法中看到最多的字眼就是parent，对于每个线程来说都有一个属于自己的父类线程。这里我们拿JDK1.8的源码来作为分析的。在init方法中有如下的方法

public static native Thread currentThread();

这个方法是用来获取当前线程，在线程的生命周期中，线程的最初的状态是new这个状态，在没有被调用start方法的时候，只能是算作是Java中的普通的实例。并没有真正的调用start0方法进行底层的调用。所以说currentThread方法得到的就是通过调用start0方法才能实现的那个线程。  
  也就是说一个线程必须由另外的一个线程来创建完成。对于其他所有的线程最终都是由main线程来创建的。而此时调用currentThread方法的时候获取到的就是main线程。

### 线程与线程组 ###

在init函数中有一段源码,这段源码看上去很难理解，但是仔细分析看来并不过是需要给当前线程找到一个合适的父线程

SecurityManager security = System.getSecurityManager();
            if (g == null) { 
                /* Determine if it's an applet or not */
    
                /* If there is a security manager, ask the security manager what to do. */
                if (security != null) { 
                    g = security.getThreadGroup();
                }
    
                /* If the security doesn't have a strong opinion of the matter use the parent thread group. */
                if (g == null) { 
                    g = parent.getThreadGroup();
                }
            }

测试代码

public class ThreadConstruction { 
        public static void main(String[] args){ 
            Thread t1 = new Thread("T1");
    
            ThreadGroup group = new ThreadGroup("TestGroup");
    
            Thread t2 = new Thread(group,"T2");
    
            ThreadGroup mainThreadGroup = Thread.currentThread().getThreadGroup();
    
            System.out.println("主线程所属的线程组是:"+mainThreadGroup.getName());
            System.out.println("T1 线程和 主线程 是否属于同一组 "+(mainThreadGroup==t1.getThreadGroup()));
            System.out.println("T2 线程和 主线程 是否属于同一组 "+(mainThreadGroup==t2.getThreadGroup()));
            System.out.println("T2 线程和 group 是否属于同一组 "+(group==t2.getThreadGroup()));
        }
    }

测试结果

主线程所属的线程组是:main
    T1 线程和 主线程 是否属于同一组 true
    T2 线程和 主线程 是否属于同一组 false
    T2 线程和  group 是否属于同一组 tru

就如注释中解释的那样，当我们创建一个线程，但是没有指定对应的线程组的时候，它会和父线程属于同一个线程组。

### Thread的stackSize参数 ###

在我们分析init方法的时候提到了一个参数stackSize，在我们看到JDK1.6API的时候也有构造方法对这个参数进行了修改。这个参数到底代表什么意义呢，既然是栈那么就按照栈的性质理解即可。也就是说这个参数越大线程内方法调用的递归深度越深，参数越小就表明递归深度小，需要创建线程数量多。  
  但是在很多的平台一些平台性能不好的情况下这个参数并不会起到什么样的作用，而是通过-XSS参数进行设置。

public Thread(ThreadGroup group,
                  Runnable target,
                  String name,
                  long stackSize)
    
    参数：
    group - 线程组。
    target - 其 run 方法被调用的对象。
    name - 新线程的名称。
    stackSize - 新线程的预期堆栈大小，为零时表示忽略该参数。 
    抛出： 
    SecurityException - 如果当前线程无法在指定的线程组中创建线程。
    从以下版本开始： 
    1.4

### 线程内存与堆内存分代 ###

![在这里插入图片描述][20190428224301180.png]  
对于这个分代操作在后面讲到垃圾回收机制的时候有更为详细的介绍。  
在JDK1.8之后持久代被彻底的删除，取代它的被称为是元空间，这里就有一个问题了，什么是持久代呢？在Java虚拟机规范中将堆内存中的一个逻辑分区称为是持久代，这个持久代如果站在内存回收的角度上讲就是方法区。在方法区中的实例在执行垃圾回收的时候是永远不会被回收的。

这里我们可以使用一个jstat命令来查看  
**JDK1.7**  
![在这里插入图片描述][2019042822500067.png]  
**JDK1.8**  
![在这里插入图片描述][20190428225130122.png]  
在这里我们比较两个命令执行的效果会发现有一个东西发生了变化，在中间部分的地方JDK1.7中是使用P表示，而JDK1.8 中使用的是M表示，而JDK1.8中的元空间同样是作为堆内存的一部分，JVM为每个类加载器分配一块内存类表，进行线性分配，块的大小决定于类加载器的类型，反射/代理/对应的类加载块会小一些，而其他的类加载会多一些。现在的GC操作是：如果发现某个类加载器具备回收的条件就把整个类加载器相关的元空间全部进行回收。节省了GC的效率。

### 线程与虚拟机栈 ###

JVM虚拟机的内存分布在之前的博客中已经详细分享介绍了。在多线程中影响线程多少的因素直接取决于JVM的虚拟机栈。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70 1]  
通过上面的表格可以看到，线程创建数量随着虚拟机栈内存的增多而减少。在之前的博客中有一个比较经典的图，也就说虚拟机栈内存是线程私有的。也就说每个线程都会占用指定的内存大小。**堆内存+线程数量\*栈内存**这个就表示Java中的一个进程的内存大小。  
如果按照这个样子来算的话，如果存在栈内存越来越大的话，在总内存数量不变的情况下线程数量只能越来越少。

**线程数=（最大地址空间-JVM堆内存-ReservedOsMemory）/XSS（线程栈大小）**

### 守护线程 ###

在分析init方法的时候

this.daemon = parent.isDaemon();

这里有一个这样的操作，是否是守护线程。那么什么是守护线程呢？

public class DaemonThread { 
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(()->{ 
                while (true){ 
                    try { 
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            });
            //thread.setDaemon(true);
            thread.start();
    
            Thread.sleep(2000L);
            System.out.println("主线程结束 thread");
        }
    }

其实这个代码我们分析一下就可以知道，当我们的主线程结束生命周期的时候，程序并不会停止下来，那么为什么会出现这种情况呢？在JVM如果没有一个非守护线程，JVM就会结束。从这个角度上看守护线程的一个作用就是具备自我结束生命周期的作用。那么什么是守护线程呢？又回到了我们最初的问题上。

**守护线程**是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。因 此，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不会终止

## 总结 ##

这次主要说了一下线程的构造、线程与线程组、父线程与子线程、线程栈、以及守护线程等。主要比较关注的几个点就是比较基础的线程栈，这个也可能会与JVM虚拟机的优化结合到一起。分析了如何使用守护线程。

上一篇\[[https://blog.csdn.net/nihui123/article/details/89609060][https_blog.csdn.net_nihui123_article_details_89609060]\]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70]: /images/20220212/f624086e0f9f48758be86e966b2d0005.png
[20190428224301180.png]: /images/20220212/a603aaa2a7ee4423bb1b867a62de2357.png
[2019042822500067.png]: /images/20220212/2f5526caa2be46fcb7e438be1107f9fa.png
[20190428225130122.png]: /images/20220212/5aa05882e72845f4923fbed08d662f7a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70 1]: /images/20220212/acd8ca038ea046eab1d1abb403a0888f.png
[https_blog.csdn.net_nihui123_article_details_89609060]: https://blog.csdn.net/nihui123/article/details/89609060