Golang高频问题(附答案)

╰+哭是因爲堅強的太久メ 2022-09-07 14:58 138阅读 0赞

> 持续更新中

### 一、Golang优点： ###

*  编译型语言，无需解释直接运行。
 *  语法简单，没有像python那样众多语法糖。
 *  支持多平台编译，支持内存自动GC(垃圾回收)。
 *  实现了语法层面的线程调度，开发多线程十分方便。

### 二、new和make的区别 ###

make：用来分配内存，初始化引用类型(slice, map, channel)并返回引用  
new： 用来分配内存，主要用来分配值类型，比如int、struct。作用是初始化一个指向类型的指针

### 三、协程、内存泄露如何定位排查？ ###

1、通过top命令查找对应进程的VIRT(虚拟内存)的开销，若开销过大，久居不下，持续增长就可能存在泄露  
2、排查线程泄露可通过go自带的工具

*  GODEBUG=schedtrace=1000 ./main 对main二进制程序进行每隔1秒打印线程、协程、调度器情况
 *  go tool trace 是一个web的可视化工具，以时间轴的方式查看线程、协程、调度、堆状况

3、内存泄露原因有两点

*  协程泄露：僵尸协程占用的对象无法释放，排查协程是否泄露即可
 *  对象无法释放：本该释放的对象被全局对象引用，导致无法gc。可以使用go tool pprof 工具导出heap信息

### 四、什么是GMP？ ###

G协程(groutine)：全称为用户态线程，协程切换无需像线程(内核态线程)那样需要CPU切换、内核进行上下文保存，同时一个线程可有多个线程，当线程分配到时间片时可以处理更多的协程，所以更轻量。  
M线程：全称为系统态线程，是计算机、CPU调度的最小单位。同个进程的线程可共享该进程分配的计算机资源。同个进程下的线程间切换需要CPU切换上下文，但不需要创建新的虚拟内存空间，不需要内存管理单元切换上下文，比进程切换更轻量。  
P处理器(调度器)：作用就是使用数量合适的线程，并让每个线程处理更多的任务(协程)，避免线程的频繁切换。

### 五、GC如何判定对象可被回收 ###

*  引用计数器法：每个对象有一个引用计算属性，新增一个引用时计数器+1，引用释放时计算器-1，计算器为0时可以被回收(php、python)，优点是简单高效，缺点是相互引用导致计算器为1无法被回收。
 *  可达性分析：从GC Root开始向下搜索，搜索走过的路径为引用链。当对象到GC Root没有引用链相连时，证明对象不可用，可被回收(java)
 *  标记清除法：从根变量开始遍历所有引用的对象，引用的对象标记为"被引用"，没有被标记的进行回收。缺点是需要STW，即要暂时停掉程序运行。(golang)

### 六、Go垃圾回收GC ###

