笔触狂放9

这个屌丝很懒，什么也没留下！

热门标签

【八股】2024春招八股复习笔记3（测试、运维、安全、游戏、客户端）

作者：笔触狂放9 | 2024-04-11 04:11:36

踩

【2023秋招-2024春招】八股系列，共8篇

【2023秋招-2024春招】笔面系列，共5篇

【2024应届】转行与混体制系列，共6篇

【2024应届】升学系列，共8篇

【2023应届】就业系列，共3篇

合计30篇

文章目录

【八股】2024春招八股复习笔记3（测试、运维、安全、游戏、客户端）

我有一个问题，既然测试、运维、安全、运营、客户端都要会开发，同时还要会很多专业领域的知识，但是待遇和职业发展却都远远不如开发。那为什么不直接投业务开发呢（好吧可能是太卷了）

1、测试开发

1、网络 & 系统（含linux）

2、数据库，MySQL，JAVA

3、测试流程：单元测试、集成测试、系统测试

4、测试用例：设计用例，加载慢，加载卡。

5、算法题、智力题

测试不等于测试开发

软件测试产业近几年一直在技术升级，经济寒冬加速推进近年来，研发流行敏捷开发，版本高速迭代；运维部署也在逐渐自动化。
但软件测试领域，企业却有两大无法忽视的痛点：
- 痛点1、互联网行业产品对产品质量和速度的诉求；
- 痛点2、市场上占比最多的功能测试工程师在工作常常出现的瓶颈。
当前各企业正在实施的办法，是持续建设自动化测试体系，将软件测试从手工密集升级到自动化测试体系中，通过提高测试流程的有效性和效率来消除测试瓶颈。随着“点点点”的手工测试，逐渐被自动化测试技术接管，原来需要10个手工测试完成的工作量，现在自动化测试团队不到5个人就能完成。

测试开发岗位介绍

测试开发的本质是助力业务成功。感觉很多同学一上来就是学习编程技术，技术学习比较枯燥，计算机基础知识不扎实，很快就陷入了基础知识的泥沼。
在我看来了解基础理论后，学习 Python，Git 等必备技巧，熟悉一门自动化框架就可以解决测试相关的面试了。
自动化测试框架有：1.Robot；2.Pytest；3.Junit；4.WebDriverIO；5.Citrus；6.Selenium；7.Cypress；8.Serenity；9.Gauge；10.Carina、Junit、Selenium、TestNG、Cucumber、pytest、Appium、ATX，参考
Junit（白盒测试、API自动化、UI自动化）、Selenium（Web自动化、爬虫）、TestNG（白盒测试、API自动化、UI自动化）、pytest（白盒测试、API自动化、UI自动化）、ATX（移动端的UI自动化测试）

测试开发八股

参考1，参考2，参考3，参考4，参考5
2020届秋招面经分类汇总（各个岗位，万字长文，共 1901 篇）
测试开发知识图谱,
经典网络题
Python语言高频考点
Linux常用命令
测开常考数据结构
操作系统高频知识点
数据库知识点
测试相关知识点
Selenium自动化测试基础实战
Postman接口测试基础和实战测试
测开面试题
请你分别介绍一下单元测试、集成测试、系统测试、验收测试、回归测试，以及这里面那一步最重要。
集成测试和系统测试的区别，以及它们的应用场景主要是什么？
黑盒与白盒的测试方法
手动测试和自动化测试的优缺点
如何进行BUG的评测
软件质量的6个特征
请你说一说bug的周期，以及描述一下不同类别的bug
web测试和app测试的不同点
软件测试实例
给你一个字符串，你怎么判断是不是ip地址？手写这段代码，并写出测试用例。
测试用例设计：一串数字，闰年的判别
简单的用户登录界面过程都需要做那些分析
请对这个系统做出测试用例：一个系统，多个摄像头，抓拍车牌，识别车牌，上传网上，网上展示

测试开发面经

京东测开一面
1.redis缓存三兄弟
2.java GC算法
3.java和python区别
4.用户登陆界面怎么去测试
5.手撕数组最大值以及三数之和，针对三数之和进行测试案例设计
6.mybaits和mybiats plus的区别
7.string，stringbuilder，stringbuffer的区别


美团暑期测开一面
自我介绍
因为是后端面的测开
主要拷打简历和项目
为什么选择测开
测试用例编写
自动化测试等等

米哈游游戏测试一面（背水一战）
因为特别想进米哈游，看米哈游游戏测试今年希望更大，就赶紧投了游戏测试，直接面试了。
整体八股问的不太多，可能因为我的实习经历和项目经历比较多，更重要的是，可能我的游戏经历也引起了面试官的兴趣。
面试问题：
自我介绍
项目深挖
实习经历深挖
实习中遇到的最大困难
是否有遇到测试给你提bug，但是你不知道怎么解决的问题
举例黑盒测试
数据库索引
数据库加了一条索引后怎么测试
排序算法
get post区别
进程和线程
这么多开发经历，为什么来做测试
怎么看待测试
最喜欢什么类型的游戏
游戏经历


浏览器与目标服务器建立TCP连接
http协议建立在tcp协议之上，http请求前，需先进行tcp连接，形成客户端到服务器的稳定的通道。俗称TCP的三次握手。
tcp连接完成后，http请求开始，请求有多种方式，常见的有get，post等。
http请求包含请求头，也可能包含请求体两部分，请求头中包含我们希望对请求文件的操作的信息，请求体中包含传递给后台的参数。
服务器收到http请求后，后台开始工作，如负载平衡，跨域等，这里就是后端的工作了。
文件处理完毕，生成响应数据包，响应也包含两部分，响应头和相应体，响应体就是我们所请求的文件。
经过网络传输，文件被下载到本地客户端，客户端开始加载。
html页面的解析与渲染

客户端浏览器加载了html文件后，由上到下解析html为DOM树（DOM Tree）。
遇到css文件，css中的url发起http请求。
这是第二次http请求，由于http1.1协议增加了Connection: keep-alive声明，故tcp连接不会关闭，可以复用。
http连接是无状态连接，客户端与服务器端需要重新发起请求--响应。在请求css的过程中，解析器继续解析html，然后到了script标签。
由于script可能会改变DOM结构，故解析器停止生成DOM树，解析器被js阻塞，等待js文件发起http请求，然后加载。这是第三次http请求。js执行完成后解析器继续解析。
由于css文件可能会影响js文件的执行结果，因此需等css文件加载完成后再执行。
浏览器收到css文件后，开始解析css文件为CSSOM树（CSS Rule Tree）。
CSSOM树生成后，DOM Tree与CSS Rule Tree结合生成渲染树（Render Tree）。
Render Tree会被css文件阻塞，渲染树生成后，先布局，绘制渲染树中节点的属性(位置，宽度，大小等)，然后渲染，页面就会呈现信息。
继续边解析边渲染，遇到了另一个js文件，js文件执行后改变了DOM树，渲染树从被改变的dom开始再次渲染。
继续向下渲染，碰到一个img标签，浏览器发起http请求，不会等待img加载完成，继续向下渲染，之后再重新渲染此部分。
DOM树遇到html结束标签，停止解析，进而渲染结束。


测试开发 & 全栈开发（嗯）
怎么理解测试开发的角色？
在测试开发的角度来讲，你的开发需求是怎么来的？
在你的测试实习中，你的开发任务是怎么来的？
设计一个git commit的功能，开发不是测试！
用户新增了一段代码片段，需要识别到新增部分并显示出来
开发语言用的啥？
列表和元祖有啥区别？
进程、线程、协程之间有啥区别？
多进程、多线程的使用场景？
手撕：一个字符串，统计其中英文字母种类、字母出现的频次、按出现频次降序排列，字典
有其他方式吗？列表
还有吗？set+count
服务端开发的django框架熟悉吗？
做一个图书管理系统，你是怎么设计的？可行性分析-需求分析-概要设计-详细设计
只针对登录系统、登录接口，怎么做参数校验？
6-20位参数，如果是5位就返回太小，怎么实现功能？
你有接触到什么库？
VUE用过吗？没有=/=
v-show和v-if有什么区别？
mysql中多对多的关系，做数据库结构设计
多表查询，inner join和left join有什么区别？
Django的ORM做left join的查询，要怎么写？
之前用过ORM做过开发吗？
反问
nowcoder  /creation/subject/956498afaa434166b5562e3f8b3810e1


招银网络科技 面经
一面 30min
1. 自我介绍（时间控制到2-3min）
2. 实习情况
3. 一个好的缺陷描述应该包含哪些内容
4. 实习过程中发现的印象比较深刻的缺陷
5. 第二段实习经历中开发类主要负责了哪些内容，有哪些产出
6. 熟悉Java和Python？线程和进程的最大区别
7. 线程生命周期中的状态
8. sleep和wait方法的区别
9. 线程产生死锁的必要条件
10. 避免死锁的办法，有哪些措施？
11. 什么是线程安全？怎样保证线程安全？
12. 【编程题】反转数字
13. SQL模糊匹配
14. 查询结果集除重，SELECT语句当中除重DISTINCT
15. 快速删除一张表的数据，有哪几种方案
16. 数据库索引
17. 左连接和右连接
18. 测试水杯
19. 反问

二面 25min
1. 自我介绍
2. 实习工作内容
3. 环境部署成功率，平均每天接入量
4. 测试和测开的区别
5. 实习中关于测试场景的设计
6. 如何对齐关于需求的理解问题
7. 产品迭代周期
8. 每天发版，怎样保证产品质量（测试过程中除了本身业务的改动，完成主流程的回归测试）
9. 回归量大吗
10. 银行业务。存取钱场景测试案例
11. 存取现金回单。回单打印错误如何解决。
12. 事务，回滚。
13. 系统卡顿、系统超时等问题出现的重复请求，如何解决或优化。
14. 了解幂等吗？重复交易流程，判重去重。
15. 反问
nowcoder  /creation/subject/956498afaa434166b5562e3f8b3810e1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

抖音测开面经，内容很多，值得一看

基础知识

Java
- 重写与重载
- java集合
- hashmap和hashtable的区别
- arraylist和linkedlist的区别
- map的put方法
- Java gc机制
- 垃圾回收算法：复制算法、标记-清除算法、标记-整理算法。
- 抽象类和接口的区别
- 线程的实现方式有哪些 extend Thread、implement runnable、implement callable
- Integer和int的区别
- String、StringBuilder与StringBuffer
- 内存溢出和内存泄露
- protected，private，public
数据库
- 事务的特性：原子性、一致性、隔离性、持久性。
- 联合主键：设置多个字段同时为主键（PRIMARY KEY(Name, Age)）
- 复合主键：多个主键联合形成一个主键组合。（成绩表中的学号、课程标号）
- mysql怎么优化
- 数据库的备份是如何实现的
- mysql创建一个学生表，包含id（int）和name（string），主键的创建：CREATE TABLE stu(id INT (5), name VARCHAR (100), PRIMARY KEY (id));
- mysql建立索引 CREATE INDEX index_name ON table_name (column_list) CREATE INDEX idx_c4 ON t(c4);
- 数据库查询10-20行内容：select * from stu limit 10, 10;
- 创建数据库：CREATE DATABASE database_name;
- 查找135开头的电话：select * from table where tel like '135%';
- left join, right join和inner join的影响性能的因素。
操作系统
- 死锁的条件、原因，死锁的必备条件
- 程序与进程
- 进程通信的方式管道适用什么场景
- 并发和并行区别
  - 并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的。
  - 并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。
