Execute Jobs Every Five Minutes | CronBase

#!/usr/bin/env bash
# Prevent overlapping executions using flock
LOCKFILE="/var/lock/five_minute_job.lock"
exec 9>"$LOCKFILE"

if ! flock -n 9; then
    echo "Error: Another instance of this job is already running." >&2
    exit 1
fi

echo "Starting high-frequency task at $(date)"
# Real production workload goes here
# Example: curl -sf https://api.example.com/health || exit 1

const cron = require('node-cron');

let isRunning = false;

// Schedule to run every 5 minutes
cron.schedule('*/5 * * * *', async () => {
    if (isRunning) {
        console.warn('Execution skipped: Previous task is still running.');
        return;
    }
    isRunning = true;
    try {
        console.log('Starting execution cycle...');
        await performTask();
    } catch (error) {
        console.error('Task failed:', error);
    } finally {
        isRunning = false;
    }
});

function performTask() {
    return new Promise((resolve) => setTimeout(resolve, 5000));
}

import os
import sys
import fcntl
from datetime import datetime

lock_file_path = "/tmp/python_five_min_job.lock"
lock_file = open(lock_file_path, "w")

try:
    # Non-blocking lock acquisition
    fcntl.lockf(lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
except IOError:
    print(f"[{datetime.now()}] Job is already running. Exiting.", file=sys.stderr)
    sys.exit(0)

def main():
    print(f"[{datetime.now()}] Starting periodic job execution...")
    # Put your core business logic here

if __name__ == "__main__":
    try:
        main()
    finally:
        lock_file.close()

package main

import (
	"context"
	"log"
	"sync/atomic"
	"time"

	"github.com/robfig/cron/v3"
)

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

	_, err := c.AddFunc("*/5 * * * *", func() {
		// Atomic check to prevent concurrent execution overlap
		if !atomic.CompareAndSwapInt32(&running, 0, 1) {
			log.Println("Previous execution still in progress, skipping run.")
			return
		}
		defer atomic.StoreInt32(&running, 0)

		log.Println("Executing scheduled task...")
		ctx, cancel := context.WithTimeout(context.Background(), 4*time.Minute)
		defer cancel()

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

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

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

func executeTask(ctx context.Context) error {
	// Simulated work
	return nil
}

package com.example.scheduler;

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Component;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Logger;

@Component
public class FiveMinuteTaskScheduler {
    private static final Logger LOGGER = Logger.getLogger(FiveMinuteTaskScheduler.class.getName());
    private final AtomicBoolean isRunning = new AtomicBoolean(false);

    // Spring's cron scheduler configuration
    @Scheduled(cron = "0 */5 * * * *")
    public void executeTask() {
        if (!isRunning.compareAndSet(false, true)) {
            LOGGER.warning("Previous job execution is still active. Skipping this cycle.");
            return;
        }
        try {
            LOGGER.info("Starting five-minute maintenance job...");
            runBusinessLogic();
        } finally {
            isRunning.set(false);
        }
    }

    private void runBusinessLogic() {
        // Business logic goes here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: five-minute-cleanup-job
  namespace: default
spec:
  schedule: "*/5 * * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: busybox:1.36
            imagePullPolicy: IfNotPresent
            command:
            - /bin/sh
            - -c
            - "echo 'Starting task...'; sleep 10; echo 'Task complete.'"
          restartPolicy: OnFailure