15 Go的并发

news/2024/5/19 3:26:31 标签: golang, Goroutines, Channels, WaitGroups, Mutex, Select

概述

        在上一节的内容中，我们介绍了Go的类型转换，包括：断言类型转换、显式类型转换、隐式类型转换、strconv包等。在本节中，我们将介绍Go的并发。Go语言以其强大的并发模型而闻名，其并发特性主要通过以下几个元素来实现：Goroutines、Channels、WaitGroups、Mutex和Select。通过结合使用以上元素，Go语言提供了强大的并发支持，使得编写高效、高性能、高吞吐量的并发程序变得相对容易。

Goroutines

        Goroutines是Go语言中轻量级的并发单元，可以与其他goroutine并发执行。它们在相同的地址空间内运行，但每个goroutine都有自己的栈和局部变量。Goroutine的启动和销毁开销很小，使得在程序中可以创建大量的Goroutine。相比于线程，Goroutine的创建和管理成本更低，因为它们不需要像线程一样分配固定的内存空间。此外，Goroutine之间可以通过Channels进行通信，避免使用共享内存和信号量等机制，从而避免了竞态条件和数据竞争等问题。

        Goroutine是Go语言的主要并发原语，通常用于实现高并发的应用程序。Go运行时将Goroutine有效地调度到真实的线程上，以避免浪费资源。因此，可以轻松地创建大量的Goroutine（比如：每个请求一个Goroutine），并且可以编写简单的、命令式的阻塞代码。

        Goroutine的语法格式为：

          go <func_name>(<arguments>)

        其中，go关键字表示启动一个新的Goroutine，func_name表示要启动的函数名，arguments表示传递给函数的参数列表。通过在函数调用前加上go关键字，可以启动一个新的Goroutine来执行该函数。这个Goroutine将与其他Goroutine并发执行，并且不需要显式地创建和管理线程。

        在下面的示例代码中，我们使用go关键字启动了两个Goroutine来执行printMsg函数。每个Goroutine都会打印出相应的消息，并且通过time.Sleep函数来模拟一些耗时的操作。主Goroutine在启动了其他两个Goroutine之后会等待一段时间，以确保所有Goroutine都有足够的时间来执行完毕。

package main

import (
    "fmt"
    "time"
)

func main() {
    // 启动第1个Goroutine
    go printMsg("Hello")
    // 启动第2个Goroutine
    go printMsg("CSDN")

    // 等待一段时间，以确保所有Goroutine执行完毕
    time.Sleep(time.Second)
}

func printMsg(msg string) {
    for i := 0; i < 5; i++ {
        fmt.Println(msg)
        // 模拟耗时的操作
        time.Sleep(200 * time.Millisecond)
    }
}

        注意：Goroutine之间的执行顺序是不确定的，因此每次运行程序都会得到不同的输出结果，这取决于Go运行时调度器的实现细节和系统负载等因素。

