02.关于线程你必须知道的8个问题（上）

向右看齐 2023-09-24 13:47 49阅读 0赞

![format_png][]

持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第3天，[点击查看活动详情][Link 1]

大家好，我是王有志，欢迎来到《Java面试都问啥？》的第一篇技术文章。

这个系列会从**Java部分**开始，接着是**MySQL和Redis**的内容，同时会继续更新**数据结构与算法**的部分，这样在第一阶段，我们就完成了面试“三幻神”的挑战。

Java的部分从**并发编程**开始，接着是**Java虚拟机**，最后是**集合框架**。至于**Java基础**，因为大部分只是API的使用，所以只提供整理好的题目，而涉及到反射，动态代理等内容，会在集合框架完成后补充。

那么话不多说，我们直接开始吧。

### 并发编程都问啥？ ###

每个模块开始时，我都会放出这一模块中知识点的统计数据，供大家参考。

统计中，我将并发编程分为了5个知识点：

*  **线程基础**：线程的基本概念，Thread类的使用等；
 *  **线程池**：线程池的原理，线程池的使用等；
 *  **synchronized**：原理，锁升级，优化等；
 *  **volatile**：原理，指令重排，JMM相关等；
 *  **ThreadLocal**：原理，使用方法，内存泄漏等；
 *  **JUC**：Lock接口，并发容器，CAS，AQS等。

统计到并发编程关键词174次，线程出现37次，线程池出现22次，synchronized出现30次，volatile出现12次，ThreadLocal出现8次，JUC出现44次，剩余21次仅提到多线程/并发编程。

![format_png 1][]

从图中看，ThreadLocal和volatile出现概率较低，但个人建议面试准备中，**并发编程的部分要全量准备**。

数据大家都看到了，接下来看看各大公司都会问哪些关于线程的问题。这部分题目主要收集自某准网面经，浅紫色底色的题目是我和小伙伴在面试过程遇到过的。

MarkDown的表格实在太丑了，偷个懒使用图片代替了，文末附上整理后Excel的获取方式。

![format_png 2][]

### 关于线程你必须知道的8个问题 ###

涉及到概念性的题目就不过多赘述了，这些可以通过百度百科获取到答案。在这里我挑选了8道比较有代表性的问题，和大家分享我的理解。

#### 并发编程的3要素 ####

并发编程的3要素：

*  **原子性**：操作不可分割，要么不间断的全部执行，要么全部不执行；
 *  **有序性**：指程序按照代码的顺序结构执行；
 *  **可见性**：当一个线程修改了共享变量后，其它线程也是立即可见的。

概念很简单，我们写一些代码展示下有序性和可见性的问题（原子性实在没有想到很好的例子，有没有小伙伴提供示例呢）。

有序性问题

public static class Singleton {
    	private Singleton instance;
    	public Singleton getInstance() {
    	    if (instance == null) {
    	        instance = new Singleton();
    	    }
    	    return instance;
    	}
      
    	private Singleton() {
    	}
    }
    复制代码

这是有序性问题的经典案例--**未做同步控制的单例模式**。当`instance`还未初始化时，多个线程同时调用`getInstance`方法，很容易出现其中一个线程获取到的`instance`为NULL。

这里涉及Java创建对象的操作，CPU时间片分配的问题，解决它的办法也有很多，暂时按下不表，放到`volatile`关键字的内容中详细解释。

可见性问题

private static boolean flag = true;
    
    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (flag) {
            }
            System.out.println("线程：" + Thread.currentThread().getName() + "，flag：" + flag);
        }, "block_thread").start();
    
        TimeUnit.MICROSECONDS.sleep(500);
        
        new Thread(() -> {
            flag = false;
            System.out.println("线程：" + Thread.currentThread().getName() + "，flag：" + flag);
        }, "change_thread").start();
    }
    复制代码

很明显，在change\_thread中修改了flag，并不会使block\_thread得到解脱，这就是共享变量在线程间不可见的问题。

#### Java创建线程的方式 ####

通常网上的资料会给出4种创建线程的方式：

*  继承Thread类
 *  实现Runnable接口
 *  实现Callable接口
 *  通过线程池创建

先不评价这个答案的正确性，我们先来看看继承`Thread`类，实现`Runnable`接口和实现`Callable`接口是如何使用的。

继承Thread类

public class ByThread {
    	public static void main(String[] args) throws InterruptedException {
    	    System.out.println("main的线程：" + Thread.currentThread().getName());
    	    MyThread myThread = new MyThread();
    	    myThread.start();
    	}
    	
