标签: queue

我的消费者队列:

m = queue.get()
queue.task_done()

<rest of the program>

问题:

1. 是否task_done()有效弹出m队列并释放消费者对队列的锁定？

2. 我需要m在程序的其余部分使用.它是安全的,还是我需要在打电话之前将其复制task_done()或m在之后使用task_done()？

要开心

为什么,为什么不java.util.concurrent提供其ExecutorServices 的队列长度指标？最近我发现自己做了这样的事情:

ExecutorService queue = Executors.newSingleThreadExecutor();
AtomicInteger queueLength = new AtomicInteger();
...

public void addTaskToQueue(Runnable runnable) {
    if (queueLength.get() < MAX_QUEUE_LENGTH) {
        queueLength.incrementAndGet(); // Increment queue when submitting task.
        queue.submit(new Runnable() {
            public void run() {
                runnable.run();
                queueLength.decrementAndGet(); // Decrement queue when task done.
            }
        });
    } else {
        // Trigger error: too long queue
    }
}

哪个工作正常,但......我认为这应该作为一部分实现ExecutorService.这是一个愚蠢的错误,容易携带一个与实际队列分开的计数器,计数器应该指示它的长度(让我想起C数组).但是,ExecutorServices是通过静态工厂方法获得的,因此无法简单地扩展优秀的单线程执行器并添加队列计数器.所以我该怎么做:

1. 重新发明已经在JDK中实现的东西？
2. 其他聪明的解决方案？

也许这是一个愚蠢的问题,但我似乎找不到明显的答案.

我需要一个只包含唯一值的并发FIFO队列.尝试添加队列中已存在的值只会忽略该值.哪个,如果不是线程安全将是微不足道的.Java中是否存在数据结构,或者是否存在表现出此行为的互联网上的代码片段？

我想知道是否存在ConcurrentQueue的实现/包装器,类似于BlockingCollection,其中从集合中获取不会阻塞,而是异步并且将导致异步等待直到将项目放入队列中.

我已经提出了自己的实现,但它似乎没有按预期执行.我想知道我是否正在重塑已经存在的东西.

这是我的实现:

public class MessageQueue<T>
{
    ConcurrentQueue<T> queue = new ConcurrentQueue<T>();

    ConcurrentQueue<TaskCompletionSource<T>> waitingQueue = 
        new ConcurrentQueue<TaskCompletionSource<T>>();

    object queueSyncLock = new object();

    public void Enqueue(T item)
    {
        queue.Enqueue(item);
        ProcessQueues();
    }

    public async Task<T> Dequeue()
    {
        TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
        waitingQueue.Enqueue(tcs);
        ProcessQueues();
        return tcs.Task.IsCompleted ? tcs.Task.Result : await tcs.Task;
    }

    private void ProcessQueues()
    {
        TaskCompletionSource<T> tcs=null;
        T firstItem=default(T);
        while (true)
        {
            bool ok;
            lock (queueSyncLock)
            {
                ok = waitingQueue.TryPeek(out tcs) && queue.TryPeek(out firstItem);
                if (ok)
                { …

有没有人知道一种pythonic方法迭代a的元素Queue.Queue 而不从队列中删除它们.我有一个生产者/消费者类型的程序,其中要处理的项目通过使用a传递Queue.Queue,我希望能够打印剩余的项目.有任何想法吗？

在Python文档中,

首先检索最低值的条目(最低值条目是返回的条目sorted(list(entries))[0]).条目的典型模式是以下形式的元组:(priority_number, data).

看来队列将按优先级排序,然后按数据排序,这可能并不总是正确的.假设数据"项目2"在"项目1"之前排队,项目1仍将首先排队.在另一个文档页面heapq中,它建议使用计数器.所以我会存储我的数据entry = [priority, count, task].是不是有类似的东西

PriorityQueue.put(item, priority)

那我自己不需要实现订购了吗？

我有一个简单的任务:

def worker(queue):
    while True:
        try:
            _ = queue.get_nowait()
        except Queue.Empty:
            break

if __name__ == '__main__':
    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()

似乎multiprocessing.Queue可以完成我需要的所有工作,但另一方面我看到很多manager().Queue()的例子并且无法理解我真正需要的东西.看起来像Manager().Queue()使用某种代理对象,但我不明白这些目的,因为multiprocessing.Queue()在没有任何代理对象的情况下执行相同的工作.

所以,我的问题是:

1)multiprocessing.manager()返回的多处理.Queue和object之间有什么区别.Queue()？

2)我需要使用什么？

我认为这很简单,但我仍然无法让它工作.通过单击一个按钮,我想要一个接一个地发生几个动画- 但现在所有的动画都在同一时间发生.这是我的代码 - 有人可以告诉我哪里出错了吗？:

$(".button").click(function(){
  $("#header").animate({top: "-50"}, "slow")
  $("#something").animate({height: "hide"}, "slow")
  $("ul#menu").animate({top: "20", left: "0"}, "slow")
  $(".trigger").animate({height: "show", top: "110", left: "0"}, "slow");
});

在Clojure中获取简单,高效的不可变队列数据类型的最佳方法是什么？

它只需要两个操作,用通常的语义排队和出列.

我当然考虑过列表和向量,但我知道它们在结尾和开始时的性能相对较差(即O(n)或更差) - 因此不适合排队!

理想情况下,我想要一个适当的持久数据结构,其中包含入队和出队操作的O(log n).

有人可以解释一下主要的区别吗？我对任何语言的编程都没有清楚的知识.