---

⭐️写在前面

---

• 这里是温文艾尔的学习之路
• 👍如果对你有帮助，给博主一个免费的点赞以示鼓励把QAQ
• 👋博客主页🎉 温文艾尔的学习小屋
• ⭐️更多文章👨‍🎓请关注温文艾尔主页📝
• 🍅文章发布日期F1a;2022.02.22
• 👋java学习之路！
• 欢迎各位🔎点赞👍评论收藏⭐️
• 🎄冲冲冲🎄
• ⭐️上一篇内容：【备战面试】每日10道面试题打卡——Java基础篇（二）

---

---

1.对线程安全的理解

不是线程安全，应该是内存安全，堆是共享内存，可以被所有线程访问

当多个线程访问同一个对象时，如果不用进行额外的同步控制或其他的协调操作，调用这个对象的行为都可以获得正确的结果，我们就说这个对象是线程安全的

@H_360_109@堆是进程和线程共有的空间，分全局堆和局部堆。全局堆就是所有没有分配的空间，局部堆就是用户分配的空间。堆在操作系统对进程初始化的时候分配，运行过程中也可以向系统要额外的堆，但是用完了要还给操作系统

• 在Java中，堆是Java虚拟机所管理的内存中最大的一块，是所有线程共享的一块内存区域，在虚拟机启动时创建。堆所存在的内存区域的唯一目的就是存放对象实例，几乎所有的对象实例以及数组都在这里分配内存
• 栈是每个线程独有的，保存其运行状态和局部变量的，栈在线程开始的时候初始化，每个线程的栈相互独立，因此，栈是线程安全的。操作系统在切换线程的时候会自动切换栈。栈空间不需要在高级语言里面显式的分配和释放。

目前主流操作系统都是多任务的，即多个线程同时运行。为了保证安全，每个线程只能访问分配给自己的内存空间，而不能访问别的进程的，这是由操作系统保障的

在每个进程的内存空间中都会有一块特殊的公共区域，通常称为堆（内存）。进程内的所有线程都可以访问到该区域，这就是造成问题的潜在原因

2.说说你对守护线程的理解

守护线程：为所有非守护线程提供服务的线程：任何一个守护线程都是整个JVM中所有非守护线程的保姆

守护线程类似于整个进程的一个默默无闻的小喽啰，它的生死无关重要，它却依赖整个进程而运行；哪天其他线程结束了，程序执行完了，守护线程会马上中断

2.1守护线程的作用是什么？

举例：GC垃圾回收线程：就是一个经典的守护线程，当我们的程序中不再有任何运行的Thread，程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是JVM上仅剩的线程时，垃圾回收线程会自动离开。它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。

应用场景

（1）来为其他线程提供服务支持的情况

（2）在任何情况下，程序结束时，这个线程必须正常且立刻关闭，就可以作为守护线程来使用；反之，如果一个正在执行某个操作的线程必须要正确的关闭掉否则就会出现不好的后果的话，那么这个线程就不能是守护线程，而是用户线程。通常都是些关键的事务，比方说，数据库录入或者更新，这些操作都是不能中断的

Thread.setDaemon(true)必须在Thread.start()之前设置，否则会跑出一个illegalThreadstateException异常。你不能把正在运行的常规线程设置为守护线程

在Daemon线程中产生的新线程也是Daemon的 守护线程不能用于去访问固有资源，比如读写操作或者计算逻辑，因为它会在任何时候甚至在一个操作的中间发生中断

Java自带的多线程框架，比如ExecutorService，会将守护线程转换为用户线程，所以如果要是用守护线程就不能用Java的线程池

3.ThreadLocal的原理和使用场景

关于ThreadLocal可以参考这篇博文的讲解

Java并发编程：深入剖析ThreadLocal - Matrix海子 - 博客园 (cnblogs.COM)

每一个Thread对象均含有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，它存储本线程中所有ThreadLocal对象及其对应的值，ThreadLocalMap是ThreadLocal类的一个内部类，这个Map里面的最小的存储单位是Entry

