Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHESPTRUFRDEEN

Elysia Tools

Navigation

C#

Windows Multithreading - C# Samples

Comprehensive C# multithreading examples for Windows platform including thread creation, synchronization, thread pools, and concurrent programming patterns

Samples

Entries inside this sample collection

CodecsharpSimple

Thread Creation and Management

Creating, starting, and managing threads in C# for parallel execution

Difficulty

3/10

Estimated time

20 min

Tags

csharp, threading, concurrency, parallel, windows

Prerequisites

Basic C# syntax, Understanding of concurrent programming

csharp
using System;
using System.Threading;
using System.Threading.Tasks;

class ThreadCreation
{
    // 1. Simple thread creation
    public static void CreateSimpleThread()
    {
        Console.WriteLine("=== Simple Thread Creation ===");

        Thread workerThread = new Thread(new ThreadStart(SimpleWorkerMethod));

        Console.WriteLine("Starting worker thread...");
        workerThread.Start();

        // Main thread continues working
        for (int i = 1; i <= 3; i++)
        {
            Console.WriteLine($"Main thread working: {i}");
            Thread.Sleep(500);
        }

        // Wait for worker thread to complete
        workerThread.Join();
        Console.WriteLine("Worker thread completed. Main thread finished.");
    }

    // Worker method for simple thread
    static void SimpleWorkerMethod()
    {
        for (int i = 1; i <= 5; i++)
        {
            Console.WriteLine($"Worker thread working: {i}");
            Thread.Sleep(300);
        }
    }

    // 2. Thread with parameters
    public static void CreateThreadWithParameters()
    {
        Console.WriteLine("\n=== Thread with Parameters ===");

        string message = "Hello from parameterized thread!";
        int iterations = 3;

        // Create thread with parameterized method
        Thread paramThread = new Thread(new ParameterizedThreadStart(ParameterizedWorkerMethod));

        Console.WriteLine("Starting parameterized thread...");
        paramThread.Start(new { Message = message, Iterations = iterations });

        // Wait for completion
        paramThread.Join();
        Console.WriteLine("Parameterized thread completed.");
    }

    // Worker method that accepts parameters
    static void ParameterizedWorkerMethod(object data)
    {
        dynamic parameters = data;
        string message = parameters.Message;
        int iterations = parameters.Iterations;

        for (int i = 1; i <= iterations; i++)
        {
            Console.WriteLine($"{message} (Iteration {i})");
            Thread.Sleep(600);
        }
    }

    // 3. Multiple threads with different priorities
    public static void ThreadsWithPriorities()
    {
        Console.WriteLine("\n=== Threads with Different Priorities ===");

        Thread highPriorityThread = new Thread(() => WorkerByPriority("High", 3));
        Thread normalPriorityThread = new Thread(() => WorkerByPriority("Normal", 3));
        Thread lowPriorityThread = new Thread(() => WorkerByPriority("Low", 3));

        // Set thread priorities
        highPriorityThread.Priority = ThreadPriority.Highest;
        normalPriorityThread.Priority = ThreadPriority.Normal;
        lowPriorityThread.Priority = ThreadPriority.Lowest;

        Console.WriteLine("Starting threads with different priorities...");

        highPriorityThread.Start();
        normalPriorityThread.Start();
        lowPriorityThread.Start();

        // Wait for all threads
        highPriorityThread.Join();
        normalPriorityThread.Join();
        lowPriorityThread.Join();

        Console.WriteLine("All priority threads completed.");
    }

    // Worker method that shows thread priority
    static void WorkerByPriority(string priorityName, int iterations)
    {
        Thread.CurrentThread.Name = $"{priorityName} Priority Thread";
        Console.WriteLine($"{Thread.CurrentThread.Name} started with priority: {Thread.CurrentThread.Priority}");

        for (int i = 1; i <= iterations; i++)
        {
            Console.WriteLine($"{priorityName} priority - Work {i}");
            Thread.Sleep(200);
        }

        Console.WriteLine($"{priorityName} priority thread finished.");
    }

    // 4. Thread with return value (using Task)
    public static void ThreadWithReturnValue()
    {
        Console.WriteLine("\n=== Thread with Return Value (Task) ===");

        // Create and start a task that returns a value
        Task<int> calculationTask = Task.Run(() => CalculateSomething(100));

        Console.WriteLine("Main thread continues working while task runs...");

        // Do some other work
        for (int i = 1; i <= 3; i++)
        {
            Console.WriteLine($"Main thread work {i}");
            Thread.Sleep(300);
        }

        // Get the result (this will wait if task isn't completed)
        int result = calculationTask.Result;
        Console.WriteLine($"Calculation result: {result}");
    }

    // Method that performs calculation and returns result
    static int CalculateSomething(int n)
    {
        Console.WriteLine("Calculation task started...");

        int sum = 0;
        for (int i = 1; i <= n; i++)
        {
            sum += i;
            if (i % 10 == 0)
            {
                Console.WriteLine($"Calculation progress: {i}/{n}");
                Thread.Sleep(50);
            }
        }

        Console.WriteLine("Calculation task completed.");
        return sum;
    }

    // 5. Thread background vs foreground
    public static void BackgroundVsForegroundThreads()
    {
        Console.WriteLine("\n=== Background vs Foreground Threads ===");

        // Create a background thread
        Thread backgroundThread = new Thread(() =>
        {
            Thread.CurrentThread.Name = "Background Thread";
            Console.WriteLine($"{Thread.CurrentThread.Name} started");
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine($"{Thread.CurrentThread.Name} working: {i}");
                Thread.Sleep(1000);
            }
            Console.WriteLine($"{Thread.CurrentThread.Name} completed");
        });

        backgroundThread.IsBackground = true;

        Console.WriteLine("Starting background thread...");
        backgroundThread.Start();

        // Create a foreground thread
        Thread foregroundThread = new Thread(() =>
        {
            Thread.CurrentThread.Name = "Foreground Thread";
            Console.WriteLine($"{Thread.CurrentThread.Name} started");
            for (int i = 1; i <= 3; i++)
            {
                Console.WriteLine($"{Thread.CurrentThread.Name} working: {i}");
                Thread.Sleep(1500);
            }
            Console.WriteLine($"{Thread.CurrentThread.Name} completed");
        });

        Console.WriteLine("Starting foreground thread...");
        foregroundThread.Start();

        // Wait for foreground thread (background thread will be terminated when app exits)
        foregroundThread.Join();

