1. Toy模板网首页
  2. > Toy博客

go语言学习——9

10月前 作者：ww要努力呀 分类：Toy博客 阅读(44) 违法举报

这篇具有很好参考价值的文章主要介绍了go语言学习——9。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

goroutine

前言：统计1~90000000数字中，哪些是素数？

  • 使用循环，很慢
  • 使用并发或者并行的方式，将任务分配给多个goroutine去完成，就会使用到goroutine

概念

进程和线程

  • 进程是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基本单位
  • 线程是进程的一个执行实例，是程序执行的最小单元，是比进程更小的能独立运行的基本单位
  • 一个进程可以创建核销多个线程，同一个进程中的多个线程可以并发执行
  • 一个程序至少有一个进程，一个进程至少有一个线程
    go语言学习——9

并发和并行

  • 多线程程序在单核上运行，就是并发
  • 多线程程序在多核上运行，就是并行
    go语言学习——9

GO协程和GO主线程

  • go主线程（直接称为线程/也可理解为进程）：一个go线程上，可以起多个协程，可以理解为协程是轻量级的线程[编译器做优化]
  • go协程的特点：
  • 有独立的栈空间
  • 共享程序堆空间
  • 调度由用户控制
  • 协程是轻量级的线程

go语言学习——9

package main

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

