2020级应届生-----------Java面试题持续整理ing(for 秋招)

自我介绍

面试官，您好。我是**，来自南京邮电大学，是应届硕士生，所学专业是通信与信息系统，今天面试的岗位是******。在校期间，我的成绩还算不错，本科专业排名前20%，研究生专业107人，排名第三十位。研二的时候主要是跟着自己的导师完成了一个与上海微小卫星研究所合作的项目，是关于低轨卫星频频感知的占用建模，也据此发表两篇论文（一篇今年3月份写的IEEE举办的国际会议论文，会在九月份EI收录，一篇今年6月份写的中文核心期刊论文）。课余时间，我自学了近半年的Java，对Java基础、JVM、常用的数据结构、数据库的增删改查都有一定的了解。暑假期间，是在亚信实习，目前正在参与一个企业后台管理系统的项目开发。最后，很荣幸参加**的这次面试，希望能够顺利通过，谢谢。

1. HashMap如何实现?

HashMap源码：

• //HashMap的主干数组，可以看到就是一个Entry数组，初始值为空数组{}，主干数组的长度一定是2的次幂，至于为什么这么做，后面会有详细分析。

transient Entry[] table = (Entry[]) EMPTY_TABLE;

• Entry是HashMap中的一个静态内部类。代码如下

static class Entry implements Map.Entry {

        final K key;

        V value;

        Entry next;//存储指向下一个Entry的引用，单链表结构

        int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算

//Creates new entry.

        Entry(int h, K k, V v, Entry n) {

            value = v; next = n; key = k; hash = h;

        } 

• HashMap的几个重要参数

transient int size;

//阈值，当table == {}时，该值为初始容量（初始容量默认为16）；当table被填充了，也就是为table分配内存空间后，threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold，后面会详细谈到

int threshold;

//负载因子，代表了table的填充度有多少，默认是0.75

final float loadFactor;

//用于快速失败，由于HashMap非线程安全，在对HashMap进行迭代时，如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），需要抛出异常ConcurrentModificationException

transient int modCount;

• Put操作（在常规构造器中，没有为数组table分配内存空间（有一个入参为指定Map的构造器例外），而是在执行put操作的时候才真正构建table数组）

  public V put(K key, V value) {

       //如果table数组为空数组{}，进行数组填充（为table分配实际内存空间），入参为threshold，此时threshold为initialCapacity 默认是1<<4(24=16)

        if (table == EMPTY_TABLE) {

            inflateTable(threshold);  *********************** ①

        }

       //如果key为null，存储位置为table[0]或table[0]的冲突链上

        if (key == null)

            return putForNullKey(value);

        int hash = hash(key);//对key的hashcode进一步计算，确保散列均匀   *********************** ②

        int i = indexFor(hash, table.length);//获取在table中的实际位置    *********************** ③

        for (Entry e = table[i]; e != null; e = e.next) {

        //如果该对应数据已存在，执行覆盖操作。用新value替换旧value，并返回旧value

            Object k;

            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {

                V oldValue = e.value;

                e.value = value;

                e.recordAccess(this);

                return oldValue; }}

        modCount++;//保证并发访问时，若HashMap内部结构发生变化，快速响应失败

        addEntry(hash, key, value, i);//新增一个entry

        return null;

    }    

• inflateTable(threshold);

inflateTable这个方法用于为主干数组table在内存中分配存储空间，通过roundUpToPowerOf2(toSize)可以确保capacity为大于或等于toSize的最接近toSize的二次幂，比如toSize=13,则capacity=16;to_size=16,capacity=16;to_size=17,capacity=32.

private void inflateTable(int toSize) {

        int capacity = roundUpToPowerOf2(toSize);//capacity一定是2的次幂

        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//此处为threshold赋值，取capacity*loadFactor和MAXIMUM_CAPACITY+1的最小值，capaticy一定不会超过MAXIMUM_CAPACITY，除非loadFactor大于1

        table = new Entry[capacity];

        initHashSeedAsNeeded(capacity);

    }

• hash()/这是一个神奇的函数，用了很多的异或，移位等运算，对key的hashcode进一步进行计算以及二进制位的调整等来保证最终获取的存储位置尽量分布均匀

（hash函数采用各种位运算可能也是为了使得低位更加散列)

final int hash(Object k) {

        int h = hashSeed;

        if (0 != h && k instanceof String) {

            return sun.misc.Hashing.stringHash32((String) k);

        }

        h ^= k.hashCode();

        h ^= (h >>> 20) ^ (h >>> 12);

        return h ^ (h >>> 7) ^ (h >>> 4);

    }

• indexFor进一步处理来获取实际的存储位置  

位运算对计算机来说，性能更高一些（HashMap中有大量位运算）

    static int indexFor(int h, int length) {

        return h & (length-1);

    }

五.get方法

 public V get(Object key) {
　　　　 //如果key为null,则直接去table[0]处去检索即可。

        if (key == null)

            return getForNullKey();

        Entry entry = getEntry(key);

        return null == entry ? null : entry.getValue();

 }

get方法通过key值返回对应value，如果key为null，直接去table[0]处检索。我们再看一下getEntry这个方法

final Entry getEntry(Object key) {

        if (size == 0) {

            return null;

        }

        //通过key的hashcode值计算hash值

        int hash = (key == null) ? 0 : hash(key);

        //indexFor (hash&length-1) 获取最终数组索引，然后遍历链表，通过equals方法比对找出对应记录

        for (Entry e = table[indexFor(hash, table.length)];

             e != null;

             e = e.next) {

            Object k;

            if (e.hash == hash &&

                ((k = e.key) == key || (key != null && key.equals(k))))

                return e;

        }

        return null;

    }   

　　可以看出，get方法的实现相对简单，key(hashcode)-->hash-->indexFor-->最终索引位置，找到对应位置table[i]，再查看是否有链表，遍历链表，通过key的equals方法比对查找对应的记录。

HashMap的实现原理：

简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n)，首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。

hashMap的数组长度一定保持2的次幂？

当发生哈希冲突并且size大于阈值的时候，需要进行数组扩容(resize方法)，扩容时，需要新建一个长度为之前数组2倍的新的数组，然后将当前的Entry数组中的元素全部传输(transfer方法)过去，扩容后的新数组长度为之前的2倍，所以扩容相对来说是个耗资源的操作。

比如16的二进制表示为 10000，那么length-1就是15，二进制为01111，同理扩容后的数组长度为32，二进制表示为100000，length-1为31，二进制表示为011111。从图可以我们也能看到这样会保证低位全为1，而扩容后只有一位差异，也就是多出了最左位的1，这样在通过 h&(length-1)的时候，只要h对应的最左边的那一个差异位为0，就能保证得到的新的数组索引和老数组索引一致(大大减少了之前已经散列良好的老数组的数据位置重新调换)，个人理解。

