Limits of st.cache_data isolation in multi-user environments

Direct Answer

Developers can reliably ensure user-specific data isolation in @st.cache_data by explicitly including session identifiers as function parameters. This creates per-user cache partitions through hash-based key differentiation.

Confirmed Mechanism

The @st.cache_data decorator maintains a global in-memory cache shared across all server sessions. Cache keys are computed from hashed input arguments with no native support for user-scoped partitioning. Thread-safety is handled internally, but concurrent access to identical keys returns the same cached result regardless of session context.

Isolation Strategy

1. Explicit Session Parameters: Include session_id or user_id as the first parameter of cached functions
2. Retrieve Session State: Use st.session_state.session_id or pass through authentication context
3. Function Signature: Structure cached functions to accept session identifiers before other parameters

Performance Implications

Including unique session identifiers as cache keys creates per-user cache partitions, which:

• Increases memory usage proportionally to active concurrent users
• Prevents cache hits across different users for identical computational results
• Maintains performance benefits within individual sessions
• Requires monitoring st.cache_data.max_entries to prevent unbounded growth

Memory Management

The cache has no built-in TTL or per-session eviction. Stale data persists until manual cache clearing. In high-concurrency environments, consider:

• Setting explicit max_entries limits
• Using smaller result objects for frequently-cached computations
• Implementing application-level cache invalidation strategies

Verification Steps

1. Test with multiple sessions passing different session_id values to the same cached function
2. Monitor memory usage using st.cache_data.get_semaphore()._cache to inspect cache contents
3. Profile cache hit rates using st.runtime.exists() to measure performance impact

Important Considerations

Thread Safety: While Streamlit handles concurrent cache access internally, race conditions can occur if session state changes during cache computation. Ensure cached functions are pure or handle state changes gracefully.

Cache Invalidation: The framework provides no mechanism to clear cache entries per-user. All invalidation requires st.cache_data.clear(), which affects all sessions.

Recommended Pattern

@st.cache_data

def expensive_computation(session_id: str, param: int) -> dict:
    # Session-specific computation
    return result

# Usage
result = expensive_computation(st.session_state.session_id, user_input)

Verification Gap

This analysis assumes Streamlit's cache implementation remains unchanged from documented behavior. The exact internal cache structure and eviction policies would require runtime verification in your specific Streamlit version.