package main 
import (
	"fmt"
	"time" //用于时间函数，例如Now()
	"math/rand" //用于伪随机数
)
/* 简单的冒泡排序算法 */
func bubblesort(str string, a []int) []int {
	for n:=len(a); n>1; n-- {
		for i:=0; i<n-1; i++ {
			if a[i] > a[i+1] {
				a[i], a[i+1] = a[i+1], a[i] //交换
			}
		}
	}
    fmt.Println(str+" done") //完成消息
    return a
}
/* 用伪随机数填充切片 */
func random_fill(a []int) []int {
    for i:=0; i<len(a); i++ { 
	    a[i] = rand.Int()
    }
    return a
}
func main() {
   rand.Seed( time.Now().UTC().UnixNano()) //设置随机数种子
   a1 := make([]int, 34589) //创建切片
   a2 := make([]int, 42) //创建切片
   a3 := make([]int, 9999) //创建切片
   a1 = random_fill(a1) //填充切片
   a2 = random_fill(a2) //填充切片
   a3 = random_fill(a3) //填充切片
   fmt.Println("Slices filled ...")
   go bubblesort("Thread 1", a1) //启动第一个协程
   go bubblesort("Thread 2", a2) //启动第二个协程
   go bubblesort("Thread 3", a3) //启动第三个协程
   fmt.Println("Main working ...")
   time.Sleep(1*60*1e9) //等待1分钟以获取“done”消息
}

Slices filled ...
Main working ...
Thread 1 done
Thread 2 done
Thread 3 done

import (
    "fmt"
    "time" //用于时间函数，例如Now()
    "math/rand" //用于伪随机数
    "runtime"
)
...
func main() {
   runtime.GOMAXPROCS(2)
   rand.Seed( time.Now().UTC().UnixNano()) //为rand设置种子
...

Slices filled ...
Main working ...
Thread 2 done
Thread 3 done
Thread 1 done

package main
import (
	"fmt"
	"math/rand"
	"runtime"
	"time"
)
/* 简单的冒泡排序算法 */
func bubblesort(str string, a []int, ch chan []int) {
	for n := len(a); n > 1; n-- {
		for i := 0; i < n-1; i++ {
			if a[i] > a[i+1] {
				a[i], a[i+1] = a[i+1], a[i] //交换
			}
		}
		runtime.Gosched() //在部分工作负载后让出处理器
	}
	fmt.Println(str + " done") //完成消息
	ch <- a
}
/* 使用伪随机数填充切片 */
func random_fill(a []int) []int {
	for i := 0; i < len(a); i++ {
		a[i] = rand.Int()
	}
	return a
}
func main() {
	rand.Seed(time.Now().UTC().UnixNano()) //设置随机数种子
	a1 := make([]int, 34589) //创建切片
	a2 := make([]int, 42)    //创建切片
	a3 := make([]int, 9999)  //创建切片
	a1 = random_fill(a1) //填充切片
	a2 = random_fill(a2) //填充切片
	a3 = random_fill(a3) //填充切片
	fmt.Println("Slices filled ...")
	ch1 := make(chan []int) //创建结果通道
	ch2 := make(chan []int) //创建结果通道
	ch3 := make(chan []int) //创建结果通道
	go bubblesort("Thread 1", a1, ch1) //1. 启动协程
	go bubblesort("Thread 2", a2, ch2) //2. 启动协程
	go bubblesort("Thread 3", a3, ch3) //3. 启动协程
	fmt.Println("Main working ...")
	<-ch1 //等待结果1
	<-ch2 //等待结果2
	<-ch3 //等待结果3
}
输出：
Slices filled ...
Main working ...
Thread 2 done
Thread 3 done
Thread 1 done
我还使用通道实现了我之前评论中建议的会合。
最好的问候 :)
<details>
<summary>英文:</summary>
The important thing is the ability to &quot;yield&quot; the processor to other processes, before the whole potentialy long-running workload is finished. This holds true as well in single-core context or multi-core context (because [Concurrency is not the same as Parallelism][1]).
This is exactly what the [runtime.Gosched()][2] function does :
&gt; Gosched yields the processor, allowing other goroutines to run. It
&gt; does not suspend the current goroutine, so execution resumes
&gt; automatically.
Be aware that a &quot;context switch&quot; is not free : it costs a little time each time.
 - On my machine without yielding, your program runs in 5.1s.
 - If you yield in the outer loop (`for n:=len(a); n&gt;1; n--`), it runs in 5.2s : small overhead.
 - If you yield in the inner loop (`for i:=0; i&lt;n-1; i++`), it runs in 61.7s : huge overhead !!
