golang学习之go并发编程内置库

已于 2022-09-25 14:53:13 修改
阅读量366 收藏
点赞数
文章标签： golang 学习 java
于 2022-09-18 09:24:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56349119/article/details/126807099
版权

文章目录

go

go 关键字用来开启一个协程

package main

import "time"

type myDate struct {
	count int
}

func (d *myDate) add() {
	d.count++
}

func (d *myDate) read() {
	println(d.count)
}

func main() {
	d := myDate{}
	for i := 0; i < 1000; i++ {
		// 开启1000个协程分别对count加1
		go d.add()
	}
	// 主协程等待3秒，让1000个子协程执行完
	time.Sleep(3 * time.Second)
	d.read()//打印结果986与预期不一致
}

sync.WaitGroup

让主协程睡眠等待有所不妥，可以使用sync.WaitGroup。sync.WaitGroup有三个方法： Add()设置等待值、 Done()等待值减一、 Wait()检查等待值是否为0，为0立即返回，否则阻塞当前协程。

package main

import (
	"sync"
)

type myDate struct {
	count int
}

// 传入指针类型否则将是一个新的wg
func (d *myDate) add(wg *sync.WaitGroup) {
	d.count++
	// 等待值减一
	wg.Done()
}

func (d *myDate) read() {
	println(d.count)
}

func main() {
	var wg sync.WaitGroup
	// 设置等待值1000
	wg.Add(1000)
	d := myDate{}
	for i := 0; i < 1000; i++ {
		// 开启1000个协程分别对count加1
		go d.add(&wg)
	}
	// 主协程检查等待值是否为0（1000个子协程执行完），如果是0则继续往下执行，否则阻塞当前协程
	wg.Wait()
	d.read() //打印结果986与预期不一致
}

sync.Mutex

互斥锁的零值表示未上锁。为防止出现异常现象上锁、解锁需成对出现。互斥锁的重复上锁操作会阻塞当前协程。互斥锁的重复解锁会出现恐慌。解锁一个未上锁的写锁会引起恐慌，解锁一个未上锁的读锁不会引起恐慌。

package main

import (
	"sync"
)

type myDate struct {
	count int
	sync.Mutex
}

func (d *myDate) add(wg *sync.WaitGroup) {
	d.Lock()         //上锁
	defer d.Unlock() //解锁
	d.count++
	wg.Done()
}

func (d *myDate) read() {
	d.Lock()         //上锁
	defer d.Unlock() //解锁
	println(d.count)
}

func main() {
	var wg sync.WaitGroup
	// 设置等待值1000
	wg.Add(1000)
	d := myDate{}
	for i := 0; i < 1000; i++ {
		// 开启1000个协程分别对count加1
		go d.add(&wg)
	}
	// 主协程检查等待值是否为0（1000个子协程执行完），如果是0则继续往下执行，否则阻塞当前协程
	wg.Wait()
	d.read() //打印1000
}

sync.RWMutex

读写锁可以分别对读、写操作进行上锁解锁。被读锁锁定的资源允许同时有多个读操作，但同时只能有一个写操作。

package main

import (
	"sync"
)

type myDate struct {
	count int
	sync.RWMutex
}

func (d *myDate) add(wg *sync.WaitGroup) {
	d.Lock()         //写操作上锁
	defer d.Unlock() //写操作解锁
	d.count++
	wg.Done()// 等待值减一
}

func (d *myDate) read(wg *sync.WaitGroup) {
	d.RLock()         //读操作上锁
	defer d.RUnlock() //读操作解锁
	println(d.count)
	wg.Done()// 等待值减一
}

func main() {
	var wg sync.WaitGroup
	// 设置等待值1010
	wg.Add(1010)
	d := myDate{}
	// 开启1000个协程分别对count加1
	for i := 0; i < 1000; i++ {
		go d.add(&wg)
	}
	for i := 0; i < 10; i++ {
		go d.read(&wg)
	}
	// 主协程检查等待值是否为0（1000个子协程执行完），如果是0则继续往下执行，否则阻塞当前协程
	wg.Wait()
}

sync/atomic

原子操作是由一个独立的CPU指令完成的，因此可以在并发环境下保证操作数据的安全。

package main

import (
	"sync"
	"sync/atomic"
)

type myDate struct {
	count int64
}

func (d *myDate) add(wg *sync.WaitGroup) {
	//d.count 原子加1
	atomic.AddInt64(&d.count, 1)
	// 等待值减一
	wg.Done()
}

