Following
on from the Joel Pobar Perth session on concurrency, I came across CCR via a message
post at CodeProject.
The CCR
- Concurrency and Coordination Runtime for asynchronous processing (see here, for a description
by Peter Blomberg) – may offer in the CCR.Core assembly (154Kb) some
welcome help with threading and concurrency, beyond using the excellent BackgroundWorker control
and a lot of brain-power for the more elaborate scenarios.
Unfortunately
to get the 154K assembly it is necessary to download 50Mb of the Microsoft Robotics
Studio May 2007 CTP.
Has
anyone seen code / blog / more thorough descriptions? Or – better –
used the assembly and compared its ease of use and applicability with roll-your-own
management of threads and concurrency using eg the thread pool?
Here’s
a description from Bromberg’s Unblog for those that are interested.
The central feature of the CCR is that it makes programming
asynchronous behavior much simpler than the typical challenge of writing
threaded code.
When an application's thread performs synchronous I/O requests, the application
is giving up control of the thread's processing to the I/O device (a hard
drive, a network, etc.). The application's responsiveness then becomes
unpredictable. When threads are suspended waiting for I/O requests to complete,
the application tends to create more threads in an attempt to accomplish more
work. The problem is that creating, scheduling, and destroying a thread
requires time and memory and can actually hurt performance rather than improve
it.
The CCR offers a number of classes that provide the developer with a simple
object model that you can use to express complex coordination patterns for
dealing with completed I/O operations. CCR offers its own high-performance
thread pool you can use to execute tasks in response to completed I/O. The
thread pool offers great scalability, and when you couple the CCR with some of
the new C# language features (such as anonymous methods and iterators), you
have gotten an easy way to write more responsive and scalable applications.
With the CLR's thread pool, if 1,000 items are queued, there is no way for a
new item to be processed until all of the first 1,000 items have been extracted
from the thread pool's queue. With the CCR you can use one DispatcherQueue
object for most work items and use another DispatcherQueue object for
high-priority work items. The Dispatcher's threads dequeue entries from all the
DispatcherQueue objects associated with it in a round-robin fashion, making
your total processing much more efficient and scalable.
The Dispatcher class creates a Dispatcher object that creates and manages a set
of threads. In effect, it is a thread pool. Like the CLR's thread pool, these
threads call methods (via delegates) in order to execute tasks. Unlike the
CLR's thread pool, there is no special thread that runs periodically checking the
workload and trying to predict whether threads should be dynamically added or
removed from the thread pool.
After you've created a Dispatcher, you'll construct a DispatcherQueue object.
This maintains a queue of delegates that identify methods ready to execute. The
Dispatcher's threads wait for entries to appear in the DispatcherQueue. As
entries appear, Dispatcher threads wake up and execute the methods.
[ MORE ]
IL Thomas
GeoSciSoft - Perth,
Australia
