标签: queue

使用库存Linux工具的最小"任务队列"来利用多核CPU

使用bash和常用工具为Linux构建最小任务队列系统的最佳/最简单方法是什么?

我有一个9'000行的文件,每行有一个bash命令行,命令是完全独立的.

command 1 > Logs/1.log
command 2 > Logs/2.log
command 3 > Logs/3.log
...
Run Code Online (Sandbox Code Playgroud)

我的盒子有多个核心,我想同时执行X任务.我在网上搜索了一个很好的方法来做到这一点.显然,很多人都有这个问题,但到目前为止还没有人有一个好的解决方案.

如果解决方案具有以下功能,那将是很好的:

  • 可以解释多个命令(例如command; command)
  • 可以解释行上的流重定向(例如ls > /tmp/ls.txt)
  • 仅使用常见的Linux工具

如果它适用于其他Unix克隆而没有太多异国情调的要求,则可获得奖励积分.

queue parallel-processing bash

7
推荐指数
2
解决办法
3293
查看次数

C#优先级队列

我正在寻找一个具有如下界面的优先级队列:

class PriorityQueue<T>
{
    public void Enqueue(T item, int priority)
    {
    }

    public T Dequeue()
    {
    }
}
Run Code Online (Sandbox Code Playgroud)

我见过的所有实现都假设这item是一个IComparable但我不喜欢这种方法; 我想在将其推入队列时指定优先级.

如果不存在现成的实现,那么自己做这个的最佳方法是什么?我应该使用什么底层数据结构?某种自平衡树,还是什么?标准的C#.net结构会很好.

c# queue data-structures

7
推荐指数
5
解决办法
2万
查看次数

是否有任何有趣的算法同时使用堆栈和队列(deque)ADT?

我们经常使用堆栈或队列在我们的算法,但在那里,我们用一个双向链表实现任何情况下都栈和算法中的队列?例如,在一个阶段,我们将()将6个项目推入堆栈,pop()2个项目,然后从双向链接列表的尾部将其余项目(4)出列().我正在寻找的是那些在这种方法中实现某些东西的模糊,有趣的算法,甚至是陌生的.伪代码,链接和解释会很好.

c algorithm queue stack data-structures

7
推荐指数
1
解决办法
1369
查看次数

在python的多处理中检查空队列

我有一个程序使用python的包多处理和队列.我的一个函数有这个结构:

from multiprocessing import Process, Queue
def foo(queue):
   while True:
       try:
           a = queue.get(block = False)
           doAndPrintStuff(a)
       except:
           print "the end"
           break

   if __name__ == "__main__"
     nthreads = 4
     queue = Queue.Queue()
     # put stuff in the queue here 
     for stuff in moreStuff:
         queue.put(stuff)
     procs = [Process(target = foo, args = (queue,)) for i in xrange(nthreads)]
     for p in procs:
       p.start()
     for p in procs:
       p.join()
Run Code Online (Sandbox Code Playgroud)

我的想法是,当我尝试从队列中提取并且它是空的时,它将引发异常并终止循环.所以我有两个问题:

1)这是一个安全的成语吗?有没有更好的方法来做到这一点?

2)我试图找到当我尝试.get()从空队列中引发的确切异常.目前我的程序正在捕获所有异常,当错误发生在其他地方并且我只收到"结束"消息时会很糟糕.

