Golang全局变量加锁的问题解决

如果全局变量只读取 那自然是不需要加锁的

如果全局变量多进程读，多进程写，那自然是需要加读写锁的

但是如果全局变量只有一个进程写，其他进程读呢？ 如果采用COW的方式，写进程只是通过单次赋值的方式来更新变量，是否就可以不加锁了呢？

就第三种情况而言：

当然我们通过 go build -race 或者 go run -race 就会出现

WARNING: DATA RACE。 但是出现 data race 就证明一定有问题么？

其实核心点在于这个赋值是否是原子的。也就是说是否存在 p1 = p2 的写入时，指针被临时替换为p3，并在此时goroutine切出的情况。可以想到的一种情况是64字节的指针需要两次mv才能完成全部变量的赋值。那么就有可能在两次mv中间切出，进而出现p3的情况。

之前在stackoverflow 上有个讨论

https://stackoverflow.com/questions/21447463/is-assigning-a-pointer-atomic-in-go

其中高votes的回答是说：

在go中，唯一保证原子性的操作是在 sync.atomic, 所以如果你想确保原子性，可以使用sync.Mutex 或者 sync.atomic 中的原子函数。 但是我不建议 sync.atomic中函数， 因为你不得不在任何使用指针的地方使用他们，这是非常难做到正确使用的。

用mutex 是好的go style - 你可以很方便的定义一个函数返回指针。 比如

import "sync"
var secretPointer *int
var pointerLock sync.Mutex
func CurrentPointer() *int {
    pointerLock.Lock()
    defer pointerLock.Unlock()
    return secretPointer
}
func SetPointer(p *int) {
    pointerLock.Lock()
    secretPointer = p
    pointerLock.Unlock()
}

所以一个ok的go style 应该是使用 sync.Mutex 的。

golang doc也是这么说的。

type T struct {
 msg string
}
var g *T
func setup() {
 t := new(T)
 t.msg = "hello, world"
 g = t
}
func main() {
 go setup()
 for g == nil {
 }
 print(g.msg)
}

Even if main observes g != nil and exits its loop, there is no guarantee that it will observe the initialized value for g.msg.

In all these examples, the solution is the same: use explicit synchronization.

但是当我们用go tool asm看时， 确实只有一个指令 MOVQ。

所以只能说

因为规范没有指定，所以你应该假设它不是原子的。即使它现在是原子的，它也有可能在不违反规范的情况下改变。

总之我们不应该做赋值原子的假设，而应该按照规范，使用sync.Mutex 来做。

补充：Golang对全局变量加锁同步解决资源访问共享问题——使用Go协程来同时并发计算多个数字（1-200）的阶乘

使用互斥锁解决资源共享问题

使用Go协程来同时并发计算多个数字（1-200）的阶乘，然后存储在数组当中

package main
import (
 "fmt"
 "time"
)

var(
 myMap = make(map[int]int, 10)
)

func test(n int){
 res:=1
 for i:=1; i<=n; i++{
  res*=i
 }
 myMap[n]=res
}

func main(){
 for i:=1; i<=200; i++{
  go test(i)
 }

 time.Sleep(time.Second*10)
 for i,v:=range myMap{
  fmt.Printf("myMap[%d]=%d\n", i, v)
 }
}

代码如下，运行结果如下：但是我们发现其并没有正常计算出各个数字的阶乘来

原因是我们没有对全局变量myMap加锁，导致了资源抢夺的问题，因此我们可以对代码加入互斥锁

package main
import (
 "fmt"
 "time"
 "sync"
)

var(
 myMap = make(map[int]int, 10)
 //声明一个全局互斥锁
 lock sync.Mutex
)

func test(n int){
 res:=1
 for i:=1; i<=n; i++{
  res+=i //这里我将阶乘改成求和，防止数据溢出
 }
 //加锁
 lock.Lock()
 myMap[n]=res
 //解锁
 lock.Unlock()
}

func main(){
 for i:=1; i<=200; i++{
  go test(i)
 }

 time.Sleep(time.Second*10)

 for i,v:=range myMap{
  fmt.Printf("myMap[%d]=%d\n", i, v)
 }
}

对资源加了互斥锁之后，多个协程之间的并发问题就得到了解决

但是上述解决方案不太完美，有其缺陷：

（1）主线程在等待所有goroutine全部完成的时间很难确定

（2）如果主线程休眠时间过长，就会加长等待时间，如果等待时间短了，还可能会有goroutine因为主线程的退出而被销毁

（3）通过全局变量加锁同步来实现通讯，也不利于多个协程对全局变量的读写操作

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。如有错误或未考虑完全的地方，望不吝赐教。

赞 (0)

