go语法--基础39--并发编程--案例2

最新推荐文章于 2023-06-16 17:32:14 发布
最新推荐文章于 2023-06-16 17:32:14 发布
阅读量182 收藏 1
点赞数
分类专栏： go基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhou920786312/article/details/119062964
版权

一、并发和并行

Go语言为并发编程而内置的上层API基于CSP模型。

communicating sequential processes：顺序通信模型

Go语言通过安全的通道发送和接受数据以实现同步。

一般情况下，一个普通的计算机跑十几二十个线程就有点负载过大了，但是同样这台机器却可以轻松地让成百上千甚至上万个goroutine进行资源竞争。

二、goroutine

goroutine是Go并发设计的核心。
Goroutine说到底其实就是协程，但是他比线程更小，十几个goroutine可能体现在底层就是五六个线程，Go语言内部帮你实现了这些goroutine之间的内存共享。

执行goroutine只需要极少的栈内存（大概是4~5KB），当然会根据相应的数据伸缩。也正因为如此，可同时运行成千上万个并发任务。

Goroutine比thread更易用、更高效、更轻便。

2.1、goroutine退出方式

主协程退出了，其他协程也要跟着退出。

package main

import (
	"fmt"
	"time"
)

//主协程退出了，子协程也要跟着退出

func main() {

	go func() {
		i := 0
		for {
			i++
			fmt.Println("子协程 i = ", i)
			time.Sleep(time.Second)
		}
	}()
	i := 0
	for {
		i++
		fmt.Println("当主协程 i = ", i)
		time.Sleep(time.Second)

		if i == 2 { //当主协程中i=2时，主协程退出
			break
		}
	}
}


输出

当主协程 i =  1
子协程 i =  1
子协程 i =  2
当主协程 i =  2

2.2、Runtime.Gosched

用于让出CPU时间片，让出当前goroutine的执行权限，调度器安排其他等待的任务执行，并在下次某个时候从该位置恢复执行。
就像接力赛，A跑了一会碰到代码runtime.Gosched()就把接力棒交给了B了，A就歇着了，B继续跑。

package main

import (
	"fmt"
	"runtime"
)

func main() {

	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println("子协程-->:", i)
		}
	}()

	for i := 0; i < 2; i++ {

		runtime.Gosched()
		fmt.Println("-------让出时间片，先让别子协程执行，执行完后，再执行主协程-------")
		fmt.Println("主协程-->:", i)
	}
}


输出

子协程-->: 0
子协程-->: 1
子协程-->: 2
子协程-->: 3
子协程-->: 4
子协程-->: 5
子协程-->: 6
子协程-->: 7
子协程-->: 8
子协程-->: 9
-------让出时间片，先让别子协程执行，执行完后，再执行主协程-------
主协程-->: 0
-------让出时间片，先让别子协程执行，执行完后，再执行主协程-------
主协程-->: 1

2.3、runtime.Goexit

立即终止当前goroutine

调度器确保所有已注册defer延迟调用被执行。

package main

import (
	"fmt"
	"runtime"
)

func test() {
	defer fmt.Println("------调度器确保所有已注册defer延迟调用被执行-----")

	// return //此函数
	fmt.Println("------Goexit执行--->:前-----")
	runtime.Goexit() //终止所在的协程
	fmt.Println("------Goexit执行--->:后-----")

}

func main() {

	go func() {
		fmt.Println("------test执行--->:前-----")

		test()

		fmt.Println("------test执行--->:后-----")
	}()
	//写一个死循环，让主协程不结束
	for {

	}
}
输出

------test执行--->:前-----
------Goexit执行--->:前-----
------调度器确保所有已注册defer延迟调用被执行-----

2.4、runtime.GOMAXPROCS()

用来设置用来并行计算的CPU核数最大值，并返回之前的值。

package main

import (
	"fmt"
	"runtime"
)

