How to Schedule Cron jobs tasks in Unix/Linux

Learn to schedule tasks using cronjob in Unix. This guide explains how to manage cronjob tasks in unix with practical examples.

Cron jobs are essential tools in Unix/Linux systems for automating repetitive tasks. Whether you’re backing up files, syncing data, or running maintenance scripts, cron jobs make sure your tasks run consistently and on time without manual intervention.

In this article, we’ll walk through how to add jobs to the cron scheduler (crontab) and understand its syntax so you can schedule tasks efficiently.

What is a Cron Job in Unix?

A cron job is a scheduled command or script that runs automatically at specified intervals. The cron daemon (crond) handles these jobs in the background on Unix-like operating systems.

Viewing and Editing Crontabation files

Each user has their own crontab file. To view or edit your crontab:

crontab -e

This command opens your crontab in the default system editor (like vi or nano), allowing you to add or modify jobs.

To view your current scheduled jobs:

crontab -l

To remove all scheduled cron jobs:

crontab -r

Unix Cron jobs Syntax Breakdown

A typical cron job line looks like this:

* * * * * command to be executed
- - - - -
| | | | |
| | | | ----- Day of week (0 - 7) (Sunday=0 or 7)
| | | ------- Month (1 - 12)
| | --------- Day of month (1 - 31)
| ----------- Hour (0 - 23)
------------- Minute (0 - 59)

Each * represents a time or date field. And each field can be configured based on the following table.

FieldValue RangeDescription
Minute0–59Minute of the hour
Hour0–23Hour of the day
Day1–31Day of the month
Month1–12Month of the year
Weekday0–7 (0 or 7 = Sunday)Day of the week

Example: Run backup cron job script

If you wished to have a script named /root/backup.sh run every day at 3 am, your crontab entry would look like as follows. First, install your cronjob by running the following command:

# crontab -e

Append the following entry:

0 3 * * * /root/backup.sh

Save and close the file.

More examples

To run /path/to/command five minutes after midnight, every day, enter:

5 0 * * * /path/to/command

Run /path/to/script.sh at 2:15 pm on the first of every month, enter:

15 14 1 * * /path/to/script.sh

To run any PHP script /scripts/phpscript.php at 10 pm on weekdays, enter:

0 22 * * 1-5 /scripts/phpscript.php

Run /root/scripts/perl/perlscript.pl at 23 minutes after midnight, 2am, 4am …, everyday, enter:

23 0-23/2 * * * /root/scripts/perl/perlscript.pl

Run /path/to/unixcommand at 5 after 4 every Sunday, enter:

5 4 * * sun /path/to/unixcommand

You can schedule any command using the cron jobs. For running any script using cron job, make sure your script has executable permissions.

If your script uses environment variables or specific paths, be sure to define them inside the script or call the appropriate environment setup.

Redirecting Output

To log output or errors, you can use the following command and save the logs in file:

0 0 * * * /path/to/script.sh >> /var/log/myscript.log 2>&1
  • >> appends standard output to a log file
  • 2>&1 redirects errors (stderr) to the same log file without displaying it to the console.

System-Wide Cron Jobs

System-wide cron files can be added to:

  • Hourly, daily, weekly, monthly: /etc/cron.hourly/, /etc/cron.daily/, etc.
  • /etc/crontab
  • /etc/cron.d/

Conclusion

Cron jobs are powerful for scheduling recurring tasks in Unix/Linux environments. By mastering crontab syntax and scheduling structure, you can automate system maintenance, backups, and custom scripts with ease.

Make sure to test your scripts before scheduling them and check logs regularly to confirm successful execution.

See also

See man pages for more information cron(8), crontab(1), crontab(5), run-parts(8)

Automatically Kill Slow MySQL Queries After N Seconds

Learn how to detect and automatically terminate slow MySQL queries after a set duration. Improve performance and avoid database slowdowns.

Maintaining a performant MySQL-backed application requires smart tuning. Without it, connections may pile up, queries stall, and user experience suffers dramatically, especially due to slow queries.

If you’re using persistent connections, idle or long-running queries can accumulate in SLEEP mode for a log time. One quick solution – especially on MySQL ≥ 5.1 – is to periodically scan the process list and terminate any query that’s been running longer than your acceptable threshold and currently in SLEEP mode.

