本文是自己之前学习shell整理的笔记，方便以后查阅！
 

一、/bin/sh 与 /bin/bash 的区别

/bin/sh与/bin/bash虽然大体上没什么区别，但仍存在不同的标准。

区别：
1.sh 一般设成 bash 的软链 (symlink);
2.在一般的 linux 系统当中（例外如 FreeBSD,OpenBSD 等），使用 sh 调用执行脚本相当于打开了bash 的 POSIX 标准模式;
3.也就是说 /bin/sh 相当于 /bin/bash --posix（#!/bin/sh是#!/bin/bash的缩减版。）

简单地说，bash是sh的完整版，bash完全兼容sh命令，反之不行。

#! 是个指示路径的表示符，/bin/bash和/bin/sh指定了脚本解析器的程序路径。

二、vi与vim的区别

1.多级撤消
在vi编辑器中，按u只能撤消上次命令，而在vim里可以无限制的撤消。

2.易用性
vi编辑器只能运行于unix中，而vim不仅可以运行于unix，还可用于windows、mac等多操作平台。

3.语法加亮
vim可以用不同的颜色来加亮你的代码。

4.可视化操作
vim不仅可以在终端运行，也可以运行于windows、 mac os、 windows。

5.对vi完全兼容
可以把vim当成vi来使用。

 
如下两图对比：
vi main.c

 
vim main.c

小结：vi和vim都是Linux中的编辑器，不同的是vim比较高级，可以视为vi的升级版本。vi使用于文本编辑，但是vim更适用于coding。
 

三、shell变量

运行shell时，会同时存在三种变量：

全局变量：指变量在当前的整个 Shell 会话中都有效。每个 Shell 会话都有自己的作用域，彼此之间互不影响。在 Shell 中定义的变量，默认就是全局变量。

局部变量：在 Shell 函数中定义的变量默认也是全局变量，它和在函数外部定义变量拥有一样的效果；要想变量的作用域仅限于函数内部，那么可以在定义时加上local命令，此时该变量就成了局部变量。

环境变量：只在当前 Shell 会话中有效，如果使用export命令将它导出，那么它就在所有的子 Shell 中也有效了。

四、Shell字符串

字符串最常用的数据类型，可以用单/双引号，也可以不用引号。
 
1.单引号
str=‘this is a string’
单引号字符串的限制：
• 单引号里面的任何字符都会原样输出，单引号字符串里面的变量是无效的，也就是变量那一串就只是字符串；
• 单引号字符中不能出现单独一个的单引号（对单引号使用转义符后也不行），但能成对出现，相当于字符串拼接s=‘abc’0e’，这个就会报错，而s='abc’0’e’会输出abc\0e

2.双引号
双引号中可以有变量，输出时会先解析里面的变量和命令；
双引号也可以出现转义字符。

#!/bin/bash
name='lr'
echo $name
s1="my name is $name"
echo $s1
s2="my name is "$name""
echo $s2
s3="my name is \"$name\""
echo $s3
# 运行结果

lr

my name is lr

my name is lr

my name is "lr"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.单/双引号使用场景

建议：
如果变量的值是数字，那么不加引号a=1；
如果要将字符串原样输出，就用反引号str=‘单引号中原样输出${test}’；
没有特别要求最好都是用双引号（最常见）。

4.拼接字符串
字符串的拼接，在 Shell 中你不需要使用任何运算符，将两个字符串并排放在一起就能实现拼接。

#!/bin/bash
name='lr'
s1="hello, $name"  # 双引号中可以直接使用变量
echo $s1
s2="hello, "\(name</span><span class="token string">""</span>  <span class="token comment"># 相当于两对双引号拼接</span>
<span class="token function">echo</span> <span class="token variable">\)s2
s3='hello, \(name'</span>  <span class="token comment"># 单引号中变量都当作普通字符串</span>
<span class="token function">echo</span> <span class="token variable">\)s3
s4='hello, "\(name"'</span>
<span class="token function">echo</span> <span class="token variable">\)s4
s5='hello, '\(name</span><span class="token string">''</span>  <span class="token comment"># 相当于两对单引号和变量进行拼接</span>
<span class="token function">echo</span> <span class="token variable">\)s5
nick='xy'
s6=\(nick</span><span class="token variable">\)name  # 中间不能有空格

s7="\(nick</span> <span class="token variable">\)name"  # 如果是双引号包围，就允许中间有空格

s8=\(nick</span><span class="token string">"..."</span><span class="token variable">\)name  # 中间可以出现其他字符串

s9="\(nick</span>...<span class="token variable">\)name"  # 中间也可以这样写

s10="昵称\({nick}...\){name}名字"
echo \(s6</span> 
<span class="token function">echo</span> <span class="token variable">\)s7

echo \(s8</span> 
<span class="token function">echo</span> <span class="token variable">\)s9

echo $s10
运行结果：

user@PxeCtrlSys:~$ ./test.sh

hello, lr

hello, lr

