// 分配0值内存，返回指向类型T的指针 *T
p := new(int) // p是一个*int类型的指针，指向一个int类型的零值
fmt.Println(*p) // 输出0

// 等价于
var i int
p := &i

s := make([]int, 5) // 创建一个长度为5的int切片
m := make(map[string]int) // 创建一个空的map
c := make(chan int, 10) // 创建一个缓冲区大小为10的int通道

package main

import "fmt"


func main(){
    
    // new 示例
    p1 := new(int)
    fmt.Printf("new(int): %T, 值: %v, 地址: %p\n", p1, *p1, p1)
    // 输出: new(int): *int, 值: 0, 地址: 0xc000014098
    
    // 2. new 用于 slice（不推荐）
    p2 := new([]int)
    fmt.Printf("new([]int): %T, 值: %v, 是否nil: %v\n", p2, *p2, *p2 == nil)
    // 输出: new([]int): *[]int, 值: [], 是否nil: true
    // *p2 是 nil，不能直接使用！
    
    // ============ make 示例 ============
    
    // 3. make 用于 slice
    s := make([]int, 5, 10)
    fmt.Printf("make([]int): %T, len: %d, cap: %d\n", s, len(s), cap(s))
    // 输出: make([]int): []int, len: 5, cap: 10
    s[0] = 100 // 可以直接使用
    
    // 4. make 用于 map
    m := make(map[string]int)
    m["key"] = 42 // 可以直接使用
    fmt.Printf("make(map): %T, 值: %v\n", m, m)
    
    // 5. make 用于 channel
    ch := make(chan int, 3)
    ch <- 1 // 可以直接使用
    fmt.Printf("make(chan): %T\n", ch)

}

// 数组： 长度是类型的一部分
var arr [5]int  // [0 0 0 0 0]
arr2 :=[3]int{1,2,3} // [1 2 3]
arr3 := [...]int{4,5,6} // 自动计算长度

// 切片： 长度可变
var slice1 []int    // nil 切片
slice2 := []int{1,2,3} // [1 2 3]
slice3 := make([]int, 5) // [0 0 0 0 0]
slice4 := make([]int, 3, 10) // 长度3，容量10

// 数组是值类型，赋值会拷贝整个数组
arr := [3] {1,2,3}
arr2 := arr    // 完整拷贝
arr2[0] = 100
fmt.Println(arr)  // [1 2 3]  不受影响
fmt.Println(arr2) // [100 2 3]

// 切片是引用类型，赋值会拷贝切片头
slice := []int{1,2,3}
slice2 := slice  // 只拷贝切片头,底层数据共享
slice2[0] = 100
fmt.Println(slice)  // [100 2 3] 受影响
fmt.Println(slice2) // [100 2 3]

// 数组: 长度固定
arr := [5]int{1,2,3,4,5}
fmt.Println(len(arr)) // 5
// arr = append(arr, 6) // 编译错误，不能改变长度

// 切片： 长度可变，有容量概念
slice := []int{1, 2, 3}
fmt.Println(len(slice))   //2 - 长度
fmt.Println(cap(slice))   //3 - 容量

slice = append(slice, 4) // 可以追加元素
fmt.Println(slice) // [1 2 3 4]

// 数组传递：值拷贝，影响性能
func modifyArray(arr [10000] int){
    arr[0] = 100   // 不会影响原数组
}


// 切片传递：只拷贝切片头(24字节)，高效
func modifySlice(slice []int) {
    slice[0] = 100  // 会影响原切片的底层数组
}

// 切片的内部结构
type slice struct {
    array unsafe.Pointer   // 指向底层数组的指针
    len int   // 长度
    len int   // 容量
}

// 数组：长度固定， 明确已知
func ProcessFixedData(){
    var buffer [1024]byte   //固定大小的缓冲区
    // ....
}

