Go面试必问：一道GMP问题，干掉90%的候选人

// 默认值：等于CPU核心数
numP := runtime.NumCPU()

// 查看当前值
fmt.Println(runtime.GOMAXPROCS(0)) // 0表示只查询，不修改

// 手动设置
runtime.GOMAXPROCS(4)

package main

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

func main() {
    // 测试不同GOMAXPROCS对CPU密集型任务的影响
    for _, p := range []int{1, 2, 4, 8, 16} {
        runtime.GOMAXPROCS(p)

        start := time.Now()
        var wg sync.WaitGroup

        for i := 0; i < 1000; i++ {
            wg.Add(1)
            go func() {
                defer wg.Done()
                sum := 0
                for j := 0; j < 1000000; j++ {
                    sum += j
                }
            }()
        }

        wg.Wait()
        fmt.Printf("GOMAXPROCS=%d, 耗时:%v\n", p, time.Since(start))
    }
}

// 4核CPU输出示例：
// GOMAXPROCS=1,  耗时:5.2s
// GOMAXPROCS=2,  耗时:2.6s
// GOMAXPROCS=4,  耗时:1.3s
// GOMAXPROCS=8,  耗时:1.3s   ← 超过核心数无提升
// GOMAXPROCS=16, 耗时:1.4s   ← 切换开销反而增加

func startm(_p_ *p, spinning bool) {
    // 尝试获取空闲的M
    mp := acquirem()
    if mp == nil {
        // 没有空闲M，创建新M
        newm(fn, _p_)
    }
}

// 无缓冲Channel：发送和接收必须同时就绪（同步）
ch := make(chan int)

// 有缓冲Channel：缓冲区未满时发送不阻塞，未空时接收不阻塞（异步）
ch := make(chan int, 10)

type hchan struct {
    qcount   uint           // 当前队列中的元素个数
    dataqsiz uint           // 环形队列大小（缓冲区容量）
    buf      unsafe.Pointer // 环形队列指针
    elemsize uint16         // 元素大小
    closed   uint32         // 是否关闭
    sendx    uint           // 发送索引（下一个写入位置）
    recvx    uint           // 接收索引（下一个读取位置）
    recvq    waitq          // 接收等待队列（阻塞的接收者）
    sendq    waitq          // 发送等待队列（阻塞的发送者）
    lock     mutex          // 互斥锁
}

ch := make(chan int, 2)
ch <- 1
ch <- 2
close(ch)

// ✅ 可以继续接收
v1 := <-ch // v1 = 1
v2 := <-ch // v2 = 2

// ⚠️ 再接收返回零值和false
v3, ok := <-ch // v3 = 0, ok = false

// ❌ 向关闭的Channel发送 → panic
ch <- 3 // panic: send on closed channel

// ❌ 重复关闭 → panic
close(ch) // panic: close of closed channel

// 规则1：只由发送方关闭Channel
// 规则2：使用range遍历，自动检测关闭
for v := range ch {
    process(v)
}

// 规则3：接收时检查是否关闭
v, ok := <-ch
if !ok {
    fmt.Println("Channel已关闭")
}

// 性能对比实验
func benchmarkChannel(bufSize int) {
    ch := make(chan int, bufSize)
    start := time.Now()

    go func() {
        for i := 0; i < 1000000; i++ {
            ch <- i
        }
        close(ch)
    }()

    for range ch {}

    fmt.Printf("缓冲区%d, 耗时:%v\n", bufSize, time.Since(start))
}

// 结果：
// 缓冲区0,     耗时:150ms
// 缓冲区1,     耗时:120ms
// 缓冲区100,   耗时:80ms
// 缓冲区1000,  耗时:75ms
// 缓冲区10000, 耗时:75ms  ← 收益递减

// ❌ 错误：发送方永远阻塞
func leak() {
    ch := make(chan int)
    go func() {
        ch <- 1 // 没有接收者，永远阻塞，Goroutine泄漏
    }()
}

// ✅ 正确：使用超时或Context
func noLeak() {
    ch := make(chan int)
    go func() {
        select {
        case ch <- 1:
            // 发送成功
        case <-time.After(1 * time.Second):
            // 超时退出
        }
    }()
}

// 检测泄漏的测试方法
func TestLeak(t *testing.T) {
    before := runtime.NumGoroutine()

    leak() // 调用可能泄漏的函数

    time.Sleep(1 * time.Second)
    after := runtime.NumGoroutine()

    if after > before {
        t.Errorf("Goroutine泄漏: before=%d, after=%d", before, after)
    }
}

func readWithTimeout(ch <-chan int, timeout time.Duration) (int, error) {
    select {
    case v := <-ch:
        return v, nil
    case <-time.After(timeout):
        return 0, errors.New("timeout")
    }
}

type Mutex struct {
    ch chan struct{}
}

func NewMutex() *Mutex {
    m := &Mutex{ch: make(chan struct{}, 1)}
    m.ch <- struct{}{} // 初始状态：未锁定（有令牌）
    return m
}

func (m *Mutex) Lock() {
    <-m.ch // 获取令牌（阻塞直到可用）
}

func (m *Mutex) Unlock() {
    m.ch <- struct{}{} // 释放令牌
}

type Semaphore struct {
    ch chan struct{}
}

func NewSemaphore(n int) *Semaphore {
    s := &Semaphore{ch: make(chan struct{}, n)}
    for i := 0; i < n; i++ {
        s.ch <- struct{}{}
    }
    return s
}

