Java面试复习

成员内部类可以无条件访问外部类所有的成员属性和成员方法（包括private成员）

如果要访问外部类的同名成员，需要以下方式

在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问

要创建成员内部类的对象，前提是必须存在一个外部类的对象

内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限

成员内部类不允许 static修饰 属性 和 方法

静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法

向外访问  只能直接访问static修饰属性和方法，同名用 Outter.str2。

非静态的外部属性方法需要实例化外部对象调用

可以有 main方法

不允许使用访问权限修饰符该类堆方法以外的全部隐藏，除了此方法其他的都不能访问

匿名内部类必须继承一个抽象类或者实现一个接口。

匿名内部类没有类名，因此没有构造方法。匿名内部类是唯一一种没有构造器的类

背景： 当一个方法执行完成之后，局部变量的生命周期也就结束了，而此时Thread对象的生命周期很可能还没有结束，那么在Thread的run方法中继续访问这个变量就不可能了。但是又必须需要这个变量，怎么办呢?Java采用了复制的手段来解决这个问题造器传参的方式来对拷贝进行初始化赋值。

方案∶也就说如果局部变量的值在编译期间就可以确定，则直接在匿名内部里面创建一个拷贝。如果局部变量的值无法在编译期间确定，则通过构造器传参的方式来对拷贝进行初始化赋值。

问题∶当在run方法中改变变量a的值的话，会造成数据不一致性

解决:java编译器就限定必须将入参变量限制为final变量

注意:在JDK8版本之中;,方法内部类中调用方法中的局部变量,可以不需要修饰为final,匿名内部类也是一样的，主要是JDK8之后堪加了Effectively final功能

一个内部类的对象能够访问创建它的对象的实现，包括私有数据

对于同一个包中的其他类来说，内部类能够隐藏起来

匿名内部类可以很方便的定义回调

使用内部类可以非常方便的编写事件驱动程序。

在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类

能够非常好的解决多重继承的问题

内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独

 创建对象的过程

1 首先在常量池中查找是否存在内容为"abc"字符串对象

2 如果不存在则在常量池中创建"abc"，并让str引用该对象

3 如果存在则直接让str引用该对象

 创建对象的过程

1 首先在堆中（不是常量池）创建一个指定的对象，并让str引用指向该对象。

2 在字符串常量池中查看，是否存在内容为"abc"字符串对象

3 若存在，则将new出来的字符串对象与字符串常量池中的对象联系起来（即让那个特殊的成员变量value的指针指向它）

4 若不存在，则在字符串常量池中创建一个内容为"abc"的字符串对象，并将堆中的对象与之联系起来。（有可能此时常量池中的"abc"已经被回收，所以要先创建一个内容 为"abc"的字符串对象）

str 放在栈上，用 new 创建出来的字符串对象放在堆上，而  abc 这个字面量是放在常量池中。

不安全，效率高，数组结构：增删慢；查询快

不安全，效率高，链表结构：增删快；查询慢

数组结构 安全 效率低

存取无序，元素唯一。遍历方式：增强for，Iterator，集合转数组

哈希算法 哈希结构 存取无序 元素唯一

二叉树算法可以排序

将原先table数组＋单向链表的数据结构，变更为table数组＋单向链表＋红黑树的结构.

默认初期长度为16，当往map中继续添加元素的时候，通过hash值跟数组长度取与来决定放在数组的哪个位置，如果出现放在同一个位置的时候，优先以链表的形式存放，在同一个位置的个数又达到了8个以上，如果数组的长度还小于64的时候，则会扩容数组。如果数组的长度大于等于64了的话，在会将该节点的链表转换成树。

如果某个节点的是树，同时现在该节点的个数又小于等于6个了，则会将该树转为链表

用来存放 局部变量 方法参数

1. 8种基本数据类型
   
2. 对象引用
   
3. ReturnAddress 返回 字节码地址
   

在一步细化后的栈   就是方法中的  计算操作需要的临时空间，也是栈结构（先进后出）列如：加减乘除

存储的数据与局部变量表一致含int、long、float、double、reference、returnType，操作数栈中byte、short、char压栈前(bipush)会被转为int。

记录方法被调用返回的位置

