1
# 场景1：基础使用，让Python脚本在后台持续运行
2
nohup python /home/xiaoying/app.py &
3

4
# 场景2：自定义输出文件，而非默认的nohup.out
5
nohup python /home/xiaoying/app.py > /var/log/app.log 2>&1 &
6

7
# 场景3：在脚本中使用nohup运行多个后台任务
8
nohup bash -c '
9
  python app1.py &
10
  python app2.py &
11
  wait
12
' > /var/log/tasks.log 2>&1 &
13

14
# 场景4：使用nohup运行一个需要长时间编译的任务
15
nohup ./configure --prefix=/usr/local && make && make install > build.log 2>&1 &
16

17
# 场景5：运行一个带参数的复杂命令
18
nohup java -Xmx512m -Xms512m -jar myapp.jar --config=/etc/myapp.cfg > /var/log/java.log 2>&1 &
19

20
# 检查进程是否仍在运行
21
ps aux | grep "python app.py"
22

23
# 查看输出日志
24
tail -f nohup.out    # 实时查看
25
cat nohup.out        # 查看全文

1
# 场景1：简单的后台运行
2
sleep 300 &
3

4
# 模拟输出
5
# [1] 2345
6
# 返回提示符
7

8
# 场景2：同时启动多个后台任务
9
python task1.py & python task2.py & python task3.py &
10

11
# 场景3：让后台进程不占用终端输出
12
./long_running_task > /dev/null 2>&1 &
13

14
# 场景4：使用子shell管理多个相关任务
15
(while true; do echo "task 1"; sleep 10; done) & \
16
(while true; do echo "task 2"; sleep 10; done) &
17

18
# 场景5：后台运行编译任务（带进度输出）
19
make all > build.log 2>&1 &
20

21
# 查看后台作业
22
jobs
23

24
# 在前台等待后台作业完成
25
wait
26

27
# 等待特定的后台作业
28
wait %1
29
wait 2345
30

31
# 向后台作业发送信号
32
fg %1           # 将后台作业调回前台
33
kill %1         # 杀死第1个后台作业
34
kill %2 %3      # 同时杀死多个后台作业

1
# 场景1：创建一个名为myapp的新会话并进入
2
screen -S myapp
3

4
# 场景2：在会话内运行一个长期任务
5
# (在screen会话内执行)
6
$ python /home/xiaoying/app.py
7

8
# 场景3：从会话内分离出来（回到原终端），会话继续运行
9
# 按 Ctrl+A，然后按 d
10
# 提示: [detached from myapp]
11

12
# 场景4：列出所有screen会话
13
screen -ls
14
# 输出示例:
15
# There are screens on:
16
#  3456.myapp    (2025-01-09 10:30)  (Detached)
17
#  3789.test    (2025-01-09 10:25)  (Attached)
18
# 2 Sockets in /run/screen/S-xiaoying.
19

20
# 场景5：重新连接到分离的会话
21
screen -r myapp
22

23
# 场景6：后台创建并运行任务（不进入会话）
24
screen -d -m -S worker python /home/xiaoying/worker.py
25

26
# 场景7：列出会话后，强制连接（如果有其他连接则断开它）
27
screen -D -r myapp
28

29
# 场景8：多个用户共享一个会话（协作调试）
30
# 用户1:
31
screen -d -m -S shared python app.py
32
screen -r shared
33

34
# 用户2:
35
screen -x shared
36

37
# 场景9：后台批量运行多个任务
38
screen -d -m -S task1 python task1.py
39
screen -d -m -S task2 python task2.py
40
screen -d -m -S task3 python task3.py
41

42
# 场景10：定期检查会话状态
43
for session in $(screen -ls | grep -oP '\d+\.\w+' | cut -d. -f2); do
44
  echo "Session: $session"
45
  screen -S $session -X hardcopy /tmp/screen_$session.log
46
done
47

48
# 场景11：清理所有已死亡的会话
49
screen -wipe

1
# 场景1：创建一个新的tmux会话
2
tmux new-session -s myapp
3

4
# 场景2：在后台创建会话并运行Python脚本
5
tmux new-session -d -s worker python /home/xiaoying/worker.py
6

7
# 场景3：列出所有tmux会话
8
tmux ls
9
# 输出示例:
10
# myapp: 3 windows (created Wed Jan  8 10:30:45 2025) [120x40]
11
# worker: 1 windows (created Wed Jan  8 10:32:15 2025) (detached) [120x40]
12

13
# 场景4：连接到指定会话
14
tmux attach-session -t myapp
15

16
# 场景5：在会话内创建新窗口并命名
17
tmux new-window -t myapp -n editor
18

19
# 场景6：在指定窗口内分割窗格（水平和竖直）
20
tmux split-window -t myapp:0 -h   # 水平分割
21
tmux split-window -t myapp:0 -v   # 竖直分割
22

23
# 场景7：在指定窗格运行命令（不进入交互式）
24
tmux send-keys -t myapp:0.0 "python app.py" Enter
25
tmux send-keys -t myapp:0.1 "tail -f /var/log/app.log" Enter
26

