Golang协程和通道

已于 2024-06-05 09:51:30 修改
阅读量2.3k 收藏 44
点赞数 34
分类专栏： Golang 文章标签： golang 后端 开发语言
于 2024-05-28 22:19:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenlong_cxy/article/details/137794384
版权

文章目录

协程（goroutine）

基本介绍

基本介绍

进程、线程与协程：

  • 进程（Process）是计算机中正在运行的程序的实例，是操作系统进行资源分配和调度的基本单位。每个进程都有自己独立的地址空间、代码、数据和文件资源。进程之间相互独立，通过进程间通信机制进行数据交换和协作。进程的创建、销毁以及切换都由操作系统自动完成，开销较大。
  • 线程（Thread）是操作系统调度的最小执行单元，是进程内的一个执行路径。线程与进程共享同一地址空间和大部分资源，包括代码段、数据段和打开的文件等。线程之间通常借助互斥锁、条件变量以及信号量等进行数据交换。线程的创建、销毁以及切换的开销较小，但需要注意线程间的同步和共享资源的管理。
  • 协程（Coroutine）协程是一种轻量级的并发执行单元，通常由编程语言本身的运行时系统进行调度和管理。协程通常在一个线程内执行，共享相同的地址空间和资源。协程间通常通过通道（Channel）实现数据交换和协作。协程的创建、销毁以及切换都由运行时系统自动完成，开销非常小，可以创建成千上万个协程而不会导致系统负载过高。

并发与并行：

  • 并发（Concurrency）指的是在单个处理器上以时间片轮转的方式交替执行多个任务，使得在一段时间内，这多个任务都得以推进，但实际在一个时间点只有一个任务在执行。
  • 并行（Parallelism）指的是多个任务同时在不同的处理器上执行，使得这多个任务同时得以推进，并且在一个时间点来看，也是多个任务在同时执行。

在Go中，通过在函数或方法的调用前加上go关键字即可创建一个go协程，并让其运行对应的函数或方法。如下：

package main

import (
	"fmt"
	"time"
)

func Print() bool {
	for i := 0; i < 10; i++ {
		fmt.Printf("Print: hello goroutine...%d\n", i+1)
		time.Sleep(time.Second)
	}
	return true
}

func main() {
	go Print() // 创建go协程

	for i := 0; i < 5; i++ {
		fmt.Printf("main: hello goroutine...%d\n", i+1)
		time.Sleep(time.Second)
	}
}

在上述代码中，主协程创建了一个新协程用于执行Print函数，主协程进行5次打印后退出，新协程进行10次打印后退出。运行结果如下：

在这里插入图片描述

说明一下：

  • 在Go中，当程序启动时会自动创建一个主协程来执行main函数，该协程与其他新创建的协程没有本质的区别，但主协程执行完毕后整个程序会退出，即使其他协程还未执行完毕，也会跟着退出。
  • 如果一个协程在执行过程中触发了panic异常，但没有对其进行捕获，那么会导致整个程序崩溃，因此在协程中也需要通过recover函数对panic进行捕获。

GMP模型

常规的协程（Coroutine）

线程是在内核态视角下的最小执行单元，而协程是在线程的基础上，在用户态视角下进行二次开发得到的更小的执行单元。常规的协程（Coroutine）通常是与一个线程强绑定的，而一个线程可以绑定多个协程。如下：

在这里插入图片描述

说明一下：

  • 由于常规的协程是与一个线程强绑定的，因此绑定于同一线程的多个协程只能做到并发，无法做到并行。
  • 当一个协程因为某些原因陷入阻塞，那么这个阻塞会直接上升到对应的线程，最终导致整个协程组陷入阻塞。

Go中的协程（Goroutine）

Go语言中的协程（Goroutine）与常规的协程（Coroutine）的实现方式有所不同，Go中的协程不是与一个线程强绑定的，而是由Go调度器动态的将协程绑定到可用的线程上执行。如下：

在这里插入图片描述

说明一下：

  • 由于Go协程与线程之间的绑定是动态的，因此各个协程之间既能做到并发，也能做到并行。
  • 当一个Go协程因为某些原因陷入阻塞，那么Go调度器会将该协程与其绑定的线程进行解绑，将线程的资源释放出来，使得线程可以与其他可调度的协程进行绑定。

GMP模型

