标签: queue

在JavaScript中实现Stack和Queue的最佳方法是什么？

我正在寻找分流码算法,我将需要这些数据结构.

假设我们有两个堆栈而没有其他临时变量.

是否可以仅使用两个堆栈"构造"队列数据结构？

关于Java库的一个非常简单快速的问题:是否有一个现成的类,它实现了Queue一个固定的最大大小 - 即它总是允许添加元素,但它会默默地删除头元素以容纳新添加元素的空间.

当然,手动实现它是微不足道的:

import java.util.LinkedList;

public class LimitedQueue<E> extends LinkedList<E> {
    private int limit;

    public LimitedQueue(int limit) {
        this.limit = limit;
    }

    @Override
    public boolean add(E o) {
        super.add(o);
        while (size() > limit) { super.remove(); }
        return true;
    }
}

据我所知,Java stdlibs中没有标准的实现,但可能是Apache Commons中的那个或类似的东西？

我有一个场景,我有多个线程添加到队列和多个线程从同一队列读取.如果队列达到特定大小,则填充队列的所有线程将在添加时被阻止,直到从队列中删除项目为止.

下面的解决方案就是我现在正在使用的问题,我的问题是:如何改进？是否有一个对象已经在我应该使用的BCL中启用此行为？

internal class BlockingCollection<T> : 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("BlockingCollection add waiting: {0}", Thread.CurrentThread.ManagedThreadId));

        _FullEvent.WaitOne();

        List.Add(item);

        Trace.WriteLine(string.Format("BlockingCollection …

我需要一个队列,多个线程可以放入东西,多个线程可以读取.

Python至少有两个队列类,Queue.Queue和collections.deque,前者似乎在内部使用后者.两者都声称在文档中是线程安全的.

但是,队列文档还指出:

collections.deque是无界队列的替代实现,具有快速原子append()和popleft()操作,不需要锁定.

我想我不太沉思:这是否意味着deque毕竟不是完全线程安全的？

如果是,我可能不完全理解这两个类之间的区别.我可以看到Queue添加了阻止功能.另一方面,它失去了一些deque功能,如支持运营商.

直接访问内部deque对象是

x在队列().deque

线程安全的？

另外,为什么当deque已经是线程安全的时候,Queue会使用互斥锁进行操作？

我正在使用std :: queue来实现JobQueue类.(基本上这个类以FIFO方式处理每个作业).在一种情况下,我想一次性清除队列(从队列中删除所有作业).我没有看到std :: queue类中有任何明确的方法.

如何有效地为JobQueue类实现clear方法？

我有一个简单的循环弹出解决方案,但我正在寻找更好的方法.

//Clears the job queue
void JobQueue ::clearJobs()
 {
  // I want to avoid pop in a loop
    while (!m_Queue.empty())
    {
        m_Queue.pop();
    }
}

当我尝试:

Queue<Integer> q = new Queue<Integer>();

编译器给我一个错误.有帮助吗？

另外,如果我想初始化队列,我是否必须实现队列的方法？

我在一个有点大的Web应用程序上工作,后端主要是在PHP中.代码中有几个地方我需要完成一些任务,但我不想让用户等待结果.例如,在创建新帐户时,我需要向他们发送欢迎电子邮件.但是当他们点击"完成注册"按钮时,我不想让他们等到实际发送电子邮件,我只想启动该过程,并立即向用户返回消息.

到目前为止,在某些地方,我一直在使用exec()感觉像是一个黑客.基本上做的事情如下:

exec("doTask.php $arg1 $arg2 $arg3 >/dev/null 2>&1 &");

这似乎有效,但我想知道是否有更好的方法.我正在考虑编写一个在MySQL表中排队任务的系统,以及一个单独的长时间运行的PHP脚本,每秒查询一次该表,并执行它找到的任何新任务.如果需要的话,这也有可能让我将来在几台工作机器之间拆分任务.

我是在重新发明轮子吗？有没有比exec()hack或MySQL队列更好的解决方案？

Python的多处理包中队列和管道之间的根本区别是什么？

在什么情况下应该选择一个而不是另一个？什么时候使用有利Pipe()？什么时候使用有利Queue()？

来自JavaDocs:

• 一的ConcurrentLinkedQueue是当许多线程共享访问一个共同的集合一个合适的选择.此队列不允许null元素.
• ArrayBlockingQueue是一个经典的"有界缓冲区",其中固定大小的数组包含由生产者插入并由消费者提取的元素.此类支持用于排序等待生产者和消费者线程的可选公平策略
• LinkedBlockingQueue通常具有比基于阵列的队列更高的吞吐量,但在大多数并发应用程序中具有较低的可预测性能.

我有两个场景,一个需要队列支持许多生产者(使用它的线程)与一个消费者,另一个是另一种方式.

我不明白使用哪种实现.有人可以解释一下这些差异是什么吗？

此外,什么是"可选的公平政策" ArrayBlockingQueue？