数组长度保持2的次幂，length-1的低位都为1，会使得获得的数组索引index更加均匀（减少冲突）(对于某个索引index，h的低位只会有一种组合）。

重写equals时也要同时覆盖hashcode同时还要保证通过equals判断相等的两个对象，调用hashCode方法要返回同样的整数值。尽管我们在进行get和put操作的时候，使用的key从逻辑上讲是等值的（通过equals比较是相等的），但由于没有重写hashCode方法，所以put操作时，key(hashcode1)-->hash-->indexFor-->最终索引位置 ，而通过key取出value的时候 key(hashcode1)-->hash-->indexFor-->最终索引位置，由于hashcode1不等于hashcode2，导致没有定位到一个数组位置而返回逻辑上错误的值null

综上：

①利用key的hashCode重新hash计算出当前对象的元素在数组中的下标。

②存储时，如果出现hash值相同的key，此时有两种情况。(1)如果key相同，则覆盖原始值；(2)如果key不同（出现冲突），则将当前的key-value放入链表中。

③获取时，直接找到hash值对应的下标，在进一步判断key是否相同，从而找到对应值。

④理解了以上过程就不难明白HashMap是如何解决hash冲突的问题，核心就是使用了数组的存储方式，然后将冲突的key的对象放入链表中，一旦发现冲突就在链表中做进一步的对比。

2. HashMap是不是线程安全?为什么非线程安全或者说哪里体现了非线程安全?HashMap的读写线程安全吗?

①HashMap 在插入的时候

　　现在假如 A 线程和 B 线程同时进行插入操作，然后计算出了相同的哈希值对应了相同的数组位置，因为此时该位置还没数据，然后对同一个数组位置，两个线程会同时得到现在的头结点，然后 A 写入新的头结点之后，B 也写入新的头结点，那B的写入操作就会覆盖 A 的写入操作造成 A 的写入操作丢失。

②HashMap 在扩容的时候

　　HashMap 有个扩容的操作，这个操作会新生成一个新的容量的数组，然后对原数组的所有键值对重新进行计算和写入新的数组，之后指向新生成的数组。

　　那么问题来了，当多个线程同时进来，检测到总数量超过门限值的时候就会同时调用 resize 操作，各自生成新的数组并 rehash 后赋给该 map 底层的数组，结果最终只有最后一个线程生成的新数组被赋给该 map 底层，其他线程的均会丢失。

③HashMap 在删除数据的时候

　　删除这一块可能会出现两种线程安全问题，第一种是一个线程判断得到了指定的数组位置i并进入了循环，此时，另一个线程也在同样的位置已经删掉了i位置的那个数据了，然后第一个线程那边就没了。但是删除的话，没了倒问题不大。

　　再看另一种情况，当多个线程同时操作同一个数组位置的时候，也都会先取得现在状态下该位置存储的头结点，然后各自去进行计算操作，之后再把结果写会到该数组位置去，其实写回的时候可能其他的线程已经就把这个位置给修改过了，就会覆盖其他线程的修改。

    HashTable 是线程安全的，因为里面的方法使用了 synchronized 进行同步。这些对容器中数据进行操作的方法都被synchronized关键字修饰，这种jdk自带的内置锁可以使得被synchronized关键字修饰的方法体和代码块一次只能被一个线程执行，也就保证了线程安全的问题。

3. 那如何实现线程安全呢?Hashtable和ConcurrentHashMap实现方式?

对于ConcurrentHashMap，简单说说线程安全的原理，其实ConcurrentHashMap实现线程安全也是通过synchronized关键字来控制代码同步来实现的，不同于HashTable的是ConcurrentHashMap在线程同步上更加细分化，它不会像HashTable那样一把包揽的将所有数据都锁住。（ 采用分段锁思路）

比如容器HashMap中存在1000个元素，各个元素都放置到HashMap数组的链表或者红黑数中，最后得到的数组大小可能只有128，ConcurrentHashMap会根据这128个数组，对其分段，比如以16个数组为一段，可以分为8段。在实际获取元素，添加元素时，会根据元素的索引找到该元素所处的段位，然后只将该段位锁住，并不影响其他段位的数据操作。这样如果按照HashTable的效率为基本单位来计算，ConcurrentHashMap在jdk1.7及以前的效率会提高8倍，当然数据量越大，提高的效率将越多。     

4. synchronized锁实现原理?

synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。

synchronized是用java的monitor机制来实现的，就是synchronized代码块或者方法进入及退出的时候会生成monitorenter跟monitorexit两条命令。线程执行到monitorenter时会尝试获取对象所对应的monitor所有权，即尝试获取的对象的锁；monitorexit即为释放锁。
     Synchronized是java语言中的一个重量级的操作，因为java线程是映射到操作系统的原生线程上的，阻塞或者唤醒一条线程，都需要操作系统来帮忙完成，需要从用户态切换到核心态，转换需要消耗很多处理时间，可能比用户代码执行的时间还长。虚拟机对此作了一些优化，比如 自旋锁，避免频繁进入切换到核心态中。

ReentrantLock重入锁

ReentrantLock和 Synchronized类似，一个表现为API 层面上的互斥（lock 和 unlock 方法），一个表现为原生语法层面上的互斥。ReentrantLock 比 Synchronized增加了一些高级功能。

①等待中断：持有锁的线程长期不释放锁（执行时间长的同步块）的时候，正在等待的线程可以选择放弃等待，做其他事情。

②实现公平锁：ReentrantLock 默认是非公平的，通过构造参数可设置为公平锁，Synchronized是非公平的 

③锁可以绑定多个条件。

jdk1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。

5. 实现线程安全的方式有哪些?并介绍一下实现?

①互斥同步

②非阻塞同步

互斥同步是一种悲观的同步策略，非阻塞同步是一种乐观同步策略，基于一种冲突检测的策略，就是先进行操作，如果没有冲突，没有其他线程争抢共享数据，那就操作成功，如果存在冲突，则进行其他补救措施（例如常用的 不断的重试，直到成功为止）

CAS操作（ABA问题）

③无同步方案

可重入代码、线程本地存储 ThreadLocal

6. 为什么要用多线程？

以前我认为多线程的作用就是提升性能。实际上，多线程并不一定能提升性能（甚至还会降低性能）；多线程也不只是为了提升性能。多线程主要有以下的应用场景： 

1、避免阻塞（异步调用） 

单个线程中的程序，是顺序执行的。如果前面的操作发生了阻塞，那么就会影响到后面的操作。这时候可以采用多线程，我感觉就等于是异步调用。这样的例子有很多： 

ajax调用，就是浏览器会启一个新的线程，不阻塞当前页面的正常操作； 

流程在某个环节调用web service，如果是同步调用，则需要等待web service调用结果，可以启动新线程来调用，不影响主流程；

2、避免CPU空转 

以http server为例，如果只用单线程响应HTTP请求，即处理完一条请求，再处理下一条请求的话，CPU会存在大量的闲置时间 

因为处理一条请求，经常涉及到RPC、数据库访问、磁盘IO等操作，这些操作的速度比CPU慢很多，而在等待这些响应的时候，CPU却不能去处理新的请求，因此http server的性能就很差，所以很多web容器，都采用对每个请求创建新线程来响应的方式实现，这样在等待请求A的IO操作的等待时间里，就可以去继续处理请求B，对并发的响应性就好了很多 

3、提升性能 
在满足条件的前提下，多线程确实能提升性能 

第1，任务具有并发性，也就是可以拆分成多个子任务。并不是什么任务都能拆分的，条件还比较苛刻 ：子任务之间不能有先后顺序的依赖，必须是允许并行的 

第2，只有在CPU是性能瓶颈的情况下，多线程才能实现提升性能的目的。比如一段程序，瓶颈在于IO操作，那么把这个程序拆分到2个线程中执行，也是无法提升性能的 

第3，有点像废话，就是需要有多核CPU才行。否则的话，虽然拆分成了多个可并行的子任务，但是没有足够的CPU，还是只有一个CPU在多个线程中切换来切换去，不但达不到提升性能的效果，反而由于增加了额外的开销，而降低了性能。

7.了解线程池不?线程池的基本参数有哪些? 线程池是解决什么问题的?

装有线程的池子，我们可以把要执行的多线程交给线程池来处理，和连接池的概念一样，通过维护一定数量的线程池来达到多个线程的复用。（为了减少在创建和销毁线程上所花的时间以及系统资源的开销）

线程池的优点：

第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

第三：提高线程的可管理性。

线程池的基本参数：

• corePoolSize：线程池的核心大小，也可以理解为最小的线程池大小。
• maximumPoolSize：最大线程池大小。
• keepAliveTime：空余线程存活时间，指的是超过corePoolSize的空余线程达到多长时间才进行销毁。
• unit：销毁时间单位。
• workQueue：存储等待执行线程的工作队列。
• threadFactory：创建线程的工厂，一般用默认即可。
• handler：拒绝策略，当工作队列、线程池全已满时如何拒绝新任务，默认抛出异常。

线程池是为了减少在创建和销毁线程上所花的时间以及系统资源的开销

8. spring框架是干什么用的?

就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明管理的（Spring根据这些配置 内部通过反射去动态的组装对象）。

Spring是一个容器，凡是在容器里的对象才会有Spring所提供的这些服务和功能。内部最核心的就是IOC了，控制反转，采用动态注入（DI），让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射。反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象，和调用对象里的方法的 。

Spring还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象 进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的 模块）从而达到对一个模块扩充的功能。这些都是通过配置类达到的。

8. spring ioc是什么?实现了什么之间的反转? DI? AOP ?

IoC不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

 

DI—Dependency Injection，即“依赖注入”：是组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

谁依赖于谁：当然是应用程序依赖于IoC容器；

为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；

谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；

注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

 

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。

Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。

Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。

Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

Target（目标对象）：织入 Advice 的目标对象.。

Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

9. 说一下数组和链表的区别?它们分别使用于什么场合?

数组和链表是两种基本的数据结构，他们在内存存储上的表现不一样，所以也有各自的特点。

数组

①在内存中，数组是一块连续的区域

②数组需要预留空间

在使用前需要提前申请所占内存的大小，这样不知道需要多大的空间，就预先申请可能会浪费内存空间，即数组空间利用率低 

③.在数组起始位置处，插入数据和删除数据效率低。

插入数据时，待插入位置的的元素和它后面的所有元素都需要向后搬移

删除数据时，待删除位置后面的所有元素都需要向前搬移

④.随机访问效率很高，时间复杂度可以达到O(1)

⑤.数组开辟的空间，在不够使用的时候需要扩容，扩容的话，就会涉及到需要把旧数组中的所有元素向新数组中搬移.

⑥.数组的空间是从栈分配的

链表

1.在内存中，元素的空间可以在任意地方，空间是分散的，不需要连续

2.链表中的元素都会两个属性，一个是元素的值，另一个是指针，此指针标记了下一个元素的地址。每一个数据都会保存下一个数据的内存的地址，通过此地址可以找到下一个数据。

3.查找数据时效率低,时间复杂度为O(N)

因为链表的空间是分散的，所以不具有随机访问性，如要需要访问某个位置的数据，需要从第一个数据开始找起，依次往后遍历，直到找到待查询的位置，故可能在查找某个元素时，时间复杂度达到O(N)

4.空间不需要提前指定大小，是动态申请的，根据需求动态的申请和删除内存空间，扩展方便，故空间的利用率较高

5.任意位置插入元素和删除元素效率较高，时间复杂度为O(1)

6.链表的空间是从堆中分配的

10. hash是解决什么问题的?解决hash冲突的方式有哪些?

哈希函数是指如何对关键字进行编址的规则，这里的关键字的范围很广，可视为无限集，如何保证无限集的原数据在编址的时候不会出现重复呢？保证不了?→哈希冲突！！！

①开放定址法： 
所谓的开放定址法就是一旦发生了冲突，就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到

②再哈希法： 
再哈希法又叫双哈希法，有多个不同的Hash函数，当发生冲突时，使用第二个，第三个，….，等哈希函数计算地址，直到无冲突。虽然不易发生聚集，但是增加了计算时间。

③链地址法： 
链地址法的基本思想是：每个哈希表节点都有一个next指针，多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这个单向 链表连接起来。

数 据 库

操作数据库：

创建数据库： create database dbname

删除数据库： drop database dbname

查看数据库： show databases;

查看详细数据库： show create database 数据库名；

使用数据库： use dbname；

操作表：

创建表： create table tname(

字段名1  数据类型 （解释）  约束条件，

字段名2  数据类型 （解释）  约束条件

) 

约束条件包括以下三条：

UNIQUE  唯一约束

NOT NULL    非空约束，此数据插入不可以为空

PRIMARY KEY    主键约束，用于标识表的记录，不允许为空，可以加快查询速度

查看表：show tables

查看详细表：how create table 表名

修改表名：ALTER TABLE 旧表名 RENAME TO 新表名；

修改字段的数据类型：ALTER TABLE 表名 MODIFY 字段名 新数据类型

修改字段名：ALTER TABLE DBNAME CHANGE 字段名 新字段名 数据类型

增加字段：ALTER TABLE DBNAME ADD 字段名 数据类型 约束条件  （First/after）

删除字段：ALTER TABLE DBNAME DROP 字段名

删除表： drop table tname

增删改查：

插入数据： insert into tname(field1, field2) values(value1, value2)

insert into <已有的新表> <列名> select <原表列名> from <原表名>

删除数据： delete from tname

            delete from <表名> [where <删除条件>]

truncate table <表名>

更新数据： update <表名> set <列名=更新值> [where <更新条件>]

查找数据： select <列名> from <表名> [where <查询条件>] [order by <列名>[asc/desc]]

select * from tname

select i, j, k   from  tname  where f=5

select name as  姓名　from  tname  where  gender='男'

select name from tname where email is null

select name '北京' as 地址 from　 tname

select top 6 name from tname

select * from tname where name like '赵%'

select * from tname where age between 18 and 20

select name from tname where address in ('北京','上海','唐山')

复杂查询：

①使用group by进行分组查询                                                           

select studentID as 学员编号, AVG(score列名) as 平均成绩 from score表名 group by studentID

②使用having子句进行分组筛选

select studentID as 学员编号, AVG from score group by studentID having count(score)>1

③多表联接查询

select t1.name,t2.mark from t1,t2 where a.name=b.name

八大数据结构及其应用场景（数组、栈、链表、树、图、堆、散列表）

1.数组

​数据结构中最基本的一个结构就是线性结构，而线性结构又分为连续存储结构和离散存储结构。连续存储结构其实就是数组。

在程序设计中，为了处理方便， 把具有相同类型的若干变量按有序的形式组织起来。这些按序排列的同类数据元素的集合称为数组。一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。

使用场景

数组在以下三个情形下很有用：

1）数据量较小。

2）数据规模已知。

3）随机访问，修改元素值。

如果插入速度很重要，选择无序数组。如果查找速度很重要，选择有序数组，并使用二分查找。

缺点

1）需要预先知道数据规模

2）插入效率低，因为需要移动大量元素。

2.栈

是只能在某一端插入和删除的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)。

使用场景

1.十进制与其它进制间的转换 125→1111111

2.行编辑器  #退格 @清除

3.平衡符号的判断  {[()()]}

4.中缀表达式转后缀表达式

顺序栈

优点

1）在输入数据量可预知的情形下，可以使用数组实现栈，并且数组实现的栈效率更高，出栈和入栈操作都在数组末尾完成。

缺点

1)如果对数组大小创建不当，可能会产生栈溢出的情况

链栈

优点

1）不会发生栈溢出的情况

2）输入数据量未知时，使用链栈。通过头插法实现入栈操作，头删法实现出栈操作。出栈和入栈均是O(1)。

缺点

1）由于入栈时，首先要创建插入的节点，要向操作系统申请内存，所以链栈没有顺序栈效率高。

3.队列

一种特殊的线性表，它只允许在表的前端(front)进行删除操作，而在表的后端(rear)进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列是按照"先进先出"或"后进后出"的原则组织数据的。队列中没有元素时，称为空队列。

只要涉及到先进先出的设计，即采用了队列的思想。Eg：排队叫号系统（先来先服务） 

如果数据量已知就使用数组实现队列，未知的话就使用链表实现队列。出队和入队均是O(1)。

消息队列

可以把消息队列比作是一个存放消息的容器，当我们需要使用消息的时候可以取出消息供自己使用。消息队列是分布式系统中重要的组件，使用消息队列主要是为了通过异步处理提高系统性能和削峰、降低系统耦合性。目前使用较多的消息队列有ActiveMQ，RabbitMQ，Kafka，RocketMQ。

使用消息队列主要有两点好处：1.通过异步处理提高系统性能（削峰、减少响应所需时间）;2.降低系统耦合性。

通过异步处理提高系统性能（削峰、减少响应所需时间）

如图，在不使用消息队列服务器的时候，用户的请求数据直接写入数据库，在高并发的情况下数据库压力剧增，使得响应速度变慢。但是在使用消息队列之后，用户的请求数据发送给消息队列之后立即 返回，再由消息队列的消费者进程从消息队列中获取数据，异步写入数据库。由于消息队列服务器处理速度快于数据库（消息队列也比数据库有更好的伸缩性），因此响应速度得到大幅改善。

通过以上分析我们可以得出消息队列具有很好的削峰作用的功能——即通过异步处理，将短时间高并发产生的事务消息存储在消息队列中，从而削平高峰期的并发事务。 举例：在电子商务一些秒杀、促销活动中，合理使用消息队列可以有效抵御促销活动刚开始大量订单涌入对系统的冲击。

