一文带你了解Golang中的并发性

目录
  • 什么是并发性,为什么它很重要
  • 并发性与平行性
    • Goroutines, the worker Mortys
    • Channels, the green portal
  • 总结

并发是一个很酷的话题,一旦你掌握了它,就会成为一笔巨大的财富。说实话,我一开始很害怕写这篇文章,因为我自己直到最近才对并发性不太适应。我已经掌握了基础知识,所以我想帮助其他初学者学习Go的并发性。这是众多并发性教程中的第一篇,请继续关注更多的教程。

什么是并发性,为什么它很重要

并发是指在同一时间运行多个事物的能力。你的电脑有一个CPU。一个CPU有几个线程。每个线程通常一次运行一个程序。当我们通常写代码时,这些代码是按顺序运行的,也就是说,每项工作都是背对背运行的。在并发代码中,这些工作是由线程同时运行的。

一个很好的比喻是对一个家庭厨师的比喻。我还记得我第一次尝试煮意大利面的时候。我按照菜谱一步步地做。我切了蔬菜,做了酱汁,然后煮了意大利面条,再把两者混合起来。在这里,每一步都是按顺序进行的,所以下一项工作必须等到当前工作完成后才能进行。

快进到现在,我在烹饪意大利面条方面变得更有经验。我现在先开始做意大利面,然后在这期间进行酱汁的制作。烹饪时间几乎减少到一半,因为烹饪意大利面条和酱汁是同时进行的。

并发性与平行性

并发性与并行性有些不同。并行性与并发性类似,即同时发生多项工作。然而,在并行性中,多个线程分别在进行不同的工作,而在并发性中,一个线程在不同的工作之间游走。

因此,并发性和并行性是两个不同的概念。一个程序既可以并发地运行,也可以并行地运行。你的代码可以按顺序写,也可以按并发写。该代码可以在单核机器或多核机器上运行。把并发性看作是你的代码的一个特征,而把并行性看作是执行的一个特征。

Goroutines, the worker Mortys

Go使编写并发代码变得非常简单。每个并发的工作都由一个goroutine来表示。你可以通过在函数调用前使用go关键字来启动一个goroutine。看过《瑞克和莫蒂》吗?想象一下,你的主函数是一个Rick,他把任务委托给goroutine Mortys。

让我们从一个连续的代码开始。

package main

import (
    "fmt"
    "time"
)

func main() {
    simple()
}

func simple() {
    fmt.Println(time.Now(), "0")
    time.Sleep(time.Second)

    fmt.Println(time.Now(), "1")
    time.Sleep(time.Second)

    fmt.Println(time.Now(), "2")
    time.Sleep(time.Second)

    fmt.Println("done")
}

2022-08-14 16:22:46.782569233 +0900 KST m=+0.000033220 0
2022-08-14 16:22:47.782728963 +0900 KST m=+1.000193014 1
2022-08-14 16:22:48.782996361 +0900 KST m=+2.000460404 2
done

上面的代码打印出当前时间和一个字符串。每条打印语句的运行时间为一秒。总的来说,这段代码大约需要三秒钟的时间来完成。

现在让我们把它与一个并发的代码进行比较。

func main() {
    simpleConc()
}

func simpleConc() {
    for i := 0; i < 3; i++ {
        go func(index int) {
            fmt.Println(time.Now(), index)
        }(i)
    }

    time.Sleep(time.Second)
    fmt.Println("done")
}

2022-08-14 16:25:14.379416226 +0900 KST m=+0.000049175 2
2022-08-14 16:25:14.379446063 +0900 KST m=+0.000079012 0
2022-08-14 16:25:14.379450313 +0900 KST m=+0.000083272 1
done

上面的代码启动了三个goroutines,分别打印当前时间和i。这段代码花了大约一秒钟完成。这比顺序版本快了三倍左右。

"等一下,"我听到你问。"为什么要等整整一秒?难道我们不能删除这一行以使程序尽可能快地运行吗?"好问题!让我们看看会发生什么。

func main() {
    simpleConcFail()
}

