【启程Golang之旅】协程和管道操作

2024-06-09 05:52

本文主要是介绍【启程Golang之旅】协程和管道操作,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

欢迎来到Golang的世界!在当今快节奏的软件开发领域,选择一种高效、简洁的编程语言至关重要。而在这方面,Golang(又称Go)无疑是一个备受瞩目的选择。在本文中,带领您探索Golang的世界,一步步地了解这门语言的基础知识和实用技巧。

目录

初识协程

启动多协程

初识锁

初识管道

协程与管道协同


初识协程

在go语言中,"协程"(coroutine)通常指的是go的轻量级线程,也被称为goroutine,它使得并发编程变得更加简单和高效。这里我先对go语言中其他概念进行一个简单叙述:

1)程序(program)

是为完成特定任务、用某种语言编写的一组指令的集合,是一段静态的代码(程序是静态的)

2)进程(process)

是程序的一次执行过程,正在运行的一个程序,进程作为资源分配的单位,在内存中会为每个进程分配不同的内存区域。(进程是动态的)是一个动的过程,进程的生命周期:有它自身的产生、存在和消亡的过程

3)线程(thread)

进程可进一步细化为线程,是一个程序内部的一条执行路径,若一个进程同一时间并行执行多个线程,就是支持多线程的。

4)协程(goroutine)

又称为微线程,纤程,协程是一种用户态的轻量级线程

与传统的线程相比,goroutine非常轻量,它们的创建和销毁成本很低,因此可以大量创建而不会对系统造成太大的负担,因此它是go实现高效并发编程的核心机制之一。

协程的作用:在执行A函数的时候,可以随时中断,去执行B函数,然后中断继续执行A函数(可以自动切换),注意这一切换过程并不是函数调用(没有调用语句),过程很像多线程,然而协程中只有一个线程在执行 (协程的本质是个单线程),如下图所示:

        对于单线程下,我们不可避免程序中出现io操作,但如果我们能在自己的程序中(即用户程序级别,而非操作系统级别)控制单线程下的多个任务能在一个任务遇到io阻塞时就将寄存器上下文和栈保存到某个其他地方,然后切换到另外一个任务去计算。在任务切回来的时候,恢复先前保存的寄存器上下文和栈,这样就保证了该线程能够最大限度地处于就绪态,即随时都可以被cpu执行的状态。

        相当于我们在用户程序级别将自己的io操作最大限度地隐藏起来,从而可以迷惑操作系统,让其看到:该线程好像是一直在计算,io比较少,从而会更多的将cpu的执行权限分配给我们的线程(注意:线程是CPU控制的,而协程是程序自身控制的,属于程序级别的切换,操作系统完全感知不到,因而更加轻量级) 

我们老说协程协程,那么协程到底如何实现呢?这里给出下面的案例进行讲解:

请编写一个程序,完成如下功能:

1)在主线程中,开启一个goroutine,该goroutine每隔1秒输出"hello golang"

2)在主线程中也每隔一秒输出"hello world",输出10次后,退出程序

3)要求主线程和goroutine同时执行

package main
import ("fmt""strconv""time"
)
func test() {for i := 0; i < 10; i++ {fmt.Println("hello golang + " + strconv.Itoa(i))// 阻塞1秒time.Sleep(1 * time.Second)}
}func main() { // 主线程go test() // 开启协程for i := 0; i < 10; i++ {fmt.Println("hello world + " + strconv.Itoa(i))// 阻塞1秒time.Sleep(1 * time.Second)}
}

开启协程之后,协程和主线程交替执行,效果如下:

主线程和协程执行流程:可以从下图所示看到:

主死协从: 在go语言中有如下概念,如果主线程退出了,则协程即使还没有执行完毕,也会退出,当然协程也可以在主线程没有退出前,就自己结束了,比如完成了自己的任务,这里我们对上面的代码进行一个简单的修改,让协程的任务量变大,如下:

当我们运行程序之后,即使协程没有执行完毕,其仍要跟随主程序的结束而结束:

启动多协程

相比于线程,协程的创建和销毁成本非常低,这里可以在同一时间启动多个协程,它们会并发执行,go运行时会自动调度协程,以便它们可以在多个操作系统线程上运行,协程之间通常通过通道进行通信,以避免共享状态导致的竞态条件。下面是一个简单的go代码示例:

package main
import ("fmt""time"
)
func main() {// 匿名函数+外部变量 = 闭包for i := 0; i <= 5; i++ {// 启动协程,使用匿名函数直接调用匿名按时go func(n int) {fmt.Println(n)}(i)}time.Sleep(time.Second * 2)
}

最终实现的效果如下所示,由于它们都在并发地运行,所以输出的顺序可能是不确定的,如果你想要控制协程的执行顺序或等待它们完成,你可以使用通道或其他同步机制,这个后面再讲:

当然如果不想使用time.Sleep的方式的话,也可以采用下面的方式进行实现:

package main
import ("fmt""sync"
)
var wg sync.WaitGroup // 只定义无需赋值
func main() {// 启动五个协程for i := 0; i < 5; i++ {wg.Add(1) // 计数器加一go func(n int) {fmt.Println(n)wg.Done() // 协程执行完成减1}(i)}// 主线程一直在阻塞,什么时候wg减为0就停止wg.Wait()
}

如果多个协程操作同一个数据的情况下,给出如下代码进行示例:

package main
import ("sync"
)
// 定义一个变量
var totalNum int
var wg sync.WaitGroup // 只定义无需赋值func add() {defer wg.Done()for i := 0; i < 100000000; i++ {totalNum++}
}
func sub() {defer wg.Done()for i := 0; i < 100000000; i++ {totalNum--}
}func main() {wg.Add(2)// 启动两个协程go add()go sub()// 等待协程结束wg.Wait()println(totalNum)
}

