Rust – Parallel Programming (RUST4)

Programming, Rust

Learn how Rust supports building safe, reliable multithreaded applications and clarify design options for concurrent systems. The language emphasizes memory safety, provides coroutines for async control flow and libraries like Tokio for scheduling and asynchronous I/O.

Practice using coroutines to write asynchronous code that reads like synchronous code, while the Tokio runtime schedules tasks and handles async I/O. You will learn to build both single-threaded async services and multithreaded programs that scale with your hardware.

THIS TRAINING COURSE WILL HELP YOU:

  • Write safe multithreaded Rust programs
  • Use coroutines and async/await effectively
  • Work with Tokio runtime and async I/O
  • Design concurrent data sharing and synchronization

WHO SHOULD ATTEND?

  • Rust developers wanting to learn concurrency
  • Engineers building async network services
  • System programmers optimizing parallel code
  • Anyone familiar with Rust basics

COURSE LOCATION AND AVAILABLE DATES



Public courses are usually delivered in Czech, but this course is also available in English. We can arrange private training for your team online, at your premises or in our classrooms, and tailor the content to your needs.

For groups of around 4 or more participants, private training can already be comparable in price to booking individual places on a public course. Send us your requirements and we’ll recommend the best format and provide an exact quote.

Request training in English

Course content:

Hide details
  • Building parallel programs
    1. Rust 2018/2021 editions
    2. Standard library support
    3. Hardware characteristics
  • Rust safety features
    1. Restricting data sharing
    2. Static code checks
    3. Ownership and data passing
  • Parallel threads
    1. Spawning and waiting
    2. Retrieving results
    3. Tasks and coroutines
  • Communication between threads
    1. Message passing
    2. Producer and consumer patterns
    3. Thread shutdown and cleanup
  • Memory access concurrency
    1. Concurrent writes
    2. Reading concurrently written memory
    3. Memory coherence
  • Atomic variables
    1. Accessing atomic variables
    2. Atomic operations
    3. Memory barriers
  • Coroutines and parallelism
    1. Asynchronous code patterns
    2. Waiting for events
    3. Cooperative tasks
  • Shared data structures
    1. Mutual exclusion and locking
    2. Waiting for events
    3. Signalling and notifications
Prerequisites:
Basic Rust experience and familiarity with Cargo and the command line.
Recommended previous course:
Rust – Generic Programming (RUST3)
Recommended follow-up course:
Rust – Design Patterns (RUST5)
Schedule:
3 days (9:00-17:00)
Price per person:
736.00 € ( 890.56 € incl. 21% VAT)

Training and learning environment