首页 > 其他分享 >Go协程及并发锁应用指南

Go协程及并发锁应用指南

时间：2024-09-15 13:50:20浏览次数：3  
标签：协程 示例 并发 done Go Channel

概念

协程（Goroutine）是Go语言独有的并发体，是一种轻量级的线程，也被称为用户态线程。相对于传统的多线程编程，协程的优点在于更加轻量级，占用系统资源更少，切换上下文的速度更快，不需要像多线程编程一样处理锁等线程安全问题。
在这里插入图片描述

1. 协程的创建

在Go语言中，可以使用go语句来启动一个协程。go语句后面跟的是一个函数调用，即启动一个新协程去执行该函数。例如：

func main() {
    go printHello() // 启动一个goroutine去执行printHello函数
    fmt.Println("main function")
}

func printHello() {
    fmt.Println("hello goroutine")
}

在上面的代码中，printHello函数会在新的协程中执行，而不会阻塞主线程。

一、协程间的通信

在这里插入图片描述

1. Channel的定义和初始化

在Go语言中，协程之间的通信主要通过channel实现。使用make函数可以创建一个channel，其语法为：

channel_name := make(chan data_type)

其中，data_type为channel中传输数据的类型。例如，创建一个传输int类型数据的channel：

ch := make(chan int)
2. Channel的读写

Channel既可以进行发送操作，也可以进行接收操作。发送操作和接收操作都是阻塞的。

  • 发送操作：channel_name <- value
  • 接收操作：value := <-channel_name

二、并发锁的应用

在并发编程中，为了防止多个协程同时访问共享资源导致的数据竞争和不一致问题，需要使用锁机制来同步访问。Go语言提供了多种锁机制，包括互斥锁（Mutex）和读写锁（RWMutex）等。
在这里插入图片描述

1. 互斥锁（Mutex）

互斥锁是Go语言中最常用的锁机制，它确保同一时刻只有一个协程可以访问临界区。使用sync包中的Mutex类型来创建互斥锁，并通过Lock()和Unlock()方法来加锁和解锁。

import "sync"

var mutex = &sync.Mutex{}

func criticalSection() {
    mutex.Lock()
    defer mutex.Unlock()
    // 临界区代码
}
2. 读写锁（RWMutex）

读写锁允许多个协程同时读取共享资源，但在有写操作时，需要互斥访问。使用sync包中的RWMutex类型来创建读写锁，通过RLock()、RUnlock()、Lock()和Unlock()方法来分别获取读锁、释放读锁、获取写锁和释放写锁。

import "sync"

var rwlock = &sync.RWMutex{}

func read() {
    rwlock.RLock()
    defer rwlock.RUnlock()
    // 读取共享资源
}

func write() {
    rwlock.Lock()
    defer rwlock.Unlock()
    // 修改共享资源
}

三、注意事项

  1. 锁的粒度：应尽可能减少锁的持有时间，避免降低程序的性能。
  2. 避免死锁：在使用锁时，需要仔细设计锁的使用顺序，避免循环等待导致的死锁。
  3. 选择合适的锁：根据具体场景选择合适的锁机制，如读写锁在读多写少的场景下可以显著提高性能。

在这里插入图片描述

四、简单完整示例

当然，以下是一个包含Go协程、Channel以及互斥锁（Mutex）完整示例的程序。这个程序将演示如何使用协程来处理并发任务，并通过Channel进行协程间的通信，同时使用互斥锁来保护共享资源的数据一致性。

package main

import (
	"fmt"
	"sync"
	"time"
)

// 假设有一个共享资源，我们需要保护它不被并发访问破坏
var (
	sharedResource int
	mutex          sync.Mutex
)

// 一个用于修改共享资源的函数，通过互斥锁保证数据一致性
func modifySharedResource(increment int) {
	mutex.Lock()
	defer mutex.Unlock()
	sharedResource += increment
	fmt.Printf("Modified sharedResource to %d\n", sharedResource)
}