因为协程是交替不确定的执行,结果可能都不一样,如下图所示:

初识锁

从上文的案例可以看出,如果多个协程操作同一个数据, 因为协程会交替并发执行,所以会出现争抢资源的情况,导致最终的结果可能并不是我们想要的,那么我们如何处理这个问题呢?这里我们就需要通过一个机制,确保一个协程在执行逻辑的时候另外的协程不执行,这里我们就需要引入一个概念:“锁的机制”,即加入互斥锁,示例代码如下,最终结果为0,是我们想要的:

package main
import ("sync"
)
// 定义一个变量
var totalNum int
var wg sync.WaitGroup // 只定义无需赋值
// 加入互斥锁
var lock sync.Mutexfunc add() {defer wg.Done()for i := 0; i < 100000000; i++ {lock.Lock() // 加锁totalNum++lock.Unlock() // 解锁}
}
func sub() {defer wg.Done()for i := 0; i < 100000000; i++ {lock.Lock() // 加锁totalNum--lock.Unlock() // 解锁}
}func main() {wg.Add(2)// 启动两个协程go add()go sub()// 等待协程结束wg.Wait()println(totalNum)
}

当然golang中sync包实现了两种锁Mutex(互斥锁)和RWMutex(读写锁),具体如下:

1)互斥锁:其中Mutex为互斥锁,Lock(加锁,Unlock()解锁,使用Lock()加锁后,便不能再次对其进行加锁,直到利用Unlock(解锁对其解锁后,才能再次加锁.适用于读写不确定场景,即读写次数没有明显的区别,其性能和效率相对较低。

2)读写锁:RWMutex是一个读写锁,其经常用于读次数远远多于写次数的场景,在读的时候数据之间不产生影响,写和读之间才会产生影响。

package main
import ("fmt""sync""time"
)
// 定义一个变量
var totalNum int
var wg sync.WaitGroup // 只定义无需赋值
// 加入读写锁
var lock sync.RWMutexfunc read() {defer wg.Done()lock.RLock() // 读锁,如果只是读数据那么这个锁不产生任何影响,但是读写同时发生时,就会有影响fmt.Println("开始读取数据")time.Sleep(time.Second)fmt.Println("读取数据完毕")lock.RUnlock() // 关锁
}
func write() {defer wg.Done()lock.Lock() // 写锁fmt.Println("开始写入数据")time.Sleep(time.Second)fmt.Println("写入数据完毕")lock.Unlock() // 关锁
}func main() {wg.Add(6)// 启动两个协程,读多写少for i := 0; i < 5; i++ {go read()}go write()// 等待协程结束wg.Wait()
}

初识管道

在go语言中,管道(Channel)是一种特殊的类型,用于在协程(goroutine)之间进行通信,它允许一个协程将数据发送到管道,并由另一个协程从管道中接收数据。这种机制可以实现协程之间的同步和数据交换,以下是管道相关特点介绍:

1)管道本质就是一个数据结构-队列

2)数据是先进先出

3)自身线程安全,多协程访问时,不需要加锁,channel本身就是线程安全的

4)管道有类型的,一个string的管道只能存放string类型数据

管道的定义: var 变量名chan 数据类型

chan是管道关键字;数据类型指的是管道的类型,里面放入数据的类型,管道是有类型的,intChan只能写入整数int;管道是引用类型,必须初始化才能写入数据,即make后才能使用。

