再谈线程

特别说明：封面图片来源 https://www.zcool.com.cn/work/ZNDU3ODY1NzY=.html
未授权…若作者看到后不愿意授权可联系下架

​

谈起线程，大多数问起的话题无非是线程有几种状态（6种），几种创建方式（三种），他们的区别是什么，进而引申多线程，线程安全，线程池等。
​

在 Java 中，线程的几种状态。
​

A thread state. A thread can be in one of the following states:
​

NEW A thread that has not yet started is in this state.
RUNNABLE A thread executing in the Java virtual machine is in this state.
BLOCKED A thread that is blocked waiting for a monitor lock is in this state.
WAITING A thread that is waiting indefinitely for another thread to perform a particular action is in this state.
TIMED_WAITING A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.
TERMINATED A thread that has exited is in this state.

public enum State {
    /**
     * Thread state for a thread which has not yet started.
     */
    NEW,

    /**
     * Thread state for a runnable thread.  A thread in the runnable
     * state is executing in the Java virtual machine but it may
     * be waiting for other resources from the operating system
     * such as processor.
     */
    RUNNABLE,

    /**
     * Thread state for a thread blocked waiting for a monitor lock.
     * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
     */
    BLOCKED,

    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * <ul>
     *   <li>{@link Object#wait() Object.wait} with no timeout</li>
     *   <li>{@link #join() Thread.join} with no timeout</li>
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul>
     *
     * <p>A thread in the waiting state is waiting for another thread to
     * perform a particular action.
     *
     * For example, a thread that has called <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
     * that object. A thread that has called <tt>Thread.join()</tt>
     * is waiting for a specified thread to terminate.
     */
    WAITING,

    /**
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * <ul>
     *   <li>{@link #sleep Thread.sleep}</li>
     *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
     *   <li>{@link #join(long) Thread.join} with timeout</li>
     *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
     *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
     * </ul>
     */
    TIMED_WAITING,

    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     */
    TERMINATED;
}

校招那会，一个面试官问过我，什么守护线程，和用户线程有什么区别，什么情况下使用使用特定的线程？回想，竟是两年前的事情。
​

和同事一起开发项目，遇到一件奇怪的事。同事把服务发在测试环境，发现 http 请求不通，但是通过 PS 命令能看见应用的进程，并且有 info 级别的日志在输出，且没有错误日志（日志配置不规范，大忌，配置可参考：），同事找到我，我是新人，瑟瑟发抖的帮忙解决问题（之前帮忙解决了一个日志无法输出的问题）。 应用是 SpringBoot 框架搭建的，服务没起来（tomcat没起来），但是依然有日志在输出，通过 PS 命令查看能发现进程存在。
​

如果是你，你能第一时间知道或者猜测哪里出问题了吗？我第一次遇见这样的情况，一脸懵逼的看着PS命令的结果和 tail -f info.log 一行行的日志，陷入了沉思，主线程挂了，子线程不应该也挂了吗？我和旁边的同事说起这个质疑，他给我的回答说：是啊。可实际上，我们看到的情况并不是这样，主线程挂了，但是子线程还在执行。
​

补补基础知识，在 Java 中，线程分为两种，用户线程和守护线程，通过 Thread.setDaemon(true) 设置为守护线程，默认为用户线程。主线程结束子线程不一定结束，如果是用户线程则子线程可一直运行，若是守护线程，则主线程结束时，子线程结束。守护线程用完就没了，比如 JVM 的垃圾回收器就是守护线程在执行。总结一句话就是：主线程结束后用户线程还会继续运行，JVM存活。
​

我们来看一段代码。
​

@Slf4j
public class ThreadTest {

    public static void main(String[] args) {
        Thread thread = new Thread(new CommandRunnable());
        //thread.setDaemon(true);
        thread.start();

        throw new RuntimeException("主线程异常");
    }

    public static class CommandRunnable implements Runnable {
        @Override
        public void run() {
            while (true) {
                log.error(UUID.randomUUID().toString());
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    //
                }
            }
        }
    }

}

​

执行记录如下，可以看出，即使主线程结束，他的子线程（用户线程）依然在执行。如果把 thread.setDaemon(true) 启用，当主线程发生异常时，子线程（此时为守护线程）则会停止。

Exception in thread "main" java.lang.RuntimeException: 主线程异常
	at com.github.Is0x4096.demo.ThreadTest.main(ThreadTest.java:20)
22:24:01.559 [Thread-0] ERROR com.github.Is0x4096.demo.ThreadTest - 98dcacae-0f42-4b1b-a65e-cf2713019afe
22:24:02.065 [Thread-0] ERROR com.github.Is0x4096.demo.ThreadTest - 350b9cee-287e-40d8-abad-e6629dc42ce7
22:24:02.569 [Thread-0] ERROR com.github.Is0x4096.demo.ThreadTest - 08367116-c49c-4b2d-a6e5-e242168dabf9
22:24:03.072 [Thread-0] ERROR com.github.Is0x4096.demo.ThreadTest - 21e4e0da-9df3-4fe2-97bd-3bc473c871d1
22:24:03.577 [Thread-0] ERROR com.github.Is0x4096.demo.ThreadTest - 1465d1a4-55b8-4e46-90be-f2c4c8fadc4b
22:24:04.081 [Thread-0] ERROR com.github.Is0x4096.demo.ThreadTest - 552e5bef-c0af-4ad1-8995-366788199f3f
22:24:04.586 [Thread-0] ERROR com.github.Is0x4096.demo.ThreadTest - 8436bf4f-3566-40a5-a8f9-6d6790da0ab6

补完基础知识点，在看来 SpringBoot 启动过程的核心代码。org.springframework.boot.SpringApplication#run(java.lang.String…)
​

public ConfigurableApplicationContext run(String... args) {
	StopWatch stopWatch = new StopWatch();
	stopWatch.start();
	ConfigurableApplicationContext context = null;
	Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
	configureHeadlessProperty();
	SpringApplicationRunListeners listeners = getRunListeners(args);
	listeners.starting();
	try {
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
		ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
		configureIgnoreBeanInfo(environment);
		Banner printedBanner = printBanner(environment);
		context = createApplicationContext();
		exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
				new Class[] { ConfigurableApplicationContext.class }, context);
		prepareContext(context, environment, listeners, applicationArguments, printedBanner);
		refreshContext(context);
		afterRefresh(context, applicationArguments);
		stopWatch.stop();
		if (this.logStartupInfo) {
			new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
		}
		listeners.started(context);
		callRunners(context, applicationArguments);
	}
	catch (Throwable ex) {
           // 应用启动错误，被 catch 住，看方面里面的逻辑
		handleRunFailure(context, ex, exceptionReporters, listeners);
		throw new IllegalStateException(ex);
	}