网络
- tcp三次握手和四次挥手
- 网络七层有哪些，tcp，udp，arp，TCP/IP都在哪一层 http，tcp，ip协议
- tcp和udp的区别、特点
- http请求方式有哪些：GET、POST、HEAD、PUT、DELETE、CONNECT、OPTIONS、TRACE。
- 拥塞控制和快重传
- TCP和UDP区别、怎么让udp实现可靠连接
- socket编程
- session与cookies区别，以及分别存储在什么地方
- 常见的状态码：502 网关错误 (Bad gateway)、504 Gateway Time-out。
- CDN
数据结构
- 索引提到了B树
- 数组和链表的区别，树是用什么存储的，可不可以用数组存储
- 快排的时间复杂度（NlogN）、最坏情况（N^2）
- 数据结构上的堆和栈有什么区别、底层结构是什么
- 红黑树
- 最大的K个数用什么排序算法，复杂度、同样是NlogN, 快排和堆排序有什么区别。
python
- ()代表tuple元祖数据类型，元祖是一种不可变序列。 []代表list列表数据类型，列表是一种可变序列。
- lamda表达式：a = lambda x,y,z:(x+8)*y-z
- 闭包

Linux

VI 显示所有行的行号：vi set number
找到共用80端口的线程
linux基本指令 awk、find、grep
shell脚本：统计一个文件中重复的行和重复次数
linux 如何将文件从一台服务器转移到另一台服务器
如何查找出现频率最高的100个ip地址

测试

微信发红包测试用例。
测试一个月饼礼盒。
测试的维度。
对收信发信进行测试
怎么测试微信的搜索功能。
测试朋友圈发布视频功能
如果有一部分用户反馈APP的视频加载不出来，你会从哪里方面去定位问题
在一个产品的周期中，你会怎么安排测试工作
怎么测试小程序的并发性的
对页面的测试、对杯子、电梯系统、三角形这些常规的测试用例，总结一下
对聊天进行测试
对朋友圈点赞进行测试
测试微信朋友圈评论功能
熟悉的软件测试的方法
电梯的测试用例
测试商场的支付功能，设计测试用例
黑盒白盒测试
项目的测试用例
游戏的测试维度
varchar(256) 变为 varchar(1024)测试
对抖音的界面进行测试
测试微博的刷新功能
用户登录页面的测试
抖音页面怎么测试
微信发红包怎么测试
登录测试？弱网测试，无网测试怎么做？
测试一瓶水、测试一个矿泉水瓶
如何测试用户登录界面
测试中如何模拟网络环境不好的条件 fiddler
如何测试一个登陆案例
设计一个测试方案，生产好的矿泉水瓶要放到流水线上生产的测试方案。
一个手机小程序，只能输入1-100的数字，还有一个提交按钮，设计测试用例
为微信的点赞功能设计测试用例，假如点赞了但是点赞数没有加一，可能报错在哪里？网络良好的情况下，发现数据传输过程出现404的情况，你认为是什么问题。
给抖音的评论功能设计测试用例
给你一个QQ登录界面有一个登录按钮一个自动记住密码的复选框账号密码输入框，你怎么设计测试用例？
一个发帖功能（可以发文字、图片、定位），你会测试哪些方面功能测试，网络测试，平台测试
然后问我如果想要上新一个新尺寸的视频，我会想要测试什么。

问题查找

让你设计一个俄罗斯方块怎么设计
web页面空白有哪些原因
测试工具loadrunner，postman，selenium用来测什么
分析一下少量联通用户反映刷抖音无法显示原因

算法题

写代码，类似高考成绩，一个表中有很多数据（无序的），给你一个成绩，查出在表中的排名
找出这两个链表是否有相交的点
判断链表有没有环，环起点在哪儿。
手撕topk，时间复杂度是多少。
写个算法，实现抢红包随机获取金额的过程参考
链表反转
两数之和（leetcode第一题～、～）
判断一个字符串是否为另一个字符串子串（暴力写的）
股票最大利润
实现单链表前后交叉排序：1,2,3,4,5,6 变成 1,4,2,5,3,6
因式分解
有序二叉树，一种遍历方法使

其他

冲突解决办法
如果UI和开发消极怠工，怎么办
如果开发认为测试出来的问题不是他的问题，怎么办
leader出错，同伴不配合怎么办
对测开的理解
对测试工作有什么期望
为什么想做测试
你了解的测试有哪些
测试与开发本质区别
测试主要运用哪种语言
对测试开发的理解
你对测试职位的理解

测开高频题

2、运维开发 SRE

运维开发：会点运维会点开发，SRE方向。比如CICD部署自动化工具的建设。

运维岗：服务器环境搭建与集群部署，网络 & 系统（linux重点），基础服务（LNMP、LAMP），脚本与工具（shell，py），安全与服务器等。

参考资料

【运维】站点可靠性工程介绍：研发，运维，SRE，Devops的关系

参考1，

Linux运维跳槽必备的40道面试精华题

2022必撸八股！198道K8s/Docker/DevOps面试真题大盘点+答案详解

运维面试题

做一个系统运维工程师需要掌握哪些必备技能?

云计算架构师/大厂运维工程师

• Haproxy 生产环境应用实战，HaproxyACL 规则及企业级常见用法， HaprOXV 动静分离集群配置方案

• keepalived 高可用集群实战进阶，Keepalived 实现高可用集群，以及结合 Haproxy 实现生产环境常用架构

• Nosql存储Redis、Mongodb

• 监控系统 Prometheus ，用 Prometheus监控系统实现自定义指标应用

• 注册中心 Zookeeper 集群与部署， Zookeeper 完全分布式集群搭建与部署

• 消息队列 kafika，握生产环境kafka 使用场景、核心功能及安装部署

• ELK 企业级海量日志系统实战进阶

• Gitlab 及Jenkins 实现 CI/CD 可持续化集成实战，enkins、GitLab 和 Ansible 等构建自动化CI和CD流水线

• Docker 容器虚拟化实战进阶，Docker 原理、模块使用、安装、部署、生产环境配置、常见应用结合

• 主机虚拟化技术与KVM，生产环境 KVM虚拟化技术安装、部署及优化

• 微服务 Dubbo 分布式框架，服务治理及治理框架的使用，解分布式应用的概念及技术要点

• 必备技能：kubernetes ，Kubernetes安全管理、网络功能、资源应用、调度策略、应用管理及系统扩展企业级实战

美团

美团秋招-运维开发一面面经
一、面试官介绍自己以及自我介绍
二、问实习部分
       华为实习都干了啥：日志分析
       分析的流程，怎么获取某些字段
三、问项目部分
       服务端的项目：主要负责哪部分，怎么和客户端通信的？用的什么协议?TCP
四、八股部分
        对计算机网络的学习程度（自己说七层、五层模型、各层的协议）
        HTTP/HTTPS的区别
        TCP是哪层的
        DNS过程（提到了hosts文件，面试官问hosts文件linux在哪放着，windows下在哪）
        ssh使用的端口（22）tomcat的端口号（8080）
        Linux各种命令：grep/egrep、top、ps、如何定时关闭进程
        有没有用过除了tomcat之外的服务器吗？比如ngnix？
五、手撕代码
       输入n，求1-n每一位出现1的个数（力扣原题）
       暴力直接秒
六、部门岗位介绍
         问了为啥后端转sre、对sre的理解、要求转正实习的话多久能来？

美团-运维开发-二面-零售
如题，总共面35分钟。没有八股，全是开放
性问题！
1.面试官自我介绍，介绍部门
2.自我介绍
3.根据自我介绍，问实习和项目（主要问项目
的扩展开放性问题）
4.问1000和100000台服务器，实际情况下你想到什么？（我说了部署）nginx负载均衡
5.手撕代码：ab的最大公约数
6.目前的面试情况，美团对我的吸引力
7.反问：该岗位该部门，除了平常计算机知
识，应该学习什么；部门平常工作模式和流程
nowcoder  /creation/subject/b3d122bd313f492c80c88a826e0babb3



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

面经

米哈游校招-游戏运维开发
工作职责
1.参与大型游戏的运维架构设计和实现，并持续进行优化，实现高可用、易扩展等特性，包括但不限于自动发布、监控平台、CMDB、配置管理等；
2.协助业务解决产品运维过程中出现的问题，帮助解决业务的痛点。
任职要求
1.计算机、软件工程等相关专业；
2.扎实的计算机体系结构、算法与数据结构、操作系统原理等基础知识功底； 熟悉Linux系统；熟悉python或golang等任一开发语言；
3.具备强烈的钻研精神和自我学习能力，具有优化意识及很强的责任心；
4.热爱游戏。
加分项
1.有游戏公司实习经历优先；

360运维开发一面二面HR面
云计算部门
9.02一面（50分钟）
一面是个女生，据二面面试官描述她的网络很强，360面试体验贼好，小姐姐会引导你并且会微笑
1、自我介绍
2、实习经历，实现做了哪些事情，做了哪些关于运维的工作
3、HBase高可用怎么设计的
4、Hbase、HDFS脑裂问题
5、mtu（以太网最大传输单元）、mss（最大传输报文段）从七层的应用到数据链路层传输过程，数据包怎么封装的
6、tcp、udp区别、tcp拥塞控制
7、http、https区别
8、tcp报文中的内容详情（详细介绍了tcp报文的各个层中有那些内容，最重要介绍6个标志位以及作用）
9、假设http协议中，如果客户端发送YIN包，而服务端的80端口宕了，返回什么包（RST）
10、ngxin、keeplived、lvs、haproxy这些了解哪些
11、linux抓包tcpdump
12、top命令介绍，可以看到哪些内容，怎么排查的高负载
13、vmstat命令以及netstat命令的问题
14、秋招投递、面试情况
15、反问
9.09二面（50分钟）
二面面试官看我是搞大数据的，就问我是一定非要做大数据么，因为他们那边是云计算部门
1.、自我介绍
2、实习工作，时长
3、对云计算的理解，IaaS、PaaS、SaaS
4、问我多大，我说21，面试官：我woc，这么小，我：哈哈哈
5、avl树介绍
6、avl树已经很牛逼了，查找速度很快，为什么来了个更牛逼红黑树：结合java的hashmap，介绍了使用红黑树的好处（面试官：你已经把我最想问的说出来了）
7、怎么判断链表有环、怎么计算环多长
8、快排什么时候时间复杂度最高、快排还有什么值得优化的地方
9、看你的博客上涉猎很广泛啊，大数据、云计算、还有算法涉猎很广泛啊（我：尴尬笑了下，说主要是有老师带）
10、现在投了多少家了，有多少家已经在面试流程中了
11、网络的知识就不问了，面试官说他的网络知识没有一面面试官强，他说你能经受住一面的严刑拷打就说明网络基础还不错，数据结构也还可以
12、做到题吧：在旋转数组过的有序数组中寻找目标值（先讲思路二分，写了5分钟ok）
13、能早点来实习吗
13、反问（部门技术栈，以及面试流程）
9.29HR面（10分钟）
1、自我介绍
2、哪里人
3、是否可以提前实习
4、职业规划
5、北京是否有朋友、亲人
6、兴趣爱好
7、反问（最后结果什么时候可以确定，HR说前几轮面评很好，最终会根据笔试和面评确定）


快手运维开发-大数据面经（已意向）
8.29一面
一面一个小时，深挖项目，问了很多hdfs和一些操作系统底层原理，hdfs读写流程+心跳机制+副本机制+HDFS纠删码，手撕lc第15题改编题，撕出来了
关于虚拟化有一个印象深刻的问题，当前资源数为7，有4个用户，每个用户需要资源数为2，如何在当前时间段为这4个用户创建虚拟机，满足每个人的需求？我答时间片，面试官说也是一种思路，不过她想让我下去看一下超配。
八股：
什么是tcp四次挥手
www网站一次访问的过程
什么是内存碎片
进程状态有哪些，如何切换
什么是僵尸进程
网络拥塞控制方法

