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鼓励一种不同的方法,在这种方法中,共享值在通道中传递,实际上,从不由单独的执行线程主动共享。在任何给定时间,只有一个goroutine可以访问该值。根据设计,数据竞争是不可能发生的。为了鼓励这种思维方式,我们把它简化为一句口号:

Do not communicate by sharing memory; instead, share memory by communicating.

不要通过共享内存进行通信;相反,通过通信共享内存。

这种方法可能走得太远。例如,引用计数最好通过在整数变量周围放置互斥来实现。但是作为一种高级方法,使用通道来控制访问可以更容易地编写清晰、正确的程序。

考虑这个模型的一种方法是考虑一个典型的单线程程序运行在一个CPU上。它不需要同步原语。现在运行另一个这样的实例;它也不需要同步。现在让这两个程序通信;如果通信是同步器,则仍然不需要其他同步。例如,Unix管道就完美地符合这个模型。尽管Go的并发方法起源于Hoare的通信顺序处理(communication Sequential Processes, CSP),但它也可以被视为Unix管道的类型安全的泛化。

2、Goroutines

它们之所以被称为goroutine,是因为现有的术语——线程、协程、进程等等——传达了不准确的含义。goroutine有一个简单的模型:它是一个与相同地址空间中的其他goroutine并发执行的函数。它是轻量级的,比分配栈空间的成本高不了多少。而且栈开始时很小,所以它们很便宜,并通过根据需要分配(和释放)堆存储来增长。

goroutine被多路复用到多个操作系统线程上,因此如果一个线程阻塞,比如在等待I/O时,其他线程继续运行。它们的设计隐藏了线程创建和管理的许多复杂性。

在函数或方法调用前加上go关键字以在新的 goroutine 中运行该调用。当调用完成时,goroutine 将无声地退出。(效果类似于Unix shell的&符号,用于在后台运行命令。)

go list.Sort() // run list.Sort concurrently; don't wait for it.

function literal在goroutine调用中很方便。

func Announce(message string, delay time.Duration) {
    go func() {
        time.Sleep(delay)
        fmt.Println(message)
    }()  // Note the parentheses - must call the function.
}

在Go中,函数字面量( function literals )是闭包: 实现确保函数引用的变量只要处于活动状态就能存活。

3、Channels

与map一样,通道也使用make进行分配,结果值作为对底层数据结构的引用。如果提供了可选的整数参数,它将设置通道的缓冲区大小。对于无缓冲通道或同步通道,默认值为0。

ci := make(chan int)            // unbuffered channel of integers
cj := make(chan int, 0)         // unbuffered channel of integers
cs := make(chan *os.File, 100)  // buffered channel of pointers to Files

无缓冲通道将通信(值的交换)与同步结合起来,确保两个计算(gorout例程)处于已知状态。

有很多使用通道的好习语。这是一个开始。在前一节中,我们在后台启动了排序。通道可以允许启动goroutine等待排序完成。

c := make(chan int)  // Allocate a channel.
// Start the sort in a goroutine; when it completes, signal on the channel.
go func() {
    list.Sort()
    c <- 1  // Send a signal; value does not matter.
}()
doSomethingForAWhile()
<-c   // Wait for sort to finish; discard sent value.

接收者总是阻塞,直到有数据接收。如果通道无缓冲,发送方将阻塞,直到接收方接收到该值。如果通道有缓冲区,发送方只阻塞直到值被复制到缓冲区;如果缓冲区已满,这意味着需要等待到某个接收器接收到一个值。 (参考3.1)

有缓冲通道可以像信号量(semaphore)一样使用,例如限制吞吐量。在本例中,传入的请求被传递给handle, handle将一个值发送到通道中,处理请求,然后从通道接收一个值,以便为下一个使用者准备“信号量”。通道缓冲区的容量限制了要处理的同时调用的数量。

var sem = make(chan int, MaxOutstanding)
func handle(r *Request) {
    sem <- 1    // Wait for active queue to drain.
    process(r)  // May take a long time.
    <-sem       // Done; enable next request to run.
}
func Serve(queue chan *Request) {
    for {
        req := <-queue
        go handle(req)  // Don't wait for handle to finish.
    }
}

