golang goroutine进行通讯 channel

1.channel的读取与声明

//goroutine之间利用channel进行通讯
package main

import (
	"fmt"
	"time"
)

func readChan (c chan int) {
	//读取通道中的内容
	a := <- c 
	fmt.Println(a)
}

func readChan2 (c chan int) {
	//读取通道中的内容
	a := <- c 
	fmt.Println(a)
}

func main () {
	var intChan chan int 
	intChan = make(chan int, 3)

	intChan <- 3
	intChan <- 2
	intChan <- 1

	//通道和队列同样，先进先出
	go readChan(intChan) //3

	go readChan2(intChan) //2

	time.Sleep(time.Second * 10)
}

　　channel 和队列是同样，先进先出的。

2. 带缓冲区的通道声明与通道阻塞

//通道阻塞
package main 

import (
	"fmt"
	"time"
)

func write (c chan int) {
	for i := 0; i < 100; i++ {
		c <- i
		fmt.Printf("put data %d\n", i)
	}
}

func read (c chan int) {
	for i := 0; i < 100; i++ {
		a := <- c
		fmt.Println(a)
		time.Sleep(time.Second)
	}
}

func main () {
	//带缓冲区的通道，这个缓冲区的大小为10
	chan01 := make(chan int, 10)

	//只写不读在通道达到长度10后，通道满了，会发送阻塞，不能在继续写入数据了
	go write(chan01)
	go read(chan01)

	time.Sleep(10 * time.Second)
}

　　输出结果为

　　

3. 关闭通道 close(channel)

　　

package main 

import (
	"fmt"
)

func main () {
	chan01 := make(chan int, 10)

	for i := 0; i < 10; i++ {
		chan01 <- i
	}

	//close 关闭通道
	close(chan01)

	//这么写会不停输出，由于读取10条后，chan01已经关闭
	// for {
	// 	b := <- chan01
	// 	fmt.Println(b)
	// }

	//1.使用ok来判断
	// for {
	// 	b, ok := <- chan01
	// 	if ok == false {
	// 		fmt.Println("chan is close")
	// 		break
	// 	}
	// 	fmt.Println(b) 
	// }

	//2使用for range 遍历
	for v := range chan01 {
		fmt.Println(v)
	}
}

　　关闭通道后，判断有两种方法1.参数ok来判断；2 for ...range  判断，通道关闭后会自动退出。

4. channel select 的应用

//channel select 操做
package main 

import (
	"fmt"
	"time"
)

func main () {
	chan01 := make(chan int, 10)
	chan02 := make(chan int, 10)

	for i := 0; i < 10; i++ {
		chan01 <- i
		chan02 <- i*i
	}

	for {
		select {
			case v := <- chan01:
				fmt.Println(v)
			case v := <- chan02:
				fmt.Println(v)		
			default:
				fmt.Println("time out")	
				time.Sleep(time.Second)
		}
	}

}