Java知识体系最强总结(2020版)

避免每次都重新搜索，不断修正链接，寻求最好的答案。

1.lock解析

2.分代垃圾回收器，回收机制

3.不错的面试题

4.从没有看到这么通俗易懂的sping的解析

6. 锁

--》非安全 数据结构(map list 堆 栈)，是因为

1)其数据的操作方法，不是原子性的(多行代码，某个线程没有运行结束，其他线程进来了)

2)另外就是多线程同时插入同一个位置的覆盖问题，以及一个插入，一个删除，其实都是插入和删除方法的非原子性。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

--》synchronized使用方法

1)synchronized加在实例方法(没有static修饰的)，实例锁，获取这个实例对象锁即可，同一个线程访问一个加synchronized的实例方法活动锁之后，可以反问另外的加了synchronized的实例方法

2)synchronized加在静态方法，需要获取class锁方可继续执行。

9.threadlocal

1)表面上，一个threadlocal为，每一个线程thread维护了一个map，key就是thead，value是threadlocal.set()方法的参数。如果在来另外一个threadlocal同样的维护了另外的一个map

2)但是实际上是每一个线程(thread)，有一个成员变量(ThreadlocalMap threadlocals)，该成员变量维护了一个table，存储了一个或者多个threadlocal，下标用threadlocal算出

15.一致性哈希

16.雪崩效应

17.rabbitmq高可用

rabbitmq不是分布式的

没有扩展可言，rabbitMQ是集群，不是分布式的，所以当某个Queue负载过重，我们并不能通过新增节点来缓解压力，因为所以节点上的数据都是相同的，这样就没办法进行扩展了

可以通过HAproxy来做负载均衡，通过不同的请求打到不同的小集群，在HA模式下，让数据不在所有rabbitmq节点上流通。

对于镜像集群而言，当某个queue负载过重，可能会导致集群雪崩，那么如何来减少集群雪崩呢？我们可以通过HA的同步策略来实现

19.java堆内存溢出 定位

20.拦截器、过滤器区别()

1.拦截器是基于java的反射机制的,而过滤器是基于函数回调。

2.拦截器不依赖与servlet容器,过滤器依赖与servlet容器。

3.拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用。

4.拦截器可以访问action上下文、值栈里的对象,而过滤器不能访问。

5.在action的生命周期中,拦截器可以多次被调用,而过滤器只能在容器初始化时被调用一次。

21 shiro

22.  MQ

https://www.cnblogs.com/xiapu5150/p/9927323.html  mq比较

https://www.jianshu.com/p/07b2169bef49    消息积压在mq队列里面怎么办

23.秒杀相关

缓存商品列表，事先设置好商品库存，存在redis中，秒杀请求进来，修改库存，重新放入缓存中，设置成功，异步处理接下来的业务。比如用队列。

