golang prevents the main goroutine from exiting

 //Use wireless loop for{
 }

 for {
    reutrn 
 }
 

var c bool = false
var nums int = 0
for i := 0; i < 3; i++ {
go func() {
("begin------------end")
(10 * )
nums++
if nums == 2 {
c = true
}
}()
}
for {
if c == true {
return
}
}

var c = make(chan bool)
........
.......
<- c

c <- true

var c = make(chan bool)
var nums int = 0
for i := 0; i < 3; i++ {
go func() {
("begin------------")
(10 * )
nums++
if nums == 2 {
c <- true
}
}()
}
<-c

package main 
import (
 "fmt"
 "runtime"
 "time"
)
 
var (
 chanNum   = 3 //The number of startups readChan  = make(chan int)        //The channel of operation information limitChan = make(chan bool, 1000) //Limit the number of goroutine channels, limit 1,000 here)
 
//Initial methodfunc init() {
 ("init")
 
 for i := 0; i < chanNum; i++ {
  go Queue(i, readChan) //Open the working pool }
}
 
func main() {
 ("main")
 
 //Enable a go method and fill data into readChan without limit go func() {
  for {
   readChan <- 1
  }
 }()
 
 //The program exits after listening to the keyboard event var input string
 (&input)
}
 
//Work Poolfunc Queue(qid int, rchan chan int) {
 var dat int
 t := () //Timer, one second for {
  select {
  case d := <-rchan:
   limitChan <- true //The buffer is full and the subsequent readChan will wait   dat += d
   go showNum(qid, dat) //Every time a data is received from the channel, a goroutine is started. LimitChan will limit the number of goroutines.  case <-t:
   showGoNum(qid) //Timer, print the current number of goroutines once a second  }
 }
}
 
func showNum(qid, i int) {
 //After the processing is successful, get a data in the Channel buffer that restricts goroutine, and limitChan can be written again //Use Defer to make sure that a buffer of limitChan is released defer func() {
  <-limitChan
 }()
 ( * 100) //Simulation program processing time consuming //(qid, "===========", i)
}
 
//Show the current goroutine numberfunc showGoNum(qid int) {
 ("%d====numGo:==%d\n", qid, ())
}