M B A R K's Blog
What is SynchronizationContext in C#?

What is SynchronizationContext in C#?

M B A R K's photo
M B A R K
·

4 min read

Table of contents

In C#, a SynchronizationContext is a way to represent and manage the execution context of a thread. It is used to enforce thread-safety in multithreaded programs, by ensuring that certain code is executed on the correct thread.

Here are some key points about SynchronizationContext:

  • It is an abstract class defined in the System.Threading namespace.

  • It provides a way to post work items to a thread, and to send and receive messages across threads.

  • It has a Send method, which blocks the calling thread until the work is complete, and a Post method, which does not block the calling thread.

  • It can be used to synchronize access to shared resources, by ensuring that only one thread is executing a particular piece of code at a time.

Examples of using SynchronizationContext

Here are some examples of how SynchronizationContext can be used in C#:

Example 1: Using SynchronizationContext to update the UI from a background thread

In a GUI application, it is often necessary to perform long-running tasks on a background thread, to avoid freezing the UI. However, when the background thread needs to update the UI, it must do so on the UI thread.

Here is an example of how to use SynchronizationContext to update the UI from a background thread:

// Create a SynchronizationContext for the UI thread
SynchronizationContext uiContext = SynchronizationContext.Current;

// Start a background thread
new Thread(() =>
{
    // Do some long-running work
    Thread.Sleep(1000);

    // Update the UI on the UI thread
    uiContext.Post(_ =>
    {
        // Update the UI here
        label.Text = "Background thread finished";
    }, null);
}).Start();

In this example, the uiContext variable is created on the UI thread and holds a reference to the SynchronizationContext for that thread. The background thread can then use the Post method of uiContext to execute a delegate on the UI thread.

Example 2: Using SynchronizationContext to synchronize access to a shared resource

In a multithreaded program, it is often necessary to synchronize access to shared resources, to ensure that only one thread is accessing the resource at a time.

Here is an example of how to use SynchronizationContext to synchronize access to a shared resource:

// Create a SynchronizationContext for the current thread
SynchronizationContext context = SynchronizationContext.Current;

// Create a shared resource
int sharedResource = 0;

// Start two background threads
new Thread(() =>
{
    // Acquire the lock
    context.Send(_ =>
    {
        // Access the shared resource here
        sharedResource++;
    }, null);
}).Start();
new Thread(() =>
{
    // Acquire the lock
    context.Send(_ =>
    {
        // Access the shared resource here
        sharedResource++;
    }, null);
}).Start();

Example 2: Multithreaded server application

One real-world example of using SynchronizationContext is in a multithreaded server application. Suppose the server receives requests from clients and processes them on separate threads to improve performance. However, the server also needs to access a shared database, which can only be accessed by one thread at a time.

In this case, the server could use SynchronizationContext to synchronize access to the database. Each thread that needs to access the database could acquire a lock using the Send method of the SynchronizationContext, execute its database queries, and then release the lock. This would ensure that only one thread is accessing the database at a time, preventing race conditions and other issues that could cause data corruption or other problems.

Here is some example code showing how this could be implemented:

// Create a SynchronizationContext for the server thread
SynchronizationContext context = SynchronizationContext.Current;

// Start a new thread to process a client request
new Thread(() =>
{
    // Acquire the lock
    context.Send(_ =>
    {
        // Access the database here
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();
            // Execute database queries...
        }
    }, null);
}).Start();

In this example, the context variable holds a reference to the SynchronizationContext for the server thread. Each thread that needs to access the database acquires the lock using the Send method of context, performs its database queries, and then releases the lock. This ensures that only one thread can access the database at a time, preventing race conditions and other threading issues.

In this example, the context variable holds a reference to the SynchronizationContext for the current thread. Each background thread uses the Send method of context to acquire a lock and execute a delegate, which accesses the shared resource. This ensures that only one thread can access the shared resource at a time, preventing race conditions and other threading issues.

Conclusion

In summary, SynchronizationContext is a powerful tool for managing and synchronizing the execution of threads in C#. It provides a way to post work items to a thread, and to send and receive messages across threads, making it useful for tasks such as updating the UI from a background thread or synchronizing access to shared resources. By understanding and effectively using SynchronizationContext, developers can write robust and thread-safe multithreaded programs.

C#multithreading