⽅法区和永久代的关系很像Java中接⼝和类的关系，类实现了接⼝，⽽永久代就是HotSpot虚拟机对虚拟机规范中⽅法区的⼀种实现⽅式。 也就是说，永久代是HotSpot的概念，⽅法区是Java虚拟机规范中的定义，是⼀种规范，⽽永久代是⼀种实现，⼀个是标准⼀个是实现，其他的虚拟机实现并没有永久带这⼀说法。

-XX:PermSize=N //⽅法区(永久代)初始⼤⼩
-XX:MaxPermSize=N //⽅法区(永久代)最⼤⼤⼩,超过这个值将会抛出
OutOfMemoryError异常:java.lang.OutOfMemoryError: PermGen

JDK 1.8 的时候，⽅法区（HotSpot的永久代）被彻底移除了（JDK1.7就已经开始了），取⽽代之是元空间，元空间使⽤的是直接内存。

-XX:MetaspaceSize=N //设置Metaspace的初始（和最⼩⼤⼩）
-XX:MaxMetaspaceSize=N //设置Metaspace的最⼤⼤⼩

为什么移除永久代？           有了元空间就不再会出现永久代OOM问题了 

字面量

符号引用

对象在新生代中 Eden 区分配。当 Eden 区没有足够空间进行分配时，虚拟机将发起一次Minor GC。

如果对象超过设置大小会直接进入老年代，不会进入年轻代

多次Miner GC后存活下来的对象

这种情况会把存活的对象部分挪到老年代，部分可能还会放在Survivor区

算法逻辑是这样的：给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加 1；当引用失效时，计数器就减 1；任何时刻计数器为 0 的对象就是不可能再被使用的

可达性分析来判定对象是否存活的。这个算法的基本思路就是通过一系列被称为 “GC Roots” 的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain）, 当一个对象到 GC Roots 没有任何引用链相连（即从 GC Roots 到这个对象不可达）时，则证明此对象是不可用的。

强引用

软引用

弱引用

虚引用

即使在可达性分析算法中不可达的对象，也并非是 “非死不可”的，这时候它们暂时处于 “缓刑” 阶段，要真正宣告一个对象死亡，至少要经历两次标记过程：如果对象在进行可达性分析后发现没有与 GC Roots 相连接的引用链，那它将会被第一次标记并且进行一次筛选，筛选的条件是此对象是否有必要执行 finalize() 方法。当对象没有覆盖 finalize() 方法，或者 finalize() 方法已经被虚拟机调用过，虚拟机将这两种情况都视为 “没有必要执行”。

　　如果这个对象被判定为有必要执行 finalize() 方法，那么这个对象将会放置在一个叫做 F-Queue 的队列之中，并在稍后由一个虚拟机自动创建的、低优先级的 Finalizer 线程去执行它。这里的 “执行” 是指虚拟机会触发这个方法，但不承诺会等待它运行结束，这样做的原因是，如果一个对象在 finalize() 方法中执行缓慢，或者发生死循环（更极端的情况），将很可能会导致 F-Queue 队列中其他对象永久处于等待，甚至导致整个内存回收系统崩溃。finalize() 方法是对象逃脱死亡命运的最后一次机会，稍后 GC 将对 F-Queue 中的对象进行第二次小规模的标记，如果对象要在 finalize() 中成功拯救自己，只要重新与引用链上的任何一个对象建立关联即可，比如在自己（this 关键字）赋值给某个类变量或者对象的成员变量，那在第二次标记时它将被移除出 “即将回收” 的集合；如果对象这个时候还没有逃脱，那基本上它就真的被回收了。

GC分为两个阶段，标记和清除。首先标记所有可回收的对象，在标记完成后统一回收所有被标记的对象。同时会产生不连续的内存碎片。碎片过多会导致以后程序运行时需要分配较大对象时，无法找到足够的连续内存，而不得已再次触发GC。

将内存按容量划分为两块，每次只使用其中一块。当这一块内存用完了，就将存活的对象复制到另一块上，然后再把已使用的内存空间一次清理掉。这样使得每次都是对半个内存区回收，也不用考虑内存碎片问题，简单高效。缺点需要两倍的内存空间。

也分为两个阶段，首先标记可回收的对象，再将存活的对象都向一端移动，然后清理掉边界以外的内存。此方法避免标记-清除算法的碎片问题，同时也避免了复制算法的空间问题。
一般年轻代中执行GC后，会有少量的对象存活，就会选用复制算法，只要付出少量的存活对象复制成本就可以完成收集。而老年代中因为对象存活率高，没有额外过多内存空间分配，就需要使用标记-清理或者标记-整理算法来进行回收。

现在的商用虚拟机的垃圾收集器基本都采用"分代收集"算法，这种算法就是根据对象存活周期的不同将内存分为几块。一般将java堆分为新生代和老年代，这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。

在新生代中，每次收集都有大量对象死去，所以可以选择复制算法，只要付出少量对象的复制成本就可以完成每次垃圾收集。而老年代的对象存活几率时比较高的，而且没有额外的空间对它进行分配担保，就必须选择“标记-清除”或者“标记-整理”算法进行垃圾收集

比较老的收集器，单线程。收集时，必须暂停应用的工作线程，直到收集结束。

多条垃圾收集线程并行工作，在多核CPU下效率更高，应用线程仍然处于等待状态。

CMS收集器是缩短暂停应用时间为目标而设计的，是基于标记-清除算法实现，整个过程分为4个步骤，包括：
初始标记（Initial Mark）
并发标记（Concurrent Mark）
重新标记（Remark）
并发清除（Concurrent Sweep）
其中，初始标记、重新标记这两个步骤仍然需要暂停应用线程。初始标记只是标记一下GC Roots能直接关联到的对象，速度很快，并发标记阶段是标记可回收对象，而重新标记阶段则是为了修正并发标记期间因用户程序继续运作导致标记产生变动的那一部分对象的标记记录，这个阶段暂停时间比初始标记阶段稍长一点，但远比并发标记时间段。
由于整个过程中消耗最长的并发标记和并发清除过程收集器线程都可以与用户线程一起工作，所以，CMS收集器内存回收与用户一起并发执行的，大大减少了暂停时间。

G1收集器将堆内存划分多个大小相等的独立区域（Region），并且能预测暂停时间，能预测原因它能避免对整个堆进行全区收集。G1跟踪各个Region里的垃圾堆积价值大小（所获得空间大小以及回收所需时间），在后台维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的Region，从而保证了再有限时间内获得更高的收集效率。
G1收集器工作工程分为4个步骤，包括：
初始标记（Initial Mark）
并发标记（Concurrent Mark）
最终标记（Final Mark）
筛选回收（Live Data Counting and Evacuation）
初始标记与CMS一样，标记一下GC Roots能直接关联到的对象。并发标记从GC Root开始标记存活对象，这个阶段耗时比较长，但也可以与应用线程并发执行。而最终标记也是为了修正在并发标记期间因用户程序继续运作而导致标记产生变化的那一部分标记记录。最后在筛选回收阶段对各个Region回收价值和成本进行排序，根据用户所期望的GC暂停时间来执行回收。

工作内存（高速缓存 变量副本）

作用于当前  实例对象本身  加锁，进入同步代码前要获得当前对象实例的锁

作用于当前  类对象本身 加锁，进入同步代码前要获得当前类对象的锁。本类的其他静态方法都要等该方法释放锁

指定加锁对象（实例对象、类），对给定对象加锁，进入同步代码库前要获得给定对象的锁

获取锁

 如果当前线程未被中断，则获取锁，可以响应中断 

返回绑定到此 Lock 实例的新 Condition 实例

仅在调用时锁为空闲状态才获取该锁，可以响应中断

如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁

释放锁

Lock readLock() //返回用于读取操作的锁
Lock writeLock() //返回用于写入操作的锁  

这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());

每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

LinkedBlockingQueue   核心线程和最大线程是相同的

这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

核心线程和最大都是一个 LinkedBlockingQueue  

（1）如果没有空闲的线程执行该任务且当前运行的线程数少于corePoolSize，则添加新的线程执行该任务。

（2）如果没有空闲的线程执行该任务且当前的线程数等于corePoolSize同时阻塞队列未满，则将任务入队列，而不添加新的线程。

