Job Control

8.2 Job Control

Why should you care about process IDs or job numbers? Actually, you could probably get along fine through your UNIX life without ever referring to process IDs (unless you use a windowing workstation ”as we'll see soon). Job numbers are more important, however: you can use them with the shell commands for job control . [4]

[4] If you have an older version of UNIX, it is possible that your system does not support job control. This is particularly true for many systems derived from Xenix, System III, or early versions of System V. On such systems, bash does not have the fg and bg commands, job number arguments to kill and wait , typing CTRL-Z to suspend a job, or the TSTP signal.

You already know the most obvious way of controlling a job: create one in the background with & . Once a job is running in the background, you can let it run to completion, bring it into the foreground , or send it a message called a signal .

8.2.1 Foreground and Background

The built-in command fg brings a background job into the foreground. Normally this means that the job will have control of your terminal or window and therefore will be able to accept your input. In other words, the job will begin to act as if you typed its command without the & .

If you have only one background job running, you can use fg without arguments, and the shell will bring that job into the foreground. But if you have several jobs running in the background, the shell will pick the one that you put into the background most recently. If you want some other job put into the foreground, you need to use the job's command name , preceded by a percent sign (%), or you can use its job number, also preceded by %, or its process ID without a percent sign. If you don't remember which jobs are running, you can use the command jobs to list them.

A few examples should make this clearer. Let's say you created three background jobs as above. Then if you type jobs , you will see this:

 [1] Running alice & 
 [2]- Running duchess & 
 [3]+ Running hatter & 

jobs has a few interesting options. jobs -l also lists process IDs:

 [1] 93 Running alice & 
 [2]- 102 Running duchess & 
 [3]+ 104 Running hatter & 

The -p option tells jobs to list only process IDs:

 93 
 102 
 104 

(This could be useful with command substitution; see Task 8-1.) The -n option lists only those jobs whose status has changed since the shell last reported it ”whether with a jobs command or otherwise . -r restricts the list to jobs that are running, while -s restricts the list to those jobs which are stopped , e.g., waiting for input from the keyboard. [5] Finally, you can use the -x option to execute a command. Any job number provided to the command will be substituted with the process ID of the job. For example, if alice is running in the background, then executing jobs -x echo %1 will print the process ID of alice .

[5] Options -r and -s are not available in bash prior to version 2.0.

If you type fg without an argument, the shell will put hatter in the foreground, because it was put in the background most recently. But if you type fg %duchess (or fg %2 ), duchess will go in the foreground.

You can also refer to the job most recently put in the background by %+ . Similarly, %- refers to the next -most-recently backgrounded job ( duchess in this case). That explains the plus and minus signs in the above: the plus sign shows the most recent job whose status has changed; the minus sign shows the next-most-recently invoked job. [6]

[6] This is analogous to ~+ and ~- as references to the current and previous directory; see the footnote in Chapter 7 . Also: %% is a synonym for %+ .

If more than one background job has the same command, then % command will distinguish between them by choosing the most recently invoked job (as you'd expect). If this isn't what you want, you need to use the job number instead of the command name. However, if the commands have different arguments , you can use %? string instead of % command . %? string refers to the job whose command contains the string. For example, assume you started these background jobs:

 $  hatter mad &  [1] 189   
  $   hatter teatime &  [2] 190   
  $  

Then you can use %?mad and %?teatime to refer to each of them, although actually %?ma and %?tea are sufficient to uniquely identify them.

Table 8.1 lists all of the ways to refer to background jobs. Given how infrequently people use job control commands, job numbers or command names are sufficient, and the other ways are superfluous.

Table 8.1. Ways to Refer to Background Jobs

Reference

Background job

% N

Job number N

% string

Job whose command begins with string

% ? string

Job whose command contains string

%+

Most recently invoked background job

%%

Same as above

% -

Second most recently invoked background job

8.2.2 Suspending a Job

Just as you can put background jobs into the foreground with fg , you can also put a foreground job into the background. This involves suspending a job, so that the shell regains control of your terminal.

To suspend a job, type CTRL-Z while it is running. [7] This is analogous to typing CTRL-C (or whatever your interrupt key is), except that you can resume the job after you have stopped it. When you type CTRL-Z, the shell responds with a message like this:

[7] This assumes that the CTRL-Z key is set up as your suspend key; just as with CTRL-C and interrupts, this is conventional but by no means required.

  [1]+ Stopped   command    

Then it gives you your prompt back. To resume a suspended job so that it continues to run in the foreground, just type fg . If, for some reason, you put other jobs in the background after you typed CTRL-Z, use fg with a job name or number.

For example:

   alice is running...     CTRL-Z  [1]+ Stopped alice    
   $     hatter &  [2] 145    
   $     fg %alice   alice resumes in the foreground...   

The ability to suspend jobs and resume them in the foreground comes in very handy when you have a conventional terminal (as opposed to a windowing workstation) and you are using a text editor like vi on a file that needs to be processed . For example, if you are editing a file for the troff text processor, you can do the following:

  $  vi myfile   edit the file...   CTRL-Z  Stopped [1] vi    
   $     troff myfile   troff reports an error   $   fg   vi comes back up in the same place in your file   

Programmers often use the same technique when debugging source code.

You will probably also find it useful to suspend a job and resume it in the background instead of the foreground. You may start a command in the foreground (i.e., normally) and find that it takes much longer than you expected ”for example, a grep , sort , or database query. You need the command to finish, but you would also like control of your terminal back so that you can do other work. If you type CTRL-Z followed by bg , you will move the job to the background. [8]

[8] Be warned , however, that not all commands are "well-behaved" when you do this. Be especially careful with commands that run over a network on a remote machine; you may end up confusing the remote program.

You can also suspend a job with CTRL-Y. This is slightly different from CTRL-Z in that the process is only stopped when it attempts to read input from the terminal.

 



Learning the Bash Shell
Learning the bash Shell: Unix Shell Programming (In a Nutshell (OReilly))
ISBN: 0596009658
EAN: 2147483647
Year: 1998
Pages: 104

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net