面试题集锦,各大公司Java后端开发面试题总括

ThreadLocal(线程变量副本)
Synchronized达成内存共享,ThreadLocal为各类线程维护多少个本地变量。
使用空间换时间,它用来线程间的数目隔离,为每贰个运用该变量的线程提供1个副本,逐个线程都可以单独地转移本身的副本,而不会和任何线程的副本冲突。
ThreadLocal类中珍视三个Map,用于存储每3个线程的变量副本,Map中成分的键为线程对象,而值为对应线程的变量副本。
ThreadLocal在Spring中表述着伟大的机能,在保管Request效率域中的Bean、事务管理、职分调度、AOP等模块都冒出了它的人影。
Spring中多方面Bean都能够讲明成Singleton效能域,选择ThreadLocal进行包装,由此有气象的Bean就可知以singleton的办法在十六线程中符合规律工作了。
友情链接:深入钻研java.lang.ThreadLocal类

ThreadLocal(线程变量副本)


Synchronized落成内存共享,ThreadLocal为各个线程维护3个当地变量。

Java内存模型:
Java虚拟机规范少将Java运转时数据分为五种。
1.程序计数器:是3个数据结构,用于保存当前健康实施的顺序的内存地址。Java虚拟机的十六线程就是经过线程轮流切换并分配处理器时间来兑现的,为了线程切换后能还原到正确的职位,每条线程都亟需1个单身的次第计数器,互不影响,该区域为“线程私有”。
2.Java虚构机栈:线程私有的,与线程生命周期相同,用于存储局地变量表,操作栈,方法再次回到值。局地变量表放着主导数据类型,还有对象的引用。
3.本地点法栈:跟虚拟机栈很像,不过它是为虚拟机使用到的Native方法服务。
4.Java堆:全数线程共享的一块内存区域,对象实例大致都在那分配内存。
5.方法区:各种线程共享的区域,储存虚拟机加载的类音信,常量,静态变量,编译后的代码。
6.运维时常量池:代表运维时每一个class文件中的常量表。包罗二种常量:编译时的数字常量、方法可能域的引用。
友情链接: Java中JVM虚拟机详解

利用空间换时间,它用来线程间的数据隔离,为每二个行使该变量的线程提供壹个副本,各种线程都得以独立地改成本人的副本,而不会和别的线程的副本冲突。


ThreadLocal类中保证贰个Map,用于存储每3个线程的变量副本,Map中成分的键为线程对象,而值为对应线程的变量副本。

“你能或不能够研讨,java GC是在什么样时候,对什么事物,做了怎么着事情?”
在怎么着时候:
1.新生代有三个艾登区和多少个surSamsungr区,首先将对象放入艾登区,如果空间欠缺就向里面的一个surNokiar区上放,若是仍旧放不下就会吸引两次发出在新生代的minor
GC,将现有的目的放入另一个sur黑莓r区中,然后清空艾登和事先的不得了surBlackBerryr区的内存。在某次GC进程中,倘诺发现依旧又放不下的目标,就将那么些目标放入老时期内存里去。
2.大对象以及长久共存的目标直接进入老年区。
3.当每一回执行minor
GC的时候理应对要进步到老时代的目的进行分析,假设那么些即时要到老年区的老龄目标的大小当先了老年区的剩余大小,那么执行五次Full
GC以尽只怕地得到老年区的上空。
对什么样事物:从GC
Roots搜索不到,而且经过一回标记清理之后仍尚未复活的靶子。
做什么: 新生代:复制清理; 老时期:标记-清除和符号-压缩算法;
永久代:存放Java中的类和加载类的类加载器自身。
GC Roots都有何: 1. 虚构机栈中的引用的对象 2.
方法区中静态属性引用的目标,常量引用的目的 3.
本地点法栈中JNI(即一般说的Native方法)引用的对象。
友情链接:Java GC的那么些事(上)
友情链接:Java GC的这些事(下)
友情链接:CMS垃圾收集器介绍

ThreadLocal在Spring中表明着巨大的效率,在管理Request效率域中的Bean、事务管理、职分调度、AOP等模块都出现了它的身形。


Spring中多方面Bean都足以注明成Singleton作用域,采纳ThreadLocal进行打包,由此有情形的Bean就可以以singleton的主目的在于多线程中健康办事了。

Synchronized
与Lock都是可重入锁,同五个线程再度进入同步代码的时候.可以采纳自个儿一度获得到的锁。
Synchronized是悲观锁机制,独占锁。而Locks.ReentrantLock是,每一趟不加锁而是一旦没有争论而去做到某项操作,假如因为抵触失败就重试,直到成功截至。
ReentrantLock适用场景

友情链接:长远钻研java.lang.ThreadLocal类

  1. 某些线程在等候三个锁的控制权的那段时日须求暂停
  2. 亟需分开处理局地wait-notify,ReentrantLock里面的Condition应用,可以控制notify哪个线程,锁可以绑定八个规格。
  3. 有着正义锁效率,每一种到来的线程都将排队等候。

友情链接: Synchronized关键字、Lock,并分解它们之间的界别

Java内存模型:


Java虚拟机规范少将Java运营时数据分为两种。

StringBuffer是线程安全的,每一趟操作字符串,String会变动贰个新的目的,而StringBuffer不会;StringBuilder是非线程安全的
友情链接:String、StringBuffer与StringBuilder之间分歧

1.程序计数器:是七个数据结构,用于保存当前不奇怪履行的次第的内存地址。Java虚拟机的八线程就是通过线程轮流切换并分配处理器时间来达成的,为了线程切换后能还原到科学的义务,每条线程都要求多个单身的次第计数器,互不影响,该区域为“线程私有”。


2.Java虚构机栈:线程私有的,与线程生命周期相同,用于存储局地变量表,操作栈,方法再次回到值。局地变量表放着主导数据类型,还有对象的引用。

fail-fast:机制是java集合(Collection)中的一种错误机制。当多个线程对同1个见面的始末进行操作时,就大概会生出fail-fast事件。
比如:当某1个线程A通过iterator去遍历某集合的历程中,若该集合的内容被其余线程所改变了;那么线程A访问集合时,就会抛出ConcurrentModificationException至极,爆发fail-fast事件

3.本地点法栈:跟虚拟机栈很像,但是它是为虚拟机使用到的Native方法服务。


4.Java堆:全数线程共享的一块内存区域,对象实例大约都在那分配内存。

happens-before:如若多个操作之间有着happens-before
关系,那么前3个操作的结果就会对后边一个操作可知。
1.先后顺序规则:多少个线程中的每一个操作,happens- before
于该线程中的任意后续操作。
2.监视器锁规则:对多个蹲点器锁的解锁,happens- before
于随着对这些监视器锁的加锁。
3.volatile变量条条框框:对三个volatile域的写,happens-
before于自由后续对那个volatile域的读。
4.传递性:如果A happens- before B,且B happens- before C,那么A happens-
before C。
5.线程运行规则:Thread对象的start()方法happens-
before于此线程的每3个动作。

5.方法区:各样线程共享的区域,储存虚拟机加载的类新闻,常量,静态变量,编译后的代码。


6.运维时常量池:代表运维时每一种class文件中的常量表。包涵三种常量:编译时的数字常量、方法或然域的引用。

Volatile和Synchronized多少个分歧点:
1 粒度差距,前者针对变量 ,后者锁对象和类
2 syn阻塞,volatile线程不打断
3 syn保障三大特色,volatile不保障原子性
4 syn编译器优化,volatile不优化 volatile具备二种特性:

友情链接:Java中JVM虚拟机详解

