2021中大厂php+go面试题(2)

小鱼儿 2022-09-04 01:46 382阅读 0赞

## 一、前言 ##

废话不多说，本篇是面试题系列的第二篇。文章面试题包括：快手，字节，得物，滴滴，百度等。第一篇面试题为：  
[2021中大厂php+go面试题(1)][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**

[2021_php_go_1]: https://blog.csdn.net/LJFPHP/article/details/119549384