use dashmap::DashMap;
use std::sync::Arc;
use std::thread;
 
fn main() {
    // DashMap divides data across multiple shards
    // Each shard has its own RwLock
    let map = DashMap::new();
    
    // By default, number of shards = number of CPUs
    println!("Shard count: {}", map.shards().len());
    
    // Each key is assigned to a shard via hash
    map.insert("key1", "value1");
    map.insert("key2", "value2");
    map.insert("key3", "value3");
    
    // Different keys may be in different shards
    // Iteration visits shards sequentially, locking each
    
    for entry in map.iter() {
        println!("{}: {}", entry.key(), entry.value());
    }
}

use dashmap::DashMap;
use std::sync::Arc;
use std::thread;
 
fn main() {
    let map = Arc::new(DashMap::new());
    
    // Populate
    for i in 0..10 {
        map.insert(i, format!("value{}", i));
    }
    
    // Iteration locks shards one at a time
    for entry in map.iter() {
        let shard_idx = map.determine_map(entry.key());
        println!("Key {} is in shard {}", entry.key(), shard_idx);
        // Read lock held only for THIS shard
        // Other shards can be modified NOW
    }
    
    // This is NOT a snapshot:
    // - Shard 1 locked -> iterate -> release
    // - Shard 2 locked -> iterate -> release
    // - Modifications between shard visits are visible!
}

use dashmap::DashMap;
use std::sync::Arc;
use std::thread;
 
fn main() {
    let map = Arc::new(DashMap::new());
    
    for i in 0..100 {
        map.insert(i, i);
    }
    
    let map_clone = Arc::clone(&map);
    let writer = thread::spawn(move || {
        // Concurrent modification during iteration
        for i in 0..100 {
            map_clone.insert(i, i * 10);  // Modify existing entries
            map_clone.insert(i + 100, i + 100);  // Add new entries
            std::thread::yield_now();
        }
    });
    
    // Iterator sees SOME modifications
    let mut seen = Vec::new();
    for entry in map.iter() {
        seen.push(*entry.key());
        // May see original value OR modified value
        // May see entries added after iteration started
        // May not see entries removed during iteration
    }
    
    writer.join().unwrap();
    
    println!("Saw {} entries during iteration", seen.len());
    // NOT a consistent snapshot - concurrent modifications visible
}

use dashmap::DashMap;
 
fn main() {
    let map = DashMap::new();
    map.insert("a", 1);
    map.insert("b", 2);
    map.insert("c", 3);
    
    // Guaranteed: Each entry will be seen at most once
    // Guaranteed: Entry values are consistent at moment of reading
    // Guaranteed: No entries will be partially read
    
    // NOT guaranteed: All entries from a single point-in-time
    // NOT guaranteed: Modifications blocked during entire iteration
    // NOT guaranteed: Same entries as at iteration start
    
    let entries: Vec<_> = map.iter().map(|e| (e.key().clone(), *e.value())).collect();
    
    // Entries were read at different times
    // Different shards may have been modified between reads
}

use dashmap::DashMap;
use std::sync::Arc;
use std::thread;
use std::time::Duration;
 
fn main() {
    let map = Arc::new(DashMap::new());
    
    // Add entries to different shards
    for i in 0..1000 {
        map.insert(i, format!("initial{}", i));
    }
    
    let map_clone = Arc::clone(&map);
    
    // Start iteration
    let iter_thread = thread::spawn(move || {
        let mut count = 0;
        for entry in map_clone.iter() {
            count += 1;
            // During iteration, other thread may:
            // 1. Modify entries we haven't visited yet
            // 2. Add entries to shards we haven't visited
            // 3. Remove entries from shards we haven't visited
            
            if count % 100 == 0 {
                println!("Iteration progress: {} entries", count);
            }
        }
        count
    });
    
    // Concurrent modification
    let map_clone2 = Arc::clone(&map);
    let writer_thread = thread::spawn(move || {
        for i in 0..1000 {
            map_clone2.insert(i, format!("modified{}", i));
        }
    });
    
    let count = iter_thread.join().unwrap();
    writer_thread.join().unwrap();
    
    println!("Iterated {} entries", count);
    // The count may not match initial state
    // Values seen may be initial OR modified
}

use dashmap::DashMap;
use std::collections::HashMap;
 
