标签: queue

有什么方法可以使用multiprocessing数据结构创建发布/订阅模式？换句话说，我希望有一个类似队列的东西，除了发布者可以同时向多个工作程序发送单个命令。

我正在使用多个队列,并希望将事件推送到另一个队列而不是默认队列.

我有一个实现ShouldQueue的标准事件类,但是如何指定此事件将被推送到的队列？

我试过了

class NewMessageArrived extends Event implements ShouldQueue
{
    use SerializesModels;
    protected $queue = 'redis';
    ....

但这不符合我的要求.有没有办法做到这一点？

我想在Laravel中使用Queue将消息推送到Queue。因此，我想先尝试基本流程，此刻会引发错误。

在Laravel中使用CommandBus时，我创建了一个侦听器：

侦听器-IncidentNotifier.php

<?php

namespace App\Listeners;


use App\Events\Incident\IncidentWasPosted;
use App\Events\EventListener;
use App\Http\Traits\SearchResponder;
use App\Jobs\SendAlarmToResponder;
use Illuminate\Foundation\Bus\DispatchesJobs;

class IncidentNotifier extends EventListener {

    use DispatchesJobs, SearchResponder;

    public function whenIncidentWasPosted(IncidentWasPosted $event) {
        $responders = $this->getResponderInRange($event);
        $this->dispatch(new SendAlarmToResponder($responders));
    }
}

该侦听器应将作业（尚未完成）排队以使用推送通知服务，因为这将在当前不使用Queue的情况下阻塞我的系统。

职位-SendToAlarmResponder.php

<?php

namespace App\Jobs;

use App\Jobs\Job;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Bus\SelfHandling;
use Illuminate\Contracts\Queue\ShouldQueue;

class SendAlarmToResponder extends Job implements SelfHandling, ShouldQueue
{
    use InteractsWithQueue, SerializesModels;

    protected $responders = array();

    public function __construct($responders)
    {
        $this->$responders = $responders;
    }

