Go语言入门(八)线程安全&锁

wx5b285b48ed74e · · 1519 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

线程安全&锁

定时器&一次性定时器

  • 定时器
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群:701969077

1519 次点击  
加入收藏 微博
上一篇:leetcode_617
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传