golang 并发

2024-01-08 11:34 由 haonan071 发表于 #后端开发

Golang 并发

并行指的是在同一时刻有多条指令在多个CPU处理器上同时执行 2个任务2个窗口需要硬件支持
并发是指在同一时刻只能有一条指令单多个进程指令快速轮换执行 2个队伍1个窗口要求提升软件能力

Golang 并发优势

go 从底层就支持并发
简化了并发程序的编写方法

Goroutine 是什么

它是go 并发设计的核心
goroutine就是协程，它比线程更小，十几个goroutine 在底层可能就是五六个线程
go 语言内部实现了goroutine的内存共享，执行goroutine只需极少的栈内存(大概4-5KB)

创建goroutine

只需要在语句前添加go 关键字即可

    package main

    import (
    "fmt"
    "time"
    )

    //测试协程
    //循环打印内容
    func newTask() {
    i := 0
    for {
    i++
    fmt.Printf("new goroutine\:i=%d\n", i)
    time.Sleep(1 \* time.Second)
    }
    }

    //main()相当于是主协程
    func main() {
    //启动子协程
    go newTask()
    i := 0
    for {
    i++
    fmt.Printf("main goroutine\:i=%d\n", i)
    time.Sleep(1 \* time.Second)
    }
    }

开发人员无需了解任何执行细节，调度器会自动将其安排到合适的系统线程上运行
如果主协程推出，所有子进程协程都会退出

    package main
    import (
    "fmt"
    "time"
    )
    //main()相当于是主协程
    func main() {
    //匿名子协程
    go func() {
      i := 0
      for {
        i++
        fmt.Println("子协程 i=", i)
        time.Sleep(1 \* time.Second)
      }
    }()
    i := 0
    for {
      i++
      fmt.Println("主协程 i=", i)
      time.Sleep(1 \* time.Second)
      //主协程第二次后退出
      if i == 2 {
        break
      }
    }
    }

程序没任何输出，也不报错

    package main

    import (
    "fmt"
    "time"
    )

    //main()相当于是主协程
    func main() {
    //匿名子协程
    go func() {
    i := 0
    for {
    i++
    fmt.Println("子协程 i=", i)
    time.Sleep(1 \* time.Second)
    }
    }()
    }

runtime 包

runtime.Gosched(): 用于让出CPU时间片，调度器重新安排任务调度，还是有几率分配到它的

    package main

    import (
    "fmt"
    "runtime"
    )

    func main() {
    //匿名子协程
    go func(s string) {
    for i := 0; i < 2; i++ {
    fmt.Println(s)
    }
    }("world")
    //主协程
    for i := 0; i < 2; i++ {
    runtime.Gosched()
    fmt.Println("hello")
    }
    }

runtime.Goexit() 立即终止当前协程

    package main

    import (
    "fmt"
    "time"
    "runtime"
    )

    func main() {
    //匿名子协程
    go func() {
    defer fmt.Println("A.defer")
    //匿名函数
    func() {
    defer fmt.Println("B.defer")
    //此时只有defer执行
    runtime.Goexit()
    fmt.Println("B")
    }()
    fmt.Println("A")
    }()
    for {
    time.Sleep(time.Second)
    }
    }

runtime.GOMAXPROCS(): 设置并行计算的CPU核数，返回之前的值

    package main

    import (
    "runtime"
    "fmt"
    )

    func main() {
    n := runtime.GOMAXPROCS(3)
    fmt.Println("n=%d\n",n)
    //循环执行2个
    for{
    go fmt.Print(0)
    fmt.Print(1)
    }
    }

channel

goroutine运行在相同的地址空间,因此访问共享内存必须做好同步，处理好线程安全
goroutine奉行通过通信来共享内存，而不是共享内存通信
channel 是一个引用类型用于多个goroutine 通讯其内部实现了同步，确保并发安全

Channel 基本使用

