【go语言学习笔记】02 Go语言高效并发

**Go语言学习笔记**

**02 Go语言高效并发**

在软件开发中，高效并发是实现高性能、提高系统吞吐率的关键。Go语言提供了强大的并发支持，使得开发者能够轻松地编写高性能的程序。在本节，我们将介绍Go语言中的并发机制和实践。

###1. GoroutineGoroutine 是 Go 中最基本的并发单位，它是轻量级线程，创建 goroutine 的成本比创建线程低得多。goroutine 使用 `go` 关键字来启动。

gopackage mainimport (
"fmt"
"time"
)

func say(s string) {
	for i :=0; i < 5; i++ {
	time.Sleep(100 * time.Millisecond)
	fmt.Println(s)
}
}

func main() {
	go say("world")
	say("hello")
}

在上面的例子中，我们启动了两个 goroutine，一个执行 `say` 函数，另一个也执行 `say` 函数。由于 Goroutine 的创建成本低，所以我们可以轻松地创建多个 Goroutine。

###2. ChannelChannel 是 Go 中用于 goroutine 之间通信的机制。它类似于管道，可以将值传递给其他 goroutine。

gopackage mainimport (
"fmt"
)

func producer(ch chan int) {
	for i :=0; i < 5; i++ {
	ch <- i}
	close(ch)
}

func consumer(ch chan int) {
	for v := range ch {
	fmt.Println(v)
}
}

func main() {
	ch := make(chan int)
	go producer(ch)
	consumer(ch)
}

在上面的例子中，我们创建了一个 channel，使用 `producer` goroutine 将值传递给 channel，使用 `consumer` goroutine 从 channel 中读取值。

###3. WaitGroupWaitGroup 是 Go 中用于等待多个 goroutine 完成的机制。它可以让我们轻松地等待多个 goroutine 的完成。

gopackage mainimport (
"fmt"
"sync"
)

func worker(wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("Worker started")
	time.Sleep(2 * time.Second)
	fmt.Println("Worker finished")
}

func main() {
	var wg sync.WaitGroup	for i :=0; i < 5; i++ {
	wg.Add(1)
	go worker(&wg)
}
	wg.Wait()
	fmt.Println("All workers finished")
}

在上面的例子中，我们使用 WaitGroup 等待多个 goroutine 的完成。

###4. MutexMutex 是 Go 中用于保护共享资源的机制。它可以让我们轻松地保护共享资源。

gopackage mainimport (
"fmt"
"sync"
)

var x intfunc worker(wg *sync.WaitGroup, mu *sync.Mutex) {
	defer wg.Done()
	mu.Lock()
	x++
	mu.Unlock()
}

func main() {
	var wg sync.WaitGroup	for i :=0; i < 5; i++ {
	wg.Add(1)
	go worker(&wg, &x)
}
	wg.Wait()
	fmt.Println(x)
}

在上面的例子中，我们使用 Mutex 保护共享资源。

###5. RWMutexRWMutex 是 Go 中用于保护共享资源的机制。它类似于 Mutex，但提供了更高效的读取操作。

gopackage mainimport (
"fmt"
"sync"
)

var x intfunc worker(wg *sync.WaitGroup, mu *sync.RWMutex) {
	defer wg.Done()
	mu.RLock()
	x++
	mu.RUnlock()
}

func main() {
	var wg sync.WaitGroup	for i :=0; i < 5; i++ {
	wg.Add(1)
	go worker(&wg, &x)
}
	wg.Wait()
	fmt.Println(x)
}

在上面的例子中，我们使用 RWMutex 保护共享资源。

###6. OnceOnce 是 Go 中用于执行一次操作的机制。它可以让我们轻松地执行一次操作。

gopackage mainimport (
"fmt"
)

func doSomething() {
	fmt.Println("Doing something")
}

func main() {
	var once sync.Onceonce.Do(doSomething)
	doSomething()
}

在上面的例子中，我们使用 Once 执行一次操作。

###7. CondCond 是 Go 中用于等待条件的机制。它可以让我们轻松地等待条件。

gopackage mainimport (
"fmt"
"sync"
)

func worker(wg *sync.WaitGroup, cond *sync.Cond) {
	defer wg.Done()
cond.L.Lock()
	for !cond.Wait() {
}
	fmt.Println("Condition met")
cond.L.Unlock()
}

func main() {
	var wg sync.WaitGroup	var cond sync.Cond{}
	for i :=0; i < 5; i++ {
	wg.Add(1)
	go worker(&wg, &cond)
}
	time.Sleep(2 * time.Second)
	fmt.Println("Condition met")
}

在上面的例子中，我们使用 Cond 等待条件。

### 总结Go语言提供了强大的并发支持，使得开发者能够轻松地编写高性能的程序。在本节，我们介绍了Go语言中的并发机制和实践，包括Goroutine、Channel、WaitGroup、Mutex、RWMutex、Once和Cond。这些机制可以让我们轻松地保护共享资源、等待条件、执行一次操作等。