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