ms

时间 2019-12-02

原文原文链接

1. 分布式锁html

http://www.hollischuang.com/archives/1716java

http://www.cnblogs.com/green-hand/p/5687611.htmlmysql

分布式的CAP理论告诉咱们“任何一个分布式系统都没法同时知足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance），最多只能同时知足两项。nginx

咱们须要的分布式锁应该是怎么样的？（这里以方法锁为例，资源锁同理）git

能够保证在分布式部署的应用集群中，同一个方法在同一时间只能被一台机器上的一个线程执行。github

这把锁要是一把可重入锁（避免死锁）web

这把锁最好是一把阻塞锁（根据业务需求考虑要不要这条）算法

有高可用的获取锁和释放锁功能spring

获取锁和释放锁的性能要好sql

ZK分布式锁（使用临时有序节点。顺序值由master节点来分配？）
在 ZooKeeper 中，节点类型能够分为持久节点（PERSISTENT ）、临时节点（EPHEMERAL），以及时序节点（SEQUENTIAL ），具体在节点建立过程当中，通常是组合使用，能够生成 4 种节点类型：持久节点（PERSISTENT），持久顺序节点（PERSISTENT_SEQUENTIAL），临时节点（EPHEMERAL），临时顺序节点（EPHEMERAL_SEQUENTIAL）；

Redis分布式锁（setNX + getSet）

BASE理论是指基本可用（Basically Available）、软状态（ Soft State）、最终一致性（ Eventual Consistency）。

当网络因为发生异常状况，致使分布式系统中部分节点之间的网络延时不断增大，最终致使组成分布式系统的全部节点中，只有部分节点之间可以正常通讯，而另外一些节点则不能----咱们将这个现象称为网络分区。当网络分区出现时，分布式系统会出现局部小集群，在极端状况下，这些局部小集群会独立完成本来须要整个分布式系统才能完成的功能，包括对数据的事物处理，这就对分布式一致性提出了很是大的挑战

2. 数据库

内连、左连、右连、全连

oracle minus 集合操做

in(, , , ) exist

select * from (
select 1 as id, 'a' as name from dual
union
select 2 as id, 'b' as name from dual
) t1
left join
(
select 1 as id, 'a' as name from dual
union
select 3 as id, 'c' as name from dual
) t2
on t1.id = t2.id

结果：
       ID    NAME ID    NAME
    1    a    1    a
    2    b

View Code

3. BIO、NIO

http://www.javashuo.com/article/p-cjevdyzn-a.html

http://www.importnew.com/22623.html

4. 短链接、长链接
dubbo（长链接 netty, socket）
HTTP的长链接和短链接本质上是TCP长链接和短链接。HTTP属于应用层协议，在传输层使用TCP协议，在网络层使用IP协议。IP协议主要解决网络路由和寻址问题，TCP协议主要解决如何在IP层之上可靠的传递数据包，使在网络上的另外一端收到发端发出的全部包，而且顺序与发出顺序一致。TCP有可靠，面向链接的特色。
http://www.cnblogs.com/0201zcr/p/4694945.html

OSI中的层功能 TCP/IP协议族

7 应用层文件传输，电子邮件，文件服务，虚拟终端 TFTP，HTTP，SNMP，FTP，SMTP，DNS，Telnet

6 表示层数据格式化，代码转换，数据加密没有协议

5 会话层解除或创建与别的接点的联系没有协议

4 传输层提供端对端的接口 TCP，UDP

3 网络层为数据包选择路由 IP，ICMP，RIP，OSPF，BGP，IGMP

2 数据链路层传输有地址的帧以及错误检测功能 SLIP，CSLIP，PPP，ARP，RARP，MTU

1 物理层以二进制数据形式在物理媒体上传输数据 ISO2110，IEEE802，IEEE802.2

5. spring scope
默认是单例模式，即scope="singleton"。另外scope还有prototype、request、session、global session做用域。

6. netty
NIO
零拷贝
粘包：经过协议约定，好比指定数据包的size来切分消息。

