• Golang使用Channel

    1.使用协程

    1. package main
    2.  
    3. //使用协程
    4. import (
    5. 	"fmt"
    6. 	"strconv"
    7. 	"time"
    8. )
    9.  
    10. func test() {
    11. 	for i := 1; i <= 10; i++ {
    12. 		fmt.Println("test() hello world" + strconv.Itoa(i))
    13. 		time.Sleep(time.Second)
    14. 	}
    15. }
    16.  
    17. // 主线程和test协程同时运行
    18. func main() {
    19. 	go test() //开启了一个协程
    20. 	for i := 1; i <= 10; i++ {
    21. 		//strconv.Itoa函数：将整型转换为字符串
    22. 		fmt.Println("main() hello Golang" + strconv.Itoa(i))
    23. 		time.Sleep(time.Second)
    24. 	}
    25. }
    1. main() hello Golang1
    2. test() hello world1
    3. main() hello Golang2
    4. test() hello world2
    5. test() hello world3
    6. main() hello Golang3
    7. main() hello Golang4
    8. test() hello world4
    9. test() hello world5
    10. main() hello Golang5
    11. main() hello Golang6
    12. test() hello world6
    13. test() hello world7
    14. main() hello Golang7
    15. main() hello Golang8
    16. test() hello world8
    17. test() hello world9
    18. main() hello Golang9
    19. main() hello Golang10
    20. test() hello world10

    2.使用20个协程计算1到20各个数的阶乘，把结果放到map中

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"sync"
    6. 	"time"
    7. )
    8.  
    9. //计算1-20的各个数的阶乘，并且把各个数的阶乘放入到map中
    10. //最后显示出来，要求使用goroutine完成
    11.  
    12. //思路：1.编写一个函数，计算各个数的阶乘，并放入到map中
    13. //2.我们启动的协程多个，统计的结果放入到map中
    14. //3.map应该做出一个全局变量
    15.  
    16. var (
    17. 	myMap = make(map[int]int, 20)
    18. 	//lock是一个全局的互斥锁
    19. 	//Mutex:互斥
    20. 	lock sync.Mutex
    21. )
    22.  
    23. func test(n int) {
    24. 	res := 1
    25. 	for i := 1; i <= n; i++ {
    26. 		res *= i
    27. 	}
    28. 	//把结果放入到map中
    29. 	//concurrent map writes
    30. 	//加锁
    31. 	lock.Lock()
    32. 	myMap[n] = res
    33. 	lock.Unlock()
    34. }
    35.  
    36. func main() {
    37.  
    38. 	//开启多个协程完成这个任务
    39. 	for i := 1; i <= 20; i++ {
    40. 		go test(i)
    41. 	}
    42.  
    43. 	//让主线程休眠，因为主线程执行完后，协程就会中止
    44. 	time.Sleep(time.Second * 5)
    45.  
    46. 	//输出结果，遍历这个结果
    47. 	//lock.Lock()
    48. 	for i, v := range myMap {
    49. 		fmt.Printf("map[%d]=%d\n", i, v)
    50. 	}
    51. 	//lock.Unlock()
    52. }
    1. map[3]=6
    2. map[7]=5040
    3. map[10]=3628800
    4. map[11]=39916800
    5. map[19]=121645100408832000 
    6. map[20]=2432902008176640000
    7. map[13]=6227020800
    8. map[9]=362880
    9. map[16]=20922789888000     
    10. map[4]=24
    11. map[5]=120
    12. map[6]=720
    13. map[8]=40320
    14. map[15]=1307674368000
    15. map[18]=6402373705728000
    16. map[17]=355687428096000
    17. map[14]=87178291200
    18. map[1]=1
    19. map[2]=2
    20. map[12]=479001600

    3.Channel的使用

    (1).Channel中只能存放指定的数据类型

    (2).Channel数据放满后，就不能放入了

    (3).如果从Channel中取出数据后，可以继续放入

    (4).在没有使用协程的情况下，如果Channel数据取完了，再取，就会报dead lock

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. /**
    6. Channel使用注意事项
    7. 1.Channel中只能存放指定的数据类型
    8. 2.Channel数据放满后，就不能放入了
    9. 3.如果从Channel中取出数据后，可以继续放入
    10. 4.在没有使用协程的情况下，如果Channel数据取完了，再取，就会报dead lock
    11. */
    12. //演示管道需求
    13. //channel相当于queue
    14.  
    15. func main() {
    16. 	//1.创建一个存放3个int类型的管道
    17. 	var intChan chan int
    18. 	//capacity=3
    19. 	intChan = make(chan int, 3)
    20.  
    21. 	//向管道写入数据
    22. 	intChan <- 10
    23. 	num := 211
    24. 	intChan <- num
    25.  
    26. 	//4.看看管道的长度和容量
    27. 	fmt.Printf("channel len=%v cap=%v \n", len(intChan), cap(intChan))
    28.  
    29. 	//5.从管道中读取数据
    30. 	var num2 int
    31. 	num2 = <-intChan
    32. 	fmt.Println("num2=", num2)
    33. 	fmt.Printf("channel len=%v cap=%v \n", len(intChan), cap(intChan))
    34. }
    1. channel len=2 cap=3
    2. num2= 10
    3. channel len=1 cap=3

    4.遍历管道

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 1.关闭管道，管道不能被写入数据，但是可以取出数据
    6. func test1() {
    7. 	intChan := make(chan int, 3)
    8. 	intChan <- 100
    9. 	intChan <- 200
    10. 	close(intChan)
    11. 	intChan <- 300
    12. 	fmt.Println("Hello")
    13.  
    14. }
    15.  
    16. // 遍历管道
    17. func test2() {
    18. 	intChan := make(chan int, 100)
    19. 	for i := 0; i < 100; i++ {
    20. 		intChan <- i * 2
    21. 	}
    22. 	//这个方法的前提是Channel要关闭，否则出现deadlock
    23. 	close(intChan)
    24. 	for v := range intChan {
    25. 		fmt.Println("v=", v)
    26. 	}
    27. }
    28.  
    29. func main() {
    30. 	test2()
    31. }

    5.goroutine和channel协同工作案例

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"time"
    6. )
    7.  
    8. /*
    9. *
    10. goroutine和channel协同工作案例
    11. 1.开启一个writeData协程，向管道intChan输入50个整数
    12. 2.开启一个readData协程，从管道intChan中读取writeData写入数据
    13. 3.writeData和readData操作的都是同一条管道
    14. 4.主线程需要等待writeData和readData协程都完成工作才退出
    15. */
    16. func writeData(intChan chan int) {
    17. 	for i := 1; i <= 50; i++ {
    18. 		intChan <- i
    19. 		time.Sleep(time.Second)
    20. 		fmt.Println("writeData=", i)
    21. 	}
    22. 	close(intChan)
    23. }
    24. func readData(intChan chan int, exitChan chan bool) {
    25. 	for {
    26. 		v, ok := <-intChan
    27. 		if !ok {
    28. 			break
    29. 		}
    30. 		time.Sleep(time.Second)
    31. 		fmt.Println("readData=", v)
    32. 	}
    33. 	//读完数据后
    34. 	exitChan <- true
    35. 	close(exitChan)
    36. }
    37. func main() {
    38. 	intChan := make(chan int, 50)
    39. 	exitChan := make(chan bool, 1)
    40. 	go writeData(intChan)
    41. 	go readData(intChan, exitChan)
    42.  
    43. 	//time.Sleep(time.Second * 10)
    44. 	for {
    45. 		_, ok := <-exitChan
    46. 		if ok {
    47. 			break
    48. 		}
    49. 	}
    50. }
    1. writeData= 1
    2. readData= 1
    3. readData= 2
    4. writeData= 2
    5. readData= 3
    6. writeData= 3
    7. readData= 4
    8. writeData= 4
    9. readData= 5
    10. writeData= 5
    11. readData= 6
    12. writeData= 6
    13. readData= 7
    14. writeData= 7
    15. readData= 8
    16. writeData= 8
    17. readData= 9
    18. writeData= 9
    19. readData= 10
    20. writeData= 10
    21. readData= 11
    22. writeData= 11
    23. readData= 12
    24. writeData= 12
    25. readData= 13
    26. writeData= 13
    27. readData= 14
    28. writeData= 14
    29. readData= 15
    30. writeData= 15
    31. readData= 16
    32. writeData= 16
    33. readData= 17
    34. writeData= 17
    35. readData= 18
    36. writeData= 18
    37. readData= 19
    38. writeData= 19
    39. readData= 20
    40. writeData= 20
    41. readData= 21
    42. writeData= 21
    43. readData= 22
    44. writeData= 22
    45. readData= 23
    46. writeData= 23
    47. readData= 24
    48. writeData= 24
    49. readData= 25
    50. writeData= 25
    51. readData= 26
    52. writeData= 26
    53. readData= 27
    54. writeData= 27
    55. readData= 28
    56. writeData= 28
    57. readData= 29
    58. writeData= 29
    59. readData= 30
    60. writeData= 30
    61. readData= 31
    62. writeData= 31
    63. readData= 32
    64. writeData= 32
    65. readData= 33
    66. writeData= 33
    67. readData= 34
    68. writeData= 34
    69. readData= 35
    70. writeData= 35
    71. readData= 36
    72. writeData= 36
    73. readData= 37
    74. writeData= 37
    75. readData= 38
    76. writeData= 38
    77. readData= 39
    78. writeData= 39
    79. readData= 40
    80. writeData= 40
    81. readData= 41
    82. writeData= 41
    83. readData= 42
    84. writeData= 42
    85. readData= 43
    86. writeData= 43
    87. readData= 44
    88. writeData= 44
    89. readData= 45
    90. writeData= 45
    91. readData= 46
    92. writeData= 46
    93. readData= 47
    94. writeData= 47
    95. readData= 48
    96. writeData= 48
    97. readData= 49
    98. writeData= 49
    99. readData= 50
    100. writeData= 50

    6.协程求素数

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"time"
    6. )
    7.  
    8. //协程求素数
    9. //要求统计1-200的数字中，哪些是素数？
    10.  
    11. // 使用并行的方式，将统计素数的任务分配给多个（4个）goroutine去完成
    12. func putNum(intChan chan int) {
    13. 	for i := 1; i <= 200; i++ {
    14. 		intChan <- i
    15. 	}
    16. 	//关闭
    17. 	close(intChan)
    18. }
    19.  
    20. // 从intChan取出数据，判断是否为素数，如果是，就放入到primeChan
    21. func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {
    22.  
    23. 	for {
    24. 		num, ok := <-intChan
    25. 		if !ok {
    26. 			break
    27. 		}
    28. 		flag := true
    29. 		for i := 2; i < num; i++ {
    30. 			if num%i == 0 {
    31. 				flag = false
    32. 				break
    33. 			}
    34. 		}
    35. 		if flag {
    36. 			//放入素数管道
    37. 			primeChan <- num
    38. 		}
    39. 	}
    40. 	fmt.Println("有一个primeNum协程因为取不到数据，退出")
    41. 	//这里我们还不能关闭primeChan
    42. 	//向exitChan写入true
    43. 	exitChan <- true
    44. }
    45.  
    46. func main() {
    47. 	intChan := make(chan int, 1000)
    48. 	//放入结果
    49. 	primeChan := make(chan int, 10000)
    50.  
    51. 	//标识退出的管道
    52. 	exitChan := make(chan bool, 4)
    53.  
    54. 	start := time.Now().Unix()
    55. 	//开启一个协程,向intChan放入1-8000个数
    56. 	go putNum(intChan)
    57.  
    58. 	//开启4个协程向intChan取出数据并判断是否为素数
    59. 	//如果是素数直接放入primeChan
    60. 	for i := 0; i < 4; i++ {
    61. 		go primeNum(intChan, primeChan, exitChan)
    62. 	}
    63.  
    64. 	go func() {
    65. 		//这里主线程要进行处理
    66. 		for i := 0; i < 4; i++ {
    67. 			<-exitChan
    68. 		}
    69. 		//从exitChan取出了4个结果，可以放心的关闭primeChan
    70. 		end := time.Now().Unix()
    71. 		fmt.Println("使用协程耗时=", end-start)
    72. 		close(primeChan)
    73. 	}()
    74.  
    75. 	//遍历primeNum，把结果取出
    76. 	for {
    77. 		res, ok := <-primeChan
    78. 		if !ok {
    79. 			break
    80. 		}
    81. 		fmt.Printf("素数=%d\n", res)
    82. 	}
    83. 	fmt.Println("main()退出")
    84. }
    1. 素数=1
    2. 素数=2                                
    3. 有一个primeNum协程因为取不到数据，退出
    4. 有一个primeNum协程因为取不到数据，退出
    5. 有一个primeNum协程因为取不到数据，退出
    6. 素数=3                                
    7. 有一个primeNum协程因为取不到数据，退出
    8. 使用协程耗时= 0                       
    9. 素数=5                                
    10. 素数=7                                
    11. 素数=11                               
    12. 素数=13                               
    13. 素数=17                               
    14. 素数=19                               
    15. 素数=23                               
    16. 素数=29                               
    17. 素数=31                               
    18. 素数=37                               
    19. 素数=41                               
    20. 素数=43                               
    21. 素数=47                               
    22. 素数=53                               
    23. 素数=59                               
    24. 素数=61                               
    25. 素数=67                               
    26. 素数=71
    27. 素数=73
    28. 素数=79
    29. 素数=83
    30. 素数=89
    31. 素数=97
    32. 素数=101
    33. 素数=103
    34. 素数=107
    35. 素数=109
    36. 素数=113
    37. 素数=127
    38. 素数=131
    39. 素数=137
    40. 素数=139
    41. 素数=149
    42. 素数=151
    43. 素数=157
    44. 素数=163
    45. 素数=167
    46. 素数=173
    47. 素数=179
    48. 素数=181
    49. 素数=191
    50. 素数=193
    51. 素数=197
    52. 素数=199
    53. main()退出

    7.使用select解决管道阻塞问题

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. //使用select解决管道阻塞问题
    8.  
    9. func main() {
    10.  
    11. 	intChan := make(chan int, 10)
    12. 	for i := 0; i < 10; i++ {
    13. 		intChan <- i
    14. 	}
    15.  
    16. 	stringChan := make(chan string, 5)
    17. 	for i := 0; i < 5; i++ {
    18. 		stringChan <- "hello" + fmt.Sprintf("%d", 5)
    19. 	}
    20.  
    21. 	//传统的方法遍历管道，如果不关闭会阻塞，会遭遇deadlock
    22. 	//有可能不好确定什么时候关闭管道
    23. 	//使用select解决
    24.  
    25. 	for {
    26. 		select {
    27. 		//注意：如果intChan一直没有关闭，不会一直阻塞而deadlock
    28. 		//会自动的到下一个case
    29. 		case v := <-intChan:
    30. 			fmt.Println("从intChan读取数据 ", v)
    31. 			//time.Sleep(time.Second)
    32. 		case v := <-stringChan:
    33. 			fmt.Println("从stringChan读取数据 ", v)
    34. 			//time.Sleep(time.Second)
    35. 		default:
    36. 			fmt.Println("都读取不到了，不玩了")
    37. 			return
    38. 		}
    39. 	}
    40. }

     8.goroutine中使用recover可以解决协程中出现panic

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"time"
    6. )
    7.  
    8. // goroutine中使用recover可以解决协程中出现panic，导致程序崩溃问题
    9. func sayHello() {
    10. 	for i := 0; i < 10; i++ {
    11. 		time.Sleep(time.Second)
    12. 		fmt.Println("Hello world")
    13. 	}
    14.  
    15. }
    16.  
    17. func test() {
    18. 	//这里我们使用defer+recover
    19. 	defer func() {
    20. 		//捕获test抛出的panic
    21. 		//捕获了以后，这个协程发生错误不影响其他协程
    22. 		if err := recover(); err != nil {
    23. 			fmt.Println("test() 发生错误", err)
    24. 		}
    25. 	}()
    26. 	
    27. 	//定义了一个map，让它发生错误
    28. 	var myMap map[int]string
    29. 	myMap[0] = "Golang" //error
    30. }
    31. func main() {
    32. 	go sayHello()
    33.  
    34. 	//panic: assignment to entry in nil map
    35. 	//报错引起整个程序崩溃
    36. 	go test()
    37. 	for i := 0; i < 10; i++ {
    38. 		fmt.Println("main() ok=", i)
    39. 		time.Sleep(time.Second)
    40. 	}
    41. }

  • 相关阅读:
    C语言中编译时出现警告C4013（C语言不加函数原型产生的潜在错误）
    FRNet：Feature Reconstruction Network for RGB-D Indoor Scene Parsing
    适用于Linux的6个最佳Python IDE
    mybatis-plus使用sql的date_format()函数来查询数据
    PageRank算法
    从零开始搭建spring boot多模块项目
    Day4：面试必考题目
    二进制明文字符串加密:还原与反还原
    【HMS core】【FAQ】Health Kit、In-App Purchases、Account Kit典型问题合集4
    关于线程的那些事
  • 原文地址：https://blog.csdn.net/m0_46306264/article/details/132925165