// 切片： 长度不确定，需要动态操作
func processDynamicData(){
    data := []string{}
    data = append(data, "item1")
    data = append(data, "item2")
    // ....
}

arr := [5]int{1,2,3,4,5}

slice1 := arr[:]   //完整切片
slice2 := arr[1:4] // [2 3 4]
slice3 := arr[:3]     // [1 2 3]
slice4 := arr[2:]     // [3 4 5]

// 好的做法：预分配容量
slice := make([]int, 0, 100)
for i := 0; i < 100; i++ {
    slice = append(slice, i)
} 

package main 

import "fmt"

func main(){
    slice := []int{1,2,3,4,5}
    
    for i,v := range slice {
     fmt.Printf("i的地址: %p, v的地址: %p, v的值: %d\n", &i, &v, v)
    }
}
// 输出：
// i的地址: 0xc000018090, v的地址: 0xc000018098, v的值: 1
// i的地址: 0xc000018090, v的地址: 0xc000018098, v的值: 2
// i的地址: 0xc000018090, v的地址: 0xc000018098, v的值: 3
// i的地址: 0xc000018090, v的地址: 0xc000018098, v的值: 4
// i的地址: 0xc000018090, v的地址: 0xc000018098, v的值: 5

// ❌ 错误示例
func main() {
    slice := []int{1, 2, 3, 4, 5}
    var result []*int
    
    for _, v := range slice {
        result = append(result, &v)  // 错误！所有指针都指向同一个地址
    }
    
    for _, p := range result {
        fmt.Print(*p, " ")  // 输出: 5 5 5 5 5
    }
}

// ✅ 正确做法1：创建临时变量
func main() {
    slice := []int{1, 2, 3, 4, 5}
    var result []*int
    
    for _, v := range slice {
        temp := v  // 创建新变量
        result = append(result, &temp)
    }
    
    for _, p := range result {
        fmt.Print(*p, " ")  // 输出: 1 2 3 4 5
    }
}

// ✅ 正确做法2：使用索引
func main() {
    slice := []int{1, 2, 3, 4, 5}
    var result []*int
    
    for i := range slice {
        result = append(result, &slice[i])  // 直接取原切片元素的地址
    }
    
    for _, p := range result {
        fmt.Print(*p, " ")  // 输出: 1 2 3 4 5
    }
}

// ❌ 错误示例
func main() {
    var funcs []func()
    slice := []int{1, 2, 3, 4, 5}
    
    for _, v := range slice {
        funcs = append(funcs, func() {
            fmt.Print(v, " ")  // 闭包捕获的是变量v的地址
        })
    }
    
    for _, f := range funcs {
        f()  // 输出: 5 5 5 5 5
    }
}

// ✅ 正确做法1：传参
func main() {
    var funcs []func()
    slice := []int{1, 2, 3, 4, 5}
    
    for _, v := range slice {
        v := v  // 创建新变量（Go 1.22之前需要）
        funcs = append(funcs, func() {
            fmt.Print(v, " ")
        })
    }
    
    for _, f := range funcs {
        f()  // 输出: 1 2 3 4 5
    }
}

// ✅ 正确做法2：函数参数
func main() {
    var funcs []func()
    slice := []int{1, 2, 3, 4, 5}
    
    for _, v := range slice {
        funcs = append(funcs, func(val int) func() {
            return func() {
                fmt.Print(val, " ")
            }
        }(v))  // 立即执行，传入v的值
    }
    
    for _, f := range funcs {
        f()  // 输出: 1 2 3 4 5
    }
}

// ❌ 错误示例
func main() {
    slice := []int{1, 2, 3, 4, 5}
    
    for _, v := range slice {
        go func() {
            fmt.Print(v, " ")  // 可能输出: 5 5 5 5 5（不确定）
        }()
    }
    
    time.Sleep(time.Second)
}

