Golang 协程 && 管道

package threadts

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

/*
    Golang中的协程和主线程:gorou
        1.一个Go线程上,可以起多个协程.也可以理解成:协程是轻量级的线程[编译器做优化]
        2.Go协程的特点
            有独立的栈空间
            共享程序堆空间
            调度由用户控制
            协程是轻量级的线程
        3.主线程退出了,协程不管有没有执行完都会终止
        4.主线程是一个物理线程,直接作用在cpu上的.是重量级的,非常消耗cpu资源
        5.协程从主线程开启的,是轻量级的线程,是逻辑态.对资源消耗非常小
        6.Glang的协程机制是重要的特点,可以轻松的开启上万个协程.
        7.注意：如果在协程代码中出现panic，没有及时用defer+recover来处理，就会导致整个程序崩溃

    MPG
        Mc:操作系统的主线程
        P:协程执行需要的上下文
        G:协程

    编译的时候加上"-race"参数,即可显示程序运行存在的资源竞争问题.
    go build -race main.go
*/

// 全局变量
var (
    myMap   = make(map[int]int, 1)
    intChan = make(chan int, 1)

    // 互斥锁
    lock sync.Mutex
)

/*
A处Sleep，B处不Sleep能运行  结论：管道为空的时候会阻塞

    B处Sleep，A处不Sleep能运行  结论：管道满了，还要在写的话就得等有人把数据取走
    当所有协程都处于休眠状态，或者所有协程都退出，而代码仍然要从空管道读取，或者往满了的管道写入都会报错（fatal error: all goroutines are asleep - deadlock!）
*/
func Test1() {
    func1 := func() {
        for i := 1; i <= 100; i++ {
            fmt.Printf("intChan <- %v \n", i)
            intChan <- i
            // time.Sleep(time.Second * 1)          // A
        }
        close(intChan)
    }
    go func1()
    for v := range intChan {
        fmt.Printf("%v <- intChan \n", v)
        time.Sleep(time.Second * 1) // B
    }
}

func Test2() {
    var chan1 chan int = make(chan int, 1)
    var chan2 chan string = make(chan string, 1)
    func1 := func() {
        for {
            select { // 注意：在这里break continue不好使。你可以用return   或这带label去break
            case t1 := <-chan1:
                fmt.Println("chan1读到数据了:", t1)
            case t2 := <-chan2:
                fmt.Println("chan2读到数据了:", t2)
            default:
                fmt.Println("func1读数据被堵塞了!")

            }

            // time.Sleep(time.Second * 1)
        }
    }
    func2 := func() {
        for i := 1; i <= 10; i++ {
            select {
            case chan1 <- i:
                fmt.Printf("chan1 <- %v 成功!\n", i)
            case chan2 <- fmt.Sprintf("func2:%v", i):
                fmt.Printf("chan2 <- %v 成功!\n", fmt.Sprintf("func2:%v", i))
            default:
                fmt.Println("func2写数据被堵塞了!")
            }
            // time.Sleep(time.Second * 1)
        }
    }
    go func1()
    go func2()

    time.Sleep(time.Second * 10)

}

// 互斥锁实现乘阶
func TestMutex() {
    chengjie := func(n int) {
        sum := 1
        for i := 1; i <= n; i++ {
            sum *= i
        }
        lock.Lock()
        myMap[n] = sum
        defer lock.Unlock()
    }
    for i := 1; i <= 200; i++ {
        go chengjie(i)
    }
    time.Sleep(time.Second * 5)
    lock.Lock()
    for i, v := range myMap {
        fmt.Printf("myMap[%d]=%d\n", i, v)
    }
    defer lock.Unlock()
}