为何会发生TCP粘包、拆包
1. 应用程序写入的数据大于套接字缓冲区大小，这将会发生拆包。
2. 应用程序写入数据小于套接字缓冲区大小，网卡将应用屡次写入的数据发送到网络上，这将会发生粘包。
3. 进行MSS（最大报文长度）大小的TCP分段，当TCP报文长度-TCP头部长度>MSS的时候将发生拆包。
4. 接收方法不及时读取套接字缓冲区数据，这将发生粘包。

如何处理粘包、拆包，一般会有如下一些经常使用的方法：
1. 使用带消息头的协议、消息头存储消息开始标识及消息长度信息，服务端获取消息头的时候解析出消息长度，而后向后读取该长度的内容。
2. 设置定长消息，服务端每次读取既定长度的内容做为一条完整消息，当消息不够长时，空位补上固定字符。
3. 设置消息边界，服务端从网络流中按消息编辑分离出消息内容，通常使用‘\n’。
4. 更为复杂的协议，例如楼主最近接触比较多的车联网协议808,809协议。

https://www.hchstudio.cn/article/2018/d5b3/

netty 题目 http://www.javashuo.com/article/p-qdxknhvh-o.html

7. logback MDC 在spring异步@Async使用线程池时，值取到旧值问题
http://forum.spring.io/forum/spring-projects/container/129674-async-with-log4j-s-mdc
https://moelholm.com/2017/07/24/spring-4-3-using-a-taskdecorator-to-copy-mdc-data-to-async-threads/ (sprint boot 中使用这个)

8. stream <--> channel + buffer

9. 数据库事务隔离级别 (http://www.cnblogs.com/fjdingsd/p/5273008.html)
　　read uncommitted --> read committed --> repeatable read --> Serializable
　　脏读　　　　　　　　　不可重复读　　　　　　幻读

MySQL 默认 repeatable read
https://dev.mysql.com/doc/refman/5.6/en/innodb-transaction-isolation-levels.html#isolevel_repeatable-read
https://dev.mysql.com/doc/refman/5.6/en/innodb-consistent-read.html
Oracle 默认 read committed

10. 雪崩
http://www.2cto.com/os/201508/433330.html
1。缓存Cache在A服务上，找不到缓存去B服务查库
雪崩可能缘由：a. A服务挂了，重启时缓存所有被清空，致使流量所有到B服务
b. B服务挂了致使缓存过时，B重启后流量所有到B

2。缓存Cache在A服务上，找不到Cache经过A去查库

3。缓存Cache单独部署 + A服务

关键词：雪崩、缓存击穿、过载保护、缓存预热、限流、服务降级

11. vilatile http://www.importnew.com/24082.html

Java内存模型：主内存、工做内存

并发编程的三大概念：原子性，有序性，可见性

volatile保证可见性。实现原理：经过向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写会到系统内存。
一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰以后，那么就具有了两层语义：
1）保证了不一样线程对这个变量进行操做时的可见性，即一个线程修改了某个变量的值，这新值对其余线程来讲是当即可见的。
2）禁止进行指令重排序。

volatile不能确保原子性
解决方案：能够经过synchronized或lock，进行加锁，来保证操做的原子性。也能够经过AtomicInteger。

volatile保证有序性。实现原理：Lock前缀指令实际上至关于一个内存屏障（也成内存栅栏），它确保指令重排序时不会把其后面的指令排到内存屏障以前的位置，也不会把前面的指令排到内存屏障的后面。

volatile的变量在被操做的时候不会产生working memory的拷贝，而是直接操做main memory，固然volatile虽然解决了变量的可见性问题，但没有解决变量操做的原子性的问题，这个还须要synchronized或者CAS相关操做配合进行。

12. Java泛型（http://www.importnew.com/24029.html）
T、 泛型通配符（?）、 ? extends T、 ? super T、 类型擦除

“Producer Extends” – 若是你须要一个只读List，用它来produce T，那么使用 ? extends T。
“Consumer Super” – 若是你须要一个只写List，用它来consume T，那么使用 ? super T。
若是须要同时读取以及写入，那么咱们就不能使用通配符了。

如何阅读过一些Java集合类的源码，能够发现一般咱们会将二者结合起来一块儿用，好比像下面这样：

public class Collections {
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (int i=0; i<src.size(); i++)
            dest.set(i, src.get(i));
    }
}

13. 正向代理反向代理（http://blog.csdn.net/m13666368773/article/details/8060481）