// ✅ 正确做法：传参
func main() {
    slice := []int{1, 2, 3, 4, 5}
    
    for _, v := range slice {
        go func(val int) {
            fmt.Print(val, " ")  // 输出顺序不定，但值正确
        }(v)
    }
    
    time.Sleep(time.Second)
}

type Person struct {
    Name string
    Age  int
}

// ❌ 错误示例
func main() {
    persons := []Person{
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 35},
    }
    
    var result []*Person
    for _, p := range persons {
        result = append(result, &p)  // 错误！
    }
    
    for _, p := range result {
        fmt.Println(p)  // 全部输出: &{Charlie 35}
    }
}

// ✅ 正确做法
func main() {
    persons := []Person{
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 35},
    }
    
    var result []*Person
    for i := range persons {
        result = append(result, &persons[i])  // 正确
    }
    
    for _, p := range result {
        fmt.Println(p)  // 正确输出每个人的信息
    }
}

func main() {
    m := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
    }
    
    for k, v := range m {
        fmt.Printf("k地址: %p, v地址: %p\n", &k, &v)
    }
    // k和v的地址也是固定的
}

func main() {
    defer fmt.Println("First defer")
    defer fmt.Println("Second defer")
    defer fmt.Println("Third defer")
}
// 输出顺序： Third defer， Second defer ， First defer

for deferInLoop(){
    for i :=0;i<5;i++{
        defer fmt.Println(i)
    }
} 
// 输出顺序：4 3 2 1 0

// ❌ 错误示例：defer在循环中累积
func readFiles() {
    for i := 0; i < 1000; i++ {
        f, _ := os.Open(fmt.Sprintf("file%d.txt", i))
        defer f.Close() // 所有Close都会累积，文件不会及时关闭
    }
} // 函数结束时才执行所有defer

// ✅ 正确做法：使用匿名函数
func readFiles() {
    for i := 0; i < 1000; i++ {
        func() {
            f, _ := os.Open(fmt.Sprintf("file%d.txt", i))
            defer f.Close() // 每次循环结束时执行
        }()
    }
}

func f1(result int) int {
    defer func() {
        result += 5  // 修改命名返回值
    }()
    return 10  // 第一步：result = 10
} // 第二步：执行defer，result变为15，第三步：返回15

func f2() int {
    var result int
    defer func() {
        result += 5  // 修改局部变量，不影响返回值
    }()
    return 10  // 返回值 = result (0), defer修改的是局部变量
}
// 最终返回10

func f3() *int{

    result :=0
    defer func(){
        result +=5  // 修改局部变量,修改指针指向的值
    }()
    return &result  // 返回指针，defer修改了指针指向的值
}
// 最终返回指向5的指针, 返回*int 值为5

func deferArgs(){
    x := 0
    defer fmt.Println("defer x:", x) // 参数在defer时求值
    x = 1
    fmt.Println("x:", x) 
}
// 输出：0（不是1）


func deferClosure(){
    i :=0
    defer func(){
        fmt.Println("defer i:",i) // 闭包捕获变量，延迟执行时使用最新值
    }()
    i ++
}
// 输出：1

package main

import "fmt"

func main() {
    var a uint8 = 255
    fmt.Printf("原始值: %d\n", a)
    
    a = a + 1  // 溢出，变为 0
    fmt.Printf("255 + 1 = %d\n", a)
    
    a = 255 + 2  // 溢出，变为 1
    fmt.Printf("255 + 2 = %d\n", a)
    
    // 输出:
    // 原始值: 255
    // 255 + 1 = 0
    // 255 + 2 = 1
}

package main

import "fmt"

func main() {
    var b uint8 = 0
    fmt.Printf("原始值: %d\n", b)
    
    b = b - 1  // 下溢，变为 255
    fmt.Printf("0 - 1 = %d\n", b)
    
    b = 0 - 5  // 下溢，变为 251
    fmt.Printf("0 - 5 = %d\n", b)
    
    // 输出:
    // 原始值: 0
    // 0 - 1 = 255
    // 0 - 5 = 251
}

