Index

Symbols

? operator for error handling, Waterfall Design Pattern

A

actor model
- actor supervision, Implementing State Recovery for Actors-Creating Actor Supervision
- actors defined, The Actor Model
- building a basic actor, Building a Basic Actor
  - refactored for heartbeat mechanism, Creating Actor Supervision-Creating Actor Supervision
- documentation link, The Actor Model
- mutexes versus actors, Building a Basic Actor-Working with Actors Versus Mutexes
- router pattern, Implementing the Router Pattern-Implementing the Router Pattern
  - actor supervision, Implementing State Recovery for Actors-Creating Actor Supervision
  - sender as global static, Implementing the Router Pattern
  - sender as global static caution, Implementing the Router Pattern
- sending a message to an actor, Building a Basic Actor
  - multiproducer, single-consumer channel (mpsc), Building a Basic Actor
  - oneshot::Sender for response, Building a Basic Actor
- state of actors, The Actor Model, Working with Actors Versus Mutexes
  - fault-tolerant state recovery, Implementing State Recovery for Actors
  - state recovery for actors, Implementing State Recovery for Actors-Implementing State Recovery for Actors
- testing actors, Building a Basic Actor
  - isolation simplifying testing, The Actor Model
anyhow library, Integrating Networking into Our Own Async Runtime
API calls via reqwest package, Improving HTTP Request Performance with Async
Arc (atomic reference counting), What Are Threads?
- basic asynchronous code, What Are Threads?
async closure in static lifetime, Building Our Own Async Queue
- async closure documentation link, Building Our Own Async Queue
async move, Building Our Own Async Queue
async programming
- about, What Is Async Rust?, Introduction to Async, Introduction to Processes
- async described, What Is Async?-What Is Async?
  - basic asynchronous code, What Is Async?
- async programming in the wild, Design Patterns
  - (see also design patterns)
- async Rust (see async Rust)
- computationally heavy tasks, Increasing Workers and Queues
- coroutines mimicking async behavior, What Are Coroutines?, Mimicking Async Behavior with Coroutines-Mimicking Async Behavior with Coroutines
- deadlocks, Controlling Coroutines, Testing For Deadlocks
- examples of using async, Where Can We Utilize Async?-Improving HTTP Request Performance with Async
  - file I/O, Where Can We Utilize Async?-Using Async for File I/O
  - HTTP request performance, Improving HTTP Request Performance with Async-Improving HTTP Request Performance with Async
- futures, Understanding Tasks, Futures
  - (see also futures)
- generators, Generating with Coroutines
  - (see also generators)
- ownership
  - AsyncRead execution, Implementing the Tokio AsyncRead Trait
  - shared data, What Are Threads?
  - variables in static lifetime, Building Our Own Async Queue
- processes, Introduction to Processes-Introduction to Processes
  - (see also processes)
  - async Rust, Introduction to Processes
  - basic asynchronous code, Introduction to Processes
  - definition, Introduction to Processes
  - drawbacks, Introduction to Processes
- reactive programming (see reactive programming)
- runtime summary, Building Our Own Async Queue
- synchronous code mix issues, Testing Coroutines
- tasks, Understanding Tasks-Understanding Tasks
  - (see also tasks)
  - definition, Understanding Tasks
  - flow control via coroutines, Controlling Coroutines-Controlling Coroutines
  - futures, Understanding Tasks, Futures
    - (see also futures)
  - nonblocking sleep allowing async, Understanding Tasks, Building Our Own Async Queue, Processing Tasks with Local Pools
- threads, What Are Threads?-What Are Threads?
  - basic asynchronous code, What Are Threads?, What Are Threads?
  - Condvar for interaction, What Are Threads?
  - definition, What Are Threads?
  - JoinHandle, What Are Threads?
  - JoinHandle return result, What Are Threads?
  - multiple Condvars, What Are Threads?
  - parked while waiting, What Are Threads?, Task Stealing
async queues
- building your own, Building Our Own Async Queue-Building Our Own Async Queue
  - about, Building Our Own Async Queues
  - async runtime summary, Building Our Own Async Queue
  - background processes, Running Background Processes
  - CPU tasks offloaded to new thread pool, Context in Futures, Increasing Workers and Queues
  - increasing threads and queues, Increasing Workers and Queues
  - join macro created, Creating Our Own Join Macro
  - networking (see networking integrated into async runtime)
  - Runnable handle, Building Our Own Async Queue
  - runtime configured, Configuring Our Runtime-Configuring Our Runtime
  - runtime rebuilt, Building a Runtime
  - static keyword, Building Our Own Async Queue
  - task stealing, Task Stealing-Task Stealing
  - task-spawning function, Building Our Own Async Queue
  - task-spawning function refactored, Refactoring Our spawn_task Function-Refactoring Our spawn_task Function
  - tasks to different queues, Passing Tasks to Different Queues-Passing Tasks to Different Queues
- lazy in evaluation, Task Stealing
  - runtime configured for, Configuring Our Runtime-Configuring Our Runtime
- multiple queues, Passing Tasks to Different Queues-Passing Tasks to Different Queues
  - task stealing, Task Stealing-Task Stealing
  - Tokio for task distribution, Passing Tasks to Different Queues
async runtime (see runtime)
async Rust
- about, What Is Async Rust?
- function colors, Testing Coroutines
- global state drawbacks, Implementing the Router Pattern
- Rust learning resources, Who Is This Book For?
- tasks, Understanding Tasks-Understanding Tasks
  - (see also tasks)
  - futures, Understanding Tasks, Futures
    - (see also futures)
  - nonblocking sleep allowing async, Understanding Tasks, Building Our Own Async Queue, Processing Tasks with Local Pools
async server built
- about, Building an Async Server with No Dependencies
- basics set up, Setting Up the Basics-Setting Up the Basics
  - Data struct public, Setting Up the Basics
  - four workspaces, Setting Up the Basics
  - serialize and deserialize functions, Setting Up the Basics
- client built, Building Our Async Client
- receiver built, Building Our Receiver
- runtime components, Building Our std Async Runtime-Building Our Sleep
  - executor built, Building Our Executor-Building Our Executor
  - executor run, Running Our Executor-Running Our Executor
  - waker, Building Our Waker-Building Our Waker
- sender built, Building Our Sender
- server built, Building Our Server
  - accepting requests, Accepting Requests-Accepting Requests
  - handling requests, Handling Requests
- sleep built, Building Our Sleep
async tasks (see tasks)
async-native-tls, Integrating Networking into Our Own Async Runtime
async-task, Building Our Own Async Queue
- building an async queue, Building Our Own Async Queue-Building Our Own Async Queue
async/await functions
- accessing thread data directly and, Getting Unsafe with Thread Data-Getting Unsafe with Thread Data
- await keyword in Tokio, Understanding Tasks, Building Our Own Async Queue
  - Tokio runtime for, Processing Tasks with Local Pools
