13518219792
与传统的系统级线程和进程相比，协程的大优势在于其“轻量级”，可以轻松创建上百万个而不会导致系统资源衰竭，而线程和进程通常多也不能超过1万个。这也是协程也叫轻量级线程的原因。
golang原生支持并发编程
轻量级线程
非抢占式多任务处理，由协程主动交出控制权
编译器/解释器/虚拟机层面的多任务
多个协程可能在一个或多个线程上运行创新互联公司是一家专业提供六盘水企业网站建设,专注与成都网站建设、网站制作、HTML5建站、小程序制作等业务。10年已为六盘水众多企业、政府机构等服务。创新互联专业网站设计公司优惠进行中。
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)
}Go语言在语言级别提供的goroutine间的通信方式
不要通过共享来通信，而要通过通信来共享。
channel的读写默认是阻塞的，除非有goroutine对其进行操作。
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
}
}定义: 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 1package main
import "fmt"
func main() {
c := make(chan int, 3 )//修改2为1就报错，修改2为3可以正常运行
c <- 1
c <- 2
fmt.Println(<-c)
fmt.Println(<-c)
}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)
}