fn main() {
    let map = DashMap::new();
    for i in 0..10 {
        map.insert(i, format!("value{}", i));
    }
    
    // Approach 1: Collect to a snapshot first
    let snapshot: HashMap<_, _> = map.iter()
        .map(|entry| (entry.key().clone(), entry.value().clone()))
        .collect();
    // Note: This still has the weakly-consistent issue during collection
    // But it's a smaller window
    
    // Approach 2: Use a separate lock for iteration
    // (Not available in DashMap - would need different data structure)
    
    // Approach 3: Use parking_lot::RwLock<HashMap> for true snapshots
    // But loses fine-grained concurrency
    
    // Approach 4: Copy the entire map
    let map2 = map.clone();
    // Now iterate the copy
    for entry in map2.iter() {
        println!("{}: {}", entry.key(), entry.value());
    }
    
    // Approach 5: For read-mostly workloads, use DashMap's read locks
    // Each shard read-locked during its iteration
    // Provides per-shard consistency
    
    println!("Snapshot collected: {} entries", snapshot.len());
}

use dashmap::DashMap;
use std::sync::Arc;
use std::thread;
 
fn main() {
    let map = Arc::new(DashMap::new());
    
    // Populate with keys that hash to different shards
    for i in 0..100 {
        map.insert(format!("key{}", i), i);
    }
    
    let map_clone = Arc::clone(&map);
    let handle = thread::spawn(move || {
        // This thread modifies shard 0 while we iterate
        // Keys that hash to shard 0 might see modifications
        
        // Determine which keys are in which shards
        for i in 0..10 {
            let key = format!("key{}", i);
            let shard = map_clone.determine_map(&key);
            println!("Key '{}' in shard {}", key, shard);
        }
    });
    
    // During iteration:
    // - Shard 0: Read-locked, consistent within this shard
    // - Shard 1: Not yet locked, modifications possible
    // - Shard N: Not yet locked, modifications possible
    
    handle.join().unwrap();
}

use dashmap::DashMap;
 
fn main() {
    let map = DashMap::new();
    map.insert("a", 1);
    map.insert("b", 2);
    
    // iter() returns an iterator that yields references
    let iter = map.iter();
    
    // Each entry is a Ref<'_, K, V>
    // The Ref holds a read guard on the shard
    for entry in iter {
        // entry is a Ref<K, V>
        // entry.key() -> &K
        // entry.value() -> &V
        
        // While `entry` is alive, its shard is read-locked
        // The guard is released when entry is dropped (next iteration)
        
        println!("{}: {}", entry.key(), entry.value());
        
        // Try to modify - this would deadlock if same shard!
        // map.insert("a", 3);  // Could block if same shard
    }
    
    // After iteration, all shard guards released
}

use dashmap::DashMap;
use std::sync::{Arc, RwLock};
use std::collections::HashMap;
 
fn main() {
    // DashMap: High concurrency, weakly consistent iteration
    let dashmap = DashMap::new();
    
    // RwLock<HashMap>: True snapshot possible, lower concurrency
    let locked_map = Arc::new(RwLock::new(HashMap::new()));
    
    // DashMap iteration
    // - Multiple readers can iterate simultaneously
    // - Writers only blocked per-shard during traversal
    // - Weakly consistent: may see concurrent modifications
    
    // RwLock<HashMap> iteration
    // - Requires read lock for entire duration
    // - All writers blocked during iteration
    // - Truly consistent: snapshot at lock acquisition
    
    // Trade-off:
    // - DashMap: Better concurrency, weaker consistency
    // - RwLock: Stronger consistency, worse concurrency
    
    // For true snapshots with DashMap:
    let dashmap = DashMap::new();
    dashmap.insert("a", 1);
    dashmap.insert("b", 2);
    
    // Must stop all writers first, then iterate
    // Or accept weakly consistent results
}

use dashmap::DashMap;
use std::sync::Arc;
use std::thread;
 
fn main() {
    let map = Arc::new(DashMap::new());
    
    // Pattern 1: Iteration for statistics (weakly consistent OK)
    let map_stats = Arc::clone(&map);
    let stats_handle = thread::spawn(move || {
        // Weakly consistent is fine for approximate statistics
        let sum: i32 = map_stats.iter().map(|e| *e.value()).sum();
        println!("Sum: {}", sum);  // Approximate, but useful
    });
    
    // Pattern 2: Iteration for validation (need snapshot)
    let map_validate = Arc::clone(&map);
    let validate_handle = thread::spawn(move || {
        // For validation, collect first to reduce race window
        let entries: Vec<_> = map_validate.iter()
            .map(|e| (e.key().clone(), *e.value()))
            .collect();
        
        // Validate on collected data
        // Still not perfect, but smaller race window
        let valid = entries.iter().all(|(_, v)| *v >= 0);
        println!("All valid: {}", valid);
    });
    
    // Pattern 3: Iteration with modification (avoid)
    // Problematic: modification during iteration can cause issues
    let map_modify = Arc::clone(&map);
    let modify_handle = thread::spawn(move || {
        for i in 0..100 {
            map_modify.insert(i, i);
        }
    });
    
    stats_handle.join().unwrap();
    validate_handle.join().unwrap();
    modify_handle.join().unwrap();
}

