Question

所以我不能肯定地说这是问题，但我只是肯定它是正确的。我有一个IVR调用记录集。我将每个数据放在一个并发队列中，并启动5个后台工作程序从队列开始工作。但是，在拨打2个电话后，电话将停止播放，直到一个人挂机，然后继续拨打电话号码3,4,5等。此代码有任何问题吗？

看起来背景工作者正在阻止彼此调用相同的方法......？这可能吗？

private ConcurrentQueue<DataTable> _ivrCallsQueue = new ConcurrentQueue<DataTable>();

private List<BackgroundWorker> _ivrCallers = new List<BackgroundWorker>();

public overrid void Process()
{
 foreach(DataRow row in _tblRecordsToProcess.Rows)
    {
       _workingActionItem = actionItemDAL.GetActionItemFromId(Convert.ToInt32(row["FNActionItemId"].ToString()));

        var workingActionItemsTable = actionItemDAL.GetActionItemParamValues(Convert.ToInt32(row["FNActionItemId"].ToString()));

       ivrCallsQueue.Enqueue(workingActionItemsTable);
    }

    StartCalls();

  while (_ivrCallers.Count != 0)
  {
      testurls = testurls;
  }
}

private void StartCalls()
{
    int maxLines = 5;

    if (_ivrCallsQueue.Count < maxLines)
    {
        maxLines = _ivrCallsQueue.Count;
    }

   for (int i = 0; i < maxLines; i++)
   {
       DataTable workingCall = new DataTable();

       _ivrCallsQueue.TryDequeue(out workingCall);

       BackgroundWorker ivrCaller = new BackgroundWorker();

       _ivrCallers.Add(ivrCaller);

            ivrCaller.DoWork += delegate(object sender, DoWorkEventArgs e)
          {
                RequestIVR(workingCall, Convert.ToInt32(workingCall.Rows[2][0].ToString()));
                _ivrCallers.Remove(ivrCaller);
            };

            ivrCaller.RunWorkerCompleted += (bw_AnalyzeResults);

            ivrCaller.RunWorkerAsync();
   }
}

private void bw_AnalyzeResults(object sender, RunWorkerCompletedEventArgs e)
{
    DataTable workingCall = new DataTable();

    if (_ivrCallsQueue.Count != 0)
    {
        _ivrCallsQueue.TryDequeue(out workingCall);

        BackgroundWorker ivrCaller = new BackgroundWorker();

        ivrCaller.DoWork += delegate(object completeSender, DoWorkEventArgs completeArgs)
        {
            RequestIVR(workingCall, Convert.ToInt32(workingCall.Rows[2][0].ToString()));
            _ivrCallers.Remove(ivrCaller);
        };

        ivrCaller.RunWorkerCompleted += (bw_AnalyzeResults);

        ivrCaller.RunWorkerAsync();
    }
    else
    {

    }
}

private void RequestIVR(DataTable workingTable,int fnActionItemID)
{
     var urlRequest = "http://uccx_http_trigger:9080/test?strTestMode=1&strTaskID=" + fnActionItemID;

    var webClient = new WebClient { UseDefaultCredentials = true, Proxy = WebRequest.DefaultWebProxy };
    DecodeResponseType(GetValueFromElement("Response Code was&nbsp;", webClient.DownloadString(urlRequest)));
  }

Answer 1

这将产生最多五个线程，每个线程都尝试从队列中提取下一个项目并对其进行处理。如果队列为空，则尝试将失败，线程将退出：

    private List<System.Threading.Thread> Threads = new List<System.Threading.Thread>();
    private ConcurrentQueue<DataTable> _ivrCallsQueue = new ConcurrentQueue<DataTable>();

    private void StartCalls()
    {
        int maxLines = Math.Min(5 , _ivrCallsQueue.Count);
        for (int i = 0; i < maxLines; i++ )
        {
            System.Threading.Thread T = new System.Threading.Thread(delegate()
            {
                DataTable workingCall;
                while (_ivrCallsQueue.TryDequeue(out workingCall))
                {
                    RequestIVR(workingCall, Convert.ToInt32(workingCall.Rows[2][0].ToString()));
                }
            });
            Threads.Add(T);
            T.Start();
        }
    }

线程将一直运行，直到所有项目都已处理完毕。

Answer 2

看起来bw_AnalyzeResults与StartCalls()几乎完全相同。换句话说，当后台工作者完成它的工作时，你会立即将同样的工作重新排队，永远递归地发生？

根据它的外观，您希望bw_AnalyzeResults分析通过调用您的Web服务返回的结果。这不是目前正在发生的事情。

以下从bw_AnalyzeResults事件处理程序获取的代码是调度后台作业并使自己处理RunWorkerCompleted事件。那么，大概是软件会一直在周围执行bw_AnalyzeResults，直到你终止这个过程？

private void bw_AnalyzeResults(object sender, RunWorkerCompletedEventArgs e)
{
    ivrCaller.DoWork += delegate(object completeSender, DoWorkEventArgs completeArgs)
    {
        RequestIVR(workingCall, Convert.ToInt32(workingCall.Rows[2][0].ToString()));
        _ivrCallers.Remove(ivrCaller);
    };
    ivrCaller.RunWorkerCompleted += (bw_AnalyzeResults);
}

窃取主要螺纹的背景工作者

2 个答案: