Limit the output of the TOP command to a specific process name

If you call the top command, you get all the running processes. But how can I limit the output only to a certain process name like开发者_开发百科 "java"?

I've tried this top -l 2 | grep java but in this way you get only snapshots and not a continuously updated list. And top -l 0 | grep java is not really clear.

I prefer the following so I can still use top interactively without having to look up the pids each time I run it:

top -p `pgrep process-name | tr "\\n" "," | sed 's/,$//'`

Of course if the processes change you'll have to re-run the command.

Explanation:

• pgrep process-name returns a list of process ids which are separated by newlines
• tr "\\n" "," translates these newlines into commas, because top wants a comma-separated list of process ids
• sed is a stream editor, and sed 's/,$//' is used here to remove the trailing comma

Find the pids of the processes you want to monitor and then use the -p option which allows you to provide a list of pids to the top command.

Example:

top -p 18884 -p 18892 -p 18919

  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND
18884 user  25   0  672M  95M  9476 S     0.0  1.1   0:02   1 java
18892 user  25   0 2280M 123M 12252 S     0.0  1.5   0:05   1 java
18919 user  22   0 1492M 198M 28708 S     0.0  2.4   0:07   1 java

(I believe you can also pass in a comma-separated list.)

how about top -b | grep java

Expanding on @dogbane's answer, you can get all the PIDs for a named process with pgrep to do the following:

top -p "$(pgrep -d ',' java)"

Use the watch command

watch -d 'top -n1 | grep mysql'

Using the answer from here I was able to create a one liner

top -pid $(pgrep process_name | sed -e ':a' -e 'N' -e '$!ba' -e 's/\n/ -pid /g')

This works for me on MacOS 10.12 (Sierra)

I solved my problem using:

top -n1 -b | grep "proccess name"

in this case: -n is used to set how many times top will what proccess
and -b is used to show all pids

it's prevents errors like : top: pid limit (20) exceeded

The following code updates a list of processes every 5 seconds via the watch command:

watch -n 5 -t top -b -n 1 -p$(pgrep java | head -20 | tr "\\n" "," | sed 's/,$//')

I run it (eg.): top -b | egrep -w 'java|mysqld'

Suppose .. if we have more than 20 process running on the server with the same name ... this will not help

top -p pgrep oracle | head -n 20 | tr "\\n" "," | sed 's/,$//'

It will try to list and provide real time output of 20 process where we have good chance of missing other prcesses which consumes more resource ....

I am still looking for better option on this

A more specific case, like I actually was looking for:

For Java processes you can also use jps -q whereby jps is a tool from $JAVA_HOME/bin and hence should be in your $PATH.

I came here looking for the answer to this on OSX. I ended up getting what I wanted with bash and awk:

topfiltered() {
  [[ -z "$1" ]] && return
  dump="/tmp/top_dump"
  rm -f "$dump"
  while :; do
    clear
    [[ -s "$dump" ]] && head -n $(( $LINES - 1 )) "$dump"
    top -l 1 -o cpu -ncols $(( $COLUMNS / 8 )) | awk -v p="$(pgrep -d ' ' $@)" '
        BEGIN { split(p, arr); for (k in arr) pids[arr[k]]=1 }
        NR<=12 || ($1 in pids)
    ' >"$dump"
  done
}

I loop top in logging mode and filter it with awk, building an associative array from the output of pgrep. Awk prints the first 12 lines, where line 12 is the column headers, and then every line which has a pid that's a key in the array. The dump file is used for a more watchable loop.

just top -bn 1 | grep java will do the trick for you

Running the below will give continuous update in console:

bcsmc2rtese001 [~]$ echo $SHELL  
/bin/bash  
bcsmc2rtese001 [~]$ top | grep efare  or watch -d 'top | grep efare' or top -p pid
27728 efare     15   0 75184 3180 1124 S  0.3  0.0 728:28.93 tclsh  
27728 efare     15   0 75184 3180 1124 S  0.7  0.0 728:28.95 tclsh

Here's the only solution so far for MacOS:

top -pid `pgrep java | awk 'ORS=" -pid "' | sed 's/.\{6\}$//'`

though this will undesirably report invalid option or syntax: -pid if there are no java processes alive.

EXPLANATION

The other solutions posted here use the format top -p id1,id2,id3, but MacOS' top only supports the unwieldy format top -pid id1 -pid id2 -pid id3.

So firstly, we obtain the list of process ids which have process name "java":

pgrep java

and we pipe this to awk which joins the results with delimitor " -pid "

| awk 'ORS=" -pid "'

Alas, this leaves a trailing delimitor! For example, we may so far have obtained the string "123 -pid 456 -pid 789 -pid ".

We then just use sed to shave off the final 6 characters of the delimitor.

| sed 's/.\{6\}$//'`

We're ready to pass the results to top:

top -pid `...`

get pid of process:

# pidof <process>

tell top what process pid(s) to display

# top -p <pid1>,<pid2>, etc

example:

landis@linux-e6510:~>pidof konsole
1841 1709
landis@linux-e6510:~>top -p 1841,1709

Top will only display the 2 'konsole' processes. This is useful on a busy server via ssh, not having to pipe thru grep.

You need to feed the output of pgrep {proc_name} to top -pid {pid_No}. The problem with top -pid is that it expects -pid before each pid you want to monitor.

On Mac in zsh I can handle this problem e.g. like that:

top `pgrep proc_name | awk '{printf " -pid %d",$1}'`

It's not ideal too, because pgrep looks for substrings in process names. E.g. pgrep dd can return results for icdd, hidd, cloudd etc. The option pgrep -x should return the exact matches only (like grep -w). But it doesn't work for me in Mac Terminal, although it does in Ubuntu virtual machine.

Using the approach mentioned in the answer by Rick Byers:

top -p `pgrep java | paste -sd "," -`

but I had more than 20 processes running so following command can be helpful for someone who encounter a similar situation.

top -p `pgrep java | head -n 20 | paste -sd "," -`

pgrep gets the list of processes with given name - java in this case. head is used to get first 20 pids because top cannot handle more than 20 pids when using -p argument. Finally paste joins the list of pids with ','.

You can control the process name you are looking for in the above command and the number of processes with that name you are interested to watch. You can ignore the head -n 20 part if the number of your processes with the given name is less than 20.