我的应用程序创建必须按用户顺序处理的resque作业,并且应尽可能快地处理它们(最大延迟1秒).
例如:为user1创建job1和job2,为user2创建job3.Resque可以并行处理job1和job3,但是应该按顺序处理job1和job2.
我对解决方案有不同的看法:
rake resque:work QUEUE=queue_1).用户在运行时被分配给队列/工作人员(例如,登录,每天等)您是否在实践中遇到过其中一种情况?或者还有其他可能值得思考的想法吗?我很感激任何意见,谢谢!
我有一个在客户端之间共享的活动队列,捕获用户活动并由另一个站点上的机器人执行.活动的一个例子可能是:
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)
可以从队列中完全删除.
这种减少/优化似乎是一个非常普遍的问题,在攻击它之前,我想尝试一些通用的解决方案.它看起来像一个寻路优化问题.
有任何想法吗?
我想创建一个非阻塞队列包描述使用算法通过马吉德·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 可以实现这一点吗?
感谢帮助!
我正在尝试创建一种填充方法,该方法采用用户指定的初始坐标,检查字符,然后根据需要进行更改。这样做之后,它将检查相邻的正方形并重复该过程。经过一些研究,我遇到了泛洪填充算法,并尝试了一下(它可以工作,但不能满足我的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) 所以,经过一番研究后,我写了一个队列.它使用固定大小的缓冲区,因此它是一个循环队列.它必须是线程安全的,我试图让它无锁.我想知道它有什么问题,因为这些事情我自己很难预测.
这是标题:
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) 我试图在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) 我有一个生产laravel应用程序和在同一台服务器上运行的登台应用程序.我正在运行redis,我将其用作我的队列驱动程序.它们显然连接到不同的数据库.问题是,从登台应用程序推送到红色队列的作业是否会干扰生产数据库,反之亦然.
我有一个生产者 - 消费者场景,生产者生产的速度比消费者消费的快得多.通常,解决方案是使生产者阻止,因为生产者/消费者场景的运行速度与最慢的组件一样快.限制或阻止生产者并不是一个好的解决方案,因为我们的应用程序为消费者提供了足够的时间来赶上.
这是一个图表,描绘了我们的应用程序中的完整"阶段"与更常见的场景:
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以确保我们不会耗尽内存.问题是在实施这样的"分层"的队列,在那里是可以在内存中排队的任务是如此立即执行,否则数据被排队在磁盘上.
我想出了两个可能的解决方案:
BlockingQueue从无到有,使用LinkedBlockingQueue或ArrayBlockingQueue实施作为参考.这可能就像在标准库中复制实现并添加文件系统读/写一样简单.BlockingQueue实施,实现一个独立的FilesystemQueue存储我的数据,并使用一个或多个线程出列文件,创建RunnableS和使用他们排队ThreadPoolExecutor.这些都是合理的,是否有更好的方法?
当推送到队列中时,我有一个脚本作为作业运行。我还有其他几个队列,所有这些队列都由主管处理。我将Redis用作Laravel 4.2的队列驱动程序。
我想了解工作的不同状态:
这些不同状态的问题在于,保留队列中有数千个作业queue:xyz:reserved(我不知道为什么)被推送到队列中,queue:xyz而这些作业(来自保留队列)阻止了新推送的作业的执行。
以下是由主管运行以处理作业的命令:
php artisan queue:work --queue=xyz --tries=1 --daemon --env=prodEnv
我的问题是:
将保留的作业推送到原始队列的过程减慢了队列中新作业的处理速度,我想通过处理这些保留的作业来使其更快。
queue ×10
java ×2
redis ×2
algorithm ×1
c++ ×1
c++11 ×1
concurrency ×1
flood-fill ×1
go ×1
ios ×1
jobs ×1
laravel ×1
laravel-4 ×1
laravel-5 ×1
lock-free ×1
optimization ×1
recursion ×1
resque ×1
struct ×1
supervisord ×1
swift ×1
threadpool ×1