Go_并发编程

gorouting

goroutine是Go语言中的轻量级线程实现，由Go运行时（runtime）管理。

package main

import (
	"fmt"
)

func main() {
	go Add(1, 1)
}

func Add(x, y int) {
z := x + y
fmt.Println(z)
}

　　在一个函数调用前加上 go 关键字，这次调用就会在一个新的goroutine中并发执行。当被调用的函数返回时，这个goroutine也自动结束了。需要注意的是，如果这个函数有返回值，那么这个返回值会被丢弃

通信

传统方式: 共享数据加锁

package main
import "fmt"
import "sync"
import "runtime"
var counter int = 0
func Count(lock *sync.Mutex) {
	lock.Lock()
	counter++
	fmt.Println(counter)
	lock.Unlock()
}
func main() {
	lock := &sync.Mutex{}
	for i := 0; i < 10; i++ {
		go Count(lock)
	}
	for {
		lock.Lock()
		c := counter
		lock.Unlock()
		runtime.Gosched()
		if c >= 10 {
			break
		}
	}
}

　　Go语言提供的是另一种通信模型，即以消息机制而非共享内存作为通信方式.

消息机制认为每个并发单元是自包含的、独立的个体，并且都有自己的变量，但在不同并发单元间这些变量不共享。每个并发单元的输入和输出只有一种，那就是消息。这有点类似于进程的概念，每个进程不会被其他进程打扰，它只做好自己的工作就可以了。不同进程间靠消息来通信，它们不会共享内存。

　　channel是Go语言在语言级别提供的goroutine间的通信方式。我们可以使用channel在两个或多个goroutine之间传递消息。channel是进程内的通信方式，因此通过channel传递对象的过程和调用函数时的参数传递行为比较一致，比如也可以传递指针等。

channel

特点

• 类似unix中的管道先进先出
• 线程安全, 多个goroutine同时访问,不需要加锁
• channel是有类型的, 一个整数的channel只能存放整数

声明

// var 变量名 chan 类型
// 比如下面的数字类型的示例
func main() {
	var intChan chan int
	intChan = make(chan int, 10)
	intChan <- 10
}

操作

// 初始化
intChan = make(chan int, 10)
// 存值
intChan <- 10
// 取值 
a := <- intChan

示例

package main

import "fmt"

type student struct {
	name string
}


func main() {
	var stuChan chan interface{}
	stuChan = make(chan interface{}, 10)
	stu := student{name:"stu1"}
	stuChan <- &stu

	var stu1 interface{}
	stu1 = <- stuChan
	var stu2 *student
	stu2, ok := stu1.(*student) // 接口转类型
	if !ok{
		fmt.Println("can not convert")
		return
	}
	fmt.Println("stu2",stu2)
}

阻塞: 取不到元素会等待, 放不进去也会等待

package main
import(
	"time"
	"fmt"
)
func main(){
	var ch chan int
	ch = make(chan int, 10)
	func (ch chan int){
		time.Sleep(2*time.Second)
		ch <- 10
	}(ch)
	a := <- ch
	fmt.Println(a)
}

关闭一个channel, 使其只能进行读操作,且读完后不会阻塞

// 关闭一个channel(只能读,不能写), 以及判断是否关闭
func main(){
	var ch chan int
	ch = make(chan int, 10)
	for i:=0; i<10; i++{
		ch <- i
	}
	close(ch) // 关闭
	for{
		var b int
		b,ok := <-ch
		if ok ==false{
			fmt.Println("chan is close")
			break
		}
		fmt.Println(b)
	}
}

循环一个channel

func main(){
    var ch chan int
    ch = make(chan int, 10)
    for i:=0; i<10; i++{
        ch <- i
    }
    close(ch)
    for v:= range ch{
        fmt.Println(v)
    }
}

通过channel阻塞的特性, 我们可以通过channel来等待gorouting结束

package main

import (
	"fmt"
)

func calc(taskChan chan int, resChan chan int,exitChan chan bool){
	for v := range taskChan{
		flag := true
		for i:=2; i<v; i++{
			if v%i == 0{
				flag = false
				break
			}
		}
		if flag{
			resChan <- v
		}
	}
	fmt.Println("exit")
	exitChan <- true // 计算结束后将一个结果放入已完成的channel中
}

func main() {
	intChan := make(chan int, 1000)
	resChan := make(chan int, 1000)
	exitChan := make(chan bool, 8)
	go func(){
		for i:= 0;i<10000 ;i++{
			intChan <- i
		}
		close(intChan)
	}() // 将数字全部放入一个channel


	for i:= 0; i<8; i++{
		go calc(intChan, resChan, exitChan)
	} // 开启8个gorouting去计算

	// 等待所有计算的gorouting全部退出
	go func(){
		for i:= 0; i<8; i++{
			<- exitChan // 阻塞等待完成
		}
		close(resChan)
	}()

	for v:= range resChan{
		fmt.Println(v)
	}
}

