Golang中多个线程和多个协程的使用区别小结

// CGO示例：创建POSIX线程
/*
#include <pthread.h>
void* thread_func(void* arg) {
    // 线程逻辑
    return NULL;
}
*/
import "C"

func main() {
    var thread C.pthread_t
    C.pthread_create(&thread, nil, (*[0]byte)(C.thread_func), nil)
    C.pthread_join(thread, nil)
}

func main() {
    // 启动百万协程
    for i := 0; i < 1_000_000; i++ {
        go func(id int) {
            // 协程逻辑
            time.Sleep(time.Second)
        }(i)
    }
    time.Sleep(2 * time.Second)
}

var counter int
var mu sync.Mutex

func threadFunc() {
    mu.Lock()
    counter++ // 临界区操作
    mu.Unlock()
}

ch := make(chan int, 10)

// 生产者
go func() {
    for i := 0; i < 100; i++ {
        ch <- i // 发送数据
    }
    close(ch)
}()

// 消费者
go func() {
    for n := range ch {
        fmt.Println(n) // 接收数据
    }
}()

// C线程示例
void* thread_func(void* arg) {
    if (error) {
        return (void*)-1; // 错误传递困难
    }
    return NULL;
}

func worker(errCh chan error) {
    defer func() {
        if r := recover(); r != nil {
            errCh <- fmt.Errorf("panic: %v", r)
        }
    }()
    
    if err := doWork(); err != nil {
        errCh <- err
    }
}

func main() {
    errCh := make(chan error, 10)
    go worker(errCh)
    
    select {
    case err := <-errCh:
        log.Fatal("Worker failed:", err)
    }
}

// Java线程池
ExecutorService pool = Executors.newFixedThreadPool(200);
for (Request req : requests) {
    pool.submit(() -> {
        processRequest(req); // 最大并发200
    });
}

func handleRequest(w http.ResponseWriter, r *http.Request) {
    // 每个请求独立协程
    go process(r) 
}

func main() {
    http.HandleFunc("/", handleRequest)
    http.ListenAndServe(":8080", nil) // 轻松支持10万并发
}

# Python线程
threads = []
for data in big_dataset:
    t = threading.Thread(target=process, args=(data,))
    t.start()
    threads.append(t)
    
for t in threads:
    t.join() # 创建数千线程即崩溃

// Go协程+工作池
func worker(dataCh chan Data, wg *sync.WaitGroup) {
    defer wg.Done()
    for data := range dataCh {
        process(data)
    }
}

func main() {
    dataCh := make(chan Data, 1000)
    var wg sync.WaitGroup
    
    // 启动100个工作者协程
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go worker(dataCh, &wg)
    }
    
    // 发送数据
    for _, data := range bigDataset {
        dataCh <- data
    }
    close(dataCh)
    wg.Wait()
}

// 使用信号量控制
sem := make(chan struct{}, 1000) // 最大1000并发

for _, task := range tasks {
    sem <- struct{}{} // 获取信号
    go func(t Task) {
        defer func() { <-sem }() // 释放信号
        process(t)
    }(task)
}

func runService(ctx context.Context) {
    for {
        select {
        case <-ctx.Done(): // 监听取消
            cleanup()
            return
        case data := <-inputCh:
            process(data)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go runService(ctx)
    
    // 需要停止时
    cancel() // 安全停止协程
}

func worker(id int, errCh chan error) {
    if err := doWork(); err != nil {
        errCh <- fmt.Errorf("worker %d: %w", id, err)
    }
}

func main() {
    errCh := make(chan error, 10)
    for i := 0; i < 10; i++ {
        go worker(i, errCh)
    }
    
    // 收集错误
    for i := 0; i < 10; i++ {
        if err := <-errCh; err != nil {
            log.Println("Error:", err)
        }
    }
}

// CGO调用原生线程
/*
#include <math.h>
void heavyCompute() {
    // 密集计算
    for (int i=0; i<1000000; i++) {
        sqrt(i);
    }
}
*/
import "C"

func main() {
    // 使用真实线程避免调度延迟
    C.heavyCompute()
}

// 绕过Go调度器
func rawSyscall() {
    // 直接系统调用
    _, _, errno := syscall.Syscall(
        syscall.SYS_GETPID, 
        0, 0, 0,
    )
    // ...
}

// 创建专用线程
/*
static void* thread_entry(void* arg) {
    // 长期运行的C线程
    return NULL;
}
*/
import "C"

func main() {
    var t C.pthread_t
    C.pthread_create(&t, nil, C.thread_entry, nil)
}