Struct Cron 

pub struct Cron<Z>
where
    Z: TimeZone + Sync + Send + 'static,
    Z::Offset: Send,
{ /* private fields */ }

Re-export of the synchronous cron scheduler.

This is only available when the “sync” feature is enabled. Use Cron for synchronous job scheduling with threads. A synchronous cron job scheduler that manages and executes scheduled jobs.

The Cron struct provides a thread-safe way to schedule jobs using cron expressions. Jobs are executed in separate threads as they become due, allowing for concurrent execution without blocking the scheduler.

Type Parameters

• Z - A timezone type that implements TimeZone + Sync + Send + 'static

Thread Safety

This struct is thread-safe and can be safely shared between threads. All jobs are executed in separate threads, and the scheduler itself runs in a background thread.

Examples

use chrono::Utc;
use cron_tab::Cron;

let mut cron = Cron::new(Utc);
let job_id = cron.add_fn("*/5 * * * * * *", || {
    println!("This job runs every 5 seconds");
}).unwrap();

cron.start();
// Jobs will now execute according to their schedule
 
// Later, you can stop the scheduler
cron.stop();

Implementations

impl<Z> Cron<Z>

where Z: TimeZone + Sync + Send + 'static, Z::Offset: Send,

Implementation of the synchronous cron scheduler.

pub fn new(tz: Z) -> Cron<Z>

Creates a new cron scheduler with the specified timezone.

The scheduler is created in a stopped state. Call start to begin executing scheduled jobs.

Arguments

• tz - The timezone to use for all scheduling calculations

Examples

use chrono::{Utc, FixedOffset};
use cron_tab::Cron;

// UTC timezone
let cron_utc = Cron::new(Utc);

// Fixed offset timezone (Tokyo: UTC+9)
let tokyo_tz = FixedOffset::east_opt(9 * 3600).unwrap();
let cron_tokyo = Cron::new(tokyo_tz);

Examples found in repository

examples/simple.rs (line 6)

fn main() {
    let local_tz = Local::from_offset(&FixedOffset::east_opt(7).unwrap());
    let mut cron = cron_tab::Cron::new(local_tz);

    let first_job_id = cron.add_fn("* * * * * * *", print_now).unwrap();

    // start cron in background
    cron.start();

    cron.add_fn("* * * * * *", move || {
        println!("add_fn {}", Local::now().to_string());
    })
    .unwrap();

    // remove job_test
    cron.remove(first_job_id);

    std::thread::sleep(std::time::Duration::from_secs(10));

    // stop cron
    cron.stop();
}

examples/one_time_execution.rs (line 13)