Channel 可以用内置make() 创建
定义一个channel 也需要定义发送到channel值类型
make(chan 类型) // 无缓冲通道
make(chan 类型, 容量) // 有缓冲通道
当capacity=0 时， channel 是无缓冲阻塞读写的，当capacity>0, channel 有缓冲，是非阻塞的，直到写满capacity个元素才阻塞写入
channel 通过操作符<-来接受和发送数据，语法为:
channel <- value //发送value到channel
<-channel //接受通道数据，丢弃
x := <-channel //取值并赋给x
x, ok := <-channel //ok 是检查通道是否关闭或者是否为空
channel 基本使用

    package main

    import "fmt"

    func main() {
    //创建存放int类型的通道
    c := make(chan int)
    //子协程
    go func() {
    defer fmt.Println("子协程结束")
    fmt.Println("子协程正在运行...")
    //将666发送到通道c
    c <- 666
    }()
    //若已取出数据，下面再取会报错
    //<-c
    //主协程取数据
    //从c中取数据
    num := <-c
    fmt.Println("num = ", num)
    fmt.Println("主协程结束")
    }

无缓冲的channel

无缓冲的通道是指在接收前没有能力保存任何值的通道
无缓冲通道，有可能阻塞
发送者-> (通道(有可能数据阻塞)) -> 接受者

package main

import (
   "fmt"
   "time"
)

func main() {
   //创建无缓冲通道
   c := make(chan int, 0)
   //长度和容量
   fmt.Printf("len(c)=%d, cap(c)=%d\n", len(c), cap(c))
   //子协程存数据
   go func() {
      defer fmt.Println("子协程结束")
      //向通道添加数据
      for i := 0; i < 3; i++ {
         c <- i
         fmt.Printf("子协程正在运行[%d]:len(c)=%d,cap(c)=%d\n", i, len(c), cap(c))
      }
   }()

   time.Sleep(2 * time.Second)
   //主协程取数据
   for i := 0; i < 3; i++ {
      num := <-c
      fmt.Println("num=", num)
   }
   fmt.Println("主协程结束")
}

有缓冲channel

有缓冲的通道是一种在被接受前能存储一个或着多个值的通道发送者->（通道(数据),(数据)(...)）->接受者在创建时修改容量即可

//创建有缓存的通道
c :=make(chan int, 3)

关闭close 通过内置close()关闭channel

    package main
      
      import "fmt"
      
      func main() {
         //创建通道
         c := make(chan int)
         //子协程存数据
         go func() {
            for i := 0; i < 5; i++ {
               c <- i
            }
            //子协程close
            close(c)
         }()
         //主协程取数据
         for {
            if data, ok := <-c; ok {
               fmt.Println(data)
            } else {
               break
            }
         }
         fmt.Println("Finshed")
      }
      
      
    # 可以遍历

    for data := range c{
      	fnt.Println(data)
      }

单方向channel

默认下通道是双向的，也就是既可以往里面发送数据也可以接收数据
go 可以定义单方向通道，也就是只发送数据或者只接收数据
var ch1 chan int //正常的
var ch2 chan <- float64 //单向的只用于写float64的数据
var ch3 <-chan int //单向的, 只用于读取int 数据
可以将channel 隐式转换为单向队列，只收或只发，不能讲单向channel 转为普通channel

//1. 将c准换为只写的通道
var send <- chan int =c

//2. 将c转为只读的通道
var recv <- chan int =c

//往send里面写数据
send < -1

//从recv读数据
<-recv

单方向的channel 场景模拟生产者，消费者

    package main

    import "fmt"

    //生产者，只写
    func producter(out chan<- int) {
    //关闭资源
    defer close(out)
    for i := 0; i < 5; i++ {
    out <- i
    }
    }

    //消费者，只读
    func consumer(in <-chan int) {
    for num := range in {
    fmt.Println(num)
    }
    }

    func main() {
    //创建通道
    c := make(chan int)
    //生产者运行，向管道c存数据
    go producter(c)
    //消费者运行
    consumer(c)
    fmt.Println("done")
    }

定时器

