Struct ParallelReadPolicy 

pub struct ParallelReadPolicy;

Parallel read policy: Query both L1 and L2 in parallel, prefer freshest data (by TTL).

This strategy provides:

• Freshness guarantee (returns data with longest remaining TTL)
• Cache warming (keeps both layers hot)
• Observability into both layer performance
• Natural cache coherency (prefers recently updated data)

Behavior

1. Start both read_l1(key) and read_l2(key) in parallel
2. Wait for both to complete
3. Compare TTLs and prefer the response with longest remaining TTL
4. Fall back to any available value if one layer misses/errors

TTL Comparison Rules

When both L1 and L2 have data:

• Compare remaining TTLs using CacheValue::ttl()
• Prefer response with longer TTL (fresher data)
• If one has no expiry (None TTL), prefer it (infinite freshness)
• If TTLs are equal, prefer L1 (tie-breaker)
• If both have no expiry, prefer L1 (tie-breaker)

Tradeoffs

• Pros: Freshness guarantee, handles L1/L2 consistency naturally, production-viable
• Cons: 2x backend load, latency limited by slower backend

Use Cases

• Production systems where data freshness is critical
• Multi-region setups where L2 may get updated first
• Cache warming while ensuring freshest data
• Validating L1/L2 consistency
• Monitoring both layer health

Note

Unlike RaceReadPolicy, this policy always waits for both backends to complete, making it slower but providing freshness guarantees and better observability.

Implementations

impl ParallelReadPolicy

pub fn new() -> Self

Create a new parallel read policy.

Trait Implementations

impl Clone for ParallelReadPolicy

fn clone(&self) -> ParallelReadPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CompositionReadPolicy for ParallelReadPolicy

fn execute_with<'life0, 'life1, 'async_trait, T, E, F1, F2, Fut1, Fut2, O>( &'life0 self, key: CacheKey, read_l1: F1, read_l2: F2, _offload: &'life1 O, ) -> Pin<Box<dyn Future<Output = Result<ReadResult<T>, E>> + Send + 'async_trait>>

where T: Send + 'static + 'async_trait, E: Send + Debug + 'static + 'async_trait, F1: FnOnce(CacheKey) -> Fut1 + Send + 'async_trait, F2: FnOnce(CacheKey) -> Fut2 + Send + 'async_trait, Fut1: Future<Output = (Result<Option<CacheValue<T>>, E>, BoxContext)> + Send + 'static + 'async_trait, Fut2: Future<Output = (Result<Option<CacheValue<T>>, E>, BoxContext)> + Send + 'static + 'async_trait, O: Offload<'static> + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a read operation with custom read closures for each layer.

impl Debug for ParallelReadPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ParallelReadPolicy

fn default() -> ParallelReadPolicy

Returns the “default value” for a type.

impl Copy for ParallelReadPolicy