Run Recurring Jobs Every Four Hours | CronBase

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

// Schedule task to run every 4 hours (0 */4 * * *)
cron.schedule('0 */4 * * *', () => {
    console.log(`[${new Date().toISOString()}] Starting scheduled 4-hour job...`);
    try {
        performMaintenance().catch(err => {
            console.error('Task execution failed:', err);
        });
    } catch (error) {
        console.error('Failed to trigger task:', error);
    }
});

async function performMaintenance() {
    // Simulated production workload
    return new Promise((resolve) => setTimeout(resolve, 5000));
}

#!/usr/bin/env bash
# Production Bash script for 4-hour cron execution
set -euo pipefail
LOG_FILE="/var/log/my_app_four_hour_job.log"
exec >> "$LOG_FILE" 2>&1
echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Starting 4-hour maintenance task..."
LOCK_FILE="/var/run/my_app_four_hour_job.lock"
exec 200>"$LOCK_FILE"
if ! flock -n 200; then
    echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] ERROR: Another instance is already running." >&2
    exit 1
fi
echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Running database maintenance..."
# Workload logic goes here
echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Task completed successfully."

import logging
from apscheduler.schedulers.blocking import BlockingScheduler

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

def run_four_hour_job():
    logger.info("Starting scheduled 4-hour maintenance job...")
    try:
        # Place actual production logic here
        pass
    except Exception as e:
        logger.error(f"Job failed with error: {e}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    scheduler.add_job(run_four_hour_job, 'cron', hour='*/4', minute=0)
    logger.info("Scheduler started. Running every 4 hours.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped.")

package main

import (
    "log"
    "os"
    "os/signal"
    "syscall"
    "github.com/robfig/cron/v3"
)

func main() {
    logger := log.New(os.Stdout, "[4-Hour-Job] ", log.LstdFlags|log.Lshortfile)
    c := cron.New()
    _, err := c.AddFunc("0 */4 * * *", func() {
        logger.Println("Executing scheduled 4-hour maintenance...")
        if err := executeWorkload(); err != nil {
            logger.Printf("Error during execution: %v\n", err)
        }
    })
    if err != nil {
        logger.Fatalf("Failed to schedule cron job: %v", err)
    }
    c.Start()
    logger.Println("Cron scheduler started successfully")
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
    <-sigChan
    logger.Println("Shutting down scheduler...")
    c.Stop()
}

func executeWorkload() error {
    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;

@Component
public class FourHourMaintenanceJob {
    private static final Logger logger = LoggerFactory.getLogger(FourHourMaintenanceJob.class);

    // Spring cron expression uses 6 fields (second, minute, hour, day, month, day-of-week)
    @Scheduled(cron = "0 0 */4 * * *")
    public void runMaintenanceTask() {
        logger.info("Starting scheduled 4-hour maintenance task...");
        try {
            executeWorkload();
            logger.info("Maintenance task completed successfully.");
        } catch (Exception e) {
            logger.error("Error executing maintenance task", e);
        }
    }

    private void executeWorkload() {
        // Production workload logic goes here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: four-hour-maintenance-job
  namespace: default
spec:
  schedule: "0 */4 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: busybox:1.35
            command:
            - /bin/sh
            - -c
            - echo "Starting 4-hour maintenance task..."; sleep 30; echo "Task completed."
          restartPolicy: OnFailure