GMP（Goroutine-Machine-Processor）模型是Go运行时系统中用于实现并发执行的模型，负责管理和调度协程的执行。G、M和P的含义分别如下：

  • G（Goroutine）：代表Go中的协程，每个G都有自己的运行栈、状态以及执行的任务函数。
  • M（Machine）：代表Go中的线程，M不直接执行G，而是先和P绑定，由P来指定M所需执行的G。
  • P（Processor）：代表Go中的调度器，P实现G和M之间的动态有机结合。对于G而言，P就是其CPU，G只有被P调度才得以执行；对于M而言，P是其执行代理，为其指定可执行的G。

GMP模型示意图如下：

在这里插入图片描述

上图说明：

  • 全局有多个M和多个P，但M和P的数量不一定是相同的。每个M在调度G之前，需要先和P进行绑定（不是强绑定），每个M调度的G由其对应的P指定。M无需记录所调度的G的状态信息，因此G在全生命周期中可以实现跨M执行。
  • 在GMP模型中有三种队列来存放G，分别是全局队列、P的本地队列和wait队列（用于存放io阻塞就绪态的G，图中未展示）。
  • 每个P都有一个对应本地队列，访问本地队列时可以接近无锁化。当P为M获取可调度的G时，会优先从自己的本地队列中进行获取，其次从全局队列中获取，最后从wait队列中获取。
  • 如果一个G在调度过程中新创建了一个G，那么这个新G会优先投递到当前P的本地队列中，如果本地队列已满则投递到全局队列中。

调度器P获取可调度的G的流程如下：

  1. 优先尝试从当前P的本地队列获取可调度的G。
  2. 尝试从全局队列获取可调度的G。
  3. 尝试从wait队列获取io阻塞就绪的G。
  4. 尝试从其他P的本地队列窃取一半的G补充到当前P的本地队列，防止不同P的闲忙差异过大（work-stealing机制）。

说明一下：

  • 由于存在work-stealing机制，因此P的本地队列的访问也不是完全无锁的，只能说接近无锁化。
  • 上述说到的只是获取可调度的G的主要流程，实际实现时还有更多的细节。比如P每进行61次调度后，会先尝试从全局队列中获取一个G进行调度，避免造成全局队列中的G的饥饿问题。

GOMAXPROCS

在GMP模型中，G只有被P调度才得以执行，因此P的数量决定了G的最大并行数量。通过runtime包中的GOMAXPROCS函数可以获取和设置P的数量。如下：

package main

import (
	"fmt"
	"runtime"
)

func main() {
	cpuNum := runtime.NumCPU()          // 获取本地机器的逻辑CPU数
	fmt.Printf("cpuNum = %d\n", cpuNum) // cpuNum = 6

	runtime.GOMAXPROCS(4)         // 设置可同时执行的最大CPU数
	num := runtime.GOMAXPROCS(0)  // 获取可同时执行的最大CPU数
	fmt.Printf("num = %d\n", num) // num = 4
}

说明一下：

  • runtime包中的NumCPU函数，用于获取本地机器的逻辑CPU数。
  • runtime包中的GOMAXPROCS函数，用于设置可同时执行的最大CPU数，并返回先前的设置。如果设置的值小于1，则不会更改当前的值，设置的值超过CPU核数无意义。
  • 从Go1.5开始，GOMAXPROCS默认设置为CPU的核数，并且可以根据需要自动调整并发执行的并行度，无需再手动设置。

协程的生命周期

Go中协程的生命周期大致由如下几种状态组成：

  • _Gidle：表示该协程刚刚创建，但还未进行初始化。
  • _Gdead：表示该协程已经完成初始化，但还未被使用。
  • _Grunnable：表示该协程已经被放入运行队列，但还未被调度。
  • _Grunning：表示该协程正在被调度。
  • _Gsyscall：表示该协程正在执行系统调用。
  • _Gwaiting：表示该协程处于挂起状态，需要等待被唤醒。
  • _Gdead：表示该协程刚刚执行完毕。

状态转换如下：

在这里插入图片描述

说明一下：

  • 当协程在调度过程中执行到系统调用代码时，其状态就会由_Grunning切换为_Gsyscall，并在系统调用结束后根据实际情况恢复为_Grunning或_Grunnable状态。
  • 协程在调度过程中，可能因为某些原因而陷入阻塞，比如等待锁资源就绪或等待channel条件就绪等，这是协程的状态会由_Grunning切换为_Gwaiting，并在协程被唤醒后恢复为_Grunnable状态。
  • 除了上述常见的协程状态外，协程还有一些其他的状态，比如_Gcopystack表示该协程正处于栈扩容流程中（Go协程的栈空间大小可动态扩缩），_Greempted表示协程被抢占后的状态。

