Go语言的并发编程

已于 2022-05-07 15:48:48 修改
阅读量2.5k 收藏 2
点赞数
分类专栏： Go语言 文章标签： golang 开发语言 后端
于 2022-02-03 21:49:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DXB2021/article/details/122777824
版权

并发指在同一时间内可以执行多个任务。并发编程含义比较广泛，包含多线程编程、多进程编程及分布式程序等。

Go语言里的并发指的是能让某个函数独立于其他函数运行的能力。当一个函数创建为协程（goroutine）时，Go语言会将其视为一个独立的工作单元，这个单元会被调度到可用的逻辑处理器上执行。

并发编程基础

1、并发与并行（理论没看懂）

理解操作系统的线程（thread）和进程（process），有助于理解Go语言运行时调度器如何得用操作系统来并发运行goroutine。

并行是让不同的代码片段同时在不同的物理处理器上执行。并行的关键是同时做很多事情，而并发是指同时管理很多事情，这些事情可能只做了一半就被暂停去做别的事情了。

使用较少的资源做更多的事情，是指导Go语言设计的哲学。

2、指定使用核心数

Go语言默认会调用CPU核心数，这些功能都是自动调整的，但是也提供了相应的标准库来指定核心数。使用flags包可以调整程序运行时调用的CPU核心数。

代码如下：

package main

import (
	"fmt"
	"time"
)

func longWait() {
	fmt.Println("开始longWait（）")
	time.Sleep(5 * 1e9)
	fmt.Println("结束longWait（）")
}

func shortWait() {
	fmt.Println("开始shortWait()")
	time.Sleep(2 * 1e9)
	fmt.Println("结束shortWait()")
}

func main() {
	fmt.Println("这里是main（）开始的地方")
	go longWait()
	go shortWait()
	fmt.Println("挂起main（）")
	time.Sleep(10 * 1e9)
	fmt.Println("这里是main（）结束的地方")
}

main()、longWait()和shortWait()三个函数作为独立的处理单元按顺序启动，然后开始并行运行，每一个函数都在运行的开始和结束阶段输出了消息。

运行结果如下：

这里是main（）开始的地方
挂起main（）
开始longWait（）
开始shortWait()
结束shortWait()
结束longWait（）
这里是main（）结束的地方

如果移除go语言关键字同，重新运行程序：

这里是main（）开始的地方
开始longWait（）
结束longWait（）
开始shortWait()
结束shortWait()
挂起main（）
这里是main（）结束的地方

协程（goroutine）

操作系统自己掌管的进程（process）、进程内的线程（thread）以及进程内的协程（coroutine，也叫轻量级线程）。

协程的最大优势在于其“轻量级”，可以轻松创建上百万个协程而不会导致系统资源衰竭，而线程和进程通常最多也不能超过1万个。

Go语言在语言级别支持轻量级线程，叫goroutine。

1、协程基础

goroutine是Go语言并行设计的核心。

goroutine是通过Go程序的runtime管理的一个线程管理器。goroutine通过go关键字实现了，其实就是一个普通的函数。

代码如下：

package main

import (
	"fmt"
	"runtime"
)

func say(s string) {
	for i := 0; i < 5; i++ {
		runtime.Gosched()
		fmt.Println(s)
	}
}

func main() {
	go say("world")
	say("hello")
}

运行结果如下：与书本不一样。

hello
hello
hello
hello
hello

书本是：

hello
world
hello
world
hello
world
hello
world
hello

并发处理：Go例程，代码如下：

package main

import (
	"fmt"
)

func routine1(index int) {
	for i := 0; i < 10; i++ {
		fmt.Println(index, " : ", i)
	}
}
func main() {
	go routine1(1)
	go routine1(2)
	for i := 0; i < 10; i++ {
		fmt.Println("0: ", i)
	}
}

运行结果如下：（感觉不对，不明白什么意思）

0:  0
0:  1
0:  2
0:  3
0:  4
0:  5
0:  6
0:  7
0:  8
0:  9

2、协程间通信

通常有两种最常见的并发通信模型：共享数据和消息。

代码如下：

package main

import (
	"fmt"
	"runtime"
	"sync"
)

var counter int = 0

func Count(lock *sync.Mutex) {
	lock.Lock()
	counter++
	fmt.Println(z)
	lock.Unlock()
}