- building an async queue, Building Our Own Async Queue
- coroutines described, What Are Coroutines?, Mimicking Async Behavior with Coroutines
- futures with, Context in Futures, High-Level Data Sharing Between Futures
AsyncRead trait, Implementing the Tokio AsyncRead Trait-Implementing the Tokio AsyncRead Trait
- documentation link, Implementing the Tokio AsyncRead Trait
Atomic Bool
- documentation link, What Are Threads?
- Relaxed ordering, What Are Threads?
atomics, Building Our Display Observer
- compare and exchange, Building Our Display Observer
- documentation link, Reactive Programming
- event bus, Enabling Broadcasting with an Event Bus-Building Our Event Bus Struct
- reactive system, Defining Our Subjects-Defining Our Subjects
audit trail example of futures, Putting It All Together-Putting It All Together
await keyword (Tokio), Understanding Tasks, Building Our Own Async Queue, Processing Tasks with Local Pools
- accessing thread data directly and, Getting Unsafe with Thread Data-Getting Unsafe with Thread Data

B

background processes, Running Background Processes
backpressure from event buildup, Interacting with Our Event Bus via Async Tasks
book web page, How to Contact Us
Box<dyn Any + Send>> dynamic trait object, What Are Threads?
broadcasting via event bus, Enabling Broadcasting with an Event Bus-Interacting with Our Event Bus via Async Tasks
- broadcast channels versus, Enabling Broadcasting with an Event Bus
- dependencies and imports, Enabling Broadcasting with an Event Bus
- event bus interactions via tasks, Interacting with Our Event Bus via Async Tasks
- handle for event bus, Building Our Event Bus Handle-Building Our Event Bus Handle
  - garbage collection for dead IDs, Interacting with Our Event Bus via Async Tasks
- struct for event bus, Building Our Event Bus Struct-Building Our Event Bus Struct

C

caching via local pool, Processing Tasks with Local Pools
callbacks, Getting User Input via Callbacks
- callback guard, Getting User Input via Callbacks
- nested callbacks leading to hell, Getting User Input via Callbacks
- user input via, Getting User Input via Callbacks-Getting User Input via Callbacks
  - event loop for nonblocking, Getting User Input via Callbacks
channels
- async file I/O example, Using Async for File I/O-Using Async for File I/O
- flume for building async queue, Building Our Own Async Queue-Building Our Own Async Queue
  - increasing threads and queues, Increasing Workers and Queues
  - task stealing, Task Stealing-Task Stealing
- lazy in evaluation, Task Stealing
- testing channel capacity, Testing Channel Capacity
- waking futures remotely, Waking Futures Remotely-Waking Futures Remotely
circuit-breaker pattern, The Circuit-Breaker Pattern-The Circuit-Breaker Pattern
- documentation link, The Circuit-Breaker Pattern
- spawn_task checking OPEN, The Circuit-Breaker Pattern
clearscreen for heater system display, Defining Our Subjects, Building Our Display Observer-Building Our Display Observer, Getting User Input via Callbacks
Clone trait
- event bus struct, Building Our Event Bus Struct-Building Our Event Bus Struct
- JoinHandle not implementing, What Are Threads?
Condvar (conditional variable), What Are Threads?
- basic asynchronous code, What Are Threads?
- thread interaction, What Are Threads?
  - multiple Condvars, What Are Threads?
  - parked thread, What Are Threads?
connectors, Understanding Executors and Connectors
- hyper relying on, Building an HTTP Connection-Building an HTTP Connection
Context in futures, Context in Futures-Context in Futures
cooperative multitasking, Understanding Tasks
Coroutine trait
- formerly Generator trait and GeneratorState, Implementing a Simple Generator in Rust
- Future trait similarity, Why Use Coroutines?
  - coroutines implementing Future traits, Controlling Coroutines
- resume as only required method, Implementing a Simple Generator in Rust
coroutines
- about syntax used in book, Coroutines
- async behavior mimicked by, Mimicking Async Behavior with Coroutines-Mimicking Async Behavior with Coroutines
  - coroutines sent over threads, Controlling Coroutines
  - drawbacks of, Mimicking Async Behavior with Coroutines
  - Executor struct created, Mimicking Async Behavior with Coroutines
  - struct for coroutines with async runtime, Controlling Coroutines
- described, Coroutines, What Are Coroutines?
  - subroutines compared, What Are Coroutines?
  - threads compared, What Are Coroutines?
  - trade-offs, What Are Coroutines?
  - Yield type and Return type, Why Use Coroutines?
- flow control via, Controlling Coroutines-Controlling Coroutines
- Future traits implemented by, Controlling Coroutines
  - struct for coroutines with async runtime, Controlling Coroutines
- as generators, Generating with Coroutines
  - async generator documentation link, Generating with Coroutines
  - calling a coroutine from a coroutine, Calling a Coroutine from a Coroutine-Calling a Coroutine from a Coroutine
  - flow control via coroutines, Controlling Coroutines
  - implementing a generator, Implementing a Simple Generator in Rust, Controlling Coroutines
  - large file transfer example, Stacking Our Coroutines-Stacking Our Coroutines
  - stacking coroutines, Stacking Our Coroutines-Stacking Our Coroutines
  - symmetric coroutines, Calling a Coroutine from a Coroutine-Calling a Coroutine from a Coroutine
- testing coroutines, Testing Coroutines-Testing Coroutines
- why use, Why Use Coroutines?
  - example uses, Coroutines, Why Use Coroutines?
  - file-writing example, Why Use Coroutines?-Why Use Coroutines?
  - Yielded and Complete states, Why Use Coroutines?
- yielding, What Are Coroutines?
CPU
- async described, What Is Async?-What Is Async?
  - basic asynchronous code, What Is Async?
  - processes, Introduction to Processes-Introduction to Processes
  - processes simple to schedule, Introduction to Processes
- work offloaded to new thread pool, Context in Futures, Increasing Workers and Queues
Ctrl-C for graceful shutdown, Graceful Shutdowns-Graceful Shutdowns
custom asynchronous queue, Building Our Own Async Queue-Building Our Own Async Queue
- about, Building Our Own Async Queues

D

data
- sharing across threads, Processing Tasks with Local Pools
- sharing between futures, Sharing Data Between Futures-Sharing Data Between Futures
  - high-level data sharing, High-Level Data Sharing Between Futures
- streaming via a coroutine generator, Implementing a Simple Generator in Rust
- thread data accessed directly, Getting Unsafe with Thread Data
Database Internals (Petrov), Implementing State Recovery for Actors
deadlocks, Controlling Coroutines, Testing For Deadlocks
- livelocks, Testing For Deadlocks
- testing for, Testing For Deadlocks-Testing For Deadlocks
decorator pattern, The Decorator Pattern-The Decorator Pattern
- compilation feature flags, The Decorator Pattern
- inner futures, The Decorator Pattern
deleted records tombstoned, Interacting with Our Event Bus via Async Tasks
Deserialize trait, Improving HTTP Request Performance with Async
design patterns
- about async programming, Design Patterns
- circuit-breaker pattern, The Circuit-Breaker Pattern-The Circuit-Breaker Pattern
  - documentation link, The Circuit-Breaker Pattern
  - spawn_task checking OPEN, The Circuit-Breaker Pattern
- decorator pattern, The Decorator Pattern-The Decorator Pattern
  - compilation feature flags, The Decorator Pattern
  - documentation link, The Decorator Pattern
- isolated async modules, Building an Isolated Module-Building an Isolated Module
  - basic sync testing, Performing Basic Sync Testing-Performing Basic Sync Testing
  - synchronous entry points, Building an Isolated Module-Building an Isolated Module
- retry pattern, The Retry Pattern
  - documentation link, The Retry Pattern
- router pattern with actor model, Implementing the Router Pattern-Implementing the Router Pattern
  - actor supervision, Implementing State Recovery for Actors-Creating Actor Supervision
  - sender as global static, Implementing the Router Pattern
  - sender as global static caution, Implementing the Router Pattern
- state machine pattern, The State Machine Pattern-The State Machine Pattern
  - documentation link, The State Machine Pattern
- waterfall pattern, Waterfall Design Pattern
  - documentation link, Waterfall Design Pattern
  - error handling, Waterfall Design Pattern
detach method, Running Background Processes
device_query crate for user input, Getting User Input via Callbacks-Getting User Input via Callbacks
- callback guard, Getting User Input via Callbacks
documentation (see resources online)

E

errors
- anyhow library, Integrating Networking into Our Own Async Runtime
- Box<dyn Any + Send>> dynamic trait object, What Are Threads?
- catch_unwind function to catch, Building Our Own Async Queue
- design pattern error handling
  - circuit-breaker pattern, The Circuit-Breaker Pattern-The Circuit-Breaker Pattern
  - retry pattern, The Retry Pattern
  - waterfall pattern, Waterfall Design Pattern
- fault-tolerant state recovery, Implementing State Recovery for Actors
- isolated async module variant return values, Building an Isolated Module
- process exit value, Introduction to Processes, Introduction to Processes
- segmentation faults, Pinning in Futures
- unwrap, What Are Threads?
event bus, Enabling Broadcasting with an Event Bus
- backpressure from event buildup, Interacting with Our Event Bus via Async Tasks
- broadcasting via, Enabling Broadcasting with an Event Bus-Interacting with Our Event Bus via Async Tasks
  - broadcast channels versus, Enabling Broadcasting with an Event Bus
  - dependencies and imports, Enabling Broadcasting with an Event Bus
  - garbage collection for dead IDs, Interacting with Our Event Bus via Async Tasks
  - handle for event bus, Building Our Event Bus Handle-Building Our Event Bus Handle
  - interactions via async tasks, Interacting with Our Event Bus via Async Tasks
  - struct for event bus, Building Our Event Bus Struct-Building Our Event Bus Struct
event loops
- callbacks made nonblocking, Getting User Input via Callbacks
- mouse and keyboard movements, Getting User Input via Callbacks
executors, Understanding Executors and Connectors
- coroutines for, Mimicking Async Behavior with Coroutines
- hyper relying on, Integrating hyper into Our Async Runtime

F

file I/O with async, Where Can We Utilize Async?-Using Async for File I/O
- audit trail example of futures, Putting It All Together-Putting It All Together
- coroutine file-writing example, Why Use Coroutines?-Why Use Coroutines?
- file reading API dependent, Using Async for File I/O
- large file transfer via coroutines, Stacking Our Coroutines-Stacking Our Coroutines
- state recovery for actors, Implementing State Recovery for Actors-Implementing State Recovery for Actors
- streaming data via a coroutine generator, Implementing a Simple Generator in Rust
- writing transactions to files, Implementing State Recovery for Actors
Flitton, Maxwell, Who Is This Book For?
flow control via coroutines, Controlling Coroutines-Controlling Coroutines
flume, Building Our Own Async Queue
- building an async queue, Building Our Own Async Queue-Building Our Own Async Queue
  - increasing threads and queues, Increasing Workers and Queues
  - multiple queues, Passing Tasks to Different Queues
  - task stealing, Task Stealing-Task Stealing
function colors, Testing Coroutines
Future trait
- building an async queue, Building Our Own Async Queue
- Coroutine trait similarity, Why Use Coroutines?
  - coroutines implementing Future traits, Controlling Coroutines
- polls used, High-Level Data Sharing Between Futures, Controlling Coroutines
- static keyword, Building Our Own Async Queue
futures, Understanding Tasks, Futures
- background tasks, Running Background Processes
- cancel safety, Context in Futures
- Context, Context in Futures-Context in Futures
- example audit trail, Putting It All Together-Putting It All Together
- executors running to completion, Understanding Executors and Connectors
- futures-lite, Building Our Own Async Queue
  - building an async queue, Building Our Own Async Queue-Building Our Own Async Queue
- non-send futures and local thread pool, Processing Tasks with Local Pools
- passed into Tokio join macro, Understanding Tasks
- pinning, Pinning in Futures-Pinning in Futures
  - documentation link, Pinning in Futures
- polling, Futures
  - coroutines integrated with, Controlling Coroutines
  - depending on state of future, The State Machine Pattern
  - poll pending, Running Background Processes
  - polling sockets in futures, Polling Sockets in Futures-Polling Sockets in Futures
  - polling without stopping, Running Background Processes
  - Rust async for polling, Building Our Own Async Queue
  - Rust implementation of futures, High-Level Data Sharing Between Futures
- processing of, How Are Futures Processed?
- Rust implementation, High-Level Data Sharing Between Futures
- sharing data between, Sharing Data Between Futures-Sharing Data Between Futures
  - high-level data sharing, High-Level Data Sharing Between Futures
- testing, Fine-Grained Future Testing-Fine-Grained Future Testing
- timeouts, Context in Futures
- wakers, Context in Futures
- waking remotely, Waking Futures Remotely-Waking Futures Remotely
futures-lite, Building Our Own Async Queue
- building an async queue, Building Our Own Async Queue-Building Our Own Async Queue

G

