Rust Concurrency Quiz

Rust

0 Passed

0% acceptance

Master Rust's concurrency model with threads, channels, and synchronization primitives for safe parallel programming

40 Questions

~80 minutes

Question 1

What is the primary concurrency model in Rust?

Message passing with channels

Shared memory with locks

Actor model

CSP (Communicating Sequential Processes)

Question 2

What does this basic thread example do?

rust

use std::thread;
let handle = thread::spawn(|| {
    println!("Hello from thread!");
});
handle.join().unwrap();

Creates new thread, executes closure, waits for completion

Compilation error

Creates thread but doesn't wait

Runtime error

Question 3

What is the difference between thread::spawn and thread::Builder?

Builder allows customizing thread properties like name and stack size

Builder creates threads differently

They are identical

Builder doesn't exist

Question 4

What does move closure do in thread::spawn?

Transfers ownership of captured variables to new thread

Copies variables to new thread

Shares variables between threads

Move is not needed

Question 5

What does this channel example demonstrate?

rust

use std::sync::mpsc;
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
    tx.send(42).unwrap();
});
let received = rx.recv().unwrap();

Message passing between threads using channels

Compilation error

Shared memory access

Runtime error

Question 6

What is mpsc in std::sync::mpsc?

Multiple Producer, Single Consumer

Message Passing System

Mutex Protected Shared Channel

Question 7

What does recv() return?

Result<T, RecvError> - blocks until message received

Option<T> - returns None if no message

T directly

recv() doesn't exist

Question 8

What does try_recv() do?

Non-blocking receive, returns immediately

Blocks like recv()

Sends message

try_recv() doesn't exist

Question 9

What is a Mutex in Rust?

Mutual exclusion primitive for shared mutable state

Channel for message passing

Thread creation primitive

Mutex doesn't exist

Question 10

What does this Mutex example show?

rust

use std::sync::Mutex;
let m = Mutex::new(5);
{
    let mut num = m.lock().unwrap();
    *num = 6;
}
println!("m = {:?}", m);

Thread-safe mutation of shared data

Compilation error

Data race

Runtime panic

Question 11

What happens if you try to lock a Mutex from the same thread twice?

Deadlock - thread waits for itself

Compilation error

Runtime panic

Succeeds

Question 12

What is RwLock?

Reader-writer lock allowing multiple readers or single writer

Read-only lock

Write-only lock

RwLock doesn't exist

Question 13

What does Arc stand for in concurrent contexts?

Atomic Reference Counting

Asynchronous Reference Counting

Automatic Reference Counting

Arc doesn't exist

Question 14

What does this Arc<Mutex<T>> example show?

rust

use std::sync::{Arc, Mutex};
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();
}

Thread-safe shared mutable counter using Arc<Mutex<>>

Compilation error

Data race

Deadlock

Question 15

What are the Send and Sync traits?

Send allows transfer between threads, Sync allows shared access

Send allows sharing, Sync allows transfer

They are the same

These traits don't exist

Question 16

Which types are not Send?

Rc<T> (not thread-safe), raw pointers, RefCell<T>

Arc<T>, Mutex<T>

All types are Send

None are Send

Question 17

Which types are not Sync?

Cell<T>, RefCell<T>, raw pointers

Arc<T>, Mutex<T>

All types are Sync

None are Sync

Question 18

What is a data race?

Concurrent access to same memory with at least one write

Multiple threads reading same data

Sequential access to data

Data races don't exist in Rust

Question 19

What is a race condition?

Program behavior depends on timing of operations

Compilation error

Same as data race

Race conditions don't exist

Question 20

What does thread::park() do?

Puts current thread to sleep until unparked

Creates new thread

Terminates thread

park() doesn't exist

Question 21

What is thread::yield_now()?

Hints scheduler to switch to another thread

Terminates current thread

Blocks indefinitely

yield_now() doesn't exist

Question 22

What is a barrier?

Synchronization point where threads wait for each other

Memory barrier

Channel type

Barriers don't exist

Question 23

What does this barrier example do?

rust

use std::sync::Barrier;
let barrier = Arc::new(Barrier::new(2));
let b1 = barrier.clone();
let handle = thread::spawn(move || {
    println!("Before barrier");
    b1.wait();
    println!("After barrier");
});
barrier.wait();
handle.join().unwrap();

