Go语言中Goroutine与CPU亲和性：理解与实践

GOMAXPROCS=1 taskset -c 0 ./your_go_program

package main

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

func myLockedGoroutine() {
    runtime.LockOSThread() // 将当前goroutine锁定到OS线程
    defer runtime.UnlockOSThread() // 确保在goroutine退出时解锁

    fmt.Printf("Goroutine %d (OS Thread ID: %d) is locked to its OS thread.\n",
        runtime.GOMAXPROCS(-1), // 获取当前GOMAXPROCS值，此处仅作示例
        // 无法直接获取OS线程ID，但可以确认它被锁定
        // 实际应用中可能需要Cgo调用pthread_self()来获取
        )
    // 在此执行需要线程固定的操作，例如Cgo调用
    time.Sleep(time.Second)
    fmt.Println("Locked goroutine finished.")
}

func main() {
    fmt.Println("Starting main goroutine.")
    go myLockedGoroutine()
    time.Sleep(2 * time.Second) // 等待locked goroutine执行
    fmt.Println("Main goroutine finished.")
}

package main

import (
    "fmt"
    "runtime"
    "time"
    "golang.org/x/sys/unix" // 引入unix包
)

// setCPUAffinity 将当前线程绑定到指定的CPU核心
// cpuID: 要绑定的CPU核心ID (从0开始)
func setCPUAffinity(cpuID int) error {
    var cpuset unix.CPUSet
    cpuset.Set(cpuID) // 设置CPU掩码，只包含指定的cpuID
    // pid=0 表示设置当前线程的亲和性
    return unix.SchedSetaffinity(0, &cpuset)
}

func myCPULockedGoroutine(targetCPU int) {
    runtime.LockOSThread() // 1. 将当前goroutine锁定到OS线程
    defer runtime.UnlockOSThread()

    if err := setCPUAffinity(targetCPU); err != nil { // 2. 将OS线程绑定到指定CPU
        fmt.Printf("Error setting CPU affinity for goroutine on CPU %d: %v\n", targetCPU, err)
        return
    }

    fmt.Printf("Goroutine (OS Thread) is locked to CPU %d.\n", targetCPU)
    // 在此执行需要CPU固定的操作
    time.Sleep(time.Second * 2)
    fmt.Printf("Goroutine on CPU %d finished.\n", targetCPU)
}

func main() {
    fmt.Println("Starting main goroutine.")

    // 启动两个goroutine，分别尝试绑定到不同的CPU核心
    go myCPULockedGoroutine(0) // 尝试绑定到CPU 0
    go myCPULockedGoroutine(1) // 尝试绑定到CPU 1

    time.Sleep(3 * time.Second) // 等待goroutines执行
    fmt.Println("Main goroutine finished.")
}

// affinity.c
#define _GNU_SOURCE
#include <sched.h>
#include <pthread.h>
#include <stdio.h>

void set_thread_affinity_c(int cpu_id) {
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(cpu_id, &cpuset);

    pthread_t current_thread = pthread_self();
    if (pthread_setaffinity_np(current_thread, sizeof(cpu_set_t), &cpuset) != 0) {
        perror("pthread_setaffinity_np failed");
    } else {
        printf("C: Thread %lu locked to CPU %d\n", current_thread, cpu_id);
    }
}

package main

/*
#cgo LDFLAGS: -pthread
#include "affinity.c" // 或者编译为.o文件后链接
*/
import "C"
import (
    "fmt"
    "runtime"
    "time"
)

func myCgoLockedGoroutine(targetCPU int) {
    runtime.LockOSThread()
    defer runtime.UnlockOSThread()

    C.set_thread_affinity_c(C.int(targetCPU))

    fmt.Printf("Go: Goroutine (via Cgo) is locked to CPU %d.\n", targetCPU)
    time.Sleep(time.Second * 2)
    fmt.Printf("Go: Goroutine on CPU %d (via Cgo) finished.\n", targetCPU)
}

func main() {
    fmt.Println("Starting main goroutine.")
    go myCgoLockedGoroutine(0)
    time.Sleep(3 * time.Second)
    fmt.Println("Main goroutine finished.")
}