var r rune = 'a' // r的值是97

s := "Hello, 世界"
runes := []rune(s) // 将字符串转换为rune切片
fmt.Println(runes) // 输出: [72 101 108 108 111 44 32 19990 30028]

package main

import (
    "fmt"
    "time"
)

func main() {
    s := "这是一个很长的中文字符串" + "重复很多次"
    longString := ""
    for i := 0; i < 1000; i++ {
        longString += s
    }
    
    // 方式1: 多次转换 (慢)
    start := time.Now()
    for i := 0; i < 100; i++ {
        runes := []rune(longString)  // 每次都转换
        _ = len(runes)
    }
    fmt.Printf("多次转换耗时: %v\n", time.Since(start))
    
    // 方式2: 转换一次 (快)
    start = time.Now()
    runes := []rune(longString)  // 只转换一次
    for i := 0; i < 100; i++ {
        _ = len(runes)
    }
    fmt.Printf("转换一次耗时: %v\n", time.Since(start))
}

package main

import (
    "fmt"
    "strings"
)

func buildStringWithRunes() string {
    var builder strings.Builder
    runes := []rune{'H', 'e', 'l', 'l', 'o', '世', '界'}
    
    for _, r := range runes {
        builder.WriteRune(r)  // 高效写入rune
    }
    return builder.String()
}

func main() {
    result := buildStringWithRunes()
    fmt.Println(result)  // Hello世界
}

type User struct {
    ID    int    `json:"id" db:"user_id"`
    Name  string `json:"name,omitempty"`
}

t := reflect.TypeOf(User{})
field, ok := t.FieldByName("ID")
fmt.Println(field.Tag) // 输出: `json:"id" db:"user_id"`

# reflect/type.go

typr StructTag string

value := field.Tag.Get("json") // "id"

func UpdateUserName(u *User, newName string) {
    u.Name = newName // 直接修改原始结构体
} 
#  如果你传值的话，修改不会反映到调用者
func UpdateUserNameValue(u User, newName string) {
    u.Name = newName // 修改的是副本
} 
# 修改必须是指针

type Big struct {
    Data [1024 * 1024]byte // 1MB数据
}

type User struct{}
func (u *User) Save() {}

func Handle(u User) {
    u.Save() // ❌ 编译不过
}

#User 的 method set 不包含 *User 的方法
#反过来可以（编译器自动取地址）

type Config struct {
    Options map[string]string
}

func Modify(c Config) {
    c.Options["x"] = "y"
}

# ⚠️ 这会修改原 map！
因为：
    struct 被拷贝
    map 是引用类型
    修改 map 内容会影响原对象
    👉 这种“半拷贝”行为非常容易误导
    ✔ 用指针，语义更清晰

type Point struct {
    X, Y int
}

func Distance(a, b Point) float64

✔ 小
✔ 不修改
✔ 数学/值对象

👉 传值更清晰

func PrintUser(u User) {
    fmt.Println(u.Name)
}
✔ 不修改
✔ 只读
👉 传值更安全

func Print(u User)
func Print(u *User) // 可能 panic

如果函数逻辑不能接受 nil：

✔ 用值
❌ 不要强迫调用方构造指针

func Handle(req Request)
func Handle(req *Request)

那就要开始担心：
    数据竞争
    隐式共享
goroutine 安全

👉 值传递天然隔离

a := []int{1, 2, 3}
b := a[:2]          // b = [1 2]

b = append(b,100) // b = [1 2 100], 可能修改了 a 底层数组
fmt.Println(a) // 可能输出 [1 2 100]


a 和 b 共享底层数组
b append 时 容量够用
覆盖了 a[2]

b := append([]int(nil), a[:2]...) // 复制一份数据

# 或者
b := slice.Clone(a[:2])

for _, v := range slice {
    if someCondition(v) {
        slice = append(slice, newValue) // 修改了 slice 导致死循环或逻辑错误
    }
}