func cpu1() {

	//设置当前的cpu核数1,并返回之前pcu核数
	oldCpuNum := runtime.GOMAXPROCS(1)

	fmt.Println("cpu1-->之前pcu核数:", oldCpuNum)

	for {
		go fmt.Print(1)
		fmt.Print(0)
	}
}
func cpu2() {

	//设置当前的cpu核数2,并返回之前pcu核数
	oldCpuNum := runtime.GOMAXPROCS(2)

	fmt.Println("cpu2-->之前pcu核数:", oldCpuNum)

	for {
		go fmt.Print(1)
		fmt.Print(0)
	}
}
func main() {
	cpu1()
 	//cpu2()
}
cpu1结果

在这里插入图片描述

当runtime.GOMAXPROCS(1)时，最多同时只能有一个goroutine被执行。所以会打印很多1。过了一段时间后，GO语言调度器将其置为休眠，并唤醒另一个goroutine,这时候开始打印很多个0了

在打印的时候，goroutine是被调度到操作系统线程上的。

cpu2结果

在这里插入图片描述

当runtime.GOMAXPROCS(2)时，我们使用了2个CPU，所以两个goroutine可以一起被执行，以同样的频率交替打印0和1。

三、channel

Goroutine运行在相同的地址空间，因此访问内存必须做好同步。

Goroutine奉行通过通信来共享内存，而不是共享内存来通信。

引用类型channel是CSP模式的具体实现，用于多个goroutine通讯。其内部实现了同步，确保并发安全。

当我们复制一个channel或用于函数参数传递时，我们只是拷贝了一个channel引用，因此调用者和被调用者将引用同一个channel对象。

和其他的引用类型一样，channel的零值也是nil。

3.1、产生资源抢占案例

下面的代码会产生资源抢占

package main

import (
	"fmt"
	"time"
)

//打印机
func Printer(str string) {
	for _, char := range str {
		fmt.Printf("%c", char)
		fmt.Println("--")
		//每秒打印一个字符
		time.Sleep(time.Second)
	}
}

//person1执行完成之后，person2执行
func person1() {
	Printer("123456")
}

func person2() {
	Printer("abcdef")
}

func main() {
	//创建两个协程，代表两个人，两个人同时使用打印机
	go person1()
	go person2()

	//不让主协程结束，死循环
	for {

	}
}
 

输出
a--
1--
2--
b--
c--
3--
4--
d--
e--
5--
6f--
--

3.2、通过管道通信解决资源抢占问题

下面代码，函数都是交替执行

package main

import (
	"fmt"
	"time"
)

//全局变量，创建一个channel
var ch = make(chan int)

//打印机
func Printer(str string) {
	for _, char := range str {
		fmt.Printf("%c", char)
		fmt.Println("--")
		//每秒打印一个字符
		time.Sleep(time.Second)
	}
}

//person1执行完成之后，person2执行
func person1() {
	Printer("123456")

	//写数据到管道
	//当管道有数据，写数据就会堵塞

	ch <- 666

}

func person2() {
	//从管道读数据
	//如果通道没有数据,就会阻塞
	<-ch
	Printer("abcdef")
}

func main() {
	//创建两个协程，代表两个人，两个人同时使用打印机
	go person1()
	go person2()

	//不让主协程结束，死循环
	for {

	}
}


输出

1--
2--
3--
4--
5--
6--
a--
b--
c--
d--
e--
f--

3.3、通过channel实现同步和数据交互

package main

import (
	"fmt"
	"time"
)

func main() {
	//创建channel
	ch := make(chan string)
	defer fmt.Println("主协程结束")
	go func() {
		defer fmt.Println("子协程执行-->完毕")
		fmt.Println("子协程执行-->开始")
		for i := 1; i <= 2; i++ {
			time.Sleep(time.Second)
			fmt.Println("子协程睡眠:", i, "秒")
		}
		ch <- "子协程end"
	}()
	str := <-ch //没有数据前，阻塞
	fmt.Println("管道内容：", str)
}


输出

