从而不需要像 C/C++那样手动取得 CPU 数 X， 再开 X 个线程去执行任务？
换句话说，这样的代码在 Go 中是不是完全无意义？
CORE_NUM := runtime.NumCPU() //取得 CPU 数 for i := 0; i < CORE_NUM-1; i++ { //开 CPU-1 个 Goroutine go func() { dojob() } } dojob() //main 自己的 Goroutine 在使用线程实现并发的语言里，像你问题里提到按照内核设置线程数，目的是期望每个线程都跑在一个独立内核上，减少不停进行上下文切换导致的额外开销。而 goroutine 是 go 的 runtime 自己调度的，并且比线程轻量级，带来两个好处：调度开销小和默认内存小。所以 goroutine 不再有之前线程出于性能考虑而带来的数量限制，所以理论上只要内存和 cpu 够强，开多少都行。
总的来说，启动线程考虑数量和内核的关系，是因为可能存在的性能问题带来的限制。而 goroutine 去掉了这个限制。你的问题像是一个之前被约束的人，有了自由后突然之间无所适从了。
如果你开始用 go 了，可以尝试习惯从业务和系统的总体计算力里来考虑并发数量，不用再把数量带来的上下文交换带来的消耗和内存占用放在考虑范围内了。
@sujin190
看下这个简单的 worker pool
”’
package main
import (
“fmt”
“time”
)
//睡 1 秒，然后把收到的数据乘 2 返回
func worker(id int, job <-chan int, ret chan<- int) {
for j := range job {
time.Sleep(time.Second)
ret <- j * 2
}
}
func main() {
//1000 个工作
const JOBNUM = 1000
jobchan := make(chan int, JOBNUM)
retchan := make(chan int, JOBNUM)
//开 1000 个 goroutine
for w := 1; w <= 1000; w++ {
go worker(w, jobchan, retchan)
}
//分发 1000 个工作
for j := 1; j <= JOBNUM; j++ {
jobchan <- j
}
close(jobchan)
//接受结果
for r := 1; r <= JOBNUM; r++ {
<-retchan
}
}
”’
如果说”每个 cpu 核心同时刻只能执行一个计算”
我的电脑有 12 核心。那么按理说我同时只能处理 12 个 goroutine，即 12 个 worker 不是吗
可实际上这 1000 个 goroutine 处理 1000 个工作（睡 1 秒），
总共只用了 1 秒， 说明这 1000 个 goroutine 是同时并行执行的
而不是每次并行处理 12 个，一共要睡（ 1000/12 ）= 83 秒
肯定是我哪里理解不对 望指点
会导致大量线程出现，影响效率。所以有些情况你得限制你的 goroutine 数量。