go语言基础(并发--goroutine+channel)

一、Go协程

1、Go协程和Go主线程

　　1）Go主线程（有程序员直接称为线程/也可以理解成进程）：一个Go线程上，可以起多个协程，你可以这样理解，协程是轻量级的线程[编译器做优化]。

　　2）Go协程的特点

　　　　有独立的栈空间

　　　　共享程序堆空间

　　　　调度由用户控制

　　　　协程是轻量级的线程9o线程-协程

2、案例说明

　　请编写一个程序，完成如下功能：

　　　　1）在主线程（可以理解成进程）中，开启一个goroutine，该协程每隔1秒输出"hello，world"

　　　　2）在主线程中也每隔一秒输出“hello，golang"”，输出10次后，退出程序

　　　　3）要求主线程和goroutine同时执行.

　　　　4）画出主线程和协程执行流程图

package main

import(
    "fmt"
    "strconv"
    "time"
）

func test(){
    fori :=1; i<=10; i++{
    fmt.Println("tesst() hello，world"+strconv.rtoa(i))
    time.sleep(time.second)
}

func main(){
    go test()  ∥开启了一个协程
    for i :=1; i<=10; i++{
        fmt.Print1n("main() he11o，golang"+strconv.rtoa(i))
        time.sleep(time.second)
    }
}

　　程序关系示例图

　　

3、协程小结

　　1）主线程是一个物理线程，直接作用在cpu上的。是重量级的，非常耗费cpu 资源。

　　2）协程从主线程开启的，是轻量级的线程，是逻辑态。对资源消耗相对小。

　　3）Golang的协程机制是重要的特点，可以轻松的开启上万个协程。其它编程语言的并发机制是一般基于线程的，开启过多的线程，资源耗费大，这里就突显Golang在并发上的优势了

二、goroutine调度模型

1、MGP模式

　　1）M：操作系统的主线程（是物理线程）

　　2）P：协程执行需要的上下文

　　3）G：协程

2、模型示例图，简图

　　

三、设置CPU数目

1、介绍：为了充分了利用多cpu的优势，在Golang程序中，设置运行的cpu数目。

　　1）go1.8后，默认让程序运行在多个核上，可以不用设置了

　　2）go1.8前，还是要设置一下，可以更高效的利益cpu

package main
import "fmt"
import "runtime"

func main(){
    //获取当前系统cpu的数量
    num := runtime.NumcPU()

    //我这里设置num-1的cpu运行go程序
    runtime.GOMAXPROCS(num)
    fmt.Println("num=", num)
}

四、不同goroutine之间如何通讯

1、goroutine之间通讯资源争夺解决方式

　　1）全局变量的互斥锁

　　2）使用管道channel来解决

2、使用全局变量加锁同步改进程序

　　1）因为没有对全局变量m加锁，因此会出现资源争夺问题，代码会出现错误，提示concurrent map writes

　　2）解决方案：加入互斥锁

package main

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

//需求：现在要计算1-200的各个数的阶乘，并且把各个数的阶乘放入到map中。
//最后显示出来。要求使用goroutine完成

//思路
//1.编写一个函数，来计算各个数的阶乘，并放入到map中.
//2.我们启动的协程多个，统计的将结果放入到map中
//3.map应该做出一个全局的。

var(
    myMap = make(map[int] int, 10)
    //声明一个全局的互斥锁
    //1ock 是一个全局的互斥锁，
    //sync是包：synchornized同步
    //Mutex：是互斥
    lock sync.Mutex
)

//test函数就是计算n！，让将这个结果放入到myMap
func test(n int){
    res := 1
    for i :=1; i<=n; i++{
    res *= i

    ∥这里我们将res放入到myMap
    //加锁
    1ock.Lock()
    myMap[n] = res  //concurrent map writes？
    //解锁
    1ock.Unlock()
}

func main(){
    //我们这里开启多个协程完成这个任务[200个]
    for i := 1; i <= 200; i++{
        go test(i)
    }

    //休眠5秒钟【第二个问题】
    time.sleep(time.Second*5)

    //这里我们输出结果，变量这个结果
    1ock.Lock()
    for i,v :=range myMap{
        fmt.printf（"map[%d]=%d
",i,v）
    }

    1ock.unlock()
}

五、管道(channel)

1、为什么需要channel

　　1）前面使用全局变量加锁同步来解决goroutine的通讯，但不完美

　　2）主线程在等待所有goroutine全部完成的时间很难确定，我们这里设置10秒，仅仅是估算。

　　3）如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有goroutine处于工作状态，这时也会随主线程的退出而销毁

　　4）通过全局变量加锁同步来实现通讯，也并不利用多个协程对全局变量的读写操作。

　　5）上面种种分析都在呼唤一个新的通讯机制-channel

2、channel的介绍

　　1）channle本质就是一个数据结构-列【示意图】

　　2）数据是先进先出

　　3）线程安全，多goroutine访问时，不需要加锁，就是说channel本身就是线程安全的

　　4）channel时有类型的，一个string的channel只能存放string类型数据。

3、定义/声明channel

　　1）channel是引用类型

　　2）channel必须初始化才能写入数据，即make后才能使用

　　3）管道是有类型的，intChan只能写入整数int

var 变量名 chan 数据类型

//举例：

var intChan chan int   //（intChan用于存放int数据）

var mapChan chan map[int]string   //（mapChan用于存放map[int]string类型）

var perChan chan Person  // 结构体Person

var perChan2 chan *Person  // 结构体指针

package main

import(
    "fmt”
)

func main() {
    //演示一下管道的使用
    //1.创建一个可以存放3个int类型的管道
    var intchan chan int
    intchan=make(chan int, 3)
    //2.看看intchan是什么
    fmt.Printf("intchan的值=%v intchan本身的地址=%p
",intchan,&intchan）

    //3.向管道写入数据
    intchan<- 10
    num := 211
    intchan<- num
    intchan<- 50
    //intchan<-98  //注意点，当我们给管写入数据时，不能超过其容量
    //4.看看管道的长度和cap（容量）
    fmt.Printf("channel 1en=%/cap=%v
",1en(intchan),cap(intchan))  //3，3

    //5.从管道中读取数据
    var num2 int 
    num2 = <-intchan 
    fmt.Println("num2=",num2)
    fmt.Printf("channel 1en=%v cap=%v
", 1en(intchan),cap(intchan))  //2，3

    //6.在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报错 deadlock
    num3 := <-intChan
    num4 := <-intChan
    num5 := <-intChan 
    fmt.Println("num3=", num3,"num4=", num4,"num5=", num5)

}

4、代码示例，管道放入map

　　创建一个mapChan，最多可以存放10个map[stringlstring的key-val，演示写入和读取。

func main(){
    var mapchan chan map[string]string 
    mapChan = make(chan map[string]string, 10)
    
    m1 :=make(map[string]string, 20)
    ml["city1"]="北京"
    ml["city2"]="天津"
    
    m2 := make(map[string]string, 20)
    m2["hero1"]="宋江"
    m2["hero2"]="武松”
    
    //..
    mapchan<-m1
    mapChan<-m2
}

5、代码示例，管道放入结构体

　　创建一个catChan，最多可以存放10个Cat结构体变量，演示写入和读取的用法

func main（）{
    var catchan chan cat 
    catchan = make(chan cat, 10)
    cat1 := cat{Name:"tom", Age：18}
    cat2 := cat{Name:"tom~", Age：19}
    
    catchan<- cat1
    catchan<- cat2
    
    //取出
    cat11 := <-catchan
    cat22 := <-catchan 
    fmt.Println(cat11，cat22)
}

6、代码示例，管道放入指针

　　创建一个catChan2，最多可以存放10个*Cat变量，演示写入和读取的用法

func main（）{
    var catchan chan *cat 
    catchan=make(chan *cat, 10)
    cat1 := cat{Name:"tom", Age：18}
    cat2 := cat{Name:"tom~", Age：19}
    
    catchan<- &cat1
    catchan<- &kat2
    
    //取出
    cat11 := <-catchan
    cat22 := <-catchan 
    fmt.Printin(cat11, cat22)
}

7、代码示例，管道放入任意类型数据

　　创建一个allChan，最多可以存放10个任意数据类型变量，演示写入和读取的用法

func main（）{
    var allchan chan interface{}
    allchan = make(chan interface{}, 10)
    cat1：=cat{Name:"tom", Age：18}
    cat2：=cat{Name:"tom~", Age：180}

    allchan<- cat1
    allchan<- cat2
    allchan<- 10
    allchan<- "jack"
    
    //取出
    cat11 := <-allchan
    cat22 := <-allchan 
    V1 := <-allchan 
    v2 := <-allchanl 
    fmt.Println(cat11, cat22, v1, v2)
}

8、代码示例，管道放入interface处理

　　通过管道获取interface类型时，需要进行类型断言

func main(){
    //定义一个存放任意数据类型的管道3个数据
    //var allchan chan interface{}
    allchan := make(chan interface{}, 3)
    allchan<- 10
    allchan<- "tom jack"
    cat := cat{"小花猫", 4}
    allchan<- cat
    
    //我们希望获得到管道中的第三个元素，则先将前2个推出
    <-allchan
    <-allchan 
    newcat := <-allchan  //从管道中取出的cat是什么？
    fmt.Printf("newcat=%T，newcat=%v
", newcat, newcat)
    
    //下面的写法是错误的！编译不通过
    //fmt.Printf（"newcat.Name=%v"，newcat.Name）

    //使用类型断言
    a := newcat.(cat)
    fmt.Printf("newcat.Name=%v", a.Name)
    
}

10、channel使用的注意事项

　　1）channel中只能存放指定的数据类型

　　2）channle的数据放满后，就不能再放入了

　　3）如果从channel取出数据后，可以继续放入

　　4）在没有使用协程的情况下，如果channel数据取完了，再取，就会报dead lock

六、channel的遍历和关闭

1、channel的关闭

　　使用内置函数close可以关闭channel，当channel关闭后，就不能再向channel写数据了，但是仍然可以从该channel读取数据。

2、代码示例，管道关闭

package main 
import(
    "fmt"
)

func main(){
    intchan := make(chan int, 3)
    intchan<- 100
    intchan<- 200
    close(intchan)  //close channel

    //这是不能够再写入数到channe1
    //intchan<-300
    fmt.Println（"okook~"）

    //当管道关闭后，读取数据是可以的
    n1 := <-intchan 
    fmt.Print1n("n1=", n1)
}

3、channel的遍历

　　channel支持for--range的方式进行遍历，请注意两个细节

　　　　1）在遍历时，如果channel没有关闭，则回出现deadlock的错误

　　　　2）在遍历时，如果channel已经关闭，则会正常遍历数据，遍历完后，就会退出遍历。

package main 
import(
    "fmt"
)

func main(){
    //遍历管道
    intchan2 := make(chan int, 100)
    for i :=0; i<100; i++{
        intchan2<- i*2  //放入100个数据到管道
    }

    //遍历管道不能使用普通的for循环
    //管道长度会改变
    //for i：=e；i< len（intchan2）；i++{
    //}

    //在遍历时，如果channe1没有关闭，则会出现deadlock的错误
    //在遍历时，如果channe1已经关闭，则会正常遍历数据，遍历完后，就会退出遍历
    Close(intchan2)

    for v := range intchan2{
        fmt.Println("v=", v)
    }

}

4、案例

　　请完成goroutine和channel协同工作的案例，具体要求：

　　　　1）开启一个writeData协程，向管道intChan中写入50个整数.

　　　　2）开启一个readData协程，从管道intChan中读取writeData写入的数据。

　　　　3）注意：writeData和readDate操作的是同一个管道

　　　　4）主线程需要等待writeData和readDate协程都完成工作才能退出

package main 
import(
    "fmt",
    _"time"
)

//write Data 
func writeData(intchan chan int){
    fori :=1; i<=50; i++{
    //放入数据
    intchan<- i 
    fmt.Println("writeData", i)
    time.sleep(time.second)
    c1ose(intchan)  //关闭管道
}

//read data 
func readData(intchan chan int, exitchan chan bool){
    for{
        v, ok := <-intchan 
        // 管道为空时退出
        if !ok{
            break 
        }
        fmt.Printf("readpata 读到数据=%
", v)

        //readData 读取完数据后，即任务完成
        exitchan<- true 
        close(exitchan)
    }
}

func main(){
    //创建两个管道
    intchan := make(chan int, 50)
    exitchan := make（chan bool, 1)

    go writepata(intchan)
    go readpata(intchan, exitchan)
    //time.sleep（time.second*10）

    for{
        _, ok := <-exitchan
        if !ok{
            break
        }
    }
}

5.案例

　　需求：要求统计1-8000的数字中，哪些是素数？

package main 
import（
    "fmt"
)

//向intchan放入1-8000个数
func putNum(intchan chan int){
    for i :=1; i<=80; i++{
        intchan<- i
    }
    //关闭intchan 
    close(intchan)
}

//从intchan取出数据，并判断是否为素数，如果是，就
//放入到primechan 
func primeNum(intchan chan int, primechan chan int, exitchan chan bool){
    //使用for循环
    //var num int 
    var flag bool  // 是否为素数的标志
    for{
        num, ok := <-intchan 
        if !ok{
            //intchan 取不到..
            Break
        } 

        flag = true  //假设是素数
        //判断num是不是素数
        for i :=2 ; i< num; i++{
            if num%i==0{
            //说明该num不是素数
                flag=false 
                break
            }
        }

        if flag{
            //将这个数就放入到primechan 
            primechan<- num 
        }
    }

    fmt.Print1n("有一个primeNum协程因为取不到数据，退出")
    //这里我们还不能关闭primechan
    //向exitchan写入true 
    exitchan<- true
}

func main(){
    intchan := make(chan int, 1000)
    primechan := make(chan int, 2000)  //放入的是素数
    //标识退出的管道
    exitchan := make(chan bool, 4)  //4个处理素数的协程标志

    //开启一个协程，向intchan放入1-8000个数
    go putNum(intchan)

    //开启4个协程，从intchan取出数据，并判断是否为素数，如果是，就放入到primechan
    for i := 1; i<4; i++{
        go primeNum(intchan, primechan, exitchan)
    }

    //这里我们主线程，进行处理
    //直接,匿名函数
    go func(){
        for i := 1; i<4; i++{
            <-exitchan
        }

        //当我们从exitchan取出了4个结果，就可以放心的关闭primechan 
        close(primechan)
    }()

    //遍历我们的primechan，把结果取出
    for{
        res, ok := <-primechan 
        if !ok{
            break
        }
    }
    //将结果输出
    //fmt.Printf（"素数=%d
"，res）
    fmt.Print1n("main线程退出")
}

七、channel使用细节和注意事项

　　1）channel可以声明为只读，或者只写性质

　　2）channel只读和只写的最佳实践案例

package main 
import(
    "fmt"
）

func main(){
    //管道可以声明为只读或者只写
    //1.在默认情况下下，管道是双向
    var chanl chan int  //可读可写

    //2.声明为只写
    var chan2 chan<- int 
    chan2=make(chan int, 3)
    chan2<- 20
    //num：=<-chan2  //error 
    fmt.Printin("chan2=",chan2)

    //3.声明为只读
    var chan3 <-chan int 
    num2 := <-chan3
    //chan3<-30  //error
    fmt.Print1n("num2"，num2)
}

　　3）使用select可以解决从管道取数据的阻塞问题

package main 
import(
    "fmt",
    "time"
)

func main(){
    //使用select可以解决从管道取数据的阻塞问题
    //1.定义一个管道10个数据int 
    intchan := make(chan int, 10)
    for i := 0; i<10; i++{
        intchan<- i
    }

    //2.定义一个管道5个数据string 
    stringchan := make(chan string, 5)
    for i:=0; i<5; i++{
        stringchan<- "hello"+fmt.sprintf("%d", i)
    }

    //传统的方法在遍历管道时，如果不关闭会阻塞而导致deadlock
    //问题，在实际开发中，可能我们不好确定什么关闭该管道.
    //可以使用select方式可以解决
    //1abe1：
    for {
        select{
        //注意：这里，如果intchan一直没有关闭，不会一直阻塞而deadlock
        //会自动到下一个case匹配
        case v := <-intchan:
            fmt.Printf("从intchan读取的数据%d
", v)
            time.sleep(time.Second)
        case v := <-stringchan:
            fmt.Printf("从stringchan读取的数据%s
", v)
            time.sleep(time.Second)
        default:
            fmt.Printf("都取不到了，不玩了，程序员可以加入逻辑
")
            time.s1eep(time.Second)
            return  // 退出for
            //break labe1   //退出到指定label
        }
    }

}

　　4）goroutine中使用recover，解决协程中出现panic，导致程序崩溃问题.

package main 
import(
    "fmt",
    "time"
)

//函数
func sayHel1o(){
    for i := 0; i<10; i++{
    time.sleep(time.second)
    fmt.Println("he11o，world")
}

//函数
func test(){
    //这里我们可以使用defer+recover 
    defer func(){
        //捕获test抛出的panic 
        if err := recover(); err != nil{
            fmt.Println("test（）发生错误", err)
        }
    }()

    //定义了一个map 
    var myMap map[int]string 
    myMap[0]="golang"  //这里模拟error,因为map需要make初始化
}

func main(){
    go sayHello()
    go test()

    for i := 0; i<10; i++{
        fmt.Println("main() ok=", i)
        time.sleep(time.Second)
    }
}