标签: queue

我有一个 FIFO 和两个线程。一个线程只会从 FIFO 入队，而另一个线程只会从 FIFO 出队。我需要使用 ConcurrentQueue 还是 Queue 就足够了？

任何人都可以帮助我使用 python 中的 bfs 代码吗？它只是打印自我价值，而不是整棵树。

from queue import *

class BinaryTree:
   def __init__(self,info,left,right):
    self.info  = info
    self.left  = left
    self.right = right

def bfs(self): 
    queue = Queue()
    queue.put(self)

    while not queue.empty():
        self = queue.get()
        print(self.info)

        if self.left:
            queue.put(self.left)

        if self.right:
            queue.put(self.right)
        return

nine = BinaryTree("9",None,None)
eleven = BinaryTree("11",None,None)
two = BinaryTree("2",eleven,nine)
one   = BinaryTree("1",None,None)
seven = BinaryTree("7",one,None)
five = BinaryTree("5",seven,two)
three = BinaryTree("3",None,None)
six = BinaryTree("6",None,None) 
four = BinaryTree("4",None,six)
eight = BinaryTree("8",four,three)
ten = BinaryTree("10",eight,five)

ten.bfs()

我的答案只是“10”，而不是整棵树。我找不到错误。

    导入队列
    q = queue.Queue()
    q.put(5)
    q.put(7)

print(q.get()) 删除队列前面的元素。如何在不删除它的情况下打印此元素？有可能这样做吗？

我正在寻找一种在 freeRTOS 中使用队列广播消息的方法，我提出了不同的想法，但每个人都有不同的问题。

我拥有的：

• 队列的项目类型是一个结构体，它有一个属性来指示消息是广播还是针对特定任务。
• 将消息写入队列的广播任务。
• 一个队列管理器任务，如果收到任何新消息，它将查看队列，并且如果消息有目的地，那么它将恢复该特定任务或恢复所有任务（如果它是广播）。

• 对于接收器任务，我提出了这些想法：

  1. 如果我使用接收函数，xQueueReceive只有任务队列中的第一个任务会读取消息并将其从队列中删除，这样其他任务将无法读取该广播消息。另一方面，这是定向消息（针对特定任务的消息）的完美原因。
  2. 如果我使用 peedk 函数xQueuePeek，消息将永远不会从队列中删除，除非我使用xQueueReceive它有点多余（在同一个任务中查看和接收，meeh，丑陋的编码）并且我不能使用任何其他删除函数，因为它会删除整个队列。但这将解决特定任务的消息，为了解决广播消息，我需要为每个接收任务设置优先级，并且只有优先级最低的任务才会使用xQueueReceive 从队列中删除该消息，所有接收任务将在偷看或阅读后暂停自己，这样他们就不会再次阅读该消息（我不确定如何处理队列管理器任务，因为我无法暂停它，它会保持队列中的新消息的通知，直到最后一个任务收到它），但整个系统将需要等待该低优先级任务运行以删除该消息以及在该时间内收到的任何新消息，它将不会被读入真实的时间。

我仍在考虑其他方法，例如为每个接收任务使用新队列或队列，但我不确定哪种方法是最好的。而且我不知道是否还有其他原因即使不使用队列技术也要广播消息。

我需要告诉你这个程序不是针对特定项目的。我只是想以不同的方式使用队列技术。我已经找到了关于广播消息的其他帖子，但这是针对特定问题的，他们在不使用队列技术的情况下解决了该问题。我只想将“这是一条广播消息”发送到队列，并且所有接收器都能够读取一次（仅一次）。

谢谢你。

我有一个广播事件，客户端有订阅频道：

/**
* Get the channels the event should broadcast on.
*
* @return PrivateChannel
*/
public function broadcastOn()
{
    return new PrivateChannel("user.{$this->userId}");
}

如何一次将数据发送到多个通道（在 user.1、user.2、user.3 ...上）？

细化，针对特定用户，而不是针对已订阅房间的每个人。

我有几种方法可以向数据库报告一些数据。我们希望异步调用对数据服务的所有调用。这些对数据服务的调用都结束了，因此我们要确保这些 DS 调用在任何给定时间按顺序依次执行。最初，我在这些方法中的每一个上使用 async await 并且每个调用都是异步执行的，但我们发现如果它们乱序，那么就有出错的空间。

所以，我认为我们应该将所有这些异步任务排队并在一个单独的线程中发送它们，但我想知道我们有哪些选择？我遇到了 'SemaphoreSlim' 。这在我的用例中是否合适？或者还有哪些其他选项适合我的用例？请指导我。

所以，我目前在我的代码中有什么

public static SemaphoreSlim mutex = new SemaphoreSlim(1);

//first DS call 

 public async Task SendModuleDataToDSAsync(Module parameters)
    {
        var tasks1 = new List<Task>();
        var tasks2 = new List<Task>();

        //await mutex.WaitAsync(); **//is this correct way to use SemaphoreSlim ?**
        foreach (var setting in Module.param)
        {
           Task job1 = SaveModule(setting);
           tasks1.Add(job1);
           Task job2= SaveModule(GetAdvancedData(setting));
           tasks2.Add(job2);
        }

        await Task.WhenAll(tasks1);
        await Task.WhenAll(tasks2);

        //mutex.Release(); // **is this correct?**
    }

 private async Task SaveModule(Module setting)
    {
        await Task.Run(() …

我想创建一个Queueof stores 类型List<Integer>。

我试过 ：

Queue<List<Integer>> q = ...;

但是，我不知道在 之后我应该按什么'='。

我正在做一个 Laravel 项目。我正在使用作业队列来执行一些功能。我使用主管来运行作业监听命令。但我不太了解这个概念。这是我的问题。

1. 我有8个工人。他们如何参与作业队列系统？
2. 如果我增加它们的数量，作业处理速度会更快吗？
3. 只要我增加它们，它也会占用更多的内存吗？如果我的服务器有 16GB 内存，我可以有多少工人？
4. 作业要排队吗？（下图）

Delphi 的泛型TQueue类有一个属性，叫做Capacity.如果其中的项目数TQueue超过其容量，额外的项目仍会添加到队列中。文档说该属性“获取或设置队列容量，即不调整大小的队列的最大大小。” 听起来队列有点像固定长度的数组（内存方面）——直到它满了，此时它变得更像是一个动态数组？那是准确的吗？

程序员什么时候想要或需要获取或设置 TQueue 的容量？

昨天面试了，他问了我一个问题。PHP 是一种单线程语言，那么工作和队列在 Laravel 背后是如何工作的呢？