我知道std::queue::pop()回报void.有两个原因:
精细.
现在,如果我理解新的C++ 11正确移动语义,那么第二个不再是有效的参数.
所以...唯一阻止std::queue类似pop函数返回值的东西在于移动构造函数抛出的可能性？
我很难想到这样一个移动构造函数会抛出的情况.谁知道一个例子？
我想这同样适用于std::stack::pop(),std::vector::pop_front(), std::vector::pop_back(),std::deque::pop_front(), std::deque::pop_back(),std::list::pop_front(), std::list::pop_back(),什么不是.
更新:这是我实施的哈希定时轮.如果您有提高性能和并发性的想法,请告诉我.(20月- 2009年)
// Sample usage:
public static void main(String[] args) throws Exception {
Timer timer = new HashedWheelTimer();
for (int i = 0; i < 100000; i ++) {
timer.newTimeout(new TimerTask() {
public void run(Timeout timeout) throws Exception {
// Extend another second.
timeout.extend();
}
}, 1000, TimeUnit.MILLISECONDS);
}
}
更新:我通过使用Hierarchical和Hashed Timing Wheels解决了这个问题.(19月- 2009年)
我正在尝试在Java中实现一个特殊用途计时器,它针对超时处理进行了优化.例如,用户可以使用死线注册任务,并且计时器可以在死线结束时通知用户的回调方法.在大多数情况下,注册任务将在很短的时间内完成,因此大多数任务将被取消(例如task.cancel())或重新安排到将来(例如task.rescheduleToLater(1,TimeUnit.SECOND)) .
我想使用此计时器来检测空闲套接字连接(例如,在10秒内没有收到消息时关闭连接)和写入超时(例如,当写操作未在30秒内完成时引发异常.)在大多数情况下,超时不会发生,客户端将发送一条消息,除非有一个奇怪的网络问题,否则将发送响应.
我不能使用java.util.Timer或java.util.concurrent.ScheduledThreadPoolExecutor,因为它们假设大多数任务都应该超时.如果取消任务,则取消的任务将存储在其内部堆中,直到调用ScheduledThreadPoolExecutor.purge(),这是一项非常昂贵的操作.(也许是O(NlogN)？)
在我在CS类中学到的传统堆或优先级队列中,更新元素的优先级是一项昂贵的操作(在许多情况下为O(logN),因为它只能通过删除元素并重新插入元素来实现.新的优先级值.像Fibonacci堆的一些堆有减少Key()和min()操作的O(1)时间,但我至少需要快速的raiseKey()和min()(或者reduceKey()和max()) .
您是否知道针对此特定用例高度优化的任何数据结构？我正在考虑的一个策略是将所有任务存储在哈希表中并每隔一秒左右迭代所有任务,但这并不是那么美妙.
我只看到一个Queue接口,Java Collections中没有Queue类吗？
有没有更好的方法在执行另一个进程之前等待排队的线程？
目前我在做:
this.workerLocker = new object(); // Global variable
this.RunningWorkers = arrayStrings.Length; // Global variable
// Initiate process
foreach (string someString in arrayStrings)
{
ThreadPool.QueueUserWorkItem(this.DoSomething, someString);
Thread.Sleep(100);
}
// Waiting execution for all queued threads
lock (this.workerLocker) // Global variable (object)
{
while (this.RunningWorkers > 0)
{
Monitor.Wait(this.workerLocker);
}
}
// Do anything else
Console.WriteLine("END");
// Method DoSomething() definition
public void DoSomething(object data)
{
// Do a slow process...
.
.
.
lock (this.workerLocker)
{
this.RunningWorkers--;
Monitor.Pulse(this.workerLocker);
}
}
我正在寻找使用pthread同步语义在C中推荐的线程安全阻塞队列(多生产者/消费者)的实现.
我希望我的客户发送的数据(通过邮件)放在队列中,我服务器上的PHP脚本首先检查队列是否为空.如果队列不为空,那么脚本将逐个处理队列中的所有数据.我该怎么办？
当使用Java的for每种语法时,Stack不对输出的元素使用LIFO排序.请考虑以下代码:
import java.util.Queue;
import java.util.Stack;
import java.util.LinkedList;
public class QueueStackTest {
private static int[] numbers = {1, 2, 3, 4, 5};
public static void main(String[] args) {
Stack<Integer> s = new Stack<Integer>();
Queue<Integer> l = new LinkedList<Integer>();
for (int i : numbers) {
s.push(i);
l.offer(i);
}
System.out.println("Stack: ");
for(Integer i : s) {
System.out.println(i);
}
System.out.println();
System.out.println("Queue:");
for(Integer i : l) {
System.out.println(i);
}
}
}
输出:
Stack:
1
2
3
4
5
Queue:
1
2 …我在Go中构建了一个简单的队列.它使用内部切片来跟踪其元素.通过附加到切片将元素推送到队列中.我想.Pop()通过删除第一个元素来实现elements.
在许多其他语言中,"弹出"列表的第一个元素是一个单行,这使我相信我的实现在下面是草率和冗长.有没有更好的办法？
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) > 1 {
queue.elements = queue.elements[1:]
} else {
queue.elements = make([]interface{}, 0)
}
return element
}
请注意,我希望Queue如果恐慌len(queue.elements) == 0.我不检查边界不是疏忽.
我目前正在研究普林斯顿的算法第一部分.其中一项任务是实现一个随机队列.这是关于使用不同数据结构的实现和权衡的问题.
题:
随机队列类似于堆栈或队列,除了从数据结构中的项目随机均匀地选择移除的项目.创建实现以下API的通用数据类型RandomizedQueue:
public class RandomizedQueue<Item> implements Iterable<Item> {
public RandomizedQueue() // construct an empty randomized queue
public boolean isEmpty() // is the queue empty?
public int size() // return the number of items on the queue
public void enqueue(Item item) // add the item
public Item dequeue() // remove and return a random item
public Item sample() // return (but do not remove) a random item
public Iterator<Item> iterator() // return an independent iterator over items in random order …我在这里搜索了如何在python中进行线程化,但到目前为止我还没有得到我需要的答案.我对Queue和Threading python类不太熟悉,因此这里出现的一些anwsers对我来说毫无意义.
我想创建一个线程池,我可以给出不同的任务,当它们全部结束时获取结果值并处理它们.到目前为止,我试图这样做,但我无法得到结果.我写的代码是:
from threading import Thread
from Queue import Queue
class Worker(Thread):
"""Thread executing tasks from a given tasks queue"""
def __init__(self, tasks):
Thread.__init__(self)
self.tasks = tasks
self.daemon = True
self.result = None
self.start()
def run(self):
while True:
func, args, kargs = self.tasks.get()
try:
self.result = func(*args, **kargs)
except Exception, e:
print e
self.tasks.task_done()
def get_result(self):
return self.result
class ThreadPool:
"""Pool of threads consuming tasks from a queue"""
def __init__(self, num_threads):
self.tasks = Queue(num_threads)
self.results = []
for _ …