Synchronizes two threads at barrier point

Compilation error

Race condition

Deadlock

Question 24

What is a Condvar (condition variable)?

Allows threads to wait for specific condition to become true

Variable that changes automatically

Channel type

Condvar doesn't exist

Question 25

What is the difference between notify_one() and notify_all()?

notify_one wakes one waiting thread, notify_all wakes all

They are identical

notify_one doesn't exist

notify_all wakes none

Question 26

What is thread local storage?

Data local to each thread, not shared between threads

Shared data across threads

Global variables

Thread local storage doesn't exist

Question 27

What does this thread_local example show?

rust

use std::cell::RefCell;
thread_local!(static FOO: RefCell<u32> = RefCell::new(1));
FOO.with(|f| {
    *f.borrow_mut() = 2;
});
let handle = thread::spawn(|| {
    FOO.with(|f| {
        println!("Other thread: {}", *f.borrow());
    });
});
handle.join().unwrap();

Each thread has separate copy of FOO

Compilation error

Shared mutable state

Data race

Question 28

What is the scoped thread API?

Threads that borrow from parent scope safely

Global threads

Threads with unlimited lifetime

Scoped threads don't exist

Question 29

What is the main advantage of message passing over shared state?

No data races, easier reasoning about concurrent code

Better performance

Less code

No advantage

Question 30

What is the main advantage of shared state over message passing?

Lower overhead for frequent small updates

No data races

Easier to reason about

No advantage

Question 31

What is deadlock?

Threads waiting for each other to release resources

Thread termination

High CPU usage

Deadlock doesn't exist

Question 32

How can you prevent deadlock?

Always acquire locks in same order, use timeouts

Use more threads

Use channels instead of mutexes

Deadlock cannot be prevented

Question 33

What is lock contention?

Threads competing for same lock, hurting performance

Multiple locks

No locks

Lock contention doesn't exist

Question 34

What is false sharing?

Cache line contention when threads modify nearby data

Incorrect sharing

No sharing

False sharing doesn't exist

Question 35

What is the difference between std::thread and rayon?

rayon provides data parallelism, std::thread provides task parallelism

They are identical

std::thread is better

rayon doesn't exist

Question 36

What does this rayon example do?

rust

use rayon::prelude::*;
let sum: i32 = (0..1000).into_par_iter().map(|x| x * x).sum();

Parallel computation of sum of squares

Compilation error

Sequential computation

Runtime error

Question 37

What is the key difference between concurrency and parallelism?

Concurrency is about dealing with multiple tasks, parallelism is about executing them simultaneously

They are the same

Concurrency is faster

Parallelism doesn't exist

Question 38

What is the thread pool pattern?

Pre-allocated threads waiting for work

Single thread handling all work

No threads

Thread pool doesn't exist

Question 39

What is cooperative vs preemptive scheduling?

Cooperative yields control voluntarily, preemptive can interrupt

They are identical

Cooperative is better

Preemptive doesn't exist

Question 40

In a web server handling multiple concurrent requests, each needing to update shared user session data and log to a shared file, which concurrency approach would you choose and why?

Message passing for logging, Arc<Mutex<>> for session data

All shared state with mutexes

All message passing

No concurrency needed

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Python

29 quizzes

Introduction & Core Fundamentals

Data Types & Zero Values

Operators & Expressions

C++

26 quizzes

Basics

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Rust

Cargo and Project Setup

40 comprehensive questions on Rust's package manager Cargo, covering project initialization, building, running, project structure, and dependency management — with 15 code examples demonstrating practical Cargo usage.

Variables and Mutability

40 comprehensive questions on Rust's variable system, covering let bindings, mut keyword, shadowing, type inference, and constants — with 12 code examples demonstrating practical variable usage patterns.

Data Types

45 comprehensive questions on Rust's type system, covering scalar types, compound types, type conversions, numeric operations, and string types — with 15 code examples demonstrating practical type usage patterns.

Control Flow

45 comprehensive questions on Rust's control flow constructs, covering if expressions, loops, and control flow keywords — with 15 code examples demonstrating practical control flow usage.

Functions

40 questions covering function parameters, return values, expressions, diverging functions, and function scope in Rust.

Ownership