有关Tomcat提高并发量，性能优化的问题(已解决

https://blog.csdn.net/wepwq70900/article/details/88528120?depth_1-utm_source=distribute.wap_relevant.none-task&utm_source=distribute.wap_relevant.none-task

支撑1万并发请求的秒杀架构设计

https://blog.csdn.net/HouFangWuLu/article/details/81131328?depth_1-utm_source=distribute.wap_relevant.none-task&utm_source=distribute.wap_relevant.none-task

每秒处理10万订单的支付架构 乐视集团

https://blog.csdn.net/weixin_34256074/article/details/94729450?depth_1-utm_source=distribute.wap_relevant.none-task&utm_source=distribute.wap_relevant.none-task

某项目从3000并发到10W并发的优化记录

https://blog.csdn.net/Mr_Yanghao/article/details/84561944?depth_1-utm_source=distribute.wap_relevant.none-task&utm_source=distribute.wap_relevant.none-task

java解决高并发之数据库连接池配置

https://blog.csdn.net/chenkun_321/article/details/88653713?depth_1-utm_source=distribute.wap_relevant.none-task&utm_source=distribute.wap_relevant.none-task

https://blog.csdn.net/shengqianfeng/article/details/86656143   秒杀设计

24.分布式事务

它是将本地事务和发消息放在了一个分布式事务里，保证要么本地操作成功成功并且对外发消息成功，要么两者都失败，开源的RocketMQ就支持这一特性，具体原理如下：

1、A系统向消息中间件发送一条预备消息

2、消息中间件保存预备消息并返回成功

3、A执行本地事务

4、A发送提交消息给消息中间件

通过以上4步完成了一个消息事务。对于以上的4个步骤，每个步骤都可能产生错误，下面一一分析：

步骤一出错，则整个事务失败，不会执行A的本地操作

步骤二出错，则整个事务失败，不会执行A的本地操作

步骤三出错，这时候需要回滚预备消息，怎么回滚？答案是A系统实现一个消息中间件的回调接口，消息中间件会去不断执行回调接口，检查A事务执行是否执行成功，如果失败则回滚预备消息

步骤四出错，这时候A的本地事务是成功的，那么消息中间件要回滚A吗？答案是不需要，其实通过回调接口，消息中间件能够检查到A执行成功了，这时候其实不需要A发提交消息了，消息中间件可以自己对消息进行提交，从而完成整个消息事务

————————————————

版权声明：本文为CSDN博主「心香壹瓣」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/yinghuabmf/article/details/81976676

https://blog.csdn.net/u010412301/article/details/78410933  TCC分布式事务最终一致性

25.spring

https://blog.csdn.net/a745233700/article/details/89307518   Spring bean 的注入方式

https://www.cnblogs.com/leskang/p/6101368.html  springmvc 请求原理

https://www.cnblogs.com/wuzhenzhao/p/10945450.html   springmvc 请求原理

26.线程池

https://blog.csdn.net/qq_20009015/article/details/100569976    如果线程池在执行任务的时候异常了，怎么办

https://www.cnblogs.com/htyj/p/10848646.html   线程创建的三种方式

27.mysql

https://www.jianshu.com/p/d7665192aaaf  mysql优化原理

https://blog.csdn.net/qq_25940921/article/details/82183093  二叉树及其平衡二叉树

MySQL多线程完成10万条数据插入数据库

https://blog.csdn.net/y_bccl27/article/details/91980036?depth_1-utm_source=distribute.wap_relevant.none-task&utm_source=distribute.wap_relevant.none-task

https://www.jianshu.com/p/70d94a8f6491  mysql读写分离之maxscale

http://www.ttlsa.com/mysql/maxscale-install-read-write-split/  读写分离

28.高可用

Keepalived之——Keepalived + Nginx 实现高可用 Web 负载均衡

https://blog.csdn.net/l1028386804/article/details/72801492?depth_1-utm_source=distribute.wap_relevant.none-task&utm_source=distribute.wap_relevant.none-task

29.redis

https://blog.csdn.net/ioteye/article/details/90736630  Redis数据同步机制

https://blog.csdn.net/dazou1/article/details/88088223  分布式锁原理与实现

https://www.cnblogs.com/liumz0323/p/10508062.html  redis api

30.线程

https://blog.csdn.net/shengqianfeng/article/details/86656143  wait notify 消费者生产者模式

https://www.jianshu.com/p/25e243850bd2?appinstall=0   你真的懂wait、notify和notifyAll吗

31 并发工具包

https://www.jianshu.com/p/a101ae9797e3   并发工具CountDownLatch、CyclicBarrier、Semapphore使用详解

https://blog.csdn.net/qq_39241239/article/details/87030142   深入理解CyclicBarrier原理

32.容器技术

https://www.cnblogs.com/lingboweifu/p/11896945.html  docker面试题

33.鉴权

http://www.ruanyifeng.com/blog/2019/04/oauth_design.html     阮一峰的网络日志OAuth 2.0 的一个简单解释

https://blog.csdn.net/JustKian/article/details/91577409  Spring Security浅析

https://blog.csdn.net/wsll581/article/details/83272856  Spring Security

https://blog.csdn.net/NDKHBWH/article/details/100074764  Spring Security

34.springcloud

1)eureka

--》自我保护机制：

服务提供者，如果是30秒发送一次心跳给eurekaserver，一分钟是两次，如果一分钟没有收到两次算一次失败？如果15分钟之内，失败次数大于等于15*0.85=12.75=13，eurekaserver启动自我保护机制，不提出该服务提供者吗？当它收到的心跳数重新恢复到阈值以上时(小于13？)，退出自我保护。

--》消费者获取服务提供者上的资源是不经过eureka的。

Eureka Client会拉取、更新和缓存Eureka Server中的信息。即使所有的Eureka Server节点都宕掉，服务消费者依然可以使用缓存中的信息找到服务提供者。

35.性能调优