Java多线程基础(一)——线程和线程组

Posted by Lain on 09-29,2019

0

工作中很少真正用到多线程,毕竟CRUD就完事了,但是作为一名Coder,还是很想弄明白底层的一些东西,之前也看过《Java并发编程实战》,但由于没有总结输出,以至于看了就忘==。前几天在学习JVM的类加载器的时候,发现线程里有一个 getContextClassLoader() 方法,心想着是时候对Thread也来一次全面的认识了(重 新 打 基 础),于是就开始了线程的学习。

Thread类

1、创建线程

在Java中,表示线程的就只有Thread类。

要创建一个线程,主要有两种方式,一种是继承Thread类,重写其run方法。另一种是实现Runnable接口,在通过Thread的构造函数传入,由于创建线程过于基础,这里不做过多记录。

@FunctionalInterface

Runnable是一个函数式接口,打开源代码可以看到类上使用了 @FunctionalInterface 注解,表示这个接口中只有一个抽象方法。

这里简单介绍一下函数式接口。

函数式接口是Java8带来的接口新特性,其特点是要求函数式接口要满足以下特性:

  1. 接口中有且只有一个 抽象 方法。
  2. 接口中的静态方法以及 默认方法(被default修饰的方法) 都不是抽象方法
  3. 接口默认继承的java.lang.Object,如果接口中显式声明覆盖了Object中的方法,该方法也不是抽象方法。
  4. 如果一个接口符合上述定义,那么无论是否添加 @FunctionalInterface 都没有关系。但加上注解,编译器会对接口进行检查,如果发现接口不符合函数式接口的定义,在编译的时候会报异常。

符合函数式接口的接口,我们可以用lambda表达式来简化对接口的实现。

比如创建线程:

Thread t1 = new Thread(()->{
    System.out.println("Hello,Lain!");
},"t1");
t1.start();

看上去是不是有点像通过匿名内部类的方式创建线程?实际上这里调用的是这个构造器:Thread(Runnable,String),而匿名内部类实际上还是相当于继承了Thread,然后重写了其run方法。

创建线程中涉及到的设计模式——策略模式

对于Thread来说,它封装了对线程的抽象,创建线程,启动线程的内部实现是不需要我们去完成的,我们只要把业务代码交给线程就行了。Runnable接口为我们提供了便利。

这里使用到了策略模式,所谓的策略模式,即是定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。对于Thread来说,它不管你Runnable里面是什么逻辑,它只管调用里面的run方法,通过这种方式将Thread与业务逻辑松耦合。

Thread的构造器

Thread拥有一系列构造器,以便于在定义Thread的时候,以初始化线程名、线程组(ThreadGroup)、Runnable对象(执行对象),以及线程栈大小(stackSize)。

线程名就不用说了,阅读源码可知,如调用的构造器没有name参数,则会默认的赋予“Thread-” + nextThreadNum()。这个方法是个线程安全的方法,它会统计创建的匿名线程的次数,并以次数作为线程名字的一部分。如果构造器里有name参数,那么这个参数不允许为null,否则会抛出空指针异常。

Runnable对象实现了Runnable接口,封装了需要在线程中处理的业务逻辑。

这里重点提一下线程组(ThreadGroup)以及线程栈大小。

线程组

ThreadGroup是用于管理一组线程的,JVM启动时,会默认创建一个System分组,默认会有五个线程(四个system和一个main线程):

