关于GOMAXPROCS，你可以在Go 1.5的发布文档中找到：
默认情况下，Go程序运行时GOMAXPROCS设置为可用的内核数量;在以前的版本中，它默认为1。
关于防止main函数立即退出，您可以利用WaitGroup的Wait函数。
我写了这个实用函数来帮助并行化一组函数：

import "sync"

// Parallelize parallelizes the function calls
func Parallelize(functions ...func()) {
    var waitGroup sync.WaitGroup
    waitGroup.Add(len(functions))

    defer waitGroup.Wait()

    for _, function := range functions {
        go func(f func()) {
            defer waitGroup.Done()
            f()
        }(function)
    }
}

所以在你的情况下，我们可以这样做

func1 := func() {
    f(0)
}

func2 = func() {
    f(1)
}

func3 = func() {
    f(2)
}

Parallelize(func1, func2, func3)

如果你想使用Parallelize函数，你可以在这里找到https://github.com/shomali11/util

这个答案已经过时了。请参见this answer。

您的代码将并发运行，但不是并行运行。您可以通过设置GOMAXPROCS使其并行运行。
目前还不清楚您在这里究竟要实现什么，但在我看来，这是一种实现并发性的非常有效的方法。

f()将同时执行，但许多dowork()将在每个f()中顺序执行。等待stdin也不是确保例程完成执行的正确方法。您必须启动一个通道，当f()完成时，每个f()都将true推入。在main()结束时，您必须在通道上等待n个true。n是你旋转的f()的数量。

这在我刚开始的时候帮助了我。

package main

    import "fmt"

    func put(number chan<- int, count int) {
        i := 0
        for ; i <= (5 * count); i++ {
            number <- i
        }
        number <- -1
    }

    func subs(number chan<- int) {
        i := 10
        for ; i <= 19; i++ {
            number <- i
        }
    }

    func main() {
        channel1 := make(chan int)
        channel2 := make(chan int)
        done := 0
        sum := 0

        go subs(channel2)
        go put(channel1, 1)
        go put(channel1, 2)
        go put(channel1, 3)
        go put(channel1, 4)
        go put(channel1, 5)

        for done != 5 {
            select {
            case elem := <-channel1:
                if elem < 0 {
                    done++
                } else {
                    sum += elem
                    fmt.Println(sum)
                }
            case sub := <-channel2:
                sum -= sub
                fmt.Printf("atimta : %d\n", sub)
                fmt.Println(sum)
            }
        }
        close(channel1)
        close(channel2)
    }

传统的基于集群的系统（如超级计算机）使用MPI在处理器之间进行并行执行。MPI是在不同处理器上的操作系统示例中执行的进程之间的通信接口;它不支持其他进程操作，如调度。（冒着使事情进一步复杂化的风险，因为MPI进程由操作系统执行，所以单个处理器可以运行多个MPI进程和/或单个MPI进程也可以执行多个线程！）”

你可以在最后添加一个循环，阻塞直到任务完成：

package main
import "time"

func f(n int, b chan bool) {
   println(n)
   time.Sleep(time.Second)
   b <- true
}

func main() {
   b := make(chan bool, 9)
   for n := cap(b); n > 0; n-- {
      go f(n, b)
   }
   for <-b {
      if len(b) == 0 { break }
   }
}