	try {
		listeners.running(context);
	}
	catch (Throwable ex) {
		handleRunFailure(context, ex, exceptionReporters, null);
		throw new IllegalStateException(ex);
	}
	return context;
}

​

程序发生了异常，接下来 Spring 会去关闭容器。

private void handleRunFailure(ConfigurableApplicationContext context, Throwable exception,
		Collection<SpringBootExceptionReporter> exceptionReporters, SpringApplicationRunListeners listeners) {
	try {
		try {
			handleExitCode(context, exception);
			if (listeners != null) {
				listeners.failed(context, exception);
			}
		}
		finally {
			reportFailure(exceptionReporters, exception);
			if (context != null) {
				context.close();
			}
		}
	}
	catch (Exception ex) {
		logger.warn("Unable to close ApplicationContext", ex);
	}
       // 再次抛异常，把错误信息抛出去，走到这里主线程结束
	ReflectionUtils.rethrowRuntimeException(exception);
}

断点走到这里，发现了 Spring 没启动的根本原因，但是这个时候主线程结束了，为什么还有日志在输出？
​

仔细看了一下日志的输出时间间隔，十秒一次，这肯定是一个定时任务的杰作，找到输出日志的类，发现果然有一个定时任务在执行，问题定位到了。下面的代码可以复现这种情况，三种方式均能导致服务没起来但是进程存在。
​

@Slf4j
@Component
public class ScheduleThreadComponent implements InitializingBean {

    public static final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(Thread::new);

    // 01
    @Override
    public void afterPropertiesSet() throws Exception {
        executor.scheduleWithFixedDelay(new CommandRunnable(), 1, 5, TimeUnit.SECONDS);
    }

    // 02
    //public ScheduleThreadComponent() {
    //    executor.scheduleWithFixedDelay(new CommandRunnable(), 1, 5, TimeUnit.SECONDS);
    //}

    // 03
    //@PostConstruct
    //public void test() {
    //    executor.scheduleWithFixedDelay(new CommandRunnable(), 1, 5, TimeUnit.SECONDS);
    //}

}




@Slf4j
@RestController
public class TestController {

	// 其他地方替换字符串，注意test并没有配置内容，模拟 Spring 启动失败
    @Value("${test}")
    private String test;
    
}

​

问题定位到了，其实是我们使用代码的方式不规范，我们在实际开发中会使用到线程池或者开启子线程去执行任务，这个任务的执行一定会在 Spring 容器启动后才会去执行，但是现在的情况是在 Spring 启动过程中我们的任务就开始执行，并且任务会一直执行，这是不太合理的做法。
​

约定大于配置，规范才能避免踩坑。
​