func main() {
	lock := &sync.Mutex{}
	for i := 0; i < 10; i++ {
		go Count(lock)
	}
	for {
		lock.Lock()
		c := counter
		lock.Unlock()
		runtime.Gosched()
		if c >= 10 {
			break
		}
	}
}

运行结果如下：

# command-line-arguments
./main.go:14:14: undefined: z

不要通过共享内存来通信，而应该通过通信来共享内存。

package main

import "fmt"

func Add(x, y int) {
	z := x + y
	fmt.Println(z)
}

func main() {
	for i := 0; i < 10; i++ {
		go Add(i, i)
	}
}

无运行结果。

通道（Channel）

代码如下：

package main

import (
	"fmt"
)

func Count(ch chan int) {
	ch <- 1
	fmt.Println("Counting")
}

func main() {
	chs := make([]chan int, 10)
	for i := 0; i < 10; i++ {
		chs[i] = make(chan int)
		go Count(chs[i])
	}
	for _, ch := range chs {
		<-ch
	}
}

1、基本语法

一般channel的声明形式为：

var chanName chan ElementType

在channel的用法中，最常见的包括写入和读出。

将一个数据写入（发送）到channel的语法很直观：

ch <- value

从channel中读取数据的语法是：

value:=<-ch

2、select

Go语言直接在语言级别支持select关键字，用于处理异步I/O问题。

3、缓冲机制

4、超时和计时器

5、channel的传递

6、单向channel

7、关闭channel

使用go语言内置的close()函数如下：

close(ch)

并发进阶

1、多核并行化

2、协程同步

只有在当需要告诉接受者不会再提供新的值的时候，才需要关闭通道。

只有发送者需要关闭通道，接收都永远不会需要。

代码如下：

package main

import (
	"fmt"
	"time"
)

func sendData(ch chan string) {
	ch <- "纽约"
	ch <- "华盛顿"
	ch <- "伦敦"
	ch <- "北京"
	ch <- "东京"
}

func getData(ch chan string) {
	var input string
	for {
		input = <-ch
		fmt.Printf("%s ", input)
	}
}

func main() {
	ch := make(chan string)
	go sendData(ch)
	go getData(ch)
	time.Sleep(1e9)
}

运行结果如下：

纽约 华盛顿 伦敦 北京 东京

代码如下：

package main

import (
	"fmt"
)

func sendData(ch chan string) {
	ch <- "纽约"
	ch <- "华盛顿"
	ch <- "伦敦"
	ch <- "北京"
	ch <- "东京"
	close(ch)
}

func getData(ch chan string) {
	for {
		input, open := <-ch
		if !open {
			break
		}
		fmt.Printf("%s ", input)
	}
}

func main() {
	ch := make(chan string)
	go sendData(ch)
	getData(ch)
}

运行结果如下：

纽约 华盛顿 伦敦 北京 东京

为一个普通函数创建goroutine的写法如下：

go 函数名（参数列表）

函数名：要调用的函数名。

参数列表：调用函数需要传入的参数。

使用go关键字创建goroutine时，被调用函数的返回值会被忽略。

代码如下：

package main

import (
	"fmt"
	"time"
)

func running() {
	var times int
	//构建一个无限循环
	for {
		times++
		fmt.Println("tick", times)
		//延时1秒
		time.Sleep(time.Second)
	}
}

func main() {
	//并发执行程序
	go running()
	//接受命令行输入，不做任何事情
	var input string
	fmt.Scanln(&input)
}

使用匿名函数创建goroutine的格式

go func (参数列表) {

        函数体

} (调用参数列表)

参数列表：函数体内的参数变量列表

函数体：匿名函数的代码。

调用参数列表：启动goroutine时，需要向匿名函数传递的调用函数。

代码如下：

package main

import (
	"fmt"
	"time"
)

func main() {

	go func() {
		var times int
		for {
			times++
			fmt.Println("tick", times)
			time.Sleep(time.Second)
		}
	}()
	var input string
	fmt.Scanln(&input)
}

调整并发的运行恒通（GOMAXPROCS）

格式如下：

runtime.GOMAXPROCS(逻辑CPU数量)

这里的逻辑CPU数量可以有如下几种数值：

<1：不修改任何数值。

=1：单核心执行。

>1：多核并发执行。

一般情况下，可以使用funtime.NumCPU()查询CPU数量 ，并使用runtime.GOMAXPROCS()函数进行设置，例如：

runtime.GOMAXPROCS(runtime.NumCPU())

理解并发和并行

