这个问题是因为golang运行时最大进行中线程数限制在10000个。

可以用创建线程池的方式限制同时运行的线程数量。

比如，带有缓冲的channel。

func doThing(d interface{}){
    // 一些业务逻辑
}
func main() {
    var data [1000]int // 假设有1000   
    poolSize := runtime.NumCPU() // 获取cpu核sem := make(chan struct{}, poolSize)
    for _, d := range data {
        sem <- struct{}{}
        go func(d int){
            doThing(d)
            <-sem
        }(d)
    }
}

以上示例中，sem<- struct{}{}操作，在sem通道满的时候会暂停等待空出，因此保证里go func(d int)同时只有poolSize个。

import (
    "context"
    "golang.org/x/sync/semaphore"
)

func doThing(d interface{}){
    // 一些操作
}

func main() {
    data := [1000]int // 假设有1000个poolSize := runtime.NumCPU() // 获取cpu数核量sem := semaphore.NewWeighted(poolSize)
    for _, d := range data {
        sem.Acquire(context.Background(), 1) // 获取1个锁go func(d interface{}){
            doThing(d)
            sem.Release(1) // 释放1个锁
        }(d)
    }
}

以上示例基本思路与上一个channel缓冲示例一样，通过获取池子中的锁来控制并发数量。

在Go语言中，runtime.GC()函数用于启动垃圾回收器。垃圾回收是自动管理计算机程序中的内存的过程，它释放了不再被程序使用的内存空间，以便其他程序可以使用这些内存空间。

runtime.GC()函数会触发一次显式的垃圾回收。这意味着它会立即释放未被引用的内存，并回收这些内存供其他用途。这有助于保持程序中的内存使用量在一个可管理的水平，并避免了内存泄漏问题。

使用runtime.GC()函数应该谨慎，因为垃圾回收会暂停程序的执行，这可能会对性能产生一些影响。因此，在大多数情况下，应该让Go运行时系统的垃圾回收器自动运行，而不是显式地调用runtime.GC()。可以使用Go语言内置的内存管理机制来控制内存分配和释放，从而最大限度地减少需要显式调用垃圾回收的情况。

以下是一个示例，展示了如何使用runtime.GC()函数：

gopackage main

import (
 "fmt"
 "runtime"
)

func main() {
 // 分配内存
 go func() {
 for i := 0; i < 100000; i++ {
 fmt.Println(i) // 释放内存
 }
 }()

 // 等待一段时间以让内存被分配和释放
 runtime.Gosched()

 // 显式触发垃圾回收
 runtime.GC()
}

在上述示例中，通过启动一个goroutine来分配和释放内存。使用runtime.Gosched()函数暂停当前goroutine的执行一段时间，以便内存分配和释放得以发生。然后，调用runtime.GC()函数显式触发垃圾回收，以释放这些内存。

需要注意的是，通常情况下不需要显式调用runtime.GC()。Go运行时系统会自动进行垃圾回收，以保持内存管理的效率和性能。

runtime.Gosched()函数在Go语言中用于暂停当前goroutine的执行，并将时间片调度器重新调度给其他等待的goroutine。

具体来说，runtime.Gosched()会释放处理器给其他goroutine，直到下一个调度器时间片结束。这使得其他goroutine有机会运行并完成其任务。当这个函数被调用时，当前的goroutine会被挂起，并让出处理器给其他的goroutine。当调度器的时间片结束后，当前的goroutine会被唤醒并从挂起的位置继续执行。

这个函数通常在需要让出控制权，让其他goroutine有机会运行的情况下使用。例如，当goroutine执行一项任务，这项任务是计算密集型的，或者需要执行很长时间，这时就可以用runtime.Gosched()让其他goroutine有机会运行。

需要注意的是，runtime.Gosched()并不会保证一定会让出处理器给其他goroutine，因为调度器的行为取决于具体的实现和系统环境。但是，这个函数提供了一种机制，使得goroutine可以主动让出处理器，从而增加了并发编程的灵活性。