Go 语言 协程和管道讲解

最新推荐文章于 2024-08-22 15:52:41 发布
最新推荐文章于 2024-08-22 15:52:41 发布
阅读量1.4k 收藏 6
点赞数 1
分类专栏： Go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fe_cow/article/details/104496419
版权

Go 语言 协程和管道讲解

一、进程和线程基本说明：

  1. 进程是程序在操作系统中一次执行过程，是系统进行资源分配和调度的基本单位；
  2. 线程是进程的一个执行实例，是程序最小单元，它是比进程更小的能独立运行的基本单位；
  3. 一个进程可创建和销毁多个线程，同一个进程的多个线程可以并发执行；
  4. 一个程序至少有一个进程，一个进程至少有一个线程；

举个栗子：

  • 使用的迅雷客户端，打开迅雷就是开启了一个进程，而下载多个视频，就是多个线程在工作；

二、并发、并行简单说明：

1.并发：

多线程程序在单核上运行，就是并发;

  • 特点：
    1. 多个任务作用在一个cpu上；
    2. 从微观的角度看，在一个时间点上，其实只有一个任务在执行，只是时间切片较块；

2.并行：

多线程程序在多核上运行，就是并行;

  • 特点：
    1. 多个任务作用在多个cpu上；
    2. 从微观的角度看，在一个时间点上，多个任务在同时执行；

并行的速度要快

三、协程基本介绍：

1.基本概念：

一个线程上，可以有多个协程，协程是轻量级的线程；

协程特点：

  1. 有独立的栈空间；
  2. 共享程序堆空间；
  3. 调度由用户控制；
  4. 协程是轻量级的线程；

2.快速案例：

package main

import (
	"fmt"
	"strconv"
	"time"
)