一旦MaxOutstanding处理程序正在执行进程,试图向已充满的通道缓冲区发送的请求都将阻塞,直到现有的一个处理程序完成并从缓冲区接收。

但是,这种设计有一个问题:Serve为每个传入的请求创建一个新的goroutine ,尽管在任何时候, 只有MaxOutstanding多个可以运行。因此,如果请求来得太快,程序可能会消耗无限的资源。我们可以通过更改Serve来限制goroutines的创建来解决这个缺陷。这里有一个明显的解决方案,但要注意它有一个bug,我们随后会修复:

func Serve(queue chan *Request) {
    for req := range queue {
        sem <- 1
        go func() {
            process(req) // Buggy; see explanation below.
            <-sem
        }()
    }
}

bug 在于,在Go for循环中,循环变量在每次迭代中都被重用,因此req变量在所有goroutine中共享。这不是我们想要的。我们需要确保每个goroutine的req是唯一的。这里有一种方法,在goroutine中将req的值作为参数传递给闭包:

func Serve(queue chan *Request) {
    for req := range queue {
        sem <- 1
        go func(req *Request) {
            process(req)
            <-sem
        }(req)
    }
}

将此版本与前一个版本进行比较,查看闭包的声明和运行方式的差异。另一个解决方案是创建一个同名的新变量,如下例所示:

func Serve(queue chan *Request) {
    for req := range queue {
        req := req // Create new instance of req for the goroutine.
        sem <- 1
        go func() {
            process(req)
            <-sem
        }()
    }
}

这样写似乎有些奇怪

req := req

但在Go 中这样做是合法的和惯用的。您将得到一个具有相同名称的新变量,故意在局部掩盖循环变量,但对每个goroutine都是惟一的。

回到编写服务器的一般问题,另一种很好地管理资源的方法是启动固定数量的handle goroutines ,所有这些handle goroutines 都从请求通道读取。goroutine的数量限制了process同时调用的数量。这个Serve函数还接受一个通道,它将被告知退出该通道;在启动goroutines之后,它会阻止从该通道接收。

func handle(queue chan *Request) {
    for r := range queue {
        process(r)
    }
}
func Serve(clientRequests chan *Request, quit chan bool) {
    // Start handlers
    for i := 0; i < MaxOutstanding; i++ {
        go handle(clientRequests)
    }
    <-quit  // Wait to be told to exit.
}

3.1 Channel都有哪些特性

Go语言中的channel具有以下几个特性:

线程安全

channel是线程安全的,多个协程可以同时读写一个channel,而不会发生数据竞争的问题。这是因为Go语言中的channel内部实现了锁机制,保证了多个协程之间对channel的访问是安全的。

阻塞式发送和接收

当一个协程向一个channel发送数据时,如果channel已经满了,发送操作会被阻塞,直到有其他协程从channel中取走了数据。同样地,当一个协程从一个channel中接收数据时,如果channel中没有数据可供接收,接收操作会被阻塞,直到有其他协程向channel中发送了数据。这种阻塞式的机制可以保证协程之间的同步和通信。

顺序性

通过channel发送的数据是按照发送的顺序进行排列的。也就是说,如果协程A先向channel中发送了数据x,而协程B再向channel中发送了数据y,那么从channel中接收数据时,先接收到的一定是x,后接收到的一定是y。

可以关闭

通过关闭channel可以通知其他协程这个channel已经不再使用了。关闭一个channel之后,其他协程仍然可以从中接收数据,但是不能再向其中发送数据了。关闭channel的操作可以避免内存泄漏等问题。

缓冲区大小

channel可以带有一个缓冲区,用于存储一定量的数据。如果缓冲区已经满了,发送操作会被阻塞,直到有其他协程从channel中取走了数据;如果缓冲区已经空了,接收操作会被阻塞,直到有其他协程向channel中发送了数据。缓冲区的大小可以在创建channel时指定,例如:

ch := make(chan int, 10)

会panic的几种情况

1.向已经关闭的channel发送数据

2.关闭已经关闭的channel

3.关闭未初始化的nil channel

会阻塞的情况:

1.从未初始化 nil channel中读数据

2.向未初始化 nil channel中发数据