Timer 定时时间到了响应一次

  package main
  
  import (
     "time"
     "fmt"
  )
  
  func main() {
     //1.基本使用
     //创建定时器
     //2秒后，定时器会将一个时间类型值，保存向自己的c
     //timer1 := time.NewTimer(2 * time.Second)
     ////打印当前时间
     //t1 := time.Now()
     //fmt.Printf("t1:%v\n", t1)
     ////从管道中取出C打印
     //t2 := <-timer1.C
     //fmt.Printf("t2:%v\n", t2)
  
     //2.Timer只响应一次
     //timer2 := time.NewTimer(time.Second)
     //for {
     // <-timer2.C
     // fmt.Println("时间到")
     //}
  
     //3.通过Timer实现延时的功能
     ////(1)睡眠
     //time.Sleep(2*time.Second)
     //fmt.Println("2秒时间到")
     ////(2)通过定时器
     //timer3 := time.NewTimer(2 * time.Second)
     //<-timer3.C
     //fmt.Println("2秒时间到")
     ////(3)After()
     //<-time.After(2 * time.Second)
     //fmt.Println("2秒时间到")
  
     //4.停止定时器
     //timer4 := time.NewTimer(3 * time.Second)
     ////子协程
     //go func() {
     // <-timer4.C
     // fmt.Println("定时器器时间到，可以打印了")
     //}()
     //stop := timer4.Stop()
     //if stop {
     // fmt.Println("timer4已关闭")
     //}
  
     //5.重置定时器
     timer5 := time.NewTimer(3 * time.Second)
     //定时器改为1秒
     timer5.Reset(1 * time.Second)
     fmt.Println(time.Now())
     fmt.Println(<-timer5.C)
  
     for {
     }
  }

