Golang并行编程学习笔记（goroutine、通道）

最新推荐文章于 2024-06-15 21:25:58 发布
最新推荐文章于 2024-06-15 21:25:58 发布
阅读量1.3k 收藏 47
点赞数 32
分类专栏： 学习之路 文章标签： golang 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Valour616/article/details/139689642
版权

文章目录

本文涵盖了go语言并行编程goroutine以及通道的基本用法，所有的程序都配有详细的注释。在文章的最后，给出了三个并行编程的具体的需求，并有对应的代码实现以供参考，用于巩固所学。

goroutine

Go可以轻易创建数万个协程，可以将协程理解为轻量级的线程。
Go协程特点：

  • 每个协程有独立的栈空间
  • 共享程序的堆空间
  • 调度由程序员控制
  • 协程是轻量级的线程

通过go关键字，开启一个协程，下例实现了协程和主程序并行打印信息。

package main

import (
	"fmt"
	"time"
)
// 每隔100ms打印一行信息，重复t次
func hello(threadName string, t int) {
	for i := 0; i < t; i++ {
		fmt.Printf("thread-%v, id = %v\n", threadName, i)
		time.Sleep(100 * time.Millisecond)
	}
}

func main() {
	// 开启一个协程
	go hello("0001", 100)
	hello("main", 10)
}

运行上面程序后不难看出，程序在主线程执行结束后，就直接退出了，并不会等待协程结束。
如果我们协程的运行时间长一点，主线程就直接夹断了。为了保证程序在所有协程执行完毕后才结束，就需要引入通道技术。

读者可以结合最后需求样例中的例1 时间服务器、例2 回声服务器，进行协程的练习。

通道

通道实现了goroutine之间的通信，针对传输数据类型的不同，需要建立指定类型的通道。通道传输机制也分为有缓冲区和无缓冲区两种，首先介绍较为简单的无缓冲通道。

无缓冲通道

无缓冲通道也被称为同步通道，数据的传输和接收为阻塞过程。即发送方传输的数据被接受之后，发送方才会继续运行；接收方在从通道中接收到数据后，才会继续执行。
下面的例子定义了一个通道，并展示了写入和读取数据的过程。

package main

import "fmt"

func write(ch chan int) {
	ch <- 1
}
func main() {
	// 定义一个int类型的通道
	ch := make(chan int)
	// 开启一个新的协程，写入数据。
    // 注意不要读写同时在主线程，否则通道内数据未被读取，会阻塞
	go write(ch)
	// 读取数据
	x := <-ch
	fmt.Printf("x: %v\n", x)
}

除了在协程之间传输数据，我们也可以使用无缓冲通道阻塞的机制，来控制程序运行的先后顺序。比如，可以实现让主程序挂起，等待所有其他程序执行完成后再结束。下面对一开始的打印信息的例子进行了改进。

package main

import (
	"fmt"
	"time"
)

func hello(threadName string, t int, fin chan int) {
	for i := 0; i < t; i++ {
		fmt.Printf("thread-%v, id = %v\n", threadName, i)
		time.Sleep(100 * time.Millisecond)
	}
	// 写入数据，代表执行完毕
	fin <- 1
}

func main() {
	fin := make(chan int)
	// 开启一个协程
	go hello("0001", 20, fin)
	// 主线程一直阻塞，直到通道有数据写入
	<-fin
}

管道

使用一个协程来处理两个通道传输的信息，这种协程被称为管道。A->B->C中，B的处理称为管道。下面这个例子实现了从一个协程接收整数，平方后传给另一个协程。

package main

import (
	"fmt"
	"time"
)

func main() {
    // 传输原始数据的通道
	natural := make(chan int)
    // 传输平方后数据的通道
	square := make(chan int)
	// 判断主协程是否能够结束
	fin := make(chan int)
	go func() {
		// 一种特殊的写法，直到通道关闭，一直进行读取
		for x := range natural {
            // 平方后传入通道中
			square <- x * x
		}
		close(square)
	}()
	go func() {
		for x := range square {
            // 读取平方后的数据，打印
			fmt.Println(x)
			time.Sleep(time.Millisecond * 20)
		}
		fmt.Println("turnal closed.")
		fin <- 1
	}()

	for i := 0; i < 20; i++ {
		natural <- i
	}
	close(natural)
	<-fin
}

