标签：bsp value 阻塞 动作 空间 tar from 操作 wro
语法结构：cap为容量
ch := make(chan type, cap)
信道是异步的，是一种在被创建时就被开辟了能存储一个或者多个值的信道。
这种类型并不要求发送与接收同时进行。只要缓冲区有未使用空间用于发送数据，或还包含可以接收的数据，那么其通信就会无阻塞地进行。只有在通道中没有要接收的值时，接收动作才会阻塞。
示例一
package main
import (
"fmt"
)
func main() {
//创建一个容量为3的缓冲信道
ch := make(chan string, 3)
ch <- "naveen"
ch <- "paul"
fmt.Println("capacity is", cap(ch)) //capacity is 3
fmt.Println("length is", len(ch)) //length is 2
fmt.Println("read value", <-ch) //read value naveen
fmt.Println("new length is", len(ch)) //new length is 1
}
示例二
package main
import (
"fmt"
"time"
)
func write(ch chan int) {
for i := 0; i < 5; i++ {
ch <- i
fmt.Println("successfully wrote", i, "to ch")
}
close(ch)
}
func main() {
ch := make(chan int, 2)
go write(ch)
time.Sleep(2 * time.Second)
for v := range ch {
fmt.Println("read value", v,"from ch")
time.Sleep(2 * time.Second)
}
}
创建一个两个容量的信道。
write协程先向信道里写入两个数据，然后阻塞，并打印，主协程睡眠两秒。
两秒后，主协程从信道中读取一个数据，并睡眠两秒，此时write协程继续向信道里写入一个数据，然后阻塞，等待主协程两秒后读取数据。
package main
import (
"fmt"
)
func main() {
ch := make(chan string, 2)
ch <- "naveen"
ch <- "paul"
ch <- "steve"
fmt.Println(<-ch)
fmt.Println(<-ch)
}
当我们向信道写入数据时，超出了信道的容量，因此写入发生了阻塞。现在想要写操作能够进行下去，必须要有其它协程来读取这个信道的数据。
但在程序中，并没有并发协程来读取这个信道，因此这里会发生死锁（deadlock）。
假设我们有 3 个并发执行的 Go 协程（由Go 主协程生成）。Go 主协程需要等待这 3 个协程执行结束后，才会终止。这就可以用 WaitGroup 来实现。
package main
import (
"fmt"
"sync"
"time"
)
func process(i int, wg *sync.WaitGroup) {
fmt.Println("started Goroutine ", i)
time.Sleep(2 * time.Second)
fmt.Printf("Goroutine %d ended\n", i)
//Done方法减少WaitGroup计数器的值，应在线程的最后执行。
wg.Done()
}
/*
WaitGroup用于等待一组线程的结束。
父线程调用Add方法来设定应等待的线程的数量。
每个被等待的线程在结束时应调用Done方法。
同时，主线程里可以调用Wait方法阻塞至所有线程结束。
*/
func main() {
no := 3
var wg sync.WaitGroup
//并发协程
for i := 0; i < no; i++ {
/*
Add方法向内部计数加上delta，delta可以是负数；
如果内部计数器变为0，Wait方法阻塞等待的所有线程都会释放，
如果计数器小于0，方法panic。
*/
wg.Add(1)
go process(i, &wg)
}
//Wait方法阻塞直到WaitGroup计数器减为0。
wg.Wait()
fmt.Println("over")
}
标签：bsp value 阻塞 动作 空间 tar from 操作 wro
原文地址：https://www.cnblogs.com/-wenli/p/11824921.html
