Go之go与channel组合使用

package main
import "fmt"
func main() {
	c := make(chan int, 3)
	c <- 15
	c <- 34
	c <- 65
	close(c)
	fmt.Printf("%d\n", <-c)   //channel被关闭后，照样可以从channel中取出数据，只是不能向其中写数据
	fmt.Printf("%d\n", <-c)
	fmt.Printf("%d\n", <-c)
	fmt.Printf("%d\n", <-c)   //当channel中数据全部被取出时，将输出0
	c <- 1
}

package main
import "fmt"
func generator(strings chan string) {
	strings <- "Five hour‘s New York jet lag"
	strings <- "and Cayce Pollard wakes in Camden Town"
	strings <- "to the dire and ever-decreasing circles"
	strings <- "of disrupted circadian rhythm."
	close(strings)
}
func main() {
	strings := make(chan string)
	go generator(strings)
	for s := range strings {
		fmt.Printf("%s\n", s)  //这里的s 相当于 <- strings，只有赋值之后才能读取到，否则一直阻塞
	} 
	fmt.Printf("\n")
}

package main
import "fmt"
func newUniqueIDService() <-chan string {
	id := make(chan string)
	go func() {
		var counter int64 = 0
		for {
			id <- fmt.Sprintf("%x", counter)   
			counter += 1
		}
	}()
	return id
}
func main() {
	id := newUniqueIDService()
	for i := 0; i < 10; i++ {
		fmt.Println(<-id)  //被阻塞，直到id被赋值
	}
}

	idle := make(chan []byte, 5) //用一个带缓冲的channel构造一个简单的队列
	select {
	case <-idle:
		//尝试从idle队列中读取
		fmt.Println("读取")
	default: //队列空，分配一个新的buffer
		fmt.Println("写入")
	}

package main
import (
	"fmt"
)
func main() {
	idle := make(chan []int, 10) //用一个带缓冲的channel构造一个简单的队列
	var b = []int{2, 1}
	select {
	case idle <- b: //尝试向队列中插入一个buffer
		fmt.Println(idle)
	default: //队列满？
		println("队列满")
	}
}

package main
func main() {
        var c chan int
        c <- 1
}

package main
import "fmt"
import "time"
func main() {
	var c1, c2 chan int = make(chan int), make(chan int)
	go func() {
		time.Sleep(time.Second * 5)
		c1 <- 5
		close(c1)
	}()
	go func() {
		time.Sleep(time.Second * 7)
		c2 <- 7
		close(c2)
	}()
	for {
		select {
		case x := <-c1: //在等待5s后,把值取出，如果close（c1）那么，将一直输出0
			fmt.Println(x)
		case x := <-c2: //在等待7s后，输出c2的值并退出
			fmt.Println(x)
			return
		}
	}
	fmt.Println("over")
}

package main
import "fmt"
import "time"
func main() {
	var c1, c2 chan int = make(chan int), make(chan int)
	go func() {
		time.Sleep(time.Second * 5)
		c1 <- 5
		close(c1)
	}()
	go func() {
		time.Sleep(time.Second * 7)
		c2 <- 7
		close(c2)
	}()
	for {
		select {
		case x, ok := <-c1: //如果c1未被关闭，则输出x，如果x关闭，c1=nil
			if !ok {
				c1 = nil
			} else {
				fmt.Println(x)
			}
		case x, ok := <-c2: //如果c2未被关闭，则输出x，如果x关闭，c2=nil
			if !ok {
				c2 = nil
			} else {
				fmt.Println(x)
			}
		}
		if c1 == nil && c2 == nil {
			break //如果=nil那么推出
		}
	}
	fmt.Println("over")
}

func worker(start chan bool) {
        heartbeat := time.Tick(30 * time.Second)
        for {
                select {
                     // … do some stuff
                case <- heartbeat:
                    //… do heartbeat stuff
                }
        }
}