怎么设计自己的系统框架

排序算法垃圾回收机制了解吗 hashmap的原理算法题：有100瓶液体，其中一瓶是毒药，一只小白鼠喝到毒药一周后就会死亡。请问给我一周时间，至少需要多少只小白鼠能确定哪瓶是毒药？（把瓶子序号变成二进制） 1.hashmap中如何计算下标 .hashset的内容是什么 2 http和https，https加密过程，加密密钥怎么来，对称加密密钥哪里生成 3.事务是什么，隔离级别，每种隔离级别解决了什么问题 4.索引有哪些，数据结构是什么，区别是什么我2016先在蚂蚁实习了将近三个月时间太短，还是有点虚的，然后去了我现在的老东家，三年多工作经验
数据结构与算法基础就像“木桶效应”的短板，决定了能装多少水。此外，在正式决定看机会之前，我给自己列一个提纲，主要包括Java要掌握的核心要点，有不懂的就查资料搞懂。 1给了长度为N的有重复元素的数组，要求输出第10大的数。典型的TopK问题，快排算法搞定。算法题要注意的是合法性校验、边界条件以及异常的处理。另外，如果要写测试用例，一定要保证测试覆盖场景尽可能全。加上平时刷刷算法题，这种考核应该没问题的。 1 怎么让HashMap变得线程安全？