garbage collection for dead event bus handles, Interacting with Our Event Bus via Async Tasks
Generator trait, Implementing a Simple Generator in Rust
- (see also Coroutine trait)
generators, Generating with Coroutines
- async generators in Rust, Generating with Coroutines
  - documentation link, Generating with Coroutines
- coroutines as, Generating with Coroutines
  - calling a coroutine from a coroutine, Calling a Coroutine from a Coroutine-Calling a Coroutine from a Coroutine
  - flow control via coroutines, Controlling Coroutines
  - implementing a generator, Implementing a Simple Generator in Rust, Controlling Coroutines
  - large file transfer example, Stacking Our Coroutines-Stacking Our Coroutines
  - stacking coroutines, Stacking Our Coroutines-Stacking Our Coroutines
  - symmetric coroutines, Calling a Coroutine from a Coroutine-Calling a Coroutine from a Coroutine
GeneratorState, Implementing a Simple Generator in Rust
- (see also Coroutine trait)
global state in async Rust, Implementing the Router Pattern
graceful shutdowns, Graceful Shutdowns-Graceful Shutdowns
- Ctrl-C overridden, Graceful Shutdowns-Graceful Shutdowns
- SIGHUP signal, Graceful Shutdowns
green threads, What Are Threads?
- documentation link, What Are Threads?

H

handle for event bus, Building Our Event Bus Handle-Building Our Event Bus Handle
- garbage collection for dead IDs, Interacting with Our Event Bus via Async Tasks
heartbeat supervisor mechanism, Implementing State Recovery for Actors-Creating Actor Supervision
heater reactive system, Building a Basic Reactive System-Getting User Input via Callbacks
- about, Building a Basic Reactive System
- display observer future built, Building Our Display Observer-Building Our Display Observer
  - running all the futures, Building Our Heater and Heat-Loss Observer
- display with user input, Getting User Input via Callbacks
- feedback simple, Defining Our Subjects
- heat-loss observer future built, Building Our Heater and Heat-Loss Observer
- heater observer future built, Building Our Heater and Heat-Loss Observer-Building Our Heater and Heat-Loss Observer
- oscillating temperature, Building Our Heater and Heat-Loss Observer
- subjects defined, Defining Our Subjects
- user input via callbacks, Getting User Input via Callbacks-Getting User Input via Callbacks
HTTP
- about, Building an HTTP Connection
- basic asynchronous code, What Is Async?
  - processes, Introduction to Processes
  - request performance, Improving HTTP Request Performance with Async-Improving HTTP Request Performance with Async
  - reqwest crate, What Is Async?
- networking integrated into runtime
  - about, Integrating Networking into Our Own Async Runtime
  - client connection and execution, Connecting and Running Our Client
  - dependencies, Integrating Networking into Our Own Async Runtime
  - HTTP connection built, Building an HTTP Connection-Building an HTTP Connection
  - hyper crate, Integrating Networking into Our Own Async Runtime
  - Tokio AsyncRead trait, Implementing the Tokio AsyncRead Trait-Implementing the Tokio AsyncRead Trait
  - Tokio AsyncWrite trait, Implementing the Tokio AsyncWrite Trait-Implementing the Tokio AsyncWrite Trait
- port 80 as standard, Building an HTTP Connection
- testing network interactions, Testing Network Interactions-Testing Network Interactions
HTTPS, Building an HTTP Connection
- port 443 as standard, Building an HTTP Connection
Huang, Jensen, Introduction to Async
hyper, Integrating Networking into Our Own Async Runtime
- client feature, Integrating Networking into Our Own Async Runtime
- mio versus, Introducing mio
- networking integrated into async runtime
  - HTTP connection built, Building an HTTP Connection-Building an HTTP Connection
  - hyper connection and execution, Connecting and Running Our Client
  - hyper integration, Integrating hyper into Our Async Runtime
  - Tokio AsyncRead trait, Implementing the Tokio AsyncRead Trait-Implementing the Tokio AsyncRead Trait
  - Tokio AsyncWrite trait, Implementing the Tokio AsyncWrite Trait-Implementing the Tokio AsyncWrite Trait
- runtime feature, Integrating Networking into Our Own Async Runtime

I

I/O operations
- file I/O with async, Where Can We Utilize Async?-Using Async for File I/O
  - audit trail example of futures, Putting It All Together-Putting It All Together
  - coroutine file-writing example, Why Use Coroutines?-Why Use Coroutines?
  - file reading API dependent, Using Async for File I/O
  - large file transfer via coroutines, Stacking Our Coroutines-Stacking Our Coroutines
- HTTP request performance, Improving HTTP Request Performance with Async-Improving HTTP Request Performance with Async
  - (see also HTTP)
- state recovery for actors, Implementing State Recovery for Actors-Implementing State Recovery for Actors
- streaming data via a coroutine generator, Implementing a Simple Generator in Rust
- writing transactions to files, Implementing State Recovery for Actors
input via device_query crate, Getting User Input via Callbacks-Getting User Input via Callbacks
interior mutability via Mutex, What Are Threads?
isolated async modules, Building an Isolated Module-Building an Isolated Module
- basic sync testing, Performing Basic Sync Testing-Performing Basic Sync Testing
- synchronous entry points, Building an Isolated Module-Building an Isolated Module

J

join macro
- creating your own, Creating Our Own Join Macro
- Tokio
  - basic asynchronous code, What Is Async?
  - futures passed into, Understanding Tasks
JoinHandle, What Are Threads?
- return result, What Are Threads?
JSON feature of reqwest enabled, Improving HTTP Request Performance with Async

K

key-value store
- commercial products for production, Implementing the Router Pattern
- router pattern for actor messages, Implementing the Router Pattern-Implementing the Router Pattern
  - actor supervision, Implementing State Recovery for Actors-Creating Actor Supervision
keyboard keypress event loop, Getting User Input via Callbacks
kill -SIGHUP <pid> for graceful shutdown, Graceful Shutdowns
Klabnik, Steve, Who Is This Book For?

L

lazy evaluation
- generators’ lazy performance, Generating with Coroutines
- isolated async modules, Building an Isolated Module
- LazyLock
  - graceful shutdown, Graceful Shutdowns
  - reactive system built, Defining Our Subjects
  - Tokio runtime built, Building a Runtime
- queues and channels as lazy, Task Stealing
  - async queue runtime configuration, Configuring Our Runtime-Configuring Our Runtime
