Go语言基础（三）

Concurrency

Goroutines

goroutine是一个轻量级的线程通过Go runtime（运行时）管理

package main

import (
	"fmt"
	"time"
)

func say(s string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}

func main() {
	go say("world")
	say("hello")
}

Channels

Channel是一种有类型的管道，通过它，可以用运算符<-发送和接收数据。
channel是由缓冲区的，缓冲区结构是一个循环列表。

ch <- v    // Send v to channel ch.
v := <-ch  // Receive from ch, and
           // assign value to v.

channel必须在用之前先创建：

ch := make(chan int)

默认情况下，发送和接收阻塞，直到另一方准备好。这允许goroutines同步，而不需要显式的锁或条件变量。

package main

import "fmt"

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // send sum to c
}

func main() {
	s := []int{7, 2, 8, -9, 4, 0}

	c := make(chan int)
	go sum(s[len(s)/2:], c)
	go sum(s[:len(s)/2], c)
	
	x, y := <-c, <-c // receive from c

	fmt.Println(x, y, x+y)
}

Buffer Channels

可以给通道一个长度。

ch := make(chan int, 100)

Range and Close

发送方可以关闭通道，以表示不再发送任何值。接收器可以通过给receive表达式赋值第二个参数来测试通道是否已经关闭

v, ok := <-ch

根据OK的值来判断是否关闭，之应该允许sender关闭通道而不允许receiver关闭。channel不像文件，通常不需要关闭，只有当接收者再也不接收数据了，就可以关闭了。

package main

import (
	"fmt"
)

func fibonacci(n int, c chan int) {
	x, y := 0, 1
	for i := 0; i < n; i++ {
		c <- x
		x, y = y, x+y
	}
	close(c)
}

func main() {
	c := make(chan int, 10)
	go fibonacci(cap(c), c)
	for i := range c {
		fmt.Println(i)
	}
}

Select

select语句允许goroutine等待多个通信操作。select会阻塞直到其中一个用例能运行，然后执行这个用例，多个用例准备好则随机选一个。
select语句只能用来处理通讯操作，它的case可以是send语句或者是receive语句，亦或是default。
就是随机选择一个case进行执行，如果没有default则遇到没法匹配的case就阻塞，有default则在出现没有匹配的case时执行default。

import "fmt"

func fibonacci(c, quit chan int) {
	x, y := 0, 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
	}()
	fibonacci(c, quit)
}

• default case:如果没有用例准备好，就运行default case

sync.Mutex

go允许使用goroutines也就是go的轻量级线程来进行并行处理数据，然而会遇到资源竞争的情况。
sync包提供了Mutexes互斥锁数据结构，可以锁住一个数据区域，使每个时刻只有一个线程能访问对应的数据区域。
信号量，互斥锁

• Lock
• Unlock

package main

import(
	"fmt"
	"time"
	"sync"
)

func isEven(n int) bool{
	return n%2 == 0
}

func main(){
	n := 0
	var m sync.Mutex
	
	go func(){
		m.Lock()
		defer m.Unlock()
		nIsEven := isEven(n)
		time.Sleep(5 * time.Millisecond)
			if nIsEven{
				fmt.Println(n , "is even")
				return
			}
			fmt.Println(n, "is odd")
	}()

	go func(){
		m.Lock()
		n++
		m.Unlock()
	}()
	
	time.Sleep(time.Second)
	
}

package main

import (
	"fmt"
	"sync"
	"time"
)

// SafeCounter is safe to use concurrently.
type SafeCounter struct {
	mu sync.Mutex
	v  map[string]int
}

// Inc increments the counter for the given key.
func (c *SafeCounter) Inc(key string) {
	c.mu.Lock()
	// Lock so only one goroutine at a time can access the map c.v.
	c.v[key]++
	c.mu.Unlock()
}

// Value returns the current value of the counter for the given key.
func (c *SafeCounter) Value(key string) int {
	c.mu.Lock()
	// Lock so only one goroutine at a time can access the map c.v.
	defer c.mu.Unlock()
	return c.v[key]
}

func main() {
	c := SafeCounter{v: make(map[string]int)}
	for i := 0; i < 1000; i++ {
		go c.Inc("somekey")
	}

	time.Sleep(time.Second)
	fmt.Println(c.Value("somekey"))
}