jvm
如何实现线程安全
9.2更新
二面依旧一个小时
还是项目，这次问的更深，包括容器的操作系统层面工作机制、性能表现等等，容器和kvm、vmware的差异在哪里，为什么会有这些差异，这里也涉及底层操作系统工作机制。hadoop的高可用如何实现，多namenode如何保持数据一致性，zookeeper和journalnode在这中间的工作原理，hadoop元数据是怎么工作的，回答通过fsimage和editlogs，追问fsimage具体做了什么，这里不了解，不再追问。
从网络七层模型讲述一下面试视频的这个通信流程。
ib网络和千兆网为什么不能直接通信，从网络七层来描述一下，然后问在哪一层可以将他们打通，方法是什么。
手撕一道代码题，这个是面试官现场出的，但是难度不高，很快写出来了。
最后问我对sre这个岗位的理解，以及后续工作上的目标，技术追求等等。随便讲了一下自己的理解。
反问快手sre工作具体内容，面试官说要负责系统稳定、线上变更，工作强度还是不低。


9.14三面
问了半小时项目，硬件部分不太熟悉，其他的基本都答出来了，没有手撕。
反问面评如何，面试官说比他当年好，不告诉我通没通过。
nowcoder  /creation/subject/b3d122bd313f492c80c88a826e0babb3


虾皮
SRE和后端选择哪一个，为什么
SRE
1.LINUX用户态和内核态（√）
2.linux切换到内核要什么命令（x）
3.描述切换的具体过程（√）
4.描述具体过程（√）
5.Linux的页最小单位是什么（x）
6LNUX内核怎么管理内存空间（√，x）磕磕绊绊答出来了一部分
7.TCP如何保证可靠性（√）
8.TCP 的拥塞控制采用的算法（√）
9.队列来实现栈（√）
10.栈来实现队列（√）
11.了解那些排序算法（√） 快排，冒泡
12.快速排序流程（√）
13.快排的时间复杂度（√，x），我说最快nlogn 最慢n2。他问我真的是nlogn吗？
14.速度最快的排序算法是什么（√，x），平均下来不是快排吗？
15.Java 中线程池的工作流程（√）
16.Jshutdown一定能够成功关闭吗（√）
17.如何保证强制关闭（x），估计面试官想让我回答awaitTermination
算法题Leet300：（√，x）最长上升子序列  一开始没回忆起来是dp，用二分超时了。
后面改成dp，结果在input处理输出上花了点时间，借了五分钟才算过去


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

3、安全开发

安全开发：就加起来就是了呀，会点安全会点开发

安全岗：攻防渗透、代码审计、安全研究、工具开发

感觉比起开发很靠实践，尤其是渗透，还是多实习，多参加国护吧。

安全岗位面试题，写多了怕博客发不出来，建议移步github：

这份很全：2023届毕业生-github

补充一些审计知识

【岗位职责】
参与漏洞扫描器的研发，编写相关漏洞检测 POC 基线检查相关逻辑实现 搭建相关漏洞靶场并输出相关文档 漏洞库相关的维护工作

【岗位要求】
至少实习 6 个月 熟悉常见 Web 漏洞原理 掌握基础的数据结构与算法，有一定的编程经验 思路清晰，有良好的语言表达能力 积极主动，具备良好的职业素养 加分项： 有个人技术博客或在相关安全社区发表过文章 Github 有活跃开发项目 使用 Golang/Python 开发过中小型项目


一面（45min）
1.介绍自己
2.介绍一下实习
3.场景题轰炸，主要针对实习中的场景，主要考察网络安全的基本功底
> 证书链、TLS、加密解密.....（这一部分比较多）
4.开发相关知识
> 面向对象的特性、Linux相关、Git
无手撕
二面（40min）
偏向于聊天，问Mysql和Redis比较多，同样问了很多密码
无手撕
nowcoder  /discuss/601509981006929920

0x00 字节跳动-渗透测试实习生
自我介绍
渗透的流程
信息收集如何处理子域名爆破的泛解析问题
如何绕过CDN查找真实ip
phpinfo你会关注哪些信息
有没有了解过权限维持
说一个你感觉不错的漏洞，展开讲讲
输出到href的XSS如何防御
samesite防御CSRF的原理
CSRF防御
json格式的CSRF如何防御
浏览器解析顺序和解码顺序
过滤逗号的SQL注入如何绕过
过滤limit后的逗号如何绕过
fastjson相关漏洞
说一个你知道的python相关的漏洞（SSTI原理，利用过程,payload相关的东西）开放性问答

0x01 阿里云安全实习
时长：20分钟
自我介绍
看你简历上说擅长java、php代码审计，也没有类似的经历能够分享一下，比如说独自审的一套代码或者开源项目，从中发现的一些比较高危的问题
在审项目的时候，比如一个web网站，简单说说思路
简单描述一下什么是水平越权，什么是垂直越权，我要发现这两类漏洞，那我代码审计要注意什么地方
解释一下ssrf
怎么防御ssrf，场景：ip/?url=image.jpg
常见的内网段有哪些，他们的掩码是什么
教育系统攻防演练，分享一个渗透的例子
除了学校，有没有试过渗透别的系统
像这样的场景（给内网靶标），渗透内网系统的思路
反问环节（问了工作内容）
岗位做的是阿里云云平台安全，内部安全保障，保障阿里云自身的安全不出问题，整个系统的上线前中后过程，每个方向都有人

0x02 深信服-漏洞研究员实习
时长：15分钟
自我介绍
在xx实习的时候做什么东西
渗透测试的思路简单说一下
护网在里面担当一个什么样的角色
红队的一些思路
拿下系统后有没有做横向
前段时间那个log4j有研究吗，可以简单说一下吗
（继上一个问题）有哪些混淆绕过的方法
内存马有没有了解过
冰蝎、哥斯拉这些工具有没有了解过
做攻击队的时候有没有研究过什么攻击，比如研究一些工具还是魔改什么的
那么多漏洞和攻击，比较擅长哪一个
说一下shiro反序列化的形成原因、利用链
对一些bypass的方法有没有了解过，有什么姿势可以简单介绍一下
反问

0x04 字节跳动-安全研究实习生
一面
时长：50分钟
你投的岗位是安全研究实习生，你了解我们这边主要是做什么的吗
自我介绍
现在有什么比较想做的方向吗，比如你写的代码审计、攻防演练、你在学校的研究方向（密码学）其实是三个大方向，现在有什么比较想做的吗
说了代码审计、安全研究
有没有审过开源框架、cms、中间件之类的
面试官介绍了工作内容
我看你简历上有几段实习经历和项目经历，先聊一下实习经历吧，在A主要做什么的
详细聊聊入侵检测主要在做什么，遇到的问题
关于入侵检测产生大量误报的原因，有没有分析过，有没有比较好的解决方法
和A比起来，B的应该就比较偏攻击方对吧，有打仗（雾，面试官好像确实是这么说的）有代码审计，聊一下在B主要做了些什么
审表达式引擎的步骤和思路
刚刚你说的审计听起来好像和普通开发的审计差不多，都是通过程序流、文档去做，有没有从安全方面入手审计一些项目
xxe是怎么造成的，从代码层面来看
我看你简历有很多攻防演练经历对吧，这几段攻防演练经历有没有哪一次印象比较深刻的，挑一个聊一聊
你的这次攻击好像更多的是利用弱口令，有没有一些更有技巧的方法
这个头像上传的webshell是怎么上传的
还有什么其他的检验方式？要怎么绕过？
这两天log4j漏洞很火，有没有去了解一下
面试官最后介绍业务


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

4、运营开发/应用开发（全栈）

运营开发：前端+后端+测试+数据+运维，主打一个全栈。面试一般可以参照后端作为标准。

应用开发

1、简单来说，就是内部运营系统，研发职称系统的开发，其实本质上与测试开发、运维开发区别不大，不过更加接近业务一些。 也可以理解为是ToB的业务。
2、因为本身不带来商业价值，所以一般大厂才会养，而且团队比较精简，推崇全栈的方式。需要相关的专业领域知识，但又不是涉及业务的那种。这些特点与上面的那些测试、安全、运维开发都是一致的。

运营开发

运营开发是公司中的一种岗位，主要职责是负责开发和维护各种在线应用程序和系统，确保它们的稳定性、性能和安全性。运营开发通常与软件工程师、系统管理员、网络工程师和数据分析师等专业人员合作，以确保应用程序和系统的运行顺畅，并及时解决任何可能的故障。
运营开发的工作内容包括但不限于：开发、测试、部署和维护软件应用程序和系统；监控和分析应用程序和系统的性能和行为，发现并解决问题；编写脚本和工具以自动化各种任务和流程；与其他团队合作，确保应用程序和系统与其他组件和服务的互操作性。
总的来说，运营开发是一种需要高度技术能力和团队合作精神的岗位，需要对计算机科学和信息技术有深入的了解，并具备一定的编程和系统管理能力。
运营开发的说法好像是企鹅特有的，不过其他公司也会有同样性质的岗位，换个说法。
运营开发：前端+后端+测试+数据+运维，主打一个全栈。面试一般可以参照后端作为标准。

牛客话题

面经

tx
莫名其妙被中台部门软件开发-运营开发捞面了，之前只投过实习岗，上周六电话让我面秋招。由于一直很忙，也没时间准备，练了几个排序算法就上了。
面试内容
上来就写题，一道sql + 一道mid，但是要我自己定义链表，脑子有点短路，其实不难，但就是输出不对，折腾半个小时面试官让我算了。然后就是计网：长连接和短连接，同步与异步在长连接中。OS：虚拟内存，分段与分页。java：IO，公平锁，可重入锁。
redis：模糊查询。啥也不会，之前面试也没人问这些。然后就听到一声叹气，我人都麻了，真给我打击了。
反问：运营开发干嘛的
答：就是后端开发，toB业务



腾讯 运营开发 暑期实习面经（1-3面）
投的腾讯后端开发，调到TEG运营开发岗
【一面】3.16
面试时间40min。面试官人很nice，口音问题有些没听清的问题会重复好几遍
1. 简单自我介绍
2. linux熟悉吗，说一些你用过的指令（看好多运营开发的面经都有问到）
回答了基本的一些，问shell用过吗，还有一个用过吗（没听清），都答没用过不太了解，gcc用过吗
3. 数据结构，hash、平衡二叉树、二叉树优劣、遍历方式（简单描述一下前序遍历）、arraylist和vector区别
4. 快速排序、冒泡排序，最好最坏时间复杂度以及区别（没有写代码，纯口头描述流程）
5. 网络， TCP和UDP区别， 说到了tcp可靠，如何保证可靠，说到了拥塞控制，让我详细说了一下拥塞控制
tcp time_wait状态发生在什么时候
6. 面向对象三大特点
7. 多路复用select、epoll了解吗（没答上来）
8. Java基本数据类型
9. string ==和equals区别
10. 抽象类和接口区别
11. 深浅克隆区别，以及如何实现
12. JVM分区
13. GC 说了一下几种方法，没有细问
14. 数据库索引 B+树、聚簇索引
15. 数据库锁（没答上来）
16. 项目相关：nginx负载均衡哪些方式、redis内存回收、cookie和session怎么实现
17. 项目中遇到的困难、收获了什么
18. 接受转Go语言吗
反问
事业群：TEG
运营开发主要工作：也是后台开发，与数据分析相关
表现如何：应该没问题，会等简历比较然后择优通知二面（听意思是还要筛选一轮简历）

【更新二面】3.18 45min
是个很nice的小姐姐
1.问项目，挖的比较深，一直问到答不出来
2.排序算法和时间复杂度
3.场景题：一个很长的列表里面包含很多字符串，如何判断一个字符串是否在这个列表里，不使用数据结构。
答得不是很好，刚开始想的是按长度初筛然后长度相同就一个一个字母比对，后面想到能不能使用哈希，面试官问字符串使用哪种哈希算法比较好，没答上来。
4.代码题：一个long整型，判断其二进制有多少个0
我和面试官都不太会用面试网站的代码编辑器，面试官看不到我写的代码，我提交报main class错误。。然后共享屏幕用我自己的编辑器写的。
5.什么时候可以入职
反问:
1.表现如何：应该没问题
2.我系统上显示的还是初试：应该是一面面试官搞错了，问题不大
【更新三面】3.19 HR面 15min左右
超级nice的hr小姐姐，基本上没面。让我自我介绍了一下，然后就跟我介绍部门以及工作时间之类的，是否接受在深圳工作，几月能入职、是否有亲人在腾讯等等
反问：后续流程、转正hc多吗（60-70%）、还要笔试吗（不用了）、薪资房补（实习生统一，后续会通知）、加微信、状态还是复试（前面流程错了，交给她改过来就行）
【总结】
三面面试体验都相当不错（也可能是部门确实缺人），一面考察知识广度，二面深挖项目，三面hr可能更多的是看剩余hc吧。面试官都十分亲和，会开玩笑聊天之类的。
nowcoder.com/discuss/353157661468336128