Entry继承自WeakReference<ThreadLocal<?>>，一个Entry由ThreadLocal对象和Object构成

        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated wITh this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                suPEr(k);
                value = v;
            }
        }

由此可见，Entry的key是ThreadLocal对象，value是线程变量，并且是一个弱引用。当没指向key的强引用后，该key就会被垃圾收集器回收

当执行set方法时，ThreadLocal首先会获取当前线程对象，然后获取当前线程的TjreadLocalMap对象，再以当前ThreadLocal对象为key，将值存储进ThreadLocalMap对象中

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

当执行get方法时，ThreadLocal首先会获取当前线程对象，然后获取当前线程的ThreadLocalMap对象，再以当前ThreadLocal对象为key，获取对应的value

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SupPressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

        PRivate Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode &amp; (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

由于每一条线程均含有各自私有的ThreadLocalMap容器，这些容器相互独立互不影响，因此不会存在线程安全性问题，从而也无需使用同步机制来保证多条线程访问容器的互斥性。

使用场景：

1. 在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束
2. 线程间数据隔离
3. 进行事务操作，用于存储线程事务信息
4. 数据库连接、session会话管理

Spring框架在事务开始时会给当前线程绑定一个Jdbc Connection，在整个过程都是使用该线程绑定的connection来执行数据库操作，实现了事物的隔离性，Spring框架里面就是用的ThreadLocal来实现这种隔离

关于ThreadLocal的理解，我查看文章发现还有一篇讲的很好

另一个角度理解java的ThreadLocal - 握住一缕风 - ITeye博客

4.ThreadLocal内存泄露原因，如何避免

首先我们要明白什么是内存泄露

内存泄露为程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果严重，无论多少内存，迟早会被占光 简而言之，内存泄露就是不再会被使用的对象或者变量占用的内存不能被回收 内存泄露最终会导致OOM问题

我们还需要明白两个概念 强引用

使用最普通的（new）,一个对象具有强引用，不会被垃圾回收器回收。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不回收这种对象

如：

public class test04 {
    public static void main(String[] args) {
        String str = "123";
        List<Integer> list = new ArrayList<>();
        list.add(1);
    }
}

如果想取消强引用和某个对象之间的关联，可以显式的将引用赋值为null，当强引用和其他对象的引用都断开时，便可以被GC垃圾回收

弱引用

弱引用对象具有更短的生命周期，在垃圾回收扫描的过程中，只要发现了具有弱引用的对象，无论内存是否充足，都会将其回收，但是垃圾回收器是一个优先级很低的线程，有时它并不是很快就能发现弱引用对象 在Java中，用java.lang.ref.WeakReference类来表示

强引用和弱引用的概述可以看我前面的文章 【JVM】JVM03(图解垃圾回收机制)上

强引用和弱引用复习完毕，我们接下来继续讨论ThreadLocal

每一个Thread维护一个ThreadLocalMap，key为使用弱引用的ThreadLocal实例，value为线程变量的副本

ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal不存在外部强引用时，key(ThreadLocal)势必会被GC回收，这样就会导致ThreadLocalMap中key为null，而value还存在着强引用，而只有Thread线程退出以后，value的强引用链条才会断掉，但如果线程迟迟不结束咋办呢？这就代表key为null的Entry的value就会一直存在一条强引用链（红色链条）

如果key使用强引用

当ThreadLocalMap的key为强引用回收ThreadLocal时，因为ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal不会被回收，就会导致Entry出现内存泄露问题

如果key使用弱引用

当ThreadLocalMap的key为弱引用回收ThreadLocal时，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收，当jey为null，在下一次ThreadLocalMap调用set，get，remove方法的时候会被清除value值

因此，ThreadLocal内存泄露的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄露，而不是因为弱引用

ThreadLocal正确的使用方法

• 每次使用完ThreadLocal都调用它的remove()方法清除数据
• 将ThreadLocal变量定义成private static，这样就一直存在ThreadLocal的强引用，也就能保证任何时候都能通过ThreadLocal的弱引用访问到Entry的value值，进而清除掉

5.并发，并行，串行的区别

• 串行在时间上不可能发生重叠，前一个任务没搞定，下一个任务就只能等待

• 串行在时间上是重叠的，两个任务在同一时刻互不干扰的同时执行

• 并发运行两个任务彼此干扰，统一时间点，只有一个任务运行，交替执行

6.并发的三大特性

1.原子性

原子性是指在一个操作中cpu不可以在中途暂停然后再调度，即不被中断操作，要不全部执行完毕，要不都不执行，就好比转账，从账户A向账户B转1000元，那么必然包括两个操作：从账户A减去1000元，往账户B加上1000元，2个操作必须全部完成

public class Test01 {
    private long count = 0;
    public void calc(){
        count++;
    }
}

• 将count从主存读到工作内存中的副本中
• +1的运算
• 将结果写入工作内存
• 将工作内存的值刷回主存（什么时候刷入由操作系统决定，不确定的）

那程序中原子性指的是最小的操作单元，比如自增操作，它本身其实并不是原子性操作，分了三步，第四步与可见性有关，包括读取变量的原始值，进行+1操作，写入工作内存。所以在多线程中，有可能一个线程还没自增完，可能才执行到第二个过程，另一个线程就已经读取了值，导致结果错误，那如果我们能保证自增操作是一个原子性的操作，那么就能保证其他线程取到的一定是自增后的数据

如果保障了原子性，只有以上三步全部执行完毕，才会发生线程切换

2.可见性

当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立刻看得到修改的值

若两个线程在不同的cpu,那么线程1改变了i的值还没刷新到主存，线程2又使用了i,那么这个i的值肯定还是之前的，线程1对变量的修改线程没看到，这就是可见性问题

package day03;

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class Test02 {

    static  boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        //线程1
        Thread t1 = new Thread(new Runnable() {
            @override
            public void run() {
                while (run){

                }
            }
        });
        t1.start();
        //线程2
        Thread.sleep(1000);
        run = false;
    }
}

