/// <summary>
/// Posts the request.
/// </summary>
/// <param name="cb">The cb.</param>
/// <param name="state">The state.</param>
/// <param name="reqStatus">The req status.</param>
/// <returns></returns>
public bool PostRequest(SharedCacheWorkRequestDelegate cb, object state, out ISharedCacheWorkRequest reqStatus)
{
var request = new WorkRequest(cb, state,
propogateThreadPrincipal, propogateCallContext,
propogateHttpContext, propogateCASMarkers);
reqStatus = request;
return(PostRequest(request));
}
public WorkRequest(SharedCacheWorkRequestDelegate cb, object arg,
bool propogateThreadPrincipal, bool propogateCallContext,
bool propogateHttpContext, bool propogateCASMarkers)
{
targetProc = cb;
procArg = arg;
procArgs = null;
Initialize(propogateThreadPrincipal, propogateCallContext,
propogateHttpContext, propogateCASMarkers);
}
public WorkRequest(SharedCacheWorkRequestDelegate cb, object arg,
bool propogateThreadPrincipal, bool propogateCallContext,
bool propogateHttpContext, bool propogateCASMarkers)
{
targetProc = cb;
procArg = arg;
procArgs = null;
Initialize(propogateThreadPrincipal, propogateCallContext,
propogateHttpContext, propogateCASMarkers);
}
public bool PostRequest(SharedCacheWorkRequestDelegate cb, object state, out ISharedCacheWorkRequest reqStatus)
{
WorkRequest request =
new WorkRequest(cb, state,
propogateThreadPrincipal, propogateCallContext,
propogateHttpContext, propogateCASMarkers);
reqStatus = request;
return PostRequest(request);
}
public bool PostRequest(SharedCacheWorkRequestDelegate cb, object state)
{
ISharedCacheWorkRequest notUsed;
return PostRequest(cb, state, out notUsed);
}
// Overloads for the early bound WorkRequestDelegate-based targets.
//
public bool PostRequest(SharedCacheWorkRequestDelegate cb)
{
return PostRequest(cb, (object)null);
}
void ThreadProc()
{
Debug.WriteLine(string.Format("[{0}, {1}] Worker thread started",
AppDomain.GetCurrentThreadId(), Thread.CurrentThread.Name));
bool done = false;
while (!done)
{
WorkRequest wr = null;
ThreadWrapper newThread = null;
lock (pool)
{
// As long as the request queue is empty and a shutdown hasn't
// been initiated, wait for a new work request to arrive.
//
bool timedOut = false;
while (!pool.stopInProgress && !timedOut && (pool.requestQueue.Count == 0))
{
if (!Monitor.Wait(pool, (isPermanent ? Timeout.Infinite : pool.decayTime)))
{
// Timed out waiting for something to do. Only dynamically created
// threads will get here, so bail out.
//
timedOut = true;
}
}
// We exited the loop above because one of the following conditions
// was met:
// - ThreadPool.Stop was called to initiate a shutdown.
// - A dynamic thread timed out waiting for a work request to arrive.
// - There are items in the work queue to process.
// If we exited the loop because there's work to be done,
// a shutdown hasn't been initiated, and we aren't a dynamic thread
// that timed out, pull the request off the queue and prepare to
// process it.
//
if (!pool.stopInProgress && !timedOut && (pool.requestQueue.Count > 0))
{
wr = (WorkRequest)pool.requestQueue.Dequeue();
Debug.Assert(wr != null);
// Check to see if this work request languished in the queue
// very long. If it was in the queue >= the new thread trigger
// time, and if we haven't reached the max thread count cap,
// add a new thread to the pool.
//
// If the decision is made, create the new thread object (updating
// the current # of threads in the pool), but defer starting the new
// thread until the lock is released.
//
TimeSpan requestTimeInQ = DateTime.Now.Subtract(wr.workingTime);
if ((requestTimeInQ >= pool.newThreadTrigger) && (pool.currentThreadCount < pool.maxThreadCount))
{
// Note - the constructor for ThreadWrapper will update
// pool.currentThreadCount.
//
newThread =
new ThreadWrapper(pool, false, priority,
string.Format("{0} (dynamic)", pool.threadPoolName));
// Since the current request we just dequeued is stale,
// everything else behind it in the queue is also stale.
// So reset the timestamps of the remaining pending work
// requests so that we don't start creating threads
// for every subsequent request.
//
pool.ResetWorkRequestTimes();
}
}
else
{
// Should only get here if this is a dynamic thread that
// timed out waiting for a work request, or if the pool
// is shutting down.
//
Debug.Assert((timedOut && !isPermanent) || pool.stopInProgress);
pool.currentThreadCount--;
if (pool.currentThreadCount == 0)
{
// Last one out turns off the lights.
//
Debug.Assert(pool.stopInProgress);
if (pool.Stopped != null)
{
pool.Stopped();
}
pool.stopCompleteEvent.Set();
}
done = true;
}
} // lock
// No longer holding pool lock here...
if (!done && (wr != null))
{
// Check to see if this request has been cancelled while
// stuck in the work queue.
//
// If the work request was pending, mark it processed and proceed
// to handle. Otherwise, the request must have been cancelled
// before we plucked it off the request queue.
//
if (Interlocked.CompareExchange(ref wr.state, WorkRequest.PROCESSED, WorkRequest.PENDING) != WorkRequest.PENDING)
{
// Request was cancelled before we could get here.
// Bail out.
continue;
}
if (newThread != null)
{
Debug.WriteLine(string.Format("[{0}, {1}] Adding dynamic thread to pool",
AppDomain.GetCurrentThreadId(), Thread.CurrentThread.Name));
newThread.Start();
}
// Dispatch the work request.
//
ThreadInfo originalThreadInfo = null;
try
{
// Impersonate (as much as possible) what we know about
// the thread that issued the work request.
//
originalThreadInfo = ThreadInfo.Impersonate(wr.threadInfo);
SharedCacheWorkRequestDelegate targetProc = wr.targetProc as SharedCacheWorkRequestDelegate;
if (targetProc != null)
{
targetProc(wr.procArg, wr.timeStampStarted);
}
else
{
wr.targetProc.DynamicInvoke(wr.procArgs);
}
}
catch (Exception e)
{
Debug.WriteLine(string.Format("Exception thrown performing callback:\n{0}\n{1}", e.Message, e.StackTrace));
}
finally
{
// Restore our worker thread's identity.
//
ThreadInfo.Restore(originalThreadInfo);
}
}
}
Debug.WriteLine(string.Format("[{0}, {1}] Worker thread exiting pool",
AppDomain.GetCurrentThreadId(), Thread.CurrentThread.Name));
}
public bool PostRequest(SharedCacheWorkRequestDelegate cb, object state)
{
ISharedCacheWorkRequest notUsed;
return(PostRequest(cb, state, out notUsed));
}
// Overloads for the early bound WorkRequestDelegate-based targets.
//
public bool PostRequest(SharedCacheWorkRequestDelegate cb)
{
return(PostRequest(cb, (object)null));
}