select语法

select 的用法与 switch 语言非常类似，由 select 开始一个新的选择块，每个选择条件由case 语句来描述。与 switch 语句可以选择任何可使用相等比较的条件相比， select 有比较多的限制，其中最大的一条限制就是每个 case 语句里必须是一个IO操作，大致的结构如下：

select {
    case <-chan1:
    // 如果chan1成功读到数据，则进行该case处理语句
    case chan2 <- 1:
    // 如果成功向chan2写入数据，则进行该case处理语句
    default:
    // 如果上面都没有成功，则进入default处理流程
}

　　可以看出， select 不像 switch ，后面并不带判断条件，而是直接去查看 case 语句。每个case 语句都必须是一个面向channel的操作。

基于此功能可以实现跳过阻塞

func main(){
    car ch chan int
    ch = make(chan int, 10)
    
    for i:=0; i<10; i++{
        ch <-i
    }
    
    for{
        select{
            case v:= <-ch
                fmt.Println(v)
            default:
                fmt.Println("get data timeout")
                time.Sleep(time.Second)
        }
    }
}

　　如果channel去不到值就会执行默认操作, 也可以接多个IO操作

超时机制

Go语言没有提供直接的超时处理机制，但我们可以利用 select 机制。虽然 select 机制不是专为超时而设计的，却能很方便地解决超时问题。因为 select 的特点是只要其中一个 case 已经完成，程序就会继续往下执行，而不会考虑其他 case 的情况。

func main(){
    car ch chan int
    ch = make(chan int, 10)
    
    for i:=0; i<10; i++{
        ch <-i
    }
    
    for{
        // 首先，我们实现并执行一个匿名的超时等待函数
        timeout := make(chan bool, 1)
        go func() {
            time.Sleep(1e9) // 等待1秒钟
            timeout <- true
        }()
        // 然后我们把timeout这个channel利用起来
        select{
            case v:= <-ch
                fmt.Println(v)
            case <-timeout
                // 一直没有从ch中读取到数据，但从timeout中读取到了数据
            default:
                fmt.Println("get data timeout")
                time.Sleep(time.Second)
        }
    }
}    

单向channel

顾名思义，单向channel只能用于发送或者接收数据。channel本身必然是同时支持读写的，否则根本没法用。假如一个channel真的只能读，那么肯定只会是空的，因为你没机会往里面写数据。同理，如果一个channel只允许写，即使写进去了，也没有丝毫意义，因为没有机会读取里面的数据。所谓的单向channel概念，其实只是对channel的一种使用限制。

我们在将一个channel变量传递到一个函数时，可以通过将其指定为单向channel变量，从而限制该函数中可以对此channel的操作，比如只能往这个channel写，或者只能从这个channel读。

单向channel变量的声明非常简单，如下：

var ch1 chan int  // ch1是一个正常的channel，不是单向的
var ch2 chan<- float64// ch2是单向channel，只用于写float64数据
var ch3 <-chan int  // ch3是单向channel，只用于读取int数据

限制操作

func Parse(ch <-chan int) {
    for value := range ch {
        fmt.Println("Parsing value", value)
    }
}

同步锁

互斥锁 : 只有一个线程能够执行加锁代码

var lock sync.Mutex
func main(){

    for i := 0; i < 2; i++ {
        go func(b map[int]int) {
            lock.Lock()
            b[8] = rand.Intn(100)
            lock.Unlock()
        }(a)
    }
}

读写锁 : 分读锁与写锁, 一个线程获得读锁时其他线程依旧可以进行读操作.而一个线程获得写锁时, 其他线程不能进行操作

func main(){
        var rwLock sync.RWMutex
        rwLock.Lock() // 写suo
        b[8] = rand.Intn(100)
        time.Sleep(10 * time.Millisecond)
        rwLock.Unlock()
        
        rwLock.RLock() // 读锁
        time.Sleep(time.Millisecond)
        fmt.Println(a)
        rwLock.RUnlock()
}

单次锁 : 只有此一次会被执行

var a string
var once sync.Once
func setup() {
    a = "hello, world"
}
func doprint() {
    once.Do(setup)
    print(a)
}
func twoprint() {
    go doprint()
    go doprint()
}

只能执行没有参数没有返回值的函数

package sync

import (
    "sync/atomic"
)

type Once struct {
	m    Mutex
	done uint32
}


func (o *Once) Do(f func()) {
	if atomic.LoadUint32(&o.done) == 1 {
		return
	}
	// Slow-path.
	o.m.Lock()
	defer o.m.Unlock()
	if o.done == 0 {
		defer atomic.StoreUint32(&o.done, 1)
		f()
	}
}