func simpleConcFail() {
    for i := 0; i < 3; i++ {
        go func(index int) {
            fmt.Println(time.Now(), index)
        }(i)
    }

    fmt.Println("done")
}

done

嗯......。程序确实在没有任何慌乱的情况下退出了,但我们缺少来自goroutines的输出。为什么它们被跳过?

这是因为在默认情况下,Go并不等待goroutine的完成。你知道main也是在goroutine里面运行的吗?主程序通过调用simpleConcFail来启动工作程序,但它在工作程序完成工作之前就退出了。

让我们回到烹饪的比喻上。想象一下,你有三个厨师,他们分别负责烹饪酱料、意大利面和肉丸。现在,想象一下,如果戈登-拉姆齐命令厨师们做一盘意大利面条和肉丸子。这三位厨师将努力工作,烹制酱汁、意大利面条和肉丸。但是,在厨师们还没有完成的时候,戈登就按了铃,命令服务员上菜。很明显,食物还没有准备好,顾客只能得到一个空盘子。

这就是为什么我们在退出节目前等待一秒钟。我们并不总是确定每项工作都会在一秒钟内完成。有一个更好的方法来等待工作的完成,但我们首先需要学习另一个概念。

总结一下,我们学到了这些东西:

  • 工作被委托给goroutines。
  • 使用并发性可以提高你的性能。
  • 主goroutine默认不等待工作goroutine完成。
  • 我们需要一种方法来等待每个goroutine完成。

Channels, the green portal

goroutines之间是如何交流的?当然是通过通道。通道的作用类似于门户。你可以通过通道发送和接收数据。下面是你如何在Go中制作一个通道。

ch := make(chan int)

每个通道都是强类型的,并且只允许该类型的数据通过。让我们看看我们如何使用这个。

func main() {
    unbufferedCh()
}

func unbufferedCh() {
    ch := make(chan int)

    go func() {
        ch <- 1
    }()

    res := <-ch
    fmt.Println(res)
}

1

很简单,对吗?我们做了一个名为ch的通道。我们有一个goroutine,向ch发送1,我们接收该数据并将其保存到res。

你问,为什么我们在这里需要一个goroutine?因为不这样做会导致死锁。

func main() {
    unbufferedChFail()
}

func unbufferedChFail() {
    ch := make(chan int)
    ch <- 1
    res := <-ch
    fmt.Println(res)
}

fatal error: all goroutines are asleep - deadlock!

我们碰到了一个新词。什么是死锁?死锁就是你的程序被卡住了。为什么上面的代码会卡在死锁中?

为了理解这一点,我们需要知道通道的一个重要特性。我们创建了一个无缓冲的通道,这意味着在某一特定时间内没有任何东西可以被存储在其中。这意味着发送方和接收方都必须同时准备好,才能在通道上传输数据。

在失败的例子中,发送和接收的动作依次发生。我们发送1到ch,但在那个时候没有人接收数据。接收发生在稍后的一行,这意味着在接收行运行之前,1不能被发送。可悲的是,1不能先被发送,因为ch是没有缓冲的,没有空间来容纳任何数据。

在这个工作例子中,发送和接收的动作同时发生。主函数启动了goroutine,并试图从ch中接收,此时goroutine正在向ch发送1。

另一种从通道接收而不发生死锁的方法是先关闭通道。

func main() {
    unbufferedCh()
}

func unbufferedCh() {
    ch2 := make(chan int)
    close(ch2)
    res2 := <-ch2
    fmt.Println(res2)
}

0

关闭通道意味着不能再向它发送数据。我们仍然可以从该通道中接收它。对于未缓冲的通道,从一个关闭的通道接收将返回一个通道类型的零值。

总结一下,我们学到了这些东西:

  • 通道是goroutines之间相互交流的方式。
  • 你可以通过通道发送和接收数据。
  • 通道是强类型的。
  • 没有缓冲的通道没有空间来存储数据,所以发送和接收必须同时进行。否则,你的代码就会陷入死锁。
  • 一个封闭的通道将不接受任何数据。
  • 从一个封闭的非缓冲通道接收数据将返回一个零值。

如果通道能保持数据一段时间,那不是很好吗?这里就是缓冲通道发挥作用的地方。

Buffered channels, the portal that is somehow cylindrical?

缓冲通道是带有缓冲器的通道。数据可以存储在其中,所以发送和接收不需要同时进行。

func main() {
    bufferedCh()
}

func bufferedCh() {
    ch := make(chan int, 1)
    ch <- 1
    res := <-ch
    fmt.Println(res)
}

1

在这里,1被储存在ch里面,直到我们收到它。

很明显,我们不能向一个满了缓冲区的通道发送更多的信息。你需要在缓冲区内有空间才能发送更多。

func main() {
    bufferedChFail()
}

func bufferedChFail() {
    ch := make(chan int, 1)
    ch <- 1
    ch <- 2
    res := <-ch
    fmt.Println(res)
}

fatal error: all goroutines are asleep - deadlock!

你也不能从一个空的缓冲通道接收。

func main() {
    bufferedChFail2()
}

func bufferedChFail2() {
    ch := make(chan int, 1)
    ch <- 1
    res := <-ch
    res2 := <-ch
    fmt.Println(res, res2)
}

fatal error: all goroutines are asleep - deadlock!

如果一个通道已满,发送操作将等待,直到有可用的空间。这在这段代码中得到了证明。

func main() {
    bufferedCh2()
}

func bufferedCh2() {
    ch := make(chan int, 1)
    ch <- 1
    go func() {
        ch <- 2
    }()
    res := <-ch
    fmt.Println(res)
}

1

我们接收一次是为了取出1,这样goroutine就可以发送2到通道。我们没有从ch接收两次,所以只接收1。

我们也可以从封闭的缓冲通道接收。在这种情况下,我们可以在封闭的通道上设置范围来迭代里面的剩余项目。

func main() {
    bufferedChRange()
}

func bufferedChRange() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
    close(ch)
    for res := range ch {
        fmt.Println(res)
    }
    // you could also do this
    // fmt.Println(<-ch)
    // fmt.Println(<-ch)
    // fmt.Println(<-ch)
}

1
2
3

在一个开放的通道上测距将永远不会停止。这意味着在某些时候,通道将是空的,测距循环将试图从一个空的通道接收,从而导致死锁。

总结一下:

  • 缓冲通道是有空间容纳项目的通道。
  • 发送和接收不一定要同时进行,与非缓冲通道不同。
  • 向一个满的通道发送和从一个空的通道接收将导致一个死锁。
  • 你可以在一个封闭的通道上进行迭代,以接收缓冲区内的剩余值。

等待戈多...我的意思是,goroutines来完成,使用通道

通道可以用来同步goroutines。还记得我告诉过你,在通过无缓冲通道传输数据之前,发送方和接收方必须都准备好了吗?这意味着接收方将等待,直到发送方准备好。我们可以说,接收是阻断的,意思是接收方将阻断其他代码的运行,直到它收到东西。让我们用这个巧妙的技巧来同步我们的goroutines。

func main() {
    basicSyncing()
}

func basicSyncing() {
    done := make(chan struct{})

    go func() {
        for i := 0; i < 5; i++ {
            fmt.Printf("%s worker %d start\n", fmt.Sprint(time.Now()), i)
            time.Sleep(time.Duration(rand.Intn(5)) * time.Second)
        }
        close(done)
    }()

    <-done
    fmt.Println("exiting...")
}

我们做了一个done通道,负责阻断代码,直到goroutine完成。done可以是任何类型,但struct{}经常被用于这些类型的通道。它的目的不是为了传输结构,所以它的类型并不重要。

一旦工作完成,worker goroutine 将关闭 done。此时,我们可以从 done 中接收,它将是一个空结构。接收动作解除了代码的阻塞,使其可以退出。

这就是我们使用通道等待goroutine完成的方式。

总结

并发可能看起来是一个令人生畏的话题。我当然认为是这样的。然而,在了解了基础知识之后,我认为实现起来真的很美。希望你们能从这个教程中有所收获我们仅仅是触及了表面,Go为我们提供的东西还有很多。下一次我们将在更多的并发性教程中见面。再见!

