C# 具有多线程轮询器取消功能的ZeroMQ发布/订阅模式
我有两个应用程序，一个C++服务器和一个C语言WPF UI。C++代码通过零服务消息[PUB/SUB]服务从任何地方/任何人接收请求。我使用我的C#代码进行反向测试，创建“反向测试”并执行它们。这些后备测试可以由许多“单元测试”组成，每个测试都可以从C/C++服务器发送/接收成千上万的消息。 目前，单个后台测试工作良好，可以发送N个单元测试，每个单元测试包含数千个请求和捕获。我的问题是建筑；当我分派另一个back测试（在第一次测试之后）时，由于轮询线程没有被取消和释放，我在第二次执行事件订阅时遇到了问题。这会导致输出错误。这似乎是一个微不足道的问题（也许对你们中的一些人来说是），但是在我当前的配置下取消这个轮询任务是很麻烦的。一些代码 我的MessageBroker类很简单，看起来像C# 具有多线程轮询器取消功能的ZeroMQ发布/订阅模式,c#,c++,multithreading,zeromq,netmq,C#,C++,Multithreading,Zeromq,Netmq,我有两个应用程序，一个C++服务器和一个C语言WPF UI。C++代码通过零服务消息[PUB/SUB]服务从任何地方/任何人接收请求。我使用我的C#代码进行反向测试，创建“反向测试”并执行它们。这些后备测试可以由许多“单元测试”组成，每个测试都可以从C/C++服务器发送/接收成千上万的消息。 目前，单个后台测试工作良好，可以发送N个单元测试，每个单元测试包含数千个请求和捕获。我的问题是建筑；当我分派另一个back测试（在第一次测试之后）时，由于轮询线程没有被取消和释放，我在第二次执行事件订阅时遇
public class MessageBroker : IMessageBroker<Taurus.FeedMux>, IDisposable
{
private Task pollingTask;
private NetMQContext context;
private PublisherSocket pubSocket;
private CancellationTokenSource source;
private CancellationToken token;
private ManualResetEvent pollerCancelled;
public MessageBroker()
{
this.source = new CancellationTokenSource();
this.token = source.Token;
StartPolling();
context = NetMQContext.Create();
pubSocket = context.CreatePublisherSocket();
pubSocket.Connect(PublisherAddress);
}
public void Dispatch(Taurus.FeedMux message)
{
pubSocket.Send(message.ToByteArray<Taurus.FeedMux>());
}
private void StartPolling()
{
pollerCancelled = new ManualResetEvent(false);
pollingTask = Task.Run(() =>
{
try
{
using (var context = NetMQContext.Create())
using (var subSocket = context.CreateSubscriberSocket())
{
byte[] buffer = null;
subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect(SubscriberAddress);
subSocket.Subscribe(String.Empty);
while (true)
{
buffer = subSocket.Receive();
MessageRecieved.Report(buffer.ToObject<Taurus.FeedMux>());
if (this.token.IsCancellationRequested)
this.token.ThrowIfCancellationRequested();
}
}
}
catch (OperationCanceledException)
{
pollerCancelled.Set();
}
}, this.token);
}
private void CancelPolling()
{
source.Cancel();
pollerCancelled.WaitOne();
pollerCancelled.Close();
}
public IProgress<Taurus.FeedMux> MessageRecieved { get; set; }
public string PublisherAddress { get { return "tcp://127.X.X.X:6500"; } }
public string SubscriberAddress { get { return "tcp://127.X.X.X:6501"; } }
private bool disposed = false;
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (this.pollingTask != null)
{
CancelPolling();
if (this.pollingTask.Status == TaskStatus.RanToCompletion ||
this.pollingTask.Status == TaskStatus.Faulted ||
this.pollingTask.Status == TaskStatus.Canceled)
{
this.pollingTask.Dispose();
this.pollingTask = null;
}
}
if (this.context != null)
{
this.context.Dispose();
this.context = null;
}
if (this.pubSocket != null)
{
this.pubSocket.Dispose();
this.pubSocket = null;
}
if (this.source != null)
{
this.source.Dispose();
this.source = null;
}
}
disposed = true;
}
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
~MessageBroker()
{
Dispose(false);
}
}
结尾> ping >代码>消息，它告诉C++我们已经完成了。然后，我们强制等待，这样在所有的返回都从C++代码中接收之前，不会发送下一个[单元]测试-我们使用<代码> MUMLALRESETEVENT/COM>进行此操作。p>
当C++接收到ping消息时，它直接返回消息。我们通过
OnMessageRecievedManualResetEvent.set（）broker.Dispose（）broker.Dispose（）broker.Dispose（）任务，以避免任何多个订阅
要取消线程，我使用CancelPolling（）
方法
private void CancelPolling()
{
source.Cancel();
pollerCancelled.WaitOne(); <- Blocks here waiting for cancellation.
pollerCancelled.Close();
}
while (true)
{
buffer = subSocket.Receive();
MessageRecieved.Report(buffer.ToObject<Taurus.FeedMux>());
if (this.token.IsCancellationRequested)
this.token.ThrowIfCancellationRequested();
}
throwifcancellationrequest（）
永远不会被调用，线程也永远不会被取消，因此永远不会被正确处理。轮询器线程正被subSocket.Receive（）方法阻塞
现在，我不清楚如何实现我想要的，我需要在一个线程上调用broker.Dispose（）
/PollerCancel（）
，而不是用于轮询消息的线程，以及如何强制取消。线程中止不是我想不惜任何代价进入的
本质上，我想在执行下一个back测试之前正确地处理代理
，如何正确地处理这个问题，分离轮询并在单独的应用程序域中运行它
我已经尝试过，在onMessageRecieve
处理程序中进行处理，但这显然是在轮询器所在的同一线程上执行的，并且不是执行此操作的方法，如果不调用其他线程，它会阻塞
实现我想要的目标的最佳方式是什么和对于这种情况，有没有一种模式可以遵循
谢谢您的时间。关于这个主题的更高层次的观点
你们致力于创建一个测试框架，你们的专注和努力表明你们的目标是制定一个严格的专业等级方法，这让我首先向这项勇敢的事业致敬
虽然测试是提供合理定量证据的一项重要活动，即测试中的系统是否满足定义的预期，但这方面的成功取决于测试环境与实际部署条件的接近程度
人们可能会同意，在另一个不同的基础上进行测试并不能证明真正的部署将在一个主要不同于测试的环境中按预期运行
问题是元素控制还是状态控制。
您的工作（至少在OP发布时）集中在代码体系结构上，该体系结构尝试将实例保持在适当的位置，并尝试在下一个测试电池启动之前重新设置轮询器实例的内部状态
在我看来，如果你努力进行专业测试，测试有几个原则需要遵循：
- 测试可重复性原则（测试的重新运行应提供相同的结果，从而避免仅提供结果的准测试——“抽签”）
- 不干预测试的原则（测试的重新运行不应受到“外部”干扰，不受测试场景的控制）
说到这里，让我带上几条灵感来自哈里·马科维茨（Harry Markowitz），这位诺贝尔奖得主因其卓越的定量投资组合优化研究而获奖
而是后退一步，控制元素的整个生命周期
CACI Simulations，Inc.（Harry Markowitz的公司之一）在90年代初开发了他们的旗舰软件框架COMET III，这是一个功能极其强大的模拟引擎，用于大规模计算/网络/电信网络中运行的过程的大型复杂设计原型和性能模拟
COMET III给人的最大印象是它能够生成测试场景，包括可配置的测试前“预热”预加载，这使得被测元件进入类似“疲劳”的状态是指机械折磨试验，还是氢扩散脆性对核电厂冶金学家意味着什么
是的，一旦您深入了解算法、节点缓冲区、内存分配、流水线/负载平衡/网格处理体系结构选择、故障恢复能力等方面的低级细节
private void CancelPolling()
{
source.Cancel();
pollerCancelled.WaitOne(); <- Blocks here waiting for cancellation.
pollerCancelled.Close();
}
while (true)
{
buffer = subSocket.Receive();
MessageRecieved.Report(buffer.ToObject<Taurus.FeedMux>());
if (this.token.IsCancellationRequested)
this.token.ThrowIfCancellationRequested();
}
public class FeedMuxMessageBroker : IMessageBroker<Taurus.FeedMux>, IDisposable
{
// Vars.
private NetMQContext context;
private PublisherSocket pubSocket;
private Poller poller;
private CancellationTokenSource source;
private CancellationToken token;
private ManualResetEvent pollerCancelled;
/// <summary>
/// Default ctor.
/// </summary>
public FeedMuxMessageBroker()
{
context = NetMQContext.Create();
pubSocket = context.CreatePublisherSocket();
pubSocket.Connect(PublisherAddress);
pollerCancelled = new ManualResetEvent(false);
source = new CancellationTokenSource();
token = source.Token;
StartPolling();
}
#region Methods.
/// <summary>
/// Send the mux message to listners.
/// </summary>
/// <param name="message">The message to dispatch.</param>
public void Dispatch(Taurus.FeedMux message)
{
pubSocket.Send(message.ToByteArray<Taurus.FeedMux>());
}
/// <summary>
/// Start polling for messages.
/// </summary>
private void StartPolling()
{
Task.Run(() =>
{
using (var subSocket = context.CreateSubscriberSocket())
{
byte[] buffer = null;
subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect(SubscriberAddress);
subSocket.Subscribe(String.Empty);
subSocket.ReceiveReady += (s, a) =>
{
buffer = subSocket.Receive();
if (MessageRecieved != null)
MessageRecieved.Report(buffer.ToObject<Taurus.FeedMux>());
};
// Poll.
poller = new Poller();
poller.AddSocket(subSocket);
poller.PollTillCancelled();
token.ThrowIfCancellationRequested();
}
}, token).ContinueWith(ant =>
{
pollerCancelled.Set();
}, TaskContinuationOptions.OnlyOnCanceled);
}
/// <summary>
/// Cancel polling to allow the broker to be disposed.
/// </summary>
private void CancelPolling()
{
source.Cancel();
poller.Cancel();
pollerCancelled.WaitOne();
pollerCancelled.Close();
}
#endregion // Methods.
#region Properties.
/// <summary>
/// Event that is raised when a message is recived.
/// </summary>
public IProgress<Taurus.FeedMux> MessageRecieved { get; set; }
/// <summary>
/// The address to use for the publisher socket.
/// </summary>
public string PublisherAddress { get { return "tcp://127.0.0.1:6500"; } }
/// <summary>
/// The address to use for the subscriber socket.
/// </summary>
public string SubscriberAddress { get { return "tcp://127.0.0.1:6501"; } }
#endregion // Properties.
#region IDisposable Members.
private bool disposed = false;
/// <summary>
/// Dispose managed resources.
/// </summary>
/// <param name="disposing">Is desposing.</param>
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
CancelPolling();
if (pubSocket != null)
{
pubSocket.Disconnect(PublisherAddress);
pubSocket.Dispose();
pubSocket = null;
}
if (poller != null)
{
poller.Dispose();
poller = null;
}
if (context != null)
{
context.Terminate();
context.Dispose();
context = null;
}
if (source != null)
{
source.Dispose();
source = null;
}
}
// Shared cleanup logic.
disposed = true;
}
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
/// <summary>
/// Finalizer.
/// </summary>
~FeedMuxMessageBroker()
{
Dispose(false);
}
#endregion // IDisposable Members.
}