1.承保此变量对具无线程的可知性,指一条线程修改了这么些变量的值,新值对于其他线程来说是可知的,但并不是二十四线程安全的。
2.禁止发令重排序优化。


Volatile怎么样保障内存可知性:

“你能依旧不能够琢磨,java
GC是在哪些时候,对什么样东西,做了什么样工作?”

1.当写3个volatile变量时,JMM会把该线程对应的地点内存中的共享变量刷新到主内存。
2.当读一个volatile变量时,JMM会把该线程对应的当地内存置为无用。线程接下去将从主内存中读取共享变量。

在如什么日期候:

协办:就是1个任务的成功需求依靠此外多个义务,唯有翘首以待被看重的任务到位后,依赖义务才能做到。
异步:不必要等待被重视的职责完结,只是布告被倚重的天职要成功什么工作,只要本人义务到位了不畏达成了,被依赖的任务是还是不是形成会通报重临。(异步的特点就是打招呼)。
打电话和发短信来比喻同步和异步操作。
堵塞:CPU停下来等2个慢的操作完毕之后,才会随之完结其余的工作。
非阻塞:非阻塞就是在这几个慢的施行时,CPU去做别的工作,等那几个慢的达成后,CPU才会随之已毕后续的操作。
非阻塞会招致线程切换扩张,伸张CPU的行使时间能不能够补充系统的切换开销要求考虑。
友情链接:Java并发编程之volatile关键字解析

1.新生代有一个艾登区和五个sur魅族r区,首先将对象放入艾登区,如若空间欠缺就向里面的3个surOPPOr区上放,借使仍旧放不下就会掀起两次发出在新生代的minor
GC,将现有的对象放入另3个sur黑莓r区中,然后清空艾登和以前的不胜sur魅族r区的内存。在某次GC过程中,假若发现照旧又放不下的对象,就将那一个目的放入老时代内存里去。


2.大对象以及长期共存的靶子直接进去老年区。

CAS(Compare And Swap) 无锁算法:
CAS是乐观锁技术,当七个线程尝试利用CAS同时创新同一个变量时,只有内部七个线程能更新变量的值,而任何线程都未果,失利的线程并不会被挂起,而是被告知本次竞争中破产,并得以重新尝试。CAS有三个操作数,内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修改为B,否则如何都不做。
友情链接:非阻塞同步算法与CAS(Compare and
Swap)无锁算法

3.当每一回执行minor
GC的时候理应对要升迁到老时期的对象举办分析,要是那几个即时要到老年区的老年目的的尺寸超越了老年区的剩余大小,那么执行三遍Full
GC以尽量地获取老年区的空中。


对怎么东西:从GC
Roots搜索不到,而且通过一遍标记清理之后仍尚未复活的目的。

线程池的意义:
在先后运营的时候就创办若干线程来响应处理,它们被叫做线程池,里面的线程叫工作线程
第二:下降能源消耗。通过重复利用已开立的线程下跌线程成立和销毁造成的花费。
其次:升高响应速度。当义务到达时,职务可以不需求等到线程创作育能即时实施。
其三:提升线程的可管理性。
常用线程池:ExecutorService 是任重(英文名:rèn zhòng)而道远的落实类,其中常用的有
Executors.newSingleThreadPool(),newFixedThreadPool(),newcachedTheadPool(),newScheduledThreadPool()。
友情链接:线程池原理
友情链接:线程池原理分析

做什么:
新生代:复制清理;
老时代:标记-清除和符号-压缩算法;
永久代:存放Java中的类和加载类的类加载器本人。


GC Roots都有哪些:

类加载器工作机制:
1.装载:将Java二进制代码导入jvm中,生成Class文件。
2.两次三番:a)校验:检查载入Class文件数量的正确性
b)准备:给类的静态变量分配存储空间 c)解析:将符号引用转成间接引用
3:开端化:对类的静态变量,静态方法和静态代码块执行初步化工作。
二老委派模型:类加载器收到类加载请求,首先将请求委派给父类加载器完结用户自定义加载器->应用程序加载器->扩张类加载器->运营类加载器。
友情链接:深远精晓Java虚拟机笔记—双亲委派模型 
友情链接:JVM类加载的那几个事
友情链接:JVM(1):Java
类的加载机制

  1. 编造机栈中的引用的对象
  2. 方法区中静态属性引用的靶子,常量引用的对象
  3. 当地点法栈中JNI(即一般说的Native方法)引用的对象。

友情链接:Java
GC的这几个事(上)

一致性哈希:
Memcahed缓存:
数据结构:key,value对
采用形式:get,put等措施
友情链接:hashcode(),equal()方法深切剖析

友情链接:Java
GC的那3个事(下)


友情链接:CMS垃圾收集器介绍

Redis数据结构: String—字符串(key-value 类型)
Hash—字典(hashmap)
Redis的哈希结构得以使你像在数据库中更新三个性子一样只修改某一项属性值
List—列表 已毕信息队列
Set—集合 利用唯一性
Sorted Set—有序集合 可以进行排序 可以达成数量持久化
友情链接: Spring + Redis
完结多少的缓存



Synchronized
与Lock都以可重入锁,同贰个线程再一次进入同步代码的时候.可以使用本人一度赢拿到的锁。

java自动装箱拆箱长远解析
谈谈Java反射机制
哪些写贰个不足变类?

Synchronized是悲观锁机制,独占锁。而Locks.ReentrantLock是,每一回不加锁而是只要没有顶牛而去达成某项操作,假使因为冲突战败就重试,直到成功截至。
ReentrantLock适用场景


  1. 有个别线程在等候1个锁的控制权的那段时光必要暂停
  2. 亟需分开处理部分wait-notify,ReentrantLock里面的Condition应用,可以决定notify哪个线程,锁可以绑定三个原则。
  3. 有着正义锁功用,各个到来的线程都将排队等候。

目录:B+,B-,全文索引
Mysql的目录是1个数据结构,目的在于使数据库高效的搜索数据。
常用的数据结构是B+Tree,各个叶子节点不但存放了索引键的连带消息还扩张了指向邻近叶子节点的指针,那样就形成了涵盖顺序访问指针的B+Tree,做这几个优化的目标是增高差距距离访问的属性。
哪些时候使用索引:

友情链接:Synchronized关键字、Lock,并分解它们中间的界别

  1. 经常出现在group by,order by和distinc关键字背后的字段
  2. 每每与任何表举办连接的表,在再三再四字段上应当树立目录
  3. 平时出以后Where子句中的字段
  4. 平时出现用作查询选取的字段
  5. Java学习交换QQ群:589809992 大家一块学Java!

友情链接:MySQL:InnoDB存储引擎的B+树索引算法
友情链接:MySQL索引背后的数据结构及算法原理

StringBuffer是线程安全的,每趟操作字符串,String会转移3个新的目的,而StringBuffer不会;StringBuilder是非线程安全的


友情链接:String、StringBuffer与StringBuilder之间差异

Spring IOC (控制反转,重视注入)
Spring帮助二种信赖注入格局,分别是性质(Setter方法)注入,构造注入和接口注入。
在Spring中,那二个结合应用的基本点及由Spring
IOC容器所管理的目的被称呼Bean。
Spring的IOC容器通过反射的体制实例化Bean并制造Bean之间的敬爱关系。
不难地讲,Bean就是由Spring IOC容器开头化、装配及被管制的目的。
取得Bean对象的进程,首先通过Resource加载配置文件并运行IOC容器,然后经过getBean方法赢得bean对象,就可以调用他的法门。
Spring Bean的成效域:
Singleton:Spring
IOC容器中唯有2个共享的Bean实例,一般都是Singleton效能域。
Prototype:每一个呼吁,会发出三个新的Bean实例。
Request:每五次http请求会发生壹个新的Bean实例。
友情链接: Spring框架IOC容器和AOP解析
友情链接:浅谈Spring框架评释的用法分析
友情链接:关于Spring的66个面试问答——终极列表