到此这篇关于一文带你了解Golang中的并发性的文章就介绍到这了,更多相关Golang并发性内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 一文带你了解Go语言实现的并发神库conc

    目录 前言 worker池 Stream ForEach和map ForEach map 总结 前言 哈喽,大家好,我是asong:前几天逛github发现了一个有趣的并发库-conc,其目标是: 更难出现goroutine泄漏 处理panic更友好 并发代码可读性高 从简介上看主要封装功能如下: 对waitGroup进行封装,避免了产生大量重复代码,并且也封装recover,安全性更高 提供panics.Catcher封装recover逻辑,统一捕获panic,打印调用栈一些信息 提供一个并发

  • go语言实现并发网络爬虫的示例代码

    go语言做爬虫也是很少尝试,首先我的思路是看一下爬虫的串行实现,然后通过两个并发实现:一个使用锁,另一个使用通道 这里不涉及从页面中提取URL的逻辑(请查看Go框架colly的内容).网络抓取只是作为一个例子来考察Go的并发性. 我们想从我们的起始页中提取所有的URL,将这些URL保存到一个列表中,然后对列表中的每个URL做同样的处理.页面的图很可能是循环的,所以我们需要记住哪些页面已经经历了这个过程(或者在使用并发时,处于这个过程的中间). 串行爬虫首先检查我们是否已经在获取地图中获取了该页面

  • Go语言实现的可读性更高的并发神库详解

    目录 前言 WaitGroup的封装 worker池 Stream ForEach和map ForEach map 总结 前言 前几天逛github发现了一个有趣的并发库-conc,其目标是: 更难出现goroutine泄漏 处理panic更友好 并发代码可读性高 从简介上看主要封装功能如下: 对waitGroup进行封装,避免了产生大量重复代码,并且也封装recover,安全性更高 提供panics.Catcher封装recover逻辑,统一捕获panic,打印调用栈一些信息 提供一个并发执行

  • Golang并发编程重点讲解

    目录 1.通过通信共享 2.Goroutines 3.Channels 3.1 Channel都有哪些特性 3.2 channel 的最佳实践 4.Channels of channels 5.并行(Parallelization) 6.漏桶缓冲区(A leaky buffer) 1.通过通信共享 并发编程是一个很大的主题,这里只提供一些特定于go的重点内容. 在许多环境中,实现对共享变量的正确访问所需要的微妙之处使并发编程变得困难.Go鼓励一种不同的方法,在这种方法中,共享值在通道中传递,实际

  • 一文带你了解Golang中的并发性

    目录 什么是并发性,为什么它很重要 并发性与平行性 Goroutines, the worker Mortys Channels, the green portal 总结 并发是一个很酷的话题,一旦你掌握了它,就会成为一笔巨大的财富.说实话,我一开始很害怕写这篇文章,因为我自己直到最近才对并发性不太适应.我已经掌握了基础知识,所以我想帮助其他初学者学习Go的并发性.这是众多并发性教程中的第一篇,请继续关注更多的教程. 什么是并发性,为什么它很重要 并发是指在同一时间运行多个事物的能力.你的电脑有

  • 一文带你了解Golang中interface的设计与实现

    目录 前言 接口是什么 iface 和 eface 结构体 _type 是什么 itab 是什么 生成的 itab 是怎么被使用的 itab 关键方法的实现 根据 interfacetype 和 _type 初始化 itab 接口断言过程总览(类型转换的关键) panicdottypeI 与 panicdottypeE iface 和 eface 里面的 data 是怎么来的 convT* 方法 Java 里面的小整数享元模式 总结 在上一篇文章<go interface 基本用法>中,我们了

  • 一文带你了解Golang中的WaitGroups

    目录 什么是WaitGroups 如何使用WaitGroups 为什么使用WaitGroups而不是channel 需要注意的一件事 总结 什么是WaitGroups WaitGroups是同步你的goroutines的一种有效方式.想象一下,你和你的家人一起驾车旅行.你的父亲在一个条形商场或快餐店停下来,买些食物和上厕所.你最好想等大家回来后再开车去地平线.WaitGroups帮助你做到这一点. WaitGroups是通过调用标准库中的sync包来定义的. var wg sync.WaitGr

  • 一文带你了解Golang中select的实现原理

    目录 概述 结构 现象 非阻塞的收发 随机执行 编译 直接阻塞 独立情况 非阻塞操作 通用情况 运行时 初始化 循环 总结 概述 select是go提供的一种跟并发相关的语法,非常有用.本文将介绍 Go 语言中的 select 的实现原理,包括 select 的结构和常见问题.编译期间的多种优化以及运行时的执行过程. select 是一种与 switch 非常相似的控制结构,与 switch 不同的是,select 中虽然也有多个 case,但是这些 case 中的表达式都必须与 Channel

  • 一文带你掌握Golang Interface原理和使用技巧

    目录 1. interface 的基本概念 2. interface 的原理 3. interface 的使用技巧 3.1 使用空接口 3.2 使用类型断言 3.3 使用类型switch 3.4 使用接口组合 3.5 将方法定义在interface类型中 3.6 使用匿名接口嵌套 4. interface 的常见使用场景 4.1 依赖注入 4.2 测试驱动开发 4.3 框架设计 5. 总结 Golang 中的 interface 是一种非常重要的特性,可以让我们写出更加灵活的代码.interfa

  • 一文带你理解 Vue 中的生命周期

    目录 1.beforeCreate & created 2.beforeMount & mounted 3.beforeUpdate & updated 4.beforeDestroy & destroyed 5.activated & deactivated 前言: 每个 Vue 实例在被创建之前都要经过一系列的初始化过程.例如需要设置数据监听.编译模板.挂载实例到 DOM.在数据变化时更新 DOM 等.同时在这个过程中也会运行一些叫做生命周期钩子的函数,给予用户

  • 一文带你掌握Java8中Lambda表达式 函数式接口及方法构造器数组的引用

    目录 函数式接口概述 函数式接口示例 1.Runnable接口 2.自定义函数式接口 3.作为参数传递 Lambda 表达式 内置函数式接口 Lambda简述 Lambda语法 方法引用 构造器引用 数组引用 函数式接口概述 只包含一个抽象方法的接口,称为函数式接口. 可以通过 Lambda 表达式来创建该接口的对象. 可以在一个接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口.同时 javadoc 也会包含一条声明,说明这个接口是一个函数式接口.

  • 一文带你了解Java中的ForkJoin

    目录 什么是ForkJoin? ForkJoinTask 任务 ForkJoinPool 线程池 工作窃取算法 构造方法 提交方法 创建工人(线程) 例:ForkJoinTask实现归并排序 ForkJoin计算流程 前言: ForkJoin是在Java7中新加入的特性,大家可能对其比较陌生,但是Java8中Stream的并行流parallelStream就是依赖于ForkJoin.在ForkJoin体系中最为关键的就是ForkJoinTask和ForkJoinPool,ForkJoin就是利用

  • 一文带你了解Java中的Object类及类中方法

    目录 1. Object类介绍 2. 重写toString方法打印对象 3. 对象比较equals方法 4. hashCode方法 1. Object类介绍 Object是Java默认提供的一个类.Java里面除了Object类,所有的类都是存在继承关系的.默认会继承Object父 类.即所有类的对象都可以使用Object的引用进行接收. 范例:使用Object接收所有类的对象 class Person{} class Student{} public class Test { public s

  • 一文带你了解Qt中槽的使用

    目录 一.建立槽和按钮之间的连接 二.槽函数的定义 一.建立槽和按钮之间的连接 connect(信号发送者,发送的信号,信号接收者,信号接收者的槽函数) 1.例子 connect(ui->pushButton,SIGNAL(clicked(bool)),this,SLOT(showinfo())); 解释: 信号反发送者:pushButton(这是一个按钮),发送信号:clicked(点击按钮),信号接收者:this(本类),信号接收者的槽函数:showinfo(点击按钮后响应的函数) 二.槽函

随机推荐