GoLang之切片并发安全问题

最新推荐文章于 2023-10-12 23:18:53 发布
最新推荐文章于 2023-10-12 23:18:53 发布
阅读量477 收藏 1
点赞数
分类专栏： Golang底层 文章标签： golang 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53267860/article/details/126820348
版权

GoLang之切片并发安全问题

目录

1.介绍切片并发问题

关于切片的，Go语言中的切片原生支持并发吗？

2.实践检验真理

实践是检验真理的唯一标准，所以当我们遇到一个不确定的问题，直接写demo来验证，因为切片的特点，我们可以分多种情况来验证
1.不指定索引，动态扩容并发向切片添加数据
2.指定索引，指定容量并发向切片添加数据

2.1不指定索引，动态扩容并发向切片添加数据

不指定索引，动态扩容并发向切片添加数据:
通过打印数据发现每次len与cap的结果都不一致

func concurrentAppendSliceNotForceIndex() {
	sl := make([]int, 0)
	wg := sync.WaitGroup{}
	for index := 0; index < 100; index++ {
		k := index
		wg.Add(1)
		go func(num int) {
			sl = append(sl, num)
			wg.Done()
		}(k)
	}
	wg.Wait()
	fmt.Println(sl)
	fmt.Printf("final len(sl)=%d cap(sl)=%d\n", len(sl), cap(sl))
}
func main() {
	concurrentAppendSliceNotForceIndex()
	/*第一次运行代码后，输出：[2 0 1 5 6 7 8 9 10 4 17 11 12 13 14 15 16 21 18 19 20 23 22 24 25 26 39 27 28 29 30 31 35 55 54 56 57 58 59 60 61 62 64 63 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 86 91 92 93 94 96 95 97 98 99]
	final len(sl)=74 cap(sl)=128*/
	//第二次运行代码后，输出：省略切片元素输出... final len(sl)=81 cap(sl)=128
	//第二次运行代码后，输出：省略切片元素输出... final len(sl)=77 cap(sl)=128
}

2.2指定索引，指定容量并发向切片添加数据

指定索引，指定容量并发向切片添加数据：
通过结果我们可以发现符合我们的预期，长度和容量都是100

func concurrentAppendSliceForceIndex() {
	sl := make([]int, 100)
	wg := sync.WaitGroup{}
	for index := 0; index < 100; index++ {
		k := index
		wg.Add(1)
		go func(num int) {
			sl[num] = num
			wg.Done()
		}(k)
	}
	wg.Wait()
	fmt.Println(sl)
	fmt.Printf("final len(sl)=%d cap(sl)=%d\n", len(sl), cap(sl))
}
func main() {
	concurrentAppendSliceForceIndex()
	/*第一次运行代码后，输出：[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 7
	9 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]
	final len(sl)=100 cap(sl)=100*/
	/*第一次运行代码后，输出：[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 7
	9 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]
	final len(sl)=100 cap(sl)=100*/
	/*第一次运行代码后，输出：[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 7
	9 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]
	final len(sl)=100 cap(sl)=100*/
}

3.回答切片并发安全问题

我们都知道切片是对数组的抽象，其底层就是数组，在并发下写数据到相同的索引位会被覆盖，并且切片也有自动扩容的功能，当切片要进行扩容时，就要替换底层的数组，在切换底层数组时，多个goroutine是同时运行的，哪个goroutine先运行是不确定的，不论哪个goroutine先写入内存，肯定就有一次写入会覆盖之前的写入，所以在动态扩容时并发写入数组是不安全的；

所以当别人问你slice支持并发时，你就可以这样回答它：

当指定索引使用切片时，切片是支持并发读写索引区的数据的，但是索引区的数据在并发时会被覆盖的；当不指定索引切片时，并且切片动态扩容时，并发场景下扩容会被覆盖，所以切片是不支持并发的～。

4.解决切片并发安全问题方式

针对上述问题，我们可以多种方法来解决切片并发安全的问题：
1.加互斥锁
2.使用channel串行化操作
3.使用sync.map代替切片

5.附

设置为1的的时候，runtime.GOMAXPROCS(1)

package main

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

func concurrentAppendSliceNotForceIndex() {
	sl := make([]int, 0)
	wg := sync.WaitGroup{}
	for index := 0; index < 100; index++ {
		k := index
		wg.Add(1)
		go func(num int) {
			sl = append(sl, num)
			wg.Done()
		}(k)
	}
	wg.Wait()
	fmt.Println(sl)
	fmt.Printf("final len(sl)=%d cap(sl)=%d\n", len(sl), cap(sl))
}
func main() {
	runtime.GOMAXPROCS(1)
	concurrentAppendSliceNotForceIndex()
	/*
		[99 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
		 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 5
		5 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
		82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98]
		final len(sl)=100 cap(sl)=128
	*/
	/*
		[13 0 1 2 3 4 5 6 7 8 9 10 11 12 99 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
		 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 5
		5 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
		82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98]
		final len(sl)=100 cap(sl)=128
	*/
	/*
		[10 0 1 2 3 4 5 6 7 8 9 99 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
		 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 5
		5 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
		82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98]
		final len(sl)=100 cap(sl)=128
	*/
}