协程的调度流程

GMP模型中存在三种类型的协程：

  • 普通的g：用户通过go关键字创建的协程，也就是GMP模型中需要被调度的G。
  • g0：特殊的调度协程，每个M都有一个g0，其主要负责对普通的g进行运行调度。
  • monitor g：全局监控协程，monitor g会越过P直接与一个M进行绑定，不断轮询对所有P的执行状况进行监控，如果发现满足抢占调度的条件，则会从第三方的角度出手干预，主动发起抢占调度。

在创建M时，Go运行时系统会为每个M初始化一个g0，g0的调度流程如下：

  1. 找到一个可被调度执行的G。
  2. 将这个G的状态切换为_Grunning，并通过调用gogo函数将执行权交给G。
  3. 执行G的代码逻辑，直到某些条件达成使得调度结束。
  4. G调度结束后，通过调用mcall函数将执行权交还给g0，并更新G的状态。

示意图如下：

在这里插入图片描述

调度类型

GMP模型中的调度类型大致可分为如下四类：

  • 主动调度：用户通过调用runtime包中的Gosched函数，可以让当前G主动让出执行权，并将其投递到全局队列中等待下一次调度。
  • 被动调度：G在调度过程中，因为某些原因而陷入阻塞而导致调度终止，比如等待锁资源就绪或等待channel条件就绪等。
  • 正常调度：G的代码逻辑被正常执行完毕，调度终止。
  • 抢占调度：在G执行系统调用的情况下，如果满足了抢占调度的条件，那么monitor g会强行将当前的P和M进行解绑，让解绑后的P重新寻找一个空闲的M进行绑定，进而可以继续调度其他的G，而解绑后M则继续执行系统调用。

触发前三种调度类型中的任意一种，都会导致当前G的调度终止，此时M的执行权将由普通的g交还给g0。示意图如下：

在这里插入图片描述

上图说明：

  • g0在调度普通的g时，会先通过findRunnable函数找到一个可被调度的G，然后通过execute函数更新对应G和P的状态信息，最后通过gogo函数将执行权交给G，进行G的调度。
  • G在调度过程中，如果因为主动调度、被动调度或正常调度导致调度终止，那么会先调用mcall函数将执行权交还给g0，然后通过调用对应的函数更新G的状态信息，并完成G和M解绑等操作，然后开启新一轮的调度。
  • gosched_m函数对应的是主动调度，该函数会先将G的状态由_Grunning切换为_Grunnable，然后将G和M解绑并将其投递到全局队列中，最后开启新一轮的调度。
  • park_m函数对应的是被动调度，该函数会先将G的状态由_Grunning切换为_Gwaiting，然后将G和M解绑，最后开启新一轮的调度。
  • goexit0函数对应的是正常调度，该函数会先将G的状态由_Grunning切换为_Gdead，然后将G和M解绑，最后开启新一轮的调度。

关于被动调度：

  • 当因被动调度陷入阻塞的G对应的条件就绪时，会由导致条件就绪的G执行goready函数将其唤醒，唤醒时会先将G的状态由_Gwaiting切换为_Grunnable，然后将其添加到唤醒者的P的本地队列中。
  • 比如某个G在申请锁时由于锁资源不就绪而陷入阻塞，此时这个G会被放在锁对应的资源等待队列中，当另一个持有锁的G在被调度的过程中执行释放锁操作时，就会执行goready函数唤醒该锁对应的资源等待队列中的G，并将其添加到自己的P的本地队列中。
  • 在调度唤醒者时M的执行权在普通的g手中，而被唤醒者的状态切换操作以及G的投递操作需要由g0执行，因此在goready函数中会先将执行权交还给g0，并在执行唤醒操作后再重新获得执行权，这里的执行权交接是通过systemstack函数完成的。
  • goready函数在将唤醒的G添加到唤醒者的P的本地队列中时，如果P的本地队列已满，则会将唤醒的G以及P的本地队列中一半的G放回到全局队列中，帮助当前的P缓解执行压力。