fail-fast:机制是java集合(Collection)中的一种错误机制。当七个线程对同2个汇集的内容举办操作时,就只怕会发生fail-fast事件。
譬如说:当某二个线程A通过iterator去遍历某集合的进程中,若该集合的情节被此外线程所改变了;那么线程A访问集合时,就会抛出ConcurrentModificationException至极,爆发fail-fast事件

代办的共有优点:业务类只必要关心业务逻辑本人,保障了业务类的重用性。
Java静态代办:
代理对象和目标对象落成了一致的接口,目的对象作为代理对象的1脾品质,具体接口落成中,代理对象可以在调用目的对象相应措施前后加上其余业务处理逻辑。
缺点:二个代理类只可以代理二个业务类。如果工作类增添方法时,相应的代理类也要增添方法。
Java动态代理:
Java动态代理是写三个类已毕InvocationHandler接口,重写Invoke方法,在Invoke方法可以举行压实处理的逻辑的编写,这么些集体代理类在运营的时候才能了解本身要代理的靶子,同时可以兑现该被代理类的章程的已毕,然后在贯彻类方式的时候可以开展加强处理。
实则:代理对象的方法 = 增强处理 + 被代理对象的法子


JDK和CGLIB生成动态代理类的不一致:
JDK动态代理只可以针对落到实处了接口的类生成代理(实例化3个类)。此时期理对象和目的对象达成了同一的接口,目的对象作为代理对象的3个脾性,具体接口落成中,可以在调用目的对象相应措施前后加上其余事情处理逻辑
CGLIB是针对类达成代理,重假使对点名的类生成三个子类(没有实例化二个类),覆盖其中的格局。
Spring AOP应用场景
品质检测,访问控制,日志管理,事务等。
暗中同意的策略是假设目标类落成接口,则接纳JDK动态代理技术,假设目的对象没有落成接口,则默许会采取CGLIB代理

happens-before:若是七个操作之间具有happens-before
关系,那么前一个操作的结果就会对后边2个操作可知。
1.顺序顺序规则:三个线程中的各个操作,happens- before
于该线程中的任意后续操作。
2.监视器锁规则:对2个蹲点器锁的解锁,happens- before
于随着对这些监视器锁的加锁。
3.volatile变量条条框框:对一个volatile域的写,happens-
before于自由后续对那几个volatile域的读。
4.传递性:如果A happens- before B,且B happens- before C,那么A happens-
before C。
5.线程运行规则:Thread对象的start()方法happens-
before于此线程的每二个动作。



SpringMVC运转原理

Volatile和Synchronized五个不一样点:
1 粒度不一致,前者锁对象和类,后者针对变量
2 syn阻塞,volatile线程不打断
3 syn保险三大特点,volatile不保证原子性
4 syn编译器优化,volatile不优化
volatile具备二种个性:

  1. 客户端请求提交到DispatcherServlet
  2. 由DispatcherServlet控制器查询HandlerMapping,找到并散发到内定的Controller中。
  3. Controller调用工作逻辑处理后,重返ModelAndView
  4. DispatcherServlet查询三个或多少个ViewResoler视图解析器,找到ModelAndView钦定的视图
  5. 视图负责将结果展现到客户端
  1. 保证此变量对富有线程的可知性,指一条线程修改了这几个变量的值,新值对于别的线程来说是可知的,但并不是三十二线程安全的。
  2. 取缔指令重排序优化。
    Volatile如何保险内存可知性:
    1.当写二个volatile变量时,JMM会把该线程对应的地头内存中的共享变量刷新到主内存。
    2.当读三个volatile变量时,JMM会把该线程对应的地面内存置为无用。线程接下去将从主内存中读取共享变量。

友情链接:Spring:基于申明的Spring
MVC(上)

友情链接: Spring:基于注明的Spring
MVC(下) 

友情链接:SpringMVC与Struts2界别与比较总括
友情链接:SpringMVC与Struts2的对比

同步:就是二个任务的成功要求依靠其它贰个职责,唯有翘首以待被依赖的天职成功后,倚重义务才能形成。
异步:不必要等待被重视的天职成功,只是通知被依赖的职责要做到什么工作,只要本人任务达成了就是完事了,被依赖的天职是还是不是已毕会打招呼重返。(异步的性状就是打招呼)。
通话和发短信来比喻同步和异步操作。
闭塞:CPU停下来等一个慢的操作完毕今后,才会随着落成其他的干活。
非阻塞:非阻塞就是在这一个慢的执行时,CPU去做其他干活,等那些慢的已毕后,CPU才会随着已毕后续的操作。
非阻塞会导致线程切换增添,伸张CPU的施用时间能照旧不能填补系统的切换开销必要考虑。


友情链接:Java并发编程之volatile关键字解析

一个Http请求
DNS域名解析 –> 发起TCP的两次握手 –> 建立TCP连接后发起http请求
–> 服务器响应http请求,浏览器得到html代码 –>
浏览器解析html代码,并恳请html代码中的能源(如javascript、css、图片等)
–> 浏览器对页面举办渲染显示给用户


规划存储海量数据的储存系统:设计2个叫“中间层”的贰个逻辑层,在这几个层,将数据库的海量数据抓出来,做成缓存,运营在服务器的内存中,同理,当有新的多少来临,也先做成缓存,再想方法,持久化到数据库中,那是一个不难的思绪。主要的步调是负载均衡,将不一样用户的央浼分发到分歧的拍卖节点上,然后先存入缓存,定时向主数据库更新数据。读写的长河使用类似乐观锁的建制,可以一向读(在写多少的时候也得以),可是每一遍读的时候会有个本子的标记,如若此次读的版本低于缓存的本子,会再度读数据,那样的情状并不多,可以忍受。

CAS(Compare And Swap)
无锁算法:

CAS是乐观锁技术,当多个线程尝试利用CAS同时创新同1个变量时,只有内部一个线程能更新变量的值,而任何线程都未果,失败的线程并不会被挂起,而是被报告这一次竞争中破产,并可以重复尝试。CAS有一个操作数,内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修改为B,否则怎么都不做。

友情链接: HTTP与HTTPS的区别
友情链接: HTTPS
为何更安全,先看这一个 

友情链接: HTTP请求报文和HTTP响应报文
友情链接: HTTP 请求方式:
GET和POST的相比

友情链接:非阻塞同步算法与CAS(Compare and
Swap)无锁算法



Session与Cookie:Cookie能够让服务端跟踪每种客户端的拜会,不过每回客户端的拜会都不或然不传回那个Cookie,若是库克ie很多,则无形的加码了客户端与服务端的多寡传输量,
而Session则很好地化解了这一个题材,同三个客户端每便和服务端交互时,将数据存储通过Session到服务端,不须求每回都不翼而飞全体的Cookie值,而是传回三个ID,各个客户端第四回访问服务器生成的绝无仅有的ID,客户端只要传回这一个ID就行了,那么些ID日常为NAME为JSESSIONID的二个Cookie。那样服务端就足以经过那个ID,来将积存到服务端的KV值取出了。
Session和Cookie的超时难题,Cookie的平安题材

