1、并发、并行、串行的区别
- 串行在时间上不可能发生重叠，前一个任务没搞定，下一个任务就只能等着。
- 并行是时间上是重叠的，两个任务在同一时刻互不干扰地同时执行。
- 并发允许两个任务彼此干扰。同一时间点只有一个任务允许，交替执行。比如cpu就是并行的。
2、并发的三大特性
原子性
原子性是指在一个操作中cpu不可以在中途暂停然后再调度，即不被中断操作，要不全部执行完成，要不都不执行。就好比转账，从账户A向账户B转1000元，那么必然包括了2个操作：从账户A减去1000元，往账户B加上1000元。2个操作必须全部完成。
i++不是原子的，它分为4个步骤。
private long count = 0;
public void calc() {
count++;
}- 将count从主存读到工作内存中的副本中
- +1的运算
- 将结果写入工作内存
- 将工作内存的值刷回主存（什么时候刷入由操作系统决定，不确定的）
那程序中原子性指的是最小的操作单元，比如自增操作，它本身其实并不是原子性操作，分了3步的，包括读取变量的原始值、进行加1操作、写入工作内存。所以在多线程中，有可能一个线程还没自增玩，可能才执行到第二步，另一个线程就已经读取了值，导致结果错误。那如果我们能保证自增操作是一个原子性的操作，那么就能保证其他线程读取到的一定是自增后的数据。
把上面操作的前3步操作变为原子性的，但是第四步还可能导致数据异常，这就看下面的可见性。有原子性和可见性，才能使得i++是安全的。
使用AtomicInteger能保证线程安全，它使用的Volatitle，它保证了可见性，里面还用到了CAS，它保证了原子性。
关键字： synchronized
可见性
当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
若两个线程在不同的cpu，那么线程1改变了i的值还没刷新到主存，线程2又使用了i，那么这个i值肯定还是之前的，线程1对变量的修改线程2没看到，这就是可见性问题。
// 线程1
boolean stop = false;
while(!stop) {
doSomething();
}
// 线程2
stop = true;如果线程2改变了stop的值，线程1一定会停止吗？不一定。当线程2更改了stop变量的值之后，但是还没来得及写入主存中，线程2转去做其他事情了，那么线程1由于不知道线程2对stop变量的更改，因此还会一直循环下去。
操作系统底层两个协议: 总线锁定， MESI（缓存一致性协议）。使用这两个协议保证变量的可见性。t1线程对0进行+1操作，这时候t2拿到的0会失效，这就是由这两个协议保证的。数据往线程的工作内存和主存写的两步也是原子操作，这也是可见性保证的。
关键字：volatile、 synchronized、final
有序性
虚拟机在进行代码编译时，对于那些改变顺序之后不会对最终结果造成影响的代码，虚拟机不一定会按照我们写的代码顺序来执行，有可能将他们重排序。实际上，对于有些代码进行重排序之后，虽然对变量的值没有造成影响，但有可能会出现线程安全问题。
int a = 0;
bool 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直接计算出结果，再到线程1，这时候a才赋值为2，很明显迟了一步。
关键字： volatile、 synchronized
创建一个对象 比如new User(); 其实会分为三步， 第一个申请一块内存，第二步给内存属性复制User，第三部给栈中变量赋值。这个场景适合volatile。
3、线程的生命周期、线程有哪些状态？
1、线程通常有五种状态，创建、就绪、运行、阻塞、死亡。
2、阻塞的情况又分为三种：
- 等待阻塞：运行的线程执行wait方法，该线程会释放占用的所有资源，jvm会把该线程放入“等待池” 中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify或notifyAll方法才能被唤醒，wait是object类的方法。
- 同步阻塞： 运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则jvm会把该线程放入“锁池”中。
- 其他阻塞：运行的线程执行sleep或join方法，或发出了io请求时，jvm会把该线程置为阻塞状态。当sleep状态超时、join等待线程终止或者超时、或者io处理完毕时，线程重新转入就绪状态。sleep是Thread类的方法。
1、新建状态（New）： 新创建了一个线程对象。
2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态（Blocked）： 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。
5、死亡状态（Dead）：线程执行完了或者因异常退出了run方法，该线程结束生命周期。
4、sleep() 、wait()、join()、yield()的区别
1、锁池
所有需要竞争同步锁的线程都会放在锁池当中，比如当前对象的锁已经被其中一个线程得到，则其他线程需要在这个锁池进行等待，当前面的线程释放同步锁后锁池中的线程去竞争同步锁，当某个线程得到后会进入就绪队列进行等待cpu资源分配。
2、等待池
当我们调用wait（）方法后，线程会放到等待池当中，等待池的线程是不会去竞争同步锁。只有调用了notify（）或notifyAll（）后等待池的线程才会开始去竞争锁，notify（）是随机从等待池选出一个线程放到锁池，而notifyAll（）是将等待池的所有线程放到锁池当中。
sleep和wait的不同
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和join
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("22222");
}
});
t1.start();
t1.join();
// 这行代码必须要等t1全部执行完毕，才会执行
System.out.printLn("1111");
}5、说说你对线程安全的理解
不是线程安全，应该是内存安全，堆是共享内存，可以被所有线程访问。
当多个线程访问一个对象时，如果不用进行额外的同步控制或其他的协调操作，调用这个对象的行为都可以获得正确的结果，我们就说这个对象是线程安全的。
堆是进程和线程共有的空间，分全局堆和局部堆。全局堆就是所有没有分配的空间，局部堆就是用户分配的空间。堆在操作系统对进程初始化的时候分配，运行过程中也可以向系统要额外的堆，但是用完了要还给操作系统，要不然就内存泄露了。
在Java中，堆是Java虚拟机所管理的内存中最大的一块，是所有线程共享的一块内存区域，在虚拟机启动时创建。堆所在内存区域的唯一目的就是存放对象实例，几乎所有的对象实例以及数据都在这里分配内存。
栈是每个线程独有的，保存其运行状态和局部自动变量的。栈在线程开始的时候初始化，每个线程的栈相互独立，因此，栈是线程安全的。操作系统在切换线程的时候会自动切换栈。栈空间不需要在高级语言里面显示地分配和释放。
目前主流操作系统都是多任务的，即多个进程同时运行。为了保证安全，每个进程只能访问分配给自己的内存空间，而不能访问别的进程的，这是由操作系统保障的。
在每个进程的内存空间中都会有一块特殊的公共区域，通常成为堆（内存）。进程内的所有线程都可以访问到该区域，这就是造成问题的潜在原因。
6、Thread、Runnable
Thread和Runnable的实质是继承关系，没有可比性。无论使用Runnable还是Thread, 都会new Thread，然后执行run方法。用法上，如果有复杂的线程操作需求，那就选择继承Thread，如果只是简单的执行一个任务，那就实现runnable。
8、说说你对守护线程的理解
9、ThreadLocal的原理和使用场景
每一个Thread对象均含有一个ThreadLocalMap类型的成员变量threadLocals，它存储本线程中所有ThreadLocal对象及其对应的值。
ThreadLocalMap由一个个Entry对象构成。Entry继承自WeakReference<ThreadLocal<?>>, 一个Entry由ThreadLocal对象和Object构成。由此可见，Entry的key是ThreadLocal对象，并且是一个弱引用。当没指向key的强引用后，该key就会被垃圾收集器回收。
当执行set方法时，TheadLocal首先会获取当前线程对象，然后获取当前线程的ThreadLocalMap对象。再以当前ThreadLocal对象为key，将值存储进ThreadLocalMap对象中。
get方法执行过程类似。ThreadLocal首先会获取当前线程对象，然后获取当前线程的ThreadLocalMap对象。再以当前ThreadLocal对象为key，获取对应的value。
由于每一条线程均含有各自私有的ThreadLocalMap容器，这些容器相互独立互不影响，因此不会存在线程安全性问题，从而也无需使用同步机制来保证多条线程访问容器的互斥性。
使用场景：
1、在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。比如User对象需要在controler、service、dao层都要用到，就可以把它放到ThreadLocal中。
2、线程间数据隔离。
3、进行事务操作，用于存储线程事务信息。
4、数据库连接，Session会话管理，这些也都数据线程级的内容。
10、 ThreadLocal内存泄漏原因，如何避免
在程序中controller、service、dao都用共同的形参的时候，使用ThreadLocal很方便。对于内存泄露，只要是我们使用的问题。
内存泄露为程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存，迟早会被占光。
不再会被使用的对象或者变量占用的内存不能被回收，就是内存泄漏。
强引用：使用最普遍的引用（new），一个对象具有强引用，不会被垃圾回收器回收。当内存空间不足，java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不回收这种对象。
如果想取消强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样可以使jvm在合适的时间就会回收该对象。
弱引用：jvm进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。在java中，用java.land.ref.Reference类来表示，可以在缓存中使用弱引用。
ThreadLocal的实现原理，每一个Thread维护一个ThreadLocalMap（线程本地变量），key为使用弱引用的ThreadLocal实例，value为线程变量的副本。
ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal不存在外部强引用时，key（ThreadLocal）势必会被GC回收，这样就会导致ThreadLocalMap中key为null，而value还存在着强引用，只有thread线程退出以后，value的强引用联调才会断掉，但如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链（红色链条）。
可以使用强引用
- 当ThreadLocalMap的key为强引用回收ThreadLocal时，因为ThreadLocalMap还持有TheadLocal的强引用，如果没有手动删除，ThreadLocal不会被回收，导致Entry内存泄露。
key使用弱引用
- 当ThreadLocalMap的key为弱引用回收ThreadLocal时，由于ThreadLocalMap持有ThreadLocal的弱引用，即时没有手动删除，ThreadLocal也会被回收。当key为null，在下一次ThreadLocalMap调用set（）、get（）、remove（）方法的时候会被清除value值。
因此，ThreadLocal内存泄露的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄露，而不是因为弱引用。
TheadLocal正确的使用方法
- 每次使用完ThreadLocal都调用它的remove（）方法清除数据。
- 将ThreadLocal变量定义成private static， 这样就一直存在TheadLocal的强引用，也就能保证任何时候都能通过TheadLocal的弱引用访问到Entry的value值，进而清除掉。
11、为什么用线程池？解释下线程池参数？
1、降低资源消耗；提高线程利用率，降低创建和销毁线程的消耗。
2、提高响应速度；任务来了，直接有线程可用可执行，而不是先创建线程，再执行。
3、提高线程的可管理性；线程是稀缺资源；使用线程池可以统一分配调优监控。
- corePoolSize 代表核心线程数，也就是正常情况下创建工作的线程数，这些线程创建后并不会消除，而是一种常驻线程。
- maxinumPoolSize： 代表的最大线程数，它与核心线程数相对应，表示最大允许被创建的线程数，比如当前任务较多，将核心线程数都用完了，还无法满足需求时，此时就会创建新的线程，但是线程池内线程总数不会超过最大线程数。
- keepAliveTime，unit 表示超出核心线程数之外的线程的空闲存活时间，也就是核心线程不会消除，但是超出核心线程数的部分线程如果空闲一定的时间则会被消除，我们可以通过setKeepAliveTime来设置空闲时间。
- workQueue 用来存放待执行的任务，假设我们现在核心线程都已被使用，还有任务进来则全部放入队列，直到整个队列被放满但任务还再持续进入则会开始创建新的线程。
- ThreadFactory 实际上是一个线程工厂，用来生产线程执行任务。我们可以选择使用默认的创建工厂，产生的线程都在同一个组内，拥有相同的优先级，且都不是守护线程。当然我们也可以选择自定义线程工厂，一般我们会根据业务来制定不同的线程工厂。
- Handler 任务拒绝策略，有两种情况，第一种是当我们调用shutdown等方法关闭线程池后，这时候即时线程池内部还没有执行完的任务正在运行，但是由于线程池关闭，我们再继续向线程池提交任务就会遭到拒绝。另一种情况就是当达到最大线程数，线程池已经没有能力继续处理新提交的任务时，这时也就拒绝。
12、简述线程池处理流程
13、线程池中阻塞队列的作用？为什么是先添加队列而不是先创建最大线程？
1、一般的队列只能保证作为一个有限长度的缓冲区，如果超出了缓冲长度，就无法保留当前的任务了，阻塞队列通过阻塞可以保留住当前想要继续入队的任务。
阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源。
阻塞队列自带阻塞和唤醒功能，不需要额外处理，无任务执行时，线程池利用阻塞队列的take方法挂起，从而维持核心线程的存活，不至于一直占用cpu资源。
2、在创建新线程的时候，是要获取全局锁的，这个时候其它的就得阻塞，影响了整体效率。
就好比一个企业里面10个（core）正式工的名额，最多找10个正式工，要是任务超过正式人工数(task>core)的情况下，工厂领导（线程池）不是首先扩招工人，还是这10人， 但是任务可以稍微积压一下，即先放到队列去（代价低）。10个正式工慢慢干，迟早会干完的，要是任务还在继续增加，超过正式工的加班忍耐极限了（队列满了），就得招外包帮忙了（注意是临时工）要是正式工加上外包还是不能完成任务，那新来的任务就会被领导拒绝了（线程池的拒绝策略）。
14、线程池线程复用的原理
线程池将线程和任务进行解耦，线程是线程，任务是任务，摆脱了之前通过Thread创建线程时的一个线程必须对应一个任务的限制。
在线程池中，同一个线程可以从阻塞队列中不断获取新任务来执行，其核心原理在于线程池对thread进行了封装 ，并不是每次执行任务都会调用Thread.start（）来创建新线程，而是让每个线程去执行一个“循环任务”，在这个“循环任务”中不停检查是否有任务需要执行，如果有则直接执行，也就是调用任务中的run方法，将run方法当成一个普通的方法执行，通过这种方式只使用固定的线程就将所有任务的run方法串联起来。
15、HashMap的扩容机制原理
1.7的HashMap就是用的数组和联表。
1.8的HashMap除了数组和联表，还用了红黑树。
1.7的扩容，是先生成新的数组，再把旧数组上的元素转移到新数组上面来，
- resize就是扩容方法。
- 有个双重循环，遍历数组每个下标，如果里面有链表要继续遍历。
1.8的扩容，也是先生成新的数组，再把链表转移过去，如果某个节点下是一个红黑树，hashmap就去计算每个节点在新数组和树上面的位置。因为根据数组容量的不同，节点位置都不同。所以当一个红黑树转移之后，可能被拆出来两个链表，或者一个链表一个红黑树等等各种可能。
16、JDK1.7到JDK1.8 HashMap发生了什么变化(底层)？
1、1.7中底层是数组+链表
17、ConcurrentHashMap的扩容机制
18、如果理解volatile关键字
在并发领域中，存在三大特性：原子性、有序性、可见性。volitle关键字用来修饰对象的属性，在并发环境下可以保证这个属性的可见性，对于加了volatile关键字的属性，在对这个属性进行修改时，会直接将cpu高级缓存中的数据写会到主内存，对这个变量的读取也会直接从主内存中读取，从而保证了可见性，底层是通过操作系统内存屏障来实现的，由于使用了内存屏障，所以会禁止指令重排，所以同时也就保证了有序性，在很多并发场景下，如果用好volatile关键字可以很好的提高执行效率。