面试题整理 自问自答

Java基础篇

1. jdk 和 jre 的区别
   jdk java Development Kit (Java 开发 工具箱) jre java 运行时环境

2. == 和 equals 的区别是什么？
   == 对于基本类型来说是值比较，对于引用类型来说是比较的是引用的内存地址；
   而 equals 默认情况下是引用比较，只是很多类重新了 equals 方法。
   比如 String、Integer 等把它变成了值比较，所以一般情况下 equals 比较的是值是否相等

3. 两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？
   hashCode和equals的两个方法都可以重写 不具备相关关系 不对

4. final 在 java 中有什么作用？
   (1)修饰类：表示该类不能被继承；
   (2)修饰方法：表示方法不能被重写；
   (3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。
   相信大家都具备基本的常识: 被final修饰的变量是不能够被改变的. 但是这里的"不能够被改变"对于不同的数据类型是有不同的含义的.
   当final修饰的是一个基本数据类型数据时, 这个数据的值在初始化后将不能被改变; 当final修饰的是一个引用类型数据时, 也就是修饰一个对象时, 引用在初始化后将永远指向一个内存地址, 不可修改. 但是该内存地址中保存的对象信息, 是可以进行修改的.

5. java 中的 Math.round(-1.5) 等于多少？
   “注意:Math的round方法是四舍五入,如果参数是负数,则往大的数如,Math.round(-1.5)=-1,如果是Math.round(1.5)则结果为2”

6. String 属于基础的数据类型吗？
   不属于。
   Java8种基础的数据类型：byte、short、char、int、long、float、double、boolean。

7. java 中操作字符串都有哪些类？它们之间有什么区别？
   String : final修饰，String类的方法都是返回new String。即对String对象的任何改变都不影响到原对象，对字符串的修改操作都会生成新的对象。
   StringBuffer : 对字符串的操作的方法都加了synchronized，保证线程安全。
   StringBuilder : 不保证线程安全，在方法体内需要进行字符串的修改操作，可以new StringBuilder对象，调用StringBuilder对象的append、replace、delete等方法修改字符串。

8. String str="i"与 String str=new String(“i”)一样吗？
   
   不一样的原因很简单，因为他们不是同一个对象。
   String str=“i”;
   这句话的意思是把“i”这个值在内存中的地址赋给str,如果再有String str3=“i”；那么这句话的操作也是把“i”这个值在内存中的地址赋给str3,这两个引用的是同一个地址值，他们两个共享同一个内存。
   而String str2 = new String(“i”);
   则是将new String(“i”);的对象地址赋给str2，需要注意的是这句话是新创建了一个对象。如果再有String str4= new String(“i”);那么相当于又创建了一个新的对象，然后将对象的地址值赋给str4,虽然str2的值和str4的值是相同的，但是他们依然不是同一个对象了。
   需要注意的是：String str=“i”; 因为String 是final类型的，所以“i”应该是在常量池。
   而new String(“i”);则是新建对象放到堆内存中。

9. .如何将字符串反转？
   使用 StringBuilder 或 StringBuffer 的 reverse 方法，本质都调用了它们的父类 AbstractStringBuilder 的 reverse 方法实现。（JDK1.8）
   不考虑字符串中的字符是否是 Unicode 编码，自己实现。
   递归
   new StringBuilder(str).reverse().toString();

10. String 类的常用方法都有那些？
    indexOf() 返回指定字符得索引
    charAt() 返回指定索引处得字符
    repalce() 字符串替换
    trim() 去除字符串两端的空白
    split() 分割字符串 返回分割后的字符串数组
    getBytes() 返回字符串的byte类型数组
    length() 返回字符串的长度
    toLowerCase() 字符串转小写
    toUpperCase() 字符串转大写
    substring() 截取字符串
    equals() 字符串比较

11. 抽象类必须要有抽象方法吗
    抽象类不一定有抽象方法；但是包含一个抽象方法的类一定是抽象类。（有抽象方法就是抽象类，是抽象类可以没有抽象方法）
    当一个方法为抽象方法时，意味着这个方法必须被子类的方法所重写，否则其子类的该方法仍然是abstract的，而这个子类也必须是抽象的，即声明为abstract。abstract抽象类不能用new实例化对象，abstract方法只允许声明不能实现。如果一个类中含有abstract方法，那么这个类必须用abstract来修饰，当然abstract类也可以没有abstract方法。 一个抽象类里面没有一个抽象方法可用来禁止产生这种类的对象。

12. 普通类和抽象类有哪些区别?
    抽象类不能被实例化
    抽象类可以有抽象方法，抽象方法只需申明，无需实现
    含有抽象方法的类必须申明为抽象类
    抽象的子类必须实现抽象类中所有抽象方法，否则这个子类也是抽象类
    抽象方法不能被声明为静态
    抽象方法不能用private修饰
    抽象方法不能用final修饰

13. 普通类和抽象类有哪些区别?
    他们都不能实例化对象，都可以包含抽象方法，而且抽象方法必须被继承的类全部实现。
    区别：
    1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
    2、抽象类要被子类继承，接口要被类实现。
    3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
    4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
    5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
    6、抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果
    7、抽象类里可以没有抽象方法
    8、如果一个类里有抽象方法，那么这个类只能是抽象类
    9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
    10、接口可继承接口，并可多继承接口，但类只能单根继承。

14. java 中 IO 流分为几种？
    •按照流的流向分，可以分为输入流和输出流；
    •按照操作单元划分，可以划分为字节流和字符流；
    •按照流的角色划分为节点流和处理流。
    

15. BIO、NIO、AIO 有什么区别？
    bio : 一个用户的请求而单独启动一个线程
    nio : 采用的是一种多路复用的机制，利用单线程轮询事件，高效定位就绪的Channel来决定做什么，只是Select阶段是阻塞式的，能有效避免大量连接数时，频繁线程的切换带来的性能或各种问题。
    aio : 暂时没弄懂

16. Files的常用方法都有哪些？
    Files.exists()：检测文件路径是否存在。
    Files.createFile()：创建文件。
    Files.createDirectory()：创建文件夹。
    Files.delete()：删除一个文件或目录。
    Files.copy()：复制文件。
    Files.move()：移动文件。
    Files.size()：查看文件个数。
    Files.read()：读取文件。
    Files.write()：写入文件。

17. Java中public，protected，private以及默认的访问权限作用域？
    
    （1）对于public修饰符，它具有最大的访问权限，可以访问任何一个在CLASSPATH下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。
    （2）对于protected修饰符，它主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西。
    （3）对于default来说，有点的时候也成为friendly（友员），它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问，即使是父类没有用protected修饰的成员也可以。
    （4）对于private来说，它的访问权限仅限于类的内部，是一种封装的体现，例如，大多数的成员变量都是修饰符为private的，它们不希望被其他任何外部的类访问。

java集合

1. java 容器都有哪些？

2. Collection 和 Collections 有什么区别？
   java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
   2、java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。
   1 主要查找和替换，binearySearch 找最大值 max 最小值 min
   2 排序 交换 翻转 sort shuffle （随机化重排）

3. List、Set、Map 之间的区别是什么？

List(列表)
List的元素以线性方式存储，可以存放重复对象，List主要有以下两个实现类：
ArrayList : 长度可变的数组，可以对元素进行随机的访问，向ArrayList中插入与删除元素的速度慢。 JDK8 中ArrayList扩容的实现是通过grow()方法里使用语句newCapacity = oldCapacity + (oldCapacity >> 1)（即1.5倍扩容）计算容量，然后调用Arrays.copyof()方法进行对原数组进行复制。
LinkedList: 采用链表数据结构，插入和删除速度快，但访问速度慢。
Set(集合)
  Set中的对象不按特定(HashCode)的方式排序，并且没有重复对象，Set主要有以下两个实现类：

HashSet： HashSet按照哈希算法来存取集合中的对象，存取速度比较快。当HashSet中的元素个数超过数组大小*loadFactor（默认值为0.75）时，就会进行近似两倍扩容（newCapacity = (oldCapacity << 1) + 1）。
TreeSet ：TreeSet实现了SortedSet接口，能够对集合中的对象进行排序。
Map(映射)
  Map是一种把键对象和值对象映射的集合，它的每一个元素都包含一个键对象和值对象。 Map主要有以下两个实现类：

HashMap：HashMap基于散列表实现，其插入和查询的开销是固定的，可以通过构造器设置容量和负载因子来调整容器的性能。
LinkedHashMap：类似于HashMap，但是迭代遍历它时，取得的顺序是其插入次序，或者是最近最少使用(LRU)的次序。
TreeMap：TreeMap基于红黑树实现。查看时，它们会被排序。TreeMap是唯一的带有subMap()方法的Map，subMap()可以返回一个子树。

4. HashMap 和 Hashtable 有什么区别？
   ConcurrentHashMap融合了hashtable和hashmap二者的优势。
   hashtable是做了同步的，hashmap未考虑同步。所以hashmap在单线程情况下效率较高。hashtable在的多线程情况下，同步操作能保证程序执行的正确性。

5. 如何决定使用 HashMap 还是 TreeMap？
   如果你需要得到一个有序的结果时就应该使用TreeMap（因为HashMap中元素的排列顺序是不固定的）。除此之外，由于HashMap有更好的性能，所以大多不需要排序的时候我们会使用HashMap。

6. hashmap 的底层原理
   HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

7. hashset的底层原理
   HashSet是基于HashMap实现的，HashSet 底层使用HashMap来保存所有元素，
   因此HashSet 的实现比较简单，相关HashSet 的操作，基本上都是直接调用底层HashMap的相关方法来完成，HashSet不允许有重复的值，并且元素是无序的。

8. ArrayList 和 LinkedList 的区别是什么？
   • 数据结构实现：
   ArrayList 是动态数组的数据结构实现，而 LinkedList 是双向链表的数据结构实现。
   • 随机访问效率：
   ArrayList 比 LinkedList 在随机访问的时候效率要高，
   因为 LinkedList 是线性的数据存储方式，所以需要移动指针从前往后依次查找。
   • 增加和删除效率：
   在非首尾的增加和删除操作，LinkedList 要比 ArrayList 效率要高，
   因为 ArrayList 增删操作要影响数组内的其他数据的下标。
   • 综合来说：
   在需要频繁读取集合中的元素时，更推荐使用 ArrayList，
   而在插入和删除操作较多时，更推荐使用 LinkedList。

9. 如何实现数组和 List 之间的转换？
   数组转 List ，使用 JDK 中 java.util.Arrays 工具类的 asList 方法
   List 转数组，使用 List 的toArray方法。无参toArray方法返回Object数组，传入初始化长度的数组对象，返回该对象数组

10. ArrayList 和 Vector 的区别是什么?
    ArrayList，Vector主要区别为以下几点：
    （1）：Vector是线程安全的，源码中有很多的synchronized可以看出，而ArrayList不是。导致Vector效率无法和ArrayList相比；
    （2）：ArrayList和Vector都采用线性连续存储空间，当存储空间不足的时候，ArrayList默认增加为原来的50%，Vector默认增加为原来的一倍；

11. 在 Queue 中 poll()和 remove()有什么区别?
    1、offer()和add()的区别
    add()和offer()都是向队列中添加一个元素。但是如果想在一个满的队列中加入一个新元素，调用 add() 方法就会抛出一个 unchecked 异常，而调用 offer() 方法会返回 false。可以据此在程序中进行有效的判断！
    2、peek()和element()的区别
    peek()和element()都将在不移除的情况下返回队头，但是peek()方法在队列为空时返回null，调用element()方法会抛出NoSuchElementException异常。
    3、poll()和remove()的区别
    poll()和remove()都将移除并且返回对头，但是在poll()在队列为空时返回null，而remove()会抛出NoSuchElementException异常。

12. 哪些集合类是线程安全的？
    一、早期线程安全的集合
    1.Vector
    Vector和ArrayList类似，是长度可变的数组，与ArrayList不同的是，Vector是线程安全的，它给几乎所有的public方法都加上了synchronized关键字。由于加锁导致性能降低，在不需要并发访问同一对象时，这种强制性的同步机制就显得多余，所以现在Vector已被弃用
    2.HashTable
    HashTable和HashMap类似，不同点是HashTable是线程安全的，它给几乎所有public方法都加上了synchronized关键字，还有一个不同点是HashTable的K，V都不能是null，但HashMap可以，它现在也因为性能原因被弃用了
    二、Collections包装方法
    Vector和HashTable被弃用后，它们被ArrayList和HashMap代替，但它们不是线程安全的，所以Collections工具类中提供了相应的包装方法把它们包装成线程安全的集合

List synArrayList = Collections.synchronizedList(new ArrayList());
Set synHashSet = Collections.synchronizedSet(new HashSet());
Map synHashMap = Collections.synchronizedMap(new HashMap());

Collections针对每种集合都声明了一个线程安全的包装类，在原集合的基础上添加了锁对象，集合中的每个方法都通过这个锁对象实现同步
三、java.util.concurrent包中的集合
1.ConcurrentHashMap
ConcurrentHashMap和HashTable都是线程安全的集合，它们的不同主要是加锁粒度上的不同。HashTable的加锁方法是给每个方法加上synchronized关键字，这样锁住的是整个Table对象。而ConcurrentHashMap是更细粒度的加锁
在JDK1.8之前，ConcurrentHashMap加的是分段锁，也就是Segment锁，每个Segment含有整个table的一部分，这样不同分段之间的并发操作就互不影响
JDK1.8对此做了进一步的改进，它取消了Segment字段，直接在table元素上加锁，实现对每一行进行加锁，进一步减小了并发冲突的概率

2.CopyOnWriteArrayList和CopyOnWriteArraySet
它们是加了写锁的ArrayList和ArraySet，锁住的是整个对象，但读操作可以并发执行

除此之外还有ConcurrentSkipListMap、ConcurrentSkipListSet、ConcurrentLinkedQueue、ConcurrentLinkedDeque等，至于为什么没有ConcurrentArrayList，原因是无法设计一个通用的而且可以规避ArrayList的并发瓶颈的线程安全的集合类，只能锁住整个list，这用Collections里的包装类就能办到

13. 迭代器 Iterator 是什么？
    使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。
    使用next()获得序列中的下一个元素。
    使用hasNext()检查序列中是否还有元素。
    使用remove()将迭代器新返回的元素删除。
    注意：iterator()方法是java.lang.Iterable接口,被Collection继承。
    Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

14. Iterator 和 ListIterator 有什么区别？
    ListIterator 继承 Iterator
    ListIterator 比 Iterator多方法
    1） add(E e) 将指定的元素插入列表，插入位置为迭代器当前位置之前
    2） set(E e) 迭代器返回的最后一个元素替换参数e
    3） hasPrevious() 迭代器当前位置，反向遍历集合是否含有元素
    4） previous() 迭代器当前位置，反向遍历集合，下一个元素
    5） previousIndex() 迭代器当前位置，反向遍历集合，返回下一个元素的下标
    6） nextIndex() 迭代器当前位置，返回下一个元素的下标

使用范围不同，Iterator可以迭代所有集合；ListIterator 只能用于List及其子类
ListIterator 有 add 方法，可以向 List 中添加对象；Iterator 不能
ListIterator 有 hasPrevious() 和 previous() 方法，可以实现逆向遍历；Iterator不可以
ListIterator 有 nextIndex() 和previousIndex() 方法，可定位当前索引的位置；Iterator不可以
ListIterator 有 set()方法，可以实现对 List 的修改；Iterator 仅能遍历，不能修改

15. 怎么确保一个集合不能被修改？
    采用Collections包下的unmodifiableMap方法，通过这个方法返回的map,是不可以修改的。他会报 java.lang.UnsupportedOperationException错。

同理：Collections包也提供了对list和set集合的方法。
Collections.unmodifiableList(List)
Collections.unmodifiableSet(Set)

多线程

1. 创建线程有哪几种方式？
   1.继承Thread类实现多线程
   2.覆写Runnable()接口实现多线程，而后同样覆写run().推荐此方式
   3.覆写Callable接口实现多线程（JDK1.5）
   4.FixThreadPool(int n); 固定大小的线程池

2. 说一下 runnable 和 callable 有什么区别？
   1、两者最大的不同点是：实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果；
   2、Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛；

3. 线程有哪些状态？
   
   
   当线程执行 wait()方法之后，线程进入 **WAITING（等待）**状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 TIME_WAITING(超时等待) 状态相当于在等待状态的基础上增加了超时限制，比如通过 sleep（long millis）方法或 wait（long millis）方法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 BLOCKED（阻塞） 状态。线程在执行 Runnable 的run()方法之后将会进入到 TERMINATED（终止） 状态。

4. 创建线程池有哪几种方式？
   a、newFixedThreadPool(nThreads);
   创建固定大小的线程池。创建核心线程数nThreads，最大线程数nThreads的线程池，队列采用阻塞队列LinkedBlockingQueue（默认大. 小Integer.MAX_VALUE）；每提交一个任务就创建一个线程，直到线程数达到nThreads。线程池的大小达到nThreads后，尽管keepAliveTime为0，因为核心线程数等于最大线程数，所以闲置线程不会被回收，线程池数量一直保持在nThreads；如果某个线程因为执. 行异常而结束，那么线程池会补充一个新线程。

这种类型的线程池，适用于处理并发相对比较稳定的任务；
b、 newCachedThreadPool()
创建一个可缓存的线程池。核心线程数0，最大线程数Integer.MAX_VALUE的线程池，队列采用SynchronousQueue；不像ArrayBlockingQueue或LinkedListBlockingQueue，SynchronousQueue内部并没有数据缓存空间；
如果线程池的大小超过了处理任务所需要的线程，60秒过后回收闲置多余线程，当任务数重新增加时，线程池又可以添加新的线程来处理任务。此线程池不会对线程池大小做限制，线程池大小基本依赖于JVM能够创建的最大线程大小。
这种类型的线程池，既可接受吞吐量高的并发，又能在并发小的时候减少创建线程，节省资源，可伸缩性好；
c、newScheduledThreadPool(corePoolSize)
创建一个大小无限的线程池。此线程池支持定时周期性执行任务。
创建核心线程数corePoolSize，最大线程数Integer.MAX_VALUE的线程池，
采用延迟队列DelayedWorkQueue；
这种类型的线程池，主要执行可延迟性的，可定时周期控制的的任务；
d、newSingleThreadExecutor
创建一个单线程的线程池。这个线程池只有一个线程在工作，
也就是相当于单线程串行执行所有任务。
如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。
此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
创建核心线程数1，最大线程数1的线程池，队列采用LinkedBlockingQueue（默认大小Integer.MAX_VALUE）；

5. 线程池都有哪些状态？
   
   2、 SHUTDOWN
   (1) 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。
   (2) 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。
   3、STOP
   (1) 状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
   (2) 状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。
   4、TIDYING
   (1) 状态说明：当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
   (2) 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。
   当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。
   5、 TERMINATED
   (1) 状态说明：线程池彻底终止，就变成TERMINATED状态。
   (2) 状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

6. 线程池中 submit() 和 execute()方法有什么区别
   1、接收的参数不一样 submit 接受callable。 execute 接受runable
   2、submit有返回值，而execute没有
   用到返回值的例子，比如说我有很多个做validation的task，我希望所有的task执行完，然后每个task告诉我它的执行结果，是成功还是失败，如果是失败，原因是什么。
   然后我就可以把所有失败的原因综合起来发给调用者。
   个人觉得cancel execution这个用处不大，很少有需要去取消执行的。而最大的用处应该是第二点。
   3、submit方便Exception处理
   意思就是如果你在你的task里会抛出checked或者unchecked exception，
   而你又希望外面的调用者能够感知这些exception并做出及时的处理，那么就需要用到submit，通过捕获Future.get抛出的异常。

7. 多线程锁的升级原理是什么？
   锁的级别 无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁
   没有优化以前，synchronized是重量级锁（悲观锁），使用 wait 和 notify、notifyAll 来切换线程状态非常消耗系统资源；线程的挂起和唤醒间隔很短暂，这样很浪费资源，影响性能。所以 JVM 对 synchronized 关键字进行了优化，把锁分为 无锁、偏向锁、轻量级锁、重量级锁 状态。
   无锁：没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功，其他修改失败的线程会不断重试直到修改成功。
   偏向锁：对象的代码一直被同一线程执行，不存在多个线程竞争，该线程在后续的执行中自动获取锁，降低获取锁带来的性能开销。偏向锁，指的就是偏向第一个加锁线程，该线程是不会主动释放偏向锁的，只有当其他线程尝试竞争偏向锁才会被释放。
   偏向锁的撤销，需要在某个时间点上没有字节码正在执行时，先暂停拥有偏向锁的线程，然后判断锁对象是否处于被锁定状态。如果线程不处于活动状态，则将对象头设置成无锁状态，并撤销偏向锁；
   轻量级锁：轻量级锁是指当锁是偏向锁的时候，被第二个线程 B 所访问，此时偏向锁就会升级为轻量级锁，线程 B 会通过自旋的形式尝试获取锁，线程不会阻塞，从而提高性能。
   当前只有一个等待线程，则该线程将通过自旋进行等待。但是当自旋超过一定的次数时，轻量级锁便会升级为重量级锁；当一个线程已持有锁，另一个线程在自旋，而此时又有第三个线程来访时，轻量级锁也会升级为重量级锁。
   重量级锁：指当有一个线程获取锁之后，其余所有等待获取该锁的线程都会处于阻塞状态。
   重量级锁通过对象内部的监视器（monitor）实现，而其中 monitor 的本质是依赖于底层操作系统的 Mutex Lock 实现，操作系统实现线程之间的切换需要从用户态切换到内核态，切换成本非常高。

8. 怎么样防止死锁
   死锁发生的四个条件
   互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
   请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
   不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
   环路等待条件：在发生死锁时，必然存在一个进程–资源的环形链。
   防止死锁 破坏上面的四个条件
   所有的资源一次性分配，这样不会再有资源的请求（破坏请求条件）
   只要一个资源获取不到，也不给这个线程分配其他资源（破坏请保持的条件）
   可剥夺条件：某进程获得了某个资源，但是得不到另一个资源，则释放占用的资源
   资源有序分配法：系统的给资源赋予一个编号，按编号递增的获取资源 释放则相反

9. ThreadLocal 是什么？有哪些使用场景？
   这个没有百度到最佳的答案
   使用场景
   日期处理 ： 对非线程安全的实现 进行包装，每个线程使用自己的ThreadLocal 每个线程使用自己的对象
   上下文信息：比如在Web服务中，一个线程都会访问自己的信息
   基本原理
   每个线程都有一个Map，类型为ThreadLocalMap，调用set就是在自己的线程的map设置了一个Entry，key是当前的WeakReference对象，值为Value

10. 说一下 synchronized 底层实现原理？
    在1.6之前，synchronized只有传统的锁机制，因此给开发者留下了synchronized关键字相比于其他同步机制性能不好的印象。在JDK 1.6引入了两种新型锁机制：偏向锁和轻量级锁，它们的引入是为了解决在没有多线程竞争或基本没有竞争的场景下因使用传统锁机制带来的性能开销问题。
    锁的升级： 偏向锁->轻量级锁->重量锁

11. synchronized 和 volatile 的区别是什么？
    相同：
    synchronized 表示只有一个线程可以获取作用对象的锁，执行代码，阻塞其他线程。
    volatile 表示变量在 CPU 的寄存器中是不确定的，必须从主存中读取。保证多线程环境下变量的可见性；禁止指令重排序。
    区别：
    synchronized 可以作用于变量、方法、对象；volatile 只能作用于变量。
    synchronized 可以保证线程间的有序性（猜测是无法保证线程内的有序性，即线程内的代码可能被 CPU 指令重排序）、原子性和可见性；volatile 只保证了可见性和有序性，无法保证原子性。
    synchronized 线程阻塞，volatile 线程不阻塞。

12. synchronized 和 ReentrantLock 区别是什么？
    01 底层实现不同 synchronized是在jvm层面通过monitor来实现，Lock是api层面的调用
    02 是否需要手动释放锁synchronized不需要用户释放锁，当代吗执行完自动释放锁，ReentrantLock的Lock和unlock需要配合try/catch来使用
    03 可否设置超时时间 synchronized不可中断，除非抛出异常或者正常完成 。Reentrantlock可中断 ，可以设置超时时间
    04 加锁是否公平，synchronized非公平锁 Reentrantlock 两者都可以，默认非公平锁
    05 是否可以设置多个条件 synchronized 控制等待和唤醒需要结合加锁对象的 wait() 和 notify()、notifyAll()；ReentrantLock 控制等待和唤醒需要结合 Condition 的 await() 和 signal()、signalAll() 方法

13. 说一下 atomic 的原理？
    JDK Atomic开头的类，是通过 CAS 原理解决并发情况下原子性问题。
    CAS 包含 3 个参数，CAS(V, E, N)。V 表示需要更新的变量，E 表示变量当前期望值，N 表示更新为的值。只有当变量 V 的值等于 E 时，变量 V 的值才会被更新为 N。如果变量 V 的值不等于 E ，说明变量 V 的值已经被更新过，当前线程什么也不做，返回更新失败。
    当多个线程同时使用 CAS 更新一个变量时，只有一个线程可以更新成功，其他都失败。失败的线程不会被挂起，可以继续重试 CAS，也可以放弃操作。
    CAS 操作的原子性是通过 CPU 单条指令完成而保障的。JDK 中是通过 Unsafe 类中的 API 完成的。
    在并发量很高的情况，会有大量 CAS 更新失败，所以需要慎用。

反射

1. 什么是反射？什么Java反射？
   1.在运行时判断任意一个对象所属的类。
   　 2.在运行时构造任意一个类的对象。
   　 3.在运行时判断任意一个类所具有的成员变量和方法。
   　 4.在运行时调用任意一个对象的方法。
2. 什么是 java 序列化？什么情况下需要序列化？
   序列化：将 Java 对象转换成字节流的过程。
   反序列化：将字节流转换成 Java 对象的过程。
   当 Java 对象需要在网络上传输 或者 持久化存储到文件中时，就需要对 Java 对象进行序列化处理。
   序列化的实现：类实现 Serializable 接口，这个接口没有需要实现的方法。实现 Serializable 接口是为了告诉 jvm 这个类的对象可以被序列化。
   对于JVM来说，要进行持久化的类必须要有一个标记，只有持有这个标记JVM才允许类创建的对象可以通过其IO系统转换为字节数据，从而实现持久化，而这个标记就是Serializable接口。而在反序列化的过程中则需要使用serialVersionUID来确定由那个类来加载这个对象，所以我们在实现Serializable接口的时候，一般还会要去尽量显示地定义serialVersionUID
3. 动态代理是什么？有哪些应用？
   动态代理：当想要给实现了某个接口的类中的方法，加一些额外的处理。比如说加日志，加事务等。可以给这个类创建一个代理，故名思议就是创建一个新的类，这个类不仅包含原来类方法的功能，而且还在原来的基础上添加了额外处理的新类。这个代理类并不是定义好的，是动态生成的。具有解耦意义，灵活，扩展性强。
   动态代理实现：首先必须定义一个接口，还要有一个InvocationHandler(将实现接口的类的对象传递给它)处理类。再有一个工具类Proxy(习惯性将其称为代理类，因为调用他的newInstance()可以产生代理对象,其实他只是一个产生代理对象的工具类）。利用到InvocationHandler，拼接代理类源码，将其编译生成代理类的二进制码，利用加载器加载，并将其实例化产生代理对象，最后返回。
   动态代理的应用：Spring的AOP，加事务，加权限，加日志。
4. 怎么实现动态代理？
   jdk： 需要代理类实现InvocationHandler 接口，并且在这个接口类中将要代理的对象注入进去，调用Proxy类的newProxyInstance方法生成代理对象，其中第一个参数是ClassLoader ，第二个是接口类，第三个是代理类。
   cglib： 代理类实现 MethodInterceptor 对方法进行拦截，使用Enhance设置supperClass 和Callback

异常处理

1. Throw和Throws的区别
   Throw：
   作用在方法内，表示抛出具体异常，由方法体内的语句处理。
   具体向外抛出的动作，所以它抛出的是一个异常实体类。若执行了Throw一定是抛出了某种异常。
   Throws：
   作用在方法的声明上，表示如果抛出异常，则由该方法的调用者来进行异常处理。
   主要的声明这个方法会抛出会抛出某种类型的异常，让它的使用者知道捕获异常的类型。
   出现异常是一种可能性，但不一定会发生异常。