首页  思维导图  详情

Java高级知识储备-持续更新...

2021-05-10 16:05:04   108  举报





AI智能生成

为你推荐

查看更多



更新客户

java全集持续更新维护

Java并发编程知识体系(最全最完整)持续更新

Java高级工程师知识储备，持续更新...

java

面试题

作者其他创作

大纲/内容

饿汉式

懒汉式(线程安全)

静态内部类

枚举

双重校验锁

单例模式使用场景

单例模式

简单工厂模式

工厂方法模式

抽象工厂模式

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

工厂模式

继承模板方法设计模式

静态代理

JDK动态代理

CGLib动态代理

动态代理

代理模式

观察者模式

装饰者模式

设计模式

CPU核心数，线程数

CPU时间片轮转机制

进程调度算法

进程

线程调度算法

线程

优缺点

协成

高并发编程的意义、好处和注意事项

并发和并行的区别

并行parallellism

并发concurrency

基础概念

创建并启动线程四种方式

理解中断

如何安全的终止线程

启动和终止线程

线程常用方法

线程的状态

线程的优先级

Demon线程

线程再认识

对象锁

类锁

synchronized

volatile

`ThreadLocal`为什么容易内存泄漏

为什么使用ThreadLocal为弱引用而不是强引用

ThreadLocal

了解`volatile`关键字不？能否解释下，然后这和`synchronized`有什么大的区别

线程间的共享

等待和通知的标准范式

notify和notifyAll应该用谁

等待和通知机制

Join方法

调用yield() 、sleep()、wait()、notify()等方法对锁有何影响？

线程间协作

画下线程的状态转换图和这些转换过程常用的`api`也标记下

线程状态

2、Java中线程基础

1、线程基础、线程之间的共享和协作

使用多线程场景

在`Java`中可以有哪些方法来保证线程安全

平时多线程用的挺多的，写出`3`条你遵循的多线程最佳实践

多线程

Hashtable

Vector

Stack

同步工具类包装Collections.synXXX

同步容器

put流程图

put流程

ConcurrentHashMap

CopyOnWriteArrayList

ConcurrentSkipListMap

ConcurrentSkipListSet

并发容器

使用场景

ArrayBlockingQueue

LinkedBlockingQueue

PriorityBlockingQueue

DelayQueue

SynchronousQueue

LinkedTransferQueue

LinkedBlockingDeque

ArrayBlockingQueue和LinkedBlockingQueue区别

超链接

阻塞型

它怎么实现线程安全的

ConcurrentLinkedQueue

非阻塞型

阻塞队列和非阻塞队列区别

线程安全的Queue队列

类的线程安全

无状态

让类不可变

更多......

如何做到类的线程安全

原因

表现

检测和解决

死锁

活锁

影响性能的因素

减少锁的竞争

多线程程序性能和思考

线程不安全引发的问题

如何让双重检查锁定安全

懒汉式

线程安全的单例模式

并发安全

什么是分而治之？

工作密取

使用的标准范式

Fork/Join

countdownlatch和join方法的区别

CountDownLatch作用、应用场景和实战

CyclicBarrier作用、应用场景和实战

CountDownLatch和CyclicBarrier辨析

Semaphore作用、应用场景和实战

Exchange作用、应用场景和实战

Callable、Future和FutureTask

线程的并发工具类

CAS的原理

ABA问题

开销

只能保证一个共享变量的原子操作

CAS的问题

基本类型

数组

引用

带版本戳

原子操作类的使用

原子操作类

原子操作CAS

Lock接口、核心方法和使用

Lock接口和synchronized的比较

可重入锁

锁的公平和非公平

ReentrantLock

ReadWriteLock接口

ReentrantReadWriteLock

用处

用Lock和Condition实现等待通知

Condition接口

显式锁

了解LockSupport

什么是AQS？学习它的必要

AQS使用方式和其中的设计模式

AQS同步方式

了解其中的方法

实现一个自己的独占锁

AQS中的数据结构

节点在同步队列中的增加和移出

独占式同步状态获取与释放

共享式同步状态获取与释放

等待队列

await方法

signal方法

Condition分析

深入源码

源码

锁的可重入

公平和非公平锁

你可以说清`ReentrantLock`和`synchronized`的差别不

了解ReentrantLock的实现

设计一个缓存组件或提高`Collection`的并发性

了解ReentrantReadWriteLock的实现

