Learn how to resolve the ‘exclusive lock’ error when using a package manager like apt on Ubuntu. Step-by-step fixes for Ubuntu and Debian-based distros.
After start, Synaptic Package Manager in Ubuntu sometimes gives error
Unable to get exclusive lock. This usually means that another package management application(like apt-get or aptitude) is already running. Please close that application first.
In this post, we will learn about the causes and solutions for this error.
There are multiple causes for this error. As the message says, it means that Ubuntu package manager is already running.
After Boot
Cause
By default, Ubuntu runs a check after reboot automatically — not immediately, but some time within. So, during this time if you try to run the update command, you will get this error.
Solution
For Ubuntu automatic system checks, you have to wait for it to complete and then run your update command.
You can check, if any system check is running or not using the following command,
ps aux | grep dpkg | grep -v grep
If it shows any text then it means system is still updating, just wait for it to completed.
Software Updater is Running
Cause
Sometimes after boot, system software updater popup comes with many system updates. You can cancel this update and it will close. But, if you accept the updates, it will start updating the system.
If this updater is running and you try to run the update command, you will get same error as above.
Solution
Generally, it is not advised to pause the updater. Once an update has started, allow it to run its course. So, wait for some time till it completes and then run your update command.
Otherwise, you can pause the updater to run update command from terminal and restart the updater later after your update command completes.
Troubleshooting guide to fix the 404 error when accessing phpMyAdmin on localhost. Learn common causes and step-by-step solutions for Apache and Nginx servers.
To run phpmyadmin without getting 404 error, configure apache.conf for phpmyadmin.
gksu gedit /etc/apache2/apache2.conf
Then add the following line to the end of the file.
Include /etc/phpmyadmin/apache.conf
And restart apache
/etc/init.d/apache2 restart
Please read this section in Ubuntu wiki describes the 404 error problem for phpmyadmin.
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.
Field
Value Range
Description
Minute
0–59
Minute of the hour
Hour
0–23
Hour of the day
Day
1–31
Day of the month
Month
1–12
Month of the year
Weekday
0–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:
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.
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
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.
Learn how to run JAR files directly from the terminal on ubuntu. Includes syntax examples, troubleshooting tips, and Java runtime requirements.
To execute .jar file, java command should be used as below:
java -jar {path_of_the_file}/{file_name}.jar
And to execute above command, Java package must be installed on Ubuntu PC. To check if java package is already installed, execute below command in a terminal:
java -version
It should display current version of Java package installed.
If it displays “The program java can be found in the following packages”, It means Java hasn’t been installed yet. Execute below command in a terminal to install java package,
sudo apt-get install default-jre
This will install the Java Runtime Environment (JRE) only not Java Development Kit (JDK). If Java Development Kit (JDK) is needed, which is usually needed to compile Java applications, execute the following command in terminal:
sudo apt-get install default-jdk
That is everything to install Java. Now run first command to execute .jar file.