此篇是本人在准备java开发岗位时准备的一些关于多线程的知识点和一些面试需要特别注意的地方，还有诸多面试知识点在主页，欢迎大家查看，互相交流学习~~后续还会有续集
线程调度
线程五种状态
线程状态：创建、就绪、运行、阻塞、死亡
新建状态(New) ：线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。
运行状态(Running)：线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。
阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
(1)、等待阻塞:运行的线程执行wait方法，该线程会释放占用的所有资源，JVM会把该线程放入"等待池"中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify或notifyAll方法才能被唤醒，wait是object类的方法
(2)、同步阻塞:运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则VM会把该线程放入"锁池"中。
(3)、其他阻塞:运行的线程执行sleep或join方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep状态超时、join等待线程终止或者超时、或者l/O处理完毕时，线程重新转入就绪状态。sleep是Thread类的方法
死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
线程状态切换
| 方法 | 作用 | 区别 |
|---|---|---|
| start | 启动线程，由虚拟机自动调度执行run()方法 | 线程处于就绪状态 |
| run | 线程逻辑代码块处理，JVM调度执行 | 线程处于运行状态 |
| sleep | 让当前正在执行的线程休眠（暂停执行） | 不释放锁 |
| wait | 使得当前线程等待 | 释放同步锁 |
| notify | 唤醒在此对象监视器上等待的单个线程 | 唤醒单个线程 |
| notifyAll | 唤醒在此对象监视器上等待的所有线程 | 唤醒多个线程 |
| yiled | 停止当前线程，让同等优先权的线程运行 | 用Thread类调用 |
| join | 使当前线程停下来等待，直至另一个调用join方法的线程终止 | 用线程对象调用 |
yield () 执行后线程直接进入就绪状态，马上释放了cpu的执行权，但是依然保留了cpu的执行资格，所以有可能cpu下次进行线程调度还会让这个线程获取到执行权继续执行
join () 执行后线程进入阻塞状态，例如在线程B中调用线程A的join ()，那线程B会进入到阻塞队列，直到线程A结束或中断线程
wait和sleep区别
- wait 方法必须在 synchronized 保护的代码中使用，而 sleep 方法并没有这个要求。
- wait 方法会主动释放锁，在同步代码中执行 sleep 方法时，并不会释放锁。
- wait 方法意味着永久等待，直到被中断或被唤醒才能恢复，不会主动恢复，sleep 方法中会定义一个时间，时间到期后会主动恢复。
- wait/notify 是 Object 类的方法，而 sleep 是 Thread 类的方法。
进程和线程区别
1.根本区别：进程是操作系统进行资源分配的最小单元，线程是操作系统进行运算调度的最小单元。
2.从属关系不同：进程中包含了线程，线程属于进程。
3.开销不同：进程的创建、销毁和切换的开销都远大于线程。
4.拥有资源不同：每个进程有自己的内存和资源，一个进程中的线程会共享这些内存和资源。
5.控制和影响能力不同：一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。
6.CPU利用率不同：进程的CPU利用率较低，因为上下文切换开销较大，而线程的CPU的利用率较高，上下文的切换速度快。
7.操纵者不同：进程的操纵者一般是操作系统，线程的操纵者一般是编程人员。
实现多线程的四种方式
继承Thread类实现多线程：
继承类Thread是支持多线程的功能类，只要创建一个子类就可以实现多线程的支持。
所有的java程序的起点是main方法，所以线程一定有自己的起点，那这个起点就是run方法；因为多线程的每个主体类之中必须重写Thread的run方法。
这个run方法没有返回值，那就说明线程一旦开始就一直执行不能返回内容。
多线程启动的唯一方法是调用Thread的start方法，如果调用的是run方法就是普通run方法的调用（调用此方法执行的是run方法体）。
总结：使用Thread类的start方法不仅仅启动多线程的执行代码，还要从不同操作系统中分配资源。
步骤：
- 创建一个继承于Thread类的子类
- 重写Thread类的run() --> 将此线程执行的操作声明在run()中
- 创建Thread类的子类的对象
- 通过此对象调用start()：start（）作用①启动当前线程 ② 调用当前线程的run()
继承Thread类（java不支持多继承）
public class ExtendsThread extends Thread {
@Override
public void run() {System.out.println('用Thread类实现线程');}
}
实现Runnable（优先使用）:
Java具有单继承局限，所有的Java程序针对类的继承都应该是回避，那么线程也一样，为了解决单继承的限制，因此才有Runnable接口。
使用方法：让一个类实现Runnable接口即可，并且也需要覆写run()方法。
疑问：但是此接口只有run方法，没有start方法，怎么启动多线程呢？
不管任何情况下，如果要想启动多线程一定要依靠Thread类完成，在Thread类中有参数是Runnable参数的构造方法：
Thread(Runnable target) 接收的是Runnable接口
可以创建一个参数是Runnable实现类的Thread类，调用start方法启动。
总结：实现Runnable接口来写多线程的业务类，用Thread来启动多线程。
实现 Runnable 接口（优先使用）
public class RunnableThread implements Runnable {
@Override
public void run() {System.out.println('用实现Runnable接口实现线程');}
}
实现Callable接口
实现Callable接口（有返回值可抛出异常）
步骤：
//class CallableTask implements Callable {
//@Override
//public Integer call() throws Exception { return new Random().nextInt();}
//}
@Override
public Object call() throws Exception {
System.out.println("CallableImpl");
return "我是Call方法的返回值";
}
public static void main(String[] args) {
CallableImpl callable=new CallableImpl();
FutureTask futureTask=new FutureTask(callable);
Thread thread=new Thread(futureTask);
需要注意一件事：
FutureTask类中的get方法获取返回值只能执行一次
而且，如果使用了这个方法但是线程还没有运行到可以返回的那行代码，那么就会一直阻塞
比如如果我在这里执行了如下代码：
Object result=futureTask.get();
那么就永远阻塞了
当然，我更想说的是，如果你使用的是这种方法创建线程并且需要返回值的话，里面就别写死循环
否则就是死锁在召唤
thread.start();
try {
Object result=futureTask.get();
System.out.println(result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
- 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
- call()可以返回值的。
- call()可以抛出异常，被外面的操作捕获，获取异常的信息
- Callable是支持泛型的
线程池
1、使用线程池
（底层都是实现run方法）
static class DefaultThreadFactory implements ThreadFactory {
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
namePrefix = "pool-" + poolNumber.getAndIncrement() +"-thread-";
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0);
if (t.isDaemon()) t.setDaemon(false); //是否守护线程
if (t.getPriority() != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY); //线程优先级
return t;
}
}
- 好处：
- 1.提高响应速度（减少了创建新线程的时间）
- 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 3.便于线程管理
优点：通过复用已创建的线程，降低资源损耗、线程可以直接处理队列中的任务加快响应速度、同时便于统一监控和管理。
2、线程池构造函数
/**
* 线程池构造函数7大参数
*/
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
TimeUnit unit,BlockingQueue workQueue,ThreadFactory threadFactory,
RejectedExecutionHandler handler) {}
参数介绍：
| 参数 | 作用 |
|---|---|
| corePoolSize | 核心线程池大小，核心线程数，也就是正常情况下创建工作的线程数，这些线程创建后并不会消除，而是一种常驻线程 |
| maximumPoolSize | 最大线程池大小，最大线程数，它与核心线程数相对应，表示最大允许被创建的线程数，比如当前任务较多，将核心线程数都用完了，还无法满足需求时，此时就会创建新的线程，但是线程池内线程总数不会超过最大线程数 |
| keepAliveTime | 线程池中超过 corePoolSize 数目的空闲线程最大存活时间；超出核心线程数之外的线程的空闲存活时间，也就是核心线程不会消除，但是超出核心线程数的部分线程如果空闲一定的时间则会被消除,我们可以通过 setKeepA7iveTime来设置空闲时间 |
| TimeUnit | keepAliveTime 时间单位 |
| workQueue | 阻塞任务队列，用来存放待执行的任务，假设我们现在核心线程都已被使用，还有任务进来则全部放入队列，直到整个队列被放满但任务还再持续进入则会开始创建新的线程 |
| threadFactory | 新建线程工厂，是一个线程工厂，用来生产线程执行任务。我们可以选择使用默认的创建工厂，产生的线程都在同一个组内，拥有相同的优先级，且都不是守护线程。当然我们也可以选择自定义线程工厂，一般我们会根据业务来制定不同的线程工厂 |
| RejectedExecutionHandler | 拒绝策略。当提交任务数超过 maxmumPoolSize+workQueue 之和时，任务会交给RejectedExecutionHandler 来处理，任务拒绝策略，有两种情况，第一种是当我们调用shutdown 等方法关闭线程池后，这时候即使线程池内部还有没执行完的任务正在执行，但是由于线程池已经关闭，我们再继续想线程池提交任务就会遭到拒绝。另一种情况就是当达到最大线程数，线程池已经没有能力继续处理新提交的任务时，这是也就拒绝 |
拒绝策略：
- AbortPolicy：直接抛出异常，默认策略；
- CallerRunsPolicy：用调用者所在的线程来执行任务；
- DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
- DiscardPolicy：直接丢弃任务；当然也可以根据应用场景实现 RejectedExecutionHandler 接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务
3、线程处理任务过程
4、线程拒绝策略
线程池中的线程已经用完了，无法继续为新任务服务，同时，等待队列也已经排满了，再也塞不下新任务了。这时候我们就需要拒绝策略机制合理的处理这个问题。
JDK 内置的拒绝策略如下：
AbortPolicy： 直接抛出异常，阻止系统正常运行。可以根据业务逻辑选择重试或者放弃提交等策略。
CallerRunsPolicy ： 只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。
不会造成任务丢失，同时减缓提交任务的速度，给执行任务缓冲时间。
DiscardOldestPolicy ： 丢弃最老的一个请求，也就是即将被执行的任务，并尝试再次提交当前任务。
DiscardPolicy ： 该策略默默地丢弃无法处理的任务，不予任何处理。如果允许任务丢失，这是最好的一种方案。
5、Execuors类实现线程池
- newSingleThreadExecutor()： 只有一个线程的线程池，任务是顺序执行，适用于一个一个任务执行的场景
- newCachedThreadPool()： 线程池里有很多线程需要同时执行，60s内复用，适用执行很多短期异步的小程序或者负载较轻的服务
- newFixedThreadPool()： 拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待，适用执行长期的任务。
- newScheduledThreadPool()： 用来调度即将执行的任务的线程池
- newWorkStealingPool() ：底层采用forkjoin的Deque，采用独立的任务队列可以减少竞争同时加快任务处理
因为以上方式都存在弊端：
FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列⻓度为 Integer.MAX_VALUE，会导致OOM。 CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为 Integer.MAX_VALUE，会导致OOM。
手动创建的线程池底层使用的是ArrayBlockingQueue可以防止OOM。
6、线程池大小设置
- CPU 密集型（n+1）
CPU 密集的意思是该任务需要大量的运算，而没有阻塞，CPU 一直全速运行。
CPU 密集型任务尽可能的少的线程数量，一般为 CPU 核数 + 1 个线程的线程池。
- IO 密集型（2*n）
由于 IO 密集型任务线程并不是一直在执行任务，可以多分配一点线程数，如 CPU * 2
也可以使用公式：CPU 核心数 *（1+平均等待时间/平均工作时间）。
7、为何使用线程池
优点：通过复用已创建的线程，降低资源损耗、线程可以直接处理队列中的任务加快响应速度、同时便于统一监控和管理。
1.降低资源消耗
线程的创建和销毁会造成一定的时间和空间上的消耗，线程池可以让我们重复利用已创建的线程。
2.提高响应速度
线程池已为我们创建好了线程，当任务到达时可以不需要等到线程创建就能立即执行。
3.提高线程的可管理性
线程是稀缺资源，不可能无限的创建，使用线程池可以进行统一分配、调优和监控。
4.提供更多更强大的功能
线程池具备可拓展性，允许开发人员向其中增加更多的功能。比如延时定时线程池ScheduledThreadPoolExecutor，就允许任务延期执行或定期执行。
8、阻塞队列的作用
1、一般的队列只能保证作为一个有限长度的缓冲区，如果超出了缓冲长度，就无法保留当前的任务了，阻塞队列通过阻塞可以保留住当前想要继续入队的任务。
阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源。
阻塞队列自带阻塞和唤醒的功能，不需要额外处理，无任务执行时,线程池利用阻塞队列的take方法挂起，从而维持核心线程的存活、不至于一直占用cpu资源
为什么是先添加队列而不是先创建最大线程？
在创建新线程的时候，是要获取全局锁的，这个时候其它的就得阻塞，影响了整体效率。
9、线程池中线程复用原理
线程池将线程和任务进行解耦，线程是线程，任务是任务，摆脱了之前通过Thread创建线程时的一个线程必须对应一个任务的限制。
在线程池中，同一个线程可以从阻塞队列中不断获取新任务来执行，其核心原理在于线程池对Thread进行了封装，并不是每次执行任务都会调用Thread.start()来创建新线程，而是让每个线程去执行一个"循环任务"，在这个"循环任务"中不停检查是否有任务需要被执行，如果有则直接执行，也就是调用任务中的run方法，将run方法当成一个普通的方法执行，通过这种方式只使用固定的线程就将所有任务的run方法串联起来。
