简明笔记:Goroutine &channel

简明笔记:Goroutine &channel

f() // call f()；wait for it to return
go f() //create a new goroutine that calls f();don't wait

Goroutine

调用普通函数，等待函数返回值返回。

创建一个goroutine，调用函数，不会等待其函数返回值返回。

package main

import (
   "fmt"
)
func helloworld(){
   fmt.Println("goroutine...")
}

func main() {
   go helloworld() //在函数面前加上关键字Go，创建一个goroutine。
   fmt.Println("执行结束...")
}
输出结果:
执行结束

执行速度很快，这里看不到helloworld()函数的输出，所以验证了我上面所说的。don't wait

package main

import (
   "fmt"
   "time"
)
func fun(){
   for i:=0;i<5;i++{
      time.Sleep(500*time.Millisecond)  // 等待0.5秒
      fmt.Println(i)
   }
}
func main() {
   go fun()
   time.Sleep(1*time.Second)   //  等待1秒
   fmt.Println("执行结束...")
}
输出结果:
0
1
执行结束...

多个goroutine 并行

func fun(){
   for i:=0;i<5;i++{
      time.Sleep(500*time.Millisecond)  // 等待0.5秒
      fmt.Println(i)
   }
}
func run(){
   fmt.Println("run function")
}
func main() {
   go fun()
   go run()
   time.Sleep(2*time.Second)   //  等待2秒
   fmt.Println("执行结束...")
}

输出结果:
run function
0
1
2
执行结束...

通道(channel)

var ch chan int // 声明一个channel 

ch :=make(chan int) //定义一个channel

ch <-value    //向ch写入数据。通常会导致程序阻塞，知道有其它goroutine从这个channel中读取数据
value := <- ch   //读取ch的数据。如果channel之前没有写入数据，那么从channel中读取数据也会导致阻塞，直到channel被写入数据为止。

举个栗子

var ch chan int  	 //定义为全局
func ready(w string){
   time.Sleep(1*time.Second)
   fmt.Println(w,"is ready")
   ch <- 1     //发送1到channel ch
}

func main() {
   ch = make(chan int)
   go ready("Potato")  
   fmt.Println("I'm waiting")
   <-ch

}

输出结果:
I'm waiting
Potato is ready

指定channel(通道)缓存

无指定缓存大小

package main

import (
   "fmt"
   "time"
)


func main() {
	c := make(chan int)
	go send(c)
	go recv(c)
	time.Sleep(3 * time.Second)
	close(c)
}
func send(c chan <- int){
	for i:=0;i<10;i++{
		fmt.Println("发送 >>>",i)
		c <- i
	}
}
func recv(c <-chan int){
	for i:=range c{
		fmt.Println("接收 <<<",i)
	}
}
输出结果:
发送 >>> 0
发送 >>> 1
接收 <<< 0
接收 <<< 1
发送 >>> 2
发送 >>> 3
接收 <<< 2
接收 <<< 3
发送 >>> 4
接收 <<< 4

没有指定缓存的通道，只尊顺一进一出的原则(默认是无缓存,即同步)，

往channel 发送数据后，这个数据如果没有取走，channel是阻塞的，也就是不能继续向channel 里面发送数据。因为上面代码中，我们没有指定channel 缓冲区的大小，默认是阻塞的。

带有缓存的channel

func main() {
   c := make(chan int,10)
   go send(c)
   go recv(c)
   time.Sleep(3 * time.Second)
   close(c)
}
func send(c chan <- int){
   for i:=0;i<5;i++{
      fmt.Println("发送 >>>",i)
      c <- i
   }
}
func recv(c <-chan int){
   for i:=range c{
      fmt.Println("接收 <<<",i)
   }
}
输出:
发送 >>> 0
发送 >>> 1
发送 >>> 2
发送 >>> 3
发送 >>> 4
接收 <<< 0
接收 <<< 1
接收 <<< 2
接收 <<< 3
接收 <<< 4

有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道(即异步)。

通道会阻塞发送和接收动 作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区 容纳被发送的值时，发送动作才会阻塞。

关注公众号:面向奶酪 获取最新文章