14_GoLang语言入门_基础语法_并发与多线程03_channel通道、生产者和消费者、select语句、超时处理

字数统计: 3.2k字   |   阅读时长≈ 14分

并发程序之间的数据传递：

其他语言：

通过共享内存实现消息传递。

go语言：

通过数据传递来实现共享内存。

队列结构：

队列queue：

是一种数据结构—-FIFO（先进先出）

数据结构：数据存储的特点。

数组、切片————线性结构。

栈stack—LIFO（后进先出）

channel:

01、通道概念：

专门的goroutines通信的管道。类似于管道中的水从一端到另一端的流动，数据可以从一端发送到另一端，通过通道接收。

02、通道目的：

实现多个goroutine之间实现数据传递。

03、通道的本质：

通道是一种容器，通道是一种数据结构—队列结构

容器，相当于”消息队列”。

04、通道的语法：

make()创建,也是引用类型的数据。

需要关联一种相关的数据类型。

05、通道的操作：

一个goroutine可以从chan中读取数据，另一个goroutine可以从中写入数据。

不能一个goroutine又读又写，会产生阻塞。

从chan中读取数据：

<- 特殊操作符

从chan中读取数据，data := <-chan 从chan中读取数据

向chan中写入数据，chan<-data 将data的数据写入chan

nil chan,同map一样不能使用，需要make()创建

06、通道阻塞：

对于chan的读取和写入操作，都是阻塞式的。

阻塞式：导致程序暂时不能执行！ 直到解除阻塞！！

* 从chan中读取数据：阻塞式，直到另一个goroutine向通道中写入数据，才能解除阻塞。
* 向chan中写入数据：阻塞式，直到另一个goroutine向通道中读取出数据，才能解除阻塞。

07、通道安全：

通道本身是安全的。同一时间，只能允许一个goroutine来读或写。

01、通道声明：简单实用通道

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("---------------------------------1.通道channel的声明----------------------------------------------")
	{
		var ch1 chan int
		fmt.Println(ch1)  //nil
		fmt.Printf("ch1的数据类型是：%T\n",ch1)

		ch1=make(chan int,0)
		fmt.Println(ch1) //0xc00008c060  引用类型}
	}
	//g1,g2-->chan写入数据，main-->从通道中读取数据
	fmt.Println("---------------------------------2.通道channel的使用----------------------------------------------")
	{
		ch2 := make(chan int, 0)
		ch3 := make(chan bool)
		go func() { //匿名函数，可以不需要做形参传递，直接调用变量
			fmt.Println("这是一个子goroutine")
			data := <-ch2 //现将ch2数据写出，再将新数据写入到ch2中
			time.Sleep(5 * time.Second)
			fmt.Println("从main传来的数据是：", data)
			ch3 <- true
		}()
		ch2 <- 100 //向通道ch2中写入数据            //仅有写入数据会报错。阻塞式，deadlock死锁
		//goroutine阻塞式，不能自救
		<-ch3  //如果ch3可以往外写数据，说明ch3已经先读取到了数据，也就说明子线程 go匿名函数已经执行完成了！
		fmt.Println("main...over...")
	}
}

02、通道阻塞：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
	"fmt"
	"time"
)
func main() {
	ch1 := make(chan string)
	go func() {
		fmt.Println("子goroutine执行！！！")
		time.Sleep(5 * time.Second)
		ch1 <- "ljk"
	}()
	time.Sleep(2 * time.Second)
	data := <-ch1 
	fmt.Println("main读取到的数据是：", data) //主程序需要"5s"后读到数据。  2s时间内，两个goroutine同时进行，还需要3s才能继续。
}

03、通道关闭：

读取通道：data:=<-chan

data,ok:=<-chan

ok为true,表示通道正常，读取到的data数据有效可用。

ok为false,表示通道关闭，读取到的data是类型的零值（默认值）。

与value,ok:=map[key]类似

通道关闭：

发送方如果数据写入完毕，可以关闭通道，用于通知接收方没有数据了，数据传输完毕。

一般只有发送方关闭。

g1—>写入数据

g2—>读取数据