- 根本原因
    range 在循环开始时就固定了 len
    append 修改的是同一个 slice
    逻辑极其容易出错

# ❌ 不要在 range 原 slice 时 append 同一个 slice

buf := make([]byte, 10 << 20) // 10MB 大缓冲区
small := buf[:1024]          // 1KB 小切片
return small  // 返回 small 导致 buf 无法被 GC 回收


# 问题
    small 只用 100B
    但 引用了 10MB 的底层数组
GC 不会回收
📌 这是 Go 服务内存暴涨的经典原因

# 解决方法
small := make([]byte, 100)
copy(small, buf[:100]) // 复制数据，断开引用

s := make([]int, 0, 1)
p := &s[0]

s = append(s, 1)
s = append(s, 2) // 触发扩容

fmt.Println(*p) // ❌ 未定义行为

go func(){
   s = append(s, 1)
}()

go func(){
   fmt.Println(s[0])
}()


问题
    slice 不是线程安全的
    append 涉及：
    len
    cap
底层数组写入
📌 这是 data race + panic 双重风险

s := make([]int,5)
a = append(s, 1)
fmt.Println(s) // [0 0 0 0 0 1]


# 正确预分配
s := make([]int, 0, 5)

s := append(s[:i], s[i+1:]...) // 删除索引 i 元素

隐藏问题
    底层数组仍然持有 s[i]
    对大对象 → GC 无法回收

# 安全删除
copy(s[i:], s[i+1:])
s[len(s)-1] = zeroValue
s = s[:len(s)-1]

// ✅ 可以比较的情况
type Point struct {
    X, Y int
}

type User struct {
    ID   int
    Name string
}

// ❌ 不能比较的情况
type Data struct {
    m map[string]int  // map不能比较
    s []int          // slice不能比较
    f func()         // 函数不能比较
}

package main

import "fmt"

// ✅ 完全可比较的结构体
type Person struct {
    Name string
    Age  int
}

// ❌ 包含不可比较字段的结构体
type Container struct {
    Data []int  // slice不可比较
}

func main() {
    p1 := Person{"Alice", 25}
    p2 := Person{"Alice", 25}
    p3 := Person{"Bob", 30}
    
    fmt.Println(p1 == p2) // true
    fmt.Println(p1 == p3) // false
    
    // c1 := Container{[]int{1, 2}}
    // c2 := Container{[]int{1, 2}}
    // fmt.Println(c1 == c2) // 编译错误！
}

// 空结构体比较
type Empty struct{}

func main() {
    var e1, e2 Empty
    fmt.Println(e1 == e2) // true，所有空结构体都相等
}

// 包含nil指针
type Node struct {
    value int
    next  *Node
}

func main() {
    n1 := Node{1, nil}
    n2 := Node{1, nil}
    fmt.Println(n1 == n2) // true
}

// 自定义比较方法
type ComplexData struct {
    items []int
}

func (c *ComplexData) Equal(other *ComplexData) bool {
    if len(c.items) != len(other.items) {
        return false
    }
    for i, v := range c.items {
        if v != other.items[i] {
            return false
        }
    }
    return true
}

package main

import "fmt"

func main() {
    // 基本闭包示例
    x := 10
    f := func() int {
        return x + 1  // 捕获外部变量x
    }
    
    fmt.Println(f()) // 11
    x = 20
    fmt.Println(f()) // 21 - 闭包引用的是变量x本身
}

// ❌ 错误示例
func main() {
    var funcs []func()
    for i := 0; i < 3; i++ {
        funcs = append(funcs, func() {
            fmt.Println(i) // 所有函数都输出3
        })
    }
    
    for _, f := range funcs {
        f() // 输出: 3 3 3
    }
}

