浅谈golang并发操作变量安全的问题
我就废话不多说了，大家还是直接看代码吧~
package main
import (
"fmt"
"time"
"sync"
"sync/atomic"
)
func main() {
test1()
test2()
}
func test1() {
var wg sync.WaitGroup
count := 0
t := time.Now()
for i := 0 ; i < 50000 ; i++ {
wg.Add(1)
go func(wg *sync.WaitGroup,i int) {
count++ //count不是并发安全的
wg.Done()
}(&wg,i)
}
wg.Wait()
fmt.Println(time.Now().Sub(t))
fmt.Println("count====>",count) //count的值<50000
fmt.Println("exit")
}
func test2() {
var wg sync.WaitGroup
count := int64(0)
t := time.Now()
for i := 0 ; i < 50000 ; i++ {
wg.Add(1)
go func(wg *sync.WaitGroup,i int) {
atomic.AddInt64(&count,1) //原子操作
wg.Done()
}(&wg,i)
}
wg.Wait()
fmt.Println(time.Now().Sub(t))
fmt.Println("count====>",count) //count的值为50000
fmt.Println("exit")
}
执行结果：
18.0485ms count====> 46621 exit 16.0418ms count====> 50000 exit
补充：golang 基于共享变量的并发
并发定义：当我们没有办法自信地确认一个事件是在另一个事件的前面或者后面发生的话，就说明x和y这两个事件是并发的。
并发安全：如果其所有可访问的方法和操作都是并发安全的话，那么类型便是并发安全的。
竞争条件：程序在多个goroutine交叉执行操作时，没有给出正确的结果。
只要有
两个goroutine并发访问
同一变量，且至
少其中的一个是写操作的时候就会发生数据竞争。
数据竞争会在两个以上的goroutine并发访问相同的变量且至少其中一个为写操作时发生。
第一种：不要去写变量，变量直接提前初始化。
第二种：多个只允许一个goroutine访问变量，用select来监听操作（go的金句：不要通过共享变量来通信，通过通信（channel)来共享变量）。
第三种：允许过个goroutine访问变量，但是同一时间只允许一个goroutine访问。
现在我们来讲第三种情况具体操作
golang 我们可以通过channel作为计量器，可以保证可以有多少个goroutine可以同时访问。make(chan struct{},1)，通过写入读取用阻塞的方式锁定住指定的代码块的访问。
var (
sema = make(chan struct{}, 1) // a binary semaphore guarding balance
balance int
)
func Deposit(amount int) {
sema <- struct{}{} // acquire token
balance = balance + amount
<-sema // release token
}
func Balance() int {
sema <- struct{}{} // acquire token
b := balance
<-sema // release token
return b
}
可以保证同一时刻只有一个goroutine来访问。
然而我们可以用sync包中的Mutex来实现上面的功能，那就是：
互斥锁 sync.Mutex
互斥锁：保证共享变量不会被并发访问。
import "sync"
var (
mu sync.Mutex // guards balance
balance int
)
func Deposit(amount int) {
mu.Lock()
balance = balance + amount
mu.Unlock()
}
func Balance() int {
mu.Lock()
b := balance
mu.Unlock()
return b
}
在Lock和Unlock之间的代码段中的内容goroutine可以随便读取或者修改，这个代码段叫做临界区。
注意：一定要释放锁(Unlock)，不管任何情况，可以利用defer Mutex.Unlock()，一定要注意go里没有重入锁，如果遇到更小原子的操作，考虑分解成不带锁功能的小块函数
接下来我们将另一种锁：读写锁sync.RWMutex
很多情况我们需要保证读的性能，而互斥锁会短暂的阻止其他的goroutine的运行，没法达到很好的多并发效果（多读单写），这时读写锁就可以很好的解决这个问题。
RLock()和RUnlock()获取和释放一个读取或者共享锁。RLock只能在临界区共享变量没有任何写入操作时可用。一般来说，我们不应该假设逻辑上的只读函数/方法也不会去更新某一些变量。如果没法确定，那么久使用互斥锁（Mutex）
最后我们来讲下内存同步的问题
var x, y int
go func() {
x = 1 // A1
fmt.Print("y:", y, " ") // A2
}()
go func() {
y = 1 // B1
fmt.Print("x:", x, " ") // B2
}()
上面的例子：A1、A2、B1、B2 执行循序却是毫无规律
在现代计算机中可能会有一堆处理器，每一个都会有其本地缓存(local cache)。为了效率，对内存的写入一般会在每一个处理器中缓冲，并在必要时一起flush到主存。这种情况下这些数据可能会以与当初goroutine写入顺序不同的顺序被提交到主存。导致程序运行串行了，又同时串行的代码访问了共享变量，尽管goroutine A中一定需要观察到x=1执行成功之后才会去读取y，但它没法确保自己观察得到goroutine B中对y的写入，所以A还可能会打印出y的一个旧版的值。
有两种方法解决：
1.变量限定在goroutine中使用，不访问共享变量
2.用互斥条件访问
以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。如有错误或未考虑完全的地方，望不吝赐教。
相关推荐
-
golang移除数组中重复的元素操作
我就废话不多说了,大家还是直接看代码吧~ 方法一: //这种发放适用于string,int,float等切片,会对切片中的元素进行排序 func SliceRemoveDuplicates(slice []string) []string { sort.Strings(slice) i:= 0 var j int for{ if i >= len(slice)-1 { break } for j = i + 1; j < len(slice) && slice[i] == sl
-
golang执行命令操作 exec.Command
我就废话不多说了,大家还是直接看代码吧~ cmd := exec.Command("cmd") in := bytes.NewBuffer(nil) cmd.Stdin = in//绑定输入 var out bytes.Buffer cmd.Stdout = &out //绑定输出 go func() { in.WriteString("node E:/design/test.js\n")//写入你的命令,可以有多行,"\n"表示回车 }
-
解决Golang map range遍历结果不稳定问题
闲言少叙,本文主要是想介绍一个Golang开发常见的一个问题.然而,此问题对于初学者来说却经常容易陷入坑中. 问题 我在写一段代码时,使用了Golang的map数据结构,目的是想用map缓存计数结果.简单来说map的键也是整型的,且以递增顺序存储.我的最初想法是,在统计结束后,按照map中存储的键有序输出值.可是,当我运行程序时,结果并不是我想要的,而且有一定概率运行结果不同. 问题代码 func sortByBits(arr []int) []int { var bitmap = make(m
-
快速解决Golang Map 并发读写安全的问题
一.错误案例 package main import ( "fmt" "time" ) var TestMap map[string]string func init() { TestMap = make(map[string]string, 1) } func main() { for i := 0; i < 1000; i++ { go Write("aaa") go Read("aaa") go Write(&qu
-
golang等待触发事件的实例
我就废话不多说了,大家还是直接看代码吧~ type Wait interface { // Register waits returns a chan that waits on the given ID. // The chan will be triggered when Trigger is called with // the same ID. Register(id uint64) <-chan interface{} // Trigger triggers the waiting c
-
golang使用aes库实现加解密操作
golang实现加密解密的库很多,这里使用的是aes库+base64库来实现. 使用时,需要指定一个私钥,来进行加解密,这里指定是: var aeskey = []byte("321423u9y8d2fwfl") 上代码: package main import ( "fmt" "crypto/cipher" "crypto/aes" "bytes" "encoding/base64"
-
浅谈golang类型断言,失败类型断言返回值问题
失败的类型断言,返回的值为最近断言类型的零值 代码入下: func main() { var data interface{} = "ehoo" if res, ok := data.(int); ok { fmt.Printf("int res:%d\n", res) } else if res, ok := data.(bool); ok { fmt.Printf("bool res:%b\n", res) } else { fmt.Prin
-
浅谈golang并发操作变量安全的问题
我就废话不多说了,大家还是直接看代码吧~ package main import ( "fmt" "time" "sync" "sync/atomic" ) func main() { test1() test2() } func test1() { var wg sync.WaitGroup count := 0 t := time.Now() for i := 0 ; i < 50000 ; i++ { wg.Add
-
浅谈Golang是如何读取文件内容的(7种)
本文旨在快速介绍Go标准库中读取文件的许多选项. 在Go中(就此而言,大多数底层语言和某些动态语言(如Node))返回字节流. 不将所有内容自动转换为字符串的好处是,其中之一是避免昂贵的字符串分配,这会增加GC压力. 为了使本文更加简单,我将使用string(arrayOfBytes)将bytes数组转换为字符串. 但是,在发布生产代码时,不应将其作为一般建议. 1.读取整个文件到内存中 首先,标准库提供了多种功能和实用程序来读取文件数据.我们将从os软件包中提供的基本情况开始.这意味着两个先决
-
浅谈golang 的高效编码细节
目录 struct 和 map 用谁呢? 字符串如何拼接是好? 用 + 的方式 使用 fmt.Sprintf() 的方式 使用 strings.Join 的方式 使用 buffer 的方式 xdm,我们都知道 golang 是天生的高并发,高效的编译型语言 可我们也都可知道,工具再好,用法不对,全都白费,我们来举 2 个常用路径来感受一下 struct 和 map 用谁呢? 计算量很小的时候,可能看不出使用 临时 struct 和 map 的耗时差距,但是数量起来了,差距就明显了,且会随着数量越
-
浅谈Golang数据竞态
目录 一个数据竞态的case 检查数据竞态 解决方案 1.WaitGroup等待 2.Channel阻塞等待 3.Channel通道 4.互斥锁 典型数据竞态 1.循环计数上的竞态 2.意外共享变量 3.无保护的全局变量 4.原始无保护变量 5.未同步的发送和关闭操作 本文以一个简单事例的多种解决方案作为引子,用结构体Demo来总结各种并发读写的情况 一个数据竞态的case package main import ( "fmt" "testing" "ti
-
浅谈Java并发编程之Lock锁和条件变量
简单使用Lock锁 Java 5中引入了新的锁机制--java.util.concurrent.locks中的显式的互斥锁:Lock接口,它提供了比synchronized更加广泛的锁定操作.Lock接口有3个实现它的类:ReentrantLock.ReetrantReadWriteLock.ReadLock和ReetrantReadWriteLock.WriteLock,即重入锁.读锁和写锁.lock必须被显式地创建.锁定和释放,为了可以使用更多的功能,一般用ReentrantLock为其实例
-
浅谈Swoole并发编程的魅力
场景介绍 假设我们要做一个石头剪刀布的Web游戏,3个玩家同时提交竞猜后显示胜者.在传统串行化Web编程中,我们一般思路是这样: 设置form表单,用户提交竞猜后保存到MySQL/Redis存储 添加一个查看结果按钮,如果未全部完成,显示正在等待其他人提交.当3个人全部提交时,查询存储,并显示最终结果 并发编程 这个场景就可以使用Swoole实现并发编程,无需依赖MySQL/Redis存储,在内存中可以完成竞猜. 当有用户提交竞猜时,hold住请求,不返回结果,用户进入等待状态.当前请求和连接保
-
浅谈Golang 切片（slice）扩容机制的原理
我们知道 Golang 切片(slice) 在容量不足的情况下会进行扩容,扩容的原理是怎样的呢?是不是每次扩一倍?下面我们结合源码来告诉你答案. 一.源码 Version : go1.15.6 src/runtime/slice.go //go1.15.6 源码 src/runtime/slice.go func growslice(et *_type, old slice, cap int) slice { //省略部分判断代码 //计算扩容部分 //其中,cap : 所需容量,newcap
-
浅谈golang fasthttp踩坑经验
一个简单的系统,结构如下: 我们的服务A接受外部的http请求,然后通过golang的fasthttp将请求转发给服务B,流程非常简单.线上运行一段时间之后,发现服务B完全不再接收任何请求,查看服务A的日志,发现大量的如下错误 从错误原因看是因为连接被占满导致的.进入服务A的容器中(服务A和服务B都是通过docker启动的),通过netstat -anlp查看,发现有大量的tpc连接,处于ESTABLISH.我们采用的是长连接的方式,此时心里非常疑惑:1. fasthttp是能够复用连接的,为什
-
浅谈Java并发中ReentrantLock锁应该怎么用
目录 1.重入锁 说明 2.中断响应 说明 3.锁申请等待限时 tryLock(long, TimeUnit) tryLock() 4.公平锁 说明 源码(JDK8) 重入锁可以替代关键字 synchronized . 在 JDK5.0 的早期版本中,重入锁的性能远远优于关键字 synchronized , 但从 JDK6.0 开始, JDK 在关键字 synchronized 上做了大量的优化,使得两者的性能差距并不大. 重入锁使用 ReentrantLock 实现 1.重入锁 package
-
浅谈Golang Slice切片如何扩容的实现
目录 一.Slice数据结构是什么? 二.详细代码 1.数据结构 2.扩容原则 3.如何理解扩容规则一 1.当小于1024个元素时 2.当大于1024个元素时 4.如何理解扩容规则二 1.简单理解内存地址更换 总结 一.Slice数据结构是什么? 切片(slice)是 Golang 中一种比较特殊的数据结构,这种数据结构更便于使用和管理数据集合.切片是围绕动态数组的概念构建的,可以按需自动增长和缩小.切片(slice)是可以看做是一个长度可变的数组.切片(slice)自身并不是动态数组或者数组指