既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
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` 关键字只会延迟函数调用的执行，而不会延迟函数内部的表达式的计算。例如：
>
>
>
> ```
> func foo() {
> x := 10
> defer fmt.Println(x) // 打印 10
> x = 20
> }
>
> ```
>
> 在上面的例子中，`foo` 函数执行时，虽然 `defer` 语句在 `x` 赋值之前声明，但是 `defer` 语句实际执行时会打印 `x` 的当前值，即 10，而不是 20。
>
>
> 总的来说，`defer` 关键字在 Go 语言中用于在函数执行完毕前延迟执行一些代码，可以方便地进行资源释放、错误处理、代码清理等操作，并且遵循后进先出的执行顺序。
>
>
>
14、Go 语言中的接口(interface)和结构体(struct)有什么区别？它们如何使用？
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
x := 10
> defer fmt.Println(x) // 打印 10
> x = 20
> }
>
> ```
>
> 在上面的例子中，`foo` 函数执行时，虽然 `defer` 语句在 `x` 赋值之前声明，但是 `defer` 语句实际执行时会打印 `x` 的当前值，即 10，而不是 20。
>
>
> 总的来说，`defer` 关键字在 Go 语言中用于在函数执行完毕前延迟执行一些代码，可以方便地进行资源释放、错误处理、代码清理等操作，并且遵循后进先出的执行顺序。
>
>
>
14、Go 语言中的接口(interface)和结构体(struct)有什么区别？它们如何使用？
[外链图片转存中...(img-C2cbxIp5-1715388670653)]
[外链图片转存中...(img-XUxnlI6k-1715388670654)]
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
扫一扫
1047
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
