既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
4、linux命令，查看端口占用，cpu负载，内存占用，如何发送信号给一个进程、修改文件权限
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 有以下几个主要区别：
- 轻量级：goroutine 的栈空间初始较小（通常只有几 KB），随着需要而动态地增长和收缩，这使得创建和销毁 goroutine 的开销较低，可以在同一个程序中创建成千上万个 goroutine，而不会过度消耗系统资源。
- 协作式调度：在传统的线程模型中，线程的调度由操作系统内核负责，而在 Go 语言中，goroutine 的调度由 Go runtime 的调度器负责。调度器使用协作式调度方式，即每个 goroutine 在执行时需要主动让出 CPU，而不是由操作系统强制切换，这样可以更好地控制调度和减少上下文切换的开销。
- 共享内存通信：goroutine 之间通过通道（Channel）进行通信，而不是通过共享内存。通道是一种在 goroutine 之间传递数据的机制，可以实现安全的并发通信，避免了传统线程中需要显式加锁的问题，简化了并发编程。
- 错误处理：在 Go 语言中，错误处理是一种编码约定，而不是使用异常来处理错误。这使得编写更健壮和可靠的代码更加容易，并且可以避免因异常处理引起的性能损失。
综上所述，goroutine 是 Go 语言中一种轻量级、高效的并发执行单元，通过协作式调度、通道通信和错误处理等特性，使得并发编程更加简洁和可靠。与传统的线程模型相比，goroutine 提供了更高的性能和更好的编程体验。
12、Go 语言中的 channel 是什么，它的作用和用法是什么？
在 Go 语言中，channel（通道）是一种用于在 goroutine 之间进行通信和同步的机制。它是一种类型安全的、阻塞式的、并发安全的数据结构，用于在不同 goroutine 之间传递数据。
Channel 的主要作用和用法如下：
- 数据传递：Channel 可以用于在不同 goroutine 之间传递数据，通过将数据发送到一个 Channel，并从另一个 goroutine 中接收数据，从而实现数据的传递和共享。
- 同步机制：Channel 可以用于在多个 goroutine 之间进行同步，例如等待一个 goroutine 完成后再继续执行下一步操作，或者在多个 goroutine 之间实现某种顺序执行的逻辑。
- 阻塞式操作：Channel 的发送和接收操作都是阻塞式的，即在发送和接收操作完成之前，goroutine 会被阻塞，直到有对应的接收或发送操作可以执行。这种阻塞式的特性使得 Channel 可以有效地在多个 goroutine 之间进行数据同步和通信，避免了常见的竞态条件和其他并发问题。
Channel 的用法主要包括以下几个方面：
- 创建和初始化：通过使用内建函数
make创建一个 Channel，并指定通道的类型和容量（可选）。例如：ch := make(chan int)。- 发送和接收数据：通过使用
<-运算符进行数据的发送和接收操作。例如：ch <- 42表示将值 42 发送到通道 ch 中，x := <-ch表示从通道 ch 中接收一个值并将其赋值给变量 x。- 阻塞和非阻塞操作：Channel 的发送和接收操作可以是阻塞的，也可以是非阻塞的。阻塞的发送和接收操作会导致 goroutine 阻塞，直到有对应的接收或发送操作可以执行；而非阻塞的发送和接收操作会立即返回，无论是否有对应的接收或发送操作可以执行。
- 关闭通道：可以使用内建函数
close关闭一个通道，表示不再向通道发送数据，但可以继续从通道接收数据。关闭通道后，对通道的发送操作将导致 panic，而对通道的接收操作可以继续接收通道中的已有数据。总的来说，Channel 是 Go 语言中用于实现 goroutine 之间通信和同步的重要机制，通过阻塞式的操作和类型安全的特性，可以简化并发编程的复杂性，并避免常见的并发问题。
13、Go 语言中的 defer 关键字有什么作用，它的执行顺序是怎样的？
Go 语言中的
defer关键字用于在函数执行完毕前（或发生 panic 时）延迟执行一些代码，常用于资源释放、错误处理、日志记录等场景。defer语句会将其后面的函数调用推迟到当前函数执行完毕之后再执行，不论函数是否正常返回或者发生了 panic。
defer关键字的作用主要包括以下几个方面：
- 资源释放：在函数执行完毕后，可以使用
defer关键字释放已经打开的资源，如文件句柄、数据库连接、网络连接等，以避免资源泄漏。- 错误处理：可以使用
defer关键字在函数发生错误时，通过调用一些错误处理函数或者日志记录函数来处理错误，以保证错误信息能够被捕获并处理。- 代码清理：可以使用
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 }
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
)
}
在上面的例子中，`foo` 函数执行时，会先打印 "Actual Execution"，然后 "First"、"Second"、"Third" 会按照逆序依次执行，即先打印 "Third"，然后打印 "Second"，最后打印 "First"。 需要注意的是，`defer` 关键字只会延迟函数调用的执行，而不会延迟函数内部的表达式的计算。例如：func foo() {
x := 10
defer fmt.Println(x) // 打印 10
x = 20
}
[外链图片转存中…(img-tVLvg6qD-1715789442476)]
[外链图片转存中…(img-BQyNPLsr-1715789442476)]
[外链图片转存中…(img-T57MB1bx-1715789442476)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
