Author: Adam Freeman
Publisher: Apress, 2010
Aimed at: Experienced C# programmers
Pros: Methodical and clear approach
Cons: Fails to cover UI thread
Reviewed by: Ian Elliot
Parallel Programming is more important than ever and there are some new approaches in the pipeline. This particular book takes a fairly traditional approach to parallel programming by focusing on the Task Programming Library. After the usual preliminaries, Chapter 2 gets started with basic tasks and at this stage it is clear that the author intends to show you every possible way to create a task and generally working with tasks. The examples are small enough to understand and overall the approach works well. As long has you have a rough idea of what you are trying to achieve it all should make good sense. By the end of the chapter you should know everything you need to know about working with tasks - as long as they work in isolation.
Chapter 3 deals with the more interesting case of sharing data between tasks and introduces the problems - race hazards and deadlock. From here each time of lock and synchronization approach is explained complete with small examples. It also deals with the new concurrent collections and even the synchronization features of the existing collections. At the end of the chapter is a collection of patterns illustrating what can go wrong and how to deal with the situation.
The next chapter moves into slightly less familiar territory - task continuations. This works its way through all the possibilities very clearly and then introduces other methods of co-ordinating tasks again many of which you are unlikely to be familiar with from a threads background.
Chapter 5 widens the horizon again with a look at using the parallel loop constructs to automatically run tasks. With the background you have in using tasks you can easily see how to extend and generally work with the higher level parallel constructs. Chapter 6 is more specialized still and looks at Parallel LINQ. If you don't know what LINQ is all about this isn't going to make much sense.
Finally the book rounds off with debugging and a chapter on parallel algorithms - parallel quicksort, map reduce and producer consumer.
Overall this is a methodical and very clear book and if you want to master the Task Parallel Library it is a good choice. However it doesn't deal with one of most common reasons for getting involved in parallel programming at all - shifting work off the UI thread and hence how to interact with the UI thread. In particular it doesn't cover the invoke pattern and doesn't discuss the dispatcher and asynchronous programming in general. If it did cover these topics it would be a much bigger book. Perhaps these should be the subject of a second volume.
As long as you can work out for yourself how to work with the UI thread, or don't care about it, then this is a good book on the topic of using the Thread Parallel Library.