降低系统耦合性

(2) 降低系统耦合性

消息队列使利用发布-订阅模式工作，消息发送者（生产者）发布消息，一个或多个消息接受者（消费者）订阅消息。 从上图可以看到消息发送者（生产者）和消息接受者（消费者）之间没有直接耦合，消息发送者将消息发送至分布式消息队列即结束对消息的处理，消息接受者从分布式消息队列获取该消息后进行后续处理，并不需要知道该消息从何而来。对新增业务，只要对该类消息感兴趣，即可订阅该消息，对原有系统和业务没有任何影响，从而实现网站业务的可扩展性设计。

另外为了避免消息队列服务器宕机造成消息丢失，会将成功发送到消息队列的消息存储在消息生产者服务器上，等消息真正被消费者服务器处理后才删除消息。在消息队列服务器宕机后，生产者服务器会选择分布式消息队列服务器集群中的其他服务器发布消息。

使用消息队列带来的一些问题

系统可用性降低： 系统可用性在某种程度上降低，为什么这样说呢？在加入MQ之前，你不用考虑消息丢失或者说MQ挂掉等等的情况，但是，引入MQ之后你就需要去考虑了！

系统复杂性提高： 加入MQ之后，你需要保证消息没有被重复消费、处理消息丢失的情况、保证消息传递的顺序性等等问题！

一致性问题： 上面讲了消息队列可以实现异步，消息队列带来的异步确实可以提高系统响应速度。但是，万一消息的真正消费者并没有正确消费消息怎么办？这样就会导致数据不一致的情况了!

4.链表

是一种物理存储单元上非连续、非顺序的存储结构，它既可以表示线性结构，也可以用于表示非线性结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成，结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

解决的问题

链表的出现解决了数组的两个问题：

1）需要预先知道数据规模

2）插入效率低

使用场景

数据库B+树叶子节点就是一个链表结构；hashMap使用链表解决hash冲突等；

1）数据量较小

2）不需要预先知道数据规模

3）适应于频繁的插入操作

缺点

1）有序数组可以通过二分查找方法具有很高的查找效率(O(log n))，而链表只能使用顺序查找，效率低下(O(n))。

5.树

每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树；

二叉树：每个节点最多含有两个子树的树称为二叉树；

完全二叉树：对于一颗二叉树，假设其深度为d（d>1）。除了第d层外，其它各层的节点数目均已达最大值，且第d层所有节点从左向右连续地紧密排列，这样的二叉树被称为完全二叉树；

满二叉树：所有叶节点都在最底层的完全二叉树；

平衡二叉树（AVL树）：当且仅当任何节点的两棵子树的高度差不大于1的二叉树；

红黑树: 是一种自平衡二叉查找树，它是在1972年由鲁道夫·贝尔发明的，他称之为”对称二叉B树”

排序二叉树(二叉查找树)：也称二叉搜索树、有序二叉树；

霍夫曼树：带权路径最短的二叉树称为哈夫曼树或最优二叉树；

B树：一种对读写操作进行优化的自平衡的二叉查找树，能够保持数据有序，拥有多于两个子树。

B+树：数据库索引

1.非叶子结点的每个元素不保存数据，只用来索引，所有数据都保存在叶子节点。

2.所有的中间节点元素都同时存在于子节点，在子节点元素中是最大（或最小）元素。

3.叶子结点本身依关键字的大小自小而大顺序链接（指针）。

1.单一节点存储更多的元素，使得查询的IO次数更少。

2.所有查询都要查找到叶子节点，查询性能稳定。

3.所有叶子节点形成有序链表，便于范围查询。

二叉查找树

解决的问题

1）有序数组具有较高的查找效率(O(log n))，而链表具有较高的插入效率（头插法，O(1)），结合这两种数据结构，创建一种貌似完美的数据结构，也就是二叉查找树。

使用场景

1）数据是随机分布的

2）数据量较大

3）频繁的查找和插入操作（可以提供O(log n)级的查找、插入和删除操作）

缺点

1）如果处理的数据是有序的（升序/降序），那么构造的二叉查找树就会只有左子树（或右子树），也就是退化为链表，查找效率低下(O(log n))。

平衡树

解决的问题

1）针对二叉查找树可能会退化为链表的情况，提出了平衡树，平衡树要求任意节点的左右两个子树的高度差不超过1，避免退化为链表的情况。

使用场景

1）无论数据分布是否随机都可以提供O(log n)级别的查找、插入和删除效率

2）数据量较大

缺点

1）平衡树的实现过于复杂。

6.图

图是由结点的有穷集合V和边的集合E组成。其中，为了与树形结构加以区别，在图结构中常常将结点称为顶点，边是顶点的有序偶对，若两个顶点之间存在一条边，就表示这两个顶点具有相邻关系。

最小生成树——无向连通图的所有生成树中有一棵边的权值总和最小的生成树

拓扑排序 ——由偏序定义得到拓扑有序的操作便是拓扑排序。建立模型是AOV网

关键路径——在AOE-网中有些活动可以并行地进行，所以完成工程的最短时间是从开始点到完成点的最长路径的长度，路径长度最长的路径叫做关键路径(Critical Path)。

最短路径——最短路径问题是图研究中的一个经典算法问题， 旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。

7.堆

在计算机科学中，堆是一种特殊的树形数据结构，每个结点都有一个值。通常我们所说的堆的数据结构，是指二叉堆。堆的特点是根结点的值最小(或最大)，且根结点的两个子树也是一个堆。

①优先级队列

在某一情况下队列的先进先出并不能满足我们的需求，我们需要优先级高的先出队列，这就类似VIP之类的.

②topk问题（构建相反堆找出前k个数） 在大规模数据处理中，经常会遇到的一类问题：在海量数据中找出出现频率最好的前k个数，或者从海量数据中找出最大的前k个数，这类问题通常被称为top K问题。例如，在搜索引擎中，统计搜索最热门的10个查询词；在歌曲库中统计下载最高的前10首歌等。

③堆排序（升序 — 构建大堆 降序 — 构建小堆）
堆排序：先建立一个最大堆。然后将最大堆的a[0]与a[n]交换，然后从堆中去掉这个节点n，通过减少n的值来实现。剩余的节点中，新的根节点可能违背了最大堆的性质，因此需要调用向下调整函数来维护最大堆。

8.散列表（哈希表）

若结构中存在关键字和K相等的记录，则必定在f(K)的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系f为散列函数(Hash function)，按这个思想建立的表为散列表。

解决的问题

同平衡树一样，哈希表也不要求数据分布是否随机，不过哈希表的实现比平衡树要简单得多。

使用场景

1.信息安全领域：

Hash算法 可用作加密算法。 
如文件校验：通过对文件摘要，可以得到文件的“数字指纹”，你下载的任何副本的“数字指纹”只要和官方给出的“数字指纹”一致，那么就可以知道这是未经篡改的。例如著名的MD5 

2.数据结构领域：

Hash算法 通常还可用作快速查找。 根据Hash函数 我们可以实现一种叫做哈希表（Hash Table）的数据结构。这种结构可以实现对数据进行快速的存取。

1）不需要对最大最小值存取。

2）无论数据分布是否随机，理想情况下（无冲突）可以提供O(1)级别的插入、查找和删除效率。

3）数据量较大

3. 数据库的Hash索引。hashMap的hash索引等。

缺点

1）由于是基于数组的，数组（哈希表）创建后难以扩展，使用开放地址法的哈希表在基本被填满时，性能下降的非常严重。

2）不能对最大最小值存取。

1.java容器类（集合类）？

①.Collection是List和Set两个接口的父接口 ：

List在Collection之上增加了"有序" ；Set在Collection之上增加了"唯一"。

而ArrayList是实现List的类，所以他是有序的， 它里边存放的元素在排列上存在一定的先后顺序 ，而且ArrayList是采用数组存放元素 ；另一种List LinkedList采用的则是链表。

HashSet、TreeSet都实现了set接口；hashSet就是hashMap，treeSet默认升序。

②.Collection和Map接口之间的主要区别在于：Collection中存储了一组对象，而Map存储关键字/值对。 
在Map对象中，每一个关键字最多有一个关联的值。 Map不能包括两个相同的键，一个键最多能绑定一个值。null可以作为键，这样的键只有一个；可以有一个或多个键所对应的 值为null。当get()方法返回null值时，即可以表示Map中没有该键，也可以表示该键所对应的值为null。因此，在Map中不能由get()方法来判断Map中是否存在某个键，而应该用containsKey()方法来判断。 

③继承Map的类有：HashMap，HashTable ，TreeMap
HashMap：Map的实现类，缺省情况下是非同步的，可以通过Map Collections.synchronizedMap(Map m)来达到线程同步。线程不安全，所以性能优于HashTable。
HashTable：线程安全的。不允许关键字或值为null。性能较差，已慢慢被弃用。

TreeMap：顺序存储。

当元素的顺序很重要时选用TreeMap，当元素不必以特定的顺序进行存储时，使用HashMap。Hashtable的使用不被推荐，因为HashMap提供了所有类似的功能，并且速度更快。当你需要在多线程环境下使用时，HashMap也可以转换为同步的。

2.做过哪些项目？项目中遇到哪些难点，你是怎样解决的？单点登录系统说一下？分布式缓存的使用场景？

项目描述

3.你实习的时候JDK用的是那个版本，这个版本有什么新的特性？

jdk1.8的一些新特性主要还是简化了代码的写法，减少了部分开发量。新特性包括：

1. 速度更快 – 红黑树 ；
2. 代码更少 – Lambda ；
3. 强大的Stream API – Stream ；
4. 便于并行 – Parallel ；
5. 最大化减少空指针异常 – Optional。

Lambada表达式：带有参数变量的表达式，是一段可以传递的代码，可以被一次或多次执行，是一种精简的字面写法，其实就是把匿名内部类中“一定”要做的工作省略掉，然后由JVM通过推导把简化的表达式还原。

格式：  (parameters参数) -> expression表达式或方法体

需求：对字符串数组按字符串长度排序需求：用Lambda实现多线程

实际上函数式接口的转换是Lambda表达式唯一能做的事情，即lambda必须和Functional Interface配套使用。主要用于替换以前广泛使用的内部匿名类，各种回调比如事件响应器、传入Thread类的Runnable等。

优点：

a.极大的减少代码冗余，同时可读性也好过冗长的匿名内部类。

b.与集合类批处理操作结合，实现内部迭代，并充分利用现代多核CPU进行并行计算。之前集合类的迭代都是外部的，即客户代码。而内部迭代意味着由Java类库来进行迭代，而不是客户代码。

HashMap中的红黑树：

二叉搜索树（中序排列为顺序的，构造二叉搜索树）。缺点：有可能出现单链形式的树。解决方案：AVL树→红黑树。

AVL树：左右子树高度差不超过1，它追求极致的平衡。平衡代价大，使用的很少。

红黑树：红黑树本质上是一种二叉查找树，但它在二叉查找树的基础上额外添加了一个标记（颜色），同时具有一定的规则。这些规则使红黑树保证了一种平衡，插入、删除、查找的最坏时间复杂度都为 O(logn)。

红黑树又是AVL树的一种。红黑树相比AVL树，在检索的时候效率其实差不多，都是通过平衡来二分查找。但对于插入删除等操作效率提高很多。红黑树不像AVL树一样追求绝对的平衡，他它允许局部很少的不完全平衡，这样对于效率影响不大，但省去了很多没有必要的调平衡操作，AVL树调平衡有时候代价较大，所以效率不如红黑树，在现在很多地方都是底层都是红黑树的天下。

*HashMap中链表长度大于8时采取红黑树的结构存储。红黑树，除了添加，效率高于链表结构。

HashMap 中有三个关于红黑树的关键参数:（这些参数的设置都是为了避免频繁转换，以提高效率。）

TREEIFY_THRESHOLD（树化阈值：必须为8）； 树形化 treeifyBin()，塑造红黑树：treeify（）

UNTREEIFY_THRESHOLD（链表还原阈值：至少为6）；

MIN_TREEIFY_CAPACITY（最小树形化容量：不小于4 * TREEIFY_THRESHOLD，设置为64）。