知道`ReentrantReadWriteLock`吗？和`ReentrantLock`有啥不同

AbstractQueuedSynchronizer

显式锁和AQS(AbstractQueuedSynchronizer)

使用

基本思想

Hash

位运算

预备知识

构造方法

如何定位

get方法

put方法

扩容

jdk1.7

jdk1.8

实现

了解什么是SkipList

ConcurrentSkipListMap等

写时复制容器

其他并发容器

概念

并发编程里面解决生产消费者模型你知道哪几种方式

生产者消费者模式

常用方法

·ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列。·LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列。·PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。·DelayQueue：一个使用优先级队列实现的无界阻塞队列。·SynchronousQueue：一个不存储元素的阻塞队列。·LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。·LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。

常用阻塞队列辨析

延时队列实战

阻塞队列实现原理

阻塞队列

什么是线程池？为什么要用线程池？

实现一个我们自己的线程池

线程池的创建

提交任务

关闭线程池

JDK中的线程池

线程池工作机制

合理配置线程池

含义

FixedThreadPoolSingleThreadExecutorCachedThreadPoolWorkStealingPool

内部方法辨析

ScheduledThreadPoolExecutor

newFixedThreadPool

newCachedThreadPool

newSingleThreadExecutor

newScheduledThreadPool

系统为我们预定义的线程池

线程池不允许使用 `Executors` 去创建，要通过 `ThreadPoolExecutor`的方式原因

`ThreadPoolExecutor`构造函数里面的参数你是否掌握，能否解释下各个参数的作用

Executor框架

优点

CompletionService

线程池的5中状态和切换

线程池

带来的问题

现代计算机物理上的内存模型

JVM对Java内存模型的实现

类型

依赖性

as-if-serial

重排序带来的问题

内存屏障

临界区

重排序

定义

规则

Happens-Before

概念和深入理解

重排序规则

内存屏障插入策略

内存语义的实现

volatile的内存语义

锁的内存语义

final的内存语义

volatile的实现原理

`jdk1.6`后进行了优化，你知道哪些大的变化

synchronized的实现原理

Java内存模型（JMM）

JMM和底层实现原理

编发编程三要素

悲观锁

乐观锁

公平锁

非公平锁

设计一个简单的可重入锁

设计一个简单的不可重入锁

不可重入锁

自旋锁

共享锁

互斥锁

写个多线程死锁的例子

那上面的例子怎么解决死锁，优化下代码

`Synchronized`锁的升级

分段锁

行锁

表锁

锁的取舍

各种锁

并发编程工具类

排序算法

HASH算法

如何保证KEY的安全性

AES

MD5

对称加密

RSA

非对称算法

加密算法

算法

数据类型分类以及在`JVM`所占的字节大小

&按位与操作

|按位或操作

&和&&区别

|和||的区别

`2`<<`3`

用最有效率的方法计算`2`乘以`8`

位运算符和短路运算符

加减实现

异或运算实现

实现两个变量交换

异或运算

i++和++i

算术运算符

==和equal方法的区别

关系运算符

运算符

数据类型和运算

抽象

封装

继承

多态

形式参数

实际参数

值传递和引用传递

找出某目录下的所有子目录以及子文件并打印到控制台上

递归

`Overload`和`Override`的区别

接口是否可以继承接口？接口是否支持多继承？类是否支持多继承？接口里面是否可以有方法实现?

接口

抽象类

类的关键作用域

default关键字

关键字

serialVersionUID用于控制序列化版本是否兼容

JDK为什么设计为一定要实现serializable接口才能序列化

serializable接口

内部类

类

实例对象类型

无状态对象

有状态对象

对象

对象的`hashCode()`和`equals()`使用场景

强引用，软引用，弱引用和虚引用

类和对象

面向对象的四大特性

`try-catch-finally`中`return`执行顺序

从一个`txt`文本里面，拷贝里面的内容到另外一个`txt`文本里面

`try-with-resource`的使用

try-catch-finally

异常处理

异常

反射

`String str = new String(\"1\");`创建了几个对象

比较字符串是否相等

字符串拼接比较

HashCode

String

String、StringBuffer、StringBuilder区别和使用场景

字符串

如果需要保证线程安全，`ArrayList`应该怎么做，用有几种方式

ArrayList

LinkedList

`Vector`和`ArrayList`、`LinkedList`联系和区别？分别的使用场景?

List

HashSet

