pgrep Command: Tutorial & Examples
Search and list processes by name or attributes
The pgrep
command is a versatile and efficient Linux utility designed to find the process IDs (PIDs) of running processes by matching
their names or other process attributes. Unlike traditional methods that require filtering the output of commands like ps
with grep
, pgrep
provides a direct way to identify processes, making process management simpler and more reliable. This article explains
how pgrep
works, its common options, practical usage examples, potential pitfalls, advanced scripting integration, and related commands, offering a thorough
reference for system administrators and users managing Linux servers.
What pgrep Does
pgrep
scans the list of currently running processes and outputs the PIDs of those that match the user-specified patterns or attributes. It allows filtering by
process name, user, group, terminal, parent process, and other criteria. This capability is essential for tasks such as monitoring, controlling, or automating
actions on specific processes, without manually parsing large process lists.
How pgrep Works
On Linux systems, pgrep
obtains information about running processes by reading the proc filesystem, which exposes process details
such as the command name, user IDs, group IDs, and command line arguments. It then compares this information against the patterns or filters provided by the
user. When a process matches the specified criteria, pgrep
outputs its PID. This scanning is done efficiently by iterating over process entries in /proc
and
applying filtering logic internally, eliminating the need for external command pipelines.
Why pgrep Is Important
Managing processes is a fundamental aspect of system administration. pgrep
streamlines identification of processes, reducing the
complexity and chance of errors compared to manual parsing of process lists. It is particularly valuable in scripts and automation, where precise and reliable
process selection is critical. By supporting filtering by user, group, terminal, and other attributes, pgrep
enables fine-grained control over process
management tasks.
How to Use pgrep
The basic syntax of pgrep
is:
pgrep [options] pattern
Here, pattern
typically represents the name or part of the name of the process to search for. For example, to find the PIDs of all processes named "sshd":
pgrep sshd
This command outputs the PIDs of all processes whose names contain the substring "sshd".
Common Command Line Parameters
Here are some of the most frequently used options for pgrep
:
-u userlist
Match processes owned by one or more users, specified as a comma-separated list of usernames or user IDs.-U userlist
Match processes with real user IDs in the specified list.-g grouplist
Match processes belonging to one or more groups, specified by group names or group IDs.-G grouplist
Match processes with real group IDs in the specified list.-t ttylist
Match processes attached to specified terminal devices (e.g., pts/0).-P ppidlist
Match processes whose parent process ID is in the specified list.-n
Select only the newest process among matches.-o
Select only the oldest process among matches.-l
List process IDs alongside their process names.-f
Match against the full command line instead of just the process name.-x
Match the exact process name (not a substring).-i
Perform case-insensitive matching of patterns.-d delimiter
Use a custom delimiter instead of the default newline for separating output entries.-c
Show the count of matching processes instead of their PIDs.-v
Negate the match, listing PIDs of processes that do not match the pattern.-a
Show the process ID and the full command line.
Practical Examples Using pgrep
Find all processes named "nginx":
pgrep nginx
Sample output:
1234 1235 1236
Find processes owned by user "www-data" running "apache2":
pgrep -u www-data apache2
Find the newest "bash" process:
pgrep -n bash
List PIDs with process names for all "sshd" processes:
pgrep -l sshd
Sample output:
2345 sshd 2350 sshd
Match full command line for pattern "python script.py":
pgrep -f "python script.py"
Count how many "mysqld" processes are running:
pgrep -c mysqld
Sample output:
3
Find all processes not matching "systemd":
pgrep -v systemd
Find processes by parent PID, e.g., children of PID 1:
pgrep -P 1
Find processes with case-insensitive matching for "Cron":
pgrep -i cron
Get comma-separated list of PIDs for "sshd":
pgrep -d ',' sshd
Sample output:
2345,2350
Potential Problems and Pitfalls
Partial Matches:
By default,pgrep
matches any substring in the process name, which may result in unintended matches. To avoid this, use the-x
option to match the exact process name.Case Sensitivity:
Pattern matching is case sensitive by default. Use-i
for case-insensitive matching if supported by your version.Permissions and Visibility:
Without sufficient privileges,pgrep
may not see processes owned by other users, leading to incomplete results.PID Reuse and Race Conditions:
Since PIDs are reused by the system after a process terminates, scripts relying solely on PIDs can act on unintended processes. Always verify the process identity before performing actions.Multiple Matches:
When multiple processes match the pattern,pgrep
outputs all matching PIDs. This behavior may affect scripts that expect a single PID. Use options like-n
or-o
to select newest or oldest process only.Matching Full Command Line (-f):
Matching the full command line can produce false positives if the pattern is too generic or common.
Tips and Best Practices
Use exact matching (
-x
) when you want to avoid partial matches:kill $(pgrep -x processname)
Check the exit status of
pgrep
in scripts:
A zero exit code means at least one match was found, non-zero means no matches.Filter by user (
-u
) to target processes owned by specific users, especially on multi-user systems.Use the
-d
option to customize output delimiters for easier parsing in scripts.Combine
pgrep
with other commands likekill
,xargs
, orawk
for automation and process management.When scripting, guard against PID reuse by validating process details before killing or restarting.
Advanced Usage and Scripting Integration
pgrep
integrates well into shell scripts and automation workflows. Some practical examples:
Restart all matching processes by sending SIGHUP:
pgrep -x myapp | xargs -r kill -HUP
Monitor if a service is running and send an alert if not:
if ! pgrep -x myservice > /dev/null; then echo "myservice is not running!" | mail -s "Service Alert" admin@example.com fi
Count running processes and act accordingly:
count=$(pgrep -c sshd) if [ "$count" -eq 0 ]; then echo "No sshd processes running" else echo "There are $count sshd processes" fi
Use in cron jobs to check and restart services if needed.
Combine with regular expressions for flexible pattern matching (if supported):
pgrep -f "python.*script\.py"
Security Considerations
pgrep
can only list processes visible to the user running it. Unprivileged users may not see all processes, which can limit effectiveness.Running
pgrep
as the superuser (root
) allows full visibility but should be done cautiously to avoid security risks.When using
pgrep
in scripts that perform actions like killing processes, ensure proper validation to avoid unintended system disruption.
Performance Considerations
On systems with a large number of processes,
pgrep
may take longer to scan all processes.Using specific filters (like user or exact match) reduces overhead.
Frequent polling using
pgrep
in scripts or monitoring tools should be balanced to avoid unnecessary system load.
Comparison With Alternatives
pidof
also finds process IDs by name but lacks many filtering options available inpgrep
.Using
ps
combined withgrep
can achieve similar results but is less efficient and more error-prone.pkill
works likepgrep
but sends signals to matched processes, allowing direct control.
See Also
Further Reading
- Linux for Hackers by Mark Reed (partner link)
- How Linux Works by Brian Ward (partner link)
- Linux for Beginners by Jason Cannon (partner link)
- Expert Linux Administration Guide by Vishal Rai (partner link)
As an Amazon Associate, I earn from qualifying purchases.