Golang_10_并发编程

func hello() {
	fmt.Println("Hello Goroutine!")
}

func main() {
	go hello()
	fmt.Println("Main Goroutine done!")
}

func main() {
	go hello() // 启动另一个goroutine去执行hello函数
	fmt.Println("Main Goroutine done!")
	time.Sleep(time.Second)
}

var wg sync.WaitGroup

func hello(i int) {
	defer wg.Done() // goroutine结束就登记-1
	fmt.Println("Hello Goroutine!", i)
}

func main() {
	for i := 0; i < 10; i++ {
		wg.Add(1) // 启动一个goroutine就登记+1
		go hello(i)
	}
	wg.Wait() // 等待所有登记的goroutine都结束
}

func a() {
    for i := 0; i < 10; i++ {
        fmt.Println("A:", i)
    }
}

func b() {
    for i := 0; i < 10; i++ {
        fmt.Println("B:", i)
    }
}

func main() {
    runtime.GOMAXPROCS(1)
    go a()
    go b()
    time.Sleep(timeSecond)
}
// 输出：
// A:0 ~ A:9
// B:0 ~ B:9
// 先做任务A再做任务B

func main() {
    runtime.GOMAXPROCS(2)
    go a()
    go b()
    time.Sleep(timeSecond)
}
// 输出：
// B:0 ~ B:4
// A:0 ~ A:8
// B:5 ~ B:9
// A:9
// A、B 交替进行

var 变量 chan 元素类型
var ch1 chan int   // 声明一个传递整型的通道
var ch2 chan bool  // 声明一个传递布尔值的通道
var ch3 chan []int // 声明一个传递int切片的通道

var ch chan int
fmt.Println(ch) // <nil>

make(chan 元素类型, [缓冲大小])
ch4 := make(chan int)
ch5 := make(chan bool)
ch6 := make(chan []int, 8)

ch := make(chan int) // 1. 定义一个通道
ch <- 10             // 2. 把10发送到ch中
x := <-ch            // 3. 从通道接受值，赋值给x
<-ch                 // 3'. 从通道接受值，忽略结果（丢弃）
fmt.Println(x)
close(ch) 			  // 4. 关闭通道
// 以上代码运行时会出错，下面“缓冲通道”会讲到

func main() {
	ch := make(chan int)
	ch <- 10
	fmt.Println("发送成功")
}

$ go build

$ ./basementStudy 
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
        /XXXX/basementStudy/main.go:7 +0x54

func recv(c chan int) {
	ret := <-c
	fmt.Println("接收成功", ret)
}

func main() {
	ch := make(chan int)
	go recv(ch) // 启动一个goroutine，从通道接收值，先阻塞，直到下面有goroutine发送
	ch <- 10
	fmt.Println("发送成功")
    // 输出：
    // 接收成功 10
	// 发送成功
}

func main() {
	ch := make(chan int, 1)
	ch <- 10
	fmt.Println("发送成功")
}

func main() {
	ch1 := make(chan int)
	ch2 := make(chan int)

	// 开启一个goroutine将1～100发到ch1中
	go func() {
		for i := 0; i < 100; i++ {
			ch1 <- i
		}
		close(ch1)
	}()

	// 开启一个goroutine从ch1中接受值，将值平方放到ch2
	go func() {
		// 循环，中间会有brerak（当ch1被close的时候）
		for {
			// 通道取值到i，通道关闭后再取值: ok=false
			i, ok := <-ch1
			if !ok {
				break
			}
			ch2 <- i * i
		}
		close(ch2)
	}()

	for i := range ch2 {
		fmt.Println(i)
	}
}

// chan<- 只能发送的单向通道
// 所以是 数字 发送到 out
func counter(out chan<- int) {
	for i := 0; i < 100; i++ {
		out <- i
	}
	close(out)
}

// <-chan 只能接收的单向通道
// 所以是 遍历"只能出的" 放入到 "只能进的"
func squarer(out <-chan int, in chan<- int) {
	for i := range out {
		in <- i * i
	}
	close(in)
}

func main() {
	ch1 := make(chan int)
	ch2 := make(chan int)

	go counter(ch1)
	go squarer(ch1, ch2)
	for i := range ch2 {
		fmt.Println(i)
	}
}

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

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

worker:3 start job:1
worker:1 start job:2
worker:2 start job:3
worker:2 end   job:3
worker:2 start job:4
worker:1 end   job:2
worker:3 end   job:1
worker:1 start job:5
worker:2 end   job:4
worker:1 end   job:5

for {
    // 尝试从ch1接收值
    data, ok := <-ch1
    // 尝试从ch2接收值
    data, ok := <-ch2
    ...
}

ch := make(chan int, 1)

for i := 0; i < 10; i++ {
    // 通道空，往里面放值
    // 通道不空，取值、打印
    select {
    case: x := <-ch:
        fmt.Println(x)
    case: ch<-i:
    }
}

var x int64
var wg sync.WaitGroup

func add() {
    for i := 0; i < 5000; i++ {
        x = x + 1
    }
    wg.Done()
}

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

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

func add() {
    for i := 0; i < 5000; i++ {
        lock.Lock() // 加锁
        x = x + 1
        lock.Unlock() // 解锁
    }
    wg.Done()
}