fn main() {
    println!("=== One-Time Task Execution Example ===\n");

    let mut cron = Cron::new(Utc);

    // Shared counter to track execution
    let counter = Arc::new(Mutex::new(0));

    // Example 1: Execute once after a delay
    println!("Scheduling job to execute after 2 seconds...");
    let counter1 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(2), move || {
        let mut count = counter1.lock().unwrap();
        *count += 1;
        println!("[After 2s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 2: Execute once at a specific datetime
    let target_time = Utc::now() + Duration::seconds(4);
    println!(
        "Scheduling job to execute at specific time: {}",
        target_time.format("%H:%M:%S")
    );
    let counter2 = Arc::clone(&counter);
    cron.add_fn_once(target_time, move || {
        let mut count = counter2.lock().unwrap();
        *count += 10;
        println!("[At {}] Job executed! Counter: {}", target_time.format("%H:%M:%S"), *count);
    })
    .unwrap();

    // Example 3: Execute once after 6 seconds
    println!("Scheduling job to execute after 6 seconds...");
    let counter3 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(6), move || {
        let mut count = counter3.lock().unwrap();
        *count += 100;
        println!("[After 6s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 4: Mix with recurring job
    println!("Scheduling recurring job every 3 seconds...");
    let recurring_counter = Arc::new(Mutex::new(0));
    let recurring_counter1 = Arc::clone(&recurring_counter);
    cron.add_fn("*/3 * * * * * *", move || {
        let mut count = recurring_counter1.lock().unwrap();
        *count += 1;
        println!("[Recurring] Executed {} times", *count);
    })
    .unwrap();

    // Start the scheduler
    println!("\nStarting scheduler...\n");
    cron.start();

    // Let it run for 8 seconds
    std::thread::sleep(std::time::Duration::from_secs(8));

    // Stop the scheduler
    cron.stop();

    println!("\n=== Execution Complete ===");
    println!("Final one-time counter: {}", *counter.lock().unwrap());
    println!("Final recurring counter: {}", *recurring_counter.lock().unwrap());
    println!("\nNote: One-time jobs execute exactly once and are automatically removed.");
}

pub fn add_fn<T>(&mut self, spec: &str, f: T) -> Result<usize>

where T: 'static + Fn() + Send + Sync,

Adds a function to be executed according to the specified cron schedule.

The function will be called without arguments whenever the cron expression matches the current time in the scheduler’s timezone.

Arguments

• spec - A cron expression string in the format “sec min hour day month weekday year”
• f - A function that implements Fn() + Send + Sync + 'static

Returns

Returns a Result<usize, CronError> where the usize is a unique job ID that can be used with remove to cancel the job.

Errors

Returns CronError::ParseError if the cron expression is invalid.

Examples

use chrono::Utc;
use cron_tab::Cron;

let mut cron = Cron::new(Utc);

// Run every second
let job_id = cron.add_fn("* * * * * * *", || {
    println!("Every second!");
}).unwrap();

// Run every day at 9:00 AM
let morning_job = cron.add_fn("0 0 9 * * * *", || {
    println!("Good morning!");
}).unwrap();

// Run every Monday at 10:30 AM
let monday_job = cron.add_fn("0 30 10 * * MON *", || {
    println!("Monday meeting reminder!");
}).unwrap();

Examples found in repository

examples/simple.rs (line 8)

fn main() {
    let local_tz = Local::from_offset(&FixedOffset::east_opt(7).unwrap());
    let mut cron = cron_tab::Cron::new(local_tz);

    let first_job_id = cron.add_fn("* * * * * * *", print_now).unwrap();

    // start cron in background
    cron.start();

    cron.add_fn("* * * * * *", move || {
        println!("add_fn {}", Local::now().to_string());
    })
    .unwrap();

    // remove job_test
    cron.remove(first_job_id);

    std::thread::sleep(std::time::Duration::from_secs(10));

    // stop cron
    cron.stop();
}

examples/one_time_execution.rs (lines 56-60)

fn main() {
    println!("=== One-Time Task Execution Example ===\n");

    let mut cron = Cron::new(Utc);

    // Shared counter to track execution
    let counter = Arc::new(Mutex::new(0));

    // Example 1: Execute once after a delay
    println!("Scheduling job to execute after 2 seconds...");
    let counter1 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(2), move || {
        let mut count = counter1.lock().unwrap();
        *count += 1;
        println!("[After 2s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 2: Execute once at a specific datetime
    let target_time = Utc::now() + Duration::seconds(4);
    println!(
        "Scheduling job to execute at specific time: {}",
        target_time.format("%H:%M:%S")
    );
    let counter2 = Arc::clone(&counter);
    cron.add_fn_once(target_time, move || {
        let mut count = counter2.lock().unwrap();
        *count += 10;
        println!("[At {}] Job executed! Counter: {}", target_time.format("%H:%M:%S"), *count);
    })
    .unwrap();

    // Example 3: Execute once after 6 seconds
    println!("Scheduling job to execute after 6 seconds...");
    let counter3 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(6), move || {
        let mut count = counter3.lock().unwrap();
        *count += 100;
        println!("[After 6s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 4: Mix with recurring job
    println!("Scheduling recurring job every 3 seconds...");
    let recurring_counter = Arc::new(Mutex::new(0));
    let recurring_counter1 = Arc::clone(&recurring_counter);
    cron.add_fn("*/3 * * * * * *", move || {
        let mut count = recurring_counter1.lock().unwrap();
        *count += 1;
        println!("[Recurring] Executed {} times", *count);
    })
    .unwrap();

    // Start the scheduler
    println!("\nStarting scheduler...\n");
    cron.start();

    // Let it run for 8 seconds
    std::thread::sleep(std::time::Duration::from_secs(8));

    // Stop the scheduler
    cron.stop();

    println!("\n=== Execution Complete ===");
    println!("Final one-time counter: {}", *counter.lock().unwrap());
    println!("Final recurring counter: {}", *recurring_counter.lock().unwrap());
    println!("\nNote: One-time jobs execute exactly once and are automatically removed.");
}

pub fn add_fn_once<T>(&mut self, datetime: DateTime<Z>, f: T) -> Result<usize>

where T: 'static + Fn() + Send + Sync,

Adds a function to be executed once at a specific datetime.

The function will be called exactly once when the specified time is reached. After execution, the job is automatically removed from the scheduler.

Arguments

• datetime - The specific time when the job should execute
• f - A function that implements Fn() + Send + Sync + 'static

Returns

Returns a Result<usize, CronError> where the usize is a unique job ID that can be used with remove to cancel the job.

Behavior with Past Times

If the specified datetime is in the past, the job will execute immediately on the next scheduler iteration. This allows for jobs that may have been scheduled while the system was offline or during startup.

Examples

use chrono::{Utc, Duration};
use cron_tab::Cron;

let mut cron = Cron::new(Utc);

// Execute once at a specific time
let target_time = Utc::now() + Duration::seconds(10);
let job_id = cron.add_fn_once(target_time, || {
    println!("This runs once at the specified time!");
}).unwrap();

Examples found in repository

examples/one_time_execution.rs (lines 35-39)

fn main() {
    println!("=== One-Time Task Execution Example ===\n");

    let mut cron = Cron::new(Utc);

    // Shared counter to track execution
    let counter = Arc::new(Mutex::new(0));

    // Example 1: Execute once after a delay
    println!("Scheduling job to execute after 2 seconds...");
    let counter1 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(2), move || {
        let mut count = counter1.lock().unwrap();
        *count += 1;
        println!("[After 2s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 2: Execute once at a specific datetime
    let target_time = Utc::now() + Duration::seconds(4);
    println!(
        "Scheduling job to execute at specific time: {}",
        target_time.format("%H:%M:%S")
    );
    let counter2 = Arc::clone(&counter);
    cron.add_fn_once(target_time, move || {
        let mut count = counter2.lock().unwrap();
        *count += 10;
        println!("[At {}] Job executed! Counter: {}", target_time.format("%H:%M:%S"), *count);
    })
    .unwrap();

    // Example 3: Execute once after 6 seconds
    println!("Scheduling job to execute after 6 seconds...");
    let counter3 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(6), move || {
        let mut count = counter3.lock().unwrap();
        *count += 100;
        println!("[After 6s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 4: Mix with recurring job
    println!("Scheduling recurring job every 3 seconds...");
    let recurring_counter = Arc::new(Mutex::new(0));
    let recurring_counter1 = Arc::clone(&recurring_counter);
    cron.add_fn("*/3 * * * * * *", move || {
        let mut count = recurring_counter1.lock().unwrap();
        *count += 1;
        println!("[Recurring] Executed {} times", *count);
    })
    .unwrap();

    // Start the scheduler
    println!("\nStarting scheduler...\n");
    cron.start();

    // Let it run for 8 seconds
    std::thread::sleep(std::time::Duration::from_secs(8));

    // Stop the scheduler
    cron.stop();

    println!("\n=== Execution Complete ===");
    println!("Final one-time counter: {}", *counter.lock().unwrap());
    println!("Final recurring counter: {}", *recurring_counter.lock().unwrap());
    println!("\nNote: One-time jobs execute exactly once and are automatically removed.");
}

pub fn add_fn_after<T>(&mut self, delay: Duration, f: T) -> Result<usize>

where T: 'static + Fn() + Send + Sync,

Adds a function to be executed once after a specified delay.

The function will be called exactly once after the specified duration has passed. After execution, the job is automatically removed from the scheduler.

Arguments

• delay - The duration to wait before executing the job
• f - A function that implements Fn() + Send + Sync + 'static

Returns

Returns a Result<usize, CronError> where the usize is a unique job ID that can be used with remove to cancel the job.

Examples

use std::time::Duration;
use chrono::Utc;
use cron_tab::Cron;

let mut cron = Cron::new(Utc);

// Execute once after 30 seconds
let job_id = cron.add_fn_after(Duration::from_secs(30), || {
    println!("This runs once after 30 seconds!");
}).unwrap();

// Execute after 5 minutes
let delayed_job = cron.add_fn_after(Duration::from_secs(300), || {
    println!("This runs after 5 minutes!");
}).unwrap();

Examples found in repository

examples/one_time_execution.rs (lines 21-25)

fn main() {
    println!("=== One-Time Task Execution Example ===\n");

    let mut cron = Cron::new(Utc);

    // Shared counter to track execution
    let counter = Arc::new(Mutex::new(0));

    // Example 1: Execute once after a delay
    println!("Scheduling job to execute after 2 seconds...");
    let counter1 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(2), move || {
        let mut count = counter1.lock().unwrap();
        *count += 1;
        println!("[After 2s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 2: Execute once at a specific datetime
    let target_time = Utc::now() + Duration::seconds(4);
    println!(
        "Scheduling job to execute at specific time: {}",
        target_time.format("%H:%M:%S")
    );
    let counter2 = Arc::clone(&counter);
    cron.add_fn_once(target_time, move || {
        let mut count = counter2.lock().unwrap();
        *count += 10;
        println!("[At {}] Job executed! Counter: {}", target_time.format("%H:%M:%S"), *count);
    })
    .unwrap();

    // Example 3: Execute once after 6 seconds
    println!("Scheduling job to execute after 6 seconds...");
    let counter3 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(6), move || {
        let mut count = counter3.lock().unwrap();
        *count += 100;
        println!("[After 6s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 4: Mix with recurring job
    println!("Scheduling recurring job every 3 seconds...");
    let recurring_counter = Arc::new(Mutex::new(0));
    let recurring_counter1 = Arc::clone(&recurring_counter);
    cron.add_fn("*/3 * * * * * *", move || {
        let mut count = recurring_counter1.lock().unwrap();
        *count += 1;
        println!("[Recurring] Executed {} times", *count);
    })
    .unwrap();

    // Start the scheduler
    println!("\nStarting scheduler...\n");
    cron.start();

    // Let it run for 8 seconds
    std::thread::sleep(std::time::Duration::from_secs(8));

    // Stop the scheduler
    cron.stop();

    println!("\n=== Execution Complete ===");
    println!("Final one-time counter: {}", *counter.lock().unwrap());
    println!("Final recurring counter: {}", *recurring_counter.lock().unwrap());
    println!("\nNote: One-time jobs execute exactly once and are automatically removed.");
}

pub fn set_timezone(&mut self, tz: Z)

Sets the timezone for the scheduler.

This affects how cron expressions are interpreted for all future job executions. Existing jobs will use the new timezone for their next scheduled execution.

Arguments

• tz - The new timezone to use

Examples

use chrono::{Utc, FixedOffset};
use cron_tab::Cron;

// Create cron with UTC timezone
let mut cron_utc = Cron::new(Utc);

// Create a separate cron with Tokyo timezone  
let tokyo_tz = FixedOffset::east_opt(9 * 3600).unwrap();
let mut cron_tokyo = Cron::new(tokyo_tz);

// Each scheduler uses its own timezone for job scheduling
cron_utc.add_fn("0 0 12 * * * *", || {
    println!("Noon UTC");
}).unwrap();

cron_tokyo.add_fn("0 0 12 * * * *", || {
    println!("Noon Tokyo time");
}).unwrap();

pub fn remove(&self, id: usize)

Removes a job from the scheduler.

Once removed, the job will no longer be executed. If the job ID doesn’t exist, this method does nothing.

Arguments

• id - The job ID returned by add_fn

Examples

use chrono::Utc;
use cron_tab::Cron;

let mut cron = Cron::new(Utc);
let job_id = cron.add_fn("* * * * * * *", || {
    println!("This will be removed");
}).unwrap();

cron.start();
 
// Later, remove the job
cron.remove(job_id);

Examples found in repository

examples/simple.rs (line 19)

fn main() {
    let local_tz = Local::from_offset(&FixedOffset::east_opt(7).unwrap());
    let mut cron = cron_tab::Cron::new(local_tz);

    let first_job_id = cron.add_fn("* * * * * * *", print_now).unwrap();

    // start cron in background
    cron.start();

    cron.add_fn("* * * * * *", move || {
        println!("add_fn {}", Local::now().to_string());
    })
    .unwrap();

    // remove job_test
    cron.remove(first_job_id);

    std::thread::sleep(std::time::Duration::from_secs(10));

    // stop cron
    cron.stop();
}

pub fn stop(&self)

Stops the cron scheduler.

This sends a stop signal to the scheduler thread, causing it to exit gracefully. Any currently executing jobs will continue to completion, but no new jobs will be started.

Examples

use chrono::Utc;
use cron_tab::Cron;

let mut cron = Cron::new(Utc);
cron.add_fn("* * * * * * *", || println!("Hello")).unwrap();
cron.start();

// Later, stop the scheduler
cron.stop();

Examples found in repository

examples/simple.rs (line 24)

fn main() {
    let local_tz = Local::from_offset(&FixedOffset::east_opt(7).unwrap());
    let mut cron = cron_tab::Cron::new(local_tz);

    let first_job_id = cron.add_fn("* * * * * * *", print_now).unwrap();

    // start cron in background
    cron.start();

    cron.add_fn("* * * * * *", move || {
        println!("add_fn {}", Local::now().to_string());
    })
    .unwrap();

    // remove job_test
    cron.remove(first_job_id);

    std::thread::sleep(std::time::Duration::from_secs(10));

    // stop cron
    cron.stop();
}

examples/one_time_execution.rs (line 71)

fn main() {
    println!("=== One-Time Task Execution Example ===\n");

    let mut cron = Cron::new(Utc);

    // Shared counter to track execution
    let counter = Arc::new(Mutex::new(0));

    // Example 1: Execute once after a delay
    println!("Scheduling job to execute after 2 seconds...");
    let counter1 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(2), move || {
        let mut count = counter1.lock().unwrap();
        *count += 1;
        println!("[After 2s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 2: Execute once at a specific datetime
    let target_time = Utc::now() + Duration::seconds(4);
    println!(
        "Scheduling job to execute at specific time: {}",
        target_time.format("%H:%M:%S")
    );
    let counter2 = Arc::clone(&counter);
    cron.add_fn_once(target_time, move || {
        let mut count = counter2.lock().unwrap();
        *count += 10;
        println!("[At {}] Job executed! Counter: {}", target_time.format("%H:%M:%S"), *count);
    })
    .unwrap();

    // Example 3: Execute once after 6 seconds
    println!("Scheduling job to execute after 6 seconds...");
    let counter3 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(6), move || {
        let mut count = counter3.lock().unwrap();
        *count += 100;
        println!("[After 6s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 4: Mix with recurring job
    println!("Scheduling recurring job every 3 seconds...");
    let recurring_counter = Arc::new(Mutex::new(0));
    let recurring_counter1 = Arc::clone(&recurring_counter);
    cron.add_fn("*/3 * * * * * *", move || {
        let mut count = recurring_counter1.lock().unwrap();
        *count += 1;
        println!("[Recurring] Executed {} times", *count);
    })
    .unwrap();

    // Start the scheduler
    println!("\nStarting scheduler...\n");
    cron.start();

    // Let it run for 8 seconds
    std::thread::sleep(std::time::Duration::from_secs(8));

    // Stop the scheduler
    cron.stop();

    println!("\n=== Execution Complete ===");
    println!("Final one-time counter: {}", *counter.lock().unwrap());
    println!("Final recurring counter: {}", *recurring_counter.lock().unwrap());
    println!("\nNote: One-time jobs execute exactly once and are automatically removed.");
}

pub fn start(&mut self)

Starts the cron scheduler in a background thread.

This method spawns a new thread that will continuously monitor for jobs that need to be executed and spawn additional threads to run them. The method returns immediately, allowing your program to continue.

Thread Safety

The scheduler runs in its own thread and spawns additional threads for each job execution. This ensures that long-running jobs don’t block the scheduler or other jobs.

Examples

use chrono::Utc;
use cron_tab::Cron;
use std::time::Duration;

let mut cron = Cron::new(Utc);
cron.add_fn("*/2 * * * * * *", || {
    println!("Job executed every 2 seconds");
}).unwrap();

// Start the scheduler
cron.start();

// The main thread can continue with other work
std::thread::sleep(Duration::from_secs(10));

// Stop the scheduler
cron.stop();

Examples found in repository

examples/simple.rs (line 11)

fn main() {
    let local_tz = Local::from_offset(&FixedOffset::east_opt(7).unwrap());
    let mut cron = cron_tab::Cron::new(local_tz);

    let first_job_id = cron.add_fn("* * * * * * *", print_now).unwrap();

    // start cron in background
    cron.start();

    cron.add_fn("* * * * * *", move || {
        println!("add_fn {}", Local::now().to_string());
    })
    .unwrap();

    // remove job_test
    cron.remove(first_job_id);

    std::thread::sleep(std::time::Duration::from_secs(10));

    // stop cron
    cron.stop();
}

examples/one_time_execution.rs (line 65)

fn main() {
    println!("=== One-Time Task Execution Example ===\n");

    let mut cron = Cron::new(Utc);

    // Shared counter to track execution
    let counter = Arc::new(Mutex::new(0));

    // Example 1: Execute once after a delay
    println!("Scheduling job to execute after 2 seconds...");
    let counter1 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(2), move || {
        let mut count = counter1.lock().unwrap();
        *count += 1;
        println!("[After 2s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 2: Execute once at a specific datetime
    let target_time = Utc::now() + Duration::seconds(4);
    println!(
        "Scheduling job to execute at specific time: {}",
        target_time.format("%H:%M:%S")
    );
    let counter2 = Arc::clone(&counter);
    cron.add_fn_once(target_time, move || {
        let mut count = counter2.lock().unwrap();
        *count += 10;
        println!("[At {}] Job executed! Counter: {}", target_time.format("%H:%M:%S"), *count);
    })
    .unwrap();

    // Example 3: Execute once after 6 seconds
    println!("Scheduling job to execute after 6 seconds...");
    let counter3 = Arc::clone(&counter);
    cron.add_fn_after(std::time::Duration::from_secs(6), move || {
        let mut count = counter3.lock().unwrap();
        *count += 100;
        println!("[After 6s] Job executed! Counter: {}", *count);
    })
    .unwrap();

    // Example 4: Mix with recurring job
    println!("Scheduling recurring job every 3 seconds...");
    let recurring_counter = Arc::new(Mutex::new(0));
    let recurring_counter1 = Arc::clone(&recurring_counter);
    cron.add_fn("*/3 * * * * * *", move || {
        let mut count = recurring_counter1.lock().unwrap();
        *count += 1;
        println!("[Recurring] Executed {} times", *count);
    })
    .unwrap();

    // Start the scheduler
    println!("\nStarting scheduler...\n");
    cron.start();

    // Let it run for 8 seconds
    std::thread::sleep(std::time::Duration::from_secs(8));

    // Stop the scheduler
    cron.stop();

    println!("\n=== Execution Complete ===");
    println!("Final one-time counter: {}", *counter.lock().unwrap());
    println!("Final recurring counter: {}", *recurring_counter.lock().unwrap());
    println!("\nNote: One-time jobs execute exactly once and are automatically removed.");
}

pub fn start_blocking(&mut self)

Runs the scheduler in the current thread (blocking).

This method runs the main scheduler loop in the current thread, making it block until stop is called. This is useful when you want to run the scheduler as the main thread of your application.

Behavior

The scheduler will:

1. Calculate the next execution time for all jobs
2. Sleep until the next job is due
3. Execute all due jobs in separate threads
4. Repeat until stopped

Examples

use chrono::Utc;
use cron_tab::Cron;

let mut cron = Cron::new(Utc);
cron.add_fn("0 0 * * * * *", || {
    println!("Top of the hour!");
}).unwrap();

// This will block until stop() is called from another thread
cron.start_blocking();

Trait Implementations

impl<Z> Clone for Cron<Z>

where Z: TimeZone + Sync + Send + 'static + Clone, Z::Offset: Send,

fn clone(&self) -> Cron<Z>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Z> Debug for Cron<Z>

where Z: TimeZone + Sync + Send + 'static + Debug, Z::Offset: Send,

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

Formats the value using the given formatter.