27
# 场景8：后台启动多个相关任务
28
tmux new-session -d -s dev
29
tmux send-keys -t dev "cd /home/xiaoying/project && npm install" Enter
30
tmux new-window -t dev -n server
31
tmux send-keys -t dev:server "npm run dev" Enter
32
tmux new-window -t dev -n logs
33
tmux send-keys -t dev:logs "tail -f logs/*" Enter
34

35
# 场景9：在特定窗格内执行多行命令
36
tmux send-keys -t myapp:0.0 "
37
  cd /home/xiaoying/project
38
  source venv/bin/activate
39
  python app.py
40
" Enter
41

42
# 场景10：列出指定会话的所有窗口
43
tmux list-windows -t myapp
44

45
# 场景11：关闭指定会话
46
tmux kill-session -t myapp
47

48
# 场景12：关闭特定窗口
49
tmux kill-window -t myapp:1
50

51
# 场景13：批量查看和管理多个会话
52
for session in $(tmux ls -F "#{session_name}"); do
53
  echo "=== Session: $session ==="
54
  tmux list-windows -t $session
55
done

1
# 场景1：查看所有监听的端口及其进程（最常用！）
2
ss -tlnp
3

4
# 场景2：查看所有TCP连接及其进程（包括已建立和待连接状态）
5
ss -tunap
6

7
# 场景3：查看特定端口被谁占用
8
ss -t --dport :8080   # 查看8080端口
9
ss -t --dport :22     # 查看SSH端口
10

11
# 场景4：按照进程ID查找所有网络连接
12
ss -p | grep "pid=2234"
13

14
# 场景5：查看UDP监听端口（如DNS、NTP服务）
15
ss -ul
16

17
# 场景6：查看某个IP地址的所有连接
18
ss src 192.168.1.100
19
ss dst 192.168.1.200
20

21
# 场景7：查看socket统计（内存使用等）
22
ss -s
23

24
# 场景8：查看TCP连接状态统计（多少个ESTABLISHED、TIME_WAIT等）
25
ss -t -s
26

27
# 场景9：实时监控（每2秒更新一次）
28
watch -n 2 'ss -tlnp'
29

30
# 场景10：查找处于TIME_WAIT状态的连接（可能导致端口不可用）
31
ss -t state TIME-WAIT
32

33
# 场景11：查看某个用户的所有网络连接
34
ss -p | grep "xiaoying"
35

36
# 场景12：输出IPv6监听端口
37
ss -tlnp | grep -i ipv6

1
# 场景1：查看所有监听的TCP端口
2
netstat -tlnp
3

4
# 场景2：查看所有已建立的TCP连接
5
netstat -tp | grep ESTABLISHED
6

7
# 场景3：查看路由表
8
netstat -r
9

10
# 场景4：显示网络接口统计
11
netstat -i
12

13
# 场景5：统计TCP状态分布
14
netstat -an | grep -i tcp | awk '{print $NF}' | sort | uniq -c | sort -rn
15

16
# 场景6：监控实时网络连接（每秒更新）
17
netstat -c
18

19
# 场景7：查看某个端口的所有连接
20
netstat -tulnp | grep :8080
21

22
# 场景8：查看处于TIME_WAIT状态的连接数
23
netstat -an | grep TIME_WAIT | wc -l
24

25
# 场景9：显示全部网络统计信息
26
netstat -s
27

28
# 场景10：查看某个用户的网络连接
29
netstat -tulnp | grep username

1
# 场景1：查看占用8080端口的进程（最常用！）
2
lsof -i:8080
3

4
# 场景2：查看所有监听的TCP端口
5
lsof -i TCP:LISTEN
6

7
# 场景3：查看所有已建立的TCP连接
8
lsof -i TCP -s TCP:ESTABLISHED
9

10
# 场景4：查看某个进程打开的所有文件和网络连接
11
lsof -p 2234
12

13
# 场景5：查看某个用户的所有打开文件和网络连接
14
lsof -u xiaoying
15

16
# 场景6：查看某个命令关联的进程打开的文件
17
lsof -c nginx
18

19
# 场景7：查看某个特定文件被哪些进程打开
20
lsof /var/log/app.log
21

22
# 场景8：仅输出占用8080端口的进程PID（用于管道）
23
lsof -t -i:8080
24

25
# 场景9：查看已删除但仍被占用的文件（排查磁盘空间泄漏）
26
lsof +L 1
27

28
# 场景10：查看某个目录被打开的文件
29
lsof +d /var/log
30

31
# 场景11：实时监控网络连接（每2秒更新）
32
watch -n 2 'lsof -i TCP:LISTEN'
33

34
# 场景12：查看占用某个端口的进程并直接杀死
35
kill -9 $(lsof -t -i:8080)
36

37
# 场景13：统计进程打开的文件描述符数量（用于排查FD泄漏）
38
lsof -p 2234 | wc -l
39

40
# 场景14：查看最多打开文件数的进程
41
lsof | awk '{print $1}' | sort | uniq -c | sort -rn | head -10
42

43
# 场景15：查看网络连接统计（不同状态的连接数）
44
lsof -i -s TCP:LISTEN,ESTABLISHED,TIME_WAIT