How to Run a Job Every 3 Hours | CronBase

#!/usr/bin/env bash
set -euo pipefail

# Lockfile to prevent overlapping executions
LOCKFILE="/var/run/tri_hourly_job.lock"

# Run with flock to ensure exclusive execution
0 */3 * * * /usr/bin/flock -n "$LOCKFILE" /usr/local/bin/my-task.sh >> /var/log/my-task.log 2>&1

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

// Schedule task to run every 3 hours (0 */3 * * *)
cron.schedule('0 */3 * * *', async () => {
  log.info('Starting tri-hourly scheduled task...');
  try {
    await performTask();
    log.info('Task completed successfully.');
  } catch (error) {
    log.error('Task failed with error: ', error);
  }
}, {
  scheduled: true,
  timezone: 'UTC'
});

async function performTask() {
  // Production task logic goes here
  return Promise.resolve();
}

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 tri_hourly_job():
    logger.info("Executing tri-hourly scheduled job")
    try:
        # Production logic goes here
        pass
    except Exception as e:
        logger.error(f"Execution failed: {e}", exc_info=True)

if __name__ == '__main__':
    scheduler = BlockingScheduler(timezone='UTC')
    scheduler.add_job(tri_hourly_job, 'cron', hour='*/3', minute=0, id='tri_hourly_sync')
    logger.info("Scheduler started. Running job every 3 hours.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped.")

package main

import (
	"log"
	"time"

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

func main() {
	// Initialize cron scheduler with UTC timezone
	nyc, err := time.LoadLocation("UTC")
	if err != nil {
		log.Fatalf("Error loading UTC timezone: %v", err)
	}

	c := cron.New(cron.WithLocation(nyc))
	_, err = c.AddFunc("0 */3 * * *", func() {
		log.Println("Starting tri-hourly task execution...")
		if err := executeTask(); err != nil {
			log.Printf("Task execution failed: %v", err)
		}
	})
	if err != nil {
		log.Fatalf("Failed to schedule job: %v", err)
	}

	c.Start()
	log.Println("Cron engine initialized")
	select {} // Keep application alive
}

func executeTask() error {
	// Production logic goes here
	return nil
}

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 TriHourlyScheduler {

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

    // Spring cron format includes seconds: "0 0 */3 * * *" translates to every 3 hours
    @Scheduled(cron = "0 0 */3 * * *", zone = "UTC")
    public void executeTriHourlyTask() {
        logger.info("Tri-hourly scheduled execution started.");
        try {
            runBusinessLogic();
            logger.info("Tri-hourly scheduled execution completed successfully.");
        } catch (Exception e) {
            logger.error("Error during scheduled execution", e);
        }
    }

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

apiVersion: batch/v1
kind: CronJob
metadata:
  name: tri-hourly-sync-job
  namespace: default
spec:
  schedule: "0 */3 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: python:3.10-slim
            command: ["python", "-c", "print('Running scheduled task')"]
          restartPolicy: OnFailure