开始吧：Golang并发性，第1部分

最新推荐文章于 2024-10-04 13:19:28 发布

cunjie3951

最新推荐文章于 2024-10-04 13:19:28 发布

阅读量127

点赞数

文章标签：网络 python java 多线程 golang

总览

每种成功的编程语言都有一些使它成功的杀手级功能。 Go的长处是并发编程。它旨在围绕强大的理论模型（CSP）进行设计，并以“ go”关键字的形式提供语言级别的语法，该关键字可启动异步任务（是的，该语言以关键字命名），以及一种内置方式在并发任务之间进行通信。

在本文（第1部分）中，我将介绍Go的并发实现的CSP模型，goroutines，以及如何同步多个协作goroutines的操作。在以后的文章（第二部分）中，我将介绍Go的通道以及如何在没有同步数据结构的goroutine之间进行协调。

CSP

CSP代表通信顺序过程。它是由Tony（CAR）Hoare于1978年首次提出的。CSP是用于描述并发系统的高级框架。在CSP抽象级别进行操作时，编写正确的并发程序要比在典型的线程和锁抽象级别进行编程容易得多。

Goroutines

Goroutines是协程的一种玩法。但是，它们并不完全相同。 goroutine是在与启动线程不同的线程上执行的函数，因此不会阻塞该函数。多个goroutine可以共享同一操作系统线程。与协程不同，goroutine无法显式地将控制权交给另一个goroutine。当特定的goroutine阻止I / O访问时，Go的运行时将隐式转移控制权。

让我们看一些代码。下面的Go程序定义了一个函数，该函数创造性地称为“ f”，该函数随机睡眠半秒钟，然后输出其参数。 main()函数在四个迭代循环中调用f()函数，其中在每个迭代中，它连续三次调用f()连续执行“ 1”，“ 2”和“ 3”。如您所料，输出为：

--- Run sequentially as normal functions
1
2
3
1
2
3
1
2
3
1
2
3

然后main在类似的循环中将f()作为goroutine调用。现在结果有所不同，因为Go的运行时将同时运行f goroutine，然后由于goroutine之间的随机睡眠不同，因此不会按调用f()的顺序打印值。这是输出：

--- Run concurrently as goroutines
2
2
3
1
3
2
1
3
1
1
3
2
2
1
3

该程序本身使用“时间”和“数学/ rand”标准库包来实现随机睡眠和最终等待所有goroutine完成。这很重要，因为当主线程退出时，即使仍有大量的goroutine仍在运行，程序也已完成。

package main

import (
    "fmt"
	"time"
	"math/rand"
)

var r = rand.New(rand.NewSource(time.Now().UnixNano()))

func f(s string) {
	// Sleep up to half a second
	delay := time.Duration(r.Int() % 500) * time.Millisecond
	time.Sleep(delay)
	fmt.Println(s)	
}


func main() {
	fmt.Println("--- Run sequentially as normal functions")
	for i := 0; i < 4; i++ {
		f("1")
		f("2")
		f("3")
	}

	fmt.Println("--- Run concurrently as goroutines")
	for i := 0; i < 5; i++ {
		go f("1")
		go f("2")
		go f("3")
	}
	
	// Wait for 6 more seconds to let all go routine finish
	time.Sleep(time.Duration(6) * time.Second)
	fmt.Println("--- Done.")	
}

同步组

当到处都是一堆狂野的goroutine时，您通常想知道它们何时完成。

有多种方法可以执行此操作，但是最好的方法之一是使用WaitGroup 。 WaitGroup是在“ sync”包中定义的一种类型，它提供Add() ， Done()和Wait()操作。它像一个计数器一样工作，它计算仍然有多少个go例程处于活动状态，并等待它们全部完成。每当启动新的goroutine时，都将调用Add(1) （如果启动多个go例程，则可以添加多个）。当goroutine完成后，它将调用Done() ，将计数减少一，并且Wait()块直到计数达到零为止。

让我们将之前的程序转换为使用WaitGroup而不是Hibernate六秒钟，以防万一最终。请注意， f()函数使用defer wg.Done()而不是直接调用wg.Done() 。这对于确保始终调用wg.Done()很有用，即使出现问题并且goroutine提前终止。否则，计数将永远不会达到零，并且wg.Wait()可能永远阻塞。

另一个小技巧是在调用f()三次之前，我只调用一次wg.Add(3) 。请注意，即使将f()作为常规函数调用，我wg.Add()调用wg.Add() 。这是必要的，因为f()调用wg.Done()不管它是作为函数运行还是通过goroutine运行。

package main

import (
    "fmt"
	"time"
	"math/rand"
	"sync"
)

var r = rand.New(rand.NewSource(time.Now().UnixNano()))
var wg sync.WaitGroup

func f(s string) {
	defer wg.Done()
	// Sleep up to half a second
	delay := time.Duration(r.Int() % 500) * time.Millisecond
	time.Sleep(delay)
	fmt.Println(s)	
}


func main() {
	fmt.Println("--- Run sequentially as normal functions")
	for i := 0; i < 4; i++ {
		wg.Add(3)
		f("1")
		f("2")
		f("3")
		
	}

	fmt.Println("--- Run concurrently as goroutines")
	for i := 0; i < 5; i++ {
		wg.Add(3)
		go f("1")
		go f("2")
		go f("3")
	}
	
	wg.Wait()	
}

同步数据结构

1,2,3程序中的goroutine不会相互通信，也不会对共享数据结构进行操作。在现实世界中，这通常是必需的。 “同步”包为互斥类型提供了具有互斥功能的Lock()和Unlock()方法。标准的Go地图就是一个很好的例子。

它不是根据设计同步的。这意味着，如果多个goroutine在没有外部同步的情况下并发访问同一映射，则结果将不可预测。但是，如果所有goroutine都同意在每次访问之前获取共享的互斥锁并在以后释放它，那么访问将被序列化。

放在一起

让我们放在一起。著名的“围棋之旅”有一个构建网络爬虫的练习。它们提供了一个包含模拟Fetcher的出色框架，其结果使您可以专注于手头的问题。我强烈建议您尝试自己解决它。

我使用两种方法编写了一个完整的解决方案：同步地图和通道。完整的源代码在这里。

这是“同步”解决方案的相关部分。首先，让我们定义一个具有互斥体结构的映射，以保存获取的URL。请注意有趣的语法，其中在一个语句中创建，初始化了匿名类型并将其分配给变量。

var fetchedUrls = struct {
    urls map[string]bool
	m    sync.Mutex
}{urls: make(map[string]bool)}

现在，代码可以在访问URL映射之前锁定m互斥锁，并在完成后解锁。

// Check if this url has already been fetched (or being fetched)
    fetchedUrls.m.Lock()
	if fetchedUrls.urls[url] {
		fetchedUrls.m.Unlock()
		return
	}

	// OK. Let's fetch this url
	fetchedUrls.urls[url] = true
	fetchedUrls.m.Unlock()

这不是完全安全的，因为其他任何人都可以访问fetchedUrls变量而忘记锁定或解锁。更加健壮的设计将提供一种数据结构，通过自动执行锁定/解锁来支持安全操作。