Configure Every 45-Minute Cron Jobs | CronBase

#!/usr/bin/env bash
# Production-ready wrapper for cron execution with file locking
set -euo pipefail

LOCKFILE="/var/run/my_45min_job.lock"
LOGFILE="/var/log/my_45min_job.log"

# Ensure single execution using flock to avoid overlapping runs
exec 200>"$LOCKFILE"
if ! flock -n 200; then
    echo "[$(date -u)] Execution skipped: Job is already running." >> "$LOGFILE"
    exit 0
fi

echo "[$(date -u)] Starting 45-minute interval task..." >> "$LOGFILE"

# Actual task execution
if /usr/local/bin/my-app-task >> "$LOGFILE" 2>&1; then
    echo "[$(date -u)] Task completed successfully." >> "$LOGFILE"
else
    echo "[$(date -u)] ERROR: Task failed with exit code $?" >> "$LOGFILE" >&2
    exit 1
fi

const cron = require('node-cron');
const { exec } = require('child_process');

let isRunning = false;

// Schedule task at minute 0 and 45 of every hour
cron.schedule('*/45 * * * *', async () => {
    if (isRunning) {
        console.warn(`[${new Date().toISOString()}] Warning: Previous execution still active. Skipping.`);
        return;
    }

    isRunning = true;
    console.log(`[${new Date().toISOString()}] Starting scheduled task...`);

    try {
        await runTask();
        console.log(`[${new Date().toISOString()}] Task completed successfully.`);
    } catch (error) {
        console.error(`[${new Date().toISOString()}] Task failed:`, error);
    } finally {
        isRunning = false;
    }
});

function runTask() {
    return new Promise((resolve) => {
        // Simulate processing work
        setTimeout(() => {
            resolve();
        }, 5000);
    });
}

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

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

def execute_job():
    logger.info("Executing scheduled task (minute 0 or 45)...")
    try:
        # Perform actual work here
        time.sleep(2)  # Simulate work
        logger.info("Task completed successfully.")
    except Exception as e:
        logger.error(f"Task failed: {str(e)}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # */45 * * * * translates to minute="0,45"
    scheduler.add_job(
        execute_job,
        'cron',
        minute='0,45',
        id='45_min_job',
        coalesce=True,
        max_instances=1
    )
    logger.info("Scheduler started. Running at minutes 0 and 45 of every hour.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped cleanly.")

package main

import (
	"context"
	"log"
	"sync"
	"time"

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

type SafeJob struct {
	mu sync.Mutex
}

func (j *SafeJob) Run() {
	// Prevent concurrent execution if a run takes longer than 15 minutes
	if !j.mu.TryLock() {
		log.Println("Previous job is still running, skipping this execution.")
		return
	}
	defer j.mu.Unlock()

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

	if err := performTask(ctx); err != nil {
		log.Printf("Error executing task: %v\n", err)
	} else {
		log.Println("Task completed successfully.")
	}
}

func performTask(ctx context.Context) error {
	select {
	case <-time.After(2 * time.Second):
		return nil
	case <-ctx.Done():
		return ctx.Err()
	}
}

func main() {
	c := cron.New()
	job := &SafeJob{}
	
	_, err := c.AddJob("*/45 * * * *", job)
	if err != nil {
		log.Fatalf("Error scheduling job: %v", err)
	}

	c.Start()
	log.Println("Cron scheduler started...")
	select {} // Keep application running
}

package com.example.scheduler;

import org.slf4j.Logger;

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

@Component
public class IntervalTaskScheduler {

    private static final Logger logger = LoggerFactory.getLogger(IntervalTaskScheduler.class);

    // Spring scheduler handles '*/45 * * * *' by expanding it to '0,45' minutes
    @Scheduled(cron = "0 0,45 * * * *")
    public void executeTask() {
        logger.info("Scheduled task execution started.");
        try {
            processBusinessLogic();
            logger.info("Scheduled task executed successfully.");
        } catch (Exception e) {
            logger.error("An error occurred during task execution", e);
        }
    }

    private void processBusinessLogic() throws InterruptedException {
        // Simulate processing workload
        Thread.sleep(5000);
    }
}

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