3.在没有读取的groutine时,向无缓冲channel发数据,

有缓冲区,但缓冲区已满,发送数据时

4.在没有数据时,从无缓冲或者有缓冲channel读数据

返回零值:

从已经关闭的channe接收数据

3.2 channel 的最佳实践

在使用channel时,应该遵循以下几个最佳实践:

避免死锁

使用channel时应该注意避免死锁的问题。如果一个协程向一个channel发送数据,但是没有其他协程从channel中取走数据,那么发送操作就会一直被阻塞,从而导致死锁。为了避免这种情况,可以使用select语句来同时监听多个channel,从而避免阻塞。

避免泄漏

在使用channel时应该注意避免内存泄漏的问题。如果一个channel没有被关闭,而不再使用了,那么其中的数据就无法被释放,从而导致内存泄漏。为了避免这种情况,可以在协程结束时关闭channel。

避免竞争

在使用channel时应该注意避免数据竞争的问题。如果多个协程同时读写一个channel,那么就可能会发生竞争条件,从而导致数据不一致的问题。为了避免这种情况,可以使用锁机制或者使用单向channel来限制协程的访问权限。

避免过度使用

在使用channel时应该注意避免过度使用的问题。如果一个程序中使用了大量的channel,那么就可能会导致程序的性能下降。为了避免这种情况,可以使用其他的并发编程机制,例如锁、条件变量等。

4、Channels of channels

Go最重要的属性之一是通道是first-class值,可以像其他值一样分配和传递。此属性的常见用途是实现安全的并行多路解复用。

在上一节的示例中,handle是请求的理想处理程序,但我们没有定义它处理的类型。如果该类型包含要在其上回复的通道,则每个客户机都可以为应答提供自己的路径。下面是Request类型的示意图定义。

type Request struct {
    args        []int
    f           func([]int) int
    resultChan  chan int
}

客户端提供了一个函数及其参数,以及请求对象内用于接收answer的通道。

func sum(a []int) (s int) {
    for _, v := range a {
        s += v
    }
    return
}
request := &Request{[]int{3, 4, 5}, sum, make(chan int)}
// Send request
clientRequests <- request
// Wait for response.
fmt.Printf("answer: %d\n", <-request.resultChan)

在服务器端,唯一需要更改的是处理程序函数。

func handle(queue chan *Request) {
    for req := range queue {
        req.resultChan <- req.f(req.args)
    }
}

显然,要实现它还有很多工作要做,但这段代码是一个速率受限、并行、非阻塞RPC系统的框架,而且还没有看到mutex 。

5、并行(Parallelization)

这些思想的另一个应用是跨多个CPU核并行计算。如果计算可以被分解成可以独立执行的独立部分,那么它就可以被并行化,并在每个部分完成时用一个通道发出信号。

假设我们有一个昂贵的操作要对一个items的向量执行,并且每个item的操作值是独立的,就像在这个理想的例子中一样。

type Vector []float64
// Apply the operation to v[i], v[i+1] ... up to v[n-1].
func (v Vector) DoSome(i, n int, u Vector, c chan int) {
    for ; i < n; i++ {
        v[i] += u.Op(v[i])
    }
    c <- 1    // signal that this piece is done
}

我们在一个循环中独立地启动这些片段,每个CPU一个。它们可以按任何顺序完成,但这没有关系;我们只是在启动所有的goroutine之后通过排泄通道来计算完成信号。

const numCPU = 4 // number of CPU cores
func (v Vector) DoAll(u Vector) {
    c := make(chan int, numCPU)  // Buffering optional but sensible.
    for i := 0; i < numCPU; i++ {
        go v.DoSome(i*len(v)/numCPU, (i+1)*len(v)/numCPU, u, c)
    }
    // Drain the channel.
    for i := 0; i < numCPU; i++ {
        <-c    // wait for one task to complete
    }
    // All done.
}

我们不需要为numCPU创建一个常量,而是可以询问运行时哪个值是合适的。函数runtime.NumCPU返回机器中硬件CPU核数,因此我们可以这样写