// 一个使用协程的函数，它会多次修改共享资源并通过Channel发送完成信号
func worker(done chan bool, increment int) {
	for i := 0; i < 5; i++ {
		modifySharedResource(increment)
		time.Sleep(time.Millisecond * 100) // 模拟耗时操作
	}
	done <- true // 发送完成信号
}

func main() {
	done := make(chan bool, 2) // 创建一个带有缓冲的Channel，确保可以发送两个值而不会阻塞

	// 启动两个协程，每个协程都将尝试修改共享资源
	go worker(done, 10)
	go worker(done, 20)

	// 等待两个协程完成
	for i := 0; i < 2; i++ {
		<-done // 阻塞等待接收来自协程的完成信号
	}

	fmt.Println("All workers done. Final sharedResource:", sharedResource)
}

在这个示例中：

  1. 定义了一个全局的共享资源sharedResource和一个互斥锁mutex。
  2. modifySharedResource函数用于修改共享资源，它首先加锁，修改完成后释放锁。
  3. worker函数是并发执行的函数，它接受一个done Channel和一个increment值作为参数。它会循环5次，每次循环都调用modifySharedResource来修改共享资源，并在每次修改后短暂睡眠以模拟耗时操作。循环结束后，它通过done Channel发送一个完成信号。
  4. 在main函数中，我们创建了一个done Channel和两个协程，每个协程以不同的increment值调用worker函数。
  5. 我们通过for循环和<-done从done Channel接收两次完成信号，确保两个协程都已完成工作。
  6. 最后，我们打印出最终的sharedResource值。

五、模拟错误收集示例

在Go语言中，协程（Goroutine）的错误处理通常是通过返回值、通道（Channel）或上下文（Context）来完成的。由于协程本质上是轻量级的线程，它们并不直接支持像传统线程那样的异常机制。不过，我们可以通过上述几种方式来实现错误传播和处理。

下面是一个扩展了之前示例的程序，其中增加了协程的错误处理。我们将使用通道（Channel）来传递错误和完成信号。

package main

import (
	"errors"
	"fmt"
	"sync"
	"time"
)

// 假设的共享资源
var sharedResource int
var mutex sync.Mutex

// 模拟可能失败的操作
func modifySharedResource(increment int) error {
	mutex.Lock()
	defer mutex.Unlock()
	// 假设某种条件下操作失败
	if increment < 0 {
		return errors.New("negative increment is not allowed")
	}
	sharedResource += increment
	fmt.Printf("Modified sharedResource to %d\n", sharedResource)
	return nil
}

// worker 协程函数，现在可以返回错误
func worker(done chan bool, errChan chan error, increment int) {
	for i := 0; i < 5; i++ {
		if err := modifySharedResource(increment); err != nil {
			errChan <- err // 将错误发送到错误通道
			return
		}
		time.Sleep(time.Millisecond * 100) // 模拟耗时操作
	}
	done <- true // 发送完成信号
}

func main() {
	done := make(chan bool, 2)
	errChan := make(chan error, 2) // 创建一个用于传递错误的通道

	// 启动两个协程，一个可能遇到错误
	go worker(done, errChan, 10)
	go worker(done, errChan, -5)  // 这个将尝试一个负增量，应该失败

	// 等待协程完成或接收错误
	for i := 0; i < 2; i++ {
		select {
		case <-done:
			fmt.Println("Worker done")
		case err := <-errChan:
			fmt.Println("Error received:", err)
			// 根据需要处理错误，比如退出程序、记录日志等
			// 这里我们简单地打印错误并继续等待其他协程
		}
	}

	// 注意：在实际情况中，你可能需要一种方式来确保所有协程都已完成或都已报告错误
	// 这里为了简化，我们没有实现这样的逻辑

	fmt.Println("All workers potentially done or errors reported. Final sharedResource:", sharedResource)

	// 注意：如果某些协程可能永远不发送完成信号（比如因为死循环或无限等待），
	// 你可能需要一个超时机制或一种方式来优雅地关闭这些协程。
}

