Module worker_manager

Worker Manager Module

This module provides the WorkerManager struct for controlling spawned threads. It allows you to manage individual workers: pause, resume, remove, and monitor them.

Overview

WorkerManager is designed to work with the spawn_workers! macro and provides fine-grained control over thread management. It’s particularly useful for:

• Dynamic worker management: Add/remove workers at runtime
• Worker state control: Pause/resume individual workers
• Monitoring: Track worker status and count
• Synchronization: Wait for all workers to complete

Key Features

• 🔄 Dynamic Worker Management: Add/remove workers programmatically
• ⏸️ State Control: Pause/resume individual workers
• 📊 Real-time Monitoring: Track worker status and count
• 🔒 Thread Safety: All operations are thread-safe
• 🎮 Fine-grained Control: Manage each worker individually
• 📈 Scalability: Handle hundreds of workers efficiently

Basic Usage

use thread_share::{enhanced_share, spawn_workers};

// Create shared data
let data = enhanced_share!(0u32);

// Spawn workers and get manager
let manager = spawn_workers!(data, {
    counter: |data| {
        for i in 1..=10 {
            data.update(|x| *x += i);
            std::thread::sleep(std::time::Duration::from_millis(100));
        }
    },
    monitor: |data| {
        for _ in 0..5 {
            std::thread::sleep(std::time::Duration::from_millis(200));
            println!("Value: {}", data.get());
        }
    }
});

// Control workers
println!("Active workers: {}", manager.active_workers());
println!("Worker names: {:?}", manager.get_worker_names());

// Wait for completion
manager.join_all().expect("Workers failed");

Advanced Usage with Programmatic Worker Addition

use thread_share::{enhanced_share, spawn_workers, worker_manager::WorkerManager};
use std::thread;

let data = enhanced_share!(0u32);

// Start with initial workers
let manager = spawn_workers!(data, {
    initial_worker: |data| {
        data.update(|x| *x += 1);
        std::thread::sleep(std::time::Duration::from_millis(100));
    }
});

// Add more workers programmatically
let data_clone = data.clone();
let handle = thread::spawn(move || {
    for _ in 0..3 {
        data_clone.update(|x| *x *= 2);
        std::thread::sleep(std::time::Duration::from_millis(150));
    }
});

manager.add_worker("dynamic_worker", handle).expect("Failed to add worker");

// Now we have 2 workers
assert_eq!(manager.active_workers(), 2);

Creating Empty Manager and Adding Workers

use thread_share::worker_manager::WorkerManager;
use std::thread;
use std::time::Duration;

// Create empty manager
let manager = WorkerManager::new();

// Add workers one by one
let handle1 = thread::spawn(|| {
    for i in 1..=5 {
        println!("Worker 1: {}", i);
        thread::sleep(Duration::from_millis(100));
    }
});

let handle2 = thread::spawn(|| {
    for i in 1..=3 {
        println!("Worker 2: {}", i);
        thread::sleep(Duration::from_millis(150));
    }
});

manager.add_worker("worker1", handle1).expect("Failed to add worker1");
manager.add_worker("worker2", handle2).expect("Failed to add worker2");

assert_eq!(manager.active_workers(), 2);
println!("Worker names: {:?}", manager.get_worker_names());

// Wait for completion
manager.join_all().expect("Workers failed");

Worker Lifecycle Management

use thread_share::{enhanced_share, spawn_workers};

let data = enhanced_share!(0u32);
let manager = spawn_workers!(data, {
    worker1: |data| { /* work */ },
    worker2: |data| { /* work */ }
});

// Pause a worker
manager.pause_worker("worker1").expect("Failed to pause");

// Check if paused
assert!(manager.is_worker_paused("worker1"));

// Resume a worker
manager.resume_worker("worker1").expect("Failed to resume");

// Remove from tracking
manager.remove_worker("worker2").expect("Failed to remove");

// Remove all workers
manager.remove_all_workers().expect("Failed to remove all");

Error Handling

All methods return Result<T, String> for proper error handling:

use thread_share::{enhanced_share, spawn_workers};

let data = enhanced_share!(0u32);
let manager = spawn_workers!(data, {
    worker: |data| { /* work */ }
});

// Handle errors gracefully
match manager.pause_worker("nonexistent") {
    Ok(()) => println!("Worker paused successfully"),
    Err(e) => println!("Failed to pause worker: {}", e),
}

// Remove worker and handle result
match manager.remove_worker("worker") {
    Ok(()) => println!("Worker removed successfully"),
    Err(e) => println!("Failed to remove worker: {}", e),
}

Thread Safety

WorkerManager is designed to be thread-safe and can be shared between threads:

use thread_share::{enhanced_share, spawn_workers};
use std::thread;
use std::sync::Arc;

let data = enhanced_share!(0u32);
let manager = spawn_workers!(data, {
    worker: |data| { /* work */ }
});

// Clone manager for another thread
let manager_clone = manager.clone();
let thread_handle = thread::spawn(move || {
    // Use manager in another thread
    let names = manager_clone.get_worker_names();
    println!("Worker names from thread: {:?}", names);
});

thread_handle.join().expect("Thread failed");

Performance Considerations

• Thread Spawning: Minimal overhead over standard thread::spawn
• Worker Management: Constant-time operations for most management functions
• Memory Usage: Small overhead for worker tracking structures
• Scalability: Efficient for up to hundreds of workers

When to Use WorkerManager

• Complex Applications: When you need fine-grained control over workers
• Dynamic Workloads: When worker count changes at runtime
• Monitoring Requirements: When you need real-time worker status
• Production Systems: When you need robust worker management
• Debugging: When you need to pause/resume workers for debugging

Structs

WorkerManager

Worker Manager for controlling spawned threads