Rust Interview Questions

In Rust, Arc (Atomic Reference Counting) is a thread-safe reference-counting pointer used for sharing data between multiple threads. Arc ensures that data is deallocated only when the last reference to it is dropped, and it provides atomic operations to safely increment and decrement the reference count across threads.

Key Features of Arc

1. Thread-Safe: Arc is safe to use in a multi-threaded context, unlike Rc (Reference Counting), which is not thread-safe.
2. Reference Counting: Arc keeps track of the number of references to the data it holds and deallocates the data when the reference count drops to zero.
3. Shared Ownership: Multiple threads can own the same data, and the data will be dropped when the last Arc is dropped.

Creating and Using Arc

Basic Example

Here’s a simple example demonstrating how to create and use an Arc:

use std::sync::Arc;

fn main() {
    let data = Arc::new(5);

    let data1 = Arc::clone(&data);
    let data2 = Arc::clone(&data);

    println!("Data1: {}", data1);
    println!("Data2: {}", data2);
}

In this example:

• Arc::new creates a new Arc instance holding the data.
• Arc::clone creates a new reference to the same data, incrementing the reference count.

Using Arc with Threads

When sharing data between threads, Arc is often combined with Mutex to ensure safe mutable access.

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());
}

In this example:

• Arc is used to share ownership of the Mutex-wrapped counter across multiple threads.
• Each thread locks the Mutex, increments the counter, and then releases the lock.
• The main thread waits for all spawned threads to finish using handle.join().

Reference Counting in Arc

Arc keeps track of the number of references to the data and ensures that the data is deallocated only when the last reference is dropped.

Example: Reference Counting

use std::sync::Arc;
use std::thread;

fn main() {
    let data = Arc::new(5);
    let data1 = Arc::clone(&data);
    let data2 = Arc::clone(&data);

    println!("Initial count: {}", Arc::strong_count(&data));

    let handle = thread::spawn(move || {
        println!("Count in thread: {}", Arc::strong_count(&data1));
    });

    handle.join().unwrap();

    println!("Final count: {}", Arc::strong_count(&data));
}

In this example:

• Arc::strong_count returns the number of references to the data.
• The reference count is incremented when data1 and data2 are created and decremented when they go out of scope.

Summary

• Purpose: Arc is used for thread-safe reference counting, allowing multiple threads to share ownership of data.
• Creation: Use Arc::new to create an Arc instance.
• Cloning: Use Arc::clone to create additional references to the same data.
• Thread Safety: Arc is thread-safe and often combined with Mutex to allow safe mutable access in multi-threaded contexts.
• Reference Counting: Arc keeps track of the number of references and deallocates the data when the count drops to zero.

By using Arc, you can safely share data between multiple threads, ensuring that the data is not deallocated prematurely and that access to it is synchronized when necessary.