标签: queue

Resque:按用户顺序执行的时间关键作业

我的应用程序创建必须按用户顺序处理的resque作业,并且应尽可能快地处理它们(最大延迟1秒).

例如:为user1创建job1和job2,为user2创建job3.Resque可以并行处理job1和job3,但是应该按顺序处理job1和job2.

我对解决方案有不同的看法:

  • 我可以使用不同的队列(例如queue_1 ... queue_10)并为每个队列启动一个worker(例如rake resque:work QUEUE=queue_1).用户在运行时被分配给队列/工作人员(例如,登录,每天等)
  • 我可以使用动态"用户队列"(例如queue _#{user.id})并尝试扩展resque,一次只有1个worker可以处理队列(如Resque中所述:每个队列一个worker)
  • 我可以将作业放在非resque队列中,并使用"每用户元作业"和resque-lock(https://github.com/defunkt/resque-lock)来处理这些作业.

您是否在实践中遇到过其中一种情况?或者还有其他可能值得思考的想法吗?我很感激任何意见,谢谢!

queue ruby-on-rails resque

5
推荐指数
1
解决办法
2220
查看次数

队列减少算法?

我有一个在客户端之间共享的活动队列,捕获用户活动并由另一个站点上的机器人执行.活动的一个例子可能是:

CREATE FOLDER  /docs
CREATE FILE    /docs/journal.txt
DELETE FILE    /docs/blog.txt
MOVE   FOLDER  /docs/images /docs/photos
...
Run Code Online (Sandbox Code Playgroud)

通常有活动可以减少到一个或没有.例如:

CREATE FOLDER /docs
RENAME FOLDER /docs /documents
Run Code Online (Sandbox Code Playgroud)

可以简单地改为:

CREATE FOLDER /documents
Run Code Online (Sandbox Code Playgroud)

类似的东西:

CREATE FOLDER /docs
RENAME FOLDER /documents
DELETE FOLDER /documents
Run Code Online (Sandbox Code Playgroud)

可以从队列中完全删除.

这种减少/优化似乎是一个非常普遍的问题,在攻击它之前,我想尝试一些通用的解决方案.它看起来像一个寻路优化问题.

有任何想法吗?

algorithm queue optimization

5
推荐指数
1
解决办法
142
查看次数

Go中的原子比较和交换结构

我想创建一个非阻塞队列包描述使用算法通过马吉德·M. Michael和迈克尔·L.·斯科特并发应用在这里.

这需要使用"sync/atomic"包提供的原子CompareAndSwap .
但是我不确定以下伪代码的Go等价物是什么:

E9:   if CAS(&tail.ptr->next, next, <node, next.count+1>)
Run Code Online (Sandbox Code Playgroud)

其中tail和next类型:

type pointer_t struct {
    ptr   *node_t
    count uint
}
Run Code Online (Sandbox Code Playgroud)

并且node是类型:

type node_t struct {
    value interface{}
    next  pointer_t
}
Run Code Online (Sandbox Code Playgroud)

如果我理解正确,似乎我需要用一个结构(一个指针和一个uint)来做一个CAS .使用atomic-package 可以实现这一点吗?

感谢帮助!

queue struct go compare-and-swap

5
推荐指数
1
解决办法
4147
查看次数

洪水填充优化:尝试使用队列

我正在尝试创建一种填充方法,该方法采用用户指定的初始坐标,检查字符,然后根据需要进行更改。这样做之后,它将检查相邻的正方形并重复该过程。经过一些研究,我遇到了泛洪填充算法,并尝试了一下(它可以工作,但不能满足我的250 x 250字符数组的最大要求)。

我最初的洪水填充算法如下:

public static void fillArea (int x, int y, char original, char fill){

   if (picture[y-1][x-1] != original){
      return;
   }
   picture[y-1][x-1] = fill;
   fillArea (x-1, y, original, fill);
   fillArea (x+1, y, original, fill);
   fillArea (x, y-1, original, fill);
   fillArea (x, y+1, original, fill);

   return;
}
Run Code Online (Sandbox Code Playgroud)

经过测试之后,我开始尝试使用Wikipedia上介绍的Queue方法,并且之前就类似问题询问过此问题。到目前为止,我已经提出了以下代码:

public static void fillArea (int x, int y, char original, char fill){
  if (x != 0)
     x--;
  if (y!= 0)
     y--;
  Queue<Point> queue = new LinkedList<Point>(); …
Run Code Online (Sandbox Code Playgroud)

java queue recursion flood-fill

5
推荐指数
1
解决办法
3731
查看次数

寻找对我的线程安全,无锁队列实现的批评

所以,经过一番研究后,我写了一个队列.它使用固定大小的缓冲区,因此它是一个循环队列.它必须是线程安全的,我试图让它无锁.我想知道它有什么问题,因为这些事情我自己很难预测.

这是标题:

template <class T>
class LockFreeQueue
{
public:
    LockFreeQueue(uint buffersize) : buffer(NULL), ifront1(0), ifront2(0), iback1(0), iback2(0), size(buffersize) { buffer = new atomic <T>[buffersize]; }
    ~LockFreeQueue(void) { if (buffer) delete[] buffer; }

    bool pop(T* output);
    bool push(T input);

private:
    uint incr(const uint val)
        {return (val + 1) % size;}

    atomic <T>* buffer;
    atomic <uint> ifront1, ifront2, iback1, iback2;
    uint size;
};
Run Code Online (Sandbox Code Playgroud)

这是实施:

template <class T>
bool LockFreeQueue<T>::pop(T* output)
{
    while (true)
    {
        /* Fetch ifront and store it in i. …
Run Code Online (Sandbox Code Playgroud)

c++ queue multithreading lock-free c++11

5
推荐指数
2
解决办法
863
查看次数

用Swift语言实现队列

我试图在Swift平台中实现Queue集合类型.关于peek,poll和offer函数,我遇到了一些问题.当我尝试在我的代码中使用这些函数时,它会失败.你对此有什么建议或真正的算法吗?

import Foundation


class Node<T> {
    var value: T? = nil
    var next: Node<T>? = nil
    var prev: Node<T>? = nil

    init() {
    }

    init(value: T) {
        self.value = value
    }
}

class Queue<T> {

var count: Int = 0

var head: Node<T> = Node<T>()

var tail: Node<T> = Node<T>()

var currentNode : Node<T> = Node<T>()

    init() {
    }

    func isEmpty() -> Bool {
        return self.count == 0
    }

    func next(index:Int) -> T? {

        if isEmpty() {
            return nil
        } …
Run Code Online (Sandbox Code Playgroud)

queue ios swift

5
推荐指数
1
解决办法
1万
查看次数

在单个服务器上将Redis用于多个Laravel应用程序的队列

我有一个生产laravel应用程序和在同一台服务器上运行的登台应用程序.我正在运行redis,我将其用作我的队列驱动程序.它们显然连接到不同的数据库.问题是,从登台应用程序推送到红色队列的作业是否会干扰生产数据库,反之亦然.

queue redis laravel

5
推荐指数
3
解决办法
3306
查看次数

删除排队的作业在Laravel 5

我在系统中使用数据库作为队列驱动程序。如何删除存储在作业表中的排队作业?

谢谢

queue laravel-5

5
推荐指数
1
解决办法
7407
查看次数

Java"分层队列"实现快速生产者,减缓消费者

我有一个生产者 - 消费者场景,生产者生产的速度比消费者消费的快得多.通常,解决方案是使生产者阻止,因为生产者/消费者场景的运行速度与最慢的组件一样快.限制或阻止生产者并不是一个好的解决方案,因为我们的应用程序为消费者提供了足够的时间来赶上.

这是一个图表,描绘了我们的应用程序中的完整"阶段"与更常见的场景:

      Our Application                 Common Scenario
 2N +--------+--------+
    |PPPPPPPP|oooooooo|                                         P = Producer
    |PPPPPPPP|oooooooo|                                         C = Consumer
  N +--------+--------+      N +--------+--------+--------+     o = Other Work
    |CPCPCPCP|CCCCCCCC|        |CPCPCPCP|CPCPCPCP|oooooooo|     N = number of tasks
    |CPCPCPCP|CCCCCCCC|        |CPCPCPCP|CPCPCPCP|oooooooo|
    -------------------        ----------------------------
    0       T/2       T        0       T/2       T      3T/2
Run Code Online (Sandbox Code Playgroud)

我们的想法是通过不抑制生产者来最大化吞吐量.

我们的任务运行的数据很容易被序列化,因此我计划实现一个文件系统解决方案,以便溢出所有无法立即满足的任务.

我正在使用具有最大容量的Java ThreadPoolExecutor,BlockingQueue以确保我们不会耗尽内存.问题是在实施这样的"分层"的队列,在那里是可以在内存中排队的任务是如此立即执行,否则数据被排队在磁盘上.

我想出了两个可能的解决方案:

  1. 实现一个BlockingQueue从无到有,使用LinkedBlockingQueue或ArrayBlockingQueue实施作为参考.这可能就像在标准库中复制实现并添加文件系统读/写一样简单.
  2. 继续使用标准的BlockingQueue实施,实现一个独立的FilesystemQueue存储我的数据,并使用一个或多个线程出列文件,创建RunnableS和使用他们排队ThreadPoolExecutor.

这些都是合理的,是否有更好的方法?

java queue concurrency multithreading threadpool

5
推荐指数
1
解决办法
907
查看次数

Laravel作业和保留状态或保留队列

当推送到队列中时,我有一个脚本作为作业运行。我还有其他几个队列,所有这些队列都由主管处理。我将Redis用作Laravel 4.2的队列驱动程序。

我想了解工作的不同状态:

  • 等待执行的作业
  • 失败的工作
  • 保留的工作

这些不同状态的问题在于,保留队列中有数千个作业queue:xyz:reserved(我不知道为什么)被推送到队列中,queue:xyz而这些作业(来自保留队列)阻止了新推送的作业的执行。

以下是由主管运行以处理作业的命令: php artisan queue:work --queue=xyz --tries=1 --daemon --env=prodEnv 我的问题是:

  • 为什么在保留的队列/状态中推送作业
  • 为什么Laravel将其推回原始队列?
  • 失败的作业和保留的作业有什么区别?要么
  • 何时将作业标记/认为是失败或保留?

将保留的作业推送到原始队列的过程减慢了队列中新作业的处理速度,我想通过处理这些保留的作业来使其更快。

queue jobs redis supervisord laravel-4

5
推荐指数
1
解决办法
940
查看次数