相关推荐

  • 解决golang 关于全局变量的坑

    学习golang不久,在定义全局变量的时候遇见了坑.写个小例子,增强记忆. 错误版本 var p int func main() { p, err := test(4) if err != nil { log.Fatal(err) } } func test(i int) (int, error) { return i + 1, nil } 编译一直不通过,p declared and not used.后来查了查资料,看见这种其实是在main里边又重新定义了p,所以一直提示p定义了但是没有使用

  • 使用golang编写一个并发工作队列

    其实golang用一个函数可以构建一个并发队列,现在编写一个灵活可控的队列程序 先定义一个工作 type Worker struct { ID int RepJobs chan int64 SM *SM quit chan bool } 包含了workid和执行任务的id,上面的SM只是任务具体内容,这个和具体业务相关,大家自己编写自己的SM业务逻辑 然后定义工作池 type workerPool struct { workerChan chan *Worker workerList []*Wo

  • 关于golang高并发的实现与注意事项说明

    一.并发的意义 并发的意义就是让 一个程序同时做多件事情,其目的只是为了能让程序同时做另一件事情而已,而不是为了让程序运行的更快(如果是多核处理器,而且任务可以分成相互独立的部分,那么并发确实可以让事情解决的更快). golang从语言级别上对并发提供了支持,而且在启动并发的方式上直接添加了语言级的关键字,不必非要按照固定的格式来定义线程函数,也不必因为启动线程的时候只能给线程函数传递一个参数而烦恼. 二.并发的启动 go的并发启动非常简单,几乎没有什么额外的准备工作,要并发的函数和一般的函数没

  • golang 并发编程之生产者消费者详解

    golang 最吸引人的地方可能就是并发了,无论代码的编写上,还是性能上面,golang 都有绝对的优势 学习一个语言的并发特性,我喜欢实现一个生产者消费者模型,这个模型非常经典,适用于很多的并发场景,下面我通过这个模型,来简单介绍一下 golang 的并发编程 go 并发语法 协程 go 协程是 golang 并发的最小单元,类似于其他语言的线程,只不过线程的实现借助了操作系统的实现,每次线程的调度都是一次系统调用,需要从用户态切换到内核态,这是一项非常耗时的操作,因此一般的程序里面线程太多会

  • 深入浅析golang zap 日志库使用（含文件切割、分级别存储和全局使用等）

    日志处理经常有以下几个需求: 1.不同级别的日志输出到不同的日志文件中. 2.日志文件按照文件大小或日期进行切割存储,以避免单一日志文件过大. 3.日志使用简单方便,一次定义全局使用. 建议使用使用Uber-go的Zap Logger,大神李文周大博客已经说的非常明确了,请先参考李老师的博客: https://www.liwenzhou.com/posts/Go/zap/ 问题二和问题三需要补充描述: 一.日志按照级别分文件切割存储 1.1 首先实现两个判断日志等级的interface info

  • golang 对私有函数进行单元测试的实例

    在待测试的私有函数所在的包内,新建一个xx_test.go文件 书写方式如下: import ( "github.com/stretchr/testify/assert" "testing" ) var XXFunc = yourPrivateFunc func TestXXFunc(t *testing.T) { ret, ... := XXFunc(...) assert.Equal(t, ret, ...) } 就可以了~ 补充:golang test使用(简

  • 基于Golang 高并发问题的解决方案

    Golang 高并发问题的解决 Golang在高并发问题上,由于协程的使用,相对于其他编程语言,已经有了很大的优势,即相同的配置上,Golang可以以更低的代价处理更多的线程,同样的线程数,占用更低的资源!及时这样,只是解决了一部分问题而已,因为在每个协程里,处理逻辑还是会有问题. 高并发时,还是要考虑服务器所能承受的最大压力,数据库读取时的io问题,连接数问题,带宽问题等等 研究了一下并发解决方案,在此记录一下 参考文章:Handling 1 Million Requests per Minu

  • Golang全局变量加锁的问题解决

    Golang全局变量加锁的问题解决

    如果全局变量只读取 那自然是不需要加锁的 如果全局变量多进程读,多进程写,那自然是需要加读写锁的 但是如果全局变量只有一个进程写,其他进程读呢? 如果采用COW的方式,写进程只是通过单次赋值的方式来更新变量,是否就可以不加锁了呢? 就第三种情况而言: 当然我们通过 go build -race 或者 go run -race 就会出现 WARNING: DATA RACE. 但是出现 data race 就证明一定有问题么? 其实核心点在于这个赋值是否是原子的.也就是说是否存在 p1 = p2

  • PHP+MySQL高并发加锁事务处理问题解决方法

    本文实例讲述了PHP+MySQL高并发加锁事务处理问题解决方法.分享给大家供大家参考,具体如下: 1.背景: 现在有这样的需求,插入数据时,判断test表有无username为'mraz'的数据,无则插入,有则提示"已插入",目的就是想只插入一条username为'mraz'的记录. 2.一般程序逻辑如下: $conn = mysqli_connect('127.0.0.1', 'root', '111111') or die(mysqli_error()); mysqli_selec

  • golang中sync.Mutex的实现方法

    目录 mutex 的实现思想 golang 中 mutex 的实现思想 mutex 的结构以及一些 const 常量值 Mutex 没有被锁住,第一个协程来拿锁 Mutex 仅被协程 A 锁住,没有其他协程抢锁,协程 A 释放锁 Mutex 已经被协程 A 锁住,协程 B 来拿锁 lockSlow() runtime_doSpin() runtime_canSpin() Mutex 被协程 A 锁住,协程 B 来抢锁但失败被放入等待队列,此时协程 A 释放锁 unlockSlow() Mutex

  • Golang中goroutine和channel使用介绍深入分析

    目录 1.goroutine-看一个需求 2.进程和线程介绍 3.并发和并行 4.Go协程和Go主线程 5.设置Golang运行的CPU数 6.channel(管道)看需求 1.goroutine-看一个需求 需求:要求统计1-900000000的数字中,那些是素数? 分析: 传统方法,就是使用一个循环,循环的判断各个数是不是素数. 使用并发或并行的方式,将统计素数的任务分配给多个goroutine去完成,这时就会使用到goroutine. 2.进程和线程介绍 进程就是程序在操作系统中的一次执行

  • go语言 全局变量和局部变量实例

    go语言 全局变量和局部变量实例

    一.局部变量 1 定义在{}里面的变量时局部变量,只能在{}里面有效 2 执行到定义的那句话,开始分配内存空间,离开作用域自动进行释放 3 作用域,就是变量作用的范围 package main import "fmt" func test() { i := 111 fmt.Println("i=", i) } func main() { test() { i := 10 fmt.Printf("i=%v\n", i) } // i=12 错误 i

  • Go语言Goroutinue和管道效率详解

    目录 goroutinue基本介绍 进程和线程说明 并发和并行 同步和异步 Go协程和Go主线程 go协程特点 goroutinue基本使用 实验代码 效果图 执行流程图 goroutinue的调度模型 MPG MPG运行状态1 MPG运行状态2 管道(channel) 不同协程之间如何通讯 全局变量加锁同步缺陷 管道基本介绍 管道基本使用 声明和定义 管道关闭和遍历 关闭 遍历 管道注意事项 综合案例 goroutinue基本介绍 进程和线程说明 进程介绍程序在操作系统中的一次执行过程,是系统

  • redis与memcached的区别_动力节点Java学院整理

    redis与memcached的区别_动力节点Java学院整理

    传统MySQL+ Memcached架构遇到的问题 实际MySQL是适合进行海量数据存储的,通过Memcached将热点数据加载到cache,加速访问,很多公司都曾经使用过这样的架构,但随着业务数据量的不断增加,和访问量的持续增长,我们遇到了很多问题: 1.MySQL需要不断进行拆库拆表,Memcached也需不断跟着扩容,扩容和维护工作占据大量开发时间. 2.Memcached与MySQL数据库数据一致性问题. 3.Memcached数据命中率低或down机,大量访问直接穿透到DB,MySQL

  • Lua协同程序coroutine的简介及优缺点

    Lua协同程序coroutine的简介及优缺点

    什么是协同(coroutine)? Lua 协同程序(coroutine)与线程比较类似:拥有独立的堆栈,独立的局部变量,独立的指令指针,同时又与其它协同程序共享全局变量和其它大部分东西. 协同是非常强大的功能,但是用起来也很复杂. 线程和协同程序区别 协程是编译器级别的,线程是操作系统级别的,在多处理器情况下,多线程程序同时运行多个线程:而协同程序是通过协作来完成,在任一指定时刻只有一个协同程序在运行,并且这个正在运行的协同程序只在必要时才会被挂起.这样Lua的协程就不能利用现在多核技术了.

  • Golang通过包长协议处理TCP粘包的问题解决

    Golang通过包长协议处理TCP粘包的问题解决

    tcp粘包产生的原因这里就不说了,因为大家能搜索TCP粘包的处理方法,想必大概对TCP粘包有了一定了解,所以我们直接从处理思路开始讲起 tcp粘包现象代码重现 首先,我们来重现一下TCP粘包,然后再此基础之上解决粘包的问题,这里给出了client和server的示例代码如下 /* 文件名:client.go client客户端的示例代码(未处理粘包问题) 通过无限循环无时间间隔发送数据给server服务器 server将会不间断的出现TCP粘包问题 */ package main import

随机推荐