标签: queue

Scala - 出队不返回正确的结果

我有一个 List[Any] 队列,但不知何故出队不会返回正确的结果,也不会从队列中删除该项目。知道为什么会这样吗?

下面是一个例子:

scala> val a = scala.collection.immutable.Queue(List(1, "A", "B", 987), List(2, "C", "D", 456), List(3, "E", "F", 123))
a: scala.collection.immutable.Queue[List[Any]] = Queue(List(1, A, B, 987), List(2, C, D, 456), List(3, E, F, 123))

scala> a.dequeue
res5: (List[Any], scala.collection.immutable.Queue[List[Any]]) = (List(1, A, B, 987),Queue(List(2, C, D, 456), List(3, E, F, 123)))

scala> a
res6: scala.collection.immutable.Queue[List[Any]] = Queue(List(1, A, B, 987), List(2, C, D, 456), List(3, E, F, 123))
Run Code Online (Sandbox Code Playgroud)

queue scala

2
推荐指数
1
解决办法
368
查看次数

python多处理队列实现

我无法理解如何将队列实现到下面的多处理示例中。基本上,我希望代码:

1)产生2个进程(完成)

2)将我的 id_list 分成两部分(完成)

3)让每个进程迭代列表打印出每个项目,并且只有在完成列表后才关闭。我知道我必须实现某种类型的排队系统,并将其传递给每个工作人员,但我不确定如何做到这一点。任何帮助将非常感激。

from multiprocessing import Pool,Queue
id_list = [1,2,3,4,5,6,7,8,9,10]

def mp_worker(record):
    try:  
        print record
        sleep(1)
    except: pass
    print "worker closed"

def mp_handler():
    p = Pool(processes = 2) #number of processes
    p.map(mp_worker, id_list)  #devides id_list between 2 processes, defined above
    p.close()
    p.join()

mp_handler()
Run Code Online (Sandbox Code Playgroud)

注意 - 代码打印出“工人关闭”10 次。我希望这条语句只打印两次(每个工人一次,在每个工人从 id_list 打印出 5 个数字之后)

python queue multiprocessing

2
推荐指数
1
解决办法
7383
查看次数

NiFi如何清除所有队列

我目前使用的是 NiFi 1.5.0(但它与以前的版本相同),我想知道是否有办法同时清除所有队列?

当处理器数量增加时,重置所有内容可能会很长。

(我已经知道如何清除单个队列: 如何清除 NiFi 队列?)

我正在寻找使用 UI 或 API 的解决方案

提前致谢 !

queue apache-nifi

2
推荐指数
1
解决办法
5261
查看次数

如何从队列中分块取出项目?

我有多个生产者线程同时将对象添加到共享队列。

我想创建一个从共享队列中读取数据以进行进一步数据处理(数据库批量插入)的单线程使用者。

问题:我只想从队列中分块获取数据,以便在批量插入期间获得更好的性能。因此,我必须以某种方式检测队列中有多少项目,然后从队列中取出所有这些项目,然后再次清空队列。

 BlockingQueue<Integer> sharedQueue = new LinkedBlockingQueue<>();

 ExecutorService pes = Executors.newFixedThreadPool(4);
 ExecutorService ces = Executors.newFixedThreadPool(1);

 pes.submit(new Producer(sharedQueue, 1));
 pes.submit(new Producer(sharedQueue, 2));
 pes.submit(new Producer(sharedQueue, 3));
 pes.submit(new Producer(sharedQueue, 4));
 ces.submit(new Consumer(sharedQueue, 1));

class Producer implements Runnable {
    run() {
            ...
            sharedQueue.put(obj);
    }
}

class Consumer implements Runnable {
    run() {
            ...
            sharedQueue.take();
    }
}
Run Code Online (Sandbox Code Playgroud)

消费者的问题:如何轮询共享队列,等待队列中有 X 个项目,然后取出所有项目并同时清空队列(这样消费者可以再次开始轮询和等待)?

我愿意接受任何建议,并且不一定与上面的代码绑定。

java queue concurrency

2
推荐指数
1
解决办法
702
查看次数

来自一个多处理管理器的多个队列

我正在编写一个将使用 python 的多处理和线程模块的脚本。为了您的理解,我产生了尽可能多的内核可用的进程,并且在每个进程中我启动了例如 25 个线程。每个线程从一个消费input_queue并产生一个output_queue。对于队列对象,我使用multiprocessing.Queue.

在我的第一次测试之后,我遇到了死锁,因为负责提供和刷新队列的线程挂了。一段时间后,我发现我可以用它Queue().cancel_join_thread()来解决这个问题。

但由于数据丢失的可能性,我想使用: multiprocessing.Manager().Queue()

现在的实际问题是:为每个队列使用一个管理器对象是否更好?或者我应该创建一个管理器并从同一个管理器对象中获取两个问题?

# One manager for all queues
import multiprocessing

manager = multiprocessing.Manager()
input_queue = manager.Queue()
output_queue = manager.Queue()

...Magic...

# As much managers as queues
manager_in = multiprocessing.Manager()
queue_in = manager_in.Queue()

manager_out = multiprocessing.Manager()
queue_out = manager_out.Queue()

...Magic...
Run Code Online (Sandbox Code Playgroud)

感谢您的帮助。

python queue multithreading python-multiprocessing

2
推荐指数
1
解决办法
5561
查看次数

Rabbitmq 一个队列中的不同消息类型

是否有任何解决方案可以在不同的消息类型之间共享一个队列?

我知道主题交换,但它使用不同的队列。

c# queue amqp rabbitmq

2
推荐指数
1
解决办法
2544
查看次数

为什么 deque 比 queue 快?

我有以下工作代码(g++ 8.2,C++17 标准。)

    queue<TreeNode*> q{};

    q.push(root);
    q.push(nullptr);
    int sum = root -> val;
    while (!q.empty()) {
        TreeNode *n = q.front();
        q.pop();

        if (n != nullptr) {
            sum += n->val;
            if (n-> left != nullptr) q.push(n->left);
            if (n-> right != nullptr) q.push(n->right);   
        } else {
            if (q.empty()) break;
            q.push(nullptr);
            sum = 0;
        }

    }
    return sum;
Run Code Online (Sandbox Code Playgroud)

然后我queue<TreeNode*>用deque<TreeNode*>. 事实证明,速度至少提高了 20%。为什么deque<TreeNode*>比 快这么多queue<TreeNode*>?

c++ queue deque data-structures

2
推荐指数
1
解决办法
650
查看次数

Apache Pulsar 消息传递语义

我浏览了消息传递语义的 Apache Pulsar 文档。Apache 函数提到的交付语义(至少一次,最多一次和有效一次),如果我们不使用 Apache 函数,那么可用的所有不同交付语义是什么?

queue message-queue apache-pulsar

2
推荐指数
1
解决办法
902
查看次数

fs2 并发队列 Scala:缺乏洞察力

我是一个新手,试图掌握 fs2 队列背后的直觉。我正在尝试做一个从Stream[IO, Int]. 但是文档对我来说是不够的,因为它直接深入到高级内容中。

这是我到目前为止所做的:

import cats.effect.{ ExitCode, IO, IOApp}
import fs2._
import fs2.concurrent.Queue

class QueueInt(q: Queue[IO, Int]) {
  def startPushingtoQueue: Stream[IO, Unit] = {
    Stream(1, 2, 3).covary[IO].through(q.enqueue)
    q.dequeue.evalMap(n => IO.delay(println(s"Pulling element $n from Queue")))
  }
}

object testingQueues extends IOApp {
  override def run(args: List[String]): IO[ExitCode] = {

    val stream = for {
      q <- Queue.bounded(10)
      b = new QueueInt(q)
      _ <- b.startPushingtoQueue.drain
    } yield ()
  }

}
Run Code Online (Sandbox Code Playgroud)

问题 1:我No implicit argument of type Concurrent[F_], …

queue scala stream fs2

2
推荐指数
1
解决办法
661
查看次数

Segmentation fault while trying to implement fixed size queue in C++

I wanted to implement a fixed size queue, I could have easily done with a struct having a queue as one of the data members and a member function that takes care of the push part of the queue, but rather wanted to try it out by inheriting queue like this.

template<typename T>
struct f_queue : public queue<T>{
    int n;
    T prev;

    f_queue(int n_):
        n(n_){}

    void push(T data){
        if(this->size() < this->n){
            this->push(data);
        }else{
            prev = this->front();
            this->pop();
            this->push(data);
        }
    } …
Run Code Online (Sandbox Code Playgroud)

c++ queue stl segmentation-fault

2
推荐指数
1
解决办法
78
查看次数