LinkedHashSet

TreeSet

`HashSet`和`TreeSet`区别

Set

Collection

HashMap

HashTable

LinkedHashMap

TreeMap

WeakHashMap

IdentityHashMap

`HashMap`和`Hashtable`的区别

`HashMap`和`TreeMap`应该怎么选择，使用场景

常见`Map`的排序规则是怎样的

如果需要线程安全，且效率高的`Map`，应该怎么做

为什么`Collections.synchronizedMap`后是线程安全的

Map

`Set`和`Map`的关系

集合

类库

http常用状态码

组成

GET 和 POST 有什么区别

缺点

特点

为什么TCP客户端最后还要发送一次确认呢

三次握手

为什么客户端最后还要等待2MSL

四次挥手

为什么建立连接是三次握手，关闭连接确是四次挥手呢

如果TCP已经建立了连接，但是客户端突然出现故障了怎么办

TCP

功能

UDP

TCP和UDP区别

HTTP

JAVA SE基础

堆内存中的数据是线程共享的吗

堆

栈

内存结构

堆/Perm 区不断增长

Minor GC(Yang GD)和Full GC

内存溢出现象

命令：jmap -heap pid 展示pid的整体堆信息

命令： jmap -histo pid 展示class的内存情况

dump 将内存使用的详细情况输出到文件

jmap命令

分析 dump 文件和堆占用情况

定位具体的类和相关代码的调用过程

排查内存泄漏过程

如何排查内存泄漏

调优命令

调优工具

调优

为什么会出现脏读？

你说`volatile`可以避免指令重排，能否解释下什么是指令重排

知道`happens-before`吗，能否简单解释下

jvm

JVM

单向链表

单向循环链表

双向链表

双向循环链表

链表

数据结构

HashMap链表插入方式

1.7链表头插-1.8改为尾插

为什么1.8扩容的时候为啥一定必须是2的多少次幂

`ReHash`重哈希

扩容机制

HashMap数据结构

看过`HashMap`源码吗，介绍下你了解的`HashMap`

能否解释下什么是`Hash`碰撞？常见的解决办法有哪些，`hashmap`采用哪种方法

`HashMap`底层是数组+链表+红黑树，为什么要用这几类结构呢

红黑树结构

为啥选择红黑树而不用其他树，比如二叉查找树，为啥不一直开始就用红黑树，而是到`8`的长度后才变换

put核心流程

为什么采用哈希码与运算(&) （数组长度-1）计算数组下标

1.8HashMap为什么在计算数组下标前，需对哈希码进行二次处理：扰动处理

HashMap什么情况下出现链表环

如何判断链表有环

为什么HashMap默认设置为16

了解`ConcurrentHashMap`吗？为什么性能比`hashtable`高，说下原理？

`jdk1.7`和`jdk1.8`里面`ConcurrentHashMap`实现的区别有没了解

说下`ConcurrentHashMap`的`put`的核心逻辑（`JDK8`以上版本）

查询效率高

插入顺序

LRU缓存

访问顺序

链表的排序选择

LinkedHashMap原理分析

String中hashcode方法为什么选择31这个质数而不选择更大的质数呢

hashcode值溢出

String中HashCode方逻辑

JDK源码

postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)：1. 自定义方法

postProcessBeanFactory(beanFactory)

postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)：1. 自定义的方法；

postProcessBeanDefinitionRegistry(registry)

invokeBeanFactoryPostProcessors(beanFactory)

refresh()

BeanDefinitionPostProcessor：1. bean的后置处理器；2. 实现这个接口的bean自定义bean加载数据；3. 注册其他bean；4. 先执行postProcessBeanDefinitionRegistry，后执行postProcessBeanFactory

postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)：1. 创建业务bean时，会调用自己实现的postProcessBeanFactory方法；

BeanFactoryPostProcessor：1. bean的后置处理器；2. 实现这个接口的bean自定义bean加载数据；

initPropertySources()：1. 初始化一些属性设置；子类自定义个性化的属性设置方法

getEnvironment().validateRequiredProperties()：1. 检验属性的合法性等

this.earlyApplicationEvents = new LinkedHashSet<>()：1. 保存容器中的一些早期的事件

prepareRefresh()：1. 刷新容器前的预处理；

refreshBeanFactory()：1. 刷新或创建beanFactory

getBeanFactory()：1. 将刚生成的beanFactory返回（空的beanFactory）

