我有一个 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) 我无法理解如何将队列实现到下面的多处理示例中。基本上,我希望代码:
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 个数字之后)
我目前使用的是 NiFi 1.5.0(但它与以前的版本相同),我想知道是否有办法同时清除所有队列?
当处理器数量增加时,重置所有内容可能会很长。
(我已经知道如何清除单个队列: 如何清除 NiFi 队列?)
我正在寻找使用 UI 或 API 的解决方案
提前致谢 !
我有多个生产者线程同时将对象添加到共享队列。
我想创建一个从共享队列中读取数据以进行进一步数据处理(数据库批量插入)的单线程使用者。
问题:我只想从队列中分块获取数据,以便在批量插入期间获得更好的性能。因此,我必须以某种方式检测队列中有多少项目,然后从队列中取出所有这些项目,然后再次清空队列。
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 个项目,然后取出所有项目并同时清空队列(这样消费者可以再次开始轮询和等待)?
我愿意接受任何建议,并且不一定与上面的代码绑定。
我正在编写一个将使用 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)
感谢您的帮助。
是否有任何解决方案可以在不同的消息类型之间共享一个队列?
我知道主题交换,但它使用不同的队列。
我有以下工作代码(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*>?
我浏览了消息传递语义的 Apache Pulsar 文档。Apache 函数提到的交付语义(至少一次,最多一次和有效一次),如果我们不使用 Apache 函数,那么可用的所有不同交付语义是什么?
我是一个新手,试图掌握 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_], …
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)