1.各个方面知识
很全面的知识总结（推荐）： https://www.yuque.com/crow/simpread/23aba84d-73b3-4950-9621-bf511b2d088a#cf651462
很全面的java知识总结2：https://www.nowcoder.com/discuss/447742?type=5&channel=1011&source_id=discuss_terminal_discuss_jinghua
牛客面经：https://www.nowcoder.com/discuss/396949?type=all&order=time&pos=&page=2
阿里五轮：https://www.jianshu.com/p/c8a271448dcd
字节四面：https://www.jianshu.com/p/745757d373e9
redis+多线程+全家桶：https://www.jianshu.com/p/0f81f4a6577b
java : https://blog.csdn.net/qq_39922867/article/details/104866582
网络：
（1）post请求&get请求区别https://blog.csdn.net/wx1528159409/article/details/83419666，相比安全在1.浏览器会记录get的请求信息，post则不会。 2.服务器上access_log会记录get的请求，因此暴露的可能性更大。
（2）浏览器输入url地址：https://www.cnblogs.com/kongxy/p/4615226.html
（3）tcp&udp: https://www.cnblogs.com/fundebug/p/differences-of-tcp-and-udp.html
https://blog.csdn.net/qq_38950316/article/details/81087809
https://www.cnblogs.com/pengmn/p/10836784.html
tcp面向连接，而udp不是，故从效率上看，udp要高，但缺点是不能保证可靠性。另外底层udp基于数据报，tcp基于字节流
（4）bio、nio、aio、五中IO模型： https://www.jianshu.com/p/8a9eeb238704 & https://www.cnblogs.com/diegodu/p/6823855.html &https://www.cnblogs.com/yanguhung/p/10145755.html
（5）http与tcp的区别： https://www.cnblogs.com/hejiao123/p/10689823.html
（6）https协议的请求过程: https://blog.csdn.net/xifeijian/article/details/54667989
（7）http协议与https协议的区别:https://www.cnblogs.com/wangyue99599/p/8459734.html
（8）tcp流量控制跟拥塞控制：https://blog.csdn.net/dangzhangjing97/article/details/81008836 & 快重传快恢复：https://www.cnblogs.com/liuwanqiu/p/10812433.html
（9）tcp三次握手和四次挥手的过程(为什么不可以两次握手，为什么握手要三次，挥手需要四次)：https://blog.csdn.net/qq_38950316/article/details/81087809 & https://www.cnblogs.com/pengmn/p/10836784.html
（10）tcp/ip协议 （TCP/IP协议说一下吧，各层有什么协议，分别什么作用说一下）：tcp/ip 协议是用于网络通信的一套协议集合．TCP/IP 被认为是一个四层协议，1) 网络接口层: 主要是指物理层次的一些接口,比如电缆等．2) 网络层: 提供独立于硬件的逻辑寻址,实现物理地址与逻辑地址的转换．在 TCP / IP 协议族中，网络层协议包括 IP 协议（网际协议），ICMP 协议（ Internet 互联网控制报文协议），以及 IGMP 协议（ Internet 组管理协议）.3) 传输层: 为网络提供了流量控制,错误控制和确认服务. 在TCP / IP 协议族中有两个互不相同的传输协议： TCP（传输控制协议）和 UDP（用户数据报协议）.4) 应用层: 为网络排错,文件传输,远程控制和 Internet 操作提供具体的应用程序 https://blog.csdn.net/yulyu/article/details/69062288 & https://blog.csdn.net/yulyu/article/details/69062288
(11)http1.0 与http1.1 的区别：https://www.cnblogs.com/heluan/p/8620312.html
(12)什么是拆包粘包？为什么会出现？:https://blog.csdn.net/john1337/article/details/102806307 & https://blog.csdn.net/ailunlee/article/details/95944377
（13）arp协议： https://www.cnblogs.com/csguo/p/7527303.html
(14) icmp协议 & traceroute：https://blog.csdn.net/weikanghuan/article/details/50825762/ &https://blog.csdn.net/a772304419/article/details/104203000
（15）tcp的面向连接怎么理解（面向连接和面向无连接区别）：https://blog.csdn.net/daaikuaichuan/article/details/83060178
（16）电脑连上了路由器，有一个ip,本地ip+端口往外可以建立多少个tcp连接：https://www.jianshu.com/p/c77e7026531a
（17）域名管理的根服务器有多少个？常见顶级域名有哪些？：13个，比如cn,com,net,edu,org
（18）请求头包括哪些信息：general: request url,request method,status,remote address. request header: Refer,Uesr Agent,Cookie; response header: content-type,accept-ranges,Date,Connection. refer作用：https://www.jianshu.com/p/1a6abab212ed
（19）https协议仍然存在安全问题，能举个例子吗？：https://www.cnblogs.com/imteck4713/p/12016313.html，ssl证书可以自己生成，有些网站是用的自己生成的证书，我们正常点击继续访问。有些是钓鱼网站用的也是https，继续访问可能就有可能暴露自己的信息。
（20）http请求包，http1.0，1.1，2.0：
操作系统：
（1）线程与进程：https://www.cnblogs.com/zhuzhu2016/p/5804875.html、https://www.jianshu.com/p/2dc01727be45 (推荐)（定义、资源共享、健壮性、通信难度 ）
（2）进程的调度算法：https://www.cnblogs.com/szitcast/p/10927375.html
（3）进程通信方式 & 区别 & 什么是事件：https://www.cnblogs.com/zgq0/p/8780893.html & https://www.ibm.com/developerworks/cn/linux/l-ipc/ & https://www.cnblogs.com/vamei/archive/2012/10/10/2715398.html & https://blog.csdn.net/liyue98/article/details/80112246
(4) 进程五态-jvm七态：https://blog.csdn.net/Alexshi5/article/details/88045763
（5）动态链接库和静态链接库：https://www.cnblogs.com/keanuyaoo/p/3359815.html
(6)poll & epoll : https://blog.csdn.net/yuanbinquan/article/details/46461165
(7) 进程间同步与互斥的区别，线程同步的方式 ：https://blog.csdn.net/weixin_41413441/article/details/80548683
（8）什么是操作系统？（操作系统的功能和作用）：https://zhidao.baidu.com/question/185897420.html
（9）分页，分段，段页的区别 & 操作系统面试知识总结：https://www.cnblogs.com/xymqx/p/4442329.html https://blog.csdn.net/gui951753/article/details/79489748 https://blog.csdn.net/jxh_123/article/details/40296175（比较短） https://blog.csdn.net/wangrunmin/article/details/7967293 （分页分段概念）
（10）用户态和内核态区别：https://www.cnblogs.com/maxigang/p/9041080.html （运行级别、访问内存、访问外围设备，好处是实现有限资源的集中管理、减少资源使用的 冲 突、防止用户程序读取其他用户程序的内存数据）
（11）锁的四个要素：https://blog.csdn.net/jxh_123/article/details/40296175
(12)共享内存和信号量的区别：信号量只有pv操作，是一个计数器，用于线程之间的简单的通信；共享内存则是一块连续内存空间，传递信息多，通信效率高；
（13）守护进程&僵尸进程&孤儿进程：https://www.cnblogs.com/wangwust/p/11254630.html& https://blog.csdn.net/linkedin_35878439/article/details/81288889 & https://www.cnblogs.com/Anker/p/3271773.html
（14）进程通信中的事件：
（15）文件描述符和File*关系：https://blog.csdn.net/pan_xi_yi/article/details/106359304
（16）解释型语言和非解释型语言：https://www.jianshu.com/p/2de3e4f4871e
linux命令：https://blog.csdn.net/Butterfly_resting/article/details/89668744
（17）不用linux的epoll，自己可以实现epolll吗？epoll管理什么资源：可以自己实现，管理用户连接资源 （socket对象）
（18）linux文件系统组织结构：
（19）协程：https://www.jianshu.com/p/6dde7f92951e
（20）怎么理解IO多路复用？https://www.jianshu.com/p/dd5b6893bef7
（21）信号量和信号：https://www.cnblogs.com/yulibostu/articles/9778636.html
(22)一个线程创建有哪几个部分？：https://zhidao.baidu.com/question/132198039.html
（23）原码和补码的作用：https://zhidao.baidu.com/question/588564780479617005.html （用反码进行减法，用补码解决0存在两种编码的问题。最后用补码进行负数运算）
(24)linux内核分为哪几个组成部分/哪几个系统：https://blog.csdn.net/weibo1230123/article/details/79776066
（25)nginx负载均衡方式：轮询、加权、iphash，最小连接，第三方库（最小响应时间，urlhash）：https://www.cnblogs.com/1214804270hacker/p/9325150.html
linux操作系统知识：https://www.cnblogs.com/fengdejiyixx/p/11414657.html
（26）awk 如何找出一份日志（有id，时间、ip地址）中访问次数最多的10个ip以及显示对应的时间？
（27）负载均衡策略？200多个机器如何获知某一台机器挂了？当机器重启时，打到这个机器上的流量会怎样？
（28）ps -ef ps -aux各个参数表示什么意思？https://www.cnblogs.com/dion-90/articles/9048627.html & https://blog.csdn.net/a12345555555/article/details/72770789
（29）查看磁盘使用的情况、内存、cpu呢？
（30）
mysql：
（1）四大特性、脏读、不可重复读、幻读：https://www.cnblogs.com/fjdingsd/p/5273008.html
（2）三大范式：https://www.cnblogs.com/linjiqin/archive/2012/04/01/2428695.html
（3）having 用在什么场景：https://blog.csdn.net/whathellll/article/details/80765020?utm_source=blogxgwz4 & https://blog.csdn.net/HD243608836/article/details/88826647
（4）exist和in的区别 ：https://www.bbsmax.com/A/gAJGwDa3JZ/ & https://www.cnblogs.com/xiaoxiong-kankan/p/7928153.html
（5）不建议使用 like '%sss' 这样的模糊查询：https://www.cnblogs.com/acm-bingzi/p/mysqlLike.html
（6）mysql 连接查询类型：左连接、右连接，内连接（等值连接）：
（7）group by 和distinct区别：https://www.cnblogs.com/yangfeizbj/p/5446516.html
（8）事务特性的实现原理：https://www.jianshu.com/p/f3de03854a68 & https://blog.csdn.net/star1210644725/article/details/96829608
（9）事务的隔离级别以及对应解决的问题，以及实现原理：https://www.jianshu.com/p/f3de03854a68 & https://blog.csdn.net/star1210644725/article/details/96829608
（10）描述一下存储过程：https://www.cnblogs.com/chenliyang/p/6553068.html &https://www.runoob.com/w3cnote/mysql-stored-procedure.html
(11)UNION:https://www.cnblogs.com/huangminwen/p/9261298.html
（12）mysql与oracle区别：主键，分页，事务，双引号，
wqkj为啥要用oracle: 并发性更好、热备份技术更加成熟、逻辑备份不需要锁表、性能诊断更加成熟、更加稳定安全：https://blog.csdn.net/star1210644725/article/details/91899117 模糊的回答：稳定性、安全性
（13）mysql引擎与myisam引擎区别：https://www.cnblogs.com/y-rong/p/5309392.html & https://www.cnblogs.com/llzhang123/p/9239682.html
(14)mysql如何分库分表优化？：https://www.cnblogs.com/wnwn/p/12330880.html 开启慢查询：https://www.cnblogs.com/woods1815/p/11829659.html
（15）为啥要用自增的主键id：https://cloud.tencent.com/developer/article/1499836
（16）数据库引擎，两种引擎的区别和实现原理：
（17）给两张表 100行和50行，left join后有多少行？如果有一行重复呢：要看on的关系，一对一还是一对多或者多对多。：https://zhuanlan.zhihu.com/p/85856388 & https://developer.aliyun.com/article/718897 （做链接on where区别)
（18）全文索引的原理：https://www.cnblogs.com/wxzhe/p/9955534.html
（19）b树 b+树,b+树比b树的优势是？：https://www.cnblogs.com/xueqiuqiu/articles/8779029.html & https://blog.csdn.net/weixin_42228338/article/details/97684517
（20）什么是事务：https://zhuanlan.zhihu.com/p/58378395
（21）SQL优化一般是怎么做的？：看mysql优化笔记
（22）explain查看关键字：https://blog.csdn.net/dennis211/article/details/78170079
（23）mysql索引树叶子节点怎么在磁盘上存储的？每一个树的节点都是4k大小，而4k大小正是由操作系统规定的页大小，然后在磁盘上以磁盘块在扇形区域进行存储，每次取数据都会根据局部性原理，取出一整页数据。
（24）mysql设计时varchar(10) 10是字符还是字节？字符、字节区别是啥？：https://blog.csdn.net/sauzny/article/details/84600645
数据结构
动态规划：hdu-1003 连续子序列和 hdu-1087 （可不连续）最大递增子序列和
排序： 最小的K个数（堆排序），数组中的逆序对（归并排序）
（1）hashmap解决冲突的方式：https://blog.csdn.net/yeiweilan/article/details/73412438
（2）霍夫曼树的应用：哈夫曼编码
（3）10w条数据如何找出前一百条频繁数据：https://blog.csdn.net/yzr1183739890/article/details/56682266
（4）动态规划和分治的区别：https://www.cnblogs.com/ZeroTensor/p/10550071.html
（5）登录系统中要快速找出最频繁登录的N个客户，如何设计一个数据结构来实现这个目标?时间复杂度要尽可能低：LFU
（6）100亿个整数，内存足够，如何找到中位数？内存不足，如何找到中位数？：https://www.cnblogs.com/hapjin/p/5769087.html &https://segmentfault.com/a/1190000019890273#comment-area （其中桶排序、分治可以最好o(n)，归并堆o(nlogn)）,bitmap显然是不可行的，因为存在一个数出现多次，基数排序什么鬼。int类型的数不重复，2^32*32 ( 有2^32个数，每个有4字节32位，) = 2^37 = (1024)*(1024)*(1024)*2^7 byte = 2^37 = (1024)*(1024)*(1024)*2^4 字节（除以8） = (1024)*(1024)*2^4 K = (1024)*2^4 M = 2^4 G = 16G，也就是无重复的int整型数据最多也就16G. bitmap的压缩能力是一个数变成了32个数，扩大能力是 2^5方。
也就是说，用bitmap可以表示16*32G的数据（不考虑超范围）。
(7)LRU:
（8）一台普通PC，2G内存，要求处理一个包含40亿个不重复并且没有排过序的无符号的int整数，给出一个整数，问如果快速地判断这个整数是否在文件40亿个数据当中？：https://www.cnblogs.com/hapjin/p/5769087.html
（9）说一下B+树,B树的分裂原理：
(10)迪杰斯特拉算法、最小生成树算法：
java ：
（1）HashMap源码分析，Hashmap添加元素的过程？ ：https://www.jianshu.com/p/2e2a18d02218 https://www.cnblogs.com/zhaojj/p/7805376.html
https://zhuanlan.zhihu.com/p/91636401 https://www.jianshu.com/p/2e2a18d02218 （有图）
（2）为什么hashmap长度是2的整次幂？答：（为了实现索引的均匀分布，减少哈希碰撞以及加快计算）因为2的整数次幂-1 二进制全是1，进行与运算可以快速获取槽位置，如果length长度为15，减1之后为14，则二进制最后一位为0，与h相与的结果是：无论h的二进制最后一位为偶数或者奇数，必定相与出偶数的结果。因此为了保障所有位相与后的二进制1是均匀的，长度应该设置为2的整数次幂。
hashmap为什么key的hashcode右移16位就可以增加随机性了？因为hashcode接下来要与表长-1进行相与，表长-1通常不大（比如15，前4位位1，后面28位都是0），而与hashcode的高位相与后必定都是0，所以右移16位（32位的一半），让高16位也参与进来，增加高16位的特性。这就比如你第1次遥骰子是6，让你遥两次都是6的概率就会更小，提高随机性，降低哈希冲突。
java 中jvm的状态转化：https://blog.csdn.net/Alexshi5/article/details/88045763
（3）有序集合：https://www.cnblogs.com/gjmhome/p/11520551.html
（4）垃圾收集器（gc）（写的挺深入）：https://www.jianshu.com/p/76959115d486 https://www.jianshu.com/p/b48f3ae30f23 & https://www.cnblogs.com/chongaizhen/p/11112742.html
(5) volatile 、final ：https://www.jianshu.com/p/bf158fbb2432 &（4）
(6)线程安全集合和线程不安全集合：https://www.cnblogs.com/huangdabing/p/9249233.html (学习java的 数组、vector等都挺好)
（7）sleep和wait区别: https://www.cnblogs.com/plmnko/archive/2010/10/15/1851854.html sleep 来自 Thread 类，和 wait 来自 Object 类；sleep 方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或方法；wait，notify和 notifyAll 只能在同步控制方法或者同步控制块里面使用，而 sleep 可以在任何地方使用；sleep 必须捕获异常，而 wait ， notify 和 notifyAll 不需要捕获异常
（8）String,StringBuffer与StringBuilder的区别： https://blog.csdn.net/u011702479/article/details/82262823
（9）String类型为什么设计成不可变的（其优点）：1.保障数据库安全性，2.保证字符串常量池的正常使用，节约空间 3.保证多线程安全 https://www.cnblogs.com/xzwblog/p/7230366.html
（10）equal 和 == 的区别：https://baijiahao.baidu.com/s?id=1652442464525126879&wfr=spider&for=pc https://www.cnblogs.com/limeiky/p/4831992.html
(11) 如何控制线程并发安全 &synchronized和lock有什么区别 ：https://www.cnblogs.com/94-181227/p/10399593.html & https://www.cnblogs.com/jinggod/p/8491242.html lock可以响应中断（两个阶段：尝试获取锁阶段和已获取锁阶段），lock可以尝试超时获取锁，lock必须手动释放锁，lock是接口类，lock可以实现公平锁
（12）java中常见的锁 & 可重入锁和非可重入锁的区别 &乐观锁和悲观锁的区别：https://www.cnblogs.com/jyroy/p/11365935.html
（13）抽象类与接口的区别：https://blog.csdn.net/xiaoxu9522/article/details/90748914
（14）CAS算法以及可能产生的问题：https://www.cnblogs.com/jyroy/p/11365935.html 同（12）
（15）线程池的七个参数及其好处 &java中有哪些常用的线程池：https://blog.csdn.net/fengye454545/article/details/79536986 https://blog.csdn.net/u012702547/article/details/52259529 https://blog.csdn.net/seu_calvin/article/details/52415337
（16）线程池的创建和使用学习可参考：https://www.cnblogs.com/xichji/p/11757110.html & https://www.cnblogs.com/Jashinck/p/10604808.html
（17）jvm类加载过程：https://blog.csdn.net/the_one_and_only/article/details/81610310
(18)反射的原理： https://blog.csdn.net/h2604396739/article/details/83109292
（19）如何打破双亲委派： https://blog.csdn.net/xiaobao5214/article/details/81674215 & https://www.cnblogs.com/joemsu/p/9310226.html （需要练习）
（20）synchronized锁膨胀过程: https://blog.csdn.net/weixin_34226706/article/details/91670082 & https://blog.csdn.net/stackflow/article/details/79455880 & https://blog.csdn.net/xueba8/article/details/88753443
(21)常用的设计模式: https://blog.csdn.net/qq_36145093/article/details/88423142 & https://www.cnblogs.com/xll1025/p/10661427.html （需要练习）单例，工厂，代理，观察者，外观：https://www.cnblogs.com/jimoer/p/9463698.html；桥接、策略、生产者消费者 ：https://www.cnblogs.com/java-my-life/archive/2012/05/10/2491891.html (基本所有模式都有) https://blog.csdn.net/zhangerqing/article/details/8239539
(22)如何保证线程顺序执行: https://www.cnblogs.com/kaleidoscope/p/9877174.html join方法、CountDownLatch
(23)start和run的区别： https://www.cnblogs.com/yiRain1992/p/9079989.html
(24) hashmap与hashtable的区别：https://blog.csdn.net/xuhuaabc/article/details/91475761
（25）array和arraylist区别：容量、存储的元素类型、方法上比较：https://blog.csdn.net/qunqunstyle99/article/details/95045693
(26)string与stringbuffer的区别：1）字符修改上的区别，string是不可改变的字符串对象，如果更改字符串本质是创建了新的字符串对象；stringbuffer是可以改变的，是在原有的字符串对象上操作，并且操作效率要比string类型高。2）初始化的区别：string可以空赋值，stringbuffer不可 3）方法上的区别，string重写了equals方法，stringbuffer没有。
(27)java collection集合和map等的总结：https://blog.csdn.net/feiyanaffection/article/details/81394745
（28）如何保证内存可见性：volatile 通过内存屏障；synchronized 通过修饰的程序段同一时间只能由同一线程运行，释放锁前会刷新到主内存
（29）JVM自动内存管理，Minor GC与Full GC的触发机制：
Minor GC触发条件：当Eden区满时，触发Minor GC。Full GC触发条件：
（1）调用System.gc时，系统建议执行Full GC，但是不必然执行；（2）老年代空间不足（3）方法区空间不足（4） Promotion Failure和Concurrent Mode Failure，前者是在年轻代晋升的时候老年代没有足够的连续空间容纳，很有可能是内存碎片导致的；后者是在并发过程中jvm觉得在并发过程结束前堆就会满了，需要提前触发Full GC
（30）JVM调优，基本思路是什么：https://www.jianshu.com/p/c8a271448dcd & https://www.jianshu.com/p/b92b08706a12
（31）g1和cms： https://www.jianshu.com/p/bdd6f03923d1 （链接无效了) & 挺难懂的 一个收集老年代，一个收集年轻代和老年代；一个会产生空间碎片，一个不会；一个是区分老年代年轻代进行收集，一个是直接分区进行收集。 &https://blog.csdn.net/Fly_as_tadpole/article/details/85047616 &https://baijiahao.baidu.com/s?id=1636852721632353675&wfr=spider&for=pc & https://segmentfault.com/a/1190000013365885
（32）代理的实现原理：https://blog.csdn.net/weixin_40573194/article/details/82834308 （写关于jdk代理和cglib 底层）(要练习)
（33）List和Set的区别：https://blog.csdn.net/YEEZY_H/article/details/94469944
(34)Java集合如何去重：https://www.cnblogs.com/suni/p/9488019.html
(35)hashcode和equals作用：https://www.cnblogs.com/keyi/p/7119825.html
（36）Java集合排序实现方式：https://www.cnblogs.com/roadlandscape/p/12093907.html
--（37）线程创建的方式：https://www.cnblogs.com/lingz/p/9692545.html （要练习）
(38)java的静态代码、静态变量和非静态代码、非静态属性执行顺序： https://blog.csdn.net/qq_36522306/article/details/80584595 & https://www.cnblogs.com/leiqiannian/p/7922824.html。静态方法要调用才会执行，程序入口方法是静态main方法，非静态代码块、构造函数要new实例才会执行，静态属性实例化和静态方法相同优先级，谁在前面谁先；但是在验证阶段，只有静态属性赋值，基础类型赋值为0，引用类型赋值为null. 各种方法执行之前都要让父类的先执行。
(39)threadlocal: https://www.jianshu.com/p/80866ca6c424 & https://www.jianshu.com/p/1d7dd90ea7e6 &https://www.jianshu.com/p/459d560a77db
(40)弱引用：https://brightloong.github.io/2018/05/27/%E5%85%B3%E4%BA%8EJava%E4%B8%AD%E7%9A%84WeakReference/ ->强引用（https://www.cnblogs.com/gudi/p/6403953.html）->transient关键字（https://blog.csdn.net/u010188178/article/details/83581506）->（反）序列化（https://www.cnblogs.com/huoxiayu/p/5465914.html）
（41）怎么理解Java的反射和泛型：https://blog.csdn.net/wufaliang003/article/details/80386125；泛型就是通过类型参数化
（42）Class.forName()与ClassLoader[ClassLoader.getSystemClassLoader().loadClass] 的区别 ： https://www.jianshu.com/p/2dbfec55c987 || https://www.cnblogs.com/zabulon/p/5826610.html ||
mysql驱动加载破坏双亲委派和Class.forName()作用：https://www.cnblogs.com/joemsu/p/9310226.html & https://www.cnblogs.com/gaojing/archive/2012/03/23/2413638.html & https://www.cnblogs.com/yaowen/p/9339788.html。Class.forName(xx)加载时对xx进行加载进了jvm，在DriverManager（启动类加载）进行调用时会执行DriverManager的静态方法，从而由AppClassLoader去加载所有的Driver实现字节码，而不是在启动类范围里查找jdk定义的驱动接口。
（43）BIO、NIO：https://www.cnblogs.com/diegodu/p/6823855.html
（42）为什么使用泛型而不使用Object：https://www.cnblogs.com/NicekHuang/p/9522309.html
（44）聚合和耦合：https://www.cnblogs.com/sxx1991/articles/5710338.html
(45)工厂模式有什么优缺点：https://www.cnblogs.com/kgrdomore/p/4242081.html & （遵循开放封闭原则，降低耦合性、更好扩展功能；缺点是需要扩展功能需要增加子工厂类，增加开发量）
(46)直接new对象不行吗？为啥用反射: https://www.zhihu.com/question/340517449/answer/810994474 & （a）反射是在运行时动态创建对象，可以访问所有属性，new在编译时创建（必须引入类路径)，只能访问公有属性，（b）使用反射实现解耦和 （c）未知类名时创建类（jdk动态代理） & http://www.bjpowernode.com/javazixun/1048.html &https://blog.51cto.com/14760318/2486850
（47）什么情况下用volatile，什么情况用synchronized 他们的区别：https://www.cnblogs.com/hapjin/p/5492880.html & https://mp.weixin.qq.com/s?__biz=MzI4MDYwMDc3MQ==&mid=2247486266&idx=1&sn=7beaca0358914b3606cde78bfcdc8da3&chksm=ebb74296dcc0cb805a45ca9c0501b7c2c37e8f2586295210896d18e3a0c72b01bea765924ce5&mpshare=1&scene=24&srcid=&key=c8fbfa031bd0c4166acd110fd54b85e9b3568f80a3f4c2d80add2f4add0ced46d1d3a0cf139c0ca64877a98635727a7fc593b850f8082d1fcf77a5ebf067fc1476285146d13d691f80b64b930006a341&ascene=0&uin=MjYwNzAzMzYzNw%3D%3D&devicetype=iMac+MacBookAir6%2C2+OSX+OSX+10.14.2+build(18C54)&version=12020810&nettype=WIFI&lang=zh_CN&fontScale=100&pass_ticket=hbg9AwR77rok2jxxdwyHyTHBDzwwC7lR8aEfF6HfW4KgJwsj0ruOpw8iNsUK%2B5kK & https://blog.51cto.com/wenshengzhu/2056138 &https://blog.csdn.net/a347911/article/details/88379625 &https://blog.csdn.net/javazejian/article/details/72828483
（48）voliate禁止指令重排序，是JVM层面实现的吗： jvm层面(ACC_VOLATILE) + cpu层面（lock addl） https://www.pianshen.com/article/17461413750/
（49）voliate和synchronized区别：https://www.cnblogs.com/MJyc/p/10374602.html
（50）AtomicInteger原理： https://www.jianshu.com/p/cea1f9619e8f
(51)单例模式-懒汉模式注意的问题：https://www.jianshu.com/p/ceb5da795c33
(52)AQS&可重入锁： https://www.cnblogs.com/chengxiao/p/7141160.html & https://www.cnblogs.com/chengxiao/p/7255941.html
(53)stop()和 suspend()方法的区别: https://blog.csdn.net/zwz2011303359/article/details/66487714
（54）解释型语言和编译型语言：https://www.jianshu.com/p/d21010003bb7
(55)java中的多态怎么理解，比如？：https://zhidao.baidu.com/question/345445792.html & https://www.cnblogs.com/yulianggo/p/10415587.html
（56）jvm与jmm模型：https://blog.csdn.net/zhaomengszu/article/details/80270696
（57）java对象是在堆上分配空间还是在栈上分配空间？：https://blog.csdn.net/o9109003234/article/details/101365108
(58)String可以继承吗，为什么,Long呢？：final修饰
(59）Long a = 127L,b=127L;a==b 输出？ Long c = 1024L;Long d = 1024L;输出c==d? :https://blog.csdn.net/mai763727999/article/details/91800949
(60)Hashtable为啥线程安全？:用synchronized修饰了增加、删除的方法，扩容？
（61）ConcurrentHashMap的实现原理：https://blog.csdn.net/weixin_44460333/article/details/86770169
（62）有遇到过OOM吗，怎么解决的，具体说下JVM怎么造成OOM的：
（63）给你一个文件里面有好几列，怎么用命令统计某一列的和：https://www.cnblogs.com/mrwuzs/p/10676683.html & https://www.cnblogs.com/lyy-blog/p/10774347.html & https://blog.csdn.net/weixin_30426879/article/details/95290984
（64）那怎么去观察死锁的，比如用java命令：https://www.cnblogs.com/bootdo/p/10481789.html
(65）java的JUC: java.util.concurrent. AtomicInteger,AtomicLong,AtomicBool
(66) 迭代器机制,与for循环的区别：https://www.cnblogs.com/xiongmozhou/p/10085105.html & https://blog.csdn.net/Jae_Wang/article/details/80526216 & https://blog.csdn.net/zq602316498/article/details/39163899 (迭代器有fast-fail机制，使用一个统一的接口来访问具体的集合元素历是通过指针进行顺序迭代查找，适合底层实现是链表的结构，for循环是通过随机访问进行取数据，虽然有些集合也实现了get方法，但是底层是从头遍历查找，影响查找效率)
(66)什么是动态代理，动态代理用在什么地方：动态代理是一种机制，就是动态的生成一个类并且由这个类去调用我们需要的方法，spring的aop,orm框架（hibernate，mybatis），场景有 日志，事务，性能监控（计算耗时），鉴权控制、全局异常处理等，原生的jdk动态代理依赖接口，原理是反射，cglib的原理则依赖字节码工具asm。
（67）序列化是怎么序列化的： https://www.cnblogs.com/shoshana-kong/p/10538661.html & https://www.cnblogs.com/lixuwu/p/10662339.html & https://blog.csdn.net/qq_27631217/article/details/79118365 &http://www.360doc.com/content/15/0413/20/15242507_462975436.shtml
(68)ArrayList 数组互转：https://www.cnblogs.com/Dream2hc/p/java51713565.html
(69) Lambda表达式：
（70）浮点数在计算机中怎么表示？：
(71)BigDecimal的四舍五入方法：https://www.cnblogs.com/yingchen/p/5459501.html
（72）List 的add方法时间复杂度多少？红黑树的插入元素呢？：List的add是O(1)复杂度，如果刚好达到容量的最大值，则需要进行扩容，也就是拷贝所有的元素到新的数组中，通常还是认为时间复杂度为O(1)。红黑树是丢弃严格左右子树高度值相差1（放宽限制）而演变来的平衡二叉树，每次插入最多可以在三次以内实现平衡，因此插入时间复杂度也是O(logn)。
(73)为什么内部类调用的外部变量必须是final修饰的？ https://blog.csdn.net/u010393325/article/details/80643636
(74)JAVA写时复制(Copy-On-Write): 写之前复制原来的引用对象，再进行修改，最后将原来的指针指向新的引用对象，最终是能够实现一致性的，适合于一致性实时性不高的场景。
(75)finalize可能会出现什么问题？：https://www.jianshu.com/p/c6e2abb9f657 & https://time.geekbang.org/column/article/6906
(76)Reachability Fence (稍微了解即可) : https://blog.csdn.net/feather_wch/article/details/82383183#reachability-fence%E5%8F%AF%E8%BE%BE%E6%80%A7%E6%A0%85%E6%A0%8F 通过底层 API 来达到强引用的效果
（78）原生jdk动态代理为什么针对接口：https://www.cnblogs.com/WeidLang/p/9857495.html
（79）comparator和comparable区别：https://blog.csdn.net/diweikang/article/details/80788194 (comparator就是一种典型的策略模式)
(80)hashmap插入数据的过程：1.key 的生成，h=key.hashcode()^(h>>>16) 2.resize()初始化，插入数据 3.若链表长度大于8并且tab槽的元素小于64，进行扩容; 4. 若链表长度大于64且槽元素大于等于64，树化链表; 【如果是将某个节点元素值更新，则进入afterNodeAccess方法】5.槽元素总值+1，6.调用afternodeInsertion。afterNodeAccess & afternodeInsertion是空实现，给linkedhashmap实现lru使用的 (https://www.jianshu.com/p/b8b00da28a49)。
（81）hashmap 1.8线程不安全原因：>>1.初始化表时，可能存在两个线程同时操作，会导致只有一个线程的tab生效，那么存在数据覆盖丢失。>>2.添加节点到tab上时，两个线程同时在槽上添加元素，导致元素覆盖。>>3. 往链表末端添加元素，最终写入主存时就只有一个生效，导致数据丢失 >>4.树化链表，假设链表中元素用volatile修饰，保证了可见性，树化链表时如果第一个线程新添加元素，在树化过程中挂起，第二个线程后添加元素，则最终使用第一个线程树化结果，第二个线程的添加元素将被丢失(树化是从链表头往后一个一个拿节点去构建树节点) >>5.扩容，类似树化链表，若第二个线程在第一个线程树化完成之前进行了树化操作，第一个线程后完成的话同样会导致元素丢失（冲突链表的节点也是一个一个从头往后找，构建一条新链表最后挂到新的tab上）。>>6.z->a->b->c 删除节点(A删a，B删b)，删除时，A线程拿到a节点，B线程拿到b节点，执行删除操作（指针变更），那A线程的结果是z->b->c，而B线程是z->a->c,删除结果只有一个写到主存,B删除失效。>>7.改变槽元素大小时++操作，线程不安全(一致性hash表改进：cas U.compareAndSwapLong()进行++操作)
（82）hashmap如何实现线程安全？：1.使用Collection.sychronizedMap();类似hashtable了，原理是使用mutex变量对象，对其加锁访问hashmap的方法，原理和hashtable是一样的。2.模拟 concurrenthashmap改造，也就是使用分段锁（合理使用cas乐观锁和sychronized加锁）。https://www.cnblogs.com/qlky/p/7359462.html。table用volatile修饰，节点指针的next、val用volatile修饰,键和hash值用final修饰
（83）标记复制算法过程也会产生stw吗？：标记复制算法是对eden区垃圾回收的算法，包括有Serial、ParNew,Parallel Scavenge收集器，都会有stw阶段：https://www.cnblogs.com/chongaizhen/p/11112742.html
(84)java创建一个对象包括哪些组成部分？对象头包括哪些？64位下，不压缩创建对象本身的大小是多少？压缩呢？（padding要求整体字节大小是8的倍数）：https://blog.csdn.net/jccg1000196340/article/details/79171321 & https://www.cnblogs.com/zhanjindong/p/3757767.html
（84）AQS有几个实现接口？实现一个读写锁？线程池某个线程的时间到了，该回收了，怎么回收的？
（85）CountDownLatch到0的时候，怎么通知多个线程同时向前执行了？
（86）long、double是线程安全的吗？https://blog.csdn.net/bingo_QAQ/article/details/106601362
（87）intern函数： https://www.cnblogs.com/dyg0826/p/11321393.html
LRU和xRU算法设计实现
密码学
对称加密算法和非对称加密算法：https://blog.csdn.net/u014294681/article/details/86705999 非对称（RSA，DSA，ECC） 对称（DES，3DES，AES）
spring: 一个小的总结：https://www.cnblogs.com/crazylqy/p/5589547.html
(1) Spring的启动流程 :https://blog.csdn.net/bluuusea/article/details/79925871 & https://www.cnblogs.com/jing99/p/11484194.html & https://blog.leapmie.com/archives/394/#%E5%8A%A0%E8%BD%BD%E4%B8%8E%E6%B3%A8%E5%86%8C（建议）
(2)Spring Bean的注入方式： https://www.cnblogs.com/moxiaotao/p/9304810.html
（3）Spring IOC如何实现(DefaultListAbleBeanFactory)：https://blog.csdn.net/maty_wang/article/details/80329606
（4） Spring Aop如何实现，有什么作用 ：https://blog.csdn.net/u010452388/article/details/80868392 实现不修改原有代码的情况下功能增强，以及实现主业务逻辑代码与其他功能代码的解耦和。（日志，监控运行时间，事务，缓存，权限控制）
（5）Spring事务传播机制有哪几种： https://www.cnblogs.com/fxtx/p/11630331.html
（6）Spring Bean的初始化过程 ：https://blog.csdn.net/qq_30038111/article/details/79945419 & https://www.jianshu.com/p/a854e23d88dd & https://blog.csdn.net/mlplds/article/details/103022695
(7) Spring如何解决循环依赖: https://www.cnblogs.com/chenshengyue/p/11399805.html & https://www.cnblogs.com/tiger-fu/p/8961361.html & 学习;https://www.jianshu.com/p/8bb67ca11831 构造器循环依赖和多例模式 prototype作用域无法解决循环依赖，单例模式 singleton作用域可以 利用 提前曝光三级缓存存储创建中的bean实例，从而实现解决循环依赖。
(8) Spring如何实现懒加载 : https://www.jianshu.com/p/f8c0e56408d9
(9)Ioc容器的加载过程： https://blog.leapmie.com/archives/394/#%E5%8A%A0%E8%BD%BD%E4%B8%8E%E6%B3%A8%E5%86%8C
(10)@Resource&@Autowired:https://www.jianshu.com/p/a74707581ffa
（11）spring的加载方式：https://www.cnblogs.com/xm1-ybtk/p/5112072.html
（12)spring哪些地方用到了什么模式？
mybatis: https://blog.51cto.com/14442094/2423256
敏捷开发：https://baike.baidu.com/item/%E6%95%8F%E6%8D%B7%E5%BC%80%E5%8F%91/5618867?fr=aladdin
使用分支开发，分支发布工作流
vims视频流矩阵调度
项目内容：项目基于SDN架构，采用OpenDaylight控制器、白盒硬件交换机开发，实现UDP视频组播流流量调度、 实时视频码率检测和端口控制等功能。 项目职责：完成基于管理平台的码流切换调度功能、码流加锁解锁功能后端开发；完成通过第三方控制面板实现流量 调度功能（基于Python的网络编程应用）。
作品介绍：校园网络故障管理平台用于监控校园网络的运行状况，包括校园物理网络可视化、实时获取设备状态、设 备流量阈值监控、设备故障告警触发等功能，并基于思科公司的Nexus 9000v镜像实现网络仿真。 完成内容：独立完成基于思科模拟器EVE-NG+N9KV交换机镜像搭建网络拓扑，使用Java语言完成拓扑视图数据、设 备状态、故障告警和故障信息记录接口的开发实现。
1.nginx 如何更好的对大量的用户请求进行负载均衡，打到后台机器上？
2.redis(不可靠问题) 某一块内存中用户信息丢失了，如何解决这种情况？
3.用户登录过程中的安全性怎么保证？
4.http2.0协议？
5.springboot的处理流程，大概的
6.从大量数据中找到某个数据？
hashmap表初始化，直接分配表大小，conhashmap使用cas进行初始化表
hashmap 存一个数据到槽上，是直接赋值；conhashmap使用cas
hashmap 存一个数据到链表末尾，是尾插，遍历查找最后节点插入；conhashmap使用sychronized加锁
hashmap 冲突链表树化时是直接树化；conhashmap使用sychronized加锁
hashmap 扩容时遍历每个槽，每个槽的链表（头开始）；conhashmap使用cas判断，用sychronized扩容。
hashmap删除节点，直接遍历更改指针删除（找到这个节点，指向下一个节点）；conshashmap则使用sychronized删除。
每次涉及到更改总体节点数据，hashmap size++；conhashmap调用addCount (cas方式+1)
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