结束程序时，没有必要手动关闭每一个通道，只有在通知接收方goroutine所有数据都发送完毕时才需要关闭通道。但是文件不一样，结束时对每个文件调用Close方法非常重要，注意不要混淆。

单向通道

以上用到的都是双向通道，go中还能定义单向通道，主要是用于编译时检查。双向通道可以转换为单向通道，反之则不可以。

  • chan<-int 是一个只能发送的通道
  • chan->int 是一个只能接收的通道

我们常在调用的函数形参中，定义单向通道，以规范化该通道在函数中的操作。下面的代码对上个例子中用到的通道进行了输入和输出的规范化处理。

package main

import (
	"fmt"
	"time"
)

func count(in chan<- int) {
	for i := 0; i < 20; i++ {
		in <- i
	}
	close(in)
}
// out管道输出数据，in管道接受数据
func square(out <-chan int, in chan<- int) {
	for x := range out {
		in <- x * x
	}
	close(in)
}

func printer(out <-chan int, fin chan<- int) {
	for x := range out {
		fmt.Println(x)
		time.Sleep(time.Millisecond * 20)
	}
	fin <- 1
}

func main() {
	num := make(chan int)
	sq := make(chan int)
	// 判断主协程是否能够结束
	fin := make(chan int)
	go count(num)
	go square(num, sq)
	go printer(sq, fin)
	<-fin
}

缓冲通道

缓冲通道在非缓冲通道的基础上，增加了一个缓冲区用于存储数据。这个缓冲区类似于队列，先进先出。多了一个缓冲区，协程没那么容易阻塞，缓冲通道的定义和使用方式如下。
注意，make(chan int, 1)和make(chan int)有本质的区别，前者在写入一个数据后，协程可以继续执行。而非缓冲通道在没有对通道数据读取之前，协程都是处于阻塞状态。

package main

import "fmt"

func main() {
	// 定义容量为3的缓冲通道
	ch := make(chan int, 3)
	// 添加数据
	ch <- 1
	ch <- 1
	ch <- 1
	// 接收数据
	fmt.Println(<-ch)
	// 获取最大容量
	fmt.Println(cap(ch))
	// 获取当前通道中数据的个数，常用于错误诊断和性能优化
	fmt.Println(len(ch))
}

下面是一个缓冲通道的应用，获取三个HTTP请求中，最早有结果的那个。这边如果使用无缓冲通道，那么除了第一个到达的goroutine，剩下的两个goroutine中有一个会因为数据没有写入而阻塞，导致goroutine泄露。泄露的goroutine不会被自动回收，所以虽然不需要我们去手动回收goroutine，但我们也得保证goroutine在不再需要的时候能够自动结束。

package main

import (
	"fmt"
	"io"
	"net/http"
)

// 获取网站html
func fetch(url string) string {
	resp, err := http.Get(url)
	if err != nil {
		return fmt.Sprintf("fetch: %v\n", err)
	}
	defer resp.Body.Close()
	data, _ := io.ReadAll(resp.Body)
	return fmt.Sprintf("%v\n%v\n", string(data), url)
}

func fastestSites(websites []string) string {
	resp := make(chan string, len(websites))
	for i := range websites {
		// t_i用于保证执行的时候，调用的下标正确
		go func(t_i int) { resp <- fetch(websites[t_i]) }(i)
	}
	return <-resp
}
func main() {
	// 测试这三个网站的返回速度
	websites := []string{"https://www.baidu.com", "https://www.zhihu.com", "https://www.csdn.com"}
	fmt.Print(fastestSites(websites))
}

需求样例3 计算质数个数中，展示了go并行编程循环的常用写法。

select多路复用

使用select可以在各种可以执行的case情况中，自动检测未被阻塞的进程，随机选择一个来执行。下例中，ch通道的缓冲区大小为一，在这个循环中，不断经历着：空、满两个状态来回切换。

package main

import "fmt"

func main() {
	ch := make(chan int, 1)
	for i := range 10 {
		select {
        // 如果通道缓冲区未满,能写入
		case ch <- i:
        // 如果通道缓冲区有数据,能读取
		case x := <-ch:
			fmt.Println(x)
		}
	}
}

