golang中slice扩容机制

 golang中的slice属性中，包含容量和长度。长度即slice中的元素个数。容量为slice对应底层数组的长度。往往我们在使用切片时，有扩容的需求，那么，slice是底层扩容是如何的呢？
 在源码/go/src/runtime/slice.go中我们可以看到：

// growslice handles slice growth during append.
// It is passed the slice element type, the old slice, and the desired new minimum capacity,
// and it returns a new slice with at least that capacity, with the old data
// copied into it.
// The new slice's length is set to the old slice's length,
// NOT to the new requested capacity.
// This is for codegen convenience. The old slice's length is used immediately
// to calculate where to write new values during an append.
// TODO: When the old backend is gone, reconsider this decision.
// The SSA backend might prefer the new length or to return only ptr/cap and save stack space.
func growslice(et *_type, old slice, cap int) slice {
	if raceenabled {
		callerpc := getcallerpc()
		racereadrangepc(old.array, uintptr(old.len*int(et.size)), callerpc, funcPC(growslice))
	}
	if msanenabled {
		msanread(old.array, uintptr(old.len*int(et.size)))
	}

	if cap < old.cap {
		panic(errorString("growslice: cap out of range"))
	}

	if et.size == 0 {
		// append should not create a slice with nil pointer but non-zero len.
		// We assume that append doesn't need to preserve old.array in this case.
		return slice{unsafe.Pointer(&zerobase), old.len, cap}
	}

	newcap := old.cap
	doublecap := newcap + newcap
	if cap > doublecap {
		newcap = cap
	} else {
		if old.len < 1024 {
			newcap = doublecap
		} else {
			// Check 0 < newcap to detect overflow
			// and prevent an infinite loop.
			for 0 < newcap && newcap < cap {
				newcap += newcap / 4
			}
			// Set newcap to the requested cap when
			// the newcap calculation overflowed.
			if newcap <= 0 {
				newcap = cap
			}
		}
	}
	......
	return slice{p, old.len, newcap}
}

结论

• 如果申请扩容的容量(cap)大于旧的容量的二倍，则直接扩容cap为最新的容量(newcap)
• 如果所需容量不是旧的容量的二倍：
  1.如果旧的silice的长度(len)小于1024，则申请容量为旧的容量的二倍。
  2.如果旧的slice长度(len)大于1024，newcap则每次以1/4旧的cap累加，直到newcap大于所需容量。最后再判断newcap是否溢出，如果溢出，则newcap等于所需容量。