Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion AI Tools Integration
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

interview

Home Interviews What is the ThreadLocal class in C#, and when is it useful? – MindStick
Ask Question

1 Answers

ICSM Computer
ICSM Computer 06 Mar 2025
Report Abuse

ThreadLocal<T> in C#

The ThreadLocal<T> class in C# provides thread-local storage, meaning that each thread accessing a ThreadLocal<T> instance will have its own separate copy of the data. This ensures that the data is not shared between threads, preventing race conditions and unintended data modifications.

It is part of the System.Threading namespace and is available in .NET Framework 4.0 and later.

Syntax

ThreadLocal<T> variable = new ThreadLocal<T>(() => new T());

The ThreadLocal<T> constructor takes a factory function (Func<T>) that initializes the value for each thread.

Use Cases

  1. Thread-Specific Caching: Storing data that should be isolated per thread, like per-thread logging or temporary calculations.
  2. Avoiding Locking: Since each thread gets its own copy of the object, there's no need for synchronization mechanisms like locks.
  3. Thread-Specific Context: Useful in scenarios like transaction management or tracking request-specific data in web applications.
using System;
using System.Threading;

class Program
{
    // ThreadLocal storage for each thread
    private static ThreadLocal<int> _threadLocalValue = new ThreadLocal<int>(() => Thread.CurrentThread.ManagedThreadId);

    static void Main()
    {
        Thread thread1 = new Thread(PrintThreadLocalValue);
        Thread thread2 = new Thread(PrintThreadLocalValue);

        thread1.Start();
        thread2.Start();
        thread1.Join();
        thread2.Join();

        // Main thread also has its own value
        Console.WriteLine($"Main thread value: {_threadLocalValue.Value}");
    }

    static void PrintThreadLocalValue()
    {
        Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} - Value: {_threadLocalValue.Value}");
    }
}

Output (example)

Thread 3 - Value: 3
Thread 4 - Value: 4
Main thread value: 1

Each thread gets a separate value, preventing unintended interference between threads.

Things to Consider

  1. Proper Disposal: ThreadLocal<T> should be disposed to free thread-specific resources.
    _threadLocalValue.Dispose();
     
  2. Potential Memory Issues: If a thread-local variable references a large object, it might lead to high memory usage because each thread keeps its own instance.
  3. Alternative Approaches: If thread-specific storage isn't necessary, consider using AsyncLocal<T> for async operations or ConcurrentDictionary<Thread, T> for manual management.
advertising
Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md