发送方，不停的写入数据

循环发送，循环结束，发送停止写入

最后需要关闭通道，用于通知接收方没有数据了

接收方，不停的读取数据

死循环，读取数据，根据ok的值判断，是否已经结束。

1
2
3
4
5
6
7
8
9
10
11
//01、接收方----for循环接收数据，需要判断关闭通道了，跳出死循环
for{
	data,ok:=<-chan
	if !ok{
		break
	}
}
//02、接收方---直到发送方关闭通道，不然一直在死循环之中。
for data :=range chan{      //直到发送方关闭通道为止，for range关闭
	data
}

** 03.1、通过data,ok:=<-chan中的ok来判断是否跳出死循环**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package main

import (
	"fmt"
	"time"
)

func main() {
	ch1 := make(chan int)
	//发送数据
	go sendData(ch1)
	//读取数据
	for {
		time.Sleep(time.Second) //1s的睡眠
		data, ok := <-ch1
		if !ok {
			fmt.Println("读取完毕，通道关闭了...", data, ok)
			break //break跳出for循环
		}
		fmt.Println("main中读取到的数据", data, ok)
	}
}
func sendData(ch chan int) {
	for i := 1; i <= 10; i++ {
		ch <- i
	}
	fmt.Println("发送方，写入数据完毕！！！")
	close(ch) //发送方关闭通道，通知接收方没有数据了。
}

** 03.2、通过for-range,发送方关闭通道，才能跳出死循环的方式读取数据。**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package main

import "fmt"

func main() {
	/*
			for range:
				数组，切片，map,string,chan
					数组/切片/string------>返回index,value
								map------>返回key,value
		                       chan------>返回value
	*/
	ch1 := make(chan string)
	go sendStrData(ch1)
	for v := range ch1 { //循环的停止条件是通道的关闭,显示的调用Close()才可以         //for循环的另一种写法
		fmt.Println("从通道中读取的数据为：", v)
	}
}
func sendStrData(ch chan string) {
	for i := 1; i <= 10; i++ {
		ch <- fmt.Sprint("数据为：", i)
	}
	fmt.Println("写入数据完毕！")
	close(ch)
}

04、缓冲通道

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
package main

import (
	"fmt"
	"time"
)

func main() {
	/*
		非缓冲通道：
			读，写都是即时阻塞。
			默认创建的通道。
		缓冲通道：
			自带一块缓冲区，可以暂时存储数据。
			设置缓冲区的大小。缓冲区存满后会阻塞。
		通道的本质是队列结构。FIFO
	*/
	fmt.Println("-------------------------------------1.非缓冲通道-----------------------------------------------")
	{
		ch1 := make(chan int)
		fmt.Println("非缓冲通道:", len(ch1), cap(ch1))
		go func() {
			//time.Sleep(3*time.Second)
			<-ch1
		}()
		ch1 <- 100 //即时阻塞
		fmt.Println("写完了！！！")
	}
	fmt.Println("-------------------------------------2.缓冲通道-------------------------------------------------")
	//02.缓冲通道：缓冲区满了才会阻塞
	{
		//	ch2 := make(chan int, 3)
		//	go func() {
		//		data := <-ch2
		//		fmt.Println("获取到的数据为：", data)
		//	}()
		//	//fmt.Println("缓冲通道：", len(ch2), cap(ch2))
		//	ch2 <- 1 //写入
		//	fmt.Println("缓冲通道：", len(ch2), cap(ch2))
		//	ch2 <- 2 //写入
		//	fmt.Println("缓冲通道：", len(ch2), cap(ch2))
		//	ch2 <- 3 //写入
		//	fmt.Println("缓冲通道：", len(ch2), cap(ch2))
		//	ch2 <- 4 //写入
		//	fmt.Println("缓冲通道：", len(ch2), cap(ch2))
		//	fmt.Println("main...over...")
	}
	fmt.Println("-------------------------------------3.带缓冲区的通道--------------------------------------------")
	{
		ch3 := make(chan string, 5)
		go sendStrData02(ch3)
		//for v:=range ch3{
		//	fmt.Println("获取到的通道数据为：",v)
		//}
		for {
			time.Sleep(time.Second)
			data, ok := <-ch3

			if !ok {
				fmt.Println("---------------------------------------据读取完毕！退出！")
				break
			}
			fmt.Println("\t获取到通道3的数据为：", data)
		}
	}
}
func sendStrData02(ch chan string) {
	for i := 1; i <= 30; i++ {
		ch <- fmt.Sprint("数据为：", i)
		fmt.Println("---已完成写出的数据为：", i)
	}
	close(ch)
}