func (s *Semaphore) Acquire() {
    <-s.ch
}

func (s *Semaphore) Release() {
    s.ch <- struct{}{}
}

// 使用示例：限制并发数为10
sem := NewSemaphore(10)
for i := 0; i < 100; i++ {
    go func() {
        sem.Acquire()
        defer sem.Release()
        doWork()
    }()
}

// Go的混合写屏障（Go 1.8引入）
writePointer(slot, ptr):
    shade(ptr)       // 标记新值为灰色（插入写屏障）
    shade(*slot)     // 标记旧值为灰色（删除写屏障）
    *slot = ptr      // 执行实际的写操作

var m runtime.MemStats
runtime.ReadMemStats(&m)

fmt.Printf("当前堆内存: %v MB\n", m.Alloc / 1024 / 1024)
fmt.Printf("历史分配总量: %v MB\n", m.TotalAlloc / 1024 / 1024)
fmt.Printf("系统内存: %v MB\n", m.Sys / 1024 / 1024)
fmt.Printf("GC次数: %v\n", m.NumGC)
fmt.Printf("GC总暂停时间: %v ms\n", m.PauseTotalNs / 1000000)

import _ "net/http/pprof"

go func() {
    http.ListenAndServe("localhost:6060", nil)
}()

// 访问 http://localhost:6060/debug/pprof/heap
// 或命令行分析：
// go tool pprof http://localhost:6060/debug/pprof/heap

// ❌ 每次循环都分配新对象
for i := 0; i < 1000000; i++ {
    s := fmt.Sprintf("hello%d", i) // 分配string
    process(s)
}

// ✅ 复用buffer
var buf bytes.Buffer
for i := 0; i < 1000000; i++ {
    buf.Reset()
    buf.WriteString("hello")
    buf.WriteString(strconv.Itoa(i))
    process(buf.String())
}

var bufPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func process() {
    buf := bufPool.Get().(*bytes.Buffer)
    defer bufPool.Put(buf)

    buf.Reset()
    buf.WriteString("hello")
    // ...
}

// ❌ 频繁扩容
var results []Result
for _, item := range items {
    results = append(results, process(item))
}

// ✅ 预分配容量
results := make([]Result, 0, len(items))
for _, item := range items {
    results = append(results, process(item))
}

// 查看逃逸分析
// go build -gcflags="-m" main.go

// ❌ 返回局部变量指针，逃逸到堆
func createUser() *User {
    u := User{}     // moved to heap: u
    return &u
}

// ✅ 传入指针参数，避免逃逸
func initUser(u *User) {
    u.Name = "test"
}

// 设置GC触发的堆增长比例
// 默认100（即堆翻倍时触发GC）
// 设置为200表示堆增长到3倍时才触发
debug.SetGCPercent(200)

// 权衡：减少GC频率，但增加内存占用

// 1. 使用sync.Pool复用请求对象
var reqPool = sync.Pool{
    New: func() interface{} {
        return &Request{}
    },
}

// 2. 使用strings.Builder替代+拼接
var builder strings.Builder
builder.WriteString("hello")
builder.WriteString("world")

// 3. 预分配切片容量
results := make([]Result, 0, 100)

// 4. 调大GC百分比
debug.SetGCPercent(200)

// 坑1：无缓冲Channel，发送方永远阻塞
func leak1() {
    ch := make(chan int)
    go func() {
        ch <- 1 // 永远阻塞，因为没有接收方
    }()
}

// 坑2：有缓冲Channel，缓冲区满
func leak2() {
    ch := make(chan int, 1)
    ch <- 1
    go func() {
        ch <- 2 // 永远阻塞，因为缓冲区已满
    }()
}

// 坑3：没有退出条件的死循环
func leak3() {
    go func() {
        for {
            // 忘记添加退出条件
            doSomething()
        }
    }()
}

func noLeak(ctx context.Context) {
    go func() {
        for {
            select {
            case <-ctx.Done():
                return // 收到取消信号，退出
            default:
                doSomething()
            }
        }
    }()
}

// ❌ 并发读写map会panic
m := make(map[int]int)
go func() { m[1] = 1 }()
go func() { m[2] = 2 }()
// fatal error: concurrent map writes

// ✅ 方案1：sync.Map（适合读多写少）
var sm sync.Map
sm.Store(1, 1)
sm.Store(2, 2)
v, ok := sm.Load(1)

// ✅ 方案2：加锁（适合写多的场景）
var mu sync.RWMutex
var m = make(map[int]int)

// 写
mu.Lock()
m[1] = 1
mu.Unlock()

// 读
mu.RLock()
v := m[1]
mu.RUnlock()

ch1 := make(chan int, 1)
ch2 := make(chan int, 1)
ch1 <- 1
ch2 <- 2

select {
case v := <-ch1:
    fmt.Println("ch1:", v)
case v := <-ch2:
    fmt.Println("ch2:", v)
}

// ⚠️ 输出是随机的！可能是ch1，也可能是ch2

// 方案1：嵌套select
select {
case v := <-highPriority:
    process(v)
default:
    select {
    case v := <-highPriority:
        process(v)
    case v := <-lowPriority:
        process(v)
    }
}

// 方案2：分开检查
if len(highPriority) > 0 {
    v := <-highPriority
    process(v)
} else {
    select {
    case v := <-highPriority:
        process(v)
    case v := <-lowPriority:
        process(v)
    }
}