2024年最新最新golang语言面试题总结（三）_golang多态面试题(3)，2024年最新整理了3家面试问题：美团+字节+腾讯_golang面试题2024

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

14=4 24=8 34=12 44=16
15=5 25=10 35=15 45=20 55=25
16=6 26=12 36=18 46=24 56=30 66=36
17=7 27=14 37=21 47=28 57=35 67=42 77=49
18=8 28=16 38=24 48=32 58=40 68=48 78=56 88=64
19=9 29=18 39=27 49=36 59=45 69=54 79=63 89=72 9*9=81

4、linux命令，查看端口占用，cpu负载，内存占用，如何发送信号给一个进程、修改文件权限



1
2
3
4
5

Linux 查看端口占用情况：
lsof -i:端口号
netstat -tunlp | grep 端口号
cpu负载：
uptime
内存占用：
top
如何发送信号给一个进程：
1. kill() 函数
2. alarm() 函数
修改文件权限：
chmod命令用于修改文件权限

5、Redis redo log， binlog 与 undo log



> 
> redo log是属于innoDB层面，binlog属于MySQL Server层面的，这样在数据库用别的存储引擎时可以达到一致性的要求。  
>  redo log是物理日志，记录该数据页更新的内容；binlog是逻辑日志，记录的是这个更新语句的原始逻辑  
>  redo log是循环写，日志空间大小固定；binlog是追加写，是指一份写到一定大小的时候会更换下一个文件，不会覆盖。  
>  binlog可以作为恢复数据使用，主从复制搭建，redo log作为异常宕机或者介质故障后的数据恢复使用。
> 
> 
> 1.redo log通常是物理日志，记录的是数据页的物理修改，而不是某一行或某几行修改成怎样怎样，它用来恢复提交后的物理数据页(恢复数据页，且只能恢复到最后一次提交的位置)。  
>  2.undo用来回滚行记录到某个版本。undo log一般是逻辑日志，根据每行记录进行记录。
> 
> 
> 


6、使用三个协程，每秒钟打印cat dog fish



> 
> 
> ```
> 使用三个协程，每秒钟打印cat dog fish
> 注意：1、顺序不能变化（协程1打印cat,协程2打印dog,协程3打印fish）
>      2、无限循环即可
> ```
> 
> 
> ```
> /*
> 使用三个协程，每秒钟打印cat dog fish
> 注意：顺序不能变化（协程1打印cat,协程2打印dog,协程3打印fish）
> 无限循环即可
> */
> func main() {
> 	wg := sync.WaitGroup{}
> 	wg.Add(3)
> 	chcat := make(chan int)
> 	chdog := make(chan int)
> 	chfish := make(chan int)
> 	go printCat(&wg, chcat, chfish)
> 	go printDog(&wg, chdog, chcat)
> 	go printfash(&wg, chfish, chdog)
> 	wg.Wait()
> }
> func printDog(wg *sync.WaitGroup, dog chan int, cat chan int) {
> 	defer wg.Done()
> 	for {
> 		<-cat
> 		fmt.Println("dog")
> 		time.Sleep(time.Second)
> 		dog <- 1
> 	}
> }
> func printCat(wg *sync.WaitGroup, cat chan int, fish chan int) {
> 	defer wg.Done()
> 	for {
> 		cat <- 1
> 		fmt.Println("cat")
> 		time.Sleep(time.Second)
> 		<-fish
> 	}
> }
> func printfash(wg *sync.WaitGroup, fish chan int, dog chan int) {
> 	defer wg.Done()
> 	for {
> 		<-dog
> 		fmt.Println("fish")
> 		time.Sleep(time.Second)
> 		fish <- 1
> 	}
> }
> 
> ```
> 
> 
> 


7、Go出现panic的场景