05、生产者和消费者：

生产者/消费者模型： ——线程之间的通信

生产者：生产产品

消费者：消费产品

比如：

母鸡：生产者 ——-线程t1 生产 notify()唤醒和notifyAll()唤醒所有

产品：鸡蛋

吃货：消费者 ——-线程t2 需要使用wait()进行阻塞，取数据 wait()等待;一般不用sleep()

notify()唤醒母鸡

商店：存储一定容量的鸡蛋 ——–容器 通道， 队列

一个生产者，两个消费者。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	ch1 := make(chan int, 5)
	ch2 := make(chan bool) //判断结束
	rand.Seed(time.Now().UnixNano())
	//写入数据:生产者
	go func() {
		for i := 1; i <= 30; i++ {
			ch1 <- i
			fmt.Println("生产者 写入的数据是：", i)
		}
		close(ch1)
	}()
	//读取数据:消费者1
	go func() {
		for data := range ch1 {
			fmt.Println("\t消费者1 读取到的数据为：", data)
			//time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
		}
		ch2 <- true
	}()
	//读取数据：消费者2
	go func() {
		for data := range ch1 {
			fmt.Println("\t消费者2 读取到的数据为：", data)
			//time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
		}
		ch2 <- true
	}()
	<-ch2
	<-ch2
	fmt.Println("main...over...")
}

06、定向通道：

通道：

默认是双向通道。

可读可写

能存能取。

make(chan Type)

定向通道：

也叫单向通道，只读或只写

只读

make(<-chan Type)

只能读取数据

只写

** make(chan<- Type)**

只能写入数据

创建通道时，采用单向通道，没有意义！

传递参数的时候使用：

函数，只有写入数据。

函数，只有读取数据。

语法级别保证通道的操作安全。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package main

import (
	"fmt"
	"time"
)

func main() {
	var ch1 = make(chan string)
	fmt.Println("---------------------------------------01.双向通道------------------------------------------------")
	{
		//go func(ch chan string) {
		//	ch <- "我是小明！"
		//	//time.Sleep(2*time.Second)
		//	str := <-ch
		//	fmt.Println("读取到的数据是：", str)
		//}(ch1)
		//
		////time.Sleep(2*time.Second)
		//data := <-ch1
		//fmt.Println("获取到的数据是：", data)
		////time.Sleep(2*time.Second)
		//ch1 <- "你要上学吗？"
		//time.Sleep(2 * time.Second)
		//fmt.Println("main...over...")
	}
	fmt.Println("---------------------------------------02.定向通道------------------------------------------------")
	{
		//只写的，定向通道
		go func(ch chan<- string) {
			ch <- "我是小明！"
		}(ch1)
		data := <-ch1
		fmt.Println("\t只写通道完成！------", data)
		fmt.Println("main...over...")
		fmt.Println("-------------------------------------------------------------------------------------------")
		time.Sleep(2 * time.Second)
		//只读的，定向通道
		ch2 := make(chan string)
		go func(ch <-chan string) {
			data1 := <-ch
			fmt.Println("\t只读通道完成！------", data1)
		}(ch2)
		ch2 <- "你要上学吗?" //通道顺序需要"先出后进"
		time.Sleep(time.Second)
		fmt.Println("main...over...")
		fmt.Println("-------------------------------------------------------------------------------------------")
	}
}

07、计时器： time包对chan的操作

** 1.Timer(): 计时器**

  • **timer1 := time.NewTimer( duration ) // ***time.Timer 类型
    • *Timer对象 中的属性C为： <-chan time.Time

** 2.After(duration**)

  • 返回值为 <-chan time.Time 同属性C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main