腾讯运营开发一、二、三、HR面面经（已oc）
8.16   一面
1.部门介绍
2.自我介绍、项目介绍、实习介绍
3.如果和下游在接口定义上产生了分歧怎么办
4.智力题？？？
1）5L、3L桶取4L水
3）100个苹果，两个人依次拿1-5个，怎么保证最后一个自己拿到
5.编程
1）随机队列二分搜索 - 要自己写排序
2）二叉树的广度优先和深度优先搜索
6.计算机网络
1）请求一个URL，过程发生了什么
2）四次挥手time_wait,close_wait
3)  拥塞控制，慢启动
7. 数据结构
1）设计热搜榜 - 说了redis的sorted set，又问具体，说了堆，堆是稳定排序嘛
8. mysql
1）聚簇索引，非聚簇索引
2）1亿个QQ号，找对应的注册时间怎么找，说不是数据结构是查询优化考察，用聚簇索引还是非聚簇索引
9. redis
1）zset的底层结构？
10. 操作系统
1）进程、线程、协程
2）进程间通信方式，跨主机通信呢？（套接字，但是没很深了解）
然后说了大概下周五大家一起面试完了给结果
然后问我能不能去实习
反问
1）技术栈：php，go，可能有需要前端
2）建议不好评价没说
---------------------------------------------------------------------------------------
8.17 二面
二面估计是凉了
1. 自我介绍，项目介绍，实习介绍 2min
2.linux命令一直说不解释
3.SQL关键字一直说不解释
4.一个场景题，14亿人，身份证和信息，查询第1w~2w人的信息
5.一个概率题，一个圆上四个点，一刀过圆心，切出两个点的概率
6.输入一个URL全过程
7.一个代码题，判断字符串包含，突然蒙住了，面试官想让用KMP没写出来
8.说自己的两个亮点
9.说自己两个缺点
10.堆和栈的区别
11.java多态实现原理
反问
1. 工作具体内容：游戏的活动都是这边做
2. 几轮：3~4轮
二面居然过了约了三面...顺便对于海量数据处理的题目，大家有什么技巧总结吗，以及这种概率题........
----------------------------------------------------------------------------------------
8.18 三面
1. 自我介绍，项目介绍，实习内容介绍
2.redis高可用，rocketMQ选择，不同MQ对比（为什么rockeMQ多Topic吞吐量较大）
kafka不支持重试，不支持定时消息，不支持事务消息，可能存在消息乱序（一台broker宕机情况下）
3.redis主从复制，缓存雪崩，穿透，击穿，布隆过滤器
4.https流程，怎么测算建立一次连接时间
5.hashmap底层，如果海量bucket怎么优化，hashmap初始容量为什么设定16，为什么负载因子0.75
设置16是因为是2的幂，符合内部计算的机制，而且这个值，不大也不小，太小了就有可能频繁发生扩容，影响效率。太大了又浪费空间。而加载因子0.75的是为了提高空间利用率和减少查询成本的折中，0.75的话碰撞最小。
6.算法题：栈实现队列
反问：
1. 部门用的语言：go php
HR面
1. 自我介绍实习介绍
2. 实习中的困难，为什么没转正
3. 性格上优缺点，兴趣爱好
4. 流程上的一些问题，直系亲属身体状况等等。。
5. 反问  大概是说HR面结果这周内给，意向书要九月份才给
nowcoder.com/creation/subject/9e2095e4042441bda814f83e935ea742

腾讯运营开发 实习面经
被捞三次，被挂三次
面完秒灰体验极好，心态逐渐平和
祝大家好运~
TEG一面(30min)运营开发
1.      聊课程
2.      计算机组成结构
3. Tcp端口范围
4. Linux常用指令：
查看进程下的线程
Vim快捷键
5. Python 常用框架
6. Python读取文件函数的库
7.      聊一个竞赛，聊一个项目
8.      为什么投
9.      反问
PCG一面（不到30min）运营开发
1.      自我介绍
2.      编程：两个日期间隔天数
3.      聊项目，项目最大的难点，怎么解决
4.      常用的linux指令
5.      你了解大数据吗
6.      朋友对你高频的三个评价
nowcoder.com/creation/subject/9e2095e4042441bda814f83e935ea742

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

5、客户端：PC & 移动 & 游戏

基本与后端保持一致，侧重系统 & 网络，数据库mysql&redis部分相对问的较少。
重点会问系统相关的开发，PC客户端主要是C++开发经验。
移动客户端：前端相关的flutter，Android，IOS等**。
游戏客户端：补充一些游戏引擎：UE4、图形学等

客户端就业现状，奉劝那些想做客户端开发学弟学妹们！

客户端通常面临的环境是单机的环境，但是因为直接面对用户的设备，所以环境总是处于一个复杂和不可控的环境中，面临的设备类型比较多，各种设备类型又会有不同的情况，例如不同机器的屏幕大小不一样，需要做不同的适配，不同厂商的推送服务，后台管理策略等等不太一样，造成体验的不一致，不同设备的内存空间，磁盘大小等也不一样，需要有一些相对应的优化手段。因为客户端通常直接面向用户的体验，所以对UI的展示，用户的操作等等这块会比较敏感。
有后选后肺腑良言。互联网整体环境不乐观，现在没有新的大型app出现了，没有增量。客户端残留开发人员众多但岗位减少，导致要求越来越苛刻。而且大前端趋势、跨平台方案频出、小程序肆虐，原生客户端不再是应用开发唯一的方案，中小公司已经没有了客户端的需求，大公司新业务也是跨端方案。客户端就是一门江河日下的夕阳技术再不跳船就要淹死了。
还有最重要的一点，客户端在国企银行证券没有岗位，他们只有系统开发工程师是做系统的，客户端无法上岸只能35被裁。客户端就是画UI的，上限太低，有的大型app会自己造些轮子，但是出去了没需求，不通用。后端做系统才是刚需。劝退不是搞笑，都是血泪凝结的经验总结。
无脑后端，前途无量，预定高管；其次前端，需求频繁，温饱有余；算法数据，收入可观，高端饭碗；测试开发，也可一战，随手一点，月入过万。走投无路，回家种田，日出日落，生活美满。鬼迷心窍，来客户端，技术拉胯，UI切图，面试火箭，不到三年，全部玩完，65在后，绿帽在前，苦口婆心，金玉良言，奉劝诸位，擦亮双眼。

客户端就业市场的供需情况，关于没有技术壁垒，

客户端八股

基本与后端保持一致，侧重系统 & 网络，数据库mysql&redis部分相对问的较少。
重点会问系统相关的开发，PC客户端主要是C++开发经验。
移动客户端会有，前端相关的flutter，Android，IOS等。
游戏客户端会补充一些游戏引擎：UE4、图形学等

——————————————游戏客户端————————————————


3.1 C++八股
1.内存

    ①内存分区

        几个区域分别存放什么

        堆和栈的区别

        static变量在哪里

        什么const在常量区，什么const在栈区，什么const放入符号表优化

        虚函数表既然希望类的所有对象共享为什么不放在全局区

    ②几个基本数据类型占多少空间

    ③内存对齐

        为什么要内存对齐

        自定义类型的内存对齐规则，举例子算占多少内存空间

        什么时候不希望进行内存对齐

        #pragma pack

2.多态

    ①虚函数

        构造/析构函数能否是虚函数

        构造/析构函数里能否调用虚函数

        讲讲虚函数指针和虚函数表

        虚函数指针什么时候创建、存放在哪里

    ②模板

        模板是要解决什么问题，有什么缺点

        模板的声明和定义为什么不能分开写，要想分开写该怎么做

        模板特化、偏特化

        模板在编译时生成的代码是否会相同，生成的相同的代码如何处理

3.其他语法

    ①继承时一般要写类的哪些成员函数

    ②拷贝构造函数和移动构造函数，深浅拷贝等等

    ③内联是什么，为了解决什么问题，递归函数的内联会有什么问题

    ④野指针是什么

    ⑤指针和引用

        有什么区别（说越全越好）

        值类型、引用类型，C++的值、指针、引用

        它们两个传参时是否要复制

        除了传值，还有什么情况C++会拷贝构造临时对象

    ⑥new/delete和malloc/free

        有什么区别（说越全越好）

        delete如何知道该释放多大的空间，这些信息存在什么位置

        delete[]和delete的区别，基本数据类型的数组使用delete可以释放完全吗

    ⑦怎样让对象只能创建在栈/堆/内存池中

    ⑧具体如何重载operator new

    ⑨RTTI原理，type_info信息存在虚函数表的哪里

4.C++ 11

    ①Lambda表达式

        Lambda表达式如何对应到函数对象

        圆括号传参数是如何实现的

        方括号捕获外部变量（闭包）是如何实现的

    ②智能指针

        有哪些智能指针，为了解决什么问题

        shared_ptr的引用计数机制，它的问题，如何用weak_ptr来解决

    ③类型转换

        四种cast简述，分别的使用场景

        dynamic_cast和虚函数的区别（dynamic_cast是为了使用子类的非虚方法或成员变量）

    ④右值

        左值、右值的概念，C++哪些情况下会产生临时对象

        移动语义

        移动构造函数和拷贝构造函数的区别

        转发和完美转发的概念

5.STL

    ①vector

        vector的capacity和扩容机制，使用时要注意什么

        接着上一题，如果扩容时会引发自定义类型挨个复制构造，C++有什么机制来避免这一点（右值，swap）

    ②list

        vector和list的区别，内存、复杂度等

    ③map

        二叉排序树、平衡二叉树、红黑树的设计思想

        红黑树的几个性质，各种操作的时间复杂度

    ④unordered_map

        哈希表跟红黑树的比较，优缺点、适用场合，各种操作的时空复杂度

        unordered_map容器的具体实现，怎么取哈希值，怎么处理哈希冲突

6.其他问题

    ①C++静态链接库（lib）和动态链接库（dll）的区别

    ②顺序遍历链表和顺序遍历数组哪个更快，为什么（我答的数组，原因先猜的不用指针寻址，再猜的cache命中率高，面试官都不认可）

    ③memory_move和memory_copy两者的作用和区别

    ④一段代码怎么样在main函数之前调用

    ⑤你觉得C++有什么功能跟面向对象的三大特性相悖

3.2 游戏引擎问题
面试官会找你擅长的引擎问。我这里记录的都是UE4的问题。

我实习内容跟Slate渲染流程的性能优化相关，就把UI模块的一部分源码看得比较细，有的面试官会顺着我会的聊很多，所以下面我写下来的问题比较多。但整体上来看，AI、网络同步是更多面试官喜欢问的，如果要准备推荐先看这些模块的资料。

UE4 C++是做UE的厂必问的，差不多就问gameplay架构、反射、GC、智能指针这几部分，不过大概都会被问到不会为止。

1.UE4 UI模块

    ①UMG和Slate的关系

    ②UMG的几种Widget分类

    ③Slate tick的大致流程，invalidation下的tick流程和缓存更新细节

    ④LayerId的分配机制（跟第②个问题相对应。SLeafWidget、SCompoundWidget派生的控件基本上都直接用父类的，SPanel派生的Overlay和ConstraintCanvas重写了比较特殊的规则）

    ⑤Slate的update flag和invalidate reason举几个例子，分别是什么意思

    ⑥render batch合批的规则

    ⑦对游戏UI框架设计的思考

    ⑧其他的性能优化方法