// ✅ 正确做法1：传参
func main() {
    var funcs []func()
    for i := 0; i < 3; i++ {
        funcs = append(funcs, func(val int) func() {
            return func() {
                fmt.Println(val)
            }
        }(i)) // 立即执行，传入i的值
    }
    
    for _, f := range funcs {
        f() // 输出: 0 1 2
    }
}

// ✅ 正确做法2：创建局部变量
func main() {
    var funcs []func()
    for i := 0; i < 3; i++ {
        i := i // Go 1.22之前需要这样
        funcs = append(funcs, func() {
            fmt.Println(i)
        })
    }
    
    for _, f := range funcs {
        f() // 输出: 0 1 2
    }
}

// ❌ 错误示例
func main() {
    slice := []int{1, 2, 3, 4, 5}
    
    for _, v := range slice {
        go func() {
            fmt.Println(v) // 可能输出多个5
        }()
    }
    
    time.Sleep(time.Second)
}

// ✅ 正确做法：传参
func main() {
    slice := []int{1, 2, 3, 4, 5}
    
    for _, v := range slice {
        go func(val int) {
            fmt.Println(val) // 输出1 2 3 4 5（顺序不定）
        }(v)
    }
    
    time.Sleep(time.Second)
}

// 加法器工厂
func makeAdder(x int) func(int) int {
    return func(y int) int {
        return x + y
    }
}

func main() {
    add5 := makeAdder(5)
    add10 := makeAdder(10)
    
    fmt.Println(add5(3))  // 8
    fmt.Println(add10(3)) // 13
}

// 日志装饰器
func withLogging(f func(int)) func(int) {
    return func(x int) {
        fmt.Printf("调用函数，参数: %d\n", x)
        f(x)
        fmt.Println("函数调用完成")
    }
}

func process(x int) {
    fmt.Printf("处理: %d\n", x * 2)
}

func main() {
    decorated := withLogging(process)
    decorated(5)
}

// 延迟计算斐波那契数列
func fibonacci() func() int {
    a, b := 0, 1
    return func() int {
        result := a
        a, b = b, a+b
        return result
    }
}

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

// 闭包可能导致内存泄漏
func leakyFunction() func() {
    data := make([]byte, 1024*1024) // 1MB数据
    return func() {
        fmt.Println(len(data)) // 闭包持有data引用
    }
}

func main() {
    f := leakyFunction()
    f() // data不会被GC回收
}

type Context interface {
    // Deadline 返回context应该被取消的时间
    Deadline() (deadline time.Time, ok bool)
    
    // Done 返回一个channel，当context被取消时关闭
    Done() <-chan struct{}
    
    // Err 返回context被取消的原因
    Err() error
    
    // Value 返回context中与key关联的值
    Value(key interface{}) interface{}
}

// 空context - 所有context的根
type emptyCtx int

func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
    return
}

func (*emptyCtx) Done() <-chan struct{} {
    return nil
}

func (*emptyCtx) Err() error {
    return nil
}

func (*emptyCtx) Value(key interface{}) interface{} {
    return nil
}

// 可取消的context
type cancelCtx struct {
    Context
    done chan struct{}
    err  error
}

// 带超时的context
type timerCtx struct {
    cancelCtx
    timer *time.Timer
}

// 带值的context
type valueCtx struct {
    Context
    key, val interface{}
}

// 1. HTTP请求处理
func handleRequest(w http.ResponseWriter, r *http.Request) {
    // 从请求获取context
    ctx := r.Context()
    
    // 设置超时
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()
    
    // 传递给数据库操作
    result, err := database.Query(ctx, "SELECT * FROM users")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    json.NewEncoder(w).Encode(result)
}

// 2. 微服务调用
func callUserService(ctx context.Context, userID string) (*User, error) {
    // 添加链路追踪ID
    traceID := ctx.Value("traceID").(string)
    ctx = context.WithValue(ctx, "service", "user-service")
    
    // 设置调用超时
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()
    
    // 发起HTTP调用
    req, _ := http.NewRequest("GET", fmt.Sprintf("http://user-service/users/%s", userID), nil)
    req = req.WithContext(ctx)
    
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var user User
    json.NewDecoder(resp.Body).Decode(&user)
    return &user, nil
}