Channels

        Channels是一种通信机制，用于在goroutines之间进行数据传输和同步操作。Channels支持发送和接收操作，并且可以在发送和接收操作之间进行阻塞，以实现同步。Channels的使用非常灵活，可以根据需要进行单向或双向数据传输。它们可以用于在不同的goroutines之间传递数据，以及实现数据共享。

        在创建Channels时，可以指定其缓冲区大小，缓冲区的大小决定了可以存储在Channels中的数据量。如果空闲缓冲区为空，发送操作会被阻塞，直到有接收操作。如果空闲缓冲区已满，接收操作会被阻塞，直到有发送操作。这种机制可以实现数据在goroutines之间的有效传输和同步。

        注意：不同类型的Channel有不同的性能和用途。无缓冲的Channel（即缓冲区大小为0）可以在发送和接收操作之间进行同步，而有缓冲的Channel可以提高并发性能，但需要小心处理缓冲区溢出的问题。

        Channel的语法格式为：

          chan <type>

        其中，type表示Channel中传输的数据类型。比如：chan int表示一个用于传输整数类型的Channel。除了指定数据类型之外，还可以使用chan来创建具有不同缓冲区大小的Channel。比如：chan int buffer(10)表示创建一个缓冲区大小为10的整数类型Channel。

        除了使用chan来创建Channel之外，还可以使用内置的make函数来创建具有指定类型的Channel。比如：make(chan int)表示创建一个整数类型的无缓冲Channel。

        在使用Channel时，可以使用以下操作进行数据传输和同步。

        x := <-ch：从Channel中接收数据，并将接收到的数据赋值给变量x。

        ch <- x：向Channel中发送数据，并将变量x的值发送到Channel中。

        如果Channel被阻塞，则接收操作将阻塞直到有数据可用。如果发送操作导致缓冲区已满，则发送操作将阻塞直到有空间可用。

        在下面的示例代码中，我们将数组分为两个切片，并通过两个goroutine来计算切片之和。在goroutine完成计算并将切片之和发送到通道后，main函数会从通道中接收数据，并计算最终的总和。

package main

import "fmt"

func sum(s []int, c chan int) {
    total := 0
    for _, v := range s {
        total += v
    }

    // 把total发送到通道
    c <- total
}

func main() {
    data := []int{1, 2, 3, 4, 5, 6}
    c := make(chan int)

    offset := len(data) / 2
    go sum(data[:offset], c)
    go sum(data[offset:], c)

    // 从通道中接收结果
    x, y := <-c, <-c
    // 输出：15 6 21 或 6 15 21
    fmt.Println(x, y, x + y)
}

        除了逐个接收数据之外，还可以通过range关键字来遍历读取到的数据。注意：使用range遍历时，需要确保发送完数据后，及时调用close()函数来关闭通道。否则，range遍历不会结束，会一直阻塞等待接收新的数据。

        在下面的示例代码中，我们首先使用make函数创建了一个整数类型的Channel。然后，我们启动一个匿名的Goroutine来循环发送数字10至50到Channel中，并在发送完毕后关闭Channel。最后，我们在主Goroutine中使用range关键字来迭代接收Channel中的数据，并将其打印输出。

        通过调用close函数可关闭一个Channel，关闭Channel表示再也不会向该Channel发送任何数据。对于已经发送到Channel中的数据，仍然可以被接收。由于Channel已经被关闭，迭代接收数据将自动停止。

package main

import "fmt"

func main() {
    // 创建一个整数类型的Channel
    ch := make(chan int)
  
    // 启动一个Goroutine
    go func() {
        for i := 10; i <= 50; i += 10 {
            // 发送数据到Channel
            ch <- i
            fmt.Println("sub routine:", i)
        }

        // 关闭Channel
        close(ch)
    }()  

    // 从Channel接收数据，依次输出：10 20 30 40 50
    for num := range ch {
        fmt.Println(num)
    }  
}

WaitGroups

        在Go语言中，WaitGroups是sync包中的一个类型，用于等待一组Goroutine执行完成。它提供了一种方便的方式，以确保所有的Goroutine都执行完毕后，再继续执行后续的逻辑。

        WaitGroups的使用比较简单：首先，需要创建一个WaitGroups实例；然后，通过调用Add()函数增加等待的Goroutine数量，每个Goroutine执行完毕后要调用Done()函数进行计数减一；最后，在主Goroutine中调用Wait()函数来等待所有的Goroutine都执行完毕。

        在下面的示例代码中，我们创建了一个WaitGroups实例wg，然后通过调用Add()函数增加了两个Goroutine。每个Goroutine中使用defer语句调用Done()函数来标记该Goroutine的执行完成。最后，在主Goroutine中调用Wait()函数来等待所有的Goroutine都执行完毕，然后继续执行后续的逻辑。

package main

import "fmt"
import "sync"
import "time"