func test(){
	for i:=1;i<=5;i++{
		fmt.Println("test() hello,world! "+strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}

func main()  {
	go test() //开启一个协程

	for i:=1;i<=5;i++{
		fmt.Println("main() hello,golang! "+strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}

output：
go语言学习——9go语言学习——9

  • 主线程是一个物理线程，直接作用在cpu，是重量级的，非常耗费cpu资源
  • 协程从主线程开启，是轻量级的线程，是逻辑态，对资源消耗相对较小
  • golang的协程机制可以轻松开启上万个协程，其他编程语言的并发机制一般基于线程，开启过多线程，资源消耗大，这就凸显Golang在并发上的优势

goroutine调度模型

MPG模式
go语言学习——9MPG模式运行状态1
go语言学习——9MPG模式运行状态2
go语言学习——9

channel

前言：计算1~200各个数的阶乘，并且把各个数的阶乘放到map中。显示出来。用goroutine完成

  • 用goroutine完成，效率高，会出现并发/并行安全问题
  • 不同goroutine如何通信？

尝试的解决方案：

package main

import (
	"fmt"
	"time"
)

var (
	myMap=make(map[int]int,10)
)

//计算阶乘
func test(n int){
	res:=1
	for i:=1;i<=n;i++{
		res*=i
	}

	myMap[n]=res
}

func main()  {
	for i:=1;i<=200;i++{
		go test(i)
	}

	time.Sleep(time.Second*10)

	for i,v:=range myMap{
		fmt.Printf("map[%d]=%d\n",i,v)
	}
}

go语言学习——9运行结果：
go语言学习——9
不同goroutine如何通信
1、全局变量的互斥锁
2、使用管道channel来解决

使用全局变量加锁同步改进程序

未对全局变量m加锁，会出现资源争夺问题，代码报错，提示concurrent map writes

解决方案：加入互斥锁

tips：阶乘很大，结果可能越界，可改为sum+=unint64(i)

改进后代码：

package main

import (
	"fmt"
	"sync"
	"time"
)

var (
	myMap=make(map[int]int,10)
//	声明一个全局互斥锁
//lock是一个全局变量互斥锁
//sync是包：synchornized同步
//Mutex：互斥
	lock sync.Mutex
)

//计算阶乘
func test(n int){
	res:=1
	for i:=1;i<=n;i++{
		res*=i
	}

	lock.Lock()
	myMap[n]=res
	lock.Unlock()
}

func main()  {
	for i:=1;i<=200;i++{
		go test(i)
	}

	time.Sleep(time.Second*10)

	lock.Lock()
	for i,v:=range myMap{
		fmt.Printf("map[%d]=%d\n",i,v)
	}
	lock.Unlock()
}

运行结果：
go语言学习——9
为什么需要channel？

  • 使用全局变量加锁同步来解决goroutine通讯，不利于多个协程对全局变量的读写操作
  • 主线程等待所有goroutine全部完成的时间很难确定
  • 主线程休眠时间长，会加长等待时间，等待时间短，goroutine可能处于工作状态，会随着主线程的退出而消亡
  • 引出新的通讯机制-channel

channel介绍

  • 本质是一个数据结构-队列
  • go语言学习——9
  • 数据先进先出FIFO
  • 线程安全，多goroutine访问，不需要加锁
  • 多类型，一个string的channel只能存放string类型

定义/声明channel

  • var 变量名 chan 数据类型
  • var intChan chan int
  • var mapChan chan map[int]string
  • 注：channel是引用类型，必须初始化才能写入数据，即make之后才能使用
package main

import "fmt"

func main(){

	var intChan chan int
	intChan=make(chan int,3)

	fmt.Printf("intchan 的值=%v  intchan地址=%p\n",intChan,&intChan)

//	写入数据
	intChan<- 10
	num:=211
	intChan<- num
	intChan<- 50
//	不要超过容量
	fmt.Printf("channel len=%v cap=%v\n",len(intChan),cap(intChan))

//	读数据
	var num2 int
	num2=<- intChan
	fmt.Println("num2=",num2)
	fmt.Printf("channel len=%v cap=%v\n",len(intChan),cap(intChan))

//	没有使用协程的情况下，如果channel数据已经全部取出，再取就会报错
	num3:=<- intChan
	num4:=<- intChan
	num5:=<- intChan
	fmt.Println(",num3=",num3,",num4=",num4,",num5=",num5)

}

go语言学习——9令num5=0之后：
go语言学习——9

  • channel数据放满后，不能再放入
  • channel数据取出后，可以再放数据
  • 没有使用协程的情况下，channel数据取完了，再取，就会报dead lock

examples：

package main

import "fmt"

type Cat struct {
	Name string
	Age int
}

func main(){
	var mapChan chan map[string]string
	mapChan=make(chan map[string]string,10)
	m1:=make(map[string]string,20)
	m1["city1"]="北京"
	m1["city2"]="天津"

	m2:=make(map[string]string,20)
	m2["hero1"]="ldh"
	m2["hero2"]="glt"

	mapChan<- m1
	mapChan<- m2

	var catChan chan Cat
	catChan=make(chan Cat,10)
	cat1:=Cat{"tom",10}
	cat2:=Cat{"jarry",5}
	catChan<- cat1
	catChan<- cat2

	cat11:=<- catChan
	cat22:=<- catChan
	fmt.Println("cat11,cat22:",cat11,cat22)

	var catChan2 chan  *Cat
	catChan2=make(chan *Cat,10)
	catChan2<- &cat1
	catChan2<- &cat2

	cat111:=<- catChan2
	cat222:=<- catChan2
	fmt.Println("cat111,cat222:",cat111,cat222)

//	任意类型数据
	var allChan chan interface{}
	allChan=make(chan interface{},10)
	allChan<- cat1
	allChan<- cat2
	allChan<- 10
	allChan<- m1

	catt:=<- allChan
	fmt.Println("catt=",catt)
	//fmt.Println("catt.name:",catt.Name)//error: catt.Name undefined (type interface{} has no field or method Name)
	//使用类型断言
	cattt:=catt.(Cat)
	fmt.Println("cattt.name:",cattt.Name)
}

go语言学习——9

channel的关闭

  • 使用内置函数close可以关闭channel，当channel关闭后，就不能再向channel写数据，但还可以从该channel读数据
package main

import "fmt"

func main() {
	intChan :=make(chan int,10)
	intChan<- 1
	intChan<- 2
	intChan<- 3
	close(intChan)
	//intChan<- 4//报错：panic: send on closed channel
	n1:=<- intChan
	fmt.Println("n1:",n1)
	//输出：n1: 1
}

channel遍历

  • 支持for-range遍历
  • 遍历时，如果channel没有关闭，出现deadlock错误
  • 遍历时，如果channel已经关闭，会正常遍历数据
package main

import "fmt"

func main() {
	intChan :=make(chan int,20)
	for i:=0;i<20;i++{
		intChan<- i
	}
	close(intChan)
	for v:=range intChan{
		fmt.Println("v=",v)
	}
}

//输出：
//v= 0
//v= 1
//v= 2
//v= 3
//v= 4
//v= 5
//v= 6
//v= 7
//v= 8
//v= 9
//v= 10
//v= 11
//v= 12
//v= 13
//v= 14
//v= 15
//v= 16
//v= 17
//v= 18
//v= 19

案例：
go语言学习——9go语言学习——9

package main

import "fmt"

func writeData(intChan chan int){
	for i:=1;i<=50;i++{
		intChan<- i
		fmt.Println("writeData:",i)
	}
	close(intChan)
}

func readData(intChan chan int,exitChan chan bool)  {
	for{
		v,ok:=<- intChan
		if !ok{
			break
		}
		fmt.Println("readDate:",v)
	}

	exitChan<- true
	close(exitChan)
}

func main() {
	intChan :=make(chan int,50)
	exitChan:=make(chan bool,1)

	go writeData(intChan)
	go readData(intChan,exitChan)

	for{
		_,ok:=<- exitChan
		if !ok{
			break
		}
	}
}

writeData: 1
writeData: 2
writeData: 3
writeData: 4
writeData: 5
writeData: 6
writeData: 7
writeData: 8
writeData: 9
writeData: 10
writeData: 11
writeData: 12
writeData: 13
writeData: 14
writeData: 15
writeData: 16
writeData: 17
writeData: 18
writeData: 19
writeData: 20
writeData: 21
writeData: 22
writeData: 23
writeData: 24
writeData: 25
writeData: 26
writeData: 27
writeData: 28
writeData: 29
writeData: 30
writeData: 31
writeData: 32
writeData: 33
writeData: 34
writeData: 35
writeData: 36
writeData: 37
writeData: 38
writeData: 39
writeData: 40
writeData: 41
writeData: 42
writeData: 43
writeData: 44
writeData: 45
writeData: 46
writeData: 47
writeData: 48
writeData: 49
writeData: 50
readDate: 1
readDate: 2
readDate: 3
readDate: 4
readDate: 5
readDate: 6
readDate: 7
readDate: 8
readDate: 9
readDate: 10
readDate: 11
readDate: 12
readDate: 13
readDate: 14
readDate: 15
readDate: 16
readDate: 17
readDate: 18
readDate: 19
readDate: 20
readDate: 21
readDate: 22
readDate: 23
readDate: 24
readDate: 25
readDate: 26
readDate: 27
readDate: 28
readDate: 29
readDate: 30
readDate: 31
readDate: 32
readDate: 33
readDate: 34
readDate: 35
readDate: 36
readDate: 37
readDate: 38
readDate: 39
readDate: 40
readDate: 41
readDate: 42
readDate: 43
readDate: 44
readDate: 45
readDate: 46
readDate: 47
readDate: 48
readDate: 49
readDate: 50

Process finished with exit code 0

案例：开头的例子
统计1~8000的数字中哪些是素数

go语言学习——9

package main

import (
	"fmt"
	"time"
)

func putNum(intChan chan int){
	for i:=1;i<=8000;i++{
		intChan<- i
	}
	close(intChan)
}

//从intChan取出数据，并判断是否为素数，是，就放入primeChan
func primeNum(intChan chan int,primeChan chan int,exitChan chan bool){
	var flag bool
	for{
		time.Sleep(time.Millisecond*10)
		num,ok:=<- intChan
		if !ok{
			break
		}
		flag=true
		for i:=2;i<num;i++{
			if num%i==0{
				flag=false
				break
			}
		}

		if flag{
			primeChan<- num
		}
	}

	fmt.Println("有一个primeNum协程因为取不到数据，退出")

	exitChan<- true
}

func main(){
	intChan:=make(chan int,1000)
	primeChan:=make(chan int,2000)
	exitChan:=make(chan bool,4)
	//开启一个协程，向intChan放入1~8000个数
	go putNum(intChan)

	//开启4个协程，从intChan取出数据，并判断是否为素数，如果是，就放到primeChan
	for i:=0;i<4;i++{
		go primeNum(intChan,primeChan,exitChan)
	}

	//这里是主线程，直接进行处理
	go func() {
		for i:=0;i<4;i++{
			<- exitChan
		}
	//	当从exitChan中取出4个结果，就可以放心关闭primeChan
		close(primeChan)
	}()

	//遍历primeChan，取出结果
	for{
		res,ok:=<- primeChan
		if !ok{
			break
		}
		fmt.Printf("素数=%d\n",res)
	}

	fmt.Println("main线程退出")
}

go语言学习——9

channel其他细节

  • channel可以声明只读或只写
  • select可解决从管道取数据阻塞的问题
    go语言学习——9 
//默认，管道是双向
var chan1 chan int
//只写
var chan2 chan<- int
//只读
var chan1 <-chan int

go语言学习——9go语言学习——9go语言学习——9文章来源地址https://www.toymoban.com/news/detail-478581.html

到了这里，关于go语言学习——9的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • go语言学习——9

    go语言学习——9

    前言：统计1~90000000数字中，哪些是素数？ 使用循环，很慢 使用并发或者并行的方式，将任务分配给多个goroutine去完成，就会使用到goroutine 进程和线程 进程 是程序在操作系统中的一次执行过程，是 系统进行资源分配和调度 的基本单位 线程 是进程的一个执行实例，是 程序

    2024年02月08日
    浏览(44)
  • Go语言学习笔记（三）

    Go语言学习笔记（三）

    教程：文档 - Go 编程语言 (studygolang.com) 在call-module-code需要注意，需要在hello目录下操作 这是一个在Go项目的模块管理中的命令。在Go的模块管理工具（ go mod ）中，这个命令用于修改模块依赖关系。 具体来说， go mod edit -replace example.com/greetings=../greetings  这个命令的作用是：

    2024年02月02日
    浏览(48)
  • go语言学习笔记1

    go语言学习笔记1

    ​ GoLang是一种静态强类型、编译型、并发型，并具有 垃圾回收 功能的编程语言；它可以在不损失应用程序性能的情况下极大的降低代码的复杂性，还可以发挥多核处理器同步多工的优点，并可解决面向对象程序设计的麻烦，并帮助程序设计师处理琐碎但重要的内存管理问题

    2024年02月12日
    浏览(50)
  • Go语言学习笔记（二）

    Go语言学习笔记（二）

    以下是一些推荐的Go语言学习资源的链接： Go语言教程：https://golang.org/doc/ Go by Example：Go by Example Golang Tutorials：https://golangtutorials.com/ Go语言第一课（慕课网）：PHP模糊查询技术案例视频教程-慕课网 Go语言进阶教程（实验楼）：极客企业版 Go语言高级编程（GitBook）：谁是凶手

    2024年01月20日
    浏览(52)
  • Go语言学习笔记（狂神说）

    Go语言学习笔记（狂神说）

    视频地址：https://www.bilibili.com/video/BV1ae41157o9 聊聊Go语言的历史-KuangStudy-文章 下面列举的是原生使用Go语言进行开发的部分项目。 Docker Docker 是一种操作系统层面的虚拟化技术，可以在操作系统和应用程序之间进行隔离，也可以称之为容器。Docker 可以在一台物理服务器上快速

    2024年02月15日
    浏览(45)

  • go语言学习_incomplete

    rust没咋整明白，再来了解下go语言基础知识，参考资料为菜鸟教程以及go程序设计语言。go语言与google关系匪浅，且发明人之一还是c语言的发明人之一，可以说是很神奇了。 go和cargo的编译命令挺像，也有build和run 关于函数大括号，go似乎更严格，虽然rust有标准风格，但括号不

    2024年02月11日
    浏览(40)
  • Go语言学习Day1：什么是Go？

    Go语言学习Day1：什么是Go？

    名人说：莫道桑榆晚，为霞尚满天。——刘禹锡（刘梦得，诗豪） 创作者：Code_流苏(CSDN) （一个喜欢古诗词和编程的Coder😊） 1、走近Go ①Go语言的Logo Go语言，通常被称为Golang，是一种高效、静态类型的编程语言，旨在简化多核心、网络编程及大型软件项目的开发。Go语言的

    2024年03月22日
    浏览(42)

  • go语言--区块链学习（一）

    温馨跳转链接：模块二：go语言–区块链学习（二）-CSDN博客 1.1 密码介绍 1.1.1 为什么要加密 ？ 保护隐私和数据安全：在信息传输过程中，不加密的数据可以被未经授权的人员截获和查看，这可能导致个人隐私泄露、商业机密被窃取或者敏感数据被篡改。通过加密数据，可以

    2024年01月21日
    浏览(43)
  • Go学习圣经：Go语言实现高并发CRUD业务开发

    Go学习圣经：Go语言实现高并发CRUD业务开发

    现在 拿到offer超级难 ，甚至连面试电话，一个都搞不到。 尼恩的技术社群中（50+），很多小伙伴凭借 “左手云原生+右手大数据”的绝活，拿到了offer，并且是非常优质的offer， 据说年终奖都足足18个月 。 第二个案例就是：前段时间，一个2年小伙伴希望涨薪到18K， 尼恩把

    2024年02月11日
    浏览(53)
  • 【Golang】一篇文章带你快速了解Go语言&为什么你要学习Go语言

    【Golang】一篇文章带你快速了解Go语言&为什么你要学习Go语言

    目录 1. 为什么互联网世界需要Go语言 1.1 硬件限制：摩尔定律已然失效  1.2 Go语言为并发而生 1.3 Go性能强悍 1.4 Go语言简单易学 1.4.1 语法简洁 1.4.2 代码风格统一 1.4.3开发效率高  2.Go语言的诞生与发展 2.1什么是Go语言   2.2 Go语言的诞生 2.3 Go Gopher——Go语言的吉祥物 3. 为什么

    2024年02月04日
    浏览(67)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包