45 in-depth questions covering Rust's ownership system, move semantics, copy types, resource cleanup through Drop trait, precise drop timing, and ownership transfer patterns — with 12 code examples to solidify understanding.

Borrowing

45 in-depth questions covering Rust's borrowing system, immutable and mutable references, aliasing rules, reference scopes, and borrow checker validation — with 13 code examples to solidify understanding.

Lifetimes

40 in-depth questions covering Rust's lifetime system, lifetime annotations, elision rules, function signatures with lifetimes, struct references, and common lifetime errors — with 11 code examples to solidify understanding.

Strings

40 comprehensive questions on Rust's string types, covering String vs &str, UTF-8 behavior, slicing, mutating strings, and conversions — with 11 code examples demonstrating practical string handling patterns.

Collections

40 comprehensive questions on Rust's collection types, covering Vec, HashMap, VecDeque, iteration patterns, and capacity management — with 11 code examples demonstrating practical collection usage.

Slices

40 comprehensive questions on Rust's slice types, covering borrowed views, indexing, mutable slices, ranges, and slice methods — with 11 code examples demonstrating practical slice usage patterns.

Pattern Matching

40 comprehensive questions on Rust's pattern matching system, covering match expressions, destructuring, guards, wildcards, and enum matching — with 11 code examples demonstrating practical pattern matching techniques.

Enums

40 comprehensive questions on Rust's enum system, covering simple variants, data-carrying variants, enum matching, methods on enums, and Option/Result patterns — with 11 code examples demonstrating practical enum usage.

Struct

40 comprehensive questions on Rust's struct system, covering named fields, tuple structs, methods, associated functions, and field ownership — with 11 code examples demonstrating practical struct usage.

Modules

40 comprehensive questions on Rust's module system, covering module creation, visibility, imports, paths, and the use keyword — with 11 code examples demonstrating practical module organization patterns.

Traits

40 comprehensive questions on Rust's trait system, covering trait definitions, implementations, bounds, associated types, and trait objects — with 11 code examples demonstrating practical trait usage patterns.

Generic

40 comprehensive questions on Rust's generic programming system, covering generic functions, structs, enums, impl blocks, and monomorphization — with 11 code examples demonstrating practical generic usage patterns.

Iterators

Master Rust's powerful iterator system for efficient data processing and transformation

Closures

Master Rust's closure system for capturing environment variables and creating flexible function-like constructs

Error Handling

Master Rust's robust error handling system with Result, Option, and the ? operator for reliable code

File and I/O Operations

Master Rust's file system operations and I/O handling for robust data persistence and streaming

Smart Pointers

Master Rust's smart pointer types for automatic memory management and safe heap allocation

Concurrency

Master Rust's concurrency model with threads, channels, and synchronization primitives for safe parallel programming

Async Programming

Master asynchronous programming in Rust with futures, async/await, and concurrent execution patterns

Memory Management

Deep dive into Rust's ownership system, borrowing rules, and advanced memory management patterns for safe and efficient code

Macros

Master Rust's metaprogramming system with declarative and procedural macros for code generation and compile-time programming

Attributes

Master Rust's attribute system for conditional compilation, testing, documentation, and code generation

Testing

Master comprehensive testing strategies in Rust including unit tests, integration tests, documentation tests, and testing best practices

Crate Architecture

Master the design and organization of Rust crates including module systems, workspace management, dependency handling, and publishing strategies

Performance and Optimization

Master advanced performance techniques in Rust including profiling, benchmarking, memory optimization, and compiler optimizations

Rust Concurrency Quiz

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 21

Question 22

Question 23

Question 24

Question 25

Question 26

Question 27

Question 28

Question 29

Question 30

Question 31

Question 32

Question 33

Question 34

Question 35

Question 36

Question 37

Question 38

Question 39

Question 40

What is Concurrency in Rust?

What You Will Practise

Other Quiz Categories

QUIZZES IN Rust

Cargo and Project Setup

Variables and Mutability

Data Types

Control Flow

Functions

Ownership

Borrowing

Lifetimes

Strings

Collections

Slices

Pattern Matching

Enums

Struct

Modules

Traits

Generic

Iterators

Closures

Error Handling

File and I/O Operations

Smart Pointers

Concurrency

Async Programming

Memory Management

Macros

Attributes

Testing

Crate Architecture

Performance and Optimization