精华内容
下载资源
问答
  • 史上最全的中高级JAVA工程师-面试题汇总

    万次阅读 多人点赞 2019-10-15 18:58:32
    史上最全的java工程师面试题汇总,纯个人总结,精准无误。适合中高级JAVA工程师。

    了解博主本人,请阅读《成就一亿技术人,我在CSDN的这九年》
    文档下载地址:
    https://download.csdn.net/download/shengqianfeng/12080443
    在这里插入图片描述

    文章目录

    缓存

    memcache的分布式原理

    memcached 虽然称为 “ 分布式 ” 缓存服务器,但服务器端并没有 “ 分布式 ” 功能。每个服务器都是完全独立和隔离的服务。 memcached 的分布式,则是完全由客户端程序库实现的。 这种分布式是 memcached 的最大特点。

    memcache的内存分配机制

    如何存放数据到memcached缓存中?(memcache内存分配机制)

    Slab Allocator内存分配机制
    预先将内存分配成数个slab仓库,每个仓库再切出不同大小的chunk,去适配收到的数据。多余的只能造成浪费,不可避免。
    增长因子(Grace factor):一般而言观察数据大小的变化规律设置合理的增长因子,默认1.25倍.
    太大容易造成浪费。memcached.exe -m 64 -p 11211 -f 1.25

    如果有100byte的内容要存储,但122大小的仓库的chunk用满了怎么办?
    答:是并不会寻找更大仓库的chunk来存储,而是把122仓库中的旧数据踢掉!

    memcache的惰性失效机制

    1 当某个值过期后并不会从内存删除。(因此status统计时的curr_items有其信息)
    2 如果之前没有get过,将不会自动删除。
    如果(过期失效,没get过一次)又没有一个新值去占用他的位置时,当做空的chunk占用。
    3 当取其值(get)时,判断是否过期:如果过期返回空,且清空。(所以curr_items就减少了)
    即这个过期只是让用户看不到这个数据而已,并没有在过期的瞬间立即从内存删除,这个过程
    称为lazy expirtion,属性失效,好处是节约了cpu和检测的成本,称为“惰性失效机制”

    memcache缓存的无底洞现象

    缓存的无底洞现象
    facebook的工作人员反应,他们在2010年左右,memcacahed节点就已经达到3000个,大约数千G的缓存,他们发现一个问题,memchache连接频率太高导致效率下降,于是加memcache节点,添加后发现连接频率导致的问题仍然没有好转,称之为“无底洞现象”。

    问题分析
    以用户为例:user-133-age,user-133_name,user-133-height…N个key
    当服务器增多,133号用户的信息也被散落在更多的服务器,
    所以同样是访问个人主页,得到相同的个人信息,节点越多,要连接节点越多,对于memcache的连接数并没有随着节点的增多而降低,问题出现。

    事实上
    nosql和传统的rdbms并不是水火不容,两者在某些设计上是可以相互参考的。
    对于nosql的key-value这种存储,key的设计可以参考mysql中表和列的设计。
    比如user表下有age、name、height列,对应的key可以用user:133:age=23,user:133:name=ls,user:133:height=168;

    问题的解决方案
    把某一组key按其共同前缀来分布,比如:user:133:age=23,user:133:name=ls,user:133:height=168;
    在用分布式算法求其节点时,应该以user:133来计算,而不是以user:133:age来计算,这样这三个关于个人信息的key都落在同一个节点上。
    再次访问只需要连接一个节点。问题解决。

    一致性Hash算法的实现原理

    Hash环

    我们把232次方想成一个环,比如钟表上有60个分针点组成一个圆,那么hash环就是由232个点组成的圆。第一个点是0,最后一个点是232-1,我们把这232个点组成的环称之为HASH环。
    在这里插入图片描述

    一致性Hash算法

    将memcached物理机节点通过Hash算法虚拟到一个虚拟闭环上(由0到232构成),key请求的时候通过Hash算法计算出Hash值然后对232取模,定位到环上顺时针方向最接近的虚拟物理节点就是要找到的缓存服务器。

    假设有ABC三台缓存服务器:
    我们使用这三台服务器各自的IP进行hash计算然后对2~32取模即:
               Hash(服务器IP)%2~32
    计算出来的结果是0到2~32-1的一个整数,那么Hash环上必有一个点与之对应。比如:
    在这里插入图片描述
    在这里插入图片描述
    现在缓存服务器已经落到了Hash环上,接下来我们就看我们的数据是怎么放到缓存服务器的?
    我们可以同样对Object取Hash值然后对2~32取模,比如落到了接近A的一个点上:
    在这里插入图片描述
    那么这个数据理应存到A这个缓存服务器节点上
    在这里插入图片描述
    所以,在缓存服务器节点数量不变的情况下,缓存的落点是不会变的。
    在这里插入图片描述
    但是如果B挂掉了呢?
    按照hash且取模的算法,图中3这个Object理应就分配到了C这个节点上去了,所以就会到C上找缓存数据,结果当然是找不到,进而从DB读取数据重新放到了C上。
    在这里插入图片描述
    但是对于编号为1,2的Object还是落到A,编号为4的Object还是落到C,B宕机所影响的仅仅是3这个Object。这就是一致性Hash算法的优点。

    Hash环的倾斜

    前面我们理想化的把三台memcache机器均匀分到了Hash环上:
    在这里插入图片描述
    但是现实情况可能是:
    在这里插入图片描述
    如果Hash环倾斜,即缓存服务器过于集中将会导致大量缓存数据被分配到了同一个服务器上。比如编号1,2,3,4,6的Object都被存到了A,5被存到B,而C上竟然一个数据都没有,这将造成内存空间的浪费。
    为了解决这个问题,一致性Hash算法中使用“虚拟节点”解决。
    在这里插入图片描述

    虚拟节点解决Hash环倾斜

    在这里插入图片描述
    “虚拟节点”是“实际节点”在hash环上的复制品,一个实际节点可能对应多个虚拟节点。这样就可以将ABC三台服务器相对均匀分配到Hash环上,以减少Hash环倾斜的影响,使得缓存被均匀分配到hash环上。

    hash算法平衡性

      平衡性指的是hash的结果尽可能分布到所有的缓存中去,这样可以使得所有的缓存空间都可以得到利用。但是hash算法不保证绝对的平衡性,为了解决这个问题一致性hash引入了“虚拟节点”的概念。虚拟节点”( virtual node )是实际节点在 hash 空间的复制品( replica ),一实际个节点对应了若干个“虚拟节点”,这个对应个数也成为“复制个数”,“虚拟节点”在 hash 空间中以 hash 值排列。“虚拟节点”的hash计算可以采用对应节点的IP地址加数字后缀的方式。
      例如假设 cache A 的 IP 地址为202.168.14.241 。
      引入“虚拟节点”前,计算 cache A 的 hash 值: Hash(“202.168.14.241”);
      引入“虚拟节点”后,计算“虚拟节”点 cache A1 和 cache A2 的 hash 值:
        Hash(“202.168.14.241#1”); // cache A1
        Hash(“202.168.14.241#2”); // cache A2
      这样只要是命中cacheA1和cacheA2节点,就相当于命中了cacheA的缓存。这样平衡性就得到了提高。
      参考:https://www.cnblogs.com/yixiwenwen/p/3580646.html

    memcached与redis的区别

    1 redis做存储,可以持久化,memcache做缓存,数据易丢失。
    2 redis支持多数据类型,memcache存放字符串。
    3 redis服务端仅支持单进程、单线程访问,也就是先来后到的串行模式,避免线程上下文切换,自然也就保证数据操作的原子性。Memcache服务端是支持多线程访问的。
    4 redis虽然是单进程单线程模式,但是redis使用了IO多路复用技术做到一个线程可以处理很多个请求来保证高性能。

    Redis的主从复制

    1 在Slave启动并连接到Master之后,它将主动发送一个SYNC命令给Master。
    2 Master在收到SYNC命令之后,将执行BGSAVE命令执行后台存盘进程(rdb快照), 同时收集所有接收到的修改数据集的命令即写命令到缓冲区,在后台存盘进程执行完毕后,Master将传送整个数据库文件到Slave。
    3 Slave在接收到数据库文件数据之后,将自身内存清空,加载rdb文件到内存中完成一次完全同步。
    4 接着,Master继续将所有已经收集到缓冲区的修改命令,和新的修改命令依次传送给Slaves
    5 Slave将在本地执行这些数据修改命令,从而达到最终的数据同步
    6 之后Master和Slave之间会不断通过异步方式进行命令的同步,从而保证数据的实时同步
    7 如果Master和Slave之间的链接出现断连现象,Slave可以自动重连Master,但是在
    重新连接成功之后:
    2.8之前的redis将进行一次完全同步
    2.8之后进行部分同步,使用的是PSYNC命令
    如下:

    Redis的部分复制过程

    部分同步工作原理如下:
    1):Master为被发送的复制流创建一个内存缓冲区(in-memory backlog),记录最近发送的复制流命令
    2):Master和Slave之间都记录一个复制偏移量(replication offset)和当前Master ID(Master run id)
    3):当出现网络断开,Slave会重新连接,并且向Master请求继续执行原来的复制进程
    4):如果Slave中断网前的MasterID和当前要连的MasterID相同,并且从断开时到当前时刻Slave记录的偏移量所指定的数据仍然保存在Master的复制流缓冲区里面,则Master会向Slave发送缺失的那部分数据,Slave执行后复制工作可以继续执行。
    5):否则Slave就执行完整重同步操作

    Redis的主从复制阻塞模式

    1 同一个Master服务可以同步n多个Slave服务
    2 Slave节点同样可以接受其它Slave节点的连接和同步服务请求,分担Master节点的同步压力
    3 Master是以非阻塞方式为Slave提供同步服务,所以主从复制期间Master一样可以提供读写请求。
    4 Slave同样是以非阻塞的方式完成数据同步,在同步期间,如果有客户端提交查询请求,Redis则返回同步之前的数据
    

    Redis的数据持久化方式

    Rdb快照和aof
    RDB快照:可以配置在n秒内有m个key修改就做自动化快照方式
    AOF:每一个收到的写命令都通过write函数追加到文件中。更安全。

    Redis的高可用部署方式

    哨兵模式

    redis3.0之前的Sentinel哨兵机制,redis3.0之前只能使用一致性hash方式做分布式缓存。哨兵的出现主要是解决了主从复制出现故障时需要人为干预的问题。

    Redis哨兵主要功能

    (1)集群监控:负责监控Redis master和slave进程是否正常工作
    (2)消息通知:如果某个Redis实例有故障,那么哨兵负责发送消息作为报警通知给管理员
    (3)故障转移:如果master node挂掉了,会自动转移到slave node上
    (4)配置中心:如果故障转移发生了,通知client客户端新的master地址

    Redis哨兵的高可用

    原理:当主节点出现故障时,由Redis Sentinel自动完成故障发现和转移,并通知应用方,实现高可用性
    在这里插入图片描述

    哨兵机制建立了多哨兵节点,共同监控数据节点的运行状况。
    同时哨兵节点之间也互相通信,交换对主从节点的监控状况。
    每隔1秒每个哨兵会向整个集群:Master主服务器+Slave从服务器+其他Sentinel(哨兵)进程,发送一次ping命令做一次心跳检测。

    哨兵如何判断redis主从节点是否正常?

    涉及两个新的概念:主观下线和客观下线。

    1. 主观下线:一个哨兵节点判定主节点down掉是主观下线。
    2. 客观下线:只有半数哨兵节点都主观判定主节点down掉,此时多个哨兵节点交换主观判定结果,才会判定主节点客观下线。

    原理:基本上哪个哨兵节点最先判断出这个主节点客观下线,就会在各个哨兵节点中发起投票机制Raft算法(选举算法),最终被投为领导者的哨兵节点完成主从自动化切换的过程。

    集群模式

      redis3.0之后的容错集群方式,无中心结构,每个节点保存数据和整个集群状态,每个节点都和其他所有节点连接,需要至少三个master提供写的功能。
      因此集群中至少应该有奇数个节点,因此至少有三个节点,每个节点至少有一个备份节点,所以redis集群应该至少6个节点。
      每个Master有一个范围的slot槽位用于写数据。

    Redis可以在线扩容吗?zk呢

      Reids的在线扩容,不需要重启服务器,动态的在原始集群中添加新的节点,并分配slot槽。
    但是zk不能在线扩容,需要重启,但是我们可以选择一个一个重启。

    Redis高并发和快速的原因

    1.redis是基于内存的,内存的读写速度非常快;
    2.redis是单线程的,省去了很多上下文切换线程的时间;
    3.redis使用多路复用技术,可以处理并发的连接。
    缺点:无法发挥多核CPU性能
    

    浏览器本地缓存的了解和使用

    资源在浏览器端的本地缓存可以通过Expires和Last-Modified返回头信息进行有效控制。
    

    1)Expires告诉浏览器在该指定过期时间前再次访问同一URL时,直接从本地缓存读取,无需再向服务器发起http请求;
      优点是:浏览器直接读取缓存信息无需发起http请求。
       缺点是:当用户按F5或Ctl+F5刷新页面时浏览器会再次发起http请求。

    2)当服务器返回设置了Last-Modified头,下次发起同一URL的请求时,请求头会自动包含If-Modified-Since头信息,服务器对静态内容会根据该信息跟文件的最后修改时间做比较,如果最后修改时间不大于If-Modified-Since头信息,则返回304:告诉浏览器请求内容未更新可直接使用本地缓存。
    (注意:只对静态内容有效,如js/css/image/html等,不包括动态内容,如JSP)
    优点:无论用户行为如何都有效;
    缺点:仍需向服务器发起一次http请求;

    缓存雪崩

    如果缓存集中在一段时间内失效,发生大量的缓存穿透,所有的查询都落在数据库上,造成了缓存雪崩。

    解决办法:
    没有完美的解决方案,可以通过随机算法让失效时间随机分布,避免同一时刻失效。

    缓存穿透

    访问一个不存在的key,缓存不起作用,请求会穿透到DB,可能DB也没查到,流量大时DB会挂掉。

    解决办法:
    1.采用布隆过滤器,使用一个足够大的bitmap,用于存储可能访问的key,不存在的key直接被过滤;
    2访问key未在DB查询到值,也将空值写进缓存,但可以设置较短过期时间。

    HashMap

    HashMap的Hash碰撞

    在这里插入图片描述
      Hash值冲突问题是Hash表存储模型需要解决的一个问题。通常有两种方法:
      将相同Hash值的Entry对象组织成一个链表放置在hash值对应的槽位。HashMap采用的是链表法,且是单向链表(通过head元素就可以操作后续所有元素,对链表而言,新加入的节点会从头节点加入。)
    核心源码:

    private void addEntry(int hash, K key, V value, int bucketIndex) {  
        Entry<K,V> e = table[bucketIndex];  
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  
        if (size++ >= threshold)  
            resize(2 * table.length);  
    }
    

    以上代码说明:
    系统总是将新添加的 Entry 对象放入 table 数组的 bucketIndex 索引处。
    1 如果 bucketIndex 索引处已经有了一个 Entry 对象,那新添加的 Entry 对象指向原有的 Entry 对象
    (产生一个 Entry 链)
    2 如果 bucketIndex 索引处没有 Entry 对象,也就是上面程序代码的 e 变量是 null,也就是新放入的
    Entry 对象指向 null,也就是没有产生 Entry 链。
    HashMap里面没有出现hash冲突时,没有形成单链表时,hashmap查找元素很快,get()方法能够直接定位到元素,
    但是出现单链表后,单个bucket 里存储的不是一个 Entry,而是一个 Entry 链,系统只能必须按顺序遍历每个
    Entry,直到找到想搜索的 Entry 为止——如果恰好要搜索的 Entry 位于该 Entry 链的最末端(该 Entry 是最早
    放入该 bucket 中),那系统必须循环到最后才能找到该元素。

    HashMap的get和put原理

    PUT原理
    当调用HashMap的put方法传递key和value时,先调用key的hashcode方法。
    通过key的Hash值来找到Bucket----‘桶’的位置,然后迭代这个位置的Entry列表
    判断是否存在key的hashcode和equals完全相同的key,如果完全相同则覆盖value,
    否则插入到entry链的头部。

    HashMap在put时的Entry链形成的场景

    当程序试图将一个key-value对放入HashMap中时,程序首先根据该 key 的 hashCode() 返回值决定该 Entry 的存储位置:
    如果这两个 Entry 的 key 的 hashCode() 返回值相同,那它们的存储位置相同。
    如果这两个 Entry 的 key 通过 equals 比较返回 true,新添加 Entry 的 value 将覆盖集合中原有 Entry 的 value,但key不会覆盖。
    

    如果这两个 Entry 的 key 通过 equals 比较返回 false,新添加的 Entry 将与集合中原有 Entry 形成 Entry 链,而且新添加的 Entry 位于 Entry 链的头部

    GET原理
    根据该 key 的 hashCode 值计算它的 hash 码,遍历并循环取出 Entry 数组中指定索引处的Entry值,如果该 Entry 的 key 与被搜索 key 相同 ,且Enrty的hash值跟key的hash码相同,然后看是否是Entry链,如果是则迭代这个位置的Entry列表,判断是否存在key的hashcode和equals完全相同的key,如果完全相同则获取value。

    HashMap的rehash

      HashMap初始容量大小为16,一般来说,当有数据要插入时,都会检查容量有没有超过设定的thredhold,如果超过,需要增大Hash表的尺寸,但是这样一来,整个Hash表里的元素都需要被重算一遍。这叫rehash,这个成本相当的大

    HashMap的线程不安全问题

      比如put操作时,有两个线程A和B,首先A希望插入一个key-value对到HashMap中,首先计算记录所要落到的桶的索引BucketIndex坐标,然后获取到该桶里面的Entry链表header头结点,此时线程A的时间片用完了,而此时线程B被调度得以执行,和线程A一样执行,只不过线程B成功将记录插到了桶里面,假设线程A插入的记录计算出来的桶索引和线程B要插入的记录计算出来的桶索引是一样的,那么当线程B成功插入之后,线程A再次被调度运行时,它依然持有过期的链表头但是它对此一无所知,以至于它认为它应该这样做,如此一来就覆盖了线程B插入的记录,这样线程B插入的记录就凭空消失了,造成了数据不一致的行为。
    参考:https://www.cnblogs.com/qiumingcheng/p/5259892.html
    另一个不安全的体现是扩容操作可能由于resize而导致死循环。
    参考:https://www.zhihu.com/question/28516433

    在这里插入图片描述

    HashMap和Hashtable的区别

    相同点
    1 都实现了Map接口
    2 Hashtable和HashMap采用的hash/rehash算法都大概一样,所以性能不会有很大的差异

    不同点
    1 hashMap允许NULL作为key和value,而hashtable不允许
    2 hashMap线程不安全,Hashtable线程安全
    3 hashMap速度快于hashtable
    4 HashMap 把 Hashtable的contains方法去掉了,改成containsvalue和containsKey,避免引起误会
    5 Hashtable是基于陈旧的Dictionary类的,HashMap是Java 1.2引进的Map接口的一个实现

    为什么collection没有实现clonable接口

    Collection接口有很多不同的集合实现形式,而clonable只对具体的对象有意义。

    为什map没有实现collection接口

    Set 和List 都继承了Conllection,Map没有继承于Collection接口,Map提供的是key-Value的映射,而Collection代表一组对象。

    Map接口的实现有哪些,区别是什么

    HashMap,LinkedHashMap,Hashtable,TreeMap。

    LinkedHashMap 是HashMap的一个子类,保存了记录的插入顺序
    Hashtable和HashMap类似,它继承自Dictionary类,不同的是它不允许键或值为空。
    TreeMap实现SortMap接口,能够把它保存的记录根据键排序,默认是按键值的升序排序,也可以指定排序的比较器

    线程池

    Executors框架的四种线程池及拒绝策略

    四种线程池

    ExecutorService executorService =
    固定大小线程池

    Executors.newFixedThreadPool(60);
    设置固定值会造成高并发线程排队等待空闲线程,尤其是当读取大数据量时线程处理时间长而不释放线程,导致无法创建新线程。

    可缓存线程池
    Executors.newCachedThreadPool();
    线程池无限大,而系统资源(内存等)有限,会导致机器内存溢出OOM。

    定长且可定时、周期线程池
    Executors.newScheduledThreadPool(5);

    单线程线程池
    Executors.newSingledThreadPool();

    /* 自定义线程池。
    		 * 构造参数:
    		 * public ThreadPoolExecutor(
    			 * int corePoolSize,--当前线程池核心线程数
    			 * int maximumPoolSize,--当前线程池最大线程数
    			 * long keepAliveTime,--保持活着的空间时间
    			 * TimeUnit unit,--时间单位
    			 * BlockingQueue<Runnable> workQueue,--排队等待的自定义队列
    			 * ThreadFactoty threadFactory,
    			 * RejectedExecutionHandler handler--队列满以后,其他任务被拒绝执行的方法
    		 * ){.........}
    

    在使用有界队列时,若有新的任务需要执行,

    • 若线程池实际线程数小于corePoolSize,则优先创建线程,
    • 若大于corePoolSize,则会将任务加入队列,
    • 若队列已满,则在总线程数不大于maximumPoolSize的前提下,创建新的线程,
    • 若线程数大于maximumPoolSize,则执行拒绝策略。或其他自定义方式。

    JDK拒绝策略

    • AbortPolicy:默认,直接抛出异常,系统正常工作。
    • DiscardOldestPolicy:丢弃最老的一个请求,尝试再次提交当前任务。
    • CallerRunsPolicy:只要线程池未关闭,该策略直接在调用者线程中,运行当前被丢弃的任务。用线程池中的线程执行,而是交给调用方来执行, 如果添加到线程池失败,那么主线程会自己去执行该任务,不会等待线程池中的线程去执行
    new ThreadPoolExecutor(   
       2, 3, 30, TimeUnit.SECONDS,    
        new SynchronousQueue<Runnable>(),    
        new RecorderThreadFactory("CookieRecorderPool"),    
         new ThreadPoolExecutor.CallerRunsPolicy());  
    
    • DiscardPolicy:丢弃无法处理的任务,不给予任何处理。
    • 自定义拒绝策略
      如果需要自定义策略,可以实现RejectedExecutionHandler接口。

    Reactor模式

    参考:https://www.cnblogs.com/duanxz/p/3696849.html

    Reactor单线程模型

    在这里插入图片描述
    在这里插入图片描述
    一个Acceptor线程,监听Accept事件,负责接收客户端的连接SocketChannel,SocketChannel注册到Selector上并关心可读可写事件。
    一个Reactor线程,负责轮训selector,将selector注册的就绪事件的key读取出来,拿出attach任务Handler根据事件类型分别去执行读写等。

    单线程模型的瓶颈
    比如:拿一个客户端来说,进行多次请求,如果Handler中数据读出来后处理的速度比较慢(非IO操作:解码-计算-编码-返回)会造成客户端的请求被积压,导致响应变慢!
    所以引入Reactor多线程模型!

    Reactor多线程模型

    在这里插入图片描述
    在这里插入图片描述

    Reactor多线程就是把Handler中的IO操作,非IO操作分开。
    操作IO的线程称为IO线程,操作非IO的线程叫做工作线程
    客户端的请求(IO操作:读取出来的数据)可以直接放进工作线程池(非IO操作:解码-计算-编码-返回)中,这样异步处理,客户端发送的请求就得到返回了不会一直阻塞在Handler中。
    但是当用户进一步增加的时候,Reactor线程又会出现瓶颈,因为Reactor中既有IO操作,又要响应连接请求。为了分担Reactor的负担,所以引入了主从Reactor模型!

    主从Reactor模型

    在这里插入图片描述
    在这里插入图片描述
      主Reactor用于响应连接请求,从Reactor用于处理IO操作请求!
      特点是:服务端用于接收客户端连接的不再是1个单独的NIO线程(Acceptor线程),而是一个独立的NIO线程池。
      Acceptor线程池接收到客户端TCP连接请求处理完成后(可能包含接入认证等),将新创建的SocketChannel注册到I/O线程池(sub reactor线程池)的某个I/O线程上,由它负责SocketChannel的读写和编解码工作。
      Acceptor线程池只用于客户端的登录、握手和安全认证,一旦链路建立成功,就将链路注册到后端subReactor线程池的I/O线程上,有I/O线程负责后续的I/O操作。
      第三种模型比起第二种模型,是将Reactor分成两部分,mainReactor负责监听server socket,accept新连接,并将建立的socket分派给subReactor。subReactor负责多路分离已连接的socket,读写网 络数据,对业务处理功能,其扔给worker线程池完成。通常,subReactor个数上可与CPU个数等同。

    JVM

    Object的内存布局

    在这里插入图片描述

    方法区卸载Class的条件

    1 该类所有的实例已经被回收
    2 加载该类的ClassLoader已经被回收
    4该类对应的java.lang.Class对象没有任何地方被引用

    Ps:方法区除了回收无用class,也回收废弃常量,即没有被引用常量

    可以作为GC Roots的对象包括哪些

    虚拟机栈(栈帧中的局部变量表)中引用的变量
    方法区中类静态属性引用的对象
    方法区中常量引用的对象
    本地方法栈中JNI引用的变量

    JVM运行时内存模型

    方法区、堆、虚拟机栈、本地方法栈、程序计数器

    Netty的ByteBuffer的引用计数器机制

    从netty的4.x版本开始,netty使用引用计数机制进行部分对象的管理,通过该机制netty可以很好的实现自己的共享资源池。
    如果应用需要一个资源,可以从netty自己的共享资源池中获取,新获取的资源对象的引用计数被初始化为1,可以通过资源对象的retain方法增加引用计数,当引用计数为0的时候该资源对象拥有的资源将会被回收。

    判断对象是否存活的两种方法

    1 引用计数法:缺点是对循环引用的对象无法回收
    2 可达性分析

    Java对象的初始化过程

    在这里插入图片描述

    类加载双亲委派模型

    从上到下分三个类加载器:

    BootStrap classloader:启动类加载器,负责将Java_HOME/lib下的类库加载到虚拟机内存中,比如rt.jar
    Extension classloader:扩展类加载器,负责将JAVA_HOME/lib/ext下的类库加载到虚拟机内存中。
    Application classloader:应用程序类加载器,负责加载classpath环境变量下指定的类库。如果程序中没有自定义过类加载器,那么这个就是程序中默认的类加载器。

    双亲委派模型:

      如果一个类加载器收到类加载的请求,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器完成。每个类加载器都是如此,只有当父加载器在自己的搜索范围内找不到指定的类时(即ClassNotFoundException),子加载器才会尝试自己去加载。
    在这里插入图片描述
    防止自定义的一些跟jdk标准库中冲突的全限定名的类被加载,导致标准库函数不可用。

    Zookeeper

    Zookeeper的常用应用场景有哪些

    • 分布式锁:获取父节点下的最小节点作为获得锁的一方
    • 命名服务:通过在zookeeper节点下创建全局唯一的一个path
    • 配置管理:配置放在zk上,所有应用监听节点改变。
    • 集群管理:GroupMembers集群管理,是否有机器退出和加入

    Zookeeper的分布式数据一致性算法

    ZAB原子消息广播协议

    一种是基于basic paxos实现的,另外一种是基于fast paxos算法实现的。

    参考:
    http://www.360doc.com/content/16/0823/11/14513665_585293946.shtml
    ZAB协议定义了选举(election)、发现(discovery)、同步(sync)、广播(Broadcast)四个阶段;

    Zk启动过程的Leader选举分析及数据同步

    参考:http://www.cnblogs.com/leesf456/p/6107600.html

    Zookeeper数据同步的简单描述

      在ZooKeeper中所有的客户端事务请求都由一个主服务器也就是Leader来处理,其他服务器为Follower,Leader将客户端的事务请求转换为事务Proposal,并且将Proposal分发给集群中其他所有的Follower,然后Leader等待Follwer反馈,当有过半数(>=N/2+1)的Follower反馈信息后,Leader将再次向集群内Follower广播Commit信息,Commit为将之前的Proposal提交;

    ZK集群最少需要几台机器?

    三台,2N+1,保证奇数,主要是为了leader选举算法中的“超过半数有效(>=N/2+1)”

    Zookeeper和Eureka的区别

    :ZK保证Cp,即一致性,分区容错性,比如当master节点因为网络故障和其他节点失去联系的时候,剩余节点会重新进行Master选举。问题在于Master选举的时间太长30~210s,选举期间整个zk集群是不可用的,这就导致选举期间的注册服务瘫痪。
      Eureka保证Ap,高可用性,它没有所谓主从节点概念,各节点平等。某节点挂掉不影响其他节点功能,其他节点照样提供查询和注册功能。Eureka客户端发现Eureka节点挂掉直接切换到其他正常的节点上去。只不过可能查到的数据不是最新的,也就是Eureka不保证数据的强一致性。
      作为注册中心,推荐Eureka,因为注册服务更重要的是可用性。

    Mysql

    InnoDB和MyISAM存储引擎的区别

    Starting from MySQL 5.5.5, the default storage engine for new tables isInnoDB rather than MyISAM.
    在这里插入图片描述

    Btree索引和Hash索引的区别

    Btree索引适合范围查找,Hash索引适合精确查找

    数据库的ACID特性

    数据库事务必须具备ACID特性
    原子性:Atomic,所有的操作执行成功,才算整个事务成功
    一致性:Consistency,不管事务success或fail,不能破坏关系数据的完整性以及业务逻辑上的一致性
    隔离性:Isolation,每个事务拥有独立数据空间,多个事务的数据修改相互隔离。事务查看数据更新时,数据要么是另一个事务修改前的状态,要么是修改后状态,不应该查看到中间状态数据。
    持久性:Durability,事务执行成功,数据必须永久保存。重启DB,数据需要恢复到事务执行成功后的状态。
    原子性、一致性、持久性DBMS通过日志来实现。
      隔离性DBMS通过锁来实现

    Mysql数据库的隔离级别

    M
    在这里插入图片描述

    Select For Update使用场景

      select for update 的使用场景,为了避免自己看到的数据并不是数据库存储的最新数据并且看到的数据只能由自己修改,需要用 for update 来限制。

    分布式事务模型之XA和TCC的区别和联系?

    XA-DTP模型

      最早的分布式事务模型是 X/Open 国际联盟提出的 X/Open Distributed Transaction Processing(DTP)模型,也就是大家常说的 X/Open XA 协议,简称XA 协议。
      DTP 模型中包含一个全局事务管理器(TM,Transaction Manager)和多个资源管理器(RM,Resource Manager)。全局事务管理器负责管理全局事务状态与参与的资源,协同资源一起提交或回滚;资源管理器则负责具体的资源操作。

    TCC模型

    TCC(Try-Confirm-Cancel)分布式事务模型相对于 XA 等传统模型,其特征在于它不依赖资源管理器(RM)对分布式事务的支持,而是通过对业务逻辑的分解来实现分布式事务。
    Try-Confirm-Cancel
    Try 操作对应2PC 的一阶段准备(Prepare);Confirm 对应 2PC 的二阶段提交(Commit),Cancel 对应 2PC 的二阶段回滚(Rollback),可以说 TCC 就是应用层的 2PC。

    参考
    https://mp.weixin.qq.com/s?__biz=MzUzMzU5Mjc1Nw==&mid=2247483681&idx=1&sn=05845495c5ef33683addd98fffc72106&chksm=faa0eefbcdd767edbf46cea6f223b426e276dd4d9b19cce64f59387590818f5e4eb96c7d2533&mpshare=1&scene=2&srcid=0118GSYShGZaOyCndUoAqsae&from=timeline#rd

    Mysql-binlog日志复制方式

    ①基于段的复制
    记录的是执行的语句
    ②基于行的复制
    记录是表中每一行的操作
    ③混合复制

    mysql主从复制原理

    在这里插入图片描述
    从服务器的IO线程读取主服务器的二进制日志变更,写入到中继日志relaylog中,如果IO线程追赶上了主服务器的日志,则进入sleep状态,直到主服务器发送唤醒信号,从服务器上的SQL线程重放relaylog中的日志。

    基于日志点的复制和GTID的复制有何区别?

    基于日志点的复制:从主服务器的哪个二进制日志的偏移量进行增量同步,如果指定错误会造成遗漏或重复。
    基于GTID的复制:从服务器会告诉主服务器,已经在从服务器上已经执行完了哪些gtid值,然后主库会把从库未执行的事务gtid值发送给从库执行。同一个事务只在指定的从库上执行一次。

    Mysql性能诊断和优化

    聚簇索引和非聚簇索引的区别

    聚簇索引,就是指主索引文件和数据文件为同一份文件,聚簇索引主要用在Innodb存储引擎中。如主键。B+Tree的叶子节点上的data就是数据本身。
    非聚簇索引就是指B+Tree的叶子节点上的data,并不是数据本身,而是数据存放的地址

    消息队列

    消费者宕机:怎么保证消息队列消息不丢失?

      比如activemq或者rabbitmq生产者消息投递到消息队列后,消费者拿到消息后,默认是自动签收机制,消息队列将删除这条消息,但是如果仅仅是拿到但是没有来得及处理业务逻辑时,消费者就宕机,那么此消息将会丢失,以后也不会再收到。
    解决办法
      消费端要设置签收机制为手动签收,只有当消息最终被处理,才告诉消息队列已经消费,此时消息队列再删除这条消息。

    MQ集群宕机:怎么保证消息不丢失?

      生产者投递消息到mq服务器,如果不保证消息和队列的持久化,那么当mq宕机时消息将彻底丢失,所以需要对消息做持久化存储,可以存储到磁盘或者数据库中,当mq服务器恢复时,消费端可以继续消费mq服务器中的消息。

      但是,比如RabbitMQ的消息持久化,是不承诺100%的消息不丢失的!
     &emsp**;原因**:因为有可能RabbitMQ接收到了消息,但是还没来得及持久化到磁盘,他自己就宕机了,这个时候消息还是会丢失的。如果要完全100%保证写入RabbitMQ的数据必须落地磁盘,不会丢失,需要依靠其他的机制。

    参考:
    https://mp.weixin.qq.com/s/ZAWPRToPQFcwzHBf47jZ-A
    https://mp.weixin.qq.com/s/HwAc6o8jdIHQTnE3ghXhIA
    https://mp.weixin.qq.com/s/AEn3j2lVJOHZx9yegwTsvw
    https://mp.weixin.qq.com/s/uqWIf0MAet_StszuOrZCwQ
    https://mp.weixin.qq.com/s/9SFrwaCCLnNyuCqP_KQ0zw
    https://mp.weixin.qq.com/s/vZ4KVC2eGmssnQUyIKgzfw
    https://mp.weixin.qq.com/s/r2_o5wa6Gn94NY4ViRnjpA

    Spring源码系列

    springmvc如何解决循环依赖的问题

      当使用构造器方式初始化一个bean,而且此时多个Bean之间有循环依赖的情况,spring容器就会抛出异常!
    解决办法:初始化bean的时候(注意此时的bean必须是单例,否则不能提前暴露一个创建中的bean)使用set方法进行注入属性,此时bean对象会先执行构造器实例化,接着将实例化后的bean放入一个map中,并提供引用。当需要通过set方式设置bean的属性的时候,spring容器就会从map中取出被实例化的bean。比如A对象需要set注入B对象,那么从Map中取出B对象即可。以此类推,不会出现循环依赖的异常。

    spring事务的传播行为和隔离级别

    spring事务七个事务传播行为

    在TransactionDefinition接口中定义了七个事务传播行为:

    • PROPAGATION_REQUIRED 如果存在一个事务,则支持当前事务。如果没有事务则开启一个新的事务。
    • PROPAGATION_SUPPORTS 如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行。但是对于事务同步的事务管理器,PROPAGATION_SUPPORTS与不使用事务有少许不同。
    • PROPAGATION_MANDATORY 如果已经存在一个事务,支持当前事务。如果没有一个活动的事务,则抛出异常。
    • PROPAGATION_REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在,则将这个存在的事务挂起。
    • PROPAGATION_NOT_SUPPORTED 总是非事务地执行,并挂起任何存在的事务。
    • PROPAGATION_NEVER 总是非事务地执行,如果存在一个活动事务,则抛出异常
    • PROPAGATION_NESTED如果一个活动的事务存在,则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行

    Spring事务的五种隔离级别

    在TransactionDefinition接口中定义了五个不同的事务隔离级别

    • ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别,使用数据库默认的事务隔离级别.
      另外四个与JDBC的隔离级别相对应
    • ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别,它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读,不可重复读和幻像读
    • ISOLATION_READ_COMMITTED 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现,但是可能会出现不可重复读和幻像读。
    • ISOLATION_REPEATABLE_READ 这种事务隔离级别可以防止脏读,不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外,还保证了避免下面的情况产生(不可重复读)。
    • ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读,不可重复读外,还避免了幻像读。

    设计模式

    单例模式

    1懒汉模式-非安全
    懒汉模式(线程不安全,可能出现多个Singleton 实例)

    public class Singleton { 
        private static Singleton instance; 
        private Singleton (){} 
    
        public static Singleton getInstance() { 
        		if (instance == null) { 
               instance = new Singleton(); 
        		} 
        		return instance; 
        } 
    }
    

    2懒汉模式-安全
    懒汉模式 (线程安全)

    public class Singleton { 
        private static Singleton instance; 
    private Singleton (){} 
    
        public static synchronized Singleton getInstance() { 
        		if (instance == null) { 
            	 instance = new Singleton(); 
        		} 
        		return instance; 
        } 
    }  
    

    3饿汉模式

    public class Singleton { 
        private static Singleton instance = new Singleton(); 
        private Singleton (){} 
        public static Singleton getInstance() { 
             return instance; 
        } 
    }
    

    4饿汉模式(变种)
    饿汉(变种,跟第三种差不多,都是在类初始化即实例化instance)

    public class Singleton { 
        private Singleton instance = null; 
        static { 
        		instance = new Singleton(); 
        } 
        private Singleton (){} 
        public static Singleton getInstance() { 
        		return this.instance; 
        } 
    }
    

    5静态内部类
    静态内部类,跟三四有细微差别:
    Singleton类被装载instance不一定被初始化,因为内部类SingletonHolder没有被主动使用,只有显示调用getInstance才会显示装载SingletonHolder 类,从而实例化instance

    public class Singleton { 
        private static class SingletonHolder { 
             private static final Singleton INSTANCE = new Singleton(); 
        } 
        private Singleton (){} 
        public static final Singleton getInstance() { 
             return SingletonHolder.INSTANCE; 
        } 
    }   
    

    6枚举
    枚举(既可以避免多线程同步问题,还可以防止被反序列化重建对象)

    public enum Singleton { 
        INSTANCE;
    public void whateverMethod() {
    	   
    } 
    
    public static void main(String[] args) {
    		Singleton s = Singleton.INSTANCE;
    		Singleton s2 = Singleton.INSTANCE;
    		System.out.println(s==s2);
    }
    
    }
    

    **输出结果:**true
      说明这种方式创建的对象是同一个,因为枚举类中的INSTANCE是static final类型的,只能被实例化一次。对于Enum中每一个枚举实例,都是相当于一个单独的Singleton实例。所以借用 《Effective Java》一书中的话,
    单元素的枚举类型已经成为实现Singleton的最佳方法

    7懒汉升级版

    public class Singleton { 
        private volatile static Singleton singleton; 
        private Singleton (){} 
        public static Singleton getSingleton() { 
        		if (singleton == null) { 
            		synchronized (Singleton.class) { 
            			if (singleton == null) { 
              			  	singleton = new Singleton(); 
           			 } 
            		} 
        		} 
        		return singleton; 
        	} 
    }
    

    策略模式

    在这里插入图片描述

    JDK源码

    ThreadLocal的实现原理

    ThreadLocal的实现原理,有什么缺点?跟线程池结合使用要注意什么
    在这里插入图片描述
    原理:Current Thread当前线程中有一个ThreadLocalMap对象,它的key是ThreadLocal的弱引用,Value是ThreadLocal调用set方法设置的对象值。每一个线程维护一个各自的ThreadLocalMap,所以多个线程之间变量相互隔离,互不干扰。

    缺点:存在内存泄漏问题,因为当ThreadLocal设置为null后,ThreadLocalMap的key的弱引用指向了null,又没有任何的强引用指向threadlocal,所以threadlocal会被GC回收掉。但是,ThreadLocalMap的Value不会被回收,CurrentThread当前线程的强引用指向了ThreadLocalMap,进而指向了这个Entry<key,value>,所以只有当currentThread结束强引用断开后,currentThread、ThreadLocalMap、Entry将全部被GC回收。
    所以结论是
      只要currentThread被GC回收,就不会出现内存泄漏。
    但是在currentThread被GC回收之前,threadlocal设置为null之后的这段时间里,Value不会被回收,比如当使用线程池的时候,线程结束不会被GC回收,会被继续复用,那这个Value肯定还会继续存在。如果这个Value很大的情况下,可能就会内存泄漏。
    虽然threadlocal的set和get方法执行时会清除key为null的value,但是如果当前线程在使用中没有调用threadlocal的set或者get方法一样可能会内存泄漏。

    跟线程池结合使用的注意事项
      因为线程池中线程复用的情况,本次的threadlocal中可能已经存在数据,所以上一次使用完threadlocal的变量后,要调用threadlocal的remove方法清除value。而且要注意调用完remove后应该保证不会再调用get方法。

    AQS实现公平锁和非公平锁

    基于AQS的锁(比如ReentrantLock)原理大体是这样:

    •   有一个state变量,初始值为0,假设当前线程为A,每当A获取一次锁,status++. 释放一次,status–.锁会记录当前持有的线程。
    •   当A线程拥有锁的时候,status>0. B线程尝试获取锁的时候会对这个status有一个CAS(0,1)的操作,尝试几次失败后就挂起线程,进入一个等待队列。
    •   如果A线程恰好释放,–status==0, A线程会去唤醒等待队列中第一个线程,即刚刚进入等待队列的B线程,B线程被唤醒之后回去检查这个status的值,尝试CAS(0,1),而如果这时恰好C线程也尝试去争抢这把锁。

    非公平锁实现
    C直接尝试对这个status CAS(0,1)操作,并成功改变了status的值,B线程获取锁失败,再次挂起,这就是非公平锁,B在C之前尝试获取锁,而最终是C抢到了锁。
    公平锁
    C发现有线程在等待队列,直接将自己进入等待队列并挂起,B获取锁

    RPC

    RPC的序列化方式有哪些

    Thrift—facebook
    ProtoBuf—google
    Hessian
    JAVA原生的序列化接口
    Json/xml

    服务熔断与服务降级概念

    服务熔断:

      一般指某个服务的下游服务出现问题时采用的手段,而服务降级一般是从整体层面考虑的。下游服务出现问题时可以进行服务熔断。
      对于目标服务的请求和调用大量超时或失败,这时应该熔断该服务的所有调用,并且对于后续调用应直接返回,从而快速释放资源,确保在目标服务不可用的这段时间内,所有对它的调用都是立即返回,不会阻塞的。再等到目标服务好转后进行接口恢复。

    服务降级:

      当服务器压力剧增的情况下,根据当前业务情况及流量对一些服务和页面有策略的降级,以此释放服务器资源以保证核心任务的正常运行。

    其他整理

    ThreadLocalMap的线性探测法、HashMap的拉链法。两种解决hash碰撞的方式有何不同?


    Netty的RPC如何实现


    Netty中源码inbound和outbound有啥区别?


    怎么分库分表可以做到多维度查找


    Fork/Join框架


    JAVA线程执行中怎么kill掉

    1 通过设置全局变量标志来控制线程的任务执行完成.进而销毁线程
    2 如果线程处于长久的阻塞状态,可以interrupt脱离线程阻塞状态跳出程序体

    HA主备怎么预防脑裂

    一般采用2个方法

    1. 仲裁
      当两个节点出现分歧时,由第3方的仲裁者决定听谁的。这个仲裁者,可能是一个锁服务,一个共享盘或者其它什么东西。
    2. fencing
      当不能确定某个节点的状态时,通过fencing把对方干掉,确保共享资源被完全释放,前提是必须要有可靠的fence设备。

    性别字段是否需要加索引

    1.聚集索引,叶子节点存储行记录,InnoDB索引和记录是存储在一起的。
    2.普通索引,叶子节点存储了主键的值。
    在InnoDB引擎中每个表都会有一个聚集索引,如果表定义了主键,那主键就是聚集索引.一个表只有一个聚集索引,其余为普通索引.如果性别sex字段定义为普通的索引,那么在使用普通索引查询时,会先加载普通索引,通过普通索引查询到实际行的主键,用主键通过聚集索引去查询最终的行.
    如果不对sex性别字段加索引,那么查找过程就是直接全表扫描查询到聚集索引定位到行,而不需要普通索引和聚集索引的切换,所以效率可能更高一点.
    在这里插入图片描述

    Https的SSL握手过程

    Https协议由两部分组成:http+ssl,即在http协议的基础上增加了一层ssl的握手过程.

    • 浏览器作为发起方,向网站发送一套浏览器自身支持的加密规则,比如客户端支持的加密算法,Hash算法,ssl版本,以及一个28字节的随机数client_random
    • .网站选出一套加密算法和hash算法,生成一个服务端随机数server_random并以证书的形式返回给客户端浏览器,这个证书还包含网站地址、公钥public_key、证书的颁发机构CA以及证书过期时间。
    • .浏览器解析证书是否有效,如果无效则浏览器弹出提示框告警。如果证书有效,则根据server_random生成一个preMaster_secret和Master_secret[会话密钥], master_secret 的生成需要 preMaster_key ,并需要 client_random 和 server_random 作为种子。浏览器向服务器发送经过public_key加密的preMaster_secret,以及对握手消息取hash值并使用master_secret进行加密发送给网站.[客户端握手结束通知,表示客户端的握手阶段已经结束。这一项同时也是前面发送的所有内容的hash值,用来供服务器校验]
    • .服务器使用private_key 解密后得到preMaster_secret,再根据client_random 和 server_random 作为种子得到master_secret.然后使用master_secret解密握手消息并计算hash值,跟浏览器发送的hash值对比是否一致.
      然后把握手消息通过master_secret进行对称加密后返回给浏览器.以及把握手消息进行hash且master_secret加密后发给浏览器.[服务器握手结束通知,表示服务器的握手阶段已经结束。这一项同时也是前面发送的所有内容的hash值,用来供客户端校验。]
    • .客户端同样可以使用master_secret进行解密得到握手消息.校验握手消息的hash值是否跟服务器发送过来的hash值一致,一致则握手结束.通信开始
    • .以后的通信都是通过master_secret+对称加密算法的方式进行. 客户端与服务器进入加密通信,就完全是使用普通的HTTP协议,只不过用"会话密钥"加密内容。SSL握手过程中如果有任何错误,都会使加密连接断开,从而阻止了隐私信息的传输
      在这里插入图片描述
      非对称加密算法:RSA,DSA/DSS
      对称加密算法:AES,RC4,3DES
      HASH算法:MD5,SHA1,SHA256
      参考: http://www.ruanyifeng.com/blog/2014/02/ssl_tls.html

    select和epoll的区别

    1 select有最大并发数限制,默认最大文件句柄数1024,可修改。
    epoll没有最大文件句柄数限制,仅受系统中进程能打开的最大文件句柄限制。
    2 select效率低,每次都要线性扫描其维护的fd_set集合。
    epoll只在集合不为空才轮训
    3select存在内核空间和用户空间的内存拷贝问题。
      epoll中减少内存拷贝,mmap将用户空间的一块地址和内核空间的一块地址同时映射到相同的一块物理内存地址

    NIO使用的多路复用器是epoll

    Epoll导致的selector空轮询

      Java NIO Epoll 会导致 Selector 空轮询,最终导致 CPU 100%
      官方声称在 JDK 1.6 版本的 update18 修复了该问题,但是直到 JDK 1.7 版本该问题仍旧存在,只不过该 BUG 发生概率降低了一些而已,它并没有得到根本性解决
    Netty的解决方案:
      对 Selector 的 select 操作周期进行统计,每完成一次空的 select 操作进行一次计数,若在某个周期内连续发生 N 次空轮询,则判断触发了 Epoll 死循环 Bug。
      然后,Netty 重建 Selector 来解决。判断是否是其他线程发起的重建请求,若不是则将原 SocketChannel 从旧的 Selector 上取消注册,然后重新注册到新的 Selector 上,最后将原来的 Selector 关闭。

    正排索引和倒排索引

    正排索引

    也叫正向索引,正排表是以document文档的ID为关键字,记录了document文档中所有的关键字keyword的信息,所以在查找某个keyword的时候,会扫描正排表中每个document文档,直到查出所有包含keyword的文档。
    图示:
    在这里插入图片描述

    倒排索引

    也叫反向索引,倒排表示以keyword关键字建立索引,关键词keyword所对应的的表项记录了出现这个keyword的所有文档。表项包含了该文档的ID和在该文档中出现的位置情况。
    倒排表一次可以查出keyword关键字对应的所有文档,效率高于正排表。
    在这里插入图片描述

    正排索引是从文档到关键字的映射(已知文档求关键字)
    倒排索引是从关键字到文档的映射(已知关键字求文档)

    后记

      本人到目前为止接触java有七年多的时间,越来越觉得语言的工具化,以工具化的角度去看待自己的技术,上边这些面试题目虽然在实际中都基本上会被问到,但是不应该投机取巧,还是少一些功利化的东西,功利化作为内驱没错,但是学习技术还是得静下心,沉住气,保持耐心.真正的实力绝对不是靠这些面试题达成的,绝对是日复一日的坚持和忍耐


    其他优质文章
    《成就一亿技术人,我在CSDN的这九年》
    《计算机如何做减法?10个程序员9个不知道!!!》
    《高级编程语言学习概论》
    《互联网三高架构之高并发和高性能的理解》
    《《跟任何人都能聊得来》读书笔记》
    《这十年里的迷茫路口》
    《一个码农的那五年》
    《搞技术的总要做点高逼格的事情,那些lowB操作留给新人练手吧!》
    《教你搭建一套自己的SVN服务器》
    欢迎下方留言跟我一起交流,让我知道您来过~

    在这里插入图片描述

    展开全文
  • 最新Java面试题,常见面试题及答案汇总

    万次阅读 多人点赞 2019-07-12 08:56:55
    Java最新面试题面试题答案汇总

    Java最新常见面试题 + 答案汇总

    原文地址:https://blog.csdn.net/sufu1065/article/details/88051083

    1、面试题模块汇总

    面试题包括以下十九个模块:Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。如下图所示:

    可能对于初学者不需要后面的框架和 JVM 模块的知识,读者朋友们可根据自己的情况,选择对应的模块进行阅读。

    适宜阅读人群

    • 需要面试的初/中/高级 java 程序员
    • 想要查漏补缺的人
    • 想要不断完善和扩充自己 java 技术栈的人
    • java 面试官

    具体面试题

    下面一起来看 208 道面试题,具体的内容。

    一、Java 基础

    1.JDK 和 JRE 有什么区别?

    2.== 和 equals 的区别是什么?

    3.两个对象的 hashCode()相同,则 equals()也一定为 true,对吗?

    4.final 在 java 中有什么作用?

    5.java 中的 Math.round(-1.5) 等于多少?

    6.String 属于基础的数据类型吗?

    7.java 中操作字符串都有哪些类?它们之间有什么区别?

    8.String str="i"与 String str=new String(“i”)一样吗?

    9.如何将字符串反转?

    10.String 类的常用方法都有那些?

    11.抽象类必须要有抽象方法吗?

    12.普通类和抽象类有哪些区别?

    13.抽象类能使用 final 修饰吗?

    14.接口和抽象类有什么区别?

    15.java 中 IO 流分为几种?

    16.BIO、NIO、AIO 有什么区别?

    17.Files的常用方法都有哪些?

    二、容器

    18.java 容器都有哪些?

    19.Collection 和 Collections 有什么区别?

    20.List、Set、Map 之间的区别是什么?

    21.HashMap 和 Hashtable 有什么区别?

    22.如何决定使用 HashMap 还是 TreeMap?

    23.说一下 HashMap 的实现原理?

    24.说一下 HashSet 的实现原理?

    25.ArrayList 和 LinkedList 的区别是什么?

    26.如何实现数组和 List 之间的转换?

    27.ArrayList 和 Vector 的区别是什么?

    28.Array 和 ArrayList 有何区别?

    29.在 Queue 中 poll()和 remove()有什么区别?

    30.哪些集合类是线程安全的?

    31.迭代器 Iterator 是什么?

    32.Iterator 怎么使用?有什么特点?

    33.Iterator 和 ListIterator 有什么区别?

    34.怎么确保一个集合不能被修改?

    三、多线程

    35.并行和并发有什么区别?

    36.线程和进程的区别?

    37.守护线程是什么?

    38.创建线程有哪几种方式?

    39.说一下 runnable 和 callable 有什么区别?

    40.线程有哪些状态?

    41.sleep() 和 wait() 有什么区别?

    42.notify()和 notifyAll()有什么区别?

    43.线程的 run()和 start()有什么区别?

    44.创建线程池有哪几种方式?

    45.线程池都有哪些状态?

    46.线程池中 submit()和 execute()方法有什么区别?

    47.在 java 程序中怎么保证多线程的运行安全?

    48.多线程锁的升级原理是什么?

    49.什么是死锁?

    50.怎么防止死锁?

    51.ThreadLocal 是什么?有哪些使用场景?

    52.说一下 synchronized 底层实现原理?

    53.synchronized 和 volatile 的区别是什么?

    54.synchronized 和 Lock 有什么区别?

    55.synchronized 和 ReentrantLock 区别是什么?

    56.说一下 atomic 的原理?

    四、反射

    57.什么是反射?

    58.什么是 java 序列化?什么情况下需要序列化?

    59.动态代理是什么?有哪些应用?

    60.怎么实现动态代理?

    五、对象拷贝

    61.为什么要使用克隆?

    62.如何实现对象克隆?

    63.深拷贝和浅拷贝区别是什么?

    六、Java Web

    64.jsp 和 servlet 有什么区别?

    65.jsp 有哪些内置对象?作用分别是什么?

    66.说一下 jsp 的 4 种作用域?

    67.session 和 cookie 有什么区别?

    68.说一下 session 的工作原理?

    69.如果客户端禁止 cookie 能实现 session 还能用吗?

    70.spring mvc 和 struts 的区别是什么?

    71.如何避免 sql 注入?

    72.什么是 XSS 攻击,如何避免?

    73.什么是 CSRF 攻击,如何避免?

    七、异常

    74.throw 和 throws 的区别?

    75.final、finally、finalize 有什么区别?

    76.try-catch-finally 中哪个部分可以省略?

    77.try-catch-finally 中,如果 catch 中 return 了,finally 还会执行吗?

    78.常见的异常类有哪些?

    八、网络

    79.http 响应码 301 和 302 代表的是什么?有什么区别?

    80.forward 和 redirect 的区别?

    81.简述 tcp 和 udp的区别?

    82.tcp 为什么要三次握手,两次不行吗?为什么?

    83.说一下 tcp 粘包是怎么产生的?

    84.OSI 的七层模型都有哪些?

    85.get 和 post 请求有哪些区别?

    86.如何实现跨域?

    87.说一下 JSONP 实现原理?

    九、设计模式

    88.说一下你熟悉的设计模式?

    89.简单工厂和抽象工厂有什么区别?

    十、Spring/Spring MVC

    90.为什么要使用 spring?

    91.解释一下什么是 aop?

    92.解释一下什么是 ioc?

    93.spring 有哪些主要模块?

    94.spring 常用的注入方式有哪些?

    95.spring 中的 bean 是线程安全的吗?

    96.spring 支持几种 bean 的作用域?

    97.spring 自动装配 bean 有哪些方式?

    98.spring 事务实现方式有哪些?

    99.说一下 spring 的事务隔离?

    100.说一下 spring mvc 运行流程?

    101.spring mvc 有哪些组件?

    102.@RequestMapping 的作用是什么?

    103.@Autowired 的作用是什么?

    十一、Spring Boot/Spring Cloud

    104.什么是 spring boot?

    105.为什么要用 spring boot?

    106.spring boot 核心配置文件是什么?

    107.spring boot 配置文件有哪几种类型?它们有什么区别?

    108.spring boot 有哪些方式可以实现热部署?

    109.jpa 和 hibernate 有什么区别?

    110.什么是 spring cloud?

    111.spring cloud 断路器的作用是什么?

    112.spring cloud 的核心组件有哪些?

    十二、Hibernate

    113.为什么要使用 hibernate?

    114.什么是 ORM 框架?

    115.hibernate 中如何在控制台查看打印的 sql 语句?

    116.hibernate 有几种查询方式?

    117.hibernate 实体类可以被定义为 final 吗?

    118.在 hibernate 中使用 Integer 和 int 做映射有什么区别?

    119.hibernate 是如何工作的?

    120.get()和 load()的区别?

    121.说一下 hibernate 的缓存机制?

    122.hibernate 对象有哪些状态?

    123.在 hibernate 中 getCurrentSession 和 openSession 的区别是什么?

    124.hibernate 实体类必须要有无参构造函数吗?为什么?

    十三、Mybatis

    125.mybatis 中 #{}和 ${}的区别是什么?

    126.mybatis 有几种分页方式?

    127.RowBounds 是一次性查询全部结果吗?为什么?

    128.mybatis 逻辑分页和物理分页的区别是什么?

    129.mybatis 是否支持延迟加载?延迟加载的原理是什么?

    130.说一下 mybatis 的一级缓存和二级缓存?

    131.mybatis 和 hibernate 的区别有哪些?

    132.mybatis 有哪些执行器(Executor)?

    133.mybatis 分页插件的实现原理是什么?

    134.mybatis 如何编写一个自定义插件?

    十四、RabbitMQ

    135.rabbitmq 的使用场景有哪些?

    136.rabbitmq 有哪些重要的角色?

    137.rabbitmq 有哪些重要的组件?

    138.rabbitmq 中 vhost 的作用是什么?

    139.rabbitmq 的消息是怎么发送的?

    140.rabbitmq 怎么保证消息的稳定性?

    141.rabbitmq 怎么避免消息丢失?

    142.要保证消息持久化成功的条件有哪些?

    143.rabbitmq 持久化有什么缺点?

    144.rabbitmq 有几种广播类型?

    145.rabbitmq 怎么实现延迟消息队列?

    146.rabbitmq 集群有什么用?

    147.rabbitmq 节点的类型有哪些?

    148.rabbitmq 集群搭建需要注意哪些问题?

    149.rabbitmq 每个节点是其他节点的完整拷贝吗?为什么?

    150.rabbitmq 集群中唯一一个磁盘节点崩溃了会发生什么情况?

    151.rabbitmq 对集群节点停止顺序有要求吗?

    十五、Kafka

    152.kafka 可以脱离 zookeeper 单独使用吗?为什么?

    153.kafka 有几种数据保留的策略?

    154.kafka 同时设置了 7 天和 10G 清除数据,到第五天的时候消息达到了 10G,这个时候 kafka 将如何处理?

    155.什么情况会导致 kafka 运行变慢?

    156.使用 kafka 集群需要注意什么?

    十六、Zookeeper

    157.zookeeper 是什么?

    158.zookeeper 都有哪些功能?

    159.zookeeper 有几种部署模式?

    160.zookeeper 怎么保证主从节点的状态同步?

    161.集群中为什么要有主节点?

    162.集群中有 3 台服务器,其中一个节点宕机,这个时候 zookeeper 还可以使用吗?

    163.说一下 zookeeper 的通知机制?

    十七、MySql

    164.数据库的三范式是什么?

    165.一张自增表里面总共有 7 条数据,删除了最后 2 条数据,重启 mysql 数据库,又插入了一条数据,此时 id 是几?

    166.如何获取当前数据库版本?

    167.说一下 ACID 是什么?

    168.char 和 varchar 的区别是什么?

    169.float 和 double 的区别是什么?

    170.mysql 的内连接、左连接、右连接有什么区别?

    171.mysql 索引是怎么实现的?

    172.怎么验证 mysql 的索引是否满足需求?

    173.说一下数据库的事务隔离?

    174.说一下 mysql 常用的引擎?

    175.说一下 mysql 的行锁和表锁?

    176.说一下乐观锁和悲观锁?

    177.mysql 问题排查都有哪些手段?

    178.如何做 mysql 的性能优化?

    十八、Redis

    179.redis 是什么?都有哪些使用场景?

    180.redis 有哪些功能?

    181.redis 和 memecache 有什么区别?

    182.redis 为什么是单线程的?

    183.什么是缓存穿透?怎么解决?

    184.redis 支持的数据类型有哪些?

    185.redis 支持的 java 客户端都有哪些?

    186.jedis 和 redisson 有哪些区别?

    187.怎么保证缓存和数据库数据的一致性?

    188.redis 持久化有几种方式?

    189.redis 怎么实现分布式锁?

    190.redis 分布式锁有什么缺陷?

    191.redis 如何做内存优化?

    192.redis 淘汰策略有哪些?

    193.redis 常见的性能问题有哪些?该如何解决?

    十九、JVM

    194.说一下 jvm 的主要组成部分?及其作用?

    195.说一下 jvm 运行时数据区?

    196.说一下堆栈的区别?

    197.队列和栈是什么?有什么区别?

    198.什么是双亲委派模型?

    199.说一下类加载的执行过程?

    200.怎么判断对象是否可以被回收?

    201.java 中都有哪些引用类型?

    202.说一下 jvm 有哪些垃圾回收算法?

    203.说一下 jvm 有哪些垃圾回收器?

    204.详细介绍一下 CMS 垃圾回收器?

    205.新生代垃圾回收器和老生代垃圾回收器都有哪些?有什么区别?

    206.简述分代垃圾回收器是怎么工作的?

    207.说一下 jvm 调优的工具?

    208.常用的 jvm 调优的参数都有哪些?

    2、面试题答案汇总

    (一)基础模块

    (二)容器

    (三)多线程

    (四)反射

    (五)对象拷贝

    (六)JavaWeb

    (七)异常

    (八)网络

    (九)设计模式

    (十)Spring/SpringMVC

    (十一)Spring Boot / Spring Cloud

    (十二)Hibernate

    (十三)Mybatis

    (十四)RabbitMQ

    (十五)Kafka

    (十六)Zookeeper

    (十七)MySql

    (十八)Redis

    (十九)JVM

    展开全文
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...

    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~

    本套Java面试题大全,全的不能再全,哈哈~

    博主已将以下这些面试题整理成了一个Java面试手册,是PDF版的。

    关注博主的微信公众号:Java团长,然后回复“面试手册”即可获取~

    一、Java 基础

    1. JDK 和 JRE 有什么区别?

    • JDK:Java Development Kit 的简称,java 开发工具包,提供了 java 的开发环境和运行环境。
    • JRE:Java Runtime Environment 的简称,java 运行环境,为 java 的运行提供了所需环境。

    具体来说 JDK 其实包含了 JRE,同时还包含了编译 java 源码的编译器 javac,还包含了很多 java 程序调试和分析的工具。简单来说:如果你需要运行 java 程序,只需安装 JRE 就可以了,如果你需要编写 java 程序,需要安装 JDK。

    2. == 和 equals 的区别是什么?

    == 解读

    对于基本类型和引用类型 == 的作用效果是不同的,如下所示:

    • 基本类型:比较的是值是否相同;
    • 引用类型:比较的是引用是否相同;

    代码示例:

    String x = "string";
    String y = "string";
    String z = new String("string");
    System.out.println(x==y); // true
    System.out.println(x==z); // false
    System.out.println(x.equals(y)); // true
    System.out.println(x.equals(z)); // true

    代码解读:因为 x 和 y 指向的是同一个引用,所以 == 也是 true,而 new String()方法则重写开辟了内存空间,所以 == 结果为 false,而 equals 比较的一直是值,所以结果都为 true。

    equals 解读

    equals 本质上就是 ==,只不过 String 和 Integer 等重写了 equals 方法,把它变成了值比较。看下面的代码就明白了。

    首先来看默认情况下 equals 比较一个有相同值的对象,代码如下:

    class Cat {
        public Cat(String name) {
            this.name = name;
        }
    
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    
    Cat c1 = new Cat("王磊");
    Cat c2 = new Cat("王磊");
    System.out.println(c1.equals(c2)); // false

    输出结果出乎我们的意料,竟然是 false?这是怎么回事,看了 equals 源码就知道了,源码如下:

    public boolean equals(Object obj) {
        return (this == obj);
    }

    原来 equals 本质上就是 ==。

    那问题来了,两个相同值的 String 对象,为什么返回的是 true?代码如下:

    String s1 = new String("老王");
    String s2 = new String("老王");
    System.out.println(s1.equals(s2)); // true

    同样的,当我们进入 String 的 equals 方法,找到了答案,代码如下:

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

    原来是 String 重写了 Object 的 equals 方法,把引用比较改成了值比较。

    总结 :== 对于基本类型来说是值比较,对于引用类型来说是比较的是引用;而 equals 默认情况下是引用比较,只是很多类重新了 equals 方法,比如 String、Integer 等把它变成了值比较,所以一般情况下 equals 比较的是值是否相等。

    3. 两个对象的 hashCode()相同,则 equals()也一定为 true,对吗?

    不对,两个对象的 hashCode()相同,equals()不一定 true。

    代码示例:

    String str1 = "通话";
    String str2 = "重地";
    System.out.println(String.format("str1:%d | str2:%d",  str1.hashCode(),str2.hashCode()));
    System.out.println(str1.equals(str2));

    执行的结果:

    str1:1179395 | str2:1179395

    false

    代码解读:很显然“通话”和“重地”的 hashCode() 相同,然而 equals() 则为 false,因为在散列表中,hashCode()相等即两个键值对的哈希值相等,然而哈希值相等,并不一定能得出键值对相等。

    4. final 在 java 中有什么作用?

    • final 修饰的类叫最终类,该类不能被继承。
    • final 修饰的方法不能被重写。
    • final 修饰的变量叫常量,常量必须初始化,初始化之后值就不能被修改。

    5. java 中的 Math.round(-1.5) 等于多少?

    等于 -1,因为在数轴上取值时,中间值(0.5)向右取整,所以正 0.5 是往上取整,负 0.5 是直接舍弃。

    6. String 属于基础的数据类型吗?

    String 不属于基础类型,基础类型有 8 种:byte、boolean、char、short、int、float、long、double,而 String 属于对象。

    7. java 中操作字符串都有哪些类?它们之间有什么区别?

    操作字符串的类有:String、StringBuffer、StringBuilder。

    String 和 StringBuffer、StringBuilder 的区别在于 String 声明的是不可变的对象,每次操作都会生成新的 String 对象,然后将指针指向新的 String 对象,而 StringBuffer、StringBuilder 可以在原有对象的基础上进行操作,所以在经常改变字符串内容的情况下最好不要使用 String。

    StringBuffer 和 StringBuilder 最大的区别在于,StringBuffer 是线程安全的,而 StringBuilder 是非线程安全的,但 StringBuilder 的性能却高于 StringBuffer,所以在单线程环境下推荐使用 StringBuilder,多线程环境下推荐使用 StringBuffer。

    8. String str="i"与 String str=new String("i")一样吗?

    不一样,因为内存的分配方式不一样。String str="i"的方式,java 虚拟机会将其分配到常量池中;而 String str=new String("i") 则会被分到堆内存中。

    9. 如何将字符串反转?

    使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。

    示例代码:

    // StringBuffer reverse
    StringBuffer stringBuffer = new StringBuffer();
    stringBuffer.append("abcdefg");
    System.out.println(stringBuffer.reverse()); // gfedcba
    // StringBuilder reverse
    StringBuilder stringBuilder = new StringBuilder();
    stringBuilder.append("abcdefg");
    System.out.println(stringBuilder.reverse()); // gfedcba

    10. String 类的常用方法都有那些?

    • indexOf():返回指定字符的索引。
    • charAt():返回指定索引处的字符。
    • replace():字符串替换。
    • trim():去除字符串两端空白。
    • split():分割字符串,返回一个分割后的字符串数组。
    • getBytes():返回字符串的 byte 类型数组。
    • length():返回字符串长度。
    • toLowerCase():将字符串转成小写字母。
    • toUpperCase():将字符串转成大写字符。
    • substring():截取字符串。
    • equals():字符串比较。

    11. 抽象类必须要有抽象方法吗?

    不需要,抽象类不一定非要有抽象方法。

    示例代码:

    abstract class Cat {
        public static void sayHi() {
            System.out.println("hi~");
        }
    }

    上面代码,抽象类并没有抽象方法但完全可以正常运行。

    12. 普通类和抽象类有哪些区别?

    • 普通类不能包含抽象方法,抽象类可以包含抽象方法。
    • 抽象类不能直接实例化,普通类可以直接实例化。

    13. 抽象类能使用 final 修饰吗?

    不能,定义抽象类就是让其他类继承的,如果定义为 final 该类就不能被继承,这样彼此就会产生矛盾,所以 final 不能修饰抽象类,如下图所示,编辑器也会提示错误信息:

    14. 接口和抽象类有什么区别?

    • 实现:抽象类的子类使用 extends 来继承;接口必须使用 implements 来实现接口。
    • 构造函数:抽象类可以有构造函数;接口不能有。
    • main 方法:抽象类可以有 main 方法,并且我们能运行它;接口不能有 main 方法。
    • 实现数量:类可以实现很多个接口;但是只能继承一个抽象类。
    • 访问修饰符:接口中的方法默认使用 public 修饰;抽象类中的方法可以是任意访问修饰符。

    15. java 中 IO 流分为几种?

    按功能来分:输入流(input)、输出流(output)。

    按类型来分:字节流和字符流。

    字节流和字符流的区别是:字节流按 8 位传输以字节为单位输入输出数据,字符流按 16 位传输以字符为单位输入输出数据。

    16. BIO、NIO、AIO 有什么区别?

    • BIO:Block IO 同步阻塞式 IO,就是我们平常使用的传统 IO,它的特点是模式简单使用方便,并发处理能力低。
    • NIO:New IO 同步非阻塞 IO,是传统 IO 的升级,客户端和服务器端通过 Channel(通道)通讯,实现了多路复用。
    • AIO:Asynchronous IO 是 NIO 的升级,也叫 NIO2,实现了异步非堵塞 IO ,异步 IO 的操作基于事件和回调机制。

    17. Files的常用方法都有哪些?

    • Files.exists():检测文件路径是否存在。
    • Files.createFile():创建文件。
    • Files.createDirectory():创建文件夹。
    • Files.delete():删除一个文件或目录。
    • Files.copy():复制文件。
    • Files.move():移动文件。
    • Files.size():查看文件个数。
    • Files.read():读取文件。
    • Files.write():写入文件。

    二、容器

    18. java 容器都有哪些?

    常用容器的图录:

    19. Collection 和 Collections 有什么区别?

    • java.util.Collection 是一个集合接口(集合类的一个顶级接口)。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式,其直接继承接口有List与Set。
    • Collections则是集合类的一个工具类/帮助类,其中提供了一系列静态方法,用于对集合中元素进行排序、搜索以及线程安全等各种操作。

    20. List、Set、Map 之间的区别是什么?

    21. HashMap 和 Hashtable 有什么区别?

    • hashMap去掉了HashTable 的contains方法,但是加上了containsValue()和containsKey()方法。
    • hashTable同步的,而HashMap是非同步的,效率上逼hashTable要高。
    • hashMap允许空键值,而hashTable不允许。

    22. 如何决定使用 HashMap 还是 TreeMap?

    对于在Map中插入、删除和定位元素这类操作,HashMap是最好的选择。然而,假如你需要对一个有序的key集合进行遍历,TreeMap是更好的选择。基于你的collection的大小,也许向HashMap中添加元素会更快,将map换为TreeMap进行有序key的遍历。

    23. 说一下 HashMap 的实现原理?

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

    HashMap的数据结构: 在java编程语言中,最基本的结构就是两种,一个是数组,另外一个是模拟指针(引用),所有的数据结构都可以用这两个基本结构来构造的,HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构,即数组和链表的结合体。

    当我们往Hashmap中put元素时,首先根据key的hashcode重新计算hash值,根绝hash值得到这个元素在数组中的位置(下标),如果该数组在该位置上已经存放了其他元素,那么在这个位置上的元素将以链表的形式存放,新加入的放在链头,最先加入的放入链尾.如果数组中该位置没有元素,就直接将该元素放到数组的该位置上。

    需要注意Jdk 1.8中对HashMap的实现做了优化,当链表中的节点数据超过八个之后,该链表会转为红黑树来提高查询效率,从原来的O(n)到O(logn)

    24. 说一下 HashSet 的实现原理?

    • HashSet底层由HashMap实现
    • HashSet的值存放于HashMap的key上
    • HashMap的value统一为PRESENT

    25. ArrayList 和 LinkedList 的区别是什么?

    最明显的区别是 ArrrayList底层的数据结构是数组,支持随机访问,而 LinkedList 的底层数据结构是双向循环链表,不支持随机访问。使用下标访问一个元素,ArrayList 的时间复杂度是 O(1),而 LinkedList 是 O(n)。

    26. 如何实现数组和 List 之间的转换?

    • List转换成为数组:调用ArrayList的toArray方法。
    • 数组转换成为List:调用Arrays的asList方法。

    27. ArrayList 和 Vector 的区别是什么?

    • Vector是同步的,而ArrayList不是。然而,如果你寻求在迭代的时候对列表进行改变,你应该使用CopyOnWriteArrayList。 
    • ArrayList比Vector快,它因为有同步,不会过载。 
    • ArrayList更加通用,因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。

    28. Array 和 ArrayList 有何区别?

    • Array可以容纳基本类型和对象,而ArrayList只能容纳对象。 
    • Array是指定大小的,而ArrayList大小是固定的。 
    • Array没有提供ArrayList那么多功能,比如addAll、removeAll和iterator等。

    29. 在 Queue 中 poll()和 remove()有什么区别?

    poll() 和 remove() 都是从队列中取出一个元素,但是 poll() 在获取元素失败的时候会返回空,但是 remove() 失败的时候会抛出异常。

    30. 哪些集合类是线程安全的?

    • vector:就比arraylist多了个同步化机制(线程安全),因为效率较低,现在已经不太建议使用。在web应用中,特别是前台页面,往往效率(页面响应速度)是优先考虑的。
    • statck:堆栈类,先进后出。
    • hashtable:就比hashmap多了个线程安全。
    • enumeration:枚举,相当于迭代器。

    31. 迭代器 Iterator 是什么?

    迭代器是一种设计模式,它是一个对象,它可以遍历并选择序列中的对象,而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象,因为创建它的代价小。

    32. Iterator 怎么使用?有什么特点?

    Java中的Iterator功能比较简单,并且只能单向移动:

    (1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时,它返回序列的第一个元素。注意:iterator()方法是java.lang.Iterable接口,被Collection继承。

    (2) 使用next()获得序列中的下一个元素。

    (3) 使用hasNext()检查序列中是否还有元素。

    (4) 使用remove()将迭代器新返回的元素删除。

    Iterator是Java迭代器最简单的实现,为List设计的ListIterator具有更多的功能,它可以从两个方向遍历List,也可以从List中插入和删除元素。

    33. Iterator 和 ListIterator 有什么区别?

    • Iterator可用来遍历Set和List集合,但是ListIterator只能用来遍历List。 
    • Iterator对集合只能是前向遍历,ListIterator既可以前向也可以后向。 
    • ListIterator实现了Iterator接口,并包含其他的功能,比如:增加元素,替换元素,获取前一个和后一个元素的索引,等等。

     三、多线程

    35. 并行和并发有什么区别?

    • 并行是指两个或者多个事件在同一时刻发生;而并发是指两个或多个事件在同一时间间隔发生。
    • 并行是在不同实体上的多个事件,并发是在同一实体上的多个事件。
    • 在一台处理器上“同时”处理多个任务,在多台处理器上同时处理多个任务。如hadoop分布式集群。

    所以并发编程的目标是充分的利用处理器的每一个核,以达到最高的处理性能。

    36. 线程和进程的区别?

    简而言之,进程是程序运行和资源分配的基本单位,一个程序至少有一个进程,一个进程至少有一个线程。进程在执行过程中拥有独立的内存单元,而多个线程共享内存资源,减少切换次数,从而效率更高。线程是进程的一个实体,是cpu调度和分派的基本单位,是比程序更小的能独立运行的基本单位。同一进程中的多个线程之间可以并发执行。

    37. 守护线程是什么?

    守护线程(即daemon thread),是个服务线程,准确地来说就是服务其他的线程。

    38. 创建线程有哪几种方式?

    ①. 继承Thread类创建线程类

    • 定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
    • 创建Thread子类的实例,即创建了线程对象。
    • 调用线程对象的start()方法来启动该线程。

    ②. 通过Runnable接口创建线程类

    • 定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
    • 创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。
    • 调用线程对象的start()方法来启动该线程。

    ③. 通过Callable和Future创建线程

    • 创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。
    • 创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。
    • 使用FutureTask对象作为Thread对象的target创建并启动新线程。
    • 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

    39. 说一下 runnable 和 callable 有什么区别?

    有点深的问题了,也看出一个Java程序员学习知识的广度。

    • Runnable接口中的run()方法的返回值是void,它做的事情只是纯粹地去执行run()方法中的代码而已;
    • Callable接口中的call()方法是有返回值的,是一个泛型,和Future、FutureTask配合可以用来获取异步执行的结果。

    40. 线程有哪些状态?

    线程通常都有五种状态,创建、就绪、运行、阻塞和死亡。

    • 创建状态。在生成线程对象,并没有调用该对象的start方法,这是线程处于创建状态。
    • 就绪状态。当调用了线程对象的start方法之后,该线程就进入了就绪状态,但是此时线程调度程序还没有把该线程设置为当前线程,此时处于就绪状态。在线程运行之后,从等待或者睡眠中回来之后,也会处于就绪状态。
    • 运行状态。线程调度程序将处于就绪状态的线程设置为当前线程,此时线程就进入了运行状态,开始运行run函数当中的代码。
    • 阻塞状态。线程正在运行的时候,被暂停,通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend,wait等方法都可以导致线程阻塞。
    • 死亡状态。如果一个线程的run方法执行结束或者调用stop方法后,该线程就会死亡。对于已经死亡的线程,无法再使用start方法令其进入就绪   

    41. sleep() 和 wait() 有什么区别?

    sleep():方法是线程类(Thread)的静态方法,让调用线程进入睡眠状态,让出执行机会给其他线程,等到休眠时间结束后,线程进入就绪状态和其他线程一起竞争cpu的执行时间。因为sleep() 是static静态的方法,他不能改变对象的机锁,当一个synchronized块中调用了sleep() 方法,线程虽然进入休眠,但是对象的机锁没有被释放,其他线程依然无法访问这个对象。

    wait():wait()是Object类的方法,当一个线程执行到wait方法时,它就进入到一个和该对象相关的等待池,同时释放对象的机锁,使得其他线程能够访问,可以通过notify,notifyAll方法来唤醒等待的线程。

    42. notify()和 notifyAll()有什么区别?

    • 如果线程调用了对象的 wait()方法,那么线程便会处于该对象的等待池中,等待池中的线程不会去竞争该对象的锁。
    • 当有线程调用了对象的 notifyAll()方法(唤醒所有 wait 线程)或 notify()方法(只随机唤醒一个 wait 线程),被唤醒的的线程便会进入该对象的锁池中,锁池中的线程会去竞争该对象锁。也就是说,调用了notify后只要一个线程会由等待池进入锁池,而notifyAll会将该对象等待池内的所有线程移动到锁池中,等待锁竞争。
    • 优先级高的线程竞争到对象锁的概率大,假若某线程没有竞争到该对象锁,它还会留在锁池中,唯有线程再次调用 wait()方法,它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行,直到执行完了 synchronized 代码块,它会释放掉该对象锁,这时锁池中的线程会继续竞争该对象锁。

    43. 线程的 run()和 start()有什么区别?

    每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的,方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。

    start()方法来启动一个线程,真正实现了多线程运行。这时无需等待run方法体代码执行完毕,可以直接继续执行下面的代码; 这时此线程是处于就绪状态, 并没有运行。 然后通过此Thread类调用方法run()来完成其运行状态, 这里方法run()称为线程体,它包含了要执行的这个线程的内容, Run方法运行结束, 此线程终止。然后CPU再调度其它线程。

    run()方法是在本线程里的,只是线程里的一个函数,而不是多线程的。 如果直接调用run(),其实就相当于是调用了一个普通函数而已,直接待用run()方法必须等待run()方法执行完毕才能执行下面的代码,所以执行路径还是只有一条,根本就没有线程的特征,所以在多线程执行时要使用start()方法而不是run()方法。

    44. 创建线程池有哪几种方式?

    ①. newFixedThreadPool(int nThreads)

    创建一个固定长度的线程池,每当提交一个任务就创建一个线程,直到达到线程池的最大数量,这时线程规模将不再变化,当线程发生未预期的错误而结束时,线程池会补充一个新的线程。

    ②. newCachedThreadPool()

    创建一个可缓存的线程池,如果线程池的规模超过了处理需求,将自动回收空闲线程,而当需求增加时,则可以自动添加新线程,线程池的规模不存在任何限制。

    ③. newSingleThreadExecutor()

    这是一个单线程的Executor,它创建单个工作线程来执行任务,如果这个线程异常结束,会创建一个新的来替代它;它的特点是能确保依照任务在队列中的顺序来串行执行。

    ④. newScheduledThreadPool(int corePoolSize)

    创建了一个固定长度的线程池,而且以延迟或定时的方式来执行任务,类似于Timer。

    45. 线程池都有哪些状态?

    线程池有5种状态:Running、ShutDown、Stop、Tidying、Terminated。

    线程池各个状态切换框架图:

    46. 线程池中 submit()和 execute()方法有什么区别?

    • 接收的参数不一样
    • submit有返回值,而execute没有
    • submit方便Exception处理

    47. 在 java 程序中怎么保证多线程的运行安全?

    线程安全在三个方面体现:

    • 原子性:提供互斥访问,同一时刻只能有一个线程对数据进行操作,(atomic,synchronized);
    • 可见性:一个线程对主内存的修改可以及时地被其他线程看到,(synchronized,volatile);
    • 有序性:一个线程观察其他线程中的指令执行顺序,由于指令重排序,该观察结果一般杂乱无序,(happens-before原则)。

    48. 多线程锁的升级原理是什么?

    在Java中,锁共有4种状态,级别从低到高依次为:无状态锁,偏向锁,轻量级锁和重量级锁状态,这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级。

    锁升级的图示过程: 

    49. 什么是死锁?

    死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。是操作系统层面的一个错误,是进程死锁的简称,最早在 1965 年由 Dijkstra 在研究银行家算法时提出的,它是计算机操作系统乃至整个并发程序设计领域最难处理的问题之一。

    50. 怎么防止死锁?

    死锁的四个必要条件:

    • 互斥条件:进程对所分配到的资源不允许其他进程进行访问,若其他进程访问该资源,只能等待,直至占有该资源的进程使用完成后释放该资源
    • 请求和保持条件:进程获得一定的资源之后,又对其他资源发出请求,但是该资源可能被其他进程占有,此事请求阻塞,但又对自己获得的资源保持不放
    • 不可剥夺条件:是指进程已获得的资源,在未完成使用之前,不可被剥夺,只能在使用完后自己释放
    • 环路等待条件:是指进程发生死锁后,若干进程之间形成一种头尾相接的循环等待资源关系

    这四个条件是死锁的必要条件,只要系统发生死锁,这些条件必然成立,而只要上述条件之 一不满足,就不会发生死锁。

    理解了死锁的原因,尤其是产生死锁的四个必要条件,就可以最大可能地避免、预防和 解除死锁。

    所以,在系统设计、进程调度等方面注意如何不让这四个必要条件成立,如何确 定资源的合理分配算法,避免进程永久占据系统资源。

    此外,也要防止进程在处于等待状态的情况下占用资源。因此,对资源的分配要给予合理的规划。

    51. ThreadLocal 是什么?有哪些使用场景?

    线程局部变量是局限于线程内部的变量,属于线程自身所有,不在多个线程间共享。Java提供ThreadLocal类来支持线程局部变量,是一种实现线程安全的方式。但是在管理环境下(如 web 服务器)使用线程局部变量的时候要特别小心,在这种情况下,工作线程的生命周期比任何应用变量的生命周期都要长。任何线程局部变量一旦在工作完成后没有释放,Java 应用就存在内存泄露的风险。

    52.说一下 synchronized 底层实现原理?

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

    Java中每一个对象都可以作为锁,这是synchronized实现同步的基础:

    • 普通同步方法,锁是当前实例对象
    • 静态同步方法,锁是当前类的class对象
    • 同步方法块,锁是括号里面的对象

    53. synchronized 和 volatile 的区别是什么?

    • volatile本质是在告诉jvm当前变量在寄存器(工作内存)中的值是不确定的,需要从主存中读取; synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住。
    • volatile仅能使用在变量级别;synchronized则可以使用在变量、方法、和类级别的。
    • volatile仅能实现变量的修改可见性,不能保证原子性;而synchronized则可以保证变量的修改可见性和原子性。
    • volatile不会造成线程的阻塞;synchronized可能会造成线程的阻塞。
    • volatile标记的变量不会被编译器优化;synchronized标记的变量可以被编译器优化。

    54. synchronized 和 Lock 有什么区别?

    • 首先synchronized是java内置关键字,在jvm层面,Lock是个java类;
    • synchronized无法判断是否获取锁的状态,Lock可以判断是否获取到锁;
    • synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ;b 线程执行过程中发生异常会释放锁),Lock需在finally中手工释放锁(unlock()方法释放锁),否则容易造成线程死锁;
    • 用synchronized关键字的两个线程1和线程2,如果当前线程1获得锁,线程2线程等待。如果线程1阻塞,线程2则会一直等待下去,而Lock锁就不一定会等待下去,如果尝试获取不到锁,线程可以不用一直等待就结束了;
    • synchronized的锁可重入、不可中断、非公平,而Lock锁可重入、可判断、可公平(两者皆可);
    • Lock锁适合大量同步的代码的同步问题,synchronized锁适合代码少量的同步问题。

    55. synchronized 和 ReentrantLock 区别是什么?

    synchronized是和if、else、for、while一样的关键字,ReentrantLock是类,这是二者的本质区别。既然ReentrantLock是类,那么它就提供了比synchronized更多更灵活的特性,可以被继承、可以有方法、可以有各种各样的类变量,ReentrantLock比synchronized的扩展性体现在几点上: 

    • ReentrantLock可以对获取锁的等待时间进行设置,这样就避免了死锁 
    • ReentrantLock可以获取各种锁的信息
    • ReentrantLock可以灵活地实现多路通知 

    另外,二者的锁机制其实也是不一样的:ReentrantLock底层调用的是Unsafe的park方法加锁,synchronized操作的应该是对象头中mark word。

    56. 说一下 atomic 的原理?

    Atomic包中的类基本的特性就是在多线程环境下,当有多个线程同时对单个(包括基本类型及引用类型)变量进行操作时,具有排他性,即当多个线程同时对该变量的值进行更新时,仅有一个线程能成功,而未成功的线程可以向自旋锁一样,继续尝试,一直等到执行成功。

    Atomic系列的类中的核心方法都会调用unsafe类中的几个本地方法。我们需要先知道一个东西就是Unsafe类,全名为:sun.misc.Unsafe,这个类包含了大量的对C代码的操作,包括很多直接内存分配以及原子操作的调用,而它之所以标记为非安全的,是告诉你这个里面大量的方法调用都会存在安全隐患,需要小心使用,否则会导致严重的后果,例如在通过unsafe分配内存的时候,如果自己指定某些区域可能会导致一些类似C++一样的指针越界到其他进程的问题。


    四、反射

    57. 什么是反射?

    反射主要是指程序可以访问、检测和修改它本身状态或行为的一种能力

    Java反射:

    在Java运行时环境中,对于任意一个类,能否知道这个类有哪些属性和方法?对于任意一个对象,能否调用它的任意一个方法

    Java反射机制主要提供了以下功能:

    • 在运行时判断任意一个对象所属的类。
    • 在运行时构造任意一个类的对象。
    • 在运行时判断任意一个类所具有的成员变量和方法。
    • 在运行时调用任意一个对象的方法。 

    58. 什么是 java 序列化?什么情况下需要序列化?

    简单说就是为了保存在内存中的各种对象的状态(也就是实例变量,不是方法),并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states,但是Java给你提供一种应该比你自己好的保存对象状态的机制,那就是序列化。

    什么情况下需要序列化:

    a)当你想把的内存中的对象状态保存到一个文件中或者数据库中时候;
    b)当你想用套接字在网络上传送对象的时候;
    c)当你想通过RMI传输对象的时候;

    59. 动态代理是什么?有哪些应用?

    动态代理:

    当想要给实现了某个接口的类中的方法,加一些额外的处理。比如说加日志,加事务等。可以给这个类创建一个代理,故名思议就是创建一个新的类,这个类不仅包含原来类方法的功能,而且还在原来的基础上添加了额外处理的新类。这个代理类并不是定义好的,是动态生成的。具有解耦意义,灵活,扩展性强。

    动态代理的应用:

    • Spring的AOP
    • 加事务
    • 加权限
    • 加日志

    60. 怎么实现动态代理?

    首先必须定义一个接口,还要有一个InvocationHandler(将实现接口的类的对象传递给它)处理类。再有一个工具类Proxy(习惯性将其称为代理类,因为调用他的newInstance()可以产生代理对象,其实他只是一个产生代理对象的工具类)。利用到InvocationHandler,拼接代理类源码,将其编译生成代理类的二进制码,利用加载器加载,并将其实例化产生代理对象,最后返回。


    五、对象拷贝

    61. 为什么要使用克隆?

    想对一个对象进行处理,又想保留原有的数据进行接下来的操作,就需要克隆了,Java语言中克隆针对的是类的实例。

    62. 如何实现对象克隆?

    有两种方式:

    1). 实现Cloneable接口并重写Object类中的clone()方法;

    2). 实现Serializable接口,通过对象的序列化和反序列化实现克隆,可以实现真正的深度克隆,代码如下:

    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class MyUtil {
    
        private MyUtil() {
            throw new AssertionError();
        }
    
        @SuppressWarnings("unchecked")
        public static <T extends Serializable> T clone(T obj) throws Exception {
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bout);
            oos.writeObject(obj);
    
            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bin);
            return (T) ois.readObject();
    
            // 说明:调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义
            // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源,这一点不同于对外部资源(如文件流)的释放
        }
    }

    下面是测试代码:

    
    import java.io.Serializable;
    
    /**
     * 人类
     * @author nnngu
     *
     */
    class Person implements Serializable {
        private static final long serialVersionUID = -9102017020286042305L;
    
        private String name;    // 姓名
        private int age;        // 年龄
        private Car car;        // 座驾
    
        public Person(String name, int age, Car car) {
            this.name = name;
            this.age = age;
            this.car = car;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public Car getCar() {
            return car;
        }
    
        public void setCar(Car car) {
            this.car = car;
        }
    
        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
        }
    
    }
    
    /**
     * 小汽车类
     * @author nnngu
     *
     */
    class Car implements Serializable {
        private static final long serialVersionUID = -5713945027627603702L;
    
        private String brand;       // 品牌
        private int maxSpeed;       // 最高时速
    
        public Car(String brand, int maxSpeed) {
            this.brand = brand;
            this.maxSpeed = maxSpeed;
        }
    
        public String getBrand() {
            return brand;
        }
    
        public void setBrand(String brand) {
            this.brand = brand;
        }
    
        public int getMaxSpeed() {
            return maxSpeed;
        }
    
        public void setMaxSpeed(int maxSpeed) {
            this.maxSpeed = maxSpeed;
        }
    
        @Override
        public String toString() {
            return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
        }
    
    }
    class CloneTest {
    
        public static void main(String[] args) {
            try {
                Person p1 = new Person("郭靖", 33, new Car("Benz", 300));
                Person p2 = MyUtil.clone(p1);   // 深度克隆
                p2.getCar().setBrand("BYD");
                // 修改克隆的Person对象p2关联的汽车对象的品牌属性
                // 原来的Person对象p1关联的汽车不会受到任何影响
                // 因为在克隆Person对象时其关联的汽车对象也被克隆了
                System.out.println(p1);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    注意:基于序列化和反序列化实现的克隆不仅仅是深度克隆,更重要的是通过泛型限定,可以检查出要克隆的对象是否支持序列化,这项检查是编译器完成的,不是在运行时抛出异常,这种是方案明显优于使用Object类的clone方法克隆对象。让问题在编译的时候暴露出来总是好过把问题留到运行时。

    63. 深拷贝和浅拷贝区别是什么?

    • 浅拷贝只是复制了对象的引用地址,两个对象指向同一个内存地址,所以修改其中任意的值,另一个值都会随之变化,这就是浅拷贝(例:assign())
    • 深拷贝是将对象及值复制过来,两个对象修改其中任意的值另一个值不会改变,这就是深拷贝(例:JSON.parse()和JSON.stringify(),但是此方法无法复制函数类型)

    六、Java Web

    64. jsp 和 servlet 有什么区别?

    1. jsp经编译后就变成了Servlet.(JSP的本质就是Servlet,JVM只能识别java的类,不能识别JSP的代码,Web容器将JSP的代码编译成JVM能够识别的java类)
    2. jsp更擅长表现于页面显示,servlet更擅长于逻辑控制。
    3. Servlet中没有内置对象,Jsp中的内置对象都是必须通过HttpServletRequest对象,HttpServletResponse对象以及HttpServlet对象得到。
    4. Jsp是Servlet的一种简化,使用Jsp只需要完成程序员需要输出到客户端的内容,Jsp中的Java脚本如何镶嵌到一个类中,由Jsp容器完成。而Servlet则是个完整的Java类,这个类的Service方法用于生成对客户端的响应。

    65. jsp 有哪些内置对象?作用分别是什么?

    JSP有9个内置对象:

    • request:封装客户端的请求,其中包含来自GET或POST请求的参数;
    • response:封装服务器对客户端的响应;
    • pageContext:通过该对象可以获取其他对象;
    • session:封装用户会话的对象;
    • application:封装服务器运行环境的对象;
    • out:输出服务器响应的输出流对象;
    • config:Web应用的配置对象;
    • page:JSP页面本身(相当于Java程序中的this);
    • exception:封装页面抛出异常的对象。

    66. 说一下 jsp 的 4 种作用域?

    JSP中的四种作用域包括page、request、session和application,具体来说:

    • page代表与一个页面相关的对象和属性。
    • request代表与Web客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面,涉及多个Web组件;需要在页面显示的临时数据可以置于此作用域。
    • session代表与某个用户与服务器建立的一次会话相关的对象和属性。跟某个用户相关的数据应该放在用户自己的session中。
    • application代表与整个Web应用程序相关的对象和属性,它实质上是跨越整个Web应用程序,包括多个页面、请求和会话的一个全局作用域。

    67. session 和 cookie 有什么区别?

    • 由于HTTP协议是无状态的协议,所以服务端需要记录用户的状态时,就需要用某种机制来识具体的用户,这个机制就是Session.典型的场景比如购物车,当你点击下单按钮时,由于HTTP协议无状态,所以并不知道是哪个用户操作的,所以服务端要为特定的用户创建了特定的Session,用用于标识这个用户,并且跟踪用户,这样才知道购物车里面有几本书。这个Session是保存在服务端的,有一个唯一标识。在服务端保存Session的方法很多,内存、数据库、文件都有。集群的时候也要考虑Session的转移,在大型的网站,一般会有专门的Session服务器集群,用来保存用户会话,这个时候 Session 信息都是放在内存的,使用一些缓存服务比如Memcached之类的来放 Session。
    • 思考一下服务端如何识别特定的客户?这个时候Cookie就登场了。每次HTTP请求的时候,客户端都会发送相应的Cookie信息到服务端。实际上大多数的应用都是用 Cookie 来实现Session跟踪的,第一次创建Session的时候,服务端会在HTTP协议中告诉客户端,需要在 Cookie 里面记录一个Session ID,以后每次请求把这个会话ID发送到服务器,我就知道你是谁了。有人问,如果客户端的浏览器禁用了 Cookie 怎么办?一般这种情况下,会使用一种叫做URL重写的技术来进行会话跟踪,即每次HTTP交互,URL后面都会被附加上一个诸如 sid=xxxxx 这样的参数,服务端据此来识别用户。
    • Cookie其实还可以用在一些方便用户的场景下,设想你某次登陆过一个网站,下次登录的时候不想再次输入账号了,怎么办?这个信息可以写到Cookie里面,访问网站的时候,网站页面的脚本可以读取这个信息,就自动帮你把用户名给填了,能够方便一下用户。这也是Cookie名称的由来,给用户的一点甜头。所以,总结一下:Session是在服务端保存的一个数据结构,用来跟踪用户的状态,这个数据可以保存在集群、数据库、文件中;Cookie是客户端保存用户信息的一种机制,用来记录用户的一些信息,也是实现Session的一种方式。

    68. 说一下 session 的工作原理?

    其实session是一个存在服务器上的类似于一个散列表格的文件。里面存有我们需要的信息,在我们需要用的时候可以从里面取出来。类似于一个大号的map吧,里面的键存储的是用户的sessionid,用户向服务器发送请求的时候会带上这个sessionid。这时就可以从中取出对应的值了。

    69. 如果客户端禁止 cookie 能实现 session 还能用吗?

    Cookie与 Session,一般认为是两个独立的东西,Session采用的是在服务器端保持状态的方案,而Cookie采用的是在客户端保持状态的方案。但为什么禁用Cookie就不能得到Session呢?因为Session是用Session ID来确定当前对话所对应的服务器Session,而Session ID是通过Cookie来传递的,禁用Cookie相当于失去了Session ID,也就得不到Session了。

    假定用户关闭Cookie的情况下使用Session,其实现途径有以下几种:

    1. 设置php.ini配置文件中的“session.use_trans_sid = 1”,或者编译时打开打开了“--enable-trans-sid”选项,让PHP自动跨页传递Session ID。
    2. 手动通过URL传值、隐藏表单传递Session ID。
    3. 用文件、数据库等形式保存Session ID,在跨页过程中手动调用。

    70. spring mvc 和 struts 的区别是什么?

    • 拦截机制的不同

    Struts2是类级别的拦截,每次请求就会创建一个Action,和Spring整合时Struts2的ActionBean注入作用域是原型模式prototype,然后通过setter,getter吧request数据注入到属性。Struts2中,一个Action对应一个request,response上下文,在接收参数时,可以通过属性接收,这说明属性参数是让多个方法共享的。Struts2中Action的一个方法可以对应一个url,而其类属性却被所有方法共享,这也就无法用注解或其他方式标识其所属方法了,只能设计为多例。

    SpringMVC是方法级别的拦截,一个方法对应一个Request上下文,所以方法直接基本上是独立的,独享request,response数据。而每个方法同时又何一个url对应,参数的传递是直接注入到方法中的,是方法所独有的。处理结果通过ModeMap返回给框架。在Spring整合时,SpringMVC的Controller Bean默认单例模式Singleton,所以默认对所有的请求,只会创建一个Controller,有应为没有共享的属性,所以是线程安全的,如果要改变默认的作用域,需要添加@Scope注解修改。

    Struts2有自己的拦截Interceptor机制,SpringMVC这是用的是独立的Aop方式,这样导致Struts2的配置文件量还是比SpringMVC大。

    • 底层框架的不同

    Struts2采用Filter(StrutsPrepareAndExecuteFilter)实现,SpringMVC(DispatcherServlet)则采用Servlet实现。Filter在容器启动之后即初始化;服务停止以后坠毁,晚于Servlet。Servlet在是在调用时初始化,先于Filter调用,服务停止后销毁。

    • 性能方面

    Struts2是类级别的拦截,每次请求对应实例一个新的Action,需要加载所有的属性值注入,SpringMVC实现了零配置,由于SpringMVC基于方法的拦截,有加载一次单例模式bean注入。所以,SpringMVC开发效率和性能高于Struts2。

    • 配置方面

    spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高。

    71. 如何避免 sql 注入?

    1. PreparedStatement(简单又有效的方法)
    2. 使用正则表达式过滤传入的参数
    3. 字符串过滤
    4. JSP中调用该函数检查是否包函非法字符
    5. JSP页面判断代码

    72. 什么是 XSS 攻击,如何避免?

    XSS攻击又称CSS,全称Cross Site Script  (跨站脚本攻击),其原理是攻击者向有XSS漏洞的网站中输入恶意的 HTML 代码,当用户浏览该网站时,这段 HTML 代码会自动执行,从而达到攻击的目的。XSS 攻击类似于 SQL 注入攻击,SQL注入攻击中以SQL语句作为用户输入,从而达到查询/修改/删除数据的目的,而在xss攻击中,通过插入恶意脚本,实现对用户游览器的控制,获取用户的一些信息。 XSS是 Web 程序中常见的漏洞,XSS 属于被动式且用于客户端的攻击方式。

    XSS防范的总体思路是:对输入(和URL参数)进行过滤,对输出进行编码。

    73. 什么是 CSRF 攻击,如何避免?

    CSRF(Cross-site request forgery)也被称为 one-click attack或者 session riding,中文全称是叫跨站请求伪造。一般来说,攻击者通过伪造用户的浏览器的请求,向访问一个用户自己曾经认证访问过的网站发送出去,使目标网站接收并误以为是用户的真实操作而去执行命令。常用于盗取账号、转账、发送虚假消息等。攻击者利用网站对请求的验证漏洞而实现这样的攻击行为,网站能够确认请求来源于用户的浏览器,却不能验证请求是否源于用户的真实意愿下的操作行为。

    如何避免:

    1. 验证 HTTP Referer 字段

    HTTP头中的Referer字段记录了该 HTTP 请求的来源地址。在通常情况下,访问一个安全受限页面的请求来自于同一个网站,而如果黑客要对其实施 CSRF
    攻击,他一般只能在他自己的网站构造请求。因此,可以通过验证Referer值来防御CSRF 攻击。

    2. 使用验证码

    关键操作页面加上验证码,后台收到请求后通过判断验证码可以防御CSRF。但这种方法对用户不太友好。

    3. 在请求地址中添加token并验证

    CSRF 攻击之所以能够成功,是因为黑客可以完全伪造用户的请求,该请求中所有的用户验证信息都是存在于cookie中,因此黑客可以在不知道这些验证信息的情况下直接利用用户自己的cookie 来通过安全验证。要抵御 CSRF,关键在于在请求中放入黑客所不能伪造的信息,并且该信息不存在于 cookie 之中。可以在 HTTP 请求中以参数的形式加入一个随机产生的 token,并在服务器端建立一个拦截器来验证这个 token,如果请求中没有token或者 token 内容不正确,则认为可能是 CSRF 攻击而拒绝该请求。这种方法要比检查 Referer 要安全一些,token 可以在用户登陆后产生并放于session之中,然后在每次请求时把token 从 session 中拿出,与请求中的 token 进行比对,但这种方法的难点在于如何把 token 以参数的形式加入请求。
    对于 GET 请求,token 将附在请求地址之后,这样 URL 就变成 http://url?csrftoken=tokenvalue。
    而对于 POST 请求来说,要在 form 的最后加上 <input type="hidden" name="csrftoken" value="tokenvalue"/>,这样就把token以参数的形式加入请求了。

    4. 在HTTP 头中自定义属性并验证

    这种方法也是使用 token 并进行验证,和上一种方法不同的是,这里并不是把 token 以参数的形式置于 HTTP 请求之中,而是把它放到 HTTP 头中自定义的属性里。通过 XMLHttpRequest 这个类,可以一次性给所有该类请求加上 csrftoken 这个 HTTP 头属性,并把 token 值放入其中。这样解决了上种方法在请求中加入 token 的不便,同时,通过 XMLHttpRequest 请求的地址不会被记录到浏览器的地址栏,也不用担心 token 会透过 Referer 泄露到其他网站中去。


    七、异常

    74. throw 和 throws 的区别?

    throws是用来声明一个方法可能抛出的所有异常信息,throws是将异常声明但是不处理,而是将异常往上传,谁调用我就交给谁处理。而throw则是指抛出的一个具体的异常类型。

    75. final、finally、finalize 有什么区别?

    • final可以修饰类、变量、方法,修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。
    • finally一般作用在try-catch代码块中,在处理异常的时候,通常我们将一定要执行的代码方法finally代码块中,表示不管是否出现异常,该代码块都会执行,一般用来存放一些关闭资源的代码。
    • finalize是一个方法,属于Object类的一个方法,而Object类是所有类的父类,该方法一般由垃圾回收器来调用,当我们调用System的gc()方法的时候,由垃圾回收器调用finalize(),回收垃圾。 

    76. try-catch-finally 中哪个部分可以省略?

    答:catch 可以省略

    原因:

    更为严格的说法其实是:try只适合处理运行时异常,try+catch适合处理运行时异常+普通异常。也就是说,如果你只用try去处理普通异常却不加以catch处理,编译是通不过的,因为编译器硬性规定,普通异常如果选择捕获,则必须用catch显示声明以便进一步处理。而运行时异常在编译时没有如此规定,所以catch可以省略,你加上catch编译器也觉得无可厚非。

    理论上,编译器看任何代码都不顺眼,都觉得可能有潜在的问题,所以你即使对所有代码加上try,代码在运行期时也只不过是在正常运行的基础上加一层皮。但是你一旦对一段代码加上try,就等于显示地承诺编译器,对这段代码可能抛出的异常进行捕获而非向上抛出处理。如果是普通异常,编译器要求必须用catch捕获以便进一步处理;如果运行时异常,捕获然后丢弃并且+finally扫尾处理,或者加上catch捕获以便进一步处理。

    至于加上finally,则是在不管有没捕获异常,都要进行的“扫尾”处理。

    77. try-catch-finally 中,如果 catch 中 return 了,finally 还会执行吗?

    答:会执行,在 return 前执行。

    代码示例1:

    
    /*
     * java面试题--如果catch里面有return语句,finally里面的代码还会执行吗?
     */
    public class FinallyDemo2 {
        public static void main(String[] args) {
            System.out.println(getInt());
        }
    
        public static int getInt() {
            int a = 10;
            try {
                System.out.println(a / 0);
                a = 20;
            } catch (ArithmeticException e) {
                a = 30;
                return a;
                /*
                 * return a 在程序执行到这一步的时候,这里不是return a 而是 return 30;这个返回路径就形成了
                 * 但是呢,它发现后面还有finally,所以继续执行finally的内容,a=40
                 * 再次回到以前的路径,继续走return 30,形成返回路径之后,这里的a就不是a变量了,而是常量30
                 */
            } finally {
                a = 40;
            }
    
    //      return a;
        }
    }

    执行结果:30

    代码示例2:

    
    package com.java_02;
    
    /*
     * java面试题--如果catch里面有return语句,finally里面的代码还会执行吗?
     */
    public class FinallyDemo2 {
        public static void main(String[] args) {
            System.out.println(getInt());
        }
    
        public static int getInt() {
            int a = 10;
            try {
                System.out.println(a / 0);
                a = 20;
            } catch (ArithmeticException e) {
                a = 30;
                return a;
                /*
                 * return a 在程序执行到这一步的时候,这里不是return a 而是 return 30;这个返回路径就形成了
                 * 但是呢,它发现后面还有finally,所以继续执行finally的内容,a=40
                 * 再次回到以前的路径,继续走return 30,形成返回路径之后,这里的a就不是a变量了,而是常量30
                 */
            } finally {
                a = 40;
                return a; //如果这样,就又重新形成了一条返回路径,由于只能通过1个return返回,所以这里直接返回40
            }
    
    //      return a;
        }
    }

    执行结果:40

    78. 常见的异常类有哪些?

    • NullPointerException:当应用程序试图访问空对象时,则抛出该异常。
    • SQLException:提供关于数据库访问错误或其他错误信息的异常。
    • IndexOutOfBoundsException:指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。 
    • NumberFormatException:当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。
    • FileNotFoundException:当试图打开指定路径名表示的文件失败时,抛出此异常。
    • IOException:当发生某种I/O异常时,抛出此异常。此类是失败或中断的I/O操作生成的异常的通用类。
    • ClassCastException:当试图将对象强制转换为不是实例的子类时,抛出该异常。
    • ArrayStoreException:试图将错误类型的对象存储到一个对象数组时抛出的异常。
    • IllegalArgumentException:抛出的异常表明向方法传递了一个不合法或不正确的参数。
    • ArithmeticException:当出现异常的运算条件时,抛出此异常。例如,一个整数“除以零”时,抛出此类的一个实例。 
    • NegativeArraySizeException:如果应用程序试图创建大小为负的数组,则抛出该异常。
    • NoSuchMethodException:无法找到某一特定方法时,抛出该异常。
    • SecurityException:由安全管理器抛出的异常,指示存在安全侵犯。
    • UnsupportedOperationException:当不支持请求的操作时,抛出该异常。
    • RuntimeExceptionRuntimeException:是那些可能在Java虚拟机正常运行期间抛出的异常的超类。

    八、网络

    79. http 响应码 301 和 302 代表的是什么?有什么区别?

    答:301,302 都是HTTP状态的编码,都代表着某个URL发生了转移。

    区别: 

    • 301 redirect: 301 代表永久性转移(Permanently Moved)。
    • 302 redirect: 302 代表暂时性转移(Temporarily Moved )。 

    80. forward 和 redirect 的区别?

    Forward和Redirect代表了两种请求转发方式:直接转发和间接转发。

    直接转发方式(Forward),客户端和浏览器只发出一次请求,Servlet、HTML、JSP或其它信息资源,由第二个信息资源响应该请求,在请求对象request中,保存的对象对于每个信息资源是共享的。

    间接转发方式(Redirect)实际是两次HTTP请求,服务器端在响应第一次请求的时候,让浏览器再向另外一个URL发出请求,从而达到转发的目的。

    举个通俗的例子:

    直接转发就相当于:“A找B借钱,B说没有,B去找C借,借到借不到都会把消息传递给A”;

    间接转发就相当于:"A找B借钱,B说没有,让A去找C借"。

    81. 简述 tcp 和 udp的区别?

    • TCP面向连接(如打电话要先拨号建立连接);UDP是无连接的,即发送数据之前不需要建立连接。
    • TCP提供可靠的服务。也就是说,通过TCP连接传送的数据,无差错,不丢失,不重复,且按序到达;UDP尽最大努力交付,即不保证可靠交付。
    • Tcp通过校验和,重传控制,序号标识,滑动窗口、确认应答实现可靠传输。如丢包时的重发控制,还可以对次序乱掉的分包进行顺序控制。
    • UDP具有较好的实时性,工作效率比TCP高,适用于对高速传输和实时性有较高的通信或广播通信。
    • 每一条TCP连接只能是点到点的;UDP支持一对一,一对多,多对一和多对多的交互通信。
    • TCP对系统资源要求较多,UDP对系统资源要求较少。

    82. tcp 为什么要三次握手,两次不行吗?为什么?

    为了实现可靠数据传输, TCP 协议的通信双方, 都必须维护一个序列号, 以标识发送出去的数据包中, 哪些是已经被对方收到的。 三次握手的过程即是通信双方相互告知序列号起始值, 并确认对方已经收到了序列号起始值的必经步骤。

    如果只是两次握手, 至多只有连接发起方的起始序列号能被确认, 另一方选择的序列号则得不到确认。

    83. 说一下 tcp 粘包是怎么产生的?

    ①. 发送方产生粘包

    采用TCP协议传输数据的客户端与服务器经常是保持一个长连接的状态(一次连接发一次数据不存在粘包),双方在连接不断开的情况下,可以一直传输数据;但当发送的数据包过于的小时,那么TCP协议默认的会启用Nagle算法,将这些较小的数据包进行合并发送(缓冲区数据发送是一个堆压的过程);这个合并过程就是在发送缓冲区中进行的,也就是说数据发送出来它已经是粘包的状态了。

    ②. 接收方产生粘包

    接收方采用TCP协议接收数据时的过程是这样的:数据到底接收方,从网络模型的下方传递至传输层,传输层的TCP协议处理是将其放置接收缓冲区,然后由应用层来主动获取(C语言用recv、read等函数);这时会出现一个问题,就是我们在程序中调用的读取数据函数不能及时的把缓冲区中的数据拿出来,而下一个数据又到来并有一部分放入的缓冲区末尾,等我们读取数据时就是一个粘包。(放数据的速度 > 应用层拿数据速度) 

    84. OSI 的七层模型都有哪些?

    1. 应用层:网络服务与最终用户的一个接口。
    2. 表示层:数据的表示、安全、压缩。
    3. 会话层:建立、管理、终止会话。
    4. 传输层:定义传输数据的协议端口号,以及流控和差错校验。
    5. 网络层:进行逻辑地址寻址,实现不同网络之间的路径选择。
    6. 数据链路层:建立逻辑连接、进行硬件地址寻址、差错校验等功能。
    7. 物理层:建立、维护、断开物理连接。

    85. get 和 post 请求有哪些区别?

    • GET在浏览器回退时是无害的,而POST会再次提交请求。
    • GET产生的URL地址可以被Bookmark,而POST不可以。
    • GET请求会被浏览器主动cache,而POST不会,除非手动设置。
    • GET请求只能进行url编码,而POST支持多种编码方式。
    • GET请求参数会被完整保留在浏览器历史记录里,而POST中的参数不会被保留。
    • GET请求在URL中传送的参数是有长度限制的,而POST么有。
    • 对参数的数据类型,GET只接受ASCII字符,而POST没有限制。
    • GET比POST更不安全,因为参数直接暴露在URL上,所以不能用来传递敏感信息。
    • GET参数通过URL传递,POST放在Request body中。

    86. 如何实现跨域?

    方式一:图片ping或script标签跨域

    图片ping常用于跟踪用户点击页面或动态广告曝光次数。 
    script标签可以得到从其他来源数据,这也是JSONP依赖的根据。 

    方式二:JSONP跨域

    JSONP(JSON with Padding)是数据格式JSON的一种“使用模式”,可以让网页从别的网域要数据。根据 XmlHttpRequest 对象受到同源策略的影响,而利用 <script>元素的这个开放策略,网页可以得到从其他来源动态产生的JSON数据,而这种使用模式就是所谓的 JSONP。用JSONP抓到的数据并不是JSON,而是任意的JavaScript,用 JavaScript解释器运行而不是用JSON解析器解析。所有,通过Chrome查看所有JSONP发送的Get请求都是js类型,而非XHR。 

    缺点:

    • 只能使用Get请求
    • 不能注册success、error等事件监听函数,不能很容易的确定JSONP请求是否失败
    • JSONP是从其他域中加载代码执行,容易受到跨站请求伪造的攻击,其安全性无法确保

    方式三:CORS

    Cross-Origin Resource Sharing(CORS)跨域资源共享是一份浏览器技术的规范,提供了 Web 服务从不同域传来沙盒脚本的方法,以避开浏览器的同源策略,确保安全的跨域数据传输。现代浏览器使用CORS在API容器如XMLHttpRequest来减少HTTP请求的风险来源。与 JSONP 不同,CORS 除了 GET 要求方法以外也支持其他的 HTTP 要求。服务器一般需要增加如下响应头的一种或几种:

    Access-Control-Allow-Origin: *
    Access-Control-Allow-Methods: POST, GET, OPTIONS
    Access-Control-Allow-Headers: X-PINGOTHER, Content-Type
    Access-Control-Max-Age: 86400

    跨域请求默认不会携带Cookie信息,如果需要携带,请配置下述参数:

    "Access-Control-Allow-Credentials": true
    // Ajax设置
    "withCredentials": true

    方式四:window.name+iframe

    window.name通过在iframe(一般动态创建i)中加载跨域HTML文件来起作用。然后,HTML文件将传递给请求者的字符串内容赋值给window.name。然后,请求者可以检索window.name值作为响应。

    • iframe标签的跨域能力;
    • window.name属性值在文档刷新后依旧存在的能力(且最大允许2M左右)。

    每个iframe都有包裹它的window,而这个window是top window的子窗口。contentWindow属性返回<iframe>元素的Window对象。你可以使用这个Window对象来访问iframe的文档及其内部DOM。

    <!-- 
     下述用端口 
     10000表示:domainA
     10001表示:domainB
    -->
    
    <!-- localhost:10000 -->
    <script>
      var iframe = document.createElement('iframe');
      iframe.style.display = 'none'; // 隐藏
    
      var state = 0; // 防止页面无限刷新
      iframe.onload = function() {
          if(state === 1) {
              console.log(JSON.parse(iframe.contentWindow.name));
              // 清除创建的iframe
              iframe.contentWindow.document.write('');
              iframe.contentWindow.close();
              document.body.removeChild(iframe);
          } else if(state === 0) {
              state = 1;
              // 加载完成,指向当前域,防止错误(proxy.html为空白页面)
              // Blocked a frame with origin "http://localhost:10000" from accessing a cross-origin frame.
              iframe.contentWindow.location = 'http://localhost:10000/proxy.html';
          }
      };
    
      iframe.src = 'http://localhost:10001';
      document.body.appendChild(iframe);
    </script>
    
    <!-- localhost:10001 -->
    <!DOCTYPE html>
    ...
    <script>
      window.name = JSON.stringify({a: 1, b: 2});
    </script>
    </html>
    

    方式五:window.postMessage()

    HTML5新特性,可以用来向其他所有的 window 对象发送消息。需要注意的是我们必须要保证所有的脚本执行完才发送 MessageEvent,如果在函数执行的过程中调用了它,就会让后面的函数超时无法执行。

    下述代码实现了跨域存储localStorage

    <!-- 
     下述用端口 
     10000表示:domainA
     10001表示:domainB
    -->
    
    <!-- localhost:10000 -->
    <iframe src="http://localhost:10001/msg.html" name="myPostMessage" style="display:none;">
    </iframe>
    
    <script>
      function main() {
          LSsetItem('test', 'Test: ' + new Date());
          LSgetItem('test', function(value) {
              console.log('value: ' + value);
          });
          LSremoveItem('test');
      }
    
      var callbacks = {};
      window.addEventListener('message', function(event) {
          if (event.source === frames['myPostMessage']) {
              console.log(event)
              var data = /^#localStorage#(\d+)(null)?#([\S\s]*)/.exec(event.data);
              if (data) {
                  if (callbacks[data[1]]) {
                      callbacks[data[1]](data[2] === 'null' ? null : data[3]);
                  }
                  delete callbacks[data[1]];
              }
          }
      }, false);
    
      var domain = '*';
      // 增加
      function LSsetItem(key, value) {
          var obj = {
              setItem: key,
              value: value
          };
          frames['myPostMessage'].postMessage(JSON.stringify(obj), domain);
      }
      // 获取
      function LSgetItem(key, callback) {
          var identifier = new Date().getTime();
          var obj = {
              identifier: identifier,
              getItem: key
          };
          callbacks[identifier] = callback;
          frames['myPostMessage'].postMessage(JSON.stringify(obj), domain);
      }
      // 删除
      function LSremoveItem(key) {
          var obj = {
              removeItem: key
          };
          frames['myPostMessage'].postMessage(JSON.stringify(obj), domain);
      }
    </script>
    
    <!-- localhost:10001 -->
    <script>
      window.addEventListener('message', function(event) {
        console.log('Receiver debugging', event);
        if (event.origin == 'http://localhost:10000') {
          var data = JSON.parse(event.data);
          if ('setItem' in data) {
            localStorage.setItem(data.setItem, data.value);
          } else if ('getItem' in data) {
            var gotItem = localStorage.getItem(data.getItem);
            event.source.postMessage(
              '#localStorage#' + data.identifier +
              (gotItem === null ? 'null#' : '#' + gotItem),
              event.origin
            );
          } else if ('removeItem' in data) {
            localStorage.removeItem(data.removeItem);
          }
        }
      }, false);
    </script>

    注意Safari一下,会报错:

    Blocked a frame with origin “http://localhost:10001” from accessing a frame with origin “http://localhost:10000“. Protocols, domains, and ports must match.

    避免该错误,可以在Safari浏览器中勾选开发菜单==>停用跨域限制。或者只能使用服务器端转存的方式实现,因为Safari浏览器默认只支持CORS跨域请求。

    方式六:修改document.domain跨子域

    前提条件:这两个域名必须属于同一个基础域名!而且所用的协议,端口都要一致,否则无法利用document.domain进行跨域,所以只能跨子域

    在根域范围内,允许把domain属性的值设置为它的上一级域。例如,在”aaa.xxx.com”域内,可以把domain设置为 “xxx.com” 但不能设置为 “xxx.org” 或者”com”。

    现在存在两个域名aaa.xxx.com和bbb.xxx.com。在aaa下嵌入bbb的页面,由于其document.name不一致,无法在aaa下操作bbb的js。可以在aaa和bbb下通过js将document.name = 'xxx.com';设置一致,来达到互相访问的作用。

    方式七:WebSocket

    WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信,同时允许跨域通讯,是server push技术的一种很棒的实现。相关文章,请查看:WebSocket、WebSocket-SockJS

    需要注意:WebSocket对象不支持DOM 2级事件侦听器,必须使用DOM 0级语法分别定义各个事件。

    方式八:代理

    同源策略是针对浏览器端进行的限制,可以通过服务器端来解决该问题

    DomainA客户端(浏览器) ==> DomainA服务器 ==> DomainB服务器 ==> DomainA客户端(浏览器)

    来源:blog.csdn.net/ligang2585116/article/details/73072868

    87.说一下 JSONP 实现原理?

    jsonp 即 json+padding,动态创建script标签,利用script标签的src属性可以获取任何域下的js脚本,通过这个特性(也可以说漏洞),服务器端不在返货json格式,而是返回一段调用某个函数的js代码,在src中进行了调用,这样实现了跨域。


    九、设计模式

    88. 说一下你熟悉的设计模式?

    参考:常用的设计模式汇总,超详细!

    89. 简单工厂和抽象工厂有什么区别?

    简单工厂模式

    这个模式本身很简单而且使用在业务较简单的情况下。一般用于小项目或者具体产品很少扩展的情况(这样工厂类才不用经常更改)。

    它由三种角色组成:

    • 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑,根据逻辑不同,产生具体的工厂产品。如例子中的Driver类。
    • 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类来实现。如例中的Car接口。
    • 具体产品角色:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现,如例子中的Benz、Bmw类。

    来用类图来清晰的表示下的它们之间的关系:

    抽象工厂模式:

    先来认识下什么是产品族: 位于不同产品等级结构中,功能相关联的产品组成的家族。

    图中的BmwCar和BenzCar就是两个产品树(产品层次结构);而如图所示的BenzSportsCar和BmwSportsCar就是一个产品族。他们都可以放到跑车家族中,因此功能有所关联。同理BmwBussinessCar和BenzBusinessCar也是一个产品族。

    可以这么说,它和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。抽象工厂模式的用意为:给客户端提供一个接口,可以创建多个产品族中的产品对象。

    而且使用抽象工厂模式还要满足一下条件:

    1. 系统中有多个产品族,而系统一次只可能消费其中一族产品
    2. 同属于同一个产品族的产品以其使用。

    来看看抽象工厂模式的各个角色(和工厂方法的如出一辙):

    • 抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
    • 具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
    • 抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
    • 具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

    十、Spring / Spring MVC

    90. 为什么要使用 spring?

    1.简介

    • 目的:解决企业应用开发的复杂性
    • 功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能
    • 范围:任何Java应用

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

    2.轻量 

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

    3.控制反转  

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

    4.面向切面  

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

    5.容器

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

    6.框架

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

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

    91. 解释一下什么是 aop?

    AOP(Aspect-Oriented Programming,面向方面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候,OOP则显得无能为力。也就是说,OOP允许你定义从上到下的关系,但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中,而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码,如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切(cross-cutting)代码,在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。

    而AOP技术则恰恰相反,它利用一种称为“横切”的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其名为“Aspect”,即方面。所谓“方面”,简单地说,就是将那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系,如果说“对象”是一个空心的圆柱体,其中封装的是对象的属性和行为;那么面向方面编程的方法,就仿佛一把利刃,将这些空心圆柱体剖开,以获得其内部的消息。而剖开的切面,也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原,不留痕迹。

    使用“横切”技术,AOP把软件系统分为两个部分:核心关注点和横切关注点。业务处理的主要流程是核心关注点,与之关系不大的部分是横切关注点。横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处都基本相似。比如权限认证、日志、事务处理。Aop 的作用在于分离系统中的各种关注点,将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说,AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”

    92. 解释一下什么是 ioc?

    IOC是Inversion of Control的缩写,多数书籍翻译成“控制反转”。

    1996年,Michael Mattson在一篇有关探讨面向对象框架的文章中,首先提出了IOC 这个概念。对于面向对象设计及编程的基本思想,前面我们已经讲了很多了,不再赘述,简单来说就是把复杂系统分解成相互合作的对象,这些对象类通过封装以后,内部实现对外部是透明的,从而降低了解决问题的复杂度,而且可以灵活地被重用和扩展。

    IOC理论提出的观点大体是这样的:借助于“第三方”实现具有依赖关系的对象之间的解耦。如下图:

    大家看到了吧,由于引进了中间位置的“第三方”,也就是IOC容器,使得A、B、C、D这4个对象没有了耦合关系,齿轮之间的传动全部依靠“第三方”了,全部对象的控制权全部上缴给“第三方”IOC容器,所以,IOC容器成了整个系统的关键核心,它起到了一种类似“粘合剂”的作用,把系统中的所有对象粘合在一起发挥作用,如果没有这个“粘合剂”,对象与对象之间会彼此失去联系,这就是有人把IOC容器比喻成“粘合剂”的由来。

    我们再来做个试验:把上图中间的IOC容器拿掉,然后再来看看这套系统:

    我们现在看到的画面,就是我们要实现整个系统所需要完成的全部内容。这时候,A、B、C、D这4个对象之间已经没有了耦合关系,彼此毫无联系,这样的话,当你在实现A的时候,根本无须再去考虑B、C和D了,对象之间的依赖关系已经降低到了最低程度。所以,如果真能实现IOC容器,对于系统开发而言,这将是一件多么美好的事情,参与开发的每一成员只要实现自己的类就可以了,跟别人没有任何关系!

    我们再来看看,控制反转(IOC)到底为什么要起这么个名字?我们来对比一下:

    软件系统在没有引入IOC容器之前,如图1所示,对象A依赖于对象B,那么对象A在初始化或者运行到某一点的时候,自己必须主动去创建对象B或者使用已经创建的对象B。无论是创建还是使用对象B,控制权都在自己手上。

    软件系统在引入IOC容器之后,这种情形就完全改变了,如图3所示,由于IOC容器的加入,对象A与对象B之间失去了直接联系,所以,当对象A运行到需要对象B的时候,IOC容器会主动创建一个对象B注入到对象A需要的地方。

    通过前后的对比,我们不难看出来:对象A获得依赖对象B的过程,由主动行为变为了被动行为,控制权颠倒过来了,这就是“控制反转”这个名称的由来。

    93. spring 有哪些主要模块?

    Spring框架至今已集成了20多个模块。这些模块主要被分如下图所示的核心容器、数据访问/集成,、Web、AOP(面向切面编程)、工具、消息和测试模块。

    更多信息:howtodoinjava.com/java-spring-framework-tutorials/

    94. spring 常用的注入方式有哪些?

    Spring通过DI(依赖注入)实现IOC(控制反转),常用的注入方式主要有三种:

    1. 构造方法注入
    2. setter注入
    3. 基于注解的注入

    95. spring 中的 bean 是线程安全的吗?

    Spring容器中的Bean是否线程安全,容器本身并没有提供Bean的线程安全策略,因此可以说spring容器中的Bean本身不具备线程安全的特性,但是具体还是要结合具体scope的Bean去研究。

    96. spring 支持几种 bean 的作用域?

    当通过spring容器创建一个Bean实例时,不仅可以完成Bean实例的实例化,还可以为Bean指定特定的作用域。Spring支持如下5种作用域:

    • singleton:单例模式,在整个Spring IoC容器中,使用singleton定义的Bean将只有一个实例
    • prototype:原型模式,每次通过容器的getBean方法获取prototype定义的Bean时,都将产生一个新的Bean实例
    • request:对于每次HTTP请求,使用request定义的Bean都将产生一个新实例,即每次HTTP请求将会产生不同的Bean实例。只有在Web应用中使用Spring时,该作用域才有效
    • session:对于每次HTTP Session,使用session定义的Bean豆浆产生一个新实例。同样只有在Web应用中使用Spring时,该作用域才有效
    • globalsession:每个全局的HTTP Session,使用session定义的Bean都将产生一个新实例。典型情况下,仅在使用portlet context的时候有效。同样只有在Web应用中使用Spring时,该作用域才有效

    其中比较常用的是singleton和prototype两种作用域。对于singleton作用域的Bean,每次请求该Bean都将获得相同的实例。容器负责跟踪Bean实例的状态,负责维护Bean实例的生命周期行为;如果一个Bean被设置成prototype作用域,程序每次请求该id的Bean,Spring都会新建一个Bean实例,然后返回给程序。在这种情况下,Spring容器仅仅使用new 关键字创建Bean实例,一旦创建成功,容器不在跟踪实例,也不会维护Bean实例的状态。

    如果不指定Bean的作用域,Spring默认使用singleton作用域。Java在创建Java实例时,需要进行内存申请;销毁实例时,需要完成垃圾回收,这些工作都会导致系统开销的增加。因此,prototype作用域Bean的创建、销毁代价比较大。而singleton作用域的Bean实例一旦创建成功,可以重复使用。因此,除非必要,否则尽量避免将Bean被设置成prototype作用域。

    97. spring 自动装配 bean 有哪些方式?

    Spring容器负责创建应用程序中的bean同时通过ID来协调这些对象之间的关系。作为开发人员,我们需要告诉Spring要创建哪些bean并且如何将其装配到一起。

    spring中bean装配有两种方式:

    • 隐式的bean发现机制和自动装配
    • 在java代码或者XML中进行显示配置

    当然这些方式也可以配合使用。

    98. spring 事务实现方式有哪些?

    1. 编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法,这就是编程式事务管理。
    2. 基于 TransactionProxyFactoryBean 的声明式事务管理
    3. 基于 @Transactional 的声明式事务管理
    4. 基于 Aspectj AOP 配置事务

    99. 说一下 spring 的事务隔离?

    事务隔离级别指的是一个事务对数据的修改与另一个并行的事务的隔离程度,当多个事务同时访问相同数据时,如果没有采取必要的隔离机制,就可能发生以下问题:

    • 脏读:一个事务读到另一个事务未提交的更新数据。
    • 幻读:例如第一个事务对一个表中的数据进行了修改,比如这种修改涉及到表中的“全部数据行”。同时,第二个事务也修改这个表中的数据,这种修改是向表中插入“一行新数据”。那么,以后就会发生操作第一个事务的用户发现表中还存在没有修改的数据行,就好象发生了幻觉一样。
    • 不可重复读:比方说在同一个事务中先后执行两条一模一样的select语句,期间在此次事务中没有执行过任何DDL语句,但先后得到的结果不一致,这就是不可重复读。

    100. 说一下 spring mvc 运行流程?

    Spring MVC运行流程图:

    Spring运行流程描述:

    1. 用户向服务器发送请求,请求被Spring 前端控制Servelt DispatcherServlet捕获;

    2. DispatcherServlet对请求URL进行解析,得到请求资源标识符(URI)。然后根据该URI,调用HandlerMapping获得该Handler配置的所有相关的对象(包括Handler对象以及Handler对象对应的拦截器),最后以HandlerExecutionChain对象的形式返回;

    3. DispatcherServlet 根据获得的Handler,选择一个合适的HandlerAdapter;(附注:如果成功获得HandlerAdapter后,此时将开始执行拦截器的preHandler(...)方法)

    4.  提取Request中的模型数据,填充Handler入参,开始执行Handler(Controller)。 在填充Handler的入参过程中,根据你的配置,Spring将帮你做一些额外的工作:

    • HttpMessageConveter: 将请求消息(如Json、xml等数据)转换成一个对象,将对象转换为指定的响应信息
    • 数据转换:对请求消息进行数据转换。如String转换成Integer、Double等
    • 数据根式化:对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等
    • 数据验证: 验证数据的有效性(长度、格式等),验证结果存储到BindingResult或Error中

    5.  Handler执行完成后,向DispatcherServlet 返回一个ModelAndView对象;

    6.  根据返回的ModelAndView,选择一个适合的ViewResolver(必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet ;

    7. ViewResolver 结合Model和View,来渲染视图;

    8. 将渲染结果返回给客户端。

    101. spring mvc 有哪些组件?

    Spring MVC的核心组件:

    1. DispatcherServlet:中央控制器,把请求给转发到具体的控制类
    2. Controller:具体处理请求的控制器
    3. HandlerMapping:映射处理器,负责映射中央处理器转发给controller时的映射策略
    4. ModelAndView:服务层返回的数据和视图层的封装类
    5. ViewResolver:视图解析器,解析具体的视图
    6. Interceptors :拦截器,负责拦截我们定义的请求然后做处理工作

    102. @RequestMapping 的作用是什么?

    RequestMapping是一个用来处理请求地址映射的注解,可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。

    RequestMapping注解有六个属性,下面我们把她分成三类进行说明。

    value, method:

    • value:指定请求的实际地址,指定的地址可以是URI Template 模式(后面将会说明);
    • method:指定请求的method类型, GET、POST、PUT、DELETE等;

    consumes,produces

    • consumes:指定处理请求的提交内容类型(Content-Type),例如application/json, text/html;
    • produces:指定返回的内容类型,仅当request请求头中的(Accept)类型中包含该指定类型才返回;

    params,headers

    • params: 指定request中必须包含某些参数值是,才让该方法处理。
    • headers:指定request中必须包含某些指定的header值,才能让该方法处理请求。

    103. @Autowired 的作用是什么?

    《@Autowired用法详解》


    未完待续......


    欢迎大家关注我的公众号:Java团长,后续面试题更新之后可以在第一时间获取~

    展开全文
  • 2019年武汉中高级java开发工程师面试题总结

    万次阅读 多人点赞 2019-02-12 10:55:35
    1.2 java中的位运算 1.3 给出两个int类型的整数 a和b, 求他们的和,要求使用位运算去做。 1.4 a+=b 和a=a+b 有什么区别? 1.53*0.1 == 0.3 将会返回什么?true 还是 false? 1.6接口和抽象类的区别 ...

     

    目录

     

    一、前言

    二、java基础

    1、基本数据类型 

      1.1  java基本数据类型及长度

      1.2 java中的位运算

      1.3 给出两个int类型的整数 a和 b, 求他们的和,要求使用位运算去做。

     1.4  a+=b 和a=a+b 有什么区别?

    1.5  3*0.1 == 0.3 将会返回什么?true 还是 false?

    1.6 接口和抽象类的区别

     1.7 什么是不可变对象,什么是可变对象?

    1.8 如何编写一个不可变对象?

    1.9 final的用法

    1.10 java当中的四种引用

    1.11  Object中有哪些方法?

    1.12 常用的运行时异常

    1.13 jdk1.8新特性

    1.14 运行时数据区包括哪几部分

    1.15 GC要回收哪些区域?

     1.16 如何判断对象是否存活?

    1.17 常用的垃圾回收算法  

    1.18  常见的垃圾收集器 

    1.19  GC什么时候被触发的 ?

    1.20 jvm查看gc命令  

    1.21 类加载为什么要使用双亲委派模式,有没有什么场景是打破了这个模式?

    1.22  类的实例化顺序?

    1.23 java内存模型

     

    1.21 内存泄漏与内存溢出区别,产生原因?

     1.22 如何解决内存溢出?

    2、集合框架

    2.1 HashMap和HashTable有何不同?

    2.2  ArrayList和Vector有何异同点?

    2.3 ArrayList和LinkedList有何区别?

    2.4 发生hash碰撞的原因

    2.5    解决冲突的办法

    2.6 经常使用的构造散列函数的方法

    2.7 HsahMap的put过程

    2.8 HashMap 的get过程

     2.9 ConcurrentHashMap 的put过程

    2.10  ConcurrentHashMap的get过程

    2.11 不安全使用HashMap会导致的安全问题?

     

    3、多线程

    3.1 现在有T1、T2、T3三个线程,你怎样保证T2在T1执行完后执行,T3在T2执行完后执行?

    3.2 什么是线程

    3.3 线程和进程有什么区别?

    3.4 Java中Runnable和Callable有什么不同?

    3.5 Java中CountDownLatch 和CyclicBarrier 有什么不同?

    3.6 线程运行的多种状态

    3.7 Java中的volatile 变量是什么?

    3.8 volatile的原理和实现机制

    3.9 使用volatile关键字的场景

    3.10 如何终止一个线程

    3.11 生产者消费者模型

    3.12 什么是ThreadLocal变量?

    3.13 什么是FutureTask?

    3.14 Java中interrupt 、interrupted 和 isInterruptedd方法的区别?

    3.15 Java中的同步集合与并发集合有什么区别?

    3.16 常用的线程池

    3.17 sleep和wait的区别?

    3.18  fail-fast和fail-safe机制

    3.19 JVM性能调优监控工具jps、jstack、jmap、jhat、jstat、hprof使用

     3.20  Java中的同步集合与并发集合有什么区别

    3.21 Java中synchronized 和 ReentrantLock 有什么不同

    3.22 Java中的fork join框架是什么?

    3.23 Java中的锁机制  偏向锁 & 轻量级锁 & 重量级锁各自优缺点及场景

    3.24 synchronized修饰代码块、普通方法、静态方法有什么区别。

    3.25 synchronized 和 lock 有什么区别?

    3.26 什么是CAS?

    3.27 Synchronized 和 CAS

    3.28 java中原子操作

    4、JavaWeb

    4.1 Http中Get和Post的区别

     4.2 tomcat的优化

    (1)tomcat内存优化

    4.3 Sevlet生命周期

    4.4 forward()和redirect()的区别

    4.5 jsp中的九大内置对象

    4.6 jsp中的四个域对象

    4.7 Jsp与servlet的区别

    4.8 TCP与UDP的区别

    4.9 tcp/udp协议在网络模型

    4.10 说说你熟悉的响应码

    5 linux常用命令

     

    5.1 基本命令

    5.2 创建文件

    5.3 移动文件、修改文件名

    5.4 拷贝文件

    5.5 查看文本内容

    5.6 打包/解包

    5.7 压缩/解压

    5.8 归档并压缩/解压

    5.9 网络服务启动与停止

     6 mysql

    6.1 乐观锁与悲观锁的区别?

    6.2 事务的特性

    6.3 不考虑事务的隔离性引发的一系列安全问题

    6.4 mysql常用的数据库引擎

    6.5 jdbc中Statement与Preparestament的区别

    6.6 sql优化

    6.7 分表分库

    6.8 oracle数据库的分页

    6.9 mysql索引的分类

    6.10 创建索引的原则

    6.11 mysql索引的工作原理

     

    6.12 复制基本原理流程

    6.13 MySQL复制的线程有几个及之间的关联

    6.14 MySQL如何保证复制过程中数据一致性及减少数据同步延时

    6.15 数据库主库和从库不一致,怎么解决?

    6.16 MySQL存储引擎MyISAM与InnoDB区别 

    6.17 索引如何提高查询效率?

    7 redis 

    7.1 redis的数据结构

    7.2 redis的持久化机制

    7.3 mySQL里有2000w数据,redis中只存20w的数据,如何保证redis中的数据都是热点数据

    7.4 redis常见性能问题和解决方案

    7.5 redis的并发竞争问题如何解决?

    7.6 redis事务的命令

    7.7 redis事务的特征

    7.8 redis集群搭建

     

    8 SpringMVC

    8.1 springMVC的运行流程

    8.2 mvc模式

    9 Spring

    9.1 什么是IOC,以及其原理?

    9.2 IOC和DI的区别? 

    9.3 什么是aop

    9.4 SpringBean实例化方式

    9.5 springBean的生命周期

    9.6 Spring的事物管理

    9.7 Spring事物的隔离级别和传播行为

    9.8 BeanFactory和ApplicationContext有什么区别?

    9.9 Spring Bean的作用域之间有什么区别?

    9.10 JDK动态代理和Gglib动态代理的区别

    9.11 BeanFactory与FactoryBean的区别

     9.12 spring在bean的创建过程中解决循环依赖

    9.13 @Transactional使用

    9.14 获取spring容器的常用的4种方式

    9.15 Spring支持三种依赖注入方式

    10 Mybatis

    10.1 mybatis的原理 

    10.2 #{}和${}的区别是什么?

    10.3 通常一个Xml映射文件,都会写一个Mapper接口与之对应,请问,这个Mapper接口的工作原理是什么?Mapper接口里的方法,参数不同时,方法能重载吗?

    10.4 Mybatis分页插件的原理是什么?

    10.5 简述Mybatis的插件运行原理,以及如何编写一个插件

    10.6 mybatis是否支持延迟加载?如果支持,它的实现原理是什么?

    10.7 Mybatis都有哪些Executor执行器?它们之间的区别是什么?

    10.8 mybatis缓存

    11 springBoot

    11.1 什么是 Spring Boot?

    11.2 Spring Boot 的核心配置文件有哪几个?它们的区别是什么?

    11.3 Spring Boot 的配置文件有哪几种格式?它们有什么区别?

    11.4 Spring Boot 的核心注解是哪个?它主要由哪几个注解组成的?

    11.5 开启 Spring Boot 特性有哪几种方式?

    11.6 Spring Boot 需要独立的容器运行吗?

    11.7 运行 Spring Boot 有哪几种方式?

    11.8 Spring Boot 自动配置原理是什么?

    11.9 如何在 Spring Boot 启动的时候运行一些特定的代码?

    11.10 Spring Boot 有哪几种读取配置的方式?

    11.11 Spring Boot 支持哪些日志框架?推荐和默认的日志框架是哪个?

    11.12 SpringBoot 实现热部署有哪几种方式?

    11.13 你如何理解 Spring Boot 配置加载顺序?

    11.14 Spring Boot 2.X 有什么新特性?与 1.X 有什么区别?

    12 微服务

    12.1 SpringCloud和Dubbo有哪些区别?          

     

    2. SpringBoot和SpringCloud,请你谈谈对他们的理解?

    3. 什么是服务熔断?什么是服务降级?

    4. Eureka和zookeeper都可以提供服务注册与发现的功能,请说说两个的区别?


    一、前言

     

    楼主本人目前在武汉工作,才刚放假,已经在准备下家公司面试。把自己面试准备的东西做个记录,以驱使自己进步。

     

     

    二、java基础

    1、基本数据类型 

      1.1  java基本数据类型及长度

    四种整数类型  2种浮点型  1种字符类型 一种布尔类型(boolean)

     

    整数类型

    Java各数据类型有固定的表数范围和字段长度,其不受操作系统影响,保证了Java的可移植性。

    类型 占存储空间 表数范围
    byte 1字节 2^{7}~2^{7}-1(-128~127  )
    short 2字节 -2^{15}~2^{15}-1
    int 4字节 -2^{31}~2^{31}-1
    long 8字节 -2^{63}~2^{63}-1
    char 2个字节  
    float 4个字节 -3.403E38~3.403E38
    double 8个字节 -17.98E308~17.98E308
    boolean 1个bit位  

    浮点数在现实中是连续的,在计算机数据结构中是离散的,计算机内部表示浮点数是有误差的。

      1.2 java中的位运算

    位运算符 作用
    & 两个数操作的位都为1结果为1,否则为0
    | 两个数操作的位只要有一个为1结果就位为1,否则为0
    ~ 参加运算的数,换算为二进制(0、1)后,进行取反运算。每个位上都取相反值,1变成0,0变成1
    ^ 参加运算的两个数,换算为二进制(0、1)后,进行异或运算。只有当相应位上的数字不相同时,该为才取1,若相同,即为0。
    << 参加运算的数,换算为二进制(0、1)后,进行左移运算,将这个数各二进制位全部向左移动若干位
    >> 参加运算的数,换算为二进制(0、1)后,进行右移运算,将这个数各二进制位全部向右移动若干位
    >>> 参加运算的数,换算为二进制(0、1)后,进行右移运算,将这个数各二进制位全部向右移动若干位,无符号右移,忽略符号位,空位都以0补齐

      1.3 给出两个int类型的整数 a和 b, 求他们的和,要求使用位运算去做。

    // 主要利用异或运算来完成
    // 异或运算有一个别名叫做:不进位加法
    // 那么a ^ b就是a和b相加之后,该进位的地方不进位的结果
    // 然后下面考虑哪些地方要进位,自然是a和b里都是1的地方
    // a & b就是a和b里都是1的那些位置,a & b << 1 就是进位
    // 之后的结果。所以:a + b = (a ^ b) + (a & b << 1)
    // 令a' = a ^ b, b' = (a & b) << 1
    // 可以知道,这个过程是在模拟加法的运算过程,进位不可能
    // 一直持续,所以b最终会变为0。因此重复做上述操作就可以
    // 求得a + b的值。
    while (b != 0) {
        int _a = a ^ b;
        int _b = (a & b) << 1;
        a = _a;
        b = _b;
    }
    return a;
    

     1.4  a+=b 和a=a+b 有什么区别?

    += 隐式的将加操作的结果类型强制转换为持有结果的类型。如果两这个整型相加,如 byte、short 或者 int,首先会将它们提升到 int 类型,然后在执行加法操作。

    如下代码:

    byte a = 20;
    byte b = 19;
    b+=a;
    b=b+a;//Type mismatch: cannot convert from int to byte

    b=b+a报错:不能把int转换成byte 

    1.5  3*0.1 == 0.3 将会返回什么?true 还是 false?

    false, java中小数 float和double类型一个占32位 一个64位其实不论是float还是double在存储方式上都是遵从IEEE的规范的,float遵从的是IEEE R32.24 ,而double 遵从的是R64.53。

    无论是单精度还是双精度在存储中都分为三个部分:

    float表示 

    1. 符号位(Sign) : 0代表正,1代表为负
    2. 指数位(Exponent):用于存储科学计数法中的指数数据,并且采用移位存储
    3. 尾数部分(Mantissa):尾数部分

     

    double表示: 

    doubleç±»åæ°æ®çå­å¨æ¹å¼

    float和double会损失精度 

    1.6 接口和抽象类的区别

      抽象类 接口
    构造器 抽象类中可以有构造器, 接口中不能
    成员变量   public static final
    方法  

     public abstract (都可以省略)

     public default   (public 可以省略)1.8新特性

      public static      (public可以省略)1.8新特性

    private     1.9新特性

     1.7 什么是不可变对象,什么是可变对象?

    不可变对象(Immutable Objects):

    即对象一旦被创建它的状态(对象的数据,也即对象属性值)就不能改变,任何对它的改变都应该产生一个新的对象。如String、基本类型的包装类、BigInteger和BigDecimal等。

     可变对象(Mutable Objects):

    相对于不可变类,可变类创建实例后可以改变其成员变量值,开发中创建的大部分类都属于可变类。

    1.8 如何编写一个不可变对象?

    A. 确保类不能被继承

    将类声明为final, 或者使用静态工厂并声明构造器为private。如果类可以被继承会破坏类的不可变性机制,只要继承类覆盖父类的方法并且继承类可以改变成员变量值,那么一旦子类以父类的形式出现时,不能保证当前类是否可变

    B. 使用private和final修饰符来修饰该类的属性

    C. 不要提供任何可以修改对象状态的方法(不仅仅是set方法, 还有任何其它可以改变状态的方法)

    不可变对象的优点:

    * 构造、测试和使用都很简单

    * 不可变对象是线程安全的,在线程之间可以相互共享,不需要利用特殊机制来保证同步问题,因为对象的值无法改变。可以降低并发错误的可能性,因为不需要用一些锁机制等保证内存一致性问题也减少了同步开销。

    * 不可变对象可以被重复使用,可以将它们缓存起来重复使用,就像字符串字面量和整型数字一样。可以使用静态工厂方法来提供类似于valueOf()这样的方法,它可以从缓存中返回一个已经存在的Immutable对象,而不是重新创建一个。

    1.9 final的用法

    1.被final修饰的类不可以被继承 

    2.被final修饰的方法不可以被重写

    3.被final修饰的方法,JVM会尝试将其内联,以提高运行效率 
    4.被final修饰的变量不可以被改变。如果修饰引用,那么表示引用不可变,引用指向的内容可变
    5.被final修饰的常量,在编译阶段会存入常量池中。

    回答出编译器对final域要遵守的两个重排序规则更好:
    1.在构造函数内对一个final域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。
    2.初次读一个包含final域的对象的引用,与随后初次读这个final域,这两个操作之间不能重排序。

    1.10 java当中的四种引用

    强引用,软引用,弱引用,虚引用。不同的引用类型主要体现在GC上:

    1. 强引用(Strong Reference):如果一个对象具有强引用,它就不会被垃圾回收器回收。即使当前内存空间不足,JVM也不会回收它,而是抛出 OutOfMemoryError 错误,使程序异常终止。如果想中断强引用和某个对象之间的关联,可以显式地将引用赋值为null,这样一来的话,JVM在合适的时间就会回收该对象。

    2. 软引用(Soft Reference):在使用软引用时,如果内存的空间足够,软引用就能继续被使用,而不会被垃圾回收器回收,只有在内存不足时,软引用才会被垃圾回收器回收。

    3. 弱引用(Weak Reference):具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收,一旦发现弱引用对象,无论当前内存空间是否充足,都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程,所以并不一定能迅速发现弱引用对象。

    4. 虚引用(Phantom Reference):顾名思义,就是形同虚设,如果一个对象仅持有虚引用,那么它相当于没有引用,在任何时候都可能被垃圾回收器回收。

    1.11  Object中有哪些方法?

    1. getClass()

     public final native Class<?> getClass();

    getClass() 返回此 Object 的运行时类

    2. hashCode()

     public native int hashCode();

    hashCode() 返回该对象的哈希码值 

    hashCode的常规协定是:

    • 在 Java 应用程序执行期间,在对同一对象多次调用 hashCode 方法时,必须一致地返回相同的整数,前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。
    • 如果根据 equals(Object) 方法,两个对象是相等的,那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。
    • 如果根据 equals(java.lang.Object) 方法,两个对象不相等,那么对这两个对象中的任一对象上调用 hashCode 方法 要求一定生成不同的整数结果。但是,程序员应该意识到,为不相等的对象生成不同整数结果可以提高哈希表的性能。

     3. equals(Object obj)

        public boolean equals(Object obj) {
            return (this == obj);
        }

    equals(Object obj)指示其他某个对象是否与此对象“相等”。

     4. clone()

     protected native Object clone()

     clone()创建并返回此对象的一个副本。克隆分为深度克隆和浅度克隆,Object的克隆为浅度克隆。

    浅度克隆:被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅拷贝仅仅复制所考虑的对象,而不复制它所引用的对象。

    深度克隆:被复制对象的所有变量都含有与原来的对象相同的值,而那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。换言之,深拷贝把要复制的对象所引用的对象都复制了一遍。

    5. toString()

    public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

     6. finalize()

     protected void finalize()

    当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。子类重写 finalize 方法,以配置系统资源或执行其他清除。

    7. notify()、notifyAll ()

    唤醒在此对象监视器上等待的单个/多个线程

    8、wait()、wait(long timeout)、wait(long timeout, int nanos)

    当前线程等待

    1.12 常用的运行时异常

    1、ClassCastException:类型转换异常

    2、ConcurrentModificationException:并发修改异常

    3、ArrayIndexOutOfBoundsException:数组角标越界

    4、UnsupportedOperationException:不支持的操作异常

    Arrays.asList() 方法把数组转换集合,在对集合进行修改时会抛出此异常。

    5、NullPointerException

    6、NumberFormatException

    7、java.lang.IllegalMonitorStateException

    1.13 jdk1.8新特性

    1、Lambda 表达式,允许像对象一样传递匿名函数 

      Lambda表达式的省略规则

                1、参数的类型可以省略,但是只能省略所有类型或者都不省略

               2、如果参数有且仅有一个()可以省略

               3、如果大括号内的语句有且仅有一个,那么无论有没有返回值  return    {}和;都可以省略

    2、Stream API,充分利用现代多核 CPU,可以写出很简洁的代码 

          流的获取方式:

         ①通过Collection直接掉用stream()方法

         ②通过数组:Arrays.stream();或者Stream.of()

       java.util.stream.Stream 的of方法源码其无法把基本数据类型的数组转换成流

       public static<T> Stream<T> of(T t) {
            return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
        }

       常用方法 

    • filter()
    • count()
    • limit()
    • skip()
    • map()
    • concat()
    • forEach()
    • collect()

    3、Date 与 Time API,最终,有一个稳定、简单的日期和时间库可供你使用 


    4、接口更新,现在,接口中可以有静态、默认方法。

    1.14 运行时数据区包括哪几部分

     Java运行时数据区分为下面几个内存区域:

    每当创建一个线程,JVM就会为该线程创建对应的Java栈,在这个Java栈中又会包含多个栈帧(Stack Frame),这些栈帧是与每个方法关联起来的,每运行一个方法就创建一个栈帧,每个栈帧会含有一些局部变量、操作栈和方法返回值等信息。下图是栈帧结构 

    堆是JVM所管理的内存中国最大的一块,是被所有Java线程锁共享的,不是线程安全的,在JVM启动时创建。堆是存储Java对象的地方,这一点Java虚拟机规范中描述是:所有的对象实例以及数组都要在堆上分配。Java堆是GC管理的主要区域,从内存回收的角度来看,由于现在GC基本都采用分代收集算法,所以Java堆还可以细分为:新生代和老年代;新生代再细致一点有Eden空间、From Survivor空间、To Survivor空间等。 

    方法区存放了要加载的类的信息(名称、修饰符等)、类中的静态常量、类中定义为final类型的常量、类中的Field信息、类中的方法信息,当在程序中通过Class对象的getName.isInterface等方法来获取信息时,这些数据都来源于方法区。方法区是被Java线程锁共享的,不像Java堆中其他部分一样会频繁被GC回收,它存储的信息相对比较稳定,在一定条件下会被GC。 

    本地方法栈和Java栈所发挥的作用非常相似,区别不过是Java栈为JVM执行Java方法服务,而本地方法栈为JVM执行Native方法服务 

    上述区域只有 堆和方法区是被所有线程共享的,存在线程安全问题。

     

    • PC寄存器/程序计数器
    • 方法区
    • 本地方法栈

    1.15 GC要回收哪些区域?

     在JVM内存模型中,有三个是不需要进行垃圾回收的:程序计数器、JVM栈、本地方法栈。因为它们的生命周期是和线程同步的,随着线程的销毁,它们占用的内存会自动释放,所以只有方法区和堆需要进行GC 

     1.16 如何判断对象是否存活?

    引用计数法 

    给对象中添加一个引用计数器,每当有一个地方引用它时,计数器值就加1;当引用失效时,计数器

    值就减1;任何时刻计数器为0的对象就是不可能再被使用的。

    可达性分析算法(根搜索算法)

    过一系列的称为“GC Roots”的对象作为起始点,从这些节点开始向下搜索,搜索所走过的路径称为

    引用链(Reference Chain),当一个对象到GC Roots没有任何引用链相连时,则证明此对象是不可用的

    在Java语言中,可作为GC Roots的对象包括下面几种:

    • 虚拟机栈(栈帧中的本地变量表)中引用的对象。
    • 方法区中类静态属性引用的对象。
    • 方法区中常量引用的对象。
    • 本地方法栈中JNI(即一般说的Native方法)引用的对象。

    1.17 常用的垃圾回收算法  

    标记-清除算法 

    标记-清除算法采用从根集合(GC Roots)进行扫描,对存活的对象进行标记,标记完毕后,再扫描整个空间中未被标记的对象,进行回收,此算法一般没有虚拟机采用。

    复制算法 
    将内存分成两块容量大小相等的区域,每次只使用其中一块,当这一块内存用完了,就将所有存活对象复制到另一块内存空间,然后清除前一块内存空间。这样一来就不容易出现内存碎片的问题。 

    标记-整理算法 
    思想:在完成标记之后,它不是直接清理可回收对象,而是将存活对象都向一端移动,然后清理掉端边界以外的内存。 
    不会产生内存碎片,但是依旧移动对象的成本

    分代收集算法

    分代收集算法是目前大部分JVM的垃圾收集器采用的算法。它的核心思想是根据对象存活的生命周期将内存划分为若干个不同的区域。一般情况下将堆区划分为老年代(Tenured Generation)和新生代(Young Generation),在堆区之外还有一个代就是永久代(Permanet Generation)。老年代的特点是每次垃圾收集时只有少量对象需要被回收,而新生代的特点是每次垃圾回收时都有大量的对象需要被回收,那么就可以根据不同代的特点采取最适合的收集算法

    1.18  常见的垃圾收集器 

    Serial收集器(复制算法) 
    新生代单线程收集器,标记和清理都是单线程,优点是简单高效。是client级别默认的GC方式,可以通过-XX:+UseSerialGC来强制指定。 
    Serial Old收集器(标记-整理算法) 
    老年代单线程收集器,Serial收集器的老年代版本。 
    ParNew收集器(停止-复制算法)  
    新生代收集器,可以认为是Serial收集器的多线程版本,在多核CPU环境下有着比Serial更好的表现。 
    Parallel Scavenge收集器(停止-复制算法)  
    并行收集器,追求高吞吐量,高效利用CPU。吞吐量一般为99%, 吞吐量= 用户线程时间/(用户线程时间+GC线程时间)。适合后台应用等对交互相应要求不高的场景。是server级别默认采用的GC方式,可用-XX:+UseParallelGC来强制指定,用-XX:ParallelGCThreads=4来指定线程数。 
    Parallel Old收集器(停止-复制算法) 
    Parallel Scavenge收集器的老年代版本,并行收集器,吞吐量优先。 
    CMS(Concurrent Mark Sweep)收集器(标记-清理算法) 
    高并发、低停顿,追求最短GC回收停顿时间,cpu占用比较高,响应时间快,停顿时间短,多核cpu 追求高响应时间的选择。

             垃圾回收器从线程运行情况分类有三种

    1. 串行回收,Serial回收器,单线程回收,全程stw;
    2. 并行回收,名称以Parallel开头的回收器,多线程回收,全程stw;
    3. 并发回收,cms与G1,多线程分阶段回收,只有某阶段会stw;

    CMS收集器基于“标记-清除”算法实现,

    优点:并发收集、低停顿

    缺点:无法处理浮动垃圾导致Full GC产生容易出现大量空间碎片

    G1从整体来看是基于“标记整理”算法实现的收集器;从局部上来看是基于“复制”算法实现的。

    1、并行于并发:G1能充分利用CPU、多核环境下的硬件优势,使用多个CPU(CPU或者CPU核心)来缩短stop-The-World停顿时间。

    2、分代收集

    3、建立可预测的停顿时间模型

    1.19  GC什么时候被触发的 ?

    由于对象进行了分代处理,因此垃圾回收区域、时间也不一样。GC有两种类型:Minor GC和Full GC

    一般情况下,当新对象生成,并且在Eden申请空间失败时,就会触发Minor GC,对Eden区域进行GC,清除非存活对象,并且把尚且存活的对象移动到Survivor区。然后整理Survivor的两个区。

    Full GC 
    对整个堆进行整理,包括Young、Tenured和Perm。Full GC因为需要对整个堆进行回收,所以比Scavenge GC要慢,因此应该尽可能减少Full GC的次数。在对JVM调优的过程中,很大一部分工作就是对于Full GC的调节。有如下原因可能导致Full GC: 
    a) 年老代(Tenured)被写满; 
    b) 持久代(Perm)被写满; 
    c) System.gc()被显示调用; 
    d) 上一次GC之后Heap的各域分配策略动态变化

    1.20 jvm查看gc命令  

    jstat -gc 12538 5000 
    即会每5秒一次显示进程号为12538的java进成的GC情况

    1.21 类加载为什么要使用双亲委派模式,有没有什么场景是打破了这个模式?

    在Java中判断两个类是否是同一个类,不仅仅是类的全限定名称相同,还需要加载它们的类加载器相同。使用双亲委派模式,加载Object类时会始终使用启动类加载器进行加载,而不会使用自定义类加载器,如果不使用双亲委派模式的话程序会混乱不堪。

    JNDI服务打破了双亲委派模式。按照双亲委派模式,启动类加载器会加载JNDI,此时启动类加载器找到无法对各厂商具体实现,引入了ThreadContextClassLoader,父加载器会请求子加载器对其进行加载。


    1.22  类的实例化顺序?

    大致的顺序是,先静态方法、再构造方法,先父类后子类。

    (1)父类静态成员和静态初始化块,按代码顺序;

    (2)子类静态成员和静态初始化块,按代码顺序;

    (3)父类实例成员和实例初始化块,按代码顺序;

    (4)父类构造方法;

    (5)子类实例成员和实例初始化块,按代码顺序;

    (6)子类构造方法。

    1.23 java内存模型

     Java内存模型是围绕着并发编程中原子性、可见性、有序性这三个特征来建立的,那我们依次看一下这三个特征:

      原子性(Atomicity):一个操作不能被打断,要么全部执行完毕,要么不执行。在这点上有点类似于事务操作,要么全部执行成功,要么回退到执行该操作之前的状态。

      基本类型数据的访问大都是原子操作,long 和double类型的变量是64位,但是在32位JVM中,32位的JVM会将64位数据的读写操作分为2次32位的读写操作来进行,这就导致了long、double类型的变量在32位虚拟机中是非原子操作,数据有可能会被破坏,也就意味着多个线程在并发访问的时候是线程非安全的。

    可见性:一个线程对共享变量做了修改之后,其他的线程立即能够看到(感知到)该变量这种修改(变化)。

      Java内存模型是通过将在工作内存中的变量修改后的值同步到主内存,在读取变量前从主内存刷新最新值到工作内存中,这种依赖主内存的方式来实现可见性的。

    无论是普通变量还是volatile变量都是如此,区别在于:volatile的特殊规则保证了volatile变量值修改后的新值立刻同步到主内存,每次使用volatile变量前立即从主内存中刷新,因此volatile保证了多线程之间的操作变量的可见性,而普通变量则不能保证这一点。

      除了volatile关键字能实现可见性之外,还有synchronized,Lock,final也是可以的。

      使用synchronized关键字,在同步方法/同步块开始时(Monitor Enter),使用共享变量时会从主内存中刷新变量值到工作内存中(即从主内存中读取最新值到线程私有的工作内存中),在同步方法/同步块结束时(Monitor Exit),会将工作内存中的变量值同步到主内存中去(即将线程私有的工作内存中的值写入到主内存进行同步)。

      使用Lock接口的最常用的实现ReentrantLock(重入锁)来实现可见性:当我们在方法的开始位置执行lock.lock()方法,这和synchronized开始位置(Monitor Enter)有相同的语义,即使用共享变量时会从主内存中刷新变量值到工作内存中(即从主内存中读取最新值到线程私有的工作内存中),在方法的最后finally块里执行lock.unlock()方法,和synchronized结束位置(Monitor Exit)有相同的语义,即会将工作内存中的变量值同步到主内存中去(即将线程私有的工作内存中的值写入到主内存进行同步)。

      final关键字的可见性是指:被final修饰的变量,在构造函数数一旦初始化完成,并且在构造函数中并没有把“this”的引用传递出去(“this”引用逃逸是很危险的,其他的线程很可能通过该引用访问到只“初始化一半”的对象),那么其他线程就可以看到final变量的值。

      有序性:对于一个线程的代码而言,我们总是以为代码的执行是从前往后的,依次执行的。这么说不能说完全不对,在单线程程序里,确实会这样执行;但是在多线程并发时,程序的执行就有可能出现乱序。用一句话可以总结为:在本线程内观察,操作都是有序的;如果在一个线程中观察另外一个线程,所有的操作都是无序的。前半句是指“线程内表现为串行语义(WithIn Thread As-if-Serial Semantics)”,后半句是指“指令重排”现象和“工作内存和主内存同步延迟”现象。

    Java提供了两个关键字volatile和synchronized来保证多线程之间操作的有序性,volatile关键字本身通过加入内存屏障来禁止指令的重排序,而synchronized关键字通过一个变量在同一时间只允许有一个线程对其进行加锁的规则来实现,

    在单线程程序中,不会发生“指令重排”和“工作内存和主内存同步延迟”现象,只在多线程程序中出现。

     

    1.21 内存泄漏与内存溢出区别,产生原因?

    内存溢出 out of memory,是指程序在申请内存时,没有足够的内存空间供其使用

    内存泄露 memory leak,是指程序在申请内存后,无法释放已申请的内存空间

    内存溢出的原因:

    1.内存中加载的数据量过于庞大,如一次从数据库取出过多数据;
    2.集合类中有对对象的引用,使用完后未清空,使得JVM不能回收;
    3.代码中存在死循环或循环产生过多重复的对象实体

    4.启动参数内存值设定的过小

     1.22 如何解决内存溢出?

    (1)用jmap生成堆信息

     

    jmap -dump:format=b,file=dumpFileName pid
    

     (2)将文件导入Visual VM中进行分析

     

    2、集合框架

    2.1 HashMap和HashTable有何不同?

    (1)HashMap允许key和value为null,而HashTable不允许。

    (2)HashTable是同步的,而HashMap不是。所以HashMap适合单线程环境,HashTable适合多线程环境。

    (3)在Java1.4中引入了LinkedHashMap,HashMap的一个子类,假如你想要遍历顺序,你很容易从HashMap转向LinkedHashMap,但是HashTable不是这样的,它的顺序是不可预知的。

    (4)HashMap提供对key的Set进行遍历,因此它是fail-fast的,但HashTable提供对key的Enumeration进行遍历,它不支持fail-fast。

    (5)HashTable被认为是个遗留的类,如果你寻求在迭代的时候修改Map,你应该使用CocurrentHashMap。

    2.2  ArrayList和Vector有何异同点?

    ArrayList和Vector在很多时候都很类似。

    (1)两者都是基于索引的,内部由一个数组支持。

    (2)两者维护插入的顺序,我们可以根据插入顺序来获取元素。

    (3)ArrayList和Vector的迭代器实现都是fail-fast的。

    (4)ArrayList和Vector两者允许null值,也可以使用索引值对元素进行随机访问。

    以下是ArrayList和Vector的不同点。

    (1)Vector是同步的,而ArrayList不是。然而,如果你寻求在迭代的时候对列表进行改变,你应该使用CopyOnWriteArrayList。

    (2)ArrayList比Vector快,它因为有同步,不会过载。

    (3)ArrayList更加通用,因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。

    2.3 ArrayList和LinkedList有何区别?

    ArrayList和LinkedList两者都实现了List接口,但是它们之间有些不同。

    (1)ArrayList是由Array所支持的基于一个索引的数据结构,所以它提供对元素的随机访问,复杂度为O(1),但LinkedList存储一系列的节点数据,每个节点都与前一个和下一个节点相连接。所以,尽管有使用索引获取元素的方法,内部实现是从起始点开始遍历,遍历到索引的节点然后返回元素,时间复杂度为O(n),比ArrayList要慢。

    (2)与ArrayList相比,在LinkedList中插入、添加和删除一个元素会更快,因为在一个元素被插入到中间的时候,不会涉及改变数组的大小,或更新索引。

    (3)LinkedList比ArrayList消耗更多的内存,因为LinkedList中的每个节点存储了前后节点的引用。

    2.4 发生hash碰撞的原因

    (1)散列函数,一个好的散列函数的值应尽可能平均分布。
    (2)处理冲突方法。
    (3)负载因子的大小。

    2.5    解决冲突的办法

    (1)线性探查法:冲突后,线性向前试探,找到近期的一个空位置。缺点是会出现堆积现象。存取时,可能不是同义词的词也位于探查序列,影响效率。
         (2)双散列函数法:在位置d冲突后,再次使用还有一个散列函数产生一个与散列表桶容量m互质的数c,依次试探(d+n*c)%m,使探查序列跳跃式分布。

    2.6 经常使用的构造散列函数的方法

      1. 直接寻址法:取key或key的某个线性函数值为散列地址。即H(key)=key或H(key) = a•key + b,当中a和b为常数(这样的散列函数叫做自身函数)

      2. 数字分析法:分析一组数据,比方一组员工的出生年月日,这时我们发现出生年月日的前几位数字大体同样,这样的话,出现冲突的几率就会非常大,可是我们发现年月日的后几位表示月份和详细日期的数字区别非常大,假设用后面的数字来构成散列地址,则冲突的几率会明显减少。因此数字分析法就是找出数字的规律,尽可能利用这些数据来构造冲突几率较低的散列地址。

      3. 平方取中法:取key平方后的中间几位作为散列地址。

      4. 折叠法:将key切割成位数同样的几部分,最后一部分位数能够不同,然后取这几部分的叠加和(去除进位)作为散列地址。

      5. 随机数法:选择一随机函数,取key的随机值作为散列地址,通经常使用于key长度不同的场合。

      6. 除留余数法:取key被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p, p<=m。不仅能够对key直接取模,也可在折叠、平方取中等运算之后取模。对p的选择非常重要,一般取素数或m,若p选的不好,容易产生同义词。

    2.7 HsahMap的put过程

    1. 判断当前桶是否为空,空的就需要初始化(resize 中会判断是否进行初始化)。

    2. 根据当前 key 的 hashcode 定位到具体的桶中并判断是否为空,为空表明没有 Hash 冲突就直接在当前位置创建一个新桶即可。

    3. 如果当前桶有值( Hash 冲突),那么就要比较当前桶中的 key、key 的 hashcode 与写入的 key 是否相等,相等就赋值给 e,在第 8 步的时候会统一进行赋值及返回。

    4. 如果当前桶为红黑树,那就要按照红黑树的方式写入数据。

    5. 如果是个链表,就需要将当前的 key、value 封装成一个新节点写入到当前桶的后面(形成链表)。

    6. 接着判断当前链表的大小是否大于预设的阈值,大于时就要转换为红黑树。

    7. 如果在遍历过程中找到 key 相同时直接退出遍历。

    8. 如果 e != null 就相当于存在相同的 key,那就需要将值覆盖。

    9. 最后判断是否需要进行扩容。

    2.8 HashMap 的get过程

    1. 首先将 key hash 之后取得所定位的桶。
    2. 如果桶为空则直接返回 null 。
    3. 否则判断桶的第一个位置(有可能是链表、红黑树)的 key 是否为查询的 key,是就直接返回 value。
    4. 如果第一个不匹配,则判断它的下一个是红黑树还是链表。
    5. 红黑树就按照树的查找方式返回值。
    6. 不然就按照链表的方式遍历匹配返回值。

     2.9 ConcurrentHashMap 的put过程

    1. 根据 key 计算出 hashcode 。
    2. 判断是否需要进行初始化。
    3. f 即为当前 key 定位出的 Node,如果为空表示当前位置可以写入数据,利用 CAS 尝试写入,失败则自旋保证成功。
    4. 如果当前位置的 hashcode == MOVED == -1,则需要进行扩容。
    5. 如果都不满足,则利用 synchronized 锁(锁对象为首节点)写入数据。
    6. 如果数量大于 TREEIFY_THRESHOLD 则要转换为红黑树。

    2.10  ConcurrentHashMap的get过程

    1. 根据计算出来的 hashcode 寻址,如果就在桶上那么直接返回值。
    2. 如果是红黑树那就按照树的方式获取值。
    3. 就不满足那就按照链表的方式遍历获取值

    2.11 不安全使用HashMap会导致的安全问题?

    (1)多线程put的时候可能导致元素丢失

    在多线程下put操作时,执行addEntry(hash, key, value, i),如果有产生哈希碰撞,导致两个线程得到同样的bucketIndex去存储,就可能会出现覆盖丢失的情况

    (2)HashMap在多线程put后可能导致get死循环

    transfer(newTable),这个操作会把当前Entry[] table数组的全部元素转移到新的table中。这个transfer的过程在并发环境下会发生错误,导致数组链表中的链表形成循环链表,在后面的get操作时e = e.next操作无限循环 

     

    3、多线程

    3.1 现在有T1、T2、T3三个线程,你怎样保证T2在T1执行完后执行,T3在T2执行完后执行?

    		Thread t1 = new Thread(() -> System.out.println("t1执行"));
    		Thread t2 = new Thread(() -> System.out.println("t2执行"));
    		Thread t3 = new Thread(() -> System.out.println("t3执行"));
    		try {
    			// t1先启动
    			t1.start();
    			t1.join();
    			// t2
    			t2.start();
    			t2.join();
    			// t3
    			t3.start();
    			t3.join();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}

    上述主要是利用join方法  等待该线程终止。主线程等待t1执行完     再开启t2线程,等待t2线程执行完再执行线程t3

    join方法源码分析

     public final synchronized void join(long millis)throws InterruptedException {
            long base = System.currentTimeMillis();
            long now = 0;
    
            if (millis < 0) {
                throw new IllegalArgumentException("timeout value is negative");
            }
    
            if (millis == 0) {
                while (isAlive()) {
                    wait(0);
                }
            } else {
                while (isAlive()) {
                    long delay = millis - now;
                    if (delay <= 0) {
                        break;
                    }
                    wait(delay);
                    now = System.currentTimeMillis() - base;
                }
            }
        }

    3.2 什么是线程

    线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位。

    3.3 线程和进程有什么区别?

    线程是进程的子集,一个进程可以有很多线程,每条线程并行执行不同的任务。不同的进程使用不同的内存空间,而所有的线程共享一片相同的内存空间

    3.4 Java中Runnable和Callable有什么不同?

    Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了,Callable是在JDK1.5增加的。它们的主要区别是

    (1)Callable规定的方法是call(),Runnable规定的方法是run()。其中Runnable可以提交给Thread来包装下,直接启动一个线程来执行,而Callable则一般都是提交给ExecuteService来执行。

    (2)Callable的任务执行后可返回值,而Runnable的任务是不能返回值得

    (3)call方法可以抛出异常,run方法不可以

    (4)运行Callable任务可以拿到一个Future对象,c表示异步计算的结果。

    3.5 Java中CountDownLatch 和CyclicBarrier 有什么不同?

    CountDownLatch类位于java.util.concurrent包下,利用它可以实现类似计数器的功能,一个线程(或者多个), 等待另外N个线程完成某个事情之后才能执行

    CyclicBarrier通过它可以实现让一组线程等待至某个状态之后再全部同时执行,CyclicBarrier可以被重用

    CountDownLatch

    CyclicBarrier

    减计数方式

    加计数方式

    计算为0时释放所有等待的线程

    计数达到指定值时释放所有等待线程

    计数为0时,无法重置

    计数达到指定值时,计数置为0重新开始

    调用countDown()方法计数减一,调用await()方法只进行阻塞,对计数没任何影响

    调用await()方法计数加1,若加1后的值不等于构造方法的值,则线程阻塞

    不可重复利用

    可重复利用

    3.6 线程运行的多种状态

    •          创建  new Thread类或者其子类对象。
    •          运行 start().  具备者CPU的执行资格和CPU的执行权。
    •          冻结 释放了CPU的执行资格和CPU的执行权。比如执行到sleep(time)  wait() 导致线程冻结。
    •          临时阻塞状态: 具备者CPU的执行资格,不具备CPU的执行权。
    •         消亡:线程结束。run方法结束 

     

    3.7 Java中的volatile 变量是什么?

    volatile是一个特殊的修饰符,只有成员变量才能使用它。 当一个共享变量被volatile修饰时,它会保证修改的值会立即被更新到主存,当有其他线程需要读取时,它会去内存中读取新值。

    volatile特性一:内存可见性,即线程A对volatile变量的修改,其他线程获取的volatile变量都是最新的。

    volatile特性二:可以禁止指令重排序

    volatile关键字保证了操作的可见性,但是不能保证对变量的操作是原子性。

    3.8 volatile的原理和实现机制

    加入volatile关键字时,生成的汇编代码会多出一个lock前缀指令

      lock前缀指令实际上相当于一个内存屏障(也成内存栅栏),内存屏障会提供3个功能:

      1)它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置,也不会把前面的指令排到内存屏障的后面;即在执行到内存屏障这句指令时,在它前面的操作已经全部完成;

      2)它会强制将对缓存的修改操作立即写入主存;

      3)如果是写操作,它会导致其他CPU中对应的缓存行无效。

    3.9 使用volatile关键字的场景

    1、状态标记量

    
    volatile boolean flag= false;
     
    // 线程1
    context = loadContext();
    flag= true;
     
    // 线程2
    while(!flag) {
        sleep();
    }
    doSomethingWithConfig(context);
    

    2、双重检查

    所谓双重检查加锁机制,指的是:并不是每次进入getInstance方法都需要同步,而是先不同步,进入方法过后,先检查实例是否存在,如果不存在才进入下面的同步块,这是第一重检查。进入同步块过后,再次检查实例是否存在,如果不存在,就在同步的情况下创建一个实例,这是第二重检查。这样一来,就只需要同步一次了,从而减少了多次在同步情况下进行判断所浪费的时间。 

    public class Singleton {
    	private volatile static Singleton instance = null;
    
    	private Singleton() {}
    
    	public static Singleton getInstance() {
    		if (instance == null) {
    			synchronized (Singleton.class) {// 1
    				if (instance == null) {// 2
    					instance = new Singleton();// 3
    				}
    			}
    		}
    		return instance;
    	}
    }

    3、独立观察(independent observation)

    安全使用 volatile 的另一种简单模式是:定期 “发布” 观察结果供程序内部使用。例如,假设有一种环境传感器能够感觉环境温度。一个后台线程可能会每隔几秒读取一次该传感器,并更新包含当前文档的 volatile 变量。然后,其他线程可以读取这个变量,从而随时能够看到最新的温度值。

    使用该模式的另一种应用程序就是收集程序的统计信息。下面程序 展示了身份验证机制如何记忆最近一次登录的用户的名字。将反复使用lastUser引用来发布值,以供程序的其他部分使用。

    public class UserManager {
        public volatile String lastUser;
     
        public boolean authenticate(String user, String password) {
            boolean valid = passwordIsValid(user, password);
            if (valid) {
                User u = new User();
                activeUsers.add(u);
                lastUser = user;
            }
            return valid;
        }
    }

    4、“volatile bean” 模式

    volatile bean 模式适用于将 JavaBeans 作为“荣誉结构”使用的框架。在 volatile bean 模式中,JavaBean 被用作一组具有 getter 和/或 setter 方法 的独立属性的容器。volatile bean 模式的基本原理是:很多框架为易变数据的持有者(例如 HttpSession)提供了容器,但是放入这些容器中的对象必须是线程安全的。

    在 volatile bean 模式中,JavaBean 的所有数据成员都是 volatile 类型的,并且 getter 和 setter 方法必须非常普通 —— 除了获取或设置相应的属性外,不能包含任何逻辑。此外,对于对象引用的数据成员,引用的对象必须是有效不可变的。(这将禁止具有数组值的属性,因为当数组引用被声明为 volatile 时,只有引用而不是数组本身具有 volatile 语义)。对于任何 volatile 变量,不变式或约束都不能包含 JavaBean 属性。下面代码示例展示了遵守 volatile bean 模式的 JavaBean:

    @ThreadSafe
    public class Person {
        private volatile String firstName;
        private volatile String lastName;
        private volatile int age;
     
        public String getFirstName() { return firstName; }
        public String getLastName() { return lastName; }
        public int getAge() { return age; }
     
        public void setFirstName(String firstName) { 
            this.firstName = firstName;
        }
     
        public void setLastName(String lastName) { 
            this.lastName = lastName;
        }
     
        public void setAge(int age) { 
            this.age = age;
        }
    }

    5 、开销较低的读-写锁策略

    目前为止,您应该了解了 volatile 的功能还不足以实现计数器。因为++x 实际上是三种操作(读、添加、存储)的简单组合,如果多个线程凑巧试图同时对 volatile 计数器执行增量操作,那么它的更新值有可能会丢失。

    然而,如果读操作远远超过写操作,您可以结合使用内部锁和 volatile 变量来减少公共代码路径的开销。清单 6 中显示的线程安全的计数器使用synchronized确保增量操作是原子的,并使用volatile 保证当前结果的可见性。如果更新不频繁的话,该方法可实现更好的性能,因为读路径的开销仅仅涉及 volatile 读操作,这通常要优于一个无竞争的锁获取的开销。

    @ThreadSafe
    public class CheesyCounter {
        // Employs the cheap read-write lock trick
        // All mutative operations MUST be done with the 'this' lock held
        @GuardedBy("this") private volatile int value;
     
        public int getValue() { return value; }
     
        public synchronized int increment() {
            return value++;
        }
    }

    有关volatile 查看更多

    3.10 如何终止一个线程

    Java提供了很丰富的API但没有为停止线程提供API。JDK 1.0本来有一些像stop(), suspend() 和 resume()的控制方法但是由于潜在的死锁威胁因此在后续的JDK版本中他们被弃用了,之后Java API的设计者就没有提供一个兼容且线程安全的方法来停止一个线程。当run() 或者 call() 方法执行完的时候线程会自动结束,如果要手动结束一个线程,你可以用volatile 布尔变量来退出run()方法的循环或者是取消任务来中断线程。示例代码

    
    public class StopThreadDemo implements Runnable {
    
    	private volatile boolean stopFlag = false;
    
    	@Override
    	public void run() {
    
    		while (!stopFlag) {
    			synchronized (StopThreadDemo.class) {
    				System.out.println("我好忙啊,我在做事情!");
    				try {
    					StopThreadDemo.class.wait();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    					this.stopThread();
    				}
    			}
    		}
    	}
    
    	private void stopThread() {
    		stopFlag = true;
    		System.out.println("老子把线程给停了!");
    	}
    
    	public static void main(String[] args) {
    		StopThreadDemo d = new StopThreadDemo();
    		Thread t1 = new Thread(d, "旺财");
    		Thread t2 = new Thread(d, "小强");
    		try {
    			t1.start();
    			t2.start();
    			Thread.sleep(5000);
    			t1.interrupt();// 对t1线程对象进行中断状态的清除,强制让其恢复到运行状态。
    			t2.interrupt();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    }
    

    3.11 生产者消费者模型

     

     class BoundedBuffer {
       final Lock lock = new ReentrantLock();
       final Condition notFull  = lock.newCondition(); 
       final Condition notEmpty = lock.newCondition(); 
    
       final Object[] items = new Object[100];
       int putptr, takeptr, count;
    
       public void put(Object x) throws InterruptedException {
         lock.lock();
         try {
           while (count == items.length) 
             notFull.await();
           items[putptr] = x; 
           if (++putptr == items.length) putptr = 0;
           ++count;
           notEmpty.signal();
         } finally {
           lock.unlock();
         }
       }
    
       public Object take() throws InterruptedException {
         lock.lock();
         try {
           while (count == 0) 
             notEmpty.await();
           Object x = items[takeptr]; 
           if (++takeptr == items.length) takeptr = 0;
           --count;
           notFull.signal();
           return x;
         } finally {
           lock.unlock();
         }
       } 
     }
    

    3.12 什么是ThreadLocal变量?

    ThreadLocal是线程本地的变量,只要是本线程内都可以使用,线程结束了,那么相应的线程本地变量也就跟随着线程消失了。

    Thread类里面有一个ThreadLocalMap,用于存储每一个线程的变量的引用,这个Map中的键为ThreadLocal对象,而值对应的是ThreadLocal通过set放进去的变量引用。

    3.13 什么是FutureTask?

    在Java并发程序中FutureTask表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回运算结果等方法,此类提供了对 Future 的基本实现。只有当运算完成的时候结果才能取回,如果运算尚未完成get方法将会阻塞。可使用 FutureTask 包装 Callable 或 Runnable 对象。因为 FutureTask 实现了 Runnable,所以可将 FutureTask 提交给 Executor 执行

    3.14 Java中interrupt interrupted 和 isInterruptedd方法的区别?

    interrupt 中断线程。

    如果当前线程没有中断它自己(这在任何情况下都是允许的),则该线程的 checkAccess 方法就会被调用,这可能抛出 SecurityException

    如果线程在调用 Object 类的 wait()wait(long)wait(long, int) 方法,或者该类的 join()join(long)join(long, int)sleep(long)sleep(long, int) 方法过程中受阻,则其中断状态将被清除,它还将收到一个 InterruptedException

    如果该线程在可中断的通道上的 I/O 操作中受阻,则该通道将被关闭,该线程的中断状态将被设置并且该线程将收到一个 ClosedByInterruptException

    如果该线程在一个 Selector 中受阻,则该线程的中断状态将被设置,它将立即从选择操作返回,并可能带有一个非零值,就好像调用了选择器的 wakeup 方法一样。

    如果以前的条件都没有保存,则该线程的中断状态将被设置。

    中断一个不处于活动状态的线程不需要任何作用。

     

    interrupted() 和 isInterrupted()的主要区别是前者会将中断状态清除而后者不会。

    (1)interrupted 是作用于当前线程,isInterrupted 是作用于调用该方法的线程对象所对应的线程。

    (2)这两个方法最终都会调用同一个方法isInterrupted(boolean flag),只不过参数一个是true,一个是false。是前者会将中断状态清除而后者不会。

    3.15 Java中的同步集合与并发集合有什么区别?

    不管是同步集合还是并发集合他们都支持线程安全,他们之间主要的区别体现在性能和可扩展性,还有他们如何实现的线程安全。同步HashMap, Hashtable, HashSet, Vector, ArrayList 相比他们并发的实现(比如:ConcurrentHashMap, CopyOnWriteArrayList, CopyOnWriteHashSet)会慢得多。造成如此慢的主要原因是锁, 同步集合会把整个Map或List锁起来,而并发集合不会。并发集合实现线程安全是通过使用先进的和成熟的技术像锁剥离。比如ConcurrentHashMap 会把整个Map 划分成几个片段,只对相关的几个片段上锁,同时允许多线程访问其他未上锁的片段。

    3.16 常用的线程池

    ThreadPoolExecutor

    构造方法:

    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
    TimeUnit unit,BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,RejectedExecutionHandler handler)

    参数:

    corePoolSize - 池中所保存的线程数,包括空闲线程。

    maximumPoolSize - 池中允许的最大线程数。

    keepAliveTime - 当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。

    unit - keepAliveTime 参数的时间单位。

    workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。

    threadFactory - 执行程序创建新线程时使用的工厂。

    handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。

     

    超出线程范围和队列容量而使执行被阻塞时所使用的处理程序
    策略 含义
    ThreadPoolExecutor.AbortPolicy   用于被拒绝任务的处理程序,它将抛出 RejectedExecutionException
    ThreadPoolExecutor.CallerRunsPolicy  用于被拒绝任务的处理程序,它直接在 execute 方法的调用线程中运行被拒绝的任务;如果执行程序已关闭,则会丢弃该任务。
    ThreadPoolExecutor.DiscardOldestPolicy  用于被拒绝任务的处理程序,它放弃最旧的未处理请求,然后重试 execute;如果执行程序已关闭,则会丢弃该任务。
    ThreadPoolExecutor.DiscardPolicy  用于被拒绝任务的处理程序,默认情况下它将丢弃被拒绝的任务。

     

    • AbortPolicy 丢弃任务,抛运行时异常
    • CallerRunsPolicy 执行任务
    • DiscardPolicy 忽视,什么都不会发生
    • DiscardOldestPolicy 从队列中踢出最先进入队列(最后一个执行)的任务

    线程池工具类 Executors 可以构造常用的线程池

    线程池  
    newFixedThreadPool(int nThreads)
     public static ExecutorService newFixedThreadPool(int nThreads) {
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());
        }

    创建一个可重用固定线程数的线程池,以共享的无界队列方式来运行这些线程

    newCachedThreadPool()
        public static ExecutorService newCachedThreadPool() {
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>());
        }

    创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们

    newScheduledThreadPool(int corePoolSize)

     

    创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。

    newSingleThreadExecutor()
      public static ExecutorService newSingleThreadExecutor() {
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        }
    

    创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程

    3.17 sleep和wait的区别?

    1. sleep和wait都会使线程进入冻结状态,并且都会释放cpu的执行权和cpu的执行资格,不同的是sleep不会释放锁,而wait会连锁一起释放。
    2. sleep()方法可以在任何地方使用;wait()方法则只能在同步方法或同步块中使用
    3. sleep方法是Thread类中定义的方法,wait是Object中定义的方法

    3.18  fail-fast和fail-safe机制

    fail-fast即快速失败机制,是java集合(Collection)中的一种错误检测机制。当在迭代集合的过程中该集合在结构上发生改变的时候,就有可能会发生fail-fast,即抛出ConcurrentModificationException异常

    fail-safe 采用安全失败机制的集合容器,在遍历时不是直接在集合内容上访问的,而是先复制原有集合内容,在拷贝的集合上进行遍历

    3.19 JVM性能调优监控工具jps、jstack、jmap、jhat、jstat、hprof使用

    A、 jps(Java Virtual Machine Process Status Tool)      

        jps主要用来输出JVM中运行的进程状态信息。语法格式如下:

    jps [options] [hostid]

        如果不指定hostid就默认为当前主机或服务器。

        命令行参数选项说明如下:

    -q 不输出类名、Jar名和传入main方法的参数
    
    -m 输出传入main方法的参数
    
    -l 输出main类或Jar的全限名
    
    -v 输出传入JVM的参数

       比如下面:

    B、 jstack

        jstack主要用来查看某个Java进程内的线程堆栈信息。语法格式如下:

    jstack [option] pid
    jstack [option] executable core
    jstack [option] [server-id@]remote-hostname-or-ip

        命令行参数选项说明如下:

    -l long listings,会打印出额外的锁信息,在发生死锁时可以用jstack -l pid来观察锁持有情况-m mixed mode,不仅会输出Java堆栈信息,还会输出C/C++堆栈信息(比如Native方法)

        jstack可以定位到线程堆栈,根据堆栈信息我们可以定位到具体代码,所以它在JVM性能调优中使用得非常多。下面我们来一个实例找出某个Java进程中最耗费CPU的Java线程并定位堆栈信息,用到的命令有ps、top、printf、jstack、grep。

    查找最消耗cpu的java线程

    命令:可以使用ps -Lfp pid或者ps -mp pid -o THREAD, tid, time或者top -Hp pid

     

     

        TIME列就是各个Java线程耗费的CPU时间,CPU时间最长的是线程ID为21742的线程,用

    printf "%x\n" 21742

        得到21742的十六进制值为54ee,下面会用到。    

        OK,下一步终于轮到jstack上场了,它用来输出进程21711的堆栈信息,然后根据线程ID的十六进制值grep,如下:

    root@ubuntu:/# jstack 21711 | grep 54ee
    "PollIntervalRetrySchedulerThread" prio=10 tid=0x00007f950043e000 nid=0x54ee in Object.wait() [0x00007f94c6eda000

    C、 jmap(Memory Map)和jhat(Java Heap Analysis Tool)

        jmap用来查看堆内存使用状况,一般结合jhat使用。

        jmap语法格式如下:

    jmap [option] pid
    jmap [option] executable core
    jmap [option] [server-id@]remote-hostname-or-ip

     

    D、jstat(JVM统计监测工具)

        语法格式如下:

    jstat [ generalOption | outputOptions vmid [interval[s|ms] [count]] ]

        vmid是Java虚拟机ID,在Linux/Unix系统上一般就是进程ID。interval是采样时间间隔。count是采样数目。比如下面输出的是GC信息,采样时间间隔为250ms,采样数为4: 

    20160220110058880 (558Ã231)

    可以看出:

    堆内存 = 年轻代 + 年老代 
    年轻代 = Eden区 + 两个Survivor区(From和To)

    现在来解释各列含义:

    S0C、S1C、S0U、S1U:Survivor 0/1区容量(Capacity)和使用量(Used)
    EC、EU:Eden区容量和使用量
    OC、OU:年老代容量和使用量
    MC、MU:元数据空间容量和使用量
    CCSC、CCSU
    YGC、YGT:年轻代GC次数和GC耗时
    FGC、FGCT:Full GC次数和Full GC耗时
    GCT:GC总耗时

     

    E、hprof(Heap/CPU Profiling Tool)

        hprof能够展现CPU使用率,统计堆内存使用情况。

        语法格式如下:

    java -agentlib:hprof[=options] ToBeProfiledClass
    java -Xrunprof[:options] ToBeProfiledClass
    javac -J-agentlib:hprof[=options] ToBeProfiledClass

     3.20  Java中的同步集合与并发集合有什么区别

    不管是同步集合还是并发集合他们都支持线程安全,他们之间主要的区别体现在性能可扩展性,还有他们如何实现的线程安全。同步HashMap, Hashtable, HashSet, Vector, ArrayList 相比他们并发的实现(比如:ConcurrentHashMap, CopyOnWriteArrayList, CopyOnWriteHashSet)会慢得多。造成如此慢的主要原因是, 同步集合会把整个Map或List锁起来,而并发集合不会。并发集合实现线程安全是通过使用先进的和成熟的技术像锁剥离。比如ConcurrentHashMap 会把整个Map 划分成几个片段,只对相关的几个片段上锁,同时允许多线程访问其他未上锁的片段。

    同样的,CopyOnWriteArrayList 允许多个线程以非同步的方式读,当有线程写的时候它会将整个List复制一个副本给它。

    如果在读多写少这种对并发集合有利的条件下使用并发集合,这会比使用同步集合更具有可伸缩性。

    同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合,不过并发集合的可扩展性更高。在Java1.5之前程序员们只有同步集合来用且在多线程并发的时候会导致争用,阻碍了系统的扩展性。Java5介绍了并发集合像ConcurrentHashMap,不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。

    3.21 Java中synchronized 和 ReentrantLock 有什么不同

     这两种方式最大区别就是对于Synchronized来说,它是java语言的关键字,是原生语法层面的互斥,需要jvm实现。而ReentrantLock它是JDK 1.5之后提供的API层面的互斥锁,需要lock()和unlock()方法配合try/finally语句块来完成。

     Synchronized进过编译,会在同步块的前后分别形成monitorenter和monitorexit这个两个字节码指令。在执行monitorenter指令时,首先要尝试获取对象锁。如果这个对象没被锁定,或者当前线程已经拥有了那个对象锁,把锁的计算器加1,相应的,在执行monitorexit指令时会将锁计算器就减1,当计算器为0时,锁就被释放了。如果获取对象锁失败,那当前线程就要阻塞,直到对象锁被另一个线程释放为止。

    3.22 Java中的fork join框架是什么?

    Fork/Join框架是Java 7提供的一个用于并行执行任务的框架,是一个把大任务分割成若干个小任务,最终汇总每个小任务结果后得到大任务结果的框架。Fork/Join框架要完成两件事情:

      1.任务分割:首先Fork/Join框架需要把大的任务分割成足够小的子任务,如果子任务比较大的话还要对子任务进行继续分割

      2.执行任务并合并结果:分割的子任务分别放到双端队列里,然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都放在另外一个队列里,启动一个线程从队列里取数据,然后合并这些数据。

      在Java的Fork/Join框架中,使用两个类完成上述操作

      1.ForkJoinTask:我们要使用Fork/Join框架,首先需要创建一个ForkJoin任务。该类提供了在任务中执行fork和join的机制。通常情况下我们不需要直接集成ForkJoinTask类,只需要继承它的子类,Fork/Join框架提供了两个子类:

        a.RecursiveAction:用于没有返回结果的任务

        b.RecursiveTask:用于有返回结果的任务

      2.ForkJoinPool:ForkJoinTask需要通过ForkJoinPool来执行

      任务分割出的子任务会添加到当前工作线程所维护的双端队列中,进入队列的头部。当一个工作线程的队列里暂时没有任务时,它会随机从其他工作线程的队列的尾部获取一个任务(工作窃取算法)。

    public class CountTask extends RecursiveTask<Integer>{
    
        private static final int THREAD_HOLD = 2;
    
        private int start;
        private int end;
    
        public CountTask(int start,int end){
            this.start = start;
            this.end = end;
        }
    
        @Override
        protected Integer compute() {
            int sum = 0;
            //如果任务足够小就计算
            boolean canCompute = (end - start) <= THREAD_HOLD;
            if(canCompute){
                for(int i=start;i<=end;i++){
                    sum += i;
                }
            }else{
                int middle = (start + end) / 2;
                CountTask left = new CountTask(start,middle);
                CountTask right = new CountTask(middle+1,end);
                //执行子任务
                left.fork();
                right.fork();
                //获取子任务结果
                int lResult = left.join();
                int rResult = right.join();
                sum = lResult + rResult;
            }
            return sum;
        }
    
        public static void main(String[] args){
            ForkJoinPool pool = new ForkJoinPool();
            CountTask task = new CountTask(1,4);
            Future<Integer> result = pool.submit(task);
            try {
                System.out.println(result.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

    3.23 Java中的锁机制  偏向锁 & 轻量级锁 & 重量级锁各自优缺点及场景

    优点

    缺点

    适用场景

    偏向锁

    加锁和解锁不需要额外的消耗,和执行非同步方法比仅存在纳秒级的差距。

    如果线程间存在锁竞争,会带来额外的锁撤销的消耗。

    适用于只有一个线程访问同步块场景。

    轻量级锁

    竞争的线程不会阻塞,提高了程序的响应速度。

    如果始终得不到锁竞争的线程使用自旋会消耗CPU。

    追求响应时间。

    同步块执行速度非常快。

    重量级锁

    线程竞争不使用自旋,不会消耗CPU。

    线程阻塞,响应时间缓慢。

    追求吞吐量。

    同步块执行速度较长。

    3.24 synchronized修饰代码块、普通方法、静态方法有什么区别。

    修饰代码块获取的是指定的对象监视器。

    修饰普通代码块并未显示使用monitorenter指令,而是通过标志位ACC_SYNCHRONIZED标志位来判断是否由synchronized修饰,获取的是该实例对象的监视器。

    修饰静态方法同普通方法,不同的是获取的是这个类的监视器 

    3.25 synchronized 和 lock 有什么区别?

    1.首先synchronized是java内置关键字,在jvm层面,Lock是个java类;

    2.synchronized无法判断是否获取锁的状态,Lock可以判断是否获取到锁;

    3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ;b 线程执行过程中发生异常会释放锁),Lock需在finally中手工释放锁(unlock()方法释放锁),否则容易造成线程死锁;

    4.Lock可以让等待锁的线程响应中断,而synchronized却不行,使用synchronized时,等待的线程会一直等待下去,不能够响应中断;

    5.synchronized的锁可重入、不可中断、非公平,而Lock锁可重入、可判断、可公平(两者皆可)

    6.Lock锁适合大量同步的代码的同步问题,synchronized锁适合代码少量的同步问题。

    3.26 什么是CAS?

    使用锁时,线程获取锁是一种悲观锁策略,即假设每一次执行临界区代码都会产生冲突,所以当前线程获取到锁的时候同时也会阻塞其他线程获取该锁。而CAS操作(又称为无锁操作)是一种乐观锁策略,它假设所有线程访问共享资源的时候不会出现冲突,既然不会出现冲突自然而然就不会阻塞其他线程的操作。因此,线程就不会出现阻塞停顿的状态。那么,如果出现冲突了怎么办?无锁操作是使用CAS(compare and swap)又叫做比较交换来鉴别线程是否出现冲突,出现冲突就重试当前操作直到没有冲突为止。

    CAS比较交换的过程可以通俗的理解为CAS(V,O,N),包含三个值分别为:V 内存地址存放的实际值;O 预期的值(旧值);N 更新的新值

    3.27 Synchronized 和 CAS

    这是两者主要的区别是Synchronized在存在线程竞争的情况下会出现线程阻塞和唤醒锁带来的性能问题,因为这是一种互斥同步(阻塞同步)。

    而CAS并不是武断的间线程挂起,当CAS操作失败后会进行一定的尝试,而非进行耗时的挂起唤醒的操作,因此也叫做非阻塞同步。

    CAS的问题

    1. ABA问题
      因为CAS会检查旧值有没有变化,这里存在这样一个有意思的问题。比如一个旧值A变为了成B,然后再变成A,刚好在做CAS时检查发现旧值并没有变化依然为A,但是实际上的确发生了变化。解决方案可以沿袭数据库中常用的乐观锁方式,添加一个版本号可以解决。原来的变化路径A->B->A就变成了1A->2B->3C。为了解决ABA问题,伟大的java为我们提供了AtomicMarkableReference和AtomicStampedReference类,为我们解决了问题

    2. 自旋时间过长

    3.28 java中原子操作

    (1)原子更新基本类型

    atomic包提高原子更新基本类型的工具类,主要有这些:

    1. AtomicBoolean:以原子更新的方式更新boolean;
    2. AtomicInteger:以原子更新的方式更新Integer;
    3. AtomicLong:以原子更新的方式更新Long

    (2)原子更新数组类型

    atomic包下提供能原子更新数组中元素的类有:

     

    1. AtomicIntegerArray:原子更新整型数组中的元素;
    2. AtomicLongArray:原子更新长整型数组中的元素;
    3. AtomicReferenceArray:原子更新引用类型数组中的元素

    (3)原子更新引用类型

    如果需要原子更新引用类型变量的话,为了保证线程安全,atomic也提供了相关的类:

     

    1. AtomicReference:原子更新引用类型;
    2. AtomicReferenceFieldUpdater:原子更新引用类型里的字段;
    3. AtomicMarkableReference:原子更新带有标记位的引用类型;

    (4)原子更新字段类型

    如果需要更新对象的某个字段,并在多线程的情况下,能够保证线程安全,atomic同样也提供了相应的原子操作类:

    • AtomicIntegeFieldUpdater:原子更新整型字段类;
    • AtomicLongFieldUpdater:原子更新长整型字段类;
    • AtomicStampedReference:原子更新引用类型,这种更新方式会带有版本号。而为什么在更新的时候会带有版本号,是为了解决CAS的ABA问题;

    要想使用原子更新字段需要两步操作:

    1. 原子更新字段类都是抽象类,只能通过静态方法newUpdater来创建一个更新器,并且需要设置想要更新的类和属性;
    2. 更新类的属性必须使用public volatile进行修饰;

     

    4、JavaWeb

    4.1 Http中Get和Post的区别

    1. GET请求,请求的数据会附加在URL之后。POST请求,请求数据在请求体中
    2. GET请求传输的数据有大小限制,POST请求没有大小限制
    3. POST的安全性比GET的高

     4.2 tomcat的优化

    (1)tomcat内存优化

    Tomcat内存优化主要是对 tomcat 启动参数优化,我们可以在 tomcat 的启动脚本 catalina.sh 中设置 java_OPTS 参数。

    JAVA_OPTS参数说明

    -server 启用jdk 的 server 版;

    -Xms java虚拟机初始化时的最小内存;

    -Xmx java虚拟机可使用的最大内存;

    -XX: PermSize 内存永久保留区域

    -XX:MaxPermSize 内存最大永久保留区域

    服务器参数配置

    (2)Tomcat并发优化

    修改Tomcat 配置文件 server.xml 中

    <Connector port="9027"
       protocol="HTTP/1.1"   
         maxHttpHeaderSize="8192"   
         maxThreads="1000"   
         minSpareThreads="100"   
         maxSpareThreads="1000"   
         minProcessors="100"   
         maxProcessors="1000"   
         enableLookups="false"   
         URIEncoding="utf-8"   
         acceptCount="1000"   
         redirectPort="8443"   
         disableUploadTimeout="true"/>

    maxThreads 客户请求最大线程数

    minSpareThreads Tomcat初始化时创建的 socket 线程数

    maxSpareThreads Tomcat连接器的最大空闲 socket 线程数

    enableLookups 若设为true, 则支持域名解析,可把 ip 地址解析为主机名

    redirectPort 在需要基于安全通道的场合,把客户请求转发到基于SSL 的 redirectPort 端口

    acceptAccount 监听端口队列最大数,满了之后客户请求会被拒绝(不能小于maxSpareThreads )

    connectionTimeout 连接超时

    minProcessors 服务器创建时的最小处理线程数

    maxProcessors 服务器同时最大处理线程数

    URIEncoding URL统一编码

    (3)Tomcat缓存优化

     <Connector port="9027"
       protocol="HTTP/1.1"   
    maxHttpHeaderSize="8192"   
    maxThreads="1000"   
    minSpareThreads="100"   
    maxSpareThreads="1000"   
    minProcessors="100"   
    maxProcessors="1000"   
    enableLookups="false"   
    compression="on"   
    compressionMinSize="2048"   compressableMimeType="text/html,text/xml,text/javascript,text/css,text/plain"   
    connectionTimeout="20000"   
    URIEncoding="utf-8"   
    acceptCount="1000"   
    redirectPort="8443"   
    disableUploadTimeout="true"/>

    compression 打开压缩功能

    compressionMinSize 启用压缩的输出内容大小,这里面默认为2KB

    compressableMimeType 压缩类型

    connectionTimeout 定义建立客户连接超时的时间. 如果为 -1, 表示不限制建立客户连接的时间

    4.3 Sevlet生命周期

    1. 第一次访问servlet,servlet会被创建,并将servlet对象常驻内存,调用init方法进行初始化操作,init方法中执行一次。

    2. 开启一个线程,调用service方法,用于处理来自浏览器端的请求,以后都是开启一个线程来处理浏览器端请求。

    3. 当tomcat服务器正常关闭时,会调用destroy方法将servlet销毁。

    注意:servlet是线程不安全的,也就是说,不建议在servlet中创建成员变量

    4.4 forward()和redirect()的区别

    1. 请求转发是一个请求,而重定向是两个请求;
    2. 请求转发后浏览器地址栏不会有变化,而重定向会有变化,因为重定向是两个请求;
    3. 请求转发的目标只能是本应用中的资源,重定向的目标可以是其他应用;
    4. 请求转发对AServlet和BServlet的请求方法是相同的,即要么都是GET,要么都是POST,因为请求转发是一个请求;
    5. 重定向的第二个请求一定是GET;

     

    4.5 jsp中的九大内置对象

    1. page     类型是Object
    2. request   类型是HttpServletRequest
    3. response  类型是HttpServletResponse
    4. session   类型是HttpSession
    5. application  类型是ServletContext
    6. out      类型是JspWriter
    7. config    类型是ServletConfig
    8. exception   类型是Throwable
    9. pageContext  类型是PageContext

    4.6 jsp中的四个域对象

    pageContext:它代表的是page域,但是jsp中page它的类型是Object,所以操作page域我们使用的是pageContext对象,page域就是指当前页面范围

    request :它是代表整个请求链

    session:整个会话

    application:整个web应用

     

    servlet中有三个域对象

    HttpServletRequest  整个请求链

    HttpSession 整个会话

    ServletContext 整个web应用。

     

    对于域对象它们都具有以下方法

    setAttribute(String name,Object value)

    getAttribute(String name)

    removeAttribute(String name)

    4.7 Jsp与servlet的区别

    Jsp  java server page 运行在服务器上的页面,它的本质就是一个servlet.

    Jsp与servlet区别:

    Jsp它的主要作用是用于显示数据。

    Servlet它的主要作用是用于处理请求完成业务逻辑操作。

    4.8 TCP与UDP的区别

     UDP

    * 面向无连接,数据不安全,速度快。不区分客户端与服务端。

    *TCP

    * 面向连接(三次握手),数据安全,速度略低。分为客户端和服务端。

    * 三次握手: 客户端先向服务端发起请求, 服务端响应请求, 传输数据

    4.9 tcp/udp协议在网络模型

     

     

     

    4.10 说说你熟悉的响应码

    200:请求成功,浏览器会把响应体内容(通常是html)显示在浏览器中;

    404:请求的资源没有找到,说明客户端错误的请求了不存在的资源;

    500:请求资源找到了,但服务器内部出现了错误;

    302:重定向,当响应码为302时,表示服务器要求浏览器重新再发一个请求,服务器会发送一个响应头Location,它指定了新请求的URL地址;

    5 linux常用命令

     

    5.1 基本命令

    (1)文件夹操作

    • ls    查看目录信息

    ls -l   查看详细信息,等价于  ll

    ls –a         查看隐藏文件

    •  ifconfig   查看ip地址
    •  pwd     查看当前所处目录的绝对路径
    • Ctrl+l清屏
    • mkdir  ./test 创建文件夹

    mkdir -p a/b/c  如果要创建的文件夹的父目录不存在,则自动创建

    • rmdir   删除空文件夹  (只能删除空文件夹)
    • rm -r  /a/b  (删除非空文件夹)

    删除文件

    rm filename  (rm -r  删除文件夹     rm -rf 强制删除文件或文件夹)

     

    5.2 创建文件

    • touch a.avi 创建一个空文件
    • echo "itcast is the greatest IT School" > itcast.txt把“>”左边的输出放到右边的文件里去
    • vi  blabla.txt 用文本编辑器编辑一个文件并且保存,按esc退出编辑:wq退出

    Vi编辑器

    linux系统中最通用的文本编辑器

    vi hello.world 进入文件编辑

    进去之后处于非编辑模式,此时,要按一个i进入insert模式

     

     

     

     

    在insert模式下,可以跟普通文本编辑器一样编辑内容

    编辑完成之后,先按Esc退出insert模式,进入非编辑模式

    然后再按 :进入底行命令模式,在底行命令中敲入wq并回车,即可保存

    如果想不保存退出,底行命令就用 q!

     

    (保存文件的另一种模式: 编辑完后按Esc退出insert模式,然后直接按快捷键保存—— shift + zz)

    5.3 移动文件、修改文件名

    • mv a/wenjian1.txt b/file1.txt   (移动文件的同时还修改了文件名)
    • rename ./a.txt ./b.txt

     

    5.4 拷贝文件

    • cp  srcFile  destFile

     

    5.5 查看文本内容

    • cat  log.a.txt  一次性显示整个文件内容
    • more  log.a.txt 可以分页看(翻页:空格,往回翻:b ,退出: q或者 Ctrl+C)
    • less  log.a.txt 不仅可以分页,还可以方便地搜索,回翻等操作(翻页:空格,往回翻:↑,往下翻:↓,退出:q或者 Ctrl+C)
    • tail -10 log.a.txt   查看文件的尾部的10行
    • tail -f user.log   实时刷新显示文件的尾部,这条命令对于观察调试程序的运行非常重要

    Ctrl+C退出

     

    • head -20 log.a.txt 查看文件的头部20行

     

    (2)文件归档压缩

    5.6 打包/解包

    tar -cvf testdir.tar testdir/

    参数c :表示创建一个打包文档

    v:显示打包的进度

    f:表示要打成的tar包的名字

     

     

    tar –xvf testdir.tar

    参数x:表示从一个现存的tar文件中进行解包操作

    5.7 压缩/解压

    gzip testdir.tar 

    gzip –d testdir.tar.gz

     

     

    5.8 归档并压缩/解压

    tar -czvf  testdir.tar.gz testdir/

    tar -xzvf testdir.tar.gz  解压到当前目录下

    tar -xzvf testdir.tar.gz -C Downloads/   解压到指定的Downloads目录下

     

    zip test.txt.zip test.txt

    unzip test.txt.zip

     

    5.9 网络服务启动与停止

     

    • 列出系统所有应用服务状态
      1. service  --status-all
    • 查看指定服务运行状态:
      1. service servicename status
    • 启动服务:
      1. service servicename start
    • 停止服务:
      1. service servicename stop

     

    • 列出所有服务的随机自起配置:
      1. chkconfig  --list
    • 关闭服务的随机自起:
      1. chkconfig servicename off
    • 开启服务的随机自起:
      1. chkconfig servicename on

     

     

    • 常用示例:
      1. 重启网络服务 service network restart
      2. 停止httpd        service httpd stop
      3. 启动 httpd      service httpd start
      4. 关闭防火墙服务  service iptables stop
      5. 关闭防火墙自动启动   chkconfig iptables off
      6. 查看端口被那个进程占用 lsof -i:端口号  netstat -lnp|grep 88

     

     6 mysql

     

    6.1 乐观锁与悲观锁的区别?

    悲观锁(Pessimistic Lock), 顾名思义,就是很悲观,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁。

     

    乐观锁(Optimistic Lock), 顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号等机制。乐观锁适用于多读的应用类型,这样可以提高吞吐量,像数据库如果提供类似于write_condition机制的其实都是提供的乐观锁

     

     

    6.2 事务的特性

    原子性:(Atomicity)

    原子性:强调事务的不可分割.

    一致性:(Consistency)

    一致性:事务在执行的前后,数据的完整性保持一致.

    隔离性:(Isolation)

    隔离性:多个事务并发执行的时候,一个事务的执行不应该受到其他的事务的干扰.

    持久性:(Durability)

    持久性:事务一个结束了.数据就永久的保存到数据库.

     

    6.3 不考虑事务的隔离性引发的一系列安全问题

    * 脏读      :一个事务读到了另一个事务未提交的数据.

    * 不可重复读 :一个事务读到了另一个事务已经提交的update的数据,导致在一个事务中多次的查询结果不一致.

    * 虚读/幻读  :一个事务读到了另一个事务已经提交的insert的数据,导致在一个事务中多次查询的结果不一致.

    * 数据库中提供了事务的隔离级别用于解决三类读问题.

    * read uncommitted  :未提交读.脏读、不可重复读、虚读都是有可能发生.

    * read committed    :已提交读.避免脏读.但是不可重复读、虚读是有可能发生.

    * repeatable read   :可重复读.避免脏读、不可重复读.但是虚读是有可能发生.

    * serializable      :串行化的.避免脏读、不可重复读、虚读的发生.

     

    * 安全性:serializable > repeatable read > read committed > read uncommitted

    * 效率性:read uncommitted > read committed > repeatable read > serializable

     

    ***** MYSQL数据库默认隔离级别:repeatable read .Oracle数据库默认的隔离级别:read committed

     

    6.4 mysql常用的数据库引擎

     

     

    InnoDB支持事务处理,支持外键,支持崩溃修复能力和并发控制。如果需要对事务的完整性要求比较高(比如银行),要求实现并发控制(比如售票),那选择InnoDB有很大的优势。如果需要频繁的更新、删除操作的数据库,也可以选择InnoDB,因为支持事务的提交(commit)和回滚(rollback)。

     InnoDB是提供了提交,回滚和崩溃恢复能力的事物安全存储引擎,支持行锁定和外键,是mysql的默认存储引擎

    MyISAM插入数据快,空间和内存使用比较低。如果表主要是用于插入新记录和读出记录,那么选择MyISAM能实现处理高效率。如果应用的完整性、并发性要求比较低,也可以使用。

    MyISAM不支持事物 插入和查询的处理效率高,支持索引

    MEMORY所有的数据都在内存中,数据的处理速度快,但是安全性不高。如果需要很快的读写速度,对数据的安全性要求较低,可以选择MEMOEY。它对表的大小有要求,不能建立太大的表。所以,这类数据库只使用在相对较小的数据库表。

     

    6.5 jdbc中Statement与Preparestament的区别

    第一:

    prepareStatement会先初始化SQL,先把这个SQL提交到数据库中进行预处理,多次使用可提高效率。

    Statement不会初始化,没有预处理.

    第二:

    prepareStatement可以替换变量在SQL语句中可以包含?,可以用

    ps=conn.prepareStatement("select* from Cust where ID=?");
    
    int sid=1001;
    
    ps.setInt(1, sid);
    
    rs = ps.executeQuery();

    可以把?替换成变量。

    而Statement只能用

    int sid=1001;
    
    Statement stmt = conn.createStatement();
    
    ResultSet rs = stmt.executeQuery("select * from Cust where ID="+sid);

    来实现。

     

    第三:

    prepareStatement会先初始化SQL,先把这个SQL提交到数据库中进行预处理,多次使用可提高效率。

    Statement不会初始化,没有预处理,没次都是从0开始执行SQL

    6.6 sql优化

    1. 对查询进行优化,要尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引。
    2. 应尽量避免在 where 子句中对字段进行 null 值判断,否则将导致引擎放弃使用索引而进行全表扫描,最好不要给数据库留NULL,尽可能的使用 NOT NULL填充数据库.
    3. 应尽量避免在 where 子句中使用 != 或 <> 操作符,否则将引擎放弃使用索引而进行全表扫描。

    4应尽量避免在 where 子句中使用 or 来连接条件,如果一个字段有索引,一个字段没有索引,将导致引擎放弃使用索引而进行全表扫描,如:

     

    select id from t where num=10 or Name = 'admin'

    可以这样查询:

    select id from t where num = 10
    
    union all
    
    select id from t where Name = 'admin'

     

    5、in 和 not in 也要慎用,否则会导致全表扫描

    6、创建适合的索引

      例如我们建立了一个这样的索引(area,age,salary),那么其实相当于创建了(area,age,salary,(area,age),(area)三个索引

    7like语句优化

    SELECT id FROM A WHERE name like '%abc%'

       由于abc前面用了“%”,因此该查询必然走全表查询,除非必要,否则不要在关键词前加%,优化成如下

    SELECT id FROM A WHERE name like 'abc%'

     

    8、尽量用内连接替换外链接,用外链接替换子查询。

    6.7 分表分库

    1 基本思想之什么是分库分表?
    从字面上简单理解,就是把原本存储于一个库的数据分块存储到多个库上,把原本存储于一个表的数据分块存储到多个表上。
    2 基本思想之为什么要分库分表?

    数据库中的数据量不一定是可控的,在未进行分库分表的情况下,随着时间和业务的发展,库中的表会越来越多,表中的数据量也会越来越大,相应地,数据操作,增删改查的开销也会越来越大;另外,由于无法进行分布式式部署,而一台服务器的资源(CPU、磁盘、内存、IO等)是有限的,最终数据库所能承载的数据量、数据处理能力都将遭遇瓶颈。
    3 分库分表的实施策略。

    分库分表有垂直切分和水平切分两种。
    3.1 何谓垂直切分,即将表按照功能模块、关系密切程度划分出来,部署到不同的库上。例如,我们会建立定义数据库workDB、商品数据库payDB、用户数据库userDB、日志数据库logDB等,分别用于存储项目数据定义表、商品定义表、用户数据表、日志数据表等。
    3.2 何谓水平切分,当一个表中的数据量过大时,我们可以把该表的数据按照某种规则,例如userID散列,进行划分,然后存储到多个结构相同的表,和不同的库上。例如,我们的userDB中的用户数据表中,每一个表的数据量都很大,就可以把userDB切分为结构相同的多个userDB:part0DB、part1DB等,再将userDB上的用户数据表userTable,切分为很多userTable:userTable0、userTable1等,然后将这些表按照一定的规则存储到多个userDB上。
    3.3 应该使用哪一种方式来实施数据库分库分表,这要看数据库中数据量的瓶颈所在,并综合项目的业务类型进行考虑。
    如果数据库是因为表太多而造成海量数据,并且项目的各项业务逻辑划分清晰、低耦合,那么规则简单明了、容易实施的垂直切分必是首选。
    而如果数据库中的表并不多,但单表的数据量很大、或数据热度很高,这种情况之下就应该选择水平切分,水平切分比垂直切分要复杂一些,它将原本逻辑上属于一体的数据进行了物理分割,除了在分割时要对分割的粒度做好评估,考虑数据平均和负载平均,后期也将对项目人员及应用程序产生额外的数据管理负担。
    在现实项目中,往往是这两种情况兼而有之,这就需要做出权衡,甚至既需要垂直切分,又需要水平切分。我们的游戏项目便综合使用了垂直与水平切分,我们首先对数据库进行垂直切分,然后,再针对一部分表,通常是用户数据表,进行水平切分。

    6.8 oracle数据库的分页

    select t1.*
    
      from (select rownum rw, k.*
    
    from ks_collect_pushed k
    
    where rownum < = 15) t1
    
     where rw > 5

    6.9 mysql索引的分类

    普通索引

    (1)直接创建索引

    CREATE INDEX index_name ON table(column(length))

    (2)修改表结构的方式添加索引

    ALTER TABLE table_name ADD INDEX index_name ON (column(length))

    (3)创建表的时候同时创建索引

    CREATE TABLE `table` (
        `id` int(11) NOT NULL AUTO_INCREMENT ,
        `title` char(255) CHARACTER NOT NULL ,
        `content` text CHARACTER NULL ,
        `time` int(10) NULL DEFAULT NULL ,
        PRIMARY KEY (`id`),
        INDEX index_name (title(length))
    )

    (4)删除索引

    DROP INDEX index_name ON table

     

    唯一索引

    CREATE UNIQUE INDEX indexName ON table(column(length))

    主键索引

    CREATE TABLE `table` (
        `id` int(11) NOT NULL AUTO_INCREMENT ,
        `title` char(255) NOT NULL ,
        PRIMARY KEY (`id`)
    );

    联合索引

    ALTER TABLE `table` ADD INDEX name_city_age (name,city,age); 

    全文索引

    (1)创建表的适合添加全文索引

    CREATE TABLE `table` (
        `id` int(11) NOT NULL AUTO_INCREMENT ,
        `title` char(255) CHARACTER NOT NULL ,
        `content` text CHARACTER NULL ,
        `time` int(10) NULL DEFAULT NULL ,
        PRIMARY KEY (`id`),
        FULLTEXT (content)
    );

     

    (2)修改表结构添加全文索引

    ALTER TABLE article ADD FULLTEXT index_content(content)

    (3)直接创建索引

    CREATE FULLTEXT INDEX index_content ON article(content)

    6.10 创建索引的原则

    1. 索引不是越多越好,索引创建过多会影响增、删、改sql语句的性能
    2. 避免对经常更新的表创建索引
    3. 对用到不同值较多的列创建索引,在不同值很少的列上不要建立索引,如学生表的性别字段上,只有“男”“女”两个不同值,因此就无需建立索引
    4. 当唯一性是数据本身的特征时,指定唯一索引,确保定义列数据的完整性,提高查询速度

    6.11 mysql索引的工作原理

    索引是在存储引擎中实现的,而不是在服务器层中实现的。所以,每种存储引擎的索引都不一定完全相同,并不是所有的存储引擎都支持所有的索引类型。

    InnoDB 索引的实现通常使用B树及其变种B+

    利用局部性原理与磁盘预读,每次新建节点时,直接申请一个页的空间,这样就保证一个节点物理上也存储在一个页里,加之计算机存储分配都是按页对齐的,就实现了一个node只需一次I/O。

     

    6.12 复制基本原理流程

    1. 主:binlog线程——记录下所有改变了数据库数据的语句,放进master上的binlog中;
    2. 从:io线程——在使用start slave 之后,负责从master上拉取 binlog 内容,放进 自己的relay log中;
    3. 从:sql执行线程——执行relay log中的语句;

    6.13 MySQL复制的线程有几个及之间的关联

    MySQL 的复制是基于如下 3 个线程的交互( 多线程复制里面应该是 4 类线程):
    1. Master 上面的 binlog dump 线程,该线程负责将 master 的 binlog event 传到slave;
    2. Slave 上面的 IO 线程,该线程负责接收 Master 传过来的 binlog,并写入 relay log;
    3. Slave 上面的 SQL 线程,该线程负责读取 relay log 并执行;
    4. 如果是多线程复制, SQL 线程只做 coordinator,只负责把 relay log 中的 binlog读出来
    然后交给 worker 线程, woker 线程负责具体 binlog event 的执行;

    6.14 MySQL如何保证复制过程中数据一致性及减少数据同步延时

    1.   在 MySQL5.5 以及之前, slave 的 SQL 线程执行的 relay log 的位置只能保存在文件( relay-log.info)里面,并且该文件默认每执行 10000 次事务做一次同步到磁盘, 这意味着 slave 意外 crash 重启时, SQL 线程执行到的位置和数据库的数据是不一致的,将导致复制报错,如果不重搭复制,则有可能会
    导致数据不一致。 MySQL 5.6 引入参数 relay_log_info_repository,将该参数设置为 TABLE 时, MySQL 将 SQL 线程执行到的位置存到mysql.slave_relay_log_info 表,这样更新该表的位置和 SQL 线程执行的用户事务绑定成一个事务,这样 slave 意外宕机后, slave 通过 innodb 的崩溃
    恢复可以把 SQL 线程执行到的位置和用户事务恢复到一致性的状态。
    2.    MySQL 5.6 引入 GTID 复制,每个 GTID 对应的事务在每个实例上面最多执行一次, 这极大地提高了复制的数据一致性;
    3.    MySQL 5.5 引入半同步复制, 用户安装半同步复制插件并且开启参数后,设置超时时间,可保证在超时时间内如果 binlog 不传到 slave 上面,那么用户提交事务时不会返回,直到超时后切成异步复制,但是如果切成异步之前用户线程提交时在 master 上面等待的时候,事务已经提交,该事务对 master
    上面的其他 session 是可见的,如果这时 master 宕机,那么到 slave 上面该事务又不可见了,该问题直到 5.7 才解决;
    4.  MySQL 5.7 引入无损半同步复制,引入参 rpl_semi_sync_master_wait_point,该参数默认为 after_sync,指的是在切成半同步之前,事务不提交,而是接收到 slave 的 ACK 确认之后才提交该事务,从此,复制真正可以做到无损的了。

    6.15 数据库主库和从库不一致,怎么解决?

    在cache里记录哪些记录发生过写请求,来路由读主还是读从

    可以利用一个缓存记录必须读主的数据。

     

    如上图,当写请求发生时:

    (1)写主库

    (2)将哪个库,哪个表,哪个主键三个信息拼装一个key设置到cache里,这条记录的超时时间,设置为“主从同步时延”

    画外音:key的格式为“db:table:PK”,假设主从延时为1s,这个key的cache超时时间也为1s。

     

    如上图,当读请求发生时:

    这是要读哪个库,哪个表,哪个主键的数据呢,也将这三个信息拼装一个key,到cache里去查询,如果,

    (1)cache里有这个key,说明1s内刚发生过写请求,数据库主从同步可能还没有完成,此时就应该去主库查询

    (2)cache里没有这个key,说明最近没有发生过写请求,此时就可以去从库查询

    以此,保证读到的一定不是不一致的脏数据。

    6.16 MySQL存储引擎MyISAM与InnoDB区别 

    1) 事务支持
    MyISAM不支持事务,而InnoDB支持。

    2) 存储结构
    MyISAM:每个MyISAM在磁盘上存储成三个文件。第一个文件的名字以表的名字开始,扩展名指出文件类型。.frm文件存储表定义。数据文件的扩展名为.MYD (MYData)。索引文件的扩展名是.MYI (MYIndex)。
    InnoDB:所有的表都保存在同一个数据文件中(也可能是多个文件,或者是独立的表空间文件),InnoDB表的大小只受限于操作系统文件的大小,一般为2GB。

    3) 存储空间
    MyISAM:可被压缩,存储空间较小。支持三种不同的存储格式:静态表(默认,但是注意数据末尾不能有空格,会被去掉)、动态表、压缩表。
    InnoDB:需要更多的内存和存储,它会在主内存中建立其专用的缓冲池用于高速缓冲数据和索引。

    4) 可移植性、备份及恢复
    MyISAM:数据是以文件的形式存储,所以在跨平台的数据转移中会很方便。在备份和恢复时可单独针对某个表进行操作。
    InnoDB:免费的方案可以是拷贝数据文件、备份 binlog,或者用 mysqldump,在数据量达到几十G的时候就相对痛苦了。

    5) 事务支持
    MyISAM:强调的是性能,每次查询具有原子性,其执行数度比InnoDB类型更快,但是不提供事务支持。
    InnoDB:提供事务支持事务,外部键等高级数据库功能。 具有事务(commit)、回滚(rollback)和崩溃修复能力(crash recovery capabilities)的事务安全(transaction-safe (ACID compliant))型表。

    6) AUTO_INCREMENT
    MyISAM:可以和其他字段一起建立联合索引。引擎的自动增长列必须是索引,如果是组合索引,自动增长可以不是第一列,他可以根据前面几列进行排序后递增。
    InnoDB:InnoDB中必须包含只有该字段的索引。引擎的自动增长列必须是索引,如果是组合索引也必须是组合索引的第一列。

    7) 表锁差异
    MyISAM:只支持表级锁,用户在操作myisam表时,select,update,delete,insert语句都会给表自动加锁,如果加锁以后的表满足insert并发的情况下,可以在表的尾部插入新的数据。
    InnoDB:支持事务和行级锁,是innodb的最大特色。行锁大幅度提高了多用户并发操作的新能。但是InnoDB的行锁,只是在WHERE的主键是有效的,非主键的WHERE都会锁全表的。

    MyISAM锁的粒度是表级,而InnoDB支持行级锁定。简单来说就是, InnoDB支持数据行锁定,而MyISAM不支持行锁定,只支持锁定整个表。即MyISAM同一个表上的读锁和写锁是互斥的,MyISAM并发读写时如果等待队列中既有读请求又有写请求,默认写请求的优先级高,即使读请求先到,所以MyISAM不适合于有大量查询和修改并存的情况,那样查询进程会长时间阻塞。因为MyISAM是锁表,所以某项读操作比较耗时会使其他写进程饿死。

    8) 全文索引
    MyISAM:支持(FULLTEXT类型的)全文索引
    InnoDB:不支持(FULLTEXT类型的)全文索引,但是innodb可以使用sphinx插件支持全文索引,并且效果更好。

    9) 表主键
    MyISAM:允许没有任何索引和主键的表存在,索引都是保存行的地址。
    InnoDB:如果没有设定主键或者非空唯一索引,就会自动生成一个6字节的主键(用户不可见),数据是主索引的一部分,附加索引保存的是主索引的值。InnoDB的主键范围更大,最大是MyISAM的2倍。

    10) 表的具体行数
    MyISAM:保存有表的总行数,如果select count(*) from table;会直接取出出该值。
    InnoDB:没有保存表的总行数(只能遍历),如果使用select count(*) from table;就会遍历整个表,消耗相当大,但是在加了wehre条件后,myisam和innodb处理的方式都一样。

    11) CURD操作
    MyISAM:如果执行大量的SELECT,MyISAM是更好的选择。
    InnoDB:如果你的数据执行大量的INSERT或UPDATE,出于性能方面的考虑,应该使用InnoDB表。DELETE 从性能上InnoDB更优,但DELETE FROM table时,InnoDB不会重新建立表,而是一行一行的删除,在innodb上如果要清空保存有大量数据的表,最好使用truncate table这个命令。

    12) 外键
    MyISAM:不支持
    InnoDB:支持

    6.17 索引如何提高查询效率?

    Mysql的索引是一个数据结构,旨在使数据库高效的查找数据。常用的数据结构是B+Tree,每个叶子节点不但存放了索引键的相关信息还增加了指向相邻叶子节点的指针,这样就形成了带有顺序访问指针的B+Tree,做这个优化的目的是提高不同区间访问的性能。

    Mysql设计利用了磁盘预读原理,将一个B+Tree节点大小设为一个页大小,在新建节点时直接申请一个页的空间,这样就能保证一个节点物理上存储在一个页里,加之计算机存储分配都是按页对齐的,这样就实现了每个Node节点只需要一次I/O操作

    红黑树这种结构,h明显要深的多,性能差得多。

    7 redis 

    7.1 redis的数据结构

    (1) Redis数据结构之String

    字符串类型是Redis中最为基础的数据存储类型,它在Redis中是二进制安全的,这便意味着该类型可以接受任何格式的数据,如JPEG图像数据或Json对象描述信息等。在Redis中字符串类型的Value最多可以容纳的数据长度是512M。

    • SET key value      

    设定该Key持有指定的字符串Value,如果该Key已经存在,则覆盖其原有值。返回值:总是返回"OK"

     

    • GET key        

    获取指定Key的Value。如果与该Key关联的Value不是string类型,Redis将返回错误信息,因为GET命令只能用于获取string Value。

    返回值:与该Key相关的Value,如果该Key不存在,则返回nil。

    (2)Redis数据结构之List

      在Redis中,List类型是按照插入顺序排序的字符串链表。和数据结构中的普通链表一样,我们可以在其头部(left)和尾部(right)添加新的元素。在插入时,如果该键并不存在,Redis将为该键创建一个新的链表。与此相反,如果链表中所有的元素均被移除,那么该键也将会被从数据库中删除。List中可以包含的最大元素数量是4294967295。

    (3)Redis数据结构之Hash

    Redis中的Hashes类型可以看成具有String Key和String Value的map容器。所以该类型非常适合于存储值对象的信息。如用户信息:Username、Password和Age等。每一个Hash可以存储4294967295个键值对。

    hset user01 username zhangsan

    (4)Redis数据结构之Set

    在Redis中,我们可以将Set类型看作为没有排序的字符串集合。Set可包含的最大元素数量是4294967295。

          Set类型在功能上还存在着一个非常重要的特性,即在服务器端完成多个Sets之间的聚合计算操作,如unions、intersections和differences。由于这些操作均在服务端完成,因此效率极高,而且也节省了大量的网络IO开销。

     

    (5)Redis数据结构之SortedSet

    Sorted-Sets和Sets类型极为相似,它们都是字符串的集合,都不允许重复的成员出现在一个Set中。它们之间的主要差别是Sorted-Sets中的每一个成员都会有一个分数(score)与之关联,Redis正是通过分数来为集合中的成员进行从小到大的排序。然而需要额外指出的是,尽管Sorted-Sets中的成员必须是唯一的,但是分数(score)却是可以重复

    7.2 redis的持久化机制

    Redis是一个开源的高性能键值对数据库

    是NoSQL技术阵营中的一员

    它通过提供多种键值数据类型来适应不同场景下的存储需求

    借助一些高层级的接口使其可以胜任,如缓存、队列系统的不同角色

    可用作缓存、队列、消息订阅/发布

       1). RDB持久化:

        该机制是指在指定的时间间隔内将内存中的数据集快照写入磁盘。   

    可以通过配置设置自动做快照持久化的方式。我们可以配置redis在n秒内如果超过m个key被修改就自动做快照,下面是默认的快照保存配置

       save 900 1     #900秒内如果超过1个key被修改,则发起快照保存
       save 300 10    #300秒内容如超过10个key被修改,则发起快照保存
       save 60 10000

        2). AOF(append only file)持久化:

    该机制将以日志的形式记录服务器所处理的每一个写操作,在Redis服务器启动之初会读取该文件来重新构建数据库,以保证启动后数据库中的数据是完整的

     

    7.3 mySQL里有2000w数据,redis中只存20w的数据,如何保证redis中的数据都是热点数据

        相关知识:redis 内存数据集大小上升到一定大小的时候,就会施行数据淘汰策略(回收策略)。redis 提供 6种数据淘汰策略

    • volatile-lru:从已设置过期时间的数据集(server.db[i].expires)中挑选最近最少使用的数据淘汰
    • volatile-ttl:从已设置过期时间的数据集(server.db[i].expires)中挑选将要过期的数据淘汰
    • volatile-random:从已设置过期时间的数据集(server.db[i].expires)中任意选择数据淘汰
    • allkeys-lru:从数据集(server.db[i].dict)中挑选最近最少使用的数据淘汰
    • allkeys-random:从数据集(server.db[i].dict)中任意选择数据淘汰
    • no-enviction(驱逐):禁止驱逐数据

      

    7.4 redis常见性能问题和解决方案

       1).Master写内存快照,save命令调度rdbSave函数,会阻塞主线程的工作,当快照比较大时对性能影响是非常大的,会间断性暂停服务,所以Master最好不要写内存快照。

       2).Master AOF持久化,如果不重写AOF文件,这个持久化方式对性能的影响是最小的,但是AOF文件会不断增大,AOF文件过大会影响Master重启的恢复速度。Master最好不要做任何持久化工作,包括内存快照和AOF日志文件,特别是不要启用内存快照做持久化,如果数据比较关键,某个Slave开启AOF备份数据,策略为每秒同步一次。

       3).Master调用BGREWRITEAOF重写AOF文件,AOF在重写的时候会占大量的CPU和内存资源,导致服务load过高,出现短暂服务暂停现象。

       4). Redis主从复制的性能问题,为了主从复制的速度和连接的稳定性,SlaveMaster最好在同一个局域网内

    7.5 redis的并发竞争问题如何解决?

    Redis是单进程单线程的,redis利用队列技术将并发访问变为串行访问,消除了传统数据库串行控制的开销

    7.6 redis事务的命令

    Redis 事务命令

    下标列出了redis事务的相关命令

    1. DISCARD

      取消事务,放弃执行事务块内的所有命令。

    2. EXEC

      执行所有事务块内的命令

    3. MULTI

      标记一个事务块的开始

    4. UNWATCH

      取消WATCH命令对所有key的监视

    5. WATCH key [key ...]

      监视一个(或多个)key,如果在事务执行之前这个(或这些) key 被其他命令所改动,那么事务将被打断。

    https://www.cnblogs.com/Survivalist/p/8119891.html

    7.7 redis事务的特征

    (1)在事务中的所有命令都将会被串行化的顺序执行,事务执行期间,Redis不会再为其它客户端的请求提供任何服务,从而保证了事物中的所有命令被原子的执行。

    (2)在Redis事务中如果有某一条命令执行失败,其后的命令仍然会被继续执行。

    (3)MULTI命令开启一个事务,可以通过执行EXEC/DISCARD命令来提交/回滚该事务内的所有操作

    redis中也是有事务的,不过这个事务没有mysql中的完善,只保证了一致性和隔离性,不满足原子性和持久性。

    7.8 redis集群搭建

    架构细节:

    (1)所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽.

    (2)节点的fail是通过集群中超过半数的节点检测失效时才生效.

    (3)客户端与redis节点直连,不需要中间proxy.客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可

    (4)redis-cluster把所有的物理节点映射到[0-16383]slot,cluster 负责维护node<->slot<->value

    Hash一致性算法

    Redis 集群中内置了 16384 个哈希槽,当需要在 Redis 集群中放置一个 key-value 时,redis 先对 key 使用 crc16 算法算出一个结果,然后把结果对 16384 求余数,这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽,redis 会根据节点数量大致均等的将哈希槽映射到不同的节点

     

    集群搭建

    集群中应该至少有三个节点,每个节点有一备份节点。需要6台服务器。

    搭建伪分布式,需要6个redis实例。

    搭建集群的步骤:

    第一步:创建6个redis实例指定端口从7001到7006

    第二步:修改redis.conf 打开Cluster-enable yes前面的注释。

    第三步:需要一个ruby脚本。在redis源码文件夹下的src目录下。redis-trib.rb

    第四步:把redis-trib.rb文件复制到到redis-cluster目录下。

    第五步:执行ruby脚本之前,需要安装ruby环境。

    1、yum install ruby

    2、yum install rubygems

    3、安装redis-trib.rb运行依赖的ruby的包。

     

    [root@bogon ~]# gem install redis-3.0.0.gem

    第六步:启动所有的redis实例。

    第七步:使用redis-trib.rb创建集群。

    ./redis-trib.rb create --replicas 1 192.168.25.153:7001 
    192.168.25.153:7002 192.168.25.153:7003 
    192.168.25.153:7004 192.168.25.153:7005  192.168.25.153:7006


    使用客户端连接集群: redis01/redis-cli -p 7001 -c

     

     

    8 SpringMVC

    8.1 springMVC的运行流程

    1. 用户向服务器发送请求,请求被SpringMVC 前端控制器DispatcherServlet捕获;

    2. DispatcherServlet对请求URL进行解析,得到请求资源标识符(URI)。然后根据该URI,调用HandlerMapping获得该Handler配置的所有相关的对象(包括Handler对象以及Handler对象对应的拦截器),最后以HandlerExecutionChain对象的形式返回;

    3. DispatcherServlet 根据获得的Handler,选择一个合适的HandlerAdapter;(附注:如果成功获得HandlerAdapter后,此时将开始执行拦截器的preHandler方法)

    4.  提取Request中的模型数据,填充Handler入参,开始执行HandlerController) 在填充Handler的入参过程中,根据你的配置,SpringMVC将帮你做一些额外的工作:

    HttpMessageConveter 将请求消息(如Jsonxml等数据)转换成一个对象,将对象转换为指定的响应信息。

    数据转换:对请求消息进行数据转换。如String转换成IntegerDouble等。

    数据根式化:对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等。

    数据验证: 验证数据的有效性(长度、格式等),验证结果存储到BindingResultError中。

    5.  Handler执行完成后,向DispatcherServlet 返回一个ModelAndView对象;

    6.  根据返回的ModelAndView,选择一个适合的ViewResolver(必须是已经注册到SpringMVC容器中的ViewResolver)返回给DispatcherServlet

    7. ViewResolver 结合ModelView,来渲染视图;

    8. 将渲染结果返回给客户端。

    8.2 mvc模式

    • (控制器Controller)- 负责转发请求,对请求进行处理。
    • (视图View) - 界面设计人员进行图形界面设计。
    • (模型Model) - 程序员编写程序应有的功能(实现算法等等)、数据库专家进行数据管理和数据库设计(可以实现具体的功能)。

     

    9 Spring

    9.1 什么是IOC,以及其原理?

    IOC控制反转,不是一种技术,而是一种思想,对象的生命周期不是由程序本身来决定,而是由容器来控制,所以称之为控制反转。

    ioc底层原理使用技术

    (1)xml配置文件

    (2)dom4j解决xml

    (3)工厂设计模式

    (4)反射

    步骤:

     

    第一步:创建类的.xml文件

    <bean id="userService" class="....."/>
    
    第二步:创建一个工厂类:使用dom4j解析配置文件+反射
    
    public class UserFactory{
    
        public static UserService getUserService(){
    
            //使用dom4j解析配置文件
    
            //根据id值获得class的属性值
    
            String classValue="class属性值";
    
            //使用反射来创建class对象
    
            Class class=Class.forName(classValue);
        
            UserService service=class.newInstatnce();
    
            return service;
        }
    } 
    

     

    9.2 IOC和DI的区别? 

     依赖注入和控制反转是对同一件事情的不同描述,从某个方面讲,就是它们描述的角度不同。依赖注入是从应用程序的角度在描述,可以把依赖注入描述完整点:应用程序依赖容器创建并注入它所需要的外部资源;

    而控制反转是从容器的角度在描述,描述完整点:容器控制应用程序,由容器反向的向应用程序注入应用程序所需要的外部资源。

    9.3 什么是aop

    aop是面向切面编程,aop是对oop(面向对象编程)的补充和完善,OOP引入封装、继承和多态性等概念建立一种对象的层次结构。当我们需要为不具备上下级关系的对象添加一系列公共的行为时,oop显得很无力。如日志,日志代码所在所有对象之间毫无关系。使用AOP技术,可以将一些系统性相关的编程工作,独立提取出来,独立实现,然后通过切面切入进系统,提高代码的复用性。

    1) Aspect :切面,切入系统的一个切面。比如事务管理是一个切面,权限管理也是一个切面;

    2) Join point :连接点,也就是可以进行横向切入的位置;

    3) Advice :通知,切面在某个连接点执行的操作(分为: Before advice , After returning advice , After throwing advice , After (finally) advice , Around advice );

    4) Pointcut :切点,符合切点表达式的连接点,也就是真正被切入的地方;

    Spring AOP的五个通知类型

    通知类型 作用
    before 前置通知
    around 环绕通知---需要放行操作
    after 后置通知----不论拦截的方法是否有异常
    after-returning 后置成功通知---------拦截的方法没油抛出异常就会执行--拦截到的方法必须正确返回;
    after-throwing 后置异常通知----拦截的方法如果抛出异常则会执行----有异常执行它没油异常不执行

     

    aop简单使用如下:

    定义一个注解

    @Target(value = { ElementType.METHOD })
    @Retention(value = RetentionPolicy.RUNTIME)
    public @interface AnalysisActuator {
    	TimeUnit timeType() default TimeUnit.SECONDS;
    
    }

    定义切面

    @Aspect
    @Component
    public class AnalysisAspect {
    	private long stTime;
        //定义切点
    	@Pointcut("@annotation(com.whty.aop.annotion.AnalysisActuator)")
    	public void declareJoinPointExpression() {
    	}
    	@Before(value = "declareJoinPointExpression()")
    	public void beforemethod() {
    		long currentTimeMillis = System.currentTimeMillis();
    		stTime=currentTimeMillis;
    		System.out.println("开始执行时间"+currentTimeMillis);
    	}
    	@After(value = "declareJoinPointExpression()")
    	public void aftermethod(JoinPoint pjp) {
    		//获取方法
    		MethodSignature signature = (MethodSignature) pjp.getSignature();
    		Method method = signature.getMethod();
    		method.getAnnotation(AnalysisActuator.class);
    		AnalysisActuator analysisActuator=(AnalysisActuator)method.getAnnotation(AnalysisActuator.class);
    		TimeUnit timeType = analysisActuator.timeType();
    		long currentTimeMillis = System.currentTimeMillis();
    		long t=currentTimeMillis-stTime;
    		System.out.println("结束执行的时间为"+currentTimeMillis);
    		System.out.println(timeType.convert(t, TimeUnit.MILLISECONDS));
    	}
    }

     测试

    @RestController
    public class Demo {
    	@RequestMapping(value="/demo")
    	@AnalysisActuator(timeType=TimeUnit.MILLISECONDS)
    	public Object demo() {
    		for (int i = 0; i < 10000000; i++) {
    			
    		}
    		return "hello";
    	}
    
    }

    结果:

    切点语法

    AspectJ指示器 描述
    execution() 用于匹配是连接点的执行方法
    @annotation 限定匹配带有指定注解的连接点
    bean() Bean的使用相对来说是比较简单的 bean()括号里面放的是你在Spring中注册的类的标识
    within() 限制连接点匹配指定的类型


     

    9.4 SpringBean实例化方式

    (1)使用类的无参构造函数

    <bean id="user" class="com.whty.model.user"></bean>

    (2)使用静态工厂创建

    public class BeanFactory2{
        public static Bean2 getBean2(){
            return new Bean2();
        }
    }
    <bean id="bean2" class="com.whty.model.Bean2Factory" factory-method="getBean2"></bean>

    (3) 使用实例工厂创建

    public class BeanFactory3{
        public static Bean3 getBean3(){
            return new Bean3();
        }
    }
    <bean id="bean3Factory" class="com.whty.model.Bean3Factory" ></bean>
    <bean id="bean3" class="com.whty.model.Bean3Factory" factory-method="getBean3"></bean>

    9.5 springBean的生命周期

     

    1、spring对bean进行实例化

    2、spring将值和bean的引用注入到bean对应的属性中

    3、如果bean实现了BeanNameAware接口,spring将bean的id传递给setBeanName()方法

    4、如果bean实现了BeanFactoryAware接口,Spring将调用setBeanFactory()方法,将BeanFactory容器实例传入 

    5、如果bean实现了ApplicationContextAware接口,Spring将调用setApplicationContext()方法,将bean所在的应用上下文的
    引用传入进来

    6、如果bean实现了BeanPostProcessor接口,Spring将调用它们的postProcessBeforeInitialization()方法;

    7、如果bean实现了InitializingBean接口,Spring将调用它们的afterPropertiesSet()方法。类似地,如果bean使用init-method声明了初始化方法,该方法也会被调用

    在spring初始化bean的时候,如果该bean是实现了InitializingBean接口,并且同时在配置文件中指定了init-method,系统则是先调用afterPropertiesSet方法,然后在调用init-method中指定的方法

    8、如果bean实现了BeanPostProcessor接口,Spring将调用它们的post-ProcessAfterInitialization()方法;

    9、此时,bean已经准备就绪,可以被应用程序使用了,它们将一直驻留在应用上下文中,直到该应用上下文被销毁;

    10、如果bean实现了DisposableBean接口,Spring将调用它的destroy()接口方法。同样,如果bean使用destroy-method声明
    了销毁方法,该方法也会被调用
     

    9.6 Spring的事物管理

    (1)编程式事务管理:将事务管理代码嵌入到业务方法中来控制事务的提交和回滚,在编程式事务中,必须在每个业务操作中包含额外的事务管理代码

    编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理,spring推荐使用TransactionTemplate

    (2)声明式事务管理:大多数情况下比编程式事务管理更好用。它将事务管理代码从业务方法中分离出来,以声明的方式来实现事务管理。事务管理作为一种横切关注点,可以通过AOP方法模块化。Spring通过Spring AOP框架支持声明式事务管理。

    声明式事务管理

    1.基于xml配置文件实现

    2.基于注解实现

    9.7 Spring事物的隔离级别和传播行为

    Spring事务的隔离级别:

    * read uncommitted  :未提交读.脏读、不可重复读、虚读都是有可能发生.

    * read committed    :已提交读.避免脏读.但是不可重复读、虚读是有可能发生.

    * repeatable read   :可重复读.避免脏读、不可重复读.但是虚读是有可能发生.

    * serializable      :串行化的.避免脏读、不可重复读、虚读的发生.

    Spring事务的传播行为

     

     

    9.8 BeanFactory和ApplicationContext有什么区别?

    BeanFactory

    是Spring里面最低层的接口,提供了最简单的容器的功能,只提供了实例化对象和拿对象的功能;

    ApplicationContext

    应用上下文,继承BeanFactory接口,它是Spring的一各更高级的容器,提供了更多的有用的功能;

    1) 国际化(MessageSource)

    2) 访问资源,如URL和文件(ResourceLoader)

    3) 载入多个(有继承关系)上下文 ,使得每一个上下文都专注于一个特定的层次,比如应用的web层 

    4) 消息发送、响应机制(ApplicationEventPublisher)

    5) AOP(拦截器

    两者装载bean的区别

    BeanFactory

    BeanFactory在启动的时候不会去实例化Bean,中有从容器中拿Bean的时候才会去实例化;

    ApplicationContext

    ApplicationContext在启动的时候就把所有的Bean全部实例化了。它还可以为Bean配置lazy-init=true来让Bean延迟实例化; 

    9.9 Spring Bean的作用域之间有什么区别?

    Spring容器中的bean可以分为5个范围。所有范围的名称都是自说明的,但是为了避免混淆,还是让我们来解释一下:

    (1)singleton:这种bean范围是默认的,这种范围确保不管接受到多少个请求,每个容器中只有一个bean的实例,单例的模式由bean factory自身来维护。

    (2)prototype:原形范围与单例范围相反,为每一个bean请求提供一个实例。

    (3)request:在请求bean范围内会每一个来自客户端的网络请求创建一个实例,在请求完成以后,bean会失效并被垃圾回收器回收。

    (4)Session:与请求范围类似,确保每个session中有一个bean的实例,在session过期后,bean会随之失效。

    (5)global-session:global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时,它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话,那么这全局变量需要存储在global-session中。

    9.10 JDK动态代理和Gglib动态代理的区别

    1.JDK动态代理是实现了被代理对象的接口,Cglib是继承了被代理对象。

    2.JDK和Cglib都是在运行期生成字节码,JDK是直接写Class字节码,Cglib使用ASM框架写Class字节码,Cglib代理实现更复杂,生成代理类比JDK效率低。

    3.JDK调用代理方法,是通过反射机制调用,Cglib是通过FastClass机制直接调用方法,Cglib执行效率更高。

    9.11 BeanFactory与FactoryBean的区别

    BeanFactory是IOC容器的核心接口,它的职责包括:实例化、定位、配置应用程序中的对象及建立这些对象间的依赖

    FactoryBean它是实现了FactoryBean<T>接口的Bean

     9.12 spring在bean的创建过程中解决循环依赖

    Spring先是用构造实例化Bean对象, 创建成功后将对象暴露出来,此时的对象还没有完成属性注入,属于早期对象,此时Spring会将这个实例化结束的对象放到一个Map中,提供set方法设置属性。 

    9.13 @Transactional使用

    @Transactional 注解只能应用到 public 可见度的方法上

    默认情况下,spring会对unchecked异常进行事务回滚;如果是checked异常则不回滚。 

    RuntimeException(比如空指针,1/0)的异常称为unchecked异常

    9.14 获取spring容器的常用的4种方式

    (1)通过Spring提供的ContextLoader

    import org.springframework.web.context.ContextLoader;
    import org.springframework.web.context.WebApplicationContext;
    public class SpringContextUtil {
    	WebApplicationContext wac = ContextLoader.getCurrentWebApplicationContext();
    }

    Spring容器初始化时,不能通过下面方法获取Spring 容器 (获取为null)

    (2)继承自抽象类ApplicationObjectSupport

    说明:抽象类ApplicationObjectSupport提供getApplicationContext()方法。能够方便的获取ApplicationContext。

    Spring初始化时。会通过该抽象类的setApplicationContext(ApplicationContext context)方法将ApplicationContext 对象注入。

    (3)继承自抽象类WebApplicationObjectSupport

    (4) 实现接口ApplicationContextAware

    实现该接口的setApplicationContext(ApplicationContext context)方法,并保存ApplicationContext 对象。Spring初始化时,会通过该方法将ApplicationContext对象注入

    public class SpringContextUtil implements ApplicationContextAware {
    
    	private static ApplicationContext applicationContext;
    
    	@Override
    	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    		SpringContextUtil.applicationContext = applicationContext;
    	}
    
    	public static <T> T getBean(Class<T> clazz) {
    		return (T) applicationContext.getBean(clazz);
    	}
    
    }

    9.15 Spring支持三种依赖注入方式

    分别是属性(Setter方法)注入,构造注入和接口注入。 

    10 Mybatis

    10.1 mybatis的原理 

    10.2 #{}和${}的区别是什么?

    #{}是预编译处理,${}是字符串替换。

    Mybatis在处理#{}时,会将sql中的#{}替换为?号,调用PreparedStatement的set方法来赋值;

    Mybatis在处理${}时,就是把${}替换成变量的值。

    使用#{}可以有效的防止SQL注入,提高系统安全性。

    10.3 通常一个Xml映射文件,都会写一个Mapper接口与之对应,请问,这个Mapper接口的工作原理是什么?Mapper接口里的方法,参数不同时,方法能重载吗?

    Mapper接口的全类名,就是映射文件中的namespace的值,接口的方法名,就是映射文件中MappedStatement的id值,接口方法内的参数,就是传递给sql的参数。Mapper接口是没有实现类的,当调用接口方法时,接口全类名+方法名拼接字符串作为key值,可唯一定位一个MappedStatement.

    java.lang.IllegalArgumentException: Mapped Statements collection already 
    contains value for com.whty.hxx.sta.web.mapper.CityMapper.getCityByExamId

    Mapper接口的工作原理是JDK动态代理,Mybatis运行时会使用JDK动态代理为Mapper接口生成代理proxy对象,代理对象proxy会拦截接口方法,转而执行MappedStatement所代表的sql,然后将sql执行结果返回。

    10.4 Mybatis分页插件的原理是什么?

    使用Mybatis提供的插件接口,实现自定义插件,在插件的拦截方法内拦截待执行的sql,然后重写sql,根据dialect方言,添加对应的物理分页语句和物理分页参数。

    10.5 简述Mybatis的插件运行原理,以及如何编写一个插件

    Mybatis仅可以编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor这4种接口的插件,Mybatis使用JDK的动态代理,为需要拦截的接口生成代理对象以实现接口方法拦截功能,每当执行这4种接口对象的方法时,就会进入拦截方法,具体就是InvocationHandler的invoke()方法,当然,只会拦截那些你指定需要拦截的方法。

    实现Mybatis的Interceptor接口并复写intercept()方法,然后在给插件编写注解,指定要拦截哪一个接口的哪些方法即可,记住,别忘了在配置文件中配置你编写的插件。

    • 编写Interceptor的实现类;
    • 使用@Intercepts注解完成插件签名;
    • 将写好的插件注册到全局配置文件中;

     

    10.6 mybatis是否支持延迟加载?如果支持,它的实现原理是什么?

    Mybatis仅支持association关联对象和collection关联集合对象的延迟加载,association指的就是一对一,collection指的就是一对多查询。在Mybatis配置文件中,可以配置是否启用延迟加载lazyLoadingEnabled=true|false。

    它的原理是,使用CGLIB创建目标对象的代理对象,当调用目标方法时,进入拦截器方法,比如调用a.getB().getName(),拦截器invoke()方法发现a.getB()是null值,那么就会单独发送事先保存好的查询关联B对象的sql,把B查询上来,然后调用a.setB(b),于是a的对象b属性就有值了,接着完成a.getB().getName()方法的调用。这就是延迟加载的基本原理。

    10.7 Mybatis都有哪些Executor执行器?它们之间的区别是什么?

     

    答:Mybatis有三种基本的Executor执行器,SimpleExecutor、ReuseExecutor、BatchExecutor。

     

    SimpleExecutor:每执行一次update或select,就开启一个Statement对象,用完立刻关闭Statement对象。

    ReuseExecutor:执行update或select,以sql作为key查找Statement对象,存在就使用,不存在就创建,用完后,不关闭Statement对象,而是放置于Map<String, Statement>内,供下一次使用。简言之,就是重复使用Statement对象。

    BatchExecutor:执行update(没有select,JDBC批处理不支持select),将所有sql都添加到批处理中(addBatch()),等待统一执行(executeBatch()),它缓存了多个Statement对象,每个Statement对象都是addBatch()完毕后,等待逐一执行executeBatch()批处理。与JDBC批处理相同。

    作用范围:Executor的这些特点,都严格限制在SqlSession生命周期范围内。

    10.8 mybatis缓存

    一级缓存 是 SqlSession 级别的缓存,是基于 HashMap 的本地缓存。每个线程都有自己的SqlSession 实例,SqlSession 实例是不能被共享,也不是线程安全的,

    当同一个 SqlSession 执行两次相同的 sql 语句时,第一次执行完后会将数据库中查询的数据写到缓存,第二次查询时直接从缓存获取不用去数据库查询。当 SqlSession 执行 insert、update、delete 操做并提交到数据库时,会清空缓存,保证缓存中的信息是最新的。MyBatis 默认开启一级缓存。

    二级缓存 是 mapper 级别的缓存,同样是基于 HashMap 进行存储,多个 SqlSession 可以共用二级缓存,其作用域是 mapper 的同一个 namespace。不同的 SqlSession 两次执行相同的 namespace 下的 sql 语句,会执行相同的 sql,第二次查询只会查询第一次查询时读取数据库后写到缓存的数据,不会再去数据库查询。

    11 springBoot

    11.1 什么是 Spring Boot?

    Spring Boot 是 Spring 开源组织下的子项目,是 Spring 组件一站式解决方案,主要是简化了使用 Spring 的难度,简省了繁重的配置,提供了各种启动器,开发者能快速上手。

    11.2 Spring Boot 的核心配置文件有哪几个?它们的区别是什么?

    Spring Boot 的核心配置文件是 application 和 bootstrap 配置文件。

    application 配置文件这个容易理解,主要用于 Spring Boot 项目的自动化配置。

    bootstrap 配置文件有以下几个应用场景。

    • 使用 Spring Cloud Config 配置中心时,这时需要在 bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息;
    • 一些固定的不能被覆盖的属性;
    • 一些加密/解密的场景;

    11.3 Spring Boot 的配置文件有哪几种格式?它们有什么区别?

    .properties 和 .yml,它们的区别主要是书写格式不同。

    1).properties

    app.user.name = javastack
    

    2).yml

    app:
      user:
        name: javastack
    

    另外,.yml 格式不支持 @PropertySource 注解导入配置。

    11.4 Spring Boot 的核心注解是哪个?它主要由哪几个注解组成的?

    启动类上面的注解是@SpringBootApplication,它也是 Spring Boot 的核心注解,主要组合包含了以下 3 个注解:

    @SpringBootConfiguration:组合了 @Configuration 注解,实现配置文件的功能。

    @EnableAutoConfiguration:打开自动配置的功能,也可以关闭某个自动配置的选项,如关闭数据源自动配置功能: @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })。

    @ComponentScan:Spring组件扫描。

    11.5 开启 Spring Boot 特性有哪几种方式?

    1)继承spring-boot-starter-parent项目

    2)导入spring-boot-dependencies项目依赖

    11.6 Spring Boot 需要独立的容器运行吗?

    可以不需要,内置了 Tomcat/ Jetty 等容器。

    11.7 运行 Spring Boot 有哪几种方式?

    1)打包用命令或者放到容器中运行

    2)用 Maven/ Gradle 插件运行

    3)直接执行 main 方法运行

    11.8 Spring Boot 自动配置原理是什么?

    注解 @EnableAutoConfiguration, @Configuration, @ConditionalOnClass 就是自动配置的核心,首先它得是一个配置文件,其次根据类路径下是否有这个类去自动配置

    11.9 如何在 Spring Boot 启动的时候运行一些特定的代码?

    可以实现接口 ApplicationRunner 或者 CommandLineRunner,这两个接口实现方式一样,它们都只提供了一个 run 方法

    11.10 Spring Boot 有哪几种读取配置的方式?

    Spring Boot 可以通过 @PropertySource,@Value,@Environment, @ConfigurationProperties 来绑定变量

    @PropertySource(value={"classpath:/user.properties"})
    public class Configs {
        @Value("${u.name}")
        private String userName;
    
        @Value("${u.age}")
        private Integer age;
    }
    mail.host=localhost
    mail.port=25
    mail.smtp.auth=false
    mail.smtp.starttls-enable=false
    mail.from=me@localhost
    mail.username=duan
    mail.password=duan123456

     

    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    @ConfigurationProperties(locations = "classpath:mail.properties", ignoreUnknownFields = false, prefix = "mail")
    public class MailProperties {
        private String host;
        private int port;
        private String from;
        private String username;
        private String password;
        private Smtp smtp;
    
    }

    11.11 Spring Boot 支持哪些日志框架?推荐和默认的日志框架是哪个?

    Spring Boot 支持 Java Util Logging, Log4j2, Lockback 作为日志框架,如果你使用 Starters 启动器,Spring Boot 将使用 Logback 作为默认日志框架

    11.12 SpringBoot 实现热部署有哪几种方式?

    主要有两种方式:

    • Spring Loaded
    • Spring-boot-devtools

    11.13 你如何理解 Spring Boot 配置加载顺序?

    在 Spring Boot 里面,可以使用以下几种方式来加载配置。

    1)properties文件;

    2)YAML文件;

    3)系统环境变量;

    4)命令行参数;

     

    11.14 Spring Boot 2.X 有什么新特性?与 1.X 有什么区别?

    • 配置变更
    • JDK 版本升级
    • 第三方类库升级
    • 响应式 Spring 编程支持
    • HTTP/2 支持
    • 配置属性绑定
    • 更多改进与加强...

    12 微服务

    12.1 SpringCloud和Dubbo有哪些区别?
              

      Dubbo      SpringCloud
    服务注册中心 Zookeeper     Eureka
    服务调用方式 RPC      REST API
    服务监控  Dubbo-monitor Spring BootAdmin
    断路器  不完善  Spring Cloud Netflix Hystrix
    服务网关 Spring Cloud Netflix Zuul
    分布式配置 Spring Cloud Config
    服务跟踪   无 Spring Cloud Sleuth
    消息总线 无  Spring Cloud Bus
    数据流   无  Spring Cloud Stream
    批量任务  无  Spring Cloud Task

      最大区别:SpringCloud抛弃了Dubbo的RPC通信,采用的是基于HTTP的REST方式。
        总体来说,两者各有优势。虽说后者服务调用的功能,但也避免了上面提到的原生RPC带来的问题。而且REST相比RPC更为灵活,服务提供方和调用方的依赖只依靠一纸契约,不存在代码级别的依赖,这在强调快速演化的微服务环境下,显得更加合适。
        品牌机与组装机的区别:很明显SpringCloud比dubbo的功能更强大,覆盖面更广,而且能够与SpringFramework、SpringBoot、SpringData、SpringBatch等其他Spring项目完美融合,这些对于微服务至关重要。使用Dubbo构建的微服务架构就像组装电脑、各环节我们选择自由度高,但是最总可能会因为内存质量而影响整体,但对于高手这也就不是问题。而SpringCloud就像品牌机,在Spring Source的整合下,做了大量的兼容性测试,保证了机器拥有更高的稳定性。
        在面临微服务基础框架选型时Dubbo与SpringCloud只能二选一。
     

     

    2. SpringBoot和SpringCloud,请你谈谈对他们的理解?


    ①   SpringBoot专注于快速方便的开发单个个体微服务。
    ②   SpringCloud是关注全局的微服务协调、整理、治理的框架,它将SpringBoot开发的单体整合并管理起来。
    ③   SpringBoot可以离开SpringCloud独立使用开发项目,但是SpringCloud离不开SpringBoot,属于依赖关系。   

    3. 什么是服务熔断?什么是服务降级?


            熔断机制是应对雪崩效应的一种微服务链路保护机制。当链路的某个微服务不可用或者响应时间太长时,会进行服务降级,进而熔断该节点微服务的调用,快速返回“错误”的响应信息。当检测到该节点微服务调用响应正常后恢复调用链路。在SpringCloud框架里熔断机制通过Hystrix实现,Hystrix会监控微服务间调用的状况,当失败的调用到一定阈值,缺省是5秒内调用20次,如果失败,就会启动熔断机制。熔断机制的注解是@HystrixCommand
            服务降级是在客户端,一般是从整体负荷考虑。就是当某个服务熔断之后,服务器将不再被调用,此时客户端可以自己准备一个本地的fallback回调,返回一个缺省值。这样做,虽然水平下降,但好歹可用,比直接挂掉强。


    4. Eureka和zookeeper都可以提供服务注册与发现的功能,请说说两个的区别?

    分布式领域中存在CAP理论,任何分布式系统只可同时满足两点,无法三者兼顾。

      ①C:Consistency,一致性,数据一致更新,所有数据变动都是同步的。

      ②A:Availability,可用性,系统具有好的响应性能。

      ③P:Partition tolerance,分区容错性

        Zookeeper保证了CP(C:一致性,P:分区容错性),Eureka保证了AP(A:高可用)


            (1)当向注册中心查询服务列表时,我们可以容忍注册中心返回的是几分钟以前的信息,但不能容忍直接down掉不可用。也就是说,服务注册功能对高可用性要求比较高,但Zookeeper会出现这样一种情况,当master节点因为网络故障与其他节点失去联系时,剩余节点会重新选leader。问题在于,选取leader时间过长,30 ~ 120s,且选取期间zk集群都不可用,这样就会导致选取期间注册服务瘫痪。在云部署的环境下,因网络问题使得zk集群失去master节点是较大概率会发生的事,虽然服务能够恢复,但是漫长的选取时间导致的注册长期不可用是不能容忍的。
              (2)、Eureka保证了可用性,Eureka各个节点是平等的,几个节点挂掉不会影响正常节点的工作,剩余的节点仍然可以提供注册和查询服务。而Eureka的客户端向某个Eureka注册或发现是发生连接失败,则会自动切换到其他节点,只要有一台Eureka还在,就能保证注册服务可用,只是查到的信息可能不是最新的。除此之外,Eureka还有自我保护机制,如果在15分钟内超过85%的节点没有正常的心跳,那么Eureka就认为客户端与注册中心发生了网络故障,此时会出现以下几种情况:
               ①、Eureka不在从注册列表中移除因为长时间没有收到心跳而应该过期的服务。
               ②、Eureka仍然能够接受新服务的注册和查询请求,但是不会被同步到其他节点上(即保证当前节点仍然可用)
               ③、当网络稳定时,当前实例新的注册信息会被同步到其他节点。

    因此,Eureka可以很好的应对因网络故障导致部分节点失去联系的情况,而不会像Zookeeper那样使整个微服务瘫痪。


     

    展开全文
  • 20个高级java开发面试题(带答案)

    千次阅读 2017-10-05 20:28:02
    这是高级Java面试系列题中的第一部分。这一部分论述了可变参数,断言,垃圾回收,初始化器,令牌化,日期,日历等等Java核心问题。大家可以先自己试试,然后再参考答案。 1. 什么是可变参数? 可变参数允许...
  • 最近收集了一些在大厂工作月薪20k的中高级java开发工程师面试题,给大家分享一下
  • 接下来与大家一起分享Java高级工程师面试的一些经验之谈。 Memcache与Redis的区别 memcache把数据存在内存之,断电后会挂掉;Redis部分数据持久化在硬盘上,断电不会丢失。 memcache存的是key-val...
  • 史上最全面Java面试汇总(面试题+答案)

    万次阅读 多人点赞 2018-07-06 14:09:25
    JAVA面试精选【Java基础第一部分】 JAVA面试精选【Java基础第二部分】 JAVA面试精选【Java基础第三部分】 JAVA面试精选【Java算法与编程一】 JAVA面试精选【Java算法与编程二】 ...Java中高级面试题 数据...
  • java高级开发面试题总结

    千次阅读 2017-07-06 16:40:55
    面试题总结——JAVA高级工程师 近期考虑换工作的问题,于是投简历面试,面试5家公司的高级Java工程师,有4家给了我offer,想着总结一下面试经验,方便最近正在寻求机会的你们 一、无笔试题 不知道是不是...
  • 高级Java开发工程师面试题汇总

    千次阅读 2016-12-08 13:47:54
    时,系统将调用"语文"的 hashCode() 方法得到其 hashCode 值——每个 Java 对象都有 hashCode() 方法,都可通过该方法获得它的 hashCode 值。得到这个对象的 hashCode 值之后,系统会根据该 hashCode 值来决定该...
  • java高级面试题2019

    千次阅读 多人点赞 2019-05-16 09:36:25
    1、HashMap实现原理 ...6、Java集合面试题及答案总结 7、Java代码优化(上) 8、Java代码优化(下) 9、史上最有用的java面试题整理 10、线程池工作原理,任务拒接策略有哪几种 11、虚拟机JVM 组...
  • 100道中高级Java面试题整理

    万次阅读 多人点赞 2019-04-16 17:15:50
    JavaEE面试题整理一、Java基础篇二、JVM篇三、Tomcat篇四、MyBatis篇五、Spring篇六、SpringMVC面试题整理七、Redis篇八、Mongodb篇九、MQ篇十、Shiro篇十一、搜索引擎篇十二、Nginx篇十三、SpringBoot篇十四、Dubbo...
  • 2020Java高级开发工程师面试题汇总

    千次阅读 2020-11-18 16:51:45
    工作三年多,面试目标为高级开发工程师 前言 9.5–11.13,经过了长达70天的面试,终于有了结果。期间崩溃过无数次,很多次面试都被虐到怀疑人生,也有三面被刷掉无奈,一次次整装重新出发,一次次从头再来。今天有...
  • 各大公司Java后端开发面试题总结

    万次阅读 多人点赞 2017-03-01 11:31:11
    ThreadLocal(线程变量副本)Synchronized实现内存共享,ThreadLocal为每个线程维护一个本地...ThreadLocal类维护一个Map,用于存储每一个线程的变量副本,Map元素的键为线程对象,而值为对应线程的变量副本。Thre
  • 总结java高级面试题

    万次阅读 多人点赞 2019-05-10 16:25:39
    在JVM启动时或者在类运行时将需要的class加载到JVM。 类加载时间与过程: 类从被加载到虚拟机内存开始,在到卸载出内存为止,正式生命周期包括了:加载,验证,准备,解析,初始化,使用和卸载7个阶段。其中...
  • 2020年首发70道阿里巴巴高级Java开发面试题(带详细答案) 面试题 1、java事件机制包括哪三个部分?分别介绍。 2、为什么要使用线程池? 3、线程池有什么作用? 4、说说几种常见的线程池及使用场景。 5、线程池都有...
  • 面试高级Java面试题

    2017-06-08 21:24:28
    面试高级Java面试题 使用递归的方式写List集合的求和在纸上写的 比较蒙圈 没答上来 回来一想就写出来了 还是当时比较紧张 public static int sum(List<Integer> list, int sum, int index) { if (index >= list....
  • java中高级面试题

    千次阅读 2018-06-18 17:37:14
    一、Java基础 ...2. Java中的异常有哪几类?分别怎么使用? 检出异常,非检出异常。检出异常需要try...catch才能编译通过。非检出异常不用try...catch也能编译通过。 RuntimeException是非检出异...
  • Java中高级面试题(6)

    千次阅读 2018-04-04 16:03:20
     Javaweb练手项目源码下载常用设计模式完整系列篇100套IT类简历模板下载Java常见面试题汇总篇对于有一定经验的开发者,在面试过程多多少少都会被问及jvm相关知识,但是往往在实际开发中涉及较少,这里整理一些...
  • 高级java工程师面试题

    千次阅读 2017-01-23 17:59:55
    1、面试java基础 (1)java 为什么分为基础对象,引用对象,两者的区别 (2)多线程,多线程安全怎么做。用过current 包里面的内容吗  多线程之间的通信如何处理。 (3)List,set,Map 的不同,各自的优点。 ...
  • java高级面试题

    千次阅读 2019-03-27 22:44:57
    2.JAVA的AQS是否了解,它是干嘛的? 3.除了synchronized关键字之外,你是怎么来保障线程安全的? 4.Tomcat本身的参数你一般会怎么调整? 5.你有没有用过Spring的AOP? 是用来干嘛的? 大概会怎么使用? 6.如果一个接口...
  • Java微信公众号开发面试题

    千次阅读 2017-08-23 09:16:00
    Java微信公众号开发面试题
  • 2018最新JAVA基础面试题高级面试题

    千次阅读 2018-07-02 14:24:45
    Java面试高级篇—Java NIO:浅析I/O模型面试题15期Java面试高级篇—详谈Java四种线程池及new Thread的弊端面试题14期Java面试高级篇—说说TCP,UDP和socket,Http之间联系和区别面试题12期Java面试高级篇—Session和...
  • 2018年JAVA基础面试题高级面试题总结

    万次阅读 多人点赞 2018-03-11 19:28:00
    Java面试前需要做足各方面的准备工作,肯定都会浏览大量的面试题,本人也不例外,通过浏览面试题和以往的面试经历,总结了从初级到中级以及高级面试题,供大家学习讨论。 Java面试高级篇—Java NIO:浅析I/O模型...
  • 2019年java中高级java面试题(一)Redis

    千次阅读 2019-06-01 16:08:02
    字符串类型是Redis最为基础的数据存储类型,它在Redis是二进制安全的,这便意味着该类型可以接受任何格式的数据,如JPEG图像数据或Json对象描述信息等。在Redis字符串类型的Value最多可以容纳的数据长度是512M...
  • Java中高级面试题部分答案解析

    万次阅读 多人点赞 2018-03-14 20:30:30
    Java中高级面试题部分答案解析List和Set比较,各自的子类比较对比一:Arraylist与LinkedList的比较1、ArrayList是实现了基于动态数组的数据结构,因为地址连续,一旦数据存储好了,查询操作效率会比较高(在内存里是...
  • 高级测试开发面试题

    千次阅读 2020-01-06 10:52:27
    高级测试开发面试题: 一、java基础 1)java中有哪些容器,区别和特点是什么 https://blog.csdn.net/qq_38774221/article/details/98974417 2)HashMap和HashTable的区别 3)Java中抽象类和接口的区别 抽象类:1、...
  • 并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到spring容器,并且实例名就是方法名。 @EnableAutoConfiguration 里通过@Import导入了 EnableAutoConfigurationImportSelector 会查询 META...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,546
精华内容 17,818
关键字:

中高级java开发面试题

java 订阅