    	static class MyThread extends Thread {
    	    @Override
    	    public void run() {
    	        System.out.println("MyThread的线程：" + Thread.currentThread().getName());
    	    }
    	}
    }
    复制代码

继承`Thread`类要实现`run`方法，用于完成业务逻辑，该方法来自于`Runnable`接口。启动线程通过`Thread.start`方法，方法内通过调用native方法`start0`来启动线程。

实现Runnable接口

public class ByRunnable {
        public static void main(String[] args) {
            System.out.println("main的线程：" + Thread.currentThread().getName());
            new Thread(new MyRunnable()).start();
        }
    
        static class MyRunnable implements Runnable {
            @Override
            public void run() {
                System.out.println("MyRunnable的线程：" + Thread.currentThread().getName());  
            }
        }
    }
    复制代码

实现`Runnable`接口同样要实现`run`方法，启动线程依旧是通过`Thread.start`方法。

实质上继承`Thread`类和实现`Runnable`接口没有差别，只不过是隔代实现`run`方法还是直接实现`run`方法。

实现Callable接口

public class ByCallable  {  
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            System.out.println("main的线程：" + Thread.currentThread().getName());
            Callable<String> callable = new MyCallable();
            FutureTask <String> futureTask = new FutureTask<>(callable);
            new Thread(futureTask).start();
            System.out.println("MyCallable的执行线程：" + futureTask.get());
        }
        
        static class MyCallable implements Callable<String> {
            @Override
            public String call() {
                System.out.println("MyCallable的线程：" + Thread.currentThread().getName());
                return Thread.currentThread().getName();
            }
        }
    }
    复制代码

实现`Callable`接口看起来会复杂一些，但通过代码可以看出来，最终还是回归到`Thread.start`方法，根据经验，这种方式是不是和`Runnable`有关系？

另外，我们注意到这种方式中借助到了`FutureTask`类，来看看`FutureTask`的继承关系：

![format_png 3][]

不出所料，`FutureTask`同样要实现`Runnable.run`方法，只不过这次由`FutureTask`实现，`FutureTask`在`run`方法中调用`Callable.call`方法来执行业务逻辑。

我们来回顾下这3种方式的特点，**启动线程都是通过`Thread.start`方法，`start`方法的基本执行单位是`Runnable`接口**，它们直接的差异在于如何实现`Runnable.run`方法。**另一个差异就是`Callable.call`方法是有返回值的**，而`Runnable.run`方法没有返回值。

使用线程池

public class ByThreadPool {
        public static void main(String[] args) {
            System.out.println("main的线程：" + Thread.currentThread().getName());
            ExecutorService executorService = Executors.newSingleThreadExecutor();
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程池的线程：" + Thread.currentThread().getName());
                }
            };
            executorService.execute(runnable);
            executorService.shutdown();
        }
    }
    复制代码

使用线程池依旧离不开`Runnable.run`方法，会不会和`Callable`一样本质上还是`Thread.start`？

如果不熟悉`ThreadPoolExecutor`源码的话，可以采用断点的方式去跟踪源码，重点关注`ThreadPoolExecutor.execute`和`ThreadPoolExecutor.addWorker`两个方法。

我们可以在`addWorker`方法中发现两行关键代码：

final Thread t = w.thread;
    t.start();
    复制代码

这证实了关于`ThreadPoolExecutor`底层调用的猜想，最终依旧是通过`Thread.start`方法启动。

回到最初的问题，Java有几种创建线程的方式？

**如果从Java的层面来看，可以认为创建`Thread`类的实例对象就完成了线程的创建，而调用`Thread.start0`可以认为是操作系统层面的线程创建和启动。**

至于网上说的4种创建线程的方式，个人认为将它们归类到线程中业务逻辑的实现方式更合理。

#### Java的线程状态 ####

Java中定义了6种线程状态（与OS的线程状态有差别），线程状态的枚举类被定义为`Thread`的内部类`State`。

public enum State {
    	NEW,
    	RUNNABLE,
    	BLOCKED,
    	WAITING,
    	TIMED_WAITING,
    	TERMINATED;
    }
    复制代码

需要注意，Java中并未定义线程的RUNNING状态，而是**通过RUNNABLE包含了RUNNABLE（可运行）和RUNNING（运行中）**。

**建议大家阅读源码中的注释，很清晰的解释了每个状态的场景**。下面我还是通过几段代码展示线程的不同状态。

Tips：代码中出现的`TimeUnit.MILLISECONDS.sleep`是为了确保线程已经进入期望的状态，如果不能很好的理解，文末附有Gitee地址，工程中的代码有注释。