并发（concurrency）：把任务在不同的时间点交给处理器进行处理。在同一个时间点，任务并不会同时运行。

并行（parallelism）：把每一个任务分配给每一个处理器独立完成。在同一个时间点，任务一定是同时运行。

代码如下：

package main

import (
	"fmt"
)

func sum(values []int, resultChan chan int) {
	sum := 0
	for _, value := range values {
		sum += value
	}
	resultChan <- sum		//将计算结果发送到channel中
}

func main() {
	values := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	resultChan := make(chan int, 2)
	go sum(values[:len(values)/2], resultChan)
	go sum(values[len(values)/2:], resultChan)
	sum1, sum2 := <-resultChan, <-resultChan		//接收结果
	fmt.Println("Result:", sum1, sum2, sum1+sum2)
}

运行结果如下：

Result: 40 15 55

去程：

代码如下：

package main

import (
	"fmt"
	"time"
)

func sheep(i int) {
	for ; ; i += 2 {
		fmt.Println(i, "只羊")
	}
}

func main() {
	go sheep(1)
	go sheep(2)
	time.Sleep(time.Millisecond)
}

运行结果如下：

2 只羊
4 只羊
6 只羊
8 只羊
10 只羊
12 只羊
14 只羊
16 只羊
18 只羊
20 只羊
22 只羊
24 只羊
26 只羊
28 只羊
30 只羊
32 只羊
34 只羊
36 只羊
38 只羊
40 只羊
42 只羊
44 只羊
46 只羊
48 只羊
50 只羊
52 只羊
54 只羊
56 只羊
58 只羊
60 只羊
62 只羊
64 只羊
66 只羊
68 只羊
70 只羊
72 只羊
74 只羊
76 只羊
78 只羊
80 只羊
82 只羊
84 只羊
86 只羊
88 只羊
90 只羊
92 只羊
94 只羊
96 只羊
98 只羊
100 只羊
102 只羊
104 只羊
106 只羊
108 只羊
110 只羊

回程：

代码如下：

package main

import (
	"fmt"
	"time"
)

var wormhole chan time.Time

func deepspace() {
	wormhole <- time.Now()
}

func main() {
	wormhole = make(chan time.Time)
	go deepspace()
	fmt.Println(<-wormhole)
}

运行结果如下：

2022-04-06 15:47:02.3888929 +0800 CST m=+0.002617601

遍历与关闭：

代码如下：

package main

import (
	"fmt"
	"time"
)

type hole chan time.Time

func deepspace(w hole, h int) {
	defer close(w)
	for ; h > 0; h-- {
		w <- time.Now()
		time.Sleep(time.Second)
	}
}

func consumer(w hole) {
	for msg := range w {
		fmt.Println("consumer", msg)
	}
}

func main() {
	w := make(hole)
	go deepspace(w, 8)
	go consumer(w)
	for {
		msg, ok := <-w
		if !ok {
			break
		}
		fmt.Println("main", msg)
	}
	fmt.Println("Done")
}

运行结果如下：

main 2022-04-09 14:52:07.041789 +0800 CST m=+0.002800701
consumer 2022-04-09 14:52:08.0456268 +0800 CST m=+1.006638501
main 2022-04-09 14:52:09.0578227 +0800 CST m=+2.018834401
consumer 2022-04-09 14:52:10.0705782 +0800 CST m=+3.031589901
main 2022-04-09 14:52:11.0742367 +0800 CST m=+4.035248401
consumer 2022-04-09 14:52:12.0782694 +0800 CST m=+5.039281101
main 2022-04-09 14:52:13.0930031 +0800 CST m=+6.054014801
consumer 2022-04-09 14:52:14.0936872 +0800 CST m=+7.054698901
Done

MapReduce：

映射化简：每个去程对应一个Map并发执行，结果写入缓冲程道，最后再用一个Reduce函数综合这个程道得到的每一个值。

代码如下：

package main

import (
	"fmt"
	"math/rand"
)

type hole chan int

func deepspace(w hole) {
	w <- rand.Int()
}

func main() {
	n := 8
	w := make(hole, n)
	//Map
	for i := 0; i < n; i++ {
		go deepspace(w)
	}
	//Reduce
	t := 0
	for i := 0; i < n; i++ {
		t += <-w
	}
	fmt.Println("Total:", t)
}

运行结果 如下：

Total: -174686420686987236

两个goroutine进行并行的累加计算：代码如下：

