GO协程

//GO 并发，简单俩说，就是同时管理多个任务，交替运行；GO并行则是多个任务同时进行
package main

import (
    "fmt"
    "runtime"
    "sync"
)


func main() {
    //设置逻辑处理器个数
    runtime.GOMAXPROCS(4)
    // sync.WaitGroup是计数信号量，main函数会等待协程执行完再结束主线程
    var wg sync.WaitGroup
    wg.Add(2)
    go func(){
        defer wg.Done()
        for i:=1;i<100;i++ {
            fmt.Println("A:",i)
        }
    }()
    go func(){
        defer wg.Done()
        for i:=1;i<100;i++ {
            fmt.Println("B:",i)
        }
    }()
    wg.Wait()
}

我们对于同一个资源的读写必须是原子化的，也就是说，同一时间只能有一个goroutine对共享资源进行读写操作。
在项目目录下，运行```go build -race````可以检测当前文件是否存在资源竞争。

//GO 并发，简单俩说，就是同时管理多个任务，交替运行；GO并行则是多个任务同时进行
// sync提供一种互斥型的锁，可以控制代码同时只能有一个goroutine访问
// 被控制的代码范围，被称为临界区
package main

import (
    "runtime"
    "sync"
    "fmt"
)

var (
    count int32
    wg sync.WaitGroup
    // 声明互斥锁
    mutex sync.Mutex
)
func inCount(){
    defer wg.Done()
    for i:=0; i<2; i++{
        mutex.Lock()
        value := count
        runtime.Gosched()
        value++
        count = value
        mutex.Unlock()
    }
}
// 位于mutex.Lock()与mutex.Unlock()之间的代码块是临界区


func main() {
    //设置逻辑处理器个数
    runtime.GOMAXPROCS(4)
    wg.Add(2)
    go inCount()
    go inCount()
    wg.Wait()
    fmt.Println(count)
}

//原子函数和互斥锁可以消除对共享资源的安全访问，消除竞争
//通道chan可以在多个goroutine中发送和接收共享的数据，达到数据同步

package main

import "fmt"

func main() {
    //声明通道，和通道传输的数据类型以及通道大小,通道大小默认为0
    //大小为0的通道是无缓冲通道
    /*
    发送goroutine和接收gouroutine必须是同步的，
    同时准备后，如果没有同时准备好的话，先执行的操作就会阻塞等待，
    直到另一个相对应的操作准备好为止。这种无缓冲的通道我们也称之为同步通道。
    */
    ch := make(chan int)
    // ch := make(chan int, 2)

    //发送给通道
    ch <- 2

    //从通道中接收
    x := <- ch

    //关闭通道
    close(ch)
}
    /*
    有缓冲通道，其实是一个队列，先进先出，队列满，发送会阻塞；队列空，接收会阻塞
    这个队列的最大容量就是我们使用make函数创建通道时，通过第二个参数指定的。
    为了解决发送和接收不同步
    */

// 单向通道
var send ch<- int  //只能发送
var receive <-ch int  //只能接收