Go语言入门（八）线程安全&锁

wx5b285b48ed74e · · 3004 次点击 · · 开始浏览

这是一个创建于的文章，其中的信息可能已经有所发展或是发生改变。

线程安全&锁

定时器&一次性定时器

定时器

func main() {
   ticker := time.NewTicker(time.Second)
   //ticker.C是一个只读的chan，所以直接可以使用for range读取
   for v := range ticker.C {
      fmt.Printf("hello %v\n",v)   //按秒输出
   }
}

一次性定时器

func main() {
   select {
   case <- time.After(time.Second):
      fmt.Printf("after\n")
   }
}

超时控制


func queryDb(ch chan int) {
   //模拟DB查询
   time.Sleep(time.Second)  //模拟查询1秒
   ch <- 100
}

func main() {
   ch := make(chan int)
   go queryDb(ch)   //异步查询
   t := time.NewTicker(time.Second*3)    //定时3秒
   select {
   case v:= <- ch:
      fmt.Printf("result:%v\n",v)   //
   case <- t.C:
      fmt.Printf("timeout\n")
   }
}

异常处理：记录异常，不至于进程被panic等问题

func main() {
   go func() {
      // 使用recover()可以捕获goroutine的任何异常，从而不至于使得整个进程挂掉
      defer func() {
         err := recover()
         if err != nil {
            fmt.Printf("catch a panic,err:%v \n",err)
         }
      }()

      var p *int
      *p = 1000
      fmt.Printf("hello")
   }()
   var i int
   for {
      fmt.Printf("%d\n",i)
      time.Sleep(time.Second)
   }
}

线程安全

典型的例子
- 多个goroutine同时操守做一个资源，这个资源叫做临界区
- 现实生活中的十字路口，通过红绿灯来实现线程安全
- 火车上卫生间，通过互斥锁实现线程安全
实际例子： x=x+1
- 先从内存中取出x的值
- CPU进行计算+1
- 然后将x+1的结果放到内存

解决线程冲突问题

以下代码的输出数据不是2000000

var count int

func test1(waitGroup *sync.WaitGroup) {
   for i:=0;i<1000000;i++ {
      count ++
   }
   waitGroup.Done()
}

func test2(waitGroup *sync.WaitGroup) {
   for i:=0;i<1000000;i++ {
      count ++
   }
   waitGroup.Done()
}

func main() {
   var wg sync.WaitGroup
   wg.Add(2)
   go test1(&wg)
   go test2(&wg)
   wg.Wait()
   fmt.Printf("count=%d\n",count)
}

互斥锁

同时且只有一个线程进入临界区，其他的线程则在等待锁
当互斥锁释放之后，等待锁的线程才可以获取锁进入临界区
多个线程同时等待同一个锁，唤醒的策略是随机的

修复线程问题，使其正确输出

var count int
var mutex sync.Mutex

func test1(waitGroup *sync.WaitGroup) {
   for i:=0;i<1000000;i++ {
      mutex.Lock()
      count ++
      mutex.Unlock()
   }
   waitGroup.Done()
}

func test2(waitGroup *sync.WaitGroup) {
   for i:=0;i<1000000;i++ {
      //加锁
      mutex.Lock()
      count ++
      //解锁
      mutex.Unlock()
   }
   waitGroup.Done()
}

func main() {
   var wg sync.WaitGroup
   wg.Add(2)
   go test1(&wg)
   go test2(&wg)
   wg.Wait()
   fmt.Printf("count=%d\n",count)
}

读写锁

使用场景：读多写少的场景
分为两种角色：读锁和写锁
当一个goroutine获取写锁之后，其他的goroutine获取写锁或读锁都会等待
当一个goroutine获取读锁之后，其他的goroutine获取写锁都会等待，但其他goroutine获取读锁时，都会继续获得锁

var rwlock sync.RWMutex
var wg sync.WaitGroup
var counter int

func writer() {
   for i := 0;i<1000;i++ {
      rwlock.Lock()
      counter++
      rwlock.Unlock()
      time.Sleep(10*time.Millisecond)
   }
   wg.Done()
}

func reader()  {
   for i:=0;i<1000;i++ {
      rwlock.RLock()
      fmt.Printf("counter=%d\n",counter)
      time.Sleep(time.Millisecond)
      rwlock.RUnlock()
   }
   wg.Done()
}

func main() {
   wg.Add(1)
   go writer()
   for i:=0;i<10;i++ {
      wg.Add(1)
      go reader()
   }
   wg.Wait()
}

对比读写锁与互斥锁的性能


var rwlock sync.RWMutex
var wg sync.WaitGroup
var mlock sync.Mutex
var counter int

func writer() {
   for i := 0;i<1000;i++ {
      rwlock.Lock()
      counter++
      rwlock.Unlock()
      time.Sleep(10*time.Millisecond)
   }
   wg.Done()
}

func reader()  {
   for i:=0;i<1000;i++ {
      rwlock.RLock()
      //fmt.Printf("counter=%d\n",counter)
      time.Sleep(time.Millisecond)
      rwlock.RUnlock()
   }
   wg.Done()
}

func writer_mutex() {
   for i := 0;i<1000;i++ {
      mlock.Lock()
      counter++
      mlock.Unlock()
      time.Sleep(10*time.Millisecond)
   }
   wg.Done()
}

func reader_mutex()  {
   for i:=0;i<1000;i++ {
      mlock.Lock()
      //fmt.Printf("counter=%d\n",counter)
      time.Sleep(time.Millisecond)
      mlock.Unlock()
   }
   wg.Done()
}