package main

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

var wg sync.WaitGroup
var sl []int

func add() {
	for index := 0; index < 100; index++ {
		sl = append(sl, index)
	}
	wg.Done()
}
func main() {
	runtime.GOMAXPROCS(1)
	wg.Add(1)
	go add()
	wg.Wait()
	//无论执行多少次都输出一下结果
	fmt.Println(sl)
	fmt.Printf("final len(sl)=%d cap(sl)=%d\n", len(sl), cap(sl))
	/*
		[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 6
		3 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]
		final len(sl)=100 cap(sl)=128
	*/
}

package main

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

var wg sync.WaitGroup
var sl []int

func add() {
	for index := 0; index < 50; index++ {
		sl = append(sl, index)
	}
	wg.Done()
}
func main() {
	runtime.GOMAXPROCS(1)
	wg.Add(2)
	go add()
	go add()
	wg.Wait()
	//无论执行多少次都输出一下结果
	fmt.Println(sl)
	fmt.Printf("final len(sl)=%d cap(sl)=%d\n", len(sl), cap(sl))
	/*
			[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
		 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49]
		final len(sl)=100 cap(sl)=128
	*/
}

不限数量：

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup
var sl []int

func add() {
	for index := 0; index < 50; index++ {
		sl = append(sl, index)
	}
	wg.Done()
}
func main() {
	wg.Add(2)
	go add()
	go add()
	wg.Wait()
	fmt.Println(sl)
	fmt.Printf("final len(sl)=%d cap(sl)=%d\n", len(sl), cap(sl))
	/*
				[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
		 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49]
		final len(sl)=82 cap(sl)=128
	*/
}

加锁

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup
var sl []int
var lock sync.Mutex

