Go语言的并发编程_golang 并发编程-优快云博客

本文链接：https://blog.youkuaiyun.com/2501_90436042/article/details/145390214

Go语言的并发编程

随着计算机科技的不断发展，尤其是多核处理器的普及并且网络应用的迅猛增长，程序的并发性变得愈发重要。Go语言（也称为Golang）凭借其内置的并发特性和简单的语法，提供了一种更为简洁高效的并发编程方式。在这篇文章中，我们将探讨Go语言的并发编程模型、goroutine、channel等核心概念，以及如何使用这些工具来构建高效的并发应用程序。

1. 什么是并发编程？

并发编程是指在同一时间段内，处理多个任务的能力。更具体地说，程序的多个部分可以在逻辑上并行运行，这使得程序能够在等待某个任务完成时，执行其他任务。对于I/O密集型的应用，如网络请求、文件读写等，并发编程能显著提升程序的性能。

2. Go语言的并发模型

Go语言的并发模型是基于CSP（Communicating Sequential Processes，即通信顺序进程）理论构建的。在Go中，Concurrency（并发）和Parallelism（并行）是不同的概念： - 并发：指的是在同一时间段内可以处理的多个任务。它强调任务的切换。 - 并行：则是指真正同时进行的任务，这通常依赖多核处理器的支持。

Go语言的设计允许程序员简单地创建并发程序，为此提供了两大核心工具：goroutine和channel。

3. Goroutine：轻量级线程

在Go中，goroutine是一种比传统线程更加轻量级的执行单元。通过关键字go，我们可以启动一个新的goroutine。goroutine的调度由Go运行时管理，开发者无需关心底层的线程管理。

3.1 启动goroutine

启动一个goroutine非常简单，只需在函数调用前加上go关键字：

```go package main

import ( "fmt" "time" )

func sayHello() { for i := 0; i < 5; i++ { fmt.Println("Hello", i) time.Sleep(time.Second) } }

func main() { go sayHello() // 启动goroutine for i := 0; i < 5; i++ { fmt.Println("Main", i) time.Sleep(time.Second) } } ```

在上述示例中，sayHello函数作为一个goroutine被启动，主函数也在并发执行。两者的输出将会交替进行。

3.2 Goroutine的生命周期

每个goroutine都有其独立的生命周期。在执行结束后，goroutine将会被自动回收。这种特性使得Go语言处理高并发场景时，可以轻松地创建成千上万个goroutine，而不会有太大的性能损耗，通常是数MB的内存使用，使得goroutine的启动和管理的代价极低。

4. Channel：goroutine间的通信

在并发编程中，不同的执行单元之间需要交换数据或信息，这时就需要一种机制来实现它们之间的通信。Go语言使用channel这一特性来进行goroutine间的通信。通过channel，goroutine可以安全地传递数据，从而避免了直接共享数据导致的竞争条件。

4.1 创建和使用Channel

创建一个channel使用make函数，基本的使用示例如下：

```go package main

import ( "fmt" )

func greet(c chan string) { c <- "Hello, goroutine!" }

func main() { c := make(chan string) // 创建一个channel go greet(c) // 启动goroutine message := <-c // 从channel中接收消息 fmt.Println(message) // 输出: Hello, goroutine! } ```

在这个例子中，我们创建了一个string类型的channel，并用它来传递消息。在goroutine中，我们使用c <- "Hello, goroutine!"将数据发送到channel。而在主函数中，我们通过message := <-c从channel中接收消息。

4.2 Buffered Channel

Go中的channel可以是缓冲的，即允许一定数量的数据在没有接收者的情况下被发送。这样可以有效地减小goroutine之间的阻塞。创建一个缓冲channel时，可以指定buffer的大小：

```go package main

import ( "fmt" )

func main() { c := make(chan string, 2) // 创建一个缓冲区大小为2的channel c <- "Hello" c <- "World" fmt.Println(<-c) // 输出: Hello fmt.Println(<-c) // 输出: World } ```

4.3 关闭Channel

在使用channel传递数据时，一旦不再需要使用它时应该关闭channel，以通知接收者已经没有数据可来。关闭channel使用close函数。

```go package main

import ( "fmt" )

func main() { c := make(chan string) go func() { c <- "Hello" close(c) // 关闭channel }()

for msg := range c { // 使用`range`遍历channel
    fmt.Println(msg) // 输出: Hello
}

} ```

在这个例子中，主goroutine从channel中循环读取数据，直到channel被关闭。

5. select：处理多路复用

在处理多个channel时，Go提供了select语句，它允许我们等待多个通信操作中的任意一个完成。这个特性使得开发者能够方便地处理并发的I/O操作。

5.1 使用Select

select的基本语法如下：

go select { case msg1 := <-c1: // 处理c1的消息 case msg2 := <-c2: // 处理c2的消息 case msg3 := <-c3: // 处理c3的消息 default: // 如果没有channel准备好，可以做其他事情 }

以下是使用select的示例：

```go package main

import ( "fmt" "time" )

func sendData(c chan string) { time.Sleep(2 * time.Second) c <- "Data from goroutine" }

func main() { c1 := make(chan string) c2 := make(chan string)

go sendData(c1)
go sendData(c2)

for i := 0; i < 2; i++ {
    select {
    case msg := <-c1:
        fmt.Println("Received:", msg)
    case msg := <-c2:
        fmt.Println("Received:", msg)
    }
}

} ```

在这个例子中，我们启动了两个goroutine来向两个不同的channel发送数据。在主程序中，通过select等待消息并处理。这种写法更加优雅且易于维护。

6. 实际应用：构建一个简单的并发HTTP爬虫

为了更好地理解Go语言的并发机制，我们来构建一个简单的并发HTTP爬虫。这个爬虫会请求多个网页并打印出响应的状态码。

6.1 实现爬虫的基本结构

首先，我们需要导入必要的包，并设置基本的URL列表：

```go package main

import ( "fmt" "net/http" "sync" )

var urls = []string{ "http://example.com", "http://golang.org", "http://google.com", } ```

6.2 定义爬虫函数

随后，我们定义一个爬虫函数，这个函数将负责请求URL并输出响应状态码：

go func fetch(url string, wg *sync.WaitGroup) { defer wg.Done() // 函数结束时调用Done resp, err := http.Get(url) if err != nil { fmt.Println("Error fetching:", url, err) return } fmt.Println(url, ":", resp.Status) }

6.3 启动并发爬虫

接下来，使用sync.WaitGroup管理goroutine的等待：

go func main() { var wg sync.WaitGroup for _, url := range urls { wg.Add(1) // 添加一个等待计数 go fetch(url, &wg) // 启动goroutine } wg.Wait() // 等待所有goroutine完成 }

6.4 完整代码

将上述代码整合，得到完整的HTTP爬虫示例：

```go package main

import ( "fmt" "net/http" "sync" )

var urls = []string{ "http://example.com", "http://golang.org", "http://google.com", }

func fetch(url string, wg *sync.WaitGroup) { defer wg.Done() resp, err := http.Get(url) if err != nil { fmt.Println("Error fetching:", url, err) return } fmt.Println(url, ":", resp.Status) }

func main() { var wg sync.WaitGroup for _, url := range urls { wg.Add(1) go fetch(url, &wg) } wg.Wait() } ```