gqueue

Documentation

Overview

Package gqueue provides dynamic/static concurrent-safe queue.

Features:

1. FIFO queue(data -> list -> chan);

2. Fast creation and initialization;

3. Support dynamic queue size(unlimited queue size);

4. Blocking when reading data from queue;

Index

• type Queue
  • func New(limit ...int) *Queue
  • func (q *Queue) Close()
  • func (q *Queue) Len() (length int)
  • func (q *Queue) Pop() interface{}
  • func (q *Queue) Push(v interface{})
  • func (q *Queue) Size() int

Examples

• New
• Queue.Close
• Queue.Len
• Queue.Pop
• Queue.Push
• Queue.Size

Types

type Queue

type Queue struct {
	C chan interface{} // Underlying channel for data reading.
	// contains filtered or unexported fields
}

Queue is a concurrent-safe queue built on doubly linked list and channel.

func New

func New(limit ...int) *Queue

New returns an empty queue object. Optional parameter `limit` is used to limit the size of the queue, which is unlimited in default. When `limit` is given, the queue will be static and high performance which is comparable with stdlib channel.

Example

package main

import (
	"context"
	"fmt"
	"time"

	"easyscdp.com/gf/container/gqueue"
	"easyscdp.com/gf/os/gtimer"
)

func main() {
	n := 10
	q := gqueue.New()

	// Producer
	for i := 0; i < n; i++ {
		q.Push(i)
	}

	// Close the queue in three seconds.
	gtimer.SetTimeout(context.Background(), time.Second*3, func(ctx context.Context) {
		q.Close()
	})

	// The consumer constantly reads the queue data.
	// If there is no data in the queue, it will block.
	// The queue is read using the queue.C property exposed
	// by the queue object and the selectIO multiplexing syntax
	// example:
	// for {
	//    select {
	//        case v := <-queue.C:
	//            if v != nil {
	//                fmt.Println(v)
	//            } else {
	//                return
	//            }
	//    }
	// }
	for {
		if v := q.Pop(); v != nil {
			fmt.Print(v)
		} else {
			break
		}
	}

}

Output:

0123456789

func (*Queue) Close

func (q *Queue) Close()

Close closes the queue. Notice: It would notify all goroutines return immediately, which are being blocked reading using Pop method.

Example

package main

import (
	"fmt"
	"time"

	"easyscdp.com/gf/container/gqueue"
)

func main() {
	q := gqueue.New()

	for i := 0; i < 10; i++ {
		q.Push(i)
	}

	time.Sleep(time.Millisecond)
	q.Close()

	fmt.Println(q.Len())
	fmt.Println(q.Pop())

}

Output:

0
<nil>

func (*Queue) Len

func (q *Queue) Len() (length int)

Len returns the length of the queue. Note that the result might not be accurate as there's an asynchronous channel reading the list constantly.

Example

package main

import (
	"fmt"

	"easyscdp.com/gf/container/gqueue"
)

func main() {
	q := gqueue.New()

	q.Push(1)
	q.Push(2)

	fmt.Println(q.Len())

	// May Output:
	// 2
}

func (*Queue) Pop

func (q *Queue) Pop() interface{}

Pop pops an item from the queue in FIFO way. Note that it would return nil immediately if Pop is called after the queue is closed.

Example

package main

import (
	"fmt"

	"easyscdp.com/gf/container/gqueue"
)

func main() {
	q := gqueue.New()

	for i := 0; i < 10; i++ {
		q.Push(i)
	}

	fmt.Println(q.Pop())
	q.Close()
	fmt.Println(q.Pop())

}

Output:

0
<nil>

func (*Queue) Push

func (q *Queue) Push(v interface{})

Push pushes the data `v` into the queue. Note that it would panic if Push is called after the queue is closed.

Example

package main

import (
	"fmt"

	"easyscdp.com/gf/container/gqueue"
)

func main() {
	q := gqueue.New()

	for i := 0; i < 10; i++ {
		q.Push(i)
	}

	fmt.Println(q.Pop())
	fmt.Println(q.Pop())
	fmt.Println(q.Pop())

}

Output:

0
1
2

func (*Queue) Size

func (q *Queue) Size() int

Size is alias of Len.

Example

package main

import (
	"fmt"

	"easyscdp.com/gf/container/gqueue"
)

func main() {
	q := gqueue.New()

	q.Push(1)
	q.Push(2)

	// Size is alias of Len.
	fmt.Println(q.Size())

	// May Output:
	// 2
}