Golang之旅23-通道channel

var 变量名 chan 元素类型

// demo
var ch1 chan int
var ch2 chan bool
var ch3 chan []int   // 切片类型

make (chan 元素类型, [缓冲大小])

ch4 := make(chan int)
ch5 := make(chan bool)

ch <- 10   // 将10发送到通道中

x := <- 10  // 从通道中取值，进行接收
<- 10

close(ch)  // 关闭

package main

import (
	"fmt"
)

/*
两个goroutine和两个channel
1. 生成0-100的数字发送到ch1
2. 从ch1中取出数求平方，结果发送到ch2中
*/

//生成0-100的数字发送到ch1
func f1(ch chan int){  // 函数的参数是通道类型
	for i:= 0; i<100;i++{
		ch <- i   // 将i传递给通道ch
	}
	close(ch)
}

// 2. 从ch1中取出数求平方，结果发送到ch2中
func f2(ch1 chan int, ch2 chan int){
	for {
		// 从通道取值方式1
		tmp, ok := <- ch1  // 取出ch1的值
		if !ok{
			break
		}
		ch2 <- tmp*tmp
	}
	close(ch2)
}

func main(){
	ch1 := make(chan int, 100)
	ch2 := make(chan int, 100)

	// 后台的goroutine
	go f1(ch1)
	go f2(ch1, ch2)

	// 从通道取值方式2
	for ret := range ch2{   // 主程序做的事情，取出ch2中的内容进行输出
		fmt.Println(ret)
	}
}

package main

import "fmt"

// 单向通道：多用于函数的参数中使用
func f1(ch chan <- int){  // 只能往ch中发送
	for i:= 0; i<100;i++{
		ch <- i
	}
	close(ch)
}

func f2(ch1 <-chan int, ch2 chan <- int){  // ch1只能取值，ch2只能发送
	for {

		// 从通道取值方式1
		tmp, ok := <- ch1
		if !ok{
			break
		}
		ch2 <- tmp*tmp
	}
	close(ch2)
}

func main(){
	ch1 := make(chan int, 100)
	ch2 := make(chan int, 100)

	go f1(ch1)
	go f2(ch1, ch2)

	// 从通道取值方式2
	for ret := range ch2{   // 主程序做的事情，取出ch2中的内容进行输出
		fmt.Println(ret)
	}
}

package main

import (
	"fmt"
	"time"
)

// worker pool 机制

func worker(id int, jobs<- chan int, results chan<- int){
	for job := range jobs{
		fmt.Printf("worker:%d start job:%d\n", id, job)
		results <- job*2
		time.Sleep(time.Millisecond * 500)
		fmt.Printf("worker: %d stop job :%d\n", id, job)
	}
}

func main(){
	jobs := make(chan int, 100)
	results := make(chan int, 100)

	// 开启3个goroutine
	for j:=0;j<3;j++{
		go worker(j, jobs, results)
	}

	// 发送5个任务
	for i:=0; i<5; i++{
		jobs <- i
	}
	close(jobs)

	// 输出结果
	for i := 0; i<5; i++{  // 显式地读取三次
		ret := <-results
		fmt.Println(ret)
	}
}

for {
    data, ok := <-ch1
    data, ok := <-ch2
}

// demo1
package  main

import "fmt"

func main()  {
	ch := make(chan int, 1)
	for i:=0;i<10;i++{
		select {  // 选择具有随机性
		case x := <-ch:  // 接收
			fmt.Println(x)
		case ch <- i:   // 取值
		default:
			fmt.Println("Do Nothing!")
		}
	}
}

// result
D:\go\src\code\select>select.exe
0
2
4
6
8

---------------
// demo2
package  main

import "fmt"

func main()  {
	ch := make(chan int, 10)  // 容量改成10
	for i:=0;i<10;i++{
		select {  // 选择具有随机性
		case x := <-ch:  // 接收
			fmt.Println(x)
		case ch <- i:   // 取值
		default:
			fmt.Println("Do Nothing!")
		}
	}
}

// result：每次结果不同
D:\go\src\code\select>select.exe
0
2

D:\go\src\code\select>select.exe
0
2
3
4

D:\go\src\code\select>select.exe
0
2
3

D:\go\src\code\select>select.exe
0
2
3
5
8

package main

import (
	"fmt"
	"time"
)

/*
1. 计算1-200每个数的阶乘
2. 启动多个协程，将结果放入map中
3. map设置成全局变量
*/

var (
	myMap = make(map[int]int, 10)
)

// 计算阶乘n! 将结果放入myMap
func test(n  int){

	res := 1
	for i:=1; i<=n; i++ {
		res *= i
	}

	myMap[n] = res   // concurrent map writes?
}

func main(){

	// 开启协程
	for i := 1; i <= 200; i++{
		go test(i)
	}

	// 休眠10秒钟
	time.Sleep(time.Second * 10)

	// 输出变量结果
	for i, v := range myMap{
		fmt.Printf("map[%d] = %d\n", i, v)
	}
}

package main

import (
	"fmt"
	"sync"
	"time"
)

/*
1. 计算1-200每个数的阶乘
2. 启动多个协程，将结果放入map中
3. map设置成全局变量
*/

var (
	myMap = make(map[int]int, 10)
	// lock 是一个全局互斥锁
	// sync：synchornized 同步
	// Mutex：互斥（排他锁），是一个结构体，包含lock和unlock两个方法
	lock sync.Mutex
)

// 计算阶乘n! 将结果放入myMap
func test(n  int){

	res := 1
	for i:=1; i<=n; i++ {
		res *= i
	}

	lock.Lock()  // 加锁
	myMap[n] = res   // concurrent map writes?
	lock.Unlock()  // 解锁
}

func main(){

	// 开启协程
	for i := 1; i <= 200; i++{
		go test(i)
	}

	// 休眠10秒钟：执行完所有的协程
	time.Sleep(time.Second * 10)

	// 输出变量结果
	// 这里加锁的原因：10秒所有的协程执行完毕；在实际的执行过程中for语句中可能出现资源竞争问题
	// 10 秒钟执行完所有协程，但是主线程并不知道，底层仍可能出现资源竞争问题，因此也需要加入互斥锁
	lock.Lock()
	for i, v := range myMap{
		fmt.Printf("map[%d] = %d\n", i, v)
	}
	lock.Unlock()
}