Threads, Tasks, and Ownership: C# and Rust Concurrency Explored

Posts in this Series on Rust for C# Developers

• Part 1: Why Every C# Developer Should Explore Rust
• Part 2: Exploring Programming Paradigms: C# and Rust Side by Side
• Part 3: Syntax Smackdown: Comparing Constructs in C# and Rus
• Part 4: Memory Wars: Garbage Collection in C# vs. Ownership in Rust
• Part 5: Threads, Tasks, and Ownership: C# and Rust Concurrency Explored
• Part 6: Building with .NET and Rust: A Tale of Two Ecosystems
• Part 7: Level Up Your Skills: Learning Rust as a C# Dev
• Part 8: Rust’s Superpower: Speed Meets Smarts

Concurrency in programming can be like cooking dinner while answering emails—you’re juggling multiple tasks at once, hoping nothing burns. C# and Rust both tackle concurrency, but their approaches couldn’t be more different. C# offers a traditional multitasking toolkit with threads and async/await, while Rust rewrites the rulebook with a compiler-enforced, fearless concurrency model. Let’s see how they compare!

C#: The Multitasking Maestro

C# makes concurrent programming accessible with features like threads, tasks, and the much-loved async/await. It’s like hiring a team of sous-chefs to help you cook—easy delegation, but you need to watch out for kitchen collisions.

Threads and Tasks

Threads are the OGs of concurrency in C#. Tasks, introduced later, offer a higher-level abstraction:

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

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("Starting tasks...");

        var task1 = Task.Run(() => DoWork("Task 1"));
        var task2 = Task.Run(() => DoWork("Task 2"));

        await Task.WhenAll(task1, task2);

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

    static void DoWork(string taskName)
    {
        Console.WriteLine($"{taskName} is working...");
        Thread.Sleep(1000); // Simulating work
        Console.WriteLine($"{taskName} is done.");
    }
}

Tasks simplify threading and allow you to use async/await for non-blocking operations. However, you’re still responsible for avoiding race conditions, deadlocks, and thread safety issues—your kitchen can still turn into chaos.

Locks and Semaphores

To manage shared resources safely, you’ll need synchronization tools like locks and semaphores:

private static readonly object _lock = new object();

lock (_lock)
{
    // Access shared resource safely
}

It works, but it’s easy to forget these guards, leading to subtle bugs.

Rust: Fearless and Safe

Rust’s approach to concurrency is all about safety without sacrificing performance. Thanks to its ownership and borrowing rules, Rust ensures that you don’t shoot yourself in the foot when working with multiple threads. It’s like having a kitchen where every chef is assigned their own workstation—no bumping into each other.

Ownership and Borrowing

Rust’s ownership model ensures exclusive access to resources. You can only mutate data if you have a unique reference to it. This eliminates the possibility of data races at compile time:

use std::thread;

fn main() {
    let data = vec![1, 2, 3];

    let handle = thread::spawn(move || {
        println!("Data: {:?}", data);
    });

    handle.join().unwrap();
}

Notice the move keyword? It transfers ownership of data to the thread, ensuring no other thread can access it.

Send and Sync Traits

Rust uses the Send and Sync traits to enforce thread safety. A type can be transferred between threads if it implements Send, and it can be shared across threads if it implements Sync. These traits are automatically applied to types deemed safe by the compiler.

Concurrency Primitives

Rust provides threads, channels, and locks, but with a safety-first twist:

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

Here, Arc (atomic reference counting) and Mutex ensure safe sharing and mutation of the counter across threads.

Comparing the Models

Feature	C#	Rust
Ease of Use	High, with async/await	Moderate, with steep learning curve
Performance	Good, with some overhead	Excellent, no runtime GC
Safety	Developer-dependent	Compiler-enforced
Concurrency Tools	Threads, tasks, locks	Threads, channels, Arc/Mutex

Final Thoughts

C# offers a developer-friendly approach to concurrency, with tools that make multitasking approachable. However, it leaves safety largely in your hands. Rust, on the other hand, enforces safety at every turn, ensuring that concurrency issues like data races are impossible by design.

So, if you’re building enterprise apps with complex async workflows, C# might be your best bet. But if you’re diving into performance-critical systems or just want to experience “fearless concurrency,” give Rust a try. Either way, you’ll come out with a stronger grasp of concurrency concepts—and that’s a win.

Which concurrency model do you prefer? Let us know in the comments below!