#threadpool

How SQL Server Works

One of the tasks assigned to a Database Administrator is troubleshooting database performance issues. To be able to effectively troubleshoot performance problems you need to have a basic understanding of how SQL Server works. The somewhat over-simplified version of how SQL Server executes your queries is:

An application sends a “request” to the server, containing some T-SQL statements.

The…

Resolved: Thread vs ThreadPool #computers #development #answer

Thread vs ThreadPool

What is the difference between using a new thread and using a thread from the thread pool? What performance benefits are there and why should I consider using a thread from the pool rather than one I’ve explicitly created? I’m thinking specifically of .NET here, but general examples are fine.

Answer [by MSalters]: Thread vs ThreadPool

Thread local storage is not a good idea…

How to: Using ThreadPool.QueueUserWorkItem in ASP.NET in a high traffic scenario

Using ThreadPool.QueueUserWorkItem in ASP.NET in a high traffic scenario

I’ve always been under the impression that using the ThreadPool for (let’s say non-critical) short-lived background tasks was considered best practice, even in ASP.NET, but then I came across this articlethat seems to suggest otherwise – the argument being that you should leave the ThreadPool to deal with ASP.NET related…

How to: When to use thread pool in C#?

When to use thread pool in C#?

I have been trying to learn multi-threaded programming in C# and I am confused about when it is best to use a thread pool vs. create my own threads. One book recommends using a thread pool for small tasks only (whatever that means), but I can’t seem to find any real guidelines. What are some considerations you use when making this programming decision?

Answer: When…

How to: How many threads is too many?

How many threads is too many?

I am writing a server, and I branch each action of into a thread when the request is incoming. I do this because almost every request makes database query. I am using a threadpool library to cut down on construction/destruction of threads.

My question is though – what is a good cutoff point for I/O threads like these? I know it would just be a rough estimate, but…

How about a rock-solid thread pool in less than 30 lines? Python threading FTW!

BackgroundWorker is a helper class in theSystem.ComponentModel namespace for managing a worker thread. It can be considered a general-purpose implementation of the EAP, and provides the following features:

A cooperative cancellation model

The ability to safely update WPF or Windows Forms controlswhen the worker completes

Forwarding of exceptions to the completion event

A protocol for reporting progress

An implementation of IComponent allowing it to be sited in Visual Studio’s designer

BackgroundWorker uses the thread pool, which means you should never call Abort on a BackgroundWorker thread.

Using BackgroundWorker

Here are the minimum steps in using BackgroundWorker:

Instantiate BackgroundWorker and handle the DoWork event.

Call RunWorkerAsync, optionally with an object argument.

This then sets it in motion. Any argument passed toRunWorkerAsync will be forwarded to DoWork’s event handler, via the event argument’s Argument property. Here’s an example:

