Go语言学习笔记

加 Golang学习 QQ群共同学习进步成家立业工作 ^-^ 群号:96933959

Goroutine

Go语言的主要的功能在于令人简易使用的并行设计,这个方法叫做Goroutine,通过Goroutine能够让你的程序以异步的方式运行,而不需要担心一个函数导致程序中断,因此Go语言也非常地适合网络服务。

我们通过go让其中一个函数同步运行,如此就不需要等待该函数运行完后才能运行下一个函数。

func main() {    // 通过 `go`,我们可以把这个函数异步执行,这样就不会阻塞往下执行。    go loop()    // 执行 Other}

Goroutine是类似线程的概念(但Goroutine并不是线程)。线程属于系统层面,通常来说创建一个新的线程会消耗较多的资源且管理不易。而 Goroutine就像轻量级的线程,但我们称其为并发,一个Go程序可以运行超过数万个 Goroutine,并且这些性能都是原生级的,随时都能够关闭、结束。一个核心里面可以有多个Goroutine,通过GOMAXPROCS参数你能够限制Gorotuine可以占用几个系统线程来避免失控。

在内置的官方包中也不时能够看见Goroutine的应用,像是net/http中用来监听网络服务的函数实际上是创建一个不断运行循环的Goroutine。

设置同时执行的cpu数(GOMAXPROCS)

GOMAXPROCS 在调度程序优化后会去掉,默认用系统所有资源。

func main() {    num := runtime.NumCPU()    //本地机器的逻辑CPU个数    runtime.GOMAXPROCS    //设置可同时执行的最大CPU数,并返回先前的设置    fmt.Println}

Goroutine中使用recover

应用场景,如果某个goroutine panic了,而且这个goroutine里面没有捕获,那么整个进程就会挂掉。所以,好的习惯是每当go产生一个goroutine,就需要写下recover。

var (    domainSyncChan = make(chan int, 10))func domainPut(num int) {    defer func() {        err := recover()        if err != nil {            fmt.Println("error to chan put.")        }    }()    domainSyncChan <- num        panic("error....")}func main() {    for i := 0; i < 10; i++ {        domainName := i        go domainPut(domainName)    }    time.Sleep(time.Second * 2)}

Goroutine 栗子

package mainimport (    "fmt"    "sync"    "time")var (    m    = make(map[int]uint64)    lock sync.Mutex //申明一个互斥锁)type task struct {    n int}func calc(t *task) {    defer func() {        err := recover()        if err != nil {            fmt.Println("error...")            return        }    }()    var sum uint64    sum = 1    for i := 1; i < t.n; i++ {        sum *= uint64    }    lock.Lock() //写全局数据加互斥锁    m[t.n] = sum    lock.Unlock() //解锁}func main() {    for i := 0; i < 10; i++ {        t := &task{n: i}        go calc // Goroutine来执行任务    }    time.Sleep(time.Second) // Goroutine异步,所以等一秒到任务完成    lock.Lock() //读全局数据加锁    for k, v := range m {        fmt.Printf("%d! = %vn", k, v)    }    fmt.Println    lock.Unlock() //解锁}

Goroutine 栗子(等待所有任务退出主程序再退出)

package mainimport (    "sync"    "fmt"    "time")func calc(w *sync.WaitGroup, i int)  {    fmt.Println("calc: ", i)    time.Sleep(time.Second)    w.Done()}func main()  {    wg := sync.WaitGroup{}    for i:=0; i<10; i++ {        wg.Add(1)        go calc(&wg, i)    }    wg.Wait()    fmt.Println("all goroutine finish")}

Channel

channel,管道、队列,先进先出,用来异步传递数据。channel加上goroutine,就形成了一种既简单又强大的请求处理模型,使高并发和线程同步之间代码的编写变得异常简单。

线程安全,多个goroutine同时访问,不需要加锁。

channel是有类型的,一个整数的channel只能存放整数。

channel使用

//chan申明var userChan chan interface{}          // chan里面放interface类型userChan = make(chan interface{}, 10)  // make初始化,大小为10var readOnlyChan <-chan int            // 只读chanvar writeOnlyChan chan<- int           // 只写chan

//chan放取数据userChan <- "nick"name := <- userChanname, ok := <- userChan

//关闭chanintChan := make(chan int, 1)intChan <- 9close

// range chanintChan := make(chan int, 10)for i := 0; i < 10; i++ {    intChan <- i}closefor v := range intChan {    fmt.Println}

放入chan数据个数超过初始化指定大小会怎样?

userChan := make(chan interface{})userChan <- "nick"// 错误!fatal error: all goroutines are asleep - deadlock!// 开启race会一直阻塞

开启一个goroutine来放入初始化未指定大小的chan不会报错。

即放即走,在等放入时有来拿数据的,就直接拿走。

userChan := make(chan interface{})go func() {    userChan <- "nick"}()name := <- userChan

userChan := make(chan interface{})go func() {    for {        userChan <- "nick"    }}()for {    name := <- userChan    fmt.Println    time.Sleep(time.Millisecond)}

chan关闭与不关闭

关闭chan后再放入数据会panic: send on closed channel。

chan不关闭取超数据的情况会报deadlock

func main() {    intChan := make(chan int, 10)    for i := 0; i < 10; i++ {        intChan <- i    }    for {        //十次后 fatal error: all goroutines are asleep - deadlock!        i := <- intChan        fmt.Println        time.Sleep(time.Second)    }}

chan关闭的情况取超出值为类型默认值,如int为0

func main() {    intChan := make(chan int, 10)    for i := 0; i < 10; i++ {        intChan <- i    }    close    for {        i := <- intChan        //十次后i值都为0,不报错        time.Sleep(time.Second)        fmt.Println    }}

判断chan是否取完

func main() {    intChan := make(chan int, 10)    for i := 0; i < 10; i++ {        intChan <- i    }    close    for {        i, ok := <- intChan        if !ok {            fmt.Println("channel is close.")            return        }        fmt.Println    }}

channel 栗子

栗子一

func sendData(ch chan<- string) {    ch <- "go"    ch <- "java"    ch <- "c"    ch <- "c++"    ch <- "python"    close}func getData(ch <-chan string, chColse chan bool) {    for {        str, ok := <-ch        if !ok {            fmt.Println("chan is close.")            break        }        fmt.Println    }    chColse <- true}func main() {    ch := make(chan string, 10)    chColse := make(chan bool, 1)    go sendData    go getData(ch, chColse)    <-chColse    close}

栗子二:interface类型chan,取出后转化为对应类型。

type user struct {    Name string}func main() {    userChan := make(chan interface{}, 1)    u := user{Name: "nick"}    userChan <- &u    close    var u1 interface{}    u1 = <-userChan    var u2 *user    u2, ok := u1.(*user)    if !ok {        fmt.Println("cant not convert.")        return    }    fmt.Println}

channel 超时处理

利用select来处理chan超时。

for {    select {    case v := <-chan1:        fmt.Println    case v := <-chan2:        fmt.Println    default:        time.Sleep(time.Second)        fmt.Println("timeout...")    }}

time.After()定时器来做处理。

在time.After()计时器触发之前,底层计时器不会被垃圾收集器回收。

select {case m := <-c:    handlecase <-time.After(5 * time.Minute):    fmt.Println("timed out")}

图片 1图片 2

    t := time.NewTicker(time.Second)    fmt.Println    for v := range t.C {        fmt.Println    }    t.Stop()

定时器栗子

Goroutine+Channel 栗子

栗子一

多个goroutine处理任务;

等待一组channel的返回结果。

func calc(taskChan, resChan chan int, exitChan chan bool) {    defer func() {        err := recover()        if err != nil {            fmt.Println("error...")            return         }    }()        for v := range taskChan {        // 任务处理逻辑        flag := true        for i := 2; i < v; i++ {            if v%i == 0 {                flag = false                break            }        }        if flag {            //结果进chan            resChan <- v        }    }    //处理完进退出chan    exitChan <- true}func main() {    //任务chan    intChan := make(chan int, 1000)    //结果chan    resChan := make(chan int, 1000)    //退出chan    exitChan := make(chan bool, 8)    go func() {        for i := 0; i < 1000; i++ {            intChan <- i        }        close    }()    //启动8个goroutine做任务    for i := 0; i < 8; i++ {        go calc(intChan, resChan, exitChan)    }    go func() {        //等所有goroutine结束        for i := 0; i < 8; i++ {            <-exitChan        }        close        close    }()    for v := range resChan {        fmt.Println    }}

栗子二

等待一组channel的返回结果sync.WaitGroup 的解决方法。

WaitGroup用于等待一组线程的结束。父线程调用Add方法来设定应等待的线程的数量。每个被等待的线程在结束时应调用Done方法。同时,主线程里可以调用Wait方法阻塞至所有线程结束。

func merge(cs <-chan int) <-chan int {    var wg sync.WaitGroup    out := make(chan int)    output := func(c <-chan int) {        for n := range c {            out <- n        }        wg.Done()    }    wg.Add    for _, c := range cs {        go output    }    go func() {        wg.Wait()        close(out)    }()    return out}

本文由华夏彩票发布于编程应用,转载请注明出处:Go语言学习笔记

您可能还会对下面的文章感兴趣: