简介
最近工作中有一个需求:要求发送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 队列。