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 int64)
  • func (q *Queue) Pop() interface{}
  • func (q *Queue) Push(v interface{})
  • func (q *Queue) Size() int64

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"

	"github.com/gogf/gf/v2/container/gqueue"
	"github.com/gogf/gf/v2/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"

	"github.com/gogf/gf/v2/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())

	// May Output:
	// 0
	// <nil>
}

func (*Queue) Len

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

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

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/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"

	"github.com/gogf/gf/v2/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"

	"github.com/gogf/gf/v2/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() int64

Size is alias of Len. Deprecated: use Len instead.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/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
}