go并发学习笔记

包含了go学习笔记,含有channel的基础学习，编写数字的平方，如何成组的合并channel，如何优雅的关闭退出并发协程，通道阻塞情况分析，channel与哪些变成情况，可谓是收藏好文.

并发1：channel的基础学习

func main() {
	ch := make(chan int, 2)
	ch <- 1
	ch <- 2
	elem, ok := <-ch
	if ok != true {
		fmt.Println("channel closed")
	}
	fmt.Println(elem)
}

一个从channel里读，一个从channel里写

func main() {
	syncChan1 := make(chan struct{}, 1)
	syncChan2 := make(chan struct{}, 2)
	go func() {
		<-syncChan1
		fmt.Println("receive a sync signal and wait a second...[receiver]")
		time.Sleep(time.Second)
		for {
			if elem, ok := <-strChan; ok {
				fmt.Println("Received:", elem, "[receiver]")
			} else {
				break
			}
		}
		fmt.Println("stopped [receiver]")
		syncChan2 <- struct{}{}
	}()
	go func() {
		for _, elem := range []string{"a", "b", "c", "d"} {
			strChan <- elem
			fmt.Println("sent:", elem, "[sender]")
			if elem == "c" {
				syncChan1 <- struct{}{} //唤醒接收的go携程，
				fmt.Println("sent a sync signal:", elem, "[sender]")
			}
		}
		fmt.Println("ait 2 seconds...[sender]")
		time.Sleep(time.Second * 2)
		close(strChan)
		syncChan2 <- struct{}{}
	}()
	<-syncChan2
	<-syncChan2
}

赋值写入

type Counter struct {
	count int
}

var mapChan2 = make(chan map[string]*Counter, 1)

func (counter *Counter) String() string {
	return fmt.Sprintf("counter:%d", counter.count)
}
func main() {
	syncChan := make(chan struct{}, 2)
	go func() {
		for {
			if elem, ok := <-mapChan2; ok {
				counter := elem["count"]
				counter.count++
			} else {
				break
			}
		}
		fmt.Println("stopped [receiver]")
		syncChan <- struct{}{}
	}()
	go func() {
		countMap := map[string]*Counter{
			"count": &Counter{},
		}
		for i := 0; i < 5; i++ {
			mapChan2 <- countMap
			time.Sleep(time.Millisecond)
			fmt.Printf("The count map::%v [sender]\n", countMap)
		}
		close(mapChan2)
		syncChan <- struct{}{}
	}()
	<-syncChan
	<-syncChan
}

用struct进行通信

func main() {
	dataChan := make(chan int, 5)
	syncChan1 := make(chan struct{}, 1)
	syncChan2 := make(chan struct{}, 2)
	go func() {
		<-syncChan1
		for {
			if elem, ok := <-dataChan; ok {
				fmt.Printf("Received:%d [receiver]\n]", elem)
			} else {
				break
			}
		}
		fmt.Println("Done [receiver]")
		syncChan2 <- struct{}{}
	}()
	go func() {
		for i := 0; i < 5; i++ {
			dataChan <- i
			fmt.Printf("Sent:%d [sender]\n", i)
		}
		close(dataChan)
		syncChan1 <- struct{}{}
		syncChan2 <- struct{}{}
	}()
	<-syncChan2
	<-syncChan2
}

用select case进行读取

func main() {
	chanCap := 5
	intChan := make(chan int, chanCap)
	for i := 0; i < chanCap; i++ {
		select {
		case intChan <- 1:
		case intChan <- 2:
		case intChan <- 3:
		}
	}
	for i := 0; i < chanCap; i++ {
		fmt.Println(<-intChan)
	}
}

并发2：编写数字的平方

func producer(nums ...int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for _, n := range nums {
			out <- n
		}
	}()
	return out
}

func square(inCh <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for n := range inCh {
			out <- n * n
		}
	}()
	return out

}

func main() {
	in := producer(1, 2, 3, 4, 5, 6)
	out := square(in)
	for ret := range out {
		fmt.Println(ret)
	}
	fmt.Println("done")
}

并发3：组装式编写数字的平方

func producer(nums ...int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for _, n := range nums {
			out <- n
		}
	}()
	return out
}

func square(inCh <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for n := range inCh {
			out <- n * n
		}
	}()
	return out

}

func merge(cs ...<-chan int) <-chan int {
	out := make(chan int)
	var wg sync.WaitGroup
	collect := func(in <-chan int) {
		defer wg.Done()
		for n := range in {
			out <- n
		}
	}
	wg.Add(len(cs))
	for _, c := range cs {
		go collect(c)
	}
	go func() {
		wg.Wait()
		close(out)
	}()
	return out

}
func main() {
	in := producer(1, 2, 3, 4, 5, 6)
	c1 := square(in)
	c2 := square(in)
	c3 := square(in)
	for ret := range merge(c1, c2, c3) {
		fmt.Printf("%3d ", ret)
	}

	fmt.Println("\ndone")
}

并发4：如何关闭退出并发协程

文章链接：退出

• 使用for-range退出
• 使用,ok退出
• 使用退出通道退出

并发5：通道阻塞情况

// 场景1
// 通道中无数据，但执行读通道

func ReadNoDataFromNoBufCh() {
	noBufCh := make(chan int)
	<-noBufCh //通道中没数据，你还读，必然阻塞
	fmt.Println("read from no buffer channel success")

}

//场景2
//通道中无数据，向通道中写数据，但无协程读取

func WriteNoBufCh() {
	ch := make(chan int)
	ch <- 1 //通道中无数据，向通道写数据，但无协程读取
	fmt.Println("write to no buffer channel success")
}

//场景3
//通道的缓存中无数据但执行读通道

func ReaNoDataFromBufCh() {
	noBufCh := make(chan int, 1)
	<-noBufCh //通道中没数据，你还读，必然阻塞
	fmt.Println("ReaNoDataFromBufCh")

}

//场景4
//通道缓存已经占满,向通道写数据,但无协程读

func WriteBufChButFull() {
	ch := make(chan int, 1)
	ch <- 1
	ch <- 2 //通道缓存已经占满,向通道写数据,但无协程读
	fmt.Println("WriteBufChButFull")
}

并发5：channel情况汇总