go-datastructures 使用指南

go-datastructures 是一个高性能的线程安全数据结构集合库，提供了多种实用的数据结构实现。下面我将介绍其主要数据结构及使用方法。

主要数据结构

1. 线程安全集合 (Set)

import (
	"github.com/Workiva/go-datastructures/set"
	"fmt"
)

func main() {
	// 创建线程安全集合
	s := set.New()

	// 添加元素
	s.Add("a")
	s.Add("b")
	s.Add("c")

	// 检查元素是否存在
	if s.Exists("a") {
		fmt.Println("a exists in set")
	}

	// 删除元素
	s.Remove("b")

	// 获取集合长度
	fmt.Println("Set size:", s.Len())

	// 遍历集合
	for item := range s.Iter() {
		fmt.Println(item)
	}
}

2. 线程安全队列 (Queue)

import (
	"github.com/Workiva/go-datastructures/queue"
	"fmt"
)

func main() {
	// 创建队列
	q := queue.New(10) // 10是初始容量

	// 入队
	q.Put("item1")
	q.Put("item2")
	q.Put("item3")

	// 出队
	item, err := q.Get()
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Got:", item)
	}

	// 获取队列长度
	fmt.Println("Queue size:", q.Len())

	// 带超时的出队操作
	item, err = q.GetUntil(1 * time.Second) // 等待1秒
	if err != nil {
		fmt.Println("Timeout:", err)
	}
}

3. 线程安全环形缓冲区 (RingBuffer)

import (
	"github.com/Workiva/go-datastructures/queue"
	"fmt"
)

func main() {
	// 创建容量为5的环形缓冲区
	rb := queue.NewRingBuffer(5)

	// 添加元素
	for i := 0; i < 7; i++ {
		if err := rb.Put(i); err != nil {
			fmt.Println("Error putting:", err)
		}
	}

	// 获取元素
	for i := 0; i < 5; i++ {
		item, err := rb.Get()
		if err != nil {
			fmt.Println("Error getting:", err)
		} else {
			fmt.Println("Got:", item)
		}
	}
}

4. 线程安全优先队列 (PriorityQueue)

import (
	"github.com/Workiva/go-datastructures/queue"
	"fmt"
)

func main() {
	// 创建优先队列
	pq := queue.NewPriorityQueue(10, false)

	// 添加带优先级的项目
	pq.Put(queue.NewItem("high", 1))
	pq.Put(queue.NewItem("medium", 5))
	pq.Put(queue.NewItem("low", 10))

	// 获取优先级最高的项目
	item, err := pq.Get()
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Highest priority:", item.Value(), "with priority", item.Priority())
	}
}

5. 线程安全跳表 (SkipList)

import (
	"github.com/Workiva/go-datastructures/slice/skip"
	"fmt"
)

func main() {
	// 创建跳表
	sl := skip.New(uint64(0))

	// 插入元素
	sl.Insert(5, "five")
	sl.Insert(3, "three")
	sl.Insert(7, "seven")

	// 查找元素
	value, exists := sl.Get(5)
	if exists {
		fmt.Println("Found:", value)
	}

	// 删除元素
	sl.Delete(3)

	// 遍历跳表
	iter := sl.Iter()
	for iter.Next() {
		fmt.Println("Key:", iter.Key(), "Value:", iter.Value())
	}
}

高级用法

1. 使用 Futures 进行异步操作

import (
	"github.com/Workiva/go-datastructures/futures"
	"time"
	"fmt"
)

func main() {
	// 创建Future
	f := futures.New()

	// 异步设置结果
	go func() {
		time.Sleep(1 * time.Second)
		f.SetResult("result")
	}()

	// 获取结果(阻塞)
	result, err := f.Get()
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Result:", result)
	}

	// 带超时的获取
	result, err = f.GetUntil(500 * time.Millisecond)
	if err != nil {
		fmt.Println("Timeout:", err)
	}
}

2. 使用 BitArray 进行位操作

import (
	"github.com/Workiva/go-datastructures/bitarray"
	"fmt"
)

func main() {
	// 创建位数组
	ba := bitarray.NewBitArray(100)

	// 设置位
	ba.SetBit(5)
	ba.SetBit(10)
	ba.SetBit(15)

	// 检查位
	if ba.GetBit(5) {
		fmt.Println("Bit 5 is set")
	}

	// 清除位
	ba.ClearBit(10)

	// 统计设置位的数量
	fmt.Println("Number of set bits:", ba.ToNums()[0])
}

性能优化建议

1. 根据场景选择合适的数据结构：

   • 频繁插入/删除：使用跳表(SkipList)
   • 优先级处理：优先队列(PriorityQueue)
   • 固定大小缓冲区：环形缓冲区(RingBuffer)

2. 合理设置初始容量，避免频繁扩容

3. 对于读多写少的场景，考虑使用 sync.RWMutex 封装的数据结构

4. 批量操作时尽量使用提供的批量方法

go-datastructures 提供了多种高性能线程安全数据结构，能够满足不同场景下的需求。选择合适的数据结构可以显著提升程序性能。