树形化 treeifyBin()→根据哈希表元素个数确定是扩容还是树形化，如果是树形化→①遍历桶中的元素，创建相同个数的树形节点，复制内容，建立起联系；②然后让桶第一个元素指向新建的树头结点，替换桶的链表内容为树形内容。

塑造红黑树：treeify()→将二叉树变为红黑树时，需要保证有序。这里有个双重循环，拿树中的所有节点和当前节点的哈希值进行对比(如果哈希值相等，就对比键，这里不用完全有序），然后根据比较结果确定在树中的位置。

红黑树添加元素 putTreeVal()→HashMap 中往红黑树中添加一个新节点 n 时，有以下操作：

从根节点开始遍历当前红黑树中的元素 p，对比 n 和 p 的哈希值；

如果哈希值相等并且键也相等，就判断为已经有这个元素（这里不清楚为什么不对比值）；

如果哈希值就通过其他信息，比如引用地址来给个大概比较结果，这里可以看到红黑树的比较并不是很准确，注释里也说了，只是保证个相对平衡即可；

最后得到哈希值比较结果后，如果当前节点 p 还没有左孩子或者右孩子时才能插入，否则就进入下一轮循环;

插入元素后还需要进行红黑树例行的平衡调整，还有确保根节点的领先地位。

红黑树中查找元素 getTreeNode()→getNode() 方法就是根据哈希表元素个数与哈希值求模（使用的公式是 (n - 1) &hash）得到 key 所在的桶的头结点，如果头节点恰好是红黑树节点，就调用红黑树节点的 getTreeNode() 方法，否则就遍历链表节点。由于之前添加时已经保证这个树是有序的，因此查找时基本就是折半查找，效率很高。

这里和插入时一样，如果对比节点的哈希值和要查找的哈希值相等，就会判断 key 是否相等，相等就直接返回（也没有判断值哎）；不相等就从子树中递归查找。

树形结构修剪 split()→HashMap 中， resize() 方法的作用就是初始化或者扩容哈希表。当扩容时，如果当前桶中元素结构是红黑树，并且元素个数小于链表还原阈值 UNTREEIFY_THRESHOLD （默认为 6），就会把桶中的树形结构缩小或者直接还原（切分）为链表结构，调用的就是 split()； HashMap 扩容时对红黑树节点的修剪主要分两部分，先分类、再根据元素个数决定是还原成链表还是精简一下元素仍保留红黑树结构。

1.分类

指定位置、指定范围，让指定位置中的元素 （hash & bit) == 0 的，放到 lXXX 树中，不相等的放到 hXXX 树中。

2.根据元素个数决定处理情况

符合要求的元素（即 lXXX 树），在元素个数小于 6 时还原成链表，最后让哈希表中修剪的痛 tab[index] 指向 lXXX 树；在元素个数大于 6 时，还是用红黑树，只不过是修剪了下枝叶；不符合要求的元素（即 hXXX 树）也是一样的操作，只不过最后它是放在了修剪范围外 tab[index + bit]。

总结：

JDK 1.8 以后哈希表的 添加、删除、查找、扩容方法都增加了一种 节点为 TreeNode 的情况：

• 添加时，当桶中链表个数超过 8 时会转换成红黑树；
• 删除、扩容时，如果桶中结构为红黑树，并且树中元素个数太少的话，会进行修剪或者直接还原成链表结构；
• 查找时即使哈希函数不优，大量元素集中在一个桶中，由于有红黑树结构，性能也不会差。

4.G1回收器和其他回收器有什么区别？

G1(Garbage First)垃圾收集器是当今垃圾回收技术最前沿的成果之一。同优秀的CMS垃圾回收器一样，G1也是关注最小时延的垃圾回收器，也同样适合大堆内存的垃圾收集，官方也推荐使用G1来代替选择CMS。G1最大的特点是引入分区的思路，弱化了分代的概念，合理利用垃圾收集各个周期的资源，解决了其他收集器甚至CMS的众多缺陷。

①. Serial + Serial Old：串行收集器是最基本、发展时间最长、久经考验的垃圾收集器，也是client模式下的默认收集器配置。串行收集器采用单线程stop-the-world的方式进行收集。当内存不足时，串行GC设置停顿标识，待所有线程都进入安全点(Safepoint)时，应用线程暂停，串行GC开始工作，采用单线程方式回收空间并整理内存。单线程也意味着复杂度更低、占用内存更少，但同时也意味着不能有效利用多核优势。事实上，串行收集器特别适合堆内存不高、单核甚至双核CPU的场合。

安全点就是指代码中一些特定的位置,当线程运行到这些位置时它的状态是确定的,这样JVM就可以安全的进行一些操作,比如GC. 线程怎么知道什么时候要进入到saftpoint呢,一般有抢占式和主动式两种,常见的做法就是设置一个状态位,让所有线程去检查这个状态,当检测到saftpoint标志时就停下来。 Eg：抛出异常的位置、循环的末尾、方法返回之前、调用某个方法之后。

②Parallel Scavenge + Parallel Old：并行收集器是以关注吞吐量为目标的垃圾收集器，也是server模式下的默认收集器配置，对吞吐量的关注主要体现在年轻代Parallel Scavenge收集器上。多线程、stop-the-world、吞吐量主要指年轻代的Parallel Scavenge收集器，通过两个目标参数-XX:MaxGCPauseMills和-XX:GCTimeRatio，调整新生代空间大小，来降低GC触发的频率。

③ ParNew + CMS + Serial Old：并发标记清除(CMS)是以关注延迟为目标、十分优秀的垃圾回收算法，开启后，年轻代使用STW式的并行收集，老年代回收采用CMS进行垃圾回收，对延迟的关注也主要体现在老年代CMS上。初始标记、并发标记、重新标记、并发清除。其中，初始标记以STW的方式标记所有的根对象；并发标记则同应用线程一起并行，标记出根对象的可达路径；在进行垃圾回收前，CMS再以一个STW进行重新标记，标记那些由mutator线程(指引起数据变化的线程，即应用线程)修改而可能错过的可达对象；最后得到的不可达对象将在并发清除阶段进行回收。值得注意的是，初始标记和重新标记都已优化为多线程执行。CMS非常适合堆内存大、CPU核数多的服务器端应用，也是G1出现之前大型应用的首选收集器。

④G1（Garbage First)收集与以上三组收集器有很大不同：

（1）G1的设计原则是"首先收集尽可能多的垃圾(Garbage First)"。因此，G1并不会等内存耗尽(串行、并行)或者快耗尽(CMS)的时候开始垃圾收集，而是在内部采用了启发式算法，在老年代找出具有高收集收益的分区进行收集。同时G1可以根据用户设置的暂停时间目标自动调整年轻代和总堆大小，暂停目标越短年轻代空间越小、总空间就越大；

（2）G1采用内存分区(Region)的思路，将内存划分为一个个相等的内存分区，回收时则以分区为单位进行回收，存活的对象复制到另一个空闲分区中。由于都是以相等的分区为单位进行操作，因此G1天然就是一种压缩方案(局部压缩)；

（3）G1虽然也是分代收集器，但整个内存分区不存在物理上的年轻代与老年代的区别，也不需要完全独立的survivor堆做复制准备。G1只有逻辑上的分代概念，或者说每个分区都可能随G1的运行在不同代之间前后切换；

（4）G1的收集都是STW的，但年轻代和老年代的收集界限比较模糊，采用了混合(mixed)收集的方式。即每次收集既可能只收集年轻代分区(年轻代收集)，也可能在收集年轻代的同时，包含部分老年代分区(混合收集)，这样即使堆内存很大时，也可以限制收集范围，从而降低停顿。

没有最好的垃圾收集器，也没有万能的垃圾收集器；只有适合具体应用场景的收集器。

5.垃圾回收为什么会停顿？哪些对象可能为GcRoots? 内存泄漏vs内存溢出？

垃圾收集的一个前提是要判断进程中的对象哪些是垃圾内存，哪些不是。怎么判断呢，JVM里面使用了一种叫可达性分析的技术来枚举根节点。一言以蔽之，JVM的内存空间里的若干对象都会有联系，形成树结构，如果一个对象通过寻路，能够找到根节点，那么这个对象就是活的，不能回收，否则就要回收。

在这个可达性分析过程中，是必须要求分析过程中树结构是不变的，也就是一致的。这意味着这个过程中，当前JAVA进程必须暂停，这就是停顿的根本原因。

在Java语言里，可作为GC Roots对象的包括如下几种： a.虚拟机栈(栈中的本地变量表)中的引用的对象 ；b.方法区中的类静态属性引用的对象 ；c.方法区中的常量引用的对象 ；d.本地方法栈中JNI（即一般说的native方法）的引用的对象。（从程序的角度来说就是，找到一段程序运行的整个过程中，始终会存活对象，这些对象的特点是始终会存活，不会死亡。即一些静态变量和常量所引用的对象等。）

①内存溢出是指内存不够用了；（栈深度>虚拟机所允许的深度（栈溢出）；扩展栈时申请不到足够内存（内存溢出））

②内存泄漏是指本该被GC的对象没有被GC回收；（无用对象未设置为null；长生命周期对象引用短生命周期对象）

③内存泄漏（积累）->内存溢出。

6.垃圾回收的过程？垃圾回收分代收集算法？为什么会有两个Survivor区？new一个对象会保存在哪里？

当系统创建一个对象的时候，总是在Eden区操作，当这个区满了，那么就会触发一次YoungGC，也就是年轻代的垃圾回收。一般来说这时候不是所有的对象都没用了，所以就会把还能用的对象复制到From区。 这样整个Eden区就被清理干净了，可以继续创建新的对象，当Eden区再次被用完，就再触发一次YoungGC，然后呢，注意，这个时候跟刚才稍稍有点区别。这次触发YoungGC后，会将Eden区与From区还在被使用的对象复制到To区， 再下一次YoungGC的时候，则是将Eden区与To区中的还在被使用的对象复制到From区。 经过若干次YoungGC后，有些对象在From与To之间来回游荡，这时候From区与To区亮出了底线（阈值），这些家伙要是到现在还没挂掉，对不起，一起滚到（复制）老年代吧。 老年代经过这么几次折腾，也就扛不住了（空间被用完），好，那就来次集体大扫除（Full GC），也就是全量回收，一起滚蛋吧。

我是一个普通的Java对象，我出生在Eden区，在Eden区我还看到和我长的很像的小兄弟，我们在Eden区中玩了挺长时间。有一天Eden区中的人实在是太多了，我就被迫去了Survivor区的“From”区，自从去了Survivor区，我就开始漂了，有时候在Survivor的“From”区，有时候在Survivor的“To”区，居无定所。直到我18岁的时候，爸爸说我成人了，该去社会上闯闯了。于是我就去了年老代那边，年老代里，人很多，并且年龄都挺大的，我在这里也认识了很多人。在年老代里，我生活了20年(每次GC加一岁)，然后被回收。

分代垃圾回收算法来回收垃圾，思想也很简单，就是根据对象的生命周期将内存划分，然后进行分区管理。在Java虚拟机分代垃圾回收机制中，应用程序可用的堆空间可以分为年轻代与老年代，然后呢，年亲代有被分为Eden区，From区与To区。 

年轻代：Minor GC；老年代：Major GC（因为Major GC一般伴随着Minor GC，也可以看做触发了Full GC）。

先看看为什么要有Survivor区：如果没有Survivor，Eden区每进行一次Minor GC，存活的对象就会被送到老年代。老年代很快被填满，触发Major GC（Full GC），Full GC消耗的时间是非常可观的，所以我们需要减少老年代的GC→减少老年代被填满。

再看看为什么有两个Survivor区：刚刚新建的对象在Eden中，一旦Eden满了，触发一次Minor GC，Eden中的存活对象就会被移动到Survivor区。这样继续循环下去，下一次Eden满了的时候，问题来了，此时进行Minor GC，Eden和Survivor各有一些存活对象，如果此时把Eden区的存活对象硬放到Survivor区，很明显这两部分对象所占有的内存是不连续的，也就导致了内存碎片化。所以应该建立两块Survivor区（S0和S1），刚刚新建的对象在Eden中，经历一次Minor GC，Eden中的存活对象就会被移动到第一块S0，Eden被清空；等Eden区再满了，就再触发一次Minor GC，Eden和S0中的存活对象又会被复制送入第二块S1（这个过程非常重要，因为这种复制算法保证了永远有一个survivor space是空的，另一个非空的survivor space无碎片。）。