还有一个函数 runtime.GOMAXPROCS,它报告(或设置)用户指定的Go程序可以同时运行的核数。默认值为runtime.NumCPU,但可以通过设置类似命名的shell环境变量或调用带有正数的函数来覆盖。用0调用它只是查询值。因此,如果我们想要满足用户的资源请求,我们应该写

var numCPU = runtime.GOMAXPROCS(0)

请务必不要混淆并发性(concurrency,将程序构造为独立执行的组件)和并行性(parallelism, 在多个cpu上并行执行计算以提高效率)这两个概念。尽管Go的并发特性可以使一些问题很容易构建为并行计算,但Go是一种并发语言,而不是并行语言,并且并不是所有的并行化问题都适合Go的模型。关于区别的讨论,请参阅本文章中引用的谈话。

6、漏桶缓冲区(A leaky buffer)

并发编程的工具甚至可以使非并发的想法更容易表达。下面是一个从RPC包中抽象出来的示例。客户端goroutine循环从某个源(可能是网络)接收数据。为了避免分配和释放缓冲区,它保留了一个空闲列表,并使用缓冲通道来表示它。如果通道为空,则分配一个新的缓冲区。一旦消息缓冲区准备好了,它就被发送到serverChan上的服务器。

var freeList = make(chan *Buffer, 100)
var serverChan = make(chan *Buffer)
func client() {
    for {
        var b *Buffer
        // Grab a buffer if available; allocate if not.
        select {
        case b = <-freeList:
            // Got one; nothing more to do.
        default:
            // None free, so allocate a new one.
            b = new(Buffer)
        }
        load(b)              // Read next message from the net.
        serverChan <- b      // Send to server.
    }
}

服务器循环从客户端接收每条消息,处理它,并将缓冲区返回到空闲列表。

func server() {
    for {
        b := <-serverChan    // Wait for work.
        process(b)
        // Reuse buffer if there's room.
        select {
        case freeList <- b:
            // Buffer on free list; nothing more to do.
        default:
            // Free list full, just carry on.
        }
    }
}

客户端尝试从freeList中检索缓冲区;如果没有可用的,则分配一个新的。服务器发送给freeList的消息会将b放回空闲列表中,除非空闲列表已满,在这种情况下,缓冲区将被丢弃在地板上,由垃圾收集器回收。(当没有其他case可用时,select语句中的default 子句将执行,这意味着select语句永远不会阻塞。)此实现仅用几行就构建了一个漏桶列表,依赖于缓冲通道和垃圾收集器进行记账。

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

(0)

