go锁与chan的性能对比

锁的作用

  • 解决并发安全问题,流程控制等

chan 的作用

  • 线程通信(数据传输), 并发安全,流程控制

golang的数据并不是并发安全的

  • golang的变量并不是并发安全的
  • 锁与chan都可以解决并发安全的问题,那么应该如何选择?
go 复制代码
// 锁
func LockServe(lock *sync.Mutex) {
	lock.Lock()
	defer lock.Unlock()
	//todo: 业务逻辑
	//...
}

// channel 读(单线程)
func ChanRead(ch chan struct{}) {
	for {
		<-ch
	}
}

// channel 读(多线程)
func ChanReadMulti(ch chan struct{}) {
	for i := 0; i < 100; i++ {
		go ChanRead(ch)
	}
}

// channel 写
func ChanWrite(ch chan struct{}) {
	ch <- struct{}{}
}


// 读写锁性能(单线程)
func BenchmarkLock(b *testing.B) {
	lock := &sync.Mutex{}
	//开始计时
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		LockServe(lock)
	}
		//BenchmarkLock-8         128537480                9.141 ns/op           0 B/op
}

// 读写锁性能(多线程)
func BenchmarkLockMulti(b *testing.B) {
	lock := &sync.Mutex{}
	//开始计时
	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			LockServe(lock)
		}
	})
	//BenchmarkLockMulti-8    15528596                77.23 ns/op            0 B/op
}

// channel 通信(单线程)
func BenchmarkChanRead(b *testing.B) {
	ch := make(chan struct{}, 9)
	defer close(ch)
	go ChanRead(ch)
	//开始计时
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ChanWrite(ch)
	}
	//BenchmarkChanRead-8     21222759                55.43 ns/op            0 B/op
}

// channel 通信(多线程读)
func BenchmarkChanReadMulti(b *testing.B) {
	ch := make(chan struct{}, 9)
	defer close(ch)
	go ChanReadMulti(ch)
	//开始计时
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ChanWrite(ch)
	}
	//BenchmarkChanReadMulti-8         4238251               260.1 ns/op             0
}

// channel 通信(多线程写)
func BenchmarkChanWrite(b *testing.B) {
	ch := make(chan struct{}, 1000)
	defer close(ch)
	go ChanRead(ch)
	//开始计时
	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			ChanWrite(ch)
		}
	})
	// BenchmarkChanWrite-8     5177377               299.1 ns/op             0 B/op
}

// channel 通信(多线程读写)
func BenchmarkChanReadWrite(b *testing.B) {
	ch := make(chan struct{}, 1000)
	defer close(ch)
	go ChanReadMulti(ch)
	//开始计时
	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			ChanWrite(ch)
		}
	})
	// BenchmarkChanReadWrite-8          558490              3862 ns/op               0 B/op          0 allocs/op
}

在单线程下:锁 :128537480 qps; chan: 21222759 qps

多线程下: 锁 : 15528596 qps; chan : 5177377 qps

单论性能,锁要比chan更加优秀

为什么锁的性能更加优秀?

  • 锁是原子的操作,消耗更低,性能更高
  • chan的底层有更加复杂的通信逻辑,消耗较大,在多线程情况下相差3倍

如何选择?

  • 在之需要解决并发问题或者流程控制的情况下优先考虑锁,因为性能更高
  • 如果需要线程通信 以及 数据传输使用chan
相关推荐
学长毕设2 小时前
基于SpringBoot的儿童慈善捐赠管理系统-附源码
java·spring boot·后端
ComPDFKit2 小时前
RAG 回答只显示 PDF 文件名?用 Python 保留引用页码
开发语言·python·pdf·rag
FRing032 小时前
vue3干货总结2(vue3生命周期、父子通信、模版引用、provide和inject)
开发语言·前端·vue.js·vue3
皮皮林5512 小时前
GitHub Copilot:你可以暂时不用,但别不知道它有多强
后端
学长毕设3 小时前
基于SpringBoot非遗文化展示与传播平台设计与实现-附源码
java·spring boot·后端
杨凯凡4 小时前
Spring Boot SSE 上线后不实时、频繁断线?Nginx 缓冲、心跳与连接回收实战
spring boot·后端·nginx
锋行天下4 小时前
langgraph 全栈项目(三)
前端·人工智能·后端
金銀銅鐵4 小时前
用 Swing 重做操作数栈演示
java·jvm·后端
琳少_4 小时前
java程序开发笔记
java·开发语言·数据库·笔记
锋行天下5 小时前
langgraph 全栈项目(二)
前端·人工智能·后端