在这个示例中：

  • modifySharedResource 函数现在可以返回一个错误，如果增量是负数。
  • worker 函数现在接受一个额外的 errChan 通道，用于在发生错误时发送错误消息。如果发生错误，worker 函数将发送错误并立即返回。
  • 在 main 函数中，我们使用了一个 select 语句来同时等待完成信号和错误。这允许我们在任何一个事件发生时都能立即响应。

请注意：这个示例并没有实现一个完美的错误处理策略，特别是如果某些协程可能永远不发送完成信号（比如因为死循环或无限等待）。在实际应用中，你可能需要实现更复杂的逻辑来确保程序的健壮性和可靠性。例如，你可以使用上下文（Context）来优雅地关闭或取消长时间运行的协程。

六、举一个实际应用的示例[更新购物车数量]

  1. 高效并发处理：购物车系统在高并发访问时，需要快速处理多个用户的请求。Go协程的轻量级特性使得能够轻松创建成千上万的并发任务，而不会对系统资源造成太大压力。

  2. 简化并发编程：Go的协程和通道（Channel）模型简化了并发编程的复杂度。通过通道进行协程间的通信，可以避免传统并发编程中的许多常见问题，如竞态条件、死锁等。

  3. 内置并发原语：Go标准库提供了丰富的并发原语，如互斥锁（Mutex）、读写锁（RWMutex）、条件变量（Cond）等，这些工具可以进一步帮助开发者编写安全、高效的并发代码。

  4. 易于调试和监控：Go的协程模型使得并发程序的调试和监控相对容易。通过工具如pprof、trace等，开发者可以很方便地分析并发程序的性能瓶颈和潜在问题。

购物车并发处理完整示例

下面是一个简化的购物车并发处理示例，展示了如何使用Go协程和通道来处理多个用户的购物车更新请求。

package main

import (
	"fmt"
	"sync"
	"time"
)

// 假设的购物车结构
type ShoppingCart struct {
	Items map[string]int
	mutex sync.Mutex
}

// 更新购物车的函数
func (c *ShoppingCart) Update(itemID string, quantity int) {
	c.mutex.Lock()
	defer c.mutex.Unlock()
	c.Items[itemID] += quantity
	fmt.Printf("Updated cart, item %s now has %d\n", itemID, c.Items[itemID])
}

// 模拟处理购物车更新请求的协程
func handleCartUpdate(cart *ShoppingCart, itemID string, quantity int, done chan<- bool) {
	time.Sleep(time.Millisecond * 100) // 模拟处理时间
	cart.Update(itemID, quantity)
	done <- true // 发送完成信号
}

func main() {
	cart := &ShoppingCart{Items: make(map[string]int)}
	done := make(chan bool, 10) // 假设最多同时处理10个请求

	// 模拟多个用户同时更新购物车
	for i := 0; i < 10; i++ {
		go handleCartUpdate(cart, fmt.Sprintf("item%d", i), 5, done)
	}

	// 等待所有更新完成
	for i := 0; i < 10; i++ {
		<-done
	}

	fmt.Println("All cart updates completed.")
	// 在这里可以进一步处理更新后的购物车，如发送到数据库保存等
}

在这个示例中：

  • 我们定义了一个ShoppingCart结构体，它包含一个商品项的映射和一个互斥锁来保护这个映射的并发访问。
  • Update方法用于更新购物车中的商品数量，它通过互斥锁来确保线程安全。
  • handleCartUpdate协程函数模拟了处理购物车更新请求的过程，它接收购物车、商品ID、数量和完成信号通道作为参数，并在更新完成后发送完成信号。
  • 在main函数中，我们创建了10个协程来模拟多个用户同时更新购物车的情况，并通过done通道等待所有更新完成。

请注意：这个示例为了简化而省略了一些重要的错误处理和优化措施，比如在实际应用中你可能需要处理网络请求、数据库操作等可能失败的情况，并且可能需要使用更复杂的并发控制策略来优化性能。

总结

通过以上指南，您可以更好地理解和应用Go协程及并发锁，在Go语言的并发编程中编写出高效、安全的代码。以上都是些简单代码片段示例，不能作为实际应用使用哦。

标签：协程,示例,并发,done,Go,Channel
From： https://blog.csdn.net/qq_35807303/article/details/142254248

相关文章

  • 【开题报告】基于django+vue物流管理系统（论文+程序）
    本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表开题报告内容研究背景随着电子商务的蓬勃发展和消费者购物习惯的转变，物流行业迎来了前所未有的发展机遇与挑战。传统的物流管理系统往往存在信息孤岛、效率低下......
  • 【Go - 超实用，3行代码实现个自增器】
    场景自增器的作用是生成一个唯一的递增序列号。这在一些需要生成自增id的场景十分有用，比如自增的订单号，任务号，序列号。要点全局统一：在整个服务体系下，多个服务或者进程，都统一调用这个自增器，来获取自增ID。严格自增：避免竞争，写冲突造成写覆盖等，导致不严格自增实现根据上面......
  • 【开题报告】基于django+vue旅游管理系统(论文+源码) 计算机毕业设计
    本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表开题报告内容研究背景随着旅游业的蓬勃发展，旅游市场的竞争日益激烈，传统的旅游管理方式已难以满足游客多元化、个性化的需求。在这个数字化时代，构建一个高效、便......
  • 【开题报告】基于django+vue基于Web的电影推荐与点评系统(论文+源码) 计算机毕业设计
    本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表开题报告内容研究背景随着互联网技术的飞速发展，在线娱乐已成为人们日常生活中不可或缺的一部分，其中网络电影观看尤为普及。然而，面对海量的电影资源，用户往往难以......
  • 【Go语言】quic-go实现0-RTT传输
    核心思路：在客户端的tls文件中缓存第一次连接留下来的会话票据，在第二次连接中就可以实现0-RTT。为此，重要的是实现tls.Config.ClientSessionCache这个接口的具体结构体文件目录tlscfg.go代码：这个模块主要用于实现客户端和服务器的tls配置packagetlscfgimport( "crypto......
  • Django 聚合查询
    文章目录一、聚合查询二、使用步骤1.准备工作2.具体使用3.分组查询（annotate）1.定义2.使用3.具体案例4.F()查询1.定义2.使用5.Q()查询1.定义2.查询一、聚合查询使用聚合查询前要先从django.db.models引入Avg、Max、Min、Count、Sum（首字母大写）聚合查询返回值......
  • Study Plan For Algorithms - Part32
    1.不同路径II一个机器人位于一个mxn网格的左上角（起始点在下图中标记为“Start”）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？网格中的障碍物......
  • Study Plan For Algorithms - Part30
    1.螺旋矩阵II给定一个正整数n，生成一个包含1到n2所有元素，且元素按顺时针顺序螺旋排列的nxn正方形矩阵matrix。classSolution:defgenerateMatrix(self,n:int)->List[List[int]]:matrix=[[0]*nfor_inrange(n)]num=1......
  • Study Plan For Algorithms - Part31
    1.旋转链表给定一个链表的头节点head，旋转链表，将链表每个节点向右移动k个位置。classListNode:def__init__(self,val=0,next=None):self.val=valself.next=nextclassSolution:defrotateRight(self,head:Optional[ListNode],k:int)->O......
  • 【开题报告】基于django+vue外卖订餐管理系统（论文+程序）
    本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表开题报告内容研究背景随着互联网的飞速发展和生活节奏的加快，外卖订餐服务已成为现代都市生活中不可或缺的一部分。它不仅极大地便利了消费者的日常生活，也为餐饮......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99