Go-02语言并发Goroutine&Channel

最新推荐文章于 2023-02-28 15:59:27 发布
最新推荐文章于 2023-02-28 15:59:27 发布
阅读量137 收藏 1
点赞数 1
分类专栏： Go BlockChain
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a972669015/article/details/114583813
版权

一、协程概念

进程(Process)，线程(Thread)，协程(Coroutine)

进程是一个程序在一个数据集中的一次动态执行过程，可以简单理解为“正在执行的程序”，它是CPU资源分配和调度的独立单位。

线程是在进程之后发展出来的概念。它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。一个进程可以包含多个线程。

协程是一种用户态的轻量级线程，又称微线程，英文名Coroutine，协程的调度完全由用户控制。

二、Goroutine

go中使用Goroutine来实现并发concurrently。

与线程相比，创建Goroutine的成本很小，它就是一段代码，一个函数入口。以及在堆上为其分配的一个堆栈（初始大小为4K，会随着程序的执行自动增长删除）。因此它非常廉价，Go应用程序可以并发运行数千个Goroutines。

1.主goroutine

封装main函数的goroutine称为主goroutine。

主goroutine首先要做的是：设定每一个goroutine所能申请的栈空间的最大尺寸。

此后，主goroutine会进行一系列的初始化工作，涉及的工作内容大致如下：

  1. 创建一个特殊的defer语句，用于在主goroutine退出时做必要的善后处理。因为主goroutine也可能非正常的结束

  2. 启动专用于在后台清扫内存垃圾的goroutine，并设置GC可用的标识

  3. 执行mian包中的init函数

  4. 执行main函数

    执行完main函数后，它还会检查主goroutine是否引发了运行时恐慌，并进行必要的处理。最后主goroutine会结束自己以及当前进程的运行。

2.使用goroutine

在函数或方法调用前面加上关键字go，将会同时运行一个新的Goroutine。

package main

import (  
    "fmt"
    "time"
)

func numbers() {  
    for i := 1; i <= 5; i++ {
        time.Sleep(250 * time.Millisecond)
        fmt.Printf("%d ", i)
    }
}
func alphabets() {  
    for i := 'a'; i <= 'e'; i++ {
        time.Sleep(400 * time.Millisecond)
        fmt.Printf("%c ", i)
    }
}
func main() {  
  	//启动多个Goroutines
    go numbers()
    go alphabets()
  	//main的goroutine被用来睡眠3秒
    time.Sleep(3000 * time.Millisecond)
    fmt.Println("main terminated")
}

Goroutine的规则

  1. 当新的Goroutine开始时，Goroutine调用立即返回。与函数不同，go不等待Goroutine执行结束。当Goroutine调用，并且Goroutine的任何返回值被忽略之后，go立即执行到下一行代码。
  2. main的Goroutine应该为其他的Goroutines执行。如果main的Goroutine终止了，程序将被终止，而其他Goroutine将不会运行。

3.runtime包

关于 runtime 包几个方法:

  • NumCPU：返回当前系统的 CPU 核数量

  • GOMAXPROCS：设置最大的可同时使用的 CPU 核数

    通过runtime.GOMAXPROCS函数，应用程序何以在运行期间设置运行时系统中得P最大数量。但这会引起“Stop the World”。所以，应在应用程序最早的调用。并且最好是在运行Go程序之前设置好操作程序的环境变量GOMAXPROCS，而不是在程序中调用runtime.GOMAXPROCS函数。

    无论我们传递给函数的整数值是什么值，运行时系统的P最大值总会在1~256之间。

go1.8后，默认让程序运行在多个核上,可以不用设置了
go1.8前，还是要设置一下，可以更高效的利益cpu

func init(){
	//1.获取逻辑cpu的数量
	fmt.Println("逻辑CPU的核数：",runtime.NumCPU())
	//2.设置go程序执行的最大的：[1,256]
	n := runtime.GOMAXPROCS(runtime.NumCPU())
	fmt.Println(n)
}

  • Gosched：让当前线程让出 cpu 以让其它线程运行,它不会挂起当前线程，因此当前线程未来会继续执行

    这个函数的作用是让当前 goroutine 让出 CPU，当一个 goroutine 发生阻塞，Go 会自动地把与该 goroutine 处于同一系统线程的其他 goroutine 转移到另一个系统线程上去，以使这些 goroutine 不阻塞。

    func main() {
	go func() {
		for i := 0; i < 5; i++ {
			fmt.Println("goroutine。。。")
		}

	}()

	for i := 0; i < 4; i++ {
		//让出时间片，先让别的协议执行，它执行完，再回来执行此协程
		runtime.Gosched()
		fmt.Println("main。。")
	}
}

  • Goexit：退出当前 goroutine(但是defer语句会照常执行)

    
func main() {
	//创建新建的协程
	go func() {
		fmt.Println("goroutine开始。。。")

		//调用了别的函数
		fun()

		fmt.Println("goroutine结束。。")
	}() //别忘了()

	//睡一会儿，不让主协程结束
	time.Sleep(3*time.Second)
}



func fun() {
	defer fmt.Println("defer。。。")

	//return           //终止此函数
	runtime.Goexit() //终止所在的协程

	fmt.Println("fun函数。。。")
}

  • NumGoroutine：返回正在执行和排队的任务总数

    runtime.NumGoroutine函数在被调用后，会返回系统中的处于特定状态的Goroutine的数量。这里的特指是指Grunnable\Gruning\Gsyscall\Gwaition。处于这些状态的Groutine即被看做是活跃的或者说正在被调度。

    注意：垃圾回收所在Groutine的状态也处于这个范围内的话，也会被纳入该计数器。

  • runtime.GC:会让运行时系统进行一次强制性的垃圾收集

    1. 强制的垃圾回收：不管怎样，都要进行的垃圾回收。
    2. 非强制的垃圾回收：只会在一定条件下进行的垃圾回收（即运行时，系统自上次垃圾回收之后新申请的堆内存的单元（也成为单元增量）达到指定的数值）。

  • GOROOT :获取goroot目录

  • GOOS : 查看目标操作系统

       //获取goroot目录：
   	fmt.Println("GOROOT-->",runtime.GOROOT())
   
   	//获取操作系统
   	fmt.Println("os/platform-->",runtime.GOOS) // GOOS--> darwin，mac系统

三、channel

Go语言中，要传递某个数据给另一个goroutine(协程)，可以把这个数据封装成一个对象，然后把这个对象的指针传入某个channel中，另外一个goroutine从这个channel中读出这个指针，并处理其指向的内存对象。Go从语言层面保证同一个时间只有一个goroutine能够访问channel里面的数据，为开发者提供了一种优雅简单的工具，所以Go的做法就是使用channel来通信，通过通信来传递内存数据，使得内存数据在不同的goroutine中传递，而不是使用共享内存来通信。

1.概念

通道就是goroutine之间的通道。它可以让goroutine之间相互通信。

每个通道都有与其相关的类型。该类型是通道允许传输的数据类型。

2.数据类型

channel是引用类型

3.声明

//声明通道
var 通道名 chan 数据类型
//创建通道：如果通道为nil(就是不存在)，就需要先创建通道
通道名 = make(chan 数据类型)
//简化方式
通道名 := make(chan 数据类型)

4.发送/接收

在通道上箭头的方向指定数据是发送还是接收。

data := <- a // 从通道读取数据
a <- data // 向通道写数据

一个通道发送和接收数据，默认是阻塞的。

如果Goroutine在一个通道上发送数据，那么其他的Goroutine应该接收数据，否则程序将在运行时出现死锁。

同样，如果Goroutine正在等待从通道接收数据，那么其他Goroutine将会在该通道上写入数据，否则程序将会死锁。

5.关闭

发送者可以通过关闭信道，来通知接收方不会有更多的数据被发送到channel上。

close(ch)

接收者可以在接收来自通道的数据时使用额外的变量来检查通道是否已经关闭。

v, ok := <- ch