主线程对stop的修改对t1线程不可见

初始状态下，t1线程从主存中读取stop=true到工作内存中，因为t1线程对stop的频繁操作，JIT将stop的值缓存至自己的工作内存中的高速缓存中，以提高访问效率

1秒之后main线程修改了run的值，并同步到主存，但是t1线程的run是从高速缓存中读取的，无法获得最新的run值，故t1线程无法停止

3.有序性

虚拟机在进行代码编译时，对于那些改变顺序之后不会对最终结果造成影响的代码（单线程情况下），虚拟机不一定会按照我们写的代码的顺序来执行，有可能将他们重排序，实际上，对于有些代码进行重排序之后，虽然对变量的值没有造成影响但有可能出现线程安全问题

    int a = 0;
    boolean flag = false;

    public void write(){
        a=2;//1
        flag=true;//2
    }

    public void mutiply(){
        if (flag){//3
            int ret = a*a;//4
        }
    }

在多线程情况下，write方法里的1和2做了重排序，线程1先对flag赋值为true，随后执行到线程2，ret直接计算出结果，再到线程1，这时候a才赋值为2，很明显迟了一步

volatile本身就包含了禁止指令重排序的语义，而synchronized关键字是由一个变量在同一时刻只允许一条线程对其进行加锁操作这条规则是明确的

synchronized关键字同时满足以上三种特性，但是volatile关键字不满足原子性

在某些情况下，volatile的同步机制的性能确实要优于锁（使用synchronized关键字或java.util.concurrent包里面的锁），因为volatile的总开销要比锁低

7.为什么使用线程池？解释下线程池参数？

1.降低资源消耗；提高线程利用率，降低创建和销毁线程的消耗

2.提高响应速度；任务来了，直接有线程可用可执行，而不是先创建线程再执行

3.提高线程的可管理性；线程是稀缺资源，使用线程池可以同一分配调优监控

