1、在 java 中守护线程和本地线程区别？
java 中的线程分为两种：守护线程（Daemon）和用户线程（User）。
任何线程都可以设置为守护线程和用户线程，
通过方法 Thread.setDaemon(boolon)；true 则把该线程设置为守护线程，反之则为用户线程。Thread.setDaemon()必须在 Thread.start()之前调用，否则运行时会抛出异常。
两者的区别：
唯一的
区别是
判断虚拟机(JVM)何时离开，Daemon 是为其他线程提供服务，如果全部的 User Thread 已经撤离，Daemon 没有可服务的线程，JVM 撤离。也可以理解为
守护线程是 JVM 自动创建的线程（但不一定），
用户线程是程序创建的线程；
比如 JVM 的垃圾回收线程是一个守护线程，当所有线程已经撤离，不再产生垃圾，守护线程自然就没事可干了，当垃圾回收线程是 Java 虚拟机上仅剩的线程时，Java 虚拟机会自动离开。
扩展：Thread Dump 打印出来的线程信息，含有 daemon 字样的线程即为守护进程，可能会有：服务守护进程、编译守护进程、windows 下的监听 Ctrl+break的守护进程、Finalizer 守护进程、引用处理守护进程、GC 守护进程。
2、线程与进程的区别？
进程是操作系统
分配资源的最小单元，
线程是操作系
统调度的最小单元。
一个程序至少有一个进程,一个进程至少有一个线程。
3、什么是多线程中的上下文切换？
多线程会
共同使用一组计算机上的 CPU，而
线程数大于给程序分配的
CPU 数量时，
为了让各个线程都有执行的机会，就
需要轮转使用 CPU。
不同的线程切换使用 CPU发生
的切换数据等就是
上下文切换。
4、死锁与活锁的区别，死锁与饥饿的区别？
死锁：是指
两个或两个以上的进程（或线程）在执行过程中，因
争夺资源而
造成的一种
互相等待的现象，若
无外力作用，它们
都将无法推进下去。
产生死锁的必要条件：
1、
互斥条件：所谓互斥就是进程在某一时间内独占资源。
2、
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3、
不剥夺条件:进程已获得资源，在末使用完之前，不能强行剥夺。
4、
循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
活锁：任务或
者执行者没有被阻塞，由
于某些条件没有满足，
导致一直重复尝试，失败，尝试，失败。
活锁和死锁的区别
处于
活锁的实体是在
不断的改变状态，所谓的“活”， 而处于
死锁的实体表现
为等待；
活锁有可能自行解开，死锁则不能。
饥饿：一个
或者多个线程因为种种原因无法获得所需要的资源，导致一直无法执行的状态。
Java 中导致饥饿的原因：
1、高
优先级线程吞噬所有的低优先级线程的 CPU 时间。
2、线程被永久堵塞在一个等待进入同步块的状态，因为其他线程总是能在它之前持续地对该同步块进行访问。
3、线程在等待一个本身也处于永久等待完成的对象(比如调用这个对象的 wait 方法)，因为其他线程总是被持续地获得唤醒。
5、Ja
va 中用到的线程调度算法是什么？
采用
时间片轮转的方式。可
以设置线程的优先级，会映射到下层的系统上面的优先级上，如非特别需要，尽量不要用，防止线程饥饿。
5、为什么我们调用 start()方法时会执行 run()方法，为什么我们不能直接调用 run()方法？
当你
调用 start()方法时你
将创建新的线程，并
且执行在 run()方法里的代码。
但是如果你
直接调用 run()方法，它
不会创建新的线程也
不会执行调用线程的代码，只会
把 run 方法当作普通方法去执行
6、Java 中你怎样唤醒一个阻塞的线程？
解决方案可以使用以对象为目标的阻塞，即利用
Object 类的 wait()和 notify()方法实现线程阻塞。
首 先 ，wait、notify 方法是
针对对象的，调
用任意对象的 wait()方法都将导致线程阻塞，阻塞的同时也将释放该对象的锁
相应地，调
用任意对象的 notify()方法则将随机解除该对象阻塞的线程，但
它需要重新获取改对象的锁，直到获取成功才能往下执行
注意： wait、notify 方法必须
在 synchronized 块或方法中被调用，并且要
保证同步块或方法的锁对象与调用 wait、notify 方法的对象是同一个如此一来在调用 wait 之前当前线程就已经成功获取某对象的锁，执行 wait 阻塞后当前线程就将之前获取的对象锁释放。
7、java 中有几种方法可以实现一个线程？
继承 Thread 类
实现 Runnable 接口
实现 Callable 接口，需要实现的是 call() 方法
8、java 如何实现多线程之间的通讯和协作？
中断 和 共享变量
9、什么是可重入锁（ReentrantLock）？
public class UnReentrant{ Lock lock = new Lock(); public void outer(){ lock.lock(); inner(); lock.unlock(); } public void inner(){ lock.lock(); //do something lock.unlock(); } }
outer 中调用了 inner，
outer 先锁住了 lock，这样 inner 就不能再获取 lock。其实
调用 outer 的线程已经获取了 lock 锁，但是
不能在 inner 中重复利用已经获取的锁资源，这种锁即称之为 不可重入可重入就意味着：线程可以进入任何一个它已经拥有的锁所同步着的代码块。
synchronized、
ReentrantLock
都是可重入的锁，可重入锁相对来说简化了并发编程的开发。
10、乐观锁和悲观锁的理解及如何实现，有哪些实现方式？
悲观锁：总是假设最坏的情况，
每次去拿数据的时候都
认为别人会修改，
所以每次在拿数据的时候都会上锁，
这样别人想拿这个数据就会阻塞直到它拿到锁。
传统的
关系型数据库里边就用
到了很多这种锁机制，比如
行锁，表锁等，读锁，写锁等，
都是在做操作之前先上锁。再比如 Java 里面的同步原语
synchronized 关键字的实现也是悲观锁。
乐观锁：顾名思义，就是很乐观，
每次去拿数据的时候都认为
别人不会修改，所
以不会上锁，但是在
更新的时候会判断一下在此期间
别人有没有去更新这个数据，可以
使用版本号等机制。
乐观锁适用于多读的应用类型，这样可以
提高吞吐量，像数据库提供的类似于 write_condition 机制，其实都是提供的乐观锁。在 Java中 java.util.concurrent.atomic 包下面的原子变量类就是使用了乐观锁的一种实现方式 CAS 实现的。
乐观锁的实现方式：
1、
使用版本标识来
确定读到的数据与
提交时的数据是否一致。提交后修改版本标识，
不一致时可以
采取丢弃和再次尝试的策略。
2、java 中的 Compare and Swap 即 CAS ，
当多个线程尝试使用 CAS 同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。
CAS 操作中包含三个操作数 —— 需要读写的内存位置（V）、进行比较的预期原值（A）和拟写入的新值(B)。如果内存位置 V 的值与预期原值 A 相匹配，那么处理器会自动将该位置值更新为新值 B。否则处理器不做任何操作。
CAS 缺点：
1、
ABA 问题：
比如说一个线程 one 从内存位置 V 中取出 A，这时候另一个线程 two 也从内存中取出 A，并且 two 进行了一些操作变成了 B，然后 two 又将 V 位置的数据变成 A，这时候线程 one 进行 CAS 操作发现内存中仍然是 A，然后 one 操作成功。
尽管线程 one 的 CAS 操作成功，但可能存在潜藏的问题。从 Java1.5 开始 JDK 的 atomic包里提供了一个类 AtomicStampedReference 来解决 ABA 问题。
2、
循环时间长开销大：
对于资源竞争严重（线程冲突严重）的情况，CAS 自旋的概率会比较大，从而浪费更多的 CPU 资源，效率低于 synchronized。
3
、只能保证一个共享变量的原子操作：
当对一个共享变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个共享变量操作时，循环 CAS 就无法保证操作的原子性，这个时候就可以用锁。
11、SynchronizedMap 和 ConcurrentHashMap 有什么区别？
SynchronizedMap 一次锁
住整张表来保证线程安全，所以每
次只能有一个线程来访为 map。
ConcurrentHashMap 使用
分段锁来保证在
多线程下的
性能。
ConcurrentHashMap 中则是
一次锁住一个桶
。ConcurrentHashMap
默认将hash 表分
为 16 个桶，诸如 get,put,remove 等常用操作只锁当前需要用到的桶。
这样，原来只能一个线程进入，现在却能同时有 16 个写线程执行，并发性能的提升是显而易见的。
另外
ConcurrentHashMap 使用了一种不
同的迭代方式。在这种迭代方式中，当iterator 被创建后集合再发生改变就不再是抛出
ConcurrentModificationException，取而代之的是在改变时 new 新的数据从而不影响原有的数据 ，iterator 完成后再将头指针替换为新的数据 ，这样 iterator线程可以使用原来老的数据，而写线程也可以并发的完成改变。
12、什么叫线程安全？servlet 是线程安全吗?
线程安全是编程中的术语，指
某个函数、函数库
在多线程环境中被调用时，
能够正确地处理多个线程之间的共享变量，使程
序功能正确完成。
Servlet 不是线程安全的，servlet
是单实例多线程的，当多个线程同时访问同一个方法，
是不能保证共享变量的线程安全性的。
Struts2 的
action 是
多实例多线程的，
是线程安全的，每
个请求过来都会 new 一个新的 action 分配给这个请求，请求完成后销毁。
SpringMVC 的 Controller 是线程安全的吗？
不是的，和 Servlet 类似的处理流程。
Struts2 好处是不用考虑线程安全问题；Se
rvlet 和 SpringMVC 需要
考虑线程安全问题，但是性能可以提升不用处理太多的 gc，可以使用 ThreadLocal 来处理多线程的问题
13、volatile 有什么用？能否用一句话说明下 volatile 的应用场景？
volatile 保证内存
可见性和
禁止指令重排。但是
不保证原子性
volatile 用于
多线程环境下的单次操作(单次读或者单次写)
14、为什么代码会重排序？
在执行程序时，为了
提高性能，
处理器和
编译器常常
会对指令进行重排序，但是不能随意重排序，不是你想怎么排序就怎么
排序，它需要满足以下
两个条件：
在单线程环境下
不能改变程序
运行的结果；
存在数据
依赖关系的
不允许重排序
需要注意的是：重排序不会影响单线程环境的执行结果，但是会破坏多线程的执行语义。
15、在 java 中 wait 和 sleep 方法的不同？
最大的不同是在
等待时 wait 会释放锁，而
sleep 一直持有锁。
Wait 通常被
用于线程间交互，
sleep 通常被
用于暂停执行。
16、什么是线程池？ 为什么要使用它？
创建线程要
花费昂贵的资源和
时间，如
果任务来了才创建线程那么
响应时间会变长，而且一个
进程能创建的线程数有限。为了避免这些问题，在
程序启动的时候就创建若干线程来响应处理，它们被
称为线程池，里面的线程叫工作线程。
从JDK1.5 开始，Java API 提供了
Executor 框架让你可以创建不同的线程池。
17、JVM 中哪个参数是用来控制线程的栈堆栈小的?
-Xss 每个线程的栈大小
18、Thread 类中的 yield 方法有什么作用？
使当前线程从
执行状态（
运行状态）
变为
可执行态（
就绪状态）。
当前线程到了就绪状态，那么接下来哪个线程会从就绪状态变成执行状态呢？可能是当前线程，也可能是其他线程，看系统的分配了。
19、Java 线程池中 submit() 和 execute()方法有什么区别？
两个方法都
可以向线程池提交任务
execute()方法的返
回类型是 void，它定义在
Executor 接口中。
submit()方法可以
返回持有计算结果的 Future 对象，它定义在
ExecutorService 接口中，它
扩展了 Executor 接口，其它线程池类像
ThreadPoolExecutor 和 ScheduledThreadPoolExecutor
都有这些方法。
19、可以直接调用 Thread 类的 run ()方法么？
当然
可以。
但是如果我们调用了 Thread 的 run()方法，它的行
为就会和普通的方法一样，会
在当前线程中执行。为了
在新的线程中执行我们的代码，
必须使用Thread.start()方法。
67、你如何确保 main()方法所在的线程是 Java 程序最后结束的线程？
我们可以使用
Thread 类的
join()方法来确保所
有程序创建的线程在
main()方法退出前结束。
来源于 --传送门