Go语言开发保证并发安全实例详解

2024-09-28 05:37:48

什么是并发安全？

在高并发场景下，进程、线程（协程）可能会发生资源竞争，导致数据脏读、脏写、死锁等问题，为了避免此类问题的发生，就有了并发安全。

这里举一个简单的例子：

 var data int
 go func() {
   data++
 }()
 if data == 0 {
   fmt.Printf("the value is %v.\n", data)
 }

在这段代码中

第2行go关键字开启了一个新的协程，来执行data++操作

第5行，对data变量进行了读取判断的操作

以上两部是由2个不同线程/协程运行，且没有任何措施保证执行顺序，所以执行结果是不确定的。

没有输出。（第3行是在第5行之前执行的）
输出 the value is 0。（第5行和第6行在第3行之前执行）
输出 the value is 1。（第5行在第3行之前执行，但第3行在第6行之前执行）

Go如何保证并发安全

目前了解到的，大概有这3种，Mutex、Channel、Atomic

Mutex

加锁应该是最常见的并发控制方法，一般分成两种，乐观锁和悲观锁。

锁是由操作系统的调度器来实现的，锁通常用来保护一段逻辑，

悲观锁

悲观锁是一种悲观思想，它总认为最坏的情况可能会出现。不管意料之外的结果是否会发生，只要存在发生的可能，就在操作这个资源之前先上锁。例如互斥锁、读写锁都是悲观锁。

在go中，除了automic，其它都是悲观锁

悲观锁应该都是由操作系统的调度器来实现的，通常用来保护一段逻辑，主要是通过阻塞其它线程，保证当前时刻只有一个线程在对资源进行操作，因此性能相对较差，浪费了计算机多核的优势。

乐观锁

乐观锁的思想与悲观锁的思想相反，它总认为资源和数据不会被别人所修改，所以读取不会上锁，但是乐观锁在进行写入操作的时候会判断当前数据是否被修改过。

乐观锁的实现方案主要包含CAS和版本号机制。

乐观锁适用于多读的场景，可以提高吞吐量。

版本号机制

通过在数据表中，增加一个版本号字段，当数据发生更新时，版本号值发生改变。例如一个线程A想要更新变量s的值，在读取s的值的同时读取版本号，在提交更新时，用之前读到的版本号值与当前的版本号值进行比对，当且仅当版本号值一致时，才会触发更新，否则不断进行重试，直到更新成功。

CAS

CAS全名为Compare And Swap，即比较与转换，是一种有名的无锁算法。在不使用锁的情况下，实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步，

互斥锁

GO使用Sync包的Mutex类型来实现互斥锁，它能保证同时只有一个goroutine可以访问资源。

func sample() {
	var l sync.Mutex
	l.Lock()
        defer l.Unlock()
	// so something
}

读写互斥锁

GO使用Sync包的RWMutex类型来实现互斥锁。当我们去并发的读取一个资源，只要数据没有发生写入，是没必要加锁的。因此读多写少的情况下，使用读写互斥锁是更好的选择，性能更好。

读写锁分为两种：读锁和写锁。

当一个goroutine获取读锁之后，其他的goroutine如果是获取读锁可以顺利获得，如果是获取写锁就会等待；

当一个goroutine获取写锁之后，其他的goroutine无论是获取读锁还是写锁都会等待。

package main
import (
	"fmt"
	"sync"
	"time"
)
var (
	wg     sync.WaitGroup
	rwlock sync.RWMutex
)
func write() {
	rwlock.Lock() // 加写锁
	time.Sleep(10 * time.Millisecond)
	rwlock.Unlock() // 解写锁
	wg.Done()
}
func read() {
	rwlock.RLock() // 加读锁
	time.Sleep(time.Millisecond)
	rwlock.RUnlock() // 解读锁
	wg.Done()
}
func main() {
	start := time.Now()
	//读多
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go read()
	}
	//写少
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go write()
	}
	wg.Wait()
	end := time.Now()
	fmt.Println(end.Sub(start))
}

以上就是Go语言开发保证并发安全实例详解的详细内容，更多关于Go保证并发安全的资料请关注我们其它相关文章！

Go语言中map使用和并发安全详解