In this post, we will learn some techniques to identify these slow queries and kill them to improve the performance of the application.

Step 1: Generate KILL QUERY Statements

This SQL query will produce the necessary KILL QUERY commands for any non-system query exceeding your time limit (e.g., 1200 seconds = 20 minutes):

SELECT
  GROUP_CONCAT(
    CONCAT('KILL QUERY ', id, ';')
    SEPARATOR ' '
  ) AS kill_cmds
FROM information_schema.processlist
WHERE user <> 'system user'
  AND time >= 1200;

You can customize the filter via the info column – for instance, if you want queries from specific database (db) or certain query patterns, you can apply those filters to info column and update the above query accordingly.

This query gives you the complete list of slow queries as per your filters. But, you need to run it everytime, whenever you want this data.

So, to automate this process, add this query to cronjob via a shell script.

Step 2: Automate with a Shell Script

Wrap this logic in a shell script and schedule it with cron to run at regular intervals. Here’s a refined example:

SECONDS_TOO_LONG=1200

QUERIES_RUNNING_TOO_LONG=`mysql -uroot -ppassword -ANe"SELECT COUNT(1) FROM information_schema.processlist WHERE user <> 'system user' AND time >= ${SECONDS_TOO_LONG}"`

if [ ${QUERIES_RUNNING_TOO_LONG} -gt 0 ]
then
    KILLPROC_SQLSTMT="SELECT GROUP_CONCAT(CONCAT('KILL QUERY ',id,';') SEPARATOR ' ') KillQuery FROM information_schema.processlist WHERE user <> 'system user' AND time >= ${SECONDS_TOO_LONG}"
    mysql -uroot -ppassword -ANe"${KILLPROC_SQLSTMT}" | mysql -uroot -ppassword
fi

This ends all slow MySQL queries running over 20 minutes and can be scheduled every few minutes in crontab.

Alternative: Log and Kill via a Temporary SQL File

Alternatively, if you want to log all the slow MySQL queries before killing them, here’s a safe method:

SECONDS_TOO_LONG=1200

QUERIES_RUNNING_TOO_LONG=`mysql -uroot -ppassword -ANe"SELECT COUNT(1) FROM information_schema.processlist WHERE user <> 'system user' AND time >= ${SECONDS_TOO_LONG}"`
if [ ${QUERIES_RUNNING_TOO_LONG} -gt 0 ]
then
    KILLPROC_SQLSTMT="SELECT CONCAT('KILL QUERY ',id,';') KillQuery FROM information_schema.processlist WHERE user <> 'system user' AND time >= ${SECONDS_TOO_LONG}"
    mysql -uroot -ppassword -ANe"${KILLPROC_SQLSTMT}" > /tmp/kill_log_queries.sql
    mysql -uroot -ppassword < /tmp/kill_log_queries.sql
fi

This approach gives you a chance to log or inspect the kill commands before they run.

Want to learn more about tuning MySQL performance? Get High Performance MySQL book from https://amzn.to/4dVaueF

Built-In Per-Session Execution Timeout (MySQL 5.7+)

If you’re using MySQL 5.7.4+, a cleaner solution exists:

SET GLOBAL max_execution_time = 5000; -- Timeout in milliseconds

This applies a soft execution limit to all SELECT queries (read-only) at runtime. Once exceeded, MySQL aborts the query with an error but keeps the session alive.

You can also set per-session limits:

SET SESSION max_execution_time = 2000;

Or use the hint syntax on specific queries:

SELECT /*+ MAX_EXECUTION_TIME(1000) */ * FROM your_table; 

Conclusion

Choose the approach that fits your environment:

  • Older MySQL (< 5.7): Use a cron-driven shell script targeting INFORMATION_SCHEMA.PROCESSLIST.
  • MySQL 5.7.4 and above: Prefer max_execution_time or per-query hints for cleaner, built-in enforcement.

They all help safeguard against runaway queries that could otherwise lock up your server.

Disclaimer: This post contains affiliate links. If you use these links to buy something, I may earn a commission at no extra cost to you.