Golang编程

整型：0

浮点型：0.0

布尔型：false

字符串：“”

指针、接口、切片、channel、map和函数类型：nil

内层代码块声明了与外层代码块同名切类型相同的变量

int、uint

int8....int64

uint8.....uint64

uintptr、byte

strconv.Itoa()

strconv.Atoi()

strconv.FormatFolat()

real

imag

type MyInt int

for init; condition; post {}

for condition {}

for {}

for key, value := range sl {}

for i := range sl {}

for _, v := range sl {}

for range sl {}

continue tag

break tag

即浅拷贝

没有具体名称的函数

用于延迟执行函数调用的关键字，无论执行成功还是失败都会执行

执行顺序是后进先出的，因此特别适合资源的清理和释放

使用场景：文件的关闭、锁的释放等等

函数的返回值在return语句执行时已经确定了

为什么不支持map？

type MyInt *int

func (r MyInt) String() string { // r的基类型为MyInt，编译器报错：invalid receiver type MyInt (MyInt is a pointer type)
return fmt.Sprintf("%d", *(*int)(r))
}

type MyReader io.Reader

func (r MyReader) Read(p []byte) (int, error) { // r的基类型为MyReader，编译器报错：invalid receiver type MyReader (MyReader is an interface type)
return r.Read(p)
}

即所属类型实现了这个接口

任何类型都可以被赋值给该空接口类型的变量，任何类型都满足空接口类型的方法集合

利于复用和组合

空结构体大小占用为0

与底层类型没有关系，不能直接赋值和比较

与底层类型完全相同，能直接赋值和比较

var p Person

p := Person{
                Name: "Alice",
                Age:  25,
        }

为结构体字段提供额外的信息

json

xml

csv

如果没有设置，则返回时间零值和false

deadline, ok := ctx.Deadline()
if ok {
    // Context 有截止时间
} else {
    // Context 没有截止时间
}

如果context永不取消，则返回nil

select {
case <-ctx.Done():
    // Context 已取消
default:
    // Context 尚未取消
}

返回方法取消时产生的错误

返回与context关联的键值对，一般用于在goroutine之间传递请求范围内的信息

通常作为根context使用

不确定上下文时使用

当取消函数被调用时，子context会被取消，同时会向context关联的Done（）通道发送取消信号，所有衍生的context都会被取消

若是调用WithCancelCause的取消函数进行的取消操作，则可以获得error的值，反之获得c.Err的值

适用于需要在特定时间点取消操作的场景

使用需要在一段时间后取消操作的场景

ctx := context.WithValue(req.Context(), requestIDKey, requestID)

ctx, cancelFunc := context.WithCancel(context.Background())
go Working(ctx)

time.Sleep(3 * time.Second)
cancelFunc()

ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()

// 在另一个 goroutine 中执行耗时操作
go func() {
   // 模拟一个耗时的操作，例如数据库查询
   time.Sleep(5 * time.Second)
   cancel()
}()

可以编写更加灵活、适配性更好的代码

var x float64 = 3.4
t := reflect.TypeOf(x)
v := reflect.ValueOf(x)

fmt.Println("Type:", t)          // 输出: Type: float64
fmt.Println("Value:", v.Interface()) // 输出: Value: 3.4

v.SetFloat(7.1)
fmt.Println(x) // 输出: 7.1

var i interface{} = "hello"
v := reflect.ValueOf(i)

if s, ok := v.Interface().(string); ok {
    fmt.Println(s) // 输出: hello
}

type MyStruct struct {
    privateField int
}

s := MyStruct{privateField: 1}
v := reflect.ValueOf(s)

field := v.Elem().FieldByName("privateField")
fmt.Println("Private Field:", field.Int()) // 输出: Private Field: 1

type MyMethods struct{}

func (m *MyMethods) MyMethod() string {
    return "Hello, World!"
}

obj := &MyMethods{}
method := reflect.ValueOf(obj).MethodByName("MyMethod")
result := method.Call(nil)
fmt.Println("Method Result:", result[0].Interface()) // 输出: Method Result: Hello, World!

除非使用reflect.Value的Unsage*方法

类型形参列表

实例化

type CommonType[T int|string|float32] T

type NewType [T * int][]T

解法

匿名函数支持使用别处已经定义好的泛型形参

func (q *Queue[T]) Put(value T) {
    value.(int) // 错误。泛型类型定义的变量不能使用类型断言

    // 错误。不允许使用type switch 来判断 value 的具体类型
    switch value.(type) {
    case int:
        // do something
    case string:
        // do something
    default:
        // do something
    }
   
    // ...
}

func (receiver Queue[T]) Put(value T) {
    // Printf() 可输出变量value的类型(底层就是通过反射实现的)
    fmt.Printf("%T", value)

    // 通过反射可以动态获得变量value的类型从而分情况处理
    v := reflect.ValueOf(value)

    switch v.Kind() {
    case reflect.Int:
        // do something
    case reflect.String:
        // do something
    }

    // ...
}