obtainFreshBeanFactory()：1. 获取beanFactory实例；2. 创建的beanFactory好多属性没有值，只有一些默认的值；

beanFactory.setBeanClassLoader(getClassLoader())：1. 设置BeanFactory的类加载器

beanFactory.setBeanExpressionResolver：1. 支持相关的表达式语言的解析

beanFactory.ignoreDependencyInterface：1. 设置忽略的自动装配接口

beanFactory.registerResolvableDependency：1. 注册可以解析的自动装配：我们能直接在任何组件中自动注入 BeanFactory ApplicationContext

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this))：1. 添加监听检测的处理器

if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME))：1. 注册环境变量相关bean

prepareBeanFactory(beanFactory)：1. beanFactory预准备工作

postProcessBeanFactory(beanFactory)：1. BeanFactory准备工作完成后进行的后置处理器工作；2. 通过子类重写这个方法来在BeanFactory创建并预准备完成以后进一步的设置；至此BeanFactory创建和预准备完成

invokeBeanFactoryPostProcessors(beanFactory)：1. 执行BeanFactoryPostProcessor后置处理器方法2. 自定义实现两个接口BeanFactoryPostProcessor，BeanDefinitionRegistryPostProcessor；3. 先执行`BeanDefinitionRegistryPostProcessor`；4. 优先执行实现了`PriorityOrdered`的处理器；5. 获取处理器bean对象；

if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME))：1. 判断容器中是否有messageSource的ID，类型是MessageSource组件；

new DelegatingMessageSource()：1. 如果没有MessageSource组件就会创建并注册到IOC容器中；

initMessageSource()：1. 标签国际化资源，初始化messgeresource组件（国际化功能：消息解析，消息绑定）

getBeanFactory()：1. 获取beanFactory；

if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME))：1. 判断有没有applicationEventMulticaster对象；

new SimpleApplicationEventMulticaster(beanFactory)：1. 创建事件派发器；

initApplicationEventMulticaster()：1. 初始化事件派发器

onRefresh()：1. 留给子容器（子类）：子类可以重写这个方法，在容器刷新的时候自定义逻辑；

getApplicationEventMulticaster().multicastEvent(earlyEvent)：1. 事件派发；

registerListeners()：1. 给容器中将所有项目里的ApplicationListener注册进来；

getSingleton(beanName)：1. 先获取map缓存中保存的实例bean；

this.alreadyCreated.add(beanName)：1. 进行标记；

markBeanAsCreated(beanName)：1. 标记当前bean已经被创建了；

mbd.getDependsOn()：1. 获取当前bean依赖的其他bean，如果存在就从容器中获取依赖的bean；

if (bp instanceof InstantiationAwareBeanPostProcessor)：1. 后置处理器的处理；

getBean(beanName)

getMergedLocalBeanDefinition(beanName)：1. 获取bean的定义信息，依次进行创建和初始化；

beanFactory.preInstantiateSingletons()：1. 单实例bean(非懒加载)初始化；

finishBeanFactoryInitialization(beanFactory)：1. 给容器中将所有项目中单实例bean(非懒加载)初始化；

`finishRefresh()`

new AnnotationConfigApplicationContext(Cap12MainConfig.class)：1. 由于AnnotationConfigApplicationContext extends GenericApplicationContext

`SpringIOC`源码以及后置处理器如何工作的

`Spring`中有哪些后置处理器

后置处理器

IOC容器源码

默认的构造方法

静态工厂方法

实例工厂方法

容器创建对象的三种方式

Spring Bean的声明周期

IOC容器Inversion of Control，即“控制反转”

检测是否存在循环依赖

`Spring`是如何解决循环依赖的

循环依赖

DI-Dependency Injection，即“依赖注入”

markBeanAsCreated(beanName)

org.springframework.aop.framework.CglibAopProxy#getProxy(java.lang.ClassLoader)

org.springframework.aop.framework.JdkDynamicAopProxy#getProxy(java.lang.ClassLoader)

getProxy(classLoader)

createAopProxy()

getProxy(getProxyClassLoader())

创建实现Ordered接口的bean(AnnotationAwareAspectJAutoProxyCreator)：1. 开启@EnableAspectJAutoProxy注解时，会把AOP核心处理器对象添加到IOC容器中

registerBeanPostProcessors(beanFactory)：后置处理器的创建，这些处理器用于拦截其他bean的创建。重点关注AnnotationAwareAspectJAutoProxyCreator后置处理器的创建

addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors())：1. 找到切面类的所有通知方法2. 切面表达式3. 切入点等信息

findCandidateAdvisors()

sortAdvisors(eligibleAdvisors)：1. 切面类的通知方法倒序排序，目的是定义执行顺序

preInstantiateSingletons()

finishBeanFactoryInitialization(beanFactory)：1. 创建业务非懒加载单实例bean，以Calculator类为例

org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class<?>...)

this.advised.getTargetSource()：1. 获取目标对象

执行器链

chain.isEmpty() && Modifier.isPublic(method.getModifiers())：1. 如果没有拦截器链，直接执行目标方法;拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）

this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex)：1. 拿到拦截点对象

mi.proceed()：1. 执行目标方法

invoke(this)：1. 会调用各自拦截器的invoke方法2. MethodBeforeAdviceInterceptor@2234为最后一个拦截器，进入invoke方法后会执行执行目标方法

invokeJoinpoint()：1. 倒叙执行拦截器的invoke方法；2. 执行源目标方法；

proceed()：1. 每个拦截器处理对应的方法2. 如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；3. 链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；拦截器链的机制，保证通知方法与目标方法的执行顺序；

org.springframework.aop.framework.CglibAopProxy.DynamicAdvisedInterceptor#intercept：1. aop代理对象执行业务处理时的处理方法2. 拦截目标的执行

AOP源码分析

registerAutoProxyCreatorIfNecessary(registry)

AutoProxyRegistrar组件：1. 给容器中注册一个 InfrastructureAdvisorAutoProxyCreator 组件，该组件利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），代理对象执行方法利用拦截器链进行调用

transactionAttributeSource()：1. 事务增强器要用事务注解的信息，AnnotationTransactionAttributeSource解析事务注解

org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor：1. 事务增强器

org.springframework.transaction.interceptor.TransactionAttributeSource：1. 解析事务注解类，包含事务信息

org.springframework.transaction.interceptor.TransactionInterceptor：1. 事务拦截器；2. 保存了事务属性信息，事务管理器；3. 是一个 MethodInterceptor

org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration#transactionAdvisor：1. 给容器中注入事务增强器BeanFactoryTransactionAttributeSourceAdvisor；1. 给容器中注入事务拦截器TransactionInterceptor

ProxyTransactionManagementConfiguration组件，创建方式同上

invokeBeanFactoryPostProcessors(beanFactory)：1. 导入组件2. 动态代理创建组件和AOP的AnnotationAwareAspectJAutoProxyCreator核心组件创建方式一样；

getTransactionAttributeSource()：1. 获取事务相关属性

determineTransactionManager(txAttr)：1. 获取事务管理器组件，如果事先没有添加指定任何transactionmanger最终会从容器中按照类型获取一个PlatformTransactionManager；

invokeJoinpoint()

invocation.proceedWithInvocation()

txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus())：1. 事务回滚

cleanupTransactionInfo(txInfo)：1. 清空事务信息

commitTransactionAfterReturning(txInfo)：1. 提交sql

org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction

org.springframework.transaction.interceptor.TransactionInterceptor#invoke

proceed()

org.springframework.aop.framework.CglibAopProxy.DynamicAdvisedInterceptor#intercept：1. 执行拦截器链，执行业务方法时被拦截，进入此方法

声明式事务源码分析：1. @EnableTransactionManagement开启事务管理功能；2. 该注解会利用org.springframework.transaction.annotation.TransactionManagementConfigurationSelector类导入两个组件：AutoProxyRegistrarProxyTransactionManagementConfiguration

AOP面向切面编程

spring为什么默认使用JDK动态代理

Spring IOC存储的实例为什么默认是单实例的

并发情况下Spring Bean是否安全

自动装配注解

主要有哪些模块

spring常用注入bean方式

Spring

MyBatis

框架

主键

外键

脏读

不可重复读

幻读

事务的四大特性

mysql常用的功能索引有哪些

B+Tree

HASH

索引方法

FULLTEXT

数据索引类型

使用索引的优缺点有哪些，使用应该注意些什么

聚集索引

非聚集索引（辅助索引）

物理索引

逻辑索引

举例说明各种索引

覆盖索引

左侧索引原则

为什么索引能提高查询速度

索引介绍

索引

UTF8Bmb4区别

字符集