> 
> 
> ```
> go中发生panic的场景：
> - 数组/切片越界
> - 空指针调用。比如访问一个 nil 结构体指针的成员
> - 过早关闭 HTTP 响应体
> - 除以 0
> - 向已经关闭的 channel 发送消息
> - 重复关闭 channel
> - 关闭未初始化的 channel
> - 未初始化 map。注意访问 map 不存在的 key 不会 panic，而是返回 map 类型对应的零值，但是不能直接赋值
> - 跨协程的 panic 处理
> - sync 计数为负数。
> - 类型断言不匹配。`var a interface{} = 1; fmt.Println(a.(string))` 会 panic，建议用 `s,ok := a.(string)`
> 
> ```
> 
> 


8、Http是短连接还是长连接？



> 
> * 在**HTTP/1.0中，默认使用的其实是短连接**。也就是说，浏览器和服务器每进行一次HTTP操作，就要建立一次连接，但任务结束后就会中断连接。如果客户端浏览器访问的某个HTML或其他类型的 Web页中包含有其他的Web资源，如JavaScript文件、图像文件、CSS文件等；当浏览器每遇到这样一个Web资源，就会建立一个HTTP会话；
> * 但**从HTTP/1.1起，默认使用长连接，用以保持会话的连接特性**。使用长连接的HTTP协议，会在响应头中加入这行代码：Connection:keep-alive；
> * 在使用长连接的情况下，当一个网页打开完成后，客户端和服务器之间用于传输HTTP数据的 TCP连接不会关闭，如果客户端再次访问这个服务器上的网页，会继续使用这一条已经建立好的连接。但**Keep-Alive也不会永久保持连接，它有一个保持时间**，可以在不同的服务器软件(如Apache)中设定这个时间。我们要注意，实现长连接要客户端和服务端都支持长连接。
> * **TCP三次握手和四次挥手过程**
> 
>  既然上面我们说到了三次握手和四次挥手，健哥就再扩展一下说说这两个操作的实现过程。
> 
>  **三次握手：先向HTTP服务器发起TCP的确认请求**
> * 客户端 --> SYN --> 服务器
> * 服务器 --> SYN+ACK --->客户端
> * 客户端 --> ACK --> 服务器
> * **四次挥手：客户端要和服务器断开TCP连接**
> * 客户端 --> FIN +ACK ---> 服务器
> * 服务器 --> FIN ---> 客户端
> * 服务器 --> ACK --> 客户端
> * 客户端 --> ACK ---> 服务器
> 
> 
> 
> **总结**
> 
> 
>     1、Http协议到底是长连接还是短连接，要看HTTP协议的版本，Http1.0中默认是短连接，      2、 Http1.1中默认是长连接；
> 
> 
>     3、 Http协议位于OSI网络模型的应用层；
> 
> 
>     4、Http协议底层在传输层上使用的是TCP协议，在网络层使用的是IP协议；
> 
> 
>     5、TCP协议具有三次握手和四次挥手的过程，传输数据安全稳定。
> 
> 
> 


9、liunx协程和线程初始申请内存大小



> 
>  协程初始化创立的时候为其调配的栈有2KB。而线程栈要比这个数字大的多，能够通过ulimit 命令查看，个别都在几兆，作者的机器上是10M。如果对每个用户创立一个协程去解决，100万并发用户申请只须要2G内存就够了，而如果用线程模型则须要10T。
> 
> 
> 协程和线程默认申请的内存是堆内存
> 
> 
> 


10、go面试题实现一个内存缓存系统