LazyLock
- graceful shutdown, Graceful Shutdowns
- reactive system built, Defining Our Subjects
- Tokio runtime built, Building a Runtime
learning Rust books, Who Is This Book For?
livelocks, Testing For Deadlocks
local pools for processing tasks, Processing Tasks with Local Pools-Processing Tasks with Local Pools
- advantages, Processing Tasks with Local Pools
- no task stealing, Processing Tasks with Local Pools, Processing Tasks with Local Pools
lock function as blocking, Sharing Data Between Futures, Testing Coroutines
lock poisoning, What Are Threads?
log file example of futures, Putting It All Together-Putting It All Together

M

Meadows, Donella H., Building Our Heater and Heat-Loss Observer
memory
- memory leak when handle dropped, Building Our Event Bus Handle
- pinning in futures, Pinning in Futures-Pinning in Futures
  - documentation link, Pinning in Futures
- processes spawned per connection, Introduction to Processes
- Rust as memory safe, Introduction to Processes
- segmentation faults, Pinning in Futures
messages via channels over mutexes, Working with Actors Versus Mutexes
- multiproducer, single-consumer channel (mpsc), Building a Basic Actor
- oneshot::Sender in messages to actors, Building a Basic Actor
  - actor supervision, Creating Actor Supervision-Creating Actor Supervision
  - router pattern, Implementing the Router Pattern-Implementing the Router Pattern
  - sending a message, Building a Basic Actor
messages via event bus, Enabling Broadcasting with an Event Bus-Interacting with Our Event Bus via Async Tasks
milliseconds (ms), Where Can We Utilize Async?
mio crate
- about, Introducing mio
- hyper versus, Introducing mio
- polling sockets in futures, Polling Sockets in Futures-Polling Sockets in Futures
- sending data over socket, Sending Data over the Socket-Sending Data over the Socket
- UnixDatagrams, Sending Data over the Socket
mocking, Performing Basic Sync Testing
- mockall, Performing Basic Sync Testing-Performing Basic Sync Testing
- mocking async code, Mocking Async Code-Mocking Async Code
- mocking network interactions, Testing Network Interactions-Testing Network Interactions
- mockito, Testing Network Interactions-Testing Network Interactions
module isolation for async code, Building an Isolated Module-Building an Isolated Module
- basic sync testing, Performing Basic Sync Testing-Performing Basic Sync Testing
- synchronous entry points, Building an Isolated Module-Building an Isolated Module
Moore’s law dead, Introduction to Async
mouse movement event loop, Getting User Input via Callbacks
mpsc (multiproducer, single-consumer channel), Building a Basic Actor
- actors versus mutexes, Working with Actors Versus Mutexes-Working with Actors Versus Mutexes
- router pattern for actors, Implementing the Router Pattern-Implementing the Router Pattern
ms (milliseconds), Where Can We Utilize Async?
multiproducer, single-consumer channel (see mpsc)
Mutex (mutual exclusion), What Are Threads?
- actors versus mutexes, Building a Basic Actor-Working with Actors Versus Mutexes
- basic asynchronous code, What Are Threads?
- try_lock for acquiring, Sharing Data Between Futures

N

nanoseconds (ns), Where Can We Utilize Async?
networking integrated into async runtime
- about, Integrating Networking into Our Own Async Runtime
- client connection and execution, Connecting and Running Our Client
- connectors, Understanding Executors and Connectors
- dependencies, Integrating Networking into Our Own Async Runtime
- executors, Understanding Executors and Connectors
- HTTP connection built, Building an HTTP Connection-Building an HTTP Connection
- hyper into async runtime, Integrating hyper into Our Async Runtime
- mio, Introducing mio
  - hyper versus, Introducing mio
  - polling sockets in futures, Polling Sockets in Futures-Polling Sockets in Futures
  - sending data over socket, Sending Data over the Socket-Sending Data over the Socket
  - UnixDatagrams, Sending Data over the Socket
- testing network interactions, Testing Network Interactions-Testing Network Interactions
- Tokio AsyncRead trait, Implementing the Tokio AsyncRead Trait-Implementing the Tokio AsyncRead Trait
- Tokio AsyncWrite trait, Implementing the Tokio AsyncWrite Trait-Implementing the Tokio AsyncWrite Trait
Nichols, Carol, Who Is This Book For?
non-send futures and local thread pool, Processing Tasks with Local Pools
ns (nanoseconds), Where Can We Utilize Async?

O

observer pattern
- building a basic reactive system, Building a Basic Reactive System-Getting User Input via Callbacks
  - about, Building a Basic Reactive System
  - display observer future built, Building Our Display Observer-Building Our Display Observer
  - display of all futures running, Building Our Heater and Heat-Loss Observer
  - display with user input, Getting User Input via Callbacks
  - feedback simple, Defining Our Subjects
  - heat-loss observer future built, Building Our Heater and Heat-Loss Observer
  - heater observer future built, Building Our Heater and Heat-Loss Observer-Building Our Heater and Heat-Loss Observer
  - oscillating temperature, Building Our Heater and Heat-Loss Observer
  - subjects defined, Defining Our Subjects
  - user input via callbacks, Getting User Input via Callbacks-Getting User Input via Callbacks
- documentation links, Building a Basic Reactive System
oneshot::Sender in messages to actors, Building a Basic Actor
- sending a message, Building a Basic Actor
oscillations in output, Building Our Heater and Heat-Loss Observer
- temperature in reactive system, Building Our Heater and Heat-Loss Observer
ownership
- AsyncRead execution, Implementing the Tokio AsyncRead Trait
- shared data, What Are Threads?
- variables in static lifetime, Building Our Own Async Queue

P

parked thread, What Are Threads?
- task stealing, Task Stealing
- Tokio quickly parking threads, Building a Runtime
pausing execution then resuming (see coroutines)
Petrov, Alex, Implementing State Recovery for Actors
PID (process ID), Introduction to Processes
- killing a PID, Introduction to Processes
pinning in futures, Pinning in Futures-Pinning in Futures
- documentation link, Pinning in Futures
polling futures, Futures
- coroutines integrated with, Controlling Coroutines
- depending on state of future, The State Machine Pattern
- poll pending, Running Background Processes
- polling sockets in futures, Polling Sockets in Futures-Polling Sockets in Futures
- polling without stopping, Running Background Processes
- Rust async for polling, Building Our Own Async Queue
- Rust implementation, High-Level Data Sharing Between Futures
port numbers
- 443 for HTTPS, Building an HTTP Connection
- 80 for HTTP, Building an HTTP Connection
PostgreSQL processes, Introduction to Processes, Introduction to Processes
- connection is a process, Introduction to Processes
procedural macros
- documentation link, Configuring Our Runtime
- Tokio runtime setup, Configuring Our Runtime
process ID (see PID)
processes, Introduction to Processes-Introduction to Processes
- async described, What Is Async?-What Is Async?
  - async Rust, Introduction to Processes
  - basic asynchronous code, Introduction to Processes, Introduction to Processes
  - drawbacks, Introduction to Processes
  - scheduling simple, Introduction to Processes