子协程执行-->开始
子协程睡眠: 1 秒
子协程睡眠: 2 秒
子协程执行-->完毕
管道内容： 子协程end
主协程结束

四、定时器

Timer是一个定时器，代表未来的一个单一事件，你可以告诉timer你要等待多长时间，它提供一个channel，在将来的那个时间给那个channel写入一个时间值。

4.1、通过timer实现延时：

package main

import (
	"fmt"
	"time"
)

func main() {
	//创建一个定时器，设置时间为2s，2s后，往time通道写内容（当前时间）
	//timer只会执行一次
	timer := time.NewTimer(2 * time.Second)

	fmt.Println("当前时间:", time.Now())
	//2s后，往timer.C写数据，有数据后，就可以读取
	t := <-timer.C
	fmt.Println("当前时间: ", t)
}


输出

当前时间: 2021-06-20 20:11:25.6545682 +0800 CST m=+0.004318801
当前时间:  2021-06-20 20:11:27.6555197 +0800 CST m=+2.005270301

4.2、停止定时器：

package main

import (
	"fmt"
	"time"
)

func main() {
	timer := time.NewTimer(2 * time.Second)
	fmt.Println("当前时间:", time.Now())
	go func() {
		<-timer.C
		fmt.Println("子协程可以打印了,因为定时器的时间到")
	}()

	timer.Stop() //停止定时器
	for {

	}
}

在这里插入图片描述

4.3、重置定时器：

package main

import (
	"fmt"
	"time"
)

func main() {
	timer := time.NewTimer(60 * time.Second)

	fmt.Println("当前时间:", time.Now())

	timer.Reset(1 * time.Second) //重置计时器
	t := <-timer.C
	fmt.Println("当前时间:", t)
}

在这里插入图片描述

4.4、定时触发计时器

Ticker是一个定时触发的计时器，他会以一个间隔（interval）往channel发送一个事件（当前时间）,而channel的接收者可以以固定的时间间隔从chnanel中读取事件。

package main

import (
	"fmt"
	"time"
)

func main() {
	//创建定时器，每隔1秒后，定时器就会给channel发送一个时间（当前时间）
	ticker := time.NewTicker(1 * time.Second)

	go func() {
		for t := range ticker.C {
			fmt.Println("Tick at", t)
		}
	}()

	//一旦一个打点停止了，将不能再从它的通道中接收到值。我们将在运行后 1600ms停止这个打点器。
	time.Sleep(time.Second * 10)
	ticker.Stop()
	fmt.Println("Ticker stopped")

}


输出