func main() {
    var wg sync.WaitGroup

    // 启动第一个Goroutine
    wg.Add(1)
    go func() {
        defer wg.Done()
        fmt.Println("Goroutine 1 started")
        time.Sleep(1 * time.Second)
        fmt.Println("Goroutine 1 finished")
    }()

    // 启动第二个Goroutine
    wg.Add(1)
    go func() {
        defer wg.Done()
        fmt.Println("Goroutine 2 started")
        time.Sleep(2 * time.Second)
        fmt.Println("Goroutine 2 finished")
    }()

    // 等待所有Goroutine执行完毕
    wg.Wait()

    // 所有Goroutine执行完毕后，继续执行后续逻辑
    fmt.Println("All Goroutines finished")
}

Mutex

        在Go语言中，mutex是一种用于实现并发安全的锁机制。它提供了一种简单的方式来保护共享资源，以避免多个Goroutine同时访问和修改数据，从而导致竞争条件或数据不一致的问题。mutex通常是通过sync.Mutex类型来实现的，这个类型提供了两个函数：Lock和Unlock。

        在下面的示例代码中，我们定义了一个全局变量counter和一个sync.Mutex类型的变量mutex。在increment函数中，我们使用mutex.Lock()来锁定mutex，以确保在同一时间只有一个Goroutine可以访问和修改counter。在完成对counter的修改后，使用defer mutex.Unlock()来解锁mutex，以确保在函数返回之前释放锁，从而允许其他Goroutine获取锁并访问共享资源。最后，在主函数中，我们启动了5个并发的Goroutine来增加计数器的值，并等待一段时间后打印最终的计数结果。

package main

import "fmt"
import "sync"
import "time"

var (
    counter int
    mutex sync.Mutex
)  

func increment() {
    // 锁定mutex，确保同一时间只有一个Goroutine可以访问和修改counter
    mutex.Lock()
    defer mutex.Unlock()

    // 增加计数器的值
    fmt.Println("Current counter:", counter)
    counter++
}

func main() {
    // 启动5个并发的Goroutine来增加计数器的值
    for i := 0; i < 5; i++ {
        go increment()
    }

    // 等待所有Goroutine执行完毕
    time.Sleep(time.Second)
    fmt.Println("Final counter:", counter)
}

Select

        select语句用于在多个通道操作之间进行选择，它允许你等待多个通道操作中的任意一个完成，然后执行对应的代码块。其语法如下：

select {
case <-channel1:
    // 执行channel1操作完成的代码块
case <-channel2:
    // 执行channel2操作完成的代码块
case <-channel3:
    // 执行channel3操作完成的代码块
default:
    // 如果没有任何通道操作完成，执行default代码块
}

        在select语句中，每个case子句必须是一个通道操作。当其中一个通道操作完成时，对应的代码块将被执行。如果没有任何通道操作完成，且存在default子句，则执行default代码块。

        在下面的示例代码中，我们创建了三个通道，并使用三个Goroutine分别向这三个通道发送消息。然后，在select语句中等待哪个通道先完成操作，并打印收到的消息。由于发送消息的Goroutine使用了不同的延迟时间，因此最终打印的消息取决于哪个通道最先完成操作。

package main

import "fmt"
import "time"

func func1(channel1 chan string) {
    time.Sleep(1 * time.Second)
    channel1 <- "Channel 1"
}

func func2(channel2 chan string) {
    time.Sleep(2 * time.Second)
    channel2 <- "Channel 2"
}

func func3(channel3 chan string) {
    time.Sleep(3 * time.Second)
    channel3 <- "Channel 3"
}

func main() {  
    channel1 := make(chan string)
    channel2 := make(chan string)
    channel3 := make(chan string)

    go func1(channel1)
    go func2(channel2)
    go func3(channel3)

    select {
    case msg1 := <-channel1:
        fmt.Println("Received from Channel 1:", msg1)
    case msg2 := <-channel2:
        fmt.Println("Received from Channel 2:", msg2)
    case msg3 := <-channel3:
        fmt.Println("Received from Channel 3:", msg3)
    }
}