如果ok的值是true，表示成功的从通道中读取了一个数据value。如果ok是false，这意味着我们正在从一个封闭的通道读取数据。

6.循环

for循环的for range形式可用于循环从通道上获取数据，直到通道关闭。

package main

import (
	"time"
	"fmt"
)

func main()  {
	ch1 :=make(chan int)//简化声明channel
	go sendData(ch1)
	// 通道的范围循环
	for v := range ch1{
		fmt.Println("读取数据：",v)
	}
	fmt.Println("main..over.....")
}
func sendData(ch1 chan int)  {
	for i:=0;i<10 ; i++ {
		time.Sleep(1*time.Second)
		ch1 <- i
	}
	close(ch1)//通知对方，通道关闭
}

7.缓冲通道

无缓冲通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。

缓冲通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道。

这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。

package main

import (
	"fmt"
	"strconv"
	"time"
)

func main() {
	/*
	非缓存通道：make(chan T)
	缓存通道：make(chan T ,size)
		缓存通道，理解为是队列：

	非缓存，发送还是接受，都是阻塞的
	缓存通道,缓存区的数据满了，才会阻塞状态。。

	 */
	ch1 := make(chan int)           //非缓存的通道
	fmt.Println(len(ch1), cap(ch1)) //0 0
	//ch1 <- 100//阻塞的，需要其他的goroutine解除阻塞，否则deadlock

	ch2 := make(chan int, 5)        //缓存的通道，缓存区大小是5
	fmt.Println(len(ch2), cap(ch2)) //0 5
	ch2 <- 100                      //
	fmt.Println(len(ch2), cap(ch2)) //1 5

	//ch2 <- 200
	//ch2 <- 300
	//ch2 <- 400
	//ch2 <- 500
	//ch2 <- 600
	fmt.Println("--------------")
	ch3 := make(chan string, 4)
	go sendData3(ch3)
	for {
		time.Sleep(1*time.Second)
		v, ok := <-ch3
		if !ok {
			fmt.Println("读完了，，", ok)
			break
		}
		fmt.Println("\t读取的数据是：", v)
	}

	fmt.Println("main...over...")
}

func sendData3(ch3 chan string) {
	for i := 0; i < 10; i++ {
		ch3 <- "数据" + strconv.Itoa(i)
		fmt.Println("子goroutine，写出第", i, "个数据")
	}
	close(ch3)
}

8.定向通道

双向通道，既可以发送数据，也可以读取数据的通道。

data := <- a // 从通道读取数据
a <- data 	 // 向通道写数据

单向通道，只能发送或者接收数据的通道。

chan <- T //只写
<- chan T //只读

四、Timer

定时器，标准库中的Timer让用户可以定义自己的超时逻辑，是一次性的时间触发事件。

1.time.NewTimer()

package main

import (
	"time"
	"fmt"
)

func main() {

	/*
		1.func NewTimer(d Duration) *Timer
			创建一个计时器：d时间以后触发，go触发计时器的方法比较特别，就是在计时器的channel中发送值
	 */
	//新建一个计时器：timer
	timer := time.NewTimer(3 * time.Second)
	fmt.Printf("%T\n", timer) //*time.Timer
	fmt.Println(time.Now())   //2019-08-15 10:41:21.800768 +0800 CST m=+0.000461190

	//此处在等待channel中的信号，执行此段代码时会阻塞3秒
	ch2 := timer.C     //<-chan time.Time
	fmt.Println(<-ch2) //2019-08-15 10:41:24.803471 +0800 CST m=+3.003225965

}

2.time.After()

在等待持续时间之后，然后在返回的通道上发送当前时间。它相当于NewTimer(d).C。

package main

import (
	"time"
	"fmt"
)

func main() {

	/*
		func After(d Duration) <-chan Time
			返回一个通道：chan，存储的是d时间间隔后的当前时间。
	 */
	ch1 := time.After(3 * time.Second) //3s后
	fmt.Printf("%T\n", ch1) // <-chan time.Time
	fmt.Println(time.Now()) //2019-08-15 09:56:41.529883 +0800 CST m=+0.000465158
	time2 := <-ch1
	fmt.Println(time2) //2019-08-15 09:56:44.532047 +0800 CST m=+3.002662179


}