// 管道实现乘阶
func TestChannel() {
    /*
        管道语法:
            var [chanName] chan [type]
        使用说明:
            1.channel是引用类型
            2.channel必须使用make初始化之后才能使用.
            3.make()初始化时指定的容量是固定的
            4.管道为空的时候去读会阻塞，管道已满的时候去写也会阻塞
            5.当所有协程都处于休眠状态，或者所有协程都退出，而代码仍然要从空管道读取，或者往满了的管道写入都会报错（fatal error: all goroutines are asleep - deadlock!）
            6.从管道中取数据遵循先进先出的规则
            7.如果你想让管道能放任意数据类型,可以指定类型为interface{}.只不过取数据之后需要做一次类型断言
            8.管道关闭之后(Close(chan)内置函数),就不能再往管道里面推数据了,但是可以从管道中读取数据,直到读完.
            9.如果你要读取第二个数据的话,必须见推出第一个数据
            10.channel支持for-range遍历,但有两个注意:
                .在遍历时,如果channel没有关闭,则会出现deadlock的错误
                .在遍历时,如果channel已经关闭,则会正常遍历数据遍历完成后,就会退出遍历
            11.默认情况下管道是可读可写的,但你也可以声明只读或者只写的管道
                只读管道的声明: var chan1 <-chan int
                只写管道的声明: var chan1 chan<- int
                只读只写管道的作用: 在传参数的时候,可以直接设定管道是否可读可写,来减少犯错
            12.可以用select来启用非阻塞读取或写入


    */

    // 创建一个可以放3个int型数据的管道变量
    var intChan chan int
    intChan = make(chan int, 3)

    // 往管道写入数据
    intChan <- 10
    var ti int = 1
    intChan <- ti

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

    // 从管道中取出数据
    ss := <-intChan
    fmt.Printf("%v := <-intChan \n", ss)
    intChan <- 11

    // 关闭管道
    close(intChan)

    // 遍历管道
    for val := range intChan {
        fmt.Printf("%v\t", val)
    }
    fmt.Println()

    fmt.Println("================================")
    var waitb chan bool = make(chan bool, 1)
    waitb <- false
    a, ok := <-waitb
    fmt.Printf("a=%v, b=%v\n", a, ok)
    waitb <- true
    a, ok = <-waitb
    fmt.Printf("a=%v, b=%v\n", a, ok)

    fmt.Println("================================")
    fmt.Println()

    var cjchan chan int = make(chan int, 200)
    var mapChan chan map[int]int = make(chan map[int]int, 1)

    for i := 1; i <= 200; i++ {
        cjchan <- i
    }
    close(cjchan)

    cj := make(map[int]int, 200)
    mapChan <- cj

    chengjie := func(c1 chan map[int]int, c2 chan int, c3 chan bool) {
        temap := make(map[int]int, 1)
        for {
            n, ok := <-c2
            if !ok {
                break
            }
            sum := 1
            for i := 1; i <= n; i++ {
                sum *= i
            }
            temap[n] = sum
            // fmt.Printf("chengjie %v: %v ok=%v\n", n, sum, ok)
        }
        imap := <-c1
        for i, v := range temap {
            imap[i] = v
        }
        c1 <- imap

        if len(imap) == 200 {
            c3 <- true
        }
    }

    // go chengjie(mapChan, cjchan, waitb)
    for i := 1; i <= 10; i++ {
        go chengjie(mapChan, cjchan, waitb)
    }

    <-waitb
    for i, v := range cj {
        fmt.Printf("myMap[%d]=%d\n", i, v)
    }

}

func TestSetCPU() {
    // 获取CPU个数. NumCPU()返回本地机器的逻辑CPU个数
    cpuNum := runtime.NumCPU()
    fmt.Println("CPU个数=", cpuNum)
    // 设置程序执行调度使用CPU个数.默认会自动设置,不需要手动设置
    runtime.GOMAXPROCS(cpuNum)

}

func TestMain() {
    TestGoroutine := func() {
        for i := 1; i < 10; i++ {
            fmt.Println("TestGoroutine() Hello world!", i)
            time.Sleep(time.Second)
        }
    }
    go TestGoroutine()
    for i := 1; i < 10; i++ {
        fmt.Println("TestMain() Hello world!", i)
        time.Sleep(time.Second)
    }

}

 

锁\原子操作

func TestSync() {
    var lock sync.RWMutex

    lock.Lock()    // "写"锁
    lock.Unlock()  // "写"解锁
    lock.RLock()   // "读"锁
    lock.RUnlock() // "读"解锁

    // 数组\切片\结构体都允许并发修改(但会存在脏写),并发修改map有时候会发生panic
    // 如果要修改map可以使用sync.Map
    var a sync.Map
    a.Store("a", 1)     // add操作
    v, _ := a.Load("a") // read操作
    fmt.Println(v)

    // 原子操作:并发的时候比如用到i++类似的
    var i int32
    atomic.AddInt32(&i, 1)
    fmt.Println(i)

    // 只执行一次函数
    var onece sync.Once
    func1 := func() {
        onece.Do(func() {
            fmt.Println("aaaaa")
        })
    }
    func1()
    func1()

}