func test(){
	for i:= 0; i < 10; i++{
		fmt.Println("test() " +  strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}

func main() {
	go test()  // 开启一个协程
	for i := 0; i < 10; i++{
		fmt.Println("main()" + strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}
  1. 主线程是一个物理线程，直接作用在CPU上，非常消耗CPU资源；
  2. 协程从主线程开启的，是轻量级的线程，对资源消耗小；
  3. 其它语言的并发机制一般是基于线程，开启过多的线程，资源消耗较大，这就体现出golang的优势；

3.MPG模式基本介绍：

  1. M：操作系统的主线程(物理线程);
  2. P：协程执行需要的上下文;
  3. G：协程;

MPG模式介绍

4.设置cpu数：

package main

import (
	"fmt"
	"runtime"
)

func main () {
	// 查看系统cpu个数
	cpuNum := runtime.NumCPU()
	// 可以自己设置使用多个cpu
	runtime.GOMAXPROCS(cpuNum)
	fmt.Println("cpuNum", cpuNum)
}
  1. go 1.8版本以后，默认让程序运行在多核上，可不用设置；
  2. go 1.8版本前，需要设置，才可以更高效的利用cpu；

四、协程之间如何通讯？

1.全局变量加锁：

package main

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

var (
	myMap = make(map[int]int, 10)
	// 声明一个全局互斥锁
	// lock 是一个全局互斥锁 sync 是包 同步的意思 Mutex:是互斥
	lock sync.Mutex
)
// test函数计算 n的阶乘, 将结果放到map中
func testCount(n int) {
	res := 1
	for i := 1; i <= n; i++ {
		res *=i
	}
	// 加锁
	lock.Lock()
	myMap[n] = res
	// 解锁
	lock.Unlock()
}
func main () {
	// 开启多个协程完成20个任务
	for i := 1; i <= 20; i++{
		go testCount(i)
	}
	time.Sleep(time.Second * 5)
	lock.Lock()
	for k, v := range myMap{
		fmt.Printf("map[%d]=%d\n", k, v)
	}
	lock.Unlock()
}
  1. 声明全局互斥锁；
  2. 写的时候加索，写完释放锁；
  3. 读的时候加索，读完释放锁；

否则会出现资源竞争的问题；报错信息：fatal error: concurrent map writes

全局变量加锁同步是低级程序操作：

  1. 主线程等待所有协程全部完成时间很难确定，因为主线程结束，不管协程是否执行完，程序就此结束；
  2. 通过全局变量加锁同步实现通讯，也不利于多个协程对全局变量的读写操作；

2.使用管道channel解决：

2.1.channel的介绍：

  1. 声明方式：

    var 变量名 chan 数据类型

  2. channel 本质 就是一个数据结构(队列);

  3. 数据是先进先出(FIFO);

  4. 线程安全，多个协程访问，不需要加锁;

  5. channel只能存放指定数据类型；

    如：一个string的channel只能存放string类型数据

  6. channel是引用类型;

    必须初始化才能写入数据，即make后才能使用

  7. channel数据放满后，就不能在放；

  8. channel数据取完后，再取就会报错;

2.2.快速栗子：
package main

import "fmt"

func main() {
	// 管道的使用
	// 1.创建一个可以存放3个int类型的管道
	var intChan chan int
	intChan = make(chan int, 3)
	// 2.查看intChan 是什么?
	fmt.Printf("intchan:%v\n", intChan)  // 输出结果： intchan:0xc00008c080 可以看出是引用类型
	// 3.向管道写入数据
	intChan<- 10
	num := 100
	intChan<- num  // 也可以写入常量
	// 4.看看管道的长度和cap(容量：定义的长度跟容量是相等的, 不同于map类型等)
	fmt.Printf("channel len=%v cap=%v\n", len(intChan), cap(intChan))
	//  4输出结果：channel len=2 cap=3

	//5.从管道中读取数据
	//var num2 int
	num2 := <-intChan
	fmt.Println("取出的num2=", num2)
	fmt.Printf("channel len=%v cap=%v\n", len(intChan), cap(intChan))
	// 5输出结果：channel len=1 cap=3
}

注意：

  • 如果往管道中存入数据，管道已经满了，或者取数据，管道中已经没有值，会报错信息fatal error: all goroutines are asleep - deadlock!
2.3.channel关闭：

使用内置函数close可以关闭channel，当channel关闭后，就不能向channel写数据，但是仍然可以读数据;

举个栗子：

package main

import "fmt"

func main() {
	// 创建一个管道,大小为3
	intChan := make(chan int, 3)
	intChan <- 3
	intChan <- 5
	// 将管道进行关闭
	close(intChan)
	// 此时会无法写入, 因为管道已经关闭: 报错信息 panic: send on closed channel
	//intChan <-6
	n1 := <- intChan
	fmt.Println("可以从管道中读取值:", n1)
}
2.4.channel遍历：

channel 支持 for-range的方式进行遍历：

  1. 在遍历时，若channel没有关闭，出现deadlock错误；
  2. 在遍历时，若channel已经关闭，会正常遍历数据，遍历完之后，就会退出遍历；

举个栗子：

package main

import "fmt"

func main () {
	// 创建一个管道, 大小为200
	intChan := make(chan int, 200)
	for i := 0; i < 200; i++ {
		intChan<- i * 2
	}
	// 在遍历取值时, 一定要关闭管道
	close(intChan)
	// 遍历, 取出管道所有的值
	for value := range intChan{
		fmt.Println("value:", value)
	}
}

如果在遍历取值的时候，不关闭管道会报错：fatal error: all goroutines are asleep - deadlock!

2.5.协程与管道的使用：
package main

import "fmt"

// 往管道里写入50条数据
func writeDate(intChan chan int)  {
	for i := 1; i <= 50; i++{
		// 写入数据
		intChan<- i
		fmt.Println("管道中写入数据:", i)
	}
	// 写完后,关闭此管道
	close(intChan)
}
// 从管道中读取数据
func readData(intChan chan int, exitChan chan bool) {
	for {
		v, ok := <-intChan
		// 说明intChan管道已经取完了
		if !ok{
			break
		}
		fmt.Printf("intChan 管道取出数据:%v\n", v)
	}
	// readData 取完后表示任务已经完成
	exitChan<- true
	close(exitChan)
}
func main()  {
	// 创建两个管道
	intChan := make(chan int, 50)
	// 退出管道, 主线程监控, 协程取完intChan后, 会写进此管道一条数据
	exitChan := make(chan bool, 1)

	// 开启写的协程、读的协程
	go writeDate(intChan)
	go readData(intChan, exitChan)

	// 写一个for循环, 监听exitChan管道, 若exitChan管道的数据取完, 主线程可以结束
	for {
		_, ok := <- exitChan
		if !ok{
			break
		}
	}
}
  1. 切记，这里创建两个管道，是解决，主线程退出，协程还没有执行完，该程序就结束的问题；
  2. 如果指向管道写入数据，而没有读取，就会出现阻塞dead lock，原因是超出了管道的容量；
2.6.管道使用细节：

  1. 声明管道为只写:

    var chan2 chan<- int
chan2 = make(chan int, 3)
chan2<-20

  2. 声明管道为只读：

    var chan3 <-chan int
num := <- chan3

  3. 只读或只写，可以应用到函数传参时，做严格校验；

  4. select可以解决从管道取数据阻塞问题：

    package main

import (
	"fmt"
	"time"
)

func main() {
	// 使用select 可以解决管道数据堵塞的问题
	// 1.定义一个int类型管道, 大小为10
	intChan := make(chan int, 10)
	for i := 0; i < 10; i++{
		intChan<- i
	}
	// 2.定义一个管道 5个数据string
	strChan := make(chan string, 5)
	for i := 0; i < 5; i++ {
		strChan<- "hello" + fmt.Sprintf("%s", i)
	}
	// 传统方法在遍历管到时, 如果不关闭会阻塞 导致deadlock
	// 实际开发中，有时不确定什么时候关闭该管道
	for {
		select {
			// 注意：若intChan 一直没有关闭, 不会一直阻塞而导致deadlock
			// 会自动到下一个case匹配
			case v := <- intChan:
				fmt.Printf("从intChan读取数据%d\n", v)
				time.Sleep(time.Second)
			case v := <- strChan:
				fmt.Printf("从strChan读取数据%s\n", v)
				time.Sleep(time.Second)
			default:
				fmt.Printf("取不到数据咯~~~\n")
				return
		}
	}
}

  5. 协程中使用recover，解决协程中出现panic，导致程序崩溃问题:

    package main

import (
	"fmt"
	"time"
)

func sayGo() {
	// 写一个正常运行的函数
	for i := 0; i < 10; i++{
		time.Sleep(time.Second)
		fmt.Println("hello golang")
	}
}

func testErr() {
	// 使用defer + recover 进行对此函数的异常捕获
	defer func() {
		if err := recover(); err != nil{
			fmt.Printf("test()函数发生错误:%v", err)
		}
	}()

	// 写一个错误的函数
	var myMap map[int]string
	myMap[0] = "hello"
}
func main() {
	go sayGo()
	go testErr() // 若此函数错误, 不会影响到其余函数 所以在此函数里加上捕获异常

	for i := 0; i < 10; i++{
		fmt.Println("main() ok=", i)
		time.Sleep(time.Second)
	}
}
Fe_cow丿
关注
专栏目录
Go语言高级编程: 多线程、协程相关的高级主题
AI天才研究院
08-01 1720
2021年Go语言已经成为非常流行的系统级编程语言，其提供了高效灵活的并发模型（包括 goroutine 和 channel），极大的提升了开发效率。因此，对于想要进一步提升自身能力的工程师来说，掌握Go语言的一些高级特性也是至关重要的。本系列文章将从多线程到协程，详细介绍并实践Go语言中的各种高级特性，帮助读者更好地理解并使用这些特性进行系统编程。在阅读本系列文章之前，建议读者对Go语言有所了解，并且熟练使用Go语言进行编程。本系列文章基于Go1.17版本编写，与更新版本的语法及特性有所差异。
Go编程基础教程：初识Go语言
AI天才研究院
10-30 115
Go语言（也称为Golang）是一种开源编程语言，由Google开发，旨在提供高效、可靠的软件开发工具。
go 协程和管道实战
实践求真知
05-05 175
一需求 1开启一个 writeData协程，向管道intChan中写入 50个整数。 2开启一个readData协程，从管道intChan中读取writeData写入的数据。 3注意：writeData和readData操作的是同一个管道。 4主线程需要等待wrtiteDate和readDate协程都完成工作才能退出管道。 二图解 三代码 package main import ( "fmt" "time" ) // write ...
Golang —— goroutine（协程）和channel（管道）
weixin_34413103的博客
02-18 632
协程（goroutine） 协程（goroutine）是Go中应用程序并发处理的部分，它可以进行高效的并发运算。 协程是轻量的，比线程更廉价。使用4K的栈内存就可以在内存中创建。 能够对栈进行分割，动态地增加或缩减内存的使用。栈的管理会在协程退出后自动释放。 协程的栈会根据需要进行伸缩，不出现栈溢出。 协程的使用 package main import ( "fmt" "time" ) ...
Go语言之协程和管道
Dreaming_My_Dream的博客
06-30 566
Go语言协程与管道的应用
Go的协程和管道
weixin_41091984的博客
05-19 164
Go有个简单的线程模型，叫做协程。为这个协程配套的简易版“数据同步”叫管道或者信道 在go tour上有两个很有特色的例子： https://tour.go-zh.org/concurrency/2 package main import "fmt" func sum(s []int, c chan int) { sum := 0 for _, v := range s { sum += v } c <- sum // 将和送入 c } func main() { s :=
go协程、管道
DAICONG’s Blog
07-14 213
请感受一下协程的强大，使用了管道序列 package main import ( "fmt" "time" ) //创建一个管道，用于写入数据 func writeChantest(writeChan chan int) { for i := 0; i < 20; i++ { writeChan <- i fmt.Println("写入数据=", i) time.Sleep(time.Second) } close(writeChan) } //创建管道，用于读取数据
进程、线程和协程详解
十分甜咖啡
07-26 2582
进程、线程和协程
Go 语言调度器（schedule）的实现原理
最新发布
禅与代码的艺术
08-22 1755
介绍了 Go 语言调度器，讲解了调度器是如何调度并执行用户协程的，并讲解了两中抢占式调度方案。
第十一课 go语言基础-协程和管道
QnHyn
06-26 507
第十一课 go语言基础-协程和管道 tags: golang 2019尚硅谷 categories: 协程 管道 文章目录第十一课 go语言基础-协程和管道第一节 相关概念介绍1.1 进程和线程介绍1.2 并发和并行1.3 Go协程和Go主线程1.4 协程入门第二节 goroutine的调度模型2.1 goroutine的调度模型2.1.1 MPG模式一2.1.2 MPG模式二(重要)2.2 设置Golang运行的cpu数2.3 goroutine的并发安全提出2.4 goroutine的并发安
Golang语言细节（一）之协程与管道
qq_30903089的博客
01-20 230
Go基础10：协程和管道
qq_30001669的博客
08-06 292
概述 进程/线程 进程：是程序在操作系统中的一次执行过程，系统进行资源分配和调度的一个独立单位。 线程：是进程的一个执行实体，是 CPU 调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。 一个进程可以创建和撤销多个线程，同一个进程中的多个线程之间可以并发执行。 并发/并行 多线程程序在单核心的 cpu 上运行，称为并发； 多线程程序在多核心的 cpu 上运行，称为并行。 并发与并行并不相同，并发主要由切换时间片来实现“同时”运行，并行则是直接利用多核实现多线程的运行，Go程序可以设置使用核心数，
golang的两把利器，协程和管道
weixin_36469852的博客
11-20 653
golang的协程相信大家都不陌生，在golang中的使用也很简单，只要加上一个关键字「go」即可，虽然说大家都知道，但是真的在实际使用中又遇到这样那样的问题，坑其实还是挺多的。而网上很多文章和教程，要么就是讲的太简单，给你简单介绍一下协程和管道的使用，「点到为止」，要么就上来给你撸GPM模型，看的人「一脸懵逼」，所以我以「实际使用过程中遇到的问题」这个角度出发,可能会分多篇总结一下golang的协程相关的知识点，希望对你有用，如果觉得还不错，记得点个赞，点个关注。 ps：如果你从来没有了解过golang的
golang中协程&管道&锁
木子七的博客
02-23 297
进程和线程 进程(Process)就是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基 本单位，进程是一个动态概念，是程序在执行过程中分配和管理资源的基本单位，每一个进 程都有一个自己的地址空间。一个进程至少有 5 种基本状态，它们是：初始态，执行态， 等待状态，就绪状态，终止状态，通俗的讲进程就是一个正在执行的程序。 线程 是进程的一个执行实例，是程序执行的最小单元，它是比进程更...
Go_协程与管道
Tai_Yang_Yue的博客
03-17 324
go协程与管道的引入和基本使用
go 协程与管道
AntHub的博客
04-05 505
文章目录协程注意事项互斥锁同步协程读写锁管道管道的定义管道的遍历只读/写管道管道的 select 功能defer + recover 机制处理错误示例代码运行结果 协程 用户态的轻量级线程；单个线程，用户态控制上下文切换； 开启一个协程：go func_name() 注意事项 如果主线程退出了，则协程即使还没有执行完毕，也会退出； 协程在完成了自己的认为后，先于主线程结束； 为了防止主线程提前退出，使用：time.Sleep(tmie.Second*5); sync.WaitGroup.Wait()
Go 学习笔记08.协程和管道
_Tsun 的博客
04-17 346
go 协程 package main import "fmt" func f(from string) { for i := 0; i < 3; i++ { fmt.Println(from, ":", i) } } func main() { // 正常调用方法 f("normal") // 协程 // go f()...
Go语言协程和管道示例
深漂小码哥
01-31 316
package main import "fmt" // write data func writeData(intChan chan int) { for i := 1; i <= 50; i++{ intChan <- i fmt.Println("write data ", i) } close(intChan) } // read data func readData(intChan chan int, exitChan chan bool) { for { .
golang goroutine协程 和 channel管道
qq_39657769的博客
04-14 533
文章目录前言进程和线程基本介绍程序，进程和线程的关系图并发和并行Go协程和Go主线程goroutine 快速入门案例一MPG模式基本介绍设置Golang 运行的CPUchannel(管道) 快速入门案例一解决方法全局变量加锁同步channel基本介绍 前言 进程和线程基本介绍 进程就是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基本单位 线程是进程的一个执行实例，是程序执行的最小单位，它是比进程更小的能独立运行的基本单位 一个进程可以创建和销毁多个线程，同一个进程中的多个线程可以并发执行 一
golang协程和管道
09-14
协程是轻量级的线程，可以在同一个程序中并发地执行多个任务。通过使用协程，我们可以更有效地利用计算资源并实现并发编程。而管道是用于在协程之间传递数据的通信机制。在Go语言中，我们可以使用管道来实现协程之间的同步和通信。 在Go语言中，我们可以通过以下步骤来使用协程和管道： 1. 使用关键字"go"来创建一个协程，让其并发执行一个函数或方法。 2. 使用"make"函数来创建一个管道，并指定其元素类型和容量。管道可以是有缓冲的（指定了容量）或者无缓冲的（未指定容量）。 3. 在协程中，使用"<-"操作符将数据发送到管道中，或者从管道中接收数据。 4. 如果管道是无缓冲的，发送操作和接收操作会导致发送方和接收方都会阻塞，直到对应的操作完成。这种情况下，协程之间的通信是同步的。 5. 如果管道是有缓冲的，发送操作只有在管道已满时才会阻塞，接收操作只有在管道为空时才会阻塞。这种情况下，协程之间的通信是异步的。 下面是一个示例代码来演示协程和管道的使用： ```go package main import ( "fmt" ) func worker(id int, jobs <-chan int, results chan<- int) { for j := range jobs { fmt.Println("worker", id, "processing job", j) results <- j * 2 } } func main() { jobs := make(chan int, 5) results := make(chan int, 5) // 创建3个协程来并发执行任务 for w := 1; w <= 3; w++ { go worker(w, jobs, results) } // 发送5个任务到管道中 for j := 1; j <= 5; j++ { jobs <- j } close(jobs) // 从结果管道中接收并打印结果 for r := 1; r <= 5; r++ { fmt.Println(<-results) } } ``` 在这个示例中，我们创建了一个有缓冲的"jobs"管道和一个有缓冲的"results"管道。然后，我们创建了3个协程来并发执行任务。每个协程从"jobs"管道中接收任务，处理任务后将结果发送到"results"管道中。最后，主函数从"results"管道中接收并打印结果。 希望这个示例能够帮助你理解如何在Go语言中使用协程和管道。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值