SourceForge.net

 using System;

 using System.Collections.Generic;

 using System.Linq;

 using System.Diagnostics;

 using System.Threading;

 namespace Sasa.Concurrency

 {

     /// <summary>

     /// Encapsulates instance-specific thread-local data.

     /// </summary>

     /// <typeparam name="T">The type of data.</typeparam>

     public abstract class ThreadScoped<T> : IRef<T>, IDisposable

     {

         internal ThreadScoped<T> next; // track refs in a list for reuse

         internal uint current;         // the current version number of the data

         // Always start with one ref node, indexed by T at the start. Each ThreadScoped allocation either generates

         // a new generic type Ref<Ref<TIndex>>, or returns an existing one that was disposed. Disposal pushes the

         // Ref back onto the list at the front so we can reuse existing generic types as they've been deallocated.

         // Invariant: the last item in the list is always the highest generic type to have been allocated.

         internal static ThreadScoped<T> free = new Ref<T>();

         /// <summary>

         /// Destroy this thread-local variable.

         /// </summary>

         ~ThreadScoped()

         {

             Dispose();

         }

         /// <summary>

         /// Ensure others can't inherit from this class.

         /// </summary>

         ThreadScoped()

         {

         }

         /// <summary>

         /// The value of the thread-local.

         /// </summary>

         public abstract T Value { get; set; }

         /// <summary>

         /// Dispose of this thread-local instance.

         /// </summary>

         public abstract void Dispose();

         /// <summary>

         /// Allocate a variable.

         /// </summary>

         /// <returns>Either a new instance, or an old instance being reused.</returns>

         internal abstract ThreadScoped<T> Allocate();

         /// <summary>

         /// A unique reference generated by the phantom type <typeparamref name="TIndex"/>.

         /// </summary>

         /// <typeparam name="TIndex">The phantom type used to generate unique instances of thread-local data.</typeparam>

         sealed class Ref<TIndex> : ThreadScoped<T>

         {

             [ThreadStatic]

             static T scoped;     // the unique thread-local slot

             [ThreadStatic]

             static uint version; // the version number of the thread-local data

             /// <summary>

             /// The thread-local data.

             /// </summary>

             /// <remarks>

             /// The thread-local and the outer version number must match to return

             /// the stored thread-local value. If the versions do not match, the

             /// thread-local value is cleared and the thread-local version number

             /// incremented.

             /// </remarks>

             public override T Value

             {

                 get { return current == version ? scoped : Update(); }

                 set { scoped = value; }

             }

             T Update()

             {

                 if (next != this) throw new ObjectDisposedException("Transacted<T> has been disposed.");

                 version = current;

                 return scoped = default(T);

             }

             public override void Dispose()

             {

                 // ensure only one disposal because an allocated ThreadLocal.next references

                 // 'this', so update 'next' to null atomically, and only allow the thread that

                 // succeeded through

                 var self = Interlocked.CompareExchange(ref next, null, this);

                 if (self == this)

                 {

                     // increment outer version number to ensure old thread-local data expires

                     ++base.current;

                     // push this ref onto the list of free refs

                     do

                     {

                         next = free;

                     } while (Atomics.SetFailed(ref free, this, next));

                 }

                 // update the thread-local version number and clear the value

                 // for every thread that calls Dispose()

                 version = current;

                 scoped = default(T);

             }

             internal override ThreadScoped<T> Allocate()

             {

                 // if 'next' is null, we are at the end of the list of free refs,

                 // so allocate a new one and enqueue it, then return 'this'

                 var x = next;

                 if (x != null) return this;

                 x = Interlocked.CompareExchange(ref next, new Ref<Ref<TIndex>>(), null);

                 // atomic swap failure doesn't matter, since the caller of Acquire()

                 // accesses whatever instance is at this.next

                 return this;

             }

         }

     }

     /// <summary>

     /// Extensions to <seealso cref="ThreadScoped{T}"/>.

     /// </summary>

     public static class ThreadScoped

     {

         /// <summary>

         /// Construct a <seealso cref="ThreadScoped{T}"/> with a default value.

         /// </summary>

         /// <typeparam name="T">The type of the variable.</typeparam>

         /// <param name="value">The default instance value.</param>

         /// <returns>A new thread-scoped variable.</returns>

         public static ThreadScoped<T> Create<T>(T value)

         {

             var x = Create<T>();

                 x.Value = value;

             return x;

         }

         /// <summary>

         /// Construct a <seealso cref="ThreadScoped{T}"/>.

         /// </summary>

         /// <typeparam name="T">The type of the variable.</typeparam>

         /// <returns>A new thread-scoped variable.</returns>

         public static ThreadScoped<T> Create<T>()

         {

             // pop the head of the static reference list in a thread-safe way

             ThreadScoped<T> x;

             do

             {

                 x = ThreadScoped<T>.free.Allocate();

             } while (Atomics.SetFailed(ref ThreadScoped<T>.free, x.next, x));

             // self-reference used to mutually exclude in Dispose()

             x.next = x;

             return x;

         }

     }

 }