go实战基础（一）-go实战goroutine(十三)-《GO开发知识笔记》

admin
admin
admin
0
文章
0
评论
2025-11-04 01:18:38 编程 来源：ZONE.CI 全球网 0 阅读模式 
    1. package main
    3. import (
    4.     "fmt"
    5.     "time"
    6. )
    8. // 在主线程(可以理解成进程)中，开启一个goroutine, 该协程每隔50毫秒秒输出 "你好golang"
    9. // 在主线程中也每隔50毫输出"你好golang", 输出10次后，退出程序
    10. // 要求主线程和goroutine同时执行
    11. func test() {
    12.     for i := 0; i < 10; i++ {
    13.         fmt.Println("test() 你好golang")
    14.         time.Sleep(time.Millisecond * 100)
    15.     }
    16. }
    18. func main() {
    19.     go test() //表示开启一个协程
    20.     for i := 0; i < 10; i++ {
    21.         fmt.Println("main() 你好golang")
    22.         time.Sleep(time.Millisecond * 100)
    23.     }
    24. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    9. //主线程退出后所有的协程无论有没有执行完毕都会退出，所以我们在主进程中可以通过WaitGroup等待协程执行完毕
    10. var wg sync.WaitGroup
    12. func test1() {
    13.     for i := 0; i < 10; i++ {
    14.         fmt.Println("test1() 你好golang-", i)
    15.         time.Sleep(time.Millisecond * 100)
    16.     }
    17.     wg.Done() //协程计数器-1
    18. }
    20. func test2() {
    21.     for i := 0; i < 10; i++ {
    22.         fmt.Println("test2() 你好golang-", i)
    23.         time.Sleep(time.Millisecond * 100)
    24.     }
    25.     wg.Done() //协程计数器-1
    26. }
    28. func main() {
    29.     wg.Add(1)  //协程计数器+1
    30.     go test1() //表示开启一个协程
    31.     wg.Add(1)  //协程计数器+1
    32.     go test2() //表示开启一个协程
    34.     wg.Wait() //等待协程执行完毕...
    35.     fmt.Println("主线程退出...")
    36. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "runtime"
    6. )
    8. func main() {
    9.     //获取当前计算机上面的Cup个数
    10.     cpuNum := runtime.NumCPU()
    11.     fmt.Println("cpuNum=", cpuNum)
    13.     //可以自己设置使用多个cpu
    14.     runtime.GOMAXPROCS(cpuNum - 1)
    15.     fmt.Println("ok")
    16. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    9. //多携程的一个案例
    10. var wg sync.WaitGroup
    12. func test(num int) {
    13.     defer wg.Done()
    14.     for i := 1; i <= 5; i++ {
    15.         fmt.Printf("协程(%v)打印的第%v条数据\n", num, i)
    16.         time.Sleep(time.Millisecond * 100)
    17.     }
    18. }
    20. func main() {
    21.     for i := 1; i <= 6; i++ {
    22.         wg.Add(1)
    23.         go test(i)
    24.     }
    25.     wg.Wait()
    26.     fmt.Println("关闭主线程...")
    28. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "time"
    6. )
    8. //需求：要统计1-120000的数字中那些是素数？for循环实现
    9. func main() {
    11.     start := time.Now().Unix()
    12.     for num := 2; num < 120000; num++ {
    13.         var flag = true
    14.         for i := 2; i < num; i++ {
    15.             if num%i == 0 {
    16.                 flag = false
    17.                 break
    18.             }
    19.         }
    20.         if flag {
    21.             // fmt.Println(num, "是素数")
    22.         }
    23.     }
    24.     end := time.Now().Unix()
    26.     fmt.Println(end - start) //11毫秒  11毫秒
    28. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    9. //需求：要统计1-120000的数字中那些是素数？goroutine  for循环实现
    11. /*
    12. 1 协程  统计  1-30000
    14. 2 协程  统计  30001-60000
    16. 3 协程  统计  60001-90000
    18. 4 协程  统计  90001-120000
    20. // start:(n-1)*30000+1       end:n*30000
    21. */
    22. var wg sync.WaitGroup
    24. func test(n int) {
    25.     for num := (n-1)*30000 + 1; num < n*30000; num++ {
    26.         if num > 1 {
    27.             var flag = true
    28.             for i := 2; i < num; i++ {
    29.                 if num%i == 0 {
    30.                     flag = false
    31.                     break
    32.                 }
    33.             }
    34.             if flag {
    35.                 // fmt.Println(num, "是素数")
    36.             }
    37.         }
    38.     }
    39.     wg.Done()
    40. }
    42. func main() {
    43.     start := time.Now().Unix()
    44.     for i := 1; i <= 4; i++ {
    45.         wg.Add(1)
    46.         go test(i)
    47.     }
    48.     wg.Wait()
    49.     fmt.Println("执行完毕")
    50.     end := time.Now().Unix()
    51.     fmt.Println(end - start) //4毫秒
    53. }
    1. package main
    3. import "fmt"
    5. func main() {
    6.     //1、创建channel
    8.     ch := make(chan int, 3)
    10.     //2、给管道里面存储数据
    11.     ch <- 10
    12.     ch <- 21
    13.     ch <- 32
    15.     //3、获取管道里面的内容
    16.     a := <-ch
    17.     fmt.Println(a) //10
    19.     <-ch //从管道里面取值   //21
    20.     c := <-ch
    21.     fmt.Println(c) //32
    22.     ch <- 56
    23.     ch <- 66
    24.     //4、打印管道的长度和容量
    25.     fmt.Printf("值：%v 容量：%v 长度%v\n", ch, cap(ch), len(ch)) //值：0xc0000d0080 容量：3 长度2
    27.     // 5、管道的类型（引用数据类型）
    29.     ch1 := make(chan int, 4)
    31.     ch1 <- 34
    32.     ch1 <- 54
    33.     ch1 <- 64
    35.     ch2 := ch1
    36.     ch2 <- 69
    37.     <-ch1
    38.     <-ch1
    39.     <-ch1
    40.     d := <-ch1
    41.     fmt.Println(d) //69
    43.     //8、管道阻塞
    45.     // ch6 := make(chan int, 1)
    46.     // ch6 <- 34
    47.     // ch6 <- 64 //all goroutines are asleep - deadlock!
    49.     // 在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报告 deadlock
    50.     // ch7 := make(chan string, 2)
    51.     // ch7 <- "数据1"
    52.     // ch7 <- "数据2"
    53.     // m1 := <-ch7
    54.     // m2 := <-ch7
    55.     // m3 := <-ch7
    56.     // fmt.Println(m1, m2, m3) //fatal error: all goroutines are asleep - deadlock!
    58.     //正确的写法
    59.     ch8 := make(chan int, 1)
    60.     ch8 <- 34
    61.     <-ch8
    62.     ch8 <- 67
    63.     <-ch8
    64.     ch8 <- 78
    65.     m4 := <-ch8
    66.     fmt.Println(m4)
    68. }
    1. package main
    3. import "fmt"
    5. // 循环遍历管道数据
    7. func main() {
    8.     //2、使用for range遍历通道，当通道被关闭的时候就会退出for range,如果没有关闭管道就会报个错误fatal error: all goroutines are asleep - deadlock!
    9.     // var ch1 = make(chan int, 10)
    10.     // for i := 1; i <= 10; i++ {
    11.     //     ch1 <- i
    12.     // }
    13.     // close(ch1) //关闭管道
    15.     // //for range循环遍历管道的值  ,注意：管道没有key
    16.     // for v := range ch1 {
    17.     //     fmt.Println(v)
    18.     // }
    20.     //2、通过for循环遍历管道的时候管道可以不关闭
    21.     var ch2 = make(chan int, 10)
    22.     for i := 1; i <= 10; i++ {
    23.         ch2 <- i
    24.     }
    26.     for j := 0; j < 10; j++ {
    27.         fmt.Println(<-ch2)
    28.     }
    29. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "sync"
    6. )
    7. package main
    8. var wg sync.WaitGroup
    9. func putNum(intChan chan int) {
    10.     for i := 2; i < 10; i++ {
    11.         intChan <- i
    12.         fmt.Println(i)
    13.     }
    14.     close(intChan)
    15.     wg.Done()
    16. }
    18. //定义一个存放任意数据类型的管道 3个数据
    19. func main() {
    21.     // allChan := make(chan interface{}, 3)
    23.     // allChan <- 10
    24.     // allChan <- "tom jack"
    25.     // cat := Cat{"小花猫", 4}
    26.     // allChan <- cat
    28.     // //我们希望获得到管道中的第三个元素，则先将前2个推出
    29.     // <-allChan
    30.     // <-allChan
    32.     // newCat := <-allChan //从管道中取出的Cat是什么?
    34.     // fmt.Printf("newCat=%T , newCat=%v\n", newCat, newCat)
    35.     // //下面的写法是错误的!编译不通过
    36.     // //fmt.Printf("newCat.Name=%v", newCat.Name)
    37.     // //使用类型断言
    38.     // a := newCat.(Cat)
    39.     // fmt.Printf("newCat.Name=%v", a.Name)
    41.     var intChan = make(chan int, 1000)
    42.     wg.Add(1)
    43.     go putNum()
    44.     wg.Wait()()
    45. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    9. /*
    10. 需求：使用goroutine和channel协同工作案例
    11. 1、开启一个WriteData的的协程给向管道inChan中写入100条数据
    12. 2、开启一个ReadData的协程读取inChan中写入的数据
    13. 3、注意：WriteData和ReadData同时操作一个管道
    14. 4、主线程必须等待操作完成后才可以退出
    16. goroutine结合Channel使用的简单demo,定义两个方法，一个方法给管道里面写数据，一个给管道里面读取数据。要求同步进行。
    18. */
    19. var wg sync.WaitGroup
    21. //写数据
    22. func fn1(ch chan int) {
    23.     for i := 1; i <= 10; i++ {
    24.         ch <- i
    25.         fmt.Printf("【写入】数据%v成功\n", i)
    26.         time.Sleep(time.Millisecond * 5000)
    27.     }
    28.     close(ch)
    29.     wg.Done()
    30. }
    31. func fn2(ch chan int) {
    32.     for v := range ch {
    33.         fmt.Printf("【读取】数据%v成功\n", v)
    34.         time.Sleep(time.Millisecond * 10)
    35.     }
    36.     wg.Done()
    37. }
    39. func main() {
    41.     var ch = make(chan int, 10)
    43.     wg.Add(1)
    44.     go fn1(ch)
    45.     wg.Add(1)
    46.     go fn2(ch)
    48.     wg.Wait()
    49.     fmt.Println("退出...")
    50. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    9. var wg sync.WaitGroup
    11. func main() {
    12.     // 1、创建channel
    13.     var ch1 = make(chan int, 3)
    14.     wg.Add(1)
    15.     go func() {
    16.         for i := 1; i <= 3; i++ {
    17.             num := <-ch1
    18.             fmt.Println(num)
    19.         }
    20.         wg.Done()
    21.     }()
    22.     wg.Add(1)
    23.     go func() {
    24.         for i := 1; i <= 3; i++ {
    25.             time.Sleep(time.Second)
    26.             ch1 <- i
    27.         }
    28.         wg.Done()
    29.     }()
    31.     wg.Wait()
    32. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    9. var wg sync.WaitGroup
    11. //向 intChan放入 1-120000个数
    12. func putNum(intChan chan int) {
    13.     for i := 2; i < 120000; i++ {
    14.         intChan <- i
    15.     }
    16.     close(intChan)
    17.     wg.Done()
    18. }
    20. // 从 intChan取出数据，并判断是否为素数,如果是，就把得到的素数放在primeChan
    22. func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {
    23.     for num := range intChan {
    24.         var flag = true
    25.         for i := 2; i < num; i++ {
    26.             if num%i == 0 {
    27.                 flag = false
    28.                 break
    29.             }
    30.         }
    31.         if flag {
    32.             primeChan <- num //num是素数
    33.         }
    34.     }
    35.     //要关闭 primeChan
    36.     // close(primeChan) //如果一个channel关闭了就没法给这个channel发送数据了
    37.     //什么时候关闭primeChan?
    39.     //给exitChan里面放入一条数据
    40.     exitChan <- true
    41.     wg.Done()
    42. }
    44. //printPrime打印素数的方法
    45. func printPrime(primeChan chan int) {
    46.     // for v := range primeChan {
    47.     //     fmt.Println(v)
    48.     // }
    49.     wg.Done()
    50. }
    52. func main() {
    54.     start := time.Now().Unix()
    56.     intChan := make(chan int, 1000)
    57.     primeChan := make(chan int, 50000)
    58.     exitChan := make(chan bool, 16) //标识primeChan close
    60.     //存放数字的协程
    61.     wg.Add(1)
    62.     go putNum(intChan)
    64.     //统计素数的协程
    65.     for i := 0; i < 16; i++ {
    66.         wg.Add(1)
    67.         go primeNum(intChan, primeChan, exitChan)
    68.     }
    70.     //打印素数的协程
    71.     wg.Add(1)
    72.     go printPrime(primeChan)
    74.     //判断exitChan是否存满值
    75.     wg.Add(1)
    76.     go func() {
    77.         for i := 0; i < 16; i++ {
    78.             <-exitChan
    79.         }
    80.         //关闭primeChan
    81.         close(primeChan)
    82.         wg.Done()
    83.     }()
    85.     wg.Wait()
    87.     end := time.Now().Unix()
    88.     fmt.Println("执行完毕....", end-start, "毫秒")
    90. }
    1. package main
    3. import "fmt"
    5. //单向管道
    6. func main() {
    8.     // 1、在默认情况下下，管道是双向
    9.     ch1 := make(chan int, 2)
    10.     ch1 <- 10
    11.     ch1 <- 12
    12.     m1 := <-ch1
    13.     m2 := <-ch1
    14.     fmt.Println(m1, m2) //10 12
    16.     // 2、管道声明为只写
    17.     ch2 := make(chan<- int, 2)
    18.     ch2 <- 10
    19.     ch2 <- 12
    20.     // <-ch2   //receive from send-only type chan<- int
    22.     // 3、管道声明为只读
    24.     ch3 := make(<-chan int, 2)
    25.     // ch3 <- 23
    27. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    9. /*
    10. 需求：使用goroutine和channel协同工作案例
    11. 1、开启一个WriteData的的协程给向管道inChan中写入100条数据
    12. 2、开启一个ReadData的协程读取inChan中写入的数据
    13. 3、注意：WriteData和ReadData同时操作一个管道
    14. 4、主线程必须等待操作完成后才可以退出
    16. goroutine结合Channel使用的简单demo,定义两个方法，一个方法给管道里面写数据，一个给管道里面读取数据。要求同步进行。
    18. */
    19. var wg sync.WaitGroup
    21. //写数据
    22. func fn1(ch chan<- int) {
    23.     for i := 1; i <= 10; i++ {
    24.         ch <- i
    25.         fmt.Printf("【写入】数据%v成功\n", i)
    26.         time.Sleep(time.Millisecond * 50)
    27.     }
    28.     close(ch)
    29.     wg.Done()
    30. }
    32. //读取管道里面的数据
    33. func fn2(ch <-chan int) {
    34.     for v := range ch {
    35.         fmt.Printf("【读取】数据%v成功\n", v)
    36.         time.Sleep(time.Millisecond * 50)
    37.     }
    38.     wg.Done()
    39. }
    41. func main() {
    43.     var ch = make(chan int, 10)
    45.     wg.Add(1)
    46.     go fn1(ch)
    47.     wg.Add(1)
    48.     go fn2(ch)
    50.     wg.Wait()
    51.     fmt.Println("退出...")
    52. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "time"
    6. )
    8. func main() {
    9.     // 在某些场景下我们需要同时从多个通道接收数据,这个时候就可以用到golang中给我们提供的select多路复用
    11.     //1.定义一个管道 10个数据int
    12.     intChan := make(chan int, 10)
    13.     for i := 0; i < 10; i++ {
    14.         intChan <- i
    15.     }
    16.     //2.定义一个管道 5个数据string
    17.     stringChan := make(chan string, 5)
    18.     for i := 0; i < 5; i++ {
    19.         stringChan <- "hello" + fmt.Sprintf("%d", i)
    20.     }
    21.     //使用select来获取channel里面的数据的时候不需要关闭channel
    22.     for {
    23.         select {
    24.         case v := <-intChan:
    25.             fmt.Printf("从 intChan 读取的数据%d\n", v)
    26.             time.Sleep(time.Millisecond * 50)
    27.         case v := <-stringChan:
    28.             fmt.Printf("从 stringChan 读取的数据%v\n", v)
    29.             time.Sleep(time.Millisecond * 50)
    30.         default:
    31.             fmt.Printf("数据获取完毕")
    32.             return //注意退出...
    33.         }
    34.     }
    36. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "time"
    6. )
    8. //函数
    9. func sayHello() {
    10.     for i := 0; i < 10; i++ {
    11.         time.Sleep(time.Millisecond * 50)
    12.         fmt.Println("hello,world")
    13.     }
    14. }
    16. //函数
    17. func test() {
    18.     //这里我们可以使用defer + recover
    19.     defer func() {
    20.         //捕获test抛出的panic
    21.         if err := recover(); err != nil {
    22.             fmt.Println("test() 发生错误", err)
    23.         }
    24.     }()
    25.     //定义了一个map
    26.     var myMap map[int]string
    27.     myMap[0] = "golang" //error
    28. }
    30. func main() {
    32.     go sayHello()
    33.     go test()
    35.     //防止主进程退出这里使用time.Sleep演示，搭建也可以用sync.WaitGroup
    36.     time.Sleep(time.Second)
    37. }
    1. package main
    3. //go build -race main.go  编译后运行查看
    5. import (
    6.     "fmt"
    7.     "sync"
    8.     "time"
    9. )
    11. var count = 0
    12. var wg sync.WaitGroup
    14. var mutex sync.Mutex
    16. func test() {
    17.     mutex.Lock()
    18.     count++
    19.     fmt.Println("the count is : ", count)
    20.     time.Sleep(time.Millisecond)
    21.     mutex.Unlock()
    22.     wg.Done()
    23. }
    25. func main() {
    26.     for r := 0; r < 20; r++ {
    27.         wg.Add(1)
    28.         go test()
    29.     }
    30.     wg.Wait()
    32. }
    1. package main
    3. //go build -race main.go  编译后运行查看
    5. import (
    6.     "fmt"
    7.     "sync"
    8.     "time"
    9. )
    11. var wg sync.WaitGroup
    13. var mutex sync.Mutex
    15. var m = make(map[int]int, 0)
    17. func test(num int) {
    18.     mutex.Lock()
    19.     var sum = 1
    20.     for i := 1; i <= num; i++ {
    21.         sum *= i
    22.     }
    23.     m[num] = sum
    24.     // fmt.Println(m[num])
    25.     fmt.Printf("key=%v value=%v\n", num, sum)
    26.     time.Sleep(time.Millisecond)
    27.     mutex.Unlock()
    28.     wg.Done()
    29. }
    31. func main() {
    32.     for r := 0; r < 40; r++ {
    33.         wg.Add(1)
    34.         go test(r)
    35.     }
    36.     wg.Wait()
    38. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    9. var wg sync.WaitGroup
    10. var mutex sync.RWMutex
    12. //写的方法
    13. func write() {
    14.     mutex.Lock()
    15.     fmt.Println("执行写操作")
    16.     time.Sleep(time.Second * 2)
    17.     mutex.Unlock()
    18.     wg.Done()
    19. }
    21. //读的方法
    22. func read() {
    23.     mutex.RLock()
    24.     fmt.Println("---执行读操作")
    25.     time.Sleep(time.Second * 2)
    26.     mutex.RUnlock()
    27.     wg.Done()
    28. }
    30. func main() {
    32.     //开启10个协程执行读操作
    33.     for i := 0; i < 10; i++ {
    34.         wg.Add(1)
    35.         go write()
    36.     }
    37.     // 开启10个协程执行写操作
    38.     for i := 0; i < 10; i++ {
    39.         wg.Add(1)
    40.         go read()
    41.     }
    42.     wg.Wait()
    44. }

    版权声明

    本站仅做备份收录，仅供研究与教学参考之用。
    读者将信息用于其他用途的，全部法律及连带责任由读者自行承担，本站不承担任何责任。

    ZONE.CI 全球网 | 安全领域涉猎者-乌云独行地带
    ZONE.CI 全球网
    安全领域涉猎者-乌云独行地带
    以太坊cppgolang区别 编程

    以太坊cppgolang区别

    以太坊是一种去中心化的开源平台，它采用智能合约技术，旨在构建和运行不受干扰的分布式应用程序。作为目前最受欢迎的区块链平台之一，以太坊提供了多种编程语言的支持，其
    12-282 评论
    progolang 编程

    progolang

    Go语言（Golang）是由Google开发的一门静态类型编程语言。作为一名专业的Golang开发者，我深知这门语言的优势和特点。在本文中，我将介绍Golang
    12-281 评论
    golangn个发送者 编程

    golangn个发送者

    Golang是一种开源的编程语言，由Google团队开发，旨在提高程序的并发性和简化软件开发过程。在Go语言中，有时需要向多个接收者发送信息。本文将介绍如何在G
    12-280 评论
    golang技能图谱 编程

    golang技能图谱

    从互联网行业的快速发展到人工智能技术的日益成熟，各种编程语言也应运而生。而在这众多的编程语言中，Golang（即Go）作为一门强大且高效的开发语言备受关注。Go
    12-281 评论
    ZONE.CI 全球网 | 安全领域涉猎者-乌云独行地带
    安全领域涉猎者-乌云独行地带
    ZONE.CI 全球网
    评论：0   参与：  8