use dashmap::DashMap;
use std::sync::Arc;
use std::thread;
 
fn main() {
    let map = Arc::new(DashMap::new());
    
    // Insert values with proper synchronization
    for i in 0..10 {
        map.insert(i, format!("value{}", i));
    }
    
    let map_clone = Arc::clone(&map);
    let handle = thread::spawn(move || {
        // Modification thread
        for i in 0..10 {
            map_clone.insert(i, format!("modified{}", i));
        }
    });
    
    // Iteration thread
    // What memory visibility guarantees exist?
    
    for entry in map.iter() {
        // Within each shard:
        // - Read lock provides happens-before relationship
        // - Values written before lock acquisition are visible
        // - Values written after lock acquisition may or may not be visible
        
        // Between shards:
        // - No synchronization guarantee
        // - Different shards may have different views
    }
    
    handle.join().unwrap();
}

use dashmap::DashMap;
 
fn main() {
    let map = DashMap::new();
    
    // Pitfall 1: Assuming atomic snapshot
    for i in 0..100 {
        map.insert(i, i);
    }
    
    // This is NOT atomic:
    let entries: Vec<_> = map.iter().collect();
    // Concurrent modification could have occurred
    
    // Pitfall 2: Long-running iteration
    // If iteration is slow, the map state at end differs from start
    // More time = more divergence from initial state
    
    // Pitfall 3: Modifying during own iteration
    for entry in map.iter() {
        // This could deadlock if inserting to same shard!
        // map.insert(entry.key().clone(), entry.value() + 1);
    }
    
    // Pitfall 4: Assuming iteration sees all entries
    // Entries removed during iteration won't be seen
    // Entries added might or might not be seen
    
    // Safe pattern: Read-only access during iteration
    let sum: i32 = map.iter().map(|e| *e.value()).sum();
    println!("Sum: {}", sum);
}

use dashmap::DashMap;
use std::sync::Arc;
use std::thread;
 
fn main() {
    let map = Arc::new(DashMap::new());
    
    // Use case 1: Monitoring and metrics
    // Approximate counts are acceptable
    let map_metrics = Arc::clone(&map);
    thread::spawn(move || {
        loop {
            let count = map_metrics.iter().count();
            println!("Approximate entry count: {}", count);
            thread::sleep(std::time::Duration::from_secs(1));
        }
    });
    
    // Use case 2: Best-effort processing
    // Missing some entries is acceptable
    let map_process = Arc::clone(&map);
    thread::spawn(move || {
        for entry in map_process.iter() {
            // Process what we see, skip what we miss
            println!("Processing: {}", entry.key());
        }
    });
    
    // Use case 3: Idempotent operations
    // Processing same entry multiple times is OK
    let map_idempotent = Arc::clone(&map);
    thread::spawn(move || {
        for entry in map_idempotent.iter() {
            // OK if we see it again later
            println!("Idempotent processing: {}", entry.key());
        }
    });
    
    // NOT acceptable for:
    // - Transactional processing requiring ACID guarantees
    // - Exact counting at a point in time
    // - Operations requiring all entries to be processed exactly once
}

use dashmap::DashMap;
use std::sync::Arc;
 
fn main() {
    let map = DashMap::new();
    for i in 0..10 {
        map.insert(i, format!("value{}", i));
    }
    
    // If you need true snapshot, you must:
    // 1. Stop all writers (external synchronization)
    // 2. Use a different data structure
    // 3. Accept the weakly consistent results
    
    // Option: Use a separate synchronization mechanism
    let snapshot: Vec<_> = {
        // In practice, you'd use external locking
        // DashMap doesn't provide a "lock all shards" operation
        
        // Collect as quickly as possible to minimize race window
        map.iter()
            .map(|e| (e.key().clone(), e.value().clone()))
            .collect()
    };
    
    // snapshot is approximately correct but not guaranteed exact
    
    // Alternative: Use parking_lot::RwLock<HashMap> for true snapshots
    // But you lose DashMap's fine-grained locking benefits
    
    println!("Snapshot has {} entries", snapshot.len());
}