Execute Jobs Every Two Minutes Reliably | CronBase

#!/bin/bash
# Production-ready Bash script with lock protection to prevent overlap
LOCKFILE="/var/lock/my_two_minute_job.lock"

# Acquire an exclusive lock without blocking
exec 200>"$LOCKFILE"
flock -n 200 || {
  echo "[$(date)] Warning: Job is already running, skipping execution to avoid overlap."
  exit 1
}

echo "[$(date)] Initiating high-frequency polling task..."
timeout 110s curl -s -f https://api.internal/v1/poll-tasks || {
  echo "[$(date)] Error: API request failed or timed out."
  exit 1
}

echo "[$(date)] Task completed successfully."

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

let isRunning = false;

// Schedule task to run every two minutes
cron.schedule('*/2 * * * *', async () => {
  if (isRunning) {
    console.warn('[Cron] Previous job is still running; skipping execution.');
    return;
  }

  isRunning = true;
  console.log('[Cron] Starting execution...');

  try {
    const response = await axios.get('https://api.internal/v1/health', { timeout: 10000 });
    console.log(`[Cron] System health status: ${response.data.status}`);
  } catch (error) {
    console.error('[Cron] Execution failed:', error.message);
  } finally {
    isRunning = false;
  }
});

import time
import requests
from apscheduler.schedulers.blocking import BlockingScheduler

scheduler = BlockingScheduler()

@scheduler.scheduled_job('cron', minute='*/2')
def execute_task():
    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Executing database cleanup... ")
    try:
        # Set a strict timeout to prevent hanging connections
        response = requests.post("https://api.internal/v1/cleanup", timeout=90)
        response.raise_for_status()
        print("Database cleanup completed successfully.")
    except requests.exceptions.RequestException as e:
        print(f"Cleanup failed: {e}")

if __name__ == '__main__':
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        pass

package main

import (
	"context"
	"log"
	"net/http"
	"time"

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

func main() {
	c := cron.New()
	
	_, err := c.AddFunc("*/2 * * * *", func() {
		log.Println("Starting two-minute queue processing...")
		ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second)
		defer cancel()

		req, _ := http.NewRequestWithContext(ctx, "POST", "https://api.internal/v1/queue", nil)
		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			log.Printf("Queue processing failed: %v", err)
			return
		}
		defer resp.Body.Close()
		log.Printf("Queue processed with status: %s", resp.Status)
	})

	if err != nil {
		log.Fatalf("Error scheduling cron job: %v", err)
	}

	c.Start()
	select {} // Block main thread to keep service running
}

package com.example.cron;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component
public class HighFrequencyTask {
    private static final Logger logger = LoggerFactory.getLogger(HighFrequencyTask.class);
    private boolean isProcessing = false;

    @Scheduled(cron = "*/2 * * * * *", zone = "UTC")
    public synchronized void executeTask() {
        if (isProcessing) {
            logger.warn("Task execution skipped: previous instance is still running.");
            return;
        }
        isProcessing = true;
        logger.info("Starting high-frequency data pipeline sync...");
        try {
            // Simulate fast pipeline operations
            Thread.sleep(5000);
            logger.info("Data pipeline sync completed.");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            logger.error("Task interrupted: ", e);
        } finally {
            isProcessing = false;
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: fast-polling-cronjob
  namespace: default
spec:
  schedule: "*/2 * * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 1
  failedJobsHistoryLimit: 3
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: poller
            image: curlimages/curl:latest
            command:
            - /bin/sh
            - -c
            - "curl -m 100 -f https://api.internal/v1/heartbeat"
          restartPolicy: OnFailure