7.Java内存模型?volatile关键字，使用场景？原子性？先行发生原则？

Java内存模型（JMM）是一种内存规范，它可以屏蔽各种硬件和操作系统的访问差异，从而保证一段Java程序在不同的平台上运行都能得到一样的结果。如何保证？JMM可提供影响并发编程的原子性操作（synchronized和Lock）、可见性操作（volatile、synchronized和Lock）、有序性操作（volatile、synchronized和Lock以及happens-before原则）。

由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。

Volatile关键字可以　1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。2）禁止进行指令重排序（通过添加内存屏障）。Volatile无法保证对变量的操作的原子性（要么都执行，要么都不执行。）。（比如自增操作：包括读取变量的原始值、进行加1操作、写入工作内存。）

通常来说，使用volatile的场景必须具备以下2个条件：1）对变量的写操作不依赖于当前值；2）该变量没有包含在具有其他变量的不变式中。（我的理解就是上面的2个条件需要保证操作是原子性操作，才能保证使用volatile关键字的程序在并发时能够正确执行。）（比如：单列模式的双重检查（double check））

class Singleton{

    private volatile static Singleton instance = null;

    private Singleton() {}

    public static Singleton getInstance() {

        if(instance==null) {

            synchronized (Singleton.class) {

                if(instance==null)

                    instance = new Singleton();}}

        return instance;}}

8.场景题：现在有三个线程，同时start，用什么方法可以保证线程执行的顺序，线程一执行完线程二执行，线程二执行完线程三执行？

一个简单的办法：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁。简单来说，就是确定前一线程已经执行完毕，才可以执行下一线程。（eg.法1：调用Thread.join()，确定Thread线程执行完；法2：CountDownLatch，创建线程类的时候，将上一个计数器和本线程计数器传入。运行前执行上一个计数器.await（前一线程为0才可以执行），再执行本计数器.countDown（本线程计数器减少）。）。

9.你是怎么理解线程安全的？HashMap是线程安全的么？如果多个线程同时修改HashMap时会发生什么情况？

线程安全：当多个线程访问某一个类（对象或方法）时，这个类始终能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。线程安全就是多线程访问时采用加锁机制（如：synchronized。）提供访问保护，当一个线程访问该类的某个数据时，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。

HashMap在多线程情况下，在put的时候，插入的元素超过了容量（由负载因子决定）的范围就会触发扩容操作，就是rehash，这个会重新将原数组的内容重新hash到新的扩容数组中，在多线程的环境下，存在同时其他的元素也在进行put操作，如果hash值相同，可能出现同时在同一数组下用链表表示，造成闭环，导致在get时会出现死循环，所以HashMap是线程不安全的。

10.ConcurrentHashMap底层原理？每个版本的实现上有什么区别？

HashMap线程不安全→Hashtable线程安全，效率低下→ConcurreHashMap（Jdk1.7/Jdk1.8）

ConcurreHashMap 在JDK1.7中采用数据结构是由一个Segment数组和多个HashEntry组成；Segment数组的意义就是将一个大的table分割成多个小的table来进行加锁，也就是锁分离技术，而每一个Segment元素存储的是HashEntry数组+链表，这个和HashMap的数据存储结构一样。

ConcurreHashMap 在JDK1.8的实现已经摒弃了Segment的概念，而是直接用Node数组+链表+红黑树的数据结构来实现，并发控制使用Synchronized和CAS来操作，整个看起来就像是优化过且线程安全的HashMap，虽然在JDK1.8中还能看到Segment的数据结构，但是已经简化了属性，只是为了兼容旧版本。ConcurrentHashMap的数据结构（数组+链表+红黑树），桶中的结构可能是链表，也可能是红黑树，红黑树是为了提高查找效率。

11.静态代理和动态代理的区别？动态代理是怎么实现的？

静态代理： 就是自己编写一个代理类来代理一个具体的类，使使用这个类的客户端不需要知道实现类是什么，怎么做的，而客户端只需知道和使用代理即可，也就是把客户端和具体类进行了解耦合。（典型的代理模式通常有三个角色，这里称之为代理三要素：共同接口：Action，真实对象：RealObject（又称作委托类），代理实例：Proxy）

传统的方式是客户端直接调用真实对象（类）来使用，如果想改变真实对象的属性，必须要在具体的真实对象（类）中进行修改，这样使得客户端和具体类耦合度变高。通过静态代理的方式，可以直接在代理对象中进行修改，使得客户端和具体类的耦合度降低。

虽然静态代理满足了解耦合的需要，但是也有一些缺点。第一，代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。第二，代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。

而且静态代理是由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。

要解决静态代理的不足，出现了动态代理。（动态生成+代理模式，也就是动态代理。）

通过使用动态代理，我们可以通过在运行时，动态生成一个持有RealObject、并实现代理接口的Proxy，同时注入我们相同的扩展逻辑。哪怕你要代理的RealObject是不同的对象，甚至代理不同的方法，都可以动过动态代理，来扩展功能。（使用动态代理，需要将要扩展的功能写在一个InvocationHandler 实现类，在这个Handler中的invoke方法中实现了代理类要扩展的公共功能。）

public class DynamicProxy implements InvocationHandler{

private Object targetObject;

public Object newProxyInstance(Object targetObject){

this.targetObject = targetObject;  //输入 targetObject（真实对象）、Action（接口），返回一个Proxy，即代理模式。

return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),targetObject.getClass().getInterfaces(),this); }

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

       System.out.println("开始代理");

       result = method.invoke(targetObject, args);

       System.out.println("结束代理");

       return null;     }      }

被代理对象targetObject通过参数传递进来，我们通过targetObject.getClass().getClassLoader()获取ClassLoader对象，然后通过targetObject.getClass().getInterfaces()获取它实现的所有接口，然后将targetObject包装到实现了InvocationHandler接口的DynamicProxy对象中。通过newProxyInstance函数我们就获得了一个动态代理对象。

可以看到，我们可以通过DynamicProxy代理不同类型的对象，如果我们把对外的接口都通过动态代理来实现，那么所有的函数调用最终都会经过invoke函数的转发，因此我们就可以在这里做一些自己想做的操作，比如日志系统、事务、拦截器、权限控制等。这也就是AOP(面向切面编程)的基本原理。

动态代理类dynamicproxy中的代码几乎都是通用的，对象只有在main方法中传递真实对象类时才会生成，也就是说只有在程序运行起来后对象才会动态生成。而且也可以生成其他类型的类的实例，提高了代码重用性和解耦合。

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强。并且动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

12.深拷贝和浅拷贝的区别？值传递与引用传递的区别？

对象拷贝(Object Copy)就是将一个对象的属性拷贝到另一个有着相同类类型的对象中去。在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用对象的部分或全部 数据。JavaScript中有两种类型的对象拷贝：浅拷贝(Shallow Copy)、深拷贝(Deep Copy)。

深浅拷贝的区别：深复制和浅复制最根本的区别在于是否是真正获取了一个对象的复制实体，而不是引用

浅拷贝 ——只是拷贝了基本类型的数据，而引用类型数据，复制后也是会发生引用，我们把这种拷贝叫做“浅拷贝”，换句话说，浅复制仅仅是指向被复制的内存地址，如果原地址中对象被改变了，那么浅复制出来的对象也会相应改变。

深拷贝 ——在计算机中开辟了一块新的内存地址用于存放复制的对象。创建一个新的和原始字段的内容相同的字段，是两个一样大的数据段，所以两者的引用是不同的，之后的新对象中的引用型字段发生改变，不会引起原始对象中的字段发生改变。

值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量。

引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。

一般认为,java内的基础类型数据传递都是值传递，java中实例对象的传递是引用传递。

所谓的深拷贝其实就是不破坏原来的数据，也就是为所谓的按值传递。

所谓的浅拷贝其实就是C语言里面的引用，新变量和原变量用的相同地址，也就是所谓的引用传递。

13.说一说设计模式？

一. 单例模式：

实现方式：

a） 将被实现的类的构造方法设计成private的。

b） 添加此类引用的静态成员变量，并为其实例化。

c）  在被实现的类中提供公共的CreateInstance函数，返回实例化的此类,就是b中的静态成员变量。

应用场景：

优点： 

    1.在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化，确保所有的对象都访问一个实例 

    2.单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。 

    3.提供了对唯一实例的受控访问。 

    4.由于在系统内存中只存在一个对象，因此可以 节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。 

    5.允许可变数目的实例。 

    6.避免对共享资源的多重占用。 

缺点： 

    1.不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。 

    2.由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。 

    3.单例类的职责过重，在一定程度上违背了“单一职责原则”。 

    4.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。 

使用注意事项： 

    1.使用时不能用反射模式创建单例，否则会实例化一个新的对象 

    2.使用懒单例模式时注意线程安全问题 

    3.单例模式和懒单例模式构造方法都是私有的，因而是不能被继承的，有些单例模式可以被继承（如登记式模式） 

适用场景： 

    单例模式只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等。如： 

    1.需要频繁实例化然后销毁的对象。 

    2.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。 

    3.有状态的工具类对象。 

    4.频繁访问数据库或文件的对象。 

以下都是单例模式的经典使用场景： 

    1.资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。 

    2.控制资源的情况下，方便资源之间的互相通信。如线程池等。 

应用场景举例： 

    1.外部资源：每台计算机有若干个打印机，但只能有一个PrinterSpooler，以避免两个打印作业同时输出到打印机。内部资源：大多数软件都有一个（或多个）属性文件存放系统配置，这样的系统应该有一个对象管理这些属性文件 

    2. Windows的TaskManager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~ 

    3. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。 

    4. 网站的计数器，一般也是采用单例模式实现，否则难以同步。 

    5. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。 

    6. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。 

    7. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。 

    8. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。 

    9. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。 

10. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例. 

二.代理模式：

一）静态代理

实现方式：

a）为真实类和代理类提供的公共接口或抽象类。（租房）

b）真实类，具体实现逻辑，实现或继承a。（房主向外租房）

c）代理类，实现或继承a，有对b的引用，调用真实类的具体实现。（中介）

d）客户端，调用代理类实现对真实类的调用。（租客租房）

二）动态代理

实现方式：

a）公共的接口（必须是接口，因为Proxy类的newproxyinstance方法的第二参数必须是个接口类型的Class）

b）多个真实类，具体实现的业务逻辑。

c）代理类，实现InvocationHandler接口，提供Object成员变量，和Set方法，便于客户端切换。

d）客户端，获得代理类的实例，为object实例赋值，调用Proxy.newproxyinstance方法在程序运行时生成继承公共接口的实例，调用相应方法，此时方法的执行由代理类实现的Invoke方法接管。

三.简单工厂模式

就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

实现方式:

a)  抽象产品类（也可以是接口）

b)  多个具体的产品类

c)  工厂类（包括创建a的实例的方法）

优点：

工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

缺点：

由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

四.模板方法模式

实现方式：

a)   父类模板类（规定要执行的方法和顺序，只关心方法的定义及顺序，不关心方法实现）

b)  子类实现类（实现a规定要执行的方法，只关心方法实现，不关心调用顺序）

 优点：

        1）封装不变部分，扩展可变部分：把认为不变部分的算法封装到父类实现，可变部分则可以通过继承来实现，很容易扩展。

      2）提取公共部分代码，便于维护。

       3）行为由父类控制，由子类实现。

 缺点：

 模板方法模式颠倒了我们平常的设计习惯：抽象类负责声明最抽象、最一般的事物属性和方法，实现类实现具体的事物属性和方法。在复杂的项目中可能会带来代码阅读的难度。

14.IP首部？TCP首部？TCP为什么是可靠的？三次握手四次挥手？

IP首部：

1、第一个4字节（也就是第一行）：

（1）版本号（Version），4位；用于标识IP协议版本，IPv4是0100，IPv6是0110，也就是二进制的4和6。