目录 1 map使用 1.1 map定义 1.2 map的使用和概念 1.3 map的容量 1.4 map的使用 1.4.1 map的遍历 1.4.2 map的删除和断言 1.5 map的坑 2 并发安全 2.1 不安全原因 2.2 解决方案总结 1 map使用 1.1 map定义 map是一种无序的集合,对应的key (索引)会对应一个value(值),所以这个结构也称为关联数组或字典. map在其他语言中hash.hash table等 var mapname map[keytype]va
解析golang中的并发安全和锁问题

1. 并发安全 package main import ( "fmt" "sync" ) var ( sum int wg sync.WaitGroup ) func test() { for i := 0; i < 5000000; i++ { sum += 1 } wg.Done() } func main() { // 并发和安全锁 wg.Add(2) go test() go test() wg.Wait() fmt.Println(sum) } 上面
golang并发安全及读写互斥锁的示例分析

目录并发安全和锁互斥锁读写互斥锁并发安全和锁有时候在Go代码中可能会存在多个goroutine同时操作一个资源(临界区),这种情况会发生竞态问题(数据竞态).类比现实生活中的例子有十字路口被各个方向的的汽车竞争:还有火车上的卫生间被车厢里的人竞争. 举个例子: var x int64 var wg sync.WaitGroup func add() { for i := 0; i < 5000; i++ { x = x + 1 } wg.Done() } func main() { w
详解go语言中并发安全和锁问题

首先可以先看看这篇文章,对锁有些了解 [锁]详解区分互斥锁.⾃旋锁.读写锁.乐观锁.悲观锁 Mutex-互斥锁 Mutex 的实现主要借助了 CAS 指令 + 自旋 + 信号量数据结构: type Mutex struct { state int32 sema uint32 } 上述两个加起来只占 8 字节空间的结构体表示了 Go语言中的互斥锁状态: 在默认情况下,互斥锁的所有状态位都是 0,int32 中的不同位分别表示了不同的状态: 1位表示是否被锁定 1位表示是否有协程已经被唤醒 1
GoFrame框架garray并发安全数组使用开箱体验

目录前言普通数组 Append At Chunk Clear Clone PopLefts 总结前言今天在搞一个需求,从三方获得有信息变更的商品,更新自己的数据库,再推送给下游进行商品更新. 期间有更新商品数量不确定,为了保证程序稳定性,每组向下游推送20个商品id. 查了garray的文档,发现支持Chunk()方法,灰常好用. func commonSendMessage(goodsIds *garray.IntArray, messageType int) { goodsIdsCh
golang 并发安全Map以及分段锁的实现方法

涉及概念并发安全Map 分段锁 sync.Map CAS ( Compare And Swap ) 双检查分断锁 type SimpleCache struct { mu sync.RWMutex items map[interface{}]*simpleItem } 在日常开发中, 上述这种数据结构肯定不少见,因为golang的原生map是非并发安全的,所以为了保证map的并发安全,最简单的方式就是给map加锁. 之前使用过两个本地内存缓存的开源库, gcache, cache2go,其中
Go语言开发保证并发安全实例详解

目录什么是并发安全? Mutex 悲观锁乐观锁版本号机制 CAS 互斥锁读写互斥锁什么是并发安全? 在高并发场景下,进程.线程(协程)可能会发生资源竞争,导致数据脏读.脏写.死锁等问题,为了避免此类问题的发生,就有了并发安全. 这里举一个简单的例子: var data int go func() { data++ }() if data == 0 { fmt.Printf("the value is %v.\n", data) } 在这段代码中第2行go关键字开启了一个新的
Kotlin 语言中调用 JavaScript 方法实例详解

Kotlin 语言中调用 JavaScript 方法实例详解 Kotlin 已被设计为能够与 Java 平台轻松互操作.它将 Java 类视为 Kotlin 类,并且 Java 也将 Kotlin 类视为 Java 类.但是,JavaScript 是一种动态类型语言,这意味着它不会在编译期检查类型.你可以通过动态类型在 Kotlin 中自由地与 JavaScript 交流,但是如果你想要 Kotlin 类型系统的全部威力 ,你可以为 JavaScript 库创建 Kotlin 头文件. 内联 J
C语言数据结构链表与归并排序实例详解

C语言数据结构链表与归并排序实例详解归并排序适合于对链表进行原址排序,即只改变指针的连接方式,不交换链表结点的内容. 归并排序的基本思想是分治法:先把一个链表分割成只有一个节点的链表,然后按照一定顺序.自底向上合并相邻的两个链表. 只要保证各种大小的子链表是有序的,那么最后返回的链表就一定是有序的. 归并排序分为分割和合并两个子过程.分割是用递归的方法,把链表对半分割成两个子链表:合并是在递归返回(回朔)的时候,把两个有序链表合并成一个有序链表. (注意:只有一个节点的链表一定是有序的) 这
C语言树状数组的实例详解

C语言树状数组的实例详解最近学了树状数组,给我的感觉就是这个数据结构好神奇啊^_^ 首先她的常数比线段树小,其次她的实现复杂度也远低于线段树 (并没有黑线段树的意思=-=) 所以熟练掌握她是非常有必要的.. 关于树状数组的基础知识与原理网上一搜一大堆,我就不赘述了,就谈一些树状数组的应用好了 1,单点修改,求区间和 #define lowbit(x) (x&-x) // 设 x 的末尾零的个数为 y , 则 lowbit(x) == 2^y void Update(int i,int v)
C语言中联合体union的实例详解

C语言中联合体union的实例详解 1.定义: union(int i, short s, char c) un; un.i = 3; printf("i=%d",un.i); printf("length = %d\n",sizeof(un);//==4,有最大的变量来决定 2.相当与java里的List T类型 3.数据交换 void swap(int *p , int *q){ int temp = *p; *p = *q; *q = temp; } 4.打
C语言中二级指针的实例详解

C语言中二级指针的实例详解用图说明示例代码: #include <stdio.h> int main(int argc, const char * argv[]) { // int a = 5; int *p1 = &a; //-打印地址-----地址相同--------------- printf("&a = %p\n", &a);// printf("p1 = %p\n", p1);// int **p2 = &p
C语言中调用Swift函数实例详解

C语言中调用Swift函数实例详解在Apple官方的<Using Swift with Cocoa and Objectgive-C>一书中详细地介绍了如何在Objective-C中使用Swift的类以及如何在Swift中使用Objective-C中的类.在后半部分也介绍了如何在Swift中使用C函数,不过对于如何在C语言中使用Swift函数却只字未提.这里我就为大家分享一下如何在C语言中调用Swift函数. 我们首先要知道的是,所有Swift函数都属于闭包.其次,Swift函数的调用约定与
C语言实现“幸运数”的实例详解

C语言实现"幸运数"的实例详解 1.题目: 标题:幸运数幸运数是波兰数学家乌拉姆命名的.它采用与生成素数类似的"筛法"生成. 首先从1开始写出自然数1,2,3,4,5,6,-. 1 就是第一个幸运数. 我们从2这个数开始.把所有序号能被2整除的项删除,变为: 1 _ 3 _ 5 _ 7 _ 9 -. 把它们缩紧,重新记序,为: 1 3 5 7 9 -. .这时,3为第2个幸运数,然后把所有能被3整除的序号位置的数删去.注意,是序号位置,不是那个数本身能否被3整除!
C语言数据输入与输出实例详解

C语言数据输入与输出实例详解 1 概论 C语言提供了跨平台的数据输入输出函数scanf()和printf()函数,它们可以按照指定的格式来解析常见的数据类型,例如整数,浮点数,字符和字符串等等.数据输入的来源可以是文件,控制台以及网络,而输出的终端可以是控制台,文件甚至是网页. 2 数据输出从第一个c语言程序中,就使用了跨平台的库函数printf实现将一段文字输出到控制台,而实际上,printf()不仅可以将数据按照指定的格式输出到控制台,还可以是网页或者是指定的文件中,printf()函数执
java ThreadPoolExecutor 并发调用实例详解

java ThreadPoolExecutor 并发调用实例详解概述通常为了提供任务的处理速度,会使用一些并发模型,ThreadPoolExecutor中的invokeAll便是一种. 代码 package test.current; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.concurrent.Callable; import java.util

Go语言开发保证并发安全实例详解

目录

什么是并发安全？

Mutex

悲观锁

乐观锁

版本号机制

CAS

互斥锁

读写互斥锁

相关推荐

随机推荐