话题一：为什么要有多线程？
单线程只是单地将代码自上而下地运行，如果程序阻塞或者耗时，整个就卡住了
多线程可以同时运行多段代码块解决了阻塞io问题，同时可以将内存的性能充分释放，提高了响应速率，使得用户的使用体验更好不至于出现卡顿。
话题二：进程与线程的区别。
进程是内存分配的最小单元，线程是cpu分配的最小单元。
在一个进程中至少包含了一个主线程，并且在同一进程内所有线程共享资源。
进程的的创建和切换开销大，线程的创建和切换的开销相对轻量级，但是由于cpu多核发展受限，后来又发明了线程池。
话题三：线程的五大生命周期。
新建（new）
通过new thread 创建线程对象，操作系统中还未创建真实线程，不分配资源。
就绪（Runnable)
调用 start（）后进入该状态，其中又分两种情况：
1.就绪：线程已经准备好了等待cpu分配时间片
2.运行中：线程抢到了cpu时间片，执行run（) 方法
阻塞（Blocked）
线程等待同步锁时进入阻塞
等待（Waiting）
主动无限的等，不占用cpu，需要其他线程主动唤醒（也可计时等待 Timed_Waiting )
终止(Terminated)
run()正常执行完/异常终止，线程结束，资源回收，无法再次启动。
话题四：并发与并行。
并发：多任务交替执行（单核cpu即可）
并行：多任务同时进行(需要有多核cpu）
话题五：线程的创建方法。
1.继承Thread类
class MyThread extends Thread { @Override public void run() { System.out.println("线程执行"); } }2.实现runnable接口
class MyRun implements Runnable { @Override public void run() { System.out.println("Runnable 线程"); } }3.匿名内部类lambda表达式
Thread t = new Thread(()->{ });话题六：线程安全问题。
1.线程安全是什么？
线程处理的数据是共享可变的，多线程同时进行可能引起数据竞争。
2.线程不安全的核心
共享变量
非原子操作
指令重排和可见性问题
3.解决方案
同步锁synchronized
原子类解决原子问题
volatile解决可见性问题
话题七：线程池
1.使用线程池的原因
减少线程创建销毁的开销，控制数量以及任务统一管理，避免OOM（内存溢出）问题
2.线程池核心参数
1.核心线程数corePoolSize：线程池常驻线程数，即使空闲也不会被回收，长期处理常规任务；
2.最大线程数maximumPoolSize：线程池允许创建的最大线程总数，任务激增时扩容；
3.空闲存活时间keepAliveTime：非核心线程的空闲超时时间，超时无任务则被回收；
4.任务队列workQueue：存储待执行任务的阻塞队列，核心线程满负载后任务进入队列；
5.拒绝策略handler：线程数和队列均满负载时，处理超额任务的策略。
3.常用的线程池
1.固定线程池FixedThreadPool：核心线程数=最大线程数，线程数量固定，适合负载稳定的批量任务；
2.缓存线程池CachedThreadPool：无核心线程、最大线程数无限，线程空闲自动回收，适合短期、大量瞬时任务；
3.定时线程池ScheduledThreadPool：支持延时、周期性执行任务，适合定时巡检、定时统计场景；
4.自定义线程池ThreadPoolExecutor：手动配置所有参数，适配业务场景，参数可控、无隐患，企业开发唯一推荐。
线程池开发规范与避坑
1.禁止使用Executors工具类创建线程池：原生线程池存在队列无界、线程数无限等问题，极易引发OOM内存溢出；
2.必须自定义线程池：根据业务QPS、任务耗时合理配置核心参数，限制最大并发数；
3.拒绝策略按需选择：核心业务使用自定义降级策略，非核心业务可丢弃、告警；
4.必须处理任务异常：线程池任务异常会静默消失，导致业务无响应、问题难排查，需全局捕获异常；
5.合理设置线程池名称：方便日志排查、线程堆栈定位问题。
话题八：多线程开发中遇见的常见问题
1.死锁问题
四大要素不可少（1：互斥条件 2：请求保持 3：不可剥夺 4: 循环等待)
public static void main(String[] args) throws InterruptedException { Object locker1 = new Object(); Object locker2 = new Object(); Object locker3 = new Object(); Thread t1 = new Thread(()->{ for(int i = 0;i<10;i++){ synchronized (locker1){ try { locker1.wait(); System.out.print('A'); synchronized (locker2){ locker2.notify(); } } catch (InterruptedException e) { throw new RuntimeException(e); } } } }); Thread t2 = new Thread(()->{ for(int i = 0;i<10;i++){ synchronized (locker2){ try { locker2.wait(); System.out.print('B'); synchronized (locker3){ locker3.notify(); } } catch (InterruptedException e) { throw new RuntimeException(e); } } } }); Thread t3 = new Thread(()->{ for(int i = 0;i<10;i++){ synchronized (locker3){ try { locker3.wait(); System.out.println('C'); synchronized (locker1){ locker1.notify(); } } catch (InterruptedException e) { throw new RuntimeException(e); } } } }); t1.start(); t2.start(); t3.start(); //先确保所有线程都执行到了wait,才能按照上述逻辑执行，有两种方法1：sleep 2：用scanner阻塞 Thread.sleep(1000); synchronized (locker1) { locker1.notify(); } } }2.线程虚假唤醒
private static volatile SingletonLazy instance = null; private static Object locker = new Object(); public static SingletonLazy getInstance() { //线程 A、线程 B 同时执行 getInstance()； //此时 instance = null，两个线程都通过外层 if(instance==null) 判断； //A 先抢到同步锁，进入代码块创建对象，释放锁； //B 阻塞完，拿到锁，直接执行 new，又创建了第二个对象； //最终出现两个不同实例，单例失效。 //👉 内层 if 就是为了解决这个场景：线程 B 拿到锁后，再检查一次 instance，发现已经不为 null，直接跳过创建。 if(instance == null) { synchronized (locker) { if (instance == null) { instance = new SingletonLazy(); } } } return instance; } private SingletonLazy(){ } } public class Demo28 { public static void main(String[] args) { Singleton t1 = Singleton.getInstance(); Singleton t2 = Singleton.getInstance(); System.out.print(t1 == t2); } }本文仅限个人拙见希望大家能够帮我指出漏洞以及那些没学到的知识谢谢！