关于golang高并发的实现与注意事项说明

package main
 
import (
 "fmt"
 "time"
)
 
func comFunc() {
 fmt.Println("This is a common function.")
}
 
func main() {
 go comFunc()
 time.Sleep(time.Second * 3)
}

package main
import (
 "fmt"
 "sync"
)
var waitGroup sync.WaitGroup
func Afunction(index int) {
 fmt.Println(index)
 waitGroup.Done() //任务完成，将任务队列中的任务数量-1，其实.Done就是.Add(-1)
}
 
func main() {
 for i := 0; i <10; i++ {
  waitGroup.Add(1) //每创建一个goroutine，就把任务队列中任务的数量+1
  go Afunction(i)
 }
 waitGroup.Wait() //.Wait()这里会发生阻塞，直到队列中所有的任务结束就会解除阻塞
}

package main
func main() {
 ch := make(chan int, 3)
 ch <- 1
 ch <- 1
 ch <- 1
 ch <- 1 //这一行操作就会发生阻塞，因为前三行的放入数据的操作已经把channel填满了
}
package main
func main() {
 ch := make(chan int, 3)
 <-ch //这一行会发生阻塞，因为channel才刚创建，是空的，没有东西可以取出
}

ch := make(chan int)  //无缓冲的channel，同等于make(chan int, 0)
ch := make(chan int, 5) //一个缓冲区大小为5的channel

package main 
import (
 "fmt"
 "sync"
)
 
var waitGroup sync.WaitGroup //使用wg等待所有routine执行完毕，并输出相应的提示信息
 
func AFunc(ch chan int) {
 waitGroup.Add(1)
FLAG:
 for {
  select {
  case val := <-ch:
   fmt.Println(val)
   break FLAG
  }
 }
 waitGroup.Done()
 fmt.Println("WaitGroup Done")
}
 
func main() {
 
 ch := make(chan int) //无缓冲通道
 execMode := 0        //执行模式 0：先启动并发，正常输出100 1：后启动并发，发生死锁
 switch execMode {
 case 0:
  go AFunc(ch)
  ch <- 100
 case 1:
  ch <- 100
  go AFunc(ch)
 }
 waitGroup.Wait()
 close(ch)
}

package main
import (
 "fmt"
 "sync"
)
var waitGroup sync.WaitGroup
func AFunc(ch chan int, putMode int) {
 val := <-ch
 switch putMode {
 case 0:
  fmt.Printf("Vaule=%d\n", val)
 case 1:
  fmt.Printf("Vaule=%d\n", val)
  for i := 1; i <= 5; i++ {
   ch <- i * val
  }
 case 2:
  fmt.Printf("Vaule=%d\n", val)
  for i := 1; i <= 5; i++ {
   <-ch
  }
 }
 
 waitGroup.Done()
 fmt.Println("WaitGroup Done", val)
}
 
func main() {
 ch := make(chan int, 10)
 putMode := 0 //该模式下，能够正常输出所有数据
 //putMode := 1//当放入速度远大于取数速度时，程序阻塞
 //putMode := 2//当取数速度远大于放数速度时，程序阻塞
 for i := 0; i <1000; i++ {
  ch <- i
  waitGroup.Add(1)
  go AFunc(ch, putMode)
 }
 waitGroup.Wait()
 close(ch)
}

package main
func main() {
 ch := make(chan int, 5)
 ch <- 1
 ch <- 1
 close(ch)
 ch <- 1 //不能对关闭的channel执行放入操作
        
        // 会触发panic
}

package main
func main() {
 ch := make(chan int, 5)
 ch <- 1
 ch <- 1
 close(ch)
 <-ch //只要channel还有数据，就可能执行取出操作
 
        //正常结束
}

package main 
import "fmt" 
func main() {
 ch := make(chan int, 5)
 ch <- 1
 ch <- 1
 ch <- 1
 ch <- 1
 close(ch)  //如果执行了close()就立即关闭channel的话，下面的循环就不会有任何输出了
 for {
  data, ok := <-ch
  if !ok {
   break
  }
  fmt.Println(data)
 }
 
 // 输出：
 // 1
 // 1
 // 1
 // 1
 // 
 // 调用了close()后，只有channel为空时，channel才会真的关闭
}