2.UE4 AI模块

    ①EQS是什么

    ②UE4的AI行为树有什么结点

    ③为什么要单独用黑板存储数据

    ④AI perception是什么

3.UE4 网络同步

    ①UE4的网络架构（C/S、状态同步、UDP）

    ②主端、服务端、模拟端的概念

    ③UE4 RPC能够调用的条件是什么，除了authority是player controller之外的其他条件

4.UE4 C++（这些会先问有什么了解，然后根据你的回答往细了问）

    ①Gameplay架构（做UE4的厂必问。主要是知乎上大钊的一系列文章）

        讲讲UE4的Gameplay架构

        GameMode和Actor都继承自UObject，那么什么样的UObject才能被拖到场景中

        Level能有几个，跟World什么关系，GameInstance是什么

    ②反射

        为什么要用反射

        UBT、UHT具体做什么，如何支持反射

        MetaData是什么，派生出什么，跟我们用的UPROPERTY、UFUNCTION等宏如何对应

        平时写的宏有什么用，比如UCLASS代表什么

    ③GC

        UObject本身的GC使用的标记-清除法的大概流程，分帧之类的细节

        如果派生自UObject的对象不想使用引擎的这套GC，该怎么做

        如果非UObject的自定义类型想使用这套GC，该怎么做

    ④智能指针

        UE4 C++的智能指针和C++ 11的智能指针有什么区别和联系，要解决什么问题

        TWeakPtr等能不能指向UObject类型的对象，能指向UObject的智能指针是什么

        TWeakObjectPtr怎么判断指向的UObject对象是否invalid

        智能指针GC和UE4自己的GC是否会冲突

5.开发经验

    ①用rider for Unreal（IDE）调试的心得

    ②Widget Reflector（调试UI的引擎工具）的使用经验

    ③Gameplay开发中，UE4变量、方法之类的哪些应该写在C++里，哪些写在蓝图里

3.3 游戏开发问题
关于游戏开发的通用问题。各个模块会再问一些特定引擎的问题，对照上面的3.2。

1.游戏AI

    ①常用的做法简述（NavMesh + 寻路）

    ②NavMesh的生成过程简述

    ③A*寻路算法的原理

    ④是否了解多个AI都在自动寻路时的动态避障算法

2.物理碰撞

    ①如何判断子弹射击到敌人（然后继续问包围盒、碰撞检测算法等），如果子弹特别快怎么办

    ②BVH、八叉树等场景管理加速结构，在这些树上检测碰撞的过程

3.网络同步

    ①状态同步和帧同步的原理

    ②上面两个在反作弊、断线重连、实时性等等场合，用哪种同步策略好

    ③TCP和UDP应用上的区别和游戏开发中的使用偏向（不用细说它们的原理）

4.场景题

    ①跳跃到最高点自动开枪，这个功能应该怎么做

    ②游戏分辨率变换、窗口尺寸变换时，UI应该怎么适配

    ③角色可以穿脱装备，每个装备对角色的血量有不同的buff，该如何设计这个功能

    ④水的着色应该写在vertex shader还是fragment shader

    ⑤游戏中物体从不透明变成透明，对渲染有什么难度

5.游戏设计模式

    ①单例模式的作用，使用单例模式和只创建一个static对象有什么区别

    ②工厂模式，有构造函数为什么还要设计抽象工厂模式

    ③观察者模式，MVC是什么、怎样对应观察者模式，观察者模式的应用场景

6.其他

    ①Unity对象生命周期（乍一听不知道是什么意思，实际上是问MonoBehaviour类的tick过程中，各函数调用的顺序，Awake、Update、FixedUpdate、OnDisable等等）

    ②让你设计一个游戏引擎UI框架，有什么想法，要考虑什么

    ③游戏引擎的RHI是干嘛的

    ④游戏开发中的对象池技术是干嘛的

3.4 图形学
对于客户端开发，图形学只是加分项，不算特别重要。我是入门水平，也没有相关的项目，所以被问到的不多，绝大多数公司只让讲一下渲染管线就好了。

1.图形渲染管线，会先让你大致讲一下渲染管线，然后问一些细节问题

    ①drawcall是什么，为什么要减小drawcall

    ②粗细粒度culling的区别

    ③MVP、viewport分别进行什么变换

    ④深度测试是什么，early-z是什么

    ⑤延迟渲染管线是什么，有什么优缺点

    ⑥半透明物体的渲染顺序

    ⑦shader中为什么要避免使用if语句

2.抗锯齿技术

    ①MSAA、SSAA的区别

    ②延迟渲染为什么用不了硬件AA

    ③DLSS原理的简单说明

3.光照模型

    ①BRDF概念

    ②简单描述blinn-phong光照模型，specular、ambiant、diffuse

    ③简单描述pbr光照模型，lambert漫反射 + cooktorrence反射（DGF）

3.5 计算机基础
五百年没看了，只记得几个经典知识点，再问详细的实在是忘了。跟面试官说不会，基本上也不会再细究。

编译的过程，几个阶段分别发生什么
寻址的过程
虚拟内存空间的概念
进程和线程的概念
进程间通信方式
进程的多个线程是否共享进程的全部资源
进程切换、线程切换，是否引起上下文切换、用户态/内核态切换
为什么线程太多会导致性能下降（1s的进程分10个线程，比分100个线程的执行时间要更短，为什么？我答了调度有消耗但面试官不认同）
怎么发现、定位内存泄漏
OSI网络模型
TCP、UDP的区别
在应用层如何保证UDP的可靠传输
TCP的三次握手四次挥手
3.6 算法题、数学题、脑筋急转弯
口述：判断扇形攻击命中（2D空间判断点在扇形内）
口述：2D空间中，在三角形/圆内如何随机并且均匀采样点，均匀是指点各自占的面积尽量均匀
口述：判断点在三角形内（比较基础，但经常被问。重心坐标、叉乘法、面积求和）
口述：层次遍历二叉树
口述：快速排序
口述：绳子分成3段，要求三段长度乘积最大
口述：两个鸡蛋判断最少从哪层楼扔下来会碎，怎么弄比较好
口述：如何检测链表相交的所有情况，包括有环、在环上相交、入环点不一样等等
手撕：1、2、3、4、5、6、7、8的链表变成1、8、2、7、3、6、4、5，不使用额外存储空间
手撕：合并n个有序链表
手撕：有重复元素的顺序数组，查找新来的元素最前面的插入位置
手撕：DFS解数独
手撕：数组的最长递增连续子序列长度
手撕：两个字符串的最长不连续公共子串（逆天，看一眼直接放弃）
手撕：链表的倒数第k个元素
手撕：顺时针90度旋转矩阵
手撕：数组的第k大元素
手撕：判断汉字的unicode编码是否合法（题很长，记不清了）
手撕：判断回文链表，不使用额外存储空间
四 各公司面试体验
总览
一面挂：tap4fun，红海无限，极致游戏，SNK中国，永航科技，联想研究院（U3D）
二面挂：诗悦网络，字节跳动朝夕光年，剑心互娱，分岔点VR，酷家乐（渲染开发），祖龙游戏，柠檬微趣
三面挂：中国系统（UE4）
放弃hr面：游族（听说必须实习），360游戏（听说必须实习）
全部面完：盖娅互娱（必须实习），数字天空
总结如下（大致按一面时间排序）。


nowcoder  /discuss/428252230693683200


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382

——————————————PC客户端+1————————————————

常见JD


能力要求:有3年以上使用C/C++进行Windows系统客户端软件开发经验;有工具类，尤其是图片编辑相关业务经验优先;熟悉OpenCL/OpenGL/ CUDA和shader编写优先。

能力要求:有3年以上使用C/C++进行Windows系统客户端软件开发经验;有加速器/VPN/SDN等开发经验优先;熟悉Wintun/WFP(Windows Filtering Platform)/openVPN等网络驱动优先。


1
2
3
4
5
6

常见面经


一面（50分钟）
一、自我介绍
二、知识点考察
1.     C++
1.1.  vector的扩容策略
1.2.  map是怎么实现的
1.3.  说一下对红黑树的了解
1.4.  unordered_map的哈希表是怎么解决碰撞问题的
1.5.  deque了解吗，说一下实现原理
1.6.  C++是面向对象的语言，虚函数可以实现多态，谈谈你对虚函数的理解
1.7.  你觉得在构造函数中可以调用虚函数吗
1.8.  构造函数有哪些
2.     网络
2.1.  https协议实现过程
2.2.  刚才这一过程的证书呢
2.3.  tcp协议是怎么保证可靠性的
2.4.  tcp是每发送一个包都会附上序列号的吗
3.     数据库
3.1.  MySQL了解
3.2.  说说B+树和B树的区别
3.3.  你觉得B+树和B树哪个更快一点
3.4.  数据库的索引有哪些
4.     操作系统
这一块内容在面完之后几天才整理，已经忘了问了哪些操作系统的题...
但是印象中还是比较常规的

三、算法题

剑指 Offer 22. 链表中倒数第k个节点

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

二面（50分钟）

一、自我介绍
二、聊实习经历和项目
三、算法题
面试官自己出的：实现一个音乐播放器shuffle歌单的算法，要求每次shuffle后歌单必须和上一次不一样；
已提供一个random(n)函数，此函数返回[0, n -1]之间的一个随机数。

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

三面（70分钟）
一、自我介绍及面试官提问（约5分钟）
二、知识点考察（约20分钟）
1.       C++
1.1       C++中的多态怎么实现的
1.2       你刚才提到了运行时的多态是用虚函数实现的，那么说一说虚函数
1.3       C++有GC吗
1.4       那么C++中内存泄露是怎么解决的
1.5       你刚提到了智能指针，展开讲讲
1.6       你刚提到的shared_ptr计数器，它的实现原理是怎样的
1.7       有了智能指针就能保证不会出现内存泄漏吗
2.       网络
2.1       在浏览器输入网址到看到网页内容，这一过程背后是怎么实现的
2.2       你刚提到的dns，它有哪些解析的方式呢
2.3       你刚提到的http，它和https有什么区别，展开讲讲https
2.4       了解中间人攻击吗
2.5       使用https一定能保证安全性吗
3.       操作系统
3.1       进程和线程的区别
3.2       进程之间通信的方式
3.3       你刚提到的管道是只能在父子进程之间吗
三、填空题（约3分钟）
给出二叉树的前序遍历和中序遍历，写出这颗二叉树的后序遍历
四、聊实习经历（约15分钟）
五、算法题（约15分钟）
剑指Offer 32. 按之字形层序打印二叉树

六、反问（10分钟）
1. 自我介绍
2. HashMap底层原理：底层数据结构、put过程（本来想继续说get和扩容机制，但面试官开始说下一个问题了，hhh）
3. HashMap是线程安全的吗
4. 那怎么解决HashMap线程安全问题
5. ConcurrentHashMap简单说一说底层原理
6. ThreadLocal大致聊了聊
7. 说一说synchronized关键字
8. Lock和synchronized关键字的区别（这里答错了，synchronized会自动释放锁，尴尬）
9. 读写锁简单聊了聊
10. 项目中乐观锁是怎么实现的
11. 项目中定时任务怎么实现的
12. Mysql的读写锁
13. 如何创建线程
14. 线程安全问题有什么，怎么解决
15. 如果要有返回结果的线程呢
16. 线程池的五大参数
17. 线程池的拒绝策略
18. 回收线程
19. JVM垃圾收集过程
20. 为什么HotSpot要用可达性分析，引用计数算法有什么缺陷
21. 新生代和老年代用到的算法是一样的吗，用到什么算法
22. ......
23. 反问
24. 几轮面试
25. 评价回答情况