// 3. 后台任务
func startBackgroundTask(ctx context.Context) {
    ticker := time.NewTicker(time.Second)
    defer ticker.Stop()
    
    for {
        select {
        case <-ctx.Done():
            // 收到取消信号，优雅退出
            fmt.Println("后台任务被取消:", ctx.Err())
            return
        case <-ticker.C:
            // 执行任务
            doWork()
        }
    }
}

// 4. 数据库操作
func GetUserByID(ctx context.Context, db *sql.DB, id int) (*User, error) {
    query := "SELECT id, name, email FROM users WHERE id = ?"
    
    var user User
    err := db.QueryRowContext(ctx, query, id).Scan(
        &user.ID, &user.Name, &user.Email,
    )
    
    if err != nil {
        return nil, err
    }
    
    return &user, nil
}

// 1. Context作为第一个参数
func processData(ctx context.Context, data []byte) error {
    // 正确：context作为第一个参数
    return nil
}

// 2. 不要在struct中存储context
// ❌ 错误
type Service struct {
    ctx context.Context
}

// ✅ 正确
type Service struct{}

func (s *Service) Process(ctx context.Context, data []byte) error {
    return nil
}

// 3. 使用context传递请求范围的数据
type contextKey string

const userIDKey contextKey = "userID"

func WithUserID(ctx context.Context, userID string) context.Context {
    return context.WithValue(ctx, userIDKey, userID)
}

func GetUserID(ctx context.Context) (string, bool) {
    userID, ok := ctx.Value(userIDKey).(string)
    return userID, ok
}

// 4. 正确处理context取消
func longRunningOperation(ctx context.Context) error {
    done := make(chan error, 1)
    
    go func() {
        // 执行耗时操作
        done <- doExpensiveWork()
    }()
    
    select {
    case err := <-done:
        return err
    case <-ctx.Done():
        // 操作被取消，清理资源
        cleanup()
        return ctx.Err()
    }
}

// ✅ 正确的context使用模式
func handleRequest(ctx context.Context, req Request) error {
    // 创建子context
    ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
    defer cancel()
    
    // 传递给下游
    result, err := processRequest(ctx, req)
    if err != nil {
        return err
    }
    
    return nil
}

// channel 底层数据结构
type hchan struct {
    qcount   uint           // 当前队列元素数量
    dataqsiz uint           // 队列容量
    buf      unsafe.Pointer // 指向缓冲区数组的指针
    elemsize uint16         // 元素大小
    closed   uint32         // 是否已关闭
    elemtype *_type         // 元素类型
    sendx    uint           // 发送索引
    recvx    uint           // 接收索引
    recvq    waitq          // 接收 goroutine 等待队列
    sendq    waitq          // 发送 goroutine 等待队列
    lock     mutex          // 保护 hchan 的锁
}

// ✅ 安全操作
func safeChannel() {
    ch := make(chan int, 10)
    
    // 发送和接收操作是原子的
    ch <- 1
    <-ch
    
    // 关闭操作是安全的
    close(ch)
}

// ❌ 不安全操作
func unsafeChannel() {
    ch := make(chan int, 10)
    
    // 对关闭后的 channel 发送数据会导致 panic
    close(ch)
    ch <- 1 // 会 panic
    
    // 关闭 nil channel 会导致 panic
    var chNil chan int
    close(chNil) // 会 panic
}

// 等待队列
type waitq struct {
    first *sudog
    last  *sudog
}

// goroutine在等待队列中的表示
type sudog struct {
    g        *g
    next     *sudog
    prev     *sudog
    elem     unsafe.Pointer
    isSelect bool
    c        *hchan
}

