Execute Automation Tasks Every Minute | CronBase

const cron = require('node-cron');
let isRunning = false;

cron.schedule('*/1 * * * *', async () => {
    if (isRunning) {
        console.warn('Previous execution still active. Skipping run.');
        return;
    }
    isRunning = true;
    try {
        console.log('Executing high-frequency polling task...');
        await new Promise(resolve => setTimeout(resolve, 5000));
    } catch (error) {
        console.error('Task failed:', error);
    } finally {
        isRunning = false;
    }
});

#!/usr/bin/env bash
# Prevent overlapping executions using flock
LOCKFILE="/var/lock/my_minute_job.lock"
exec 9>"$LOCKFILE"
if ! flock -n 9; then
    echo "Job is already running. Exiting to prevent overlap."
    exit 1
fi
echo "Starting minute-by-minute execution..."
curl -f -s https://api.example.com/health || echo "Health check failed"

import os
import sys
import fcntl

lock_file_path = '/tmp/my_minute_task.lock'
lock_file = open(lock_file_path, 'w')
try:
    fcntl.flock(lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
except IOError:
    print('Another instance of this task is running. Exiting.')
    sys.exit(0)

def main():
    print('Running scheduled database cleanup and queue processing...')

if __name__ == '__main__':
    main()

package main

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

func main() {
	c := cron.New()
	var running int32
	_, err := c.AddFunc("*/1 * * * *", func() {
		if !atomic.CompareAndSwapInt32(&running, 0, 1) {
			log.Println("Previous job run still in progress, skipping.")
			return
		}
		defer atomic.StoreInt32(&running, 0)
		log.Println("Starting every-minute execution pipeline...")
		ctx, cancel := context.WithTimeout(context.Background(), 50*time.Second)
		defer cancel()
		_ = ctx
	})
	if err != nil {
		log.Fatalf("Error scheduling job: %v", err)
	}
	c.Start()
	select {}
}

package com.example.cron;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.concurrent.atomic.AtomicBoolean;

@Component
public class MinuteTaskScheduler {
    private final AtomicBoolean isRunning = new AtomicBoolean(false);

    @Scheduled(cron = "0 */1 * * * *")
    public void executeTask() {
        if (!isRunning.compareAndSet(false, true)) {
            System.out.println("Execution skipped: Previous task is still running.");
            return;
        }
        try {
            System.out.println("Executing system health and metric collection...");
        } finally {
            isRunning.set(false);
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: every-minute-worker
  namespace: default
spec:
  schedule: "*/1 * * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: busybox:1.35
            command: ["sh", "-c", "echo 'Running high-frequency queue process' && sleep 10"]
          restartPolicy: OnFailure