关于抢占调度：

  • 在G需要执行系统调用之前，会先调用reentersyscall函数保存当前G的执行环境，并将G和P的状态更新为对应的系统调用状态，最后解除P和当前M之间的绑定，因为M即将进入系统调用而导致短暂不可用。与M解除绑定关系的P会被添加到当前M的oldp容器中，后续M执行完系统调用后会优先寻找该P重新建立绑定关系。
  • 在G执行系统调用期间，如果P的本地队列不为空，或者当前没有空闲的M和P，或者G执行系统调用的时间超过10ms，则monitor g会将当前M的oldp容器中的P的状态置为空闲，并让其与其他空闲的M（也可能新创建一个M）进行绑定，进而可以继续调度其他的G，而当前的M仍然继续执行系统调用。
  • 当M执行完系统调用后，会通过exitsyscall函数尝试寻找P进行绑定。如果此时M的oldp容器中的P仍然可用，则重新与该P建立绑定关系，并将G的状态重新置为_Grunning，继续执行后续的代码逻辑。如果原先的P已经不可用，则将G的状态置为_Grunnable，并解除G和M的绑定关系，尝试从全局P队列中寻找一个可用的P进行绑定，如果找到了则在绑定对应的P后继续调度该G，否则将该G投递到全局队列，并让当前的M陷入沉睡，直到被唤醒后再继续发起调度。

协程间共享变量

协程间共享变量

  • 在协程之间共享变量是常见的需求，以便协程之间能够进行数据交换和协同工作。
  • 为了保证共享资源的并发安全，通常需要引入互斥锁对共享资源进行保护。

例如，下面程序中启动了4个协程进行抢票，在抢票过程中需要并发访问全局变量tickets，代码中通过加锁的方式保证了tickets变量的并发安全。如下：

package main

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

var (
	tickets = 1000     // 共享资源
	mtx     sync.Mutex // 互斥锁
)

func ByTicket(id int) {
	for {
		mtx.Lock() // 加锁
		if tickets <= 0 {
			mtx.Unlock() // 解锁
			break
		}
		time.Sleep(time.Microsecond) // 模拟抢票过程的耗时
		tickets--
		fmt.Printf("goroutine %d get a ticket, tickets = %d\n", id, tickets)
		mtx.Unlock() // 解锁
	}
}

func main() {
	// 启动4个协程进行抢票
	for i := 0; i < 4; i++ {
		go ByTicket(i)
	}
	for {
		if tickets <= 0 {
			break
		}
	}
	fmt.Printf("tickets sold out...tickets = %d\n", tickets)
}

说明一下：

  • Mutex是sync包中的互斥锁类型，用于保护共享资源的并发访问，该类型提供了Lock和Unlock两个方法，分别用于加锁和解锁。

通道（channel）

基本介绍

基本介绍

  • 通道（channel）是Go中用于协程间通信和数据交换的机制，其提供了一种安全、同步和高效的方式来传递数据，以实现协程之间的通信和协同工作。
  • channel本质是一个队列，遵守先进先出（FIFO）的原则。channel本身是线程安全的，多协程可以通过channel直接发送和接收数据，显式的加锁解锁操作。

channel的示意图如下：

在这里插入图片描述

channel的定义方式

channel的定义方式

在定义channel时，通过make创建指定类型以及容量的channel。如下：

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	// make channel
	var intChan = make(chan int, 10)
	fmt.Printf("intChan type = %T\n", intChan)                // intChan type = chan int
	fmt.Printf("intChan len = %d\n", len(intChan))            // intChan len = 0
	fmt.Printf("intChan cap = %d\n", cap(intChan))            // intChan cap = 10
	fmt.Printf("intChan size = %d\n", unsafe.Sizeof(intChan)) // intChan size = 8
}

说明一下：

  • channel是引用类型，其定义后需要先通过make函数分配内存空间，然后才能使用。在使用make函数为channel分配内存空间时，其第一个参数表示channel的类型，第二个参数表示channel的容量，第二个参数若省略则默认为0。
  • 通过len函数可以获取channel中元素的数量，通过cap函数可以获取channel的容量。channel中仅包含一个指向底层队列的指针，属于引用类型，因此channel类型变量的大小为8字节。
  • channel中只能存放对应类型的数据，如果想让channel存放任意类型的数据，可以指定channel中存放的元素类型为interface{}。

channel的读写

channel的读写

channel的读写：

  • 通过channel <- data的方式向channel中写入数据，在写入数据时，如果channel已满，则写操作会被阻塞，直到channel中有数据被读走，再执行写操作。
  • 通过data := <-channel的方式从channel中读取数据，在读取数据时，如果channel为空，则读操作会被阻塞，直到有数据写入channel中，再执行读操作。

