go语言并发编程

释放双眼,带上耳机,听听看~!

一、goroutine

与传统的系统级线程和进程相比,协程的大优势在于其“轻量级”,可以轻松创建上百万个而不会导致系统资源衰竭,而线程和进程通常多也不能超过1万个。这也是协程也叫轻量级线程的原因。

golang原生支持并发编程

轻量级线程

非抢占式多任务处理,由协程主动交出控制权

编译器/解释器/虚拟机层面的多任务

多个协程可能在一个或多个线程上运行

go语言并发编程

1.1 go对协程的实现

goroutine–Go对协程的实现

go + 函数名:启动一个协程执行函数体

package main

import (

    “fmt”

    “time”

)

func test_Routine() {

    fmt.Println(“This is one routine!!!”)

}

func Add(x, y int) {

    z := x + y

    fmt.Println(z)

}

func main() {

    for i := 1; i < 10; i++ {

        //启动一个协程执行函数体

        go Add(i, i)

    }

    //为避免并发执行后程序立即退出,先sleep 2秒

    time.Sleep(2)

}

package main

import (

    “fmt”

    “runtime”

    “time”

)

func main() {

    //定义一个数组

    var a [10]int

    //循环并发执行匿名函数,实现

    for i := 0; i < 10; i ++ {

        go func(i int) {

            for {

                a[i]++

                //主动让go协程让出时间片

                runtime.Gosched()

            }

        }(i)

    }

    time.Sleep(time.Millisecond)

    fmt.Println(a)

}

二、channel

Go语言在语言级别提供的goroutine间的通信方式

不要通过共享来通信,而要通过通信来共享。

channel的读写默认是阻塞的,除非有goroutine对其进行操作。

go语言并发编程

package main

import (

    “fmt”

    “strconv”

)

//定义一个加法函数,传入x,y整型参数,quit整型通道

func Add(x, y int, quit chan int) {

    z := x + y

    fmt.Println(z)

    //发送 1 到channel quit

    quit <- 1

}

//读取channel中的数据

func Read(ch chan int) {

    //将channel中数据发送出去,赋值给value

    value := <-ch

    fmt.Println(“value:” + strconv.Itoa(value))

}

//写数据到channel中

func Write(ch chan int) {

    //ch <- 10

}

func main() {

    //ch := make(chan int)

    //go Read(ch)

    //go Write(ch)

    //time.Sleep(10)

    //fmt.Println(“end of code”)

    //定义一个容量为10的非阻塞整型通道切片,变 量名为chs

    chs := make([]chan int, 10)

    //循环地给channel切片chs初始化

    for i := 0; i < 10; i++ {

        chs[i] = make(chan int)

        go Add(i, i, chs[i])

    }

    //遍历channel切片chs,并从channel中发出数据,留空

    for _, v := range chs {

        <-v

    }

}

三、缓冲channel

定义: c = make(chan int, n) n为缓冲区的大小,代表channel可以存储多少个元素,这几个元素可以无阻塞的写入,缓存的元素写满之后阻塞,除非有goroutine操作。

例子中定义一个容量为2的channel,

// 缓冲channel

package main

import (

    “fmt”

    “time”

)

// 定义一个chnnel类型变量 ch

var ch chan int

//测试buffered channel函数

func test_channel() {

    // 第一次发送常量1到channel ch

    ch <- 1

    fmt.Println(“ch 1”)

    // 第二次发送常量1到channel ch

    ch <- 1

    fmt.Println(“ch 2”)

    // 第三次发送常量1到channel ch

    ch <- 1

    fmt.Println(“come to end goroutine 1”)

}

func main() {

    ch = make(chan int, 0) // 等价于 ch = make(chan int) 都是不带缓冲的channel

    ch = make(chan int, 2) // 是带缓冲的channel

    go test_channel()

    time.Sleep(2 * time.Second)

    fmt.Println(“running end!”)

    <-ch

    time.Sleep(time.Second)

}

output:

ch 1

ch 2

running end!

come to end goroutine 1

package main

import “fmt”

func main() {

    c := make(chan int, 3   )//修改2为1就报错,修改2为3可以正常运行

    c <- 1

    c <- 2

    fmt.Println(<-c)

    fmt.Println(<-c)

}

四、select

Linux很早就引入的函数,用来实现非阻塞的一种方式。Go语言直接在语言级别支持select关键字,用于处理异步IO 问题。我们上面介绍的都是只有一个channel的情况,那么如果存在多个channel的时候,我们该如何操作呢,Go里面提供了一个关键字select,通过select可以监听channel上的数据流动。

select默认是阻塞的,只有当监听的channel中有发送或接收可以进行时才会运行,当多个channel都准备好的时候,select是随机的选择一个执行的。

package main

import (

    “fmt”

    “time”

)

func main() {

    ch := make(chan int)

    //匿名函数,传入一个参数整型channel类型ch

    go func(ch chan int) {

        ch <- 1

    }(ch)

    time.Sleep(time.Second)

    select {

    //如果ch成功读到数据,则执行下面的语句

    case <-ch:

        fmt.Print(“come to read ch!”)

    default:

        fmt.Print(“come to default!”)

    }

}

// 实现超时控制

package main

import (

    “fmt”

    “time”

)

func main() {

    ch := make(chan int)

    //定义一个channel timeout

    timeout := make(chan int, 1)

    //定义一个匿名函数,用来实现超时控制

    go func() {

        time.Sleep( time.Second)

        timeout <- 1

    }()

    select {

    case <-ch:

        fmt.Print(“come to read ch!/n”)

    case <-timeout:

        fmt.Print(“come to timeout!/n”)

    }

    fmt.Print(“end of code!”)

}

// 使用time.After(time.Second)实现控制

package main

import (

    “fmt”

    “time”

)

func main() {

    ch := make(chan int)

    select {

    case <-ch:

        fmt.Print(“come to read ch!/n”)

    case <-time.After(time.Second):

        fmt.Print(“come to timeout!/n”)

    }

    fmt.Print(“end of code!”)

}

// goroutine_2.go

package main

import (

    “fmt”

    “runtime”

    “strconv”

    “time”

)

func main() {

    //协程1

    go func() {

        for i := 1; i < 100; i++ {

            if i == 10 {

                //主动出让cpu 使用的话 需要 导入 runtime包

                runtime.Gosched()

            }

            fmt.Println(“routine 1:” + strconv.Itoa(i))

        }

    }()

    //协程2

    go func() {

        for i := 100; i < 200; i++ {

            fmt.Println(“routine 2:” + strconv.Itoa(i))

        }

    }()

    time.Sleep(time.Second)

}

©著作权归作者所有:来自51CTO博客作者PowerMichael的原创作品,如需转载,请注明出处,否则将追究法律责任

【转自慕课】https://www.imooc.com

Go

『No6: Go 项目组织』

2022-3-3 6:33:37

Go

golang操作json

2022-3-3 6:35:30

搜索