        Console.WriteLine("Foreground thread completed. Application will exit now.");
        Console.WriteLine("(Background thread would be terminated if this were a real application)");
    }

    // 6. Thread abort and cancellation
    public static void ThreadCancellation()
    {
        Console.WriteLine("\n=== Thread Cancellation ===");

        // Create a cancellation token source
        CancellationTokenSource cts = new CancellationTokenSource();

        // Create a long-running task that can be cancelled
        Task<int> runningTask = Task.Run(() =>
            LongRunningMethod(cts.Token), cts.Token);

        // Let the task run for a bit
        Thread.Sleep(3000);

        Console.WriteLine("Requesting cancellation...");
        cts.Cancel();

        try
        {
            // Wait for task to complete or cancel
            runningTask.Wait();
            Console.WriteLine($"Task completed with result: {runningTask.Result}");
        }
        catch (AggregateException ex)
        {
            if (ex.InnerExceptions[0] is OperationCanceledException)
            {
                Console.WriteLine("Task was successfully cancelled.");
            }
            else
            {
                Console.WriteLine($"Task failed: {ex.InnerExceptions[0].Message}");
            }
        }
    }

    // Long-running method that supports cancellation
    static int LongRunningMethod(CancellationToken cancellationToken)
    {
        Console.WriteLine("Long-running task started...");

        for (int i = 1; i <= 100; i++)
        {
            // Check for cancellation
            if (cancellationToken.IsCancellationRequested)
            {
                Console.WriteLine($"Cancellation requested at iteration {i}");
                cancellationToken.ThrowIfCancellationRequested();
            }

            Console.WriteLine($"Working... {i}%");
            Thread.Sleep(100);
        }

        Console.WriteLine("Long-running task completed successfully.");
        return 42; // Return some result
    }

    // 7. Thread safe data sharing
    public static void ThreadSafeDataSharing()
    {
        Console.WriteLine("\n=== Thread-Safe Data Sharing ===");

        // Shared counter with lock
        object lockObject = new object();
        int sharedCounter = 0;

        // Create multiple threads that modify shared data
        Thread[] threads = new Thread[5];

        for (int i = 0; i < threads.Length; i++)
        {
            threads[i] = new Thread((threadId) =>
            {
                int threadNum = (int)threadId;
                Thread.CurrentThread.Name = $"Worker {threadNum}";

                for (int j = 1; j <= 1000; j++)
                {
                    lock (lockObject)
                    {
                        int temp = sharedCounter;
                        // Simulate some processing
                        Thread.Sleep(1);
                        sharedCounter = temp + 1;

                        if (j % 200 == 0)
                        {
                            Console.WriteLine($"{Thread.CurrentThread.Name}: Shared counter = {sharedCounter}");
                        }
                    }
                }

                Console.WriteLine($"{Thread.CurrentThread.Name} completed.");
            });
        }

        // Start all threads
        for (int i = 0; i < threads.Length; i++)
        {
            threads[i].Start(i);
        }

        // Wait for all threads to complete
        foreach (Thread thread in threads)
        {
            thread.Join();
        }

        Console.WriteLine($"Final shared counter value: {sharedCounter}");
    }

    // 8. Thread with exception handling
    public static void ThreadExceptionHandling()
    {
        Console.WriteLine("\n=== Thread Exception Handling ===");

        Thread threadWithException = new Thread(() =>
        {
            try
            {
                Console.WriteLine("Thread starting work...");

                // Simulate work
                for (int i = 1; i <= 3; i++)
                {
                    Console.WriteLine($"Thread working: {i}");
                    Thread.Sleep(500);
                }

                // Throw an exception
                throw new InvalidOperationException("Something went wrong in the thread!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Thread caught exception: {ex.Message}");
                // Handle the exception
                Thread.CurrentThread.Abort();
            }
        });

        threadWithException.Start();
        threadWithException.Join();

        Console.WriteLine("Thread execution completed with exception handling.");
    }

    // 9. Thread pool usage
    public static void ThreadPoolUsage()
    {
        Console.WriteLine("\n=== Thread Pool Usage ===");

        Console.WriteLine($"Available worker threads: {ThreadPool.ThreadCount}");
        Console.WriteLine($"Available completion port threads: {ThreadPool.CompletedWorkItemCount}");

        // Queue work items to thread pool
        for (int i = 1; i <= 5; i++)
        {
            int workItem = i;
            ThreadPool.QueueUserWorkItem(state =>
            {
                Thread.CurrentThread.Name = $"ThreadPool Worker {workItem}";
                Console.WriteLine($"{Thread.CurrentThread.Name} processing item {workItem}");

                // Simulate work
                Thread.Sleep(1000);

                Console.WriteLine($"{Thread.CurrentThread.Name} completed item {workItem}");
            });
        }

        // Wait for thread pool work to complete
        Thread.Sleep(6000);
        Console.WriteLine("All thread pool work items completed.");
    }

    // 10. Thread naming and identification
    public static void ThreadIdentification()
    {
        Console.WriteLine("\n=== Thread Identification ===");

        Console.WriteLine($"Main thread ID: {Thread.CurrentThread.ManagedThreadId}");
        Console.WriteLine($"Main thread name: {Thread.CurrentThread.Name}");
        Console.WriteLine($"Main thread is background: {Thread.CurrentThread.IsBackground}");
        Console.WriteLine($"Main thread is alive: {Thread.CurrentThread.IsAlive}");
        Console.WriteLine($"Main thread state: {Thread.CurrentThread.ThreadState}");

        Thread[] threads = new Thread[3];

        for (int i = 0; i < threads.Length; i++)
        {
            int threadIndex = i;
            threads[i] = new Thread(() =>
            {
                Thread.CurrentThread.Name = $"Named Thread {threadIndex + 1}";

                Console.WriteLine($"Thread {Thread.CurrentThread.Name} - ID: {Thread.CurrentThread.ManagedThreadId}");
                Console.WriteLine($"Thread {Thread.CurrentThread.Name} - Is Background: {Thread.CurrentThread.IsBackground}");
                Console.WriteLine($"Thread {Thread.CurrentThread.Name} - State: {Thread.CurrentThread.ThreadState}");

                // Simulate work
                Thread.Sleep(1000);

                Console.WriteLine($"Thread {Thread.CurrentThread.Name} - Finished");
            });
        }

        // Start all threads
        foreach (Thread thread in threads)
        {
            thread.Start();
        }

        // Wait for completion
        foreach (Thread thread in threads)
        {
            thread.Join();
        }
    }

    static void Main(string[] args)
    {
        Console.WriteLine("=== C# Thread Creation Demo ===\n");

        try
        {
            CreateSimpleThread();
            CreateThreadWithParameters();
            ThreadsWithPriorities();
            ThreadWithReturnValue();
            BackgroundVsForegroundThreads();
            ThreadCancellation();
            ThreadSafeDataSharing();
            ThreadExceptionHandling();
            ThreadPoolUsage();
            ThreadIdentification();

            Console.WriteLine("\nAll thread creation examples completed successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in thread demo: {ex.Message}");
        }
    }
}
CodecsharpIntermediate

Thread Synchronization and Locks

Thread synchronization techniques using locks, mutexes, semaphores, and other synchronization primitives

Difficulty

6/10

Estimated time

30 min

Tags

csharp, synchronization, threading, concurrency, windows

Prerequisites

