I&#39;m currently using a `List&lt;T&gt;` as a queue (use `lst[0]` then `lst.removeAt(0)`) to hold objects.  There&#39;s about 20 items max at a given time.  I realized there was an actual `Queue&lt;T&gt;` class.  I&#39;m wondering if there&#39;s any benefit (performance, memory, etc.) to using a `Queue&lt;T&gt;` over a `List&lt;T&gt;` acting like a queue?

Queue&lt;T&gt; vs List&lt;T&gt;

Can somebody please explain the main differences? I don&#39;t have a clear knowledge about these functions in programming for any language.

Difference between &quot;enqueue&quot; and &quot;dequeue&quot;

I want to use a database table as a queue. I want to insert in it and take elements from it in the inserted order (FIFO). My main consideration is performance because I have thousands of these transactions each second. So I want to use a SQL query that gives me the first element without searching the whole table. I do not remove a row when I read it.
Does SELECT TOP 1 ..... help here?
Should I use any special indexes?

Using a database table as a queue

Why and when should I use stack or queue data structures instead of arrays/lists? Can you please show an example for a state thats it&#39;ll be better if you&#39;ll use stack or queue? 


Stack and Queue, Why?

What is the difference between them? I know that 

A queue is designed to have elements inserted at the end of the queue, and elements removed from the beginning of the queue.
Where as Dequeue represents a queue where you can insert and remove elements from both ends of the queue. 

But which is more efficient?

Plus what&#39;s the difference between them two? Because I have a bit of knowledge about them, what I said above, but I would like to know more about them.


Queue vs Dequeue in java

What is the easiest way to create a delay (or parking) queue with Python, Pika and RabbitMQ? I have seen an similar [questions][1], but none for Python. 

I find this an useful idea when designing applications, as it allows us to throttle messages that needs to be re-queued again.

There are always the possibility that you will receive more messages than you can handle, maybe the HTTP server is slow, or the database is under too much stress.

I also found it very useful when something went wrong in scenarios where there is a zero tolerance to losing messages, and while re-queuing messages that could not be handled may solve that. It can also cause problems where the message will be queued over and over again. Potentially causing performance issues, and log spam. 


  [1]: https://stackoverflow.com/questions/4444208/delayed-message-in-rabbitmq

How to create a delayed queue in RabbitMQ?

I need a queue which multiple threads can put stuff into, and multiple threads may read from.

Python has at least two queue classes, `Queue.Queue` and `collections.deque`, with the former seemingly using the latter internally. Both claim to be thread-safe in the documentation.

However, the Queue docs also state:

&gt; collections.deque is an alternative
&gt; implementation of unbounded queues
&gt; with fast atomic append() and
&gt; popleft() operations **that do not
&gt; require locking.**

Which I guess I don&#39;t quite unterstand: Does this mean deque isn&#39;t fully thread-safe after all?

If it is, I may not fully understand the difference between the two classes. I can see that Queue adds blocking functionality. On the other hand, it loses some deque features like support for the in-operator.

Accessing the internal deque object directly, is

&gt; x in Queue().deque

thread-safe?

Also, **why does Queue employ a mutex for it&#39;s operations when deque is thread-safe already?**

Queue.Queue vs. collections.deque

A very simple &amp; quick question on Java libraries: is there a ready-made class that implements a `Queue` with a fixed maximum size - i.e. it always allows addition of elements, but it will silently remove head elements to accomodate space for newly added elements.

Of course, it&#39;s trivial to implement it manually:

    import java.util.LinkedList;

    public class LimitedQueue&lt;E&gt; extends LinkedList&lt;E&gt; {
        private int limit;
    
        public LimitedQueue(int limit) {
            this.limit = limit;
        }
    
        @Override
        public boolean add(E o) {
            super.add(o);
            while (size() &gt; limit) { super.remove(); }
            return true;
        }
    }

As far as I see, there&#39;s no standard implementation in Java stdlibs, but may be there&#39;s one in Apache Commons or something like that?

Size-limited queue that holds last N elements in Java

What is the best way to implement a Stack and a Queue in JavaScript?

I&#39;m looking to do the shunting-yard algorithm and I&#39;m going to need these data-structures.

How do you implement a Stack and a Queue in JavaScript?

I am using std::queue for implementing JobQueue class. ( Basically this class process each job in FIFO manner).
In one scenario, I want to clear the queue in one shot( delete all jobs from the queue).
I don&#39;t see any clear method available in std::queue class.