type AllInt interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint32
}

type Uint interface {
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}

type A interface { // 接口A代表的类型集是 AllInt 和 Uint 的交集
    AllInt
    Uint
}

程序趋于健壮、稳定

// 启动一个新的协程
go sayHello()

package main

import (
    "fmt"
    "time"
)

func sendMessage(ch chan string, message string) {
    ch <- message // 发送消息到通道
}

func main() {
    // 创建一个字符串通道
    messageChannel := make(chan string)

    // 启动一个协程发送消息
    go sendMessage(messageChannel, "Hello from Goroutine!")

    // 主线程从通道接收消息
    receivedMessage := <-messageChannel
    fmt.Println(receivedMessage)
}

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 协程完成时减少计数

    fmt.Printf("Worker %d starting\n", id)
    // 模拟一些工作
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1)       // 每启动一个协程增加计数
        go worker(i, &wg) // 启动协程
    }

    wg.Wait() // 等待所有协程完成
    fmt.Println("All workers done")
}

package main

import (
    "fmt"
    "time"
)

func doSomething(ch chan string) {
    // 模拟一些工作
    time.Sleep(2 * time.Second)
    ch <- "Task completed"
}

func main() {
    ch := make(chan string)

    go doSomething(ch)

    select {
    case result := <-ch:
        fmt.Println(result)
    case <-time.After(1 * time.Second):
        fmt.Println("Timeout occurred")
    }
}

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for job := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, job)
        results <- job * 2
    }
}

func main() {
    const numJobs = 5
    const numWorkers = 3

    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    // 创建并启动协程池
    var wg sync.WaitGroup
    for i := 1; i <= numWorkers; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            worker(i, jobs, results)
        }(i)
    }

    // 提供任务
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    // 等待所有工作完成
    go func() {
        wg.Wait()
        close(results)
    }()

    // 处理结果
    for result := range results {
        fmt.Printf("Result: %d\n", result)
    }
}

package main

import (
    "fmt"
    "time"
)

func longRunningTask(ch chan string) {
    // 模拟一些长时间运行的任务
    time.Sleep(3 * time.Second)
    ch <- "Task completed"
}

func main() {
    ch := make(chan string)

    go longRunningTask(ch)

    select {
    case result := <-ch:
        fmt.Println(result)
    case <-time.After(2 * time.Second):
        fmt.Println("Timeout occurred")
    }
}

package main

import (
    "fmt"
    "context"
    "time"
)

func doSomething(ctx context.Context, ch chan string) {
    select {
    case <-time.After(3 * time.Second):
        ch <- "Task completed"
    case <-ctx.Done():
        ch <- "Task canceled"
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    ch := make(chan string)

    go doSomething(ctx, ch)

    // 模拟在某个条件下取消任务
    time.Sleep(2 * time.Second)
    cancel()

    result := <-ch
    fmt.Println(result)
}

调度器

M:N模型

栈

调用约定

协程的通道是用于协程之间轻量级通信的机制

os的管道是用于进程之间通信的机制

通过内置的channel类型来实现的，chan允许协程间安全的发送数据和接收数据

创建通道

发送消息

接收消息

信号量阻塞

用于协程之间安全通信的数据结构，基于CSP理论

CSP理论

基本操作

阻塞和死锁：若发送者协程发送数据，但没有接受者来接收就会导致阻塞

单向通道限制：单向通道只能发送或接收数据，不能同时进行；双向通道可以隐式转换为单向通道

关闭已关闭的通道：关闭已经关闭的通道会panic，应该在关闭之前检查通道的状态

缓冲通道的容量限制：固定容量，满了会阻塞发送者；当通道为空时，会阻塞接受者

无缓冲通道的同步性：发送和接收都是同步的，发送者和接收者都会被阻塞，直到另一方准备好；该方式在某些情况下会有性能问题

a := []int{1, 2, 3, 4, 5}
fmt.Println(len(a), cap(a)) // 5, 5

c := *new([]int) fmt.Println(len(c), cap(c)) // 0, 0

// implementation of new builtin
// compiler (both frontend and SSA backend) knows the signature
// of this function.
func newobject(typ *_type) unsafe.Pointer {
return mallocgc(typ.Size_, typ, true)
}

b := a[1:3:4] // [low:high:max]
fmt.Println(len(b), cap(b)， b) // 2, 3， [2 3]

d := make([]int, 5, 5)
fmt.Println(len(d), cap(d)) // 5, 5

makeslice函数

growslice

roundupsize：字节对齐（使CPU读取字节更加高效）

底层数组是共享存储的

传递的是底层数组的指针；除非出发切片扩容，否则修改的都是同一个底层数组

v是切片的值的一个拷贝，修改不会影响到切片，但是直接修改切片就有可能影响到

hmap

bmap

先将bucket挂到oldbucket上，再将bucket指向新的bucket地址

渐进式扩容：每次插入、修改、删除操作就迁移两个桶

都迁移完成后oldbucket变成nil