func main() {
   start := time.Now().UnixNano()
   wg.Add(1)
   go writer()
   for i:=0;i<10;i++ {
      wg.Add(1)
      go reader()
   }
   wg.Wait()
   end := time.Now().UnixNano()
   cost_time := (float64(end)-float64(start))/1000/1000/1000
   fmt.Printf("RWlock总耗时：%f s\n",cost_time)

   start_m := time.Now().UnixNano()
   wg.Add(1)
   go writer_mutex()
   for i:=0;i<10;i++ {
      wg.Add(1)
      go reader_mutex()
   }
   wg.Wait()
   end_m := time.Now().UnixNano()
   cost_time_m := (float64(end_m)-float64(start_m))/1000/1000/1000
   fmt.Printf("Mutexlock总耗时：%f s\n",cost_time_m)
}

原子操作

计数需求，会使用到原子操作
加锁代价会比较耗时，需要上下文切换
针对基本数据类型，可以使用原子操作确保线程安全
原子操作在用户态就可以完成，因此性能要比互斥锁要高

var counts int32

func test3() {
   for i:=0;i<1000000;i++ {
      //counts ++,替换成原子加1操作
      atomic.AddInt32(&counts,1)
   }
}

func test4() {
   for i:=0;i<1000000;i++ {
      atomic.AddInt32(&counts,1)
   }
}

func main() {
   go test3()
   go test4()
   time.Sleep(time.Second)
   fmt.Printf("counts=%d\n",counts)
}

练习

采用多线程遍历目录，然后生成缩略图
参考代码（单线程模式）

const DEFAULT_MAX_WIDTH float64 = 64
const DEFAULT_MAX_HEIGHT float64 = 64

// 计算图片缩放后的尺寸
func calculateRatioFit(srcWidth, srcHeight int) (int, int) {
   ratio := math.Min(DEFAULT_MAX_WIDTH/float64(srcWidth), DEFAULT_MAX_HEIGHT/float64(srcHeight))
   return int(math.Ceil(float64(srcWidth) * ratio)), int(math.Ceil(float64(srcHeight) * ratio))
}

// 生成缩略图
func makeThumbnail(imagePath, savePath string) error {

   file, _ := os.Open(imagePath)
   defer file.Close()

   img, _, err := image.Decode(file)
   if err != nil {
      return err
   }

   b := img.Bounds()
   width := b.Max.X
   height := b.Max.Y

   w, h := calculateRatioFit(width, height)

   fmt.Println("width = ", width, " height = ", height)
   fmt.Println("w = ", w, " h = ", h)

   // 调用resize库进行图片缩放
   m := resize.Resize(uint(w), uint(h), img, resize.Lanczos3)

   // 需要保存的文件
   imgfile, err := os.Create(savePath)
   if err != nil {
      fmt.Printf("os create file, err:%v\n", err)
      return err
   }
   defer imgfile.Close()

   // 以PNG格式保存文件
   err = png.Encode(imgfile, m)
   if err != nil {
      return err
   }

   return nil
}

func main() {
   var imageFile string
   var saveFile string

   flag.StringVar(&imageFile, "file", "", "--image file")
   flag.StringVar(&saveFile, "dest", "", "--dest file")
   flag.Parse()

   if len(imageFile) == 0 || len(saveFile) == 0 {
      fmt.Printf("%s -file image filename -dest dest filename\n", os.Args[0])
      return
   }

   err := makeThumbnail(imageFile, saveFile)
   if err != nil {
      fmt.Printf("make thumbnail failed, err:%v\n", err)
      return
   }
   fmt.Printf("make thumbnail succ, path:%v\n", saveFile)
}

有疑问加站长微信联系（非本文作者）

本文来自：51CTO博客

感谢作者：wx5b285b48ed74e

查看原文：Go语言入门（八）线程安全&锁

入群交流（和以上内容无关）：加入Go大咖交流群，或添加微信：liuxiaoyan-s 备注：入群；或加QQ群：692541889

3004 次点击

加入收藏微博

收入我的专栏

上一篇：leetcode_617

下一篇：Go 为什么这么“快”

锁

线程

goroutine

互斥

0 回复

添加一条新回复（您需要登录后才能回复没有账号？）

请尽量让自己的回复能够对别人有帮助
支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
支持 @ 本站用户；支持表情（输入 : 提示），见 Emoji cheat sheet
图片支持拖拽、截图粘贴等方式上传

关注我

扫码关注领全套学习资料
加入 QQ 群：
- 192706294（已满）
- 731990104（已满）
- 798786647（已满）
- 729884609（已满）
- 977810755（已满）
- 815126783（已满）
- 812540095（已满）
- 1006366459（已满）
- 692541889
加入微信群：liuxiaoyan-s，备注入群
也欢迎加入知识星球 Go粉丝们（免费）

Go语言入门（八）线程安全&锁

线程安全&锁

定时器&一次性定时器

线程安全

解决线程冲突问题

互斥锁

读写锁

原子操作

练习

用户登录

今日阅读排行

一周阅读排行

关注我

线程安全&锁

定时器&一次性定时器

线程安全

解决线程冲突问题

互斥锁

读写锁

原子操作

练习

Go语言入门（八）线程安全&锁

线程安全&锁

定时器&一次性定时器

线程安全

解决线程冲突问题

互斥锁

读写锁

原子操作

练习

用户登录

今日阅读排行

一周阅读排行

关注我

给该专栏投稿 写篇新文章

收入到我管理的专栏 新建专栏

线程安全&锁

定时器&一次性定时器

线程安全

解决线程冲突问题

互斥锁

读写锁

原子操作

练习

给该专栏投稿写篇新文章

收入到我管理的专栏新建专栏