SpinWait Structure
Collapse the table of content
Expand the table of content

SpinWait Structure

.NET Framework 4.6 and 4.5

Provides support for spin-based waiting.

Namespace:   System.Threading
Assembly:  mscorlib (in mscorlib.dll)

[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public struct SpinWait


Gets the number of times SpinOnce has been called on this instance.


Gets whether the next call to SpinOnce will yield the processor, triggering a forced context switch.


Indicates whether this instance and a specified object are equal.(Inherited from ValueType.)


Returns the hash code for this instance.(Inherited from ValueType.)


Gets the Type of the current instance.(Inherited from Object.)


Resets the spin counter.


Performs a single spin.


Spins until the specified condition is satisfied.

System_CAPS_pubmethodSystem_CAPS_staticSpinUntil(Func<Boolean>, Int32)

Spins until the specified condition is satisfied or until the specified timeout is expired.

System_CAPS_pubmethodSystem_CAPS_staticSpinUntil(Func<Boolean>, TimeSpan)

Spins until the specified condition is satisfied or until the specified timeout is expired.


Returns the fully qualified type name of this instance.(Inherited from ValueType.)

SpinWait encapsulates common spinning logic. On single-processor machines, yields are always used instead of busy waits, and on computers with Intel processors employing Hyper-Threading technology, it helps to prevent hardware thread starvation. SpinWait encapsulates a good mixture of spinning and true yielding.

SpinWait is a value type, which means that low-level code can utilize SpinWait without fear of unnecessary allocation overheads. SpinWait is not generally useful for ordinary applications. In most cases, you should use the synchronization classes provided by the .NET Framework, such as Monitor. For most purposes where spin waiting is required, however, the SpinWait type should be preferred over the SpinWait method.

The following example shows how to use a SpinWait:

using System;
using System.Threading;
using System.Threading.Tasks;

class SpinWaitDemo
    // Demonstrates:
    //      SpinWait construction
    //      SpinWait.SpinOnce()
    //      SpinWait.NextSpinWillYield
    //      SpinWait.Count
    static void Main()
        bool someBoolean = false;
        int numYields = 0;

        // First task: SpinWait until someBoolean is set to true
        Task t1 = Task.Factory.StartNew(() =>
            SpinWait sw = new SpinWait();
            while (!someBoolean)
                // The NextSpinWillYield property returns true if
                // calling sw.SpinOnce() will result in yielding the
                // processor instead of simply spinning.
                if (sw.NextSpinWillYield) numYields++;

            // As of .NET Framework 4: After some initial spinning, SpinWait.SpinOnce() will yield every time.
            Console.WriteLine("SpinWait called {0} times, yielded {1} times", sw.Count, numYields);

        // Second task: Wait 100ms, then set someBoolean to true
        Task t2 = Task.Factory.StartNew(() =>
            someBoolean = true;

        // Wait for tasks to complete
        Task.WaitAll(t1, t2);

Universal Windows Platform
Available since 4.5
.NET Framework
Available since 4.0
Portable Class Library
Supported in: portable .NET platforms
Windows Phone Silverlight
Available since 8.0
Windows Phone
Available since 8.1

While SpinWait is designed to be used in concurrent applications, it is not designed to be used from multiple threads concurrently. SpinWait members are not thread-safe. If multiple threads must spin, each should use its own instance of SpinWait.

Return to top
© 2015 Microsoft