GO_note3_并发

GO入门学习遇到的一些小贴士，给自己当note

学习资料：https://www.liwenzhou.com/posts/Go/go_menu/

并发

并发：同一时间段内执行多个任务（你在用微信和两个女朋友聊天）

并行：同一时刻执行多个任务（你和你朋友都在用微信和女朋友聊天）

goroutine

两个例子

1.basic

package main

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

var wg sync.WaitGroup

func hello() {
	fmt.Println("hello xiaoyuyu~")
	wg.Done() //计数牌-1
}

func main() { //开启一个主goroutine去执行main
	wg.Add(1) //计数牌+1

	go hello() //开启一个goroutine去执行hello()
	fmt.Println("hello main!")
	// time.Sleep(time.Second)

	wg.Wait() //阻塞，等所有小弟干完活才收工
}

---

2.闭包

package main

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

var wg sync.WaitGroup

func main() { //开启一个主goroutine去执行main
	for i := 0; i < 10000; i++ {
		wg.Add(1)        //计数牌+1
		go func(i int) { ////开启一个goroutine去执行
			fmt.Println("hello", i)
			wg.Done() //计数牌-1
		}(i)
	}

	fmt.Println("hello main!")
	// time.Sleep(time.Second)

	wg.Wait() //阻塞，等所有小弟干完活才收工
}

GOMAXPROCS

package main

import (
	"fmt"
	"runtime"
	"sync"
	// "time"
)

var wg sync.WaitGroup

func a(k int) {
	for i := 0; i < k; i++ {
		fmt.Println("hello a:", i)
	}
	wg.Done() //计数牌-1
}

func b(k int) {
	for i := 0; i < k; i++ {
		fmt.Println("hello b:", i)
	}
	wg.Done() //计数牌-1
}

func main() { //开启一个主goroutine去执行main
	runtime.GOMAXPROCS(6)
	wg.Add(2) //计数牌+2
	go a(100)
	go b(100)
	// time.Sleep(time.Second)

	wg.Wait() //阻塞，等所有小弟干完活才收工
}

channel

单纯地将函数并发执行是没有意义的。函数与函数间需要交换数据才能体现并发执行函数的意义

如果说goroutine是Go程序并发的执行体，channel就是它们之间的连接。channel是可以让一个goroutine发送特定值到另一个goroutine的通信机制。

Go 语言中的通道（channel）是一种特殊的类型。通道像一个传送带或者队列，总是遵循先入先出（First In First Out）的规则，保证收发数据的顺序。每一个通道都是一个具体类型的导管，也就是声明channel的时候需要为其指定元素类型。

1.basic

package main

import "fmt"

func main() {
	var ch1 chan int
	ch1 = make(chan int, 1)
	ch1 <- 10
	x := <-ch1
	fmt.Println(x)
	close(ch1)
}

2.channel + goroutine

package main

import (
	"fmt"
	"sync"
)

//单向通道，只能往里发送
func create(c1 chan<- int) {
	for i := 0; i < 100; i++ {
		c1 <- i
	}
	close(c1)
	wg.Done()
}

func double(c1 <-chan int, c2 chan<- int) {
	for {
		temp, ok := <-c1
		if !ok {
			break
		}
		c2 <- temp * temp
	}
	close(c2)
	wg.Done()
}

var wg sync.WaitGroup

func main() {
	c1 := make(chan int, 110)
	c2 := make(chan int, 110)

	wg.Add(2)
	go create(c1)
	go double(c1, c2)

	for ret := range c2 {
		fmt.Println(ret)
	}

	wg.Wait()
}

worker pool（goroutine池）

三个goroutine解决五个任务也可以的哦

控制goroutine的数量，防止goroutine泄漏和暴涨

package main

import (
	"fmt"
	"time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
	for j := range jobs {
		fmt.Printf("worker:%d start job:%d\n", id, j)
		time.Sleep(time.Second)
		fmt.Printf("worker:%d end job:%d\n", id, j)
		results <- j * 2
	}
}

func main() {
	jobs := make(chan int, 100)
	results := make(chan int, 100)
	// 开启3个goroutine   worker_pool
	for w := 1; w <= 3; w++ {
		go worker(w, jobs, results)
	}
	// 5个任务
	for j := 1; j <= 5; j++ {
		jobs <- j
	}
	close(jobs)
	// 输出结果
	var ret int
	for a := 1; a <= 5; a++ {
		ret = <-results
		fmt.Println(ret)
	}
}

select多路复用

好处就是可以处理多个channel，哪个channel的收发存在信息，就去处理，灵活多变

func main() {
	ch := make(chan int, 1)
	for i := 0; i < 10; i++ {
		select {
		case x := <-ch:
			fmt.Println(x)
		case ch <- i:
		}
	}
}

结果是随机的，因为执行的语句也是随机的

并发安全和锁

熟悉操作系统的同学懂得都懂

互斥锁

package main

import (
	"fmt"
	"sync"
)

var (
	x    int64
	wg   sync.WaitGroup
	lock sync.Mutex
)

func add() {
	for i := 0; i < 1000; i++ {
		lock.Lock()
		x++
		lock.Unlock()
	}
	wg.Done()
}

func main() {
	wg.Add(2)
	go add()
	go add()
	wg.Wait()
	fmt.Println(x)
}

读写互斥锁

其实没啥东西，不需要我们设计底层，直接调用方法就好了

直接放上学习资料里面的例子

var (
	x      int64
	wg     sync.WaitGroup
	lock   sync.Mutex
	rwlock sync.RWMutex
)

func write() {
	// lock.Lock()   // 加互斥锁
	rwlock.Lock() // 加写锁
	x = x + 1
	time.Sleep(10 * time.Millisecond) // 假设读操作耗时10毫秒
	rwlock.Unlock()                   // 解写锁
	// lock.Unlock()                     // 解互斥锁
	wg.Done()
}

func read() {
	// lock.Lock()                  // 加互斥锁
	rwlock.RLock()               // 加读锁
	time.Sleep(time.Millisecond) // 假设读操作耗时1毫秒
	rwlock.RUnlock()             // 解读锁
	// lock.Unlock()                // 解互斥锁
	wg.Done()
}

func main() {
	start := time.Now()
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go write()
	}

	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go read()
	}

	wg.Wait()
	end := time.Now()
	fmt.Println(end.Sub(start))
}

sync.Once

在编程的很多场景下我们需要确保某些操作在高并发的场景下只执行一次，例如只加载一次配置文件、只关闭一次通道等

sync.Map

Go语言中内置的map不是并发安全的，要加锁

1.可以自己加锁实现

2.也可以使用GO语言内置的功能sync.Map

sync.Map内置了诸如Store、Load、LoadOrStore、Delete、Range等操作方法

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup
var m2 = sync.Map{}

func main() {
	for i := 0; i < 20; i++ {
		wg.Add(1)
		go func(i int) {
			m2.Store(i, i+100)
			value, _ := m2.Load(i)
			fmt.Printf("key:%d value:%d\n", i, value)
			wg.Done()
		}(i)
	}
	wg.Wait()
}

本文作者： xiaoyuyu
本文链接： http://woaixiaoyuyu.github.io/2020/02/29/GO-note3-%E5%B9%B6%E5%8F%91/
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！

赏

谢谢你请我吃糖果