五、select

select 是 Go 中的一个控制结构。select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s); 
    /* 可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}

  • 每个case都必须是一个通信

  • 所有channel表达式都会被求值

  • 所有被发送的表达式都会被求值

  • 如果有多个case都可以运行，select会随机公平地选出一个执行。其他不会执行。

  • 否则：

    如果有default子句，则执行该语句。

    如果没有default字句，select将阻塞，直到某个通信可以运行；Go不会重新对channel或值进行求值。

package main

import (
	"fmt"
	"time"
)

func main() {
	/*
	分支语句：if，switch，select
	select 语句类似于 switch 语句，
		但是select会随机执行一个可运行的case。
		如果没有case可运行，它将阻塞，直到有case可运行。
	 */

	ch1 := make(chan int)
	ch2 := make(chan int)

	go func() {
		time.Sleep(2 * time.Second)
		ch2 <- 200
	}()
	go func() {
		time.Sleep(2 * time.Second)
		ch1 <- 100
	}()

	select {
	case num1 := <-ch1:
		fmt.Println("ch1中取数据。。", num1)
	case num2, ok := <-ch2:
		if ok {
			fmt.Println("ch2中取数据。。", num2)
		}else{
			fmt.Println("ch2通道已经关闭。。")
		}


	}
}

select语句结合time包的和chan相关函数：

package main

