一、前言
废话不多说，本篇是面试题系列的第二篇。文章面试题包括：快手，字节，得物，滴滴，百度等。第一篇面试题为：
2021中大厂php+go面试题(1)
友情提示： 大部分的面试题都是重复的，因此会越写越少。。
二、正文
1、快手一面
1.CDn工作原理
答：CDN通过广泛的网络节点分布，提供快速、稳定、安全、可编程的全球内容分发
加速服务，支持将网站、音视频、下载等内容分发至接近用户的节点，使用户可就近
取得所需内容，提高用户访问的响应速度和成功率。
https://blog.csdn.net/aliyunbaike/article/details/84952966
2.go的init用过吗，主要使用场景是哪些？
答：每一个源文件都可以包含一个 init 函数，该函数会在 main 函数执行前，
被 Go 运行框架调用，也就是说 init 会在 main 函数前被调用。
3.快速排序
4.go的map怎么删除元素
delete(map, 键)
如果要清空map元素，直接make一个新map就可以
5.go的syncmap
1)map在并发编程中，读是线程安全的，写不是
2）sync.map是线程安全的，不需要初始化，声明即可
3）Store 表示存储，Load 表示获取，Delete 表示删除
4）
2、边锋一面
1.redis的连接跟mysql的连接有什么区别？为什么redis可以承受
更高的访问量？
io多路复用
2.dns解析的具体流程
3.nginx访问php的方式，优缺点，怎么访问的
4.php获取请求到生成opcode的过程 ，opcode是干什么的，跟机器码有什么区别
答：
本质上一个opcode由两个参数(op1，op2)、返回值和处理函数组成。它的官方解释就
是PHP脚本编译后的中间语言，类似于java中的bytecode或者是.net中的MSL。
5.php定义类外的 静态变量，还有类里面的静态变量有什么区别？你说到类里面的静态变量是不会立刻释放的，那么有100个请求去请求这个类，静态变量的值累加，100次之后你认为这个值是多少，为什么
6.php定义类外的 静态变量，还有类里面的静态变量有什么区别？你说到类里面的静态变量是不会立刻释放的，那么有100个请求去请求这个类，静态变量的值累加，100次之后你认为这个值是多少，为什么
答：都是在程序一启动时就分配了内存空间，生命周期一样，但是作用域和可见性却
不一样
1）类内部静态变量必须通过类名或者对象名去访问，该变量在整个程序中都可见。
2）类外的静态变量只能在定义文件中使用，只在定义文件中可见，无法在非定义文件中使用。
7.nginx发送请求到php，这个请求是什么格式的，里面都包含了哪些内容
用户访问域名->域名进行DNS解析->请求到对应IP服务器和端口->
nginx监听到对应端口的请求->nginx对url进行location匹配->
执行匹配location下的规则->nginx转发请求给php->
php-fpm的master进程监听到nginx请求->master进程将请求分配给闲置的worker进程
->worker进程执行请求->worker进程返回执行结果给nginx->nginx返回结果给用户
nginx连接php的方式：
1）tcp方式： ip+9000端口
2）unix_socket:(要求nginx和php必须在同一台服务器上)
fastcgi_pass unix:/tmp/php-fpm.socket
8.redis做队列，如果消费者挂掉了，这个数据丢失怎么办
Redis有个命令叫做LPUSHRPOP（以及阻塞版本和不同方向的版本），即从一个队列
弹出的同时将这个消息送入另一个队列，同时返回给客户端。原子操作。
9.rebbitmq会积压到内存爆掉，kafka为什么不会
答：当RabbitMQ收到消息时，如果是持久化消息，则会储存在内存中，同时也会写入
磁盘；如果是非持久化消息，则只会存在内存中
3、字节一面
1.bitmap设置的长度是多大，用到了哪些hash函数
bitmap底层使用的还是字符串结构，最多是512M
，也就是2的32次方 位
2.渐进式hash，对渐进式的理解
1）从dict.ht[0].table[0]的bucket进行rehash。
2）处理完一个bucket后，将ht[0].table[dict.rehashidx] 置为 NULL。
3）将dict.rehashidx加1，处理下一个bucket
查询： 比较当前key的大小和 rehashidx的大小，来选择
去h0还是h1中进行查询。
3.kafka的分区和消费者的分配原则
（1）分区数： Tt / max(Tp, Tc)
(2) key怎么分配到分区的？
1）有key的时候，做一次hash，根据分区数取模
2）key为null，则随机找一个分区写入
（3）分区和消费者的策略
1）range ：partitions的个数除于消费者线程的总数来决定每个消费者线程消费
几个分区。如果除不尽，那么前面几个消费者线程将会多消费一个分区
2）将所有主题的分区组成 list列表，然后对 list列表按照 hashCode
进行排序
4.统计相同用户的访问次数，sort排序
cat logs/baidu.access.log | awk '{print $(NF-1)}' | sort | uniq -c | sort -k 1 -n -r|head -10
5.有n个任务，每个任务有开始和结束时间，如何安排任务的顺序，
使得完成的任务个数是最多的
4、b站B部门一面
1.php实现锁
1）静态变量（同一个请求的话，会不释放。多个请求的话会初始化）
2）apcu
将PHP代码编译之后所产生的bytecode暂存在共享内存内供重复使用，以提升应用的运行效率。（Opcode Cache）
提供用户数据缓存功能，需要显示的调用，和redis/memcache类似。（User Data Cache）
2.订单表的分库，如何查询？数据量比较大的话呢
淘宝的做法是拆分买家库和卖家库，也就是两个库：买家库、卖家库。
买家库，按照用户的id来分库分表。卖家库，按照卖家的id来分库分表。
写入的时候，先写入买家库，然后通过消息队列异步写入到卖家库。
3.http304产生的原因，我们可以用它来实现什么场景
4.redis的bitmqp的缺点
数据比较松散的情况下不好用
5.go的读写锁
6.redis的list做队列，当数据比较多的时候怎么处理？
（1）拆分法
可以遍历list，拆分到多个list中去，多个list可以按照顺序，比如1,-1000，
10001-2000 这样取名字
（2）如果有范围查询的需求，可以考虑转换为zset来处理范围查询，按照时间戳
来进行排序即可
7.外部请求接口很慢，该怎么排查？服务器资源不足怎么办
（1）服务器扩容
（2）需要预估一个qps，扩容*120%即可
1.内存使用过高，频繁gc导致cpu占满
2.内存使用不高，出现了类似死循环场景
通过第三方监控平台查看堆栈信息
8.lru的加锁，在操作链表的时候需要加读写锁的
5、货拉拉一面
1.php-fpm的超时配置，超时之后会显示什么
（1）Nginx 504 Gateway Time-out的含义是没有请求到可以执行的PHP-CGI。
（2）Nginx 502 Bad Gateway的含义是请求的PHP-CGI已经执行，但是由于
读取资源的程序没有执行完毕而导致PHP-CGI进程终止。
（3） 502错误是php-fpm控制的，超时会终止cgi
（4） 504是nginx报出的，代表nginx连接fastcgi超时
2.codis的缺点是什么
（1）master挂掉了，只能靠运维人员去维护
（2）codis不保证数据一致性，不支持主从复制
（3）非官方出品，后续升级没保障
（4）codis不支持事务
3.mysql的死锁产生，还有如何防止
（1）按同一顺序访问对象。
（2）保持事务简短并在一个批处理中。
（3）使用低隔离级别。
（4）避免长事务，将事务拆解
（5）设置锁超时等待innodb_lock_wait_timeout
4.mysql分表的查询问题，怎么不遍历所有表做一个查询
(1)借用redis或者数据表，存储映射关系，映射查询字段和分表的关系
（2）找到分表之后，直接执行查询，组合数据即可
5.php5.6和7.0的区别，写代码用到什么新特性了
(1)PHP7.0之前出现的致命错误，都改成了抛出异常
(2)增加了空结合操作符（？？）。效果相当于三元运算符
(3) PHP7.0新增了函数的返回类型声明
(4)define 可以定义常量数组
为什么php7比较快：
1、存储变量的结构体变小，尽量使结构体里成员共用内存空间，减少引用，
这样内存占用降低，变量的操作速度得到提升。
2、字符串结构体的改变，字符串信息和数据本身原来是分成两个独立内存块存放，
php7尽量将它们存入同一块内存，提升了cpu缓存命中率。
3、数组结构的改变，数组元素和hash映射表在php5中会存入多个内存块，
php7尽量将它们分配在同一块内存里，降低了内存占用、提升了cpu缓存命中率。
4、改进了函数的调用机制，通过对参数传递环节的优化，减少一些指令操作，
提高了执行效率。
6.laravel,yii，ci的区别，laravel的特点？控制反转？依赖注入？
（1）laravel社区最活跃，支持的扩展也多
（2）yii的配置文件比较麻烦，不过支持多种环境配置
（3）laravel的路由比较强大，但是基于组件式，稍微臃肿点
（4）yii的view和model层不太好用
控制反转：和依赖注入配合使用，只不过是用容器去绑定依赖，
这样相当于控制权给到了容器。
依赖注入：不用在程序里实例化类，可以通过参数的形式注入进去
ci:CI中的超级对象就是当前控制器对象，它提供了很多属性.($this)
7.composer的自动加载机制
（1）autoload机制 可以使得 PHP 程序有可能在使用类时才自动包含类文件，
而不是一开始就将所有的类文件include进来，这种机制也称为
Lazy loading (惰性加载)。
（2）单个autoload也不方便，难以维护，所以就出现了composer:
composer 会找到符合 PR4 规范的第三方库的源
将其加载到 vendor 目录下
初始化顶级域名的映射并写入到指定的文件里
写好一个 autoload 函数，并且注册到 spl_autoload_register()里
8.redis的持久化，会持久化过期的key吗
（1）aof是以记录命令方式，所以如果还没过期，那么不会有变更的命令，
如果过期，会在aof日志插入一条del命令。
（2）rdb的话是内存快照方式，如果持久化时，key已经过期，那么不会持久化，
如果在过期之前就已经持久化了，那么在恢复数据时，会判断key是否过期，
如果过期不会导入。
9.redis和memcache的区别
（1）存储数据安全--memcache挂掉后，数据没了；redis可以定期保存到磁盘（持久化）；
（2）灾难恢复--memcache挂掉后，数据不可恢复; redis数据丢失后可以通过aof恢复；
（3）redis数据结构更丰富
（4）Memcached单个key-value大小有限，一个value最大只支持1MB，而Redis最大支持512MB
6、滴滴一面
1.go的协程比线程轻到哪里了？
（1）协程在用户态进行上下文切换，耗时是线程的30/1。
线程需要：1,000 ~ 1,500 纳秒
（2）协程初始2kb，线程好几m
（3）线程切换：cpu上下文(寄存器),私有的栈，线程状态等
协程千幻：cpu上下文（寄存器）
缺点：cpu无法实现抢占式调用协程
2.算法题：堆排序
升序----使用大顶堆
降序----使用小顶堆
(1)为什么升序要用大顶堆呢
大顶堆的特点：每个结点的值都大于或等于其左右孩子结点的值，我们把大顶堆构建
完毕后根节点的值一定是最大的，然后把根节点和最后一个元素（也可以说最后一个节
点）交换位置，那么末尾元素此时就是最大元素了
3.go的runtime
(1)在把用户写的程序翻译成可执行文件的过程中，把 runtime 代码塞进了
可执行文件
1）初始化全局变量，
2）调用每个模块的init函数
3）初始化 GC，以及初始化 Go scheduler
4) 启用一个协程，调用用户写的 main 函数。
7、滴滴二面
1.php的autoload加载机制
//根据类名找到文件
$path = str_replace('_', '/', $class_name);
//直接引入
require_once $path . '.php';
2.php的数组扩容
（1）有个参数，当删除的数量比较多时，先进行rehash计算，去掉删除的部分
（2）删除比较少，空间不足，则扩容+rehash,申请2倍的空间，然后rehash计算
3.redis的zset结构
（1）数据量小于128或者存储的key小于64则为ziplist
特点是内存连续，占用空间小
（2）正常情况下是跳跃表，存在多级索引，第一层是双向链表结构
由许多层结构组成。
每一层都是一个有序的链表。最底层 (Level 1) 的链表包含所有元素。
如果一个元素出现在 Level i 的链表中，则它在 Level i 之下的链表也都会出现
(3)为什么用跳跃表不用红黑树
（1）跳跃表底层是双向链表，适合做范围查询
（2）跳跃表的修改，删除只需要更改相邻节点的指针，不需要重建树
（3）跳跃表占用的内存比红黑树少一些
（3）zet结构
1）由字典和跳跃表构成。字典让我们查询单个元素的时间复杂度是o(1)，
跳跃表主要是按照分值对元素排序.范围查询的时候，时间复杂度是o(loginN)
4.一个请求到php程序的过程
（1）三次握手之后，请求建立连接，进入全连接队列，accept()函数可以取到
（2）Nginx会按照FastCGI协议的消息格式发送数据，
worker进程再按照协议多次read()数据并解析
（3）词法语法分析，生成语言片段
（4）zend引擎根据opcode调用机器指令
（5）执行用户通过register_shutdown_function()注册的关闭函数
（6）释放资源，清理符号表，销毁超全局变量，重置max_execution_time 等等
5.一个请求到go程序的过程
golang作为常驻进程, 请求第三方服务或者资源(http, mysql, redis等)完毕后,
需要手动关闭连接, 否则连接会一直存在;
（1）为什么请求之后要defer关闭
https://www.cnblogs.com/lovezbs/p/13197587.html
如果请求不手动关闭的话，每个请求都会创建两个goroutine,y
分别去往这个连接写入请求(writeLoop函数)和读取响应(readLoop函数)，
且请求结束不会主动释放，会导致goroutine不断增加，导致内存泄露
（2）go的链接复用问题
在go的源码中特意指出，需要读取rep.body才能复用链接。有时候
我们只读取header做判断，code不是200就返回错误，这样的话该链接
就不会复用，导致出现大量的tcp : rst.
--- go作为客户端
1.创建http.Client对象client
2.创建http.Request对象req
3.发送请求client.do(req)
4.关闭resp.Body.Close()
---- 源码部分
（1）client.do
主要是参数校验，设置默认值，调用client.send
（2）client.send
cookie的装载，获取Transport对象，调用http.send
（3）http.send
校验请求参数，超时取消(setRequestCancel)和请求事务: rt.RoundTrip(req)
（4）client.setRequestCancel
创建一个协程利用select chan机制阻塞等待取消请求
（5）Transport.RoundTrip
参数校验，获取缓存的或新建的连接
（6）Transport.getConn
连接池有空闲则取出空闲连接
连接池无空闲则创建新连接
达到最大数量则阻塞，等待空闲连接
同时开启了两个goroutine，分别 读取response 和 写request
--- go作为服务端是如何处理的
http.HandleFunc("/hello", SayHello)
（0） 首先调用Http.HandleFunc
往DefaultServeMux的map[string]muxEntry中增加对应的handler和路由规则
（1）http.ListenAndServe(":9090", nil) //设置监听的端口
（2）ListenAndServe内部使用net包调用了 net.Listen("tcp", addr) 来监听端口
--- 接收客户端请求
（1）启动for循环，使 Listener 不断地接收来自客户端的请求，accept
（2）给每个请求实例化一个conn,serve.NewConn
（3）调用go c.serve启动协程，用户的每一次请求都是在一个新的 goroutine中服务，互相不影响
--- 处理请求
（1）分析请求，取出请求体resp,req
（2）根据ServeMux 路由规则管理器map，判断请求分发给哪些handle
（3）我们注册的函数会转化为handleFunc类型，然后通过
handler.serveHttp(resp,req),从而实现请求处理
6.gin框架的接口会开启协程吗
答：会的，参照上面的请求流程
客户端：每次请求开启两个协程，负责读写
服务端：每次开启一个协程处理请求
7.外部怎么访问k8s的pod
（1）nodeip: service设置为nodeip类型，集群外就可以使用K8s任意一个节点
的IP加上30000端口访问该服务了，kube-proxy会自动将流量以轮询的方式转发给
该service的每一个pod。
（2）LoadBalancer：公有云提供的负载均衡器。
任意节点的IP加30051端口访问服务 10.97.121.42:30051
使用EXTERNAL-IP来访问，这是云供应商提供的负载均衡IP
（3）ingress
K8s管理的负载均衡容器，它的镜像包含一个nginx或HAProxy负载均衡器和
一个控制器守护进程
外部访问URL,访问该服务，入口是80端口，然后Ingress controller直接将流量
转发给后端Pod，不需再经过kube-proxy的转发，比LoadBalance方式更高效
8.k8s的服务发现
(1)通过service实现的
（2）etcd是干什么的
https://zhuanlan.zhihu.com/p/96721097
etcd 是一个分布式的、可靠的 key-value 存储系统，它用于存储分布式系统
中的关键数据。
使用Raft 一致性算法来实现分布式一致性
服务注册：
（1）提交服务配置，创建service对象，创建endpoint对象
（2）DNS监控service变化，注册服务
服务发现：
（1）kube-proxy 监控ep变化，通过IPVS修改路由规则，去往service流量转向pod
（2）服务通过DNS和service name 寻找 cluster ip
（3）流量转发给 cluster ip,随后被路由规则转给 对应POD
（4）kube-proxy 监控 pod，一旦发现 pod 服务变化，将会把新的 ip 地址更新
到 service。kube-proxy 更新的存储在 etcd 里的映射关系(ep)
9.dns解析步骤
1）操作系统会先检查自己本地的hosts文件是否有这个网址映射关系
2）如果hosts里没有这个域名的映射，则查找本地DNS解析器缓存
3）查找本地DNS服务器，也就是配置中的首选dns服务器
4）转发模式：把请求转发到上一层dns服务器，不断转发
5）非转发： 先发送到13台根服务器，根服务器返回顶级域名服务器的ip，
客户端访问该ip，然后由顶级域名服务器进行下一级的查询
6）为什么根域名只有13台？
答：因为采用udp协议减小开销，dns规定512字节的传输上限，
一次返回最多返回13个根域名记录
10.redis集群的分布式是什么样子的
不同的服务在不同的节点上。这些服务组合起来才是完整的功能，
这就是分布式。
8、b站B部门二面
1.k8s的服务发现，服务注册，服务调用是为了什么
服务注册：
（1）提交服务配置，创建service对象，创建endpoint对象
（2）DNS监控service变化，注册服务
服务调用：
（1）有两种方式，一种是RPC方式，另一种是事件驱动（Event-driven）方式，也就是发消息方式
服务发现：
（1）kube-proxy 监控ep变化，通过IPVS修改路由规则，去往service流量转向pod
（2）服务通过DNS和service name 寻找 cluster ip
（3）流量转发给 cluster ip,随后被路由规则转给 对应POD
（4）kube-proxy 监控 pod，一旦发现 pod 服务变化，将会把新的 ip 地址更新
到 service。kube-proxy 更新的存储在 etcd 里的映射关系(ep)
2.k8s我们发布服务的时候，怎么进行一个平滑启动
答：https://yuerblog.cc/2019/12/11/k8s-%E5%A6%82%E4%BD%95%E5%B9%B3%E6%BB%91%E5%8F%91%E5%B8%83%E5%BA%94%E7%94%A8%EF%BC%9F/
上线：
1）POD上线需要配置健康检查
2）健康检查通过，service才会将POD加入endpoints列表，
流量进入可以正常响应
下线：
1）POD下线时会在etcd中先标记POD状态为terminating退出中，
其他相关联动资源会监听到变化并采取后续动作。
2）先关闭监听，处理完已有请求，退出进程
3.redis集群扩容的一个过程
（1）添加节点
（2）分配hash槽，可以全部重新分配，
也可以指定节点分出一部分槽出来
（3）槽迁移
每个节点计算自己的槽，比如原来节点负责5000个槽，现在负责4000个，
则把多余的1000迁移到新节点。主要是迁移槽上的key，
4.mysql同时读写一行会数据，会触发锁吗
对于普通SELECT语句，InnoDB不会加任何锁，所以读写同时进行没有问题，
读为快照读，写为当前读
5.go的map的底层结构
(1)结构：散列表+bucket
(2)底层一个数组arr
index = hash(key)
arr[index] = struct{xxxx}
(3)每个bucket中可以存储8个kv键值对，
(4)hash值的低八位和bucket数组长度取余，定位到在数组中的那个下标，
hash值的高八位存储在bucket中的tophash中，用来快速判断key是否存在，
6.redis和mysql的强一致性如何实现
（1）两段式提交，引入一个协调者。
事务A和事务B都分为准备和提交阶段，状态同步给协调者，任一步骤出问题则回滚
（2）raft算法实现
7.kafka在扩容的时候，怎么在不影响现有业务的情况下扩容
（1）kafka新增节点，对其他节点来说是无感知的
（2）在新节点上创建topic,或者迁移topic分区即可
8.redis的热点key如何处理
（1）收集热点key，比如自己写日志或者用redis提供的命令
（2）加载到内存，直接在内存中读取
（3）热点key分散，加个随机数进行分散，分散到多个redis机器，
读的时候随机从有备份的redis上读取即可
9.redis集群的脑裂如何避免
min-slave解决。当脑裂之后，会有一个分区的slave升级为master,
此时根据配置文件，当slave少于配置个数则停止写入。
这样保证只有一个master提供写入，等网络恢复也不会有问题
10.es的架构，index的内部实现
https://blog.csdn.net/u013380694/article/details/101760607
它可以将索引划分为多个分片，可以部署到集群中的任何一个节点，
且每个分片都有副本，实现高可用
（1）它允许水平切分内容卷。
（2）它允许通过分片来分布和执行操作来应对日益增长的执行量。
（3）一个索引就像数据库。而type就相当于每一张表，
而mapping就相当于表的结构定义，定义了什么字段类型等
往index的一个type里添加一行数据就叫做一个document
每一个document有多个field
查询：
（1）客户端发送请求到协调节点
（2）协调节点从分片上查询数据，由协协调节点进行聚合
（3）合并数据，返回给客户端
9、回响科技一面
1.kafka多个分区怎么保证消息顺序
（1）首先发送消息可以通过指定key+单分区实现
（2）多个消费者消费的时候，可以自己对key取模，放入到队列中，
开多线程去消费这些队列。队列内是有序的
2.mysql在没有隔离级别的情况下，多线程修改一行数据可以吗
（1）隔离级别是为了解决事务的并发问题，比如脏读，不可重复读，幻读问题等
（2）当没有隔离级别的时候，多线程修改一行数据，就会
出现：原始数据是0.线程1想+1，线程2也想+1，那么同时执行，结果是2，
但是对于线程1来说，我只是想+1而已
3.幂等性和线程安全？两个线程修改一个变量，为什么不行
（1）确保在多线程访问的时候，我们的程序还能按照我们预期的行为去执行，
那么就是线程安全。
（2）两个线程修改一个变量是可以的，但结果可能不是我们想要的
4.redis为什么要有单线程，除了锁还有其他原因吗
（1）锁开销
（2）不存在多进程或者多线程导致的切换而消耗CPU
（3）无法发挥多核CPU性能，不过可以通过在单机开多个Redis实例来完善，
同时给redis实例绑定cpu核即可发挥多核的优势
5.rpc和http访问的区别在哪
相同点：底层通讯都是基于socket，都可以实现远程调用，都可以实现服务调用服务
不同点：
（1）速度来看，RPC要比http更快，虽然底层都是TCP，但是http协议的信息往往比较臃肿
（2难度来看，RPC实现较为复杂，http相对比较简单
（3）如果对效率要求更高用rpc，灵活性通用性要求高用http
（4）rpc是长连接，http是短连接，效率更高
（5）rpc可以压缩消息，实现更极致的流量优化
6.mysql直接修改库存有什么问题？
（1）没什么问题，主要是怕mysql承受不住太大的流量挂掉
（2）常规方法是库存设置无符合，不能是负数，使用事务，
代价是速度比较慢
（3）我们可以考虑使用乐观锁，查询出version，修改的时候根据version来修改
7.go中的锁是怎么实现的
互斥锁：通过状态status和信号量来实现的。
协程1加锁的话，lock=1
协程2加锁的话，waiter=1，代表等下
锁释放：
协程A主要是通过释放信号量来通知协程b，此时协程B可以加锁
自旋：加锁失败会持续请求加锁，不会立刻阻塞。是通过cpu的空转实现的，30个时钟周期
8. redis的rdb和aof过程大概说一下
10、全民快乐一面
1.go常用的包有哪些，说说http和io包的函数
2.php的trait函数，trait引用的方法和原父类方法哪个优先级比较高
父级使用trait关键字，当前类 通过use使用父类
（1）代码复用，相当于copy了一份代码
（2）类成员优先级为：当前类>Trait>父类
3.mysql主从不一致的原因，在配置一样，不考虑网络因素的情况下
（1）主从两台机器的负载不一致，线程忙不过来
（2）max_allowed_packet ，主库设置的大，当有大sql的话，从库无法执行
（3）自增键不一致 ，自增步长不一致导致
（4）同步参数未设置
=1
4.go的channel怎么保证线程安全的
（1）channel内部维护了一个互斥锁，来保证线程安全
5.100W用户刷视频，怎么保证用户刷的视频不不重复
6.php安装扩展的步骤，编译的命令是哪个
1. wget extension.tar.gz下载相应的扩展包并解压。
2. cd extension/切换到扩展extension的目录中
3. /php/bin/phpize 运行php安装目录下的phpize文件，
这时候会在extension目录下生成相应的configure文件。
4. /configure --with-php-config=/php/bin/php-config 运行配置，
如果你的服务器上只是装了一个版本的php则不需要添加--with-php-config 。后面的参数只是为了告诉phpize要建立基于哪个版本的扩展。
5. make && make install 编译模块
7.唯一索引和主键索引的区别
(1)一个表只能有一个主键索引，可以有多个唯一索引；
(2)主键索引一定是唯一索引， 唯一索引不是主键索引；
(3)主键可以与外键 构成 参照完整性约束， 防止数据不一致。
11、货拉拉二面
1.kafka保证消息顺序性写入
生产者发送消息的send有四个参数
（分区号、时间戳、key、headers），我们可以指定key，
来保证消息都发送到同一个分区
2.php的while..true常驻进程会造成什么影响
3.缓存击穿和缓存穿透
（1）缓存击穿，是redis额热点key过期
1）不给热点key设置过期时间
2）互斥锁，发现无缓存，加锁去更新缓存
（2）缓存穿透是redis+mysql都顶不住了
1）参数校验，防止不存在的key
2）布隆过滤器
3）缓存空值或者默认值
12、b站B部门三面
1.接口网络超时如何排查
（1）代码层面
1）下游sql等查询是否超时
2）数据库连接是否满了，代码中是否出现死循环等
占用大量的cpu和内存
（2）网络层面
1）运营商网络问题
2.kafka的offset和mysql的索引的区别
kafka索引：
（1）偏移量索引文件用来建立消息偏移量(offset)到物理地址之间的映射关系，
方便快速定位消息所在的物理文件位置；
（2）时间戳索引文件则根据指定的时间戳(timestamp)来查找对应的偏移量信息。
查找步骤：
（1）根据offset找到日志分段的索引文件(.index文件)
（2）读取偏移量索引索引文件，使用二分找到最大索引项
（3）读取日志分段文件并且从日志分段文件中顺序查找(.log文件)
relativeOffset对应的消息
区别：
（1）kafka是系数索引，mysql是b+树索引
（2）kafka维护索引使用了跳跃表结构，索引维护结构不会随便变动，有新索引
文件才更新。mysql的索引树更新比较频繁
（3）应用场景不同，kafka是主要是顺序写入，顺序读出，很少有检索的操作。
3.x=1 and y>1 order by z如何建索引
13.好未来一面
1.服务间通信的实现
微服务必须使用进程间通信机制来交互，微服务架构
异步消息机制和同步请求/响应机制这两类 IPC 机制可用
2.服务探针的实现
存活探针：为了查看容器是否正在运行，如果返回false则重启pod
就绪探针：查看容器是否准备好接受HTTP请求,通过则把流量发到pod上
存活探针和就绪探针被称作健康检查。
3.进程，线程间的通信方式
进程--------
1）管道( pipe )：一般是父子进程通信
2）信号量：主要作为进程间以及同一进程内不同线程之间的同步手段
也是一种锁机制
3）共享内存：最快的ipc通信
4）套接字：可用于不同的进程通信。
5）消息队列：由消息的链表，存放在内核中并由消息队列标识符标识
线程----------------
线程间的通信目的主要是用于线程同步，所以线程没有像进程通信中的用于
数据交换的通信机制。
1）锁机制：包括互斥锁、条件变量、读写锁
2）信号量机制(Semaphore)：包括无名线程信号量和命名线程信号量
3）信号机制(Signal)：类似进程间的信号处理
14、映客一面
1.手写lru
2.mysql的acid分别是怎么实现的
Atomicity）原子性： 事务是最小的执行单位，不允许分割。原子性确保动作
要么全部完成，要么完全不起作用；
（1）通过undo日志，事务回滚时能够撤销所有已经成功执行的sql语句
（Consistency）一致性： 执行事务前后，数据保持一致；
（1）一致性是事务追求的最终目标，前问所诉的原子性、持久性和隔离性，
其实都是为了保证数据库状态的一致性。
（Isolation）隔离性： 并发访问数据库时，一个事务不被其他事务所干扰。
（1）四种隔离级别实现的
（Durability）持久性: 一个事务被提交之后。对数据库中数据的改变是持久的，
即使数据库发生故障。
（1）Innnodb有很多 log，持久性靠的是 redo log。
（2）如果出现缓冲丢失，可以从redo logo日志中恢复
3.go的syncmap怎么实现并发安全的
（1）步骤
a、过 read 和 dirty 两个字段将读写分离，读的数据存在只读字段 read 上，
将最新写入的数据则存在 dirty 字段上
b、读取时会先查询 read，不存在再查询 dirty，写入时则只写入 dirty
c、读取 read 并不需要加锁，而读或写 dirty 都需要加锁
d、另外有 misses 字段来统计 read 被穿透的次数（被穿透指需要读 dirty
的情况），超过一定次数则将 dirty 数据同步到 read 上
e、对于删除数据则直接通过标记来延迟删除
（2）原理
sync.map实现就是依靠两张map对读操作和写操作分离，后续根据需要在把
dirty map合入 read map中。
4.tcp的timewait怎么产生的，如何防范
作用：
（1）保证服务器能收到最后一次ack
（2）同时2msl能保证旧报文消失，防止旧报文出现在新的连接中
防范：
（1）服务器设置套接字：so_reuseaddr
（2）短连接改成长连接
（3）linux内核参数：net.ipv4.tcp_tw_reuse
5.介绍项目的时候，最好是把技术栈各方
面都详细的说一下
6.插入100W数据，大概耗时多少，如何优化？批量插入的时候会影响
其他操作吗，如何优化？
7.redis的分布式锁在高并发情况下会出现什么问题
（1）锁续约问题，可以用redisson的看门狗机制
（2）锁超时时间一定要设置
（3）根据value上锁，防止释放锁混乱
（4）分布式场景下，master加锁之后挂掉，slave会成为新的master
此时A客户端认为自己上锁了，B客户端也能获取到锁，会造成锁混乱
使用redlock会好一些
8.https到底是对称加密还是非对称加密？
答：是非对称加密(公私钥) +对称加密(传输内容对称加密)
1.客户端请求服务端，获取公钥。
2.服务端生成公私钥，自己保存私钥（SK），将公钥（PK）发给客户端。
3.客户端生成随机字符串key，通过公钥(PK)加密后发送给服务端。
4.服务端拿到加密后的内容后，用自己的私钥(SK)进行解密，得到key,
后续的过程都是通过密钥(key)来进行对称加密来传输。
15、小猪民宿
1.php的worker线程假死，如何重连的
（1）首先，php-fpm假死一般是线程繁忙或者请求数过多，超时等原因，
主要是修改配置文件，增加请求数量限制，超时时间等。
（2）kill掉worker之后，master进程会自动创建一个work出来
2.设计php框架的问题
3. mysql的查询优化器工作原理
（1）主要是判断cost，cost包括扫描行数等
（2）参照mysql拾遗
4.单机多少配置才能顶住1000qps
参考：https://blog.csdn.net/weixin_34346099/article/details/88679411
假如机器是4核8G:
(1)同时处理的请求做多4个
(2) 假设一个进程30M，那么4048/30 = 135（留一些给mysql）
(3) 假设一个请求200ms，那么1000qps要求
T = (1000 / n ) * t
总耗时：T
一次处理请求：n
每次请求时间：t 200ms
(4) 根据计算可以得知，我们一次要处理200个请求才行
首先我们的worker进程是足够的，其次是4核也够用
(5 )其他需要注意的点
1）mysql连接数
2) 服务器句柄限制， ulimit -n查看
3）tcp的timewait影响，允许端口复用
5.压测需要注意的参数
1）qps
2) 请求处理时间
3）
16.滴滴二面
1.一致性hash
（1）对2的32次方取模，构造0-2的32次方哈希环
（2）对服务器的IP或主机名作为关键字进行哈希
（3）计算key的hash，计算出在哪个空间，顺时针往下寻找节点即可
（4）为了防止数据分布不均匀，构造虚拟节点
（5）节点宕机，只会影响不一部分数据，其他节点还能正常使用
2.两个文件a和b里面都是id，求出不同的id
（1）分治，hash(id)%1000，分成1000个小文件,a0...a99
（2）此时a99中的id肯定也在b99中，文件就转化为了对小文件的求去重
(3) 读取a0，构造hash表，再便遍历b0，如果a0中不存在则为不重复
的id，放入新集合中即可
4.myisam的应用场景
特点：高性能读取，存储的有行数，无事务
场景：（1）需要频繁count的场景
（2）读多写少的场景
17.百度1-5面
大部分八股文跟上面雷同，只记录不同的
1.对于团队管理的理解
2.项目的架构设计，为什么这么设计
3.字符串中，中括号，大括号，小括号， 判断是否匹配（算法）
4.乱序数组，构建二叉树（算法）
三、后记
以上就是博主历时2个月的面试记录了。提醒大家一定要刷算法题，博主基本都是倒在算法题上面。其次面试看运气，不要在意，面就完了。
end