加 Golang学习 QQ群共同学习进步成家立业工作 ^-^ 群号：96933959
Go语言的主要的功能在于令人简易使用的并行设计，这个方法叫做Goroutine，通过Goroutine能够让你的程序以异步的方式运行，而不需要担心一个函数导致程序中断，因此Go语言也非常地适合网络服务。
我们通过go让其中一个函数同步运行，如此就不需要等待该函数运行完后才能运行下一个函数。
func main() { // 通过 `go`，我们可以把这个函数异步执行，这样就不会阻塞往下执行。 go loop() // 执行 Other }
Goroutine是类似线程的概念（但Goroutine并不是线程）。线程属于系统层面，通常来说创建一个新的线程会消耗较多的资源且管理不易。而 Goroutine就像轻量级的线程，但我们称其为并发，一个Go程序可以运行超过数万个 Goroutine，并且这些性能都是原生级的，随时都能够关闭、结束。一个核心里面可以有多个Goroutine，通过GOMAXPROCS参数你能够限制Gorotuine可以占用几个系统线程来避免失控。
在内置的官方包中也不时能够看见Goroutine的应用，像是net/http中用来监听网络服务的函数实际上是创建一个不断运行循环的Goroutine。
GOMAXPROCS 在调度程序优化后会去掉，默认用系统所有资源。
func main() { num := runtime.NumCPU() //本地机器的逻辑CPU个数 runtime.GOMAXPROCS(num) //设置可同时执行的最大CPU数，并返回先前的设置 fmt.Println(num) }
应用场景，如果某个goroutine panic了，而且这个goroutine里面没有捕获(recover)，那么整个进程就会挂掉。所以，好的习惯是每当go产生一个goroutine，就需要写下recover。
var ( domainSyncChan = make(chan int, 10) ) func domainPut(num int) { defer func() { err := recover() if err != nil { fmt.Println("error to chan put.") } }() domainSyncChan <- num panic("error....") } func main() { for i := 0; i < 10; i++ { domainName := i go domainPut(domainName) } time.Sleep(time.Second * 2) }
package main import ( "fmt" "sync" "time" ) var ( m = make(map[int]uint64) lock sync.Mutex //申明一个互斥锁 ) type task struct { n int } func calc(t *task) { defer func() { err := recover() if err != nil { fmt.Println("error...") return } }() var sum uint64 sum = 1 for i := 1; i < t.n; i++ { sum *= uint64(i) } lock.Lock() //写全局数据加互斥锁 m[t.n] = sum lock.Unlock() //解锁 } func main() { for i := 0; i < 10; i++ { t := &task{n: i} go calc(t) // Goroutine来执行任务 } time.Sleep(time.Second) // Goroutine异步，所以等一秒到任务完成 lock.Lock() //读全局数据加锁 for k, v := range m { fmt.Printf("%d! = %v\n", k, v) } fmt.Println(len(m)) lock.Unlock() //解锁 }
channel，管道、队列，先进先出，用来异步传递数据。channel加上goroutine，就形成了一种既简单又强大的请求处理模型，使高并发和线程同步之间代码的编写变得异常简单。
线程安全，多个goroutine同时访问，不需要加锁。
channel是有类型的，一个整数的channel只能存放整数。
//chan申明 var userChan chan interface{} // chan里面放interface类型 userChan = make(chan interface{}, 10) // make初始化，大小为10 var readOnlyChan <-chan int // 只读chan var writeOnlyChan chan<- int // 只写chan
//chan放取数据 userChan <- "nick" name := <- userChan name, ok := <- userChan
//关闭chan intChan := make(chan int, 1) intChan <- 9 close(intChan)
// range chan intChan := make(chan int, 10) for i := 0; i < 10; i++ { intChan <- i } close(intChan) for v := range intChan { fmt.Println(v) }
userChan := make(chan interface{}) userChan <- "nick" // 错误！fatal error: all goroutines are asleep - deadlock! // 开启race会一直阻塞
开启一个goroutine来放入初始化未指定大小的chan不会报错。
即放即走，在等放入时有来拿数据的，就直接拿走。
userChan := make(chan interface{}) go func() { userChan <- "nick" }() name := <- userChan
userChan := make(chan interface{}) go func() { for { userChan <- "nick" } }() for { name := <- userChan fmt.Println(name) time.Sleep(time.Millisecond) }
关闭chan后再放入数据会 panic: send on closed channel。
chan不关闭取超数据的情况会报 deadlock
func main() { intChan := make(chan int, 10) for i := 0; i < 10; i++ { intChan <- i } for { //十次后 fatal error: all goroutines are asleep - deadlock! i := <- intChan fmt.Println(i) time.Sleep(time.Second) } }
chan关闭的情况取超出值为类型默认值，如int为0
func main() { intChan := make(chan int, 10) for i := 0; i < 10; i++ { intChan <- i } close(intChan) for { i := <- intChan //十次后i值都为0，不报错 time.Sleep(time.Second) fmt.Println(i) } }
判断chan是否取完
func main() { intChan := make(chan int, 10) for i := 0; i < 10; i++ { intChan <- i } close(intChan) for { i, ok := <- intChan if !ok { fmt.Println("channel is close.") return } fmt.Println(i) } }
func sendData(ch chan<- string) { ch <- "go" ch <- "java" ch <- "c" ch <- "c++" ch <- "python" close(ch) } func getData(ch <-chan string, chColse chan bool) { for { str, ok := <-ch if !ok { fmt.Println("chan is close.") break } fmt.Println(str) } chColse <- true } func main() { ch := make(chan string, 10) chColse := make(chan bool, 1) go sendData(ch) go getData(ch, chColse) <-chColse close(chColse) }
type user struct { Name string } func main() { userChan := make(chan interface{}, 1) u := user{Name: "nick"} userChan <- &u close(userChan) var u1 interface{} u1 = <-userChan var u2 *user u2, ok := u1.(*user) if !ok { fmt.Println("cant not convert.") return } fmt.Println(u2) }
利用select来处理chan超时。
for { select { case v := <-chan1: fmt.Println(v) case v := <-chan2: fmt.Println(v) default: time.Sleep(time.Second) fmt.Println("timeout...") } }
time.After()定时器来做处理。
在time.After()计时器触发之前，底层计时器不会被垃圾收集器回收。
select { case m := <-c: handle(m) case <-time.After(5 * time.Minute): fmt.Println("timed out") }
t := time.NewTicker(time.Second) fmt.Println(t) for v := range t.C { fmt.Println(v) } t.Stop()定时器栗子
多个goroutine处理任务；
等待一组channel的返回结果。
func calc(taskChan, resChan chan int, exitChan chan bool) { defer func() { err := recover() if err != nil { fmt.Println("error...") return } }() for v := range taskChan { // 任务处理逻辑 flag := true for i := 2; i < v; i++ { if v%i == 0 { flag = false break } } if flag { //结果进chan resChan <- v } } //处理完进退出chan exitChan <- true } func main() { //任务chan intChan := make(chan int, 1000) //结果chan resChan := make(chan int, 1000) //退出chan exitChan := make(chan bool, 8) go func() { for i := 0; i < 1000; i++ { intChan <- i } close(intChan) }() //启动8个goroutine做任务 for i := 0; i < 8; i++ { go calc(intChan, resChan, exitChan) } go func() { //等所有goroutine结束 for i := 0; i < 8; i++ { <-exitChan } close(resChan) close(exitChan) }() for v := range resChan { fmt.Println(v) } }
等待一组channel的返回结果 sync.WaitGroup 的解决方法。
WaitGroup用于等待一组线程的结束。父线程调用Add方法来设定应等待的线程的数量。每个被等待的线程在结束时应调用Done方法。同时，主线程里可以调用Wait方法阻塞至所有线程结束。
func merge(cs <-chan int) <-chan int { var wg sync.WaitGroup out := make(chan int) output := func(c <-chan int) { for n := range c { out <- n } wg.Done() } wg.Add(len(cs)) for _, c := range cs { go output(c) } go func() { wg.Wait() close(out) }() return out }
相关文章