（2）首部长度（Internet Header Length），4位；用于标识首部的长度，单位为4字节，所以首部长度最大值为：(2^4 - 1) * 4 = 60字节，但一般只推荐使用20字节的固定长度。

（3）服务类型（Type Of Service），8位；用于标识IP包的优先级，但现在并未使用。

（4）总长度（Total Length），16位；标识IP数据报的总长度，最大为：2^16 -1 = 65535字节。

2、第二个四字节：

（1）标识（Identification），16位；用于标识IP数据报，如果因为数据链路层帧数据段长度限制（也就是MTU，支持的最大传输单元），IP数据报需要进行分片发送，则每个分片的IP数据报标识都是一致的。

（2）标识（Flag），3位，但目前只有2位有意义；最低位为MF，MF=1代表后面还有分片的数据报，MF=0代表当前数据报已是最后的数据报。次低位为DF，DF=1代表不能分片，DF=0代表可以分片。

（3）片偏移（Fragment Offset），13位；代表某个分片在原始数据中的相对位置。

3、第三个四字节：

（1）生存时间（TTL），8位；以前代表IP数据报最大的生存时间，现在标识IP数据报可以经过的路由器数。

（2）协议（Protocol），8位；代表上层传输层协议的类型，1代表ICMP，2代表IGMP，6代表TCP，17代表UDP。

（3）校验和（Header Checksum），16位；用于验证数据完整性，计算方法为，首先将校验和位置零，然后将每16位二进制反码求和即为校验和，最后写入校验和位置。

4、第四个四字节：源IP地址

5、第五个四字节：目的IP地址

TCP首部：

1、第一个4字节：

（1）源端口，16位；发送数据的源进程端口

（2）目的端口，16位；接收数据的进程端口

2、第二个4字节与第三个4字节

（1）序号，32位；代表当前TCP数据段第一个字节占整个字节流的相对位置；

（2）确认号，32位；代表接收端希望接收的数据序号，为上次接收到数据报的序号+1，当ACK标志位为1时才生效。

3、第四个4字节：

（1）数据偏移，4位；实际代表TCP首部长度，最大为60字节。

（2）6个标志位，每个标志位1位；

SYN，为同步标志，用于数据同步；ACK，为确认序号，ACK=1时确认号才有效；FIN，为结束序号，用于发送端提出断开连接；URG，为紧急序号，URG=1是紧急指针有效；PSH，指示接收方立即将数据提交给应用层，而不是等待缓冲区满；RST，重置连接。

（3）窗口值，16位；标识接收方可接受的数据字节数。详解可参看：http://www.cnblogs.com/woaiyy/p/3554182.html

4、第五个4字节

（1）校验和，16位；用于检验数据完整性。

（2）紧急指针，16位；只有当URG标识位为1时，紧急指针才有效。紧急指针的值与序号的相加值为紧急数据的最后一个字节位置。用于发送紧急数据。

TCP的可靠保证，是它的三次握手双向机制，这一机制保证校验了数据，保证了他的可靠性。

1、确认和重传：接收方收到报文就会确认，发送方发送一段时间后没有收到确认就重传。

2、数据校验

3、数据合理分片和排序：

UDP：IP数据报大于1500字节（MTU）.这个时候发送方IP层就需要分片(fragmentation).把数据报分成若干片,使每一片都小于MTU.而接收方IP层则需要进行数据报的重组.这样就会多做许多事情,而更严重的是,由于UDP的特性,当某一片数据传送中丢失时,接收方便无法重组数据报.将导致丢弃整个UDP数据报.TCP则会按MTU合理分片，接收方会缓存未按序到达的数据，重新排序后再交给应用层。

4、流量控制：当接收方来不及处理发送方的数据，能提示发送方降低发送的速率，防止包丢失。

5、拥塞控制：当网络拥塞时，减少数据的发送。

三次握手：                                              四次挥手：

 

15.为什么三次握手？为什么四次挥手？为什么等待2MSL？

【问题1】为什么连接的时候是三次握手，关闭的时候却是四次握手？

答：因为当Server端收到Client端的SYN连接请求报文后，可以直接发送SYN+ACK报文。其中ACK报文是用来应答的，SYN报文是用来同步的。但是关闭连接时，当Server端收到FIN报文时，很可能并不会立即关闭SOCKET，所以只能先回复一个ACK报文，告诉Client端，"你发的FIN报文我收到了"。只有等到我Server端所有的报文都发送完了，我才能发送FIN报文，因此不能一起发送。故需要四步握手。

【问题2】为什么TIME_WAIT状态需要经过2MSL(最大报文段生存时间)才能返回到CLOSE状态？

答：虽然按道理，四个报文都发送完毕，我们可以直接进入CLOSE状态了，但是我们必须假象网络是不可靠的，有可以最后一个ACK丢失。所以TIME_WAIT状态就是用来重发可能丢失的ACK报文。在Client发送出最后的ACK回复，但该ACK可能丢失。Server如果没有收到ACK，将不断重复发送FIN片段。所以Client不能立即关闭，它必须确认Server接收到了该ACK。Client会在发送出ACK之后进入到TIME_WAIT状态。Client会设置一个计时器，等待2MSL的时间。如果在该时间内再次收到FIN，那么Client会重发ACK并再次等待2MSL。所谓的2MSL是两倍的MSL(Maximum Segment Lifetime)。MSL指一个片段在网络中最大的存活时间，2MSL就是一个发送和一个回复所需的最大时间。如果直到2MSL，Client都没有再次收到FIN，那么Client推断ACK已经被成功接收，则结束TCP连接。

【问题3】为什么不能用两次握手进行连接？

答：3次握手完成两个重要的功能，既要双方做好发送数据的准备工作(双方都知道彼此已准备好)，也要允许双方就初始序列号进行协商，这个序列号在握手过程中被发送和确认。

       现在把三次握手改成仅需要两次握手，死锁是可能发生的。作为例子，考虑计算机S和C之间的通信，假定C给S发送一个连接请求分组，S收到了这个分组，并发 送了确认应答分组。按照两次握手的协定，S认为连接已经成功地建立了，可以开始发送数据分组。可是，C在S的应答分组在传输中被丢失的情况下，将不知道S 是否已准备好，不知道S建立什么样的序列号，C甚至怀疑S是否收到自己的连接请求分组。在这种情况下，C认为连接还未建立成功，将忽略S发来的任何数据分 组，只等待连接确认应答分组。而S在发出的分组超时后，重复发送同样的分组。这样就形成了死锁。

【问题4】如果已经建立了连接，但是客户端突然出现故障了怎么办？

TCP还设有一个保活计时器，显然，客户端如果出现故障，服务器不能一直等下去，白白浪费资源。服务器每收到一次客户端的请求后都会重新复位这个计时器，时间通常是设置为2小时，若两小时还没有收到客户端的任何数据，服务器就会发送一个探测报文段，以后每隔75秒钟发送一次。若一连发送10个探测报文仍然没反应，服务器就认为客户端出了故障，接着就关闭连接。

1.描述一下Ping这个操作？

PING (Packet Internet Groper)，因特网包探索器，用于测试网络连接量的程序。Ping发送一个ICMP(Internet Control Messages Protocol）即因特网信报控制协议；回声请求消息给目的地并报告是否收到所希望的ICMP echo （ICMP回声应答）。它所利用的原理是这样的：利用网络上机器IP地址的唯一性，给目标IP地址发送一个数据包，再要求对方返回一个同样大小的数据包来确定两台网络机器是否连接相通，时延是多少。

ping过程：

• 如果在同一个网段。

首先，如果主机A，要去ping主机B，那么主机A，就要封装二层报文，他会先查自己的MAC地址表，如果没有B的MAC地址，就会向外发送一个ARP广播包，首先，交换机会收到这个报文后，交换机有学习MAC地址的功能，所以他会检索自己有没有保存主机B的MAC地址，如果有，就返回给主机A，如果没有，就会向所有端口发送ARP广播，其它主机收到后，发现不是在找自己，就纷纷丢弃了该报文，不去理会。直到主机B收到了报文后，就立即响应，我的MAC地址是多少，同时学到主机A的MAC地址，并按同样的ARP报文格式返回给主机A。

• 如果不在同一个网段。

如果主机A要ping主机C，那么主机A发现主机C的IP和自己不是同一网段，他就去找网关转发，但是他也不知道网关的MAC地址情况下呢？他就会向之前那个步骤一样先发送一个ARP广播，学到网关的MAC地址，再发封装ICMP报文给网关路由器.。

当路由器收到主机A发过来的ICMP报文，发现自己的目的地址是其本身MAC地址，根据目的的IP2.1.1.1，查路由表，发现2.1.1.1/24的路由表项，得到一个出口指针，去掉原来的MAC头部，加上自己的MAC地址向主机C转发。(如果网关也没有主机C的MAC地址，还是要向前面一个步骤一样，ARP广播一下即可相互学到。路由器2端口能学到主机D的MAC地址，主机D也能学到路由器2端口的MAC地址。)

最后，在主机C已学到路由器2端口MAC地址，路由器2端口转发给路由器1端口，路由1端口学到主机A的MAC地址的情况下，他们就不需要再做ARP解析，就将ICMP的回显请求回复过来。

2.现在在哪里实习？实习主要做些什么？

亚信实习；bug调试，网页（layui）编程。

3.说一下Java里面你最感兴趣的一个部分？

面向对象；从刚刚接触java就会学习到这一概念（觉得这个概念很抽象），到后来逐渐的慢慢了解这门语言（逐渐具体）。面向对象是一种新兴的程序设计方法，或者是一种新的程序设计规范，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。Java里很多东西都会体现出面向对象。比如接口…。

4.熟悉Java的哪些框架？用了Spring的哪些东西？Spring最新的版本是多少？

Spring、Spring Boot、Mybatis等（见后面）； Spring 5，Springboot2.0

8、最近一年看过哪些书，印象深刻有哪些，挑一本给我讲下。

《计算机网络》、《深入理解Java虚拟机》、《大话数据结构》、《剑指offer》等

《计算机网络》该书由底向上（物理层、数据链路层、网络层IP、传输层TCP/UDP、应用层）全面介绍了计算网络的体系架构，使我对计算机网络的理解更加具体。

9.说一说你的缺点？

我有的时候做事情有时候比较粗心。有时犯一些低级的错误，比方说有一次买票和导师从南京去上海，到南站取完票发现买成了从上海到南京的票，就很耽误事。不过这也是我的一个优点，因为我做事宏观有余，细节不足，这也培养了我的性格--不容易焦虑，抗压能力强。我初中的时候也是一个非常细节的人，细节到我第二天早上要用哪一只笔去参加中考考试，这平白无故的给我添加了很多焦虑，使得我中考失利。吸取教训后，每次遇到事情，我都会只做一个比较宏观的计划，因为我认为未来只要有个大概就行，做好当下最重要，不要让未来给现在徒添烦劳，增加压力。

10.Servlet是线程安全的么？

Servlet 默认是单例模式，在web 容器中只创建一个实例，所以多个线程同时访问servlet的时候，Servlet是线程不安全的。 要解释为什么Servlet为什么不是线程安全的，需要了解Servlet容器（即Tomcat）使如何响应HTTP请求的。

当Tomcat接收到Client的HTTP请求时，Tomcat从线程池中取出一个线程，之后找到该请求对应的Servlet对象并进行初始化，之后调用service()方法。要注意的是每一个Servlet对象再Tomcat容器中只有一个实例对象，即是单例模式。如果多个HTTP请求请求的是同一个Servlet，那么着两个HTTP请求对应的线程将并发调用Servlet的service()方法。

上图中的Thread1和Thread2调用了同一个Servlet1，所以此时如果Servlet1中定义了实例变量或静态变量，那么可能会发生线程安全问题（因为所有的线程都可能使用这些变量）。多线程并不共享局部变量，所以要尽可能地在servlet中使用局部变量。

11.创建一个对象的详细过程？其中发生了些什么？（类加载）

Java类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证（Verification）、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using) 和 卸载(Unloading)七个阶段。其中准备、验证、解析3个部分统称为连接（Linking），如图所示：

类初始化时机：

