Go语言中Goroutine与CPU亲和性：深度解析与实践

# 示例：将Go程序绑定到CPU核心0
GOMAXPROCS=1 taskset -c 0 ./your_go_program

package main

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

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    runtime.LockOSThread() // 将当前Goroutine锁定到OS线程
    defer runtime.UnlockOSThread()

    fmt.Printf("Goroutine %d locked to OS thread. OS Thread ID (conceptually): %d\n", id, getOSThreadID())
    // 模拟一些工作
    time.Sleep(100 * time.Millisecond)
}

// 辅助函数：尝试获取OS线程ID (平台相关，此处为示意)
func getOSThreadID() int {
    // 在Linux上，可以通过CGO调用syscall.Gettid()获取线程ID
    // 但此处为简化，仅作概念性展示
    return 0 // 实际应用中需要通过系统调用获取
}

func main() {
    var wg sync.WaitGroup
    numWorkers := 2

    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()
    fmt.Println("All workers finished.")
}

package main

import (
    "fmt"
    "log"
    "runtime"
    "sync"
    "syscall"
    "time"
    "unsafe"

    "golang.org/x/sys/unix"
)

// setCPUAffinity 将当前OS线程绑定到指定的CPU核心
func setCPUAffinity(cpuID int) error {
    // 创建一个CPU集合，并设置指定的CPU
    var cpuset unix.CPUSet
    cpuset.Set(cpuID)

    // SchedSetaffinity(pid, cpusetsize, cpuset)
    // pid为0表示当前线程
    // cpusetsize为sizeof(cpuset)
    // cpuset为CPU集合
    err := unix.SchedSetaffinity(0, unsafe.Sizeof(cpuset), &cpuset)
    if err != nil {
        return fmt.Errorf("failed to set CPU affinity to %d: %w", cpuID, err)
    }
    return nil
}

func workerWithCPUBinding(id int, targetCPU int, wg *sync.WaitGroup) {
    defer wg.Done()

    runtime.LockOSThread() // 1. 将当前Goroutine锁定到OS线程
    defer runtime.UnlockOSThread()

    // 2. 将当前OS线程绑定到指定的CPU
    err := setCPUAffinity(targetCPU)
    if err != nil {
        log.Printf("Goroutine %d: Error setting CPU affinity: %v", id, err)
        return
    }

    // 获取当前OS线程ID (tid)
    tid := syscall.Gettid()
    fmt.Printf("Goroutine %d (OS Thread %d) successfully locked to CPU %d\n", id, tid, targetCPU)

    // 模拟一些工作
    for i := 0; i < 5; i++ {
        // 在这里执行对CPU亲和性敏感的工作
        time.Sleep(50 * time.Millisecond)
    }
    fmt.Printf("Goroutine %d (OS Thread %d) on CPU %d finished.\n", id, tid, targetCPU)
}

func main() {
    // 确保GOMAXPROCS大于1，以便有多个OS线程可供调度
    // 否则，即使LockOSThread，也可能因为只有一个OS线程而无法看到效果
    // runtime.GOMAXPROCS(runtime.NumCPU()) // 确保使用所有CPU

    var wg sync.WaitGroup
    numWorkers := 2 // 启动两个Goroutine

    // 尝试将第一个Goroutine绑定到CPU 0，第二个绑定到CPU 1
    // 请确保你的系统有至少两个可用的CPU核心
    targetCPUs := []int{0, 1} 

    if runtime.NumCPU() < len(targetCPUs) {
        log.Fatalf("System has only %d CPUs, but trying to bind to %d CPUs. Please adjust targetCPUs.", runtime.NumCPU(), len(targetCPUs))
    }

    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go workerWithCPUBinding(i, targetCPUs[i], &wg)
    }

    wg.Wait()
    fmt.Println("All CPU-bound workers finished.")
}

package main

/*
#define _GNU_SOURCE
#include <sched.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

// set_pthread_affinity attempts to set the affinity of the current thread
// to the specified CPU. Returns 0 on success, non-zero on error.
int set_pthread_affinity(int cpu_id) {
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(cpu_id, &cpuset);

    // pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
    // 0 on success, non-zero on error
    return pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
}
*/
import "C"
import (
    "fmt"
    "log"
    "runtime"
    "sync"
    "time"
)

func workerWithCGOAffinity(id int, targetCPU int, wg *sync.WaitGroup) {
    defer wg.Done()

    runtime.LockOSThread() // 1. 锁定Goroutine到OS线程
    defer runtime.UnlockOSThread()

    // 2. 通过CGO调用C函数设置OS线程的CPU亲和性
    ret := C.set_pthread_affinity(C.int(targetCPU))
    if ret != 0 {
        log.Printf("Goroutine %d: Failed to set pthread affinity to CPU %d, error code: %d", id, targetCPU, ret)
        return
    }

    fmt.Printf("Goroutine %d (locked to OS thread) successfully bound to CPU %d via CGO.\n", id, targetCPU)

    // 模拟一些工作
    time.Sleep(100 * time.Millisecond)
    fmt.Printf("Goroutine %d on CPU %d finished.\n", id, targetCPU)
}

func main() {
    var wg sync.WaitGroup
    numWorkers := 2
    targetCPUs := []int{0, 1}

    if runtime.NumCPU() < len(targetCPUs) {
        log.Fatalf("System has only %d CPUs, but trying to bind to %d CPUs. Please adjust targetCPUs.", runtime.NumCPU(), len(targetCPUs))
    }

    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go workerWithCGOAffinity(i, targetCPUs[i], &wg)
    }

    wg.Wait()
    fmt.Println("All CGO-bound workers finished.")
}