goroutine channel

 

 

 

 

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

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

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

var (
    myMap = make(map[int]int, 10)  
    //声明一个全局的互斥锁
    //lock 是一个全局的互斥锁， 
    //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
    //加锁
    lock.Lock()
    myMap[n] = res //concurrent map writes?
    //解锁
    lock.Unlock()
}

func main() {

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


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

    //这里我们输出结果,变量这个结果
    lock.Lock()
    for i, v := range myMap {
        fmt.Printf("map[%d]=%d\n", i, v)
    }
    lock.Unlock()

}

 

 

 

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\n", intChan, &intChan)


    //3. 向管道写入数据
    intChan<- 10
    num := 211
    intChan<- num
    intChan<- 50
    // //如果从channel取出数据后，可以继续放入
    <-intChan
    intChan<- 98//注意点, 当我们给管写入数据时，不能超过其容量


    //4. 看看管道的长度和cap(容量)
    fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan)) // 3, 3

    //5. 从管道中读取数据

    var num2 int
    num2 = <-intChan 
    fmt.Println("num2=", num2)
    fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan))  // 2, 3

    //6. 在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报告 deadlock

    num3 := <-intChan
    num4 := <-intChan

    //num5 := <-intChan

    fmt.Println("num3=", num3, "num4=", num4/*, "num5=", num5*/)

}

intChan 的值=0xc000086080 intChan本身的地址=0xc000080018
channel len= 3 cap=3 
num2= 211
channel len= 2 cap=3 
num3= 50 num4= 98

　　

 

package main

import "fmt"

func main()  {
    var mapchan chan map[string]string
    mapchan = make(chan map[string]string,10)

    m1 := make(map[string]string,10)
    m1["name"] = "阿凡达"
    m1["age"] = "25"
    m2 := make(map[string]string,10)
    m2["name"] = "欧阳"
    m2["age"] = "28"
    mapchan <- m1
    mapchan <- m2
    fmt.Println(mapchan)
}

 

package main

import "fmt"

func main()  {
    intchan := make(chan int ,3)
    intchan <- 100
    intchan <- 200
    close(intchan)
    fmt.Println("11111111111")
    n1 :=  <-intchan
    fmt.Println(n1) //100
    fmt.Println(<-intchan) //200
    fmt.Println(<-intchan) //0
    fmt.Println(<-intchan) //0
    intchan <- 300 //panic: send on closed channel
}

 

package main
import (
    "fmt"
    "time"
)


//write Data
func writeData(intChan chan int) {
    for i := 1; i <= 50; i++ {
        //放入数据
        intChan<- i //
        fmt.Println("writeData ", i)
        //time.Sleep(time.Second)
    }
    close(intChan) //关闭
}

//read data
func readData(intChan chan int, exitChan chan bool) {

    for {
        v, ok := <-intChan
        if !ok {
            break
        }
        time.Sleep(time.Second)
        fmt.Printf("readData 读到数据=%v\n", v) 
    }
    //readData 读取完数据后，即任务完成
    exitChan<- true
    close(exitChan)

}

func main() {

    //创建两个管道
    intChan := make(chan int, 10)
    exitChan := make(chan bool, 1)
    
    go writeData(intChan)
    go readData(intChan, exitChan)

    //time.Sleep(time.Second * 10)
    for {
        _, ok := <-exitChan
        if !ok {
            break
        }
    }

}

View Code