• .net IO异步和Producer/Consumer队列实现一分钟n次http请求


    简介

    最近工作中有一个需求:要求发送http请求到某站点获取相应的数据,但对方网站限制了请求的次数:一分钟最多200次请求。

    搜索之后,在stackoverflow网站查到一个类似的问题.。但里面用到了Reactive Extensions,权衡之下最后还是决定自己简单实现一分钟最多200次请求。

    思路

    思路很简单,一分钟200次,平均下来一次请求300ms,大概3次的时候将近一秒,所以一次异步发送三个请求,然后线程暂停900ms。

    这里的关键是运行代码时尽量不要堵塞线程,可以速度很快执行发送请求之前的代码。

    实现

    异步请求

    http请求属于IO请求,其异步可以调用HttpWebRequest.BeginGetResponse方法实现,但现在流行TPL,方法TaskFactory.FromAsync更加方便简介。

    request = (HttpWebRequest)WebRequest.Create(addUrl);
    request.Method = "POST";
    request.Timeout = timeOut;
    request.Proxy = null;
    request.Accept = "application/xml, */*";
    request.ContentType = "application/xml";
    
    XElement inputElem = BuildRequestInputXml(userName, pwd, ctripPolicy);
    byte[] inputBytes = Encoding.UTF8.GetBytes(inputStr);
    inputBytes = ms.ToArray();
    using (var stream = request.GetRequestStream())
    {
        stream.Write(inputBytes, 0, inputBytes.Length);
    }
    Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse, request.EndGetResponse, null, TaskCreationOptions.None).ContinueWith(
        t =>
        {
            HttpWebResponse response = t.Result;
            using (StreamReader reader = new StreamReader(responseStream))
            {
                responseStr = reader.ReadToEnd();
            }
            DBAccessHelper.UpdateDB(responseStr);
    
        });
    

     异步实现之后就是发送三次请求,然后暂停900ms:

    for (int i = 0; i < datas.Length; i++)
    {
        StartOneQueryAsync(datas[i].t1, datas[i].t2);
    
        if ((i + 1) % 3 == 0)
        {
        Thread.Sleep(TimeSpan.FromMilliseconds(900));
        }            
     }
    

     测试和改进

    简单实现之后就开始测试,但后来发现代码在发送了200次请求之后,后续请求就会被堵塞很长的时间(3~4s),最后测试结果是4000个请求大概30分钟才完成,这个和我们理想的20分钟有很大的差距。

    一开始的分析是发送请求次数过多,因为是异步发送,后续处理的线程可能不够而导致线程被堵塞。

    这里的解决方法就是使用 生产者/消费者队列,如网上的MSMQ,RabbitMQ等。

    不过在.net 4.0中添加了一些异步集合类:ConcurrentStack<T>,ConcurrentQueue<T>,ConcurrentBag<T>,ConcurrentDictionary<TKey,TValue>。

    所以这里的思路就是用异步队列ConcurrentQueue<Action>将要执行的方法Action添加到异步队列中,然后开启2到3个格外的线程从异步队列中获取Action再执行之。

    这种ProducerConsumer模式在.net 4.0中也已存在,其中有BlockingCollection<T>类就实现了IProducerConsumerCollection<T>接口,有了这些之后我们就可以实现一个Producer/Consumer 队列:

    public class UpdateDBQueue : IDisposable
    {
        BlockingCollection<Action> _taskQ = new BlockingCollection<Action>();
    
        public UpdateDBQueue(int workerCount)
        {
            // 创建格外的线程来执行task
            for (int i = 0; i < workerCount; i++)
            {
                Task.Factory.StartNew(Consume);
            }
        }
    
        public void Enqueue(Action action) { _taskQ.Add(action); }
    
        void Consume()
        {
            // 队列中没有数据就会被堵塞,在方法CompleteAdding被调用之后就会自动结束
            foreach (Action action in _taskQ.GetConsumingEnumerable())
            {
                action(); // Perform task.
            }
        }
    
        public void Dispose()
        {
            _taskQ.CompleteAdding();
        }     
    }
    

     这里如果还是 .net 2.0的同学可以参考stackoverflow的这篇文章,里面有介绍2.0如何实现Producer/Consumer 队列

    下面就是新加了队列后的代码。

    Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse, request.EndGetResponse, null, TaskCreationOptions.None).ContinueWith(
        t =>
        {
            HttpWebResponse response = t.Result;
            using (StreamReader reader = new StreamReader(responseStream))
            {
                responseStr = reader.ReadToEnd();
            }
          //数据更新推送到队列
           updateUBQueue.Enqueue(() =>{
               DBAccessHelper.UpdateDB(responseStr);
            });
        });
    

     持续测试和改进

    加上队列之后再次测试,发现在200次请求之后还是有堵塞的情况发生,这样看样子应该不是后续处理线程不够,应该是请求的时候线程被堵塞。

    代码比较简单,后来发现request.GetRequestStream方法也有对应的HttpWebRequest.GetRequestStream,看样子也是IO请求,所以最后也写成异步:

    Task.Factory.FromAsync<Stream>(request.BeginGetRequestStream, request.EndGetRequestStream, null, TaskCreationOptions.None)
    .ContinueWith(streamTask => 
    {
        using (var stream = streamTask.Result)
        {
            stream.Write(inputBytes, 0, inputBytes.Length);
        }
    
        Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse, request.EndGetResponse, null, TaskCreationOptions.None)
                .ContinueWith(responseTask =>
                {
                    #region Get Response
                    HttpWebResponse response = null;
                    try
                    {
                        response = (HttpWebResponse)responseTask.Result;
                        string responseStr = string.Empty;
                        using (Stream responseStream = response.GetResponseStream())
                        {
                                using (StreamReader reader = new StreamReader(responseStream))
                                {
                                    responseStr = reader.ReadToEnd();
                                }
                        }
                    updateUBQueue.Enqueue(() =>
                    {
                        DBAccessHelper.UpdateDB(responseStr);
                    });
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Log("*****", ex);
                    }
                    finally
                    {
                        if (response != null)
                        {
                            response.Close();
                        }
                        if (request != null)
                        {
                            request.Abort();
                        }
                    }
    
                });
    
    });
    

     最后测试的时候发现4000多个请求在21分钟就可以完成,测试通过。

    总结:

    http异步请求的时候GetResponse也需要异步,.net 4.0已经包含了异步队列ConcurrentQueue<T>,使用BlockingCollection<T>可以实现自己的Producer/Consumer 队列。

  • 相关阅读:
    WCF的一些基本知识点
    WCF服务编程基础
    Spring IoC 原理猜想(转载)
    利用httponly提升应用程序安全性(转载)
    Ajax:CustomValidator对输入的文本框进行验证
    WCF学习系列
    WCF 契约
    JavaScript:search() 方法
    HDU 1596 find the safest road
    HDU 2063 过山车
  • 原文地址:https://www.cnblogs.com/julyluo/p/4905361.html
Copyright © 2020-2023  润新知