Automate Tasks Every 20 Minutes | CronBase

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

# Use flock to prevent overlapping executions every 20 minutes
LOCKFILE="/var/lock/my-20min-job.lock"

exec 9>"$LOCKFILE"
if ! flock -n 9; then
  echo "Error: Another instance of the job is already running." >&2
  exit 1
fi

echo "Starting 20-minute maintenance task..."
# Place actual operational logic here (e.g., sync scripts, cleanup)
/usr/local/bin/sync-api-data.sh

echo "Task completed successfully."

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

// Schedule task to run every 20 minutes (at :00, :20, and :40)
cron.schedule('*/20 * * * *', async () => {
  console.log(`[${new Date().toISOString()}] Starting scheduled sync...`);
  try {
    // Simulate operational work or call external service
    await performSync();
    console.log('Sync completed successfully.');
  } catch (error) {
    console.error('Execution failed:', error);
  }
});

async function performSync() {
  return new Promise((resolve) => setTimeout(resolve, 5000));
}

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

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("cron_job")

def execute_task():
    logger.info(f"Job started at {datetime.datetime.now()}")
    try:
        # Perform the 20-minute interval business logic
        pass
    except Exception as e:
        logger.error(f"Execution failed: {e}")

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # Trigger job every 20 minutes
    scheduler.add_job(execute_task, 'cron', minute='*/20')
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        pass

package main

import (
	"context"
	"log"
	"time"
	"github.com/robfig/cron/v3"
)

func main() {
	c := cron.New()
	_, err := c.AddFunc("*/20 * * * *", func() {
		log.Println("Starting 20-minute batch execution...")
		// Implement 18-minute timeout to prevent overlapping runs
		ctx, cancel := context.WithTimeout(context.Background(), 18*time.Minute)
		defer cancel()
		
		select {
		case <-time.After(5 * time.Second):
			log.Println("Batch execution complete.")
		case <-ctx.Done():
			log.Println("Job cancelled or timed out.")
		}
	})
	if err != nil {
		log.Fatalf("Failed to schedule cron: %v", err)
	}
	c.Start()
	select {}
}

package com.cronbase.scheduler;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.logging.Logger;

@Component
public class TwentyMinuteScheduler {
    private static final Logger LOGGER = Logger.getLogger(TwentyMinuteScheduler.class.getName());

    // Runs every 20 minutes (at :00, :20, and :40 past the hour)
    @Scheduled(cron = "0 */20 * * * *")
    public void executeTask() {
        LOGGER.info("Starting scheduled task at: " + LocalDateTime.now());
        try {
            performMaintenance();
        } catch (Exception e) {
            LOGGER.severe("Task execution encountered an error: " + e.getMessage());
        }
    }

    private void performMaintenance() {
        // Actual business logic execution
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: twenty-minute-cleanup
  namespace: default
spec:
  schedule: "*/20 * * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: busybox:1.36
            imagePullPolicy: IfNotPresent
            command:
            - /bin/sh
            - -c
            - "echo 'Starting 20-minute clean up task'; sleep 30; echo 'Task complete'"
          restartPolicy: OnFailure