I can quote Juval Lowy:
"When a thread calls SpinWait(), the calling thread waits
the number of iterations specified, and the thread is
never added to the queue of waiting threads. As a result,
the thread is effectively put to sleep without
relinquishing the remainder of its CPU time slot.

The .NET documentation does not define what an iteration
is, but it is likely mapped to a predetermined number
(probably just one) of NOP (no-operations) assembly
instructions. Consequently, the following SpinWait()
instruction will take different time to complete on
machines with different CPU clock speeds:

const long MILLION = 1000000;
Thread.SpinWait(MILLION);

SpinWait() is not intended to replace Sleep(), but is
rather made available as an advanced optimization
technique. If you know that some resource your thread is
waiting for will become available in the immediate future,
it is potentially more efficient to spin and wait, instead
of using either Sleep() or a synchronization object,
because those force a thread context switch, which is one
of the most expensive operations performed by the
operating system. Even in the esoteric cases for which
SpinWait() was designed, using it is an educated guess at
best. SpinWait() will gain you nothing if the resource is
not available at the end of the call, or if the operating
system preempts your thread because its time slot has
elapsed, or because another thread with a higher priority
is ready to run. In general, I recommend that you should
always use deterministic programming (using
synchronization objects in this case) and avoid ptimization
techniques."

HTH,
Richard

SpinWait keeps the calling thread active on the processor, while Sleep
results in the calling thread by preemted off the processor.  If you
expected a resource that a thread is waiting on to become available very
soon (say, for example, that another processor on the same box will be
releasing a lock on it), you could SpinWait for a certain period, then try
to acquire the resource again before your processor timeslice expired.
SpinWait is an optimization technique to avoid excessive context switching.

Nick Wienholt, MVP
Maximizing .NET Performance
http://www.apress.com/book/bookDisplay.html?bID=217
Sydney Deep .NET User Group www.sdnug.org