> 
> 
> 
> ```
> 面试题内容
> 1、支持设定过期时间，精度到秒
> 2、支持设定最大内存，当前超出时做出合适的处理
> 3、支持并发安全
> 4、按照以下接口要求实现
> 
> ```
> 
> 
> ```
> type Cache interface {
> 	//size:1KB 100KB 1MB 2MB 1GB
> 	SetMaxMemory(size string) bool
> 	//将value写入缓存
> 	Set(key string, val interface{}, expire time.Duration) bool
> 	//根据key值获取value
> 	Get(key string) (interface{}, bool)
> 	//删除key
> 	Del(key string) bool
> 	//判断key是否存在
> 	Exists(key string) bool
> 	//清空所有key
> 	Flush() bool
> 	//获取缓存中所有key的数量
> 	Keys() int64
> }
> ```
> 
> 1、util.go文件中代码
> 
> 
> 
> ```
> package cache
> 
> import (
> 	"encoding/json"
> 	"log"
> 	"regexp"
> 	"strconv"
> 	"strings"
> )
> 
> const (
> 	B = 1 << (iota * 10)
> 	KB
> 	MB
> 	GB
> 	TB
> 	PB
> )
> 
> func ParseSize(size string) (int64, string) {
> 	//默认大小为100MB
> 	re, _ := regexp.Compile("[0-9]+")
> 	unit := string(re.ReplaceAll([]byte(size), []byte("")))
> 	num, _ := strconv.ParseInt(strings.Replace(size, unit, "", 1), 10, 64)
> 	unit = strings.ToUpper(unit)
> 	var byteNum int64 = 0
> 	switch unit {
> 	case "B":
> 		byteNum = num
> 	case "KB":
> 		byteNum = num * KB
> 	case "MB":
> 		byteNum = num * MB
> 	case "GB":
> 		byteNum = num * GB
> 	case "TB":
> 		byteNum = num * TB
> 	case "PB":
> 		byteNum = num * PB
> 	default:
> 		num = 0
> 		byteNum = 0
> 	}
> 	if num == 0 {
> 		log.Println("ParseSize 仅支持B KB MB GB TB PB")
> 		num = 100
> 		unit = "MB"
> 		byteNum = num * MB
> 	}
> 	sizeStr := strconv.FormatInt(num, 10) + unit
> 	return byteNum, sizeStr
> }
> func GetValSize(val interface{}) int64 {
> 	bytes, _ := json.Marshal(val)
> 	size := int64(len(bytes))
> 	return size
> }
> 
> ```
> 
> 2、cache.go
> 
> 
> 
> ```
> package cache
> 
> import "time"
> 
> type Cache interface {
> 	//size:1KB 100KB 1MB 2MB 1GB
> 	SetMaxMemory(size string) bool
> 	//将value写入缓存
> 	Set(key string, val interface{}, expire time.Duration) bool
> 	//根据key值获取value
> 	Get(key string) (interface{}, bool)
> 	//删除key
> 	Del(key string) bool
> 	//判断key是否存在
> 	Exists(key string) bool
> 	//清空所有key
> 	Flush() bool
> 	//获取缓存中所有key的数量
> 	Keys() int64
> }
> 
> ```
> 
> 3、memCache.go
> 
> 
> 
> ```
> package cache
> 
> import (
> 	"fmt"
> 	"log"
> 	"sync"
> 	"time"
> )
> 
> type memCache struct {
> 	//最大内存
> 	maxMemorySize int64
> 	//最大内存字符串表示
> 	maxMemorySizeStr string
> 	//当前已使用内存
> 	currencyMemorySize int64
> 	//缓存健值对
> 	values map[string]*memCacheValue
> 	//读写锁
> 	locker sync.RWMutex
> 	//清除过期缓存时间间隔
> 	clearExpireItemTimeInterval time.Duration
> }
> type memCacheValue struct {
> 	//value值
> 	val interface{}
> 	//过期时间
> 	expireTime time.Time
> 	//有效时长
> 	expire time.Duration
> 	//value 大小
> 	size int64
> }
> 
> func NewMemCache() Cache {
> 	mc := &memCache{
> 		values:                      make(map[string]*memCacheValue),
> 		clearExpireItemTimeInterval: time.Second * 10,
> 	}
> 	//go mc.clearExpireItem()
> 	return mc
> }
> 
> //size:1KB 100KB 1MB 2MB 1GB
> func (mc *memCache) SetMaxMemory(size string) bool {
> 	mc.maxMemorySize, mc.maxMemorySizeStr = ParseSize(size)
> 	return true
> }
> 
> //将value写入缓存
> func (mc *memCache) Set(key string, val interface{}, expire time.Duration) bool {
> 	mc.locker.Lock()
> 	defer mc.locker.Unlock()
> 	v := &memCacheValue{
> 		val:        val,
> 		expireTime: time.Now().Add(expire),
> 		expire:     expire,
> 		size:       GetValSize(val),
> 	}
> 	mc.del(key)
> 	mc.add(key, v)
> 	if mc.currencyMemorySize > mc.maxMemorySize {
> 		mc.del(key)
> 		log.Println(fmt.Sprintf("max memory size %d", mc.maxMemorySize))
> 	}
> 	return true
> }
> func (mc *memCache) Get(key string) (interface{}, bool) {
> 	mc.locker.RLock()
> 	defer mc.locker.RUnlock()
> 	mcv, ok := mc.values[key]
> 	if ok {
> 		//判断缓存是否过期
> 		if mcv.expire != 0 && mcv.expireTime.Before(time.Now()) {
> 			mc.del(key)
> 			return nil, false
> 		}
> 		return mcv.val, ok
> 	}
> 	return nil, false
> }
> func (mc *memCache) del(key string) {
> 	tmp, ok := mc.get(key)
> 	if ok && tmp != nil {
> 		mc.currencyMemorySize -= tmp.size
> 		delete(mc.values, key)
> 	}
> }
> func (mc *memCache) add(key string, val *memCacheValue) {
> 	mc.values[key] = val
> 	mc.currencyMemorySize += val.size
> }
> 
> //根据key值获取value
> func (mc *memCache) get(key string) (*memCacheValue, bool) {
> 	val, ok := mc.values[key]
> 	return val, ok
> }
> 
> //删除key
> func (mc *memCache) Del(key string) bool {
> 	mc.locker.Lock()
> 	defer mc.locker.Unlock()
> 	mc.del(key)
> 	return true
> }
> 
> //判断key是否存在
> func (mc *memCache) Exists(key string) bool {
> 	mc.locker.RLock()
> 	defer mc.locker.RUnlock()
> 	_, ok := mc.values[key]
> 	return ok
> }
> 
> //清空所有key
> func (mc *memCache) Flush() bool {
> 	mc.locker.Lock()
> 	defer mc.locker.Unlock()
> 	mc.values = make(map[string]*memCacheValue, 0)
> 	mc.currencyMemorySize = 0
> 	return true
> }
> 
> //获取缓存中所有key的数量
> func (mc *memCache) Keys() int64 {
> 	mc.locker.RLock()
> 	defer mc.locker.RUnlock()
> 	return int64(len(mc.values))
> }
> func (mc *memCache) clearExpireItem() {
> 	timeTicker := time.NewTicker(mc.clearExpireItemTimeInterval)
> 	defer timeTicker.Stop()
> 	for {
> 		select {
> 		case <-timeTicker.C:
> 			for key, item := range mc.values {
> 				if item.expire != 0 && time.Now().After(item.expireTime) {
> 					mc.locker.Lock()
> 					mc.del(key)
> 					mc.locker.Unlock()
> 				}
> 			}
> 		}
> 	}
> }
> 
> ```
> 
> 4、memCache\_test.go
> 
> 
> 
> ```
> package cache
> 
> import (
> 	"testing"
> 	"time"
> )
> 
> func TestCacheDP(t *testing.T) {
> 	testData := []struct {
> 		key    string
> 		val    interface{}
> 		expire time.Duration
> 	}{
> 		{"slsd", 678, time.Second * 10},
> 		{"dds", 678, time.Second * 11},
> 		{"slsddsd", 678, time.Second * 12},
> 		{"dsd", map[string]interface{}{"a": 3, "b": false}, time.Second * 13},
> 		{"ds", "aadasdasdad", time.Second * 14},
> 		{"dsdsd", "这里是的的饿的啊得到", time.Second * 15},
> 	}
> 	c := NewMemCache()
> 	c.SetMaxMemory("10MB")
> 	for _, item := range testData {
> 		c.Set(item.key, item.val, item.expire)
> 		val, ok := c.Get(item.key)
> 		if !ok {
> 			t.Error("缓存取值失败")
> 		}
> 		if item.key != "slsddsd" && val != item.val {
> 			t.Error("缓存取值数据与预期不一致")
> 		}
> 	}
> }
> 
> ```
> 
> 5、main.go
> 
> 
> 
> ```
> package main
> 
> import (
> 	"fmt"
> 	cache_server "test111/cache-server"
> 	"time"
> )
> 
> func main() {
> 	//fmt.Println(dns_reques.DigDomain("127.0.0.1:53", "www.baidu.com"))
> 	cache := cache_server.NewMemCache()
> 	cache.SetMaxMemory("200GB")
> 	cache.Set("aa", 1, 10*time.Second)
> 	cache.Set("bb", false, 10*time.Second)
> 	cache.Set("data", map[string]interface{}{"a": 1}, 10*time.Second)
> 	/*
> 		cache.Set("int", 1)
> 		cache.Set("bool", false)
> 		cache.Set("data", map[string]interface{}{"a": 1})
> 	*/
> 	fmt.Println(cache.Get("aa"))
> 	fmt.Println(cache.Get("bb"))
> 	fmt.Println(cache.Get("data"))
> 	cache.Del("int")
> 	cache.Flush()
> 	cache.Keys()
> }
> 
> ```
> 
> 
> 


11、Go 语言中的 goroutine 是什么，它和线程有什么区别？



> 
> 在 Go 语言中，goroutine 是一种轻量级的并发执行单元，由 Go runtime 管理的用户态线程。Goroutine 可以通过关键字 `go` 来创建，可以在同一个地址空间中并发地执行多个函数。
> 
> 
> 与传统的线程相比，goroutine 有以下几个主要区别：
> 
> 
> 1. 轻量级：goroutine 的栈空间初始较小（通常只有几 KB），随着需要而动态地增长和收缩，这使得创建和销毁 goroutine 的开销较低，可以在同一个程序中创建成千上万个 goroutine，而不会过度消耗系统资源。
> 2. 协作式调度：在传统的线程模型中，线程的调度由操作系统内核负责，而在 Go 语言中，goroutine 的调度由 Go runtime 的调度器负责。调度器使用协作式调度方式，即每个 goroutine 在执行时需要主动让出 CPU，而不是由操作系统强制切换，这样可以更好地控制调度和减少上下文切换的开销。
> 3. 共享内存通信：goroutine 之间通过通道（Channel）进行通信，而不是通过共享内存。通道是一种在 goroutine 之间传递数据的机制，可以实现安全的并发通信，避免了传统线程中需要显式加锁的问题，简化了并发编程。
> 4. 错误处理：在 Go 语言中，错误处理是一种编码约定，而不是使用异常来处理错误。这使得编写更健壮和可靠的代码更加容易，并且可以避免因异常处理引起的性能损失。
> 
> 
> 综上所述，goroutine 是 Go 语言中一种轻量级、高效的并发执行单元，通过协作式调度、通道通信和错误处理等特性，使得并发编程更加简洁和可靠。与传统的线程模型相比，goroutine 提供了更高的性能和更好的编程体验。
> 
> 
> 
> 