线程池的效用:
在程序运营的时候就创制若干线程来响应处理,它们被称为线程池,里面的线程叫工作线程
率先:下落能源消耗。通过重新利用已开立的线程下落线程创立和销毁造成的损耗。
其次:进步响应速度。当任务到达时,职分可以不需求等到线程创立就能立刻实施。
其三:提升线程的可管理性。
常用线程池:ExecutorService 是关键的落到实处类,其中常用的有
Executors.newSingleThreadPool(),newFixedThreadPool(),newcachedTheadPool(),newScheduledThreadPool()。


友情链接:线程池原理

分布式Session框架

友情链接:线程池原理分析

  1. 配置服务器,Zookeeper集群管理服务器可以统一管理全体服务器的布署文件
  2. 共享那几个Session存储在贰个分布式缓存中,可以每一天写入和读取,而且质量要很好,如Memcache,Tair。
  3. 打包多个类继承自HttpSession,将Session存入到这一个类中然后再存入分布式缓存中
  4. 鉴于Cookie不能跨域访问,要贯彻Session同步,要联手SessionID写到不一致域名下。


类加载器工作机制:
1.装载:将Java二进制代码导入jvm中,生成Class文件。
2.延续:a)校验:检查载入Class文件数量的正确性
b)准备:给类的静态变量分配存储空间 c)解析:将符号引用转成间接引用
3:起首化:对类的静态变量,静态方法和静态代码块执行开首化工作。

适配器形式:将3个接口适配到另1个接口,Java
I/O中InputStreamReader将Reader类适配到InputStream,从而完结了字节流到字符流的准换。
装饰者情势:保持原来的接口,增强原来一些职能。
FileInputStream
完成了InputStream的兼具接口,BufferedInputStreams继承自FileInputStream是有血有肉的装饰器落成者,将InputStream读取的故事情节保留在内存中,而拉长读取的品质。

二老委派模型:类加载器收到类加载请求,首先将请求委派给父类加载器完结
用户自定义加载器->应用程序加载器->伸张类加载器->运转类加载器。


友情链接:长远明白Java虚拟机笔记—双亲委派模型

Spring事务配置方式:
1.切点新闻,用于固定实施东西切面的事务类措施
2.说了算作业行为的政工属性,这么些属性包蕴事物隔离级别,事务传播行为,超时时间,回滚规则。

友情链接:JVM类加载的这么些事

Spring通过aop/tx Schema
命名空间和@Transaction申明技术来拓展表明式事物配置。



一致性哈希:

Mybatis
每五个Mybatis的应用程序都以1个SqlSessionFactory对象的实例为主干。首先用字节流通过Resource将配备文件读入,然后经过SqlSessionFactoryBuilder().build方法创立SqlSessionFactory,然后再通过SqlSessionFactory.openSession()方法创立一个SqlSession为每3个数据库事务服务。
经历了Mybatis开始化 –>创造SqlSession
–>运营SQL语句,重回结果三个进程

Memcahed缓存:
数据结构:key,value对
利用办法:get,put等措施


友情链接:hashcode(),equal()方法长远解析

Servlet和Filter的区别:
整的流水线是:Filter对用户请求进行预处理,接着将呼吁提交Servlet举办拍卖并转移响应,最终Filter再对服务器响应进行后处理。


Filter有如下多少个用处:
Filter可以展开对特定的url请求和对应做预处理和后处理。
在HttpServletRequest到达Servlet之前,拦截客户的HttpServletRequest。
依据须求检查HttpServletRequest,也足以修改HttpServletRequest头和数量。
在HttpServletResponse到达客户端此前,拦截HttpServletResponse。
基于需求检查HttpServletResponse,也足以修改HttpServletResponse头和数目。

Redis数据结构: String—字符串(key-value
类型)

Hash—字典(hashmap)
Redis的哈希结构得以使你像在数据库中更新几天性能一样只修改某一项属性值
List—列表 落成消息队列
Set—集合 利用唯一性
Sorted Set—有序集合 可以开展排序
能够兑现数量持久化

实际Filter和Servlet极其相似,分裂只是Filter不可以一直对用户生成响应。实际上Filter里doFilter()方法里的代码就是从七个Servlet的service()方法里抽取的通用代码,通过使用Filter可以达成更好的复用。

友情链接:Spring + Redis
完毕数据的缓存

Filter和Servlet的生命周期:
1.Filter在web服务器运营时开头化
2.如若有些Servlet配置了 1
,该Servlet也是在汤姆cat(Servlet容器)运行时早先化。
3.只要Servlet没有安顿1
,该Servlet不会在汤姆cat运转时初阶化,而是在伸手到来时初叶化。
4.每趟请求, Request都会被初阶化,响应请求后,请求被灭绝。
5.Servlet开始化后,将不会趁机请求的扫尾而撤回。
6.关闭汤姆cat时,Servlet、Filter依次被吊销。



java自动装箱拆箱深刻剖析

HashMap与HashTable的区别。
① 、HashMap是非线程安全的,HashTable是线程安全的。
二 、HashMap的键和值都允许有null值存在,而HashTable则尤其。
三 、因为线程安全的题材,HashMap功能比HashTable的要高。

谈谈Java反射机制

HashMap的落到实处机制:

何以写二个不得变类?

  1. 保安一个种种成分是八个链表的数组,而且链表中的各种节点是一个Entry[]键值对的数据结构。
  2. 落到实处了数组+链表的表征,查找快,插入删除也快。
  3. 对此各种key,他对应的数组索引下标是 int i =
    hash(key.hashcode)&(len-1);
  4. 每一个新插手的节点放在链表首,然后该新进入的节点指向原链表首
  5. Java学习互换QQ群:589809992 大家一道学Java!

HashMap和TreeMap区别
友情链接: Java中HashMap和TreeMap的分别长远驾驭

目录:B+,B-,全文索引
Mysql的目录是八个数据结构,意在使数据库高效的追寻数据。
常用的数据结构是B+Tree,逐个叶子节点不但存放了索引键的相干新闻还增添了指向附近叶子节点的指针,那样就形成了包蕴顺序访问指针的B+Tree,做那些优化的目标是升高不一样距离访问的习性。
怎么时候使用索引:

HashMap冲突
友情链接: HashMap争执的解决办法以及原理分析
友情链接: HashMap的工作原理
友情链接: HashMap和Hashtable的区别
友情链接: 2种办法让HashMap线程安全

  1. 平时出现在group by,order by和distinc关键字背后的字段
  2. 不时与其余表展开再三再四的表,在接二连三字段上相应建立目录
  3. 平常出现在Where子句中的字段
  4. 平日出现用作查询采纳的字段

友情链接:MySQL:InnoDB存储引擎的B+树索引算法

HashMap,ConcurrentHashMap与LinkedHashMap的区别

友情链接:MySQL索引背后的数据结构及算法原理

  1. ConcurrentHashMap是选用了锁分段技术技能来确保线程安全的,锁分段技术:首先将数据分为一段一段的蕴藏,然后给每一段数据配一把锁,当一个线程占用锁访问其中三个段数据的时候,其余段的数目也能被此外线程访问
  2. ConcurrentHashMap 是在种种段(segment)中线程安全的
  3. LinkedHashMap维护壹个双链表,可以将里面的数码按写入的种种读出

