go语言并发goroutine(七)

1.goroutine基础

goroutine 是go语言实现的核心，实质就是线程，
goroutine 是通过go语言runtime管理的一个线程
管理器，goroutine通过go关键字来实现，其实就
是一个普通的函数

import (
	"fmt"
	"runtime"
)

func say(s string) {
	for i:= 0; i < 5; i++ {
		runtime.Gosched()  //把时间片让给别人
		fmt.Println(s)
	}
}

func main() {
	//runtime.GOMAXPROCS(2) //告诉调度器使用几个线程  
	go say("world")  //开一个新的Goroutines执行
	say("hello")	 //当前Gorutines执行
	say("tod")	
}

2.goroutine channels

goroutine运行在相同的地址空间，因此访问共享内存必须做好同步
go语言提供了一个很好的通信机制channel，channel可以与Unix
shell 中的双向管道做类比，通过它发送或者接收值，这些值只能是
特定的类型：channel类型，定义一个channel时，也需要定义发送到
channel值得类型，注意：必须使用make创建channel
channel通过操作符 “<-” 来接收和发送数据

默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，
这样就使得Goroutinus同步变得简单，而不需要显示的lock，所谓阻塞，
就是如果读取(value := <- ch), 它将会阻塞，直到有数据接收，另外，
任何发送(ch <- value)将会被阻塞，直到数据被读出，无缓冲channel
是在多个goroutine之间同步很好的工具

import "fmt"

func sum(a []int, c chan int) {
	sum := 0
	for _, v := range a {
	 	sum += v
	}
	 
	c <- sum //发送sum值到chann c中
 }

 func main() {
	a := []int{1, 2, 3, 4, 5, 6}
	c := make(chan int)
	go sum(a[:len(a)/2], c)
	go sum(a[len(a)/2:], c)

	x, y := <-c, <-c  //接收chann c的值
	fmt.Println(x, y, x + y)
	fmt.Println("exit")
 }

3.Buffered Channels

channel也可以指定缓冲区的大小
ch := make(chan bool, 4),创建了可以存储4个元素
的bool型channel，在这个channel中，前4个元素可以
无阻塞的写入，当写入第5个元素时，代码将会阻塞，
直到其他goroutine从channel中读取一些元素，腾出空间

import "fmt"

//使用range读取chann buff中的值
func fibonacci(n int, c chan int) {
	x := 0
	for i := 0; i < n; i++ {
		x += 1
		c <- x
	}
	close(c) //关闭chann
}

func main() {
	c := make(chan int, 2)
	c <- 1
	c <- 2
	fmt.Println(<- c)
	fmt.Println(<- c)

	c1 := make(chan int, 10)
	go fibonacci(cap(c1), c1)

	//用range的方式读取chann buff中的值
	for i:= range c1 {
		fmt.Println(i)
	}
}

4.select

当我们使用多个chann的时候可以用select来做监听

import "fmt"

func fibo(c, quit chan int) {
	x, y := 1, 1
	for {
		select {
		case c <- x:
			x = y
			y = x + y
		case <- quit:
			fmt.Println("quit")
			return
		}
	}
}

func main() {
	c := make(chan int)
	quit := make(chan int)

	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println(<-c)
		}
		quit <- 0
	}()
	fibo(c, quit)
}

5.timeout

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan int)
	o := make(chan bool)

	go func() {
		for {
			select {
			case v := <- c:
				fmt.Println(v)
			case <- time.After(5 * time.Second):
				fmt.Println("timeout")
				o <- true
				break
			}
		}
	}()
}