func main() {
    wg.Add(2)
    go add()
    go add()
    wg.Wait()
    fmt.Println(x)
}
// 稳定输出10000

var (
	x 		int64
    wg 		sync.WaitGroup
    lock	sync.Mutex		// 普通互斥锁
    rwlock	sync.RWMutex	// 读写互斥锁
)

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

func read() {
    lock.Lock() // 加普通互斥锁
    //rwlock.RLock() // 加读写互斥锁
    time.Sleep(10 * time.Millisecond) // 假设读操作耗时1毫秒
    //rwlock.RUnlock() // 解读写互斥锁
    lock.Unlock() // 解普通互斥锁
    wg.Done() // 计数器-1
}

func main() {
    // 用来和后面的 end 时间来计算耗时
    start := time.Now()
    
    // 开启10个写goroutine
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go write()
    }
    
    // 开启1000个读goroutine
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go read()
    }
    wg.Wait()
    
    // 计算耗时
    end := time.Now()
    fmt.Println(end.Sub(start))
}

var wg sync.WaitGroup

func hello(i int) {
	defer wg.Done() // goroutine结束就登记-1
	fmt.Println("Hello Goroutine!", i)
}

func main() {
	for i := 0; i < 10; i++ {
		wg.Add(1) // 启动一个goroutine就登记+1
		go hello(i)
	}
	wg.Wait() // 等待所有登记的goroutine都结束
}

var wg sync.WaitGroup

func hello() {
    defer wg.Done() // goroutine结束就登记-1
    fmt.Println("Hello Goroutine！")
}

func main() {
    wg.Add(1)
    go hello() // 启动另外一个goroutine去执行hello函数
    fmt.Println("main goroutine done!")
    wg.Wait()
}
// main goroutine done!
// Hello Goroutine！

// 或者下面写法，不另外创建函数
var wg sync.WaitGroup       // step1
func main(){
    wg.Add(1)				// step2
    go func(){
        defer wg.Done() // step3 每个任务内defer 
        fmt.Println("Hello goroutine！")
    }()
    wg.Wait() // step4 后面的语句阻塞，直到所有goroutine返回
    fmt.Println("The last statement to be executed")
}

func (o *Once) Do(f func()){}

var icons map[string]image.Image

func loadIcons() {
    icons = map[string]image.Image{
        "left":		loadIcon("left.png"),
        "up":		loadIcon("up.png"),
        "right":	loadIcon("right.png"),
        "down":		loadIcon("down.png"),
    }
}

// Icon 被多个goroutine调用时不是并发安全的
func Icon(name string) image.Image {
    if icons == nil {
        loadIcons()
    }
    return icons[name]
}

func loadIcons() {
    icons = make(map[string]image.Image)
    icons["left"] = loadIcon("left.png")
	icons["up"] = loadIcon("up.png")
	icons["right"] = loadIcon("right.png")
	icons["down"] = loadIcon("down.png")
}

package main

import (
	"image"
	"sync"
)

var icons map[string]image.Image

var loadIconsOnce sync.Once

func loadIcon(path string) (im image.Image) {
	return im
}

func loadIcons() {
	icons = map[string]image.Image{
		"left":  loadIcon("left.png"),
		"up":    loadIcon("up.png"),
		"right": loadIcon("right.png"),
		"down":  loadIcon("down.png"),
	}
}

// Icon 是并发安全的
func Icon(name string) image.Image {
	loadIconsOnce.Do(loadIcons)
	return icons[name]
}

package main

import (
	"fmt"
	"strconv"
	"sync"
)

var m = make(map[string]int)

func get(key string) int {
	return m[key]
}

func set(key string, value int) {
	m[key] = value
}

func main() {
	wg := sync.WaitGroup{}

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(n int) {
			key := strconv.Itoa(n)
			set(key, n)
			fmt.Printf("k=:%v,v:=%v\n", key, get(key))
			wg.Done()
		}(i)
	}
	wg.Wait()
}

var m = sync.Map{}

func main() {
	wg := sync.WaitGroup{}

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func(n int) {
			key := strconv.Itoa(n)
			m.Store(key, n)         // map添加一组键值
			value, _ := m.Load(key) // map根据key取value
			fmt.Printf("key=%v, value=%v\n", key, value)
			wg.Done()
		}(i)
	}
	wg.Wait()
}

var x int64
var l sync.Mutex
var wg sync.WaitGroup

// 普通版加函数
func add() {
	// x = x + 1
	x++ // 等价于上面的操作
	wg.Done()
}

// 互斥锁版加函数
func mutexAdd() {
	l.Lock()
	x++
	l.Unlock()
	wg.Done()
}

// 原子操作版加函数
func atomicAdd() {
	atomic.AddInt64(&x, 1)
	wg.Done()
}

func main() {
	start := time.Now()
	for i := 0; i < 10000; i++ {
		wg.Add(1)
		// go add()       // 普通版add函数 不是并发安全的
		// go mutexAdd()  // 加锁版add函数 是并发安全的，但是加锁性能开销大
		go atomicAdd() // 原子操作版add函数 是并发安全，性能优于加锁版
	}
	wg.Wait()
	end := time.Now()
	fmt.Println(x)
	fmt.Println(end.Sub(start))
}