【每天一个Go知识点】(13)【转】goroutine的使用

1.goroutine的优势:

当你需要让某个任务并发操作的时候，将任务封装成一个函数，直接使用 go 函数名去进行并发执行，
go程序就会智能的将goroutine中的任务合理安排给每个CPU去执行，之所以这么方便是因为go已经
内置了调度和上下文切换机制！

• 案例：使用10个线程去执行一个函数，打印Hello
  注意：主函数执行完的话，整个程序都执行结束了，所以得等所有线程都结束才执行主函数
  需要使用syn.WaitGroup进行等待线程执行结束。结束标志就是等wg中的值为0

package main

import (
   "fmt"
   "sync"
)

var wg sync.WaitGroup

func sayHello(){
   defer wg.Done()
   fmt.Println("Hello！")
}


func main() {
   wg.Add(10)
   for i:=0;i<10;i++{
       go sayHello()
   }
   wg.Wait()
   fmt.Println("主函数执行完成！")
}

2.goroutine的原理

线程由CPU调度是抢占式的，协程由用户态调度是协作式的
虽然一个goroutine的栈只占几KB，但实际是可伸缩的，如果需要更多内容，runtime会自动为goroutine分配
goroutine和OS线程是多对多的关系，即m:n

3. goroutine的GOMAXPROCS

GOMAXPROCS参数用来决定多少个OS线程来同时执行GO代码，默认是CPU的核心数，比如你的电脑是8核的，那么就会把你的Go程序调度到8个线程上去执行。
但是，比如一些日志系统和监控系统，主要就是来监控程序的，如果直接将cup跑满的话，会大大降低程序的执行效率，所以通过设置GOMAXPROCS来设置go程序会被几个线程给调度

package main

import (
    "fmt"
    "sync"
)

func a() {
    for i := 1; i < 10; i++ {
        fmt.Println("A:", i)
    }
}

func b() {
    for i := 1; i < 10; i++ {
        fmt.Println("B:", i)
    }
}

func main() {
    runtime.GOMAXPROCS(1)
    go a()
    go b()
    time.Sleep(time.Second)
}

3.channel

• 1. 为什么使用channel：
     Go语言的并发模型是CSP（Communicating Sequential Processes），提倡通过通信共享内存而不是通过共享内存而实现通信
• 2. 什么是channel：
     channel就是一个管道，主要作用就是用来协程之间的通信的
• 3. 如何使用channel：

  • 非缓冲channel，就是阻塞channel，如果执行从channel中拿数据的操作，但是没有数据可以拿出来就会阻塞，同理：如果往channel中加入数据的话，此时内部有数据，也会一直阻塞，一直到数据别消费，可以成功加入新数据为止

  • 缓冲channel，在channel没有满的情况下，可以直接存放和取出，不会阻塞！
    定义：var cha = make(chan int 10) 创建一个缓冲区为10的channel

  • 当通道被关闭时，再往该通道发送值会引发panic (案例：一个方法拿到数据，放入channel，另一个方法从channel中拿数据，并且进行操作，最后打印)

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup
//创建非缓冲通道
var cha = make(chan int)

func getNum(num int){
    defer wg.Done()
    cha <- num
}

func operationNum(){
    defer wg.Done()
    num := <- cha
    num = num * 10
    fmt.Println("拿到的值是：",num)
}

func main() {
    wg.Add(2)
    go getNum(10)
    go operationNum()
    wg.Wait()
    fmt.Println("主函数执行完成！")
}

• 4. 单向channel
     存在的意义：有些时候为了接口的安全，有些接口中只能接收通道的值和只能规定通道返回值，所以必须得有单向channel
     只能存值的channel：

package main
    
import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup
var cha = make(chan int)

func getNum(num int)<-chan int{
    defer wg.Done()
    cha <- num
    return cha
}

func operationNum(){
    defer wg.Done()
    num := <- cha
    num = num * 10
    fmt.Println("拿到的值是：",num)
}

func getChan(in chan<-int ){
    defer wg.Done()
    fmt.Println("接收到一个channel")
}

func main() {
    wg.Add(2)
    go getNum(10)
    go operationNum()
    var cha1 = make(chan<- int)
    go getChan(cha1)
    wg.Wait()
    fmt.Println("主函数执行完成！")
}

————————————————
版权声明：本文为CSDN博主「Java拌饭」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_42987796/article/details/122069909