import (
	"fmt"
	"time"
)
func main() {
	//1.创建一个计时器
	timer1 := time.NewTimer(3 * time.Second) //3s之后
	fmt.Printf("%T\n", timer1)               //*time.Timer
	chan1 := timer1.C
	fmt.Printf("%T\n", chan1) //<-chan time.Time
	fmt.Println(time.Now())
	time1 := <-chan1
	fmt.Println(time1) //3s后渠道了时间
	//2.使用After(),返回值 ,获取只读通道类型的值
	ch2 := time.After(5 * time.Second)
	fmt.Println(time.Now())
	data := <-ch2
	fmt.Println(data)
}

08、select语句：

select语句类似于switch语句，但是select会随机执行一个可运行的case。

如果没有case可以运行，它将阻塞，直到有case可运行。

select是一种分支语句，专门用于通道读写操作的。

select{

case chan读/写：

分支1

case chan读/写：

分支2

case chan读/写：

分支3

…

default:

}

执行流程：

1.每个case后的通道都会被执行，如果多个都可以执行，那么select会随机执行一个可运行的case。

2.如果没有case可以运行，如果有default执行default。

如果没有default它将阻塞，直到有case可运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package main

import (
	"fmt"
	"time"
)

func main() {
	/*
		
	*/
	fmt.Println("-------------------------------------1.select分支语句---------------------------------------------")
	ch1 := make(chan int)
	ch2 := make(chan int)
	go func() {
		ch1 <- 100
		time.Sleep(2 * time.Second)
	}()
	go func() {
		time.Sleep(2 * time.Second)
		ch2 <- 200
	}()
	select {
	case data := <-ch1:
		fmt.Println("ch1中读取数据了！", data)
	case data := <-ch2:
		fmt.Println("ch2中读取数据了！", data)
	default:
		fmt.Println("目前一直都没有数据！！！！") //default直接执行，不等待了！
	}
}

09、 select+time 超时操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("--------------------------01.select+timer-------------------------------")
	{
		//ch1 := make(chan int)
		//ch2 := make(chan int)
		//go func() {
		//	time.Sleep(2*time.Second)
		//	<-ch1
		//}()
		//go func() {
		//	time.Sleep(3*time.Second)
		//	<-ch2
		//}()
		//select {
		//	case ch1 <- 100:
		//		fmt.Println("ch1写入数据")
		//	case ch2 <- 200:
		//		fmt.Println("ch2写入数据")
		//	case <-time.After(2*time.Second):
		//		fmt.Println("超时a...")
		//	case <-time.NewTimer(1*time.Second).C:
		//	fmt.Println("超时b...")
		//	//default:
		//	//	fmt.Println("还没来得及写入数据，就已经完成！")
		//}
		//time.Sleep(2*time.Second)
		//fmt.Println("main...over...")}
	}
	fmt.Println("--------------------------02.for+select+timer----------------------------")
	{
		ch1 := make(chan int)
		ch2 := make(chan int)
		go func() {
			time.Sleep(1 * time.Second)
			ch1 <- 100
			//close(ch1)
		}()
		//go func() {
		//	time.Sleep(1*time.Second)
		//	ch2<-200
		//}()

		//结束循环的条件：通道结束，或者超时5次以上 结束循环
		count := 0
	out:
		for {
			select {
			case data, ok := <-ch1: //1s后，通道堵塞了，没有数据了
				if !ok {
					fmt.Println("ch1的通道关闭了！！！")
					break out
				}
				fmt.Println("ch1读取到到数据为:", data, ok)
			case data := <-ch2: //
				fmt.Println("ch1读取到到数据为:", data)
			case <-time.After(2 * time.Second):
				fmt.Println("超时2s了...")
				count++
				if count > 5 {
					break out
				}
				//default:
				//	fmt.Println("数据还未来得及写入.....")
			}
		}
	}
}

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
三维数字孪生、虚拟仿真
三维平台数据展示、VR沉浸式开发、党建360/720全景开发

联系QQ:2583493258

很惭愧

只做了一点微小的工作
谢谢大家