*   响应多次
    package main

    import (
    "time"
    "fmt"
    )

    func main() {
    //创建定时器，间隔1秒
    ticker := time.NewTicker(time.Second)
    i := 0
    //子协程
    go func() {
    for {
    <-ticker.C
    fmt.Println(<-ticker.C)
    i++
    fmt.Println("i=", i)
    //停止定时器
    if i == 5 {
    ticker.Stop()
    }
    }
    }()

    //死循环
    for {

    }

select 用法

go 语言提供了select 关键字，可以监听channel 上的数据流动
语法与switch 类似，区别时select 要求每个case 语句必须是一个IO操作

  select {
  case <-chan1:
     // 如果chan1成功读到数据，则进行该case处理语句
  case chan2 <- 1:
     // 如果成功向chan2写入数据，则进行该case处理语句
  default:
     // 如果上面都没有成功，则进入default处理流程
  }
  ```go
  package main
  
  import (
     "fmt"
  )
  
  func main() {
     //创建数据通道
     int_chan := make(chan int, 1)
     string_chan := make(chan string, 1)
     //创建2个子协程，写数据
     go func() {
        //time.Sleep(2 * time.Second)
        int_chan <- 1
     }()
     go func() {
        string_chan <- "hello"
     }()
     //如果都能匹配到，则随机选择一个去跑
     select {
     case value := <-int_chan:
        fmt.Println("intValue:", value)
     case value := <-string_chan:
        fmt.Println("strValue:", value)
     }
     fmt.Println("finish")
  }

协程同步锁

go 中channel 实现了同步，确保并发安全，同时也提供了锁的操作方式
go 中sync包提供了锁的相关支持
Mutex 以加锁的方式解决并发安全问题

  package main
  
  import (
     "time"
     "fmt"
     "sync"
  )
  
  //账户
  type Account struct {
     money int
     flag sync.Mutex
  }
  
  //模拟银行检测
  func (a *Account)Check()  {
     time.Sleep(time.Second)
  }
  
  //设置账户余额
  func (a *Account)SetAccount(n int)  {
     a.money +=n
  }
  
  //查询账户余额
  func (a *Account)GetAccount() int{
     return a.money
  }
  
  //买东西1
  func (a *Account)Buy1(n int){
     a.flag.Lock()
     if a.money>n{
        //银行检测
        a.Check()
        a.money -=n
     }
     a.flag.Unlock()
  }
  
  //买东西2
  func (a *Account)Buy2(n int){
     a.flag.Lock()
     if a.money>n{
        //银行检测
        a.Check()
        a.money -=n
     }
     a.flag.Unlock()
  }
  
  func main() {
     var account Account
     //设置账户余额
     account.SetAccount(10)
     //2个子协程买东西
     go account.Buy1(6)
     go account.Buy2(5)
     time.Sleep(2 * time.Second)
     fmt.Println(account.GetAccount())
  }

sync.WaitGroup 用来等待一组协程结束，需要设置等待个数，每个子协程结束后要调用Done() 然后在主进程Wait() 即可

  package main
  
  import (
     "fmt"
  )
  
  func main() {
     //创建通道
     ch := make(chan int)
     //count表示活动的协程个数
     count := 2
     go func() {
        fmt.Println("子协程1")
        //子协程1执行完成，给通道发送信号
        ch <-1
     }()
     go func() {
        fmt.Println("子协程2")
        ch <-1
     }()
     //time.Sleep(time.Second)
     //从ch中不断读数据
     for range ch{
        count --
        if count == 0{
           close(ch)
        }
     }
  }

go提供了解决方案sync.WaitGroup
Add() 添加计数
Done() 操作结束时调用，计数减1
Wait() 主函数调用，等待所有操作结束

这个开源项目，让你轻松搭建属于自己的云存储服务！

filebrowser —— 一个后端基于 Go、前端基于 Vue 实现的在线云存储服务，可以通过浏览器对服务器上的文件进行管理。 ...阅读全文

Mybatis 拦截器实现单数据源内多数据库切换 | 京东物流技术团队

物流的分拣业务在某些分拣场地只有一个数据源，因为数据量比较大，将所有数据存在一张表内查询速度慢，也为了做不同设备数据的分库管理，便在这个数据源内创建了多个不同库名但表完全相同的数据库，如下图所示：现在需要上线报表服务来查询所有数据库中的数据进行统计，那么现在的问题来了，该如何满足在配置一个数据源 ...阅读全文

记一次线上问题 → 偶尔的热情真的难顶呀！

开心一刻昨晚和媳妇坐在沙发上刷视频我用手肘轻轻推了推媳妇：你看这渣男，玩完女的都不娶人家媳妇：哎哟我天，哎呀妈，我这也没好哪去呀我疑惑的看向媳妇：啥意思啊媳妇看向自己的手机：啥意思啊，特么有些人，娶完了也不玩呀背景介绍我负责的系统需要同步上游系统的数据同步机制分两步 1、上游系统数据 ...阅读全文

【scikit-learn基础】--『监督学习』之贝叶斯分类

贝叶斯分类是一种统计学分类方法，基于贝叶斯定理，对给定的数据集进行分类。它的历史可以追溯到18世纪，当时英国统计学家托马斯·贝叶斯发展了贝叶斯定理，这个定理为统计决策提供了理论基础。不过，贝叶斯分类在实际应用中的广泛使用是在20世纪80年代，当时计算机技术的进步使得大规模数据处理成为可能。 1. ...阅读全文

PySimpleGUI 使用浅谈

1. 背景 PySimpleGUI是一个简单易用的Python GUI库，它提供了一种直观且快速创建图形用户界面的方式。 2. 安装 pip install PySimpleGUI 3. PySimpleGUI 的基本结构一个基本的 PySimpleGUI 程序主要包括以下几个部分： 1. 导入 ...阅读全文

python的metaclass

python中的metaclass可谓熟悉而又陌生，自己开发时很少用，阅读源码时却经常遇到，那么到底什么是metaclass呢？何时使用metaclass呢？动态创建class的方法假设我们需要动态创建一个class，那么一般我们有这样几种方法通过一个函数动态创建class 通过type动态创 ...阅读全文

爬虫实战 - 微博评论数据可视化

简介：我们都知道在数据比较少的情况下，我们是可以很轻易的获取到数据中的信息。但是当数据比较庞大的时候呢，我们就很难看出来了。尤其是面对现如今数以万计的数据，就更了。不过好在我们可以通过计算机来帮我们进行分析，其中比较高效的手段便是数据可视化了。通过将数据进行可视化，我们可以让数据开口说话。进而有 ...阅读全文

劫持 PE 文件：新建节表并插入指定 DLL 文件

这种方法其实是 PE 感染的一种，通过对目标程序添加一个新节并注入DLL，然后这会改变 PE 文件的大小，将原有的导入表复制到新节中，并添加自己的导入表描述符，最后将数据目录项中指向的导入表的入口指向新节。 ...阅读全文

C 语言函数完全指南：创建、调用、参数传递、返回值解析

C 语言中的函数函数是一段代码块，只有在被调用时才会运行。您可以将数据（称为参数）传递给函数。函数用于执行某些操作，它们对于重用代码很重要：定义一次代码，并多次使用。预定义函数事实证明，您已经知道什么是函数了例如，main() 是一个函数，用于执行代码，printf() 也是一个函数，用 ...阅读全文

通过JDK动态代理类实现一个类中多种方法的不同增强

1.为什么说JDK动态代理必须要实现当前父接口才能使用 JDK动态代理是基于接口的代理，它要求目标类（被代理的类）必须实现一个或多个接口。这是因为JDK动态代理是通过创建目标类的接口的代理对象来实现的，代理对象实现了目标接口，并在方法调用时委托给InvocationHandler中的invoke方法 ...阅读全文