Go List使用踩坑

Go List使用踩坑

简介

最近在写项目时，遇到了一个因为不小心将*List写成了List出现的潜在bug

在一开始定义的这个结构体中包含了一个list.List对象而不是指针

type SegmentedLRU struct {
	data                       map[uint64]*list.Element
	stageOneCap, stageTwoCap   uint64
	stageOneList, stageTwoList list.List
}

因为这个操作我们后续对list对象的一些操作可能会造成非常多的问题，尽管go语言提供了一个隐式取指针，但是仍然存在问题，关于隐式取指针这里不过多介绍了。

这里我通过以下方式进行初始化

func NewSegmentedLRU(data map[uint64]*list.Element, stageOneCap, stageTwoCap uint64) *SegmentedLRU {
	return &SegmentedLRU{
		data:         data,
		stageOneCap:  stageOneCap,
		stageTwoCap:  stageTwoCap,
		stageOneList: *list.New(),
		stageTwoList: *list.New(),
	}
}

这个操作仅仅只是将List对象拷贝了一份到这个结构体的stageOneList,stageTwoList中，接下来我们聊一聊bug出现在哪里

func (lru *SegmentedLRU) String() string {
	var s string
	fmt.Printf("stageOneList len : %d", lru.stageOneList.Len())
	for e := lru.stageOneList.Front(); e != nil; e = e.Next() {
		s += fmt.Sprintf("%v,", e.Value.(*storeItem).Value)
	}

	s += "|"
	fmt.Printf("stageTwoList len : %d", lru.stageTwoList.Len())

	for e := lru.stageTwoList.Front(); e != nil; e = e.Next() {
		s += fmt.Sprintf("%v,", e.Value.(*storeItem).Value)
	}

	return s
}

在这个方法中我们的循环不会立刻停下来，即便后续没有元素了，e = e.Next()后会出现e仍然不为nil,但是e.Value是nil的特殊情况,如此一来e.Value.(*storeItem).Value这段代码就会报错，在查看了list包的源码后我明白了到底是为什么

ist源码中的相关定义:

// Element is an element of a linked list.
type Element struct {
	// Next and previous pointers in the doubly-linked list of elements.
	// To simplify the implementation, internally a list l is implemented
	// as a ring, such that &l.root is both the next element of the last
	// list element (l.Back()) and the previous element of the first list
	// element (l.Front()).
	next, prev *Element

	// The list to which this element belongs.
	list *List

	// The value stored with this element.
	Value any
}

// Next returns the next list element or nil.
func (e *Element) Next() *Element {
	if p := e.next; e.list != nil &&   {
		return p
	}
	return nil
}


// List represents a doubly linked list.
// The zero value for List is an empty list ready to use.
type List struct {
	root Element // sentinel list element, only &root, root.prev, and root.next are used
	len  int     // current list length excluding (this) sentinel element
}

注意: List中root是Element对象，而Element中prev,next则是*Element指针，Element中还有一个 *List指针

在之前我们list.New()出两个List指针后解引用赋值给了我们的stageOneList、stageTwoList字段了，很明显这是一个拷贝List对象的操作，如此操作之后整体的结构就变成了这样

注意到Next()方法中判断循环结束是依靠p != &e.list.root 来实现的，因此我们通过Next()来遍历List时会多出来一个e 不为nil但是Value为nil的特殊对象，到这里这个bug就已经非常清楚了，我们只需要将原本的List对象改为*List对象就可以解决了

type SegmentedLRU struct {
	data                       map[uint64]*list.Element
	stageOneCap, stageTwoCap   uint64
	stageOneList, stageTwoList list.List
}