C# threading basics, Understanding of race conditions

csharp
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Concurrent;

class ThreadSynchronization
{
    // 1. Simple lock usage
    private static readonly object simpleLock = new object();
    private static int sharedCounter = 0;

    public static void SimpleLockDemo()
    {
        Console.WriteLine("=== Simple Lock Demo ===");
        sharedCounter = 0;

        Thread[] threads = new Thread[10];

        for (int i = 0; i < threads.Length; i++)
        {
            threads[i] = new Thread(() =>
            {
                for (int j = 0; j < 1000; j++)
                {
                    lock (simpleLock)
                    {
                        int temp = sharedCounter;
                        Thread.Sleep(1); // Simulate work
                        sharedCounter = temp + 1;
                    }
                }
            });
        }

        // Start all threads
        foreach (Thread thread in threads)
        {
            thread.Start();
        }

        // Wait for completion
        foreach (Thread thread in threads)
        {
            thread.Join();
        }

        Console.WriteLine($"Final counter value: {sharedCounter} (Expected: 10000)");
        Console.WriteLine($"Lock was {(sharedCounter == 10000 ? "successful" : "unsuccessful")} in preventing race conditions");
    }

    // 2. Monitor.Enter/Exit with try/finally
    private static readonly object monitorLock = new object();
    private static bool criticalResourceAvailable = true;

    public static void MonitorDemo()
    {
        Console.WriteLine("\n=== Monitor.Enter/Exit Demo ===");

        Thread[] threads = new Thread[5];

        for (int i = 0; i < threads.Length; i++)
        {
            int threadId = i;
            threads[i] = new Thread(() =>
            {
                Thread.CurrentThread.Name = $"Monitor Worker {threadId}";
                UseCriticalResource();
            });
        }

        // Start threads with small delay
        foreach (Thread thread in threads)
        {
            thread.Start();
            Thread.Sleep(100);
        }

        // Wait for completion
        foreach (Thread thread in threads)
        {
            thread.Join();
        }

        Console.WriteLine("All Monitor operations completed.");
    }

    static void UseCriticalResource()
    {
        bool lockTaken = false;

        try
        {
            Monitor.Enter(monitorLock, ref lockTaken);

            if (!criticalResourceAvailable)
            {
                Console.WriteLine($"{Thread.CurrentThread.Name}: Resource not available, waiting...");
                Monitor.Wait(monitorLock); // Release lock and wait
            }

            Console.WriteLine($"{Thread.CurrentThread.Name}: Acquired critical resource");

            // Simulate critical section work
            Thread.Sleep(2000);

            Console.WriteLine($"{Thread.CurrentThread.Name}: Releasing critical resource");
        }
        finally
        {
            if (lockTaken)
            {
                Monitor.Exit(monitorLock);
            }
        }
    }

    // 3. Mutex for inter-process synchronization
    private static Mutex mutex = null;

    public static void MutexDemo()
    {
        Console.WriteLine("\n=== Mutex Demo ===");

        // Create or open a named mutex
        bool isNewMutex;
        mutex = new Mutex(false, "MyApplicationMutex", out isNewMutex);

        Console.WriteLine($"Mutex created: {isNewMutex}");

        Thread[] threads = new Thread[3];

        for (int i = 0; i < threads.Length; i++)
        {
            int threadId = i;
            threads[i] = new Thread(() =>
            {
                Thread.CurrentThread.Name = $"Mutex Thread {threadId}";
                UseMutexResource();
            });
        }

        // Start threads
        foreach (Thread thread in threads)
        {
            thread.Start();
        }

        // Wait for completion
        foreach (Thread thread in threads)
        {
            thread.Join();
        }

        mutex.ReleaseMutex();
        mutex.Dispose();

        Console.WriteLine("Mutex demo completed.");
    }

    static void UseMutexResource()
    {
        try
        {
            Console.WriteLine($"{Thread.CurrentThread.Name}: Waiting for mutex...");

            // Wait for mutex with timeout
            if (mutex.WaitOne(5000))
            {
                try
                {
                    Console.WriteLine($"{Thread.CurrentThread.Name}: Acquired mutex, using shared resource");

                    // Simulate work with shared resource
                    Thread.Sleep(3000);

                    Console.WriteLine($"{Thread.CurrentThread.Name}: Completed work with shared resource");
                }
                finally
                {
                    mutex.ReleaseMutex();
                    Console.WriteLine($"{Thread.CurrentThread.Name}: Released mutex");
                }
            }
            else
            {
                Console.WriteLine($"{Thread.CurrentThread.Name}: Timeout waiting for mutex");
            }
        }
        catch (AbandonedMutexException)
        {
            Console.WriteLine($"{Thread.CurrentThread.Name}: Acquired abandoned mutex");
            mutex.ReleaseMutex();
        }
    }

    // 4. Semaphore for limiting concurrent access
    private static SemaphoreSlim semaphore = new SemaphoreSlim(2, 2); // Allow 2 concurrent threads

    public static void SemaphoreDemo()
    {
        Console.WriteLine("\n=== Semaphore Demo ===");
        Console.WriteLine("Semaphore allows maximum 2 concurrent threads");

        Thread[] threads = new Thread[6];

        for (int i = 0; i < threads.Length; i++)
        {
            int threadId = i;
            threads[i] = new Thread(() =>
            {
                Thread.CurrentThread.Name = $"Semaphore Thread {threadId}";
                AccessLimitedResource();
            });
        }

        // Start all threads
        foreach (Thread thread in threads)
        {
            thread.Start();
            Thread.Sleep(200); // Stagger starts
        }

        // Wait for completion
        foreach (Thread thread in threads)
        {
            thread.Join();
        }

        semaphore.Dispose();
        Console.WriteLine("Semaphore demo completed.");
    }

    static void AccessLimitedResource()
    {
        try
        {
            Console.WriteLine($"{Thread.CurrentThread.Name}: Waiting to access limited resource...");

            // Wait for semaphore
            semaphore.Wait();

            try
            {
                Console.WriteLine($"{Thread.CurrentThread.Name}: Acquired semaphore, accessing resource");
                Console.WriteLine($"Current semaphore count: {semaphore.CurrentCount}");

                // Simulate resource usage
                Thread.Sleep(2000);

                Console.WriteLine($"{Thread.CurrentThread.Name}: Finished using resource");
            }
            finally
            {
                semaphore.Release();
                Console.WriteLine($"{Thread.CurrentThread.Name}: Released semaphore");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"{Thread.CurrentThread.Name}: Error - {ex.Message}");
        }
    }

    // 5. ReaderWriterLockSlim for read-heavy scenarios
    private static ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();
    private static string sharedData = "Initial Data";

    public static void ReaderWriterLockDemo()
    {
        Console.WriteLine("\n=== ReaderWriterLock Demo ===");

        Thread[] threads = new Thread[8];

        // Create 6 reader threads and 2 writer threads
        for (int i = 0; i < threads.Length; i++)
        {
            int threadId = i;
            bool isReader = i < 6;

            threads[i] = new Thread(() =>
            {
                Thread.CurrentThread.Name = isReader ? $"Reader {threadId}" : $"Writer {threadId}";

                if (isReader)
                {
                    ReadData();
                }
                else
                {
                    WriteData($"Updated Data at {DateTime.Now:HH:mm:ss}");
                }
            });
        }

        // Start threads
        foreach (Thread thread in threads)
        {
            thread.Start();
            Thread.Sleep(100);
        }

        // Wait for completion
        foreach (Thread thread in threads)
        {
            thread.Join();
        }

        rwLock.Dispose();
        Console.WriteLine("ReaderWriterLock demo completed.");
    }

    static void ReadData()
    {
        try
        {
            Console.WriteLine($"{Thread.CurrentThread.Name}: Waiting to read...");
            rwLock.EnterReadLock();

            try
            {
                Console.WriteLine($"{Thread.CurrentThread.Name}: Reading data: '{sharedData}'");
                Thread.Sleep(1000); // Simulate read operation
                Console.WriteLine($"{Thread.CurrentThread.Name}: Completed reading");
            }
            finally
            {
                rwLock.ExitReadLock();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"{Thread.CurrentThread.Name}: Read error - {ex.Message}");
        }
    }

    static void WriteData(string newData)
    {
        try
        {
            Console.WriteLine($"{Thread.CurrentThread.Name}: Waiting to write...");
            rwLock.EnterWriteLock();

            try
            {
                Console.WriteLine($"{Thread.CurrentThread.Name}: Writing data...");
                sharedData = newData;
                Thread.Sleep(2000); // Simulate write operation
                Console.WriteLine($"{Thread.CurrentThread.Name}: Completed writing");
            }
            finally
            {
                rwLock.ExitWriteLock();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"{Thread.CurrentThread.Name}: Write error - {ex.Message}");
        }
    }

    // 6. Barrier for thread synchronization points
    public static void BarrierDemo()
    {
        Console.WriteLine("\n=== Barrier Demo ===");

        // Barrier that requires 4 threads to continue
        Barrier barrier = new Barrier(4, b =>
        {
            Console.WriteLine($"Phase {b.CurrentPhaseNumber} completed. All threads have reached the barrier.");
        });

        Thread[] threads = new Thread[4];

        for (int i = 0; i < threads.Length; i++)
        {
            int threadId = i;
            threads[i] = new Thread(() =>
            {
                Thread.CurrentThread.Name = $"Barrier Thread {threadId}";
                WorkWithBarrier(barrier);
            });
        }

        // Start threads
        foreach (Thread thread in threads)
        {
            thread.Start();
        }

        // Wait for completion
        foreach (Thread thread in threads)
        {
            thread.Join();
        }

        barrier.Dispose();
        Console.WriteLine("Barrier demo completed.");
    }

    static void WorkWithBarrier(Barrier barrier)
    {
        try
        {
            // Phase 1: Initial work
            Console.WriteLine($"{Thread.CurrentThread.Name}: Starting phase 1 work");
            Thread.Sleep(new Random().Next(1000, 3000));
            Console.WriteLine($"{Thread.CurrentThread.Name}: Completed phase 1, waiting at barrier");

            barrier.SignalAndWait();

            // Phase 2: Second phase work
            Console.WriteLine($"{Thread.CurrentThread.Name}: Starting phase 2 work");
            Thread.Sleep(new Random().Next(1000, 3000));
            Console.WriteLine($"{Thread.CurrentThread.Name}: Completed phase 2, waiting at barrier");

            barrier.SignalAndWait();

            // Final phase
            Console.WriteLine($"{Thread.CurrentThread.Name}: Starting final phase work");
            Thread.Sleep(new Random().Next(500, 1500));
            Console.WriteLine($"{Thread.CurrentThread.Name}: Completed all work");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"{Thread.CurrentThread.Name}: Error - {ex.Message}");
        }
    }

    // 7. CountdownEvent for coordinating multiple threads
    public static void CountdownEventDemo()
    {
        Console.WriteLine("\n=== CountdownEvent Demo ===");

        // CountdownEvent that waits for 5 signals
        CountdownEvent countdown = new CountdownEvent(5);

        // Thread that waits for countdown
        Thread coordinatorThread = new Thread(() =>
        {
            Thread.CurrentThread.Name = "Coordinator";
            Console.WriteLine($"{Thread.CurrentThread.Name}: Waiting for all worker threads to signal completion...");

            countdown.Wait();

            Console.WriteLine($"{Thread.CurrentThread.Name}: All workers completed! Proceeding with coordination task.");
        });

        coordinatorThread.Start();

        // Create worker threads
        Thread[] workerThreads = new Thread[5];

        for (int i = 0; i < workerThreads.Length; i++)
        {
            int threadId = i;
            workerThreads[i] = new Thread(() =>
            {
                Thread.CurrentThread.Name = $"Worker {threadId}";

                // Simulate work
                Console.WriteLine($"{Thread.CurrentThread.Name}: Starting work...");
                Thread.Sleep(new Random().Next(1000, 4000));

                Console.WriteLine($"{Thread.CurrentThread.Name}: Work completed, signaling coordinator");
                countdown.Signal();
            });
        }

        // Start all workers
        foreach (Thread thread in workerThreads)
        {
            thread.Start();
        }

        // Wait for completion
        coordinatorThread.Join();
        foreach (Thread thread in workerThreads)
        {
            thread.Join();
        }

        countdown.Dispose();
        Console.WriteLine("CountdownEvent demo completed.");
    }

    // 8. AutoResetEvent and ManualResetEvent
    private static AutoResetEvent autoEvent = new AutoResetEvent(false);
    private static ManualResetEvent manualEvent = new ManualResetEvent(false);

    public static void ResetEventDemo()
    {
        Console.WriteLine("\n=== Reset Events Demo ===");

        // AutoResetEvent demo
        Thread autoProducer = new Thread(() =>
        {
            Thread.CurrentThread.Name = "Auto Producer";
            for (int i = 1; i <= 5; i++)
            {
                Console.WriteLine($"{Thread.CurrentThread.Name}: Produced item {i}");
                Thread.Sleep(1000);
                autoEvent.Set(); // Signal one waiting thread
                Console.WriteLine($"{Thread.CurrentThread.Name}: Signaled consumer");
            }
        });

        Thread autoConsumer = new Thread(() =>
        {
            Thread.CurrentThread.Name = "Auto Consumer";
            for (int i = 1; i <= 5; i++)
            {
                Console.WriteLine($"{Thread.CurrentThread.Name}: Waiting for item...");
                autoEvent.WaitOne();
                Console.WriteLine($"{Thread.CurrentThread.Name}: Consumed item {i}");
            }
        });

        autoProducer.Start();
        autoConsumer.Start();

        // Wait for auto event demo
        autoProducer.Join();
        autoConsumer.Join();

        Console.WriteLine("\n--- ManualResetEvent Demo ---");

        // ManualResetEvent demo
        Thread manualSignaler = new Thread(() =>
        {
            Thread.CurrentThread.Name = "Manual Signaler";
            Thread.Sleep(2000);
            Console.WriteLine($"{Thread.CurrentThread.Name}: Setting manual event (allowing all waiting threads)");
            manualEvent.Set();

            Thread.Sleep(3000);
            Console.WriteLine($"{Thread.CurrentThread.Name}: Resetting manual event (blocking new threads)");
            manualEvent.Reset();

            Thread.Sleep(2000);
            Console.WriteLine($"{Thread.CurrentThread.Name}: Setting manual event again");
            manualEvent.Set();
        });

        Thread[] manualWaiters = new Thread[4];
        for (int i = 0; i < manualWaiters.Length; i++)
        {
            int threadId = i;
            manualWaiters[i] = new Thread(() =>
            {
                Thread.CurrentThread.Name = $"Manual Waiter {threadId}";
                Thread.Sleep(threadId * 1000);
                Console.WriteLine($"{Thread.CurrentThread.Name}: Waiting for manual event");
                manualEvent.WaitOne();
                Console.WriteLine($"{Thread.CurrentThread.Name}: Manual event received, proceeding");
            });
        }

        manualSignaler.Start();
        foreach (Thread thread in manualWaiters)
        {
            thread.Start();
        }

        // Wait for manual event demo
        manualSignaler.Join();
        foreach (Thread thread in manualWaiters)
        {
            thread.Join();
        }

        // Cleanup
        autoEvent.Dispose();
        manualEvent.Dispose();

        Console.WriteLine("Reset events demo completed.");
    }

    // 9. Interlocked operations for atomic operations
    private static long atomicCounter = 0;
    private static double atomicBalance = 1000.0;

    public static void InterlockedDemo()
    {
        Console.WriteLine("\n=== Interlocked Operations Demo ===");

        Thread[] threads = new Thread[10];

        for (int i = 0; i < threads.Length; i++)
        {
            threads[i] = new Thread(() =>
            {
                Thread.CurrentThread.Name = $"Interlocked Worker";

                // Atomic increment
                long newValue = Interlocked.Increment(ref atomicCounter);
                Console.WriteLine($"{Thread.CurrentThread.Name}: Incremented counter to {newValue}");

                // Atomic compare and exchange
                double currentBalance = atomicBalance;
                double withdrawal = 50.0;
                double newBalance = currentBalance - withdrawal;

                double exchangedBalance = Interlocked.CompareExchange(ref atomicBalance, newBalance, currentBalance);

                if (exchangedBalance == currentBalance)
                {
                    Console.WriteLine($"{Thread.CurrentThread.Name}: Successfully withdrew {withdrawal:C}, new balance: {newBalance:C}");
                }
                else
                {
                    Console.WriteLine($"{Thread.CurrentThread.Name}: Withdrawal failed due to concurrent modification");
                }

                Thread.Sleep(100);
            });
        }

        // Start all threads
        foreach (Thread thread in threads)
        {
            thread.Start();
        }

        // Wait for completion
        foreach (Thread thread in threads)
        {
            thread.Join();
        }

        Console.WriteLine($"Final atomic counter: {atomicCounter}");
        Console.WriteLine($"Final atomic balance: {atomicBalance:C}");
        Console.WriteLine("Interlocked operations demo completed.");
    }

    // 10. Concurrent collections for thread-safe collections
    private static ConcurrentQueue<string> concurrentQueue = new ConcurrentQueue<string>();
    private static ConcurrentDictionary<string, int> concurrentDict = new ConcurrentDictionary<string, int>();
    private static BlockingCollection<string> blockingCollection = new BlockingCollection<string>();

    public static void ConcurrentCollectionsDemo()
    {
        Console.WriteLine("\n=== Concurrent Collections Demo ===");

        // Producer-Consumer with BlockingCollection
        Thread producer = new Thread(() =>
        {
            Thread.CurrentThread.Name = "Producer";
            for (int i = 1; i <= 10; i++)
            {
                string item = $"Item {i}";
                blockingCollection.Add(item);
                Console.WriteLine($"{Thread.CurrentThread.Name}: Produced {item}");
                Thread.Sleep(200);
            }

            blockingCollection.CompleteAdding();
            Console.WriteLine($"{Thread.CurrentThread.Name}: Production completed");
        });

        Thread consumer = new Thread(() =>
        {
            Thread.CurrentThread.Name = "Consumer";
            foreach (string item in blockingCollection.GetConsumingEnumerable())
            {
                Console.WriteLine($"{Thread.CurrentThread.Name}: Consumed {item}");
                Thread.Sleep(500);
            }

            Console.WriteLine($"{Thread.CurrentThread.Name}: Consumption completed");
        });

        // ConcurrentQueue demo
        Thread[] queueWorkers = new Thread[3];
        for (int i = 0; i < queueWorkers.Length; i++)
        {
            int threadId = i;
            queueWorkers[i] = new Thread(() =>
            {
                Thread.CurrentThread.Name = $"Queue Worker {threadId}";

                for (int j = 1; j <= 5; j++)
                {
                    string item = $"Thread {threadId} Item {j}";
                    concurrentQueue.Enqueue(item);
                    Console.WriteLine($"{Thread.CurrentThread.Name}: Enqueued {item}");
                    Thread.Sleep(100);
                }
            });
        }

        // ConcurrentDictionary demo
        Thread[] dictWorkers = new Thread[3];
        for (int i = 0; i < dictWorkers.Length; i++)
        {
            int threadId = i;
            dictWorkers[i] = new Thread(() =>
            {
                Thread.CurrentThread.Name = $"Dict Worker {threadId}";

                for (int j = 1; j <= 5; j++)
                {
                    string key = $"Key_{threadId}_{j}";
                    concurrentDict.AddOrUpdate(key, 1, (k, v) => v + 1);
                    Console.WriteLine($"{Thread.CurrentThread.Name}: Updated {key}");
                    Thread.Sleep(150);
                }
            });
        }

        // Start all threads
        producer.Start();
        consumer.Start();

        foreach (Thread thread in queueWorkers)
        {
            thread.Start();
        }

        foreach (Thread thread in dictWorkers)
        {
            thread.Start();
        }

        // Wait for completion
        producer.Join();
        consumer.Join();

        foreach (Thread thread in queueWorkers)
        {
            thread.Join();
        }

        foreach (Thread thread in dictWorkers)
        {
            thread.Join();
        }

        // Display results
        Console.WriteLine("\n--- Queue Contents ---");
        while (concurrentQueue.TryDequeue(out string queueItem))
        {
            Console.WriteLine($"Dequeued: {queueItem}");
        }

        Console.WriteLine("\n--- Dictionary Contents ---");
        foreach (var kvp in concurrentDict)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }

        blockingCollection.Dispose();
        Console.WriteLine("Concurrent collections demo completed.");
    }

    static void Main(string[] args)
    {
        Console.WriteLine("=== C# Thread Synchronization Demo ===\n");

        try
        {
            SimpleLockDemo();
            MonitorDemo();
            MutexDemo();
            SemaphoreDemo();
            ReaderWriterLockDemo();
            BarrierDemo();
            CountdownEventDemo();
            ResetEventDemo();
            InterlockedDemo();
            ConcurrentCollectionsDemo();

            Console.WriteLine("\nAll synchronization examples completed successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in synchronization demo: {ex.Message}");
        }
    }
}
CodecsharpIntermediate

