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)

}

四、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)

}