ConcurrentHashMap应用场景
1:ConcurrentHashMap的施用场景是高并发,可是并不可能担保线程安全,而一起的HashMap和HashMap的是锁住整个容器,而加锁之后ConcurrentHashMap不须求锁住整个容器,只需求锁住对应的Segment就好了,所以可以保障高并发同步访问,升高了功用。
2:可以四线程写。
ConcurrentHashMap把HashMap分成若干个Segmenet
1.get时,不加锁,先固定到segment然后在找到头结点举办读取操作。而value是volatile变量,所以可以保障在竞争原则时有限支撑读取最新的值,假设读到的value是null,则可能正在修改,那么就调用ReadValueUnderLock函数,加锁保险读到的数码是没错的。
2.Put时会加锁,一律添加到hash链的头顶。
3.Remove时也会加锁,由于next是final类型不可变更,所以必须把删除的节点以前的节点都复制一次。
4.ConcurrentHashMap允许八个修改操作并发进行,其关键在于使用了锁分离技术。它采纳了八个锁来控制对Hash表的不一样Segment举行的修改。

Spring IOC
(控制反转,依赖注入)

ConcurrentHashMap的应用场景是高并发,可是并不只怕担保线程安全,而一起的HashMap和HashTable的是锁住整个容器,而加锁之后ConcurrentHashMap不须要锁住整个容器,只必要锁住对应的segment就好了,所以可以保险高并发同步访问,进步了功用。

Spring援救两种依赖注入方式,分别是性质(Setter方法)注入,构造注入和接口注入。

ConcurrentHashMap可以保障每便调用都是原子操作,不过并不保障数十一次调用之间也是原子操作。
友情链接:Java集合—ConcurrentHashMap原理分析

在Spring中,这么些结合应用的主脑及由Spring
IOC容器所管理的目的被称为Bean。


Spring的IOC容器通过反射的体制实例化Bean并创造Bean之间的正视关系。
归纳地讲,Bean就是由Spring IOC容器先导化、装配及被管理的目标。
得到Bean对象的长河,首先通过Resource加载配置文件并运行IOC容器,然后经过getBean方法赢得bean对象,就可以调用他的法子。
Spring Bean的作用域:
Singleton:Spring
IOC容器中唯有多个共享的Bean实例,一般都以Singleton功能域。
Prototype:每贰个呼吁,会发生二个新的Bean实例。
Request:每一趟http请求会发生贰个新的Bean实例。

Vector和ArrayList的区别
友情链接:Java中Vector和ArrayList的区别

友情链接:Spring框架IOC容器和AOP解析


友情链接:浅谈Spring框架注脚的用法分析

ExecutorService service = Executors…. ExecutorService service = new
ThreadPoolExecutor() ExecutorService service = new
ScheduledThreadPoolExecutor();

友情链接:至于Spring的六十六个面试问答——终极列表

ThreadPoolExecutor源码分析


线程池本人的情形:

代办有如何?各有怎样特色?

图片 1

代办的共有优点:业务类只需求关怀业务逻辑自己,保险了业务类的重用性。
Java静态代办:
代理对象和对象对象落成了一样的接口,目的对象作为代理对象的3个属性,具体接口已毕中,代理对象足以在调用目的对象相应措施前后加上其他作业处理逻辑。
缺陷:壹个代理类只能够代理壹个业务类。借使工作类扩大方法时,相应的代理类也要追加方法。
Java动态代理:
Java动态代理是写壹个类落成InvocationHandler接口,重写Invoke方法,在Invoke方法可以拓展抓好处理的逻辑的编制,这些集体代理类在运作的时候才能肯定本身要代理的对象,同时可以兑现该被代理类的艺术的完结,然后在已毕类格局的时候可以开展抓好处理。
实际上:代理对象的点子 = 增强处理 + 被代理对象的主意

等候义务队列和劳作集:

JDK和CGLIB生成动态代理类的界别:
JDK动态代理只能够针对落实了接口的类生成代理(实例化二个类)。此时期理对象和目的对象完成了一样的接口,目的对象作为代理对象的三天品质,具体接口完结中,能够在调用目的对象相应措施前后加上其它作业处理逻辑
CGLIB是针对类完结代理,主假使对点名的类生成三个子类(没有实例化三个类),覆盖其中的主意

Spring AOP应用场景
属性检测,访问控制,日志管理,事务等。
暗中认同的方针是只要目的类落成接口,则运用JDK动态代理技术,假如目的对象没有兑现接口,则暗许会选择CGLIB代理

图片 2


线程池的最紧要情状锁:

SpringMVC运转原理

图片 3

  1. 客户端请求提交到DispatcherServlet
  2. 由DispatcherServlet控制器查询HandlerMapping,找到并散发到内定的Controller中。
  3. Controller调用工作逻辑处理后,重回ModelAndView
  4. DispatcherServlet查询五个或五个ViewResoler视图解析器,找到ModelAndView内定的视图
  5. 视图负责将结果突显到客户端

线程池的现有时间和大小:

友情链接:Spring:基于注脚的Spring
MVC(上)

图片 4

友情链接:Spring:基于申明的Spring MVC(下)

1.2 ThreadPoolExecutor 的中间工作原理
有了以上定义好的多寡,上面来看望里面是怎么完结的 。 Doug Lea
的总体思路总计起来就是 5 句话:

友情链接:SpringMVC与Struts2界别与相比较总括

  1. 倘使当前池大小 poolSize 小于 corePoolSize ,则开立异线程执行职责。
  2. 即使当前池大小 poolSize 大于 corePoolSize
    ,且等待队列未满,则跻身等待队列
  3. 若果当前池大小 poolSize 大于 corePoolSize 且小于 maximumPoolSize
    ,且等待队列已满,则开立异线程执行职责。
  4. 如若当前池大小 poolSize 大于 corePoolSize 且大于 maximumPoolSize
    ,且等待队列已满,则调用拒绝策略来处理该职务。
  5. 线程池里的每一个线程执行完任务后不会马上退出,而是会去检查下等待队列里是或不是还有线程职务急需实践,假使在
    keepAliveTime 里等不到新的任务了,那么线程就会退出。

友情链接:SpringMVC与Struts2的对比

Executor包结构


图片 5

3个Http请求的流水线?
DNS域名解析 –> 发起TCP的一遍握手 –> 建立TCP连接后发起http请求
–> 服务器响应http请求,浏览器拿到html代码 –>
浏览器解析html代码,并请求html代码中的财富(如js、css、图片等) –>
浏览器对页面举办渲染显示给用户

图片 6

统筹存储海量数据的贮存系统:设计3个叫“中间层”的八个逻辑层,在这几个层,将数据库的雅量数据抓出来,做成缓存,运营在服务器的内存中,同理,当有新的多寡来临,也先做成缓存,再想艺术,持久化到数据库中,这是三个简约的思绪。首要的步子是负载均衡,将差距用户的呼吁分发到区其余拍卖节点上,然后先存入缓存,定时向主数据库更新数据。读写的进度使用类似乐观锁的编制,可以一直读(在写多少的时候也得以),可是每趟读的时候会有个本子的标志,要是此次读的版本低于缓存的本子,会再一次读数据,那样的情事并不多,可以忍受。

图片 7

友情链接:HTTP与HTTPS的区别

CopyOnWriteArrayList :
写时加锁,当添加二个成分的时候,将原来的容器举办copy,复制出贰个新的器皿,然后在新的容器里面写,写完事后再将原容器的引用指向新的容器,而读的时候是读旧容器的多少,所以可以展开并发的读,但这是一种弱一致性的方针。
接纳景况:CopyOnWriteArrayList适合利用在读操作远远大于写操作的光景里,比如缓存。

友情链接:HTTPS 为何更安全,先看这一个


友情链接:HTTP请求报文和HTTP响应报文

Linux常用命令:cd,cp,mv,rm,ps(进度),tar,cat(查看内容),chmod,vim,find,ls

友情链接:HTTP 请求方式:
GET和POST的相比



死锁的须求条件

Session与Cookie

  1. 互斥 至少有三个财富处于非共享状态
  2. 占据并等候
  3. 非抢占
  4. 循环等待

Cookie可以让服务端跟踪每一个客户端的访问,可是每便客户端的拜访都不能不传回那么些Cookie,若是Cookie很多,则无形的加码了客户端与服务端的数据传输量,
而Session则很好地消除了这一个难点,同1个客户端每一趟和服务端交互时,将数据存储通过Session到服务端,不需要每一回都流传全数的Cookie值,而是传回二个ID,各个客户端第两次访问服务器生成的唯一的ID,客户端只要传回那么些ID就行了,这几个ID平时为NAME为JSESSIONID的二个库克ie。那样服务端就可以经过这一个ID,来将积存到服务端的KV值取出了。
Session和Cookie的晚点难题,Cookie的安全题材

不留余地死锁,第多个是死锁预防,就是不让上边的三个规范还要创造。二是,合理分配财富。
三是行使银行家算法,假使该进程请求的财富操作系统剩余量可以满意,那么就分配。



分布式Session框架

进度间的通信格局

  1. 布署服务器,Zookeeper集群管理服务器可以统一管理全数服务器的配备文件
  2. 共享那些Session存储在多个分布式缓存中,可以随时写入和读取,而且质量要很好,如Memcache,Tair。
  3. 包装三个类继承自HttpSession,将session存入到这一个类中然后再存入分布式缓存中
  4. 出于Cookie无法跨域访问,要兑现Session同步,要联手SessionID写到分歧域名下。
  1. 管道( pipe
    ):管道是一种半双工的通讯形式,数据只可以单向流动,而且不得不在颇具亲缘关系的历程间使用。进度的血肉关系一般是指父子进度关系。
  2. 显赫管道 (named pipe) :
    知名管道也是半双工的通讯格局,不过它同意无亲缘关系进度间的通讯。
  3. 信号量( semophore ) :
    信号量是1个计数器,可以用来决定三个经过对共享能源的拜会。它常作为一种锁机制,幸免某经过正在访问共享财富时,其余进程也拜会该能源。因而,首要用作进程间以及同样进程内不一致线程之间的一块儿手段。
  4. 新闻队列( message queue ) :
    新闻队列是由消息的链表,存放在基本中并由音信队列标识符标识。消息队列克制了信号传递新闻少、管道只好承载无格式字节流以及缓冲区大大小小受限等缺陷。
  5. 信号 ( sinal ) :
    信号是一种比较复杂的通讯格局,用于布告接收进程某些事件早已爆发。
  6. 共享内存( shared memory )
    :共享内存就是炫耀一段能被其余进度所走访的内存,那段共享内存由3个进程成立,但三个经过都得以访问。共享内存是最快的
    IPC
    格局,它是本着其余进度间通讯格局运营效能低而特意规划的。它往往与任何通讯机制,如信号量,合营使用,来兑现进度间的一块和通信。
  7. 套接字( socket ) :
    套解口也是一种过程间通讯机制,与此外通讯机制不相同的是,它可用以不一样机器间的长河通讯。
  8. Java学习沟通QQ群:589809992 大家一同学Java!


适配器情势:将3个接口适配到另一个接口,Java
I/O中InputStreamReader将Reader类适配到InputStream,从而落成了字节流到字符流的准换。
装饰者形式:保持原来的接口,增强原来有的职能。
FileInputStream
完毕了InputStream的具备接口,BufferedInputStreams继承自FileInputStream是实际的装饰器完毕者,将InputStream读取的情节保留在内存中,而狠抓读取的个性。

进度与线程的界别和互换
操作系统的经过调度算法
微机连串的层系存储结构详解



Spring事务配置形式:

数据库事务是指作为单个逻辑工作单元执行的一文山会海操作。

  1. 切点音信,用于固定实施东西切面的事务类形式
  2. 决定工作行为的政工属性,这一个属性包含事物隔离级别,事务传播行为,超时时间,回滚规则。
    Spring通过aop/tx Schema
    命名空间和@Transaction声明技术来举行评释式事物配置。

图片 8


友情链接:数据库事务的四大特色以及工作的割裂级别

Mybatis
每一个Mybatis的应用程序都是3个SqlSessionFactory对象的实例为大旨。首先用字节流通过Resource将配备文件读入,然后通过SqlSessionFactoryBuilder().build方法创立SqlSessionFactory,然后再经过sqlSessionFactory.openSession()方法创制3个sqlSession为每一个数据库事务服务。
经历了Mybatis开端化 –>创造SqlSession –>运营SQL语句
再次来到结果八个进程



MySQL数据库优化总计
MYSQL
优化常用方法

MySQL存储引擎--MyISAM与InnoDB不同
关于SQL数据库中的范式

Servlet和Filter的区别:
整的流水线是:Filter对用户请求举行预处理,接着将呼吁提交Servlet举办拍卖并生成响应,最终Filter再对服务器响应举行后处理。


Filter有如下多少个用处:
Filter可以开展对一定的url请求和相应做预处理和后甩卖。
在HttpServletRequest到达Servlet此前,拦截客户的HttpServletRequest。
据悉必要检查HttpServletRequest,也得以修改HttpServletRequest头和数量。
在HttpServletResponse到达客户端从前,拦截HttpServletResponse。
根据须求检查HttpServletResponse,也得以修改HttpServletResponse头和数目。

Hibernate的一流缓存是由Session提供的,由此它只存在于Session的生命周期中,当程序调用save(),update(),saveOrUpdate()等格局及调用查询接口list,filter,iterate时,如Session缓存中还不设有对应的靶子,Hibernate会把该对象插足到拔尖缓存中,当Session关闭的时候缓存也会流失。

实际Filter和Servlet极其相似,不相同只是Filter无法直接对用户生成响应。实际上Filter里doFilter()方法里的代码就是从四个Servlet的service()方法里抽取的通用代码,通过拔取Filter可以兑现更好的复用。

Hibernate的一流缓存是Session所安放的,无法被卸载,也无法展开任何配置拔尖缓存采纳的是key-value的Map格局来落成的,在缓存实体对象时,对象的主关键字ID是Map的key,实体对象就是相应的值。

Filter和Servlet的生命周期:
1.Filter在web服务器运营时先导化
2.假设有个别Servlet配置了 <load-on-startup >1 </load-on-startup
>,该Servlet也是在汤姆cat(Servlet容器)运转时开端化。
3.只要Servlet没有计划<load-on-startup >1 </load-on-startup
>,该Servlet不会在汤姆cat运维时开始化,而是在哀求到来时初阶化。
4.每一回请求, Request都会被早先化,响应请求后,请求被销毁。
5.Servlet伊始化后,将不会趁着请求的截至而撤回。
6.关闭汤姆cat时,Servlet、Filter依次被吊销。

Hibernate二级缓存:把收获的兼具数据对象依据ID放入到第叁级缓存中。Hibernate二级缓存策略,是指向于ID查询的缓存策略,删除、更新、扩张数据的时候,同时立异缓存。


进度和线程的分别:

HashMap与HashTable的区别。
① 、HashMap是非线程安全的,HashTable是线程安全的。
二 、HashMap的键和值都允许有null值存在,而HashTable则卓殊。
叁 、因为线程安全的题材,HashMap作用比HashTable的要高。

进度:逐个进程都有独立的代码和多少空间(进度上下文),进程间的切换会有较大的开发,三个经过蕴含1–n个线程。

HashMap的达成机制:

线程:同一类线程共享代码和数目空间,逐个线程有单独的运营栈和程序计数器(PC),线程切换开销小。

  1. 珍爱1个各样成分是3个链表的数组,而且链表中的每一个节点是3个Entry[]键值对的数据结构。
  2. 落成了数组+链表的特点,查找快,插入删除也快。
  3. 对此各种key,他对应的数组索引下标是 int i =
    hash(key.hashcode)&(len-1);
  4. 每一个新投入的节点放在链表首,然后该新加盟的节点指向原链表首

线程和进程一样分成七个阶段:成立、就绪、运维、阻塞、终止。

HashMap和TreeMap区别

多进度是指操作系统能而且运维多少个职务(程序)。

友情链接:Java中HashMap和TreeMap的分别深刻通晓

十六线程是指在同样程序中有多少个顺序流在履行。

HashMap冲突

在java中要想落成多线程,有二种手段,一种是继续Thread类,别的一种是完毕Runable接口,还有就是兑现Callable接口。

友情链接:HashMap冲突的消除方法以及原理分析


友情链接:HashMap的办事规律

Switch能否用string做参数?

友情链接:HashMap和Hashtable的区别

a.在 Java 7 从前, switch 只好帮助byte,short,char,int
可能其对应的封装类以及 Enum 类型。在Java 7中,String 协助被添加了。

友情链接:2种艺术让HashMap线程安全



Object有何公用方法?

HashMap,ConcurrentHashMap与LinkedHashMap的区别

a.方法equals测试的是八个对象是或不是等于

  1. ConcurrentHashMap是采取了锁分段技术技能来保险线程安全的,锁分段技术:首先将数据分为一段一段的蕴藏,然后给每一段数据配一把锁,当三个线程占用锁访问其中二个段数据的时候,其他段的数码也能被其他线程访问
  2. ConcurrentHashMap 是在各类段(segment)中线程安全的
  3. LinkedHashMap维护2个双链表,可以将里面的数额按写入的逐条读出

b.方法clone进行对象拷贝

ConcurrentHashMap应用场景

c.方法getClass重临和近期目的相关的Class对象

1:ConcurrentHashMap的利用场景是高并发,可是并不大概保证线程安全,而共同的HashMap和HashMap的是锁住整个容器,而加锁之后ConcurrentHashMap不必要锁住整个容器,只必要锁住对应的Segment就好了,所以可以确保高并发同步访问,升高了频率。

d.方法notify,notifyall,wait都是用来对给定对象开展线程同步的

2:可以八线程写。
ConcurrentHashMap把HashMap分成若干个Segmenet
1.get时,不加锁,先固定到segment然后在找到头结点举行读取操作。而value是volatile变量,所以可以保障在竞争规则时保障读取最新的值,即使读到的value是null,则只怕正在修改,那么久调用ReadValueUnderLock函数,加锁保障读到的多寡是毋庸置疑的。
2.Put时会加锁,一律添加到hash链的底部。
3.Remove时也会加锁,由于next是final类型不可更改,所以必须把删除的节点以前的节点都复制一回。
4.ConcurrentHashMap允许五个修改操作并发进行,其关键在于使用了锁分离技术。它接纳了八个锁来支配对Hash表的不相同Segment举办的改动。


ConcurrentHashMap的使用场景是高并发,可是并没办法确保线程安全,而一同的HashMap和HashTable的是锁住整个容器,而加锁之后ConcurrentHashMap不要求锁住整个容器,只要求锁住对应的segment就好了,所以可以确保高并发同步访问,升高了效用。

Java的三种引用,强弱软虚,以及采纳的现象

友情链接:Java集合—ConcurrentHashMap原理分析

a.利用软引用和弱引用解决OOM问题:用3个HashMap来保存图片的门路和相应图片对象关系的软引用之间的映射关系,在内存不足时,JVM会自动回收那些缓存图片对象所占据的长空,从而使得地幸免了OOM的难点。


b.通过软可及对象重获方法达成Java对象的高速缓存:比如大家创建了一Employee的类,即便每便必要查询2个雇员的消息。哪怕是几秒中之前刚刚查询过的,都要重新营造贰个实例,那是急需开销很多时日的。大家得以由此软引用和
HashMap
的组成,先是保存引用方面:以软引用的措施对1个Employee对象的实例进行引用并保存该引用到HashMap
上,key 为此雇员的
id,value为那一个目标的软引用,另一方面是取出引用,缓存中是或不是有该Employee实例的软引用,假如有,从软引用中拿到。倘使没有软引用,或然从软引用中赢得的实例是null,重新创设三个实例,并保存对那一个新建实例的软引用。

Vector和ArrayList的区别

c.强引用:若是二个对象拥有强引用,它就不会被垃圾回收器回收。即便当前内存空间不足,JVM也不会回收它,而是抛出
OutOfMemoryError
错误,使程序十三分终止。若是想中断强引用和有些对象之间的关联,可以显式地将引用赋值为null,那样一来的话,JVM在适宜的时刻就会回收该对象。

友情链接:Java中Vector和ArrayList的区别

d.软引用:在采取软引用时,假诺内存的空间充足,软引用就能三番一回被运用,而不会被垃圾回收器回收,唯有在内存不足时,软引用才会被垃圾回收器回收。


e.弱引用:具有弱引用的对象拥有的生命周期更短命。因为当 JVM
举办垃圾回收,一旦发觉弱引用对象,无论当前内存空间是或不是充足,都会将弱引用回收。但是鉴于杂质回收器是一个预先级较低的线程,所以并不一定能快速发现弱引用对象。

ExecutorService service = Executors….
ExecutorService service = new ThreadPoolExecutor()
ExecutorService service = new ScheduledThreadPoolExecutor();

f.虚引用:顾名思义,就是形同虚设,假设1个对象仅具有虚引用,那么它一定于尚未引用,在任哪天候都只怕被垃圾回收器回收。

ThreadPoolExecutor源码分析


线程池本人的情事:

Hashcode的听从,与 equal 有怎么着不一致?

 

a.同样用于鉴定3个目的是还是不是等于的,java集合中有 list 和 set 两类,其中
set不允许成分重复实现,那3个这几个不容许再一次完毕的章程,借使用 equal
去相比的话,如果存在一千个要素,你 new
多少个新的要素出来,必要去调用一千次 equal
去挨家挨户和他们相比较是或不是是同多个对象,这样会大大降低功用。hashcode实际上是回来对象的贮存地方,倘诺那几个义务上从未有过成分,就把成分直接存储在上头,即便那个地方上曾经存在成分,那么些时候才去调用equal方法与新成分进行相比较,相同的话就不存了,散列到其他地方上。

图片 9


此间写图片描述

Override和Overload的意义以及界别
a.Overload顾名思义是双重加载,它可以表现类的多态性,可以是函数里面可以有一样的函数名然则参数名、再次回到值、类型不大概平等;只怕说可以转移参数、类型、重回值但是函数名字照旧不变。
b.就是ride(重写)的意思,在子类继承父类的时候子类中可以定义某艺术与其父类有平等的名目和参数,当子类在调用这一函数时自动调用子类的格局,而父类约等于被覆盖(重写)了。
切实可前往C++中重载、重写(覆盖)的界别实例分析查看

等候任务队列和办事集:


 

抽象类和接口的界别

图片 10

a.多个类只好继续单个类,但是可以达成多少个接口

这里写图片描述

b.抽象类中得以有构造方法,接口中不可以有构造方法

线程池的主要情形锁:

c.抽象类中的全部办法并不一定假如架空的,你可以选拔在抽象类中落到实处部分为主的点子。而接口需求全数的主意都无法不是虚幻的

 

d.抽象类中可以分包静态方法,接口中不得以

图片 11

e.抽象类中得以有日常成员变量,接口中不可以