Thread Pool and Task Parallel Library

Advanced thread pool usage, Task Parallel Library (TPL), and parallel programming patterns

Difficulty

7/10

Estimated time

35 min

Tags

csharp, threadpool, parallel, async, tpl, windows

Prerequisites

C# async/await, Task Parallel Library basics, LINQ

csharp
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Concurrent;
using System.Linq;

class ThreadPoolTPL
{
    // 1. Basic ThreadPool usage
    public static void BasicThreadPoolDemo()
    {
        Console.WriteLine("=== Basic ThreadPool Demo ===");

        Console.WriteLine($"Min threads: {ThreadPool.GetMinThreads(out int minWorker, out int minIO)} Worker: {minWorker}, IO: {minIO}");
        Console.WriteLine($"Max threads: {ThreadPool.GetMaxThreads(out int maxWorker, out int maxIO)} Worker: {maxWorker}, IO: {maxIO}");

        // Queue multiple work items
        for (int i = 1; i <= 10; i++)
        {
            int workItem = i;
            ThreadPool.QueueUserWorkItem(state =>
            {
                Thread.CurrentThread.Name = $"ThreadPool Worker {workItem}";
                Console.WriteLine($"{Thread.CurrentThread.Name}: Processing item {workItem}");

                // Simulate work
                Thread.Sleep(1000 + workItem * 100);

                Console.WriteLine($"{Thread.CurrentThread.Name}: Completed item {workItem}");
            });
        }

        // Wait for work to complete
        Thread.Sleep(15000);
        Console.WriteLine("ThreadPool demo completed.");
    }

    // 2. Task.Run and basic TPL
    public static async Task BasicTaskDemo()
    {
        Console.WriteLine("\n=== Basic Task Demo ===");

        // Create and run tasks
        Task<int> calculationTask = Task.Run(() =>
        {
            Console.WriteLine("Calculation task started on thread: " + Thread.CurrentThread.ManagedThreadId);

            int result = 0;
            for (int i = 1; i <= 100; i++)
            {
                result += i;
                if (i % 25 == 0)
                {
                    Console.WriteLine($"Calculation progress: {i}/100");
                }
            }

            Console.WriteLine("Calculation task completed");
            return result;
        });

        Task<string> stringTask = Task.Run(() =>
        {
            Console.WriteLine("String task started on thread: " + Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(2000);
            return "Hello from Task!";
        });

        // Main thread continues work
        Console.WriteLine("Main thread continues working while tasks run...");
        for (int i = 1; i <= 3; i++)
        {
            Console.WriteLine($"Main thread work {i}");
            await Task.Delay(500);
        }

        // Wait for results
        int calculationResult = await calculationTask;
        string stringResult = await stringTask;

        Console.WriteLine($"Calculation result: {calculationResult}");
        Console.WriteLine($"String result: {stringResult}");
    }

    // 3. Task.ContinueWith
    public static void TaskContinuationDemo()
    {
        Console.WriteLine("\n=== Task Continuation Demo ===");

        Task<int> initialTask = Task.Run(() =>
        {
            Console.WriteLine("Initial task starting...");
            Thread.Sleep(2000);
            Console.WriteLine("Initial task completed");
            return 42;
        });

        // Add continuations
        Task continuation1 = initialTask.ContinueWith(antecedent =>
        {
            Console.WriteLine($"Continuation 1: Received result {antecedent.Result}");
            return antecedent.Result * 2;
        }, TaskContinuationOptions.OnlyOnRanToCompletion);

        Task continuation2 = continuation1.ContinueWith(antecedent =>
        {
            Console.WriteLine($"Continuation 2: Final result {antecedent.Result}");
        }, TaskContinuationOptions.OnlyOnRanToCompletion);

        // Error handling continuation
        Task errorContinuation = initialTask.ContinueWith(antecedent =>
        {
            Console.WriteLine($"Error handling: Task failed with {antecedent.Exception?.InnerException?.Message}");
        }, TaskContinuationOptions.OnlyOnFaulted);

        // Wait for all continuations
        Task.WaitAll(continuation2, errorContinuation);

        Console.WriteLine("All continuations completed.");
    }

    // 4. Task.WhenAll and WhenAny
    public static async Task TaskWhenDemo()
    {
        Console.WriteLine("\n=== Task.WhenAll and WhenAny Demo ===");

        // Create multiple tasks
        Task[] tasks = new Task[5];

        for (int i = 0; i < tasks.Length; i++)
        {
            int taskIndex = i;
            tasks[i] = Task.Run(async () =>
            {
                Console.WriteLine($"Task {taskIndex} starting...");
                await Task.Delay(new Random().Next(1000, 5000));
                Console.WriteLine($"Task {taskIndex} completed");
                return taskIndex * 10;
            });
        }

        // WhenAny - wait for first task to complete
        Task firstCompleted = await Task.WhenAny(tasks);
        Console.WriteLine($"First task completed: {firstCompleted.Id}");

        // WhenAll - wait for all tasks to complete
        Console.WriteLine("Waiting for all tasks to complete...");
        await Task.WhenAll(tasks);
        Console.WriteLine("All tasks completed!");

        // Get results from all tasks
        Task<int>[] intTasks = tasks.Cast<Task<int>>().ToArray();
        int[] results = await Task.WhenAll(intTasks);

        Console.WriteLine($"All results: [{string.Join(", ", results)}]");
    }

    // 5. Parallel.For and Parallel.ForEach
    public static void ParallelLoopsDemo()
    {
        Console.WriteLine("\n=== Parallel Loops Demo ===");

        // Parallel.For
        Console.WriteLine("--- Parallel.For Demo ---");
        object syncObject = new object();
        int totalSum = 0;

        Parallel.For(1, 101, (i, state) =>
        {
            if (i > 50) // Stop condition
            {
                Console.WriteLine($"Stopping parallel loop at {i}");
                state.Stop();
                return;
            }

            int localSum = i * i;

            // Thread-safe accumulation
            lock (syncObject)
            {
                totalSum += localSum;
                Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId}: {i}² = {localSum}");
            }
        });

        Console.WriteLine($"Total sum of squares: {totalSum}");

        // Parallel.ForEach
        Console.WriteLine("\n--- Parallel.ForEach Demo ---");
        var products = new[] { "Laptop", "Mouse", "Keyboard", "Monitor", "Webcam" };

        Parallel.ForEach(products, new ParallelOptions { MaxDegreeOfParallelism = 2 }, product =>
        {
            Console.WriteLine($"Processing {product} on thread {Thread.CurrentThread.ManagedThreadId}");

            // Simulate processing
            Thread.Sleep(1000 + new Random().Next(500));

            Console.WriteLine($"Completed processing {product}");
        });

        Console.WriteLine("Parallel loops demo completed.");
    }