一面：
1.自我介绍，项目
2.synchronized,volatile
3.等等吧，比较杂，记不住了
编程：sql一道，位运算实现a+b,链表中删除连续的和为0的序列
二面：
1.自我介绍
2.项目相关的，应用情况
3.线程池实现，弊端
4.线程间怎么通信
5.虚拟地址、逻辑地址、物理地址相关
6.子网掩码
7.dns服务器，为什么大公司都有自己的dns服务器，可以做哪些优化？dns解析过程？（不会）
8.redis数据库为什么快
9.类加载过程，双亲委派机制，为什么要这样做
10.jvm内存结构，简单分析
11.图像处理相关，如图像尺寸计算等
12.用户态和内核态，哪些系统调用是内核态调用的？I/O相关read(), write()等
13.tcp,udp的区别，tcp如何保证可靠连接
14.Java中闭包有了解过吗，为什么lamda函数无法访问所在方法内的变量，idea会提示设置成final，这么设计的原因是什么（好像和jvm编译有关）
15.反射和注解有了解过吗，为什么能拿到方法等
16.ipv6相关（不会）
编程：给定N和一个数组，用N每次可以减去最左端或者最右端的值，减完后删除，问N能否减到0，最少操作次数。不能减到0则返回-1
三面：
1.自我介绍，项目。
2.霍夫曼编码，以及二义性问题如何解决的
3.如果让你给新入学的大一新生上课，你怎么讲解一门语言，章节怎么安排？比方说python
4.设计模式了解哪些？单例，观察者，生产者和消费者。。。了解过适配器模式吗？没
4.图像处理，图像编码，视频编码，图像信息提取？纹理信息提取
5.开心网需要绑定微信，实时通知用户信息，这个通信过程你怎么设计
6.一群人中有一个superstar,所有人都认识这个sp,sp不认识任一个人，给你一个能返回A是否认识B的方法，你如何最快地找出这个sp？



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

——————————————附PC客户端面经9篇————————————————

岗位JD

快手-客户端开发工程师
全职
工程类 - 客户端
北京、杭州

2024-03-25
职位描述
1、负责快手各产品的客户端设计与开发；
2、负责基础模块和组件的研发和维护； 
3、关注性能，提升客户端用户体验。
任职要求
1、本科及以上学历，计算机相关专业优先；
2、有扎实的计算机基础知识，掌握算法和数据结构，熟悉计算机网络知识；
3、掌握一种及以上的编程语言，C++/Java/Objective-C语言优先；
4、熟悉面向对象的设计思想。

加分项：
1、有客户端相关实际项目经验或互联网公司实习经验者优先；
2、开源社区活跃贡献者优先，有OI、ICPC等相关竞赛经验者优先。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1、

快手客户端一面
1、计算机网络 拥塞控制，http/ https 请求方法
慢开始：1、2、4、8 …增长非常快
拥塞避免：到达门限后每次+1，超时就门限/2，重新执行慢开始。
快重传：收到三个重复确认，例如收到三个 M2，则 M3 丢失，立即重传 M3。
快恢复：此时令门限=窗口/2，窗口从新门限开始拥塞避免。

2、进程线程，线程有哪些资源，栈中保存什么，函数调用的时候压栈怎么样的，
线程私有，线程上下文：所属线程的栈区、程序计数器、栈指针以及函数运行使用的寄存器。
栈存储局部变量和函数参数的线性结构。
函数调用前，先把返回地址。压栈，然后把当前函数的指针压栈。

3、c++项目完整流程，静态链接库和动态链接库有什么区别，动态链接库怎么装载到内存的
动态通常用.so为后缀，静态用.a为后缀。
动态运行时载入，静态编译时载入。

4、虚拟内存，中断，操作系统的锁，自己实现一个读写锁
虚拟内存是操作系统提供的一种内存管理技术，它使得应用程序能够访问大于物理内存容量的地址空间。通过虚拟内存，每个进程都认为自己拥有独立的连续内存空间，并且可以访问其中的数据。
中断是计算机系统中的一种事件，它可以打断正在执行的程序，转而去执行一段特殊的程序（中断处理程序），以响应某个事件的发生。中断可以来自各种不同的事件，例如外部设备的请求、时钟中断、错误事件等。
中断的主要作用是提高系统的并发性和响应性。通过中断，系统可以及时地响应外部设备的请求，而不需要等待设备的完成。当中断发生时，当前正在执行的程序会被暂停，系统会跳转到中断处理程序进行处理，处理完毕后再返回到原来的程序继续执行。

操作系统的锁：
操作系统的锁是一种同步机制，用于控制多个进程或线程对共享资源的访问。它可以确保在任意给定时间只有一个进程或线程可以访问共享资源，从而避免了并发访问可能导致的数据不一致或竞态条件的问题。
常见的操作系统锁包括互斥锁（Mutex）、读写锁（ReadWrite Lock）、条件变量（Condition Variable）等。
自己实现一个读写锁：
下面是一个简单的读写锁的实现，基于互斥锁和条件变量：
在读取状态下，多个线程可以同时获取读取锁，但无法获取写入锁。只有在没有线程获取写入锁时，才能获取读取锁。

在写入状态下，只能有一个线程获取写入锁，而其他线程无法获取读取锁或写入锁。只有在没有线程获取读取锁或写入锁时，才能获取写入锁。
读写锁的主要方法包括：
lockRead()：获取读取锁，如果有其他线程正在写入或有活跃的写入锁，则阻塞等待。
unlockRead()：释放读取锁，如果没有其他线程获取读取锁，则通知等待的写入线程或唤醒其他等待读取锁的线程。
lockWrite()：获取写入锁，如果有其他线程正在读取或写入，则阻塞等待。
unlockWrite()：释放写入锁，如果没有其他线程获取写入锁，优先唤醒等待的写入线程，否则唤醒等待读取锁的线程。


5、算法题 二叉树层序遍历 构建一个二叉树测试



 nowcoder  /feed/main/detail/559605511ed54dff8a1e604ccec04d88


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2、

快手客户端开发一面
面试官 商业化

问题
1.浏览器输入网址回车后，都发生了什么
zhuanlan.zhihu  /p/80551769
dailichun  /2018/03/12/whenyouenteraurl.html
URL 解析
DNS 查询、TCP 连接（构造请求，三次握手，ARP找路，广播传输）
处理请求、接受响应、渲染页面

a：三次握手
1.1三次握手多一次少一次行不行，为什么不行。
1.2tcp和udp的区别
2.http和https区别，七层模型，http在哪一层？
3.了解域名吗，有什么用，了解dns吗。
CA获取 SSL 证书。这些网站会在交换数据之前先与浏览器共享该证书。默认端口 443
http无状态：
也就是说服务器不维护任何有关客户端过去所发请求的消息。这其实是一种懒政，有状态协议会更加复杂，需要维护状态(历史信息)，而且如果客户或服务器失效，会产生状态的不一致，解决这种不一致的代价更高。
51cto  /article/701195.html
SSL 3.0 进一步升级，新版本被命名为 TLS 1.0


4.进程和线程
进程是资源分配的最小单位，线程是CPU 调度的最小单位，一个进程可以有多个线程
进程编程调试简单可靠性高，但是创建销毁开销大；
线程正相反，开销小，切换速度快，但是编程调试相对复杂。
进程通信：管道、系统IPC（包括消息队列、信号量、信号、共享内存等）、以及套接字socket
线程通信：临界区，互斥量，信号量，事件。

5.线程中的互斥锁和xx锁
主要用于线程互斥
当进入临界区时，需要获得互斥锁并且加锁；
当离开临界区时，需要对互斥锁解锁，以唤醒其他等待该互斥锁的线程。

6.cpp的面相对象相比面相过程有什么优势
a：不用重复造轮子，效率高。继承封装多态
7.cpp多态是什么
8.写完代码后，代码运行变成二进制数中间有什么过程。

算法题：
判断链表是否有环
怎么判断环的长度。



 nowcoder  /feed/main/detail/a4df659040494b8fa4e7bef2ee35abf7


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

3、

快手客户端一面
自我介绍，然后项目经历不是很匹配，面试小哥让我给他科普一下
然后开始问:

1.进程线程区别，进程资源类型(不确定)，线程切换方式，线程通信方式，线程池概念(到这不会了)

2.tcp与udp区别，http与https区别，http1.0 2.0 3.0区别，https概念，packet协议(到这里不会了)
HTTP1.1继承了HTTP1.0的简单，克服了HTTP1.0性能上的问题（支持长连接）。
HTTP2.0，二进制分帧，多路复用，头部压缩，服务器推送。
HTTP3.0，减少了tcp三次握手时间，以及tls握手时间
解决了http 2.0中前一个stream丢包导致后一个stream被阻塞的问题
优化了重传策略，重传包和原包的编号不同，降低后续重传计算的消耗
连接迁移，不再用tcp四元组确定一个连接，而是用一个64位随机数来确定这个连接更合适的流量控制
包(Packet)是TCP/IP协议通信传输中的数据单位
packet协议是由用户构造mac头和数据部分，系统只负责发送和接收，mac头收到数据包的时候，根据mac头判断出上层协议，然后遍历packet_type链表，找出对应的协议，再把数据包分发给他处理


3.智能指针，菱形继承，lambda表达式原理，C++11的新特性，C++中锁的类型(到这里不会了)
菱形继承：
由于最底层的派生类继承了两个基类，同时这两个基类有继承的是一个基类，故而会造成最顶部基类的两次调用，会造成数据冗余及二义性问题。

lambda表达式原理：
创建 lambda匿名类，实现构造函数。创建 lambda 对象。通过对象调用 operator()。

C++11的新特性：
auto，nullptr，引用，构造函数初始化列表，智能指针，array 以及tuple。

C++中锁的类型：
多线程中的锁主要有五类：互斥锁、条件锁、自旋锁、读写锁、递归锁。 


4.设计模式，说了几种
zhuanlan.zhihu  /p/128145128
《设计模式：可复用面向对象软件的基础》
1、创建对象
+ 单例：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
+ 工厂：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类。
+ 抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
+ 原型：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
2、对象之间的组合和关系
+ 适配器：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。（读卡器）
+ 装饰器：允许向一个现有的对象添加新的功能，同时又不改变其结构。（形状装饰上不同的颜色，同时又不改变形状）
+ 代理：（快捷方式，代售点）创建具有现有对象的对象，以便向外界提供功能接口。为其他对象提供一种代理以控制对这个对象的访问。
+ 外观：（接待人员，挂号、门诊、划价、取药）为子系统中的一组接口提供一个一致的界面
+ 桥接：（开关内外）一个作为桥接的接口，使得实体类的功能独立于接口实现类。
+ 组合：(操作数、操作符和另一个操作数)把一组相似的对象当作一个单一的对象
+ 享元：（数据库连接池）减少创建对象的数量，以减少内存占用和提高性能。
3、对象之间的通信和交互
+ 观察者：（消息队列），对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新
+ 备忘录：（ctrl+z，后退）捕获一个对象的内部状态，并在该对象之外保存这个状态。
+ 迭代器：（迭代器）提供一种方法顺序访问一个聚合对象中各个元素，而又无须暴露该对象的内部表示。
+ 模板（直接丢一个实体就可以保存）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
+ 策略：我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的context对象。
+ 中介者：MVC框架，其中C（控制器）就是M（模型）和V（视图）的中介者。


5.然后就是一个手撕，给一个"("和")"组成的串，求里面配对的"()"个数，实际上就一个栈，
然后面试小哥说还有时间，让我用动归尝试一下，最后尝试出来一个不知道对不对，
总之他让我简单说一下就过去了。 

 nowcoder  /feed/main/detail/fd567863994f4d139aa3a8164b1fcfab 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

4、

秋招首面快手-客户端开发工程师一面凉经
我本来投的手子都是嵌入式与linux岗位，结果到部门筛选都挂了；就瞎投了客户端软件开发，手子莫名奇妙给了个面，诚惶诚恐！！！下面记录一下面试过程：