例如，下面程序中定义了一个容量为5的channel，并启动了一个协程不断向该channel中写入数据，而在主协程中每隔1秒从该channel中读取一次数据。如下：

package main

import (
	"fmt"
	"time"
)

func WriteNum(intChan chan int) {
	num := 0
	for {
		intChan <- num // 向channel中写入数据
		fmt.Printf("write a num: %d\n", num)
		num++
	}
}

func ReadNum(intChan chan int) {
	for {
		time.Sleep(time.Second)
		num := <-intChan // 从channel中读取数据
		fmt.Printf("read a num: %d\n", num)
	}
}

func main() {
	intChan := make(chan int, 5)

	go WriteNum(intChan)

	ReadNum(intChan)
}

在上述代码中，由于向channel中写入数据的过程中没有进行任何休眠操作，因此程序运行后channel立马被写满了，此时对channel的写操作将会被阻塞，直到channel中的数据被主协程读走，才能再次执行写操作，因此后续对channel的写操作也被同步为每秒一次。程序运行结果如下：

在这里插入图片描述

说明一下：

  • 将channel的容量指定为0，意味着channel中不能存储任何数据，此时该channel将成为一个无缓冲通道。对无缓冲通道的写操作将会被阻塞，直到有另一个协程准备对channel进行读操作，反之亦然，因此无缓冲通道是一种强制同步的机制。

channel的关闭

channel的关闭

在Go中，通过内建函数close可以关闭指定的channel，channel关闭后不能再对其进行写操作，否则会触发panic异常，但仍可以从该channel中读取数据。如下：

package main

import "fmt"

func main() {
	charChan := make(chan int, 10)
	for i := 0; i < 10; i++ {
		charChan <- 'a' + i
	}
	close(charChan) // 关闭channel

	for {
		ch, ok := <-charChan
		if !ok {
			break
		}
		fmt.Printf("read a char: %c\n", ch)
	}
}

运行程序后可以看到，channel虽然被关闭了，但仍然可以读取channel中的数据。如下：

在这里插入图片描述

说明一下：

  • 通过<-channel的方式读取channel中的数据将会得到两个值，第一个值是从channel中读取到的数据，第二个值表示本次对channel进行的读操作是否成功，如果channel已关闭并且channel中没有数据可读，那么第二个值将会返回false，否则为true。

channel的遍历方式

channel的遍历方式

在Go中，可以通过for range循环的方式对channel中的元素进行遍历，其特点如下：

  • for range循环的每次迭代会从channel中读取一个数据，并将该值赋给指定的变量。
  • 如果channel中没有数据可读取，for range会阻塞等待，直到有数据可读或channel关闭。
  • channel被关闭后，for range可以继续从channel中读取数据，当所有数据都被读取后会自动结束迭代。

使用案例如下：

package main

import "fmt"

func main() {
	charChan := make(chan int, 10)
	for i := 0; i < 10; i++ {
		charChan <- 'a' + i
	}
	close(charChan) // 关闭channel

	for value := range charChan {
		fmt.Printf("read a char: %c\n", value)
	}
}

说明一下：

  • 在对channel进行读操作时，要确保有协程会对channel进行对应的写操作，否则会造成死锁（deadlock）。
  • 如果去掉上述代码中关闭channel的操作，那么for range循环在读取完channel中的数据后不会自动结束迭代，而会继续进行读操作，但此时没有任何协程会再对该channel进行写操作，因此会造成死锁（deadlock）。

只读/只写channel

只读/只写channel

在Go中，通过<-chan type和chan<- type的方式，可以将channel声明为只读或只写。如下：

package main

import (
	"fmt"
	"time"
)

func WriteNum(intChan chan<- int) { // 只写channel
	num := 0
	for {
		intChan <- num // 向channel中写入数据
		fmt.Printf("write a num: %d\n", num)
		num++
	}
}

func ReadNum(intChan <-chan int) { // 只读channel
	for {
		time.Sleep(time.Second)
		num := <-intChan // 从channel中读取数据
		fmt.Printf("read a num: %d\n", num)
	}
}

func main() {
	intChan := make(chan int, 5)

	go WriteNum(intChan)

	ReadNum(intChan)
}