class Program {   static BackgroundWorker _bw = new BackgroundWorker();   static void Main()   {     _bw.DoWork += bw_DoWork;     _bw.RunWorkerAsync ("Message to worker");     Console.ReadLine();   }   static void bw_DoWork (object sender, DoWorkEventArgs e)   {     // This is called on the worker thread     Console.WriteLine (e.Argument);        // writes "Message to worker"     // Perform time-consuming task...   } }

BackgroundWorker has a RunWorkerCompleted event that fires after the DoWork event handler has done its job. Handling RunWorkerCompleted is not mandatory, but you usually do so in order to query any exception that was thrown in DoWork. Further, code within a RunWorkerCompleted event handler is able to update user interface controls without explicit marshaling; code within the DoWork event handler cannot.

To add support for progress reporting:

Set the WorkerReportsProgress property to true.

Periodically call ReportProgress from within the DoWork event handler with a “percentage complete” value, and optionally, a user-state object.

Handle the ProgressChanged event, querying its event argument’s ProgressPercentage property.

Code in the ProgressChanged event handler is free to interact with UI controls just as withRunWorkerCompleted. This is typically where you will update a progress bar.

To add support for cancellation:

Set the WorkerSupportsCancellation property to true.

Periodically check the CancellationPending property from within the DoWork event handler. If it’s true, set the event argument’s Cancel property to true, and return. (The worker can also set Cancel and exit withoutCancellationPending being true if it decides that the job is too difficult and it can’t go on.)

Call CancelAsync to request cancellation.

Here’s an example that implements all the preceding features:

using System; using System.Threading; using System.ComponentModel; class Program {   static BackgroundWorker _bw;   static void Main()   {     _bw = new BackgroundWorker     {       WorkerReportsProgress = true,       WorkerSupportsCancellation = true     };     _bw.DoWork += bw_DoWork;     _bw.ProgressChanged += bw_ProgressChanged;     _bw.RunWorkerCompleted += bw_RunWorkerCompleted;     _bw.RunWorkerAsync ("Hello to worker");     Console.WriteLine ("Press Enter in the next 5 seconds to cancel");     Console.ReadLine();     if (_bw.IsBusy) _bw.CancelAsync();     Console.ReadLine();   }   static void bw_DoWork (object sender, DoWorkEventArgs e)   {     for (int i = 0; i <= 100; i += 20)     {       if (_bw.CancellationPending) { e.Cancel = true; return; }       _bw.ReportProgress (i);       Thread.Sleep (1000);      // Just for the demo... don't go sleeping     }                           // for real in pooled threads!     e.Result = 123;    // This gets passed to RunWorkerCompleted   }   static void bw_RunWorkerCompleted (object sender,                                      RunWorkerCompletedEventArgs e)   {     if (e.Cancelled)       Console.WriteLine ("You canceled!");     else if (e.Error != null)       Console.WriteLine ("Worker exception: " + e.Error.ToString());     else       Console.WriteLine ("Complete: " + e.Result);      // from DoWork   }   static void bw_ProgressChanged (object sender,                                   ProgressChangedEventArgs e)   {     Console.WriteLine ("Reached " + e.ProgressPercentage + "%");   } }

Press Enter in the next 5 seconds to cancel Reached 0% Reached 20% Reached 40% Reached 60% Reached 80% Reached 100% Complete: 123 Press Enter in the next 5 seconds to cancel Reached 0% Reached 20% Reached 40% You canceled!

Subclassing BackgroundWorker

BackgroundWorker is not sealed and provides a virtual OnDoWork method, suggesting another pattern for its use. In writing a potentially long-running method, you could write an additional version returning a subclassedBackgroundWorker, preconfigured to perform the job concurrently. The consumer then needs to handle only theRunWorkerCompleted and ProgressChanged events. For instance, suppose we wrote a time-consuming method called GetFinancialTotals:

public class Client {   Dictionary <string,int> GetFinancialTotals (int foo, int bar) { ... }   ... }

We could refactor it as follows:

public class Client {   public FinancialWorker GetFinancialTotalsBackground (int foo, int bar)   {     return new FinancialWorker (foo, bar);   } } public class FinancialWorker : BackgroundWorker {   public Dictionary <string,int> Result;   // You can add typed fields.   public readonly int Foo, Bar;   public FinancialWorker()   {     WorkerReportsProgress = true;     WorkerSupportsCancellation = true;   }   public FinancialWorker (int foo, int bar) : this()   {     this.Foo = foo; this.Bar = bar;   }   protected override void OnDoWork (DoWorkEventArgs e)   {     ReportProgress (0, "Working hard on this report...");     // Initialize financial report data     // ...     while (!<finished report>)     {       if (CancellationPending) { e.Cancel = true; return; }       // Perform another calculation step ...       // ...       ReportProgress (percentCompleteCalc, "Getting there...");     }     ReportProgress (100, "Done!");     e.Result = Result = <completed report data>;   } }

Whoever calls GetFinancialTotalsBackground then gets a FinancialWorker: a wrapper to manage the background operation with real-world usability. It can report progress, can be canceled, is friendly with WPF and Windows Forms applications, and handles exceptions well.

BackgroundWorker and ProgressBar demo

ThreadPool - Asynchronous delegates

ThreadPool.QueueUserWorkItem doesn’t provide an easy mechanism for getting return values back from a thread after it has finished executing. Asynchronous delegate invocations (asynchronous delegates for short) solve this, allowing any number of typed arguments to be passed in both directions. Furthermore, unhandled exceptions on asynchronous delegates are conveniently rethrown on the original thread (or more accurately, the thread that callsEndInvoke), and so they don’t need explicit handling.

Here’s how you start a worker task via an asynchronous delegate:

Instantiate a delegate targeting the method you want to run in parallel (typically one of the predefined Funcdelegates).

Call BeginInvoke on the delegate, saving its IAsyncResult return value. BeginInvoke returns immediately to the caller. You can then perform other activities while the pooled thread is working.

When you need the results, call EndInvoke on the delegate, passing in the saved IAsyncResult object.

In the following example, we use an asynchronous delegate invocation to execute concurrently with the main thread, a simple method that returns a string’s length:

static void Main() {   Func method = Work;   IAsyncResult cookie = method.BeginInvoke ("test", null, null);   //   // ... here's where we can do other work in parallel...   //   int result = method.EndInvoke (cookie);   Console.WriteLine ("String length is: " + result); } static int Work (string s) { return s.Length; }