Execute Tasks Every Ten Minutes | CronBase

const cron = require('node-cron');
// Schedule task to run every 10 minutes safely
let isRunning = false;
cron.schedule('*/10 * * * *', async () => {
    if (isRunning) {
        console.warn('[Warning] Previous execution still running. Skipping this interval.');
        return;
    }
    isRunning = true;
    try {
        console.log(`[${new Date().toISOString()}] Starting database cleanup...`);
        await performCleanup();
    } catch (error) {
        console.error('[Error] Execution failed:', error);
    } finally {
        isRunning = false;
    }
});
async function performCleanup() {
    // Simulated async operation
    return new Promise(resolve => setTimeout(resolve, 2000));
}

#!/usr/bin/env bash
# Production Bash script for a 10-minute cron job.
# Uses flock to prevent overlapping execution.
set -euo pipefail
LOCKFILE="/var/lock/my_ten_minute_job.lock"
exec 9>"$LOCKFILE"
if ! flock -n 9; then
    echo "Error: Job is already running. Exiting to prevent overlap." >&2
    exit 1
fi
echo "[$(date -u)] Starting high-frequency sync task..."
# Simulate work
sleep 5
echo "[$(date -u)] Task completed successfully."

import os
import sys
import fcntl
import time

# Production Python script utilizing file locking to prevent overlap when run via cron
LOCK_FILE = "/tmp/python_ten_minute_job.lock"

def main():
    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Starting data sync pipeline...")
    # Simulate heavy processing
    time.sleep(10)
    print("Sync complete.")

if __name__ == "__main__":
    lock_fd = open(LOCK_FILE, 'w')
    try:
        # Acquire an exclusive lock without blocking
        fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
    except IOError:
        print("Another instance of the script is already running. Exiting safely.", file=sys.stderr)
        sys.exit(0)
    try:
        main()
    finally:
        fcntl.flock(lock_fd, fcntl.LOCK_UN)

package main

import (
    "context"
    "log"
    "sync/atomic"
    "time"
    "github.com/robfig/cron/v3"
)

func main() {
    c := cron.New()
    var isRunning int32

    // Schedule to run every 10 minutes
    _, err := c.AddFunc("*/10 * * * *", func() {
        // Prevent concurrent runs using atomic CAS
        if !atomic.CompareAndSwapInt32(&isRunning, 0, 1) {
            log.Println("[Warning] Task is already running; skipping execution.")
            return
        }
        defer atomic.StoreInt32(&isRunning, 0)

        ctx, cancel := context.WithTimeout(context.Background(), 8*time.Minute)
        defer cancel()

        if err := runTask(ctx); err != nil {
            log.Printf("[Error] Task failed: %v", err)
        }
    })

    if err != nil {
        log.Fatalf("Failed to schedule cron job: %v", err)
    }

    c.Start()
    select {} // Keep application running
}

func runTask(ctx context.Context) error {
    log.Println("Starting 10-minute telemetry check...")
    select {
    case <-time.After(5 * time.Second):
        log.Println("Telemetry check completed.")
    case <-ctx.Done():
        return ctx.Err()
    }
    return nil
}

package com.example.cron;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.concurrent.atomic.AtomicBoolean;

@Component
public class TenMinuteTaskScheduler {
    private static final Logger log = LoggerFactory.getLogger(TenMinuteTaskScheduler.class);
    private final AtomicBoolean isRunning = new AtomicBoolean(false);

    // Runs every 10 minutes (standard cron syntax)
    @Scheduled(cron = "*/10 * * * *")
    public void executeTask() {
        if (!isRunning.compareAndSet(false, true)) {
            log.warn("Previous execution is still running. Skipping this run.");
            return;
        }
        try {
            log.info("Starting ten-minute cache eviction process...");
            performEviction();
        } catch (Exception e) {
            log.error("Error occurred during cache eviction", e);
        } finally {
            isRunning.set(false);
        }
    }

    private void performEviction() throws InterruptedException {
        // Simulate processing time
        Thread.sleep(3000);
        log.info("Cache eviction process completed successfully.");
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: ten-minute-data-sync
  namespace: default
spec:
  schedule: "*/10 * * * *"
  concurrencyPolicy: Forbid # Crucial: Prevents concurrent runs if a job hangs
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      activeDeadlineSeconds: 540 # Automatically terminate if running over 9 minutes
      template:
        spec:
          containers:
          - name: sync-worker
            image: registry.example.com/sync-worker:v1.2.0
            resources:
              requests:
                memory: "256Mi"
                cpu: "200m"
              limits:
                memory: "512Mi"
                cpu: "500m"
          restartPolicy: OnFailure