1、CPU的最小时间周期是什么?（计算机中最基本的、最小的时间单位。在一个时钟周期内，CPU完成一个最基本的动作。）
2、CPU的指令怎么使用？（通过改变寄存器中的内容）
3、进程间的通信方式（管道，消息队列，套接字）
4、介绍一下虚拟内存到物理内存的映射
虚拟内存分页：
首先，虚拟内存被划分为固定大小的页（通常是4KB）。每个页都有一个唯一的虚拟页号。
物理内存分页：
同样地，物理内存也被分为固定大小的页，与虚拟内存页的大小相同。每个物理页都有一个唯一的物理页号。
页表：
操作系统维护一个称为页表的数据结构，用于记录虚拟页号与物理页号之间的映射关系。页表通常以树状结构组织，以支持大型的虚拟地址空间。
虚拟内存映射：
当应用程序访问虚拟内存时，操作系统会根据页表将虚拟页号转换为物理页号。如果虚拟页号在页表中存在对应的映射关系，那么操作系统会找到相应的物理页号，并使用内存管理单元（MMU）将虚拟地址转换为物理地址。
缺页中断：
如果虚拟页号在页表中不存在对应的映射关系，那么会触发缺页中断。操作系统会暂停应用程序的执行，并尝试从磁盘或其他存储介质中加载相应的物理页到物理内存中。之后，操作系统会更新页表，建立新的虚拟页号与物理页号的映射关系，并恢复应用程序的执行。
内存访问权限：
页表中的每个映射条目还可以包含关于内存访问权限的信息，例如读、写、执行等。操作系统可以根据这些权限设置来保护内存的安全性，防止应用程序越界访问或非法操作。

5、内存页的大小
6、内存页大小越大越好？还是越小越好，大了有什么影响、小了有什么影响
7、说一下缺页中断
内存页的大小是一个在设计虚拟内存系统时需要仔细考虑的参数，不同的页大小会对系统的性能和内存管理产生不同的影响。下面是对内存页大小对系统性能和内存管理的影响的一般性描述：
较大的内存页大小的优点：
较小的页表：较大的页大小可以减少页表所需的条目数，因为每个页表条目对应的内存范围更大。这减少了页表的大小，从而减少了内存开销和页表访问的时间。
较少的页表缓存（TLB）缺失：TLB是用于加速虚拟地址到物理地址转换的高速缓存。较大的页大小可以减少TLB缺失的概率，因为同一虚拟地址范围内的多个页可能被映射到同一个物理页，从而提高了转换的效率。
较少的页面表维护开销：较大的页大小减少了页表的数量，从而减少了页面表的创建、销毁和维护的开销。
较大的内存页大小的缺点：
内部碎片：较大的页大小可能导致内部碎片的增加。如果一个页面中只有一小部分被使用，那么剩余部分的空间就会被浪费，造成内存的浪费。
更新开销：如果一个较大的页面被多个进程或线程共享，当其中一个进程或线程修改了页面的某个部分时，整个页面都需要被复制到新的物理页中，这可能导致较大的开销。
较小的内存页大小的优点：
较小的内部碎片：较小的页大小可以减少内部碎片，因为更小的页可以更好地匹配应用程序的内存使用模式，减少未使用部分的浪费。
较小的更新开销：较小的页大小使得在共享页面进行修改时只需要复制更少的数据，减少了更新的开销。
较小的内存页大小的缺点：
较大的页表：较小的页大小会导致页表中的条目数量增加，增加了内存开销和页表访问的时间。
较高的TLB缺失率：较小的页大小增加了TLB缺失的概率，因为同一虚拟地址范围内的多个页需要映射到不同的物理页。

8、说一下什么是内存交换
内存交换（Memory Swapping）是一种操作系统中的内存管理技术，它允许将某些当前不活动的进程或进程的部分内容从主存（物理内存）移出，以释放内存空间，并将其存储到辅助存储设备（通常是硬盘）上，从而实现对内存的有效利用。

10、说一下ios七层网络模型
11、网络层有哪些协议
12、DNS了解吗？

手撕算法：二维数组顺时针打印输出
（函数写出来了，最后调试语法错了，被面试官结束）

#如何判断面试是否凉了##面试中的破防瞬间


 nowcoder  /feed/main/detail/0f666dbb4d9945589c3a6c563d8dc8d7 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

5、


快手游戏客户端一面凉经
挂了就放面经系列.jpg
1，自我介绍
2，做一道题：一副牌，能不能全凑成顺子和同花
3，对C++是什么级别的认知。
4，内联函数可不可以是虚函数
内联函数的展开：内联函数在编译时被展开，其代码会直接插入到调用处，以避免函数调用的开销。然而，虚函数的调用涉及到一系列复杂的机制，包括虚函数表的访问和函数指针的解引用等。这些机制使得内联函数和虚函数的实现方式存在冲突。
虚函数调用的机制：虚函数的调用需要在运行时根据对象的实际类型进行查找，这涉及到虚函数表（vtable）的查找和动态绑定。而内联函数在编译时展开，不需要进行运行时的查找和绑定。
内联函数的覆盖问题：虚函数的覆盖是通过在派生类中重新定义相同的函数签名来实现的。而内联函数的展开是在编译时进行的，编译器在编译时无法确定要展开的是基类的内联函数还是派生类的内联函数，因此无法正确实现覆盖的语义。

5，New和malloc有什么区别
6，多态有几种
7，静态多态是什么，动态多态是什么？
多态的实现主要分为静态多态和动态多态，
静态多态主要是重载，在编译的时候就已经确定；
动态多态是用虚函数机制实现的，在运行期间动态绑定。
举个例子：一个父类类型的指针指向一个子类对象时候，使用父类的指针去调用子类中重写了的父类中的虚函数的时候，会调用子类重写过后的函数，在父类中声明为加了virtual 关键字的函数，在子类中重写时候不需要加virtual也是虚函数。

8，什么是拷贝构造函数
9， 什么情况下要自己写拷贝构造函数
10， 什么是移动构造函数
11， 深拷贝和浅拷贝区别
拷贝构造函数（Copy Constructor）是一种特殊的构造函数，用于创建一个新对象，其内容与另一个同类对象完全相同。它的参数是同类对象的引用（通常是const引用），用于指定要进行拷贝的对象。拷贝构造函数通常用于对象的初始化，包括通过值传递参数、返回对象副本、以及在函数中创建新对象等情况。
自己编写拷贝构造函数的情况包括以下几种：
a. 当类中包含指针成员变量时，需要进行深拷贝，确保在拷贝构造过程中创建新的资源副本，而不是简单地复制指针的值。
b. 当类中包含非静态的引用成员变量时，需要确保在拷贝构造过程中正确处理引用的初始化。
c. 当类中包含资源管理的成员变量，如文件句柄、数据库连接等，需要确保在拷贝构造过程中正确处理资源的拷贝或所有权转移。
d. 当需要自定义对象的拷贝行为，例如需要记录对象的拷贝次数或拷贝过程中进行某些特殊操作时。
移动构造函数（Move Constructor）是C++11引入的特性，用于高效地将临时对象或将要销毁的对象的资源转移给新创建的对象，而不进行深拷贝。移动构造函数的参数是同类对象的右值引用，并通过使用移动语义实现资源的转移。移动构造函数通常用于提高性能，避免不必要的资源拷贝开销。


12， 虚函数表是什么，原理是什么？ 对应
13， 虚函数表底层是怎么存放的？ 链表
14， 虚函数表是在什么阶段被初始化的
在有虚函数的类中，类的最开始部分是一个虚函数表的指针，这个指针指向一个虚函数表，表中放了虚函数的地址，实际的虚函数在代码段(.text)中。
当子类继承了父类的时候也会继承其虚函数表，当子类重写父类中虚函数时候，会将其继承到的虚函数表中的地址替换为重新写的函数地址。使用了虚函数，会增加访问内存开销，降低效率。
虚函数表在编译阶段被创建，并在程序运行时被初始化。


15， 析构函数为什么要用虚函数
析构函数需要使用虚函数是为了实现多态的析构。当基类指针或引用指向派生类对象时，如果析构函数不被声明为虚函数，那么在删除该对象时，只会调用基类的析构函数，而不会调用派生类的析构函数。这样会导致派生类中的资源无法正确释放，可能引发内存泄漏或行为不一致的问题。
通过将基类的析构函数声明为虚函数（使用关键字virtual），可以实现动态绑定，确保在删除派生类对象时，会首先调用派生类的析构函数，然后再调用基类的析构函数。这样可以保证派生类中的资源得到正确释放，确保对象的完整析构。

16， 构造函数为什么不能用虚函数
构造函数不能使用虚函数是因为在对象的构造过程中，对象的类型是逐渐从基类向派生类转变的。在基类的构造函数中，对象的类型尚未完全确定，因此无法实现动态绑定。
虚函数的动态绑定是根据对象的实际类型来决定调用哪个函数，而在构造函数中，对象的实际类型正在逐步构建中，无法确定具体的派生类类型。因此，构造函数只能根据静态类型（即构造函数所属的类）进行函数调用，无法实现动态多态性。

17， 构造函数里可以用虚函数呢？
在构造函数中可以调用虚函数，但需要注意的是，由于对象的类型在构造函数中逐步构建，因此在基类的构造函数中调用的虚函数只能是当前类定义的虚函数，而不是派生类中重写的虚函数。这是因为派生类的构造函数尚未执行，派生类中的虚函数尚未就绪。
这种情况下，调用的虚函数会被静态绑定到当前类的版本，而不是派生类的版本。这可能导致意外结果或不一致行为，因此在构造函数中调用虚函数应该谨慎使用，并确保只调用当前类中定义的虚函数，避免依赖派生类的行为。

C++中的虚函数动态绑定是一种运行时多态的机制，它允许在基类指针或引用指向派生类对象时，根据对象的实际类型来确定调用的函数。这种动态绑定的机制使得程序可以根据对象的实际类型来决定调用哪个函数，而不仅仅局限于基类的声明类型。这样就实现了多态性，即在相同的函数调用语法下，不同的对象可以表现出不同的行为。
虚函数动态绑定的关键点是，它将函数调用的决策推迟到运行时，以便根据对象的实际类型来进行动态调度。这提供了更大的灵活性和扩展性，使得派生类可以通过重写基类的虚函数来改变或扩展基类的行为，而不需要修改基类的代码。


18， 虚析构函数是动态多态还是静态多态
19， 菱形继承怎么解决？
虚析构函数是动态多态。动态多态是指在运行时根据对象的实际类型来确定调用的函数，而不是根据指针或引用的静态类型。虚析构函数可以实现动态绑定，确保在删除派生类对象时正确调用派生类的析构函数，以防止内存泄漏。

a. 冗余数据：派生类中包含了两份相同的基类成员，造成了冗余的数据存储。
b. 命名冲突：派生类继承了两个具有相同成员函数或成员变量的基类，当通过派生类对象访问这些成员时，会出现二义性和命名冲突。

为了解决菱形继承问题，C++提供了虚继承（Virtual Inheritance）的机制。
通过在继承关系中使用virtual关键字，可以确保在派生类中只包含一份共同基类的实例。这样做可以解决冗余数据和命名冲突的问题。在菱形继承中，需要将共同基类标记为虚基类，即在派生类对该基类的继承声明中使用virtual关键字。这样，派生类中只会包含一份虚基类的实例，避免了冗余数据和命名冲突。


20， map和hashmap有什么区别
21， 哈希表的底层原理是什么？
22， 你如何构造一个哈希表
23， Vector什么时候会访问失效（迭代器失效）（push_back容量不足，搬迁了）
24， Vector的扩容机制

25， 红黑树的底层原理是什么（红黑树就是AVL树的加强版，满足最长路径一定超过最短路径的两倍，又不要求绝对平衡）
26， 红黑树的复杂度，哈希表的复杂度
27， 什么时候用map，什么时候用hashmap
28， Map，你要从里面删一堆数据，你要怎么做（使用 Iterator 迭代器删除、stream过滤删除）
29， 对lua有了解吗（用c实现的开源脚本，比较轻量，用于游戏的快速开发）