Tick at 2021-06-20 20:44:10.8299989 +0800 CST m=+1.005164601
Tick at 2021-06-20 20:44:11.8299812 +0800 CST m=+2.005146901
Tick at 2021-06-20 20:44:12.8312571 +0800 CST m=+3.006422801
Tick at 2021-06-20 20:44:13.8298241 +0800 CST m=+4.004989801
Tick at 2021-06-20 20:44:14.8309582 +0800 CST m=+5.006123901
Tick at 2021-06-20 20:44:15.8302667 +0800 CST m=+6.005432401
Tick at 2021-06-20 20:44:16.8301526 +0800 CST m=+7.005318301
Tick at 2021-06-20 20:44:17.8297111 +0800 CST m=+8.004876801
Tick at 2021-06-20 20:44:18.8301434 +0800 CST m=+9.005309101
Ticker stopped
勤径苦舟
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
桫哥-GOlang基础-Go语言实战：并发爬虫
06-12
基础部分带你从零到一，打牢语法基础； 进阶部分包含实战案例和框架封装； 绝不浅尝辄止！ 风格依旧水煮，依旧不拘一格脑洞大开；
Go 面试笔记 DB 网络 系统 Go 分布式 算法
我是要成为海贼王的男人！
07-12 509
Go： 理解go-routine、channel概念、用法； context 内存、性能分析（pprof）； 如何限制并发的routine数； 掌握接口的用法与设计，提升代码的设计能力； 线程与协程区别 多个协程可由一个或多个线程管理，协程的调度发生在其所在的线程中。 可以被调度，调度策略由应用层代码定义，即可被高度自定义实现。 执行效率高。 因为协程的调度切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。调度发生在应用态而非内核态。 占用内存
Go语言并发编程
yyq1102394156的博客
04-22 124
Go语言并发编程 一、线程等待 type WaitGroup结构体（Add、Done、Wait）： package main import ( "fmt" "sync" ) func mainWait() { for i := 1; i < 10; i++ { fmt.Println("main:", i) } } func TestWait(wg *sync.WaitGroup) { defer wg.Done() //减少信号次数 for i := 1; i < 100;
Go---Go并发编程（详细）
weixin_52025712的博客
11-27 1080
Go语言并发编程Goroutine（协程）使用goroutinegoroutine与线程goroutine的栈是可增长的goroutine调度Goroutine池使用实例runtime包runtime.Gosched()runtime.Goexit()runtime.GOMAXPROCS操作系统线程和goroutine的关系channel通道的声明和初始化channel操作通道的缓存大小无缓存有缓冲单向通道定时器TimerTickerselect使用格式监听通道，直到有一个 channel 开始执行判断管道
学习go语言基础完成的小项目
qq_62331653的博客
06-16 1785
Go语言是由Google公司开发的一门编程语言，其主要目标是简化和加快软件开发过程，并使得开发出的程序具有高效率、高性能和可维护性，作为一门新兴的编程语言，Go语言在各个领域都有广泛的应用，尤其在Web服务器、网络编程、云计算等领域中表现出色，学习Go语言需要一定的编程基础，但相对于其他编程语言而言，它的语法结构更加简单，易于学习。此外，Go语言对并发编程提供了原生支持，使得开发者可以更轻松地编写高并发程序。所以我在大二就开始学习go语言，并用自己才学的基础知识做一些小项目，以便吸收所学的知识。 运行结果：
1.Go语言入门的第一个简单案例
等我千分就网恋的blog
09-21 239
一.Go语言入门的第一个简单案例 需求 要求开发一个hello.go程序,可以输出"hello,world!" 代码如下 package main import "fmt" func main() { fmt.Println("hello golang!") } 说明 go文件的后缀是**.go** package main 表示hello.go文件所在的包是main 在go中每个文件都必须归属于一个包 import "fmt" 表示引入包名为fmt的包,引入该包后,可以使用fmt
桫哥-GOlang-13并发编程
06-12
基础部分带你从零到一，打牢语法基础； 进阶部分包含实战案例和框架封装； 绝不浅尝辄止！ 风格依旧水煮，依旧不拘一格脑洞大开；
零基础学Go语言：轻松入门并发编程！.zip
最新发布
03-03
本资源为大学生提供了Go语言的入门教程，通过简单易懂的语言和实际案例，讲解了Go语言的基本概念、语法和编程技巧。 适用人群：对编程感兴趣的大学生，想要学习网络服务和并发编程的学生。 使用场景及目标：适用于...
桫哥-GOlang-区块链科普
06-12
?基础部分带你从零到一，打牢语法基础； 进阶部分包含大量实战案例和框架封装； 成语APP、多人聊天室、并发爬虫、文本大数据处理等； 绝不浅尝辄止！ 风格依旧水煮，依旧不拘一格脑洞大开；
桫哥-GOlang-03复合类型
06-12
基础部分带你从零到一，打牢语法基础； 进阶部分包含实战案例和框架封装； 绝不浅尝辄止！ 风格依旧水煮，依旧不拘一格脑洞大开；
Go 网络编程示例
firstcode666的博客
01-19 609
示例：并发时钟服务器 本节介绍 net 包，它提供构建客户端和服务器程序的组件，这些程序通过 TCP、UDP 或者 UNIX 套接字进行通信。网络服务 net/http 包是在 net 包的基础上构建的。 时钟服务器 这个示例是一个时钟服务器，它以每秒一次的频率向客户端发送当前时间： package main import ( "io" "log" "net" "time" ) func main() { listener, err := net....
Go语言网络编程入门不走弯路最佳案例（写Api接口）
zhaoolee的CSDN博客
12-13 2895
Go语言是Google领导开发的一门编程语言，国内可访问的官网 https://golang.google.cn/ image-20201213123438844 只要选对了框架，用Go语言完成网络编程会变得非常容易，目前Github Star数量最多的Go语言的框架为gin, 开源地址 github.com/gin-gonic/gin ，并且提供了中文文档 https://gin-g...
go语法--基础38--并发编程--案例1
zhou920786312的博客
07-26 106
并发案例 一、无缓冲:生成者消费者 1.1、案例 package main import ( "fmt" "time" ) func Producer(p chan<- int) { for i := 0; i < 10; i++ { p <- i fmt.Println("生产者-->商品:", i) } } func Consumer(c <-chan int) { for i := 0; i < 10; i++ { v := <-c
GO:并发实例
Wang_liixue的博客
07-24 329
func task1() { for i := 0; i < 2; i++ { fmt.Println("火车驶向云外") } } func task2() { for i := 0; i < 2; i++ { fmt.Println("梦安魂于九霄") } } func main() { task1() task2() } 火车驶向云外 火车驶向云外 梦安魂于九霄 梦安魂于九霄 func main() { go task1() go task2() //main(
GO 语言 Web 开发实战一
m0_37322399的博客
01-15 1907
xdm，咱今天分享一个 golang web 实战的 demogo 的 http 包，以前都有或多或多的提到一些，也有一些笔记在我们的历史文章中，今天来一个。
go并发编程
weixin_56258107的博客
06-15 236
1. 并发介绍 进程和线程 A. 进程是程序在操作系统中的一次执行过程，系统进行资源分配和调度的一个独立单位。 B. 线程是进程的一个执行实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。 C.一个进程可以创建和撤销多个线程;同一个进程中的多个线程之间可以并发执行。 并发和并行 A. 多线程程序在一个核的cpu上运行，就是并发。 B. 多线程程序在多个核的cpu上运行，就是并行。 并发 并行 协程和线程 协程：独立的栈空间
学习Go语言必备案例 (1)
热门推荐
数据知道的博客
06-10 1万+
关于Go语言安装包的下载和环境搭建，可参考：在IntelliJ idea上安装Go语言的开发环境 (在IDEA中配置 ‘go1.12.5’ 最新版本的插件) Go语言是一个被设计用来建立简单，快速和可信赖的软件的开源程序设计语言。下面通过带注释的例子程序去详细介绍介绍 Go语言，每篇文章介绍10个案例。 1. 值 Go 拥有各值类型，包括字符串，整形，浮点型，布尔型等: package main ...
Go语言基础之并发
weixin_30470643的博客
09-13 402
目录 一、Go语言中的并发编程 二、并发与并行 三、goroutine 3.1 使用goroutine 3.2 启动单个goroutine 3.3 启动多个goroutine 四、goroutine与线程 ...
Go并发编程总结
每天进步一点点。。。的博客
05-11 7966
最近一直在看Go语言的并发编程，主要的书籍是 &lt;Go语言学习笔记&gt;。看完之后，看到网上这篇博客总结的不错，所讲的内容学习笔记上都有。Golang :不要通过共享内存来通信，而应该通过通信来共享内存。这句风靡在Go社区的话,说的就是 goroutine中的 channel。他在go并发编程中充当着类型安全的管道作用。1、通过golang中的 goroutine 与sync.Mutex进行...
mastering_go_zh_cn-master
07-12
《Mastering Go》对Go语言的各个方面进行了全面深入的讲解，涵盖了从基础知识、语法和特性，到高级主题和实践技巧的内容。读者可以通过阅读本书，了解到Go语言的特点和优势，学习如何使用Go语言编写高效且可维护的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值