Go语言入门

语言处理系统

解释型

• python

• javascript

编译型

• go

• c++

混合体

• java

变量与类型

变量的内涵

强类型与弱类型

变量的声明与赋值

var name type = expression

name := expression  //只能在函数里用

变量名

变量生命周期

作用域

运算符优先级

程序控制结构

选择结构

if-else

if exp{}else if{}else{}

switch-case

switch var1{    case val1:    case val2,val3:    default:}

switch{    case exp1:    case exp2:    default:}

循环结构

完整C风格for循环

for i:=0;i<10;i++{    fmt.Println(i)}

只有条件判断的for循环

i:=1for i<100{    fmt.Println(i)    i*=2}

无限循环

for{    xxx
}

for-range循环

for i,v:=range Vals{    fmt.Println(i,v)}

Break&Continue

Label

函数

函数声明

func first(x int,_ int) int //预留参数

func test(a,b int) (int,err){ //多返回值    xxx
}

func addSum(sum ... int)int{    //... 表示可变参数，可以传入无穷多个int，用for-range获取值    var sum int    for _,value := range nums{        sum+=value
    }    return sum
}

函数递归

func f1(n int)int{    if n==1{        return 1    }    return f1(n-1)*n
}

func fib(n int) int{    return fibter(1,0,n)}func fibter(a,b,count int)int{    if count==0{        return b    //不是返回上一层，而是直接退出函数    }    return fibter(a+b,a,count-1)}

高阶函数

闭包

复合类型

数组

var arr [10]intvar arr2 [12]int{1,5:4,6,10:11,11}var arr [13][13]int{}

切片

var slice1 []intvar slice2 = []int{1,2,3,4}var slice3 = []int{1,5:10,19:111}var slice4 = make([]int,length,capacity) //capacity 可省略 容量爆了就翻倍2->4->8->16slice2:=slice[1:4]  //截取，左闭右开，但cap=4，会复用相同底层结构，共享同一块内存

哈希表

hash = f(key)index = hash % array_size

defer

• 延迟执行

• 参数预计算



a=2

• LIFO执行顺序



start 5->start 1

panic 函数

panic特性

recover函数

https://www.jb51.net/article/272258.htm

接口

多态

package main
import "fmt"type AnimalIF interface {    Sleep()    GetColor() string    GetType() string}type Cat struct {    color string}func (c *Cat) GetColor() string {    return c.color
}func (c *Cat) GetType() string {    return "cat"}func (c *Cat) Sleep() {    fmt.Println("Cat is Sleep")}type Dog struct {    color string}func (d *Dog) Sleep() {    fmt.Println("Dog is Sleep")}func (d *Dog) GetColor() string {    return d.color
}func (d *Dog) GetType() string {    return "Dog"}func main() {    var animal AnimalIF
    animal = &Cat{"Green"}    animal.Sleep()    animal = &Dog{"Red"}    fmt.Println(animal.GetType())    animal.Sleep()}

嵌套

package main
import "fmt"type Flyer interface {    fly()}type Swimmer interface {    swim()}type FlyFish interface {    Flyer
    Swimmer
}type Fish struct {}func (fish Fish) fly() {    fmt.Println("fly")}func (fish Fish) swim() {    fmt.Println("swim")}func main() {    var ff FlyFish
    ff = Fish{}    ff.fly()    ff.swim()}

类型断言

反射

TypeOf

type Kind uintconst (    Invalid Kind = iota  // 非法类型    Bool                 // 布尔型    Int                  // 有符号整型    Int8                 // 有符号8位整型    Int16                // 有符号16位整型    Int32                // 有符号32位整型    Int64                // 有符号64位整型    Uint                 // 无符号整型    Uint8                // 无符号8位整型    Uint16               // 无符号16位整型    Uint32               // 无符号32位整型    Uint64               // 无符号64位整型    Uintptr              // 指针    Float32              // 单精度浮点数    Float64              // 双精度浮点数    Complex64            // 64位复数类型    Complex128           // 128位复数类型    Array                // 数组    Chan                 // 通道    Func                 // 函数    Interface            // 接口    Map                  // 映射    Ptr                  // 指针    Slice                // 切片    String               // 字符串    Struct               // 结构体    UnsafePointer        // 底层指针)

ValueOf

v:=reflect.Valueof(x)return int(v.Int())

package main
import (    "fmt"    "reflect")func reflectSetValue1(x interface{}) {    v := reflect.ValueOf(x)    if v.Kind() == reflect.Int64 {        v.SetInt(200) //修改的是副本，reflect包会引发panic    }}func reflectSetValue2(x interface{}) {    v := reflect.ValueOf(x)    // 反射中使用 Elem()方法获取指针对应的值    if v.Elem().Kind() == reflect.Int64 {        v.Elem().SetInt(200)    }}func main() {    var a int64 = 100    // reflectSetValue1(a) //panic: reflect: reflect.Value.SetInt using unaddressable value    reflectSetValue2(&a)    fmt.Println(a)}

结构体反射

package main
import (    "fmt"    "reflect")type User struct {    Id   int    `json:"id" ini:"s_id"`    Name string `json:"name" ini:"s_name"`    Age  int    `json:"score" ini:"s_score"`    test interface{}}func (u User) Call(arg int) {    fmt.Println(arg)}func main() {    user := User{        Id:   0,        Name: "C++",        Age:  3,        test: 1131,    }    //user.Call()    Do(user)}func Do(input interface{}) { //传指针加Elem()即可,加了Elem()必须要传指针    t := reflect.TypeOf(input)    v := reflect.ValueOf(input)    fmt.Println("t is ", t)    fmt.Println("v is ", v)    for i := 0; i < t.NumField(); i++ { //t.Numfield==v.Numfield        field := t.Field(i)        value := v.Field(i)        tag := t.Field(i).Tag.Get("json")        fmt.Println("field is ", field, "\nvalue is ", value, "\ntag is ", tag)    }    fmt.Println("-------------------------------------------------------")    for i := 0; i < v.NumMethod(); i++ {        fmt.Println("i=", i)        method := t.Method(i).Name
        var args = []reflect.Value{reflect.ValueOf(1)}        fmt.Println(method)        v.Method(i).Call(args)    }}

Go 并发编程

协程vs线程

调度方式

上下文切换速度

调度策略

栈大小

goroutine

sync.WaitGroup

package main
import (    "fmt"    "sync")// 声明全局等待组变量var wg sync.WaitGroup
func hello() {    fmt.Println("hello")    wg.Done() // 告知当前goroutine完成}func main() {    wg.Add(1) // 登记1个goroutine    go hello()    fmt.Println("你好")    wg.Wait() // 阻塞等待登记的goroutine完成}

动态栈

goroutine调度

• G：表示 goroutine，每执行一次go f()就创建一个 G，包含要执行的函数和上下文信息。

• 全局队列（Global Queue）：存放等待运行的 G。

• P：表示 goroutine 执行所需的资源，最多有 GOMAXPROCS 个。

• P 的本地队列：同全局队列类似，存放的也是等待运行的G，存的数量有限，不超过256个。新建 G 时，G 优先加入到 P 的本地队列，如果本地队列满了会批量移动部分 G 到全局队列。

• M：线程想运行任务就得获取 P，从 P 的本地队列获取 G，当 P 的本地队列为空时，M 也会尝试从全局队列或其他 P 的本地队列获取 G。M 运行 G，G 执行之后，M 会从 P 获取下一个 G，不断重复下去。

• Goroutine 调度器和操作系统调度器是通过 M 结合起来的，每个 M 都代表了1个内核线程，操作系统调度器负责把内核线程分配到 CPU 的核上执行。

• Work stealing
所有P放满了才会放到全局队列，如果某个M没东西了，会从其他P偷一个G过来，· 其他P没得偷从全局偷

• handoff
如果某P的本地队列中的某G使得M阻塞，P会移动到另一个唤醒/创建的M，原来的M在G运行完之后睡眠或者销毁

GOMAXPROCS

func main(){    runtime.GOMAXPROCS(i)}

channel

1. 对一个关闭的通道再发送值就会导致 panic。

2. 对一个关闭的通道进行接收会一直获取值直到通道为空。

3. 对一个关闭的并且没有值的通道执行接收操作会得到对应类型的零值。

4. 关闭一个已经关闭的通道会导致 panic。

func recv(c chan int) {    ret := <-c
    fmt.Println("接收成功", ret)}func main() {    ch := make(chan int)    go recv(ch) // 创建一个 goroutine 从通道接收值    ch <- 10    fmt.Println("发送成功")}

value, ok := <- ch

• value：从通道中取出的值，如果通道被关闭则返回对应类型的零值。

• ok：通道ch关闭时返回 false，否则返回 true。

Worker Pool

package main
import (    "fmt"    "time")func worker(id int, jobs <-chan int, results chan<- int) {    for job := range jobs {        fmt.Println("worker id: ", id, "doing job: ", job)        results <- job * 2        time.Sleep(time.Second)        fmt.Println("worker id: ", id, "finished job: ", job)    }}func main() {    jobs := make(chan int, 100)    results := make(chan int, 100)    for j := 0; j < 3; j++ {        go worker(j, jobs, results)    }    for i := 0; i < 5; i++ {        jobs <- i
    }    close(jobs)    for i := 0; i < 5; i++ {        fmt.Println(<-results)    }}

select

• 可处理一个或多个 channel 的发送/接收操作。

• 如果多个 case 同时满足，select 会随机选择一个执行。

• 对于没有 case 的 select 会一直阻塞，可用于阻塞 main 函数，防止退出

package main
import "fmt"func main() {    ch := make(chan int, 1)    for i := 0; i < 10; i++ {        select { //如果多个case都满足，随机选一个执行        case x := <-ch: //可以从channel中取值            fmt.Println("Receiving", x)        case ch <- i:            fmt.Println("Sending ", i) //可以从channel中存放值        default:            fmt.Println("do nothing")        }    }}

并发安全和锁

原子锁

互斥锁

package main
import (    "fmt"    "sync")// sync.Mutexvar (    x int64    wg sync.WaitGroup // 等待组    m sync.Mutex // 互斥锁)// add 对全局变量x执行5000次加1操作func add() {    for i := 0; i < 5000; i++ {        m.Lock() // 修改x前加锁        x = x + 1        m.Unlock() // 改完解锁    }    wg.Done()}func main() {    wg.Add(2)    go add()    go add()    wg.Wait()    fmt.Println(x)}

读写互斥锁

// 使用互斥锁，10并发写，1000并发读do(writeWithLock, readWithLock, 10, 1000) // x:10 cost:1.466500951s// 使用读写互斥锁，10并发写，1000并发读do(writeWithRWLock, readWithRWLock, 10, 1000) // x:10 cost:117.207592ms

sync.WaitGroup

var wg sync.WaitGroup
func hello() {    defer wg.Done()    fmt.Println("Hello Goroutine!")}func main() {    wg.Add(1)    go hello() // 启动另外一个goroutine去执行hello函数    fmt.Println("main goroutine done!")    wg.Wait()}

sync.Once

package singleton
import (    "sync")type singleton struct {}var instance *singleton
var once sync.Once
func GetInstance() *singleton {    once.Do(func() {        instance = &singleton{}    })    return instance
}

sync.Map

package main
import (    "fmt"    "sync")func main() {    wg := sync.WaitGroup{}    m := sync.Map{}    for i := 0; i < 20; i++ {        go func(i int) {            wg.Add(1)            m.Store(i, i+100)            t, _ := m.Load(i)            fmt.Println(i, ":", t)            wg.Done()        }(i)    }    wg.Wait()}

Cond

var c sync.Cond
//协程Ac.L.Lock()for !conditon(){    c.Wait()}c.L.Unlock
//协程Bc.Broadcast()

感谢李文周大佬的教程

GO并发模式

Ping-Pong模式

Fan-in模式

Fan-out模式

Sub-worker模式

Pipeline模式

依赖管理

GO Modules

go mod init modulename
go get modulename
go mod tidy

其他

构造函数

package main
import "fmt"type Person struct {    name string    age  int}func NewPerson(name string, age int) (*Person, error) {    if name == "" {        return nil, fmt.Errorf("name is null")    }    if age < 0 {        return nil, fmt.Errorf("age must be above 0")    }    return &Person{name, age}, nil}func main() {    per, err := NewPerson("tom", -1)    if err == nil {        fmt.Println(per)    } else {        fmt.Println(err)    }}