package mainimport "fmt"func main() {// 定义一个int类型管道var intChan chan int// 通过make初始化,管道可以存放3个int类型数据intChan = make(chan int, 3)// 证明管道是引用类型fmt.Printf("intChan的值:%v \n", intChan) // intChan的值:0xc000018200// 向管道存放数据,注意存放的数据不能超出管道的容量intChan <- 1 // 往管道中存放数据num := 20intChan <- num // 往管道中存放数据// 取出管道数据(队列先进先出)fmt.Printf("intChan的值:%v \n", <-intChan) // intChan的值:1fmt.Printf("intChan的值:%v \n", <-intChan) // intChan的值:20// 输出管道的长度fmt.Printf("intChan的长度:%d \n", len(intChan)) // intChan的长度:2
}

管道的关闭使用内置函数close可以关闭管道,当管道关闭后,就不能再向管道写数据了,但是仍然可以从该管道读取数据。

package mainimport "fmt"func main() {// 定义管道var intChan chan int// 通过make初始化管道,可以存放3个int类型数据intChan = make(chan int, 3)// 往管道中写入数据intChan <- 1intChan <- 2// 关闭管道close(intChan)// 再次写入数据会报错//intChan <- 3 // panic: send on closed channel// 当管道关闭后,再读取数据是可以的num := <-intChanfmt.Println(num) // 1
}

管道的遍历:管道支持for-range的方式进行遍历,请注意两个细节:

1)在遍历时,如果管道没有关闭,则会出现deadlock的错误

2)在遍历时,如果管道已经关闭,则会正常遍历数据,遍历完后,就会退出遍历。

package mainimport "fmt"func main() {// 定义管道var intChan chan int// 通过make初始化管道,可以存放100个int类型数据intChan = make(chan int, 100)// 往管道中写入数据for i := 0; i < 100; i++ {intChan <- i}// 在遍历前,如果没有关闭管道,就会出现deedlock的错误// 遍历管道中的数据for v := range intChan {fmt.Println("value = ", v)}
}

如上代码由于没有关闭管道,导致出现如下问题:

所以我们需要在遍历管道前,需要进行管道的关闭,如下:

管道的只读只写: 可以在初始化管道的时候,通过代码设置只读只写属性,如下:

func main() { // 主线程// 默认情况下,管道是双向的,可读可写var intChan chan int// 声明为只写管道var intChan1 chan<- int// 声明为只读管道var intChan2 <-chan int
}

select功能:解决多个管道的选择问题,也可以叫做多路复用,可以从多个管道中随机公平地选择一个来执行,如下代码输出的就是hello

1)case后面必须进行的是io操作,不能是等值,随机去选择一个io操作

2)default防止select被阻塞住,加入default 

package mainimport ("fmt""time"
)func main() { // 主线程// 定义一个int类型管道intChan := make(chan int, 1)go func() {time.Sleep(time.Second * 5)intChan <- 1}()// 定义一个string类型管道stringChan := make(chan string, 1)go func() {time.Sleep(time.Second * 2)stringChan <- "hello"}()//fmt.Println(<-intChan) // 阻塞等待,本身取数据就是阻塞的select {case v := <-intChan:fmt.Println("intChan: ", v)case v := <-stringChan:fmt.Println("stringChan: ", v)default:fmt.Println("防止select被阻塞")}
}

异常错误捕获:多个协程工作,其中一个协程出现panic,导致程序崩溃,这里利用refer+recover捕获panic进行处理,即使协程出现问题,主线程仍然不受影响可以继续执行,示例代码如下:

package mainimport ("fmt""time"
)// 输出数字
func printNum() {for i := 0; i < 10; i++ {fmt.Println(i)}
}// 除法操作
func devide() {defer func() {err := recover()if err != nil {fmt.Println("程序异常退出")}}()num1 := 10num2 := 0result := num1 / num2fmt.Println(result)
}func main() {// 启动两个协程go printNum()go devide()time.Sleep(time.Second * 5)
}

得到的结果如下所示:

协程与管道协同

接下来我们通过一个案例来实现协程与管道的共同操作,案例需求如下:

请完成协程和管道协同工作的案例,具体要求:

1)开启一个writeData协程,向管道中写入50个整数。

2)开启一个readData协程,从管道中读取writeData写入的数据。

3)注意:writeData和readDate操作的是同一个管道。

4)主线程需要等待writeData和readDate协程都完成工作才能退出

其对应的原理图如下所示:

package mainimport ("fmt""strconv""sync""time"
)var wg sync.WaitGroup// 写数据
func writeData(intChan chan int) {defer wg.Done()for i := 0; i < 50; i++ {intChan <- ifmt.Println("写入的数据为:" + strconv.Itoa(i))time.Sleep(time.Second)}// 关闭通道close(intChan)
}// 读数据
func readData(intChan chan int) {defer wg.Done()for i := range intChan {fmt.Println("读取的数据为:" + strconv.Itoa(i))time.Sleep(time.Second)}
}
func main() { // 主线程// 写协程和读协程共同操作同一个通道intChan := make(chan int, 50)wg.Add(2)// 开启读和写的协程go writeData(intChan)go readData(intChan)// 主线程一直在阻塞,什么时候wg.Done()减为0,主线程才会结束wg.Wait()
}

最终实现的效果如下所示:

这篇关于【启程Golang之旅】协程和管道操作的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1044369

相关文章

Mysql表的简单操作(基本技能)

《Mysql表的简单操作(基本技能)》在数据库中,表的操作主要包括表的创建、查看、修改、删除等,了解如何操作这些表是数据库管理和开发的基本技能,本文给大家介绍Mysql表的简单操作,感兴趣的朋友一起看... 目录3.1 创建表 3.2 查看表结构3.3 修改表3.4 实践案例:修改表在数据库中,表的操作主要

C# WinForms存储过程操作数据库的实例讲解

《C#WinForms存储过程操作数据库的实例讲解》:本文主要介绍C#WinForms存储过程操作数据库的实例,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、存储过程基础二、C# 调用流程1. 数据库连接配置2. 执行存储过程(增删改)3. 查询数据三、事务处

Java使用Curator进行ZooKeeper操作的详细教程

《Java使用Curator进行ZooKeeper操作的详细教程》ApacheCurator是一个基于ZooKeeper的Java客户端库,它极大地简化了使用ZooKeeper的开发工作,在分布式系统... 目录1、简述2、核心功能2.1 CuratorFramework2.2 Recipes3、示例实践3

Java利用JSONPath操作JSON数据的技术指南

《Java利用JSONPath操作JSON数据的技术指南》JSONPath是一种强大的工具,用于查询和操作JSON数据,类似于SQL的语法,它为处理复杂的JSON数据结构提供了简单且高效... 目录1、简述2、什么是 jsONPath?3、Java 示例3.1 基本查询3.2 过滤查询3.3 递归搜索3.4

golang 日志log与logrus示例详解

《golang日志log与logrus示例详解》log是Go语言标准库中一个简单的日志库,本文给大家介绍golang日志log与logrus示例详解,感兴趣的朋友一起看看吧... 目录一、Go 标准库 log 详解1. 功能特点2. 常用函数3. 示例代码4. 优势和局限二、第三方库 logrus 详解1.

Android Kotlin 高阶函数详解及其在协程中的应用小结

《AndroidKotlin高阶函数详解及其在协程中的应用小结》高阶函数是Kotlin中的一个重要特性,它能够将函数作为一等公民(First-ClassCitizen),使得代码更加简洁、灵活和可... 目录1. 引言2. 什么是高阶函数?3. 高阶函数的基础用法3.1 传递函数作为参数3.2 Lambda

Python使用DrissionPage中ChromiumPage进行自动化网页操作

《Python使用DrissionPage中ChromiumPage进行自动化网页操作》DrissionPage作为一款轻量级且功能强大的浏览器自动化库,为开发者提供了丰富的功能支持,本文将使用Dri... 目录前言一、ChromiumPage基础操作1.初始化Drission 和 ChromiumPage

利用Go语言开发文件操作工具轻松处理所有文件

《利用Go语言开发文件操作工具轻松处理所有文件》在后端开发中,文件操作是一个非常常见但又容易出错的场景,本文小编要向大家介绍一个强大的Go语言文件操作工具库,它能帮你轻松处理各种文件操作场景... 目录为什么需要这个工具?核心功能详解1. 文件/目录存javascript在性检查2. 批量创建目录3. 文件

Redis中管道操作pipeline的实现

《Redis中管道操作pipeline的实现》RedisPipeline是一种优化客户端与服务器通信的技术,通过批量发送和接收命令减少网络往返次数,提高命令执行效率,本文就来介绍一下Redis中管道操... 目录什么是pipeline场景一:我要向Redis新增大批量的数据分批处理事务( MULTI/EXE

使用Python高效获取网络数据的操作指南

《使用Python高效获取网络数据的操作指南》网络爬虫是一种自动化程序,用于访问和提取网站上的数据,Python是进行网络爬虫开发的理想语言,拥有丰富的库和工具,使得编写和维护爬虫变得简单高效,本文将... 目录网络爬虫的基本概念常用库介绍安装库Requests和BeautifulSoup爬虫开发发送请求解