A brief analysis of the examples and differences of using nohup and screen to run background tasks in Linux

Using SSH terminal (such as putty, xshell) to connect to Linux server to run time-consuming tasks may take several hours or even days to complete. At this time, the terminal is occupied and we still have other tasks to do. Therefore, we need to put this type of time-consuming task into the background to run. We only need to record the logs. There are the following common methods to achieve this requirement.

command &

Enter command & in the terminal to run. At this time, using Ctrl + C to terminate the command will be invalid because the program is immune to the SIGINT1 signal of & background running, and it will continue to run. But if you close the terminal directly, the process will be terminated. It can be seen that the process running in the background using & will be terminated by the SIGHUP2 signal, but if you exit the terminal normally using the exit command, the program will continue to run in the background and will not be terminated.

nohup command

By default, standard output will be appended to nohup.out in the current directory. If the nohup.out file in the current directory is not writable, the output is redirected to the $HOME/nohup.out file.

Then, it is easy for us to think of combining these two features and running the command like this:

nohup command > /home/user/myfile.log 2>&1 &


This will execute the task in the background until it is finished, and will direct the program's standard output (1) and standard error (2) to the file /home/user/myfile.log.

screen tool

Screen can be understood as a session window management tool. For general use, we only need to use the following operations:

# Install screen using yum
yum install screen
# Create a session window named test screen -S test
# Temporarily leave the window Ctrl+ad (hold down Ctrl and press a, d in sequence)
# View the existing session windows screen -ls
# Enter the window screen -r test
screen -r process ID
# Close the window exit
# Window switching Ctrl+ac: Create a window in the current screen session Ctrl+aw: Window list Ctrl+an: Next window Ctrl+ap: Previous window Ctrl+a 0-9: Switch between the 0th window and the 9th window

With the screen tool, we can create a window on the terminal, run the required commands, then leave temporarily, and then continue to do other things. Of course, you can also use other terminals to connect to the server and use the screen -r command to connect to the required window. You will find that the program is always running, and exiting the terminal will not affect the programs running on those temporarily left terminals.

test:

We write a test script test.sh:

#!/bin/sh
for ((i=1; i<1000; i++))
do
  d=`date '+%Y-%m-%d %H:%M:%S'`
  echo "$d $ith output;"
  tt
  sleep 2s
done
Bash

Just use & to run in the background:

[root@localhost test.cc]# ./test.sh > test.log 2>&1 &
[1] 15037
[root@localhost test.cc]# ps -aux | grep test.sh
root 15037 0.0 0.0 113180 1424 pts/0 S 16:10 0:00 /bin/sh ./test.sh
root 15045 0.0 0.0 112712 992 pts/0 S+ 16:10 0:00 grep --color=auto test.sh
Bash

You can see that 15037 processes are running;

If you close the terminal directly, logging stops, indicating that the process stops executing when the terminal session ends;

However, after repeated tests, I found that if I use the exit command to exit the terminal normally, and then reconnect to the terminal, the program run with & continues to run, that is, the & command has the same effect as nohup. The test environment I use here is CentOS7.6.

Use nohup & run

[root@localhost test.cc]# nohup ./test.sh > test.log 2>&1 &
[1] 14349

Test results: directly close the terminal or use the exit command to exit the terminal, and the program will continue to execute.

Run using screen

# Create window screen -S test
# Run the command. You don't need the & at the end, but the program will occupy the window./test.sh > test.log 2>&1 &
# Temporarily leave Ctrl + ad

At this time, you can close the terminal directly, and then reconnect. You will find that the program is still running. If you want to find the window connection:

# Existing window [root@localhost ~]# screen -ls
There is a screen on:
  18048.test (Detached)
1 Socket in /var/run/screen/S-root.
# Enter the window [root@localhost ~]# screen -r test

After entering, you will find that the window still maintains the state before leaving, including the programs and commands entered before. When you enter the exit command in the window to exit the window, if you do not use & after the previous command, the program will terminate, because relative to the test window, this is a foreground program, and the program will naturally terminate when the window exits.

Because of the temporary detach function of screen, the foreground program can continue to run in the temporary detach window. Compared with a real terminal, it is equivalent to running in the background.

Program termination (interrupt) signal, issued when the user types the INTR character (usually Ctrl-C), is used to notify the foreground process group to terminate the process ↩︎

Sent when the terminal connection ends, usually to close the terminal and notify each process group in the same session ↩︎

Summarize

The above is the example and difference of using nohup and screen to run background tasks in Linux introduced by the editor. I hope it will be helpful to everyone. If you have any questions, please leave me a message and the editor will reply to you in time. I would also like to thank everyone for their support of the 123WORDPRESS.COM website!
If you find this article helpful, please feel free to reprint it and please indicate the source. Thank you!