test_thread_names.rs

use std::sync::atomic::{AtomicUsize, Ordering};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Testing thread naming...");
    
    // Test Rayon global pool
    rayon::ThreadPoolBuilder::new()
        .thread_name(|i| format!("rayon-global-{}", i))
        .num_threads(4)
        .build_global()?;
    
    // Test Tokio runtime
    let tokio_counter = AtomicUsize::new(0);
    let runtime = tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .thread_name_fn(move || {
            let counter = tokio_counter.fetch_add(1, Ordering::SeqCst);
            format!("tokio-test-{}", counter)
        })
        .worker_threads(4)
        .build()?;
    
    println!("Thread pools created!");
    println!("Process PID: {}", std::process::id());
    println!("\nCheck thread names with:");
    println!("  ps -T -p {} -o pid,tid,comm", std::process::id());
    
    runtime.block_on(async {
        // Spawn some work to ensure threads are created
        let handles: Vec<_> = (0..4).map(|i| {
            tokio::spawn(async move {
                tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
                println!("Tokio task {} done", i);
            })
        }).collect();
        
        for h in handles {
            h.await.ok();
        }
        
        // Spawn rayon work
        rayon::spawn(|| {
            std::thread::sleep(std::time::Duration::from_secs(1));
            println!("Rayon task done");
        });
        
        tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
    });
    
    Ok(())
}