1.1. 固定长度Queue

List列表是一种非连续存储的容器，由多个节点组成，节点通过一些变量记录彼此之间的关系。列表有多种实现方法，如单链表、双链表等。

1.2. 简单示例

package main

import (
    "container/list"
    "fmt"
)

func main() {
    nums := list.New()
    nums.PushBack(1)
    nums.PushBack(2)
    nums.PushBack(3)
    for e := nums.Front(); e != nil; e = e.Next() {
        fmt.Println(e.Value)
    }
}

1.2.1. 使用

// 追加新元素到末尾，返回该元素指针
func (l *List) PushBack(v interface{}) *Element
// 追加另一个列表到末尾
func (l *List) PushBackList(other *List)
// 添加新元素到开头，返回该元素指针
func (l *List) PushFront(v interface{}) *Element
// 添加另一个列表到开头
func (l *List) PushFrontList(other *List)
// 在mark后面插入新元素，返回新元素指针
func (l *List) InsertAfter(v interface{}, mark *Element) *Element
// 在mark前插入新元素，返回新元素指针
func (l *List) InsertBefore(v interface{}, mark *Element) *Element

1.2.2. 简单封装

package QueueFixed
// 左进右出 FIFO 固定长度Queue

import (
    "container/list"
    "sync"
)

type Queue struct {
    l   *list.List
    m   sync.Mutex
    Max int
}

//初始化一个固定长度的队列
func NewFixedQueue(max int) *Queue {
    return &Queue{l: list.New(), Max: max}
}
// 左边进
func (q *Queue) Lpush(v interface{}) bool{
    if q.Len() >= q.Max{
        q.Rpop()
    }
    q.PushFront(v)
    return true
}
// 右边出
func (q *Queue) Rpop() {
    q.Remove(q.Front())
}
// 头部插入
func (q *Queue) PushFront(v interface{}) {
    if v == nil {
        return
    }
    q.m.Lock()
    defer q.m.Unlock()
    q.l.PushBack(v)
}
// 尾部插入
func (q *Queue) PushBack(v interface{}) {
    if v == nil {
        return
    }
    q.m.Lock()
    defer q.m.Unlock()
    q.l.PushBack(v)
}

func (q *Queue) Front() *list.Element {
    q.m.Lock()
    defer q.m.Unlock()
    return q.l.Front()
}

func (q *Queue) Back() *list.Element {
    q.m.Lock()
    defer q.m.Unlock()
    return q.l.Back()
}
func (q *Queue) Remove(e *list.Element) {
    if e == nil {
        return
    }
    q.m.Lock()
    defer q.m.Unlock()
    q.l.Remove(e)
}

func (q *Queue) Len() int {
    q.m.Lock()
    defer q.m.Unlock()
    return q.l.Len()
}