Here is the modified program correctly yielding, with the small overhead :
    package main
    
    import (
    	&quot;fmt&quot;
    	&quot;math/rand&quot;
    	&quot;runtime&quot;
    	&quot;time&quot;
    )
    
    /* Simple bubblesort algorithm*/
    func bubblesort(str string, a []int, ch chan []int) {
    	for n := len(a); n &gt; 1; n-- {
    		for i := 0; i &lt; n-1; i++ {
    			if a[i] &gt; a[i+1] {
    				a[i], a[i+1] = a[i+1], a[i] //swap
    			}
    		}
    		runtime.Gosched() // yield after part of the workload
    	}
    	fmt.Println(str + &quot; done&quot;) //done message
    	ch &lt;- a
    }
    
    /*fill slice with pseudo numbers*/
    func random_fill(a []int) []int {
    	for i := 0; i &lt; len(a); i++ {
    		a[i] = rand.Int()
    	}
    	return a
    }
    
    func main() {
    	rand.Seed(time.Now().UTC().UnixNano()) //set seed for rand.
    
    	a1 := make([]int, 34589) //create slice
    	a2 := make([]int, 42)    //create slice
    	a3 := make([]int, 9999)  //create slice
    
    	a1 = random_fill(a1) //fill slice
    	a2 = random_fill(a2) //fill slice
    	a3 = random_fill(a3) //fill slice
    	fmt.Println(&quot;Slices filled ...&quot;)
    
    	ch1 := make(chan []int) //create channel of result
    	ch2 := make(chan []int) //create channel of result
    	ch3 := make(chan []int) //create channel of result
    
    	go bubblesort(&quot;Thread 1&quot;, a1, ch1) //1. Routine Start
    	go bubblesort(&quot;Thread 2&quot;, a2, ch2) //2. Routine Start
    	go bubblesort(&quot;Thread 3&quot;, a3, ch3) //3. Routine Start
    	fmt.Println(&quot;Main working ...&quot;)
    
    	&lt;-ch1 // Wait for result 1
    	&lt;-ch2 // Wait for result 2
    	&lt;-ch3 // Wait for result 3
    }
Output :
    Slices filled ...
    Main working ...
    Thread 2 done
    Thread 3 done
    Thread 1 done
I also used channels to implement the rendez-vous, as suggested in my previous comment.
Best regards :)
  [1]: http://blog.golang.org/2013/01/concurrency-is-not-parallelism.html
  [2]: http://golang.org/pkg/runtime/#Gosched
</details>
# 答案3
**得分**: 3
自从Go 1.2发布以来，原始程序现在可能可以正常工作而无需修改。您可以在[Playground][1]中尝试它。
这在[Go 1.2发布说明][2]中有解释：
&gt; 在之前的版本中，一个无限循环的goroutine可能会使同一线程上的其他goroutine饿死，当GOMAXPROCS只提供一个用户线程时，这是一个严重的问题。在Go 1.2中，这部分得到了解决：调度器在进入函数时会偶尔被调用。
  [1]: http://play.golang.org/p/n3Mh86QfiC
  [2]: https://golang.org/doc/go1.2#preemption
<details>
<summary>英文:</summary>
Since the release of Go 1.2, the original program now &lt;s&gt;works&lt;/s&gt; _may work_ fine without modification. You may try it in [Playground][1].
This is explained in the [Go 1.2 release notes][2] :
&gt; In prior releases, a goroutine that was looping forever could starve
&gt; out other goroutines on the same thread, a serious problem when
&gt; GOMAXPROCS provided only one user thread. In Go 1.2, this is partially
&gt; addressed: The scheduler is invoked occasionally upon entry to a
&gt; function.
  [1]: http://play.golang.org/p/n3Mh86QfiC
  [2]: https://golang.org/doc/go1.2#preemption
</details>