常规状态的转换

这里指的是线程从创建后（NEW），到启动后（RUNNABLE），再到最后终止（TERMINATED）的一种无竞争线程状态转换。

*  **NEW（新建）**：创建线程后尚未启动（未调用`start`方法）；
 *  **RUNNABLE（可运行）**：可运行状态的线程在Java虚拟机中等待调度线程选中获取CPU时间片；
 *  **TERMINATED（终止）**：线程执行结束。

写一段简单的代码来看下：

public class NormalStateTransition {
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(() -> {
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            });
            System.out.println("线程[" + thread.getName() + "]创建，状态：[" + thread.getState() + "]");
            thread.start();
            System.out.println("线程[" + thread.getName() + "]启动，状态：[" + thread.getState() + "]");
            TimeUnit.SECONDS.sleep(2);
            System.out.println("线程[" + thread.getName() + "]结束，状态：[" + thread.getState() + "]");
        }
    }
    复制代码

代码非常简单，这里就不再解释了。

常规状态的转换：

![format_png 4][]

阻塞状态的转换

阻塞状态是一种“异常”的状态，通常是在等待资源。

**BLOCKED（阻塞）**：等待监视器锁而阻塞的线程状态，处于阻塞状态的线程正在等待监视器锁进入同步的代码块/方法，或者在调用`Object.wait`之后重新进入同步的代码块/方法。

再写一段代码：