12、Go 语言中的 channel 是什么，它的作用和用法是什么？



> 
> 在 Go 语言中，channel（通道）是一种用于在 goroutine 之间进行通信和同步的机制。它是一种类型安全的、阻塞式的、并发安全的数据结构，用于在不同 goroutine 之间传递数据。
> 
> 
> Channel 的主要作用和用法如下：
> 
> 
> 1. 数据传递：Channel 可以用于在不同 goroutine 之间传递数据，通过将数据发送到一个 Channel，并从另一个 goroutine 中接收数据，从而实现数据的传递和共享。
> 2. 同步机制：Channel 可以用于在多个 goroutine 之间进行同步，例如等待一个 goroutine 完成后再继续执行下一步操作，或者在多个 goroutine 之间实现某种顺序执行的逻辑。
> 3. 阻塞式操作：Channel 的发送和接收操作都是阻塞式的，即在发送和接收操作完成之前，goroutine 会被阻塞，直到有对应的接收或发送操作可以执行。这种阻塞式的特性使得 Channel 可以有效地在多个 goroutine 之间进行数据同步和通信，避免了常见的竞态条件和其他并发问题。
> 
> 
> Channel 的用法主要包括以下几个方面：
> 
> 
> 1. 创建和初始化：通过使用内建函数 `make` 创建一个 Channel，并指定通道的类型和容量（可选）。例如：`ch := make(chan int)`。
> 2. 发送和接收数据：通过使用 `<-` 运算符进行数据的发送和接收操作。例如：`ch <- 42` 表示将值 42 发送到通道 ch 中，`x := <-ch` 表示从通道 ch 中接收一个值并将其赋值给变量 x。
> 3. 阻塞和非阻塞操作：Channel 的发送和接收操作可以是阻塞的，也可以是非阻塞的。阻塞的发送和接收操作会导致 goroutine 阻塞，直到有对应的接收或发送操作可以执行；而非阻塞的发送和接收操作会立即返回，无论是否有对应的接收或发送操作可以执行。
> 4. 关闭通道：可以使用内建函数 `close` 关闭一个通道，表示不再向通道发送数据，但可以继续从通道接收数据。关闭通道后，对通道的发送操作将导致 panic，而对通道的接收操作可以继续接收通道中的已有数据。
> 
> 
> 总的来说，Channel 是 Go 语言中用于实现 goroutine 之间通信和同步的重要机制，通过阻塞式的操作和类型安全的特性，可以简化并发编程的复杂性，并避免常见的并发问题。
> 
> 
> 