http://www.niftyadmin.cn/n/5202111.html

相关文章

linux rsyslog综合实战2

linux rsyslog综合实战2

本次我们通过rsyslog服务将A节点服务器上的两个(E.g：多个日志也可以)日志(Path:/var/log/245-1.log、245-2.log)实时同步到B节点服务器目录下(Path:/opt/rsyslog/245) 1.rsyslog架构 2.环境信息 环境信息 HostnameIpAddressOS versionModuleNotersyslog1192.168.10.245CentOS…
阅读更多...
基于霍克斯过程的限价订单簿模型下的深度强化学习做市策略

基于霍克斯过程的限价订单簿模型下的深度强化学习做市策略

数量技术宅团队在CSDN学院推出了量化投资系列课程 欢迎有兴趣系统学习量化投资的同学&#xff0c;点击下方链接报名&#xff1a; 量化投资速成营&#xff08;入门课程&#xff09; Python股票量化投资 Python期货量化投资 Python数字货币量化投资 C语言CTP期货交易系统开…
阅读更多...
2021秋招-总目录

2021秋招-总目录

2021秋招-目录 知识点总结 预训练语言模型: Bert家族 1.1 BERT、attention、transformer理解部分 B站讲解–强烈推荐可视化推倒结合代码理解代码部分常见面试考点以及问题: word2vec 、 fasttext 、elmo;BN 、LN、CN、WNNLP中的loss与评价总结 4.1 loss_function&#xff1…
阅读更多...
2023.11.20 关于 Spring MVC 详解

2023.11.20 关于 Spring MVC 详解

目录 MVC 工作流程 Spring MVC 掌握三个功能 创建 Spring MVC 项目 推荐安装插件 EditStarters 安装步骤 使用方法 实现连接功能 基础注解 RequestMapping 指定 GET 和 POST 方法类型 ResponseBody 获取参数 传递 单个 或 多个参数 参数重命名 RequestParam …
阅读更多...
pytorch中.to(device) 和.cuda()的区别

pytorch中.to(device) 和.cuda()的区别

在PyTorch中&#xff0c;使用GPU加速可以显著提高模型的训练速度。在将数据传递给GPU之前&#xff0c;需要将其转换为GPU可用的格式。 函数原型如下&#xff1a; def cuda(self: T, device: Optional[Union[int, device]] None) -> T:return self._apply(lambda t: t.cuda…
阅读更多...
享元模式 rust和java的实现

享元模式 rust和java的实现

文章目录 享元模式介绍实现javarust实现代码 rust仓库rust仓库 享元模式 享元模式&#xff08;Flyweight Pattern&#xff09;主要用于减少创建对象的数量&#xff0c;以减少内存占用和提高性能。这种类型的设计模式属于结构型模式&#xff0c;它提供了减少对象数量从而改善应…
阅读更多...
探索 Material 3：全新设计系统和组件库的介绍

探索 Material 3：全新设计系统和组件库的介绍

探索 Material 3&#xff1a;全新设计系统和组件库的介绍 一、Material 3 简介1.1 Material 3 的改进和更新1.2 Material 3 的优势特点 二、Material 3 主题使用2.1 使用 Material3 主题2.2 使用 Material3 主题颜色 三、Material 3 组件使用3.1 MaterialButton&#xff1a;支持…
阅读更多...
【Java】多线程-单例模式/volatile-指令重排序

【Java】多线程-单例模式/volatile-指令重排序

单例模式即代码中只有一个实例的模式 适用场景&#xff1a;有些场景下&#xff0c;有的类只能有一个对象&#xff0c;不能有多个 要注意&#xff1a;在单例模式下&#xff0c;要保证不能产生多个实例 1、饿汉模式 class Singleton{private static Singleton instance new …
阅读更多...
最新文章

Copyright @ 2022~2023