• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营
  • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    详解Go 并发

    golang 天生语言层面支持并发, 非常棒的语言, 有时我们业务开发时, 遇到复杂场景, 需要用于并发, 将多个请求使用协程组完成并发, 当遇到嵌套循环,还存在上下文关系需要改造为并发请求, 将之前的时间复杂度为O(n^2)改为O(n)的时间复杂度, 那是否还能否并时间复杂度进一步降为O(1)呢? 就出现嵌套并发. 具体如何嵌套并发, 如何写. 今天就一步一步分析.

    串行执行

    1. 时间复杂度为O(n^2)
    2. 不使用并发
    3. 结果执行时间为 9s
    // 串行执行
    func SerializeRun() {
    	start := time.Now()
    	xx := []int{1, 2, 3}
    	yy := []int{100, 200, 300}
    	for _, x := range xx {
    		for _, y := range yy {
    			abc(x, y)
    		}
    	}
    	fmt.Printf("串行执行总时间:%s\n", time.Since(start))
    }
    
    func abc(x, y int) {
    	time.Sleep(time.Second * 1)
    	fmt.Printf("x:%d, y:%d\n", x, y)
    }

    执行结果

    x:1, y:100
    x:1, y:200
    x:1, y:300
    x:2, y:100
    x:2, y:200
    x:2, y:300
    x:3, y:100
    x:3, y:200
    x:3, y:300
    串行执行总时间:9.0026338s

    单协程组并发

    1. 使用了协程组将O(n^2)降为O(n)
    2. 结果执行时间为 3s
    // 单并行执行
    func SingleConcurrenceRun() {
    	start := time.Now()
    	xx := []int{1, 2, 3}
    	yy := []int{100, 200, 300}
    	for _, x := range xx {
    		wgg := sync.WaitGroup{}
    		for _, y := range yy {
    			wgg.Add(1)
    			go func(x, y int) {
    				defer wgg.Done()
    				abc(x, y)
    			}(x, y)
    		}
    		wgg.Wait()
    	}
    	fmt.Printf("单并行执行总时间:%s\n", time.Since(start))
    }
    func abc(x, y int) {
    	time.Sleep(time.Second * 1)
    	fmt.Printf("x:%d, y:%d\n", x, y)
    }

    结果

    x:1, y:300
    x:1, y:200
    x:1, y:100
    x:2, y:100
    x:2, y:200
    x:2, y:300
    x:3, y:300
    x:3, y:100
    x:3, y:200
    单并行执行总时间:3.0013813s

    嵌套并发执行

    1. 使用嵌套协程组执行并发.
    2. 将O(n^2)降到O(1)
    3. 结果执行时间为 1s
    // 嵌套执行
    func NestConcurrenceRun() {
    	xx := []int{1, 2, 3}
    	yy := []int{100, 200, 300}
    	start := time.Now()
    	wgg := sync.WaitGroup{}
    	for _, x := range xx {
    		wgg.Add(1)
    		go func(x int) {
    			wg := sync.WaitGroup{}
    			for _, y := range yy {
    				wg.Add(1)
    				go func(x, y int) {
    					defer wg.Done()
    					abc(x, y)
    				}(x, y)
    			}
    			wg.Wait()
    			wgg.Done()
    		}(x)
    	}
    	wgg.Wait()
    	fmt.Printf("嵌套并发执行总时间:%s\n", time.Since(start))
    }
    func abc(x, y int) {
    	time.Sleep(time.Second * 1)
    	fmt.Printf("x:%d, y:%d\n", x, y)
    }

    结果

    x:1, y:200
    x:3, y:300
    x:3, y:200
    x:1, y:300
    x:2, y:200
    x:1, y:100
    x:2, y:300
    x:2, y:100
    x:3, y:100
    嵌套并发执行总时间:1.0023542s

    以上就是详解Go 并发的详细内容,更多关于Go 并发的资料请关注脚本之家其它相关文章!

    您可能感兴趣的文章:
    • 详解Go多协程并发环境下的错误处理
    • Django高并发负载均衡实现原理详解
    • golang并发编程的实现
    • 一百行Golang代码实现简单并发聊天室
    • 基于Django的乐观锁与悲观锁解决订单并发问题详解
    • django解决订单并发问题【推荐】
    • golang并发ping主机的方法
    • golang并发下载多个文件的方法
    • Go并发调用的超时处理的方法
    上一篇:详解Go 结构体格式化输出
    下一篇:MacOS下本地golang环境搭建详细教程
  • 相关文章
  • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

    详解Go 并发 详解,并发,详解,并发,