These notes cover the basics of processes, signals and their control keys and some concept on processes.

• add & at the end of a command to run the process in the background
• Process IDs referee to processes in the entire system.
• Job numbers refers to processes running in the background of the current shell.
  • Job numbers are simple (ex. 1, 2, 3…), which Process IDs are not.
• When jobs completes with 0 exit status Done, along with the job number and command.
• Jobs completing with a non-zero exit status prints Exit followed by the exit status number, instead of Done.

• fg command brings a job into foreground; meaning, you can interact with it and have no access to the shell command line.
  • No arguments with fg, brings most recent job to foreground. Same as fg %+ (plus means the most recent job).
  • The next/second most recent job is assigned –, which you can get with fg %-.
  • When you get the list of jobs with jobs command you will see the + and – after job number for the most and second most recent jobs.
• To bring specific jobs to foreground:
  • fg %command_name  – brings the most recent process that uses command_name.
  • fg %job_number – brings the specified job_number.
  • fg process_ID – brings the specified process_ID. (**Note: process ID has no % before it)
  • fg %?string – You can type the first part of a command and the rest will be predicted. For example, if command name is python you can type fg %? pyt.
• bg command sends process to the background.

• jobs command lists all jobs currently running.
  • -p prints only process ID.
  • -l prints with process ID

Signals

• Use CTRL-C first, if it doesn’t work use CTRL-\, then if that fails too use KILL signal. However, KILL is not linked to a control key, so it cannot be used on processes that are running.

• stty – sets signal names to control keys.
  • syntax: stty signal_name ^key, where key a key on the keyboard and signal_name is not always the same as the signal name.
  • stty -a displays all the signals assigned to control keys.
  • changing signal keys is not recommended.

• kill – command sends specific signals to a process.
  • by default sends TERM signal to a process.
  • TERM and QUIT give process time to clean up, while KILL does not.
  • kill uses the same syntax as fg to select process by ID, job number or command.
• killall – same as kill but sends signal to all processes with the name given by the first argument.

• ps – displays information about processes running on the system.
  • ps with no options only gives processes list for the current terminal.
  • ps -a shows processes running on all the terminals.
  • ps output example:

username:~$ ps
  PID TTY          TIME CMD
 4673 pts/0    00:00:00 bash
 4698 pts/0    00:00:00 ps

• “Zombies” or “Orphans” are processes that have information about what shell they came from missing.
  • “Zombies” are hidden with ps -a so you have to use ps -e (In the list, column TTY shows “?” for zombies).
  • daemons are “zombie” processes which handle system services.

• trap command
  • trap command sig1 sig2 …
  • if any of the signals are received, run command, which can be a function or script.
  • trap without arguments prints lists of traps set
  • trap can be used to clean up, if user sends signal. This is similar to finally in try/except/finally in Python.
  • trap – signals resets signals defined.
• trap functions

func () {
        trap command1 sig1
}

trap command2 sig1
func()

• Since the signals are the same and the function is called after the trap outside the function, trap inside the function will be used. (func() redefines the previous trap)
• $$ is a special variable “$” that contained the process ID of the current shell process.
  • Can be to create temporary files.
• $! is another special variable “!” contains process ID of the most recent background job.

• Coroutines are two programs that run together and possibly communicate. For example ls | more.
• wait command waits for background jobs to finish.
  • With wait courotines that don’t communicate don’t keep running after the end/ they don’t become “orphans”.
• Coroutines that don’t communicate can have a performance advantage, but could also cause thrashing, which is when processes compete for system resources.
• Parallelization uses multiple hardware (CPU) to split processes between the CPUs, allowing the processes to run faster.
• Subshells inherit current directory (PWD), environment variables, file descriptors (stdin, stdout and stderr) and ignored signals (An example is setting trap second argument to null string).
• Nested Subshells are like command blocks, but with parenthesis and have properties of a subshell.
• Process substitution:

command <(command1)

• command is some command and with syntax <(command1) the output from command1 is set as the first argument for command. (Pretty useful!)