我正在寻找一个INotifyCollectionChanged的实施Stack和Queue.我可以自己滚动,但我不想重新发明轮子.
我创建了一个自定义通用队列,它实现了一个通用的IQueue接口,该接口使用System.Collections.Generic命名空间中的通用Queue作为私有内部队列.示例已清除不相关的代码.
public interface IQueue<TQueueItem>
{
void Enqueue(TQueueItem queueItem);
TQueueItem Dequeue();
}
public class CustomQueue<TQueueItem> : IQueue<TQueueItem>
{
private readonly Queue<TQueueItem> queue = new Queue<TQueueItem>();
...
public void Enqueue(TQueueItem queueItem)
{
...
queue.Enqueue( queueItem );
...
}
public TQueueItem Dequeue()
{
...
return queue.Dequeue();
...
}
}
Run Code Online (Sandbox Code Playgroud)
我希望保持与核心实现的一致性,并注意到核心Queue实现了IEnumerable,所以我将通过在类上显式实现IEnumerable或使用IQueue接口继承它来做同样的事情.
我想知道的是,当列举队列时,每个移动接下来要将下一个项目出列?我已经使用反射器来了解微软是如何做到的,他们所做的只是逐步通过队列私有阵列,但微软远非绝对不可靠,所以我想得到一般意见.
public class CustomQueue<TQueueItem> : IQueue<TQueueItem>, IEnumerable<TQueueItem>
{
...
public IEnumerator<TQueueItem> GetEnumerator()
{
while (queue.Count > 0)
{
yield return Dequeue();
}
}
//Or
public IEnumerator<TQueueItem> GetEnumerator()
{
return queue.GetEnumerator();
}
...
} …Run Code Online (Sandbox Code Playgroud) 我是python的新手(我来自PHP),我一直在阅读教程和尝试几天,但我无法理解这个队列示例(http://docs.python.org/2/library /que.html)
def worker():
while True:
item = q.get()
do_work(item)
q.task_done()
q = Queue()
for i in range(num_worker_threads):
t = Thread(target=worker)
t.daemon = True
t.start()
for item in source():
q.put(item)
q.join() # block until all tasks are done
Run Code Online (Sandbox Code Playgroud)
我不明白的是工作线程是如何完成和存在的.我已经读过q.get()块,直到一个项可用,所以如果所有项都被处理并且没有留在队列中,为什么q.get()不会永远阻塞?
我有成千上万的文本文件,我想以各种方式解析.我想将输出保存到单个文件而不会出现同步问题.我一直在使用多处理池来节省时间,但我无法弄清楚如何组合池和队列.
以下代码将保存infile名称以及文件中连续"x"的最大数量.但是,我希望所有进程将结果保存到同一个文件,而不是像我的示例中那样保存到不同的文件.任何有关这方面的帮助将不胜感激.
import multiprocessing
with open('infilenamess.txt') as f:
filenames = f.read().splitlines()
def mp_worker(filename):
with open(filename, 'r') as f:
text=f.read()
m=re.findall("x+", text)
count=len(max(m, key=len))
outfile=open(filename+'_results.txt', 'a')
outfile.write(str(filename)+'|'+str(count)+'\n')
outfile.close()
def mp_handler():
p = multiprocessing.Pool(32)
p.map(mp_worker, filenames)
if __name__ == '__main__':
mp_handler()
Run Code Online (Sandbox Code Playgroud) 我有一个线程将结果写入队列.
在另一个线程(GUI)中,我定期(在IDLE事件中)检查队列中是否有结果,如下所示:
def queue_get_all(q):
items = []
while 1:
try:
items.append(q.get_nowait())
except Empty, e:
break
return items
Run Code Online (Sandbox Code Playgroud)
这是一个很好的方法吗?
编辑:
我问,因为有时等待的线程会卡住几秒而不会取出新的结果.
"卡住"问题原来是因为我在空闲事件处理程序中进行处理,而不是确保通过调用实际生成这样的事件wx.WakeUpIdle,如建议的那样.
因此,在嵌入式系统部门,我明年将参加大学,我们将了解到动态数据结构在嵌入式系统程序中是一件坏事.但讲义没有说明原因.
现在我正在开发一个中等规模的嵌入式系统LURC控制器,主要是利用AVR169MEGA的"Butterfly"演示板的外围设备.产生4个PWM信号来控制伺服和ESC.并提供9 seg液晶屏.
现在我想不出任何更好的存储指令的方法,因为它们是收到的小瓶USART序列,而不是队列.尤其是我需要等待收到未知数量的数据的东西:例如,要在LCD屏幕上显示的字符串.
那你为什么不在嵌入式系统的微控制器上使用动态数据结构呢?只是你在一个严重的内存限制环境中,并且必须确保你的mallocs成功吗?
我是企业Java开发的新手,虽然我确信这个问题同样适用于任何语言或平台,例如.NET.
我现在第一次处理消息队列,我对他们非常感兴趣.(具体来说,我们使用的是ActiveMQ).我的技术主管希望ActiveMQ队列成为我们所有数据库和内部Web服务的领跑者; 因此,不是从客户端发出数据库查询而是直接转到数据库,它首先排队.
我的问题是:排队等待每个主要处理组件的方式?最佳实践是否要求将它们放在通常会受到大量请求影响的系统组件之前?是否存在不应使用队列的情况?
感谢您的任何见解!
我正在寻找Scala中的FIFO流,即提供功能的东西
流应该是可关闭的,并且应该阻止访问下一个元素,直到添加元素或关闭流.
实际上我有点惊讶的是,集合库没有(似乎)包含这样的数据结构,因为IMO是一个非常经典的数据结构.
我的问题:
1)我忽略了什么吗?是否已有提供此功能的课程?
2)好的,如果它没有包含在集合库中,那么它可能只是现有集合类的一个简单组合.但是,我试图找到这个简单的代码,但对于这样一个简单的问题,我的实现看起来仍然非常复杂.这样的FifoStream有更简单的解决方案吗?
class FifoStream[T] extends Closeable {
val queue = new Queue[Option[T]]
lazy val stream = nextStreamElem
private def nextStreamElem: Stream[T] = next() match {
case Some(elem) => Stream.cons(elem, nextStreamElem)
case None => Stream.empty
}
/** Returns next element in the queue (may wait for it to be inserted). */
private def next() = {
queue.synchronized {
if (queue.isEmpty) queue.wait()
queue.dequeue()
}
}
/** Adds new elements to this stream. */
def …Run Code Online (Sandbox Code Playgroud)我需要a HashMap或simpy a Map,其中固定数量的元素(n)像FIFO队列一样工作.
因此,在元素编号<= n之前,新元素只需放入地图中.
对于元素编号> n,将删除第一个插入的元素,并将最新的元素放入地图中.
Java中有类似的东西,还是我必须实现它?
我有一个Queueq1,我想创建一个Queue与Queueq1 相同的q2.如何做到这一点,因为Queue没有实现Cloneable.