Peekable Queue in the Golang

Question

I am trying to develop a mechanism to collaborate with many processes - goroutines. There are two classes of processes - providers and users. Suppliers queue their bids for their services, and users accept pending bids and start working with suppliers. However, the user may not like the proposal, and then two things should happen:

• This rate must be returned to the queue. It should be placed at the beginning of the queue.
• The user should be offered the next bid in line

Ideally, I would like to avoid the central process that coordinates the communication between providers and users. Another way to think about this problem is to imagine a “peeping” queue or channel. The concept is similar to how AWS Kinesis works. The reader can access the "peek" at the head of the lineup. As this reader peeks, no other reader sees this subject. The reader likes the item, then it removes it from the queue. If not the reader releases the element lock, another reader can peek.

Any ideas on how to best implement this behavior in Go using feeds and goroutines?

Answer 1

@DaveC , - .

"/" , . / .

, , , , :

import (
    "container/list"
    "sync"
)

type Queue struct {
    q list.List
    l sync.Mutex
}

func (q *Queue) Push(data interface{}) {
    q.l.Lock()
    q.q.PushBack(data)
    q.l.Unlock()
}

func (q *Queue) Pop() interface{} {
    q.l.Lock()
    data := q.q.Remove(q.q.Front())
    q.l.Unlock()
    return data
}

func (q *Queue) TakeAnother(data interface{}) interface{} {
    q.l.Lock()
    e := q.q.Front()
    // swap the data with whatever is in the front of the list
    e.Value, data = data, e.Value
    q.l.Unlock()
    return data
}

goroutines, , .