（3）如果没有空闲的线程执行该任务且阻塞队列已满同时池中的线程数小于maximumPoolSize，则创建新的线程执行任务。

（4）如果没有空闲的线程执行该任务且阻塞队列已满同时池中的线程数等于maximumPoolSize，则根据构造函数中的handler指定的策略来拒绝新的任务。

MySQL使用 limit分页公式   Oracle 使用 伪列ROWNUM

MySQL 可以设置自增，Oracle使用序列

MYSQL日期字段分DATE和TIME两种，ORACLE日期字段只有DATE，包含年月日时分秒信息，用当前数据库的系统时间为SYSDATE, 精确到秒

不支持水平分片架构，水平分片的设计当中，这种方法显然不能保证全局唯一。

子主题

ALTER TABLE table_name ADD UNIQUE (column); -- 创建唯一索引
ALTER TABLE table_name ADD UNIQUE (column1,column2); -- 创建唯一组合索引

 ALTER TABLE table_name ADD INDEX index_name (column);-- 创建普通索引
ALTER TABLE table_name ADD INDEX index_name(column1, column2, column3);-- 创建组合索引
-- 只有在查询条件中使用了创建索引时的第一个字段，索引才会被使用。使用组合索引时遵循最左前缀集合。

ALTER TABLE table_name ADD FULLTEXT (column); -- 创建全文索引

它生成的bean完全由自己管理，生命周期可以自己控制
传统的方式没有任何容器去管理它的生命周期，完全是靠回收机制回收

是Spring里面最低层的接口，提供了最简单的容器的功能，只提供了实例化对象和拿对象的功能；IOC容器的基本实现，一般不会直接使用。

BeanFactory在启动的时候不会去实例化Bean，中有从容器中拿Bean的时候才会去实例化；

应用上下文，继承BeanFactory接口，它是Spring的一各更高级的容器，提供了更多的有用的功能；开发使用

ApplicationContext在启动的时候就把所有的Bean全部实例化了。它还可以为Bean配置lazy-init=true来让Bean延迟实例化；

ClassPathXmlApplicationContext：可以加载类路径下的配置文件，要求配置文件必须在类路径下面

FileSystemXmlApplicationContext：可以加载磁盘任意路径下的配置文件

AnnotationConfigApplicationContext：用于读取注解创建容器

运行期，生成字节码，再加载到虚拟机中，JDK是利用反射原理，CGLIB使用了ASM原理。

初始化的时候，已经将目标对象进行代理，放入到spring 容器中

要看条件，如果实现了接口的类，是使用jdk。如果没实现接口，就使用cglib。

哪些方法可以被增强，这些方法就是连接点

实际被增强的方法就是切入点

实际增强的逻辑部分称为通知     有before,after,afterReturning,afterThrowing,around

把增强动作应用到切入点的过程

前置通知：在我们执行目标方法之前运行(@Before)

后置通知：在我们目标方法运行结束之后 ,不管有没有异常(@After)

异常通知：在我们的目标方法出现异常后运行(@AfterThrowing)

最终通知：在我们的目标方法正常返回值后运行(@AfterReturning)

