javascript

java

python

c#

android

c++

node.js

php

html

jquery

ios

reactjs

css

.net

git

ruby-on-rails

sql

c

ruby

string

sql-使用数据库表作为队列

我想将数据库表用作队列。 我想在其中插入并按插入顺序(FIFO)从中获取元素。 我主要考虑的是性能,因为每秒我有成千上万的交易。 因此,我想使用一个SQL查询,该查询为我提供第一个元素,而无需搜索整个表。 阅读时我不会删除任何行。SELECT TOP 1 .....在这里有帮助吗?我应该使用任何特殊索引吗?

trans by 2020-08-12T00:30:04Z

图-队列的符号是什么?

在流程图或流程图中,FIFO队列的符号是什么?

trans by 2020-08-07T08:37:30Z

SQL Server进程队列竞争条件

我有一个订单队列,可通过存储过程由多个订单处理器访问。 每个处理器传递一个唯一的ID,该ID用于锁定接下来的20个订单以供自己使用。 然后,存储过程将这些记录返回给要处理的订单处理器。

在某些情况下,多个处理器能够检索相同的“ OrderTable”记录,此时它们将尝试同时对其进行操作。 这最终会导致在此过程的后期引发错误。

我的下一个动作是允许每个处理器抓住所有可用的订单,然后对处理器进行轮循,但是我希望简单地使这一部分代码线程安全,并允许处理器在需要时捕获记录。

如此明确-任何想法我为什么会遇到这种比赛情况以及如何解决问题。

BEGIN TRAN
    UPDATE  OrderTable WITH ( ROWLOCK )
    SET     ProcessorID = @PROCID
    WHERE   OrderID IN ( SELECT TOP ( 20 )
                                        OrderID
                                FROM    OrderTable WITH ( ROWLOCK )
                                WHERE   ProcessorID = 0)
COMMIT TRAN


SELECT  OrderID, ProcessorID, etc...
FROM    OrderTable
WHERE   ProcessorID = @PROCID
trans by 2020-08-03T09:28:38Z

delphi-TThreadedQueue不能同时使用多个使用者吗?

尝试在单个生产者多消费者方案中使用TThreadedQueue(Generics.Collections)。 (Delphi-XE)。这个想法是将对象推入队列,并让多个工作线程耗尽队列。

但是,它无法正常工作。当两个或多个工作线程正在调用PopItem时,将从TThreadedQueue中引发访问冲突。

如果对PopItem的调用使用关键部分进行了序列化,则一切正常。

当然,TThreadedQueue应该能够处理多个使用者,所以我会丢失某些东西吗?或者这是TThreadedQueue中的纯错误?

这是产生错误的简单示例。

program TestThreadedQueue;

{$APPTYPE CONSOLE}

uses
//  FastMM4 in '..\..\..\FastMM4\FastMM4.pas',
  Windows,
  Messages,
  Classes,
  SysUtils,
  SyncObjs,
  Generics.Collections;

type TThreadTaskMsg =
       class(TObject)
         private
           threadID  : integer;
           threadMsg : string;
         public
           Constructor Create( ID : integer; const msg : string);
       end;

type TThreadReader =
       class(TThread)
         private
           fPopQueue   : TThreadedQueue<TObject>;
           fSync       : TCriticalSection;
           fMsg        : TThreadTaskMsg;
           fException  : Exception;
           procedure DoSync;
           procedure DoHandleException;
         public
           Constructor Create( popQueue : TThreadedQueue<TObject>;
                               sync     : TCriticalSection);
           procedure Execute; override;
       end;

Constructor TThreadReader.Create( popQueue : TThreadedQueue<TObject>;
                                  sync     : TCriticalSection);
begin
  fPopQueue:=            popQueue;
  fMsg:=                 nil;
  fSync:=                sync;
  Self.FreeOnTerminate:= FALSE;
  fException:=           nil;

  Inherited Create( FALSE);
end;

procedure TThreadReader.DoSync ;
begin
  WriteLn(fMsg.threadMsg + ' ' + IntToStr(fMsg.threadId));
end;

procedure TThreadReader.DoHandleException;
begin
  WriteLn('Exception ->' + fException.Message);
end;