    // 6. Parallel LINQ (PLINQ)
    public static void PLINQDemo()
    {
        Console.WriteLine("\n=== PLINQ Demo ===");

        // Create a large dataset
        int[] numbers = Enumerable.Range(1, 1000000).ToArray();
        Console.WriteLine($"Processing {numbers.Length:N0} numbers");

        // Sequential LINQ
        var sequentialStart = DateTime.Now;
        var sequentialResult = numbers
            .Where(n => n % 2 == 0)
            .Select(n => n * n)
            .Take(1000)
            .ToList();
        var sequentialTime = DateTime.Now - sequentialStart;

        Console.WriteLine($"Sequential processing: {sequentialTime.TotalMilliseconds:F2}ms, Found {sequentialResult.Count} results");

        // Parallel LINQ
        var parallelStart = DateTime.Now;
        var parallelResult = numbers
            .AsParallel()
            .WithDegreeOfParallelism(Environment.ProcessorCount)
            .Where(n => n % 2 == 0)
            .Select(n => n * n)
            .Take(1000)
            .ToList();
        var parallelTime = DateTime.Now - parallelStart;

        Console.WriteLine($"Parallel processing: {parallelTime.TotalMilliseconds:F2}ms, Found {parallelResult.Count} results");
        Console.WriteLine($"Speedup: {(sequentialTime.TotalMilliseconds / parallelTime.TotalMilliseconds):F2}x");

        // AsParallel() with ordering
        Console.WriteLine("\n--- PLINQ with Ordering ---");
        var orderedResult = numbers
            .AsParallel()
            .AsOrdered()
            .Where(n => n % 1000 == 0)
            .Take(10)
            .ToList();

        Console.WriteLine($"First 10 multiples of 1000: [{string.Join(", ", orderedResult)}]");
    }

    // 7. Producer-Consumer pattern with BlockingCollection
    public static void ProducerConsumerDemo()
    {
        Console.WriteLine("\n=== Producer-Consumer Demo ===");

        var queue = new BlockingCollection<string>(5); // Bounded capacity
        var producerTasks = new Task[2];
        var consumerTasks = new Task[3];

        // Producers
        for (int i = 0; i < producerTasks.Length; i++)
        {
            int producerId = i;
            producerTasks[i] = Task.Run(async () =>
            {
                Thread.CurrentThread.Name = $"Producer {producerId}";

                for (int j = 1; j <= 5; j++)
                {
                    string item = $"Producer{producerId}-Item{j}";
                    Console.WriteLine($"{Thread.CurrentThread.Name}: Producing {item}");

                    queue.Add(item);
                    Console.WriteLine($"{Thread.CurrentThread.Name}: Added {item} to queue (Count: {queue.Count})");

                    await Task.Delay(1000); // Production time
                }

                Console.WriteLine($"{Thread.CurrentThread.Name}: Finished production");
            });
        }

        // Consumers
        for (int i = 0; i < consumerTasks.Length; i++)
        {
            int consumerId = i;
            consumerTasks[i] = Task.Run(async () =>
            {
                Thread.CurrentThread.Name = $"Consumer {consumerId}";

                while (!queue.IsCompleted)
                {
                    try
                    {
                        string item = queue.Take(); // Blocks if empty
                        Console.WriteLine($"{Thread.CurrentThread.Name}: Consumed {item} (Count: {queue.Count})");

                        await Task.Delay(1500); // Processing time
                    }
                    catch (InvalidOperationException)
                    {
                        // Queue is completed and empty
                        break;
                    }
                }

                Console.WriteLine($"{Thread.CurrentThread.Name}: Finished consumption");
            });
        }

        // Wait for all producers to complete
        Task.WaitAll(producerTasks);
        queue.CompleteAdding(); // Signal no more items will be added

        // Wait for all consumers to finish
        Task.WaitAll(consumerTasks);

        Console.WriteLine("Producer-Consumer demo completed.");
    }