我C++，只能说确实是平庸，答得很差，TAT，挂了也确实合情合理。
希望能找到工作吧。



 nowcoder  /feed/main/detail/7816d40f3fdb46a6ba89c890b1ea733a 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

6、

快手客户端一面
面试官：你这简历好像专门搞 Java 的为什么投客户端？
我：那肯定简历在 Java 岗筛不过去啊
然后答完 jvm 内存模型，说你既然说到了垃圾回收，那我就来问问你垃圾回收算法
我：？？？？我没说啊，啥时候说了？？
然后全程在问 jvm，然后了 volatile ，都挖到操作系统了，最后一道单例收尾，最后吐槽一下，大众哪哪都好，就是会议室网巨差连续两次了（虽然面试官也差），希望快点挂了我吧，我想从头再来 #如何判断面试是否凉了#



 nowcoder  /feed/main/detail/6fd5a38d41e14103abc803b43c2e9661 


1
2
3
4
5
6
7
8
9
10
11
12

7、

快手客户端一面凉经 凉透了
全程八股 数据库，框架，中间件一点没问，操作系统一点没问，JVM，并发编程也没问
面试官先说我专业技能和这个岗不太匹配，问我有意愿转客户端开发吗（为啥java和客户端开发不匹配啊？面试官说客户端不用框架，所以我简历上的项目在面试的时候也没意义）

jdk jre jvm关系
反射的对象和new的对象的区别
一个class文件从编写到执行的过程
hashmap底层源码

https原理
tcp和udp的区别
tcp如何保证可靠传输，超时重传基于什么协议

threallocal底层原理，底层用的什么数据结构，扩容过程
throwable接口
Serilizable序列化的意义，有什么用
如何实现一个类的5个对象中3个对象要序列化，另外2个不序列化
serialVersionUID是什么

数字证书保存在服务端还是客户端（数字证书通常是保存在客户端）
对称与非对称加密的区别，都有哪些算法是加密，哪些算法是解密（
对称：DES 、 3DES 、 AES
非对称：RSA 、DSA（数字签名用）、 ECC椭圆曲线，ECC（移动设备用）
）
token session cookie的区别（
Cookie是由服务器发送给客户端，并由客户端存储在本地的小型文本文件。客户端在每次请求中通过将Cookie包含在请求头中发送给服务器。Cookie可以被客户端修改和删除，但受同源策略的限制。
Session是服务器端的一种状态管理机制，用于跟踪用户在应用程序中的会话状态。服务器在用户首次访问时创建一个唯一的会话ID，并将该ID存储在Cookie中或通过URL重写传递给客户端。

令牌是身份验证和授权的凭证，用于跨请求进行身份验证和授权。
session会话是服务器端的状态管理机制，用于跟踪用户的会话状态和存储会话数据。
Cookie是在客户端存储数据的机制，可以用于存储用户信息和状态。
）
手写单例模式（用于确保一个类只有一个实例，并提供一个全局访问点。）


 nowcoder  /feed/main/detail/229b0b047c75469e9ac4c910a0983aa2 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

8、

快手客户端一面凉经
1.自我介绍
2.原来实习做的项目是基于Android还是iOS？我说是PC端
3.对Android了解吗？
4.你几个项目中，你觉得对你自己提升最大的是那个？遇到了什么困难？怎么解决的？有什么成长收获？

5.讲讲面向对象？
6.面向对象和面向过程什么区别？
7.C++三大特性？封装、继承、多态

8.线程怎么切换上下文？
线程上下文切换是指在多线程环境中，从一个正在执行的线程切换到另一个线程的过程。线程上下文切换的实现通常由操作系统内核负责，具体的步骤如下：
步骤如下：
保存当前线程的上下文：
选择下一个要执行的线程：
恢复下一个线程的上下文：
切换到下一个线程的执行：
线程上下文切换是一种开销较高的操作，因为它涉及到保存和恢复上下文信息，以及切换线程的控制权。上下文切换的频繁发生可能会影响系统的性能。因此，在设计和编写多线程应用程序时，需要合理地管理线程的数量和调度策略，以避免不必要的上下文切换开销。

9.生产者-消费者
是一种经典的并发编程模式，用于解决多线程环境下生产者和消费者之间的协作问题。
定义生产者类（Producer）：
生产者负责生成数据或任务，并将其添加到共享的缓冲区中。
生产者类通常有一个方法，用于生成数据并将其添加到缓冲区中。
定义消费者类（Consumer）：
消费者负责从共享的缓冲区中获取数据或任务，并进行处理。
消费者类通常有一个方法，用于从缓冲区中获取数据并进行相应的处理。
生产者-消费者模式可以用于解决许多并发编程场景，例如任务调度、消息队列等，通过合理的设计和同步机制，可以实现生产者和消费者之间的有效协作，提高系统的并发性能和资源利用率。

10.vector了解吗？
11.vector扩容
12.为什么按1.5或者2倍进行扩容？
减少内存重新分配的次数：扩容时，需要重新分配一块更大的内存，并将原有元素复制到新的内存空间中。如果每次扩容都只增加一个固定的大小，会导致频繁地进行内存重新分配，增加了时间和空间开销。按照 1.5 倍或 2 倍扩容，可以减少内存重新分配的次数。
平衡内存占用和性能：过小的扩容因子可能导致频繁的扩容操作，增加了内存分配和复制的开销。过大的扩容因子可能导致浪费较多的内存空间。选择适当的扩容因子可以在一定程度上平衡内存占用和性能。
避免指数级增长：按照 1.5 倍或 2 倍进行扩容，可以避免容量呈指数级增长，而是以较为平缓的速度增长，使得 vector 的大小与实际元素数量之间保持合理的比例。


13.C++野指针、怎么解决！
野指针就是指向一个已删除的对象
或者未申请访问受限内存区域的指针
初始化指针：在定义指针变量时，始终将其初始化为 nullptr 或者有效的内存地址。这样可以避免指针被随机赋予一个未知的值。

避免悬空指针：当对象被释放后，立即将指针置为 nullptr。这样可以避免指针继续指向已释放的内存。

使用智能指针：C++提供了智能指针（如 std::shared_ptr、std::unique_ptr），可以自动管理资源的生命周期。智能指针会在对象不再被使用时自动释放内存，并确保不会出现野指针的情况。

注意指针的生命周期：在使用指针时，要确保指针指向的对象在使用期间是有效的。避免在超出对象生命周期的情况下访问指针。

防御性编程：在使用指针之前，进行必要的有效性检查，确保指针指向有效的内存。可以使用条件语句或断言来检查指针的有效性。

动态内存管理：如果手动管理动态内存（如使用 new 和 delete），确保在适当的时候释放内存，并将指针置为 nullptr。避免内存泄漏和悬空指针问题。

使用容器和算法：使用标准库提供的容器（如 std::vector、std::list）和算法，它们会自动管理内存，并提供了更安全的操作方式，避免了手动内存管理的风险。


算法题：LRU缓存
LRU（Least Recently Used）缓存是一种常用的缓存淘汰策略，它根据数据的访问顺序来决定淘汰哪些数据。当缓存达到最大容量时，将最近最少使用的数据从缓存中淘汰出去。
leetcode.cn/problems/lru-cache/solutions/

//主函数
    LRUCache(int _capacity):capacity(_capacity),size(0){
        head = new node();
        tail = new node();
        head->next = tail;
        tail->pre = head;
    }
    int get(int key) {
        if(!cache.count(key))return -1;
        node * t = cache[key];
        moveToHead(t);  //定位后移动到双向链表头部
        return t->val;
    }
    void put(int key, int value) {
        if(!cache.count(key)){//不存在就新建
            node* t = new node(key,value);
            cache[key] = t;
            addToHead(t); //添加到双向链表头部
            size++;
            if(size>capacity){//超出容量则删除尾部节点
                node* re = removeTail();
                cache.erase(re->key);
                delete re;
                size--;
            }
        }else{//存在就定位修改，然后移动到头部 
            node* t = cache[key];
            t->val = value;
            moveToHead(t);
        }
    }


反问
-------------------------------



 nowcoder  /feed/main/detail/02e1b7fc03bf468aa647401f361ae800 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

9、

快手客户端一面（40min）
自我介绍
1.ArrayList的扩容机制？
2.底层实现？深拷贝还是浅拷贝？
3.单例模式
4.懒汉线程安全？
单例模式分为懒汉式和饿汉式，今天主要来讲讲其中的懒汉式，懒汉式因为要实现懒加载(使用时再创建对象)，所以存在线程安全问题。

5.多线程下如何保证类的线程安全？
单例模式：主要解决一个全局使用的类频繁的创建和销毁的问题。
单例模式下可以确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
1)饿汉式：基于class loader 机制避免多线程的同步问题，不过，instance 在类装载时就实例化，可能会产生垃圾对象。
2)懒汉式：通过双重锁机制实现线程安全。
使用锁机制，防止多次访问,可以这样，第一次判断为空不加锁，若为空，再进行加锁判断是否为空，若为空则生成对象。

6.CopyOnWriteArrayList底层实现？如何实现线程安全？
7.HTTP支持长链接吗？什么时候开始支持的？
8.长连接什么时候会释放？
如果客户端在完后一个HTTP 请求后，在60 秒内都没有再发起新的请求，定时器的时间一到，就会触发回调函数来释放该连接。
9.服务端通过timeout还是探测决定是否关闭长连接？
10.TCP有没有这种关闭连接的方式？
服务端关闭长连接的方式可以通过两种方式进行决定：timeout（超时）和探测。
TCP协议提供了一种双向的连接关闭方式，即通过发送FIN（Finish）数据包来关闭连接。TCP连接的关闭是一个经过握手的过程，称为四次挥手（Four-Way Handshake）。

HTTP 1.0 中默认是关闭的，需要在http头加入"Connection: Keep-Alive"，才能启用Keep-Alive；
HTTP 1.1 中默认启用Keep-Alive，如果加入"Connection: close "，才关闭。
keep-alive 是客户端和服务端的一个约定，如果开启 keep-alive，则服务端在返回 response 后不关闭 TCP 连接；
同样的，在接收完响应报文后，客户端也不关闭连接，发送下一个 HTTP 请求时会重用该连接。
在HTTP协议中，Keep-Alive属性保持连接的时间长短是由服务端决定的，通常配置都是在几十秒左右。

11.算法题：给你一个数组，和一个数字m，问这个数组中存不存在一个子序列（不一定连续），使得它的和为m，输出true或false
12.反问
感觉面的挺一般的，没问项目也没问MySQL、Redis、MQ，甚至没问JVM，40分钟就面完了，面试官人很好，全程在引导


 nowcoder  /discuss/521996343180599296 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

10、

### 项目
自我介绍。
讲一下github的开源项目
好几个项目，讲一下亮点
前端后端业务逻辑上的实现（java三层怎么实现的，api请求过程，存在本地后）
上传下载功能实现（调api库）
怎么分工的

### 八股

#### 计网
tcp三次握手，为什么不能两次
tcp和udp的区别
tcp滑动窗口的过程讲一下
浏览器输入url
拥塞控制，流量控制的方法，
dns解析的原理
网络层arp怎么找主机
tcp和http的关系
socket的流程，进行实现？
tcp怎么保证安全？ 

#### C++

栈和队列的区别
数组和链表区别，vector扩容，数组添加一个元素
hashmap了解吗，底层实现，构造类
hashmap安全怎么实现的
hashmap扩容实现？
多线程下如何保证类的线程安全（单例模式）

#### 系统

互斥量怎么实现的。
线程池了解吗？
生产者消费者模式
拥塞控制是生产者消费者吗

### 算法
翻转m到n的链表，写完逐行读代码。 
vector存储后翻转，变量名规范，记录3个关键位置。


算法基本功很扎实，回答的都很不错，基础知识多了解一些。


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/402853