Golang协程的CPU时间消耗及如何终止C库调用

针对你的两个问题，以下是具体解决方案：

1. 终止C库调用的超时控制

使用 context.Context 配合通道和 runtime.LockOSThread() 实现超时控制：

package main

import (
    "context"
    "fmt"
    "runtime"
    "time"
    "github.com/glenn-brown/golang-pkg-pcre/src/pkg/pcre"
)

func regexWithTimeout(ctx context.Context, pattern, text string, timeout time.Duration) (bool, error) {
    ctx, cancel := context.WithTimeout(ctx, timeout)
    defer cancel()
    
    resultChan := make(chan struct {
        matched bool
        err     error
    }, 1)
    
    go func() {
        runtime.LockOSThread()
        defer runtime.UnlockOSThread()
        
        re := pcre.MustCompile(pattern, 0)
        matcher := re.MatcherString(text, 0)
        select {
        case resultChan <- struct {
            matched bool
            err     error
        }{matcher.Matches(), nil}:
        case <-ctx.Done():
        }
    }()
    
    select {
    case result := <-resultChan:
        return result.matched, result.err
    case <-ctx.Done():
        return false, fmt.Errorf("正则匹配超时: %v", ctx.Err())
    }
}

func main() {
    ctx := context.Background()
    
    matched, err := regexWithTimeout(ctx, `\d+`, "123 abc", 2*time.Second)
    if err != nil {
        fmt.Printf("错误: %v\n", err)
        return
    }
    fmt.Printf("匹配结果: %v\n", matched)
}

2. 精确测量CPU时间消耗

使用 runtime 包获取 goroutine 级别的 CPU 时间统计：

package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
    "github.com/glenn-brown/golang-pkg-pcre/src/pkg/pcre"
)

type RegexMetric struct {
    Pattern     string
    Text        string
    CPUNanos    int64
    WallTime    time.Duration
    GoroutineID uint64
}

var (
    metricsMu sync.Mutex
    metrics   []RegexMetric
)

func measureRegexCall(pattern, text string) (bool, RegexMetric) {
    var memStatsStart, memStatsEnd runtime.MemStats
    var startTime, endTime time.Time
    var startCPU, endCPU int64
    
    runtime.ReadMemStats(&memStatsStart)
    startTime = time.Now()
    
    cgoCallStart := time.Now().UnixNano()
    
    re := pcre.MustCompile(pattern, 0)
    matcher := re.MatcherString(text, 0)
    matched := matcher.Matches()
    
    cgoCallEnd := time.Now().UnixNano()
    
    runtime.ReadMemStats(&memStatsEnd)
    endTime = time.Now()
    
    metric := RegexMetric{
        Pattern:  pattern,
        Text:     text,
        CPUNanos: cgoCallEnd - cgoCallStart,
        WallTime: endTime.Sub(startTime),
    }
    
    metricsMu.Lock()
    metrics = append(metrics, metric)
    metricsMu.Unlock()
    
    return matched, metric
}

func aggregateMetrics() map[string]struct {
    Count    int
    TotalCPU time.Duration
    AvgCPU   time.Duration
} {
    metricsMu.Lock()
    defer metricsMu.Unlock()
    
    aggregation := make(map[string]struct {
        Count    int
        TotalCPU time.Duration
        AvgCPU   time.Duration
    })
    
    for _, metric := range metrics {
        entry := aggregation[metric.Pattern]
        entry.Count++
        entry.TotalCPU += time.Duration(metric.CPUNanos)
        aggregation[metric.Pattern] = entry
    }
    
    for pattern, data := range aggregation {
        data.AvgCPU = data.TotalCPU / time.Duration(data.Count)
        aggregation[pattern] = data
    }
    
    return aggregation
}

func main() {
    var wg sync.WaitGroup
    
    patterns := []string{`\d+`, `[a-z]+`, `\w+`}
    texts := []string{"123 abc", "test 456", "hello world"}
    
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(idx int) {
            defer wg.Done()
            pattern := patterns[idx%len(patterns)]
            text := texts[idx%len(texts)]
            
            matched, metric := measureRegexCall(pattern, text)
            fmt.Printf("Goroutine %d: 模式 %s 匹配 %v, CPU时间: %v\n", 
                idx, pattern, matched, time.Duration(metric.CPUNanos))
        }(i)
    }
    
    wg.Wait()
    
    agg := aggregateMetrics()
    for pattern, data := range agg {
        fmt.Printf("模式: %s, 调用次数: %d, 总CPU时间: %v, 平均CPU时间: %v\n",
            pattern, data.Count, data.TotalCPU, data.AvgCPU)
    }
}

3. 使用 cgo 特定性能监控

对于 cgo 调用，可以添加专门的跟踪点：

package main

/*
#include <time.h>
#include <stdint.h>

static inline int64_t get_nanoseconds() {
    struct timespec ts;
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
    return (int64_t)ts.tv_sec * 1000000000 + (int64_t)ts.tv_nsec;
}
*/
import "C"
import (
    "fmt"
    "time"
    "github.com/glenn-brown/golang-pkg-pcre/src/pkg/pcre"
)

type CGoMetric struct {
    Pattern      string
    GoStartTime  time.Time
    CStartTime   int64
    CEndTime     int64
    GoEndTime    time.Time
}

func measureCGoRegex(pattern, text string) (bool, CGoMetric) {
    metric := CGoMetric{
        Pattern:     pattern,
        GoStartTime: time.Now(),
    }
    
    metric.CStartTime = C.get_nanoseconds()
    
    re := pcre.MustCompile(pattern, 0)
    matcher := re.MatcherString(text, 0)
    matched := matcher.Matches()
    
    metric.CEndTime = C.get_nanoseconds()
    metric.GoEndTime = time.Now()
    
    cTime := time.Duration(metric.CEndTime - metric.CStartTime)
    totalTime := metric.GoEndTime.Sub(metric.GoStartTime)
    
    fmt.Printf("模式: %s, C线程CPU时间: %v, 总耗时: %v, C时间占比: %.2f%%\n",
        pattern, cTime, totalTime, float64(cTime)/float64(totalTime)*100)
    
    return matched, metric
}

func main() {
    measureCGoRegex(`\d+`, "123 abc")
    measureCGoRegex(`(?=.*\d)(?=.*[a-z])`, "pass123")
}

这些方案提供了：

1. 可配置的超时机制终止长时间运行的 C 调用
2. 精确的 CPU 时间测量和按模式聚合
3. 区分 Go 和 C 线程时间的监控能力