正向代理：位于客户端和原始服务器(origin server)之间的服务器，客户端必需要进行一些特别的设置才能使用正向代理。容许客户端经过它访问任意网站而且隐藏客户端自身

反向代理：对外都是透明的，对于客户端而言它就像是原始服务器，访问者并不知道本身访问的是一个代理，而且客户端不须要进行任何特别的设置。反向代理还能够为后端的多台服务器提供负载平衡，或为后端较慢的服务器提供缓冲服务。（nginx反向代理，动静分离）

14. 高可用（HA）架构
http://aokunsang.iteye.com/blog/2053719 浅谈web应用的负载均衡、集群、高可用(HA)解决方案

http://zhuanlan.51cto.com/art/201612/524201.htm 互联网架构“高可用”
http://www.blogjava.net/ivanwan/archive/2013/12/25/408014.html LVS/Nginx/HAProxy负载均衡器的对比分析

高可用HA(High Availability)是分布式系统架构设计中必须考虑的因素之一，它一般是指，经过设计减小系统不能提供服务的时间。

方法论上，高可用是经过冗余(集群化) + 自动故障转移(failover)来实现的。

虚拟IP（VirtualIP/VIP）: 实现原理主要是靠TCP/IP的ARP协议。 http://blog.csdn.net/whycold/article/details/11898249

常见的Tomcat集群方案：ngnix+tomcat；lvs+ngnix+tomcat；(lvs负责集群调度，nginx负责静态文件处理，tomcat负责动态文件处理[最优选择])。

15. 分布式环境下的黏性Session 和非黏性Session

16. 六大设计原则 http://blog.csdn.net/cq361106306/article/details/38708967

http://www.javashuo.com/article/p-dttkmyhb-b.html

单一职责原则
里氏替换原则
依赖倒置原则
接口隔离原则
迪米特法则
开闭原则

单一职责原则告诉咱们实现类要职责单一；
里氏替换原则告诉咱们不要破坏继承体系；
依赖倒置原则告诉咱们要面向接口编程；
接口隔离原则告诉咱们在设计接口的时候要精简单一；
迪米特法则告诉咱们要下降耦合。
而开闭原则是总纲，他告诉咱们要对扩展开放，对修改关闭。

17. 浏览器与服务器交互的过程

http://www.cnblogs.com/xdp-gacl/p/3734395.html

18. 线程的状态和生命周期

http://blog.csdn.net/lonelyroamer/article/details/7949969

19. java.util.concurrent.atomic.AtomicXXX
其内部实现不是简单的使用synchronized，而是一个更为高效的方式CAS (compare and swap) + volatile和native方法，从而避免了synchronized的高开销，执行效率大为提高。

CAS指令在Intel CPU上称为CMPXCHG指令，它的做用是将指定内存地址的内容与所给的某个值相比，若是相等，则将其内容替换为指令中提供的新值，若是不相等，则更新失败。

从内存领域来讲这是乐观锁，由于它在对共享变量更新以前会先比较当前值是否与更新前的值一致，若是是，则更新，若是不是，则无限循环执行(称为自旋锁)，直到当前值与更新前的值一致为止，才执行更新。

20. 线程池

ThreadPoolExecutor、AbstractExecutorService、ExecutorService和Executor

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) 各个参数的含义

Java经过Executors提供四种线程池，分别为：
newCachedThreadPool建立一个可缓存线程池，若是线程池长度超过处理须要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 建立一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 建立一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 建立一个单线程化的线程池，它只会用惟一的工做线程来执行任务，保证全部任务按照指定顺序(FIFO, LIFO, 优先级)执行。

http://ifeve.com/java-threadpool/

http://www.javashuo.com/article/p-hcakyhag-a.html

http://www.importnew.com/19011.html

21. zookeeper 选举算法

zookeeper 如何保证一致性

http://blog.csdn.net/liuhaiabc/article/details/70771322

22. 安全

XSS ------ Filter进行特殊字符(<script>)过滤
CSRF ------- 更新数据时，使用POST请求而且携带token
SQL注入 ------- Filter进行特殊字符(;)过滤

23. Socket三次握手、四次挥手

http://www.cnblogs.com/Jessy/p/3535612.html

