目录
1、sleep()、wait()、join()、yield()的区别
10、线程池中阻塞队列的作用？为什么是添加队列而不是先创建最大线程？
1、sleep()、wait()、join()、yield()的区别
1、锁池
所有需要竞争同步锁的线程都会放到锁池当中，比如当前对象的锁已经被其中一个线程得到，则其他线程需要在这个锁池进行等待，当前面的线程释放同步锁中的线程去竞争同步锁，当某个线程得到后台会进入就绪队列进行等待cpu分配。
2、等待锁
当我们调用wait()方法后，线程会放到等待锁当中，等待池的线程是不会竞争同步锁。只有调用notify()或者notifyAll()后等待池的线程才会开始竞争锁，notify()是随机从等待池选出一个线程放到锁池，而notifyAll()是将等待池的所有线程放到锁池当中。
1、sleep是Thread类的静态本地方法，wait则是Object类的本地方法
2、sleep方法不会释放lock，但是wait会释放，并且会加入到等待队列中。
sleep 就是把CPU的执行资格和执行权释放出来，不再运行此线程，当定时时间结束再取回CPU资源，参与CPU调度，获取到CPU资源后就可以继续执行了。而如果sleep是该线程有锁，那么sleep不会释放这个锁，而是把锁带着进入冻结状态，也就是说其他需要这个锁的线程根本不可能获取这个锁。也就是说无法执行程序。如果在睡眠期间其他线程调用了这个线程的interrupt方法，那么这个线程也就会抛出interruptexception异常方法，这点和wait是一样的。
3、sleep方法不依赖于同步器synchronized，但是wait需要依赖synchronized关键字。
4、sleep不需要唤醒（休眠之后推出阻塞），但是wait需要（不指定时间需要被别人中断）。
5、sleep一般用于与当前线程休眠，或者轮询暂停操作，wait则多用于多线程之间通信。
6、sleep会让出CPU执行时间且强制切换上下文，而wait则不一定，wait后可能还是有机会重新竞争到锁继续执行的。
yield（）执行后线程直接进入就绪状态，马上是否CPU的执行权，但是依然保留CPU的执行资格，所以有可能CPU下次进行线程调度还会让这个线程获取到执行权继续执行
join（）执行后线程进行阻塞状态，例如在线程B中调用线程A的join（），那线程B就会进入到阻塞队列，直接线程A结束或者中断线程。
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("22222222222");
}
});
t1.start();
t1.join();
// 这行代码必须等t1全部执行完毕，才会执行
System.out.println("1111111");
}
22222222222
11111112、说说你对线程安全理解
不是线程安全，应该是内存安全，堆是共享内存，可以被所有线程访问
当多个线程访问一个对象时，如果不再进行额外的同步控制或者其他的协同操作，调用这个对象的行为都可以获得正确的结果，我们就说这个对象的线程是安全的。
堆是进程和线程共有的空间，分全部堆和局部堆。全局堆就是所有没有分配的空间，局部堆就是用户分配的空间，堆在操作系统对进程初始化时候分配，运行过程中也可以向系统额外索要堆，但是用完了要还给操作系统，要不然就是内存泄漏。
在java中，堆是java虚拟机所管理的内存中最大的一块，是所有线程共享的一块内存区域，在虚拟机启动时创建，堆所在的内存区域的唯一目的就是存放对象的实例，几乎所有对象实例以及数组都在这里分配内存。
栈是每个线程独有的，保存其运行状态和局部自动变量的。栈在线程开始时候初始化，每个线程的栈相互独立，因此，栈是线程安全的。操作系统在切换线程的时候会自动切换栈。栈空间不需要在高级语言里显式的分配和释放。目前主流操作系统是多任务的，即多个进程同时运行。为了保证安全，每个进程只能访问分配给自己的内存空间，而不是访问别的空间的，这是由操作系统保障的。在每个进程的内存空间中都会有一块特殊的公共空间，通常称为堆（内存）。进程内的所有线程都可以访问到该区域，这就是造成问题潜在原因。
3、Thread和Runable
在实际工作中，我们很可能习惯性地选择Runnable或Thread之一直接使用，根本没在意二者的区别，但在面试中很多自以为是的菜货面试官会经常而且非常严肃的问出：请你解释下Runnable或Thread的区别？尤其是新手就容易上当，不知如何回答，就胡乱编一通。鄙人今天告诉你们这二者本身就没有本质区别，就是接口和类的区别。问出这个问题的面试官本身就是个二流子！如果非要说区别，请看如下：
Runnable的实现方式是实现其接口即可 Thread的实现方式是继承其类 Runnable接口支持多继承，但基本上用不到 Thread实现了Runnable接口并进行了扩展，而Thread和Runnable的实质是实现的关系，不是同类东西，所以Runnable或Thread本身没有可比性。 网络上流传的最大的一个错误结论：Runnable更容易可以实现多个线程间的资源共享，而Thread不可以！ 这是一个二笔的结论！网络得出此结论的例子如下：
//program--Thread
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
new MyThread().start();
new MyThread().start();
}
static class MyThread extends Thread{
private int ticket = 5;
public void run(){
while(true){
System.out.println("Thread ticket = " + ticket--);
if(ticket < 0){
break;
}
}
}
}
}
运行结果如下：
Thread ticket = 5
Thread ticket = 5
Thread ticket = 4
Thread ticket = 3
Thread ticket = 2
Thread ticket = 1
Thread ticket = 0
Thread ticket = 4
Thread ticket = 3
Thread ticket = 2
Thread ticket = 1
Thread ticket = 0
Process finished with exit code 0
1很显然，总共5张票但卖了10张。这就像两个售票员再卖同一张票，原因稍后分析。现在看看使用runnable的结果：
//program--Runnable
public class Test2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread2 mt=new MyThread2();
new Thread(mt).start();
new Thread(mt).start();
}
static class MyThread2 implements Runnable{
private int ticket = 5;
public void run(){
while(true){
System.out.println("Runnable ticket = " + ticket--);
if(ticket < 0){
break;
}
}
}
}
}运行结果如下：
Runnable ticket = 5
Runnable ticket = 4
Runnable ticket = 3
Runnable ticket = 1
Runnable ticket = 0
Runnable ticket = 2
Process finished with exit code 0嗯，嗯，大多数人都会认为结果正确了，而且会非常郑重的得出：Runnable更容易可以实现多个线程间的资源共享，而Thread不可以！ 真的是这样吗？大错特错！ program–Thread这个例子结果多卖一倍票的原因根本不是因为Runnable和Thread的区别，看其中的如下两行代码：
new MyThread().start();
new MyThread().start();例子中，创建了两个MyThread对象，每个对象都有自己的ticket成员变量，当然会多卖1倍。如果把ticket定义为static类型，就离正确结果有近了一步（因为是多线程同时访问一个变量会有同步问题，加上锁才是最终正确的代码）。 现在看program–Runnable例子中，如下代码：
MyThread2 mt=new MyThread2();
new Thread(mt).start();
new Thread(mt).start(); 只创建了一个Runnable对象，肯定只卖一倍票（但也会有多线程同步问题，同样需要加锁），根本不是Runnable和Thread的区别造成的。再来看一个使用Thread方式的正确例子：
public class Test3 extends Thread {
private int ticket = 10;
public void run(){
for(int i =0;i<10;i++){
synchronized (this){
if(this.ticket>0){
try {
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+"卖票---->"+(this.ticket--));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public static void main(String[] arg){
Test3 t1 = new Test3();
new Thread(t1,"线程1").start();
new Thread(t1,"线程2").start();
}
}运行结果如下：
线程1卖票---->10
线程1卖票---->9
线程1卖票---->8
线程1卖票---->7
线程1卖票---->6
线程1卖票---->5
线程1卖票---->4
线程1卖票---->3
线程1卖票---->2
线程1卖票---->1
Process finished with exit code 0上例中只创建了一个Thread对象（子类Test3）,效果和Runnable一样。synchronized这个关键字是必须的，否则会出现同步问题，篇幅太长本文不做讨论。 上面讨论下来，Thread和Runnable没有根本的没区别，只是写法不同罢了，事实是Thread和Runnable没有本质的区别，这才是正确的结论，和自以为是的大神所说的Runnable更容易实现资源共享，没有半点关系！ 现在看下Thread源码：
public
class Thread implements Runnable {
/* Make sure registerNatives is the first thing <clinit> does. */
private static native void registerNatives();
static {
registerNatives();
}
private volatile String name;
private int priority;
private Thread threadQ;
private long eetop;可以看出，Thread实现了Runnable接口，提供了更多的可用方法和成员而已。
结论，Thread和Runnable的实质是继承关系，没有可比性。无论使用Runnable还是Thread，都会new Thread，然后执行run方法。用法上，如果有复杂的线程操作需求，那就选择继承Thread，如果只是简单的执行一个任务，那就实现runnable。 再遇到二笔面试官问Thread和Runnable的区别，你可以直接鄙视了！
4、说说你对守护线程的理解
守护线程：为所有非守护线程提供服务的线程，任何一个守护线程都是整个jvm中所有非守护线程的保姆；
守护线程类似于整个进程一个默默无闻的小喽啰，它的生死无关重要，它却依赖整个进程而运行；哪天其他线程结束了，没有要执行的了，程序要执行的了，程序就结束了，理都没理守护线程，就把它中断了；
注意：由于守护线程的终止是自身无法控制的，因此千万不要把IO、file等重要的操作逻辑分配给它，因为他不靠谱；
守护线程的作用是什么？
举例，GC垃圾回收线程；就是一个经典的守护线程，当我们的程序中不再有任何程序运行Thread，程序就不会再产生垃圾，垃圾回收器就无事可做，所以当垃圾回收线程是JVM上仅剩的线程时，垃圾回收线程会自动离开。它始总在低级别状态中运行，用于实时监控和管理系统中的可回收资源。
应用场景：（1）来为其他线程提供服务支持的情况；（2）或者在任何情况下，程序结束时，这个线程必须正常且立刻关闭；就可以 作为守护线程来使用；反之，如果一个正在执行某个操作的线程必须要正确地关闭掉否则就会出现不好的后果的话，那么这个线程就不能是守护线程，而是用户线程。通常都是些关键的事务，比方说，数据库录入或者更新，这些操作都是不能中断的。
thread.setDaemon(true)必须在thread.start() 之前设置，否则就会抛出illegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。
在Daemon线程中产生新的线程也是Daemon的。
守护线程不能用于去访问固有资源，比如读写操作或者计算逻辑。因为它会在任何时候甚至在一个操作中间发生中断。
java自带的多线程框架，比如ExcutorService，会将守护线程转换为用户线程，所以如果要使用后台线程就不能用java线程池。
5、ThreadLocal的原理和使用场景
https://baijiahao.baidu.com/s?id=1653790035315010634&wfr=spider&for=pc
6、并发、并行、串行的区别
串行在时间上不可能发生重叠，前一个任务没搞定，下一个任务就只能 等着。
并行在时间是重叠的，两个任务在同一时间互不干扰的同时执行。
并发允许两个任务彼此干扰。统一时间点，只有一个任务执行，交替执行。
7、并发的三大特性
原子性
原子性是指在一个操作中CPU不可以在中途暂停然后再去调度，即不被中断操作，要不全部执行完成，要不都不执行。就好比转账，从账户A向账户B转1000元，那么必然包括2个操作，从账户A减去1000元，往账户B加上1000元。2个操作必须全部完成。
private long count=0;
public void calc(){
count++;
}1、将count从主存读到工作内存中的副本中
2、+1的运算
3、将结果写入工作内存
4、将工作内存的值刷回主存（什么时候刷入由操作系统决定，不确定的）
那程序中原子性是指最小的操作单元，比如自增操作，它本身其实并不是原子性操作，分了3步的，包括读取变量的原始值，进行加1操作、写入内存。所以在多线程中，有可能一个线程还没自增完，可能才执行到第二步，另一个线程已经读取了值，导致结果错误。那如果我们能保证自增操作是一个原子性操作，那么就能保证其他线程读取到一定是自增后的数据。
关键字：synchronize
可见性
当一个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立刻看到修改的值。
罗两个线程在不同的CPU，那么线程1改变了i的值还没刷新到主存，线程2又使用了i，那么这个i值肯定还是之前的，线程1对变量的修改线程没看到这就是可见性问题。
// 线程1
boolean stop=false;
while(!stop){
dosomething();
}
//线程2
stop=true;如果线程2改变了stop的值，线程1一定会停止吗？不一定。当线程2更改了stop变量的值之后，但是还没来得及写入内存当中，线程2转去做别的事情了，那么线程1由于不知道线程2对stop变量的更改，因此还会一直循环下去。
关键字：volatile、synhronized、final
有序性
虚拟机在进行代码编译时候，对于那些改变顺序之后不会对最终结果造成影响的代码，虚拟机不一定按照我们写的代码顺序去执行，有可能将他们进行重排序。实际上，对于这些代码进行重排序之后，虽然对变量的值没有造成影响，但是有可能出现线程安全问题。
int a=0;
boolean flag=false;
public void write(){
a=2;//1
flag=true ;//2
}
public void multiply(){
if(flag){ //3
int ret=a*a;//4
}
}write方法里的1和2做了重排序，线程1先对flag赋值为true，随后执行线程2，ret直接计算出结果，再到线程2，这时候a才赋值为2，很明显迟了一步。
关键字：volatile、synhronized
volatile本身就包括了禁止指令重排序的语义，而synchronized关键字是由“一个变量在同一时刻只允许一条线程对其进行lock操作”这条规则明确的。
8、为什么用线程池？解释下线程池参数？
为什么使用线程池？ 降低资源消耗：提高线程的利用率，降低线程创建和销毁的资源消耗 提高响应速度：任务来了，直接有线程可用可执行，不需要先创建线程，再执行。对线程进行统一管控处理：线程是稀缺资源，使用线程池可以统一分配调优监控。 线程池参数详解
# corePoolSize 代表核心线程数，也就是正常情况下创建工作的线程数。这些线程创建后并不会消除，而是一种常驻线程。
# maxinumPoolSize 代表的是最大线程数，它与核心线程数相对应，表示最大允许被创建的线程数，比如当前任务较多，将核心线程数都用完了，还无法满足需求时，此时就会创建新的线程，但是线程池内线程池总数不会超过当前设置的最大线程数。
# keepAliveTime unit表示超出核心线程数之外的线程的空闲存活时间，也就是核心线程不会消除，但是超出核心线程数的部分线程如果空闲一定的时间则会被消除，我们可以通过setKeepAliveTime 来设置空闲时间。
# workQueue 用来存放待执行的任务，假设我们现在核心线程池已经都被使用，还有任务进来则全部放入队列，知道整个队列被放满但任务还再秩序进入则会开始创建新的线程
# ThreadFactory 实际上是一个线程工厂，用来生产线程执行任务，我们可以选择使用默认的创建工厂，产生的线程都在同一个组内，拥有相同的优先级，且都不是守护线程，当然我们也可以自定义线程工厂，一般我们会根据业务来制定不同的线程工厂。
# Handler 任务拒绝策略。有两种情况，第一种是当我们调用shutdown 等方法关闭线程池后，这时候及时线程池内部还有没执行完的任务正在执行，但是由于线程池已经关闭，我们再继续向线程池提交任务就会遭到拒绝。另一种情况就是当达到最大线程数，线程池已经没有能力继续处理提交的任务时，这时也会拒绝
# 扩展：四种拒绝策略
# AbortPolicy（默认）:丢弃任务并抛出RejectedExecutionException异常。这是线程池默认的拒绝策略，在任务不能再提交的时候，抛出异常，及时反馈程序运行状态。如果是比较关键的业务，推荐使用此拒绝策略，这样子在系统不能承载更大的并发量的时候，能够及时的通过异常发现。
# DiscardPolicy：丢弃任务，但是不抛出异常。如果线程队列已满，则后续提交的任务都会被丢弃，且是静默丢弃。使用此策略，可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略。例如，收集类统计就可以采用的这种拒绝策略。
# DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务。此拒绝策略，是一种喜新厌旧的拒绝策略。是否要采用此种拒绝策略，还得根据实际业务是否允许丢弃老任务来认真衡量。
# CallerRunsPolicy：由调用线程处理该任务。如果任务被拒绝了，则由调用线程（提交任务的线程）直接执行此任务
原文链接：https://blog.csdn.net/lxn1023143182/article/details/114180272
10、线程池中阻塞队列的作用？为什么是添加队列而不是先创建最大线程？
1、一般的队列只能保证作为一个有限长度的缓冲区，如果超出了缓冲长度，就无法保留当前的任务了，阻塞队列通过阻塞可以保留住当前想要想要继续入队的任务。
阻塞队列可以保证任务队列没有任务阻塞获取任务线程，使得线程进入wait状态，释放CPU资源。
阻塞队列自带阻塞和唤醒功能，不需要额外处理，无任务执行时，线程池利用阻塞队列的take方法挂起，从而维持核心线程的存活，不至于一直占CPU资源
2、在创建新线程的时候，是要获取全局锁的，这个时候其它的就得阻塞，影响整体效率。
就好比一个企业里面有10个正式工名额，最多招10个正式工，要是任务超过正式工数情况下，公司领导（线程池）不是首先扩招个人，还是这10个人，但是任务可以稍微挤压一下，即先放到队列去（代价低）。10个正式工慢慢干，迟早会干完的，要是任务还在继续增加，超过正式工的加班忍耐极限了（队列满了），就得招外包帮忙了（注意是临时工）要是正式工加上外包还是不能完成任务，那新来的任务就会被领导拒绝了（线程池的拒绝策略）。
11线程池中线程复用原理
线程池将线程任务进行解耦，线程是线程，任务是任务，摆脱了之前通过Thread创建线程时的一个线程必须对应一个任务的限制。
在线程池中，同一个线程可以从阻塞队列中不断获取新任务来执行，其核心原理在于线程池对Thread进行了封装，并不是每次执行任务时都会调用Thread.start()来创建新线程，而是让每个线程去执行循环任务，在这个循环任务中不断检查是否需要被直接执行，也是调用任务中的run方法，将run方法当成一个普通方法执行，通过这种方式只读使用固定的线程将所有任务的run方法串联起来。
410
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