那边写图片描述

解析XML的二种方法的规律与风味:DOM、SAX、PULL

线程池的水土保持时间和分寸:

a.DOM:消耗内存:先把xml文档都读到内存中,然后再用DOM
API来访问树形结构,并获取数据。那个写起来很简短,不过很开销内存。若是多少过大,手机不够牛逼,或许手机直接死机

 

b.SAX:解析效能高,占用内存少,基于事件驱动的:尤其简明地说就是对文档举办依次扫描,当扫描到文档(document)开端与截至、成分(element)开头与为止、文档(document)停止等地点时通报事件处理函数,由事件处理函数做相应动作,然后继续同样的围观,直至文档停止。

图片 12

c.PULL:与 SAX
类似,也是依照事件驱动,大家可以调用它的next()方法,来收获下七个分析事件(就是早先文档,甘休文档,开端标签,截至标签),当远在某些成分时能够调用XmlPullParser的getAttributte()方法来赢得属性的值,也可调用它的nextText()获取本节点的值。

此处写图片描述


1.2 ThreadPoolExecutor 的其中工作规律
有了上述定义好的数据,下边来探望其中是如何兑现的 。 Doug Lea
的全方位思路总括起来就是 5 句话:

wait()和sleep()的区别

  1. 假定当前池大小 poolSize 小于 corePoolSize ,则开立异线程执行任务。
  2. 比方当前池大小 poolSize 大于 corePoolSize
    ,且等待队列未满,则跻身等待队列
  3. 若果当前池大小 poolSize 大于 corePoolSize 且小于 maximumPoolSize
    ,且等待队列已满,则创造新线程执行职分。
  4. 若是当前池大小 poolSize 大于 corePoolSize 且大于 maximumPoolSize
    ,且等待队列已满,则调用拒绝策略来处理该任务。
  5. 线程池里的每一个线程执行完义务后不会即时退出,而是会去反省下等待队列里是或不是还无线程义务需求实践,倘诺在
    keepAliveTime 里等不到新的职责了,那么线程就会脱离。

sleep来自Thread类,和wait来自Object类

Executor包结构

调用sleep()方法的进程中,线程不会自由对象锁。而 调用 wait
方法线程会放出对象锁

 

sleep睡眠后不出让系统财富,wait让出系统能源其余线程能够占据CPU

图片 13

sleep(milliseconds)需求内定1个睡眠时间,时间一到会自动提示

那里写图片描述


 

JAVA 中堆和栈的界别,说下java 的内存机制

图片 14

a.基本数据类型比变量和对象的引用都以在栈分配的

此间写图片描述

b.堆内存用来存放由new创设的目的和数组

 

c.类变量(static修饰的变量),程序在One plus载的时候就在堆中为类变量分配内存,堆中的内存地址存放在栈中

图片 15

d.实例变量:当您拔取java关键字new的时候,系统在堆中开拓并不一定是连连的长空分配给变量,是按照零散的堆内存地址,通过哈希算法换算为一长串数字以特色这一个变量在堆中的”物理地点”,实例变量的生命周期–当实例变量的引用丢失后,将被GC(垃圾回收器)列入可回收“名单”中,但并不是即时就自由堆中内存

此地写图片描述

e.局地变量:
由声明在某艺术,或某代码段里(比如for循环),执行到它的时候在栈中开辟内存,当一些变量一但剥离成效域,内存霎时释放

CopyOnWriteArrayList :
写时加锁,当添加多少个因素的时候,将原本的容器举行copy,复制出2个新的器皿,然后在新的器皿里面写,写完将来再将原容器的引用指向新的器皿,而读的时候是读旧容器的多少,所以可以拓展并发的读,但那是一种弱一致性的政策。
运用意况:CopyOnWriteArrayList适合采用在读操作远远超越写操作的景观里,比如缓存。



JAVA多态的兑现原理

Linux常用命令:cd,cp,mv,rm,ps(进程),tar,cat(查看内容),chmod,vim,find,ls

a.抽象的来讲,多态的情致就是同等新闻可以根据发送对象的不比而使用三种不一样的表现形式。(发送音讯就是函数调用)


b.达成的规律是动态绑定,程序调用的法子在运营期才动态绑定,追溯源码可以窥见,JVM
通过参数的全自动转型来找到合适的主意。

死锁的必要条件

  1. 互斥 至少有三个能源处于非共享状态
  2. 占用并等候
  3. 非抢占
  4. 巡回等待
    解决死锁,第二个是死锁预防,就是不让上边的两个标准还要建立。二是,合理分配能源。
    三是运用银行家算法,借使该进程请求的能源操作系统剩余量能够满意,那么就分配。

进度间的通信方式

  1. 管道( pipe
    ):管道是一种半双工的通讯形式,数据只好单向流动,而且只可以在装有亲缘关系的进程间拔取。进度的深情关系一般是指父子进度关系。
  2. 老牌管道 (named pipe) :
    盛名管道也是半双工的通讯方式,可是它同意无亲缘关系进度间的通讯。
    3.信号量( semophore ) :
    信号量是二个计数器,可以用来控制七个进程对共享能源的拜访。它常作为一种锁机制,幸免某进程正在访问共享财富时,其余进度也走访该资源。由此,首要作为进度间以及同样进程内不一样线程之间的共同手段。
  3. 音信队列( message queue ) :
    消息队列是由新闻的链表,存放在基础中并由音讯队列标识符标识。音讯队列克服了信号传递音信少、管道只好承载无格式字节流以及缓冲区大大小小受限等缺陷。
    5.信号 ( sinal ) :
    信号是一种相比复杂的通讯格局,用于公告接收进程某些事件早已暴发。
    6.共享内存( shared memory )
    :共享内存就是炫耀一段能被此外进度所走访的内存,那段共享内存由三个进度创建,但五个经过都可以访问。共享内存是最快的
    IPC
    格局,它是针对性其余进度间通信形式运维功用低而特意安排的。它往往与其余通讯机制,如信号量,合作使用,来贯彻进度间的一块儿和通信。
    7.套接字( socket ) :
    套解口也是一种进度间通讯机制,与任何通信机制不一样的是,它可用来分歧机器间的进度通讯。

进度与线程的分化和联系

操作系统的进程调度算法

电脑连串的层系存储结构详解


数据库事务是指作为单个逻辑工作单元执行的一比比皆是操作

 

图片 16

此间写图片描述

友情链接:数据库事务的四大特征以及业务的割裂级别


MySQL数据库优化总计

MYSQL
优化常用方法

MySQL存储引擎--MyISAM与InnoDB差异

有关SQL数据库中的范式


Hibernate的一流缓存和二级缓存的建制

Hibernate的超级缓存是由Session提供的,因而它只设有于Session的生命周期中,当程序调用save(),update(),saveOrUpdate()等方法
及调用查询接口list,filter,iterate时,如Session缓存中还不存在对应的靶子,Hibernate会把该目的加入到一流缓存中,当Session关闭的时候缓存也会消亡。
Hibernate的一流缓存是Session所安置的,不可以被卸载,也不可以拓展任何配置超级缓存接纳的是key-value的Map形式来贯彻的,在缓存实体对象时,对象的主关键字ID是Map的key,实体对象就是呼应的值。

Hibernate二级缓存:把收获的富有数据对象遵照ID放入到第贰级缓存中。Hibernate二级缓存策略,是本着于ID查询的缓存策略,删除、更新、增添数据的时候,同时创新缓存。

作者:huangqjduter
链接:https://www.jianshu.com/p/f29f52726c87
來源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

 


InnoDB存储引擎的B+树的目录算法

上学链接