How do I efficiently implement the clear method for JobQueue class ?

I have one simple solution of popping in a loop but I am looking for better ways.


 
    //Clears the job queue
    void JobQueue ::clearJobs()
     {
      // I want to avoid pop in a loop
        while (!m_Queue.empty())
        {
            m_Queue.pop();
        }
    }





How do I clear the std::queue efficiently?

What are the fundamental differences between queues and pipes in [Python&#39;s multiprocessing package][1]?

In what scenarios should one choose one over the other?  When is it advantageous to use `Pipe()`?  When is it advantageous to use `Queue()`?


  [1]: http://docs.python.org/library/multiprocessing.html

Multiprocessing - Pipe vs Queue

I have a scenario where I have multiple threads adding to a queue and multiple threads reading from the same queue. If the queue reaches a specific size **all threads** that are filling the queue will be blocked on add until an item is removed from the queue.

The solution below is what I am using right now and my question is: How can this be improved?  Is there an object that already enables this behavior in the BCL that I should be using?

    internal class BlockingCollection&lt;T&gt; : CollectionBase, IEnumerable
    {
        //todo: might be worth changing this into a proper QUEUE

        private AutoResetEvent _FullEvent = new AutoResetEvent(false);

        internal T this[int i]
        {
            get { return (T) List[i]; }
        }

        private int _MaxSize;
        internal int MaxSize
        {
            get { return _MaxSize; }
            set
            {
                _MaxSize = value;
                checkSize();
            }
        }

        internal BlockingCollection(int maxSize)
        {
            MaxSize = maxSize;
        }

        internal void Add(T item)
        {
            Trace.WriteLine(string.Format(&quot;BlockingCollection add waiting: {0}&quot;, Thread.CurrentThread.ManagedThreadId));

            _FullEvent.WaitOne();

            List.Add(item);

            Trace.WriteLine(string.Format(&quot;BlockingCollection item added: {0}&quot;, Thread.CurrentThread.ManagedThreadId));

            checkSize();
        }

        internal void Remove(T item)
        {
            lock (List)
            {
                List.Remove(item);
            }

            Trace.WriteLine(string.Format(&quot;BlockingCollection item removed: {0}&quot;, Thread.CurrentThread.ManagedThreadId));
        }

        protected override void OnRemoveComplete(int index, object value)
        {
            checkSize();
            base.OnRemoveComplete(index, value);
        }

        internal new IEnumerator GetEnumerator()
        {
            return List.GetEnumerator();
        }

        private void checkSize()
        {
            if (Count &lt; MaxSize)
            {
                Trace.WriteLine(string.Format(&quot;BlockingCollection FullEvent set: {0}&quot;, Thread.CurrentThread.ManagedThreadId));
                _FullEvent.Set();
            }
            else
            {
                Trace.WriteLine(string.Format(&quot;BlockingCollection FullEvent reset: {0}&quot;, Thread.CurrentThread.ManagedThreadId));
                _FullEvent.Reset();
            }
        }
    }

Creating a blocking Queue&lt;T&gt; in .NET?

When I try:

    Queue&lt;Integer&gt; q = new Queue&lt;Integer&gt;();

The compiler is giving me an error. Any help?

Also, if I want to initialize a queue do I have to implement the methods of the queue?

How do I instantiate a Queue object in java?

I work on a somewhat large web application, and the backend is mostly in PHP. There are several places in the code where I need to complete some task, but I don&#39;t want to make the user wait for the result. For example, when creating a new account, I need to send them a welcome email. But when they hit the &#39;Finish Registration&#39; button, I don&#39;t want to make them wait until the email is actually sent, I just want to start the process, and return a message to the user right away.

Up until now, in some places I&#39;ve been using what feels like a hack with exec(). Basically doing things like:

    exec(&quot;doTask.php $arg1 $arg2 $arg3 &gt;/dev/null 2&gt;&amp;1 &amp;&quot;);

Which appears to work, but I&#39;m wondering if there&#39;s a better way. I&#39;m considering writing a system which queues up tasks in a MySQL table, and a separate long-running PHP script that queries that table once a second, and executes any new tasks it finds. This would also have the advantage of letting me split the tasks among several worker machines in the future if I needed to.

Am I re-inventing the wheel? Is there a better solution than the exec() hack or the MySQL queue?

Run PHP Task Asynchronously

I need a queue with a fixed size. When I add an element and the queue is full, it should automatically remove the oldest element. 

Is there an existing implementation for this in Java?


Is there a fixed sized queue which removes excessive elements?

I&#39;m using `ConcurrentQueue` for a shared data structure which purpose is holding the last N objects passed to it (kind of history).

Assume we have a browser and we want to have the last 100 browsed Urls. I want a queue which automatically drop (dequeue) the oldest (first) entry upon new entry insertion (enqueue) when the capacity gets full (100 addresses in history).

How can I accomplish that using `System.Collections` ?

Fixed size queue which automatically dequeues old values upon new enques

From the JavaDocs:

 - A [ConcurrentLinkedQueue][1] is an appropriate choice when many threads will share access to a common collection. This queue does not permit null elements.
 - [ArrayBlockingQueue][2] is a classic &quot;bounded buffer&quot;, in which a fixed-sized array holds elements inserted by producers and extracted by consumers. This class supports an optional fairness policy for ordering waiting producer and consumer threads
 - [LinkedBlockingQueue][3] typically have higher throughput than array-based queues but less predictable performance in most concurrent applications.

I have 2 scenarios, one requires the queue to support many producers (threads using it) with one consumer and the other is the other way around.

I do not understand which implementation to use. Can somebody explain what the differences are?

Also, what is the &#39;optional fairness policy&#39; in the `ArrayBlockingQueue`?

  [1]: http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ConcurrentLinkedQueue.html
  [2]: http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ArrayBlockingQueue.html
  [3]: http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/LinkedBlockingQueue.html

Which concurrent Queue implementation should I use in Java?

Take the `PriorityQueue` for example http://java.sun.com/j2se/1.5.0/docs/api/java/util/PriorityQueue.html#offer(E)

Can anyone give me an example of a [`Queue`][1] where the [`add`][2] and [`offer`][3] methods are different?

According to the [`Collection`][4] doc, the `add` method will often seek to ensure that an element exists within the `Collection` rather than adding duplicates. So my question is, what is the difference between the `add` and `offer` methods?

Is it that the `offer` method will add duplicates regardless? (I doubt that it is because if a `Collection` should only have distinct elements this would circumvent that).

EDIT:
In a `PriorityQueue` the `add` and `offer` methods are the same method (see my answer below). Can anyone give me an example of a class where the `add` and `offer` methods are different?


  [1]: http://docs.oracle.com/javase/8/docs/api/java/util/Queue.html
  [2]: http://docs.oracle.com/javase/8/docs/api/java/util/Queue.html#add-E-
  [3]: http://docs.oracle.com/javase/8/docs/api/java/util/Queue.html#offer-E-
  [4]: http://docs.oracle.com/javase/8/docs/api/java/util/Collection.html

What is the difference between the add and offer methods in a Queue in Java?

What is the basic difference between stack and queue??

  Please help me i am unable to find the difference.

  **How** do you differentiate a stack and a queue?

  I searched for the answer in various links and found this answer..

 In high level programming,

 *a stack is defined as a list or sequence of elements that is lengthened by placing new elements &quot;on top&quot; of existing elements and shortened by removing elements from the top of existing elements. It is an ADT[Abstract Data Type] with math operations of &quot;push&quot; and &quot;pop&quot;.*

 *A queue is a sequence of elements that is added to by placing the new element at the rear of existing and shortened by removing elements in front of queue. It is an ADT[Abstract Data Type]. There is more to these terms understood in programming of Java, C++, Python and so on.*

Can i have an answer which is more detailed? Please help me.

what is the basic difference between stack and queue?

My question relates to [this question][1] asked earlier.  In situations where I am using a queue for communication between producer and consumer threads would people generally recommend using `LinkedBlockingQueue` or `ConcurrentLinkedQueue`?

What are the advantages / disadvantages of using one over the other?

The main difference I can see from an API perspective is that a `LinkedBlockingQueue` can be optionally bounded.

  [1]: https://stackoverflow.com/questions/1426342/need-a-queue-that-can-support-multiple-readers/1426375#1426375

LinkedBlockingQueue vs ConcurrentLinkedQueue

The documentation for the `multiprocessing` module shows how to pass a queue to a process started with `multiprocessing.Process`. But how can I share a queue with asynchronous worker processes started with `apply_async`? I don&#39;t need dynamic joining or anything else, just a way for the workers to (repeatedly) report their results back to base.

    import multiprocessing
    def worker(name, que):
        que.put(&quot;%d is done&quot; % name)

    if __name__ == &#39;__main__&#39;:
        pool = multiprocessing.Pool(processes=3)
        q = multiprocessing.Queue()
        workers = pool.apply_async(worker, (33, q))


This fails with: 
    `RuntimeError: Queue objects should only be shared between processes through inheritance`.
I understand what this means, and I understand the advice to inherit rather than require pickling/unpickling (and all the special Windows restrictions). But how *do* I pass the queue in a way that works? I can&#39;t find an example, and I&#39;ve tried several alternatives that failed in various ways. Help please?

Sharing a result queue among several processes

I want to use a queue data structure in my Objective-C program.  In C++ I&#39;d use the STL queue.  What is the equivalent data structure in Objective-C?  How do I push/pop items?

How do I make and use a Queue in Objective-C?

What is the basic difference between stream processing and traditional message processing? As people say that kafka is good choice for stream processing but essentially kafka is a messaging framework similar to ActivMQ, RabbitMQ etc.

Why do we generally not say that ActiveMQ is good for stream processing as well.

Is it the speed at which messages are consumed by the consumer determines if it is a stream?

Difference between stream processing and message processing

I have a few queues running with RabbitMQ. A few of them are of no use now, how can I delete them? Unfortunately I had not set the `auto_delete` option.

If I set it now, will it be deleted?

Is there a way to delete those queues now?

Deleting queues in RabbitMQ

`NSOperationQueue` has `waitUntilAllOperationsAreFinished`, but I don&#39;t want to wait synchronously for it. I just want to hide progress indicator in UI when queue finishes.

What&#39;s the best way to accomplish this?

I can&#39;t send notifications from my `NSOperation`s, because I don&#39;t know which one is going to be last, and `[queue operations]` might not be empty yet (or worse - repopulated) when notification is received.


Get notification when NSOperationQueue finishes all tasks

I need to iterate over `std::queue`.
www.cplusplus.com says:

&gt; By default, if no container class is specified for a particular queue class, the standard container class template deque is used.

So can I somehow get to the queue&#39;s underlying deque and iterate over it?

std::queue iteration

Suppose we have two stacks and no other temporary variable.

Is to possible to &quot;construct&quot; a queue data structure using only the two stacks?

How to implement a queue using two stacks?

I need a simple FIFO implemented queue for storing a bunch of ints (I don&#39;t mind much if it is generics implementation).

Anything already baked for me in `java.util` or Trove/Guava library?

FIFO based Queue implementations?

I am using RabbitMQ and I have a queue that holds email messages. My consumer service de-queues messages and attempts to send them. If, for any reason, my consumer cannot send the message, I would like to re-queue the message to send again. I realize I can do a basicNack and set the requeue flag to be true, however, I don&#39;t want to requeue the message indefinitely (say, if our email system goes down, I don&#39;t want to continuously requeue unsent messages). I would like to define a finite number of times that I can requeue the message to be sent again. I can&#39;t set a field on the email message object, however, when I dequeue it and send a nack. The updated field is not present on the message in the queue. Is there any other way in which I can approach this? Thanks in advance.

How do I set a number of retry attempts in RabbitMQ?

I came across this question:
**Implement a queue in which push_rear(), pop_front() and get_min() are all constant time operations.**

I initially thought of using a min-heap data structure which has O(1) complexity for a get_min(). But push_rear() and pop_front() would be O(log(n)).

Does anyone know what would be the best way to implement such a queue which has O(1) push(), pop() and min()?

I googled about this, and wanted to point out this [Algorithm Geeks thread][1]. But it seems that none of the solutions follow constant time rule for all 3 methods: push(), pop() and min().

Thanks for all the suggestions.


  [1]: http://groups.google.com/group/algogeeks/browse_thread/thread/157129d83d284e07?pli=1

Implement a queue in which push_rear(), pop_front() and get_min() are all constant time operations

A project I&#39;m working on uses multiple threads to do work on a collection of files. Each thread can add files to the list of files to be processed, so I put together (what I thought was) a thread-safe queue. Relevant portions follow:

    // qMutex is a std::mutex intended to guard the queue
    // populatedNotifier is a std::condition_variable intended to
    //                   notify waiting threads of a new item in the queue
    
    void FileQueue::enqueue(std::string&amp;&amp; filename)
    {
    	std::lock_guard&lt;std::mutex&gt; lock(qMutex);
    	q.push(std::move(filename));
    
    	// Notify anyone waiting for additional files that more have arrived
    	populatedNotifier.notify_one();
    }
    
    std::string FileQueue::dequeue(const std::chrono::milliseconds&amp; timeout)
    {
    	std::unique_lock&lt;std::mutex&gt; lock(qMutex);
    	if (q.empty()) {
    		if (populatedNotifier.wait_for(lock, timeout) == std::cv_status::no_timeout) {
    			std::string ret = q.front();
    			q.pop();
    			return ret;
    		}
    		else {
    			return std::string();
    		}
    	}
    	else {
    		std::string ret = q.front();
    		q.pop();
    		return ret;
    	}
    }

However, I am occasionally segfaulting inside the `if (...wait_for(lock, timeout) == std::cv_status::no_timeout) { }` block, and inspection in gdb indicates that the segfaults are occurring because the queue is empty. How is this possible? It was my understanding that `wait_for` only returns `cv_status::no_timeout` when it has been notified, and this should only happen after `FileQueue::enqueue` has just pushed a new item to the queue.

C++11 thread-safe queue

I have created a Queue class in javascript and I would like to store functions as data in a queue. That way I can build up requests (function calls) and respond to them when I need to (actually executing the function).

Is there any way to store a function as data, somewhat similar to

    .setTimeout(&quot;doSomething()&quot;, 1000);

except it would be

    functionQueue.enqueue(doSomething());

Where it would store doSomething() as data so when I retrieve the data from the queue, the function would be executed.

I&#39;m guessing I would have to have doSomething() in quotes -&gt; &quot;doSomething()&quot; and some how make it call the function using a string, anyone know how that could be done?


How do I store javascript functions in a queue for them to be executed eventually

Can anyone suggest Go container for simple and fast FIF/queue, Go has 3 different containers: `heap`, `list` and `vector`. Which one is more suitable to implement a queue?

Is there a queue implementation?

I need to choose a new Queue broker for my new project.  

This time I need a scalable queue that supports pub/sub, and keeping message ordering is a must.  

I read Alexis comment: He writes:

&gt; &quot;Indeed, we think RabbitMQ provides stronger ordering than Kafka&quot;

I read the message ordering section in rabbitmq docs:

    

&gt; &quot;Messages can be returned to the queue using AMQP methods that feature
&gt; a requeue
&gt;      parameter (basic.recover, basic.reject and basic.nack), or due to a channel 
&gt;      closing while holding unacknowledged messages...With release 2.7.0 and later 
&gt;      it is still possible for individual consumers to observe messages out of 
&gt;      order if the queue has multiple subscribers. This is due to the actions of 
&gt;      other subscribers who may requeue messages. From the perspective of the queue 
&gt;      the messages are always held in the publication order.&quot;

If I need to handle messages by their order, I can only use rabbitMQ with an exclusive queue to each consumer?  

Is RabbitMQ still considered a good solution for ordered message queuing?




RabbitMQ - Message order of delivery

I am working (in Java) on a recursive image processing algorithm that recursively traverses the pixels of the image, outwards from a center point.

Unfortunately, that causes a Stack Overflow. So I have decided to switch to a Queue-based algorithm.

Now, this is all fine and dandy- but considering the fact that its queue will be analyzing THOUSANDS of pixels in a very short amount of time, while constantly popping and pushing, WITHOUT maintaining a predictable state (It could be anywhere between length 100, and 20000), the queue implementation needs to have significantly fast popping and pushing abilities.


A linked list seems attractive due to its ability to push elements onto itself without rearranging anything else in the list, but in order for it to be fast enough, it would need easy access to both its head, AND its tail (or second-to-last node if it were not doubly-linked). Sadly, I cannot find any information related to the underlying implementation of linked lists in Java, so it&#39;s hard to say if a linked list is really the way to go...


This brings me to my question. What would be the best implementation of the Queue interface in Java for what I intend to do? (I do not wish to edit or even access anything other than the head and tail of the queue -- I do not wish to do any sort of rearranging, or anything. On the flip side, I DO intend to do a lot of pushing and popping, and the queue will be changing size quite a bit, so preallocating would be inefficient)

Best implementation of Java Queue?

Can I traverse a standard `priority_queue` or standard `queue` in c++ with an iterator (like a `vector`)? I don&#39;t want to use pop because it cause my queue to be dequeued. 

Thanks for any help

How to iterate over a priority_queue?

I&#39;m looking for a implementation of java.util.Queue or something in the Google collection who behave like a Queue, but also ensure that each element of the queue is unique. (all further insertion will have no effect)

It&#39;s that possible, or will I have to do it by hand?

For now I&#39;m using a Queue&lt;MyStuff&gt;, with a LinkedList implementation, and I check the uniqueness before insertion. ( I use a side Map for doing this, add / remove element from the side map before / after the queu ). I don&#39;t like it too much.

Any input is welcome. If it&#39;s not in the java.util package, then maybe it&#39;s a bad idea?

A Queue that ensure uniqueness of the elements?

I have several threads running in parallel from Python on a cluster system. Each python thread outputs to a directory `mydir`. Each script, before outputting checks if *mydir* exists and if not creates it:

    if not os.path.isdir(mydir):
        os.makedirs(mydir)

but this yields the error:


    os.makedirs(self.log_dir)                                             
      File &quot;/usr/lib/python2.6/os.py&quot;, line 157, in makedirs
    mkdir(name,mode)
    OSError: [Errno 17] File exists

I suspect it might be due to a race condition, where one job creates the *dir* before the other gets to it. Is this possible? If so, how can this error be avoided? 

I&#39;m not sure it&#39;s a race condition so was wondering if other issues in Python can cause this odd error.

Python &quot;FileExists&quot; error when making directory

I&#39;m on Laravel using `php artisan queue:listen` to run queued jobs. One of these jobs is fairly involved and takes a long time, and so I&#39;m getting the following error:

    [Symfony\Component\Process\Exception\ProcessTimedOutException]                                                                                                                                                                              
    The process &quot;&quot;/usr/local/Cellar/php55/5.5.14/bin/php&quot; artisan queue:work  
    --queue=&quot;QUEUE_URL&quot; --delay=0 --memory=128 --sleep=3 --tries=0&quot; 
    exceeded the timeout of 60 seconds.

I know that I could run `queue:listen` with an arbitrarily high timeout value, but that&#39;s not ideal, as I _do_ want it to time out in the event that some process is _actually_ unreseponsive. I tried regularly calling `set_time_limit(60)` within the function called by the job, but that did not solve my problem.

I found a thread online mentioning `Symfony\Component\Process\Process-&gt;setTimeout(null)`, but I don&#39;t know how to access that process object, or if that would even fix the issue.

Any help would be much appreciated.

Laravel queue process timeout error

I find I sometimes need to iterate some collection and make an ajax call for each element. I want each call to return before moving to the next element so that I don&#39;t blast the server with requests - which often leads to other issues. And I don&#39;t want to set async to false and freeze the browser.

Usually this involves setting up some kind of iterator context that i step thru upon each success callback. I think there must be a cleaner simpler way?

Does anyone have a clever design pattern for how to neatly work thru a collection making ajax calls for each item?

Sequencing ajax requests

How can I clear a queue. For example I have datas in a queue, but for some reason I don&#39;t need the existing data, and  just want to clear the queue.

Is there any way? Will this work:

    oldQueue = Queue.Queue()

 

Clear all items from the queue

I&#39;ve built a simple queue in Go. It uses an internal slice to keep track of its elements. Elements are pushed onto the queue by appending to the slice. I&#39;d like to implement `.Pop()` by removing the first element in `elements`.

In many other languages, &quot;popping&quot; the first element of a list is a one-liner, which leads me to believe my implementation below is sloppy and verbose. Is there a better way?

    type Queue struct {
    	elements []interface{}
    }
    
    func (queue *Queue) Push(element interface{}) {
    	queue.elements = append(queue.elements, element)
    }
    
    func (queue *Queue) Pop() interface{} {
    	element := queue.elements[0]
    	if len(queue.elements) &gt; 1 {
    		queue.elements = queue.elements[1:]
    	} else {
    		queue.elements = make([]interface{}, 0)
    	}
    	return element
    }

Please note that I wish for the `Queue` to panic if `len(queue.elements) == 0`. It&#39;s not an oversight that I don&#39;t check the bounds.

How do I (succinctly) remove the first element from a slice in Go?

I&#39;d like to create some sort of `Producer/Consumer` threading app. But I&#39;m not sure what the best way to implement a queue between the two. 

So I&#39;ve some up with two ideas (both of which could be entirely wrong). I would like to know which would be better and if they both suck then what would be the best way to implement the queue. It&#39;s mainly my implementation of the queue in these examples that I&#39;m concerned about. I&#39;m extending a Queue class that is an in house class and is thread safe. Below are two examples with 4 classes each.

Main class-

    public class SomeApp
    {
        private Consumer consumer;
        private Producer producer;

        public static void main (String args[])
        {
            consumer = new Consumer();
            producer = new Producer();
        }
    } 

Consumer class-

    public class Consumer implements Runnable
    {
        public Consumer()
        {
            Thread consumer = new Thread(this);
            consumer.start();
        }

        public void run()
        {
            while(true)
            {
                //get an object off the queue
                Object object = QueueHandler.dequeue();
                //do some stuff with the object
            }
        }
    }

Producer class-

    public class Producer implements Runnable
    {
        public Producer()
        {
            Thread producer = new Thread(this);
            producer.start();
        }

        public void run()
        {
            while(true)
            {
                //add to the queue some sort of unique object
                QueueHandler.enqueue(new Object());
            }
        }
    }

Queue class-

    public class QueueHandler
    {
        //This Queue class is a thread safe (written in house) class
        public static Queue&lt;Object&gt; readQ = new Queue&lt;Object&gt;(100);
        
        public static void enqueue(Object object)
        {
            //do some stuff
            readQ.add(object);
        }

        public static Object dequeue()
        {
            //do some stuff
            return readQ.get();
        }
    }
        
**OR**

Main class-

    public class SomeApp
    {
        Queue&lt;Object&gt; readQ;
        private Consumer consumer;
        private Producer producer;

        public static void main (String args[])
        {
            readQ = new Queue&lt;Object&gt;(100);
            consumer = new Consumer(readQ);
            producer = new Producer(readQ);
        }
    } 

Consumer class-

    public class Consumer implements Runnable
    {
        Queue&lt;Object&gt; queue;

        public Consumer(Queue&lt;Object&gt; readQ)
        {
            queue = readQ;
            Thread consumer = new Thread(this);
            consumer.start();
        }

        public void run()
        {
            while(true)
            {
                //get an object off the queue
                Object object = queue.dequeue();
                //do some stuff with the object
            }
        }
    }

Producer class-

    public class Producer implements Runnable
    {
        Queue&lt;Object&gt; queue;

        public Producer(Queue&lt;Object&gt; readQ)
        {
            queue = readQ;
            Thread producer = new Thread(this);
            producer.start();
        }

        public void run()
        {

            while(true)
            {
                //add to the queue some sort of unique object
                queue.enqueue(new Object());
            }
        }
    }

Queue class-

    //the extended Queue class is a thread safe (written in house) class
    public class QueueHandler extends Queue&lt;Object&gt;
    {    
        public QueueHandler(int size)
        {
            super(size); //All I&#39;m thinking about now is McDonalds.
        }

        public void enqueue(Object object)
        {
            //do some stuff
            readQ.add();
        }

        public Object dequeue()
        {
            //do some stuff
            return readQ.get();
        }
    }

And go!

Producer/Consumer threads using a Queue

I have a Queue&amp;lt;T&amp;gt; object that I have initialised to a capacity of 2, but obviously that is just the capacity and it keeps expanding as I add items.  Is there already an object that automatically dequeues an item when the limit is reached, or is the best solution to create my own inherited class?

Limit size of Queue&lt;T&gt; in .NET?

I have a Queue&lt;string&gt; object that I need to ensure is thread-safe. Would it be better to use a lock object like this:

    lock(myLockObject)
    {
    //do stuff with the queue
    }

Or is it recommended to use Queue.Synchronized like this:

    Queue.Synchronized(myQueue).whatever_i_want_to_do();

From reading the MSDN docs it says I should use Queue.Synchronized to make it thread-safe, but then it gives an example using a lock object. From the MSDN article:

&gt; To guarantee the thread safety of the
&gt; Queue, all operations must be done
&gt; through this wrapper only.
&gt; 
&gt; Enumerating through a collection is
&gt; intrinsically not a thread-safe
&gt; procedure. Even when a collection is
&gt; synchronized, other threads can still
&gt; modify the collection, which causes
&gt; the enumerator to throw an exception.
&gt; To guarantee thread safety during
&gt; enumeration, you can either lock the
&gt; collection during the entire
&gt; enumeration or catch the exceptions
&gt; resulting from changes made by other
&gt; threads.

If calling Synchronized() doesn&#39;t ensure thread-safety what&#39;s the point of it? Am I missing something here?

In C# would it be better to use Queue.Synchronized or lock() for thread safety?

I need to use a priority queue in my Python code, and:

 - am looking for any **fast** implementations for priority queues
 - optimally, I&#39;d like the queue to be **generic** (i.e. work well for any object with a specified comparison operator).

Looking around for something efficient, I came upon [heapq][1], but:

 - I&#39;m looking for something faster than `heapq`, which is implemented in native Python, so it&#39;s not fast.
 - It looks good, but seems to be specified only for integers. I suppose it works with any objects that have comparison operators, but it doesn&#39;t specify what comparison operators it needs. 
 - Update: Re comparison in `heapq`, I can either use a `(priority, object)` as Charlie Martin suggests, or just implement `__cmp__` for my object. 


  [1]: http://docs.python.org/library/heapq.html

A generic priority queue for Python

I&#39;m trying to compare the growth rates (both run-time and space) for stack and queue operations when implemented as both arrays and as linked lists. So far I&#39;ve only been able to find average case run-times for queue `pop()`s, but nothing that comprehensively explores these two data structures and compares their run-times/space behaviors.

Specifically, I&#39;m looking to compare `push()` and `pop()` for both queues and stacks, implemented as **both** arrays and linked lists (thus 2 operations x 2 structures x 2 implementations, or 8 values).

Additionally, I&#39;d appreciate best, average and worst case values for both of these, and anything relating to the amount of space they consume.

The closest thing I&#39;ve been able to find is this &quot;mother of all cs cheat sheets&quot; pdf that  is clearly a masters- or doctoral-level cheat sheet of advanced algorithms and discrete functions.

**I&#39;m just looking for a way to determine when and where I should use an array-based implementation vs. a list-based implementation for both stacks and queues.**

Array-Based vs List-Based Stacks and Queues

I&#39;m a newbie with Rabbitmq(and programming) so sorry in advance if this is obvious.  I am creating a pool to share between threads that are working on a queue but I&#39;m not sure if I should use connections or channels in the pool.  

I know I need channels to do the actual work but is there a performance benefit of having one channel per connection(in terms of more throughput from the queue)? or am I better off just using a single connection per application and pool many channels?


note: because I&#39;m pooling the resources the initial cost is not a factor, as I know connections are more expensive than channels.  I&#39;m more interested in throughput.

Is there a performance difference between pooling connections or channels in rabbitmq?

I have a simple task like that:

    def worker(queue):
        while True:
            try:
                _ = queue.get_nowait()
            except Queue.Empty:
                break
    
    if __name__ == &#39;__main__&#39;:
        manager = multiprocessing.Manager()
        # queue = multiprocessing.Queue()
        queue = manager.Queue()
    
        for i in range(5):
            queue.put(i)
    
        processes = []
    
        for i in range(2):
            proc = multiprocessing.Process(target=worker, args=(queue,))
            processes.append(proc)
            proc.start()
    
        for proc in processes:
            proc.join()

It seems that multiprocessing.Queue can do all work that i needed, but on the other hand I see many examples of manager().Queue() and can&#39;t understand what I really need. Looks like Manager().Queue() use some sort of proxy objects, but I doesn&#39;t understand those purpose, because multiprocessing.Queue() do the same work without any proxy objects.

So, my questions is:

1) What really difference between multiprocessing.Queue and object returned by multiprocessing.manager().Queue()?

2) What do I need to use?

Python multiprocessing.Queue vs multiprocessing.manager().Queue()

I am using jQuery.queue() for the first time and haven&#39;t quite grasped it. 
Could someone please point out what I&#39;m doing wrong?

Looking in firebug I am still seeing my POST requests firing at the same time - so I&#39;m wondering if I&#39;m calling dequeue() in the wrong place.

Also - how can I get the queue length?

The reason I need to queue these requests is that it gets fired on click of a button. And its possible for the user to click multiple buttons in quick succession.


Tried to strip out the basic structure of my code:

    $(&quot;a.button&quot;).click(function(){
       $(this).doAjax(params);
    });
    
    // method
    doAjax:function(params){ 

       $(document).queue(&quot;myQueueName&quot;, function(){
         $.ajax({
           type: &#39;POST&#39;,
           url: &#39;whatever.html&#39;,
           params: params,
           success: function(data){
             doStuff;

             $(document).dequeue(&quot;myQueueName&quot;);
           }
         });
       });

    }


Queue ajax requests using jQuery.queue()

In a flowchart or process diagram, what is the symbol for a FIFO queue?

All Queue Solutions on Gang of Coders

Total of 51 Queue Solutions