- definition, Introduction to Processes
- exit value and errors, Introduction to Processes, Introduction to Processes
- PID, Introduction to Processes
  - killing a PID, Introduction to Processes
- spawning per connection, Introduction to Processes, Introduction to Processes
- threads versus, Introduction to Processes, What Are Threads?

Q

question mark (?) operator for error handling, Waterfall Design Pattern
queues (see async queues)

R

race conditions tested for, Testing for Race Conditions-Testing for Race Conditions
- about race conditions, Testing for Race Conditions
reactive programming
- about, Reactive Programming
- broadcasting via event bus, Enabling Broadcasting with an Event Bus-Interacting with Our Event Bus via Async Tasks
  - broadcast channels versus, Enabling Broadcasting with an Event Bus
  - dependencies and imports, Enabling Broadcasting with an Event Bus
  - event bus interactions via tasks, Interacting with Our Event Bus via Async Tasks
  - garbage collection for dead IDs, Interacting with Our Event Bus via Async Tasks
  - handle for event bus, Building Our Event Bus Handle-Building Our Event Bus Handle
  - struct for event bus, Building Our Event Bus Struct-Building Our Event Bus Struct
- building a basic reactive system, Building a Basic Reactive System-Getting User Input via Callbacks
  - about, Building a Basic Reactive System
  - display observer future built, Building Our Display Observer-Building Our Display Observer
  - display of all futures running, Building Our Heater and Heat-Loss Observer
  - display with user input, Getting User Input via Callbacks
  - feedback simple, Defining Our Subjects
  - heat-loss observer future built, Building Our Heater and Heat-Loss Observer
  - heater observer future built, Building Our Heater and Heat-Loss Observer-Building Our Heater and Heat-Loss Observer
  - oscillating temperature, Building Our Heater and Heat-Loss Observer
  - subjects defined, Defining Our Subjects
  - user input via callbacks, Getting User Input via Callbacks-Getting User Input via Callbacks
real-time responsiveness (see reactive programming)
Relaxed ordering, What Are Threads?
reqwest package
- basic asynchronous code, What Is Async?
  - API calls, Improving HTTP Request Performance with Async
  - processes, Introduction to Processes
- JSON feature enabled, Improving HTTP Request Performance with Async
- testing network interactions, Testing Network Interactions-Testing Network Interactions
resources for learning Rust, Who Is This Book For?
resources online
- actor model, The Actor Model
- async closure documentation, Building Our Own Async Queue
- AsyncRead trait documentation, Implementing the Tokio AsyncRead Trait
- Atomic Bool, What Are Threads?
- atomics documentation, Reactive Programming
- book web page, How to Contact Us
- design pattern documentation
  - circuit-breaker, The Circuit-Breaker Pattern
  - decorator, The Decorator Pattern
  - retry, The Retry Pattern
  - state machine, The State Machine Pattern
  - waterfall, Waterfall Design Pattern
- green threads documentation, What Are Threads?
- observer pattern documentation, Building a Basic Reactive System
- pinning and unpinning, Pinning in Futures
- procedural macro documentation, Configuring Our Runtime
- Rust by Example, Who Is This Book For?
- Rust RFC Book
  - async and await, Understanding Tasks
  - async generators, Generating with Coroutines
- state machines, The State Machine Pattern
retry pattern, The Retry Pattern
- documentation link, The Retry Pattern
router pattern with actor model, Implementing the Router Pattern-Implementing the Router Pattern
- actor supervision, Implementing State Recovery for Actors-Creating Actor Supervision
- sender as global static, Implementing the Router Pattern
- sender as global static caution, Implementing the Router Pattern
Runnable handle, Building Our Own Async Queue
runtime
- building a Tokio runtime, Building a Runtime-Building a Runtime
  - (see also Tokio runtime)
  - used for actors, The Actor Model
  - used in local pools code, Processing Tasks with Local Pools
- configured for async queue, Configuring Our Runtime-Configuring Our Runtime
  - runtime rebuilt, Building a Runtime
- coroutine struct for interaction with, Controlling Coroutines
- networking integrated into (see networking integrated into async runtime)
Rust
- async generators, Generating with Coroutines
  - Rust RFC Book for information, Generating with Coroutines
- async Rust (see async Rust)
- futures implementation, High-Level Data Sharing Between Futures
- green threads not implemented, What Are Threads?
- learning resources, Who Is This Book For?
- RFC Book link
  - async and await, Understanding Tasks
  - async generators, Generating with Coroutines
Rust by Example (Rust online community), Who Is This Book For?
The Rust Programming Language (Klabnik and Nichols), Who Is This Book For?
Rust Web Programming (Flitton), Who Is This Book For?

S

schedulers
- green threads, What Are Threads?
  - documentation link, What Are Threads?
- process scheduling simple, Introduction to Processes
- threads independently managed, What Are Threads?
segmentation faults, Pinning in Futures
Send trait
- building an async queue, Building Our Own Async Queue
  - static keyword, Building Our Own Async Queue
- JoinHandle implementing, What Are Threads?
server built (see async server built)
SIGHUP signal for graceful shutdown, Graceful Shutdowns
sleep function
- file I/O, Using Async for File I/O, Using Async for File I/O
- nonblocking sleep functions
  - coroutines mimicking, Mimicking Async Behavior with Coroutines-Mimicking Async Behavior with Coroutines
  - explained, Building Our Own Async Queue
  - Tokio sleep function, Using Async for File I/O, Understanding Tasks, Processing Tasks with Local Pools
  - Tokio sleep function allowing async, Understanding Tasks, Building Our Own Async Queue, Processing Tasks with Local Pools
  - when blocking better, Building Our Own Async Queue
- response latency and, Task Stealing
- Tokio
  - await keyword, Understanding Tasks, Building Our Own Async Queue
  - nonblocking, Using Async for File I/O, Understanding Tasks, Processing Tasks with Local Pools
  - nonblocking allowing async, Understanding Tasks, Building Our Own Async Queue, Processing Tasks with Local Pools
smol, Integrating Networking into Our Own Async Runtime
sockets
- HTTP connection built, Building an HTTP Connection-Building an HTTP Connection
- mio, Introducing mio
  - hyper versus mio, Introducing mio
  - polling sockets in futures, Polling Sockets in Futures-Polling Sockets in Futures
  - sending data over socket, Sending Data over the Socket-Sending Data over the Socket
  - UnixDatagrams, Sending Data over the Socket