相关推荐

  • 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中的并发性

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

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

    目录 前言 worker池 Stream ForEach和map ForEach map 总结 前言 哈喽,大家好,我是asong:前几天逛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 并发编程之生产者消费者详解

    golang 最吸引人的地方可能就是并发了,无论代码的编写上,还是性能上面,golang 都有绝对的优势 学习一个语言的并发特性,我喜欢实现一个生产者消费者模型,这个模型非常经典,适用于很多的并发场景,下面我通过这个模型,来简单介绍一下 golang 的并发编程 go 并发语法 协程 go 协程是 golang 并发的最小单元,类似于其他语言的线程,只不过线程的实现借助了操作系统的实现,每次线程的调度都是一次系统调用,需要从用户态切换到内核态,这是一项非常耗时的操作,因此一般的程序里面线程太多会

  • golang并发编程的实现

    go main函数的执行本身就是一个协程,当使用go关键字的时候,就会创建一个新的协程 channel channel 管道,用于在多个协程之间传递信号 无缓存管道 当对无缓冲通道写的时候,会一直阻塞等到某个协程对这个缓冲通道读 阻塞场景: 通道中无数据,但执行读通道. 通道中无数据,向通道写数据,但无协程读取. 综上,无缓存通道的读写必须同时存在,且读写分别在两个不同的协程 func main(){ ch := make(chan int) go func(ch chan int){ ch <

  • 瞅一眼就能学会的GO并发编程使用教程

    目录 GO的并发编程分享 啥是并发编程呢 为啥要有并发编程 并发和并行的区别 协程 goroutine 是啥 GO 高并发的原因是啥 GOLANG并发编程涉及哪些知识点呢 Goroutine的那些事 如何使用 goroutine 启动单个协程 多个协程 GO 中的协程 goroutine 是如何调度 总结 GO的并发编程分享 之前我们分享了网络编程,今天我们来看看GO的并发编程分享,我们先来看看他是个啥 啥是并发编程呢 指在一台处理器上同时处理多个任务 此处说的同时,可不是同一个时间一起手拉手做

  • java并发编程专题(八)----(JUC)实例讲解CountDownLatch

    CountDownLatch 是一个非常实用的多线程控制工具类." Count Down " 在英文中意为倒计数, Latch 为门问的意思.如果翻译成为倒计数门阀, 我想大家都会觉得不知所云吧! 因此,这里简单地称之为倒计数器.在这里, 门问的含义是:把门锁起来,不让里面的线程跑出来.因此,这个工具通常用来控制线程等待,它可以让某一个线程等待直到倒计时结束, 再开始执行. CountDown Latch 的构造函数接收一个整数作为参数,即当前这个计数器的计数个数. public Co

  • C语言通过案例讲解并发编程模型

    目录 1.按照指定的顺序输出 2.生产者消费者模型 3.读写锁 下面代码.思路等来源于b站郭郭 和CSAPP样例,同时希望大家好好读一下CSAPP的内容,真的讲的很好 1.按照指定的顺序输出 我们执行两个线程:foo1 和foo2 foo1:打印step1, step3 foo2:打印step2 请用并发使得按照1 2 3 的顺序输出 答:首先两个线程执行顺序不可预判,我们必须保证打印step2之前step1就打印好了,因此需要阻塞一下step2,实现的方式是初始化sem为0,只有打印完step

  • GoLang并发机制探究goroutine原理详细讲解

    目录 1. 进程与线程 2. goroutine原理 3. 并发与并行 3.1 在1个逻辑处理器上运行Go程序 3.2 goroutine的停止与重新调度 3.3 在多个逻辑处理器上运行Go程序 通常程序会被编写为一个顺序执行并完成一个独立任务的代码.如果没有特别的需求,最好总是这样写代码,因为这种类型的程序通常很容易写,也很容易维护.不过也有一些情况下,并行执行多个任务会有更大的好处.一个例子是,Web 服务需要在各自独立的套接字(socket)上同时接收多个数据请求.每个套接字请求都是独立的

  • 理论讲解python多进程并发编程

    一.什么是进程 进程:正在进行的一个过程或者说一个任务.而负责执行任务则是cpu. 二.进程与程序的区别 程序:仅仅是一堆代 进程:是指打开程序运行的过程 三.并发与并行 并发与并行是指cpu运行多个程序的方式 不管是并行与并发,在用户看起来都是'同时'运行的,他们都只是一个任务而已,正在干活的是cpu,而一个cpu只能执行一个任务. 并行就相当于有好多台设备,可以同时供好多人使用. 而并发就相当于只有一台设备,供几个人轮流用,每个人用一会就换另一个人. 所以只有多个cpu才能实现并行,而一个c

  • Java并发编程之关键字volatile的深入解析

    目录 前言 一.可见性 二.有序性 总结 前言 volatile是研究Java并发编程绕不过去的一个关键字,先说结论: volatile的作用: 1.保证被修饰变量的可见性 2.保证程序一定程度上的有序性 3.不能保证原子性 下面,我们将从理论以及实际的案例来逐个解析上面的三个结论 一.可见性 什么是可见性? 举个例子,小明和小红去看电影,刚开始两个人都还没买电影票,小红就先去买了两张电影票,没有告诉小明.小明以为小红没买,所以也去买了两张电影票,因为他们只有两个人,所以他们只能用两张票,这就是

  • Go并发编程实践

    前言 并发编程一直是Golang区别与其他语言的很大优势,也是实际工作场景中经常遇到的.近日笔者在组内分享了我们常见的并发场景,及代码示例,以期望大家能在遇到相同场景下,能快速的想到解决方案,或者是拿这些方案与自己实现的比较,取长补短.现整理出来与大家共享. 简单并发场景 很多时候,我们只想并发的做一件事情,比如测试某个接口的是否支持并发.那么我们就可以这么做: func RunScenario1() { count := 10 var wg sync.WaitGroup for i := 0;

随机推荐