select多路复用也可以用来实现取消操作，在代码的关键位置检查是否有取消操作，可以阻止协程代码继续执行。

func cancelled(done chan int) bool {
	select {
	case <-done:
		return true
	default:
		return false
	}
}

需求样例

例1 时间服务器

时间服务器并行处理tcp连接
服务端代码：

package main

import (
	"io"
	"log"
	"net"
	"time"
)
// 定时向客户端发送时间信息
func sendTime(conn net.Conn) {
	log.Printf("connection received: %v\n", conn)
	for {
		_, err := io.WriteString(conn, time.Now().Format(time.RFC1123)+"\n")
		if err != nil {
			log.Printf("connection closed: %v\n", conn)
			return
		}
		time.Sleep(time.Second)
	}
}

func main() {
	var server = "localhost:8080"
    // 监听tcp连接
	listener, err := net.Listen("tcp", server)
	if err != nil {
		log.Fatalf("server create error: %v \n", err)
	}
	log.Printf("clock server running on %v\n", server)
	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Printf("connection establish error: %v\n", err)
		}
		go sendTime(conn)
	}
}

客户端代码，用来建立tcp连接，这边也是开协程，同时建立了100个tcp连接。

package main

import (
    "io"
    "log"
    "net"
    "os"
    "time"
)
// 建立tcp连接
func connect() {
    conn, err := net.Dial("tcp", "localhost:8080")
    if err != nil {
        log.Fatalf("connection establishment error: %v\n", err)
    }
    defer conn.Close()
    // 将接收到的数据传入标准输出窗口
    io.Copy(os.Stdout, conn)
}

func main() {
    for i := 0; i < 100; i++ {
        go connect()
    }
    for {
        time.Sleep(time.Second)
    }
}

展示的是开一个协程时的效果。
在这里插入图片描述

例2 回声服务器

服务端，监听用户发来的信息，并渐弱回复五条信息。
在这里插入图片描述

package main

import (
	"bufio"
	"io"
	"log"
	"net"
	"strings"
	"time"
)
// 每隔一段时间往连接里塞一个渐弱的字符串，重复五次
func echoBack(conn net.Conn, shout string, t time.Duration) {
	for i := 4; i >= 0; i-- {
		var back = "\t" + strings.ToUpper(shout)
		for j := 0; j < i; j++ {
			back += "!"
		}
		back += "\n"
		io.WriteString(conn, back)
		time.Sleep(t)
	}
}

// 接收到连接后，进行处理
func handleConn(conn net.Conn) {
	log.Printf("connection received: %v\n", conn)
	for {
		var input = bufio.NewScanner(conn)
		for input.Scan() {
			go echoBack(conn, input.Text(), time.Second)
		}
	}
}

func main() {
	// 监听tcp连接
	var server = "localhost:8080"
	listener, err := net.Listen("tcp", server)
	if err != nil {
		log.Fatalf("server create error: %v \n", err)
	}
	log.Printf("echo server running on %v\n", server)
	for {
		// 接收到tcp连接
		conn, err := listener.Accept()
		if err != nil {
			log.Printf("connection establish error: %v\n", err)
		}
		go handleConn(conn)
	}
}

客户端，向服务端发送信息
在这里插入图片描述

package main

import (
	"io"
	"log"
	"net"
	"os"
	"time"
)

func connect() {
	// 发起tcp连接
	conn, err := net.Dial("tcp", "localhost:8080")
	if err != nil {
		log.Fatalf("connection establishment error: %v\n", err)
	}
	defer conn.Close()
	// 将接受到的消息重定向到标准输出
	go io.Copy(os.Stdout, conn)
	// 将标准输入重定向到tcp连接，传输给服务器
	io.Copy(conn, os.Stdin)
}

func main() {
	go connect()
	for {
		time.Sleep(time.Second)
	}
}

在学习了通道和select多路复用后，可以将代码优化，添加超时结束对话功能。将服务端的handleConn替换为如下形式。

func handleConn(conn net.Conn) {
	log.Printf("connection received: %v\n", conn)
	shout := make(chan string, 10)
	go func() {
		input := bufio.NewScanner(conn)
		for input.Scan() {
			shout <- input.Text()
		}
	}()
	for {
		// ticker是一个通道，这边在20秒后会定时往通道中传入一个数据，类似于计时器
		ticker := time.NewTicker(20 * time.Second)
		select {
		case <-ticker.C:
			// 超时了
			io.WriteString(conn, "overtime, bye!~")
			conn.Close()
			return
		case x := <-shout:
			// 停止倒计时
			ticker.Stop()
			go echoBack(conn, x, time.Second)
		}
	}
}