监控系统怎么做的，分为哪些模块，模块之间怎么交互的？用的什么数据库？
订单表有做拆分么，怎么拆的？
水平拆分后查询过程描述下
如果落到某个分片的数据很大怎么办？
哈希取模会有什么问题么？
主键索引和普通索引的区别？
你们系统目前的瓶颈在哪里？
你打算怎么优化？简要说下你的优化思路
怎么理解微服务？
CMS GC有什么问题？
怎么避免产生浮动垃圾？
强制young gc会有什么问题？
知道G1么？
回收过程是怎么样的？
你提到的Remember Set底层是怎么实现的？
Java中的HashMap、TreeMap解释下？
TreeMap查询写入的时间复杂度多少？
HashMap多线程有什么问题？
CAS和synchronize有什么区别？都用synchronize不行么？
如果要保证线程安全怎么办？(ConcurrentHashMap)
ConcurrentHashMap怎么实现线程安全的？
get需要加锁么，为什么？
在多核CPU下，可见性怎么保证？
聊项目，系统之间是怎么交互的？
系统并发多少，怎么优化？
给我一张纸，画了一个九方格，都填了数字，给一个MN矩阵，从1开始逆时针打印这MN个数，要求时间复杂度尽可能低
可以先说下你的思路(想起来了，说了什么时候要变换方向的条件，向右、向下、向左、向上，依此循环)
数据怎么流转的？链路追踪的信息是怎么传递的？
跳表的查询过程是怎么样的，查询和插入的时间复杂度?
红黑树了解么，时间复杂度?
既然两个数据结构时间复杂度都是O(logN)，zset为什么不用红黑树
那我们做一道题吧，数组A，2*n个元素，n个奇数、n个偶数，设计一个算法，使得数组奇数下标位置放置的都是奇数，偶数下标位置放置的都是偶数
下一个奇数？怎么找？
你这样时间复杂度有点高，如果要求O(N)要怎么做为什么B+树要这样设计？奇数升序偶数降序的数组将其按从小到大排序为单项链表：思路：将奇数项和偶数向分别拿出来将偶数项正序然后将两个数组采用归并的方式排到数组中。后端怎么处理前端传过来的文件 GC机制（GC算法，分代收集，收集器，STW）给定一个数组a[N]和一个整数P，求a[i] + a[j] + a[k] =P，保证i<j<k 身份证如何有效建立索引写一个分页查询两个人抛硬币，先抛的人赢的概率单链表排序，奇数位升序，偶数位降序学生表 Student (S#,Sname,Sage,Ssex)，课程表 Course (C#,Cname)，成绩表SC (S#,C#,score)，查询平均成绩大于 60 分的同学的学号和平均成绩 Redis常用数据结构及底层数据结构实现如何实现本地缓存？请描述一下你知道的方式降低内存占用算法题：蛇形打印二叉树算法题：给出[[1, 2], [3, 5], [8, 8], [15, 16], [32, 38]]，求间隔

算法题：给出两个升序数组A、B和长度m、n，求第k个大的数

算法题：给出数组A，长度为n，数组中元素的值位于[0, n - 1]之间，求是否有重复元素

算法题：二叉树的左视图算法题：面值[1,3,4]的硬币，输入n，输出最少组成n的硬币个数以及组成的硬币

背题：看一看最近的面经文，了解现在公司都在面什么类型的题，准备一些常见题，开背吧！如果一些基础的 js 都不会那问题就有点小大了。

算法：做一些算法题，leetcode 上面的一二三星就够了，前端算法很简单，基本都是初中数学的难度吧。

项目：项目回顾，把你做的项目从技术架构到源码都要做到足够了解，至少面试的时候不要被面试官问住了。并且要体现出你在工作中的作用，体现出自驱性（大公司都很看重自驱性）

亮点：准备亮点，回答问题的时候不用全部回答上来，但是在面试的过程中一定要有亮点（不然你就会得到反馈，面试官说你还行，但是没有过～）我一般会准备几个点，每个点都保证可以睡上半小时。另外一定要了解得很深入，并且能够用自己的话流畅的表达出来！！（我准备的几点，性能优化、工程化、缓存、http）

内推：最好找人内推，成功率会提高一些

练手：先找几家不太想去的公司（规模差不多）练练手，如果第一次面试就去心仪的公司面试，淘汰率会非常高。

心态：心态很重要，面试不过很正常，不证明你不优秀，只是不适合，总结面试经验，为下一次做准备。

答题：怎么把自己会的问题说好，这个很关键

逻辑清晰：一定要逻辑清晰，不然即使你知道这个问题的答案，面试官也不会满意，如果你逻辑清晰，即使这个答案不会，面试官也会给你加分

独特理解：现在的面试题大同小异，那么如何体现出你的优势就很重要。结合业务以及你自身的知识储备来讲

深入思考：对每个问题一定要有深入的思考，不然就很难进入大公司了，深度上要有一个拔高才能在面试中获得好的成绩

从你项目中看出，你使用的是 mysql，mysql 的 int 数据类型都有哪些？从小到大说一下，各占多少字节？

java 中的 int 都有哪些？字节占多少

问你一个关于计算机网络的，tcp 的三次握手说一下？

tcp 和 udp 的区别？

你说你熟悉 linux，我给你一个案例，搜索出 log 文本中出现次数最多的 IP，并且给出次数

说下 java 的 gc？

说一下 hashmap 这个数据结构？

进行一次查找的话 haspmap 的时间复杂度是多少？

给你一个算法你看一下，有一个无限长的整型数组，从小到大排序，非递增。那么怎么找到数组中一个 key？

闲聊

之后就问了我最近看了哪本书，学到了什么，最近还在学的什么技术呢？问了我职业规划，兴趣爱好，还说了说公司的语言选型，我后来问了下对于我的面试表现评价，人家不方便说，又问了新人培养等问题。 1.4 字节跳动四面 HR 面，大约 35 分钟，主要是问个人职业规划、薪资待遇，以及对字节跳动的期许等等

写在最后作为一名即将求职的程序员，面对一个可能跟近些年非常不同的 2019 年，你的就业机会和风口会出现在哪里？在这种新环境下，工作应该选择大厂还是小公司？已有几年工作经验的老兵，又应该如何保持和提升自身竞争力，转被动为主动？

就目前大环境来看，跳槽成功的难度比往年高很多。一个明显的感受：今年的面试，无论一面还是二面，都很考验 Java 程序员的技术功底。

最近我整理了一份复习用的面试题及面试高频的考点题及技术点梳理成一份“Java 经典面试问题（含答案解析）.pdf 和一份网上搜集的“Java 程序员面试笔试真题库.pdf”（实际上比预期多花了不少精力），包含分布式架构、高可扩展、高性能、高并发、Jvm 性能调优、Spring，MyBatis，Nginx 源码分析，Redis，ActiveMQ、Mycat、Netty、Kafka、Mysql、Zookeeper、Tomcat、Docker、Dubbo、Nginx 等多个知识点高级进阶干货！

第一轮主要考察 Java 基础 hashmap的实现 Java中的垃圾回收除了代码之外你还学习了什么技术，框架死锁是怎么产生的线程和进程的区别第二、三轮注重对应技术的掌握： MySQL的索引，B+树性质 Redis的持久化方式 TCP四次挥手讲一下过程，最后一次ack如果客户端没收到怎么办对于socket编程，accept方法是干什么的，在三次握手中属于第几次第四面则是关于参与过的项目和在对业务的理解历经4面，“跳进”字节跳动

字节跳动一面：自我介绍 tcp和udp区别，应用场景 tcp三次握手，为什么有第三次？讲一下get和post区别，其他命令讲一下进程和线程区别，什么时候用多线程？怎么保证线程安全？ synchronized的使用，是对什么加锁？栈和队列，怎么用栈实现队列？垃圾回收算法，复制算法中存活对象太多怎么办？可达性分析，GC Root可以是哪些对象？ hashmap底层实现，put get过程，扩容，为什么容量为2的倍数？ java基本类型，基本类型间的转换(short+int得到int类型，不能直接把int型赋给short型) String类，字符串相加+的底层操作，StringBuilder和StringBuffer 算法：给一个数组，使数组奇数在前半段，偶数在后半段，在原数组上操作。

字节跳动二面：多个项目的技术架构，不是业务架构 MySQL，Redis，Nginx，Kafka这些技术架构项目技术点，学到了哪些？也要具体知识点。 MySQL中为什么是最左前缀？有没有接触过一些自动熔断工具 502可能的原因有哪些？线上问题怎么排查？Full GC频繁怎么办？服务的QPS，数据库的架构和版本。 SpringBoot的优缺点分析 SpringBoot的启动源码分析服务的部署方式？算法题目：按照之字形分层遍历二叉树，要求bug free，并且构造二叉树进行测试。

字节跳动三面： jdk8默认的垃圾回收器, 知道哪些垃圾回收器? G1详细说一下 synchronized关键字的底层是什么? 线程之间哪些资源是共享的? 什么是独享的? 堆和栈有什么区别? linux查看资源的命令?怎么样查看哪些端口被占用了 linux内存中swap是什么? 什么用? 用户态和内核态的区别? 为什么要有用户态内核态区别? 中断有哪些类型，区别？死锁概念？条件？算法题：奇数位递增偶数位递减的数组，排序 get可以缓存？在INTP(?没听懂在哪)里是怎么实现的？写sql，group by的查询？

那你说的内存泄漏是指主线程还是线程池？
可是主线程不是都退出了，引用的对象不应该会主动回收么？
那你说下SpringMVC不同用户登录的信息怎么保证线程安全的？
这个直接用ThreadLocal不就可以么，你见过SpringMVC有锁实现的代码么？
我们聊聊mysql吧，说下索引结构
为什么使用B+树？
什么是索引覆盖？
什么时候需要自定义类加载器？
我们做一道题吧，手写一个对象池

hashmap 的原理
Java 的垃圾回收，gc 算法
进程阻塞、内存泄露怎么排查和解决

HashMap、hashtable、concurrenthashmap 的区别

Linux CPU 100% 的时候怎么排查
Linux 大文件怎么查找
Redis 的持久化方式十亿个数的集合和10w个数的集合，如何求它们的交集。集合的数字不重复

可达性分析算法中根节点有哪些? 怎样排查 CPU 彪高、内存彪高?

以下代码题输出什么？（巨坑，输出100，从泛型+向上转型+map+equals原理上想）

Map<Short, String> map = new HashMap<>();
for(short i = 0; i <100; i++) 
{ 
map.put(i, String.valueOf(i)); 
map.remove(i-1);
}
System.out.println(map.size());

算法：手写jdk中的优先级队列 PriorityQueue（最大堆） . 剑指offer62:圆圈剩下的数字
写一个快排
给出一个数组nums，一个值k，找出数组中的两个下标 i，j 使得 nums[i] + nums[j] = k. 2种解法，排序数组+双指针o(n)遍历或使用HashMap额外存储空间。
说说操作系统内存模型不连续空间分配，说说分段，分页，虚拟内存，页淘汰算法....
手撕一个阻塞队列，生产者生产0~100的随机数，消费者消费后将其存储到一个list，需要保持list中元素保持递增。(信号量+线程安全)
说说hashmap的resize死循环
说说hashtable和hahsmap区别，说说copyOnwriteArrayList以及他们分别采用的并发修改当然(fast-fail,fast-safe）

7.事务隔离
10.编程：快排无锁队列实现细节算法部分：

（1）给一个正整数，判断是否是2的n次幂，他说用最快的方式不要递归？肯定是运算的方式，你能想到的数的运算有哪些，除了加减乘除？这个地方讲了很多，运算太多了，但是感觉不是面试官想要的，我最后把二进制的移位都说了出来，才get到他的点，问还有些什么，他最后问我怎么没提异或，并且出了几个二进制数让我异或算结果

（2）给一个数组,数组里面有rgb三种数，数量和顺序完全无序，给一个算法按照他想要的r都在前面，g都在中间，b都在后面，用移动次数最少的算法进行计算，写算法这个地方一直叫我优化再优化了，

银行家算法了解么？

算法部分：

（1）有很多纸盒子，每个纸盒里里面套着纸盒子，其中有一个有硬币，怎么把硬币找出来，写算法

（2）树的遍历方法有什么，写一个二叉树前序遍历算法

（1）寻找最近的父节点，给了两个例子，差不多leetcode中等难度

（2）开放性的问题，猫抓老鼠，猫在圆型中间，老鼠在圆的周长上，速度相同，问猫能不能抓到老鼠 Java的深浅拷贝（clone方法）
Hashtable和HashMap区别，说下HashMap结构 算法：
(A,B)(A,C)(B,D)(D,A)判断是否有循环引用，提示用拓扑排序（尴尬，没看过，换了超简单的第二题做出来了）
蛇形打印二叉树主键索引查询和非主键索引查询区别
b+树好处
一致性哈希
说一下ConcurentHashMap
设计LRU
数组找是否存在和为M的两个数

内存泄露原因,举例子，怎么排查，OOM异常
集合框架源码，concurrenthashmap, hashmap linkedhashmap实现L _RU
synchronized原理, jdk6对他的优化，(偏向锁等)， JNI, 逃逸分析,对象的markword
知道几个设计模式，怎么用，写双重检查锁单例模式
算法：手写jdk中的优先级队列 PriorityQueue（最大堆）
剑指offer62:圆圈剩下的数字
写一个快排
给出一个数组nums, -个值k,找出数组中的两个下标i, j 使得nums[i] + numsj]= k 2种解法,排.数组+双指针o(n遍历或使用HashMap额外存储空间。

如果有10w请求插入Redis,如何优化?用户量如何统计的

手撕一个阻塞队列，生产者生产0~ 100的随机数，消费者消费后将其存储到一个list, 需要保持list中元素保持递增。(信号量+线程安全)
说说hashmap的resize死循环
说说hashtable和hahsmap区别，说说copyOnwriteArrayL ist以及他们分别采用的并发修改当然(fast-fail,fast-safe)
在用户登录的时候，由于HTTP是无状态的如何识别不同的用户(session或者cookie)，然后让说一下session和cook各有什么优缺点。
单点登录的问题如何解决(服务器集群的情况下，用户如何在一-台服务器上登录，访问其他的服务器就不需要登录了) ?

答:服务器集群之间厂播session厂播或者使用Redis共享session。

为什么Redis他是通过hashtable实现的，但是它的扩容的时候并没有卡顿?
为何Redis是单线程的还是这么快?
商城如果有用户注册的模块，那么在用户注册成功之后一般会返回一个邮箱连接，然后用户点击连接跳转到商城主页。现在要求连接的有效时间为30分钟，这种服务如何保证?

答：可以在数据表中增加一个超时时间的字段，用户点击连接的时候判断是否已经超时，在进行商品展示的时候，如果一个商品有不同的分配，那么可能会涉及到有多级分类的问题。

如何涉及数据库表，来实现商品的多级分类？。
两个字符串的最大子序列问题。

字节跳动二面

对于你的商城项目，如果对于同一个分类有多个卖家，如何设计数据表?
对于高并发的系统，如何设计架构才能避免瞬间数据库收到瞬间高流量的冲击?
如果你用Redis实现的话，可能会出现商品超卖的问题，那么你是如何结果商品超卖问题的?
一般在支付的过程中，用户支付、账户被冻结、订单的生成、卖家库存减少、卖家收到钱，这是个一系列的过程，那么你如何设计实现分布式的事务? 字符串匹配，二叉搜索树的第K小节点，链表每隔K个节点进行翻转。
设计一个短连接服务\ MD5hash算法
两个鸡蛋问题，如果有100层楼，如何判断出恰好在第几层楼摔坏?
能不能推演出一个数学公式一般情况下，我们的IP的存储都是将点十进制转化为-个长整型进行存储，如1.2.3.4–》1234，现在有一个20w行的文件，其中文件的每一行都存储了一些信息:

设计一个IPquery的服务，以最快的形式，根据我查询的IP返回用户的基本信息。(用代码实现) 上亿级查询不同数据的怎么处理(这些数据都不在Redis缓存里) 在实践中，如何正确使用对象来减少垃圾回收造成的资源浪费？ HashMap与ConcurrentHashMap的底层实现? HashMap与ConcurrentHashMap，是否是线程安全，Redis是不是线程安全？最长回文串变体，给一个字符串，可以使用里面所有字符，在一次循环的限制下，找到并返回一个最长回文串 zset底层数据结构？跳表如何插入一个值？如何做到保证数据可靠性 Mysql： mysql 为什么索引为什么用b+树 b+树除了高低小查询快，还有什么好处？什么是聚集索引，什么是非聚集索引 hashMap 底层数据结构为什么用红黑树红黑树是平衡树吗？如何保证hashMap线程安全？聊聊：syn锁与ReentrantLock与volatile 操作系统：聊聊虚拟内存，为什么要虚拟内存计算机网络：为什么网络要分层？算法：反转链表变体给定一个链表头节点，和一个left 和right 反转left和right之间的值。

0.HashMap的源码，实现原理，JDK8中对HashMap做了怎样的优化。

拉链结构，数组+链表，原理是hash找数组，冲突后拉链表，1.8优化为会进化成红黑树提高效率，并且使用2^n来做容量值

引申点：

equal & hashcode

其他地方的hash处理，如redis的hash、集群slot等

对hash算法类型的了解（安全哈希和非安全哈希如mermerhash）

对hashMap实现的了解：取hashcode，高位运算，低位取模

一致性hash（处理了什么问题，在什么场景用到）

红黑树简单描述

1.HaspMap扩容是怎样扩容的，为什么都是2的N次幂的大小。

在容量到达抵达负载因子*最大容量的时候进行扩容，负载因子的默认值为0.75

2N的原因：

hash的计算是通过hashcode高低位混合然后和容量的length进行与运算在length=2n的时候，与运算相当于是一个取模操作那么在每次rehash完毕之后mod2N的意义在于要么该元素是在原位置，要么是在最高位偏移多一位的位置，提高效率引申点：

ConcurrentHashMap的扩容：1.7分段扩容以及1.8transfer并发协同的扩容

redis渐进式hash扩容处理

3.HashMap，HashTable，ConcurrentHashMap的区别。

Map线程不安全（没有用任何同步相关的原语），Table安全（直接加syn），Concurrent提供更高并发度的安全（分段锁思想orSyn+Cas）

引申点：

对线程安全的定义：如hashmap在1.7前会头插死循环，但是在1.8改善后还是不能叫线程安全，因为没有可见性

对锁粒度的思考：在介于map和table之间存在tradeoff之后的均衡解

Syn和ReentranceLock的区别

锁升级

4.极高并发下HashTable和ConcurrentHashMap哪个性能更好，为什么，如何实现的。

分两种情况讨论：

极高并发读：并发读的情况下，Table也为读加了锁，没有并发可言，ConcurrentMap读锁并没有加并发，直接可读，若读resize的某个tab为空则转到新tab去读，Node的元素val和指针next都是volatile修饰的，可以保证可见性，所以concurrentMap获胜极高并发写：在并发写的情况下，table也是直接加了Syn做锁，强制串行，并且resize也只能单线程扩容，ConcurrentMap首先对于每个数组都有并发度，其次在resize的时候支持多线程协同，所以concurrentMap获胜所以整体而言concurrentMap优势在于：

读操作基于volatile可见性所以无锁写操作优势在于一是粗粒度的数组锁，二是协同resize 这个问题的思路是先分类讨论然后描述细节最后在下结论

引申点：

volatile的实现：保证内存可见、禁止指令重排序但无法保证原子性

java内存模型

JVM做的并行优化、先行发生原则与指令重排序

底层细节的熟悉

5.HashMap在高并发下如果没有处理线程安全会有怎样的安全隐患，具体表现是什么。

1.7前死锁，1.7后线程会获取脏值导致逻辑不可靠

6.java中四种修饰符的限制范围。

public：公用，谁来了都给你用

protected：包内使用，子类也可使用

default：包内使用，子类不可使用

private：自己用

7.Object类中的方法。

wait\hashcode\equal\wait\notify\getclass\tostring\nofityall\finalize

引申点：

wait和sleep区别

hashcode存在哪儿（对象头里）

finalize作用：GC前执行，但是不一定能把这个函数跑完

getClass后能获取什么信息：引申到反射

8.接口和抽象类的区别，注意JDK8的接口可以有实现。

接口：可以imp多个接口，1.7之前不允许实现，1.8后可以实现方法

抽象类：只能继承一个类，抽象类中可以存在默认实现方法

接口的语义是继承该接口的类有该类接口的行为

抽象类的语义是继承该抽象类的类本身就是该抽象类

9.动态代理的两种方式，以及区别。

CGLIB：其本质是在内存中继承了一个子类，可以代理希望代理的那个类的所有方法 JDK动态代理：实现InvocationHandler，通过生成一个Proxy来反射调用所有的接口方法优劣：

CGLIB：会在内存中多存额外的class信息，对metaspace区的使用有影响，但是性能好，可以访问非接口的方法 JDK动态代理：本质是生成一个继承所有接口的Proxy来反射调用方法，局限性在于其只能代理接口的方法引申点：

Spring的AOP实现以及应用场景

反射的开销：检查方法权限，序列化以及匹配入参

ASM

10.Java序列化的方式。

继承Serializable接口并添加SerializableId（idea有组件可以直接生成），ID实际上是一个版本，标志着序列化的结构是否相同

11.传值和传引用的区别，Java是怎么样的，有没有传值引用。

本质上来讲Java传递的是引用的副本，实际上就是值传递，但是这个值是引用的副本，比如方法A中传入了一个引用ref，那么在其中将ref指向其他对象并不影响在方法A外的ref，因为ref在传入方法A的时候实际上是指向同一个对象的另一个引用，可以称之为ref’，ref’若直接修改引用的对象会影响ref，但若ref’指向其他对象则和ref没有关系了

12.一个ArrayList在循环过程中删除，会不会出问题，为什么。

分情况讨论：

fori删除，不会直接抛异常，但是会产生异常访问 foreach删除（实际就是迭代器），会直接抛出并发修改异常，因为迭代器会进行获取迭代器时的exceptModCount和真实的modCount的对比引申点：

迭代器实现

ArrayList内部细节

13.@transactional注解在什么情况下会失效，为什么。

方法A存在该注解，同时被方法B调用，外界调用的是Class.B的方法，因为内部实际上的this.a的调用方式没走代理类所以不会被切面切到

数据结构和算法 1.B+树

出度为m的一颗树，节点的子女在[M/2,M]之间

叶子节点存储全量信息

非叶子节点只充当索引进行叶子节点的路由（内存友好、局部性友好）

底层的叶子节点以链表的形式进行相连（范围查找友好）

2.快速排序，堆排序，插入排序（其实八大排序算法都应该了解

快排：核心是分治logn

堆排：基于二叉树nlogn

插入：暴力n2

3.一致性Hash算法，一致性Hash算法的应用

一致性hash，将整个hash的输出空间当成一个环，环中设立多个节点，每个节点有值，当对象的映射满足上个节点和这个节点中间值的时候它就落到这个节点当中来

应用：redis缓存，好处是平滑的数据迁移和快速的rebalance

引申点：

一致性hash热点怎么处理：虚拟节点

redis如何实现的：客户端寻址

JVM 1.JVM的内存结构。

程序计数器：计算读到第几行了，类似一个游标

方法栈：提供JVM方法执行的栈空间

本地方法栈：提供native方法执行的栈空间

堆：存对象用的，young分eden,s0,s1，分配比例大概是8:1:1，Old只有一个区

方法区：1.8后为metaspace，存class信息，常量池（后迁移到堆中），编译出来的热点代码等

引申点：

heap什么时候发生溢出

stack什么时候发生溢出

方法区什么时候发生溢出

hotspot code的机制

流量黑洞如何产生的

2.JVM方法栈的工作过程，方法栈和本地方法栈有什么区别。

方法栈是JVM方法使用的，本地方法栈是native方法使用的，在hotspot其实是用一个

3.JVM的栈中引用如何和堆中的对象产生关联。

引用保存地址，直接可以查找到堆上对应地址的对象

4.可以了解一下逃逸分析技术。

方法中开出来的local变量如果在方法体外不存在的话则称之为无法逃逸

可以直接分配在栈上，随着栈弹出直接销毁，省GC开销消除所有同步代码，因为本质上就是个单线程执行引申点：

JVM编译优化：

逃逸分析

栈上分配

分层编译与预热

栈上替换

常量传播

方法内联

…

5.GC的常见算法，CMS以及G1的垃圾回收过程，CMS的各个阶段哪两个是Stop the world的，CMS会不会产生碎片，G1的优势。

常见算法：

标记清楚：存在内存碎片，降低内存使用效率标记整理：整理可分为复制整理和原地整理，不存在内存碎片，但是需要额外的cpu算力来进行整理，若为复制算法还需要额外的内存空间 CMS流程：

初始标记(stw)：获得老年代中跟GCRoot以及新生代关联的对象，将其标记为root 并发标记：将root标记的对象所关联的对象进行标记重标记：在并发标记阶段，并没有stw，所以会有一些脏对象产生，即标记完毕之后又产生关联对象修改最终标记(stw)：最终确定所有没有脏对象的存活对象并发清理：并发的清理所有死亡对象 Reset：重设程序为下一次FGC做准备 CMS优劣：

优点：

不像PN以及Serial一样全程需要stw，只需要在两个标记阶段stw即可

并发标记、清楚来提升效率，减少stw的时间和整体gc时间

在最终标记前通过预设次数的重标记来清理脏页减少stw时间

缺点：

仍然存在stw

基于标记清楚算法的GC，节省算力但是会产生内存碎片

并发标记和清楚会造成cpu的高负担

G1流程：这个我只懂个大概，如下

分块分代回收，可分为youngGC和MixedGC，特点是可预测的GC时间（即所谓的软实时特性）

引申点：

是否进行过线上分析

GC日志是否读过，里面有什么信息

你们应用的YGC和FGC频率以及时间是多少

你清楚当前应用YGC最多的一般是什么吗

业务相关：

在线上大部分curd业务当中，实际上造成ygc影响较严重且可优化的是日志系统

对dump出来的堆进行分析的话里面有很大一块是String，而其中大概率会是日志中的各种入参出参

优化方案有很多：

将不需要打日志的地方去除全量日志打印功能
日志在不同环境分级打印
只打出错误状态的日志
在大促期间关闭非主要日志打印
同步改异步等

6.标记清除和标记整理算法的理解以及优缺点。

上文已答

7.eden survivor区的比例，为什么是这个比例，eden survivor的工作过程。

8:2

定性的来讲：大部分对象都只有极短的存活时间，基本就是函数run到尾就释放了，所以给新晋对象的buffer需要占较多的比例，而s区可以相对小一点来容纳长时间存活的对象，较小的另一个原因是在几次年龄增长后对象会进入老年代

定量的来讲：实验所得，也可以根据自己服务器的情况动态调整（不过笔者没调过）

8.JVM如何判断一个对象是否该被GC，可以视为root的都有哪几种类型。

没有被GCRoot所关联

Root对象：（tips：不用硬记，针对着JVM内存区域来理解即可）

函数栈上的引用：包括虚拟机栈和native栈 static类的引用：存在方法区内常量池中的常量：堆中引申点：

gc roots和ref count的区别

9.强软弱虚引用的区别以及GC对他们执行怎样的操作。

强：代码中正常的引用，存在即不会被回收

软：在内存不足的时候会对其进行GC，可用于缓存场景（类似redis淘汰）

弱：当一个对象只有弱引用关联的时候会被下一次GC给回收

虚：又称幽灵引用，基本没啥用，在GC的时候会感知到

引申点：

每个引用的使用场景

是否在源码或者项目中看到过or使用过这几种引用类型（ThreadLocal里用了WeakReference）

10.Java是否可以GC直接内存。

在GC过程中如果发现堆外内存的Ref被使用则GC

11.Java类加载的过程。

12.双亲委派模型的过程以及优势。

13.常用的JVM调优参数。

14.dump文件的分析。

15.Java有没有主动触发GC的方式（没有）。

多线程 1.Java实现多线程有哪几种方式。

2.Callable和Future的了解。

3.线程池的参数有哪些，在线程池创建一个线程的过程。

4.volitile关键字的作用，原理。

5.synchronized关键字的用法，优缺点。

6.Lock接口有哪些实现类，使用场景是什么。

7.可重入锁的用处及实现原理，写时复制的过程，读写锁，分段锁（ConcurrentHashMap中的segment）

8.悲观锁，乐观锁，优缺点，CAS有什么缺陷，该如何解决。

9.ABC三个线程如何保证顺序执行。

10.线程的状态都有哪些。

11.sleep和wait的区别。

12.notify和notifyall的区别。

13.ThreadLocal的了解，实现原理。

数据库相关 1.常见的数据库优化手段

log同步刷盘改异步刷盘集群的话强双写改异步同步针对sql优化（explain慢sql）添加索引 2.索引的优缺点，什么字段上建立索引

优点：查的快，支持range

缺点：大部分查询实际需要回表，索引建立会额外消耗内存和磁盘，对开发者的sql也有要求

字段：区分度大的字段

3.数据库连接池。

4.durid的常用配置。

计算机网络

1.TCP，UDP区别。

2.三次握手，四次挥手，为什么要四次挥手。

3.长连接和短连接。

4.连接池适合长连接还是短连接。

设计模式 1.观察者模式

2.代理模式

举例子JDK动态代理，通过一层proxy对真实对象进行代理，进行一些额外操作（e.g.:增强行为、负载均衡等）

3.单例模式，有五种写法，可以参考文章单例模式的五种实现方式

普通单例 lazyloading+syn单例 lazyloading+doublecheck单例枚举最后一种不知道，查了发现是静态内部类单例，利用静态内部类第一次访问才加载的机制实现lazyloading 4.可以考Spring中使用了哪些设计模式

分布式相关

1.分布式事务的控制。

2.分布式锁如何设计。

3.分布式session如何设计。

4.dubbo的组件有哪些，各有什么作用。

duboo不熟悉

5.zookeeper的负载均衡算法有哪些。

zookeeper就会个zab，不过负载均衡无非是公平轮询、加权轮询、随机轮询或者维护某些资源信息的动态路由这几种

6.dubbo是如何利用接口就可以通信的。

不太熟，估计涉及到服务注册以及序列化反序列化相关内容

缓存相关 1.redis和memcached的区别。

2.redis支持哪些数据结构。

3.redis是单线程的么，所有的工作都是单线程么。

4.redis如何存储一个String的。

5.redis的部署方式，主从，集群。

6.redis的哨兵模式，一个key值如何在redis集群中找到存储在哪里。

7.redis持久化策略。

框架相关 1.SpringMVC的Controller是如何将参数和前端传来的数据一一对应的。

2.Mybatis如何找到指定的Mapper的，如何完成查询的。

3.Quartz是如何完成定时任务的。

4.自定义注解的实现。

5.Spring使用了哪些设计模式。

6.Spring的IOC有什么优势。

7.Spring如何维护它拥有的bean。

一些较新的东西

1.JDK8的新特性，流的概念及优势，为什么有这种优势。

2.区块链了解

那先要明白什么是线程池

线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新建一个线程。

使用线程池的好处

线程池改进了一个应用程序的响应时间。由于线程池中的线程已经准备好且等待被分配任务，应用程序可以直接拿来使用而不用新建一个线程。
线程池节省了CLR 为每个短生存周期任务创建一个完整的线程的开销并可以在任务完成后回收资源。
线程池根据当前在系统中运行的进程来优化线程时间片。
线程池允许我们开启多个任务而不用为每个线程设置属性。
线程池允许我们为正在执行的任务的程序参数传递一个包含状态信息的对象引用。
线程池可以用来解决处理一个特定请求最大线程数量限制问题。

字节跳动java研发面试题:MySQL优化经验

对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。

应尽量避免在 where 子句中使用!=或<>操作符，否则引擎将放弃使用索引而进行全表扫描。

尽量使用数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。

任何地方都不要使用 select * from t ，用具体的字段列表代替“*”，不要返回用不到的任何字段。

避免频繁创建和删除临时表，以减少系统表资源的消耗。诸如此类，等等等等......

什么是线程死锁？死锁如何产生？如何避免线程死锁？

死锁的介绍：

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。当线程进入对象的synchronized代码块时，便占有了资源，直到它退出该代码块或者调用wait方法，才释放资源，在此期间，其他线程将不能进入该代码块。当线程互相持有对方所需要的资源时，会互相等待对方释放资源，如果线程都不主动释放所占有的资源，将产生死锁。

死锁的产生的一些特定条件：

互斥条件：进程对于所分配到的资源具有排它性，即一个资源只能被一个进程占用，直到被该进程释放。
请求和保持条件：一个进程因请求被占用资源而发生阻塞时，对已获得的资源保持不放。
不剥夺条件：任何一个资源在没被该进程释放之前，任何其他进程都无法对他剥夺占用。
循环等待条件：当发生死锁时，所等待的进程必定会形成一个环路（类似于死循环），造成永久阻塞。

如何避免：

加锁顺序：当多个线程需要相同的一些锁，但是按照不同的顺序加锁，死锁就很容易发生。如果能确保所有的线程都是按照相同的顺序获得锁，那么死锁就不会发生。当然这种方式需要你事先知道所有可能会用到的锁，然而总有些时候是无法预知的。
加锁时限：加上一个超时时间，若一个线程没有在给定的时限内成功获得所有需要的锁，则会进行回退并释放所有已经获得的锁，然后等待一段随机的时间再重试。但是如果有非常多的线程同一时间去竞争同一批资源，就算有超时和回退机制，还是可能会导致这些线程重复地尝试但却始终得不到锁。
死锁检测：死锁检测即每当一个线程获得了锁，会在线程和锁相关的数据结构中（map、graph等等）将其记下。除此之外，每当有线程请求锁，也需要记录在这个数据结构中。死锁检测是一个更好的死锁预防机制，它主要是针对那些不可能实现按序加锁并且锁超时也不可行的场景。

字节跳动java研发面试题:spring中Bean的作用域

singleton：Spring IoC容器中只会存在一个共享的Bean实例，无论有多少个Bean引用它，始终指向同一对象。Singleton作用域是Spring中的缺省作用域。\
prototype：每次通过Spring容器获取prototype定义的bean时，容器都将创建一个新的Bean实例，每个Bean实例都有自己的属性和状态，而singleton全局只有一个对象。\
request：在一次Http请求中，容器会返回该Bean的同一实例。而对不同的Http请求则会产生新的Bean，而且该bean仅在当前Http Request内有效。\
session：在一次Http Session中，容器会返回该Bean的同一实例。而对不同的Session请求则会创建新的实例，该bean实例仅在当前Session内有效。\
global Session：在一个全局的Http Session中，容器会返回该Bean的同一个实例，仅在使用portlet context时有效。

字节跳动java研发面试题:Spring框架中都用到了哪些设计模式？

代理模式：在AOP和remoting中被用的比较多。\
单例模式：在spring配置文件中定义的bean默认为单例模式。\
模板方法模式：用来解决代码重复的问题。\
前端控制器模式：Spring提供了DispatcherServlet来对请求进行分发。\
依赖注入模式：贯穿于BeanFactory / ApplicationContext接口的核心理念。\
工厂模式：BeanFactory用来创建对象的实例。

字节跳动java研发面试题:springmvc的核心是什么，请求的流程是怎么处理的，控制反转怎么实现的

核心：控制反转和面向切面

请求处理流程：

首先用户发送请求到前端控制器，前端控制器根据请求信息（如URL）来决定选择哪一个页面控制器进行处理并把请求委托给它，即以前的控制器的控制逻辑部分；

页面控制器接收到请求后，进行功能处理，首先需要收集和绑定请求参数到一个对象，并进行验证，然后将命令对象委托给业务对象进行处理；处理完毕后返回一个ModelAndView（模型数据和逻辑视图名）；

前端控制器收回控制权，然后根据返回的逻辑视图名，选择相应的视图进行渲染，并把模型数据传入以便视图渲染；

前端控制器再次收回控制权，将响应返回给用户。

字节跳动java研发面试题:JVM的内存结构

根据 JVM 规范，JVM 内存共分为虚拟机栈、堆、方法区、程序计数器、本地方法栈五个部分。\

Java虚拟机栈：线程私有；每个方法在执行的时候会创建一个栈帧，存储了局部变量表，操作数栈，动态连接，方法返回地址等；每个方法从调用到执行完毕，对应一个栈帧在虚拟机栈中的入栈和出栈。\
堆：线程共享；被所有线程共享的一块内存区域，在虚拟机启动时创建，用于存放对象实例。\
方法区：线程共享；被所有线程共享的一块内存区域；用于存储已被虚拟机加载的类信息，常量，静态变量等。\
程序计数器：线程私有；是当前线程所执行的字节码的行号指示器，每条线程都要有一个独立的程序计数器，这类内存也称为“线程私有”的内存。\
本地方法栈：线程私有；主要为虚拟机使用到的Native方法服务。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。那话不多说，坐稳扶好，发车喽！

一面二面连着一起，三面因为过了五一所以隔了很久，hr面在三面后一天

一面：45分钟项目：介绍项目需求，设计思路，主要技术（因为问到的是ai相关的项目，因此没多问技术）

一、JAVA 1.垃圾回收算法典型的垃圾回收算法在JVM规范中并没有明确GC的运作方式，各个厂商可以采用不同的方式去实现垃圾回收器。这里讨论几种常见的GC算法。

标记-清除算法(Mark-Sweep) 最基础的垃圾回收算法，分为两个阶段，标注和清除。标记阶段标记出所有需要回收的对象，清除阶段回收被标记的对象所占用的空间。如图：

从图中我们就可以发现，该算法最大的问题是内存碎片化严重，后续可能发生大对象不能找到可利用空间的问题。

复制算法(Copying) 为了解决Mark-Sweep算法内存碎片化的缺陷而被提出的算法。按内存容量将内存划分为等大小的两块。每次只使用其中一块，当这一块内存满后将尚存活的对象复制到另一块上去，把已使用的内存清掉，如图：

这种算法虽然实现简单，内存效率高，不易产生碎片，但是最大的问题是可用内存被压缩到了原本的一半。且存活对象增多的话，Copying算法的效率会大大降低。

标记-整理算法(Mark-Compact) 结合了以上两个算法，为了避免缺陷而提出。标记阶段和Mark-Sweep算法相同，标记后不是清理对象，而是将存活对象移向内存的一端。然后清除端边界外的对象。如图：

分代收集算法(Generational Collection) 分代收集法是目前大部分JVM所采用的方法，其核心思想是根据对象存活的不同生命周期将内存划分为不同的域，一般情况下将GC堆划分为老生代(Tenured/Old Generation)和新生代(Young Generation)。老生代的特点是每次垃圾回收时只有少量对象需要被回收，新生代的特点是每次垃圾回收时都有大量垃圾需要被回收，因此可以根据不同区域选择不同的算法。

目前大部分JVM的GC对于新生代都采取Copying算法，因为新生代中每次垃圾回收都要回收大部分对象，即要复制的操作比较少，但通常并不是按照1：1来划分新生代。一般将新生代划分为一块较大的Eden空间和两个较小的Survivor空间(From Space, To Space)，每次使用Eden空间和其中的一块Survivor空间，当进行回收时，将该两块空间中还存活的对象复制到另一块Survivor空间中。

而老生代因为每次只回收少量对象，因而采用Mark-Compact算法。

另外，不要忘记在Java基础：Java虚拟机(JVM)中提到过的处于方法区的永生代(Permanet Generation)。它用来存储class类，常量，方法描述等。对永生代的回收主要包括废弃常量和无用的类。

对象的内存分配主要在新生代的Eden Space和Survivor Space的From Space(Survivor目前存放对象的那一块)，少数情况会直接分配到老生代。当新生代的Eden Space和From Space空间不足时就会发生一次GC，进行GC后，Eden Space和From Space区的存活对象会被挪到To Space，然后将Eden Space和From Space进行清理。

如果To Space无法足够存储某个对象，则将这个对象存储到老生代。在进行GC后，使用的便是Eden Space和To Space了，如此反复循环。当对象在Survivor区躲过一次GC后，其年龄就会+1。默认情况下年龄到达15的对象会被移到老生代中。

典型的垃圾收集器垃圾收集算法是垃圾收集器的理论基础，而垃圾收集器就是其具体实现。下面介绍HotSpot虚拟机提供的几种垃圾收集器。

3.1. Serial/Serial Old 最古老的收集器，是一个单线程收集器，用它进行垃圾回收时，必须暂停所有用户线程。Serial是针对新生代的收集器，采用Copying算法；而Serial Old是针对老生代的收集器，采用Mark-Compact算法。优点是简单高效，缺点是需要暂停用户线程。

ParNew Seral/Serial Old的多线程版本，使用多个线程进行垃圾收集。

Parallel Scavenge 新生代的并行收集器，回收期间不需要暂停其他线程，采用Copying算法。该收集器与前两个收集器不同，主要为了达到一个可控的吞吐量。

Parallel Old Parallel Scavenge的老生代版本，采用Mark-Compact算法和多线程。

CMS Current Mark Sweep收集器是一种以最小回收时间停顿为目标的并发回收器，因而采用Mark-Sweep算法。

G1 G1(Garbage First)收集器技术的前沿成果，是面向服务端的收集器，能充分利用CPU和多核环境。是一款并行与并发收集器，它能够建立可预测的停顿时间模型。

2.cms和g1区别 CMS：以获取最短回收停顿时间为目标的收集器，基于并发“标记清理”实现

过程：

1、初始标记：独占PUC，仅标记GCroots能直接关联的对象

2、并发标记：可以和用户线程并行执行，标记所有可达对象

3、重新标记：独占CPU(STW)，对并发标记阶段用户线程运行产生的垃圾对象进行标记修正

4、并发清理：可以和用户线程并行执行，清理垃圾

优点:

并发，低停顿

缺点：

1、对CPU非常敏感：在并发阶段虽然不会导致用户线程停顿，但是会因为占用了一部分线程使应用程序变慢

2、无法处理浮动垃圾：在最后一步并发清理过程中，用户县城执行也会产生垃圾，但是这部分垃圾是在标记之后，所以只有等到下一次gc的时候清理掉，这部分垃圾叫浮动垃圾

3、CMS使用“标记-清理”法会产生大量的空间碎片，当碎片过多，将会给大对象空间的分配带来很大的麻烦，往往会出现老年代还有很大的空间但无法找到足够大的连续空间来分配当前对象，不得不提前触发一次FullGC，为了解决这个问题CMS提供了一个开关参数，用于在CMS顶不住，要进行FullGC时开启内存碎片的合并整理过程，但是内存整理的过程是无法并发的，空间碎片没有了但是停顿时间变长了

G1：是一款面向服务端应用的垃圾收集器

特点：

1、并行于并发：G1能充分利用CPU、多核环境下的硬件优势，使用多个CPU（CPU或者CPU核心）来缩短stop-The-World停顿时间。部分其他收集器原本需要停顿Java线程执行的GC动作，G1收集器仍然可以通过并发的方式让java程序继续执行。

2、分代收集：分代概念在G1中依然得以保留。虽然G1可以不需要其它收集器配合就能独立管理整个GC堆，但它能够采用不同的方式去处理新创建的对象和已经存活了一段时间、熬过多次GC的旧对象以获取更好的收集效果。也就是说G1可以自己管理新生代和老年代了。

3、空间整合：由于G1使用了独立区域（Region）概念，G1从整体来看是基于“标记-整理”算法实现收集，从局部（两个Region）上来看是基于“复制”算法实现的，但无论如何，这两种算法都意味着G1运作期间不会产生内存空间碎片。

4、可预测的停顿：这是G1相对于CMS的另一大优势，降低停顿时间是G1和CMS共同的关注点，但G1除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用这明确指定一个长度为M毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒

3.stop the world一般怎么处理这个一两句话说不清楚，感兴趣的朋友可以自己上网搜一下教程

4.判断对象是否存活判断对象是否存活一般有两种方式：

引用计数：每个对象有一个引用计数属性，新增一个引用时计数加1，引用释放时计数减1，计数为0时可以回收。此方法简单，无法解决对象相互循环引用的问题。

可达性分析（Reachability Analysis）：从GC Roots开始向下搜索，搜索所走过的路径称为引用链。当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的。不可达对象。

在Java语言中，GC Roots包括：

虚拟机栈中引用的对象。

方法区中类静态属性实体引用的对象。

方法区中常量引用的对象。

本地方法栈中JNI引用的对象。

二、计算机网络： 1.tcp三次握手四次挥手过程及各个状态三次握手第一次握手：主机A发送位码为syn＝1,随机产生seq number=10001的数据包到服务器，主机B由SYN=1知道，A要求建立联机，此时状态为SYN_SENT；第二次握手：主机B收到请求后要确认联机信息，向A发送ack number=(主机A的seq+1),syn=1,ack=1,随机产生seq=20001的包，此时状态由LISTEN变为SYN_RECV；第三次握手：主机A收到后检查ack number是否正确，即第一次发送的seq number+1,以及位码ack是否为1，若正确，主机A会再发送ack number=(主机B的seq+1),ack=1，主机B收到后确认seq值与ack=1则连接建立成功，双方状态ESTABLISHED。

完成三次握手，主机A与主机B开始传送数据

各个状态名称与含义

CLOSED: 这个没什么好说的了，表示初始状态。 LISTEN: 这个也是非常容易理解的一个状态，表示服务器端的某个SOCKET处于监听状态，可以接受连接了。 SYN_RECV: 这个状态表示接受到了SYN报文，在正常情况下，这个状态是服务器端的SOCKET在建立TCP连接时的三次握手会话过程中的一个中间状态，很短暂，基本上用netstat你是很难看到这种状态的，除非你特意写了一个客户端测试程序，故意将三次TCP握手过程中最后一个ACK报文不予发送。因此这种状态时，当收到客户端的ACK报文后，它会进入到ESTABLISHED状态。 SYN_SENT: 这个状态与SYN_RECV遥想呼应，当客户端SOCKET执行CONNECT连接时，它首先发送SYN报文，因此也随即它会进入到了SYN_SENT状态，并等待服务端的发送三次握手中的第2个报文。SYN_SENT状态表示客户端已发送SYN报文。 ESTABLISHED：这个容易理解了，表示连接已经建立了。

四次挥手

FIN_WAIT_1: 这个状态要好好解释一下，其实FIN_WAIT_1和FIN_WAIT_2状态的真正含义都是表示等待对方的FIN报文。而这两种状态的区别是：FIN_WAIT_1状态实际上是当SOCKET在ESTABLISHED状态时，它想主动关闭连接，向对方发送了FIN报文，此时该SOCKET即进入到FIN_WAIT_1状态。而当对方回应ACK报文后，则进入到FIN_WAIT_2状态，当然在实际的正常情况下，无论对方何种情况下，都应该马上回应ACK报文，所以FIN_WAIT_1状态一般是比较难见到的，而FIN_WAIT_2状态还有时常常可以用netstat看到。

FIN_WAIT_2：上面已经详细解释了这种状态，实际上FIN_WAIT_2状态下的SOCKET，表示半连接，也即有一方要求close连接，但另外还告诉对方，我暂时还有点数据需要传送给你，稍后再关闭连接。

TIME_WAIT: 表示收到了对方的FIN报文，并发送出了ACK报文，就等2MSL后即可回到CLOSED可用状态了。如果FIN_WAIT_1状态下，收到了对方同时带 FIN标志和ACK标志的报文时，可以直接进入到TIME_WAIT状态，而无须经过FIN_WAIT_2状态。

CLOSING: 这种状态比较特殊，实际情况中应该是很少见，属于一种比较罕见的例外状态。正常情况下，当你发送FIN报文后，按理来说是应该先收到（或同时收到）对方的 ACK报文，再收到对方的FIN报文。但是CLOSING状态表示你发送FIN报文后，并没有收到对方的ACK报文，反而却也收到了对方的FIN报文。什么情况下会出现此种情况呢？其实细想一下，也不难得出结论：那就是如果双方几乎在同时close一个SOCKET的话，那么就出现了双方同时发送FIN报文的情况，也即会出现CLOSING状态，表示双方都正在关闭SOCKET连接。

CLOSE_WAIT: 这种状态的含义其实是表示在等待关闭。怎么理解呢？当对方close一个SOCKET后发送FIN报文给自己，你系统毫无疑问地会回应一个ACK报文给对方，此时则进入到CLOSE_WAIT状态。接下来呢，实际上你真正需要考虑的事情是察看你是否还有数据发送给对方，如果没有的话，那么你也就可以 close这个SOCKET，发送FIN报文给对方，也即关闭连接。所以你在CLOSE_WAIT状态下，需要完成的事情是等待你去关闭连接。 LAST_ACK: 这个状态还是比较容易好理解的，它是被动关闭一方在发送FIN报文后，最后等待对方的ACK报文。当收到ACK报文后，也即可以进入到CLOSED可用状态了。

为什么建立连接协议是三次握手，而关闭连接却是四次握手呢？这是因为服务端的LISTEN状态下的SOCKET当收到SYN报文的建连请求后，它可以把ACK和SYN（ACK起应答作用，而SYN起同步作用）放在一个报文里来发送。但关闭连接时，当收到对方的FIN报文通知时，它仅仅表示对方没有数据发送给你了；但未必你所有的数据都全部发送给对方了，所以你可以未必会马上会关闭SOCKET,也即你可能还需要发送一些数据给对方之后，再发送FIN报文给对方来表示你同意现在可以关闭连接了，所以它这里的ACK报文和FIN报文多数情况下都是分开发送的。

为什么TIME_WAIT状态还需要等2MSL后才能返回到CLOSED状态？因为虽然双方都同意关闭连接了，而且握手的4个报文也都发送完毕，按理可以直接回到CLOSED 状态(就好比从SYN_SENT 状态到ESTABLISH 状态那样)，但是我们必须假想网络是不可靠的，你无法保证你(客户端)最后发送的ACK报文一定会被对方收到，就是说对方处于LAST_ACK 状态下的SOCKET可能会因为超时未收到ACK报文，而重发FIN报文，所以这个TIME_WAIT 状态的作用就是用来重发可能丢失的ACK报文。

关闭TCP连接一定需要4次挥手吗? 不一定，4次挥手关闭TCP连接是最安全的做法。但在有些时候，我们不喜欢TIME_WAIT 状态(如当MSL数值设置过大导致服务器端有太多TIME_WAIT状态的TCP连接，减少这些条目数可以更快地关闭连接，为新连接释放更多资源)，这时我们可以通过设置SOCKET变量的SO_LINGER标志来避免SOCKET在close()之后进入TIME_WAIT状态，这时将通过发送RST强制终止TCP连接(取代正常的TCP四次握手的终止方式)。但这并不是一个很好的主意，TIME_WAIT 对于我们来说往往是有利的。

2.accept connect listen对应三次握手什么阶段 Connect（）函数：是一个阻塞函数通过TCp三次握手父服务器建立连接客户端主动连接服务器建立连接方式通过TCP三次握手通知Linux内核自动完成TCP 三次握手连接如果连接成功为0 失败返回值-1

一般的情况下客户端的connect函数默认是阻塞行为直到三次握手阶段成功为止。

2.服务器端的listen() 函数：不是一个阻塞函数：功能：将套接字和套接字对应队列的长度告诉Linux内核

他是被动连接的一直监听来自不同客户端的请求 listen函数只要作用将socketfd 变成被动的连接监听socket 其中参数backlog作用设置内核中队列的长度。

3.accept() 函数阻塞：从处于established 状态的队列中取出完成的连接当队列中没有完成连接时候会形成阻塞，直到取出队列中已完成连接的用户连接为止。

问题一：服务器没有及时调用accept函数取走完成连接的队列怎么办？

服务器的连接队列满掉后，服务器不会对再对建立新连接的syn进行应答，所以客户端的 connect 就会返回 ETIMEDOUT。但实际上Linux的并不是这样的当TCP连接队列满了之后 Linux并不会书中所说的拒绝连接，只是会延时连接。

三、操作系统： 1.linux c程序布局一个程序本质上都是由 BSS 段、data段、text段三个组成的。可以看到一个可执行程序在存储（没有调入内存）时分为代码段、数据区和未初始化数据区三部分。

BSS段(未初始化数据区)：在采用段式内存管理的架构中，BSS段（bss segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。数据段：在采用段式内存管理的架构中，数据段（data segment）通常是指用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。代码段：在采用段式内存管理的架构中，代码段（text segment）通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，并且内存区域属于只读。在代码段中，也有可能包含一些只读的常数变量，例如字符串常量等。程序编译后生成的目标文件至少含有这三个段，这三个段的大致结构图如下所示：

text段和data段在编译时已经分配了空间，而BSS段并不占用可执行文件的大小，它是由链接器来获取内存的。

bss段（未进行初始化的数据）的内容并不存放在磁盘上的程序文件中。其原因是内核在程序开始运行前将它们设置为0。需要存放在程序文件中的只有正文段和初始化数据段。

data段（已经初始化的数据）则为数据分配空间，数据保存到目标文件中。

数据段包含经过初始化的全局变量以及它们的值。BSS段的大小从可执行文件中得到，然后链接器得到这个大小的内存块，紧跟在数据段的后面。当这个内存进入程序的地址空间后全部清零。包含数据段和BSS段的整个区段此时通常称为数据区。

可执行程序在运行时又多出两个区域：栈区和堆区。

（4）栈区：由编译器自动释放，存放函数的参数值、局部变量等。每当一个函数被调用时，该函数的返回类型和一些调用的信息被存放到栈中。然后这个被调用的函数再为他的自动变量和临时变量在栈上分配空间。每调用一个函数一个新的栈就会被使用。栈区是从高地址位向低地址位增长的，是一块连续的内存区域，最大容量是由系统预先定义好的，申请的栈空间超过这个界限时会提示溢出，用户能从栈中获取的空间较小。

（5）堆区：用于动态分配内存，位于BSS和栈中间的地址区域。由程序员申请分配和释放。堆是从低地址位向高地址位增长，采用链式存储结构。频繁的 malloc/free造成内存空间的不连续，产生碎片。当申请堆空间时库函数是按照一定的算法搜索可用的足够大的空间。因此堆的效率比栈要低的多。

下图将体现c的源文件对应存储空间：

此时程序还没有被放入内存，只是在硬盘存储的情况，此时bss并未占用空间。bss在链接的时候被获得内存空间。

下图表示程序运行，即程序在内存时的存储布局：

四、智力题：一枚硬币不均匀，如何把他设计成公平硬币（拒绝采样）这个题留给你们自己思考，发散一下思维，毕竟谁还没被智力题欺负过呢！

五、算法及数据结构：堆排序建堆及排序过程这里只简单的提一下吧建堆从第一个非叶子结点开始向下交换（即每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换(交换之后可能造成被交换的孩子节点不满足堆的性质，因此每次交换之后要重新对被交换的孩子节点进行调整)。有了初始堆之后就可以进行排序了）排序排序过程为取出堆顶元素的操作，实现细节（取出堆顶元素与堆尾元素交换，将堆顶元素向下调整堆———在每一个调整过程中当不向下调整时即为调整结束）。取出的顺序为先第一个非叶子结点，第二个非叶子结点…一直到堆顶

这里还问了一下堆调整的时间复杂度，关于这个也不赘述了

手撕：最长无重复子串思路与解法思路1：暴力法，实际解题中不会使用暴力法，这并不代表我们可以忽略它。索引从字符串的第一位开始，将后面的字符依次加入到 set 里面。如果 set 里面已经有了该字符，此次循环结束，内循环结束后记录 size。字符串的每一位都用这种方法去计算，得到的最大的 size 即是答案。代码如下（不是Java的也看得懂，我进行了关键语法的注释，下同）

public int lengthOfLongestSubstring(String s) { int maxLen = 0; for(int i = 0; i < s.length(); i++){ // 创建一个存放字符的集合 HashSet set = new HashSet<>(); for(int j = i; j < s.length(); j++) { // 判断集合是否存在第 j 个字符 if(set.contains(s.charAt(j))) break; set.add(s.charAt(j)); } maxLen = Math.max(maxLen,set.size()); } return maxLen; }

复制代码这里也只贴这一种解法吧，还有很多种有趣的解法，大伙也可以发散一下思维。

二面：1小时10分钟项目：设计思路，遇到的最大问题，怎么保证分布式情况下主键全局唯一（项目聊了很久很久....）场景题：大量主机向一台服务器发送消息，怎么保证性能（当时没太懂什么意思，就谈了谈io模型，被问用没用过epoll）

计算机网络： 1.同tcp三次四次老八股这个前面说了，这里就跳过了

2.tcp keep alive实现原理其实 keepalive 的原理就是 TCP 内嵌的一个心跳包以服务器端为例，如果当前 server 端检测到超过一定时间（默认是 7,200,000 milliseconds ，也就是 2 个小时）没有数据传输，那么会向client 端发送一个 keep-alive packet （该 keep-alive packet 就是 ACK 和当前 TCP 序列号减一的组合），此时 client 端应该为以下三种情况之一：

client 端仍然存在，网络连接状况良好。此时 client 端会返回一个 ACK 。 server 端接收到 ACK 后重置计时器，在 2 小时后再发送探测。如果 2 小时内连接上有数据传输，那么在该时间基础上向后推延 2 个小时。

客户端异常关闭，或是网络断开。在这两种情况下， client 端都不会响应。服务器没有收到对其发出探测的响应，并且在一定时间（系统默认为 1000 ms ）后重复发送 keep-alive packet ，并且重复发送一定次数（ 2000 XP 2003 系统默认为 5 次 , Vista 后的系统默认为 10 次）。

客户端曾经崩溃，但已经重启。这种情况下，服务器将会收到对其存活探测的响应，但该响应是一个复位，从而引起服务器对连接的终止。

3.tcp粘包 www.cnblogs.com/sui77626523…

三面：1小时项目：问了所有项目，设计思路，遇到最大的困难

这一块你如实说自己的经历就可以了，没什么好说的

操作系统： 1.复盘了一面没答好的malloc（从内存布局，空闲块链表分配算法以及系统调用全都说了一遍） 2.copyonwrite CopyOnWrite 思想写入时复制（CopyOnWrite，简称COW）思想是计算机程序设计领域中的一种通用优化策略。其核心思想是，如果有多个调用者（Callers）同时访问相同的资源（如内存或者是磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者修改资源内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这过程对其他的调用者都是透明的（transparently）。此做法主要的优点是如果调用者没有修改资源，就不会有副本（private copy）被创建，因此多个调用者只是读取操作时可以共享同一份资源。

通俗易懂的讲，写入时复制技术就是不同进程在访问同一资源的时候，只有更新操作，才会去复制一份新的数据并更新替换，否则都是访问同一个资源。

JDK 的 CopyOnWriteArrayList/CopyOnWriteArraySet 容器正是采用了 COW 思想，它是如何工作的呢？简单来说，就是平时查询的时候，都不需要加锁，随便访问，只有在更新的时候，才会从原来的数据复制一个副本出来，然后修改这个副本，最后把原数据替换成当前的副本。修改操作的同时，读操作不会被阻塞，而是继续读取旧的数据。这点要跟读写锁区分一下。

源码分析我们先来看看 CopyOnWriteArrayList 的 add() 方法，其实也非常简单，就是在访问的时候加锁，拷贝出来一个副本，先操作这个副本，再把现有的数据替换为这个副本。

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

复制代码 CopyOnWriteArrayList 的 get(int index) 方法就是普通的无锁访问。

public E get(int index) {
    return get(getArray(), index);
}

@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
    return (E) a[index];
}

复制代码优点和缺点 1.优点对于一些读多写少的数据，写入时复制的做法就很不错，例如配置、黑名单、物流地址等变化非常少的数据，这是一种无锁的实现。可以帮我们实现程序更高的并发。

CopyOnWriteArrayList 并发安全且性能比 Vector 好。Vector 是增删改查方法都加了synchronized 来保证同步，但是每个方法执行的时候都要去获得锁，性能就会大大下降，而 CopyOnWriteArrayList 只是在增删改上加锁，但是读不加锁，在读方面的性能就好于 Vector。

2.缺点数据一致性问题。这种实现只是保证数据的最终一致性，在添加到拷贝数据而还没进行替换的时候，读到的仍然是旧数据。

内存占用问题。如果对象比较大，频繁地进行替换会消耗内存，从而引发 Java 的 GC 问题，这个时候，我们应该考虑其他的容器，例如 ConcurrentHashMap

计算机网络： 1.如何在应用层保证udp可靠传输 2.https和http区别以及https的ssl握手机制 3.https为什么要采用对称和非对称加密结合的方式

智力题： 1.rand5到rand7，算是拒绝采样吧，和一面思路很像 2.有32个大小相同的石头，有一把称，请问最少称多少次可以找出质量最大的石头第二大呢第n大呢

手撕：蛇形遍历数组

谈心：平常看什么书，看哪些技术网站能干多久反问

hr面这个没什么好说的，扯不到技术，就随便聊聊，别把天聊死了就行。

没被问到数据库有点诧异，毕竟准备最充分的就是数据库，明显感觉部门重视操作系统和计算机网络，算法无论是手撕还是口述都有，所以还是需要重视

©著作权归作者所有：来自51CTO博客作者Java俱乐部的原创作品，请联系作者获取转载授权，否则将追究法律责任字节跳动Java岗一二三面全经过分享 blog.51cto.com/u_15157097/… 一.计算机网络

①http和https有什么区别？
没回答出来。https是ssl(安全套接层+http，加密版本)
②数字证书有哪些？
没看过这个知识点，讲了一下公钥体系。
③http有哪些版本，区别？
0.9/1.0/1.1/2.0，我说成1.2而且只知道持久连接。
0.9是原始版本，只有get操作。
1.0新增了post，head操作，增加了状态码等。一般是一个请求一个连接。有keepalive。
1.1增加了持久连接，全二进制，管道，put，delete，options等请求方式。
2.0增加了双工，数据流等。
④TCP和IP属于什么层？TCP挥手握手？
终于有个会的了
⑤TCP可靠传输的机制？窗口的含义是什么？
回答窗口协议，可重传，连接建立。

二.操作系统

①介绍一下linux内存模型
？懵逼我只懂Java内存模型。
好像分为内核虚拟储存器，用户栈，文件映射区，运行时堆，读写段，只读段，保留区
②介绍一下页表
③单cpu单核处理器，多线程需要加锁吗？
要
④一些数据在磁盘上，要发送到网络上，要经过哪些过程？
并不懂。
NIO零拷贝
⑤介绍一下BIO, NIO, AIO
胡扯一通。
阻塞, 阻塞同步, 非阻塞同步, 异步

三.数据库

①中间件那些有了解吗？没有我就跳过了
②sql数据库引擎有了解吗？
③数据库锁有了解吗？

讲道理一般的面试到这里就应该开始和你聊人生了。跳动的面试官面无表情继续问，真敬业

四. Java

①字节对齐如何实现有什么作用，举个例子。
②介绍一下泛型擦除
③map原理，1.8以后呢？
④介绍一下可重入锁原理
⑤讲一下虚拟机如何加载. class文件，双亲委派

五.数据结构

①红黑树规定，插入删除如何操作？
②广度优先搜索用到什么数据结构？

**六.编程题
**

15分钟内要能运行
深度优先遍历，思路比较容易想到，关键要熟练

写了10分钟，面试官准时打卡下班，问了几个问题。面试官心想拜拜咧您。
感觉收获挺多大的。

顺便讲刚刚面试云从科技，在人工智能岛上(还真是四面环水)，上面还有阿里微软IBM这些公司，大厂进不了在门口看看也不错。环境挺好，而且跳槽方便，出门右拐就到。
一面面试官察觉到我基础不太行，为了避免时间太短还给我讲起了机器学习，第二个面试官基本谈人生，人都很好。

到此这篇关于字节跳动Java后端视频面一面凉经的文章就介绍到这了,更多相关字节跳动Java后端面试内容请搜索脚本之家以前的文章或继续浏览下面的相关文章，希望大家以后多多支持脚本之家！作者：程序杰杰
链接：www.nowcoder.com/discuss/614…
来源：牛客网
\

1先聊聊你的项目吧

e...\

2多个线程开启，设置随机时间，如何安全的让所有线程停止？别说，写出了。

呃...\

CountDownLatch\

CycleBarrier

面试官：await底层实现原理？\

我：我只知道线程执行完之前，会阻塞等待，和Object的wait与lock的...\

面试官：停，我问的是底层实现原理\

我：不知道...\

3.那如果我想让时间最短的停止之后，安全的通知其他线程停止呢，同时主线程也要安全的停止？

呃..\

线程池有一个shutdown方法可以安全\

面试官：还有吗？

我：不知道了\

4.那说一说进程和线程之间的区别吧。

面试官：ok，那进程之间的通讯呢？\

面试官：ok，共享内存如何实现的？\

我：用户态不同进程共享同一片内存空间\

面试官：你确定？\

我：差不多吧\

面试官：行吧\

4.我看你简历上有关于redis的，那你说说redis网络模型吧。

我：对不起面试官，我只是简单用过redis

面试官：好吧，那出一到题来做做吧\

我：（内心想，这还用做？已经没戏了，好吧，做做吧，结果做的也不太好，完了啊心态崩了吧）\

算法题目如下：

在微服务的架构下，公司内部会有非常多的独立服务。服务之间可以相互调用，往往大型应用调用链条很长，如果出现循环依赖将出现非常恶劣的影响。对于一个具体应用，已知各个服务的调用关系（即依赖关系），请判断是否存在循环调用。输入：一组服务依赖关系list，('A', 'B') 表示 A 会调用 B 服务service_relations = [['A', 'B'], ['A', 'C'], ['B', 'D'], ['D', 'A']] 输出：由于存在 A - B - D - A 故存在循环依赖，返回True；反之如果不存在，返回False

（题目刷题刷多了的应该不太难吧，感觉和我秋招时候看过的题好像啊，最后思路说出来了，写完了时间到了）

面试官：那今天就到这里，后序如果有的话，HR会通知你

我：好的（心想：都如果了，还有谁能通知我，再见，春招就找这一个，拉到就算了，写论文去了，拜拜）

\1. 自我介绍

介绍下项目流程，在项目中用到了哪些技术
怎么设计自己的系统框架
说下乐观锁与悲观锁，分别有哪些应用场景
怎么处理死锁
写两个stack实现queue的代码
说一下你记得的排序算法

二面：【60min】
我以为一面结束之后我就可以走了，结果让我稍等一下，会有第二位面试官来给我二面，是技术面。\

自我介绍
说下进线和线程有什么区别
synchronize和lock有什么区别
mysql发生了死锁该怎么处理
Java垃圾回收机制了解吗
hashmap的原理
算法题：有100瓶液体，其中一瓶是毒药，一只小白鼠喝到毒药一周后就会死亡。请问给我一周时间，至少需要多少只小白鼠能确定哪瓶是毒药？（把瓶子序号变成二进制）

三面【30min】
三面的面试官很友好，没有我什么面试题。\

说下oracle有什么作用
说下你聘用的职位是做什么的
谈谈对项目的理解
怎么开展一个项目

最后：
整个面试过程用了半天的时间。Hr让我回家等消息，在第二天的晚上我等来了offer~。收获真的挺大的，了解到了各个一线互联网公司现在的工作环境和状态。入职之后努力加油。希望看到文章你，也能拿到满意的offer~ 目录技术一面（算法）技术二面技术三面 JAVA开发技术面试中可能问到的问题面试注意点一、字节跳动技术一面（算法） Java 的 16 进制与字符串的相互转换函数 JAVA 时间格式化处理将毫秒转化为日期文本的倒序输出判断一个数字是奇数还是偶数用Hibernate 实现分页 35 选 7 彩票程序获取 GMT8 时间中文乱码转换小标签 Big5 字与 Unicode 的互换取得服务器当前的各种具体时间用半角的特殊符号代替全角的特殊符号数组和数组之间的转换代码从资源文件里读取值的类一个随机类计算传入值是否星期六转换文件大小 Java 日期格式化及其使用例子 Java几个常用方法判断字符是否属于中文去掉字符串中重复的子字符串将指定 byte 数组以 16 进制的形式打印到控制台获得任意一个整数的阶乘，递归拷贝一个目录或者文件到指定路径下简单的 txt 转换 xml 字母排序(A-Z)(先大写，后小写) 列出某文件夹及其子文件夹下面的文件，并可根据扩展名过滤字符串匹配的算法二、字节跳动技术二面 List和Set比较，各自的子类比较 HashMap和ConcurrentHashMap的区别 HashTable和ConcurrentHashMap的区别 String,StringBuffer和StringBuilder的区别 wait和sleep的区别 JVM的内存结构强引用，软引用和弱引用的区别数组在内存中如何分配 Spring MVC的核心是什么，请求的流程是怎么处理的，控制反转怎么实现的 Mybatis如何处理结果集 Java的多态表现在哪里接口有什么用说说http,https协议说说tcp/ip协议族 tcp五层网络协议 TCP与UDP的区别 cookie和session的区别，分布式环境怎么保存用户状态 BIO、NIO和AIO的区别 Java中常说的堆和栈，分别是什么数据结构；另外，为什么要分为堆和栈来存储数据为什么要用线程池 MySQL优化经验悲观锁和乐观锁的区别，怎么实现什么是线程死锁？死锁如何产生？如何避免线程死锁？ notify和notifyAll区别谈一谈对MySQL InnoDB的认识谈一谈数据库事务的隔离级别？ MySQL主备同步的基本原理类在虚拟机中的加载过程强引用、软引用、弱引用、虚引用与GC的关系请写一段栈溢出、堆溢出的代码三、字节跳动技术三面说一下spring中Bean的作用域说一下spring中Bean的生命周期对Spring中依赖注入两种方式的认识 Spring框架中都用到了哪些设计模式？ BeanFactory 和ApplicationContext的区别数据库的三大范式 TCP和UDP的区别及其适用场景说一下Spring的核心模块（转发）forward与（重定向）redirect的区别 redis常用的五种数据类型内部类和静态内部类的区别非静态内部类中的变量和方法不能声明为静态的原因 String，StringBuilder，StringBuffer的区别集合和数组之间的相互转换面向对象的特征有哪些方面? 概括的解释下线程的几种状态 Java集合类里面基本的接口有哪些 Iterator和ListIterator的区别 Enumeration和Iterator的区别介绍一下HTTP的响应结构 final、finalize和finally各自的作用说一下你了解的几种进程间的通信方式四、JAVA开发技术面试中可能问到的问题

基础知识

集合类：List和Set比较，各自的子类比较（ArrayList，Vector，LinkedList；HashSet，TreeSet）； HashMap的底层实现，之后会问ConcurrentHashMap的底层实现；如何实现HashMap顺序存储：可以参考LinkedHashMap的底层实现； HashTable和ConcurrentHashMap的区别； String,StringBuffer和StringBuilder的区别； Object的方法有哪些：比如有wait方法，为什么会有； wait和sleep的区别，必须理解； JVM的内存结构，JVM的算法；强引用，软引用和弱引用的区别；数组在内存中如何分配；用过哪些设计模式，手写一个（除单例）； springmvc的核心是什么，请求的流程是怎么处理的，控制反转怎么实现的； spring里面的aop的原理是什么； mybatis如何处理结果集：反射，建议看看源码； java的多态表现在哪里；接口有什么用；说说http,https协议； tcp/ip协议簇； osi五层网络协议； tcp，udp区别；用过哪些加密算法：对称加密，非对称加密算法；说说tcp三次握手，四次挥手； cookie和session的区别，分布式环境怎么保存用户状态； git，svn区别；请写一段栈溢出、堆溢出的代码； ThreadLocal可以用来共享数据吗； 2. IO

bio，nio，aio的区别； nio框架：dubbo的实现原理；京东内部的jsf是使用的什么协议通讯：可参见dubbo的协议； 3. 算法

java中常说的堆和栈，分别是什么数据结构；另外，为什么要分为堆和栈来存储数据。 TreeMap如何插入数据：二叉树的左旋，右旋，双旋；一个排序之后的数组，插入数据，可以使用什么方法？答：二分法；问：时间复杂度是多少？平衡二叉树的时间复杂度； Hash算法和二叉树算法分别什么时候用；图的广度优先算法和深度优先算法：详见jvm中垃圾回收实现； 4. 多线程

说说阻塞队列的实现：可以参考ArrayBlockingQueue的底层实现（锁和同步都行）；进程通讯的方式：消息队列，共享内存，信号量，socket通讯等；用过并发包的哪些类；什么地方用了多线程； Excutors可以产生哪些线程池；为什么要用线程池； volatile关键字的用法：使多线程中的变量可见； 5. 数据库相关（MySQL）

MySQL优化经验： MySQL的语句优化，使用什么工具； MySQL的索引分类：B+，hash；什么情况用什么索引； MySQL的存储引擎有哪些，区别是什么；说说事务的特性和隔离级别；悲观锁和乐观锁的区别，怎么实现； 6. Mq

mq的原理是什么：有点大。。都可以说； mq如何保证实时性； mq的持久化是怎么做的； 7. Redis

redis和memcache的区别；用redis做过什么； redis是如何持久化的：rdb和aof； redis集群如何同步； redis的数据添加过程是怎样的：哈希槽； redis的淘汰策略有哪些； redis有哪些数据结构； 8. Zookeeper

zookeeper是什么； zookeeper哪里用到； zookeeper的选主过程； zookeeper集群之间如何通讯；你们的zookeeper的节点加密是用的什么方式；分布式锁的实现过程； 9. Linux

linux常用的命令有哪些；如何获取java进程的pid；如何获取某个进程的网络端口号；如何实时打印日志；如何统计某个字符串行数；五、面试注意点至少定出2天的准备时间一定得再次阅读公司的职位要求在刷题前，先准备项目描述的说辞一定得准备项目描述里提到的技术一定得准备亮点话题，并想办法往这方面绕，而且亮点话题多多益善时间多，再去刷题面试题，通过准备让面试官感觉你软实力也行

©著作权归作者所有：来自51CTO博客作者未来可期_的原创作品，请联系作者获取转载授权，否则将追究法律责任圆你的大厂梦!字节跳动Java高频面试题真题:一/二/三面+常见问题 blog.51cto.com/u_14637764/… 作者：牛客559491978号
链接：www.nowcoder.com/discuss/686…
来源：牛客网
\

抖音

感觉头条不怎么问项目，或许是我项目太low了，比较喜欢问计算机基础和中间件知识

一面

1.http请求头，expire，cache-control字段，状态码，301，302，401，403

2.https原理，数字签名，数字证书，非对称加密算法过程，有什么问题

3.tcp连接client和server有哪些状态，time_wait状态

4.虚拟内存，虚拟地址和物理地址怎么转换，内存分段，内存分页，优缺点

5.linux最多可以建立多少个tcp连接，client端，server端，超过了怎么办

6.eureka原理，强一致性么，为什么，怎么保证强一致性，多级缓存怎么保证一致性，eureka集群，宕机了服务还能调用么

7.hystrix原理，半开状态知道么，具体的一个转换过程，它的隔离是怎么实现的

8.zookeeper一致性保证，zab协议原理，半数原则如果查询到另外一半呢，那zookeeper属于哪种一致性，强一致性么，还是最终一致性

9.zookeeper选举机制，选举过程有什么问题

算法：最长不重复的连续子串

聊天：头条为什么用go，对java和go怎么看，愿意转go么

一面

算法题，给了长度为 N 的有重复元素的数组，要求输出第 10 大的数。

需要在 2 小时内完成。

二面

自我介绍

目前在部门做什么，业务简单介绍下，内部有哪些系统，作用和交互过程说下

Dubbo 踩过哪些坑，怎么解决的？

对线程安全的理解

乐观锁和悲观锁的区别？

这两种锁在 Java 和 MySQL 分别是怎么实现的？

事务有哪些特性？

怎么理解原子性？

HashMap 为什么不是线程安全的？

怎么让 HashMap 变得线程安全？

jdk1.8 对 ConcurrentHashMap 做了哪些优化？

redis 主从机制了解么？怎么实现的？

有过 GC 调优的经历么？

有什么想问的

三面

自我介绍

接下来就是全部问的项目，对自己的项目细节逐个盘问，最后问了下如何改进方案

有什么想问我么？

四面

介绍下自己

问项目

说说 Spring 的生命周期吧

说说 GC 的过程

强制 young gc 会有什么问题？

知道 G1 么？

回收过程是怎么样的？

你提到的 Remember Set 底层是怎么实现的？

CMS GC 有什么问题？

怎么避免产生浮动垃圾？

有什么想问的么？

五面

HRBP 面，主要聊了部门在做的事情、职业发展、福利待遇等。阿里面试官有一票否决权，很看重你的价值观是否 match。

HR 面一定要诚实，不要说谎，只要你说谎 HR 都会去证实。

最后 HR 还对我说目前稳定性保障部挺缺人的，希望我尽快回复。

小结

蚂蚁面试比较重视基础，所以 Java 那些基本功一定要扎实。

拼多多

一面

聊项目

Java 中的 HashMap、TreeMap 解释下？

TreeMap 查询写入的时间复杂度多少？

ConcurrentHashMap 怎么实现线程安全的？

HashMap 多线程有什么问题？怎么解决？

CAS 和 synchronize 有什么区别？都用 synchronize 不行么？

get 需要加锁么，为什么？

volatile 的作用是什么？

给我一张纸，画了一个九方格，都填了数字，给一个 MN 矩阵，从 1 开始逆时针打印这 MN 个数，要求时间复杂度尽可能低，可以先说下思路

有什么想问我的？

二面

自我介绍下

手上还有其他 offer 么？

部门组织结构是怎样的？

系统有哪些模块，每个模块用了哪些技术，数据怎么流转的？给了我一张纸，我在上面简单画了下系统之间的流转情况

链路追踪的信息是怎么传递的？

SpanId 怎么保证唯一性？

RpcContext 是在什么维度传递的？

Dubbo 的远程调用怎么实现的？

Spring 的单例是怎么实现的？

为什么要单独实现一个服务治理框架？

谁主导的？内部还在使用么？

逆向有想过怎么做成通用么？

有什么想问的

HR 面

主要问了些职业发展、是否有其他 offer、以及入职意向等问题，顺便说了下公司的福利待遇等，手上有其他 offer 或者大厂经历会有一定加分。

字节跳动

一面

自我介绍

聊项目

Redis 熟悉么，了解哪些数据结构? zset 底层怎么实现的?

红黑树了解么，时间复杂度?

既然两个数据结构时间复杂度都是 O(logN)，zset 为什么不用红黑树

线程池的线程数怎么确定？

如果是 IO 操作为主怎么确定？

如果计算型操作又怎么确定？

跳表的查询过程是怎么样的，查询和插入的时间复杂度?

说下 Dubbo 的原理?

CAS 了解么？还了解其他同步机制么？

做题：数组 A，2*n 个元素，n 个奇数、n 个偶数，设计一个算法，使得数组奇数下标位置放置的都是奇数，偶数下标位置放置的都是偶数。先说下你的思路

你有什么想问我的？

二面

自我介绍

问项目

分布式追踪的上下文是怎么存储和传递的？

SpringMVC 不同用户登录的信息怎么保证线程安全的？

我们聊聊 mysql 吧，说下索引结构，为什么使用 B+树？

Dubbo 的 RpcContext 是怎么传递的？主线程的 ThreadLocal 怎么传递到线程池？你说的内存泄漏具体是怎么产生的？

线程池的线程是不是必须手动 remove 才可以回收 value？那你说的内存泄漏是指主线程还是线程池？

什么是索引覆盖？

Java 为什么要设计双亲委派模型？

什么时候需要自定义类加载器？

做题：手写一个对象池

有什么想问我的

小结

头条的面试确实很专业，而且面试官最后给我了一点建议，就是研究技术的时候一定要结合技术的背景。

面试官都有一个特点，会抓住一个值得深入的点或者你没说清楚的点深入下去直到你把这个点讲清楚，不然面试官会觉得你并没有真正理解。字节跳动技术一面讲一下线程参数的含义 Innodb的索引实现为什么是B+树？ Redis的使用，分布式锁的实现操作系统虚拟内存换页的过程 TCP三次握手 volatile关键字的作用乐观锁、悲观锁之前用过哪些设计模式？算法题：滑动窗口字节跳动技术二面说一下B树和B+树的区别说一下HashMap的实现，扩容机制，扩容时如何保证可操作？ Redis扩容机制（渐进式单线程扩容） Spring IoC的原理，如何实现，如何解决循环依赖？两线程对变量i进行加1操作，结果如何？为什么？怎么解决？ CAS概念、原子类实现原理 synchronize底层实现，如何实现Lock？ AQS有什么特点？手写项目中某个模块代码。介绍各种网络协议。 DNS在网络层用哪个协议，为什么。介绍HTTPS协议，详述SSL建立连接过程。代码题：反转单链表。代码题：复杂链表复制。字节跳动技术三面算法题多到爆炸，感觉是算法专场，宇宙条果真名不虚传说一下Java垃圾回收机制 64匹马，8个赛道，找最快的4匹马给出两个升序数组A、B和长度m、n，求第k个大的给出数组A，长度为n，数组中元素的值位于[0, n - 1]之间，求是否有重复元素讲一下多线程与多进程区别 JVM中什么时候会进行垃圾回收？什么样的对象是可以回收的？ Spring主要思想是什么？字节跳动技术四面场景题目：设计一个短域名服务：短信存不了太长网站，需要弄成短域名，你该如何设计一个服务，可以为全国的网址服务。 TCP为什么是三次握手四次挥手？数据库的隔离级别 sql题，写了个连表查询外加模糊查询算法：镜像二叉树 ...... 4月11号邮件收到信息，HR直接给了意向书，查收然后确认好了，确定了入职时间 ———————————————— 版权声明：本文为CSDN博主「普通网友」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：blog.csdn.net/Java_may/ar… 作者：努力吧！少年
链接：www.nowcoder.com/discuss/531…
来源：牛客网
\

自我介绍。介绍自己的项目经历以及一些特长而不是简单自我介绍喜好等

Java基础

1、重载和重写的区别。

2、String 和 StringBuffer、StringBuilder 的区别是什么？String 为什么是不可变的？

3、自动装箱与拆箱。

4、== 与 equals。

5、final 关键字。

6、Object类的常见方法。

7、Java 中的异常处理。

8、获取用键盘输入常用的的两种方法。

9、接口和抽象类的区别是什么。

JVM

1、Java 中会存在内存泄漏吗，简述一下？

2、描述一下 JVM 加载 Class 文件的原理机制？

3、什么是tomcat类加载机制？

4、类加载器双亲委派模型机制？

5、垃圾回收常见问题。

6、什么是GC? 为什么要有 GC？

7、简述一下Java 垃圾回收机制？

8、如何判断一个对象是否存活？

9、垃圾回收的优点和原理，并考虑 2 种回收机制？

10、Java 中垃圾收集的方法有哪些？

11、讲讲你理解的性能评价及测试指标？

12、常用的性能优化方式有哪些？

集合框架

1、Arraylist 与 LinkedList 异同。

2、ArrayList 与 Vector 区别。

3、HashMap的底层实现。

4、HashMap 和 Hashtable 的区别。

5、HashMap 的长度为什么是2的幂次方。

6、HashMap 多线程操作导致死循环问题。

7、HashSet 和 HashMap 区别。

8、ConcurrentHashMap 和 Hashtable 的区别。

9、ConcurrentHashMap线程安全的具体实现方式/底层具体实现。

多线程与并发

1、AQS 原理。

2、AQS 对资源的共享方式。

3、AQS底层使用了模板方法模式。

4、说一说自己对于 synchronized 关键字的了解。

5、说说自己是怎么使用 synchronized 关键字，在项目中用到了吗？

6、讲一下 synchronized 关键字的底层原理。

8、说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗？

9、谈谈 synchronized和ReenTrantLock 的区别。

10、说说 synchronized 关键字和 volatile 关键字的区别。

11、为什么要用线程池？

12、实现Runnable接口和Callable接口的区别。

13、执行execute()方法和submit()方法的区别是什么呢？

14、如何创建线程池。

15、介绍一下Atomic 原子类。

16、JUC 包中的原子类是哪4类？

17、讲讲 AtomicInteger 的使用。

18、能不能给我简单介绍一下 AtomicInteger 类的原理？ 5.15 一面(3点开始，80分钟)

1.自我介绍，聊了聊学校近况

2.Java 集合框架，看了哪些源码，arraylist、linkedlist原理，让你实现一个 hashmap 机会如何设计(没让手写😂)

3.线程池的执行过程、核心参数以及常用的几个线程池(感觉每次面试都会问😂)

4.JVM 的相关知识，OOM 如何定位，说几个虚拟机指令以及虚拟机栈可能会发生什么错误，四种引用类型

5.Java 并发，synchronized 性能为什么提高了(锁升级过程)，与 Java 的 lock 有什么区别以及使用场景

6.网络，输入 www.baidu.com 都会发生什么

7.http 报文结构，头部都有哪些字段

8.进程与线程，了解协程吗(大概说了下)

9.死锁了解吗，说一下条件，如何解决

10.让写一下链表实现插入方法(顺序不在这里，忘了在哪了，突然想起来了)，查询效率呢，怎么优化

11.写个算法，给一个表达式的字符串(+-*/)，算出字符串的结果，没考虑括号说了下括号的思路

12.问问题

面试小哥很厉害，比较有耐心。没回答上来的都给耐心讲解，引导着问问题，由浅入深体验极佳😀

面完让稍等一下，十分钟后二面

5.15 二面(45分钟)

1.面试官看着就很厉害，在家办公感觉很忙，上来先问实习的时间以及时长，说最好半年

2.没有自我介绍直接开始，先是网络，TCP 三次握手四次挥手，time_wait 和 close_wait 具体干什么，为什么要三次两次不行吗，有大量连接处于 time_wait 的原因，TCP 是长连接还是短连接

3.Https 了解吗，说一下整个过程(对称加密，非对称加密)，与 http 的不同点

4.进程线程又问了，进程间通信方式(剩下的想不起来)

5.数据库部分知识，手写一个 SQL (子查询感觉主要看 group by 和 having)

6.算法题，最长公共连续子串

一二面顺序可能也是混乱的，记不清楚了，二面面试官感觉好忙啊，写题的时候，他就在忙着敲什么，感觉好不容易啊，一边得面试还在工作😂，体验较好，部分问题也引导着问 ———————————————— 版权声明：本文为CSDN博主「邹郎」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：blog.csdn.net/weixin_3390… 自我介绍介绍下项目流程，在项目中用到了哪些技术怎么设计自己的系统框架说下乐观锁与悲观锁，分别有哪些应用场景怎么处理死锁写两个stack实现queue的代码说一下你记得的排序算法二面：【60min】

我以为一面结束之后我就可以走了，结果让我稍等一下，会有第二位面试官来给我二面，是技术面。

自我介绍说下进线和线程有什么区别 synchronize和lock有什么区别 mysql发生了死锁该怎么处理 Java垃圾回收机制了解吗 hashmap的原理算法题：有100瓶液体，其中一瓶是毒药，一只小白鼠喝到毒药一周后就会死亡。请问给我一周时间，至少需要多少只小白鼠能确定哪瓶是毒药？（把瓶子序号变成二进制）三面【30min】

三面的面试官很友好，没有我什么面试题。

说下oracle有什么作用说下你聘用的职位是做什么的谈谈对项目的理解怎么开展一个项目最后：整个面试过程用了半天的时间。Hr让我回家等消息，在第二天的晚上我等来了offer~。收获真的挺大的，了解到了各个一线互联网公司现在的工作环境和状态。入职之后努力加油。希望看到文章你，也能拿到满意的offer~ ———————————————— 版权声明：本文为CSDN博主「程序媛-双喜」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：blog.csdn.net/weixin_5641…

一面

自我介绍
项目中的监控：那个监控指标常见的有哪些？
微服务涉及到的技术以及需要注意的问题有哪些？
注册中心你了解了哪些？
consul 的可靠性你了解吗？
consul 的机制你有没有具体深入过？有没有和其他的注册中心对比过？
项目用 Spring 比较多，有没有了解 Spring 的原理？AOP 和 IOC 的原理
Spring Boot除了自动配置，相比传统的 Spring 有什么其他的区别？
Spring Cloud 有了解多少？
Spring Bean 的生命周期
HashMap 和 hashTable 区别？
Object 的 hashcode 方法重写了，equals 方法要不要改？
Hashmap 线程不安全的出现场景
线上服务 CPU 很高该怎么做？有哪些措施可以找到问题
JDK 中有哪几个线程池？顺带把线程池讲了个遍
应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描
SQL 索引的顺序，字段的顺序
查看 SQL 是不是使用了索引？（有什么工具）
TCP 和 UDP 的区别？TCP 数据传输过程中怎么做到可靠的？
说下你知道的排序算法吧
查找一个数组的中位数？

二面

你有什么问题想问我的吗？（常规问询）

自我介绍、工作经历、技术栈
项目中你学到了什么技术？
微服务划分的粒度？
微服务的高可用怎么保证的？
负载均衡与反向代理，隔离，限流，降级，超时与重试，回滚，压力测试与应急预案
常用的负载均衡，该怎么用，你能说下吗？

（技术问）

http重定向
DNS负载均衡
反向代理负载均衡
IP负载均衡(LVS-NAT)
直接路由(LVS-DR)
IP隧道(LVS-TUN)
网关能够为后端服务带来哪些好处？
Spring Bean 的生命周期
xml 中配置的 init、destroy 方法怎么可以做到调用具体的方法？反射的机制
Object 类中的方法
对象比较是否相同
hashmap put 方法存放的时候怎么判断是否是重复的
Object toString 方法常用的地方，为什么要重写该方法
Set 和 List 区别？
ArrayList 和 LinkedList 区别
如果存取相同的数据，ArrayList 和 LinkedList 谁占用空间更大？
Set 存的顺序是有序的吗？
常见 Set 的实现有哪些？
TreeSet 对存入对数据有什么要求呢？
HashSet 的底层实现呢？
TreeSet 底层源码有看过吗？
HashSet 是不是线程安全的？为什么不是线程安全的？
Java 中有哪些线程安全的 Map？
HashTable 你了解过吗？
如何保证线程安全问题？
synchronized、lock
volatile 的原子性问题？为什么 i++ 这种不支持原子性？从计算机原理的设计来讲下不能保证原子性的原因happens before 原理
cas 操作
lock 和 synchronized 的区别？
公平锁和非公平锁
Java 读写锁
读写锁设计主要解决什么问题？
你项目除了写 Java 代码，还有前端代码，那你知道前端有哪些框架吗？
MySQL 分页查询语句
MySQL 事务特性和隔离级别

二、事务的并发问题

不可重复读会出现在什么场景？
sql having 的使用场景
前端浏览器地址的一个 http 请求到后端整个流程是怎么样？
http 默认端口，https 默认端口
DNS 你知道是干嘛的吗？
你们开发用的 ide 是啥？你能说下 idea 的常用几个快捷键吧？
代码版本管理你们用的是啥？
git rebase 和 merge 有什么区别？

你们公司加班多吗？（题外话）

举例回答：

项目用 Spring 比较多，有没有了解 Spring 的原理？AOP 和 IOC 的原理

答：(1). IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。对于Spring而言，就是由Spring来控制对象的生命周期和对象之间的关系；IoC还有另外一个名字——“依赖注入（Dependency Injection）”。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，即由容器动态地将某种依赖关系注入到组件之中。

(2). 在Spring的工作方式中，所有的类都会在spring容器中登记，告诉spring这是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

(3). 在系统运行中，动态的向某个对象提供它所需要的其他对象。

(4). 依赖注入的思想是通过反射机制实现的，在实例化一个类时，它通过反射调用类中set方法将事先保存在HashMap中的类属性注入到类中。总而言之，在传统的对象创建方式中，通常由调用者来创建被调用者的实例，而在Spring中创建被调用者的工作由Spring来完成，然后注入调用者，即所谓的依赖注入or控制反转。注入方式有两种：依赖注入和设置注入； IoC的优点：降低了组件之间的耦合，降低了业务对象之间替换的复杂性，使之能够灵活的管理对象。

AOP（Aspect Oriented Programming）

(1). AOP面向方面编程基于IoC，是对OOP的有益补充；

(2). AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，比如日志记录，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。

(3). AOP代表的是一个横向的关系，将“对象”比作一个空心的圆柱体，其中封装的是对象的属性和行为；则面向方面编程的方法，就是将这个圆柱体以切面形式剖开，选择性的提供业务逻辑。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹，但完成了效果。

(4). 实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

(5). Spring实现AOP：JDK动态代理和CGLIB代理 JDK动态代理：其代理对象必须是某个接口的实现，它是通过在运行期间创建一个接口的实现类来完成对目标对象的代理；其核心的两个类是InvocationHandler和Proxy。 CGLIB代理：实现原理类似于JDK动态代理，只是它在运行期间生成的代理对象是针对目标类扩展的子类。CGLIB是高效的代码生成包，底层是依靠ASM（开源的java字节码编辑类库）操作字节码实现的，性能比JDK强；需要引入包asm.jar和cglib.jar。使用AspectJ注入式切面和@AspectJ注解驱动的切面实际上底层也是通过动态代理实现的。

(6). AOP使用场景：

Authentication 权限检查
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading延迟加载
Debugging 调试
logging, tracing, profiling and monitoring日志记录，跟踪，优化，校准
Performance optimization性能优化，效率检查
Persistence 持久化
Resource pooling资源池
Synchronization同步
Transactions 事务管理

另外Filter的实现和struts2的拦截器的实现都是AOP思想的体现。不管怎样，兵来将挡，火来水掩。当天下午四点钟准时接到了面试小哥的电话，小哥的声音听起来比较年轻，估计跟我们年纪相差在五岁以内。接下来给大家分享一下在面试过程中被问到的Java面试题

字节跳动一面:

聊聊项目
进程间通信有哪些,各个优缺点
负载均衡算法
selectpol/epoll
分布式锁怎么实现, Redis加锁过程
聚簇索弓|和非聚簇索引底层实现
隔离级别, MySQL具体怎么做的
SpringMVC的请求过程
常见的GC回收器,越详细越好
算法题，最长连续相同字符的子串

字节跳动二面:

线程池，原理尽量详细些
HashMap底层实现
Spring AOP怎么实现,围绕bean生命周期去讲
mysq|在业务中怎么实现乐观锁
MVCC原理,和for update有什么区别
Redis的setnx有哪些注意点,比如宕机时会发生什么
zset底层原理
https通信过程
服务注册与服务发现
写个题,每K个节点翻转链表

字节跳动三面：

怎么理解微服务？
服务治理怎么实现的？(说了限流、压测、监控等模块的实现)
这个不是中间件做的事么，为什么你们部门做？(当时没有单独的中间件团队，微服务刚搞不久，需要进行监控和性能优化)
说说Spring的生命周期吧
说说GC的过程(说了young gc和full gc的触发条件和回收过程以及对象创建的过程)
CMS GC有什么问题？(并发清除算法，浮动垃圾，短暂停顿)
怎么避免产生浮动垃圾？(记得有个VM参数设置可以让扫描新生代之前进行一次young gc，但是因为gc是虚拟机自动调度的，所以不保证一定执行。但是还有参数可以让虚拟机强制执行一次young gc)
强制young gc会有什么问题？(STW停顿时间变长)
知道G1么？(了解一点 )
回收过程是怎么样的？(young gc、并发阶段、混合阶段、full gc，说了Remember Set)
你提到的Remember Set底层是怎么实现的？字节面经：字节跳动一面：

实习项目就聊了差不多30分钟问了MySQL的索引 redis的string类型为什么使用RabbitMQ？ RabbitMQ有哪些部件？如何保证准确性跟一致性？ hashcode和equals？动态代理快排无序数组计算每个位置大于前面的多少个数字（归并排序）字节跳动二面：

谈谈项目? mongodb底层原理或者数据结构是什么，务处理,插入和mysq有什么区别，为什么会慢如载过程(Java) ，每一步做了什么子类和父类的实例变量和方法有什么区别重载和覆盖区别，返回值类型不同，可以重载吗，为什么,底层如何实现的 java多线程,状态图，画出来,阻塞的状态有哪几种,运行顺序,多线程的一些方法 java泛型 ThreadLocal, Concurrent 下面的包，原理是什么, AtomicInteger,原理是什么,如何做到高效率的，有什么优化措施悲观锁和乐观锁 @Transaction的原理，还有比如在一个类中两个方法， -个是B方法，-个是C方法, B. 上没有注解，C上有那么在外面调用B**有事务，为什么，根据底层原理能不能推断出来(给提示问你能不能推断出来) 查询学生成绩不及格的所有人的姓名和编号,根据这个语句,如何建立索引，为什么, mysq底层是什么，为什么效率高，主键能不能太大，为什么,如果太大,底层数据结构会不会变化，为什么 linux查询tcp连接处理CLOSE_ WAIT的状态的数目了不了解RabbitMQ, kafka, RocketMQ, ActiveMQ, 以及其他消息中间件 redis为什么效率高，线程，数据结构,网络模型，aio, nio, bio, 为什么这么设计?如何处理高并发字节跳动三面:

数据仓库，雪花模型和星型模型区别和用处,数据仓库的过程(分层) ，如何设计数据仓库和数据湖的区别分布系统的设计，分布式系统CAP，分布式系统的模型 linux环境下的线上业务管理有没有，如何管理 redis的集合有没有限制，限制是多少 redis的1w条的插入和更新有什么区别 mysql join的底层原理是什么，有哪几种(不是左右连接这种) linux命令查询一个文件内出现重复最多的数字的 linux命令查询一个文件的行数字节跳动HR：

自我介绍，对公司面试的评价，实习时间为什么转专业？你认为你有什么优点？有什么缺点？有什么兴趣爱好？在团队中习惯充当什么样的角色？遇到过比较困难的事情是什么？觉得自己很幸运的事情是什么？对于未来的规划？有没有使用过公司的其他产品？有没有转正想法？你还有什么想问的？ ———————————————— 版权声明：本文为CSDN博主「程序员志强」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：blog.csdn.net/Melodrammaa… 一面：写一个题，找一个无序数组的中位数

写了个快排，然后让我找到无序数组第k大的一个数，我说先排序再找，实际上可以用快排的partition函数。

快排的时间复杂度，最坏情况呢，最好情况呢，堆排序的时间复杂度呢，建堆的复杂度是多少，nlgn。

操作系统了解么，Linux和windows

说说Linux的磁盘管理，一脸懵逼

Linux有哪些进程通信方式，五大件

Linux的共享内存如何实现，大概说了一下。

共享内存实现的具体步骤，我说没用过

socket网络编程，说一下TCP的三次握手和四次挥手，中间网络不好，面试官都没听清楚，很尴尬

跳过网络，问了项目的一些东西

问我如何把docker讲的很清楚，我从物理机，虚拟机到容器具体实现稍微说了下。

问我cgroup在linux的具体实现，不会。

多线程用过哪些，chm和countdownlatch用过

二面：自我介绍

Java的集合类哪些是线程安全

分别说说这些集合类，hashmap怎么实现的，扯了很多

MySQL索引的实现，innodb的索引，b+树索引是怎么实现的，为什么用b+树做索引节点，一个节点存了多少数据，怎么规定大小，与磁盘页对应。

MySQL的事务隔离级别，分别解决什么问题。

Redis了解么，如果Redis有1亿个key，使用keys命令是否会影响线上服务，我说会，因为是单线程模型，可以部署多个节点。

问我知不知道有一条命令可以实现上面这个功能。不知道

Redis的持久化方式，aod和rdb，具体怎么实现，追加日志和备份文件，底层实现原理的话知道么，不清楚。

Redis的list是怎么实现的，我说用ziplist+quicklist实现的，ziplist压缩空间，quicklist实现链表。

sortedset怎么实现的，使用dict+skiplist实现的，问我skiplist的数据结构，大概说了下是个实现简单的快速查询结构。

了解什么消息队列，rmq和kafka，没细问

写题时间到。第一题：写一个层序遍历。

第二题：写一个插入树节点到一颗排序树的插入方法，使用递归方式找到插入位置即可。

第三题：一个有向图用邻接矩阵表示，并且是有权图，现在问怎么判断图中有没有环。

我说直接dfs走到原点即为有环，刚开始写的时候我又问了一嘴是不是只要找到一个就行，面试官说是的，然后我说这样应该用bfs，有一次访问到原节点就是有环了。

面试官问我不用递归能不能做这个题，其实我都还没开始写。然后我就说没有思路，他提示我拓扑图。我没明白拓扑图能带来什么好处。现在一想，好像当访问过程中找不到下一个节点时就说明有环。做一个访问标记应该就可以。

第四题：一个二叉树，找到二叉树中最长的一条路径。

我先用求树高的方式求出了根节点的左右子树高度，加起来便是。

然后面试官提示需要考虑某个子树深度特别大的情况，于是我用遍历的方式刷新最大值，用上面那个方法遍历完整个树即可。

面试官说复杂度比较高，但是由于时间问题就说结束了。

三面：介绍一下项目

你谈到的并发技术，chm和countdownlatch怎么使用的

为什么要这么处理，使用线程池是不是也可以。我说也可以

操作系统的进程通信方式，僵尸进程和孤儿进程是什么，如何避免僵尸进程，我说让父进程显示通知，那父进程怎么知道子进程结束了，答不会。

计算机网络TCP和UDP有什么区别，为什么迅雷下载是基于UDP的，我说FTP是基于TCP，而迅雷是p2p不需要TCP那么可靠的传输保证。

操作系统的死锁必要条件，如何避免死锁。

写一个LRU的缓存，需要完成超时淘汰和LRU淘汰。

我说用lhm行不行，他说用linkedlist和hashmap可以。

于是我就写了put和get函数，进行了队头队尾操作。

他说get复杂度会不会太高，我瞎掰了半天没找到办法，他说那就这样吧，今天面试到这。

过期淘汰的处理我还没写呢，就说结束了，感觉凉了啊，我说我要不要把剩下逻辑下完，他说不用，心凉了一大截~

然后HR小姐姐让我等结果了。

面试经历只是提供给大家一点临时的应付技巧，真正的本领还是要靠平时的学习和积累，只有学习的多了，技术掌握的透彻，才会在面试的时候临危不乱，处变不惊。临时抱佛脚虽然有时可行，但是，也有抱不住的时候啊。

当然面试难免让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式，就会容易很多。作者：码农清风 www.bilibili.com/read/cv7533… 出处：bilibili 第一轮面试：1小时28分钟自我介绍

数据库索引的作用是什么？

段页式

虚拟内存

缺页中断

Major/Minor page fault区别

TLB作用

进程/线程和虚拟内存的关系

x86相关没听清直接说不会

讲讲jvm，内存泄漏怎么理解的

垃圾回收机制，垃圾回收算法讲解一下，怎么判断是老年代，触发垃圾回收的时机在什么时候？

BIO、NIO、AIO

select poll epoll

RMQ算法

无锁队列实现细节

数据库ACID

实验室项目

vector底层为什么扩容是1.5倍

算法部分：

（2）给一个数组,数组里面有rgb三种数，数量和顺序完全无序，给一个算法按照他想要的r都在前面，g都在中间，b都在后面，用移动次数最少的算法进行计算，写算法这个地方一直叫我优化再优化，我快疯了，我说我不行要放弃了，他说你简历不是写着强烈的好奇心求知欲嘛，没事再想想，我直接笑喷了才放松了点继续想，这简直是心理战

第二轮面试：1小时11分钟自我介绍

问我计算机网络，操作系统，组成原理，数据结构哪个学的最好？我说计网，因为我实习的时候看了很多计网相关的东西，他叫我把自己最熟悉的东西详细讲解出来

使用https就能保证数据安全吗?

http协议处于网络模型哪一层

tcp和udp的本质区别是什么？这个地方在数据可靠性深挖的比较多

实习过程中用http协议做的事情，http状态码解释

http发起请求的时候，get,post别的还有些啥

用post获取数据会有什么问题吗？get和post的区别有哪些

c和Java的区别，本质区别

面向对象几大特征？什么时候该用继承什么时候不该用继承？有没有遇到过这种使用？为什么继承破坏了封装？

实际项目中运用过多线程吗？用来干什么？

多线程安全问题怎么解决？实际项目中怎么解决的，场景和解决方式

多线程协作方式，除了锁还有什么吗？

信号量解释一下，干什么用的？

死锁怎么产生的？

发生了死锁怎么办？

银行家算法了解么？

算法部分：

（1）有很多纸盒子，每个纸盒里里面套着纸盒子，其中有一个有硬币，怎么把硬币找出来，写算法

（2）树的遍历方法有什么，写一个二叉树前序遍历算法

第三轮面试：1小时15分钟自我介绍一下

讲一件自己做项目最有挑战的一件事情

比较mysql和mongodb的优劣

mysql用join来做连接，mongodb怎么做的

mongodb冗余字段的方式和mysql有啥不同，缺点

信息变更了，name变了怎么处理这些冗余字段?

mongodb里面的aggravate使用过吗，举一个例子，有什么用

pipeline运行机制是什么，假如你来做mongdb执行引擎，自己设计一个方式来设计这个pipeline

这个问题我回答了很久，因为我完全不懂pipeline，硬着头皮设计。

你觉得docker这个技术能解决什么问题？为什么要用docker做部署？有什么好处

运行在docker里面的文件系统，docker怎么实现文件系统机制？

在docker里面根目录cd，能不能跳出沙箱回到宿主机？

问了下我前端知识了解的程度？react 和 jquery有什么区别？

直接上算法了

（1）寻找最近的父节点，给了两个例子，差不多leetcode中等难度

（2）开放性的问题，猫抓老鼠，猫在圆型中间，老鼠在圆的周长上，速度相同，问猫能不能抓到老鼠，这个问题我给的回答他不是很满意，我把关键点说到了但是不能用数学解释出来

结局结局当然是凉了，没有第四面的通知，但这次经历给我的感受还是很不一样的，也为我下一场面试积攒了经验。之后打算再投几家互联网一线大厂，希望能够顺顺利利，收到好消息吧。

另外，上文的三面题目的答案和具体解析都整理在了文档里，文章篇幅有限就不在这里分享了，有需要的可以私信我口令「面试题」免费领取。作者：马士兵-马小茶 www.bilibili.com/read/cv8035… 出处：bilibili 字节跳动的邮件会说考察通用型的业务问题和过往的项目经历

字节跳动一定会考算法题，建议有针对性的刷LeetCode探索里面的字节跳动算法题专场，里面的算法题真的很准，我面试时就碰到两题原题。

自我介绍，公司职能，项目简介

索引是否能够命中相关问题最左匹配。

spring注解、ioc AOP相关的，基本都问到了

hashmap源码链表+数组 and so on , 对扩容和内存机制也有说

说一下你知道的GC算法标记-整理、标记-删除，标记-复制，分代回收，大致说了下内容，面试官没表示满意，也没说不满意，直接下一题了

描述一下你现在负责的项目，说一说大体架构就把自己手头上负责的项目大致架构图画一画，这个估计是想了解对手头负责事情的了解程度和表达能力

说一说怎么解决脱库风险这个没说好，只能说出一些访问限制，数据权限等角度，感觉解决不了脱库问题

笔试题：一个链表，每K位反转

写一个线程安全的单例模式

.进程调度都有哪些算法

你的user表的主键是什么，如果不用auto_increment，我该如何实现id

ARP是什么？ARP内部如何实现？

DNS是什么？内部如何实现

内存单元的作用是什么

栈，队列是什么？区别是什么？算法题1：用栈来实现队列。

操作系统，进程状态，进程调度，CPU调度基本单位，进程线程区别

CPU调度单位，中断实现机制，软硬中断的区别

计算机网络，IP协议在那层，ping命令底层用的什么协议，一个ip数据包经过一个路由器之后包里改变了什么，

traceroute命令底层是用的什么协议，是怎么实现的。

算法题：二叉树最小公共祖先

get,post的区别

http请求的组成

OSI 7层协议？有哪些是可靠的网络连接？TCP为什么是可靠连接？cookie vs. session

封装、继承、多态

二分查找

无重复元素的二分查找

含重复元素的二分查找

找第k大数

快排实现、堆实现

进阶：不用额外空间，尽可能快的找到第k大数

两个栈实现一个队列、怎么优化

滑动窗口、窗口大小

什么是线程安全

左连接、右连接

c++与java的区别

实现hashmap，怎么扩容，怎么处理数据冲突？怎么高效率的实现数据迁移？

单例模式，什么时候用到，还了解哪些设计模式，装饰者模式是什么，举例

介绍死锁和如何避免

从输入网址到获得页面的网络请求过程

HTTP header

Redis了解吗？

MySQL引擎有什么？有什么差异？

Linux进程状态，Linux进程什么时候会变为等待？

算法题1：LRU cache （LeetCode 146）

算法题2：一个有符号的有序数组，问这些数平方之后有多少个不重复的数？（双指针）

算法题：在一个长字符串中找一个子字符串是否存在，有，返回index，没有，返回-1。子字符串要求连续，但不在乎内部字符的顺序。（滑动窗口问题）

n个人，n个座位，每个人都有自己的座位，问每个人都不坐自己座位的坐法有多少种？（动态规划，解决重复子问题，两种情况讨论）

你有一个网站项目，服务器是怎么弄的？

session和cookie有什么差异，分别什么时候用，在什么时候生成，长时cookie和短时cookie分别用在什么时候

堆。什么是最小堆？什么是最大堆？在堆中怎么插入一个元素？

java修饰符、java线程同步的方法、synchronized对不同方法加锁的区别、java中的引用、kotlin和java的区别，算法题是平衡二叉树的判断。

数据库索引、事物等的概念、sql语句的结构、java中类似c++中的析构函数、java和c++的异同点、java和c++各自传参数的方式

Handler原理已定义View、listview如何优化，算法是求给定数组中连续数字的最大和

数据库如何短时间高效批量插入数据

手写快排和堆排

最短路径算法

&&一面：&&

1.自我介绍 3.讲一下spring mvc的原理

4.了解哪些[排序[算法]

5.快排的[算法]流程和时间复杂度？

6.什么是哈希[排序]

写题：

1.三路归并[算法]实现

2.最长不重复子串长度最长上升子序列 3.操作系统的页面置换[算法]详细讲了一下

javab

字节跳动二面

没被问到数据库有点诧异，毕竟准备最充分的就是数据库，明显感觉部门重视操作系统和计算机网络，算法无论是手撕还是口述都有，所以还是需要重视

抖音

一面

一面

二面

三面

四面

五面

小结

拼多多

一面

二面

HR 面

字节跳动

一面

二面

小结

Java基础

JVM

集合框架

多线程与并发

一面

二面

二、事务的并发问题

字节跳动一面:

字节跳动二面:

字节跳动三面：