- tokens identifying, Polling Sockets in Futures
spawn_blocking function (Tokio), Processing Tasks with Local Pools
spawn_task function, Building Our Own Async Queue
- calling custom Tokio runtime, Building a Runtime
- circuit-breaker pattern, The Circuit-Breaker Pattern
- refactored, Refactoring Our spawn_task Function-Refactoring Our spawn_task Function
- running background processes, Running Background Processes
- runtime configuration, Configuring Our Runtime
  - custom executor for, Integrating hyper into Our Async Runtime
- socket continually polled, Polling Sockets in Futures
state
- actors, The Actor Model, Working with Actors Versus Mutexes
  - fault-tolerant state recovery, Implementing State Recovery for Actors
  - state recovery for actors, Implementing State Recovery for Actors-Implementing State Recovery for Actors
- coroutines
  - storing and resuming state, What Are Coroutines?
  - Yielded and Complete states, Why Use Coroutines?
- graceful shutdowns, Graceful Shutdowns-Graceful Shutdowns
- sharing data across threads, Processing Tasks with Local Pools
- state isolation of processes spawned per connection, Introduction to Processes
- state machine design pattern, The State Machine Pattern-The State Machine Pattern
  - documentation link, The State Machine Pattern
- state machine documentation link, The State Machine Pattern
- state of future from other threads, Waking Futures Remotely
state machine documentation link, The State Machine Pattern
state machine pattern, The State Machine Pattern-The State Machine Pattern
- documentation link, The State Machine Pattern
streaming data via a coroutine generator, Implementing a Simple Generator in Rust
subroutines compared to coroutines, What Are Coroutines?
subscribers to event bus messaging, Enabling Broadcasting with an Event Bus-Interacting with Our Event Bus via Async Tasks
supply chain oscillations, Building Our Heater and Heat-Loss Observer
suspending execution then resuming (see coroutines)
symmetric coroutines, Calling a Coroutine from a Coroutine-Calling a Coroutine from a Coroutine
Sync trait implemented by JoinHandle, What Are Threads?

T

TAP (task-based asynchronous pattern), Understanding Tasks-Understanding Tasks
task stealing, Task Stealing-Task Stealing
- local pools can’t, Processing Tasks with Local Pools, Processing Tasks with Local Pools
task-based asynchronous pattern (TAP), Understanding Tasks-Understanding Tasks
task-spawning function (see spawn_task function)
tasks, Understanding Tasks-Understanding Tasks
- background processes, Running Background Processes
- coroutines compared to async tasks, Why Use Coroutines?
  - flow control via coroutines, Controlling Coroutines-Controlling Coroutines
- deadlocks, Controlling Coroutines, Testing For Deadlocks
- definition, Understanding Tasks
- event bus interactions, Interacting with Our Event Bus via Async Tasks
- futures, Understanding Tasks
  - cancel safety, Context in Futures
  - Context, Context in Futures-Context in Futures
  - example audit trail, Putting It All Together-Putting It All Together
  - high-level data sharing between, High-Level Data Sharing Between Futures
  - passed into join macro, Understanding Tasks
  - pinning, Pinning in Futures-Pinning in Futures
  - pinning documentation link, Pinning in Futures
  - poll pending, Running Background Processes
  - polling, Futures, High-Level Data Sharing Between Futures
  - polling via Rust async, Building Our Own Async Queue
  - polling without stopping, Running Background Processes
  - processing of, How Are Futures Processed?
  - sharing data between, Sharing Data Between Futures-Sharing Data Between Futures
  - static keyword, Building Our Own Async Queue
  - timeouts, Context in Futures
  - waking remotely, Waking Futures Remotely-Waking Futures Remotely
- laziness of queues and channels, Task Stealing
  - runtime configured for, Configuring Our Runtime-Configuring Our Runtime
- multiple queues, Passing Tasks to Different Queues-Passing Tasks to Different Queues
  - task stealing, Task Stealing-Task Stealing
  - Tokio for task distribution, Passing Tasks to Different Queues
- Runnable handle, Building Our Own Async Queue
- spawn_task function, Building Our Own Async Queue
  - refactored, Refactoring Our spawn_task Function-Refactoring Our spawn_task Function
- wakers, Context in Futures
  - Context, Context in Futures-Context in Futures
TCP
- about, Building an HTTP Connection
- client connection and execution, Connecting and Running Our Client
- HTTP connection built, Building an HTTP Connection-Building an HTTP Connection
- mio, Introducing mio
  - hyper versus, Introducing mio
  - polling sockets in futures, Polling Sockets in Futures-Polling Sockets in Futures
  - sending data over socket, Sending Data over the Socket-Sending Data over the Socket
  - UnixDatagrams, Sending Data over the Socket
- Tokio AsyncRead trait, Implementing the Tokio AsyncRead Trait-Implementing the Tokio AsyncRead Trait
- Tokio AsyncWrite trait, Implementing the Tokio AsyncWrite Trait-Implementing the Tokio AsyncWrite Trait
TCP server built
- about, Building an Async Server with No Dependencies
- basics set up, Setting Up the Basics-Setting Up the Basics
  - Data struct public, Setting Up the Basics
  - four workspaces, Setting Up the Basics
  - serialize and deserialize functions, Setting Up the Basics
- client built, Building Our Async Client
- receiver built, Building Our Receiver
- runtime components, Building Our std Async Runtime-Building Our Sleep
  - executor built, Building Our Executor-Building Our Executor
  - executor run, Running Our Executor-Running Our Executor
  - waker, Building Our Waker-Building Our Waker
- sender built, Building Our Sender
- server built, Building Our Server
  - accepting requests, Accepting Requests-Accepting Requests
  - handling requests, Handling Requests
- sleep built, Building Our Sleep
temperature reactive system, Building a Basic Reactive System-Getting User Input via Callbacks
testing
- about, Testing
- actors, Building a Basic Actor
  - isolation simplifying testing, The Actor Model
- arrange, act, assert, Performing Basic Sync Testing
- basic sync testing, Performing Basic Sync Testing-Performing Basic Sync Testing
- channel capacity, Testing Channel Capacity
- coroutines tested easily, Controlling Coroutines
  - simple generator implementation, Controlling Coroutines
  - testing coroutines, Testing Coroutines-Testing Coroutines
- for deadlocks, Testing For Deadlocks-Testing For Deadlocks
- fine-grained future testing, Fine-Grained Future Testing-Fine-Grained Future Testing
- fixtures as decorator pattern, The Decorator Pattern
- global state in async Rust, Implementing the Router Pattern
- mocking, Performing Basic Sync Testing
  - mockall, Performing Basic Sync Testing-Performing Basic Sync Testing
  - mocking async code, Mocking Async Code-Mocking Async Code
  - mocking network interactions, Testing Network Interactions-Testing Network Interactions
  - mockito, Testing Network Interactions-Testing Network Interactions