// channel的核心操作流程
func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    // 1. 对hchan.lock加锁
    
    // 2. 检查是否已关闭，已关闭则解锁并panic
    
    // 3. 检查是否有等待的接收者
    if c.recvq.first != nil {
        // 直接发送给接收者，解锁
        send(c, sg, ep, func() { unlock(&c.lock) })
        return true
    }
    
    // 4. 检查缓冲区是否已满
    if c.dataqsiz > 0 && c.qcount < c.dataqsiz {
        // 发送到缓冲区，解锁
        qp := chanbuf(c, c.sendx)
        typedmemmove(c.elemtype, qp, ep)
        c.sendx++
        if c.sendx == c.dataqsiz {
            c.sendx = 0
        }
        c.qcount++
        unlock(&c.lock)
        return true
    }
    
    // 5. 检查是否阻塞
    if !block {
        unlock(&c.lock)
        return false
    }
    
    // 6. 阻塞当前goroutine
    gp := getg()
    mysg := acquireSudog()
    mysg.elem = ep
    mysg.c = c
    gp.waiting = mysg
    c.sendq.enqueue(mysg)
    goparkunlock(&c.lock, waitReasonChanSend, traceEvGoBlockSend, 3)
    
    return true
}

// nil channel 操作
func nilChannel() {
    var ch chan int // nil
    
    // 发送操作：永久阻塞
    go func() {
        ch <- 1
        fmt.Println("send successful") // 永远不会执行
    }()
    
    // 接收操作：永久阻塞
    go func() {
        <-ch
        fmt.Println("receive successful") // 永远不会执行
    }()
    
    // 关闭操作：panic
    // close(ch) // 会导致程序崩溃
}

// 已关闭 channel 操作
func closedChannel() {
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    close(ch)
    
    // 读取操作：正常读取剩余数据
    v1, ok1 := <-ch
    v2, ok2 := <-ch
    v3, ok3 := <-ch
    fmt.Println(v1, ok1) // 1, true
    fmt.Println(v2, ok2) // 2, true
    fmt.Println(v3, ok3) // 0, false
    
    // 发送操作：panic
    // ch <- 3 // 会panic
}

// 面试题1: channel close后读的问题
func channelReadAfterClose() {
    ch := make(chan int)
    close(ch)
    
    v, ok := <-ch
    fmt.Printf("v=%v, ok=%v\n", v, ok) // 0, false
}

// 面试题2: 向为nil的channel发送数据会怎么样？
func sendToNilChannel() {
    var ch chan int
    // ch <- 1 // 永久阻塞，会导致程序死锁
}

// 面试题3: 向关闭的channel发送数据会怎么样？
func sendToClosedChannel() {
    ch := make(chan int)
    close(ch)
    // ch <- 1 // 会panic: send on closed channel
}

// chansend 函数简化版
func sendFlow(c *hchan, value interface{}) bool {
    // 1. 对 channel 加锁
    lock()
    
    // 2. 检查 channel 是否已关闭
    if c.closed > 0 {
        panic("send on closed channel")
    }
    
    // 3. 如果有 goroutine 在等待接收，直接发送
    if !c.recvq.empty() {
        sg := c.recvq.dequeue()
        // 将数据直接发送给接收者的栈空间
        *((*int)(sg.elem)) = value
        // 唤醒接收者
        goready(sg.g, 3)
        unlock()
        return true
    }
    
    // 4. 如果缓冲区未满，写入缓冲区
    if c.qcount < c.dataqsiz {
        // 计算写入位置
        pos := c.sendx
        c.buf[pos] = value
        c.sendx++
        c.qcount++
        unlock()
        return true
    }
    
    // 5. 发送阻塞，将当前 goroutine 加入发送队列
    sg := acquireSudog()
    sg.elem = &value
    sg.c = c
    c.sendq.enqueue(sg)
    // 阻塞当前 goroutine
    gopark()
    
    return true
}