(以下摘录自简书

Attach Listener:Attach Listener线程是负责接收到外部的命令,而对该命令进行执行的并且吧结果返回给发送者。通常我们会用一些命令去要求jvm给我们一些反 馈信息,如:java -version、jmap、jstack等等。如果该线程在jvm启动的时候没有初始化,那么,则会在用户第一次执行jvm命令时,得到启动。

Signal Dispatcher:前面我们提到第一个Attach Listener线程的职责是接收外部jvm命令,当命令接收成功后,会交给signal dispather线程去进行分发到各个不同的模块处理命令,并且返回处理结果。signal dispather线程也是在第一次接收外部jvm命令时,进行初始化工作。

Finalizer:这个线程也是在main线程之后创建的,其优先级为10,主要用于在垃圾收集前,调用对象的finalize()方法;关于Finalizer线程的几点:

  1. 只有当开始一轮垃圾收集时,才会开始调用finalize()方法;因此并不是所有对象的finalize()方法都会被执行;

  2. 该线程也是daemon线程,因此如果虚拟机中没有其他非daemon线程,不管该线程有没有执行完finalize()方法,JVM也会退出;
  3. JVM在垃圾收集时会将失去引用的对象包装成Finalizer对象(Reference的实现),并放入ReferenceQueue,由Finalizer线程来处理;最后将该Finalizer对象的引用置为null,由垃圾收集器来回收;
  4. JVM为什么要单独用一个线程来执行finalize()方法呢?如果JVM的垃圾收集线程自己来做,很有可能由于在finalize()方法中误操作导致GC线程停止或不可控,这对GC线程来说是一种灾难;

Reference Handler:VM在创建main线程后就创建线程,其优先级最高,为10,它主要用于处理引用对象本身(软引用、弱引用、虚引用)的垃圾回收问题。

main:程序主线程

我们可以实际验证一下:

package fun.lain.laintest.thread;
import java.util.Arrays;

public class CreateThreadTest {
    //https://www.cnblogs.com/noteless/p/10354721.html
    public static void main(String[] args) throws InterruptedException {
        //输出父线程组中所有线程
        CreateThreadTest.printParentGroup("System:");
        CreateThreadTest.printGroup("main");
    }

    public static void printGroup(String threadMark){
        Thread[] threads = new Thread[6];
        Thread.currentThread().getThreadGroup().enumerate(threads);
        System.out.println(threadMark + Arrays.toString(threads));
    }

    public static void printParentGroup(String threadMark){
        Thread[] threads = new Thread[6];
        Thread.currentThread().getThreadGroup().getParent().enumerate(threads);
        System.out.println(threadMark + Arrays.toString(threads));
    }
}

输出结果:

System:[Thread[Reference Handler,10,system], Thread[Finalizer,8,system], Thread[Signal Dispatcher,9,system], Thread[Attach Listener,5,system], Thread[main,5,main], null]
main[Thread[main,5,main], null, null, null, null, null]

可以看到确实是启动了这么些个线程。

如果我们在main方法中新建了线程,且线程没有指定线程组,那么这个线程会被归到main方法所在的线程组中去。

注意: 当程序执行线程的构造器时,就已经为线程对象归好了线程组,并非是在线程启动的时候。也就是说线程默认在哪个线程组,取决于线程对象被定义的线程,而不是线程对象调用start()方法的线程!

我们可以看一下Thread的源代码片段:

public Thread(String name) {
    init(null, null, name, 0);
}
//...

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();//native方法,获得当前线程
    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) {//当ThreadGroup为空的时候
            g = parent.getThreadGroup();//设置为当前线程的线程组
        }
        //.....
}

可以看到,在构造Thread对象的时候,他所在的线程组就已经设置好了。

然后在启动线程的时候,再将自己加入该线程组。

/**
 * Causes this thread to begin execution; the Java Virtual Machine
 * calls the <code>run</code> method of this thread.
 * <p>
 * The result is that two threads are running concurrently: the
 * current thread (which returns from the call to the
 * <code>start</code> method) and the other thread (which executes its
 * <code>run</code> method).
 * <p>
 * It is never legal to start a thread more than once.
 * In particular, a thread may not be restarted once it has completed
 * execution.
 *
 * @exception  IllegalThreadStateException  if the thread was already
 *               started.
 * @see        #run()
 * @see        #stop()
 */
public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);//在这里,将自己添加进了线程组

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

最后,当线程结束的时候,线程会从线程组里移除。

下面看一个例子:

package fun.lain.laintest.thread;

import java.util.Arrays;

public class CreateThreadTest {
    public static void main(String[] args) throws InterruptedException {
        CreateThreadTest.printParentGroup("System:");
        CreateThreadTest.printGroup("main");
        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                //再启动一个线程
                Thread t2 = new Thread(()->{
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    CreateThreadTest.printGroup("T2:");
                },"t2");
                t2.start();

                CreateThreadTest.printGroup("T1:");

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t1.start();
        //确保线程t1中的t2已经启动
        Thread.sleep(500);

        CreateThreadTest.printGroup("main pre");
        CreateThreadTest.printParentGroup("System pre");
        //确保线程t1,t2均启动完成
        Thread.sleep(4000);
        CreateThreadTest.printGroup("main aft");
        CreateThreadTest.printParentGroup("System after");

    }

    public static void printGroup(String threadMark){
        Thread[] threads = new Thread[6];
        Thread.currentThread().getThreadGroup().enumerate(threads);
        System.out.println(threadMark + Arrays.toString(threads));
    }