- race conditions, Testing for Race Conditions-Testing for Race Conditions
Thinking in Systems (Meadows), Building Our Heater and Heat-Loss Observer
thread pools
- CPU-intensive work offloaded, Context in Futures, Increasing Workers and Queues
- local pools for processing tasks, Processing Tasks with Local Pools-Processing Tasks with Local Pools
  - advantages, Processing Tasks with Local Pools
  - no task stealing, Processing Tasks with Local Pools, Processing Tasks with Local Pools
- Rust web servers, Introduction to Processes
threads, What Are Threads?-What Are Threads?
- async described, What Is Async?-What Is Async?
  - basic asynchronous code, What Are Threads?, What Are Threads?
  - Condvar for interaction, What Are Threads?
  - JoinHandle, What Are Threads?
  - JoinHandle return result, What Are Threads?
  - multiple Condvars, What Are Threads?
  - parked while waiting, What Are Threads?, Task Stealing
- coroutines compared, What Are Coroutines?
  - coroutines sent over threads, Controlling Coroutines
- definition, What Are Threads?
- green threads, What Are Threads?
  - documentation link, What Are Threads?
- local pool thread affinity, Processing Tasks with Local Pools
- processes versus, Introduction to Processes, What Are Threads?
- thread data accessed directly, Getting Unsafe with Thread Data
timeouts, Context in Futures
- future cancel safety, Context in Futures
timing the running of scripts, Introduction to Processes
Tokio runtime
- AsyncRead trait, Implementing the Tokio AsyncRead Trait-Implementing the Tokio AsyncRead Trait
- AsyncWrite trait, Implementing the Tokio AsyncWrite Trait-Implementing the Tokio AsyncWrite Trait
- basic asynchronous code, What Is Async?
  - #[tokio::main] macro, Building a Runtime
  - file I/O, Using Async for File I/O-Using Async for File I/O
  - HTTP request performance, Improving HTTP Request Performance with Async-Improving HTTP Request Performance with Async
  - processes, Introduction to Processes, Introduction to Processes
- broadcast channels, Enabling Broadcasting with an Event Bus
- building a runtime, Building a Runtime-Building a Runtime
  - #[tokio::main] macro, Building a Runtime
  - calling function signature, Building a Runtime
  - calling the runtime, Building a Runtime
  - configuration options, Building a Runtime-Building a Runtime
  - LazyLock, Building a Runtime
  - used for actors, The Actor Model
  - used in local pools code, Processing Tasks with Local Pools
- graceful shutdowns, Graceful Shutdowns-Graceful Shutdowns
  - Ctrl-C overridden, Graceful Shutdowns-Graceful Shutdowns
  - SIGHUP signal, Graceful Shutdowns
- green threads implemented, What Are Threads?
- join macro
  - basic asynchronous code, What Is Async?
  - futures passed into, Understanding Tasks
- local pools for processing tasks, Processing Tasks with Local Pools-Processing Tasks with Local Pools
- mio crate as foundation, Introducing mio
- networking (see networking integrated into async runtime)
- parking threads quickly, Building a Runtime
- reactive heater system, Defining Our Subjects
- runtime struct, Configuring Our Runtime
- sleep function
  - await keyword, Understanding Tasks, Building Our Own Async Queue, Processing Tasks with Local Pools
  - nonblocking, Using Async for File I/O, Understanding Tasks, Processing Tasks with Local Pools
  - nonblocking allowing async, Understanding Tasks, Building Our Own Async Queue, Processing Tasks with Local Pools
- spawn_blocking function, Processing Tasks with Local Pools
- tasks, Understanding Tasks-Understanding Tasks
  - distribution to different queues, Passing Tasks to Different Queues
  - futures, Understanding Tasks
    - (see also futures)
- test macro, Testing For Deadlocks
  - fine-grained future testing, Fine-Grained Future Testing-Fine-Grained Future Testing
- timeouts, Context in Futures
- UnsafeCell for thread data, Getting Unsafe with Thread Data
tombstoning deleted records, Interacting with Our Event Bus via Async Tasks
traits
- AsyncRead trait, Implementing the Tokio AsyncRead Trait-Implementing the Tokio AsyncRead Trait
  - documentation link, Implementing the Tokio AsyncRead Trait
- Box<dyn Any + Send>> dynamic trait object, What Are Threads?
- Clone trait
  - event bus struct, Building Our Event Bus Struct-Building Our Event Bus Struct
  - JoinHandle not implementing, What Are Threads?
- Coroutine trait
  - coroutines implementing Future traits, Controlling Coroutines
  - formerly Generator trait and GeneratorState, Implementing a Simple Generator in Rust
  - Future trait similarity, Why Use Coroutines?
  - resume as only required method, Implementing a Simple Generator in Rust
- Deserialize trait, Improving HTTP Request Performance with Async
- future trait
  - polls used, High-Level Data Sharing Between Futures
- Future trait
  - building an async queue, Building Our Own Async Queue
  - Coroutine trait similarity, Why Use Coroutines?
  - coroutines implementing Future traits, Controlling Coroutines
  - polls used, Controlling Coroutines
  - static keyword, Building Our Own Async Queue
- JoinHandle
  - Clone trait not implemented, What Are Threads?
  - Send and Sync traits implemented, What Are Threads?
- Send trait
  - building an async queue, Building Our Own Async Queue
  - JoinHandle implementing, What Are Threads?
  - static keyword, Building Our Own Async Queue
- SymmetricCoroutine trait created, Calling a Coroutine from a Coroutine
- Sync trait implemented by JoinHandle, What Are Threads?
- Unpin trait, Pinning in Futures
  - documentation link, Pinning in Futures
transactions written to files, Implementing State Recovery for Actors
try_lock
- acquiring Mutex, Sharing Data Between Futures
- nonblocking, Sharing Data Between Futures, Testing Coroutines

U

UnixDatagrams via mio, Sending Data over the Socket
Unpin trait, Pinning in Futures
- documentation link, Pinning in Futures
UnsafeCell (Tokio) for thread data, Getting Unsafe with Thread Data
unwrap, What Are Threads?
user input via device_query crate, Getting User Input via Callbacks-Getting User Input via Callbacks

V

variables
- LazyLock for lazy initialization, Defining Our Subjects
- ownership in static lifetime, Building Our Own Async Queue

W

wakers, Context in Futures
- waking futures remotely, Waking Futures Remotely-Waking Futures Remotely
waterfall pattern, Waterfall Design Pattern
- documentation link, Waterfall Design Pattern
- error handling, Waterfall Design Pattern

Y

yielding by a coroutine, What Are Coroutines?