说明一下：

  • 对只读的channel进行写操作，或对只写的channel进行读操作都会产生报错。
  • 由于WriteNum函数中只会对intChan进行写操作，而ReadNum函数中只会对intChan进行读操作，这时为了避免误操作，可以分别将WriteNum和ReadNum函数的intChan参数声明为只写和只读的channel。

channel最佳案例

题目要求：统计1-300000中有多少个素数

为了快速统计出素数的个数，使用多个Go协程并发进行素数判断，具体的解决思路如下：

  • 启动一个生产者协程，负责将1-300000的数字写入到intChan中，作为数据源。
  • 启动多个消费者协程，负责从intChan中读取数据进行素数判断，并将素数写入到primeChan中。
  • 主协程负责不断读取primeChan中的数据，统计素数的个数。

为了让主协程能够判断primeChan中的素数是否已经读取完毕，需要借助一个exitChan：

  • 生产者协程在生产完数据后关闭intChan，使得各个消费者协程能够判断intChan中的数据是否消费完毕，并在数据消费完毕后写入一个结束标志到exitChan中。
  • 启动一个匿名协程，负责从exitChan中读取结束标志，当读取到的结束标志个数等于消费者的个数时，表明所有消费者协程已经退出，这时关闭primeChan和exitChan。
  • 当primeChan被关闭，并且primeChan中的数据已经读取完时，则说明所有素数已经统计完毕。

示意图如下：

在这里插入图片描述

代码如下：

package main

import "fmt"

func Producer(numChan chan<- int) {
	for num := 1; num <= 300000; num++ {
		numChan <- num
	}
	close(numChan)
}

func IsPrime(num int) bool {
	for i := 2; i <= num-1; i++ {
		if num%i == 0 {
			return false
		}
	}
	return true
}

func Consumer(numChan <-chan int, primeChan chan<- int, exitChan chan<- bool) {
	for {
		num, ok := <-numChan
		if !ok {
			break
		}
		if IsPrime(num) {
			primeChan <- num
		}
	}
	exitChan <- true
}

func main() {
	numChan := make(chan int, 300000)
	primeChan := make(chan int, 300000)
	exitChan := make(chan bool, 6)

	// 生产者协程
	go Producer(numChan)

	// 消费者协程
	for i := 0; i < 6; i++ {
		go Consumer(numChan, primeChan, exitChan)
	}

	// 匿名协程
	go func() {
		for i := 0; i < 6; i++ {
			<-exitChan
		}
		close(primeChan)
		close(exitChan)
	}()

	// 主协程
	count := 0
	for {
		_, ok := <-primeChan
		if !ok {
			break
		}
		count++
	}
	fmt.Printf("prime count = %d\n", count) // prime count = 25998
}

select语句

select语句

在Go中，select语句用于实现非阻塞的通信。其特点如下：

  • select语句可以同时监听多个channel的操作，它会选择一个已经就绪的操作，并执行相应的分支代码。
  • 如果有多个操作就绪，select语句会随机选择其中一个操作执行，如果没有操作就绪，则会执行default分支。
  • 需要注意的是，如果没有操作就绪，并且select语句中没有default分支，则select语句会阻塞，直到至少有一个操作就绪。

使用案例如下：

package main

import "fmt"

func main() {
	intChan := make(chan int, 10)
	stringChan := make(chan string, 10)

	for i := 0; i < 10; i++ {
		intChan <- i
		stringChan <- fmt.Sprintf("hello select%d", i)
	}

label:
	for {
		select {
		case num := <-intChan:
			fmt.Printf("read intChan: %d\n", num)
		case str := <-stringChan:
			fmt.Printf("read stringChan: %s\n", str)
		default:
			fmt.Printf("no data now...\n")
			break label
		}
	}
}

运行代码后可以看到，当intChan和stringChan中都有数据时，select语句会随机对一个channel进行读操作，并在两个channel中的数据都被读取完后，通过执行default分支中的break语句跳出for循环。运行结果如下：

在这里插入图片描述