首先，咱们要知道TCP是全双工的，即客户端在给服务器端发送信息的同时，服务器端也能够给客户端发送信息。而半双工的意思是A能够给B发，B也能够给A发，可是A在给B发的时候，B不能给A发，即不一样时，为半双工。单工为只能A给B发，B不能给A发；或者是只能B给A发，不能A给B发。
http://www.javashuo.com/article/p-swvqtzls-b.html 为何不是两次握手，而是三次
http://www.javashuo.com/article/p-mhmgxyoa-bv.html

24. 分布式 id 生成器

百度uid生成器：https://github.com/baidu/uid-generator

美团点评生成器：http://tech.meituan.com/MT_Leaf.html

25. 消息队列的顺序性和重复消费问题

消息队列的顺序性：消息投递到同一个消息服务器的同一个消息队列Q1，只有一个消费者消费Q1

重复消息：消费者接口幂等

RocketMQ支持事务消息：http://blog.csdn.net/u012422829/article/details/70248286
（作本地事务前发送prepared消息，本地事务完成后发送确认消息。若是确认消息发送失败，RocketMQ会检查prepared消息，而后回调业务系统确认业务是否成功）

事务消息：解决业务作成功了，发送消息失败的问题（可靠MQ）。
也能够经过在业务系统中建一张消息发送队列表来解决，业务事务与发送消息放在同一个事务中

26. Redis、Memcache 一致性hash算法

一致性 hash 解决的问题：
在缓存场景中，当集群中加入 1 台机器后，这台机器要可以分摊其余机器的流量和缓存数据，简单的取模方式去路由和普通 hash 环是行不通的，一致性 hash 引入了虚拟节点，就能够作到了
新增节点对数据的影响比例为：（一致性 hash 的节点是均匀分布的）
3台 --> 4台 = 1/4
n-1台 --> n台 = 1/n

27. happen-before规则

出现线程安全的问题通常是由于主内存和工做内存数据不一致性和重排序致使的

在执行程序时，为了提升性能，编译器和处理器经常会对指令进行重排序。

对于主内存和工做内存的“脏读”问题，能够经过同步机制（控制不一样线程间操做发生的相对顺序）来解决或者经过volatile关键字使得每次volatile变量都可以强制刷新到主存，从而对每一个线程都是可见的。

针对编译器重排序，JMM的编译器重排序规则会禁止一些特定类型的编译器重排序；针对处理器重排序，编译器在生成指令序列的时候会经过插入内存屏障指令来禁止某些特殊的处理器重排序。

JMM实际上是在遵循一个基本原则：只要不改变程序的执行结果（指的是单线程程序和正确同步的多线程程序），编译器和处理器怎么优化都行。

28. Dubbo的Consumber 和 Provider 在不一样的线程组中，为何可使用 ThreadLocal（RpcContext）来保存微服务的上下文？
由于 Consumber 调用 Provider 时，会将 RpcContext 往 Provider 端传递，而且在 Provider 端进行反序列化，这样就能够作到了。

29. Socket 调用能够像普通的方法调用同样准确的拿到返回值吗？
不能，由于接收返回消息时，不能确切的知道返回的是哪一个请求的结果。因此，须要在发出请求时，将请求打上标记（惟一id），返回结果时，带上这个标记。就像 Dubbo 同样。
（短链接是能够的，nio长链接就可能会串）
那 http 1.1 也是基于 tcp ，当 keep-alive=true（长链接）时，为何就能够作到在同一个 channel 通道中发多个请求时，返回结果不串呢？
由于：http 1.1 协议规定 server 发送返回报文的顺序必须与接收请求的顺序相同。这样先发的请求就能先收到返回，在不须要知道请求 id 的状况下，也能正确处理响应了

30. dubbo 按权重随机算法 https://blog.csdn.net/danny_idea/article/details/82258367

31. spring 如何解决循环依赖？
spring 经过对 bean 的早期引用（early reference）进行缓存，在预到循环依赖的bean 初始化时，取早期引用缓存进行注入
http://www.imooc.com/article/34150

深度分析：
http://www.javashuo.com/article/p-smkruniq-nt.html
http://www.javashuo.com/article/p-stnwfmxu-nt.html
https://blog.csdn.net/f641385712/article/details/93475774