Up to this point in the tutorial, you've been running just one process at a time. However, since UNIX is a multi-tasking operating system, you are not limited to a single process -- you can run an arbitrary number of processes simultaneously (within the constraints imposed by the resources available on the system). So far, in your interactions with the shell you've been launching a process and then waiting for it to complete and return control back to the shell (at which point you see the shell prompt again). This is called running a process in the foreground. It is also possible to run a process in the background. In this case, the program is launched and control is returned the the shell immediately, allowing you to run other commands. In the meantime, the initial process continues to run in the background. To place a process in the background when you launch it, add the ampersand character ('&') to the end of the command line (.e.g., "myprog &"). The ability to launch programs and move them between foreground and background execution is often called job control.

Exercise 13.1

We will use the date and sleep commands to create process that runs long enough for us to see that the process continues to run in the background. The date command simply prints the current date and time, while sleep just waits for specified amount of time and does nothing productive (yes, it's a very lazy program!). We are going to run date twice, with a sleep in the middle. We'll use parentheses to run the three programs as a group, but we still need to separate each command so the shell recognizes them as distinct entities (this is done with the semicolon). The output will be redirected to a file.

          % (date; sleep 60; date) > date.out &

Notice that the shell prompt returns immediately. Quickly enter the jobs command to see what processes are running:

	  % jobs
          [1]  + Running              ( date; sleep 60; date ) > date.out

The number is square brackets is the job id for the process you are running. Note that this is different from the process id, which is a unique number assigned to all processes running on the system. The job id is a sequential number assigned to the processes associated with the current shell you are running. The first one you launch is 1, the second one is 2, and so forth.

Next look at the contents of the output file:

	  % cat date.out
          Wed Sep 19 10:04:22 PDT 2002

Keep doing this every few seconds until the second date shows up in the output file. It should be exactly 60 seconds later than the first date. You will also notice a message from the shell telling you the process that was running in the background has completed:

	  % cat date.out
          Wed Sep 19 10:04:22 PDT 2002
          Wed Sep 25 10:05:42 PDT 2002
          [1]  + Done                 ( date; sleep 20; date ) > date.out

Exercise 13.2

Run the same command used in the previous exercise, but omit the ampersand at the end:

          % (date; sleep 60; date) > date2.out

Notice that the shell prompt does not return immediately. Now press CTRL-Z. The shell prompt should return. Then use jobs to see the current status of the job:

	  % jobs
          [1]  + Suspended       ( date; sleep 60; date ) > date2.out

The job has been suspended. Now place it in the background using the bg command. If you have multiple jobs, you can specify which one to place in the background using "%N", where "N" is the job id (e.g., "%1" for job id 1). If you only have one job, you can omit the job id.

          % bg %1
          [1]    ( date; sleep 60; date ) > date2.out &

Your shell prompt should return and the process will continue to execute in the background. If you later decide to move the process back to the foreground, this is done with the fg command.

          % fg %1

Now the shell prompt goes away and the process will only return control to the shell when it completes.

Exercise 13.3

Run the sleep command in the foreground. Wait a few seconds and press CTRL-C. This will terminate the sleep command and return control to the shell.

          % sleep 600
          % 

Now run the same command in the background. Then run jobs to verify that it is running and display the job id. Finally, instruct the program to exit using kill along with the job id for the process.

          % sleep 600 &
          [1] 733

          % jobs
          [1]  + Running                sleep 600

          % kill %1

          % jobs
          [1]    Terminated             sleep 600

Exercise 13.4

Run sleep in the background again. Then use ps and grep to find its process id and use kill to terminate it.

          % sleep 600 &

          % ps -ef | grep sleep
          boris  1582  2125  0 11:41:22 pts/3    0:00 sleep 600

          % kill 1582

Note that when using kill with a process id, we just supply the process id (no '%' before the id). To confirm the process has been terminated, you can repeat the ps -ef | grep sleep command above.

In general, a higher priority is given to interactive processes (such as the login shell you are using now). This makes the system much more pleasant to use for humans, since we tend not to like waiting around for machines to do work for us. Therefore, you want to be careful when running batch processes (for example, a sort of a huge text database) to avoid using up all of the CPU resources and making interactive use of the system frustrating for other users. The nice program is perfect for this application. You can use it to lower the scheduling priority of your batch process. Generally, this will not increase the run time of your process significantly, but it will often help to reduce its effect on interactive processes a great deal.

Exercise 13.5

Run sleep in the background again, this time using nice to lower the scheduling priority. Note that non-administrative users can assign nice values between 0 (no effect) and 19 (greatest effect). The higher the nice value, the lower the scheduling priority (in other words, the nicer the program becomes!).

	  % nice +19 sleep 600 &