浅谈golang并发

1.并发的基础

1.并发和并行

    并发是单位时间内同时运行的程序
    并行是任意时间内同时运行的程序

其实所谓的并行，最直接的就是多台服务器并行处理，cup，内存都不会相互影响，我们平时说的并行程序是单机上的并发，并不能说成完全的并行，因为还是需要共享内存，堆栈。而并发不然，并发是规定时间内多个请求都得到执行和处理，实际上处理可能就是分时操作，并发重在避免阻塞，讲究的是程序不会因为一个阻塞而停止处理，并发实际上已经在我们很多语言都有体现过了。但是两者经常在一起出现，长得如此相像，让人还是会觉得两者是相同的。

2.goroutine

操作系统可以进行线程和进程间的切换，本身具有处理并发的能力，但是进程间的切换代价过于昂贵。如果在应用程序级别在构建一层调度，那么是不是就有更高层级的并发灵活性呢。go 就是基于这个思想产生的语言

goroutine特性

1.go 是非阻塞式，不会等待
2.调度器不能保证调度顺序
3.没有层级的概念，所有的goroutine都是被平等的调度
4.main 函数也是一个特殊的goroutine

goroutine相关的几个特殊的函数

当goroutine 创建非常容易的时候，那么随之而来的是离散的goroutine，我们如何知道目前有多少goroutine在游走就成了不可避免的话题，还好官方包为我们准备好了相关的函数。我简单的提出几个比较重要的

runtime.GOMAXPROCS (1)：当参数大于1，表示最多开启的goroutine，反之就是打印goroutine的数量
runtime.Goexit() :退出goroutine，因为函数内已经注册了defer ，所以并不会在程序中调用错误
runtime.Gosched:放弃当前被选中调度的机会，上面我们说过goroutine调度是调度器决定的，而且是不能保证顺序，
                如果我们在goroutine中放弃被调度，是不是刚好就能操控被调度的机会呢

3.Chan

其实goroutine解决了很多问题，但是也带来了很多问题，在并发程序中资源共享就显得特别尖锐的问题。我们就需要处理多线程通讯的共享机制，那么channel就产生了。

简单声明一个channel,并没有初始化，值是nil,这个是没有任何实际的意义的，而且丢给goroutine使用也会被一直阻塞，所以我们需要make函数进行创建。

缓冲区

channel 有两个属性：len代表没有被读取的数量，cap代表缓冲区容量，当无缓冲区的channel 的值len和cap都是0。有缓冲的channel主要用于goroutine数据通讯，无缓冲的主要用作goroutine通讯和goroutine的同步

操作不同状态的channel会产生不同的行为

1 .panic
    向已经关闭的channel中投递数据会panic
    重复关闭channel会发生panic

2.阻塞
    1.向未初始化的channel写读数据都会发生goroutine的阻塞
    2.向缓冲区已满的channel写数据会发生阻塞
    3.读取没有数据的channel会发生阻塞

3.非阻塞
  1.读取已经关闭的channel不会阻塞
  2.向缓冲区没有满的channel读写数据不会发生阻塞

4.WaitGroup

除了使用无缓冲的chan来实现同步之外，我们还可以使用sync包下的waitgroup来实现goroutine的同步机制

此方法是在sync 包下，具体有这么几个方法

1. add () :括号中可以指定数量
2.done（）：相当于add -1
3.wait ：阻塞等待所有goroutine将num 归零

5.退出等待机制

读取已经关闭的通道并不会引起阻塞，而会得到通道类型的零值，但是如果我们要实现一个我们写入方关闭通道其实并不是那么好实现，除非面向过程编程，举个例子来说：我们要在程序调用方发出发多条短信，常规的做法是循环切片，开启多个 goroutine 去处理相应的逻辑，将结果放入公共通道进行判断。但是如果我们要加一个需求：我们可以手动打断这个发送过程，这样的写法就显得力不从心了
这里就不得不说一下另外一个select的机制了,著名的context包在golang的1.7阶段时候就进入了到官方包下面了，以下一个实例就是我们常说的golang退出等待机制，实际单个生成随机数就是一个退出等待机制了

//创建一个随机数

func CreateRandom1(done chan struct{})(chan int){

    ch:=make(chan int)
    go func() {
        label :
            for{
                select {
                case ch<-rand.Int():
                case <-done:
                    break label
                }
            }
        close(ch)
    }()
    return ch
}

//创建一个随机数二
func CreateRandom2(done chan  struct{})chan int{
    ch:=make(chan int)
    go func() {
    label :
        for{
            select {
            case ch<-rand.Int():
            case <-done:
                break label
            }
        }
        close(ch)
    }()
    return ch
}

//select 扇出形获取到随机数量
func GetRandom(done chan struct{})chan int{
    ch:=make(chan int)
    send:=make(chan struct{})
    go func() {
        label:
            for{
                select {
                case ch<-<-CreateRandom1(send):
                case ch<-<-CreateRandom2(send):
                case <-done:
                    send<- struct{}{}
                    send<- struct{}{}
                    break label
                }
            }
            close(ch)
    }()
    return ch
}


func main(){
    done:=make(chan struct{})

    ch:=GetRandom(done)

    //此时需要的时候就可以获取

    fmt.Println(<-ch)
    fmt.Println(<-ch)
    //fmt.Println(<-ch)
    fmt.Println(runtime.NumGoroutine())
    close(ch)


}