Golang协程中channel和sync的角色扮演分析

目录

• Channel
• 代码示例
• Sync
• 代码示例
• 实际应用
• 问题代码
• 问题分析
• 解决方案
• Mutex（互斥锁）解决案例
• Channel 解决案例
• 结论
• Channel 的角色
• Sync 的角色

channel 是Go语言中用于协程（goroutine）之间通信的一种机制。通过channel，你可以在不同的goroutine之间安全地传递数据。

package main
import (
	"fmt"
	"strconv"
	"time"
)
func main() {
	fmt.Println("主进程开始")
	done := make(chan bool, 5)
	for i := 0; i < 5; i++ {
		fmt.Println("等待进协程:" + strconv.Itoa(i))
		go worker(i, done)
	}
	for i := 0; i < 5; i++ {
		fmt.Println("等待出协程:" + strconv.Itoa(i))
		<-done
		fmt.Println("已经出协程:" + strconv.Itoa(i))
	}
	close(done)
	fmt.Println("主进程结束")
}
func worker(i int, done chan bool) {
	time.Sleep(2 * time.Second)
	fmt.Println("协程:" + strconv.Itoa(i))
	done <- true
}

Golang缓冲channel和非缓冲channel的区别说明

sync 包提供了基本的同步原语，用于在多个goroutine之间协调对共享资源的访问。

package main
import (
    "fmt"
    "strconv"
    "sync"
    "time"
)
func main() {
    fmt.Println("主进程开始")
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        fmt.Println("等待进协程:" + strconv.Itoa(i))
        wg.Add(1)
        go worker(i, &wg)
    }
    fmt.Println("主进程等待")
    wg.Wait()
    fmt.Println("主进程结束")
}
func worker(i int, wg *sync.WaitGroup) {
    defer wg.Done()
    time.Sleep(2 * time.Second)
    fmt.Println("协程:" + strconv.Itoa(i))
}

package main
import (
	"fmt"
	"sync"
)
// 定义结构体
type MyStruct struct {
	Field1 string
	Field2 int
}
func main() {
	var myStructs []MyStruct
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		fmt.Println(i)
		go worker(&myStructs, &wg, i)
	}
	wg.Wait()
	fmt.Println(myStructs)
	fmt.Println(len(myStructs))
}
func worker(data *[]MyStruct, wg *sync.WaitGroup, i int) {
	defer wg.Done()
	ss := MyStruct{
		Field1: fmt.Sprintf("Data %d", i),
		Field2: i * 10,
	}
	*data = append(*data, ss)
}

多个 worker 协程并发地向共享切片 myStructs 添加元素时存在竞态风险。由于 Go 语言的切片并非并发安全，当多个协程同时调用 append 函数修改切片时，可能导致数据竞争或意外行为。

Golang语言中的互斥锁和读写锁（Mutex和RWMutex）

package main
import (
    "fmt"
    "sync"
)
// 定义结构体
type MyStruct struct {
    Field1 string
    Field2 int
}
func main() {
    var myStructs []MyStruct
    var mu sync.Mutex
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go worker(&myStructs, &wg, &mu, i)
    }
    wg.Wait()
    fmt.Println(myStructs)
    fmt.Println(len(myStructs))
}
func worker(data *[]MyStruct, wg *sync.WaitGroup, mu *sync.Mutex, i int) {
    defer wg.Done()
    ss := MyStruct{
        Field1: fmt.Sprintf("Data %d", i),
        Field2: i * 10,
    }
    mu.Lock()
    *data = append(*data, ss)
    mu.Unlock()
}

问题虽已解决，但Mutex在高并发场景下会导致大量锁等待，对系统性能造成显著影响。

package main
import (
	"fmt"
	"sync"
)
type MyStruct struct {
	Field1 string
	Field2 int
}
func main() {
	var wg sync.WaitGroup
	dataChan := make(chan MyStruct, 10)
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go worker(dataChan, &wg, i)
	}
	go func() {
		wg.Wait()
		close(dataChan)
	}()
	var myStructs []MyStruct
	for ss := range dataChan {
		myStructs = append(myStructs, ss)
	}
	fmt.Println(myStructs)
	fmt.Println(len(myStructs))
}
func worker(dataChan chan<- MyStruct, wg *sync.WaitGroup, i int) {
	defer wg.Done()
	ss := MyStruct{
		Field1: fmt.Sprintf("Data %d", i),
		Field2: i * 10,
	}
	dataChan <- ss
}

channel是Go语言中协程（goroutine）之间通信的桥梁，它有以下重要作用：

• 协程间通信：channel提供了一种在goroutine之间安全地传递数据的方式。通过使用channel，goroutine可以相互发送和接收数据，从而实现协作和协调。
• 同步与协调：channel的阻塞特性使得goroutine之间的同步变得简单而直观。当一个goroutine试图从一个没有数据的channel中接收数据时，它会阻塞直到有数据可用。同样，当一个goroutine试图向一个已经满的channel发送数据时，它也会被阻塞。这种阻塞机制使得goroutine能够按照预期的顺序进行通信和协作。
• 避免共享状态：通过使用channel进行通信，可以减少对共享状态的依赖，从而降低并发编程中的复杂性和错误率。每个goroutine可以拥有自己的局部变量和状态，并通过channel与其他goroutine进行交互，而无需直接访问共享内存。

sync包提供了一组同步原语，用于保护共享资源和协调goroutine的执行，确保并发程序的正确性和一致性。sync包中的关键组件包括：

• 互斥锁（Mutex）：sync.Mutex是一个互斥锁，用于保护共享资源，确保同一时间只有一个goroutine可以访问该资源。通过加锁和解锁操作，可以防止多个goroutine同时修改共享资源，从而避免竞态条件和数据不一致。
• 读写锁（RWMutex）：sync.RWMutex是互斥锁的一种扩展，允许多个goroutine同时读取共享资源，但在写入时阻塞所有其他goroutine（无论是读还是写）。这种读写分离的机制可以提高并发程序的性能，特别是在读多写少的场景中。
• 等待组（WaitGroup）：sync.WaitGroup提供了一种等待一组goroutine完成的方法。通过调用Add方法增加等待组的计数，并在每个goroutine结束时调用Done方法减少计数，主goroutine可以调用Wait方法阻塞，直到所有goroutine都完成执行。这有助于协调goroutine的执行顺序和依赖关系。
• 条件变量（Cond）：sync.Cond是一个条件变量，允许一个或多个goroutine等待某个条件为真，并在该条件变为真时通知它们。条件变量提供了一种更灵活的同步机制，适用于需要根据特定条件进行等待和通知的场景。

综上所述，channel和sync包在Go语言的并发编程中各自扮演着重要的角色。channel用于goroutine之间的通信和同步，而sync包提供了保护共享资源和协调goroutine执行的同步原语。它们共同确保了并发程序的正确性和高效性。

到此这篇关于Golang协程中channel和sync的角色扮演分析的文章就介绍到这了,更多相关go协程channel和sync内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

您可能感兴趣的文章:

• 浅析GO并发处理选择sync还是channel
• golang channel多协程通信常用方法底层原理全面解析
• GO利用channel协调协程的实现
• Golang利用channel协调协程的方法详解
• GO语言协程创建使用并通过channel解决资源竞争