golang基础之通道
叱咤少帅的博客
10-17 533
golang基础之通道
Golang协程间的通信
qq_37112905的博客
08-07 2399
通道（channel）是Golang中协程之间通信的重要方式 协程 Golang中的协程和其它语言中定义的协程不太一样，Golang中的协程更倾向于并行； 协程之间的通信 协程之间通过channel进行通信，对于未指定缓冲的channel来说必须等待其它的协程来写或读才能继续执行剩下的语句（生产-消费），这也是协程之间阻塞的方式。 channel的使用： package main imp...
go通道与协程
幸福诗歌的博客
02-21 512
协程 在 Go 中,应用程序并发处理的部分被称作 goroutines(协程) ,它可以进行更有效的并发运算。 操作系统会在物理处理器上调度线程来运行,而 Go 语言的运行时会在逻辑处理器上调度 goroutine来运行。每个逻辑处理器都分别绑定到单个操作系统线程。 协程是一种比线程更加轻量级的存在。正如一个进程可以拥有多个线程一样，一个线程也可以拥有多个协程 最重要的是，协程不是被...
go 通道和协程
m0_50575361的博客
04-24 264
通道： 1.创建通道 声明并初始化一个通道的时候，需要用到Go语言的内建函数make。我们传给这个函数的第一个参数应该是代表了通道的具体类型的类型字面量。 在声明一个通道类型变量的时候，我们首先要确定该通道类型的元素类型。 比如 chan int chan代表通道类型关键字，int代表了通道类型的元素类型 初始化通道时，make还可以接收一个int类型的参数 容量为0时称为非缓冲通道，不为0时称为缓冲通道 通道相对于一个先进先出的队列，元素的发送和接收使用操作符<- package main impo
Golang协程与通道整理
热门推荐
微风轻拂
07-11 1万+
协程goroutine      不由OS调度，而是用户层自行释放CPU，从而在执行体之间切换。Go在底层进行协助实现      涉及系统调用的地方由Go标准库协助释放CPU      总之，不通过OS进行切换，自行切换，系统运行开支大大降低 通道channel 并发编程的关键在于执行体之间的通信，go通过通过channel进行通信 channel可以认
『GoLang』协程与通道
七秒钟的记忆
04-23 846
Go语言协程与通道的初始，新手其实这么多都嫌多了，知道基本用法就好，然后以后遇到了，要理解PV操作原理再根据文档写代码会很轻松，这种不能硬着头皮学
GoLang协程与通道---中
m0_53157173的博客
08-17 618
此外，需要注意在有多个 case 符合条件时， select 对 case 的选择是伪随机的，如果上面的代码稍作修改如下，则 select 语句可能不会在定时器超时信号到来时立刻选中 time.After(timeoutNs) 对应的 case，因此协程可能不会严格按照定时器设置的时间结束。再次声明，结果通道 ch 必须是带缓冲的：以保证第一个发送进来的数据有地方可以存放，确保放入的首个数据总会成功，所以第一个到达的值会被获取而与执行的顺序无关。select监听进入通道的数据，也可以是用通道发送值的时候。.
GoLang协程与通道---上
m0_53157173的博客
08-16 428
一个应用程序是运行在机器上的一个进程；进程是一个运行在自己内存地址空间里的独立执行体。一个进程由一个或多个操作系统线程组成，这些线程其实是共享同一个内存地址空间的一起工作的执行体。几乎所有’正式’的程序都是多线程的，以便让用户或计算机不必等待，或者能够同时服务多个请求（如 Web 服务器），或增加性能和吞吐量（例如，通过对不同的数据集并行执行代码）。一个并发程序可以在一个处理器或者内核上使用多个线程来执行任务，但是只有同一个程序在某个时间点同时运行在多核或者多处理器上才是真正的并行。...
golang协程池设计详解
09-18
上述代码展示了一个简单的Golang协程池实现。首先，定义一个`SimplePool`结构体，包含一个`sync.WaitGroup`用于同步等待所有工作协程完成，以及一个`work`通道作为任务队列。`NewSimplePoll`函数初始化协程池，根据...
golang mysql 并发_Golang 协程并发更新共享数据
weixin_34567845的博客
02-06 856
前言以论坛项目为例，其中一个常见的统计更新需求是发布主题或回帖时会相应累加更新数据库相关统计表中目标日期对应的主题数或发帖数。考虑到这种性质的统计数据其实并不需要纯实时更新且增加不必要的数据库写压力，我们可以在 Golang 层面从数据库初始化存储至内存变量并在相应处理业务中更新相关的统计数据变量，再定时更新至数据库即可。但这里有一个典型的问题是竞态条件(race condition)，即数据一旦...
Golang 协程顺序打印
qhh0205
07-23 5627
Golang 协程顺序打印 A、B 两个协程分别打印 1、2、3、4 和 A，B，C，D 实现：定义 A、B 两个 channal，开 A、B 两个协程，A 协程输出[1, 2, 3, 4]、B 协程输出[A, B, C, D]，通过两个独立的 channal 控制顺序，交替输出。 func main() { A := make(chan bool, 1) B := make(chan boo...
golang：协程goroutine、管道通信channel
lena blog
08-27 680
协程 原先使用的进程线程，在进行切换的时候都要切换到内核态：在进程控制块PCB中保存中断现场，然后再将CPU恢复到下一个进程的现场。 使用协程，可以将中断现场信息保存在用户空间，对内核来说是透明的。在切换协程的时候无需切换到内核态，大大地减少了开销。 如下图，协程和线程是M:N的关系，效率高与否具体取决于协程调度器的调度。 GMP G：表示goroutine协程。 M：表示thread线程。 P：表示processor处理器。 当创建新的协程的时候，优先将其加入某一个processor处理器的本地队列，若
超实用的 Golang 通道（channel）指南：教你轻松实现并发编程
最新发布
喜欢把复杂的事情说简单
09-18 2556
Golang 中的通道是一种高效、安全、灵活的并发机制，用于在并发环境下实现数据的同步和传递。通道提供了一个线程安全的队列，只允许一个 goroutine 进行读操作，另一个 goroutine 进行写操作。通过这种方式，通道可以有效地解决并发编程中的竞态条件、锁问题等常见问题。
golang 通道类型
技术的搬运工
02-11 877
Go 语言中的通道（channel）是一种特殊的类型。通道像一个传送带或者队列，总是遵循先入先出（First In First Out）的规则，保证收发数据的顺序。每一个通道都是一个具体类型的导管，也就是声明channel的时候需要为其指定元素类型。如果说goroutine是Go程序并发的执行体，channel就是它们之间的连接。channel是可以让一个goroutine发送特定值到另一个goroutine的通信机制。
Golang教程：（二十一）协程
Cynhard的专栏
07-18 1万+
原文：https://golangbot.com/goroutines/ 在上一篇教程中，我们讨论了并发，以及并发和并行的区别。在这篇教程中我们将讨论在Go中如何通过Go协程实现并发。 什么是协程 Go协程（Goroutine）是与其他函数或方法同时运行的函数或方法。可以认为Go协程是轻量级的线程。与创建线程相比，创建Go协程的成本很小。因此在Go中同时运行上千个协程是很常见的。
介绍 Golang 通道(channel)
neweastsun的专栏
07-04 2342
介绍 Golang 通道(channel) 本文介绍如何使用Golang通道。通道是Go应用中链接协程通信的管道，协程可以往通道中推入值或从中读取值。利用通道可以非常方便地实现高性能、高并发应用，相比与其他语言更简单，这并不是巧合，而是Go语言的设计理念————并发作为语言的一等公民，使得并发应用尽可能简单而不失灵活性。 通道的思想起始很早就有了，但Go的实现者希望通道承担更多使命————以尽可能简单的方式让开发者创建更好、更清晰的高性能并发应用。确实，Go语言最吸引我的能力是可以轻松创建并发应用，到目前为
Golang 通道 channel
云满笔记
08-02 2240
channel
GoLang协程与通道---下
m0_53157173的博客
08-17 684
假设我们需要处理很多任务；一个worker处理一项任务。任务可以被定义为一个结构体（具体的细节在这里并不重要）： 旧模式：使用共享内存进行同步由各个任务组成的任务池共享内存；为了同步各个worker以及避免资源竞争，我们需要对任务池进行加锁保护： sync.Mutex：它用来在代码中保护临界区资源：同一时间只有一个go协程（goroutine）可以进入该临界区。如果出现了同一时间多个go协程都进入了该临界区，则会产生竞争：Pool结构就不能保证被正确更新。在传统的模式中（经典的面向对象的语言中应用得比较多，
十四、Golang协程,通道详解
阿澈不吃蒜的博客
08-15 2022
（Process）就是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基本单位，进程是一个动态概念，是程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空间。一个进程至少有 5 种基本状态，它们是：初始态，执行态，等待状态，就绪状态，终止状态。通俗的讲进程就是一个正在执行的程序。是进程的一个执行实例，是程序执行的最小单元，它是比进程更小的能独立运行的基本单位；一个进程可以创建多个线程，同一个进程中的多个线程可以并发执行，一个程序要运行的话至少有一个进程。
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

2021dragon

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值