gtype

并发安全的基本类型。

使用场景

gtype使用得非常频繁,任何需要并发安全的场景下都适用。
在普通的并发安全场景中,一个基本类型的变量,特别是一个struct的属性,往往使用一把(读写)锁或者多把(读写)锁来进行管理。
但是在这样的使用中,变量/struct/属性的操作性能十分低下,且由于锁机制的存在往往使得操作变得相当复杂,必须小心翼翼地维护好变量/属性的并发安全性(特别是使用到的(RW)Mutex)。

gtype针对于最常用的基本数据类型,提供了对应的并发安全数据类型,便于在并发安全场景下更好地维护变量/属性,开发者无需在struct中再创建和维护繁琐的(RW)Mutex。且gtype内部绝大多数基本类型都使用了atomic原子操作来维护并发安全性,因此效率会比(RW)Mutex互斥锁高出数十倍。

使用方式

  1. import "gitee.com/johng/gf/g/container/gtype"

方法列表godoc.org/github.com/johng-cn/gf/g/container/gtype

由于gtype模块下的基本类型比较多,这里便不一一列举。任何并发安全的基本类型,可以使用 gtype.New* 方法来创建。

性能测试

测试环境

  1. CPU: Intel(R) Core(TM) i5-4460 CPU @ 3.20GHz
  2. MEM: 8GB
  3. SYS: Ubuntu 16.04 amd64

测试结果

基准测试结果如下:

  1. john@john-B85M:~/Workspace/Go/GOPATH/src/gitee.com/johng/gf/g/container/gtype$ go test -bench=".*" -benchmem
  2. goos: linux
  3. goarch: amd64
  4. pkg: gitee.com/johng/gf/g/container/gtype
  5. BenchmarkInt_Set-4 300000000 5.87 ns/op 0 B/op 0 allocs/op
  6. BenchmarkInt_Val-4 2000000000 0.46 ns/op 0 B/op 0 allocs/op
  7. BenchmarkInt_Add-4 300000000 5.86 ns/op 0 B/op 0 allocs/op
  8. BenchmarkInt32_Set-4 300000000 5.87 ns/op 0 B/op 0 allocs/op
  9. BenchmarkInt32_Val-4 2000000000 0.47 ns/op 0 B/op 0 allocs/op
  10. BenchmarkInt32_Add-4 300000000 5.85 ns/op 0 B/op 0 allocs/op
  11. BenchmarkInt64_Set-4 300000000 5.88 ns/op 0 B/op 0 allocs/op
  12. BenchmarkInt64_Val-4 2000000000 0.46 ns/op 0 B/op 0 allocs/op
  13. BenchmarkInt64_Add-4 300000000 5.88 ns/op 0 B/op 0 allocs/op
  14. BenchmarkUint_Set-4 300000000 5.88 ns/op 0 B/op 0 allocs/op
  15. BenchmarkUint_Val-4 2000000000 0.46 ns/op 0 B/op 0 allocs/op
  16. BenchmarkUint_Add-4 300000000 5.87 ns/op 0 B/op 0 allocs/op
  17. BenchmarkUint32_Set-4 300000000 5.86 ns/op 0 B/op 0 allocs/op
  18. BenchmarkUint32_Val-4 2000000000 0.50 ns/op 0 B/op 0 allocs/op
  19. BenchmarkUint32_Add-4 200000000 5.86 ns/op 0 B/op 0 allocs/op
  20. BenchmarkUint64_Set-4 300000000 5.86 ns/op 0 B/op 0 allocs/op
  21. BenchmarkUint64_Val-4 2000000000 0.47 ns/op 0 B/op 0 allocs/op
  22. BenchmarkUint64_Add-4 300000000 5.85 ns/op 0 B/op 0 allocs/op
  23. BenchmarkBool_Set-4 300000000 5.85 ns/op 0 B/op 0 allocs/op
  24. BenchmarkBool_Val-4 2000000000 0.46 ns/op 0 B/op 0 allocs/op
  25. BenchmarkString_Set-4 20000000 90.1 ns/op 23 B/op 1 allocs/op
  26. BenchmarkString_Val-4 2000000000 1.58 ns/op 0 B/op 0 allocs/op
  27. BenchmarkBytes_Set-4 20000000 76.2 ns/op 35 B/op 2 allocs/op
  28. BenchmarkBytes_Val-4 2000000000 1.58 ns/op 0 B/op 0 allocs/op
  29. BenchmarkInterface_Set-4 50000000 30.7 ns/op 8 B/op 0 allocs/op
  30. BenchmarkInterface_Val-4 2000000000 0.74 ns/op 0 B/op 0 allocs/op
  31. BenchmarkAtomicValue_Store-4 50000000 27.3 ns/op 8 B/op 0 allocs/op
  32. BenchmarkAtomicValue_Load-4 2000000000 0.73 ns/op 0 B/op 0 allocs/op
  33. PASS
  34. ok gitee.com/johng/gf/g/container/gtype 49.454s

使用示例

gtype并发安全基本类型的使用非常简单,往往就以下几个方法(以gtype.Int类型举例):

  1. // 创建并发安全基本类型对象
  2. func NewInt(value...int) *Int
  3. // 克隆一个对象
  4. func (t *Int) Clone() *Int
  5. // 设置值
  6. func (t *Int) Set(value int)
  7. // 获取值
  8. func (t *Int) Val() int
  9. // (整型/浮点型有效)数值 增加/删除 delta
  10. func (t *Int) Add(delta int) int {

基本使用示例:

  1. package main
  2. import (
  3. "gitee.com/johng/gf/g/container/gtype"
  4. "fmt"
  5. )
  6. func main() {
  7. // 创建一个Int型的并发安全基本类型对象
  8. i := gtype.NewInt()
  9. // 设置值
  10. i.Set(10)
  11. // 获取值
  12. fmt.Println(i.Val())
  13. // 数值-1,并返回修改之后的数值
  14. fmt.Println(i.Add(-1))
  15. }

执行后,输出结果为:

  1. 10
  2. 9