hello, \(name</span>
hello<span class="token punctuation">,</span> <span class="token string">"<span class="token variable">\)name"

hello, lr
xylr

xy lr

xy...lr

xy...lr

昵称xy...lr名字
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

获取字符串长度
使用${#变量名}获取长度：

#!/bin/bash
name='lr'
echo ${#name}
运行结果：

2
1
2
3
4
5
6

五、Shell函数

shell函数格式：

[ function ] funname [()]
{
    action;
    [return int;]
}
1
2
3
4
5

可以带function func()定义，也可以直接func()定义，不带任何参数。
参数返回，可以显示加：return返回，如果不加，将以最后一条命令运行结果，作为返回值。return后跟数值n（0-255）。

无返回值函数：

#!/bin/bash
func(){

echo "这是一个函数中的内容"

}
echo "开始调用函数"

func

echo "调用函数完成"
1
2
3
4
5
6
7
8
9

运行结果：
user@PxeCtrlSys:~$ ./test.sh

开始调用函数
这是一个函数中的内容
调用函数完成
 
 
有返回值函数：
定义一个带return的函数

#!/bin/bash
func(){

echo "请输入两个数，执行加法"

echo -n "请输入第一个数："

read num1

echo -n "请输入第二个数："

read num2

# return $[ $num1 + $num2]

# 下方表达式也正确

return \(<span class="token punctuation">(</span><span class="token punctuation">(</span> <span class="token variable">\)num1 + $num2 ))

}
echo "开始调用函数"

func

echo "函数返回值为 $?"

echo "调用函数完成"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行结果：
user@PxeCtrlSys:~$ ./test.sh

开始调用函数
请输入两个数，执行加法
请输入第一个数：2
请输入第二个数：3
函数返回值为 5
调用函数完成

六、Shell基本运算符

expr是一款表达式计算工具，使用它完成表达式的求值操作。（但操作麻烦，不常用。）
例如，两个数量价，注意是反引号，而不是单引号。

#!/bin/bash
val=expr 2<span class="token operator">+</span>2

echo "求值结果：\(val</span>"</span>
val=`expr 2 <span class="token operator">+</span> 2`
<span class="token function">echo</span> <span class="token string">"求值结果：<span class="token variable">\)val"
1
2
3
4
5
6

运行结果：
user@PxeCtrlSys:~$ ./test.sh

求值结果：2+2
求值结果：4

 
注：
① 表达式和运算符之间要用空格，例如2+2是不正确的，需要写成2 + 2，这与大多数编程语言不同；
② 完整的表达式要被两个反引号 ``包含

1、Shell expr：进行整数计算

a 不等于 b

#!/bin/bash
a=2

b=3
echo expr <span class="token variable">$a</span> <span class="token operator">+</span> <span class="token variable">$b</span>

echo expr <span class="token variable">$a</span> <span class="token operator">-</span> <span class="token variable">$b</span>

echo expr <span class="token variable">$a</span> \<span class="token operator">*</span> <span class="token variable">$b</span>  # 做乘法需要添加斜杠转义

echo expr <span class="token variable">$b</span> <span class="token operator">/</span> <span class="token variable">$a</span>

echo expr <span class="token variable">$b</span> <span class="token operator">%</span> <span class="token variable">$a</span>
c=\(b</span>
<span class="token function">echo</span> <span class="token string">"赋值后c的值：<span class="token variable">\)c"
if [ \(a</span> == <span class="token variable">\)b ]

then

echo "a 等于 b"

else

echo "a 不等于 b"

fi
if [ \(b</span> == <span class="token variable">\)c ]

then

echo "b 等于 c"

fi
if [ \(a</span> <span class="token operator">!</span>= <span class="token variable">\)b ]

then

echo "a 不等于 b"

fi
if [ \(c</span> <span class="token operator">!</span>= <span class="token variable">\)b ]

then

echo "c 不等于 b"

fi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

运行结果：
user@PxeCtrlSys:~$ ./test.sh

5
-1
6
1
1
赋值后c的值：3
a 不等于 b
b 等于 c
a 不等于 b
 
运算符

 

数学计算命令
Shell 中常用的六种数学计算方式

2、Shell (())：对整数进行数学运算

(( )) 只能进行整数运算，不能对小数（浮点数）或者字符串进行运算。语法格式 ((表达式)) ，就是将数学运算表达式放在((和))之间。

表达式可以只有一个，也可以有多个，多个表达式之间以逗号,分隔。对于多个表达式的情况，以最后一个表达式的值作为整个 (( )) 命令的执行结果。

可以使用

    获
   
   
    取
   
   
    (
   
   
    (
   
   
    )
   
   
    )
   
   
    命
   
   
    令
   
   
    的
   
   
    结
   
   
    果
   
   
    ，
   
   
    这
   
   
    和
   
   
    使
   
   
    用
   
  
  
   获取 (( )) 命令的结果，这和使用
  
 
</span><span class="katex-html"><span class="base"><span class="strut" style="height: 1em; vertical-align: -0.25em;"></span><span class="mord cjk_fallback">获</span><span class="mord cjk_fallback">取</span><span class="mopen">(</span><span class="mopen">(</span><span class="mclose">)</span><span class="mclose">)</span><span class="mord cjk_fallback">命</span><span class="mord cjk_fallback">令</span><span class="mord cjk_fallback">的</span><span class="mord cjk_fallback">结</span><span class="mord cjk_fallback">果</span><span class="mord cjk_fallback">，</span><span class="mord cjk_fallback">这</span><span class="mord cjk_fallback">和</span><span class="mord cjk_fallback">使</span><span class="mord cjk_fallback">用</span></span></span></span></span>获得变量值是类似的。</p> 

在 (( )) 中使用变量无需加上$前缀，(( )) 会自动解析变量名，这使得代码更加简洁，也符合程序员的书写习惯。

算术运算

①直接输出运算结果

user@PxeCtrlSys:~$ echo $((1+1))
2
user@PxeCtrlSys:~$ echo $((2*3))
6
1
2
3
4

②计算完成后，给变量赋值

user@PxeCtrlSys:~$ i=5
user@PxeCtrlSys:~$ ((i=i*2))
user@PxeCtrlSys:~$ echo $i
10
user@PxeCtrlSys:~$ ((i*=2))  # 简写，等效于 ((i=i*2))
user@PxeCtrlSys:~$ echo $i
20
1
2
3
4
5
6
7

③复杂运算，结果赋值给变量a，变量在括号内

user@PxeCtrlSys:~$ ((a=2-5*2/4+2**2))
user@PxeCtrlSys:~$ echo $a
4
1
2
3

④ 运算结果赋值给变量b，变量b在括号外，需要使用$

user@PxeCtrlSys:~$ b=$((2-5*2/4+2**2))
user@PxeCtrlSys:~$ echo $b
4
1
2
3

⑤ 直接输出表达式的值，$符号不能去掉

user@PxeCtrlSys:~$ echo $((2-5*2/4+2**2))
4
1
2

⑥利用公式计算1-100的和

user@PxeCtrlSys:~$ echo $((100*(100+1)/2))
5050
1
2

逻辑运算

①结果为真，输出1，1表示真

user@PxeCtrlSys:~$ echo $((3<5))
1
user@PxeCtrlSys:~$ echo $((3>5))
0
user@PxeCtrlSys:~$ echo $((3==2+1))
1
1
2
3
4
5
6

②多条件成立

user@PxeCtrlSys:~$ if ((8>6&&5==2+3))
> then

> echo yes

> fi

yes
1
2
3
4
5
6
7

 

3、Shell let：对整数进行数学运算

① 和双小括号 (( )) 一样，let 命令也只能进行整数运算，不能对小数（浮点数）或者字符串进行运算。
② 语法格式 let 表达式、let “表达式”、let ‘表达式’，都等价于 ((表达式))。
当表达式中含有 Shell 特殊字符（例如 |）时，需要用双引号" "或者单引号’ '将表达式包围起来。
③ 和 (( )) 类似，let 命令也支持一次性计算多个表达式，并且以最后一个表达式的值作为整个 let 命令的执行结果。但是，对于多个表达式之间的分隔符，let 和 (( )) 是有区别的。

• let 命令以空格来分隔多个表达式；
(( )) 以逗号,来分隔多个表达式。

user@PxeCtrlSys:~$ i=2
user@PxeCtrlSys:~$ let i+=3
user@PxeCtrlSys:~$ echo $i
5
1
2
3
4

let i+=3等价于((i+=3))，但后者效率更高。
let后面可以跟多个表达式，用空格分隔。

user@PxeCtrlSys:~$ a=3
user@PxeCtrlSys:~$ let b=3**2 c=a+b
user@PxeCtrlSys:~$ echo $a $b
3 9
user@PxeCtrlSys:~$ echo $c
12
1
2
3
4
5
6

4、Shell $[]：对整数进行数学运算

#直接输出结果
user@PxeCtrlSys:~$ echo $[2*3]
6
user@PxeCtrlSys:~$ echo $[(2+3)/3]
1
user@PxeCtrlSys:~$ echo $[(2+3)%3]
2
user@PxeCtrlSys:~$ a=6
#将结果赋值给变量
user@PxeCtrlSys:~$ b=\(<span class="token namespace">[a*2]</span>
user@PxeCtrlSys:~\) echo \(b</span>
12
user@PxeCtrlSys:~\) echo $[a+b]

18
#变量前加$对结果没有影响
user@PxeCtrlSys:~$ echo \(<span class="token punctuation">[</span><span class="token variable">\)a+$b]

18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5、字符串运算符

#!/bin/bash
a="abc"

b="efg"
if [ \(a</span> = <span class="token variable">\)b ]
then

echo "\(a</span> = <span class="token variable">\)b : a 等于 b"
else

echo "\(a</span> = <span class="token variable">\)b: a 不等于 b"

fi

if [ \(a</span> <span class="token operator">!</span>= <span class="token variable">\)b ]
then

echo "\(a</span> != <span class="token variable">\)b : a 不等于 b"
else

echo "\(a</span> != <span class="token variable">\)b: a 等于 b"

fi

if [ -z \(a</span> <span class="token punctuation">]</span>
then
   <span class="token function">echo</span> <span class="token string">"-z <span class="token variable">\)a : 字符串长度为 0"

else

echo "-z $a : 字符串长度不为 0"
fi

if [ -n "\(a</span>"</span> <span class="token punctuation">]</span>
then
   <span class="token function">echo</span> <span class="token string">"-n <span class="token variable">\)a : 字符串长度不为 0"

else

echo "-n \(a</span> : 字符串长度为 0"</span>
fi
<span class="token keyword">if</span> <span class="token punctuation">[</span> <span class="token variable">\)a ]
then

echo "$a : 字符串不为空"
else

echo "$a : 字符串为空"

fi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

运行结果：
user@PxeCtrlSys:~$ ./test.sh

abc = efg: a 不等于 b
abc != efg : a 不等于 b
-z abc : 字符串长度不为 0
-n abc : 字符串长度不为 0
abc : 字符串不为空

6、文件测试运算符

文件测试运算符用于检测Unix文件的各种属性。

变量 file 表示文件"/home/user/test.sh"，它的大小为100字节，具有 rwx 权限。下面的代码，将检测该文件的各种属性：

#!/bin/bash
file="/home/user/test.sh"
if [ -r $file ]
then
   echo "文件可读"
else
echo "文件不可读"
fi

if [ -w \(file</span> <span class="token punctuation">]</span>
then
   <span class="token function">echo</span> <span class="token string">"文件可写"</span>
<span class="token keyword">else</span>
   <span class="token function">echo</span> <span class="token string">"文件不可写"</span>
fi
<span class="token keyword">if</span> <span class="token punctuation">[</span> <span class="token operator">-</span>x <span class="token variable">\)file ]

then

echo "文件可执行"

else

echo "文件不可执行"

fi

if [ -f \(file</span> <span class="token punctuation">]</span>
then
   <span class="token function">echo</span> <span class="token string">"文件为普通文件"</span>
<span class="token keyword">else</span>
   <span class="token function">echo</span> <span class="token string">"文件为特殊文件"</span>
fi
<span class="token keyword">if</span> <span class="token punctuation">[</span> <span class="token operator">-</span>d <span class="token variable">\)file ]

then

echo "文件是个目录"

else

echo "文件不是个目录"

fi

if [ -s \(file</span> <span class="token punctuation">]</span>
then
   <span class="token function">echo</span> <span class="token string">"文件不为空"</span>
<span class="token keyword">else</span>
   <span class="token function">echo</span> <span class="token string">"文件为空"</span>
fi
<span class="token keyword">if</span> <span class="token punctuation">[</span> <span class="token operator">-</span>e <span class="token variable">\)file ]

then

echo "文件存在"

else

echo "文件不存在"

fi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

运行结果：
user@PxeCtrlSys:~$ ./test.sh

文件可读
文件可写
文件可执行
文件为普通文件
文件不是个目录
文件不为空
文件存在

七、read用法

read命令接收标准输入（键盘）的输入，或其他文件描述符的输入（后面在说）。得到输入后，read命令将数据放入一个标准变量中。

①处理输入

#!/bin/bash
read -p "Enter your name:" name
echo "hello $name, welcome to my program"
exit 0
1
2
3
4

②时间设置
 
可以使用 -t 参数来限制用户的输入时间。例如，使用下面的命令设置用户在10秒内输入参数：

#!/bin/bash  
read -t 10 -p "Enter the Internet domain name (e.g. nixcraft.com) : "  
domain_name  
whois $domain_name  
1
2
3
4

③ 输入密码

使用 -s 参数可以不显示用户的输入。示例如下：

#!/bin/bash  
read -s -p "Enter Password : " my_password  
echo  
echo "Your password - $my_password" 
1
2
3
4

 

八、转义

默认情况下，echo 不会解析以反斜杠\开头的转义字符。比如，\n表示换行，echo 默认会将它作为普通字符对待。

echo "hello \nworld"
#运行结果
hello \nworld
1
2
3

echo -e "hello \nworld"
#运行结果
hello
world
1
2
3
4

1、显示换行：-e参数和\n

#!/bin/bash
echo -e "this is first line \n"

echo "next"
#运行结果

user@PxeCtrlSys:~$ ./test.sh

this is first line
next
1
2
3
4
5
6
7
8
9
10

输出中-e表示开启转义，\n表示换行。

2、显示不换行：-e参数和\c或-n参数

#!/bin/bash
echo -e "this is first line \c"

echo "next"
# 运行结果

user@PxeCtrlSys:~$ ./test.sh

this is first line next
1
2
3
4
5
6
7
8
9

-e开启转义，\c表示不换行。

3、输出结果重定向到文件

#!/bin/bash
echo -e "this is first line" > file.ts
# 运行结果

user@PxeCtrlSys:~$ ./test.sh

user@PxeCtrlSys:~$ ls

file.ts software test.sh

user@PxeCtrlSys:~$ cat file.ts

this is first line
1
2
3
4
5
6
7
8
9
10
11

4、原样输出，不转义，不取变量

直接使用单引号即可

#!/bin/bash
name='lr'

echo '$name"'
# 运行结果

user@PxeCtrlSys:~$ ./test.sh

$name"\
1
2
3
4
5
6
7
8
9

5、显示命令执行结果

使用反引号，而不是单引号，可以执行Linux的命令。

#!/bin/bash
echo date
# 运行结果

user@PxeCtrlSys:~$ ./test.sh

Tue Mar 5 10:41:55 CST 2019
1
2
3
4
5
6
7
8

九、Shell exit：退出Shell命令

exit 是一个 Shell 内置命令，用来退出当前Shell：

如果在终端中直接运行 exit 命令，会退出当前登录的 Shell，并关闭终端；
如果在Shell中出现 exit 命令，会停止执行后边的所有代码，立即退出 Shell 脚本。
exit 命令可以接受的参数是一个状态值 n，代表退出时的状态。如果不指定，默认状态值是 0。

#!/bin/bash
echo "exit命令前输出"

exit 9

echo "exit命令后输出"
# 运行结果

user@PxeCtrlSys:~$ ./test.sh

exit命令前输出 # 也就是说exit后面的语句已经不会执行了
# 紧接着用 \(? 来获取test.sh的退出状态</span>
user@PxeCtrlSys:~\) echo $?

9
1
2
3
4
5
6
7
8
9
10
11
12
13
14

十一、Shell ulimit：显示并设置进程资源速度

  系统的可用资源是有限的，如果不限制用户和进程对系统资源的使用，则很容易陷入资源耗尽的地步，而使用 ulimit 命令可以控制进程对可用资源的访问（ulimit 是一个 Shell 内置命令）。

  默认情况下 Linux 系统的各个资源都做了软硬限制，其中硬限制的作用是控制软限制（换言之，软限制不能高于硬限制）。使用ulimit -a可以查看当前系统的软限制，使用命令ulimit -a –H可查看系统的硬限制。

1、ulimit -a查看软限制

user@PxeCtrlSys:~$ ulimit -a
core file size (blocks, -c) 0
# core文件大小，单位是block，默认为0
data seg size (kbytes, -d) unlimited
# 数据段大小，单位是kbyte，默认不做限制
scheduling priority (-e) 0
# 调度优先级，默认为0
file size (blocks, -f) unlimited
# 创建文件的大小，单位是block，默认不做限制
pending signals (-i) 15596
# 挂起的信号数量，默认是8192
max locked memory (kbytes, -l) 64
# 最大锁定内存的值，单位是kbyte，默认是32
max memory size (kbytes, -m) unlimited
# 最大可用的常驻内存值，单位是kbyte，默认不做限制
open files (-n) 65536
# 最大打开的文件数，默认是1024
pipe size (512 bytes, -p) 8
# 管道最大缓冲区的值
POSIX message queues (bytes, -q) 819200
# 消息队列的最大值，单位是byte
real-time priority (-r) 0
# 程序的实时性优先级，默认为0
stack size (kbytes, -s) 8192
# 栈大小，单位是kbyte
cpu time (seconds, -t) unlimited
# 最大cpu占用时间，默认不做限制
max user processes (-u) 15596
# 用户最大进程数，默认是8192
virtual memory (kbytes, -v) unlimited
# 最大虚拟内存，单位是kbyte，默认不做限制
file locks (-x) unlimited
# 文件锁，默认不做限制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

每一行中都包含了相应的改变该项设置的参数，以最大可以打开的文件数为例（open files 默认是 1024），想要增大至 4096 则按照如下命令设置（可参照此方法调整其他参数）。

# -n参数是设置最大文件打开数
# 下面命令会同时设置硬限制和软限制
user@PxeCtrlSys:~$ ulimit -n 65536
# 使用-S参数单独设置软限制

user@PxeCtrlSys:~$ ulimit -S -n 65536
# 使用-H参数单独设置硬限制

user@PxeCtrlSys:~$ ulimit -H -n 65536
1
2
3
4
5
6
7
8
9
10

2、limits.conf 配置文件

使用 ulimit 直接调整参数，只会在当前运行时生效，一旦系统重启，所有调整过的参数就会变回系统默认值。所以建议将所有的改动放在 ulimit 的系统配置文件中。

user@PxeCtrlSys:~$ cat /etc/security/limits.conf 
# /etc/security/limits.conf
#该文件是ulimit的配置文件，任何对系统的ulimit的修改都应写入该文件
#Each line describes a limit for a user in the form:
#配置应该写成西面格式，即每个配置占用1行，每行4列
#<domain> <type> <item> <value>
#
#Where:
#<domain>取值如下：一个用户名、一个组名，组名前面用@符号、通配符*、通配符%
#<domain> can be:
# - a user name
# - a group name, with @group syntax
# - the wildcard *, for default entry
# - the wildcard %, can be also used with %group syntax,
# for maxlogin limit
# - NOTE: group and wildcard limits are not applied to root.
# To apply a limit to the root user, <domain> must be
# the literal username root.
#
#<type>有两个可用值：soft用于设置软限制、hard用于设置硬限制
#<type> can have the two values:
# - "soft" for enforcing the soft limits
# - "hard" for enforcing hard limits
#
#<item> can be one of the following:
# - core - limits the core file size (KB)
# - data - max data size (KB)
# - fsize - maximum filesize (KB)
# - memlock - max locked-in-memory address space (KB)
# - nofile - max number of open files
# - rss - max resident set size (KB)
# - stack - max stack size (KB)
# - cpu - max CPU time (MIN)
# - nproc - max number of processes
# - as - address space limit (KB)
# - maxlogins - max number of logins for this user
# - maxsyslogins - max number of logins on the system
# - priority - the priority to run user process with
# - locks - max number of file locks the user can hold
# - sigpending - max number of pending signals
# - msgqueue - max memory used by POSIX message queues (bytes)
# - nice - max nice priority allowed to raise to values: [-20, 19]
# - rtprio - max realtime priority
# - chroot - change root to directory (Debian-specific)
#
#<domain> <type> <item> <value>
#
#以下是使用样例
#* soft core 0
#root hard core 100000
#* hard rss 10000
#@student hard nproc 20
#@faculty soft nproc 20
#@faculty hard nproc 50
#ftp hard nproc 0
#ftp - chroot /ftp
#@student - maxlogins 4
# End of file
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

十二、crontab定时任务使用

用以下的方法启动、关闭这个cron服务：
 service crond start //启动服务
 service crond stop //关闭服务
 service crond restart //重启服务
 service crond reload //重新载入配置
查看crontab服务状态：service crond status
手动启动crontab服务：service crond start
查看crontab服务是否已设置为开机启动，执行命令：ntsysv
加入开机自动启动:
chkconfig –level 35 crond on
 
shell脚本加入crontab：
1 执行 crontab -e
2 在vi中编辑 如*/5 * * * * 决定路径/脚本shell
3保存
系统就会自动执行了
 
基本格式 :

* * * * * command
1

分　时　日　月　周　命令

第1列表示分钟1～59 （每分钟用*或者 /1表示，/5 代表每5分钟）
第2列表示小时1～23（0表示0点）
第3列表示日期1～31
第4列表示月份1～12
第5列标识号星期0～6（0表示星期天）
第6列要运行的命令
 

例：

crontab -e
#每5分钟执行一次脚本
*/5 * * * * sh/root/monitor.sh
1
2
3

 

十三、shell 循环语句for/do/done

#!/bin/sh
for FRUIT in apple banana pear; do

echo "I like $FRUIT"

done
1
2
3
4
5
6

FRUIT是一个循环变量，第一次循环$FRUIT的取值是apple，第二次取值是banana，第三次取值是pear。

十四、if语句用法

1、条件测试操作

  shell环境根据命令执行后的返回状态值来判断是否执行成功，当返回值为0时表示成功，否则（非0值）表示失败或异常。

  使用专门的测试工具——test命令，可以对特定条件进行测试，并根据返回值来判断条件是否成立（返回值为0表示条件成立）。

①文件测试

-d：测试是否为目录(Directory)；
-e：测试文件或目录是否存在(Exist)；
-f：测试是否为文件(File)；
-r：测试当前用户是否有权限读取(Read)；
-w：测试当前用户是否有权限写入(Write)；
-x：测试是否设置有可执行(Excute)权限；
 
执行条件测试操作以后，通过预定义变量$？可以获得测试命令的返回状态值，从而判断该条件是否成立。
 
示例：
若测试的条件成立，则测试操作的返回值为0

[root@centos01 ~]# test -d /boot   <!--测试目录是否存在-->
[root@centos01 ~]# echo $?         <!--查看前一命令的返回值-->
0                 <!--返回0表示条件成立-->
1
2
3

若测试的条件不成立，则测试操作的返回值将不为0（通常为1）

[root@centos01 ~]# test -d /ertec    <!--测试目录是否存在-->
[root@centos01 ~]# echo $?           <!--查看前一命令的返回值-->
1             <!--返回1表示条件不成立-->
1
2
3

②整数值比较：

-eq：第一个数等于(Equal)第二个数；
-ne：第一个数不等于(Not Equal)第二个数；
-gt：第一个数大于(Greater Than)第二个数；
-lt：第一个数小于(Lesser Than)第二个数；
-le：第一个数小于或等于(Lesser or Equal)第二个数；
-ge：第一个数大于或等于(Greater or Equal)第二个数；

整数值比较在Shell脚本编写中的应用较多。例如，用来判断已登录用户数量、开启进程数、磁盘使用率是否超标，以及软件版本号是否符号要求等。实际使用时，往往会通过变量引用、命令替换等方式来获取一个数值。
 
③字符串比较：

=：第一个字符串与第二个字符串相同。
!=：第一个字符串与第二个字符串不相同，其中 “ ！”表示取反。
-z：检查字符串是否为空，对于未定义或赋予空值的变量将是为空串。
 

④逻辑测试：

• &&：逻辑与，表示“而且”，只有当前后两个条件都成立时，整个测试命令的返回值才为0（结果成立），使用test命令测试时，“&&”可以使用“-a”代替。
• ||：逻辑或，表示“或者”，只要前后两个条件有一个成立，整个测试命令返回的值即为0(结果成立)。使用test命令测试时可以使用“-o”代替。
• ！：逻辑否，表示“不”，只有当条件不成立时，整个测试命令返回的值才为0(结果成立)。

2、使用if条件语句

①单分支if语句
if语句的“分支”指的是不同测试结果所对应的执行语句（一条或多条）。对于单分支的选择结构，只有在“条件成立”时才会执行相应的代码，否则不会执行任何操作。单分支if语句的语法格式如下所示：

单分支if语句示例：

②双分支if语句
对于双分支的选择结构，要求针对“条件成立” “条件不成立”两种情况分别执行不同的操作。双分支if语句的语法格式如下所示：

双分支if语句示例：

③多分支if语句
由于if语句可以根据测试结果的成立、不成立分别执行操作，所有能够嵌套使用，进行多次判断。例如，首先判断某学生的得分是否及格，若及格则再次判断是否高于90分等。多分支if语句的语法格式如下：

多分支if语句示例：

read命令接收标准输入（键盘）的输入，或其他文件描述符的输入。得到输入后，read命令将数据放入一个标准变量中。

十五、while循环详解

while 循环是 Shell 脚本中最简单的一种循环，当条件满足时，while 重复地执行一组语句，当条件不满足时，就退出 while 循环。

1、while 循环的用法如下：

while condition
do
    statements
done
1
2
3
4

condition表示判断条件，statements表示要执行的语句（可以只有一条，也可以有多条），do和done都是 Shell 中的关键字。

2、while 循环的执行流程为：

1).先对 condition 进行判断，如果该条件成立，就进入循环，执行 while 循环体中的语句，也就是 do 和 done 之间的语句。这样就完成了一次循环。
2).每一次执行到 done 的时候都会重新判断 condition 是否成立，如果成立，就进入下一次循环，继续执行 do 和 done 之间的语句，如果不成立，就结束整个 while 循环，执行 done 后面的其它 Shell 代码。
3).如果一开始 condition 就不成立，那么程序就不会进入循环体，do 和 done 之间的语句就没有执行的机会。

3、while :

冒号命令相当于true，放在while后面，表示无限循环。

十六、top命令参数详解

top命令经常用来监控linux的系统状况，是常用的性能分析工具，能够实时显示系统中各个进程的资源占用情况。
 

1、top前5行统计信息

第1行：top - 05:43:27 up 4:52, 2 users, load average: 0.58, 0.41, 0.30
第1行是任务队列信息，其参数如下：

load average: 如果这个数除以逻辑CPU的数量，结果高于5的时候就表明系统在超负荷运转了。

第2行：Tasks: 159 total, 1 running, 158 sleeping, 0 stopped, 0 zombie
第3行：%Cpu(s): 37.0 us, 3.7 sy, 0.0 ni, 59.3 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
第2、3行为进程和CPU的信息。
当有多个CPU时，这些内容可能会超过两行，其参数如下：

st：虚拟机占用百分比

第4行：KiB Mem: 1530752 total, 1481968 used, 48784 free, 70988 buffers
第5行：KiB Swap: 3905532 total, 267544 used, 3637988 free. 617312 cached Mem
第4、5行为内存信息。
其参数如下：

2、进程信息

PID： 进程id
USER ：进程所有者的用户名
PR ：优先级
NI： nice值。负值表示高优先级，正值表示低优先级
VIRT ：进程使用的虚拟内存总量，单位kb。VIRT=SWAP+RES
RES ：进程使用的、未被换出的物理内存大小，单位kb。RES=CODE+DATA
SHR ：共享内存大小，单位kb
S ：进程状态。D=不可中断的睡眠状态 R=运行 S=睡眠 T=跟踪/停止 Z=僵尸进程
%CPU ：上次更新到现在的CPU时间占用百分比
%MEM： 进程使用的物理内存百分比
TIME+ ：进程使用的CPU时间总计，单位1/100秒
COMMAND ：命令名/命令行
 

练习

一、利用shell脚本监控linux中CPU、内存利用率。（centos7）

利用vmstat工具监控CPU详细信息，然后基于/proc/stat计算CPU利用率进行监控，超过1%报警并提取出占用cpu最高的前十进程。
vmstat是Linux系统监控工具，使用vmstat命令可以得到关于进程、内存、内存分页、堵塞IO、traps及CPU活动的信息。

代码如下：

#!/bin/bash
#
CPU_us=$(vmstat | awk '{print $13}' | sed -n '$p')
CPU_sy=$(vmstat | awk '{print $14}' | sed -n '$p')
CPU_id=$(vmstat | awk '{print $15}' | sed -n '$p')
CPU_wa=$(vmstat | awk '{print $16}' | sed -n '$p')
CPU_st=$(vmstat | awk '{print $17}' | sed -n '$p')
CPU1=<span class="token function">cat</span> <span class="token operator">/</span>proc<span class="token operator">/</span>stat <span class="token punctuation">|</span> grep <span class="token string">'cpu '</span> <span class="token punctuation">|</span> awk <span class="token string">'{print $2" "$3" "$4" "$5" "$6" "$7" "$8}'</span>

sleep 5

CPU2=<span class="token function">cat</span> <span class="token operator">/</span>proc<span class="token operator">/</span>stat <span class="token punctuation">|</span> grep <span class="token string">'cpu '</span> <span class="token punctuation">|</span> awk <span class="token string">'{print $2" "$3" "$4" "$5" "$6" "$7" "$8}'</span>

IDLE1=<span class="token function">echo</span> <span class="token variable">$CPU1</span> <span class="token punctuation">|</span> awk <span class="token string">'{print $4}'</span>

IDLE2=<span class="token function">echo</span> <span class="token variable">$CPU2</span> <span class="token punctuation">|</span> awk <span class="token string">'{print $4}'</span>

CPU1_TOTAL=<span class="token function">echo</span> <span class="token variable">$CPU1</span> <span class="token punctuation">|</span> awk <span class="token string">'{print $1+$2+$3+$4+$5+$6+$7}'</span>

CPU2_TOTAL=<span class="token function">echo</span> <span class="token variable">$CPU2</span> <span class="token punctuation">|</span> awk <span class="token string">'{print $1+$2+$3+$4+$5+$6+$7}'</span>

IDLE=<span class="token function">echo</span> <span class="token string">"<span class="token variable">$IDLE2</span>-<span class="token variable">$IDLE1</span>"</span> <span class="token punctuation">|</span> bc

CPU_TOTAL=<span class="token function">echo</span> <span class="token string">"<span class="token variable">$CPU2_TOTAL</span>-<span class="token variable">$CPU1_TOTAL</span>"</span> <span class="token punctuation">|</span> bc

#echo -e "IDLE2:\(IDLE2\nIDLE1:\)IDLE1\nCPU2:\(CPU2_TOTAL\nCPU1:\)CPU1_TOTAL"

#echo -e "IDLE:\(IDLE\nCPU:\)CPU_TOTAL"

RATE=<span class="token function">echo</span> <span class="token string">"scale=4;(<span class="token variable">$CPU_TOTAL</span>-<span class="token variable">$IDLE</span>)/<span class="token variable">$CPU_TOTAL</span>*100"</span> <span class="token punctuation">|</span> bc <span class="token punctuation">|</span> awk <span class="token string">'{printf "%.2f",$1}'</span>
echo -e "us=\(CPU_us</span>\tsy=<span class="token variable">\)CPU_sy\tid=\(CPU_id</span>\twa=<span class="token variable">\)CPU_wa\tst=\(CPU_st</span>"</span>
<span class="token function">echo</span> <span class="token string">"CPU_RATE:\){RATE}%"

CPU_RATE=<span class="token function">echo</span> <span class="token variable">$RATE</span> <span class="token punctuation">|</span> cut <span class="token operator">-</span>d<span class="token punctuation">.</span> <span class="token operator">-</span>f1

#echo "CPU_RATE:\(CPU_RATE"</span>
<span class="token keyword">if</span> <span class="token punctuation">[</span> <span class="token variable">\)CPU_RATE -ge 1 ]

then echo "CPU Warn"

ps aux | grep -v USER | sort -rn -k3 | head

fi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

执行查看结果

虚拟机中没跑什么东西，所以CPU使用率不高，报警值设置了1%。

二、利用free工具监控内存利用率，超过60报警并提取出占用内存最高的前十进程。

代码如下：

#!/bin/bash
#
total=$(free -m | sed -n '2p' | awk '{print $2}')
used=$(free -m | sed -n '2p' | awk '{print $3}')
free=$(free -m | sed -n '2p' | awk '{print $4}')
shared=$(free -m | sed -n '2p' | awk '{print $5}')
buff=$(free -m | sed -n '2p' | awk '{print $6}')
cached=$(free -m | sed -n '2p' | awk '{print $7}')
rate=`echo "scale=2;$used/$total" | bc | awk -F. '{print $2}'`
echo -e "total\tused\tfree\tshared\tbuffer\tavailable"
echo -e "${total}M\t${used}M\t${free}M\t${shared}M\t${buff}M\t${cached}M\nrate:${rate}%"
if [ $rate -ge 60 ]
then echo "Memory Warn"
ps aux | grep -v USER | sort -rn -k4 | head
fi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

执行查看结果

上述脚本详细的代码含义：
1.$()：与(反引号)类似，里面执行完再返回值，所有shell通用。

2.$:变量

3.| ：表示一个管道的意思，表示把前面的输出作为后面指令的输入。

4.vmstat命令是最常见的Linux/Unix监控工具，可以展现给定时间间隔的服务器的状态值,包括服务器的CPU使用率，内存使用，虚拟内存交换情况,IO读写情况。

5.awk是一个文本分析工具，他可以把文件逐行的读入，以空格为默认分隔符将每行切片，切开的部分再进行各种分析处理，$几（0除外）就代表选取输出第几列数据，例如$2 是指第二个切片。print $2是打印第二个切片的值。

6.sed是Linux下一款功能强大的非交互流式文本编辑器，可以对文本文件进行增、删、改、查等操作，支持按行、按字段、按正则匹配文本内容。
-n：取消默认输出，sed默认会输出所有文本内容，使用-n参数后只显示处理过的行。
p:打印，打印出匹配的内容，通常与-n选项和用。

7.cat /proc/stat 查看CPU使用率。

8.grep是一种强大的文本搜索工具，它能使用正则表达式搜索文本，并把匹配的行打印出来。
grep 'cpu '：过滤掉CPU。
grep -v grep 不包含grep的行
grep -i 忽略大小写
-q: 静默模式，它查找出的东西不打印输出任何信息
-n:显示关键字的行号
-c:统计匹配到的行数
-w 精确匹配到字符
-e:匹配多个关键字（其中用 | 分割开）
-v: 输出不带关键字的行（反查询）

9.bc 命令是任意精度计算器语言，通常在linux下当计算器用。
它类似基本的计算器, 使用这个计算器可以做基本的数学运算。

10.awk ‘{printf “%.2f”,$1}’`
%.2f：表示输出浮点数, 其中小数位为2；
echo -e 处理特殊字符，转义。

11.echo $RATE | cut -d. -f1
cut是一个选取命令
-d：指定字段的分隔符。
-f ：与-d一起使用，指定显示哪个区域。
用-f1来设置要取的是第一个域。

12.-ge是大于等于
就是判断变量，是否大于等于1

13.ps aux是显示所有进程和其状态。
grep -v USER ：找出ps aux进程中不包含USER信息的。
sort可针对文本文件的内容，以行为单位来排序。
-r 以相反的顺序来排序。
-n 依照数值的大小排序。
head ：显示出一个文件的前10行。（如果只显示一行，则“head -n 1 ”）
sort -rn -k3：依据第三列从大到小排序

14.fi：每个if语句都要用fi结束，而且是每一个if都要对应一个fi。
整个if语句用fi闭合起来才算完整，书写时if和fi要垂直对齐以方便查看。

三、shell脚本监控web服务状态，若服务不存在，重启服务及数据库（守护）

脚本代码如下：

#!/bin/sh
# 获取tomcat进程ID
TomcatID=$(ps -ef |grep tomcat |grep -w 'tomcat'|grep -v 'grep'|awk '{print $2}')
# tomcat启动程序(tomcat路径)
StartTomcat=/usr/local/tomcat/bin/startup.sh
TomcatCache=/usr/local/tomcat/work
#达梦启动、关闭服务
#Startdm=$(systemctl start DmServiceDMSERVER)
Stopdm=$(systemctl stop DmServiceDMSERVER)
#定义要监控的页面地址

#获取本机ip

ip=$(ip addr | grep 'state UP' -A2 | tail -n1 | awk '{print $2}' | awk -F"/" '{print \(1}'</span><span class="token punctuation">)</span>
WebUrl=http:<span class="token operator">/</span><span class="token operator">/</span><span class="token variable">\)ip:8080

#日志输出

GetPageInfo=/tmp/TomcatMonitor.Info

TomcatMonitorLog=/tmp/TomcatMonitor.log

Monitor()

{

#date +'%F %H:%M:%S':日期格式，例如2020-02-22 19:18:30

echo "[info]开始监控tomcat...[\(<span class="token punctuation">(</span>date <span class="token operator">+</span><span class="token string">'%F %H:%M:%S'</span><span class="token punctuation">)</span></span>]"</span>
<span class="token keyword">if</span> <span class="token punctuation">[</span> <span class="token variable">\)TomcatID ];then #这里判断Tomcat进程是否存在

echo "[info]当前tomcat进程ID为:\(TomcatID</span>,继续检测页面..."</span>
<span class="token comment"># 检测是否启动成功(成功的话页面会返回状态"200")</span>
TomcatServiceCode=\)(curl -s -o \(GetPageInfo</span> <span class="token operator">-</span>m 10 <span class="token operator">--</span>connect<span class="token operator">-</span>timeout 10 <span class="token variable">\)WebUrl -w %{http_code})

if [ \(TomcatServiceCode</span> <span class="token operator">-eq</span> 200 <span class="token punctuation">]</span><span class="token punctuation">;</span>then
<span class="token function">echo</span> <span class="token string">"[info]页面返回码为<span class="token variable">\)TomcatServiceCode，tomcat启动成功，测试页面正常"

else

echo "[error]tomcat页面出错，请注意...状态码为\(TomcatServiceCode</span>，错误日志已输出到<span class="token variable">\)GetPageInfo"

echo "[error]页面访问出错，开始重启tomcat"

kill -9 \(TomcatID</span> <span class="token comment"># 杀掉原tomcat进程</span>
<span class="token function">sleep</span> 6
<span class="token function">rm</span> <span class="token operator">-</span>rf <span class="token variable">\)TomcatCache # 清理tomcat缓存

sleep 7

\(StartTomcat</span>
<span class="token function">sleep</span> 5
<span class="token function">echo</span> <span class="token string">"重启达梦服务，请稍后..."</span>
<span class="token function">sleep</span> 1
<span class="token variable">\)Stopdm

sleep 8

systemctl start DmServiceDMSERVER

sleep 24

echo "达梦服务启动成功！"
fi

else

echo "[error]tomcat进程不存在!tomcat开始自动重启..."

echo "[info]\(StartTomcat</span>，请稍候..."</span>
<span class="token function">sleep</span> 3
<span class="token function">rm</span> <span class="token operator">-</span>rf <span class="token variable">\)TomcatCache

sleep 8

\(StartTomcat</span>
<span class="token function">sleep</span> 9
<span class="token function">echo</span> <span class="token string">"重启达梦服务，请稍后..."</span>
<span class="token function">sleep</span> 3
<span class="token variable">\)Stopdm

sleep 10

systemctl start DmServiceDMSERVER

sleep 24

echo "达梦服务启动成功！"

fi

echo "--------------------------"

}

#日志导入到\(TomcatMonitorLog</span>
Monitor&gt;&gt;<span class="token variable">\)TomcatMonitorLog
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

正常状态下执行脚本
执行成功后查看tomcat状态：

查看日志：

查看数据库状态：

关掉tomcat再执行脚本
关tomcat （或kill -9杀掉tomcat进程）

执行成功后查看日志：

查看tomcat状态：

查看数据库状态：