package main

import (
	"fmt"
)

func sum(values []int, resultChan chan int) {
	sum := 0
	for _, value := range values {
		sum += value
	}
	resultChan <- sum
}

func main() {
	values := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	resultChan := make(chan int, 2)
	go sum(values[:len(values)/2], resultChan)
	go sum(values[len(values)/2:], resultChan)
	sum1, sum2 := <-resultChan, <-resultChan
	fmt.Println("Result:", sum1, sum2, sum1+sum2)
}

运行结果如下：

Result: 40 15 55

select语句：

代码如下：

package main

import (
	"fmt"
	"math/rand"
	"time"
)

type hole chan int

func deepspace(w hole, h int) {
	defer close(w)
	d := time.Duration(rand.Intn(h)) * time.Second
	for ; h > 0; h-- {
		w <- rand.Int()
		time.Sleep(d)
	}
}

func main() {
	n := 8
	w := make(hole)
	t := 0
	maxTime := time.Second
	go deepspace(w, n)
Out:
	for i := 0; i < n; i++ {
		select {
		case n := <-w:
			t += n
		case <-time.After(maxTime):
			fmt.Println("Time out")
			break Out
		}
	}
	fmt.Println("Total:", t)
}

运行结果如下：

Time out
Total: 8674665223082153551

程道值：

代码如下：

package main

import (
	"fmt"
)

type Read struct {
	key   string
	reply chan<- string
}

type Write struct {
	key string
	val string
}

var hole = make(chan interface{})

func deepspace() {
	m := map[string]string{}
	for {
		switch r := (<-hole).(type) {
		case Read:
			r.reply <- m[r.key] + " from Mars."
		case Write:
			m[r.key] = r.val
		}
	}
}

func main() {
	go deepspace()
	hole <- Write{"Name", "Martin"}
	home := make(chan string)
	hole <- Read{"Name", home}
	fmt.Println(<-home)
}

运行结果如下：

Martin from Mars.

