在.NET中使用TPL

Question

I have to refactor a fairly time-consuming process in one of my applications and after doing some research I think it's a perfect match for using TPL. I wanted to clarify my understanding of it and ask if there are any more issues which I should take into account.

In few words, I have a windows service, which runs overnight and sends out emails with data updates to around 10000 users. At presence, the whole process takes around 8 hrs to complete. I would like to reduce it to 2 hrs max.

Application workflow follows steps below: 1. Iterate through all users list 2. Check if this user has to be notified 3. If so, create an email body by calling external service 4. Send an email

Analysis of the code has shown that step 3 is the most time-consuming one and takes around 3,5 sec to complete. It means, that when processing 10000 users, my application waits well over 6 hrs in total for a response from the external service! I think this is a reason good enough to try to introduce some asynchronous and parallel processing.

So, my plan is to use Parallel class and ForEach method to iterate through users in step 1. As I can understand this should distribute processing each user into a separate thread, making them run in parallel? Processes are completely independent of each other and each doesn't return any value. In the case of any exception being thrown it will be persisted in logs db. As with regards to step 3, I would like to convert a call to external service into an async call. As I can understand this would release the resources on the thread so it could be reused by the Parallel class to start processing next user from the list?

I had a read through MS documentation regarding TPL, especially Potential Pitfalls in Data and Task Parallelism document and the only point I'm not sure about is "Avoid Writing to Shared Memory Locations". I am using a local integer to count a total number of emails processed. As with regards to all of the rest, I'm quite positive they're not applicable to my scenario.

My question is, without any implementation as yet. Is what I'm trying to achieve possible (especially the async await part for external service call)? Should I be aware of any other obstacles that might affect my implementation? Is there any better way of improving the workflow?

Just to clarify I'm using .Net v4.0

Answer 1

Yes, you can use the TPL for your problem. If you cannot influence your external problem, then this might be the best way.

However, you can make the best gains if you can get your external source to accept batches. Because this source could actually optimize the performance. Right now you have a message overhead of 10000 messages to serialize, send, work on, receive and deserialize. This is stuff that could be done once . In addition, your external source might be able to optimize the work they do if they know they will get multiple records.

So the bottom line is: if you need to optimize locally, the TPL is fine. If you want to optimize your whole process for actual gains, try to find out if your external source can help you, because that is where you can make some real progress.

Answer 2

You didn't show any code, and I'm assuming that step 4 ( send an e-mail ) is not that fast either.

With the presented case, unless your external service from step 3 ( create an email body by calling external service ) processes requests in parallel and supports a good load of simultaneous requests, you will not gain much with this refactor.

In other words, test the external service and the e-mail server first for:

• Parallel request execution

  The way to test this is to send at least 2 simultaneous requests and observe how long it takes to process them.

  If it takes about double the time of a single, the requests have some serial processing, either they're queued or some broad lock is being taken.

• Load test

  Go up to 4, 8, 12, 16, 20, etc, and see where it starts to degrade.

  You should set a limit on the amount of simultaneous requests to something that keeps execution time above eg 80% of the time it takes to process a single request, assuming you're the sole consumer

  Or a few requests before it starts degrading (eg divide by the number of consumers) to leave the external service available for other consumers.

Only then can you decide if the refactor is worth. If you can't change the external service or the e-mail server, you must weight it they offer enough parallel capability without degrading.

Even so, be realistic. Don't let your service push the external service and the e-mail server to their limits in production.