Linux运维需要掌握的命令
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
;}’5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print
Linux运维需要掌握的命令
作为Linux运维，需要了解Linux操作系统的基本使用和管理知识，下面学习啦小编给大家介绍下Linux运维需要掌握的命令，想成为Linux运维的朋友可以来学习一下。
1.删除0字节文件
代码如下：
find -type f -size 0 -exec rm -rf {} \;
2.查看进程
按内存从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -k5 -nr
3.按cpu利用率从大到小排列
代码如下：
ps -e -o “%C ： %p ： %z ： %a”|sort -nr
4.打印说cache里的URL
代码如下：
grep -r -a jpg /data/cache/* | strings | grep “http：” | awk -F‘http：’ ‘{print “http：”$2;}’
5.查看http的并发请求数及其TCP连接状态：
代码如下：
netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a， S[a]}’
6. sed -i ‘/Root/s/no/yes/’ /etc/ssh/sshd_config sed在这个文里Root的一行，匹配Root一行，将no替换成yes.
7.如何杀掉mysql进程：
代码如下：
ps aux |grep mysql |grep -v grep |awk ‘{print $2}’ |xargs kill -9 (从中了解到awk的用途)
killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF
}’ |xargs kill -9 (从中了解到awk的用途)killall -TERM mysqld
kill -9 `cat /usr/local/apache2/logs/httpd.pid` 试试查杀进程PID
8.显示运行3级别开启的服务：
代码如下：
ls /etc/rc3.d/S* |cut -c 15- (从中了解到cut的用途，截取数据)
9.如何在编写SHELL显示多个信息，用EOF
代码如下：
cat 《《 EOF
+--------------------------------------------------------------+
| === Welcome to Tunoff services === |
+--------------------------------------------------------------+
EOF