import (
	"fmt"
	"time"
)

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

	//go func() {
	//	ch1 <- 100
	//}()

	select {
	case <-ch1:
		fmt.Println("case1可以执行。。")
	case <-ch2:
		fmt.Println("case2可以执行。。")
	case <-time.After(3 * time.Second):
		fmt.Println("case3执行。。timeout。。")

	//default:
	//	fmt.Println("执行了default。。")
	}
}
又菜又爱玩٩( ö̆ ) و
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go基础--goroutine和channel
06-19
总结起来，Go 语言中的 goroutine 和 channels 提供了一种强大而优雅的方式来处理并发和通信。它们使程序员能够轻松地构建并发系统，而无需深入底层线程管理和同步原语。通过理解和熟练运用这些概念，你可以构建出高...
golang网络通信超时设置
翔云
05-12 1万+
网络通信中，为了防止长时间无响应的情况，经常会用到网络连接超时、读写超时的设置。 本文结合例子简介golang的连接超时和读写超时设置。 1.超时设置 1.1 连接超时 func DialTimeout(network, address string, timeout time.Duration) (Conn, error) 第三个参数timeout可以用来设置连接超时设置。 如果超过time...
golang sleep函数 休眠延时
whatday的专栏
10-19 6万+
golang的休眠可以使用time包中的sleep。 函数原型为： func Sleep(d Duration) 其中的Duration定义为： type Duration int64 Duration的单位为 nanosecond。 为了便于使用，time中定义了时间常量： const ( Nanosecond Duration = 1 Microsecond = 1000 *...
golang编程之时间编程
yavobo的专栏
04-02 1527
本文转载于：http://blog.chinaunix.net/uid-24774106-id-4006530.html    编程离不开时间，时间管理，严格的说分成两块，一个是当前的时刻，对应的是一个点，还有是一段时间间隔。本文简单的讲讲go的时间相关的编程，比较简单，高手可以一笑而过。     golang对时间的支持，是package time做的事儿，里面有好多的函数，我就不一一举例学
go time.Sleep睡眠指定时间（小时级到纳秒级）
Aiky哇
06-16 1万+
// Sleep pauses the current goroutine for at least the duration d. // A negative or zero duration causes Sleep to return immediately. func Sleep(d Duration)
Golang实现睡眠排序(SleepSort)
Chrispink
05-26 1937
睡眠排序 睡眠排序原理就是为一个长度为n的待排序数组创建一个长度为n的线程向量,将待排序数字作为线程sleep函数的参数,sleep完成后输出数字,那么数字越大sleep时间越长,就排到越后面. 联想到Golang特点之一就是使用goroutine处理多线程情景, 因此做了尝试. 多个goroutine休眠时间以数字大小成正比, 休眠结束后放入管道channel, 管道内数字排序即为数组升序排...
Go-tunny-golang的一个goroutine池
08-13
Go-tunny是一个基于Go语言实现的goroutine池库，它为高效并发处理任务提供了一种结构化的方法。goroutine池的概念借鉴了线程池在其他编程语言中的设计，旨在优化资源管理和性能，避免频繁创建和销毁goroutines带来的...
Go-ChanBroker一个goroutine的Broker类似于kafka
08-14
Go-ChanBroker是一个基于Go语言实现的轻量级消息代理，它借鉴了Kafka的设计理念，但使用Go的...通过理解和使用Go-ChanBroker，开发者可以在Go应用中构建可靠的消息传递基础设施，同时享受到Go语言并发编程的优势。
Go-Golang编程语言的并发性跟踪和可视化工具
08-14
Go语言中的并发是其强大性能的关键特性之一。Goroutines是轻量级线程，它们的创建和切换开销小，允许程序轻松地开启大量并发任务。Channels则作为goroutines之间的通信桥梁，确保数据安全传递，避免竞态条件。然而，...
Go-Golet以使用goroutine从一个golang程序管理许多服务
08-14
Golet模式充分利用了Go语言的并发特性，简化了多服务管理的复杂性，同时保持了代码的清晰和可维护性。对于开发者来说，理解和掌握这种模式对于编写高并发、高可用性的Golang程序至关重要。在实际项目中，Golet模式...
golang实现并发数控制的方法
09-20
下面小编就为大家分享一篇golang实现并发数控制的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Go 线程休息5秒
weixin_34417814的博客
06-04 2342
2019独角兽企业重金招聘Python工程师标准>>> ...
golang好用的延时函数
nimei31的博客
02-15 1万+
通常golang里面计算程序执行时间，我们会在开始记录一个时间，然后用结束时候的时间去减开始时间，这样也挺好的但是今天碰见啦一个自带的好的方法，挺有意思，贴上代码：package mainimport (    "time"    "fmt")func main(){    f:=time.Since(time.Now())    time.Sleep(1e9)  fmt.Println("...
Go time Sleep 实现延时
深望的博客
04-15 1207
Go 中 time.Sleep 不能传入数字来实现延时，而是传入 time.Duration time.Sleep(time.Duration(200) * time.Millisecond) time.Sleep(1 * time.Second)
golang 定时任务time.Sleep和time.Tick实现结果比较
AlphaTao的博客
04-19 1万+
参考： https://blog.csdn.net/Star_CSU/article/details/86650684 这篇文章中对sleep和tick的原理做了介绍 总的来说 Sleep是使用睡眠完成定时，结束后继续往下执行循环来实现定时任务。 Tick函数是使用channel阻塞当前协程，完成定时任务的执行 现在来看一下 两种方法实现出来的效果有何不同 这里我们设置定时时长为5 使用“Do S...
Go语言休眠sleep
最新发布
小龙在线
02-28 1593
time标准库中的sleep可以休眠程序，阻塞线程。
【Go】如何控制协程的最大并发数
qq_42887507的博客
07-19 3111
在Go中控制协程的最大并发数
golang sleep
热门推荐
翔云
10-04 9万+
golang的休眠可以使用time包中的sleep。 函数原型为： func Sleep(d Duration) 其中的Duration定义为： type Duration int64 Duration的单位为 nanosecond。为了便于使用，time中定义了时间常量： const ( Nanosecond Duration = 1 Microse
golang sleep(睡眠)
weixin_44014995的博客
02-17 1万+
golang的休眠可以使用time包中的sleep。 函数原型为： func Sleep(d Duration) 其中的Duration定义为： type Duration int64 Duration的单位为 nanosecond。 为了便于使用，time中定义了时间常量： const ( minDuration Duration = -1 << 63 maxDuration Duration = 1<<63 - 1 ) Example 下面实现休眠2秒功能。 pac
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值