三色标记法：`白色`表示对象未标记，将在本次GC中清除；`黑色`表示对象及其子对象已被标记；\`\`灰色\`表示对象被标记，但子对象还没进行扫描

STW：当golang启动GC时，会停止内存变化即停止所有goroutine，GC完成才恢复

GC触发条件：

*  阈值：默认内存扩大一倍触发GC
 *  定期：默认2分钟触发
 *  手动：runtime.gc()

写屏障：因为Go支持并行GC，代码执行和GC同时进行，这样可能对GC过程中，对象依赖发生变更。开启写屏障需要停止STW

### 七、map是否并发安全？ ###

不是并发安全，map的写操作通过标记位实现的，写之前标记位置为1，写后置为0.并且每次修改都会判断map的flags和hashwriting，前后不为0则抛出错误；  
可以使用sync.map;

hashWriting  = 4 // a goroutine is writing to the map

### 八、竞态和内存逃逸 ###

竞态：对数据的多个操作无法判定哪个先完成的现象。如下返回值可能为0或5。检测程序有无静态go run -race main.go  
解决的方式有等待组waitgroup、channel、互斥锁

func example() int { 
    	var i int
    	go func(){  i=5 }()
    	return i
    }

内存逃逸：函数的栈数据没有随着函数的结束而释放，而存放在了堆中。  
栈分配：函数内部变量，仅作用于函数内部  
堆分配：函数内存对外开放的变量。或者内部变量所需内存超出栈的容量

func example(){ 
    	for i:=0;i<10;i++{   // 内部变量
    		go func(){ fmt.Print(i)}() // 输出10个10，并没有随着test的结束而释放i
    	}
    }

### 九、反射有什么作用？ ###

1、假如函数传进来一个interface类型的参数，你想知道它的类型

func xxx(x interface{ }){ 
    	t := reflect.TypeOf(a)
        fmt.Printf("a is type: %s", t.Name())
    }

2、假如你想修改变量的值而不修改它的指向，此时可用反射。  
修改变量的值后，值的地址会改变，现在我不想它的值的地址改变，想让值变,地址不变咋办？

func xxx(a interface{ }) { 
    	if v := reflect.ValueOf(a); v.Elem().Kind() == reflect.Int { 
    		v.Elem().SetInt(8)
    	}
    }
    func main() { 
    	var a = 5
    	xxx(&a) // 必须传地址
    	fmt.Println(a)
    }

### 十、什么是并发、并行？ ###

*  一个处理器会在一个时间片中执行一个进程，当时间片用完或者发生了中断(进程抢占事件)，当前进程的上下文会被保存。然后处理器开始处理另外一个进程。如此频繁切换执行，由于切换执行快，让人感觉在同时执行，其实还是串行执行。这种叫并发
 *  在多核处理器上，进程可以调度到不同处理器上，时间片轮训只针对每个处理器，同一时刻在两个处理器上执行两个进程，它们是运行的，这种叫并行。

### 十一、什么是进程、线程、协程？ ###

*  进程是计算机`资源分配`的最小单位
 *  线程是计算机`调度`的最小单位，也是CPU调度的最小单位。同个进程的线程可共享该进程分配的计算机资源。同个进程下的线程间切换需要CPU切换上下文，但不需要创建新的虚拟内存空间，不需要内存管理单元切换上下文，比进程切换更轻量。
 *  协程也称为用户态的协程，无需CPU来切换协程，也无需CPU对协程的上下文保存。自己管理线程，让线程处理更多的任务(协程)，避免线程频繁切换，仅需用户态的应用层面进行切换，所以更轻量。  
    综上所述：并发实际是线程。每个进程都有一个主线程，因为线程是调度的最小单位。线程间调度需要CPU来切换，需要内核层的上下文切换。(操作系统内部用pid表示进程id，tgid表示线程id)

### 十二、进程间通信、进程下多线程间通信？ ###

进程间资源不共享，要想资源共享需要IPC，所以有了通信共享内存。常见的几种方式有信号量、共享内存、套接字等；  
而同个进程的多个线程共享资源，通信起来比进程容易多了，因为它们共享虚拟内存空间，直接就可以读取内存。

### 十三、什么是IO多路复用？ ###

IO多路复用，其实就是维持一个线程队列，然后让一个线程或多个线程去队列里拿任务完成。为什么呢？因为线程数量是有限的，线程间通信需要点资源，内核也要频繁切换，干脆就弄一个池，有任务就派个小弟过去。  
只有一个线程的IO多路复用，典型就是Redis和Nodejs，无需切换上下文，一个线程走天下。而多个线程的IO多路复用，就是glolang的协程方式，协程自己管理线程，把线程控制到一定的数量，然后构造一个处理器来调度任务。

### 十四、CAP理论 ###

CAP

*  一致性(Consistency): 同时刻的数据版本都相同;
 *  可用性(Availability): 响应每个数据请求;
 *  分区容忍(Partition tolerance): 节点间数据不一致系统仍正常工作

AP: 最终一致性, 若无同步,则返回上个版本数据  
CP: 强一致性, 若无同步,则返回重试

### 十五、如何实现RPC框架 ###

问这个问题就是了解你熟悉哪些RPC框架，以及各个组件的角色  
1、rpc是远程过程调用，在于谁调用谁，涉及client和server、register。server注册服务到总线并监听请求，client则在总线查询服务并进行调用  
2、调用过程涉及通信和编码，transport通信器和codec编码器  
3、调用方式除了同步还有异步，涉及broker消息发布组件  
4、从集群服务取某个服务，涉及select调度选择器  
5、service是对client和server的初始化封装，基于此可简单创建rpc服务/调用

### 十六、CSP并发模型 ###

描述两个实体通过共享的通讯(channel)进行通信的并发模型。CSP的process和channel概念并别对应goroutine(并发实体)和channel(通讯实现数据共享)。

*  channel：实体间解耦，实现原理是阻塞的消息队列
 *  goroutine：底层使用coroutine(协程)实现，coroutine是运行在用户态的线程。go实现coroutine是因为：  
    1、用户空间避免了内核态和用户态切换导致的成本  
    2、语言、框架层面进行线程调度  
    3、更新的栈空间允许创建大量实例

### 十七、项目里的消息推送怎么做的 ###

推送消息(生产者):  
1、构建producer对象

*  kafka连接
 *  选择的分区器
 *  推送成功标志(所有节点都收到|大部分|主节点收到即返回)
 *  是否等待成功失败的响应

2、构建message，含有topic、分区、key和value  
3、调用producer.send方法发送消息，返回分区和偏移量

订阅消息(消费者)  
1、构建comsumer对象，仅含有kafka连接  
2、获取topic所有的对象分区id,对每个分区根据topic和偏移量获取消费分区cp  
3、从消费分区cp遍历消息

### 十八、Session共享方案 ###

IP\_Hash：在集群服务中，可根据客户端ip配对某个服务。比如登陆操作，在A服务登陆后，之后也是请求A服务，不会请求B服务，B服务也不会有A服务的session。  
redis：使用redis缓存session\_id，就是让第三方中间件帮我们保留session  
token：让客户端有状态，服务端无状态。请求时由浏览器携带token进行请求(保存到cookie中)

### 十九、让你开发一个公共系统，你会怎么做？ ###

1、高可用：公共系统，你的接口可能被其他服务进行调用，为让其他服务尽可能不发生异常，需要考虑系统高可用？如何实现，做成集群，但也有同时宕机的可能。可以在k8s上容器化部署集群。  
2、安全性：公共系统，顾名思义，需要保持某些隐私，接口实现验证，比如github最新推送代码需要携带token。  
3、安全运营：每个版本都有可能有bug，当有新版本发布时尽量降低因新版本产生的影响，可采用蓝绿版本、金丝雀等，实际上如何去做？在k8s上对depolyment镜像更改后扩容或者全部升级，再回滚时立即取消即可，只有个别版本升级。  
4、扩展性：随着需求越来越多，系统将变得复杂和臃肿，而且人员变动大，系统可能随时有新需求和新人接手新功能。实际解决可采用架构微服务话，将足够内聚的功能形成一个领域，或划分为一个微服务，微服务之间是松耦合的，所以新人就只需了解自己的微服务的功能即可，只要保持对外的接口或者异步驱动事件稳定即可，无需了解整个系统的方方面面。  
5、高并发：虽然不像秒杀系统那样巨大的压力，但是可能会有其他客户端的死循环调用或者其他非正常调用，此时需要对这些流量进行控制。  
6、持续集成：也就是CICD，例如提交代码可快速部署到目标环境，无需再重复搞环境、构建的问题；例如使用jenkins不仅可以自动构建环境、部署，还可以接入jmeter等接口测试脚本，生成接口性能报表。

### 二十 操作系统相关 ###

1、 Linux内核的组成部分  
2、用户空间与内核通信方式有哪些？  
3、系统调用read()/write()，内核具体做了哪些事情  
4、系统调用与普通函数调用的区别  
5、内核态，用户态的区别  
6、 bootloader内核 、根文件的关系  
7 、Bootloader启动过程：  
8、 linux下检查内存状态的命令

1、大小端的区别以及各自的优点，哪种时候用。（判断大小端的三种方式）  
2 、一个程序从开始运行到结束的完整过程（四个过程）  
3、什么是堆，栈，内存泄漏和内存溢出？  
4、堆和栈的区别  
5、死锁的原因、条件  
6、硬链接与软链接的区别；  
7、虚拟内存，虚拟地址与物理地址的转换  
8、计算机中，32bit与64bit有什么区别  
9、中断和异常的区别  
10、中断怎么发生，中断处理流程  
11、 Linux 操作系统挂起、休眠、关机相关命令  
13、在有数据cache情况下，DMA数据链路为：外设-DMA-DDR-cache-CPU,CPU需要对cache做什么操作，才可以得到数据

1、什么是进程，线程，有什么区别  
2、多进程、多线程的优缺点  
3、什么时候用进程，什么时候用线程  
4、多进程、多线程同步（通讯）的方法  
5、进程线程的状态转换图 。什么时候阻塞，什么时候就绪  
6、父进程、子进程的关系以及区别  
7、什么是进程上下文、中断上下文  
8、一个进程可以创建多少线程，和什么有关  
9、进程间通讯：  
（1）管道/无名管道（2）信号（3）共享内存（4）消息队列（5）信号量（6）socket  
注意：临界区则是一种概念，指的是访问公共资源的程序片段，并不是一种通信方式。