我试过了:

  import Queue
  queue = Queue.Queue()
  [queue.put(x) for x …
Run Code Online (Sandbox Code Playgroud)

python queue multiprocessing

7
推荐指数
1
解决办法
3万
查看次数

没有队列的ThreadPoolExecutor

我想创建一个固定大小的线程池,不允许任何任务进入其队列.换句话说,如果当前正在使用线程池,则应彻底拒绝传入任务.根据文档,在我看来,实现此目的的一种方法是创建一个拒绝接受任务的虚拟Queue对象.在Java中实现这一目标的惯用方法是什么?

java queue threadpool

7
推荐指数
1
解决办法
3181
查看次数

C#throttling For循环

初步情况

我正在开发.NET Framework 4.0,C#,Winform Application.应用程序将在GridView中列出(并测试)WebServiceOperations(当前有60个DataRows => WebServiceOperations).

目的

我只需点击一下按钮即可测试/调用所有这些操作.每个操作都会创建一个类的新实例.在这个类中,我调用WebServiceOperation异步并等待结果.结果随后得到验证.使用委托和事件,整个代码可以顺利运行.

现在谈到挑战/问题:当点击该按钮时,我使用for循环(int i = 0; i <gridViewWsOperations.RowCount; i ++)=>换句话说,目前我正在对它们进行60次操作'同时'=>服务器同时处理60个请求超载,我得到超时.所以我需要以某种方式限制结束请求的数量,让我们同时说10.考虑一下,for循环(我必须将请求排入队列)与我将请求出列的方法(process_result事件)不在同一个线程中.我尝试使用ConcurrentQueue,因为这种类型的集合似乎是线程安全的.

链接

MSDN上的ConcurrentQueue

示例代码真的会有所帮助!

---这是我的解决方案/示例代码---

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.Concurrent;
using System.Threading;

namespace ConcurrentQueueSample
{
    class Program
    {
        static SemaphoreSlim semaphoreSlim = new SemaphoreSlim(3);

        static void Main(string[] args)
        {
            System.Timers.Timer timer = new System.Timers.Timer();
            timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
            timer.Interval = 1234;
            timer.Enabled = true;
            timer.Start();

            for (int i = 0; i < 10; i++) new Thread(go).Start(i);
        }

        static …
Run Code Online (Sandbox Code Playgroud)

c# queue stack winforms concurrent-collections

7
推荐指数
1
解决办法
719
查看次数

为erlang寻找持久的,分布式的工作队列

在重新发明轮子之前,我正在寻找满足这些要求的开源项目的指针.

  • 如果没有太多的包袱(例如:扭曲依赖的迷宫),在erlang中实现虽然go或C是可能的.
  • erlang中的端点或客户端(例如:我希望在执行作业时运行erlang代码.)
  • 将作业分配给节点,并调用一些erlang函数来完成这些作业.
  • 以某种方式坚持工作
  • 没有主节点,没有单点故障
  • 同质的建筑
  • 管理可能备份的作业队列,而不会丢弃工作
  • 一项工作不止一次是可以的
  • 像Riak或Couchbase这样的操作配置文件(例如:启动一个节点,然后启动其他节点并指向它们.)

强烈偏爱轻量级的东西.在erlang中有很多过度的企业级解决方案,看起来他们需要花费很长时间来学习,因为我将从头开始重新创建这个(事实上,我基本上构建了一个解决这个问题的解决方案来回答某人另外在stackoverflow上的问题.我可以构建我所描述的内容,但这似乎是正好在erlang的设计中间的那些需求之一.)

我考虑过: - ejabbered - 更多的消息传递框架 - rabitmq - 理论上这样做,但每次我去他们的网站我都淹没在抽象的海洋中.它似乎准备好做所有事情.我甚至无法判断它是否有任何持久性.

编辑添加:这是使用储物柜进行分布式锁定的幻灯片.似乎它解决了问题的一个关键部分(如果想要自己推出.) http://www.slideshare.net/knutnesheim/locker-distributed-consistent-locking

进一步编辑: 我真的在寻找比RabbitMQ更轻量级的东西.我知道它可以做我想要的,但似乎学习它的成本与自己做的成本相当,最终定制解决方案将更接近我真正需要的.

queue erlang worker elixir

7
推荐指数
2
解决办法
1954
查看次数

TensorFlow队列在关闭后是否可以重新打开?

我想将项目排队,关闭队列以确保其他会话将所有剩余项目出列,然后在下一个时期重新打开它.这可能吗?

q = tf.FIFOQueue(...)
close_q = q.close()
reopen_q = #???

with tf.Session([...]) as sess:
    [...]
    sess.run(close_q)
    [...]
    sess.run(reopen_q)
Run Code Online (Sandbox Code Playgroud)

queue tensorflow

7
推荐指数
1
解决办法
1508
查看次数

Python线程队列非常慢

我在线程中以非常高的速率(每秒几千个样本)获取样本(整数),并将put()它们放在threading.Queue. 主线程get()将样本逐个放入长度为4096的列表中,然后msgpack将它们发送出去,最后通过ZeroMQ将它们发送到客户端。客户端在屏幕上显示块(打印或绘图)。简而言之,最初的想法是,用单个样本填充队列,但以大块的形式清空它。

一切都 100% 符合预期。但后一部分,即访问队列非常非常慢。队列变大,输出总是滞后几秒到几十秒。

我的问题是:我该如何做才能使队列访问更快?有更好的方法吗?

python queue multithreading python-multithreading pyzmq

7
推荐指数
1
解决办法
4838
查看次数

类型错误:无法使用 RQ 腌制“_thread.lock”对象

我正在使用带有烧瓶的 RQ 在循环中排队作业。我有以下代码:

from rq import Queue
from rq.job import Job
from worker import conn

q = Queue(connection=conn)

for i in range(5):
    job = q.enqueue_call(
    func=process_data, args=(i, data,))
    print(job.get_id()) 
Run Code Online (Sandbox Code Playgroud)

现在我收到错误:

TypeError: cannot pickle '_thread.lock' object
Run Code Online (Sandbox Code Playgroud)

我有以下代码的工人:

import os

import redis
from rq import Worker, Queue, Connection

listen = ['default']

redis_url = os.getenv('REDISTOGO_URL', 'redis://localhost:6379')

conn = redis.from_url(redis_url)

if __name__ == '__main__':
    with Connection(conn):
        worker = Worker(list(map(Queue, listen)))
        worker.work()
Run Code Online (Sandbox Code Playgroud)

如何纠正?

python queue flask

7
推荐指数
1
解决办法
1188
查看次数