DXB2021
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Go语言并发编程
GeeCode的博客
07-17 206
Go语言通过goroutine和channel提供了强大的并发编程支持。goroutine是一种轻量级的线程，可以在Go语言运行时环境中创建数千个goroutine，而且创建和销毁goroutine的代价非常小；channel是一种通信机制，用于在goroutine之间传递数据。在本篇技术博客中，我们将介绍如何使用goroutine和channel实现并发编程，包括goroutine的创建和销毁、channel的创建和使用、goroutine的同步和互斥、以及相关的示例代码。
Go语言并发编程（一）
古月林夕のblog
08-27 2824
Go语言的特色不得不提的就是并发机制，在C语言中编写非常繁琐复杂的并发程序在Go语言中可以非常便捷。Go中并发程序主要通过goroutine和channel来实现。这篇文章我主要是解释一下的是“并发”一词，以及goroutine实现并发与并行的原理。
go语言的并发编程
m0_69298614的博客
07-10 236
go语言原生就支持协程，底层就实现了协程调度，高并发是go语言的特性之一。
2024年Go最全并行计算之OpenMP入门简介_openmp 并行计算，offer拿到手软
2401_84931491的博客
05-11 284
的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！#pragma omp parallel [for | sections] [子句[子句]…#pragma omp [parallel] sections [子句]#pragma omp [parallel] for [子句]// 需要并行执行的代码。
Go语言并发详解
qq_41854911的博客
11-09 7577
文章目录一、Go语言并发简述（并发的优势）进程/线程并发/并行协程/线程Goroutine 介绍channel二、Go语言goroutine（轻量级线程）使用普通函数创建 goroutine1) 格式2) 例子使用匿名函数创建goroutine1) 使用匿名函数创建goroutine的格式2) 使用匿名函数创建goroutine的例子提示三、Go语言并发通信四、Go语言竞争状态简述Goroutine 7 (finished) created at: main.main() D:/code/src/m
Go 并发编程
qq_46457076的博客
01-17 672
关于 Go 语言之高性能并发编程的基础知识！
【go 并发编程】go 语言并发执行5个不同的函数
赖德发的博客
04-14 482
在上面的示例程序中，我们首先定义了 5 个函数：foo1、foo2、foo3、foo4 和 foo5。然后，我们创建了一个 WaitGroup 用于同步 Goroutine 的执行，并启动了 5 个 Goroutine，每个 Goroutine 执行一个函数。需要注意的是，在使用 Goroutine 时，您需要确保在并发访问共享资源时进行适当的同步，以避免数据竞争和死锁等问题。在本例中，我们使用了 sync.WaitGroup 来同步 Goroutine 的执行。
Go语言进阶：并发编程与goroutines详解
最新发布
06-29
Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶Go语言进阶...
深入解析Go语言并发编程中的协程机制与应用场景
04-25
深入解析Go语言并发编程中的协程机制与应用场景
GO语言并发编程之互斥锁、读写锁详解
01-20
在本节，我们对Go语言所提供的与锁有关的API进行说明。这包括了互斥锁和读写锁。我们在第6章描述过互斥锁，但却没有提到过读写锁。这两种锁对于传统的并发程序来说都是非常常用和重要的。 一、互斥锁 互斥锁是传统的...
Go并发编程实践
12-25
并发编程一直是Golang区别与其他语言的很大优势，也是实际工作场景中经常遇到的。近日笔者在组内分享了我们常见的并发场景，及代码示例，以期望大家能在遇到相同场景下，能快速的想到解决方案，或者是拿这些方案与...
Go并发编程
上山的人
05-07 1257
并发介绍 进程和线程 A. 进程是程序在操作系统中的一次执行过程，系统进行资源分配和调度的一个独立单位。 B. 线程是进程的一个执行实体，是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。 C.一个进程可以创建和撤销多个线程；同一个进程中的多个线程之间可以并发执行。 协程和线程 协程：独立的栈空间，共享堆空间，调度由用户自己控制，本质上有点类似于用户级线程，这些用户级线程的调度也是自己实现的。线程：一个线程上可以跑多个协程，协程是轻量级的线程...
Go语言之并发编程
凯歌技术控团队
07-19 281
有人把Go语言比作 21 世纪的C语言，第一是因为Go语言设计简单，第二则是因为 21 世纪最重要的就是并发程序设计，而 Go 从语言层面就支持并发。同时实现了自动垃圾回收机制。Go语言的并发机制运用起来非常简便，在启动并发的方式上直接添加了语言级的关键字就可以实现，和其他编程语言相比更加轻量。
Go并发编程详解
金戈鐡馬
12-04 1296
随着硬件的发展，并发程序变得越来越重要。Web服务器会一次处理成千上万的请求。平板电脑和手机app在渲染用户画面同时还会后台执行各种计算任务和网络请求。即使是传统的批处理问题--读取数据，计算，写输出--现在也会用并发来隐藏掉I/O的操作延迟以充分利用现代计算机设备的多个核心。计算机的性能每年都在以非线性的速度增长。
如何在Go中并发运行多个函数
热门推荐
CHQIUU的专栏
12-17 1万+
在本教程中，你使用go关键字创建了一个程序来启动并发运行的goroutines，并在运行时打印出数字。程序运行后，你使用创建了一个包含int值的新通道，然后使用该通道在一个goroutine中生成数字，并将它们发送到另一个goroutine并打印到屏幕上。最后，你同时启动了多个“打印”goroutines，作为在多核计算机上如何使用通道和goroutines来加速程序的示例。如果您有兴趣了解更多关于Go中的并发性，Go团队创建的文档有更详细的介绍。并发不是并行。
【Go】六、并发编程
Czh的博客
04-22 796
作为Go区别于其他语言的巨对优势点，并发编程值得我们去深入研究！本文通过2w字长文，多方面对并发编程的重点进行列举，并用简单的小demo进行举例。
go语言学习 —— go并发编程
Charles Ren's Tech Blog
05-12 792
文章目录go并发构建go协程使用普通函数构建goroutine使用匿名函数构建go并发与并行go并发go并行go并发通信使用共享变量channel通道机制（无缓冲通道举例）创建通道将数据放入通道接收通道中的数据特性：接收方式举例：阻塞接收举例：循环接收通道类型有缓冲通道单向通道 go并发 Go 语言的并发通过 goroutine 特性完成。goroutine 类似于线程，但是可以根据需要创建多个 goroutine 并发工作。 Go 语言还提供 channel 在多个 goroutine 间进行通信 gor
golang并发编程实战
03-08
首先，文章从介绍Go语言的基础概念开始，涵盖了goroutine，它是Golang中轻量级的线程，允许多个函数在同一时刻执行，通过调度器自动管理资源的切换。goroutine的创建与调度非常简单，只需关键字`go`即可启动一个新...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值