Advanced Go读书笔记

一、语言基础

main.main函数执行过程

image.png

PS：在main.main函数执行之前所有代码都运行在同一个goroutine中即运行在程序的主系统线程中。
slice底层数组部分通过隐式指针传递(指针本身是传值的，只是指向的是同一份数据而已)，被调函数通过指针修改调用参数slice底层数组中的数据。但是slice本身是要维护其对应的数据结构的，例如，长度和容量。另外，在slice底层数组扩容时，其指向的底层数组也会发生改变。因此，像append这种操作必须要返回一个slice的原因。

3.golang中函数的递归调用深度逻辑上没有限制，函数调用栈是不会出现溢出错误的，因为golang在运行时会根据需要动态地调整函数栈的大小。每个goroutine刚启动时只会分配很小的栈(4KB或8KB)，根据需要动态调整栈的大小，栈最大可以达到GB级别。

image.png

PS：一个goroutine会以一个很小的栈启动(2KB或4KB)，当遇到深度递归导致当前栈空间不足时，goroutine会根据需要动态地伸缩栈的大小(主流实现中栈的最大值可达到1GB)。因为启动的代价很小，所以我们可以轻易地启动成千上万个goroutine。

golang 互斥锁 + 原子操作 --> 单例模式

// Once 结构体定义
type Once struct {
    m    Mutex
    done uint32
}

// Do 有且仅执行一次f()操作
func (o *Once) Do(f func()) {
    if atomic.LoadUint32(&o.done) == 1 {
        return
    }
    // Slow-path.
    o.m.Lock()
    defer o.m.Unlock()
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}

5.golang中同一个goroutine内顺序一致性内存模型是得到保证的，但是不同goroutine之间，并不满足顺序一致性内存模型，需要通过明确定义的同步事件来作为同步的参考。如果两个事件不可排序，那么就说这两个事件是并发的。为了最大化并行，golang的编译器和处理器在不影响上述规定的前提下可能会对执行语句重新排序(CPU也不会对一些语句乱序执行)。
golang中通过同步的方式来给多个事件进行排序，例如

//  同一goroutine内的顺序一致性得到保证，因此
//  main在等待另一goroutine的操作执行结束后，才会退出
func main() {
    done := make(chan int)
    go func(){
        println("你好, 世界")
        done <- 1
     }()
     <-done
}

对于无缓冲信道进行的接收，发生在对该信道进行的发送完成之前。对于带缓冲的channel，第K个接收完成操作发生在第K+C个发送操作完成之前，其中C是channel的缓存大小。(无缓冲channel是带缓冲channel的一种特例)
严谨的并发程序的正确性不应该依赖于CPU的执行速度和休眠时间等不靠谱的因素的。严谨的并发应该是可以静态推导出结果的：根据线程内顺序一致性，结合Channel或sync同步事件的可排序性来推导，最终完成各个线程各个代码的偏序关系排序。如果两个事件无法根据此规则来排序，那么它们就是并发的。
select {} 将会一直阻塞下去。
如何优雅地stop所有的goroutine

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(wg *sync.WaitGroup, stop chan struct{}) {
    defer wg.Done() //
    for {
        select {
        default:
            fmt.Println("Hello, World!")
            time.Sleep(time.Second)
        case <-stop:
            return
        }
    }
}

func main() {
    stop := make(chan struct{})
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go worker(&wg, stop)
    }

    time.Sleep(time.Second)
    close(stop)
    wg.Wait() //
    fmt.Println("end")
}

海量请求处理

image.png

workerpool.go:

image.png

worker.go: 代码有地方写错了，不过还好

image.png

service.go: job --> worker job --> process

image.png

main.go: web服务器

image.png

context实现超时控制

image.png
C errno <--> syscall.Errno
PS：在处理错误返回值时，没有错误的返回值最好直接返回nil。
recover函数必须要和有异常的栈帧只隔一个栈帧，recover函数才能正确捕获异常。换言之，recover函数捕获的是祖父一级调用函数栈帧的异常(刚好跨越一层defer函数)。正确的处理姿势应该是这样的:

func main() {
    defer func() {
    if r := recover(); r != nil { ... }
        // 虽然总是返回nil, 但是可以恢复异常状态
    }()
    // 警告: 用`nil`为参数抛出异常
    panic(nil)
}

二、Go Web

一种优雅的middleware实现

type middleware func(http.Handler) http.Handler
type Router struct {
    middlewareChain [] func(http.Handler) http.Handler
    mux map[string] http.Handler
}
func NewRouter() *Router{
    return &Router{}
}
func (r *Router) Use(m middleware) {
    r.middlewareChain = append(r.middlewareChain, m)
}
// 每次添加一个uri，便用所有的middleware进行层层包装
func (r *Router) Add(route string, h http.Handler) {
    var mergedHandler = h
    for i := len(r.middlewareChain) - 1; i >= 0; i-- {
        mergedHandler = r.middlewareChain[i](mergedHandler)
    }
    r.mux[route] = mergedHandler
}

什么事情适合在middleware中做？
golang chi web框架提供了下列middleware:

image.png
validator工作原理
利用reflect对整个struct进行递归遍历，获取struct相应field的validate tag，根据tag的限制条件对field的取值进行校验。
PS：在validate过程中使用了大量的reflect，可能会存在性能问题。

三、分布式系统

版权声明：本文来源简书，感谢博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://www.jianshu.com/p/4c9c15ea8cce
站方申明：本站部分内容来自社区用户分享，若涉及侵权，请联系站方删除。

发表于 2020-01-12 12:54:06
阅读 ( 965 )
分类：Go