func (d *myDate) read() {
	println(d.count)
}

func main() {
	var wg sync.WaitGroup
	wg.Add(1000)
	d := myDate{}
	for i := 0; i < 1000; i++ {
		go d.add(&wg)
	}
	wg.Wait()
	d.read()打印1000
}

sync.Once

sync.Once只有一个Do方法，该方法只会被执行一次

package main

import (
	"sync"
)

func main() {

	var one sync.Once
	var wg sync.WaitGroup
	count := 10
	wg.Add(count)

	for i := 0; i < 10; i++ {
		one.Do(func() {
			for j := 0; j < count; j++ {
				go func(i, j int) {
					// i值始终为0
					println(i, j)
					// 等待值减一
					wg.Done()
				}(i, j)
			}
		})
	}

	one.Do(func() {
		println("不打印")
	})
	wg.Wait()
}

sync.Pool

数据存储池，get获取的值是个不确定的值，有可能已被垃圾回收器回收。当获取不到数据时会调用New函数，如果没有New函数返回nil。

package main

import (
	"fmt"
	"sync"
)

func main() {

	var wg sync.WaitGroup
	wgcount := 10
	wg.Add(wgcount)

	var pool sync.Pool

	//向池中加入数据
	pool.Put(1)
	pool.Put(2)
	pool.Put(3)

	//返回并冲pool中删除数据
	fmt.Println(pool.Get())//1
	fmt.Println(pool.Get())//3
	fmt.Println(pool.Get())//2
	fmt.Println(pool.Get())//<nil>
	fmt.Println(pool.Get())//<nil>

	type user struct {
		Name string
		Age  int
	}

	u := user{Name: "tome", Age: 18}
	//向池中加入数据
	pool.Put(&u)
	//没有获取到数据时调用此函数
	pool.New = func() any {
		println("没有获取到数据时调用此函数")
		return &u
	}

	for i := 0; i < wgcount; i++ {
		go func() {
			a := pool.Get()
			if u1, ok := a.(*user); ok {
				u1.Age++
				pool.Put(&u1)
				fmt.Println(u1)
			}
			wg.Done()
		}()

	}
	wg.Wait()
	fmt.Println(u)
}

sync.Map

并发安全的map

package main

import (
	"fmt"
	"sync"
)

func main() {
	var pool sync.Map

	type user struct {
		Name string
		Age  int
	}

	//保存数据
	pool.Store("tom", user{Name: "tome", Age: 18})
	pool.Store("tim", user{Name: "tim", Age: 19})

	// 获取数据
	if u, ok := pool.Load("tom"); ok {
		fmt.Println(u)
	} else {
		println("数据不存在")
	}

	if u, ok := pool.Load("jim"); ok {
		fmt.Println(u)
	} else {
		println("数据不存在")
	}

	// 覆盖存量数据
	pool.Store("tim", user{Name: "tim", Age: 20})
	if u, ok := pool.Load("tim"); ok {
		fmt.Println(u)
	} else {
		println("数据不存在")
	}

	//删除数据
	pool.Delete("tim")
	if u, ok := pool.Load("tim"); ok {
		fmt.Println(u)
	} else {
		println("数据不存在")
	}

	actual, loaded := pool.LoadOrStore("timdd", user{Name: "tiddm", Age: 22})
	fmt.Println(actual, loaded)

	// 遍历pool
	pool.Range(func(key, value any) bool {
		fmt.Println(key, value)
		return false
	})

}

chan

chan通道，用于协程间的数据传送。 golang学习之chan

package main

import (
	"fmt"
)
// 生产者
func Producer(queue chan<- int) {
	for i := 0; i < 10; i++ {
		go func(i int) {
			queue <- i
		}(i)
	}
}

// 消费者
func Consumer(queue <-chan int) {
	for i := 0; i < 10; i++ {
		v := <-queue
		fmt.Println("消费", v)
	}
}
func main() {
	queue := make(chan int)
	Producer(queue)
	Consumer(queue)
}

sync.Cond

通过某个条件变量控制多个协程之间的协作运行。模拟实现sync.WaitGroup 主协程等待子协程完成工作：

package main
import (
	"fmt"
	"sync"
)

