private Thread()
{
_managedThreadId = System.Threading.ManagedThreadId.GetCurrentThreadId();
PlatformSpecificInitialize();
RegisterThreadExitCallback();
}
private static int MakeForCurrentThread()
{
if (s_idDispenser == null)
{
Interlocked.CompareExchange(ref s_idDispenser, ImmutableIdDispenser.Empty, null);
}
int id;
var priorIdDispenser = Volatile.Read(ref s_idDispenser);
for (;;)
{
var updatedIdDispenser = priorIdDispenser.AllocateId(out id);
var interlockedResult = Interlocked.CompareExchange(ref s_idDispenser, updatedIdDispenser, priorIdDispenser);
if (Object.ReferenceEquals(priorIdDispenser, interlockedResult))
{
break;
}
priorIdDispenser = interlockedResult; // we already have a volatile read that we can reuse for the next loop
}
Debug.Assert(id != ManagedThreadIdNone);
t_currentThreadId = new ManagedThreadId(id);
t_currentManagedThreadId = id;
return(id);
}
private void Initialize()
{
_priority = ThreadPriority.Normal;
_managedThreadId = new ManagedThreadId();
PlatformSpecificInitialize();
RegisterThreadExitCallback();
}
public static int SetForCurrentThread(ManagedThreadId threadId)
{
t_currentThreadId = threadId;
t_currentManagedThreadId = threadId.Id;
return(threadId.Id);
}
private static int MakeForCurrentThread()
{
//
// Get the current thread handle. We need to use DuplicateHandle, because GetCurrentThread returns a pseudo-handle
// that cannot be used outside of this thread.
//
IntPtr thisNativeThreadHandle;
Interop.mincore.DuplicateHandle(
Interop.mincore.GetCurrentProcess(),
Interop.mincore.GetCurrentThread(),
Interop.mincore.GetCurrentProcess(),
out thisNativeThreadHandle,
0,
false,
(uint)Interop.Constants.DuplicateSameAccess);
//
// First, search for a dead thread, so we can reuse its thread ID
//
for (ManagedThreadId current = s_list; current != null; current = current._next)
{
//
// Try to take the lock on this ID. If another thread already has it, just move on to the next ID.
//
if (Interlocked.Exchange(ref current._lock, 1) != 0)
continue;
try
{
//
// Does the ID currently belong to a dead thread?
//
if (LowLevelThread.WaitForSingleObject(current._nativeThreadHandle, 0) == (uint)Interop.Constants.WaitObject0)
{
//
// The thread is dead. We can claim this ID by swapping in our own thread handle.
//
Interop.mincore.CloseHandle(current._nativeThreadHandle);
current._nativeThreadHandle = thisNativeThreadHandle;
t_currentManagedThreadId = current._managedThreadId;
return current._managedThreadId;
}
}
finally
{
//
// Release the lock.
//
current._lock = 0;
}
}
//
// We couldn't find a dead thread, so we can't reuse a thread ID. Create a new one.
//
ManagedThreadId newManagedThreadId = new ManagedThreadId(Interlocked.Increment(ref s_nextThreadId));
newManagedThreadId._nativeThreadHandle = thisNativeThreadHandle;
while (true)
{
ManagedThreadId oldList = s_list;
newManagedThreadId._next = oldList;
if (Interlocked.CompareExchange(ref s_list, newManagedThreadId, oldList) == oldList)
{
t_currentManagedThreadId = newManagedThreadId._managedThreadId;
return newManagedThreadId._managedThreadId;
}
}
}
private static int MakeForCurrentThread()
{
if (s_idDispenser == null)
Interlocked.CompareExchange(ref s_idDispenser, ImmutableIdDispenser.Empty, null);
int id;
var priorIdDispenser = Volatile.Read(ref s_idDispenser);
for (;;)
{
var updatedIdDispenser = priorIdDispenser.AllocateId(out id);
var interlockedResult = Interlocked.CompareExchange(ref s_idDispenser, updatedIdDispenser, priorIdDispenser);
if (Object.ReferenceEquals(priorIdDispenser, interlockedResult))
break;
priorIdDispenser = interlockedResult; // we already have a volatile read that we can reuse for the next loop
}
Debug.Assert(id != ManagedThreadIdNone);
t_currentThreadId = new ManagedThreadId(id);
t_currentManagedThreadId = id;
return id;
}
private static int MakeForCurrentThread()
{
//
// Get the current thread handle. We need to use DuplicateHandle, because GetCurrentThread returns a pseudo-handle
// that cannot be used outside of this thread.
//
IntPtr thisNativeThreadHandle;
Interop.mincore.DuplicateHandle(
Interop.mincore.GetCurrentProcess(),
Interop.mincore.GetCurrentThread(),
Interop.mincore.GetCurrentProcess(),
out thisNativeThreadHandle,
0,
false,
(uint)Interop.Constants.DuplicateSameAccess);
//
// First, search for a dead thread, so we can reuse its thread ID
//
for (ManagedThreadId current = s_list; current != null; current = current._next)
{
//
// Try to take the lock on this ID. If another thread already has it, just move on to the next ID.
//
if (Interlocked.Exchange(ref current._lock, 1) != 0)
{
continue;
}
try
{
//
// Does the ID currently belong to a dead thread?
//
if (LowLevelThread.WaitForSingleObject(current._nativeThreadHandle, 0) == (uint)Interop.Constants.WaitObject0)
{
//
// The thread is dead. We can claim this ID by swapping in our own thread handle.
//
Interop.mincore.CloseHandle(current._nativeThreadHandle);
current._nativeThreadHandle = thisNativeThreadHandle;
t_currentManagedThreadId = current._managedThreadId;
return(current._managedThreadId);
}
}
finally
{
//
// Release the lock.
//
current._lock = 0;
}
}
//
// We couldn't find a dead thread, so we can't reuse a thread ID. Create a new one.
//
ManagedThreadId newManagedThreadId = new ManagedThreadId(Interlocked.Increment(ref s_nextThreadId));
newManagedThreadId._nativeThreadHandle = thisNativeThreadHandle;
while (true)
{
ManagedThreadId oldList = s_list;
newManagedThreadId._next = oldList;
if (Interlocked.CompareExchange(ref s_list, newManagedThreadId, oldList) == oldList)
{
t_currentManagedThreadId = newManagedThreadId._managedThreadId;
return(newManagedThreadId._managedThreadId);
}
}
}
private void SetStartHelper(Delegate threadStart, int maxStackSize)
{
_threadStart = threadStart;
_maxStackSize = maxStackSize;
_managedThreadId = new ManagedThreadId();
}