    // 8. TaskFactory and custom task creation
    public static void TaskFactoryDemo()
    {
        Console.WriteLine("\n=== TaskFactory Demo ===");

        // Create custom TaskFactory
        var customFactory = new TaskFactory(
            CancellationToken.None,
            TaskCreationOptions.LongRunning,
            TaskContinuationOptions.None,
            TaskScheduler.Default);

        // Create tasks with custom factory
        Task[] customTasks = new Task[3];

        for (int i = 0; i < customTasks.Length; i++)
        {
            int taskId = i;
            customTasks[i] = customFactory.StartNew(() =>
            {
                Thread.CurrentThread.Name = $"Custom Task {taskId}";
                Console.WriteLine($"{Thread.CurrentThread.Name}: Starting (Long-running task)");

                // Simulate long-running work
                Thread.Sleep(3000);

                Console.WriteLine($"{Thread.CurrentThread.Name}: Completed");
            });
        }

        // TaskFactory with parent-child relationships
        Task parentTask = Task.Factory.StartNew(() =>
        {
            Console.WriteLine("Parent task started");

            Task child1 = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("Child task 1 started");
                Thread.Sleep(2000);
                Console.WriteLine("Child task 1 completed");
            }, TaskCreationOptions.AttachedToParent);

            Task child2 = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("Child task 2 started");
                Thread.Sleep(1500);
                Console.WriteLine("Child task 2 completed");
            }, TaskCreationOptions.AttachedToParent);

            Console.WriteLine("Parent task waiting for children");

            // Parent automatically waits for attached children
        });

        // Wait for all tasks
        Task.WaitAll(customTasks);
        parentTask.Wait();

        Console.WriteLine("TaskFactory demo completed.");
    }

    // 9. TaskScheduler and custom scheduling
    public static void TaskSchedulerDemo()
    {
        Console.WriteLine("\n=== TaskScheduler Demo ===");

        // Get current scheduler
        TaskScheduler currentScheduler = TaskScheduler.Current;
        TaskScheduler defaultScheduler = TaskScheduler.Default;

        Console.WriteLine($"Current scheduler: {currentScheduler.GetType().Name}");
        Console.WriteLine($"Default scheduler: {defaultScheduler.GetType().Name}");

        // Task with specific scheduler
        Task defaultSchedulerTask = Task.Factory.StartNew(() =>
        {
            Console.WriteLine($"Running on {TaskScheduler.Current.GetType().Name}");
            Console.WriteLine($"Thread ID: {Thread.CurrentThread.ManagedThreadId}");
            Console.WriteLine($"Is ThreadPool: {Thread.CurrentThread.IsThreadPoolThread}");
        });

        // UI context simulation (would use SynchronizationContext in real UI app)
        TaskScheduler uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();

        // Continue on UI thread (simulation)
        Task uiTask = Task.Run(() =>
        {
            Console.WriteLine("Background work completed");
            return "Result from background";
        }).ContinueWith(antecedent =>
        {
            Console.WriteLine("This would run on UI thread in real application");
            Console.WriteLine($"Background result: {antecedent.Result}");
        }, uiScheduler);

        // Wait for tasks
        Task.WaitAll(defaultSchedulerTask, uiTask);

        Console.WriteLine("TaskScheduler demo completed.");
    }

    // 10. Cancellation with TPL
    public static async Task CancellationDemo()
    {
        Console.WriteLine("\n=== Task Cancellation Demo ===");

        var cts = new CancellationTokenSource();
        CancellationToken token = cts.Token;

        // Create long-running tasks that support cancellation
        Task[] tasks = new Task[5];

        for (int i = 0; i < tasks.Length; i++)
        {
            int taskId = i;
            tasks[i] = Task.Run(async () =>
            {
                Thread.CurrentThread.Name = $"Cancellable Task {taskId}";

                try
                {
                    Console.WriteLine($"{Thread.CurrentThread.Name}: Started");

                    for (int j = 1; j <= 10; j++)
                    {
                        token.ThrowIfCancellationRequested();

                        Console.WriteLine($"{Thread.CurrentThread.Name}: Working... {j * 10}%");
                        await Task.Delay(1000, token);
                    }

                    Console.WriteLine($"{Thread.CurrentThread.Name}: Completed successfully");
                }
                catch (OperationCanceledException)
                {
                    Console.WriteLine($"{Thread.CurrentThread.Name}: Was cancelled");
                }
            }, token);
        }

        // Cancel after 5 seconds
        Task.Delay(5000).ContinueWith(_ =>
        {
            Console.WriteLine("Initiating cancellation...");
            cts.Cancel();
        });

        try
        {
            // Wait for all tasks (will handle cancellations gracefully)
            await Task.WhenAll(tasks);
        }
        catch (AggregateException ex)
        {
            Console.WriteLine($"Caught {ex.InnerExceptions.Count(e => e is OperationCanceledException)} cancellation exceptions");
        }

        Console.WriteLine("Cancellation demo completed.");
    }

    // 11. Dataflow pattern with TPL Dataflow
    public static void DataflowDemo()
    {
        Console.WriteLine("\n=== Dataflow Pattern Demo ===");

        // Create buffer blocks
        var producerBlock = new BufferBlock<int>();
        var processorBlock = new TransformBlock<int, string>(x =>
        {
            Console.WriteLine($"Processing {x} on thread {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(500); // Simulate processing
            return $"Processed_{x}";
        });

        var consumerBlock = new ActionBlock<string>(result =>
        {
            Console.WriteLine($"Consuming {result} on thread {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(300);
        });

        // Link blocks together
        producerBlock.LinkTo(processorBlock, new DataflowLinkOptions { PropagateCompletion = true });
        processorBlock.LinkTo(consumerBlock, new DataflowLinkOptions { PropagateCompletion = true });

        // Start producer
        Task.Run(async () =>
        {
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine($"Producing {i}");
                await producerBlock.SendAsync(i);
                await Task.Delay(200);
            }

            producerBlock.Complete();
        });

        // Wait for completion
        consumerBlock.Completion.Wait();
        Console.WriteLine("Dataflow demo completed.");
    }

    static async Task Main(string[] args)
    {
        Console.WriteLine("=== C# ThreadPool and TPL Demo ===\n");

        try
        {
            BasicThreadPoolDemo();
            await BasicTaskDemo();
            TaskContinuationDemo();
            await TaskWhenDemo();
            ParallelLoopsDemo();
            PLINQDemo();
            ProducerConsumerDemo();
            TaskFactoryDemo();
            TaskSchedulerDemo();
            await CancellationDemo();
            DataflowDemo();

            Console.WriteLine("\nAll ThreadPool and TPL examples completed successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in TPL demo: {ex.Message}");
        }
    }
}

Tools

Tools frequently paired with this sample

Related

Related sample collections

Related

Related workflows

Hub

Infer JSON Schema from Samples and Spreadsheets

Derive a reviewable JSON Schema draft from representative JSON samples or XLSX rows, then inspect types, requiredness, nulls, and outliers before treating it as a contract.

Hub

Private Habit Records: Backup, Restore and Sharing Review

Preserve a local habit journal, test JSON restoration without overwriting your working records, and prepare reviewed CSV or PNG copies without private notes.

Hub

Article to X and LinkedIn Drafts: Fact Review and Handoff

Turn one authorized article into reviewed X and LinkedIn drafts, preserve claim-to-source evidence, check links and final edits, and deliver drafts without automatic publication.

Hub

Markdown Interactive Deck Review and Offline Handoff

Review one interactive Markdown lesson, reconcile content and settings, test the actual offline player and deliver audience files separately from private speaker sources.

Home
Tools3208
Samples593
Visualizations469
Viewers103
Hubs237
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance646

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web193

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff
Small-Room Furniture Layout Review and Move-In Handoff
FLAC/WAV Source Screening and Evidence Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact

Development

Windows PE / Linux ELF / Mach-O Binary Header, Section, Import & Export Inspector

Upload a PE-COFF (.exe/.dll), ELF or Mach-O binary and parse its headers end to end: DOS/PE signature, COFF machine, optional header (entry point, image base, subsystem, ASLR/NX/CFG), section table with RVA↔offset mapping, import/export directories, ELF program headers and PIE detection, dynamic symbols and DT_NEEDED, Mach-O load commands and dylibs — with cross-architecture annotations and a hex preview.

Swift

macOS Multithreading Swift Samples

macOS Swift multithreading examples including thread creation, synchronization with locks, and thread pool usage

C++

Windows Multithreading - C++ Samples

Comprehensive C++ multithreading examples for Windows platform including thread creation, synchronization, and thread pools

C#

Windows Cryptography - C# Samples

Comprehensive C# cryptography examples for Windows platform including hash computation, symmetric encryption, asymmetric encryption, and digital signatures

C#

Windows Database - C# Samples

Comprehensive C# database examples for Windows platform including SQLite connections, SQL queries, transactions, and database operations

C#

Windows Data Structures - C# Samples

Comprehensive C# data structures examples for Windows platform including arrays, lists, dictionaries, queues, stacks, and collections

C#

Windows Date and Time - C# Samples

Comprehensive C# date and time processing examples for Windows platform including DateTime, TimeSpan, TimeZone, and calendar operations