go的横空出世,让很多人眼前一亮,它的语法以简洁著称,并且它对多核并发的原生支持,让他在云计算和分布式领域展露头脚,它的核心围绕channel和goroutine展开。
首先golang channel 分为有缓冲与无缓冲两种类型,很多人认为无缓冲channel单单只是 默认缓冲为1缓冲的channel,其实它们最大的区别是阻塞问题。如下
c1:=make(chan int) 无缓冲
c2:=make(chan int,1) 有缓冲
c1<-1
在c1<- 1处,因为c1是无缓冲的,因此程序会阻塞在这里,不会往下执行,但是c2则不会,他在channel满之前是不会阻塞的,他会继续往下执行,但是如果你在c2第一个数据未取出之前继续塞第二个数据,就会阻塞在你放第二个数据处,因为她的缓冲区单位只有1.例:
dgucochann := make(chan int,2)
dgucochann <- 1
fmt.Println("Hello DGuco")
dgucochann <- 2
fmt.Println("Hello Yuki")
dgucochann <- 3
fmt.Println("Hello Go")
在这种情况下,程序在第6行处会阻塞,会打印前两句话Hello DGuco和Hello Yuki,因为该channel只有两个单位的缓冲,在第6行时没有另外一个goroutine去取出里面的数据,所以阻塞在这里。
1 信号量的传递
package main
import (
"fmt"
"time"
)
var mychan = make(chan int)
func dgucofunc1() {
fmt.Println("In dguco_func1")
mychan <- 1
}
func dgucofunc2() {
a := <-mychan
fmt.Println("In dguco_func1")
}
func main() {
go dgucofunc1()
go dgucofunc2()
time.Sleep(time.Millisecond * 10)
}
package main
import (
"fmt"
"time"
)
func dgucoproducer(c chan int, max int) {
for i := 0; i < max; i++ {
c <- i
}
//close(c)
}
func dgucoconsumer(c chan int) {
ok := true
value := 0
for ok {
fmt.Println("Wait receive")
if value, ok = <-c; ok {
fmt.Println(value)
}
if ok == false{
fmt.Println("*******Break********")
}
}
}
func main() {
c := make(chan int)
defer close(c)
go dgucoproducer(c, 10)
go dgucoconsumer(c)
time.Sleep(time.Second * 5)
fmt.Println("Done")
}
package main
import "time"
import "fmt"
var mychannel = make(chan bool)
func dgucotimertask() {
fmt.Println("My TimerTask..")
}
func dgucotimer() {
//返回一个定时器
mytimer := time.NewTicker(time.Millisecond * 1000)
select {
case <-mytimer.C:
go dgucotimertask()
}
}
func main() {
dgucotimer()
time.Sleep(time.Millisecond * 10)
}
}
package main
import "time"
import "fmt"
var mychannel = make(chan bool)
func dgucotimertask() {
fmt.Println("My TimerTask..")
}
func dgucotimer() {
timeout := time.NewTicker(time.Millisecond * 10000)
select {
case <-mychannel:
go dgucotimertask()
case <-timeout.C:
fmt.Println("Time out")
}
fmt.Println("Hello go")
}
func main() {
dgucotimer()
time.Sleep(time.Millisecond * 10)
}
package main
import "time"
import "fmt"
var mychannel = make(chan int)
func dgucoroutine() {
for i := 0; i < 10; i++ {
mychannel <- i
}
}
func dgucoroutine1() {
for {
i := <-mychannel
fmt.Println("dgucoroutine1:", i)
}
}
func dgucoroutine2() {
for {
i := <-mychannel
fmt.Println("dgucoroutine2:", i)
}
}
func main() {
go dgucoroutine()
go dgucoroutine1()
go dgucoroutine2()
// mychannel <- 4
time.Sleep(time.Millisecond * 100)
}