1) 遇到new、getstatic、putstatic或invokestatic这四条字节码指令时，如果类没有进行过初始化，则需要先对其进行初始化。2) 使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。3) 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。4) 当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。5) 当使用jdk1.7动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果

对象创建的时机：

1). 使用new关键字创建对象；2). 使用Class类的newInstance方法(反射机制)；3). 使用Constructor类的newInstance方法(反射机制)（可调用私有构造）；4). 使用Clone方法创建对象；5). 使用(反)序列化机制创建对象。

创建一个对象常常需要经历如下几个过程：父类的类构造器() -> 子类的类构造器() -> 父类的成员变量和实例代码块 -> 父类的构造函数 -> 子类的成员变量和实例代码块 -> 子类的构造函数。

虚拟机会保证一个类的类构造器()在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的类构造器()，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。     类构造器()与实例构造器()不同，它不需要程序员进行显式调用，虚拟机会保证在子类类构造器()执行之前，父类的类构造()执行完毕。    在同一个类加载器下，一个类只会被初始化一次，但是一个类可以任意地实例化对象。也就是说，在一个类的生命周期中，类构造器()最多会被虚拟机调用一次，而实例构造器()则会被虚拟机调用多次，只要程序员还在创建对象。

当一个对象被创建时，虚拟机就会为其分配内存来存放对象自己的实例变量及其从父类继承过来的实例变量(即使这些从超类继承过来的实例变量有可能被隐藏也会被分配空间)。在为这些实例变量分配内存的同时，这些实例变量也会被赋予默认值(零值)。在内存分配完成之后，Java虚拟机就会开始对新创建的对象按照程序猿的意志进行初始化。在Java对象初始化过程中，主要涉及三种执行对象初始化的结构，分别是 实例变量初始化、实例代码块初始化 以及 构造函数初始化。

实例化一个类的(创建)对象的过程是一个典型的递归过程: 在准备实例化一个类的对象前，首先准备实例化该类的父类，如果该类的父类还有父类，那么准备实例化该类的父类的父类，依次递归直到递归到Object类。此时，首先实例化Object类，再依次对以下各类进行实例化，直到完成对目标类的实例化。具体而言，在实例化每个类时，都遵循如下顺序：先依次执行实例变量初始化和实例代码块初始化，再执行构造函数初始化。也就是说，编译器会将实例变量初始化和实例代码块初始化相关代码放到类的构造函数中去，并且这些代码会被放在对超类构造函数的调用语句之后，构造函数本身的代码之前。

//父类

class Foo {

    int i = 1;

    Foo() {

        System.out.println(i);             -----------(1)

        int x = getValue();

        System.out.println(x);             -----------(2)

    }

    { i = 2;}

    protected int getValue() {

        return i;}}

//子类

class Bar extends Foo {

    int j = 1;

    Bar() {j = 2;}

    {j = 3;}

    @Override

    protected int getValue() {

        return j;}}

public class ConstructorExample {

    public static void main(String args) {

        Bar bar = new Bar();

        System.out.println(bar.getValue());             -----------(3)

    }}

/* Output:

            2

            0

            2

 */

1、一个实例变量在对象初始化的过程中会被赋值几次？

我们知道，JVM在为一个对象分配完内存之后，会给每一个实例变量赋予默认值，这个时候实例变量被第一次赋值，这个赋值过程是没有办法避免的。如果我们在声明实例变量x的同时对其进行了赋值操作，那么这个时候，这个实例变量就被第二次赋值了。如果我们在实例代码块中，又对变量x做了初始化操作，那么这个时候，这个实例变量就被第三次赋值了。如果我们在构造函数中，也对变量x做了初始化操作，那么这个时候，变量x就被第四次赋值。也就是说，在Java的对象初始化过程中，一个实例变量最多可以被初始化4次。

2、类的初始化过程与类的实例化过程的异同？

类的初始化是指类加载过程中的初始化阶段对类变量按照程序猿的意图进行赋值的过程；而类的实例化是指在类完全加载到内存中后创建对象的过程。

3、假如一个类还未加载到内存中，那么在创建一个该类的实例时，具体过程是怎样的？

我们知道，要想创建一个类的实例，必须先将该类加载到内存并进行初始化，也就是说，类初始化操作是在类实例化操作之前进行的，但并不意味着：只有类初始化操作结束后才能进行类实例化操作。实例初始化不一定要在类初始化结束之后才开始初始化。                               

public class StaticTest {  在类的初始化阶段需要做的是执行类构造器()。类构造器本                   

    public static void main(String[] args) {  质上是编译器收集所有静态语句块和类变量的

        staticFunction();  }                   赋值语句按语句在源码中的顺序合并生成

    static StaticTest st = new StaticTest();             类构造器()。因此，对上述

    static {   //静态代码块                        程序而言，JVM将先执行第一条静

        System.out.println("1");  }                  态变量的赋值语句在实例化上述程

    {       // 实例代码块                        序中的st变量时，实际上是把实例

        System.out.println("2");  }                  初始化嵌入到了静态初始化流程中，

    StaticTest() {    // 实例构造器                  并且在上面的程序中，嵌入到了静

        System.out.println("3");                      态初始化的起始位置。这就导致了

        System.out.println("a=" + a + ",b=" + b);  }    实例初始化完全发生在静态初始化

    public static void staticFunction() {   // 静态方法   之前，当然，这也是导致a为110，

        System.out.println("4");   }                   b为0的原因。（执行顺序如下：）

    int a = 110;    // 实例变量         public class StaticTest {

    static int b = 112;  }   // 静态变量      (){

/* Output:                                   a = 110;    // 实例变量

        2                                   System.out.println("2");  // 实例代码块

        3                                   System.out.println("3"); 

        a=110,b=0                           System.out.println("a=" + a + ",b=" + b); 

        1                                   System.out.println("1");     

        4   */                               }  }

12.Java NIO你了解么？讲一讲你最熟悉的部分？

NIO即New IO，这个库是在JDK1.4中才引入的。NIO和IO有相同的作用和目的，但实现方式不同，NIO主要用到的是块，所以NIO的效率要比IO高很多。在Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。

NIO主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector。传统IO基于字节流和字符流进行操作，而NIO基于Channel和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个线程可以监听多个数据通道。

https://mp.weixin.qq.com/s/fwkKymPOBJODo6sFHYMUHA

（1）、面向流与面向缓冲

     Java IO和NIO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。 Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。

（2）、阻塞与非阻塞IO

     Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

（3）、选择器（Selectors）

     Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

1.七岁一个阶段，说一说每一个阶段对你影响最大的一个人或事？

2.说一下你大学阶段做了些什么？

3.你感觉你前两个面试官怎么样？

4.春招的时候为什么没有去bat实习？

5.你当初准备暑期实习的话，是想学到些什么？现在感觉自己有哪些进步？

1.自我介绍？

2.说一下最能代表你技术水平的项目吧？

3.maven如何进行依赖管理，如何解决依赖冲突？

4.maven的源和插件了解哪些？maven的生命周期？

5.如何保证分布式缓存的一致性？分布式session实现？

6.spring的bean的创建时机？依赖注入的时机？

7.你们的图片时怎么存储的，对应在数据库中时如何保存图片的信息的？

8.单点登录系统的实现？

9.项目中用到的JDK的哪些特性？

10.java8流式迭代的好处？

11.多线程如何在多个CPU上分布？线程调度算法有哪些？

12.线程调度和进程调度的区别？

13.项目中用到了哪些集合类？

14.说一下TreeMap的实现原理？红黑树的性质？红黑树遍历方式有哪些？如果key冲突如何解决？setColor()方法在什么时候用？什么时候会进行旋转和颜色转换？

框架Spring、Spring Boot + MyBatis

1、Spring是什么?

Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。

轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

2、Spring 的优点？

1、非侵入式设计

Spring是一种非侵入式（non-invasive）框架，它可以使应用程序代码对框架的依赖最小化。

 简单说一下我的理解吧。假设大家都想要把用户代码塞到一个框架里。侵入式的做法就是要求用户代码“知道”框架的代码，表现为用户代码需要继承框架提供的类。非侵入式则不需要用户代码引入框架代码的信息，从类的编写者角度来看，察觉不到框架的存在。 使用spring，编写一些业务类的时候不需要继承spring特定的类，通过配置完成依赖注入后就可以使用，此时，spring就没有侵入到我业务类的代码里。 侵入式让用户代码产生对框架的依赖，这些代码不能在框架外使用，不利于代码的复用。

 简单来说，非侵入式就是不继承框架提供的类，而是通过配置完成依赖注入后，就可以使用。

优点：允许所开发出来的应用系统能够在不同的环境中自由移植，不需要修改应用系统中的核心功能实现的代码，利于代码的复用。

2、方便解耦、简化开发

Spring就是一个大工厂，可以将所有对象的创建和依赖关系的维护工作都交给Spring容器的管理，大大的降低了组件之间的耦合性。

3、支持AOP

Spring提供了对AOP的支持，它允许将一些通用任务，如安全、事物、日志等进行集中式处理，从而提高了程序的复用性。

4、支持声明式事务处理

只需要通过配置就可以完成对事物的管理，而无须手动编程。

5、方便程序的测试

Spring提供了对Junit4的支持，可以通过注解方便的测试Spring程序。

6、方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如Struts、Hibernate、MyBatis、Quartz等）的直接支持。

7、降低Jave EE API的使用难度。

Spring对Java EE开发中非常难用的一些API（如JDBC等），都提供了封装，使这些API应用难度大大降低。

3、Spring的AOP理解：

OOP面向对象，允许开发者定义纵向的关系，但并适用于定义横向的关系，导致了大量代码的重复，而不利于各个模块的重用。

AOP，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。可用于权限认证、日志、事务处理。

AOP实现的关键是实现代理模式，将通知通过配置注入目标对象实现动态代理的过程即为AOP。简单理解就是：Spring AOP能帮我们产生动态代理对象，所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。

Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理：

①JDK动态代理只提供接口的代理，不支持类的代理。核心InvocationHandler接口和Proxy类，InvocationHandler 通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；接着，Proxy利用 InvocationHandler动态创建一个符合某一接口的的实例,  生成目标类的代理对象。

 ②如果代理类没有实现 InvocationHandler 接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成指定类的一个子类对象，并覆盖其中特定方法并添加增强代码，从而实现AOP。CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。

静态代理与动态代理区别在于生成AOP代理对象的时机不同，相对来说AspectJ的静态代理方式具有更好的性能，但是AspectJ需要特定的编译器进行处理，而Spring AOP则无需特定的编译器处理。

 InvocationHandler 的 invoke(Object  proxy,Method  method,Object[] args)：proxy是最终生成的代理实例;  method 是被代理目标实例的某个具体方法;  args 是被代理目标实例某个方法的具体入参, 在方法反射调用时使用。

4、Spring的IoC理解：

所谓控制反转就是指：由Spring框架来统一管理创建对象，（本来实例对象是由调用者来创建的，这样耦合性会太强）。只需要在Spring的配置文件中配置相应的bean对象以及相关的属性，让Spring容器来生成并管理类的实例对象。最直观的表达就是，IOC让对象的创建不用去new了，可以由spring自动生成，使用java的反射机制，根据配置文件在运行时动态的去创建对象以及管理对象，并调用对象的方法的。

实现IOC需要DI技术支持。依赖注入（DI）有两种种方式：

1.构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。

2.Setter方法注入：Setter方法注入是容器通过调用无参构造器或无参static工厂方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。

最好的解决方案是用构造器参数实现强制依赖，setter方法实现可选依赖。

5、BeanFactory和ApplicationContext有什么区别？

  BeanFactory和ApplicationContext是Spring的两大核心接口，都可以当做Spring的容器。其中ApplicationContext是BeanFactory的子接口。

（1）BeanFactory：是Spring里面最底层的接口，包含了各种Bean的定义，读取bean配置文档，管理bean的加载、实例化，控制bean的生命周期，维护bean之间的依赖关系。ApplicationContext接口作为BeanFactory的派生，除了提供BeanFactory所具有的功能外，还提供了更完整的框架功能：

①继承MessageSource，因此支持国际化。

②统一的资源文件访问方式。

③提供在监听器中注册bean的事件。

④同时加载多个配置文件。

⑤载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的web层。