procedure TThreadReader.Execute;
var signal : TWaitResult;
begin
  NameThreadForDebugging('QueuePop worker');
  while not Terminated do
  begin
    try
      {- Calling PopItem can return empty without waittime !? Let other threads in by sleeping. }
      Sleep(20);
      {- Serializing calls to PopItem works }
      if Assigned(fSync) then fSync.Enter;
      try
        signal:= fPopQueue.PopItem( TObject(fMsg));
      finally
        if Assigned(fSync) then fSync.Release;
      end;
      if (signal = wrSignaled) then
      begin
        try
          if Assigned(fMsg) then
          begin
            fMsg.threadMsg:= '<Thread id :' +IntToStr( Self.threadId) + '>';
            fMsg.Free; // We are just dumping the message in this test
            //Synchronize( Self.DoSync);
            //PostMessage( fParentForm.Handle,WM_TestQueue_Message,Cardinal(fMsg),0);
          end;
        except
          on E:Exception do begin
          end;
        end;
      end;
      except
       FException:= Exception(ExceptObject);
      try
        if not (FException is EAbort) then
        begin
          {Synchronize(} DoHandleException; //);
        end;
      finally
        FException:= nil;
      end;
   end;
  end;
end;

Constructor TThreadTaskMsg.Create( ID : Integer; Const msg : string);
begin
  Inherited Create;

  threadID:= ID;
  threadMsg:= msg;
end;

var
    fSync : TCriticalSection;
    fThreadQueue : TThreadedQueue<TObject>;
    fReaderArr : array[1..4] of TThreadReader;
    i : integer;

begin
  try
    IsMultiThread:= TRUE;

    fSync:=        TCriticalSection.Create;
    fThreadQueue:= TThreadedQueue<TObject>.Create(1024,1,100);
    try
      {- Calling without fSync throws exceptions when two or more threads calls PopItem
         at the same time }
      WriteLn('Creating worker threads ...');
      for i:= 1 to 4 do fReaderArr[i]:= TThreadReader.Create( fThreadQueue,Nil);
      {- Calling with fSync works ! }
      //for i:= 1 to 4 do fReaderArr[i]:= TThreadReader.Create( fThreadQueue,fSync);
       WriteLn('Init done. Pushing items ...');

      for i:= 1 to 100 do fThreadQueue.PushItem( TThreadTaskMsg.Create( i,''));

      ReadLn;

    finally
      for i:= 1 to 4 do fReaderArr[i].Free;
      fThreadQueue.Free;
      fSync.Free;
    end;

  except
    on E: Exception do
      begin
        Writeln(E.ClassName, ': ', E.Message);
        ReadLn;
      end;
  end;
end.

更新:Delphi XE2中修复了导致TThreadedQueue崩溃的TMonitor中的错误。

更新2:上面的测试强调队列处于空状态。 达里安·米勒(Darian Miller)发现,在队列处于满状态时,仍然可以重现XE2中的错误。 该错误再次出现在TMonitor中。 有关更多信息,请参见下面的答案。 以及指向QC101114的链接。

更新3:随着Delphi-XE2 Update 4的发布,已发布了针对TMonitor的修复程序,该修复程序可以解决TThreadedQueue中的问题。到目前为止,我的测试不再能够再现TThreadedQueue中的任何错误。当队列为空且已满时,测试单个生产者/多个消费者线程。还测试了多个生产者/多个消费者。 我将读取器线程和写入器线程从1更改为100,没有任何故障。 但是了解历史,我敢于打破TMonitor

trans by 2020-08-03T00:31:22Z

数据结构-基于数组与基于列表的堆栈和队列

我正在尝试比较同时实现为数组和链接列表的堆栈和队列操作的增长率(运行时和空间)。 到目前为止,我只能找到队列push()s的平均案例运行时间,但是没有什么能够全面研究这两个数据结构并比较它们的运行时间/空间行为。

具体来说,我希望比较两个队列和堆栈的push()pop(),它们既作为数组又作为链表实现(因此2个操作x 2个结构x 2个实现或8个值)。

此外,我将对这两个值的最佳,平均和最差值以及与它们占用的空间量有关的任何值表示赞赏。

我能找到的最接近的东西是“所有cs备忘单之母” pdf,它显然是高级算法和离散功能的硕士或博士级备忘单。

我只是在寻找一种方法来确定何时和何地在堆栈和队列中使用基于数组的实现与基于列表的实现。

trans by 2020-07-25T02:50:33Z

python-如何在RabbitMQ中创建延迟的队列?

使用Python,Pika和RabbitMQ创建延迟(或停放)队列的最简单方法是什么? 我见过类似的问题,但Python没有。

在设计应用程序时,我发现这是一个有用的想法,因为它使我们能够限制需要再次重新排队的消息。

总是有可能收到的消息超出您的处理能力,例如HTTP服务器速度慢或数据库承受的压力太大。

我还发现,在丢失消息的容忍度为零的情况下出现问题时,如果出现问题,并且对无法处理的消息进行重新排队可能会解决此问题,那么它非常有用。 它还可能会导致问题,使消息一遍又一遍地排队。 潜在导致性能问题,并记录垃圾邮件。

trans by 2020-07-23T16:24:07Z

Python的通用优先级队列

我需要在Python代码中使用优先级队列,并且:

  • 正在寻找优先级队列的任何快速实现
  • 最佳情况下,我希望队列是通用的(即对于具有指定比较运算符的任何对象都可以很好地工作)。

寻找高效的东西,我遇到了heapq,但是:

  • 我正在寻找比heapq更快的东西,后者是在本机Python中实现的,所以它并不快。
  • 看起来不错,但似乎只为整数指定。 我想它可以与任何具有比较运算符的对象一起使用,但是它没有指定所需的比较运算符。
  • 更新:在heapq中进行比较,我可以按照Charlie Martin的建议使用(priority, object),也可以只为我的对象实现__cmp__
trans by 2020-07-14T02:25:02Z

Java Queue的最佳实现?

我(使用Java)正在研究一种递归图像处理算法,该算法以递归方式从中心点向外遍历图像的像素。

不幸的是,这会导致堆栈溢出。 因此,我决定切换到基于队列的算法。

现在,这一切都很好而且很花哨-但考虑到这样一个事实,即它的队列将在很短的时间内分析成千上万个像素,同时不断弹出并推动,而不会保持可预测的状态(长度可能在100到100之间, 和20000),队列实现需要具有显着的快速弹出和推送功能。

链表似乎很有吸引力,因为它能够将元素推入自身而无需重新排列链表中的其他任何内容,但是为了使其足够快,它需要轻松访问其头部和尾部(或第二个尾部)。 -last节点(如果不是双向链接)。 可悲的是,我找不到与Java中链表的底层实现有关的任何信息,因此很难说链表是否真的是要走的路...

这使我想到了我的问题。 我打算做什么,用Java在Queue接口中最好的实现是什么? (除了队列的首尾,我不希望编辑甚至访问任何东西-我不希望进行任何形式的重排或任何其他事情。另一方面,我确实想做很多事情 然后弹出,队列将改变大小很多,因此预分配效率不高)

trans by 2020-07-04T02:43:26Z

.net-队列<T>与列表<T>

我当前使用List<T>作为队列(使用lst[0]然后lst.removeAt(0))来保存对象。 给定时间最多可容纳20件物品。 我意识到这里有一个实际的Queue<T>类。 我想知道使用Queue<T>与像队列一样工作的List<T>是否有任何好处(性能,内存等)?

trans by 2020-07-01T10:27:16Z

.net-如何在RabbitMQ中设置多次重试尝试?

我正在使用RabbitMQ,并且我有一个队列来保存电子邮件。 我的消费者服务使消息出队并尝试发送它们。 如果由于任何原因我的使用者无法发送消息,我想重新排队该消息以再次发送。 我知道我可以执行basicNack并将requeue标志设置为true,但是,我不想无限期地重新排队消息(例如,如果我们的电子邮件系统出现故障,我不想连续地重新排队未发送的消息)。 我想定义一个有限的次数,使我可以重新排队要再次发送的消息。 但是,当我将其出队并发送小消息时,无法在电子邮件对象上设置字段。 队列中的消息上没有更新的字段。 我还有其他方法可以解决这个问题吗? 提前致谢。

trans by 2020-06-18T15:22:18Z

去-是否有队列实现?

谁能为简单快速的FIF /队列推荐Go容器,Go有3种不同的容器:heaplistvector。哪种容器更适合实现队列?

trans by 2020-06-18T06:11:39Z

队列-RabbitMQ-邮件传递顺序

我需要为我的新项目选择一个新的队列代理。

这次,我需要一个支持pub / sub的可伸缩队列,并且必须保持消息顺序。

我读过亚历克西斯的评论:他写道:

“的确,我们认为RabbitMQ比Kafka提供更强的订购能力”

我阅读了Rabbitmq文档中的消息排序部分:

“可以使用具有以下功能的AMQP方法将消息返回到队列中:   排队        参数(basic.recover,basic.reject和basic.nack),或由于通道        在保留未确认消息的同时关闭...对于2.7.0及更高版本        个人消费者仍然有可能观察不到        如果队列有多个订阅者,则排序。 这是由于        可能重新排队消息的其他订阅者。 从队列的角度        邮件始终按发布顺序保存。”

如果我需要按照消息的顺序处理消息,那么我只能对每个使用者使用RabbitMQ,并且将其排他队列吗?

RabbitMQ仍然被认为是有序消息队列的好解决方案吗?

trans by 2020-02-15T18:53:52Z

清除队列中的所有项目

如何清除队列。 例如,我在队列中有数据,但是由于某种原因,我不需要现有数据,只想清除队列。

有什么办法吗? 这项工作会:

oldQueue = Queue.Queue()
trans by 2020-02-14T21:11:55Z

使用jQuery.queue()将Ajax请求排队

我是第一次使用jQuery.queue(),但还不太了解。有人可以指出我做错了吗?

看着萤火虫,我仍然看到POST请求同时触发-所以我想知道我是否在错误的地方调用dequeue()。

另外-如何获得队列长度?

我需要将这些请求排队的原因是单击按钮后便将其触发。 用户可以快速连续单击多个按钮。

试图剥离我的代码的基本结构:

$("a.button").click(function(){
   $(this).doAjax(params);
});

// method
doAjax:function(params){ 

   $(document).queue("myQueueName", function(){
     $.ajax({
       type: 'POST',
       url: 'whatever.html',
       params: params,
       success: function(data){
         doStuff;

         $(document).dequeue("myQueueName");
       }
     });
   });

}
trans by 2020-01-02T19:26:14Z

java-使用队列的生产者/消费者线程

我想创建某种Producer/Consumer线程应用程序。 但是我不确定在两者之间实现队列的最佳方法是什么。

因此,我提出了两个想法(这两个想法可能都是完全错误的)。 我想知道哪种更好,如果它们都烂了,那么实现队列的最佳方法是什么。 我关心的主要是这些示例中队列的实现。 我正在扩展一个内部类并且是线程安全的Queue类。 下面是两个示例,每个示例有4个类。

主班

public class SomeApp
{
    private Consumer consumer;
    private Producer producer;

    public static void main (String args[])
    {
        consumer = new Consumer();
        producer = new Producer();
    }
} 

消费阶层

public class Consumer implements Runnable
{
    public Consumer()
    {
        Thread consumer = new Thread(this);
        consumer.start();
    }

    public void run()
    {
        while(true)
        {
            //get an object off the queue
            Object object = QueueHandler.dequeue();
            //do some stuff with the object
        }
    }
}

生产者类别

public class Producer implements Runnable
{
    public Producer()
    {
        Thread producer = new Thread(this);
        producer.start();
    }

    public void run()
    {
        while(true)
        {
            //add to the queue some sort of unique object
            QueueHandler.enqueue(new Object());
        }
    }
}

队列类

public class QueueHandler
{
    //This Queue class is a thread safe (written in house) class
    public static Queue<Object> readQ = new Queue<Object>(100);

    public static void enqueue(Object object)
    {
        //do some stuff
        readQ.add(object);
    }

    public static Object dequeue()
    {
        //do some stuff
        return readQ.get();
    }
}

要么

主班

public class SomeApp
{
    Queue<Object> readQ;
    private Consumer consumer;
    private Producer producer;

    public static void main (String args[])
    {
        readQ = new Queue<Object>(100);
        consumer = new Consumer(readQ);
        producer = new Producer(readQ);
    }
} 

消费阶层

public class Consumer implements Runnable
{
    Queue<Object> queue;

    public Consumer(Queue<Object> readQ)
    {
        queue = readQ;
        Thread consumer = new Thread(this);
        consumer.start();
    }

    public void run()
    {
        while(true)
        {
            //get an object off the queue
            Object object = queue.dequeue();
            //do some stuff with the object
        }
    }
}

生产者类别

public class Producer implements Runnable
{
    Queue<Object> queue;

    public Producer(Queue<Object> readQ)
    {
        queue = readQ;
        Thread producer = new Thread(this);
        producer.start();
    }

    public void run()
    {

        while(true)
        {
            //add to the queue some sort of unique object
            queue.enqueue(new Object());
        }
    }
}

队列类

//the extended Queue class is a thread safe (written in house) class
public class QueueHandler extends Queue<Object>
{    
    public QueueHandler(int size)
    {
        super(size); //All I'm thinking about now is McDonalds.
    }

    public void enqueue(Object object)
    {
        //do some stuff
        readQ.add();
    }

    public Object dequeue()
    {
        //do some stuff
        return readQ.get();
    }
}

去!

trans by 2019-11-09T16:47:04Z

队列-Rabbitmq中的池化连接或通道之间是否存在性能差异?

我是Rabbitmq(和编程人员)的新手,如果很明显,请提前抱歉。 我正在创建一个池以在正在队列中工作的线程之间共享,但是不确定是否应该在池中使用连接或通道。

我知道我需要通道来完成实际工作,但是每个连接只有一个通道会带来性能优势(就队列中的吞吐量而言)? 还是我最好只对每个应用程序使用单个连接并合并多个通道?

注意:因为我正在集中资源,所以初始成本不是一个因素,因为我知道连接比通道更昂贵。 我对吞吐量更感兴趣。

trans by 2019-11-07T21:36:17Z

集合-.NET中Queue <T>的限制大小?

我有一个初始化为2的Queue <T>对象,但显然这只是该容量,并且在添加项目时一直在扩展。 是否已经有一个对象,当达到限制时,该对象会自动使项目出队,或者是创建我自己的继承类的最佳解决方案?

trans by 2019-10-28T07:49:27Z

CodeGo.net>如何遍历priority_queue?

我可以使用迭代器(例如vector)遍历c ++中的标准priority_queue或标准queue吗? 我不想使用pop,因为它会导致我的队列出队。

谢谢你的帮助

trans by 2019-10-25T04:53:23Z

java-使用队列的生产者/消费者线程

我想创建某种Producer/Consumer线程应用程序。 但是我不确定在两者之间实现队列的最佳方法是什么。

因此,我提出了两个想法(这两个想法可能都是完全错误的)。 我想知道哪种更好,如果它们都烂了,那么实现队列的最佳方法是什么。 我关心的主要是这些示例中队列的实现。 我正在扩展一个内部类并且是线程安全的Queue类。 下面是两个示例,每个示例有4个类。

主班

public class SomeApp
{
    private Consumer consumer;
    private Producer producer;

    public static void main (String args[])
    {
        consumer = new Consumer();
        producer = new Producer();
    }
} 

消费阶层

public class Consumer implements Runnable
{
    public Consumer()
    {
        Thread consumer = new Thread(this);
        consumer.start();
    }

    public void run()
    {
        while(true)
        {
            //get an object off the queue
            Object object = QueueHandler.dequeue();
            //do some stuff with the object
        }
    }
}

生产者类别

public class Producer implements Runnable
{
    public Producer()
    {
        Thread producer = new Thread(this);
        producer.start();
    }

    public void run()
    {
        while(true)
        {
            //add to the queue some sort of unique object
            QueueHandler.enqueue(new Object());
        }
    }
}

队列类

public class QueueHandler
{
    //This Queue class is a thread safe (written in house) class
    public static Queue<Object> readQ = new Queue<Object>(100);

    public static void enqueue(Object object)
    {
        //do some stuff
        readQ.add(object);
    }

    public static Object dequeue()
    {
        //do some stuff
        return readQ.get();
    }
}

要么

主班

public class SomeApp
{
    Queue<Object> readQ;
    private Consumer consumer;
    private Producer producer;

    public static void main (String args[])
    {
        readQ = new Queue<Object>(100);
        consumer = new Consumer(readQ);
        producer = new Producer(readQ);
    }
} 

消费阶层

public class Consumer implements Runnable
{
    Queue<Object> queue;

    public Consumer(Queue<Object> readQ)
    {
        queue = readQ;
        Thread consumer = new Thread(this);
        consumer.start();
    }

    public void run()
    {
        while(true)
        {
            //get an object off the queue
            Object object = queue.dequeue();
            //do some stuff with the object
        }
    }
}

生产者类别

public class Producer implements Runnable
{
    Queue<Object> queue;

    public Producer(Queue<Object> readQ)
    {
        queue = readQ;
        Thread producer = new Thread(this);
        producer.start();
    }

    public void run()
    {

        while(true)
        {
            //add to the queue some sort of unique object
            queue.enqueue(new Object());
        }
    }
}

队列类

//the extended Queue class is a thread safe (written in house) class
public class QueueHandler extends Queue<Object>
{    
    public QueueHandler(int size)
    {
        super(size); //All I'm thinking about now is McDonalds.
    }

    public void enqueue(Object object)
    {
        //do some stuff
        readQ.add();
    }

    public Object dequeue()
    {
        //do some stuff
        return readQ.get();
    }
}

去!

trans by 2019-10-11T17:34:20Z

java-基于FIFO的队列实现?

我需要一个简单的FIFO实现的队列来存储一堆int(如果是泛型实现,我并不介意)。

java.util或Trove / Guava库中已经为我准备的东西已经烤好了吗?

trans by 2019-09-30T17:03:22Z

1 2 下一页 共2页