在Golang中实现有无限容量的同步Queue

chan对象是Golang的一个核心卖点，可以轻松实现goroutine之间的通信。Golang允许我们为chan设置不同的缓冲大小。当默认缓冲大小为0的时候，一个goroutine对chan的写入操作必须要等到有其他goroutine对chan进行读取的时候才会返回，反之一个goroutine对chan进行读取的时候要等到另外一个goroutine对chan进行写入才会返回。如果我们不希望每次对chan进行读取和写入都堵塞的话，可以对chan设置缓冲大小。这样，在缓冲区没满之前，goroutine可以不停的对chan进行写入而不会发生堵塞，直到缓冲区被填满。

有时候我们需要把某个请求或者数据放入到chan中，然后立刻返回去做其他事情。这种情况下为了避免chan发生堵塞，我们需要为chan设置一个足够大的缓冲大小。如果缓冲大小设置的过小，就很难避免出现堵塞，而把缓冲大小设置的过大，又会造成额外的内存开销，因为chan对象在创建（make）的时候就已经分配了足够的内存作为缓冲。

因此我在实际项目中经常使用一个同步的先入先出队列（SyncQueue）。数据生产者调用队列的Push函数将数据添加到队列中，Push函数在任何情况下不会发生堵塞。数据消费者使用Pop函数获得一个数据。如果队列中当前为空，则Pop函数会挂起当前goroutine，直到有其他goroutine Push新的数据到队列中。SyncQueue不需要提前生成一个巨大的缓存，因此不会占用大量的内存，并且提供无限（除非内存满）的队列长度。

同步队列（SyncQueue）实现：https://github.com/xiaonanln/go-xnsyncutil/blob/master/xnsyncutil/sync_queue.go

接口文档：https://godoc.org/github.com/xiaonanln/go-xnsyncutil/xnsyncutil#SyncQueue

package xnsyncutil

import (
    "sync"

    "gopkg.in/eapache/queue.v1"
)

// Synchronous FIFO queue
type SyncQueue struct {
    lock    sync.Mutex
    popable *sync.Cond
    buffer  *queue.Queue
    closed  bool
}

// Create a new SyncQueue
func NewSyncQueue() *SyncQueue {
    ch := &SyncQueue{
        buffer: queue.New(),
    }
    ch.popable = sync.NewCond(&ch.lock)
    return ch
}

// Pop an item from SyncQueue, will block if SyncQueue is empty
func (q *SyncQueue) Pop() (v interface{}) {
    c := q.popable
    buffer := q.buffer

    q.lock.Lock()
    for buffer.Length() == 0 && !q.closed {
        c.Wait()
    }

    if buffer.Length() > 0 {
        v = buffer.Peek()
        buffer.Remove()
    }

    q.lock.Unlock()
    return
}

// Try to pop an item from SyncQueue, will return immediately with bool=false if SyncQueue is empty
func (q *SyncQueue) TryPop() (v interface{}, ok bool) {
    buffer := q.buffer

    q.lock.Lock()

    if buffer.Length() > 0 {
        v = buffer.Peek()
        buffer.Remove()
        ok = true
    } else if q.closed {
        ok = true
    }

    q.lock.Unlock()
    return
}

// Push an item to SyncQueue. Always returns immediately without blocking
func (q *SyncQueue) Push(v interface{}) {
    q.lock.Lock()
    if !q.closed {
        q.buffer.Add(v)
        q.popable.Signal()
    }
    q.lock.Unlock()
}

// Get the length of SyncQueue
func (q *SyncQueue) Len() (l int) {
    q.lock.Lock()
    l = q.buffer.Length()
    q.lock.Unlock()
    return
}

func (q *SyncQueue) Close() {
    q.lock.Lock()
    if !q.closed {
        q.closed = true
        q.popable.Signal()
    }
    q.lock.Unlock()
}

 

 

Category: Golang 标签：chan, golang, queue, sync