上篇:Go并发编程

简介: 上篇:Go并发编程
  1. 基本使用
package main
import (
 "fmt"
 "sync"
)
var wg sync.WaitGroup
func hello() {
 fmt.Println("hello func...")
 wg.Done() // 通知计数器减1
}
func main() {
 wg.Add(4) // 计数器,4个并发任务
 go hello()
 go hello()
 go hello()
 go hello()
 fmt.Println("main func!")
 wg.Wait() // 等待所有任务执行完成
}
  1. 改造一下,开启10000个goroutine
package main
import (
 "fmt"
 "sync"
)
var wg sync.WaitGroup
func hello(i int) {
 fmt.Println("hello func...", i)
 wg.Done()
}
func main() {
 // wg.Add(10000)
 for i := 0; i < 10000; i++ {
  wg.Add(1)
  go hello(i)
 }
 fmt.Println("main func!")
 wg.Wait()
}
  1. 将上一个例子改造成匿名函数
package main
import (
 "fmt"
 "sync"
)
var wg sync.WaitGroup
func main() {
 // wg.Add(10000)
 for i := 0; i < 10000; i++ {
  go func(i int) {
   fmt.Println("hello...", i)
  }(i)
 }
 fmt.Println("main func!")
 wg.Wait()
}
  1. 指定占用CPU核心数
package main
import (
 "fmt"
 "runtime"
 "sync"
)
var wg sync.WaitGroup
func test1() {
 for i := 0; i < 10; i++ {
  fmt.Println("func test1...", i)
 }
}
func test2() {
 for i := 0; i < 10; i++ {
  fmt.Println("func test2...", i)
 }
}
func main() {
 runtime.GOMAXPROCS(1) // 只占用1个CPU核心
 wg.Add(2)
 go test1()
 go test2()
 wg.Wait()
}
  1. 带缓冲区的通道,类似于异步的操作
package main
import "fmt"
func main() {
 ch1 := make(chan int, 1) // 只能存放1个值的缓冲区通道
 ch1 <- 10  // 发送
 x := <-ch1 // 接收
 fmt.Println(x)
 close(ch1)
}
  1. 无缓冲区的通道,又称为同步通道
package main
import "fmt"
func main() {
 ch1 := make(chan int) // 无缓冲区通道,又称为同步通道,
 ch1 <- 10             // 此时这里会处于阻塞的状态,除非有另外一个goroutine去取值,它才会发送
 x := <-ch1
 fmt.Println(x)
 close(ch1)
}
  1. 获取通道的容量和通道里的元素数量
package main
import "fmt"
func main() {
 ch1 := make(chan int, 10)
 ch1 <- 89
 ch1 <- 70
 fmt.Println(len(ch1)) // 获取通道中元素的数量
 fmt.Println(cap(ch1)) // 获取通道的容量
 close(ch1)
}
  1. 通道和goroutine的小栗子
package main
import (
 "fmt"
 "sync"
)
type myinterface interface{}
var ch1 = make(chan myinterface, 1)
var wg sync.WaitGroup
func sendData(i myinterface) {
 fmt.Printf("向通道发送 %v 成功\n", i)
 ch1 <- i
 wg.Done()
}
func readData() {
 v := <-ch1
 fmt.Println("从通道获取的值:", v)
 wg.Done()
}
func main() {
 nameArray := []string{"ttr", "tantianran"}
 wg.Add(2)
 go sendData(nameArray)
 go readData()
 wg.Wait()
}
  1. 通道+goroutine,实现协同干活例子2