func add() {
	for index := 0; index < 50; index++ {
		lock.Lock()
		sl = append(sl, index)
		lock.Unlock()
	}
	wg.Done()
}
func main() {
	wg.Add(2)
	go add()
	go add()
	wg.Wait()
	fmt.Println(sl)
	fmt.Printf("final len(sl)=%d cap(sl)=%d\n", len(sl), cap(sl))
	/*
		[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
		17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49]
		final len(sl)=100 cap(sl)=128

	*/
	/*
		[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
		 30 31 32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
		 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 33 34 35 3
		6 37 38 39 40 41 42 43 44 45 46 47 48 49]
		final len(sl)=100 cap(sl)=128
	*/
}
~庞贝
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go并发读写文件、分片写、分片下载文件
空山新雨后，天气晚来秋
05-25 2790
Go并发读写文件、分片写、分片下载文件（实用版）
Golang 中的 slice 为什么是并发不安全的？
lp15929801907的博客
05-10 1681
Golang 中的 slice 为什么是并发不安全的？怎样实现一个并发安全的 slice ?
go中的slice
白小白的小白的博客
08-31 818
go slice array
golang之slice并发访问
最新发布
techdashen的博客
10-12 376
没有到 9999 : 9999。
码住！Golang并发安全与引用传递总结
QcloudCommunity的博客
06-08 687
导语|因为现在服务上云的趋势，业务代码都纷纷转向golang的技术栈。在迁移或使用的过程中，由于对golang特性的生疏经常会遇到一些问题，本文总结了golang并发安全和参数引用传值时的一些知识。一、Map类型并发读写引发FatalError先看一个在Go中关于Map类型并发读写的经典例子：var testMap = map[string]string{} fu...
Go-golang-set-Go的线程安全的和非线程安全的高性能集
08-14
golang-set - Go的线程安全的和非线程安全的高性能集
go中数组、切片、map是否线程(并发)安全？
01-17 3462
李某人带你了解go中数组、切片、map的线程安全（面试版）
GO：切片Slice的概念，使用及线程安全性
AXIMI的博客
07-29 2967
文章目录二维切片 二维切片 创建 func main() { // 创建 res := make([][]int, row) for i := range res { res[i] = make([]int, column) } fmt.Println(res) // 遍历 for i, row := range res { for j, value := range res[i] { fmt.Print(res[i]][j]) } } } ...
golang_并发安全: slice和map并发不安全及解决方法
热门推荐
Grayan的博客
02-23 2万+
并发安全 并发安全也叫线程安全，在并发中出现了数据的丢失，称为并发不安全 map和slice都是并发不安全的 切片并发不安全 场景: 10000个协程同时添加切片 var s []int func appendValue(i int) { s = append(s, i) } func main() { for i := 0; i &lt; 10000; i++ { //10000个协程同...
concurrent-list:用于 go 的并发安全切片
06-29
并发列表 字符串类型的并发安全切片，列表不允许重复。 列表中的项目已排序，因此不要期望在索引 N-1 处找到第 N 个项目，请参见下面的示例。 用法 导入包： import ( "github.com/streamrail/concurrent-list" ) 例子 c := clist . New () c . Add ( "foo" ) c . Add ( "bar" ) // Prints "bar", "foo", list doesn't necessarily maintains insert order. for item := range c . IterBuffered () { fmt . Println ( item ) } j := c . ToJSON () dup := clist . FromJSON ( j ) if c
golang并发下载多个文件的方法
09-19
今天小编就为大家分享一篇golang并发下载多个文件的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Go中的快速并发/并行排序-Golang开发
05-26
sorty特定于类型的快速并发/并行排序库。 sorty是就地QuickSort实现（将InsertionSort作为子例程），不需要额外的内存。 调用相应的Sort *（）以并发地进行排序，从而实现特定于类型的快速并发/并行排序库。 sorty是...
一个简单高效的Go线程安全分片哈希图-Golang开发
05-26
碎片图（Shardmap）一种简单高效的Go安全线程安全碎片图。 这是标准Go映射和sync.Map的替代方法，并且针对您的映射需要执行大量并发读写的操作进行了优化。 碎片图下Go的一种简单高效的线程安全碎片图。 这是标准Go...
Golang 面试题汇编
05-21
实现阻塞读的并发安全Map 高并发下的锁与map读写问题 定时与 panic 恢复 为 sync.WaitGroup 中Wait函数支持 WaitTimeout 功能. 七道语法找错题目 golang 并发题目测试 记一道字节跳动的算法面试题 多协程查询切片...
go map/slice 并发写的线程安全问题
梦~'
03-11 1548
切片的写入和map一样都是非线程安全的，但是map有提供sync.Map{}。 切片只能通过 加锁 / channel 的方式来实现线程安全的并发写操作。 关于方法二（对于map也同理且适用）： 可以考虑把数据写入、更新的代码封装到一个 channel 中，有一个专门的协程来单独维护 slice 的数据更新。 // 方式一 加锁： func WriteDataToSlice1() { list := make([]int, 0) var mutex sync.Mutex ...
golang mysql大量写入_Golang 实现分片读取http超大文件流和并发控制
weixin_39954698的博客
02-01 641
分片读取http超大文件流Golang中的HTTP发送get请求，在获取内容有两种情况。Golang发送http get请求方式resp, err := http.Get(sendUrl)if err != nil {fmt.Println("出错", err)return}第一种方式是直接全部读取出来，这种方式在小数据量的时候很方便。body变量直接全部接收resp响应内容body, err2 ...
goLang 实现并发切片上传和下载文件
JineD的博客
07-19 2874
将大文件进行分片，定义分片规格为1M，比如有5M大小的文件，那么就会分成文件名为0，1，2，3，4，5这6个文件，上传到服务端后，服务端会创建一个uuid的文件夹用来保存这5个分片文件，并且会记录一个元数据文件，里面保存着该元数据文件对应哪个目录，文件切片大小、文件大小和文件md5等原信息。（7）开始读文件，如果是续传的，还可以根据续传情况进行偏移量偏移，跳过指定的切片段，读时每次只读1M，然后判断该切片是否已被上传过，如果上传过则无须再上传，可直接跳过，否则就创建一个goroutine进行异步上传；...
go记录之——slice
qq_52563729的博客
07-31 482
1
golang gorm 并发请求
08-10
golang中使用gorm进行并发请求时，可以通过goroutine和channel的方式来实现。 首先，我们需要确保已经正确地导入了gorm和相应的数据库驱动程序。然后，我们可以使用goroutine来创建并发请求。 假设我们有一个名为User的结构体，表示数据库中的用户表，其中包括id和name两个字段。 ```go type User struct { gorm.Model Name string } ``` 然后，我们可以创建一个用于处理请求的goroutine函数，如下所示： ```go func fetchUser(id int, result chan<-User, db *gorm.DB) { var user User db.First(&user, id) result <- user } ``` 在主函数中，我们可以创建一个用于保存结果的result通道，并启动多个goroutine来处理数据库查询： ```go func main() { db, err := gorm.Open("mysql", "user:password@tcp(host:port)/database") if err != nil { panic("failed to connect database") } defer db.Close() var result []User resultChan := make(chan User) go fetchUser(1, resultChan, db) go fetchUser(2, resultChan, db) go fetchUser(3, resultChan, db) for i := 0; i < 3; i++ { user := <-resultChan result = append(result, user) } // 处理结果 fmt.Println(result) } ``` 在以上示例中，我们创建了三个goroutine同时查询数据库，并将结果通过通道发送回主函数。主函数通过从通道中接收结果来等待所有查询完成，并将结果保存在result切片中。 这样，我们就可以实现并发查询数据库的功能。注意在使用gorm时要确保数据库连接的线程安全性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值