    public function handle($responders)
    {
        var_dump($responders);
    } …

我必须在一个实现入队操作queue.在节点结构中,datatypefor dataPtr是void*.这是我的代码,但在调用此函数时,如何传递参数？

typedef struct node
{
void* dataptr;
 struct node* next;
 } QUEUE_NODE;

typedef struct
{
    QUEUE_NODE* front;
    QUEUE_NODE* rear;
    int count;
}QUEUE;

//createqueue
QUEUE* createQueue(void)
{
    QUEUE* queue;
    queue = (QUEUE*)malloc(sizeof(QUEUE));
    if (queue)
    {
        queue->front = NULL;
        queue->rear = NULL;
        queue->count = 0;
    }
    return queue;
}
//Enqueue
bool enqueue(QUEUE* queue, void* itemptr)
{
    QUEUE_NODE* newptr;
    if (!(newptr = (QUEUE_NODE*)malloc(sizeof(QUEUE_NODE))))
        return false;
    newptr->dataptr = itemptr;
    newptr->next = NULL;
    if (queue->count == 0) …

我正在尝试建立一个能够显示先出先出概念的队列.我想要一个作为等待名单的数组.后来的病人将在晚些时候出院.在这个房间里有24名病人的限制,其余的将进入等待名单.每当房间空无一人时,等候室(最早)的第一批病人就会前往房间.这是我到目前为止提出的代码.任何帮助是极大的赞赏.

    Dim arrayU() As Variant
    Dim arrayX() As Variant
    Dim arrayW() As Variant
    Dim LrowU As Integer
    Dim LrowX As Integer
    Dim LrowW As Integer
    'Dim i As Integer
    Dim j As Integer
    Dim bed_in_use As Integer

    LrowU = Columns(21).Find(What:="*", LookIn:=xlValues, SearchOrder:=xlByRows, SearchDirection:=xlPrevious).Row
    LrowX = Columns(24).Find(What:="*", LookIn:=xlValues, SearchOrder:=xlByRows, SearchDirection:=xlPrevious).Row
    LrowW = Columns(23).Find(What:="*", LookIn:=xlValues, SearchOrder:=xlByRows, SearchDirection:=xlPrevious).Row

    ReDim arrayU(1 To LrowU)
    ReDim arrayX(1 To LrowX)
    ReDim arrayW(1 To LrowW)

    For i = 3 To LrowU
        arrayU(i) = Cells(i, 21)
    Next i

    i …

我试图了解池和队列如何在Python中工作，并且以下示例未按预期工作。我希望程序结束，但是由于第二个队列没有清空，它陷入了无限循环。

import multiprocessing
import os
import time

inq = multiprocessing.Queue()
outq = multiprocessing.Queue()

def worker_main(q1, q2):
    while True:
        i = q1.get(True)
        time.sleep(.1) 
        q2.put(i*2)

def worker2(q):
    print q.get(True)

p1 = multiprocessing.Pool(3, worker_main,(inq, outq,))
p2 = multiprocessing.Pool(2, worker2,(outq,))


for i in range(50):
    inq.put(i)


while inq.qsize()>0 or outq.qsize()>0:
    print 'q1 size', inq.qsize(), 'q2 size', outq.qsize()
    time.sleep(.1)

输出显示第二个队列（outq）为.get一次，仅此而已。

输出：

q1 size 49 q2 size 0
q1 size 47 q2 size 0
2
4
q1 size 44 q2 size 1
q1 size 41 q2 size …

Run Code Online (Sandbox Code Playgroud)

我正在实现一个BOOOS - 基于面向对象的操作系统,现在我需要让我的程序调度程序在FCFS和Priority之间进行选择.我有一个名为Task的类,我创建了两个队列:std::queue和a std::priority_queue.这些队列是在Task.h中声明的静态成员,我需要在Task.cc中的任何其他东西之前初始化该类的其他静态成员,如下所示:

namespace BOOOS {

    volatile Task * Task::__running;
    Task * Task::__main;
    int Task::__tid_count;
    int Task::__task_count;
    std::queue<Task*> Task::__ready;
    std::priority_queue<Task*> Task::__ready;

    (rest of the Task.cc)

}

你可以看到我有两个__ready队列.这就是为什么我只需要使用其中一个.如果用户想要初始化FCFS调度程序,我使用没有优先级的那个,如果用户想要优先级调度程序,我使用priority_queue.这是由BOOOS的静态枚举成员控制的.所以,这是我的问题:我可以if在代码的这一部分中使用类似的东西来选择只有一个队列而不是创建两个队列并且if每次我需要在我的程序中操作它吗？

队列的大小可以通过使用 qsize()

• 我们如何知道队列的最大大小？或以其他方式，条件queue.full()何时返回True？

• 为什么结果q.put(i)总是产生，None而结果q.get(i)却产生相应的价值？

  from queue import Queue
  q = Queue()
  
  print("------Queue info when putting -----")
  
  for i in range(5):
     print("---Loop---- :",i) 
     print("queue empty : ", q.empty())
     print("put : ",q.put(i))
     print("queue size : ", q.qsize())
     print("queue full : ", q.full())
  
  print("------Queue info when getting -----")        
  
  for i in range(5): 
     print("---Loop---- :",i)
     print("get : ",q.get(i))
     print("task done : ",q.task_done())
     print("queue empty : ", q.empty())
  

  Run Code Online (Sandbox Code Playgroud)

输出如下：

------Queue info when putting -----     
---Loop---- …

请帮我转换这行到swift 3.0:

dispatch_async(DispatchQueue.global(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0))

它究竟意味着什么？类似于:在主队列中的括号中执行代码？

提前致谢.

PS.这行代码取自苹果公司的代码,用于处理核心数据

我正在尝试读取像队列一样使用的数据库表的前100项.当我这样做时,我试图将这些项目标记为:

UPDATE TOP(@qty)
    QueueTable WITH (READPAST)  
SET 
    IsDone = 1
OUTPUT
    inserted.Id,
    inserted.Etc
FROM
    QueueTable 
WHERE
    IsDone = 0
ORDER BY
    CreatedDate ASC;

唯一的问题是,根据MSDN上的UPDATE(Transact-SQL),它ORDER BY在UPDATE和中无效:

与INSERT,UPDATE或DELETE一起使用的TOP表达式中引用的行不按任何顺序排列.

我如何实现我需要的更新队列顶部的项目同时选择它们？