例3 计算质数个数

使用多个协程分别计算质数个数，当然有更高效的算法，这边只是为了看一下使用协程后程序运行时间能优化多少。同时，下面这个例子展示了并行循环的一般模式，使用waitgroup去等待所有协程执行完毕，关闭通道。

package main

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

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

func main() {
	// 计算 2~num的质数个数
	num := 200 //50000000
	thread_num = min(thread_num, num)
	// 上取整
	gap := (num-2)/thread_num + 1
	res := make(chan int, thread_num)
	var wg sync.WaitGroup
	// 将要计算的数分组
	for i := 2; i <= num; {
		// wait group 添加1
		wg.Add(1)
		j := min(i+gap-1, num)
		go func(l, r int) {
			// wait group 减少1
			defer wg.Done()
			cnt := 0
			for k := l; k <= r; k++ {
				if isPrime(k) {
					cnt++
				}
			}
			res <- cnt
		}(i, j)
		i = j + 1
	}

	// close chan
	go func() {
		wg.Wait()
		close(res)
		fmt.Println("chan closed.")
	}()
	tot := 0
	for range thread_num {
		x := <-res
		tot += x
	}
	fmt.Println(tot)
}

我使用了之前博客中提到的go的测试模块，设置不同的thread_num测试程序运行所用的时间。效果显著，结果图如下。我的计算机是32核，当设定的协程数量超过计算机的核数时，提升就不是很明显了。当然，这也和我程序的写法有关，我给每个协程分配的任务量是不一样的，后面的那些协程计算量大，是程序的瓶颈。

在这里插入图片描述

