Run Every Three Minutes Schedule Guide | CronBase

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

let isTaskRunning = false;

// Schedule task for every 3 minutes: */3 * * * *
cron.schedule('*/3 * * * *', async () => {
  if (isTaskRunning) {
    console.warn('[WARN] Previous task execution is still active. Skipping run to prevent race conditions.');
    return;
  }

  isTaskRunning = true;
  console.log(`[INFO] Executing high-frequency task at ${new Date().toISOString()}`);

  try {
    const response = await axios.get('https://api.example.com/v1/metrics', { timeout: 150000 });
    console.log(`[INFO] Metrics collected successfully. Status: ${response.status}`);
  } catch (error) {
    console.error('[ERROR] Failed to execute 3-minute cron task:', error.message);
  } finally {
    isTaskRunning = false;
  }
});

#!/usr/bin/env bash
# Production Bash script for a 3-minute cron task with locking mechanism
set -euo pipefail

LOCKFILE="/var/lock/my_three_minute_task.lock"
TIMEOUT_SECS=170 # Slightly less than 3 minutes to prevent overlap

# Ensure single instance execution using flock
exec 9>"$LOCKFILE"
if ! flock -n 9; then
    echo "[ERROR] Another instance of the task is still running. Exiting to prevent overlap." >&2
    exit 1
fi

echo "[INFO] Starting 3-minute cron execution at $(date -u)"
# Simulate production workload with timeout protection
timeout "$TIMEOUT_SECS" curl -sSf https://api.internal/health-check || {
    echo "[ERROR] Task failed or timed out" >&2
    exit 1
}
echo "[INFO] Task completed successfully"

import logging
import sys
import requests
from apscheduler.schedulers.blocking import BlockingScheduler

logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
logger = logging.getLogger(__name__)

def fetch_queue_status():
    logger.info("Starting queue status check...")
    try:
        response = requests.get("https://api.internal/queue/status", timeout=120)
        response.raise_for_status()
        logger.info(f"Queue check successful: {response.json()}")
    except requests.exceptions.RequestException as e:
        logger.error(f"Network error during queue check: {e}")
    except Exception as e:
        logger.error(f"Unexpected error: {e}")

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # Adding a job for every 3 minutes using standard cron syntax
    scheduler.add_job(
        fetch_queue_status,
        'cron',
        minute='*/3',
        id='queue_status_job',
        coalesce=True,
        max_instances=1
    )
    logger.info("Starting scheduler for every 3 minutes...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped cleanly.")

package main

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

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

type SafeRunner struct {
	mu     sync.Mutex
	active bool
}

func (r *SafeRunner) Run() {
	r.mu.Lock()
	if r.active {
		log.Println("[WARN] Task is already running; skipping execution")
		r.mu.Unlock()
		return
	}
	r.active = true
	r.mu.Unlock()

	defer func() {
		r.mu.Lock()
		r.active = false
		r.mu.Unlock()
	}()

	log.Println("[INFO] Starting 3-minute task execution...")
	ctx, cancel := context.WithTimeout(context.Background(), 150*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, "POST", "https://api.internal/v1/jobs", nil)
	if err != nil {
		log.Printf("[ERROR] Failed to create request: %v", err)
		return
	}

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Printf("[ERROR] Request failed: %v", err)
		return
	}
	defer resp.Body.Close()
	log.Printf("[INFO] Execution finished with status code %d", resp.StatusCode)
}

func main() {
	c := cron.New()
	runner := &SafeRunner{}
	_, err := c.AddJob("*/3 * * * *", runner)
	if err != nil {
		log.Fatalf("Failed to schedule cron job: %v", err)
	}
	c.Start()
	select {} // Keep running
}

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.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;

@Component
public class HighFrequencyTaskScheduler {
    private static final Logger logger = LoggerFactory.getLogger(HighFrequencyTaskScheduler.class);
    private final HttpClient httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .build();

    // Cron expression for every 3 minutes: */3 * * * *
    @Scheduled(cron = "0 */3 * * * *")
    public void executeTask() {
        logger.info("Executing 3-minute health sync job...");
        try {
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://api.internal/health"))
                    .timeout(Duration.ofSeconds(150))
                    .GET()
                    .build();

            HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
            logger.info("Health check response code: {}", response.statusCode());
        } catch (InterruptedException e) {
            logger.error("Execution interrupted", e);
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            logger.error("Failed to complete 3-minute scheduled task", e);
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: high-frequency-cleanup
  namespace: production
spec:
  schedule: "*/3 * * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  startingDeadlineSeconds: 60
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: internal-registry.io/ops/cleanup-worker:v1.2.0
            imagePullPolicy: IfNotPresent
            resources:
              limits:
                cpu: "200m"
                memory: "256Mi"
              requests:
                cpu: "100m"
                memory: "128Mi"
          restartPolicy: OnFailure