环绕通知：动态代理, 需要手动执行joinPoint.procced()(其实就是执行我们的目标方法执行之前相当于前置通知, 执行之后就相当于我们后置通知(@Around)

@Aspect  定义切面类

@Component  加载到IOC容器

定义切入点函数

@Pointcut注解进行定义切入点函数  表达式只用一次   相同接入点

启动@aspectj的自动代理支持  <aop:aspectj-autoproxy />  spring boot @EnableAspectJAutoProxy

自动按照类型注入，只要容器中有唯一的一个bean类型和要注入的变量匹配，就可以注入成功。
如果ioc容器中没有任何bean类型和变量匹配，则注入失败。
如果IOC容器中有多个bean匹配时，根据先按照类型　再　使用变量名称去匹配

做用：在按照类中注入的基础之上 在同过名称注入。它在给类成员注入时不能单独使用。但是在给方法注入时可以
Qualifier 组合 Autowired 使用

直接按照bean的Id注入 可以单独使用

属性：value用于指定数据的值 它可以使用spring的SpEl (就是Spring的el表达式)

条件注入

启动类

子主题

服务提供者启动时，会通过 Eureka Client 向 Eureka Server 注册信息，Eureka Server 会存储该服务的信息，Eureka Server 内部有二层缓存机制来维护整个注册表

服务消费者在调用服务时，如果 Eureka Client 没有缓存注册表的话，会从 Eureka Server 获取最新的注册表

Eureka Client 通过注册、心跳机制和 Eureka Server 同步当前客户端的状态。

@EnableEurekaServer

spring-cloud-starter-eureka

spring-boot-starter-actuator

集中式 LB

进程式

RoundRobinRule：轮询（默认）

RandomRule：随机

RetryRule：重试（先按照轮询规则获取服务，如果获取服务失败则在指定时间内进行重试）

AvailabilityFilteringRule：会先过滤掉由于多次访问故障而处于断路器状态的服务，还有并发的连接数量超过阈值的服务，然后对剩余的服务列表按照轮询策略进行访问；

WeightedResponseTimeRule：根据平均响应时间计算所有服务的权重，响应时间越快的服务权重越大被选中的概率越大。刚启动时如果统计信息不足，则使用RoundRobinRule（轮询）策略，等统计信息足够，会切换到WeightedResponseTimeRule；

BestAvailableRule：会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务；

ZoneAvoidanceRule：复合判断Server所在区域的性能和Server的可用性选择服务器；

在配置类中注入相应的Bean

编写自定义的轮询规则

Ribbon中的IRule自定义原则

程序bug导致服务不可用，或者运行缓慢

缓存击穿，导致调用全部访问某服务，导致down掉 

访问量的突然激增。 

硬件问题，这感觉只能说是点背了

横向扩充

限流

熔断

服务熔断 在服务端实现

启动类：@EnableCircuitBreaker   添加对熔断器的配置

服务异常的方法可以注释：@HystrixCommand 然后指定处理方式

当某个异常条件被触发就直接熔断整个服务，而不是一直等到此服务超时

服务降级在客户端实现：当线程达到阈值的时候就启动服务降级,如果其他请求继续访问就直接返回fallback的默认值

1.implements FallbackFactory 写一个服务处理工厂

2.@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)
和feign一起使用

创建监控页面：

将服务加入监控中：@EnableCircuitBreaker //添加对熔断器的配置
在服务端：添加一个servlet bean

站在系统的角度，解决企业系统间的通信问 题，把原先散乱、无规划的系统间的网状结构，梳理成 规整、可治理的系统间星形结构，这一步往往需要引入 一些产品，比如 ESB、以及技术规范、服务管理规范； 这一步解决的核心问题是【有序】

站在功能的角度，把业务逻辑抽象成 可复用、可组装的服务，通过服务的编排实现业务的 快速再生，目的：把原先固有的业务功能转变为通用 的业务服务，实现业务逻辑的快速复用；这一步解决 的核心问题是【复用】

站在企业的角度，把企业职能抽象成 可复用、可组装的服务；把原先职能化的企业架构转变为服务化的企业架构，进一步提升企业的对外服务能力；“前面两步都是从技术层面来解决系统调用、系统功能复用的问题”。第三步，则是以业务驱动把一个业务单元封装成一项服务。这一步解决的核心问题是【高效】

我们必须接受自动化文化，自动化部署和自动化测试方案必须要在微服务实施开始前就规划好

协调者询问参与者事务是否执行成功，参与者发回事务执行结果。

如果事务在每个参与者上都执行成功，事务协调者发送通知让参与者提交事务；否则，协调者发送通知让参与者回滚事务。

 同步阻塞 所有事务参与者在等待其它参与者响应的时候都处于同步阻塞状态，无法进行其它操作。

 单点问题 协调者在 2PC 中起到非常大的作用，发生故障将会造成很大影响。特别是在阶段二发生故障，所有参与者会一直等待状态，无法完成其它操作。 

 数据不一致 在阶段二，如果协调者只发送了部分 Commit 消息，此时网络发生异常，那么只有部分参与者接收到 Commit 消息，也就是说只有部分参与者提交了事务，使得系统数据不一致。 

太过保守 任意一个节点失败就会导致整个事务失败，没有完善的容错机制。