Crisp0v0
关注
专栏目录
Golang并发编程学习笔记（二）
weixin_54083160的博客
02-16 441
本文主要讲述一些协程(Goroutine)和管道(Channel)的综合案例，如果对于相关概念不明晰请先看该系列Golang并发编程学习笔记（一）进行了解。本系列后面还会对生产者和消费者模式、协程管道定时任务的应用、定时器的终止与重置等具体案例进行具体的讲解。
Go语言学习笔记—golang并发编程之goroutine
qq_39280718的博客
07-06 445
视频来源于B站Go语言基础进阶视频av56860636 文章为自己整理的学习笔记，侵权即删，谢谢支持！
GoLang学习笔记之进阶编程（二）：Goroutine与Channel
qq_41736299的博客
12-11 568
在我刚开始学习Go语言的时候，就了解到Go语言的优势，即天生适合高并发。那么GO语言为什么会适合高并发呢，还有GO语言的并发模式通常是怎么样的，本章节将介绍GO语言的轻量级协程Goroutine以及协程间的通信媒介Channel。
golang学习笔记015--goroutine和channel
逆天的博客
01-29 1522
目录1.goroutine1.1 进程和线程介绍1.2 并行和并发1.3 Go协程和Go主线程1.4 goroutine快速入门（1）案例说明（2）代码实现（3）主线程和协程执行流程图（4）快速入门小结1.5 goroutine的调度模型（1）MPG模式基本介绍（2）MPG模式运行的状态1（3）MPG模式运行的状态21.6 设置Golang运行的cpu数2.channel2.1 需求2.2初步实现，但有问题2.3 不同goroutine之间如何通讯2.4 使用全局变量加锁同步改进程序2.5 为什么需要cha
Golang基础学习笔记
gyfghh的博客
10-15 336
只有类型兼容的才可以转换！
Golang学习笔记4——并发编程
Overvautious的博客
05-11 523
1. 并发基础 1.1 概念 并发与并行的区别： 并发：逻辑上具有处理多个同时性任务的能力。即看起来是多个任务同时执行，但并不一定是同一时刻，例如单核并发，通过多线程共享单核CPU利用时间片切换串行执行（并发非并行）。 并行：物理上同一时刻执行多个并发任务。一般依赖多核CPU达到多个任务在同一个时刻执行(并发且并行)。 二者概念的区别是是否同时执行，比如吃饭时，电话来了，需要停止吃饭去接电话，接完电话继续吃饭，这是并发执行，但是吃饭时电话来了，边吃边接是并行。 并发的主流实现模型： 实现模型 说
Go语言编程笔记7：goroutine和通道
梦幻天空
11-23 558
Go语言编程笔记7：goroutine和通道 图源：wallpapercave.com goroutine Python中并发的核心概念是协程，Go语言中类似的概念叫做goroutine。虽然两者在原理和使用方式等方面都有很大不同，但都是用于解决并发问题的核心概念。 协程（coroutine）与goroutine从名称上看就很相似。 我们知道，Python因为有全局线程锁的缘故，除了发生I/O的部分以外，大部分使用协程实现并发的时候实际上都是单线程在执行，事实上并不能挖掘多线程的全部性能，对于I/O密
golang学习之八：并发编程基础(goroutine、channel、select)
java_xxxx的博客
07-31 1374
这里写目录标题协程goroutine创建协程主协程退出，其它协程也都退出主协程先退出导致其它子协程未来的及调用runtime包Gosched（写在哪个协程里，哪个协程就让出cpu时间片）Goexit（写在哪个协程里，就终止哪个协程执行）GOMAXPROCS（设置可并行计算的CPU核数的最大值，并返回之前的值） 协程goroutine goroutine是Go并行设计的核心。goroutine说到底其实就是协程，但是它比线程更小，十几个goroutine可能体现在底层就是五六个线程，Go语言内部帮你实现了这些
118云原生编程语言Golang学习笔记
tangguanlin2008的博客
12-11 2378
Golang学习笔记 文章目录1.Go简介1.1 简介1.2 设计初衷1.3 Golang vs Java1.4 应用领域1.5 用go语言的公司2.Go下载和安装2.1 开发工具2.2 Go下载2.3 Go安装2.4 Idea安装go插件2.5 DOS命令3.基础语法3.1 Go执行流程3.1.1 Go基本目录结构3.1.2 第一个HelloWord3.1.3 编译teset.go3.1.4 执行test.ext3.1.5 编译+执行3.1.6 Golang执行流程3.2...
go 语言学习笔记 (已自动恢复).zip_Docker_Go 笔记_Go_ Go_ Go!_并行算法
09-20
Go语言通过内置的goroutine和channel机制，使得并行编程变得简单而直观。例如，你可以创建多个goroutine来并行处理任务，然后通过channel收集结果，实现任务的并行执行。此外，Go的`sync`包提供了互斥锁、读写锁等...
Golang底层原理学习笔记（三）
lcynone的博客
01-14 187
Golang底层原理学习笔记
Golang底层原理学习笔记（二）
lcynone的博客
01-14 211
Golang底层原理学习笔记
golang学习笔记（进阶篇）
lcynone的博客
01-13 698
Golang学习笔记_进阶篇
使用Spring连接mysql数据库
Valour616的博客
04-12 6232
使用Spring连接数据库 文章目录使用Spring连接数据库前言具体操作①创建maven项目，导入相关依赖②搭建项目的包结构③创建快递类编写Courier类配置Courier的bean建mysql表④使用DataSource连接数据库bean配置连接数据库编写增删改查代码测试功能add测试delete测试update测试list测试总结 前言 这篇文章主要介绍了Spring通过DataSource类连接数据库，通过JdbcTemplate类操作数据库的的步骤。并结合以上内容，辅以Spring的IOC特
[Golang]GIN框架源码分析(获取POST数据过程)
最新发布
Valour616的博客
06-15 528
本文通过阅读Golang的Gin框架源码，分析了Gin框架接收前端传来POST请求中携带数据的过程。
Java图形用户界面设计(Java学习记录)
Valour616的博客
10-20 380
JavaFx 1、Java窗体JFrame类 通过构造JFrame子类创造最简单的窗体 import javax.swing.*; public class Example extends JFrame { Example() { setSize(480, 360); setVisible(true); setTitle("win"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
centos导出当前所有yum包为本地仓库
Valour616的博客
06-08 343
讲述如何将当前centos系统中所有的yum包导出为本地仓库，以方便在离线系统内配置环境。
golang异常处理方案
Valour616的博客
05-08 205
简单介绍了三种常用的golang异常处理方案
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值