我目前正在使用可靠UDP协议的Java实现,可在此处找到.该项目绝对没有教程,所以我发现很难找出问题.
我已经设置了客户端和服务器.服务器在localhost:1234上运行,客户端在localhost:1235上运行.服务器首先建立,并循环侦听连接 -
try {
ReliableSocket clientSocket = server.socket.accept();
InetSocketAddress clientAddress = (InetSocketAddress) clientSocket.getRemoteSocketAddress();
Logger.getLogger("ServerConnectionListener").info("New Connection from "+
clientAddress.getHostName()+":"+clientAddress.getPort()+" Processing...");
LessurConnectedClient client = new LessurConnectedClient(clientSocket);
ClientCommunicationSocketListener listener = new ClientCommunicationSocketListener(this, client);
clientSocket.addListener(listener);
} catch (Exception e) {
e.printStackTrace();
}
Run Code Online (Sandbox Code Playgroud)
建立连接后,它会为该套接字上的事件创建一个侦听器 -
class ClientCommunicationSocketListener implements ReliableSocketListener {
ServerConnectionListener connectionListener;
LessurConnectedClient client;
public ClientCommunicationSocketListener(ServerConnectionListener connectionListener, LessurConnectedClient client){
this.connectionListener = connectionListener;
this.client = client;
}
@Override
public void packetReceivedInOrder() {
connectionListener.server.handlePacket(client);
}
@Override
public void packetReceivedOutOfOrder() {
connectionListener.server.handlePacket(client);
}
}
Run Code Online (Sandbox Code Playgroud)
收到数据包后,它会将其传递给server.handlePacket,后者执行打印"Packet …
我需要在固定大小的FIFO队列周围实现生产者/消费者模式.我认为围绕ConcurrentQueue的包装类可能适用于此,但我不完全确定(我之前从未使用过ConcurrentQueue).这种扭曲是队列只需要保存固定数量的项目(在我的例子中是字符串).我的应用程序将有一个生产者任务/线程和一个消费者任务/线程.当我的消费者任务运行时,它需要在那个时刻出现队列中存在的所有项目并对其进行处理.
对于它的价值,我的消费者处理排队的项目只不过是通过SOAP将它们上传到一个不是100%可靠的网络应用程序.如果无法建立连接或调用SOAP调用失败,我应该丢弃这些项目并返回队列以获取更多信息.由于SOAP的开销,我试图最大化队列中可以在一次SOAP调用中发送的项目数.
有时,我的制作人可能会比我的消费者能够删除和处理它们更快地添加项目.如果队列已满并且我的生产者需要添加另一个项目,我需要将新项目排队,然后将最旧的项目出列,以便队列的大小保持固定.基本上,我需要始终保留队列中生成的最新项目(即使这意味着某些项目不会被消耗,因为我的消费者当前正在处理以前的项目).
关于生产者如果队列中的项目是固定的那样保留数字,我从这个问题中发现了一个潜在的想法:
我目前在ConcurrentQueue周围使用一个包装类(基于该答案)和Enqueue()方法,如下所示:
public class FixedSizeQueue<T>
{
readonly ConcurrentQueue<T> queue = new ConcurrentQueue<T>();
public int Size { get; private set; }
public FixedSizeQueue(int size)
{
Size = size;
}
public void Enqueue(T obj)
{
// add item to the queue
queue.Enqueue(obj);
lock (this) // lock queue so that queue.Count is reliable
{
while (queue.Count > Size) // if queue count > max queue size, then dequeue an item
{
T objOut;
queue.TryDequeue(out objOut);
}
} …Run Code Online (Sandbox Code Playgroud) 遇到一个问题,我的一个团队成员正在PHP中进行排队过程.PHP脚本在命令行上运行,并在每个循环后递归调用自身,以检查数据库中是否有任何项目等待处理.如果有,它会自行处理,处理队列中的项目,并重复.如果没有,它就会死掉,而cron作业每5分钟重新启动一次队列.
有时两个进程同时运行,抓取相同的队列,并以彼此的方式进入.我正在考虑在唤醒过程中引入一个抖动,这样在进程启动之间就是一个随机的时间.
有没有更好的办法?
我经常需要处理一个项目队列,其中没有一个用户应该能够阻塞队列,并且队列中的项目应该按某种顺序处理.我经常写一个类来做这个,但我认为应该有一些通用版本,但我找不到一个.
所以我正在寻找一个队列类,我可以在其中指定一个类型,一个分区选择器和一个选择器,以便我可以将对象添加到队列中,然后当我将对象退出时,我从第一个对象中获取我的订单说明符排序的下一个分区.
例如,我会像这样调用如何分区以及如何对队列进行排序:
var queue = new RoundRobinQueue<Message>(
_ => _.UserID,
_ => _.SendDate
);
Run Code Online (Sandbox Code Playgroud)
后,我已经添加了很多信息的,我可以Parallel.ForEach在我的队列中的项目,并处理它们在最早的顺序SendDate下一个User.这样,如果一个用户很慢,他的项目将不会阻塞队列,因为他只获得一个线程,但如果只有一个用户,他是唯一的分区,所以他获得所有线程.
我看了一遍,但在C#中找不到一个很好的通用实现.有任何想法吗?
我正在重构遗留应用程序.有问题的应用程序使用SQL Server数据库表对由一个或多个Windows服务检索和处理的作业进行排队.我想创建一个迭代器,它将处理"等待"状态的下一个排队作业进行处理,同时保持正确的锁定.样本单元测试包括在下面.我的问题是,我的方法是否有任何潜在的showstoppers.
// Database DDL
if object_id('Jobs') is not null begin
drop table Jobs;
end
go
create table Jobs
(
Id int identity(1,1) not null primary key clustered
, JobStatus varchar(50) not null
);
insert Jobs
select 'Waiting'
union all
select 'Waiting'
union all
select 'Processing'
union all
select 'Completed'
union all
select 'Failed';
// Unit Test
// Data Model
public sealed class Job
{
public readonly int JobId;
public Job(int jobId)
{
JobId = jobId;
}
}
[TestFixture]
public …Run Code Online (Sandbox Code Playgroud) 我有一个相对简单的"复制"程序,它只是将一个文件的所有行复制到另一个文件.我玩弄Haskell的并发支持TMQueue和STM所以我想我会尝试这样的:
{-# LANGUAGE BangPatterns #-}
module Main where
import Control.Applicative
import Control.Concurrent.Async -- from async
import Control.Concurrent.Chan
import Control.Concurrent.STM (atomically)
import Control.Concurrent.STM.TMQueue -- from stm-chans
import Control.Monad (replicateM, forM_, forever, unless)
import qualified Data.ByteString.Char8 as B
import Data.Function (fix)
import Data.Maybe (catMaybes, maybe)
import System.IO (withFile, IOMode(..), hPutStrLn, hGetLine)
import System.IO.Error (catchIOError)
input = "data.dat"
output = "out.dat"
batch = 100 :: Int
consumer :: TMQueue B.ByteString -> IO ()
consumer q = withFile output WriteMode …Run Code Online (Sandbox Code Playgroud) 我正在尝试同时使用多线程队列和多处理队列.20个线程将使用线程队列来检索许多网页.然后,我想将页面放入多进程队列,以便4个进程工作者可以处理数据.以下是我的基本结构.我的问题是,工作队列给出了一个错误,说Queue不可迭代.我认为多线程队列正在覆盖多进程队列,但我真的不知道出了什么问题.
ticker_queue = Queue()
work_queue = Queue()
tickers = get_tickers()
for i in tickers:
ticker_queue.put(i)
for i in range(20):
t = Thread(target=network_worker, args = (ticker_queue, work_queue)).start()
for i in range(4):
p = Process(target = worker, args = (work_queue)).start()
Run Code Online (Sandbox Code Playgroud)
这是追溯
Traceback (most recent call last):
File "OneDrive\Python\andys.py", line 108, in <module>
p = Process(target = worker, args = (work_queue)).start()
File "C:\Python27\lib\multiprocessing\process.py", line 104, in __init__
self._args = tuple(args)
TypeError: 'Queue' object is not iterable
Run Code Online (Sandbox Code Playgroud) 我正在测试Laravel 5.1中的队列功能.我可以在我的数据库表中将作业排队,称为作业,我可以让它们成功运行.我还创建了一个名为failed_jobs的队列故障表.为了测试它,在jobs表中我操纵有效负载数据使其失败然后我像这样运行队列工作守护进程,所以它会在一次失败尝试后将作业放入failed_jobs表中:
php artisan queue:work --daemon --tries=1 --queue=myqueue
Run Code Online (Sandbox Code Playgroud)
当作业失败时,它会立即按预期放入failed_jobs表中.
仅供参考我就像Laravel 5.1文档推荐的那样:
http://laravel.com/docs/5.1/queues#dealing-with-failed-jobs
我已经尝试在AppServiceProvider的boot()方法中注册我的队列失败事件,如文档中所述:
Queue::failing(function ($connection, $job, $data) {
Log::error('Job failed!');
});
Run Code Online (Sandbox Code Playgroud)
我也在实际的作业脚本中尝试了fail()方法,如下所示:
/**
* Handle a job failure.
*
* @return void
*/
public function failed()
{
Log::error('failed!');
}
Run Code Online (Sandbox Code Playgroud)
无论哪种方式,当排队的作业失败时都不会触发这些事件.我在日志中看不到任何内容,除了我故意发生的异常堆栈跟踪.Laravel 5.1在这里有错误还是我遗漏了什么?
更新:
我做了一些更多的研究.当发生队列作业失败时,处理该失败的逻辑在vendor/laravel/framework/src/Illuminate/Queue/Worker.php中:
protected function logFailedJob($connection, Job $job)
{
if ($this->failer) {
$this->failer->log($connection, $job->getQueue(), $job->getRawBody());
$job->delete();
$job->failed();
$this->raiseFailedJobEvent($connection, $job);
}
return ['job' => $job, 'failed' => true];
}
Run Code Online (Sandbox Code Playgroud)
失败的()函数永远不会执行,它会阻止调用下一个函数raiseFailedJobEvent().就好像脚本在调用failed()时静默停止.现在,如果我颠倒这些行的顺序,我可以触发raiseFailedJobEvent(),如果我在EventServiceProvider.php或AppServiceProvider.php中注册一个队列事件处理程序,我可以验证它被触发,我可以成功处理该事件.不幸的是,在raiseFailedJobEvent()之前失败()会阻止此事件发生.
更新:
问题似乎源于我如何使其失败.如果我故意破坏作业队列表中的数据,则永远不会调用failed()方法.日志中有一个堆栈跟踪:
Stack trace:
#0 [internal function]: Illuminate\Foundation\Bootstrap\HandleExceptions->handleError(8, 'unserialize():
Run Code Online (Sandbox Code Playgroud)
如果我实际进入vendor/laravel/framework/src/Illuminate/Queue/Worker.php并在每次运行时强制它失败(当然是以无异常的方式),则调用failure().显然,问题是如何知道这个队列在真实世界中的失败?如果损坏的数据库数据导致失败但仍然阻止调用fail(),则这是不好的.如果现实世界中存在db队列数据的实际损坏怎么办?
我目前正在研究排队解决方案来处理1MB的中型消息.除了Redis,Kafka和RabbitMQ之间的功能差异,我找不到任何关于他们在大小约1MB的消息上的表现的好答案.
我正在尝试读取tensorflow中的一些数据,然后将其与其标签进行匹配.我的设置如下:
"a", "b", "c", "d", "e", ..."a", "b", "w, "g", "d", ...,0, 1, 2, 3, 4, ...我想创建一个包含前两个数组之间的对的示例队列,比如["b", "b"], ["d", "g"], ["c", "w"], ....我还想要一个相应数字的队列到那些对,在这种情况下将是1, 3, 2, ...
但是,当我生成这些队列时,我的示例和我的数字不匹配 - 例如,一个队列["b", "b"], ["d", "g"], ["c", "w"], ...与一个标签队列一起5, 0, 2, ....
可能是什么导致了这个?为了测试,我已禁用队列/批处理生成中的所有混洗,但问题仍然存在.
这是我的代码:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
from constants import FLAGS
letters_data = ["a", "b", "c", "d", "e", "f", "g", "h", "i", …Run Code Online (Sandbox Code Playgroud) queue ×10
c# ×3
.net ×2
python ×2
apache-kafka ×1
ghc ×1
haskell ×1
input ×1
java ×1
jobs ×1
laravel ×1
laravel-5 ×1
linq ×1
networking ×1
performance ×1
php ×1
rabbitmq ×1
redis ×1
round-robin ×1
rudp ×1
shuffle ×1
tensorflow ×1
udp ×1
yield-return ×1