package main
import "fmt"
func producer(ch chan int) {
 for i := 0; i < 10; i++ {
  ch <- i
 }
 close(ch)
}
func consumer(ch1 chan int, ch2 chan int) {
 for {
  v, ok := <-ch1
  if !ok {
   break
  }
  ch2 <- v * 2
 }
 close(ch2)
}
func main() {
 ch1 := make(chan int, 100)
 ch2 := make(chan int, 200)
 go producer(ch1)
 go consumer(ch1, ch2)
 for i := range ch2 {
  fmt.Println(i)
 }
}
相关文章
|
3月前
|
Go 调度 开发者
Go语言中的并发编程:深入理解与实践###
探索Go语言在并发编程中的独特优势,揭秘其高效实现的底层机制。本文通过实例和分析,引导读者从基础到进阶,掌握Goroutines、Channels等核心概念,提升并发处理能力。 ###
|
1月前
|
并行计算 安全 Go
Go语言中的并发编程:掌握goroutines和channels####
本文深入探讨了Go语言中并发编程的核心概念——goroutine和channel。不同于传统的线程模型,Go通过轻量级的goroutine和通信机制channel,实现了高效的并发处理。我们将从基础概念开始,逐步深入到实际应用案例,揭示如何在Go语言中优雅地实现并发控制和数据同步。 ####
|
2月前
|
存储 Go 开发者
Go语言中的并发编程与通道(Channel)的深度探索
本文旨在深入探讨Go语言中并发编程的核心概念和实践,特别是通道(Channel)的使用。通过分析Goroutines和Channels的基本工作原理,我们将了解如何在Go语言中高效地实现并行任务处理。本文不仅介绍了基础语法和用法,还深入讨论了高级特性如缓冲通道、选择性接收以及超时控制等,旨在为读者提供一个全面的并发编程视角。
|
2月前
|
安全 Serverless Go
Go语言中的并发编程:深入理解与实践####
本文旨在为读者提供一个关于Go语言并发编程的全面指南。我们将从并发的基本概念讲起,逐步深入到Go语言特有的goroutine和channel机制,探讨它们如何简化多线程编程的复杂性。通过实例演示和代码分析,本文将揭示Go语言在处理并发任务时的优势,以及如何在实际项目中高效利用这些特性来提升性能和响应速度。无论你是Go语言的初学者还是有一定经验的开发者,本文都将为你提供有价值的见解和实用的技巧。 ####
|
2月前
|
Go 调度 开发者
Go语言中的并发编程:深入理解goroutines和channels####
本文旨在探讨Go语言中并发编程的核心概念——goroutines和channels。通过分析它们的工作原理、使用场景以及最佳实践,帮助开发者更好地理解和运用这两种强大的工具来构建高效、可扩展的应用程序。文章还将涵盖一些常见的陷阱和解决方案,以确保在实际应用中能够避免潜在的问题。 ####
|
2月前
|
安全 Go 数据处理
Go语言中的并发编程:掌握goroutine和channel的艺术####
本文深入探讨了Go语言在并发编程领域的核心概念——goroutine与channel。不同于传统的单线程执行模式,Go通过轻量级的goroutine实现了高效的并发处理,而channel作为goroutines之间通信的桥梁,确保了数据传递的安全性与高效性。文章首先简述了goroutine的基本特性及其创建方法,随后详细解析了channel的类型、操作以及它们如何协同工作以构建健壮的并发应用。此外,还介绍了select语句在多路复用中的应用,以及如何利用WaitGroup等待一组goroutine完成。最后,通过一个实际案例展示了如何在Go中设计并实现一个简单的并发程序,旨在帮助读者理解并掌
|
2月前
|
安全 Java Go
Go语言中的并发编程:掌握goroutine与通道的艺术####
本文深入探讨了Go语言中的核心特性——并发编程,通过实例解析goroutine和通道的高效使用技巧,旨在帮助开发者提升多线程程序的性能与可靠性。 ####
|
2月前
|
Go 开发者
Go语言中的并发编程:掌握goroutines和channels####
本文深入探讨了Go语言中并发编程的核心概念,重点介绍了goroutines和channels的工作原理及其在实际开发中的应用。文章通过实例演示如何有效地利用这些工具来编写高效、可维护的并发程序,旨在帮助读者理解并掌握Go语言在处理并发任务时的强大能力。 ####
|
2月前
|
算法 安全 程序员
Go语言的并发编程:深入理解与实践####
本文旨在探讨Go语言在并发编程方面的独特优势及其实现机制,通过实例解析关键概念如goroutine和channel,帮助开发者更高效地利用Go进行高性能软件开发。不同于传统的摘要概述,本文将以一个简短的故事开头,引出并发编程的重要性,随后详细阐述Go语言如何简化复杂并发任务的处理,最后通过实际案例展示其强大功能。 --- ###
|
2月前
|
存储 安全 Go
Go 语言以其高效的并发编程能力著称,主要依赖于 goroutines 和 channels 两大核心机制
Go 语言以其高效的并发编程能力著称,主要依赖于 goroutines 和 channels 两大核心机制。本文介绍了这两者的概念、用法及如何结合使用,实现任务的高效并发执行与数据的安全传递,强调了并发编程中的注意事项,旨在帮助开发者更好地掌握 Go 语言的并发编程技巧。
36 2

相关实验场景

更多