• corePoolSize：代表核心线程数，也就是正常情况下创建工作的线程数，这些线程创建后并不会消除，而是一种常驻线程
• maxinumPoolSize代表的是最大线程数，它与核心线程数相对应，表示最大允许被创建的线程数，比如当前任务较多，将核心线程数都用完了，还无法满足需求时，此时就会创建新的线程，但是线程池内县城总数不会超过最大线程数
• keepnumPoolSize、unit表示超出核心线程数之外的线程的空闲存活时间，也就是核心线程不会消除，但是超出核心线程数的部分线程如果空闲一定的时间则会被消除，我们可以通过setKeepAliveTime来设置空闲时间
• workQueue用来存放待执行的任务，假设我们现在核心线程都已被占用，还有任务进来则全部放入队列，直到整个队列被放满但任务还在持续进入则会开始创建新的线程
• ThreaDFactory实际上是一个线程工厂，用来生产线程执行任务，我们可以选择使用默认的创建工厂，产生的线程都在同一个组内，拥有相同的优先级，但都不是守护线程，当然我们也可以选择自定义线程工厂，一般我们会根据业务来制定不同的线程工厂
• Handler任务拒绝策略，有两种情况，第一种是当我们调用shutdown等方法关闭线程池后，这时候即使线程池内部还有没执行完的任务正在执行，但是由于线程池已经关闭，我们再继续想线程池提交任务就会遭到拒绝，另一种情况就是当达到最大线程数，线程池已经没有能力继续处理新提交的任务时，这也就拒绝

8.简述线程池处理流程

我们创建线程池，并向线程池中添加任务时，首先线程池会判断核心线程是否已满，未满则创建核心线程执行任务，已满判断任务队列是否已满，没满的话将任务先放入任务队列，等待核心线程空闲，如果任务队列已满则判断是否达到对打线程数，没有达到就创建额外的线程执行任务，达到最大数量就根据策略处理任务

9.线程池中阻塞队列的作用？为什么是先添加队列而不是先创建最大线程？

1.一般的队列只能保证作为一个有限长度的缓冲区，如果超出了缓冲长度，就无法保留当前的任务了，阻塞队列通过阻塞可以保留住当前想要继续入队的任务

阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源

阻塞队列自带阻塞和唤醒的功能，不需要额外处理，无任务执行时，线程池利用阻塞队列的take方法挂起，从而维持核心线程的存活，不至于一直占用cpu资源

2.在创建新线程的时候，是要获取全局锁的，这个时候其它的就要阻塞，影响了整体效率

• 就好比一个企业里面有10个(core)正式工的名额，最多招10个正式工，要是任务超过正式工任务的情况下，工厂领导（线程池）不是首先扩招工人，还是这10个人，但是任务可以稍微积压一下，即先放到队列里去，以求完成工作的代价降到最低，10个工人慢慢干，总会把工作做完的，如果任务持续增加，超出工人的加班忍耐极限了（队列满了），就招外包进行帮忙（额外的线程），外包干完活就会走人，要是正式工加上外包都干不完任务，那么工厂领导就会把新来的任务拒绝掉(线程池的拒绝策略)

10.线程池中线程复用原理

线程池将线程和任务进行解耦，线程是线程，任务是任务，拜托了之前通过Thread创建线程时的一个线程必须对应一个任务的限制

• 在线程池中，同一个线程可以从阻塞队列中不断获取新任务来执行，其核心原理在于线程池对Thread进行了封装，并不是每次执行任务都会调用Thread.start()来创建新线程，而是让每个线程去执行一个“循环任务”，在这个“循环任务”中不停检查是否有任务需要被执行，如果有则直接执行，也就是调用任务中的run方法，将run方法当成一个普通的方法执行，通过这种方式只使用固定的线程就将所有任务的run方法串联起来

上面的面试题是博主通过牛客面经，博文，资料加上我自己的理解总结而成的，小温自己也在积极准备面试，所以文章中出现的关于面试题的错误请在评论区指出，我再进行改正优化，如果文章对你有所帮助，请给博主一个免费的三连吧，感谢大家