13、Go 语言中的 defer 关键字有什么作用，它的执行顺序是怎样的？



> 
> 
> Go 语言中的 `defer` 关键字用于在函数执行完毕前（或发生 panic 时）延迟执行一些代码，常用于资源释放、错误处理、日志记录等场景。`defer` 语句会将其后面的函数调用推迟到当前函数执行完毕之后再执行，不论函数是否正常返回或者发生了 panic。
> 
> 
> `defer` 关键字的作用主要包括以下几个方面：
> 
> 
> 1. 资源释放：在函数执行完毕后，可以使用 `defer` 关键字释放已经打开的资源，如文件句柄、数据库连接、网络连接等，以避免资源泄漏。
> 2. 错误处理：可以使用 `defer` 关键字在函数发生错误时，通过调用一些错误处理函数或者日志记录函数来处理错误，以保证错误信息能够被捕获并处理。
> 3. 代码清理：可以使用 `defer` 关键字在函数执行完毕后，清理一些临时变量、缓存数据等，以保持代码的整洁性和可读性。
> 
> 
> `defer` 语句的执行顺序是后进先出（Last In, First Out，LIFO）的顺序，即最后一个 `defer` 语句会最先执行，而最先声明的 `defer` 语句会最后执行。例如：
> 
> 
> 
> ```
> func foo() {
>     defer fmt.Println("Third")
>     defer fmt.Println("Second")
>     defer fmt.Println("First")
>     fmt.Println("Actual Execution")
> }
> 
> ```
> 
> 在上面的例子中，`foo` 函数执行时，会先打印 "Actual Execution"，然后 "First"、"Second"、"Third" 会按照逆序依次执行，即先打印 "Third"，然后打印 "Second"，最后打印 "First"。
> 
> 
> 需要注意的是，`defer` 关键字只会延迟函数调用的执行，而不会延迟函数内部的表达式的计算。例如：
> 
> 
> 
> ```


![img](https://img-blog.csdnimg.cn/img_convert/e57769c170c768a90d128caa924bfc34.png)
![img](https://img-blog.csdnimg.cn/img_convert/a94a24dacbd2520cf0fc637b871b19d4.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

")
>     defer fmt.Println("Second")
>     defer fmt.Println("First")
>     fmt.Println("Actual Execution")
> }
> 
> ```
> 
> 在上面的例子中，`foo` 函数执行时，会先打印 "Actual Execution"，然后 "First"、"Second"、"Third" 会按照逆序依次执行，即先打印 "Third"，然后打印 "Second"，最后打印 "First"。
> 
> 
> 需要注意的是，`defer` 关键字只会延迟函数调用的执行，而不会延迟函数内部的表达式的计算。例如：
> 
> 
> 
> ```


[外链图片转存中...(img-mcfyhBaP-1715486931141)]
[外链图片转存中...(img-KTXkSnLF-1715486931142)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

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
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661