    public static void printParentGroup(String threadMark){
        Thread[] threads = new Thread[6];
        Thread.currentThread().getThreadGroup().getParent().enumerate(threads);
        System.out.println(threadMark + Arrays.toString(threads));
    }
}

这里定义了两个静态方法,用来输出当前线程的线程组,以及父线程的线程组内线程的状况。

输出结果如下:

System:[Thread[Reference Handler,10,system], Thread[Finalizer,8,system], Thread[Signal Dispatcher,9,system], Thread[Attach Listener,5,system], Thread[main,5,main], null]

main[Thread[main,5,main], null, null, null, null, null]

T1:[Thread[main,5,main], Thread[t1,5,main], Thread[t2,5,main], null, null, null]

main pre[Thread[main,5,main], Thread[t1,5,main], Thread[t2,5,main], null, null, null]

System pre[Thread[Reference Handler,10,system], Thread[Finalizer,8,system], Thread[Signal Dispatcher,9,system], Thread[Attach Listener,5,system], Thread[main,5,main], Thread[t1,5,main]]

T2:[Thread[main,5,main], Thread[t1,5,main], Thread[t2,5,main], null, null, null]
main aft[Thread[main,5,main], null, null, null, null, null]

System after[Thread[Reference Handler,10,system], Thread[Finalizer,8,system], Thread[Signal Dispatcher,9,system], Thread[Attach Listener,5,system], Thread[main,5,main], null]//线程结束,会从线程组中移除

可以看到,在线程T1中再启动一个线程T2,T2也会被加入main线程组,结合源代码可以知道,这里T2是拿的T1的线程组,而T1又是拿的main线程的,因此只要不指定线程组,无论是在哪里创建多少个线程,他们在线程组里都是平级关系的。

线程组的构造方法

ThreadGroup有两个公开的构造方法:

ThreadGroup(String name);
public ThreadGroup(ThreadGroup parent, String name);

线程组必须要有一个父组,如果我们不指定,那么它会默认使用当前线程的线程组。

/**
  * Constructs a new thread group. The parent of this new group is
  * the thread group of the currently running thread.
  * <p>
  * The <code>checkAccess</code> method of the parent thread group is
  * called with no arguments; this may result in a security exception.
  *
  * @param   name   the name of the new thread group.
  * @exception  SecurityException  if the current thread cannot create a
  *               thread in the specified thread group.
  * @see     java.lang.ThreadGroup#checkAccess()
  * @since   JDK1.0
  */
public ThreadGroup(String name) {
    this(Thread.currentThread().getThreadGroup(), name);
}

刚刚的例子,我们可以自己创建一个线程组玩一玩。

public class CreateThreadTest {
    public static void main(String[] args) throws InterruptedException {
        CreateThreadTest.printParentGroup("System:");
        CreateThreadTest.printGroup("main");
        //自己创建线程组
        ThreadGroup group = new ThreadGroup("Lain");
        Thread t1 = new Thread(group,"t1"){
            @Override
            public void run() {
                //再启动一个线程
                Thread t2 = new Thread(()->{
                    //...

输出结果:

System:[Thread[Reference Handler,10,system], Thread[Finalizer,8,system], Thread[Signal Dispatcher,9,system], Thread[Attach Listener,5,system], Thread[main,5,main], null]

main[Thread[main,5,main], null, null, null, null, null]
T1:[Thread[t1,5,Lain], Thread[t2,5,Lain], null, null, null, null]

main pre[Thread[main,5,main], Thread[t1,5,Lain], Thread[t2,5,Lain], null, null, null]

System pre[Thread[Reference Handler,10,system], Thread[Finalizer,8,system], Thread[Signal Dispatcher,9,system], Thread[Attach Listener,5,system], Thread[main,5,main], Thread[t1,5,Lain]]

T2:[Thread[t1,5,Lain], Thread[t2,5,Lain], null, null, null, null]

main aft[Thread[main,5,main], null, null, null, null, null]

System after[Thread[Reference Handler,10,system], Thread[Finalizer,8,system], Thread[Signal Dispatcher,9,system], Thread[Attach Listener,5,system], Thread[main,5,main], null]

可以看到T1,T2都变成我们自定义的组了。

另外我们也可以发现,ThreadGroup的enumerate方法是会遍历整个子树的,会输出组以及子组中的全部线程。

线程组提供了对多个线程的统一管理,我之后会再对这些操作进行详细的探究,今天就到这了。