（2）①BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化。这样，我们就不能发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常。

        ②ApplicationContext，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误，这样有利于检查所依赖属性是否注入。 ApplicationContext启动后预载入所有的单实例Bean，通过预载入单实例bean ,确保当你需要的时候，你就不用等待，因为它们已经创建好了。

        ③相对于基本的BeanFactory，ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动较慢。

（3）BeanFactory通常以编程的方式被创建，ApplicationContext还能以声明的方式创建，如使用ContextLoader。

（4）BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册。

6、什么是Spring Bean？请解释Spring Bean的生命周期？

Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中 的形式定义。一个Spring Bean 的定义包含容器必知的所有配置元数据，包括如何创建一个bean，它的各种属性、生命周期详情及它的依赖。

这里有三种重要的方法给Spring 容器提供配置元（Bean）数据：1.XML配置文件。2.基于注解的配置。3.基于java的配置（是指允许你在少量的Java注解的帮助下，进行你的大部分Spring配置而非通过XML文件。）

首先说一下Servlet的生命周期：实例化，初始init，接收请求service，销毁destroy；

 Spring上下文中的Bean生命周期也类似，如下：

（1）实例化Bean：

对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。

（2）设置对象属性（依赖注入）：

实例化后的对象被封装在BeanWrapper对象中，紧接着，Spring根据BeanDefinition中的信息 以及 通过BeanWrapper提供的设置属性的接口完成依赖注入。

（3）处理Aware接口：

接着，Spring会检测该对象是否实现了xxxAware接口，并将相关的xxxAware实例注入给Bean：

①如果这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，此处传递的就是Spring配置文件中Bean的id值；

②如果这个Bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()方法，传递的是Spring工厂自身。

③如果这个Bean已经实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文；

（4）BeanPostProcessor：

如果想对Bean进行一些自定义的处理，那么可以让Bean实现了BeanPostProcessor接口，那将会调用postProcessBeforeInitialization(Object obj, String s)方法。由于这个方法是在Bean初始化结束时调用的，所以可以被应用于内存或缓存技术；

（5）InitializingBean 与 init-method：

如果Bean在Spring配置文件中配置了 init-method 属性，则会自动调用其配置的初始化方法。

（6）如果这个Bean实现了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj, String s)方法；

以上几个步骤完成后，Bean就已经被正确创建了，之后就可以使用这个Bean了。

（7）DisposableBean：

当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean这个接口，会调用其实现的destroy()方法；

（8）destroy-method：

最后，如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。

7、什么是基于注解的容器配置? 如何开启注解？ 有哪几种注解？

相对于XML文件，注解型的配置依赖于通过字节码元数据装配组件，而非尖括号的声明。开发者通过在相应的类，方法或属性上使用注解的方式，直接组件类中进行配置，而不是使用xml表述bean的装配关系。注解装配在默认情况下是不开启的，为了使用注解装配，我们必须在Spring配置文件中配置 元素。

@Required 表明bean的属性必须在配置的时候设置，通过一个bean定义的显式的属性值或通过自动装配，若@Required注解的bean属性未被设置，容器将抛出BeanInitializationException。

@Autowired 注解提供了更细粒度的控制，包括在何处以及如何完成自动装配。它的用法和@Required一样，修饰setter方法、构造器、属性或者具有任意名称或多个参数的PN方法。

@Qualifier 当有多个相同类型的bean却只有一个需要自动装配时，将@Qualifier 注解和@Autowire 注解结合使用以消除这种混淆，指定需要装配的确切的bean。

基于注解的方式：

使用@Autowired注解来自动装配指定的bean。在使用@Autowired注解之前需要在Spring配置文件进行配置，。在启动spring IoC时，容器自动装载了一个AutowiredAnnotationBeanPostProcessor后置处理器，当容器扫描到@Autowied、@Resource或@Inject时，就会在IoC容器自动查找需要的bean，并装配给该对象的属性。在使用@Autowired时，首先在容器中查询对应类型的bean：

如果查询结果刚好为一个，就将该bean装配给@Autowired指定的数据；

如果查询的结果不止一个，那么@Autowired会根据名称来查找；

如果上述查找的结果为空，那么会抛出异常。解决方法时，使用required=false。

@Autowired可用于：构造函数、成员变量、Setter方法

注：@Autowired和@Resource之间的区别

(1) @Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在（可以设置它required属性为false）。

(2) @Resource默认是按照名称来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注入。

8、 什么是bean装配? bean的自动装配？有哪些自动装配？以及自动装配的局限性？解释Spring支持的几种bean的作用域。

bean装配是指在Spring 容器中把bean组装到一起，前提是容器需要知道bean的依赖关系，如何通过依赖注入来把它们装配到一起。

Bean 的自动装配是指Spring容器能够自动装配相互合作的bean，这意味着容器不需要和配置，能通过Bean工厂自动处理bean之间的协作。

有五种自动装配的方式，可以用来指导Spring容器用自动装配方式来进行依赖注入。

1.no：默认的方式是不进行自动装配，通过显式设置ref属性来进行装配。

2.byName：通过参数名 自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byname，之后容器试图匹配、装配和该bean的属性具有相同名字的bean。

3.byType:：通过参数类型自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byType，之后容器试图匹配、装配和该bean的属性具有相同类型的bean。如果有多个bean符合条件，则抛出错误。

4.constructor：这个方式类似于byType， 但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。

5.autodetect：先尝试使用constructor来自动装配，如果无法工作，则使用byType方式。

自动装配的局限性是：

重写：你仍需用 和 配置来定义依赖，意味着总要重写自动装配。

基本数据类型：你不能自动装配简单的属性，如基本数据类型，String字符串，和类。

模糊特性：自动装配不如显式装配精确，如果有可能，建议使用显式装配

 

Spring容器中的bean可以分为5个范围：

（1）singleton：默认，每个容器中只有一个bean的实例，单例的模式由BeanFactory自身来维护。

（2）prototype：为每一个bean请求提供一个实例。

（3）request：为每一个网络请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收。

（4）session：与request范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效。

（5）global-session：全局作用域，global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。全局作用域与Servlet中的session作用域效果相同。

9、Spring框架中的单例Beans是线程安全的么？Spring如何处理线程并发问题？

Spring框架并没有对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题需要开发者自行去搞定。但实际上，大部分的Spring bean并没有可变的状态(比如Serview类和DAO类)，所以在某种程度上说Spring的单例bean是线程安全的。如果你的bean有多种状态的话（比如 View Model 对象），就需要自行保证线程安全。最浅显的解决办法就是将多态bean的作用域由“singleton”变更为“prototype”。

 

在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域，因为Spring对一些Bean中非线程安全状态采用ThreadLocal进行处理，解决线程安全问题。

ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。同步机制采用了“时间换空间”的方式，仅提供一份变量，不同的线程在访问前需要获取锁，没获得锁的线程则需要排队。而ThreadLocal采用了“空间换时间”的方式。

ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

10、Spring 框架中都用到了哪些设计模式？

（1）工厂模式：BeanFactory就是简单工厂模式的体现，用来创建对象的实例；

（2）单例模式：Bean默认为单例模式。

（3）代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术；

（4）模板方法：用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。

（5）观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现--ApplicationListener。

11、Spring事务的实现方式和实现原理：

Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。真正的数据库层的事务提交和回滚是通过binlog或者redo log实现的。

（1）Spring事务的种类：

spring支持编程式事务管理和声明式事务管理两种方式：

①编程式事务管理使用TransactionTemplate。

②声明式事务管理建立在AOP之上的。其本质是通过AOP功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

声明式事务最大的优点就是不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明或通过@Transactional注解的方式，便可以将事务规则应用到业务逻辑中。

声明式事务管理要优于编程式事务管理，这正是spring倡导的非侵入式的开发方式，使业务代码不受污染，只要加上注解就可以获得完全的事务支持。唯一不足地方是，最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。

（2）spring的事务传播行为：

spring事务的传播行为说的是，当多个事务同时存在的时候，spring如何处理这些事务的行为。

① PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置。

② PROPAGATION_SUPPORTS：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行。‘

③ PROPAGATION_MANDATORY：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常。

④ PROPAGATION_REQUIRES_NEW：创建新事务，无论当前存不存在事务，都创建新事务。

⑤ PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

⑥ PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

⑦ PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则按REQUIRED属性执行。

（3）Spring中的隔离级别：

① ISOLATION_DEFAULT：这是个 PlatfromTransactionManager 默认的隔离级别，使用数据库默认的事务隔离级别。

② ISOLATION_READ_UNCOMMITTED：读未提交，允许另外一个事务可以看到这个事务未提交的数据。

③ ISOLATION_READ_COMMITTED：读已提交，保证一个事务修改的数据提交后才能被另一事务读取，而且能看到该事务对已有记录的更新。

④ ISOLATION_REPEATABLE_READ：可重复读，保证一个事务修改的数据提交后才能被另一事务读取，但是不能看到该事务对已有记录的更新。

⑤ ISOLATION_SERIALIZABLE：可串行化，一个事务在执行的过程中完全看不到其他事务对数据库所做的更新。

12、spring的事务传播行为？事务特性？事务隔离问题与隔离级别？

spring事务的传播行为说的是，当多个事务同时存在的时候，spring如何处理这些事务的行为。最常用的是：PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置。

事务的特性：ACID特性。

原子性（Atomicity）：要么都执行，要么都不执行；（整体）

一致性（Consistency）：事务完成后，所有的数据必须保持一致；（完整）

隔离性（Isolation）：并发事务中一个事务的影响在该事务提交前对其它事务不可见；（并发）

持久性（Durability）：事务完成后，它对系统的影响是永久的。（结果）

事务中的隔离问题：1.脏读；2.不可重复读；3.幻读。

事务中的隔离级别：1.读未提交；2.读已提交；3.可重复读；4.串行化。

13、解释一下Spring AOP里面的几个名词：

（1）切面（Aspect）：被抽取的公共模块，可能会横切多个对象。 在Spring AOP中，切面可以使用通用类（基于模式的风格） 或者在普通类中以 @AspectJ 注解来实现。

（2）连接点（Join point）：指方法，在Spring AOP中，一个连接点 总是 代表一个方法的执行。 

（3）通知（Advice）：在切面的某个特定的连接点（Join point）上执行的动作。通知有各种类型，其中包括“around”、“before”和“after”等通知。许多AOP框架，包括Spring，都是以拦截器做通知模型， 并维护一个以连接点为中心的拦截器链。

（4）切入点（Pointcut）：切入点是指 我们要对哪些Join point进行拦截的定义。通过切入点表达式，指定拦截的方法，比如指定拦截add*、search*。

（5）引入（Introduction）：（也被称为内部类型声明（inter-type declaration））。声明额外的方法或者某个类型的字段。Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用一个引入来使bean实现 IsModified 接口，以便简化缓存机制。

（6）目标对象（Target Object）： 被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做 被通知（adviced） 对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个 被代理（proxied） 对象。

（7）织入（Weaving）：指把增强应用到目标对象来创建新的代理对象的过程。Spring是在运行时完成织入。

切入点（pointcut）和连接点（join point）匹配的概念是AOP的关键，这使得AOP不同于其它仅仅提供拦截功能的旧技术。 切入点使得定位通知（advice）可独立于OO层次。 例如，一个提供声明式事务管理的around通知可以被应用到一组横跨多个对象中的方法上（例如服务层的所有业务操作）。

14、Spring通知有哪些类型？

（1）前置通知（Before advice）：在某连接点（join point）之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。

（2）返回后通知（After returning advice）：在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。 

（3）抛出异常后通知（After throwing advice）：在方法抛出异常退出时执行的通知。 

（4）后通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。 

（5）环绕通知（Around Advice）：包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。 环绕通知是最常用的一种通知类型。大部分基于拦截的AOP框架，例如Nanning和JBoss4，都只提供环绕通知。 

同一个aspect，不同advice的执行顺序：

①没有异常情况下的执行顺序：                 ②有异常情况下的执行顺序：

around before advice                           around before advice

before advice                                  before advice

target method 执行                            target method 执行

around after advice                             around after advice

after advice                                    after advice

afterReturning                                  afterThrowing:异常发生

java.lang.RuntimeException: 异常发生