func main() {'
	cond := sync.NewCond(&sync.Mutex{})

	count := 10
	adder := 0

	for i := 0; i < count; i++ {
		go func(i int) {
			fmt.Println("子goroutine", i, "do something")
			cond.L.Lock()
			adder++
			cond.L.Unlock()
			cond.Broadcast()

		}(i)
	}

	cond.L.Lock()
	for adder != count {
		fmt.Println("主goroutine waiting")
		cond.Wait()
	}
	cond.L.Unlock()
	fmt.Println("done")
}

context

context可用于父子协程之间务完成情况同步信息。

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	t := 2
	// 根context
	ctx := context.Background()
	// 生成一个超时context
	ctx, cancel := context.WithTimeout(ctx, time.Duration(t)*time.Second)
	defer cancel()

	go func() {
		// 模拟子协程工作3秒
		time.Sleep(3 * time.Second)
		cancel()
	}()

	select {
	case <-ctx.Done():// 任务已结束
		fmt.Println("testWTimeout.Done:", ctx.Err())// 任务结束原因
	case e := <-time.After(time.Duration(t) * time.Second):// 任务超时
		fmt.Println("testWTimeout:", e)
	}
}
星星火光
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Golang学习笔记（一）：简介
01-21
Go语言最主要的特性 代码如下: 自动垃圾回收 更丰富的内置类型 函数多返回值 错误处理 匿名函数和闭包 类型和接口 并发编程 反射 语言交互性 高性能/高效开发 安装 安装说明 地址 http://golang.org/doc/install ...
Go语言，也被称为Golang，是由Google设计和开发的一种编程语言
10-11
发布时间： Go语言于2009年发布，并在2012年公开。 类型系统： Go语言是静态类型语言，这意味着所有的变量类型在...由于Go语言的简洁、高效和强大的并发编程能力，它被广泛用于网络编程、云服务、分布式系统等高性能
golang 实现并发
weixin_45805339的博客
07-05 490
go语言，语言层面原生支持高并发，通过关键字go与信号通道channel组合实现。实现起来还是相当容易的例如： 2 通过sync.WaitGroup 除了关键字go和channel，我们还有更简单的方法来实现，就是标准库sync中的WaitGrop WaitGroup等待一组goroutines完成。主goroutine调用Add来设置要等待的goroutine的数量。然后每个goroutines运行并在完成时调用Done。同时，Wait可以用来阻塞，直到所有goroutines完成。 WaitGroup在
【Go】扩展并发原语之errgroup.Group的实战与源码解读
TomCN0803的博客
01-31 1036
虽然提供了对错误的返回，但是只能返回所有启动的 goroutine 产生的第一个错误，如果不做额外扩展的话后面所产生的错误都会被丢弃，然而在很多时候，获取每个 goroutine 的错误情况又是很必要的。是将输入文本转化为可读 channel，后三者则分别对应了 MapReduce 的三个步骤，它们每个步骤所产生的 channel 都作为下一步操作的输入 channel，会将数据全部存于内存中，在实际生产中可能会遇到很大的文件，这时候我们就需要考虑其它的堆实现方式了，不过这不是本文的重点。
Go并发(goroutine)及并发常用模型的实现
qq_42901723的博客
08-12 118
Go 语言最吸引人的地方是它内建的并发支持。作为天然支持高并发的语言,写并发比java和python要简单方便的多.在并发编程中，对共享资源的正确访问需要精确的控制，在目前的绝大多数语言中，都是通过加锁等线程同步方案来解决这一困难问题，而 Go 语言却另辟蹊径，它将共享的值通过 Channel 传递(实际上多个独立执行的线程很少主动共享资源)。在任意给定的时刻，最好只有一个 Goroutine 能够拥有该资源。数据竞争从设计层面上就被杜绝了。
【Go语言从入门到实战】并发篇
How many ten years in the life time?
05-28 1377
并发篇：协程、共享内存并发机制、CSP并发机制（Channel）、多路选择和超时控制、channel的关闭和广播、任务的取消、Context、并发任务（单例模式、仅需任意任务完成、所有任务完成、对象池、sync.Pool 对象缓存） 另外还有单元测试的内容。
golang并发编程与系统标准库
Weirdo_
10-08 216
【代码】golang并发编程与系统标准库。
golang入门
weixin_43507224的博客
04-28 1404
1.go语言介绍 1.什么是go？ Go语言是谷歌2009发布的第二款开源编程语言。是从B语言、C语言逐步演化过来的，是C语言家族成员，因此很多人将Go语言称为21世纪的C语言。现如今Go语言已经成为云计算、云存储时代最重要的基础编程语言(摘自Go语言圣经)。 Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。 2.为什么选择go,与其它语言相比，有哪些优点 容易入手 基本语法不多，几天时间就能大概掌握 效率 Go拥有接近C的
Go 并发编程
qq_46457076的博客
01-17 559
关于 Go 语言之高性能并发编程的基础知识！
Go并发编程详解
金戈鐡馬
12-04 1287
随着硬件的发展，并发程序变得越来越重要。Web服务器会一次处理成千上万的请求。平板电脑和手机app在渲染用户画面同时还会后台执行各种计算任务和网络请求。即使是传统的批处理问题--读取数据，计算，写输出--现在也会用并发来隐藏掉I/O的操作延迟以充分利用现代计算机设备的多个核心。计算机的性能每年都在以非线性的速度增长。
Go语言并发详解
qq_41854911的博客
11-09 7246
文章目录一、Go语言并发简述（并发的优势）进程/线程并发/并行协程/线程Goroutine 介绍channel二、Go语言goroutine（轻量级线程）使用普通函数创建 goroutine1) 格式2) 例子使用匿名函数创建goroutine1) 使用匿名函数创建goroutine的格式2) 使用匿名函数创建goroutine的例子提示三、Go语言并发通信四、Go语言竞争状态简述Goroutine 7 (finished) created at: main.main() D:/code/src/m
golang常见的几种并发模型框架
聪明的狐狸
08-26 1万+
golang常见的几种并发模型。
Go（也被称为Golang）是由Google公司开发的一种静态强类型、编译型的编程语言 自2007年诞生以来，Go凭借其简洁、高
05-02
Go语言的设计初衷是为了解决大规模并发处理的问题，它内置了强大的并发原语，如goroutine（轻量级线程）和channel（通道），使得开发者可以轻松编写出高性能的并发程序。与传统的线程和进程相比，goroutine的创建和...
Kylin Go 是一款基于 Golang 的跨平台高效的编程语言，面相过程，动态脚本语言。
最新发布
05-23
并发性：Go语言内置了对并发的支持，通过轻量级的goroutine和channel机制，可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性：Go语言具有强大的类型系统和内存管理...
LetsGo:Golang 小视频教程，零散时间学习 Golang
05-02
内容包括 Golang 基础、内置库、web 开发、并发编程等，均来自笔者日常学习和开发经验总结。 教程中会有一些和 Python 等语言特性的对比，方便读者理解。希望教程有如下特色： 每一小节均包含视频和文章，演示笔者...
Go语言并发之context标准库
YIYIYI
06-15 1177
Go语言并发之context标准库
Golang适合高并发场景的原因分析
热门推荐
蝈蝈俊.net
06-01 8万+
典型的两个现实案例： 我们先看两个用Go做消息推送的案例实际处理能力。 360消息推送的数据： 16台机器，标配：24个硬件线程，64GB内存 Linux Kernel 2.6.32 x86_64 单机80万并发连接，load 0.2~0.4，CPU 总使用率 7%~10%，内存占用20GB (res) 目前接入的产品约1280万在线用户 2分钟一次GC，停顿2
Golang的并发模式
Erick Lv的笔记
08-24 1057
简介 主要学习3个在工程中常用的并发包，同时学习这些包常用的情景模式。 runner runner可以给一组任务进行顺序分配，然后进行总体的时间限制。该方式确定了任务的顺序后，可以让任务顺序执行，直到时间限制到了或者任务完成或者人为中断。本例子中同时允许使用Ctrl+C进行人工中断。 runner包源代码分析： package main import ( &amp;quot;os&amp;quot; ...
Golang百万级高并发实践
Jeanphorn的专栏
01-09 3万+
写在前面Go语言作为新兴的语言，最近发展势头很是迅猛，其最大的特点就是原生支持并发。它使用的是“协程（goroutine）模型”，和传统基于 OS 线程和进程实现不同，Go 语言的并发是基于用户态的并发，这种并发方式就变得非常轻量，能够轻松运行几万并发逻辑。Go 的并发属于 CSP 并发模型的一种实现，CSP 并发模型的核心概念是：“不要通过共享内存来通信，而应该通 过通信来共享内存”。这在 G
golang 并发编程
11-15
Golang 是一种编程语言，其设计目标之一就是支持并发编程。在 Golang 中，我们可以使用 goroutine 来实现并发操作。goroutine 可以理解为一种轻量级的线程，它可以由 Go 语言的运行时环境进行调度，并发执行。 在 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值