public class BlockedStateTransition {
        public static void main(String[] args) throws InterruptedException {
            AtomicBoolean locker = new AtomicBoolean(false);
            new Thread(() -> {
                synchronized (locker) {
                    try {
                        TimeUnit.MILLISECONDS.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
      
            Thread t = new Thread(() -> {
                synchronized (locker) {
                    try {
                        TimeUnit.MILLISECONDS.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程[" + Thread.currentThread().getName() + "]阻塞后，状态：[" + Thread.currentThread().getState() + "]");
                }
            });
            System.out.println("线程[" + t.getName() + "]创建，状态：[" + t.getState() + "]");
            t.start();
            System.out.println("线程[" + t.getName() + "]启动，状态：[" + t.getState() + "]");
            System.out.println("线程[" + t.getName() + "]阻塞中，状态：[" + t.getState() + "]");
            TimeUnit.MILLISECONDS.sleep(5000);
            System.out.println("线程[" + t.getName() + "]结束，状态：[" + t.getState() + "]");
        }
    }
    复制代码

首先是匿名线程持有`locker`，接着线程t启动，进入RUNNABLE状态，线程t尝试获取`locker`，进入BLOCKED状态，等待后获取到`locker`，进入RUNNABLE状态，最后执行结束，进入TERMINATED状态。

阻塞状态转换：

![format_png 5][]

等待状态的转换

关于等待状态，Java源码的注释有详细描述如何进入等待状态，以及如何唤醒处于等待状态的线程：

> Thread state for a waiting thread. A thread is in the waiting state due to calling one of the following methods:
> 
>     Object.wait with no timeout
>       Thread.join with no timeout
>       LockSupport.park
>     复制代码
> 
> A thread in the waiting state is waiting for another thread to perform a particular action. For example, a thread that has called Object.wait() on an object is waiting for another thread to call Object.notify() or Object.notifyAll() on that object. A thread that has called Thread.join() is waiting for a specified thread to terminate.

**WAITING（等待）**：线程处于等待状态，处于等待状态的线程正在等待另一个线程执行的特定操作（通知或中断）。

再再写一段代码：

public class WaitingStateTransition {
        public static void main(String[] args) throws InterruptedException {
            AtomicBoolean locker = new AtomicBoolean(false);
            Thread t = new Thread(() -> {
                synchronized (locker) {
                    try {
                        TimeUnit.MILLISECONDS.sleep(100);
                        locker.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程[" + Thread.currentThread().getName() + "]唤醒，状态：[" + Thread.currentThread().getState() + "]");
                }
            });
            System.out.println("线程[" + t.getName() + "]创建，状态：[" + t.getState() + "]");
            t.start();
            System.out.println("线程[" + t.getName() + "]启动，状态：[" + t.getState() + "]");
            TimeUnit.MILLISECONDS.sleep(150);
            System.out.println("线程[" + t.getName() + "]等待，状态：[" + t.getState() + "]");
      
            new Thread(() -> {
                synchronized (locker) {
                    locker.notify();
                }
            }).start();
            TimeUnit.MILLISECONDS.sleep(100);
            System.out.println("线程[" + t.getName() + "]结束，状态：[" + t.getState() + "]");
        }
    }
    复制代码

线程t创建后，进入NEW状态，启动后，进入RUNNABLE状态，`locker.wait`后，进入WAITING状态，匿名线程启动，`locker.notify`后，唤醒线程t，进入RUNNABLE状态，最后线程执行结束，进入TERMINATED状态。

等待状态的转换：

![format_png 6][]

限时等待状态的转换

Java源码的注释上，也很详细的解释了如何进入限时等待：

> 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:
> 
>     Thread.sleep
>       Object.wait with timeout
>       Thread.join with timeout
>       LockSupport.parkNanos
>       LockSupport.parkUntil
>     复制代码

**TERMINATED（限时等待）**：线程处于限时等待状态，与等待状态不同的是，在指定时间后，线程会被自动唤醒。

Tips：也有翻译成超时等待的，但是我觉得不太合适。

再再再写一段代码：

public class TimedWaitingStateTransition {
        public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(() -> {
                try {
                    TimeUnit.MILLISECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程[" + Thread.currentThread().getName() + "]限时等待后，状态：[" + Thread.currentThread().getState() + "]");
            });
            System.out.println("线程[" + t.getName() + "]创建，状态：[" + t.getState() + "]");  
            t.start();
            System.out.println("线程[" + t.getName() + "]启动，状态：[" + t.getState() + "]");  
            TimeUnit.MILLISECONDS.sleep(50);
            System.out.println("线程[" + t.getName() + "]限时等待中，状态：[" + t.getState() + "]");
            TimeUnit.MILLISECONDS.sleep(100);
            System.out.println("线程[" + t.getName() + "]结束，状态：[" + t.getState() + "]");  
        }
    }
    复制代码

线程t创建后，进入NEW状态，启动后进入RUNNABLE状态，线程休眠100ms，进入TIMED\_WAITING状态，休眠时间结束后，进入RUNNABLE状态，最后线程执行结束，进入TERMINATED状态。

限时等待状态的转换：

![format_png 7][]

线程状态转换总结

上面我们通过4段代码了解了线程状态的转换，下面我们通过一张图来总结下线程的状态转换。

![format_png 8][]

### 结语 ###

今天分享了并发编程的统计数据，因此面试题目较少，不过还是希望对你有帮助。

下一篇内容是剩余的5个知识点（如果一篇能够写完的话）：

*  Thread类核心方法
 *  同步与互斥
 *  Java线程调度方式
 *  死锁的产生与解决
 *  多线程的优点

本篇文章的代码仓库：

*  [并发3要素问题][3]
 *  [线程实现方式][Link 2]
 *  [线程状态转换][Link 3]

关注，回复**面试题合集**获取整理后的面试题（正在同步更新，可以持续关注）。

--------------------

好了，今天就到这里了，Bye~~

[format_png]: https://img-blog.csdnimg.cn/img_convert/942a4b6bde8ffd7d5584cdaed32163b8.webp?x-oss-process=image/format,png
[Link 1]: https://juejin.cn/post/7147654075599978532
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/882fe0b2bbc3ced6387f0b40cbbfe76a.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/f20875c102898094ee1c6b7c383fdbc2.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/2ffd548e885e0a3d8a652ed4cb2564ac.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/fbcc6219bf9faf16856150cbec3a413a.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/c1a752a662ba92f46e42b958e30c10b4.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/cba876dcc29047323eab1eef72b18b1c.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/faf4043ed8b9cbc54589d08354a06761.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/5d666cb783349b111231c990120fb74b.webp?x-oss-process=image/format,png
[3]: https://link.juejin.cn/?target=https%3A%2F%2Fgitee.com%2Fwyz-A2%2FJavaInterview%2Ftree%2Fmaster%2FConcurrence%2Fsrc%2Fmain%2Fjava%2Fcom%2Fwyz%2Fthread%2Fquestion
[Link 2]: https://link.juejin.cn/?target=https%3A%2F%2Fgitee.com%2Fwyz-A2%2FJavaInterview%2Ftree%2Fmaster%2FConcurrence%2Fsrc%2Fmain%2Fjava%2Fcom%2Fwyz%2Fthread%2Fcreate
[Link 3]: https://link.juejin.cn/?target=https%3A%2F%2Fgitee.com%2Fwyz-A2%2FJavaInterview%2Ftree%2Fmaster%2FConcurrence%2Fsrc%2Fmain%2Fjava%2Fcom%2Fwyz%2Fthread%2Fstate