linux基础

1：Linux 操作系统简介

　　Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件、

　　　　应用程序和网络协议。它支持32位和64位硬件。Linux 继承了Unix 以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。

　　1991年的10月5日，Linux 创始人林纳斯.托瓦兹(Linus Torvalds) 在comp.os.minix新闻组上发布消息，正式向外宣布Linux内核的诞生，
　　　　1994年3月，Linux1.0发布，代码量17万行，当时是按照完全自由免费的协议发布，随后正式采用GPL ( General Public License的缩写，

　　　　是一份GNU通用公共授权)协议。

2：Linux具有如下优点:

　　1：稳定、免费或者花费少（免费开源，）
　　2：安全性高（比windows安全性高很多，linu设计的时候严谨性很高，linux全是英文界面，）
　　3：多任务，多用户（一台linux系统上面可以运行多个任务，几十个上百人同时登录系统使用）
　　4：资源消耗少
　　5：由于内核小，所以它可以支持多种电子产品 如：androd手机和pda等，（安卓手机很多都是基于linux内核版本来研发的）

3：linux的使用范畴

　　Linux：主要使用在网站，大数据和虚拟化和企业其他这方面。开源免费的系统，

　　　　　　基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU的操作系统，
　　windws：pc机器

4： Linux 发展趋势

　　随着IT产业的不断发展，用户对网站体验要求也越来越高，而目前主流网站后端承载系统都是Linux系统，
　　　　目前Android手机全部基于Linux内核研发。企业大数据、云存储、虚拟化等先进技术都是基于Linux系统。

　　2010年据有关权威部门统计:将来几年内我国软件行业的从业机会十分庞大，中国每年对软件人才的需求将达到50万人左右。
　　　　而对于Linux专业人才的就业前景，更是广阔:据悉在未来5-10年内Linux专业人才的需求将达到120万+!尤其是有经验的资深的Linux工程师目前非常的缺乏，
　　　　薪资也是非常诱人，平均月薪都是15-20K，能力强的薪资更高。

5： Linux 系统安装

　　在安装Linux系统之前，先来了解windows系统结构，windows 系统一般是安装在 C盘系统盘，

　　同样Linux也有类似的系统盘(/根分区)，Linux通常分区为(根分区、swap 分区)，

　　　　Linux系统以文件的存储方式，所有的文件都是存储在某个目录下的，类似于windows的文件夹。

 

　　对于文件系统的属性来说，windows 文件系统类型一般是ntfs、fat32 等，
　　而Linux文件系统类型则为ext2、ext3、 ext4等(文件系统:是操作系统用于明确磁盘或分区上的文件的方法和数据结构，
　　　　文件系统由三部分组成:与文件管理有关软件、被管理文件以及实施文件管理所需数据结构。)

　　安装Linux 系统是每一个初学者的第一个门槛。在这个过程中间，最大的困惑莫过于给硬盘进行分区。虽然现在各种发行版本的Linux 已经提供了友好的图形交互界面，
　　　　但是很多人还是感觉无从下手。这其中的原因主要是不清楚Linux 的分区规定。就好比如果我们了解linux分区原则，系统盘c，数据盘d，就很好分区了

　　在Linux中规定，每一个硬盘设备最多只能有4个主分区(其中包含扩展分区)构成，
　　　　任何一个扩展分区都要占用一个主分区号码，也就是在一个硬盘中，主分区和扩展分区-共最多是4个。

　　下面正式来安装Linux系统，安装系统前需要准备如下软件:
　　　　VMware workstation 10.0　　　　　　虚拟机
　　　　CentOS 6.5 x86_ i386.iso
　　　　CentOS是redhat的一个开放版本，CentOS是子版本

6：linux目录结构

　　目录文件大体功能：进入任何一个目录执行命令，目录的命名也是标准和规范，自己也可也新建一个临时的目录，也是可以的，

　　　　/ 　　　　根目录

　　　　/bin 　　存放必要的命令

　　　　/boot 　　存放内核以及启动所需的文件/dev存放设备文件

　　　　/etc 　　存放系统配置文件

　　　　/home 　　普通用户的宿主目录，用户数据存放在其主目录中

　　　　/lib 　　　　存放必要的运行库

　　　　/mnt 　　　　存放临时的映射文件系统，通常用来挂载使用。

　　　　/proc 　　　　存放存储进程和系统信息

　　　　/root 　　　　超级用户的主目录

　　　　/sbin 　　　　存放系统管理程序

　　　　/tmp 　　　　存放临时文件

　　　　/usr 　　　　存放应用程序，命令程序文件、程序库、手册和其它文档。

　　　　/var 　　　　系统默认日志存放目录

7：root用户和普通用户

　　进入系统，我们会看到这样的字符: [root@localhost ~]# ，

　　其中#代表当前是root用户登录，

　　如果是$表示当前为普通用户。root用户能执行系统的任何东西，普通用户只能在自己的数组目录，自己家目录操作文件，

8：linux用户权限　　　　

　　在Linux操作系统中，root 的权限是最高的，相当于windows 的administrator,拥有最高权限，能执行任何命令和操作。
　　　　在系统中，通过UID来区分用户的权限级别，UID等于0,表示此用户具有最高权限，也就是管理员。其他的用户UID依次增加，
　　　　通过/etc/passwd 用户密码文件可以查看到每个用户的独立的UID.

　　每一个文件或者目录的权限，都包含一个用户权限、一个组的权限、其他人权限，例如下:（三种角色对自己文件都有特定的权限）
　　　　标红第一个root表示该文件所有者是root用户，第二个root代表该文件的所属的组为root组，其他用户这里默认不标出。
　　　　[root@node1 ~]# ls -l monitor log.sh
　　　　-rw-r--r-- 1 root root 91 May 7 20:21 monitor log.sh
　　　　[root@node1 ~]#　

　　如果我们想改变某个文件的所有者或者所属的组，可以使用命令chown（继承的意思）
　　　　chown -R test:test monitor_ log.sh 即可。

　　每个Linux文件具有四种访问权限:可读(小)、 可写(w)、 可执行(x)和无权限(-).
　　利用ls-1命令可以看到某个文件或目录的权限，它以显示数据的第一个字段为
　　准。第一个字段由10个字符组成，如下:

　　-rw-r--r-- 1 rootroot 91 May 720:21 monitor _log-.sh

　　第一位表示文件类型，表示文件，d表示目录;后面每三位为一组。

　　第一组: 2-4位表示文件所有者的权限，即用户user权限，简称u

　　第二组: 5-7 位表示文件所有者所属组成员的权限，group 权限，简称g

　　第三组: 8-10 位表示所有者所属组之外的用户的权限，other权限， 简称。

　　从上面这个文件，我们可以看出，monito log.sh 文件对应的权限为:

　　root用户具有rw读和写的权限，root组具有r读的权限，其他人具有r读的权限。

　　Monitor log.sh 权限可以表示为: 644

　　chmod o+w test.txt  　　　　给o（other其他用户）增加test.txt的w（写）的权限

　　chmod u+x test.txt 　　　　给u（用户增加x（执行权限））

　　chmod u=rwx,g=rwx,o=rwx test.txt 　　　　设置u-所有者是root用户，g-该文件的所属的组为root组，o-其他用户 三个一起设置权限
　　　　为了能更简单快捷的使用和熟悉权限，rwx权限可以用数字来表示，分别表示为r(4)、w(2)、x (1)
　　u的权限rw，r=4，w=2，所以用户三种权限加起来设置为6，----644，用户6的权限rw，组4的权限r，其他人4的权限r

　　chmod 777 test.txt 　　可以把test.txt文件的三个权限全部设置成rwx

　　　　　　　　　　　　  第一个数字代表用户，第二个数字代表组，第三个数字代表其他人的权限

　　　　　　　　　　　　 chmod 777 test.txt 可以把test.txt文件的三个权限全部设置成rwx

　　　　　　　　　　　　  第一个数字代表用户，第二个数字代表组，第三个数字代表其他人的权限

9：linux网络配置，

　　ifconfig  linux查看ip，windows：ipconfig

　　ifup eth0 启动eth0网卡，linux ip网卡命名是eth0

　　linux所有的东西都是以文件方式存储的，设置网络的文件，修改内容文件
　　　　cd /etc/sysconfig/netwodk-scripts/ 在这个文件夹下的 ifcfg-eth0 默认是dhcp获取的，可以改成静态的，BOOTPROTO属性改成static静态
　　　　ONBOOT 系统开启或者服务重启，这个网卡是启动还是关闭，我们设置成功yes打开
　　　　IPADDR=192.168.10.129
　　　　NETMASK=255.255.255.0
　　　　GETWAY=192.168.10.1
　　　　　　上面设置网络信息----谨记，上面设置网络参数不能有空格，
　　　　　　然后重启network网卡服务：/etc/init.d/network restart
　　　　linux都是在操作系统里面的东西，权限，创建删除，

10：操作系统的作用

　　管理硬件和程序的一套系统软件，
　　处理器管理
　　内存管理
　　文件系统管理
　　进程管理
　　外设管理
　　用户管理
　　等等

11：计算机软件

　　计算机软件：系统软件+应用软件+操作系统（操作系统也是软件，对下对接硬件，对上提供接口给应用软件调用，系统调用）

　　操作系统：调度管理，管理底下的硬件，给应用软件提供服务器

12：linux内核：

　　操作系统的内核：负责cpu的调度，内存的管理非常重要最核心的功能，内核还不是完整的操作系统，GUN项目：

13：终端的概念：

　　远古时期：硬件设备
　　个人电脑时代：虚拟终端设备
　　网络时代：远程终端：软件模拟出一个终端设备来，软件模拟窗口，显示器一样显示东西，通过键盘输入命令，鼠标也可也操作，linux主机在机房，云服务器
　　　　　　我们一般就是通过远程终端软件模拟器连接---直接通过pytty连接服务器（pytty）
　　ssh协议登录上去的，linux主机ip地址，端口号默认ssh的22端口，服务端的ssh需要起来，用户名+密码太短时是否有提示

　　netstat -an|grep 22 　　　　　　 linux查看sshd的服务器，绑定在22端口这个端口上，正在监听在这个端口上，

　　　　　　　　　　　　　　　　   必须要有这个ssh这个服务xshll等终端（客户端）才能连接进去。网络协议ssh协议

14：交互式的命令提示行

　　[root@worker1 ~]#　　　　　　root用户名 worker主机名  #代表root权限用户 　　~当前用户的home目录

15：shell与命令

　　用户通过命令和Linux进行交互

　　Linux是通过Shell来解释执行命令

　　Shell是一个程序

　　Shell的种类

　　　　标准shell (sh),
　　　　Bourne Again SHell (bash) 主流的linux，主要围绕这个讲解
　　　　Korn shell (ksh)
　　　　C shell (csh) unix环境用的多

　　远程登录，通过字符终端命令方式和linux进行交互，命令输入过去，linux接收到命令作出反应后返回结果，

　　　　人机交互，通过命令的方式和linux操作系统进行交互操作系统接收用户命令，是通过Shell来解释执行命令，

　　交互式窗口：远程终端输入命令，shell接管了，远程终端输入的命令都被shell程序接收了，

　　　　人通过终端设备输入命令，敲给shell，shell接收到终端命令之后首先判断这个命令需要什么样的程序去执行，

　　　　然后再把这些程序调用起来执行用户的命令，返回执行结果----大概的过程

　　命令通常也是一个个的可执行程序（ls，psw等）

　　每个命令执行具体任务完成一个功能，

16：命令的格式

　　command 参数1 参数2.....参数n　　　　conmand命令名字+一个个参数，参数个数可变

　　　linux命令由一个命令和零到多个参数构成，命令和参数之间，以及参数与参数之间空格隔开　

　　命令和参数都是区分大小写的　　PS和ls/Home

　　选项参数可以合并

　　　　ps -e-f = ps-ef

17：linux文本编辑器

　　vi编辑器
　　VI/VIM概述
　　Vi是所有Linux系统都提供的文本编辑器，它提供了一个窗口，通过它可以编辑文本文件

　　vim是vi的增强版本支持vi全部的功能
　　　　增加命令
　　　　增强功能包括颜色标记功能

　　远程登录方式基本只能用vi编辑器了，vim是vi增强版本，码农基本都是vim编辑。不需要使用键盘，

　　vi的全部功能vim都是有的，还增强了一些功能，分屏。增加了一些命令，常用的代码文件python，shell，
　　java都增加了高亮显示，识别了文本文件所属的语言，加颜色标记---看起来清晰明了

　　centos安装的vi都是vim，敲的vi的命令实际上显示的是vim

　　vi 输出：VIM - Vi IMproved ，增强版vi

18：VI编辑创建文件

　　在Linux终端中，直接输入vi就可以打开vi工具，这个时候默认的是命令模式
　　如果vi后面接具体的文件名，表示打开该文件进行查看和编辑
　　编辑一个已经存在的文件(看底部提示
　　编辑一个不存在的文件(看底部提示)
　　vi+文件名 vi编辑文件，如果文件不存在，新建这个文件编辑，如果文件存在，打开已经存在的文件进行编辑保存
　　没有鼠标，纯键盘操作(和Windows记事本比较)

　　远程登录linux主机，shell里面敲vi命令就可以打开了，

19：VI操作模式

　　vi可分为三种操作模式，分别是
　　　　1.命令模式(command mode)
　　　　2.插入模式(Insert mode)
　　　　3.底线模式(Last line mode)

　　　　三种工作状态，完成不同的任务，各个状态下完成不同的任务，

　　一：命令(COMMAND)模式（刚进入vi编辑器就是命令模式，）
　　　　刚进入时的缺省状态
　　　　此时不可以直接去添加文字
　　　　不能用退格删除文字

　　　　控制屏幕光标的移动， 定位要编辑的区域，输入字符
　　　　字符的删除、复制、粘贴
　　　　进入插入模式
　　　　进入底线模式

　　　　刚进入vi编辑器就是命令模式，不能输入字符，主要功能：
　　　　　　1：控制屏幕光标的移动，字符的删除、复制、粘贴
　　　　　　2：进入插入模式
　　　　　　3：进入底线模式 （文本导航，删除复制黏贴）

　　二：插入模式insert模式（可以输入了）

　　　　在插入模式下面可以对文件内容进行编辑
　　　　插入模式下底部有个　　INSERT 　　标记
　　　　在命令模式下，可以输入下面的字符进入插入模式（命令模式进入插入模式一般按i底部出现insert--进入插入模式）
　　　　　　i :插入，从目前光标所在之前插入所输入的字符 （光标前面插入insert）
　　　　　　a :增加，目前光标所在的下一个字符处开始插入字符 （光标后面插入，往后添加）
　　　　　　o:插入新的一行，从行首开始输入文字 （o-open new line 插入新行，光标跳入下一行）
　　　　插入模式下，按Esc键，插入模式切换到命令模式，这时候本身没有保存，esc不会退出vi，只是切换回命令模式

　　三：底线模式（底行模式） 只有命令模式才能进入底线模式

　　　　先按Esc键进入命令模式后，再输入shift+冒号:进入底线模式 命令模式按冒号，（底下出现冒号和光标，底行模式）
　　　　在底线模式下，可以完成对文件的保存、内容替换、显示格式的设置等工作，输入命令后点击回车就是执行了命令，
　　　　再按Esc键又退回到命令模式
　　　　set nu ：底线模式显示行号命令

　　　　set nonu：底线模式取消行号　

　　进入vi首先进入命令模式 ——>输入i，a，o进入插入模式，编辑和输入字符 ——>输入esc 又退回到命令模式 

　　——>shift+冒号，命令模式进入底线模式 >——>esc又能退回命令模式
　　插入模式不能和底线模式互相切换的，需要命令模式中转站

　　底线模式下：q 退出vi，文本不保存退出

　　vi编辑是存键盘操作，不需要使用鼠标，命令快捷键进行光标移动

　　命令模式功能-光标移动功能

　　　　　　按G:　　 移动到文件的最后一行   shitf+g就是大g-退到最后一行
　　　　　　按gg :　　移动到文件的开头 第一行
　　　　　　按0或^:　　光标移动到所在行的行首
　　　　　　按$:　　　　光标移动到所在行的行尾
　　　　光标的上下左右移动:
　　　　　　使用键盘上的方向键
　　　　　　或者kjhl对应上下左右
　　　按ctrl+f往下翻一页 文件很大才需要翻页。系统log文件查找问题， forward前
　　    按ctrl+b往上翻一页 backward后
　　    vim pageup pagedown也能翻页

　　命令模式功能-删除、复制

　　　　x:删除 　 vi编辑大小写敏感，按大x往前删，小x往后删 　　

　　　　　　　　小x删除当前光标所在的字符，相当于delete键删除 大X相当于backspace退格键，命令模式下退格键相当于左移
　　　　　　　　只有插入模式下退格键才可以删除，按大x往前删，小x往后删

　　　　　　　　x与X(del与backspace )

　　　　　　　　3x表示删除光标所在位置后的3个字符，包括光标所在的位置

　　　　　　　　如果不小心先按了数字键，按ECS取消

　　　　dw:删除光标所在处到词尾的内容

　　　　dd:删除光标所在的行，3dd表示删除光标所在位置往下的3行，包括光标所在的行（删除三行）

　　　　yw:复制光标所在处到词尾的内容（空白和(括号都认为是单词的间隔） yw：word复制一个单词

　　　　p:黏贴(包括前面复制操作或者删除操作的内容) paste黏贴，复制到光标所在的下一行
　　　　　　vi里面假如一行很长，会换行显示，虽然显示多行其实还是一行，
　　　　　　复制多行，数字的操作，　

　　　　vi命令模式下数字键要特别小心：vi里面数字键代表几次操作，比如 3+x会执行删除三个字符，这样的情况
　　　　命令模式下按 u 键就是撤销上一步操作，恢复（undo） 不小心按了数字键，按esc撤销刚才数字按底的操作，再输入操作

　　命令模式功能一替换、撤销　

　　　　r:取代光标所在处的字符 repalce，输入r后输入1
　　　　R:连续取代字符直到按Esc为止 R后不停输入1，替换多个字符
　　　　u:假如误操作一个指令，可以马上按u,进行撤销，可以连续按u ，散销多个之前做过的操作(等于windows下面ctrl+z)

　　　　Ctrl+r: 重做被撤销的操作(等于windows下面ctrl+y) redo--再做一次　

　

　　插入模式：也可以上下左右。插入模式的退格键才是删除，命令模式的退格键不会删除　

　　插入模式功能：

　　　　注意：

　　　　　　上下左右键也可以导航

　　　　　　退格键可以删除字符

　　　　　　终端模拟器，比如PuTTY，xhell。中的复制粘贴 使用终端模拟器复制再插入模式里面黏贴进去

　　底线模式功能：　　查找、定位（控制功能），在命令模式下面输入冒号进入底线模式

　　　　set nu:会在文件的每一行前面列出行号 ，log文件看日志显示行号 set nu是set number的缩写，set number也是可以的
　　　　set nonu 取消行号，

　　　　#是你要输入的数字，再按回车，将跳到数字指定的行，比如找到log日志的1000行， 输入冒号进入底线模式，

　　　　　　直接输入20跳到20行，输入的数字比文件还多，跳最后一行 #表示一个数字，直接数字就行，跳转100输入100行，跳转1000输入1000

　　　　/关键字 : 先按/，再输入你要寻找的字，vi关键字查找，/下划线，正斜杠，比如查询查询bit  / bit 输入inter bit高亮显示，

　　　　　　也可也不按冒号进入底线模式，命令模式下直接/bit也可也查找

　　　　　　查找到很多bit可以按键盘的n（next） 跳转到下一个bit，往回找（shift+n也就是大N往回找）

　　　　　　可以输入n,进行向下连续查找，

　　　　　　N是往上查找
　　　　　　set ic:忽略大小写 不管大小写都要找，冒号进入底线模式，敲set ic （ic-ignorecase缩写）忽略大小写，大写的也能找到
　　　　　　set noic:不忽略大小写

　　底线模式功能-字符替换

　　　　在底线模式下输入1, $s/string/replace/g会将全文的string字符串取代为replace字符串

　　　　　　1, $s/string/replace/g　　string准备替换的字符，replace要用来替换的字符
　　　　　　文档中所有的str替换成replace　　文档中所有的str替换成replace

　　　　　　1,$表示从第一行到最后一行　　　　 $ vi里面表示最后的意思　　s表示替换　　g表示每行全部替换　　　　　

　　　　　　str一行出现多次，不带g这个参数就只替换每一行第一次出现的这个字符，后面出现的str不会替换了

　　　　或者%s/string/replace/g　　　　也能替换文档中的内容

　　　　1, 20s/string/replace/g: 　　将1至20行间的string替relpace字符串

　　　　5s/gog/pig/g 　　　　　　　　现在只替换第五行的，不是每行都被替换

　　　　# w filename　　　　　　　　如果您想摘取文章的某一段，存成另一个文件，可用这个指令#代表行号，例如30,50 w nice

　　　　使用vi看日志，使用vi编辑配置文件---大部分都是这种使用，不会编辑大型文件

　　底线模式功能-保存、退出

　　　　w write，　　写入磁盘。 1,3w bbb 把当前文件的1-3行写入另外一个文件bbb
　　　　q 　　 　　退出
　　　　q！ 　　 强制退出
　　　　w a1 　　当前文件保存后需要另外文件另存一份，w+文件名 　　写到a1文件，当前正在编辑的文件还是for——vi
　　　　file 　　   查看当前编辑文件的属性（当前编辑的哪个文件）

 

　　　　w filename 　　　　(将文件保存为filename)
　　　　wq 　　　　　　　　(保存文件并且退出vi)
　　　　q!　　　　　　　　(强制退出vi并不保存当前更改的内容)
　　　　w!　　　　　　　　(强制写文件，如果该文件属性为只读，那么也强制更改该文件，并退出)
　　　　f　　　　　　　　 查看当前文件信息
　　　　edit　　　　　　    在vi里面打开另一个文件 edit bbb 当前文件跳转到bbb文件
　　　　！　　　　　　　　强制的意思，

　　　　文件只读，不一定能写进去，加！，强制写进去，当前用户必须对文件有操作权限，但是文件只是只读

　　　　　　打开vi查看查看编辑另外一个文件，

　　模式之间的切换，删除，光标的导航，保存----重点了解

20：linux文件系统

　　分区和文件系统的概念
　　linux目录结构，文件系统挂接
　　绝对路径和相对路径

　　一：分区和文件系统的概念

　　　　Windows.上的分区和文件系统：
　　　　　　新机器分区、格式化(选择文件系统NTFS) ，隐藏文件系统结构数据文件系统的理解类比国家划分、选择管理制度

　　　　　　如果只分配了一个c盘，其他的都没利用起来，空白磁盘不能不用，-----磁盘分区，windows基本都是文件系统ntfs格式，

　　　　　　如果把磁盘比作地球空间，分区把各个区域按照国家划分下来，------大分区，小分区
　　　　　　有了区域需要管理好，管理制度，不同的区域可能管理制度不一样，管理制度对应我们分区上创建文件系统的操作，文件系统是管理文件的系统
　　　　　　它除了文件数据存放在文件系统，还有一些需要的管理数据，这个数据看不见，摸不着，操作系统划分完分区会有隐藏的数据存在磁盘
　　　　　　那是操作系统用来管理的管理型数据，----档案管，隐藏的数据文件结构

　　　　WINDOWS文件系统特点：

　　　　　　Windows的文件结构是多个并列的树状结构，
　　　　　　最顶部的是不同的磁盘(分区)如: C, D, E等盘文件路径都是从盘符开始
　　　　　　Windows文件系统里面都是磁盘文件或目录
　　　　　　Windows文件路任是大小写不区分的　　

　　　　linux上的分区和文件系统：

　　　　　　linux支持的常见的文件系统种类:ext2 ext3 ext4 不同管理方式不同的文件系统　　文件系统驱动的概念

　　　　LINUX文件系统目录特点：

　　　　　　Linux文件系统目录里面不都是磁盘文件

　　　　　　Linux中，文件是个非常广泛的概念:

　　　　　　　　磁盘上的文本，图片，视频文字，Linux文件不单单只磁盘上的文件，图片，视频，

　　　　　　　　还包括硬件设备在系统里让命令访问到它，也是用一个文件系统路径一样的东西来去访问

　　　　　　　　比如打印机、终端设备: /dev/try 设备文件，并不止磁盘文件，

　　　　　　　　一些抽象的概念比如管道等: /proc

　　　　　　　　改变思维定式:看到文件路径就是磁盘上的存储的目录或文件对应起来。

　　　　　　　　linux文件不一定是磁盘上的东西，可能是存在内存里面一个抽象的对象

　　　　　　　　牛角尖: /dev, /proc 到底存在哪里?

　　　　LINUX文件目录结构的建立与挂接

　　　　　　文件结构不是从盘符开始的，而是从/根的目录开始，文件系统目录结构操作系统在引导的过程当中首先一步一步创建起来的

　　　　　　创建一个初始文件系统目录结构(包括mount到/文件系统)

　　　　　　初始化程序:挂接文件系统(mount /etc/fstab)

　　　　　　手动也可以mount命令

　　　　linux文件系统目录结构

　　　　　　/ 根（底下把子目录给创建出来如下，有的子目录对应磁盘上的文件，有的是不对应的）

　　　　　　对应磁盘上的根目录，挂接到根节点，根节点对应磁盘上的一个分区
　　　　　　除了磁盘分区文件，还有其他一些文件也挂接到根节点下面，不是这个磁盘上对应的文件系统，比如：proc 目录，不对应磁盘上的文件，
　　　　　　dev 设备，不对应磁盘上的，指的设备文件 ，这就是和windows不同的地方 不是每个分区分配一个盘幅，都是从 /根节点开始。

　　　　　　至于这个分区上的文件怎么访问，看磁盘挂在哪个地方，比如磁盘分区---sda1分区，挂接到根目录下的opt目录下面，挂接好了之后
　　　　　　这个分区下面有a1 a2 a3三个文件，挂接上opt好了之后，就在这个opt目录下面了，可以 /opt/a1这样访问文件路径
　　　　　　分区没有挂接之前没法访问的，必须挂接到文件目录结构中去才能访问 ----挂接，挂上去
　　　　　　挂接操作怎么完成：装机装好了之后在分区的过程中会让选择，比如分了个区，让挂到根目录下，至少挂到根目录下
　　　　　　也可能还一些分区挂到opt 或者其他目录，挂上去后，安装过程软件会记录到一张表文件上面：mount /etc/fstab，记录下来。
　　　　　　哪个分区挂在哪个地方了，---启动过程中读取这个文件：执行挂接操作，也就是mount操作
　　　　　　初始化程序干这个事情，已经挂好之后，挂载是程序的一些操作，程序可以调用系统文件挂载上去----手工也可也执行mount命令进行挂载
　　　　　　比如新插了个磁盘上去，不自动挂载的话需要mount命令手动挂载（底层系统调用）--文件系统连接到某个目录

 

　　　　　　现在的虚拟机接个光盘：centsos会自动检测光盘mount上去，操作系统管理程序发现一个光盘被插入了，然后它调用mount操作，mount到文件系统上去

　　　　　　通过mou命令也可也执行挂接：nt 命令查看挂接的操作，

　　　　　　/dev/sr0 on /media/CentOS_6.5_Final type iso9660 (ro,nosuid,nodev,uhelper=udisks,uid=0,gid=0,iocharset=utf8,mode=0400,dmode=0500)

　　　　　　dev/sr0 光盘设备   　　　　 /media/CentOS_6.5_Final 挂接的目录  ，创建了这么一个目录挂接上去了

　　　　　　type iso9660 光盘的文件系统 格式iso9660，

　　　　　　df  查看光盘挂载的目录，可以通过挂机点访问文件系统

　　　　linux命令执行挂接操作：

　　　　　　1:umount 反挂接，弄下来，不让他挂接目录，现在没法访问： umount /media/CentOS_6.5_Final/ /media/CentOS_6.5_Final
　　　　　　2：mkdir 创建目录 mkdir dog 光盘可以是物理光盘，也可以是image文件，虚拟光盘文件，iso文件
　　　　　　3：man mount 查看mount挂接文件系统命令的用法
　　　　　　4：mount 设备名称（文件系统） 挂接地址名称　　如下：

　　　　　　　　 mount /dev/sr0 /home/jcy/test/dog 　　只有root用户才能挂接 挂接文件系统的命令

　　　　linux系统上的目录结构

　　　　　　/bin存放必要的命令

　　　　　　/boot存放内核以及启动所需的文件/dev存放设备文件

　　　　　　/etc存放系统配置文件I

　　　　　　/home普通用户的宿主目录，用户数据存放在其主目录中

　　　　　　/lib存放必要的运行库

　　　　　　/mnt存放临时的映射文件系统，通常用来挂载使用。

　　　　　　/proc存放存储进程和系统信息

　　　　　　/root超级用户的主目录

　　　　　　/sbin存放系统管理程序

　　　　　　/tmp存放临时文件

　　　　　　/usr存放应用程序，命令程序文件、程序库、手册和其它文档。

　　　　　　/var系统默认日志存放目录

 

　　linux文件结构是单个的树状结构，没有C,D,E盘符，一切都是从 / 根目录开始，根目录下面有些东西是磁盘上的内容，没有挂接的话磁盘上的内容不能访问

　　　　挂接到哪个挂接点上，文件就从那挂接点的路径开始访问

　　linux操作系支持哪些文件系统的格式（靠操作系统的安装的文件系统驱动）

　　　　：ext3（内置的，安装各种文件系统驱动模块识别挂接其他的格式，如ntfs，都是靠驱动） nfs proc vfat   

　　LINUX下磁盘分区特性：磁盘分区都必须挂载到目录树中的某个具体的目录上才 能进行读写操作 (否则就像Windows下 而分区没有盘符)

　　　　可以挂接到任何文件系统的盘符，很长的文件结构都行/a/b/c/d，----都可以通过这个路径访问文件系统

　　df -ahT  查看linux系统磁盘分区情况，ahT加这个参数查看得比较详细，可以查看文件系统的类型，T=Type h=可读性很好的情况展示结果

　　　　filesystem 对应的文件系统所在的设备是什么----分区

　　　　proc 虚拟文件系统，不是真正磁盘的文件系统，-------/dev/打头的一般对应磁盘分区文件

21：文件名与特殊文件

　　Linux文件名称:大小写敏感，无专用扩展名

　　　　/opt/al 和/opt/A1 是两个文件

　　 ls命令查看文件和目录　　　　　　xhsell里面蓝色是文件夹，其他颜色是文件)，列出文件内容

　　　　ls;　　ls- a-1;　　　　　　　　a：all 查看更详细信息　　　　l：list 列排序

　　/　　 　　表示根目录

　　. 　　　　表示当前目录

　　.. 　　　　表示当前目录的父目录

　　.字符串　　表示隐含文件，如".bash_ profile" 文件 ，linux .+文件 ，表示这个文件隐藏了，ls不加a参数查看不到

22：LINUX系统常用目录： 经常访问的目录

　　/ Linux系统的根目录
　　/etc 系统管理和配置文件 操作web服务器，大量配置文件都在etc这个目录下
　　/home 用户主目录，比如用户user的主目录就是，多用户系统，每个用户都有自己的主目录，刚登录的时候都是进入到自己主目录里面去的，
　　　　　　比如用户user，用户主目录一般都是home/user下，这个home/user给自己用的，自己创建文件，目录，给用户用的
　　/home/user
　　/boot Linux系统的内核文件放在该目录下面，读取内核文件执行
　　/sbin 系统管理命令，这里存放的是系统管理员使用的管理程序，bin =binary 二进制代码文件，给cpu之间读取的，可执行程序
　　/root 系统管理员的主目录
　　/bin 常用可执行文件，主要有: cat,chmod,chown, date,ImV,mkdir, cp,bash等等(基本是单人维护模式下还能够被操作的指令)
　　/dev 设备文件，如/dev/cd0 设备文件一般放这下面
　　/usr 用户级应用程序 和文件几乎都在这个目录下面
　　/proc 一个虚拟文件系统，放置的数据都是在内存当中。例如系统核心、进程信息(process)、设备的状态及网络状态等等（放系统信息，进程信息）
　　/tmp 公用的临时文件存储点，存放一些临时文件，清除了也没关系
　　/mnt 系统提供这个目录是让用户临时挂载其他的文件系统，光盘一般挂这上去，临时挂载的东西
　　/lib 一些库文件。不可以删除，删了系统跑不起来了（库，可执行程序必须要加载一些库才能执行）

 

23：绝对路径与相对路径　
　　当前目录(工作目录) 我们直接工作的目录（shell目录，shell本身在的目录就是当前目录）很多操作都是基于当前目录的　

　　当用户刚登录系统时，当前目录是用户的家目录(home 目录)

　　用户家目录在创建用户的时候会产生，一般是/home/用户名:比如你是用户limin,家目录一般是/home/limin 一般用户只能在家目录写文件，其他目录不行

　　当前目录下面的所有文件都可以直接访问， 假设当前目录下面有个文件，a. txt。 要用vi编辑它，就可以直接执行vi  a. txt

　　绝对路径（全路径）：

　　　　开始于根目录，紧跟着目录树的一个个分支，一直到达所期望的目录或文件 /home/jcy/test 从/根目录开始的就是全路径 ls /home/jcy/test 绝对路径显示

　　相对路径

　　　　开始于当前目录，紧跟着目录树的一个个分支，一直到达所期望的目录或文件。 进入到想要显示的文件输入：ls 当前路径显示 这就是相对路径

　　. 代表当前目录　　　　ls ./test/log 和ls test/log效果一样的，因为.代表当前路径，.有的时候作为程序脚本运行需要的，

　　　　　　　　　　　　./hell.sh 表示告诉shell在当前路径下找程序hell.sh运行执行，不然shell程序找不到脚本

　　..代表当前目录的父目录　　python ../hello.py 代表执行当前目录下的上一层目录下的hello.py 的python文件

　　相对路径谨记：不能 cd /aaa/bbb/ 这样写，最前面不要加/，最前面加/代表根目录开始找   需要 cd aaa/bbb 这样写 或者cd ./aaa/bbb 这样写　　

24：看文本文件内容　

　　cat   less  vi   more head tail　　

25：通配符　　　　有的时候经常用的*或者？匹配一系列文件

　　模式　　　　 　　　　　　匹配对象
　　* 　　　　　　 　　　　   所有文件，匹配任意字符 ls * 列出当前目录下的所有文件
　　g* 　　　　　　　　　　  文件名以”g“开头的文件，可能是g文件，可能是g1 　　　　　　 　　 ls y* 列出当前目录下y开头的文件或者y开头的文件夹里面的内容
　　b*.txt 　　　　　　　　     以"b"开头，中间有零个或任意多个字符，并以".txt"结尾的文件　　     rm -rf *.log 删除所有的.log结尾的日志文件
　　Data??? 　　　　　　　　 以"Data"开头，其后紧接着3个字符的文件 ？匹配一个字符。三个？匹配三个字符　　　　　　 ls a？
　　[abc]* 　　　　　　　　     文件名以"a","b",或"c"开头的文件

26：文件链接　　

　　类似windows快捷方式，把文件用一种类似快捷方式，再另外一个目录再创建一个名字，看起来和文件一样，其实是一个链接

　　为什么需要链接
　　　　巨大的文件、目录，复制占空间，
　　　　不能移动，那个位置也有用
　　　　和复制的区别:文件在磁盘中只有一个拷贝，节省磁盘空间

　　硬链接、软链接

　　　　ln dog dog-hard; 　　　　硬链接、软链接dog要链接的文件的名字（链接源文件） dog-hard要参数链接的名字，链接文件的名称

　　　　ln-s pig pig-soft 　　　　 软链接

　　硬链接与软链接

　　　　硬链接:是给文件创建一个副本，原文件名和连接文件名都指向相同的物理地址。文件在磁盘中只有一个拷贝，节省磁盘空间
　　　　软链接(符号链接) :软链接的数据是所连接的文件的路径名。类似windows下的快捷方式
　　　　对源文件的修改，软、硬链接文件内容也一样的修改，因为都是指向同一个文件内容的。　

　　硬链接和软连接 原始文件在磁盘都是只有一个拷贝，软连接连接的文件名
　　　　文件本身数据存在磁盘上，本身文件文件名其实文件系统就是一个指针一样的东西指向磁盘地址，
　　　　硬连接　　地位和文件名地位一模一样的，相当于又起了个名字，也是指向磁盘的数据
　　　　软连接　　指向文件名的地址，文件存的磁盘的路径软链接是得不到的
　　　　区别：如果硬链接：把原来文件重命名了,硬链接不受影响，硬链接和文件名没关系，软链接一旦名字改了或者删了

　　　　　　 那么软连接失效，没有指向真正的数据，只是指向文件名硬连接指向问了磁盘存储的地址

　　硬链接与软链接-举例
　　　　创建两个文文件:
　　　　　　echo dog > dog;echo pig > pig

　　　　分别创建软、硬链接:
　　　　　　ln dog dog_hard; ln -S pig pig_soft
　　　　　　　　[root@worker1 yuan]# ln dog dog_hard
　　　　　　　　[root@worker1 yuan]# ln -s pig pig_soft

　　　　　　　　　　　　　　　　　　　　ll 　　查看文件信息如下
　　　　　　　　-rw-r--r--. 2 root root 4 Nov 19 11:14 dog
　　　　　　　　-rw-r--r--. 2 root root 4 Nov 19 11:14 dog_hard
　　　　　　　　-rw-r--r--. 1 root root 4 Nov 19 11:14 pig
　　　　　　　　lrwxrwxrwx. 1 root root 3 Nov 19 11:17 pig_soft -> pig 　　　　　　　　　　软链接有个指向的信息 > 指向pig
　　　　　　　　drwxr-xr-x. 2 root root 4096 Nov 19 10:38 python

　　　　　　dog_hard硬链接和原文件dog颜色一模一样的，pig_soft软链接，蓝色标志，改变源文件，硬链接和软链接都会改变--链接指向到同一个东西
　　　　　　　　不同的是dog和pig修改名字就会不同，软连接只记得指向文件的名字，而不是直接指向源文件磁盘地址，修改了文件名就找不到了，硬连接可以
　　　　　　　　软连接就是记名字，修改文件名就gg

　　　　改变硬链接对应的之前的文件名:
　　　　　　mv dog dog _new　　　　　　修改文件名
　　　　　　cat dog_hard

　　　　　　可以看到硬链接指向的文件的真实内容，所以改变以前的文件名并不影响改变软链接的文件名

　　　　改变软链接对应的之前的文件名

　　　　　　mV pig pig-new
　　　　　　cat pig-soft
　　　　　　cat: pig-soft: No such file or directory
　　　　　　可以看到软链接指向的文件名，所以改变以前的文件名，导致软链接也不可访问了。
　　　　　　删除操作也是一样的。

　　硬链垓与软链接的区别
　　　　对源文件删除(重命名)，会导致软链接不可用，而硬链接不受影响。
　　　　硬链接不能跨越物理设备（不能跨越分区，只能在同一个分区的文件，同一个mount下面可以创建硬链接），软链接可以跨越物理设备
　　　　硬链接不能关联目录，只能是关联文件，软链接可以关联目录

27：文件，目录的常用操作　　

　　find命令全找文件
　　diff命令比较文件
　　grep命令在文件中查找◆
　　WC命令统计
　　du查看目录占用的磁盘空间>

28：find命令

    find命令会在指定目录及其子目录下查找符合条件的特定文件。
    当我们忘了文件的位置，可以使用该命令。隐约记得在哪个目录层级
    
    命令格式:    find 目录名 条件            目录名：查找的目录名称，有一个文件在什么目录        条件：指明文件名有什么特征的
    
    
    常见条件:
    　　-name name指定要被寻找的文件或目录名称，可用通配符，    记得文件名，不记得文件路径，
    　　-type x以文件类型作为寻找条件。 文件类型x如下:            指明寻找目录还是文件
        　　d---目录(directory)， f ---文件(file),

    例如:
    find /temp -name"abc”                                    temp找名字为abc的，确定名称abc
    find /temp -name"abc*"                                    找abc开头的文件，通配符
    find /temp -name"abc*" - type f            

实例如下    
        
    find python -name "pachong.py"            实例：寻找pythpn文件夹里面的pachong.py文件
        [root@worker1 yuan]# find python -name "pachong.py"
        python/pachong.py

    find . -name "pachong.py"                .代表当前路径，代表从当前路径开始找，找所有    pachong.py文件        
        [root@worker1 worker1]# find . -name "pachong.py"
        ./yuan/python/pachong.py        
            
    find . -name "pa*"                        加*通配符号的，只有是pa开头的文件都能匹配到
        [root@worker1 worker1]# find . -name "pa*"
        ./.gnome2/panel2.d
        ./yuan/python/pachong.py
        ./.gconf/apps/panel
            
    find . -name "pa*" -type f                加参数-type f只匹配file文件类型，不匹配目录
        [root@worker1 worker1]# find . -name "pa*" -type f
        ./yuan/python/pachong.py

    find . -name "pa*" -type d                加参数-type d只匹配目录类型，不匹配文件    
        [root@worker1 worker1]# find . -name "pa*" -type d
        ./.gnome2/panel2.d
        ./.gconf/apps/panel
        [root@worker1 worker1]# 

29：比较文本文件差异 diff

    diff命令                
        用在文件大致相同的情况下
        命令格式: diff -y 文件名1 文件名2
        输出解释:
            |    显示每个文件不同的行
            <    显示左边文件比右边文件多出来的行
            >    显示右边文件比左边文件多出来的行        
            
    实例：
        [root@worker1 yuan]# diff -y a.txt b.txt 
        111                                111
        222                                222
        abc                                  |    333
                                          >    bbb
                                          >    aaa
                
    源代码比较都是比较强大的比较工具了    ：beyond compare 工具打的文本文件比较，上千上万行文件代码比较

30：文本关键字搜索--grep命令，对前面结果进行过滤的场景，把指定的行中关键字搜索出来，指定行的搜索

    grep命令
        一种强大的文本搜索工具，并把匹配的行打印出来。
        啥时候用?
            查看日志
            查看命令输出

        grep root /var/ log/ messages            root指关键字，root支持正则表达式，也可也写全，全字匹配，在/var/ log/ messages文本文件里面把所有包含root关键字的行数显示出来
        大小写敏感
        支持正则表达式搜索文本
        
            
    实例：grep parrten pachong.py 
        [root@worker1 python]# grep parrten pachong.py 
            parrten=re.compile('<li class="piclist\d+">(.*?)</li>',re.S)
            titleList=parrten.findall(html)
              parrten1=re.compile('<a href="/article/\d+.html" rel="external nofollow" >(.*)</a>')
              ti1=parrten1.findall(title)
              parrten2=re.compile('<div class="f18 mb20">(.*?)</div>',re.S)
              til2=parrten2.findall(title)
        [root@worker1 python]# 
                
        
        
    grep命令一例子
        grep ‘test 123' d*                通配符                显示所有以d开头的文件中包含test 123的行。
        grep' test’ aa bb CC            多个文件            显示在aa, bb, cC文件中匹配test的行。
        grep root- r / var/log            目录中递归搜索        在/var/log所有子目录子文件中搜索包含字符串“root”的行
        grep '^test’ /var/ log/scp. log    正则表达式            在scp. log中以字符串‘test”文件            
        grep ‘test 123' *                                    在当前目录下寻找文件    test 123
    
    grep 搜索，关键字有的时候加了引号，有的时候没有加，如果他是单个字符中间没有空格可以不加引号，如果中间有空格那就必须要加了，不加引号把后面的参数当成文件名了，所有需要引号
        单引号双引号都行
            
    grep '^test’ /var/ log/scp. log        ^表示一行的开始，在scp. log中查找以字符串‘test”开头的行
        

    grep命令常用参数
        -c:只输出匹配行的计数。                        不输出内容，只显示匹配到多少行
        -i:不区分大小写。让大小写不敏感
        -h:查询多文件时不显示文件名。
        -n:显示匹配行及行号。
        -V:显示不包含匹配文本的所有行                
        -F:指明pattern非正则表达式，            查找的字符串里面如果包含了正则表达式的关键字符，用 -F 表明不适应正则，就是普通的字符串匹配
        -A<n>    #同时显示该行之后n行的内容        n是数字，显示查找的这一行和之后的n行都显示    
        -B<n>    #同时显示该行之前n行的内容        
        


    grep:文本过滤器，如果仅仅是过滤文本，可使用grep, 效率高;
    
    sed与awk:        
        不止搜索，而且增加处理(增加、删除、改动)。搜到的行里面删除增加替换一些东西
    例如
        ps | sed '1d’                    不显示第一行                ps命令输出的内容，直接用后面这个命令的输入作为处理，sed通常处理文本文件，也可也处理输入输出
                                                                    sed 命令本身，1d 第一行删除，删除显示的内容的第一行
        ps | sed 's/bash/ mygod/"        替换                        输出的内容的bash替换成mygod，替换
        ps | awk '{print $1,$4}’        只显示第1列，第4列的内容    awk  
        
    管道：    
    
    seb        自学：百度 雅虎 谷歌    bing

31：文件内容统计(WC) 统计前面文件或者命令输出有多少行的

    WC -l /etc/ passwd            ：        统计/etc/passwd文件有多少行
    WC -c /etc/ passwd                    统计/etc/passwd文件有多少个字节
    带着管道符            ps -ef | wc -1：
    管道：前面命令的输出，打印在屏幕上的东西，作为后面命令的输入，本来要从文件中读，加管道后前面再加命令就不从文件读了，从前面文件输出到屏幕上的内容读取

    实例：
    wc -l pachong.py     统计pachong.py文件行数    
        [root@worker1 python]# wc -l pachong.py 
        67 pachong.py

    wc -c pachong.py     统计pachong.py文件字符数
        [root@worker1 python]# wc -c pachong.py 
        2089 pachong.py

32：查看文件和目录的磁盘空间的使用空间(du)

    du                命令是查看文件和目录的磁盘使用空间
    df                命令是查看文件系统使用空间的
    du - ah            显示指定目录以及其所有子目录和文件的磁盘占用率，a所有的，

    例如
        du- sh                #并显示指定目录整体磁盘占用率
            [jcy@localhost ]$ du -sh / hone/jcy
            1.1M/home/jcy

    df 查看文件系统的使用空间，不关心具体某个空间和某个目录，关心整个文件系统

    [root@worker1 python]# df -ahT        显示的都是文件系统里面的信息，看整个磁盘
    Filesystem                     Type                   Size  Used Avail Use% Mounted on
    /dev/mapper/vg_worker1-lv_root ext4                    18G  3.3G   14G  20% /
    proc                           proc                      0     0     0    - /proc
    sysfs                          sysfs                     0     0     0    - /sys
    devpts                         devpts                    0     0     0    - /dev/pts
    tmpfs                          tmpfs                  504M   80K  504M   1% /dev/shm
    /dev/sda1                      ext4                   485M   33M  427M   8% /boot
    none                           binfmt_misc               0     0     0    - /proc/sys/fs/binfmt_misc
    gvfs-fuse-daemon               fuse.gvfs-fuse-daemon     0     0     0    - /root/.gvfs
    /dev/sr0                       iso9660                3.6G  3.6G     0 100% /media/CentOS_6.5_Final

    
    [root@worker1 yuan]# du -sh python    显示python文件夹的字节大小
    20K    python
    
    [root@worker1 yuan]# du -ah python    显示python每个目录占有的空间和每个目录里面的文件占有的空间全部显示出来
    4.0K    python/pachong.py
    4.0K    python/hello1.py
    4.0K    python/bbb
    4.0K    python/aaa
    20K    python

33：LINUX件分割操作(SPLIT) SPLITE文件分隔

　　split [-bl] 文件 前缀
　　　　缺省按行分割，1000行
　　　　缺省前缀为x,切分成xaa、xab、 xac
　　　　-b　　设定分割完成后的文件大小，单位为b,k,m
　　　　-l　　以行数进行分割
　　　　-a　　指明后缀长度

　　示例

    [root@worker1 python]# split -l 5 pachong.py         按照5行为一个文件切割，每个文件都是5行
    [root@worker1 python]# ll
    total 72
    -rw-r--r--. 1 root root   16 Nov 19 08:56 aaa
    -rw-r--r--. 1 root root   11 Nov 19 08:57 bbb
    -rw-r--r--. 1 root root   21 Nov 18 20:34 hello1.py
    -rw-r--r--. 1 root root 2089 Nov 19 08:44 pachong.py
    -rw-r--r--. 1 root root   45 Nov 19 13:45 xaa
    -rw-r--r--. 1 root root   74 Nov 19 13:45 xab
    -rw-r--r--. 1 root root  151 Nov 19 13:45 xac
    -rw-r--r--. 1 root root  142 Nov 19 13:45 xad
    -rw-r--r--. 1 root root   79 Nov 19 13:45 xae
    -rw-r--r--. 1 root root  122 Nov 19 13:45 xaf
    -rw-r--r--. 1 root root  256 Nov 19 13:45 xag
    -rw-r--r--. 1 root root  170 Nov 19 13:45 xah
    -rw-r--r--. 1 root root  176 Nov 19 13:45 xai
    -rw-r--r--. 1 root root  248 Nov 19 13:45 xaj
    -rw-r--r--. 1 root root  271 Nov 19 13:45 xak
    -rw-r--r--. 1 root root  169 Nov 19 13:45 xal
    -rw-r--r--. 1 root root  158 Nov 19 13:45 xam
    -rw-r--r--. 1 root root   28 Nov 19 13:45 xan

    [root@worker1 python]# split -l 5 pachong.py pachong.        切割文件指定前缀pachong
    [root@worker1 python]# ll
    total 128
    -rw-r--r--. 1 root root   16 Nov 19 08:56 aaa
    -rw-r--r--. 1 root root   11 Nov 19 08:57 bbb
    -rw-r--r--. 1 root root   21 Nov 18 20:34 hello1.py
    -rw-r--r--. 1 root root   45 Nov 19 13:48 pachong.aa
    -rw-r--r--. 1 root root   74 Nov 19 13:48 pachong.ab
    -rw-r--r--. 1 root root  151 Nov 19 13:48 pachong.ac
    -rw-r--r--. 1 root root  142 Nov 19 13:48 pachong.ad
    -rw-r--r--. 1 root root   79 Nov 19 13:48 pachong.ae
    -rw-r--r--. 1 root root  122 Nov 19 13:48 pachong.af
    -rw-r--r--. 1 root root  256 Nov 19 13:48 pachong.ag
    -rw-r--r--. 1 root root  170 Nov 19 13:48 pachong.ah
    -rw-r--r--. 1 root root  176 Nov 19 13:48 pachong.ai
    -rw-r--r--. 1 root root  248 Nov 19 13:48 pachong.aj
    -rw-r--r--. 1 root root  271 Nov 19 13:48 pachong.ak
    -rw-r--r--. 1 root root  169 Nov 19 13:48 pachong.al
    -rw-r--r--. 1 root root  158 Nov 19 13:48 pachong.am
    -rw-r--r--. 1 root root   28 Nov 19 13:48 pachong.an
    -rw-r--r--. 1 root root 2089 Nov 19 08:44 pachong.py

    
    指定大小分割文件
        例: #    split -b 300k /etc/abc.txt abc. txt
            abc. txtaa
            abc. txtab
            abc. txtac
            分割成了三个小的档案

        split -l 5 abc.txt 1og
            把abc. txt分隔为多个文件，每个文件包含5行，生成的文件前缀为log

        cat abc.txta* >> abc.txt    把上面的三个小档案合成一个了，cat查看文件内容，cat拼接文件查看，

    cat hello1.py pachong.py     两个文件连起来显示，可以加多个，

34：用户管理

　　一：LINUX用户、用户组

　　　　Linux系统是一个多用户的操作系统，
　　　　任何一个要使用系统资源的用户，必须登录进入系统。
　　　　Linux用户属于一个或多个特定的组，称为用户组，即group

 

　　　　为什么要分用户和用户组?
　　　　　　资源访问控制
　　　　　　　　文件 (泛义上的文件)
　　　　所有文件都从属于一个特定的用户，和一个特定的用户组
　　　　每个文件都有一定的访问权限，用于限制不同用户和用户组的访问行为

　　用户和用户组：用户分开，资源控制权限的不同，linux主要就是文件，linux每个文件必然属于一个特定的用户，同时文件还属于哪个用户组，
　　　　每个文件都有一定的访问权限，用于限制不同用户和用户组的访问行为

 

　　linux系统中的用户分为：
　　　　1：root用户 系统超级用户
　　　　2：普通用户 自己创建的普通用户
　　　　3：系统用户

文件/etc/ passwd，用户都可以再linux一个文件找到，/etc/passwd文件，这个文件列出系统中所有用户的信息，这个文件也是我们工作中经常需要查看的

    oracle:     x:        1021:    1020:    Oracle user:         /data/network/oracle:        /bin/bash
      1         2         3          4               5                      6                                 7   

    1-用户名:长度在1到32个字符之间.                用户名：oracle
    2-密码: x表示加密密码存储在/etc/ shadow.
    3-用户ID (UID): 0是给root用户用的.            1021：用户数字标志，id一般都是一个数字    ，
    4-用户组ID (GID):用户的主组ID                主要的组
    5-用户ID说明                                描述用户信息，可以人为输入
    6-用户家目录                                为用户分配。专门给用户用的目录，里面存储用户自己独有的信息和文件，用户一般再家目录上进行操作，存放磁盘文件等操作
    7一用户的缺省shell                            /bin/bashd 用户缺省的shell，shell登录的时候就使用这个shell'，bin/shell        

　　LINUX ROOT用户
　　　　root 用户
　　　　超级管理员用户，具有操作系统的最大权限

　　LINUX普通用户
　　　　普通用户
　　　　由超级用户创建及授权，并且可以登录到Linux系统执行某些任务

　　LINUX系统用户
　　　　系统用户
　　　　系统内建了若干用户，如mail. ftp、 bin等，默认情况下，系统用户都是无法登录的
　　　　/sbin/nologin

　　二：创建用户

root用户使用useradd命令创建用户
    比如: useradd jack
    参数
        -d指明用户家目录                不加-d用户的加目录缺省的，在。    home/用户名 家目录下面
        -s指定用户登入后所使用的shell        Linux中的shell，是指一个面向用户的命令接口，表现形式就是一个可以由用户录入的界面，这个界面也可以反馈运行信息；   缺省的shell就是 bin/shell
                                            
        -g指明用户所属组
        -c加上备注文字

    该命令完成的事情
        在/etc/passwd文件中新增一行数据，表示该用户的信息;
        为该用户创建用户组，将该用户标识符加在/etc/group文件中;如果有- g选项，则不创建用户组，而是将该用户加入指定组中
        为该用户创建一个家目录(home directory) ， 将其家目录的拥有者改为该用户所有，组别也改为该用户的组别

　　三：修改用户密码

    root用户使用下列命令为用户jack设置密码) 
    passwd jack
        XXXXXX
    创建了用户之后，其密码是随机的                root新创建用户的时候密码随机的，不知道什么密码，指定密码
    用户可以修改自己的密码需要输入当前密码
    只有root用户可以修改其他用户密码

    新创建一般只有root用户了，root用户创建好了之后直接指定密码，新用户使用root用户指定的密码登录后再登录进去后自己修改密码

　　tail 　　命令显示文本文件的最后几行

        实例：
        创建用户：                                        useradd ywt
            [root@worker1 ~]# useradd ywt
            [root@worker1 ~]# tail /etc/passwd
            saslauth:x:497:76:"Saslauthd user":/var/empty/saslauth:/sbin/nologin
            postfix:x:89:89::/var/spool/postfix:/sbin/nologin
            abrt:x:173:173::/etc/abrt:/sbin/nologin
            rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
            nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
            gdm:x:42:42::/var/lib/gdm:/sbin/nologin
            sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
            tcpdump:x:72:72::/:/sbin/nologin
            worker1:x:500:500:worker1:/home/worker1:/bin/bash
            ywt:x:501:501::/home/ywt:/bin/bash


        增加起始的密码;                                    passwd ywt
            [root@worker1 ~]# passwd ywt
            Changing password for user ywt.
            New password: 
            BAD PASSWORD: it is too simplistic/systematic
            BAD PASSWORD: is too simple
            Retype new password: 
            passwd: all authentication tokens updated successfully.

　　四：修改用户信息usermod

    只有root用户能调用该命令
    修改用户的备注信息
        usermod - c ‘dev team leader’ jcy            usermod -c "ywt is leader" ywt        

    修改用户的登录目录（家目录）
        usermod -d ’/tmp’jcy

    修改用户账号名
        usermod -l newname oldname

    修改用户所属的组
        usermod -g root jcy            修改用户的主组
        usermod -G g2，g3 jcy     修改用户的其他组

　　五：用户查询用户可以使用下列指令查询用户相关信息

    1. who            #查询当前在线的用户
    2. whoami         #用户身份查询
    3. groups        #查询用户所属的组
    4.id            #显示当前用户信息    

        用户通过模拟终端登录进去，能够查看到，用户在线格式，登录时间，登录的ip

　　六：用户间切换：su

    例如:
        切换到用户jcy    su - jcy
                        su jcy
        切换到root用户
                        su -
                        su
        有没有-的区别：加了 -和直接用终端登录上去基本差不多，相当于把这个用户登录的初始化都做了一遍，包括进入用户的家目录，执行用户初始化脚本的家目录脚本都会执行一遍
            不加 -，只是以新用户登录，用户执行环境还是以以当前用户环境来做            
            前者重新初始化环境，比如:全新用户home目录，新的环境变量    
        
        每个用户可以切换到root用户，只需要直到密码，也可以切换到自己
        
        最开始jcy用户登录。对应shell，然后进入jack用户，然后又进入jack这层，session的三层嵌套，如果这时候输入exit退出，先退回到jack的执行环境
        这一层jack又exit会退回到jcy登录的这一层了，jcy这层再敲exit，那么这时候终端退出了-----

　　七：删除用户：userdel root用户才能执行删除命令，用户登录的状态下不能删除，

    userdel
        如果加参数-r，表示在删除用户的同时，一并把用户的家目录及本地邮件存储的目录或文件也一同删除

    例子
        userdelsupportA              #删除用户supportA,但不删除其家目录及文件;
        userdel - r support2        #删除用户support2,其家目录及文件一并删除;    

　　八：用户组

    Linux系统中，每个用户账号至少属于一个组，每个组可以包括多个用户。
    用户可以属于多个组，
        其中一个是主组( primary group ) - 用户创建文件的时候，文件也属于这个主组，
        其余的叫附属组( supplementary groups )

    管理组的常用命令有以下几个
        1. groupadd命令创建组
        2. groupdel命令删除组
        3. usermod命令修改用户所属组

    都是只能root用户操作

　　九：创建、删除用户组

    root用户创建用户组sales,
    groupadd     sales

    root用户删除用户组sales
    groupdel    sales

    如果有用户属于这个组呢?     primary组不能删除，组里对应用户的组是主组的话不能删除，组里面所有的用户用这个组来当从属组的话可以删除
    
    查看分组的信息：cat /etc/group

　　十：创建用户的时候指定用户组

    root用户创建sa1,sa2用户，并把他们添加到sales组里面
        useradd -g sales sal
        useradd -g sales sa2
        
    不加-g参数的话，那么useradd会为我们创建一个同名的组，创建sa1用户的同时创建sa1这个组，加了-g不会创建新的组了，直接把用户添加到组里面去了
    

　　十一：groups  显示用户的主组

　　　　主组和附属组---权限控制，对应不同的组，不同文件有不同的属性，所以用户属于多个组，用户就具有多个组的权限，归属这个组的权限都有了

　　十二：修改用户所属的组

    usermod -g root jcy        修改用户的主组(primary group)   小g修改主组
    usermod -G g2,g3 jcy       修改用户的附属组

35：文件权限管理 和用户组息息相关

　　LINUX的文件访问权限

　　　　还是从ls -1说起:
　　　　文件必有一个所属用户和一个所属的组不同类型的用户有不同的访问权限

        [worker1@worker1 yuan]$ ll
        total 52
        -rw-r--r--. 1 root root   12 Nov 19 12:30 a.txt
        -rw-r--r--. 1 root root   20 Nov 19 12:30 b.txt
        -rw-r--r--. 2 root root    4 Nov 19 11:14 dog
        -rw-r--r--. 2 root root    4 Nov 19 11:14 dog_hard
        -rw-r--r--. 1 root root    4 Nov 19 11:14 pig
        lrwxrwxrwx. 1 root root    3 Nov 19 11:17 pig_soft -> pig
        drwxr-xr-x. 2 root root 4096 Nov 19 13:48 python
        -rw-r--r--. 1 root root  119 Nov 19 13:44 xaa
        -rw-r--r--. 1 root root  293 Nov 19 13:44 xab
        -rw-r--r--. 1 root root  201 Nov 19 13:44 xac
        -rw-r--r--. 1 root root  426 Nov 19 13:44 xad
        -rw-r--r--. 1 root root  424 Nov 19 13:44 xae
        -rw-r--r--. 1 root root  440 Nov 19 13:44 xaf
        -rw-r--r--. 1 root root  186 Nov 19 13:44 xag
                                                                                                                                                
-rw-r--r--.             1           root                        root                   12                     Nov 19 12:30     a.txt
文件的访问权限        所有者个数    文件所属的用户名字（owner）        文件所属的用户组（Group） 文件大小字节为单位        文件最后修改时间    文件名，目录名

　　一：LINUX文件访问

    三种访问权限:读、写、执行，用户能对文件干的三种事情
        先理解下面的表格，后面有操作演示

    权限         （对文件来说）文件的存取权限                            目录（文件夹）的存取权限
    r             具有读文件的权限（vi，cat等读取文件）                  能查看文件夹里面的内容(比如:用ls命令能查看文件夹里面的内容)（能不能查看文件夹里面的内容）

    W             具有写文件的权限（修改文件，touch修改时间，删除）        能创建和删除文件(比如:在文件夹下面，使用touch命令创建文件)（能不能目录下创建删除文件）

    X             具有执行文件的权限（脚本，可执行的二进制程序）           能使用该目录下的文件(如cd命令)，能进入该目录    （能不能cd进去，没有写权限cd不进去）


    对一个文件来说访问它的用户还分为三种类型:
        用户类型                            说明
        owner                                文件的所有者(一般来说，谁创建了该文件，那么他就是所有者)    拥有者可以修改
        group                                文件所属工作组，（一般来说，创建文件的用户，文件所属的主组就是当前创建文件的用户所属的主组合) -- touch file举例说明
        other                                其他用户(非owner和非group)

    一般都是再自己家目录，也可也是共享目录touch文件，tmp目录就可以普通用户写入
    访问文件可能是用户拥有者，也可能不是拥有者，而是用户属于这个文件所属的工作组---组一样的

　　二：linux文件访问权限：（重点）

    ll显示文件信息，最前面显示的数权限信息如下：r读     w写     x执行

        -                                                rw-                        r--                                            r--        
      看文件属性的                                        对应拥有者的权限        针对和文件属于同一组的用户                    对应其他的用户的（不是所有者也不是组里面的）                    
        d代表目录                                                                （比如文件属于jcy这个组，
        -代表普通文件                                                            对于jcy组这一组的用户来说可以r）
        l，link符号链接或者软链接文件

    不能读也可也写的，echo命令追加，echo asdsada >> bbb     asdsada字符追加到bbb文件

　　三：改变文件访问权限的操作1：　　 chmod命令

    chmod命令------change mod
        ◆谁可以改变文件访问权限?         只有Root和Owner可以改变权限
        ◆chmod [who] [op] [permission] file...
            例如:chmod u+x filel
            
            who项表示用户类型，它的内容为以下一项或多项        u，g，a，o
                u    拥有者user -- ower)                            改变谁的文件的权限
                g    与拥有者同一组的用户(group)其他人(other)
                o    其他人 
                a    所有人(all)
        
            op项表示动作    +，-
                +    表示要加上permission指定的权利，加什么指定的权限，比如 u+r  对u所有者+上r读取文件的权限
                -    表示要取消pernission指定的权利

            permission项为存取权限，它的内容为以下一项或多项        r，w，x
                r    表示加可读
                W    表示加可写
                X    表示加可执行权限
                
    加上了可执行的权限，会变成绿色，表示可执行的了


    实例：chmod命令举例，
        chmod ug+w test            拥有者和同组用户对test文件加上“可写”权限
        chmod a-X abc.c            所有人对abc.c文件不可执行，a=all，全部，所有人
        chmod u+rwx myfilel        拥有者对myfile“加上可读、可写、可执行权限

　　四：改变文件访问权限第二种写法：直接使用=，不用+，-写法全新写入权限

    chmod u=rwx myfile
    chmod u=rwx, g=rx, o=r myfile

　　五：改变文件访问权限第三种写法

    chmod 755 myf        等价于  chmod u=rwx, g=rx, o=rx myf
    
    r=4  w=2    x=1
    
    可读可写可执行权限都用数字标志，数字是用的二进制三位的数字来标识的    二进制：0，1
    
    二进制：文件属性，三位， r w x  ，最右边第一位0，1来标识，有执行权限1标识，w有执行权限1，r有读的权限1，所以111标识可读，可写，可执行 111=十进制的1+2+4=7
        没有执行权限0标识

36：进程管理

　　一：什么是进程

　　　　程序：qq安装好了之后。到文件夹下面，.exe可执行文件，qq程序，双击运行，在windows任务管理器进程查看

　　　　　　 可以查看到进程启动了　　运行起来拉起进程，

　　二：程序和进程的概念:

　　　　程序(软件)用代码决定程序的行为，存在存储介质里面，比如硬盘。

　　　　写了代码决定程序的行为，windows计算机，excel等都是程序，代码写了之后存储到存储介质上面----静态的

　　　　　　就好像，莱谱上的一道做莱方法，此如怎么娆土豆娆鸡

　　　　程序运行起来，就是操作系统把存储介质上的可执行文件，加载到内存里面运行，这个运行的程序叫做进程

　　　　　　就好像，厨师根据了菜谱，在做菜的过程

　　　　安装的类比?复来工作的打包，满汉全席，特珠工具打色子。

　　三：LINUX里的进程

    Shell 就是一个进程查，基本上我们用户和操作系统打交道就是一个进程，shell---
        看进程的命令:     ps        
        
        [worker1@worker1 tmp]$ ps
          PID TTY          TIME CMD                        CMD    command    显示进程敲的时候对应的命令
         4298 pts/1    00:00:00 bash                    bash就是当前正在接收我们敲入命令的程序，
         4522 pts/1    00:00:00 ps
        
        TIME显示的是进程所占的cpu时间
        TTY 指的进程运行在哪个终端哪个终端把它起起来的
        PID才是重点
        
    进程ID号，类似身份证号，计算机使用数字标志一个东西的 (PID )
        ◆操作系统用数字来标识进程
        ◆ps命令显示进程的id

　　四：进程的创建

进程是由另一个进程创建的
    第一个进程init,进程ID为1
    比如shell (很多 进程的父进程) : ps -f一下看看
    创建者:父进程        对应PPID
    被创建者:子进程        对PID
    如果父进程死了?     init变成子进程的父进程，父进程id变成1了
    进程的创建方法:系统调用fork，exec   父进程调用了fork，exec来创建的---了解

　　五：系统的启动过程

系统的启动过程：操作系统的引导，引导起来过程中，创建第一个进程init,进程ID为1，init负责启动其他进程，其他进行又启动了他们各自需要启动的进程
    登录到系统里面的时候。字符终端登录的，系统会创建一个shell进程，一般shell进程
    远程登录的话就是sshd，sshd协议守护进程来创建shell进程
    shell进程----我们直接打交道的进程，shell又负责创建很多子进程，shell里面输入命令的时候shell解释执行命令，比如输入ls
    需要执行ls命令，就把ls进程创建起来了，所以shell是很多进程的父进程
    
    比如shell (很多 进程的父进程) : ps -f一下看看        ps -f当前shell创建的，当前终端的，参数只有 -f    一个就是指在当前终端上这些进程
        [worker1@worker1 tmp]$ ps -f
        UID        PID  PPID  C STIME TTY          TIME CMD
        worker1   4298  4297  0 17:14 pts/1    00:00:00 -bash
        worker1   4589  4298  0 19:15 pts/1    00:00:00 ps -f
    
    pid进程自己id
    ppid 父进程的id

　　六：ps命令查看进程，常用的查看进程的信息的

    不带任何参数：显示当前这次登录所创建出来的一些进程，再打开一个终端创建了一些进程不在这个ps命令里面显示，只显示当前这次终端登录的创建的信息
        ◆同一个用户同一个终端----

    -ef参数：e表示所有,f表示full- format,尤其是PPID 和command 内客    （-f 显示更全的信息，比如ppid父进程id    -e表示所有的意思，加e参数--显示全部进程）
        -ef 显示所有进程的一些详细信息

    axu参数：ax表示所有，u表示user-oriented>        ps aux  和上面一样，没有打印出父进程的id


    经常和管道符连用：ps - ef|grep java   管道符号，把前面命令输出的结果给后面命令当作输入的文件用，grep本身是一个文件中的关键字

　　七：后台运行进程

前台进程和后台进程
    Shell里正在执行的和用户进行交互的进程叫前台进程
    举例ps,ls分别为前台进程，时间短
    有的命令执行时间长，比如备份程序，
    可以在后台执行
        加 &
            示例runfor. py
                后台运行意味着不从标准输入读入字符
    后台运行的进程我们叫后台进程，或者后台任务
    

    前台进程：占据着系统的标准输入，现在我们敲的东西被它所接收过来的去执行
    后台进程：后台运行的进程，不占据标准输入读入字符

        输入ps命令，由于命令执行快，前台执行。很快就执行完了，没有看到占用的系统的标志输入
        输入python，执行python解释器，现在不是shell里面，shell退居二线了，由python解释器来占据终端，读取标准输入的东西
            现在输入shell的命令就不行了，不认识，现在和python解释器打交道了，python解释器就是前台的进程
            前台的进程：占据着当前终端的标准输入---我们现在和它打交道，我们输入的命令都被它拦截下来了--------这就是前台进程
                如果前台进程执行完了，输入quit，我们又回到了shell，现在输入ls就能识别了，现在shell和我们打交道了
            

    为什么需要让一个进程后台运行：因为有的进程如ps，ls执行完就退出了，历史使命很简单，前台运行一下没关系，python进程也是
        但是有的进程比如备份系统东西的程序可能执行时间很长，而且它干的事情不需要和用户打交道，它就是默默后台备份，备份完了后台打印信息备份完成就结束了
        不需要前台运行，这种情况如果让他敲命令备份程序backup的话，这时候可能占据前台的空间，不需要看到任何事情
        这时候希望不要在前台运行，后台默默运行就行了，
        
    实例：runfor.py 脚本 ，演示后台运行，其实它什么事情都不干，就是运行一段时间  如下：
        python runfor.py 60  就是运行10s，退出，运行完了之后打印一句话        演示用的，    现在这60s不能输入其他命令，输入其他命令标准输入被脚本程序占据，shell退到后面去了
        那么这时候，希望这种程序后台运行，运行同时还能干其他事情，多任务 ，它在后台运行干他的，我在前台干我的，-
        linux里面，为了让进程在后台运行   加 &  符号 ，可以在后台运行了，
        输入    python runfor.py 60 &  运行，现在输出：[1] 16913  意思是shell把这个程序放在后台去运行了，并且程序的pid是16913 ，现在可以ps命令查看
    
    
    
    后台运行进程
    nohup 与后台进程        nohup命令：打印shell终端，执行程序，有的程序需要执行很长的时间，比如备份程序，执行一整个晚上，电脑需要一直开着
                            xshell和后面的连接可能有时间限制，一段时间不操作连接就会断开，这时候运行的进程如果在前台哪怕在后台运行一旦起起来了
                            的终端xshell断开了，很可能进程也死掉了-----窗口关了进程就死了
                            
                            命令前面+ nohup这个关键字，这时候终端关了，程序不会退出的，
                            nohup  
                            
        ◆示例:没有nohup直接点X，关闭putty, 进程会退出
        ◆原因有的shell会发送SIGHUP信号给子进程
    
        nohup python runfor. py &
        nohup python runfor.py  > /dev/null 2 > &1 &
        
        
        为什么nohup能让程序不退出，
        为什么没有nohup，运行程序关了终端会退出，-一个程序运行的时候是个进程，父进程是shell，shell起的子进程，如果终端关了的话，起起来的终端
            xshell的窗口关了，shell发现自己终端连接断开了，他会发送SIGHUP信号给子进程，告诉他终端以及挂了，接收到这个信号的子进程，
            缺省干的事情就会把自己退出的----收到信息缺省就退出了，为什么关了终端为什么会退出
        
        为什么+ nohup就不会退出呢，加了nohup之后shell让起起来的python程序不收到SIGHUP信号了，首先让他和标准输入设备断开了，只有这个执行
            和终端设备没什么关心了，收到SIGHUP信号

　　八：进程前、后台切换

    列出后台进程jobs，  ：知道系统哪些后台执行的程序，当前系统shell有哪些后台执行程序
        示例:执行
            python runfor. py 301 &
            python runfor. py 302 &
            python runfor. py 303 &
        
        启动三个python进程，jobs显示三个在后端运行的进程，

        fg <num>      将后台进程调到前台                         fg 1  ，把jobs里显示进程的num数字放在fg后面，可以把这个进程调到前端运行，现在敲任何东西都没反应了
        Ctrl+Z        可挂起进程，注意jobs显示的状态是stopped      Ctrl+Z 把当前在前台运行的进程挂起在后台了，输入jobs 进程变成stoped休眠了，进程不再执行被挂起来，
                                                               如果还需要进程后台运行需要加bg 1  之后进程又在运行了                                                                    
        bg           可让进程在后台执行

    
    jobs列出系统种所有后端进程，之后让其中一个进程跑到前台运行  fg + 进程前面分配的任务号，任务号在jobs打印的进程前面的[]括号里面，fg 1
    现在敲任何命令没有反应了，因为前台被这个进程占据了，这时候想让进程后台执行，ctrl+z ，把当前的前台进程挂起了，所谓挂起状态就是不再执行了stoped
    继续后端执行需要 bg+任务号，让他后台跑   -----------具体过程

　　九：终止进程

◆进程的两种终止方式
    自行终止，
        任务执行完成，比如ps                    ps命令执行完了，打印出信息自己退出
        用户让其退出，比如shell exit            和用户交互的，shell本身的进程，不让他退出一直在等待敲命令，除非敲exit shell进程终止了
        异常退出，比如程序里有除以0的代码        程序代码有bug，异常，程序异常退出
    
    用户手动杀死进程
        kill PID        SIGTERM              kill 本质不是杀死进程，kill是给进程发信号的
                                             什么参数都不带只带进程的pid 它是指给进程发这个信息----linux里都是信号传递的过程---kill什么都不带就给进程发SIGTERM信号--
                                             终止进程----收到这个信息的进程常用操作也是结束，但是它是来的及，既然被进程接受了，那进程所对应的程序的，在编写程序的时候
                                            可以编写退出之前最后的清理工作，可以把清理工作写一段代码写在里面 所有这个kill是一种比较优雅的退出，告诉进程用户想让你
                                             退出，自行结束  ------来得及做一些预先安排的操作，程序员写的代码在结束里面
                                                
        kill -9 PID        SIGKILL                    SIGKILL信号不会给进程接收，由操作系统自己来干这个事情，不让进程自己有什么时间自行退出，强行立刻终止，----残暴    ，恶意程序加-9 杀死        
        Ctrl + C        SIGINI                    前台进程按下 ctrl+c 会发一个信息SIGINT ，也是进程自己接受到这个信息自己终止了， 

        只能是owner和root才能杀死进程
        进程也有owner的概念，ps命令的时候  ps -ef|grep runfor.py        前面显示的就是进程的owner

37：重定向和管道

　　一：标准输入、标准输出、标准错误

1：标准输入、标准输出、标准错误
    ◆Stdin、stdout、 stderr:
        用户通过终端与shell交互
        shell缺省打开3个文件句柄
        子进程继承父进程打开的文件
        进程从stdin读取用户输入
        从stdout、stderr输出信息
        指向同一个设备文件-终端
    

    用户通过终端和系统打交道，和系统真正打交道的是一个个进程，比如shell就是程序运行起来的进程。shell进程缺省打开三个文件描述符，三个文件描述符缺省的三个叫什么名字
        ：标准输入，标准输出，标准错误 ，shell程序会打开三个文件描述符--文件描述符也叫文件句柄，他门是指向文件的一个对象属于进程里面的一个东西，经常叫做对象
        三个标准对象作用：进程用来向终端输入和输出用的，开始的时候这三样东西缺省都指向终端设备，因为终端设备是用户输入东西给进程的，同时终端上面显示器
        
        是进程要输出给我们看的，--所有这三个对象都是指向终端设备的，缺省时候一开始进行shell都是指向终端设备，那么如果我这时候键盘输入东西就是通过终端设备被进程读，
        从标准输入里面读，由于指向终端也就是从终端里面读
        
        shell接受到命令了，它执行完了之后结果给大家看，对进程来说，往标准输出stdout里面写，写了之后由于stdout连接的是终端设备，所以跑到终端设备显示
        进程如果有些错误会往stderr标准错误文件描述符上面写，由于标准错误也是连接的终端设备，所以标准错误也在终端上被我们看到
        
        标准输入、标准输出、标准错误：进程里面的三样东西，进程通过它从用户读取数据，指向那从那读，输出
        
        由于进程会创建子进程，比如shell会创建子进程，比如ps命令，ps子进程就被创建了，linux系统子进程会继承父进程所有打开的文件，所有标准输入、标准输出、标准错误这三个
            也被子进程继承了，子进程ps命令，继承了父进程的三个文件标识符，继承了也是指向同一个终端设备的，ps打印的结果也是出现在终端设备上的，ls等命令也是如此
            三个对象都是指向终端设备，
        
    标准输入
    标准输出

　　二：重定向-标准输出

    有的时候，不想输出到终端上(命令结果要处理)---不希望命令的结果输出到终端上，（缺省结果输出到终端上），比如输出的结果存到文件修改，慢慢查看对比
        使用shell的一个功能    :    重定向
        ps -ef > out    也可以    ps-ef 1>out       ps -ef > out ，本来ps -ef的结果输出到屏幕上的，这样指向的话不输出到屏幕上了，改成输出到out文件，屏幕上没有任何打印
                                                            > 符号：箭头  标准输出重定向到out文件
        0 - stdin; 1 - stdout; 2 - stderr
        /dev/null
        追加而不是覆盖
        

    重定向：输出输出这些东西，缺省输入和输出都是终端，改变了导向，本来应该出现在屏幕上（终端）的东西，被弄到文件里面去了，这就是重定向，通过 > 这个重定向符来实现
        重定向标准输出，重定向到log文件
    
    其他写法：ps-ef 1>out                0代表标准输入     1代表标准输出文件描述符  2：标准错误描述符
        1代表把标准输出重定向到out，也可也什么都不写，缺省就是重定向标准输出到out
        
    实例：
     
    ps -ef > out.log            
        [root@worker1 ~]# ps -ef > out.log
        [root@worker1 ~]# cat out.log 
        UID        PID  PPID  C STIME TTY          TIME CMD
        root         1     0  0 08:35 ?        00:00:01 /sbin/init

    除了文件之外，还有标准输出，有些程序打印很多东西，重定向到/dev/null里面去 ---/dev/null这个设备文件想象成一个黑洞，如果重定向到这个里面去等于丢到黑洞里面去了，没了，垃圾场
    比如：ps -ef > /dev/null         这个命令的结果看不到了，不关心结果，不要输出了  ----不关心输出的方式，这个命令不占用内存，系统丢弃


    如果out文件本身有内容：ps -ef > out    这样重定向，会把out里面内容给覆盖掉，如果希望原来结果保留，添加到文件的后面：使用 >>  如下：
    ps -ef >> out.log 

　　三：重定向-标准错误

    ◆一段python程序toboth. py
        import sys
        sys.stderr.write(' this is to stderr\n' )                往标准错误里面打印一句话
        sys.stdout.write(' this is to stdout\n' )                往标准输出里面打印一句话
        
        这段程序既往标准输入里面打，也往标准错误里面打

        先看python toboth. py
        再看python toboth. py 2>err. log
        

    ◆同时重定向stdout和stderr到同一个文件
        Command > both 2 > &1                        &1表示把2标准错误重定向得到标准输出，both是从定向文件    

        注意次序    从左到右:反过来不行    command 2>&1 >both    
        
        command &> both (bash 4支持这样写把标准输出和标准错误重定向到both文件。还是多用上面的写法)
        
            缺省输出是标准输出，stdout，和标准错误stderr都是指向终端设备，Command > both 2 > &1        ：Command > both标准输出重定向到both文件了
            2 > &1表示2标准错误重定向到标准输出了，表示重定向到标准输出指向的设备了，标准错误也改道----------标准错误和标准输出都指向到了both文件了
            写反了不行：command 2>&1 >both    把2标准错误指向1标准输出，1标准输出一开始指向的还是终端，所有这样写不会把标准错误执行到both文件，只能把标准输出执行到both文件
            
        &符号  1 代表标准输出   2代表标准错误  为什么 &1，1这边要加&，因为不加表示把2重定向到1这个文件了，&转义用的，

    ◆同时重定向stdout、 stderr到不同的文件    command > out 2 > err        标准输出重定向到out，标准错误重定向到err


    实例： 
    [root@worker1 yuan]# python toboth.py                                 终端打出两行，因为缺省标准输出和标准错误都是指向终端的，所有标准输出和错误都能看到，
    this is to stderr
    this is to stdout
    [root@worker1 yuan]# python toboth.py > out.log                        标准输出信息重定向到out.log那么终端现在只看到标准错误了，不打印标准输出了
    this is to stderr
    [root@worker1 yuan]# python toboth.py 2> out.log                    标准错误重定向到out.log文件现在只打印标准输出了
    this is to stdout

　　四：重定向：标准输入

　　　　自动化的过程，知道需要什么东西，不需要键盘打，存到文件里面去，直接指向进程时候从文件读取----测试自动化

　　　　有时需要从文件里面读取内容，而不是终端设备   标准输入，键盘打的东西，最终变成字符流流到stdin文件描述符这个地方，

　　　　　　那么进程就可以从里面把它读出来，默认也是指向终端的，

    演示
        #readadd. py和readadd. dat
        读取3个数，分别打印出+1的结果
                
    输入，键盘输入，终端输入，输入重定向，不从键盘输入，输入 <  小于符号

    实例： 
        指向python脚本readadd.py 需要输入三个整数数据，需要从键盘输入，现在我们把这个三个数据存储到readadd.dat 文件里面
            执行脚本的时候重定向到readadd.dat 文件里面读取数据而不是从键盘输入，


        [root@worker1 yuan]# python readadd.py < readadd.dat                         输出指向readadd.py程序，数据是给程序用的，箭头朝向文件
        (1, '+1=', 2)
        (2, '+1=', 3)
        (3, '+1=', 4)
        现在就不需要从键盘输入数据了，重定向到文件读取而不是终端读取了，

    自动化测试数据：重定向到文件

　　五：管道（重点：将一个命令的输入重定向到管道里面去，同时把管道作为另外命令的输入）

    ◆经常需要将一个命令的输出的内容，给另一个命令作为输入的内容进行处理
    ◆ps一ef    和    grep python
        可以:
            Ps-ef 〉tmp.out
            grep python tmp. out
            
        可以更方便
            ps - ef grep python
    
    管道
    ◆管道示意图
        将前面的ps-ef命令的stdout (本来是输出到终端设备的) 重定向到一个临时管道设备里面，
        同时将后一个命令grep 1182 的stdin重定向到这个临时的管道设备
    
    

    第一个ps-ef命令的标准输出重定向临时的管道文件，然后把管道文件作为另外一个命令的标准输入给重定向过去----结合使用


实例： ps一ef    和    grep python       ps一ef的命令输出处理一下，grep python把输出的结果里面含有python的这个关键字的行列出来
    如果我们没有管道的话也可也干，1：Ps-ef 〉tmp.out  标准输出重定向到tmp.out临时文件   2：grep python tmp. out 到tmp. out文件把python给gerp出来也可以达到目的
    这样麻烦：多了临时文件。命令要写两条----使用管道 |  把前面命令的标准输出重定向给管道（临时存储所，不占存储空间，）把标准输出的数据管子一样流给后面一条命令作为输入用
    （本质还是重定向）把标准输出从终端设备重定向都管道文件，再把后面命令的标准输入从终端重定向到也是这个管道文件
    
    
    ps一ef|grep 1182                把ps一ef这个命令的结果中含有1182的行输出出来，
    ps一ef|grep 1182|grep 1183        从1182输出的结果里面找包含1183的行---还可以接

　　六：管道的一些用法

    ◆让stdout和stderr 同时重定向到管道    
        python both.py 2>&1|grep err    
        
    ◆连续使用管道
        ps - ef| grep python|grep- V grep

38：环境变量：针对shell而言

　　什么是shell变量?   shell里面直接写a=1  a就是一个变量，相当于给对象起了个名字，

　　　　a=l ; b=2有名字的对象

    [root@worker1 yuan]# a=1
    [root@worker1 yuan]# echo $a
    1
    [root@worker1 yuan]# a=aasdadada    
    [root@worker1 yuan]# echo $a
    aasdadada

    a就是一个变量，给对象取名，可以访问这个对象


        ◆什么是Shell环境变量    环境变量也是变量，特殊变量，这个变量可以一个个传递给子进程    shell的解释执行起很多子进程
                                当前shell的环境变量可以传递给子进程，所以子进程可以读出在执行代码过程（设计代码从环境变量读出信息）中从环境变量读出信息
                                信息可以影响进程的行为，记录下一些信息，当初编写程序的时候根据这些变量的值来决定进程的行为
                                
            特殊意义的变量， 用来影响进程的行为，可以传递给子进程

        printenv    查看shell中有哪些环境变量
            ◆环境变量是如何生成的?
            ◆操作系统为每个进程保存
            ◆每个进程可能会修改环境变量，通过初始化脚本或者用户操作
            ◆子进程继承父进程的环境变量

    printenv              查看shell中有哪些环境变量
    USER=root            前面变量名，后面变量值
    SHELL=/bin/bash        
    PATH=/usr/lib/qt-3.3/bin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin

        写的程序可以从系统读取环境变量，根据环境变量决定进程的行为，根据需求来使用----------环境变量控制程序的行为（类似全局变量）


    PATH=/usr/lib/qt-3.3/bin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin        用来让shell找输入的命令在那的（很多: 分隔的路径）
        比如执行ls命令，就从PATH路径一个个找这个命令，找到就不找了  PATH决定shell的命令的寻找的路径（很重要）

    一些可执行文件，    ./hello.sh   这种需要指定路径执行，直接输入hello.sh从上面的PATG找不到这个文件
    环境变量可以被修改的，可以让path增加

    echo $PATH
    [root@worker1 yuan]# echo $PATH                        查看具体某个环境变量的值
    /usr/lib/qt-3.3/bin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin


    export PATH=./:$PATH    ./相对路径，当前路径下去找，必须要加:$PATH，不然其他路径没了，用这命令特别小心，以前的路径移动要带着，用 $PATH展开，  $PATH意思就是展示PATH的值-结果 
                            export PATH=./:$PATH    这样写相当于PATH增加了一个./当前目录，增加在前面优先当前目录找，找不到shell再往后寻找
                            增加了环境变量现在执行hello.sh就可以执行了

    这种方式增加环境变量在这个shell里面只是临时生效，同样打开另外的终端就不行了，因为只在当前的shell下生效    export临时的生效 

    如果想让path路径永久生效：重新登录也能生效的改变环境变量,在这几个shell文件中去选，把命令放到下面这么几个文件里面去，
        这几个文件，是登录之后shell缺省会去执行的几个脚本，如果命令放这个地下相当于登录就会强行执行脚本，这个脚本包含了export命令之后那他每次登录就生效了
        加到/. bash profile这个里面就可以一直找到这个东西，命令强行加到这个里面 ,--------把命令：export PATH=./:$PATH  vi到 ~/. bash profile这个文件里面，系统每次起来都会自动执行
        ~ 符号知道当前用户的根目录， . 在前面表示隐藏文件  ls -a才能查看到如下：
        
[worker1@worker1 ~]$ pwd
/home/worker1
[worker1@worker1 ~]$ ls -a
.      .bash_history  .bashrc  .dbus      Downloads  .gconfd  .gnupg           .gvfs            .local    .nautilus  .pulse         Templates  .xsession-errors
..     .bash_logout   .cache   Desktop    .esd_auth  .gnome2  .gstreamer-0.10  .ICEauthority    .mozilla  Pictures   .pulse-cookie  Videos     yuan
.abrt  .bash_profile  .config  Documents  .gconf     .gnote   .gtk-bookmarks   .imsettings.log  Music     Public     .ssh           .viminfo   zzz
[worker1@worker1 ~]$ vi .bash_profile         把export PATH=./:$PATH   加入进去    （:./）  ---保存起来

现在重新登录终端，shell就会执行.bash_profile 的脚本了，路径加到PATH里面了，现在再执行hello.sh就能正常执行了------存文件里面的永久有效的

如果改了文件想让立刻生效不重新登录使用：source    命令 ： source    .bash_profile     让shell执行.bash_profile脚本文件就有效了 
        
        
    ◆对BASH来说            对于ba shell好几个地方可以放，/etc/profile    /. bash profile    /. bash_login
        ◆login shell
            /etc/profile,    ~/. bash profile,     ~/. bash_login,     ~/.profile    

        non-login shell
            ~/.bashrc

        ◆echo $0来区分 -bash 与 bash

        但是很多系统的    ~/.bash_ profile    包含了    ^/.bashre    
        要手工执行某个初始化脚本，source.bashre

环境变量PATH
    决定Shell搜索命令的路径
    主要给Shell用
    为什么当前路径下的hello. sh不能执行?
    PATH值的路径查找顺序
    改变环境变量
        试试export PATH=./:$PATH
        重新登录试试


环境变量PS1        PS1这个环境变量shell用来决定这个我们登录之后前面命令行显示什么东西的，    现在一般显示：worker1@worker1 ~]$ 这个，也收环境变量控制的
    echo $PS1
        \u         -当前用户
        \h         -主机名
        \w        -当前路径
        \t        -当前时间

    ◆export PS1=’\u\w>'
    ◆export PS1=" e[0;36m\u\w \e[m"

    [worker1@worker1 ~]$ echo $PS1                查看当前环境变量显示什么东西的
    [\u@\h \W]\$                                export PS1="[\u@\h \W]\$"


    显示可以自己定制：
    export PS1="\u >"            一定需要双引号
        [worker1@worker1 ~]$export PS1="\u >"
        worker1 >

39：网络接口配置

　　ifconfig -a 　　　　显示系统上网络接口的信息，a all，全部的  ---eth0和lo，pan就是网络接口名

    [worker1@worker1 ~]$ifconfig -a 
    eth0      Link encap:Ethernet  HWaddr 00:0C:29:C6:08:AF    Link encap:Ethernet：连接的封装，以太网的网络接口   
                                             HWaddr 00:0C:29:C6:08:AF：硬件地址，以太网卡的mac地址（二层传输地址，和物理网卡绑定的，虚拟机也会生成一个mac地址）
              inet addr:192.168.10.199  Bcast:192.168.10.255  Mask:255.255.255.0    inet addr：ipv4网络地址  Bcast：广播地址（子网里全填1）  Mask：子网掩码    
              
              inet6 addr: fe80::20c:29ff:fec6:8af/64 Scope:Link                                inet6 ：ipv6地址
              
              UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
              
              RX packets:20530 errors:0 dropped:0 overruns:0 frame:0        RX packets:20530：这个网络接口它接受到的报文的数量（以太网包--数据链路层）
              
              TX packets:8085 errors:0 dropped:0 overruns:0 carrier:0        TX packets:8085 :发出去的网络包的个数
              
              collisions:0 txqueuelen:1000 
              
              RX bytes:1922036 (1.8 MiB)  TX bytes:997806 (974.4 KiB)        RX bytes:接受到的网络包的总共的多少字节            TX bytes:接受报文的字节数量
              
              Interrupt:19 Base address:0x2000 

    lo        Link encap:Local Loopback                       lo：环回设备，虚拟的对象，这个对象的目的主要为了给本机内部的地址，--网络编程（通过环回地址127.0.0.1）
                                                                 本机自己访问自己的地址---只能本机用--内部地址
              inet addr:127.0.0.1  Mask:255.0.0.0
              inet6 addr: ::1/128 Scope:Host
              UP LOOPBACK RUNNING  MTU:16436  Metric:1
              RX packets:2504 errors:0 dropped:0 overruns:0 frame:0
              TX packets:2504 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:0 
              RX bytes:196116 (191.5 KiB)  TX bytes:196116 (191.5 KiB)

    pan0      Link encap:Ethernet  HWaddr 16:29:F4:7B:51:E9  
              BROADCAST MULTICAST  MTU:1500  Metric:1
              RX packets:0 errors:0 dropped:0 overruns:0 frame:0
              TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:0 
              RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)

　　一：什么是网络接口

    Linux中的一个网络给对象                    抽象的对象，类似设备文件，linux对网络接口进行操作，可以对应操作实际的对应的物理网卡和网络链路的设置
    可以对应实际的网卡，也可以是虚拟的
    命令通过操作网络接口来控制网络
    linux内核虚拟出网络接口这样一个对象来供用户进行操作，用户通过这些虚拟的网络接口对象来操作实际的网卡的目的---
    网络接口对象的的意义：让命令可以来操作，同时达到真正操作网络设备的目的（实际的虚拟的）

　　二：禁用、启用网络接口

　　　　有些网络接口，一台机器上插了好几个网卡，一些是公网，一些是私网，让公网不通，可以禁用网络接口

    方法一
        ifdown eth0
        ifup eth0

    方法ニ
        ifconfig eth0 down
        ifconfig eth0 up
        
    网络接口被禁用后这个网络接口对应的连接不通了
    网络接口的禁用开启需要root用户
    

　　三：查看IP地址的方法

    为什么要查看IP?>             ip addr
        
    显示主机的ipv4地址>         ip -4 addr        

    显示主机的ipv6地址            ip -6 addr

　　四：IP地址的配置-临时方案（命令行的方式是临时方式，重启就失效，持久的是配置文件的方式）

    命令行方式配置IP    ip配置到网络接口，网络接口是操作系统虚拟出来的一个概念，然后操作系统再把网络接口和网卡绑定，ip绑定网络接口而不是网卡---网卡对应的是mac地址
    
        ifconfig eth0 192. 168. 79.10 netmask 255. 255. 255.0 up                eth0是网络接口，改变当前网卡的ip地址
            eth0一般对应是第一个网卡，192. 168. 0.1是给eth0配置的ip地址
            netmask 255. 255.255.0配置的是子网掩码，
            up是表示立即激活

    一块网卡配置多个IP地址        给这个网卡添加多个网络接口的方式
    ifconfig eth0:1 192. 168. 79. 111 netmask 255. 255.255.0
    ifconfig eth0:2 192. 168. 79. 112 netmask 255. 255.255.0

    重启后就会失效
    上面命令也是要root用户执行
    
    配置多个ip：测试的需要，被测系统可能需要多个ip模拟多个用户登录，测试工具可以绑定在多个ip地址上模拟用户，------不需要多台机器高，

    停了的话：使用ifup

    命令可以写在shell脚本里面---去主动执行添加
    或者不行执行放到系统启动就会执行的脚本 ：/etc/rc.local 命令加到这个里面启动就会执行这个脚本的
    
    一个接口只能一个ip，一个网卡能绑定多个接口

　　五：IP地址的配置-持久有效（永久指定一个网口）

    修改网络接口配置文件
    修改/etc/ sysconfig/network-scripts/ifcfg-eth0文件
        DEVICE=eth0                                    #物理设备名--接口名
        TYPE=Ethernet                                #以太网
        HWADDR=" 00:0C:29:1B:8A:2E"                    #mac地址
        BOOTPROTO=static                            #[static dhcp]    启动协议，static静态，固定id
        IPADDR=192.168.79.111                        #IP地址
        NETMASK=255.255.255.0                        #掩码值
        NETWORK=192.168. 79. 0                        #网络地址    网段，所属哪个子网的范围
        GATEWAY=192.168.79.1                        #网关地址
        ONBOOT=yes                                    #机器重启处于可用还是down的状态
        NM_CONTROLLED=no                            #网络接口是不是受networkmanage服务控制，最好no，
        UUID                                        #系统分配的唯一标准

        立即生效需要执行service network restart    重新启动网络服务器

    修改网络接口配置文件
    
    建议:每种配置脚本都新创建一个加 前缀.dhcp或者.static然后，覆盖拷贝到对应的接口配置文件   --配置文件可以copy一份，网络的配置文件也要如此

　　六：ping-C<测试数据包数量〉<目的主机地址〉

Ping的作用:
    连通性检查
    网速检查
    
ping -C <测试数据包数量> <目的主机地址>

[root@worker1 worker1]$ping baidu.com
PING baidu.com (39.156.69.79) 56(84) bytes of data.             域名把他对应ip找出来，
64 bytes from 39.156.69.79: icmp_seq=1 ttl=46 time=43.7 ms      time=43.7 ms：指的这次ping的操作包从我这边发出去被对方收到再返回回来（响应）--发送--收到的的时间
64 bytes from 39.156.69.79: icmp_seq=2 ttl=46 time=56.2 ms
64 bytes from 39.156.69.79: icmp_seq=3 ttl=46 time=45.1 ms
64 bytes from 39.156.69.79: icmp_seq=4 ttl=46 time=84.9 ms

　　七：域名查询：nslookup命令

    nslookup <域名>
    用于查询某个域名对应的ip地址

　　八：Ping百度的时候出现“ping: unknown host www.baidu.com”，不知道百度是个啥。说明需要配置DNS服务器。

    vi /etc/resolv.conf
    nameserver 8.8.8.8
    nameserver 8.8.4.4

　　九：实例:查看baidu服务器的ip地址：nslookup baidu.com

    [root@worker1 worker1]$nslookup baidu.com
    Server:        8.8.8.9                    dns域名服务器ip（通过哪个域名服务器查询的）
    Address:    8.8.8.9#53

    Non-authoritative answer:
    www.baidu.com    canonical name = www.a.shifen.com. canonical name：别名，一般指的这个域名被dns加速了，可能这个域名对应的ip不是一个ip，分压，域名可能对应好几个ip
    Name:    www.a.shifen.com
    Address: 182.61.200.6
    Name:    www.a.shifen.com
    Address: 182.61.200.7
    

    域名查询：host命令
        [root@worker1 worker1]$host www.baidu.com
        www.baidu.com is an alias for www.a.shifen.com.
        www.a.shifen.com has address 182.61.200.6
        www.a.shifen.com has address 182.61.200.7
        www.a.shifen.com has IPv6 address 2409:8c54:870:28:0:ff:b049:5cef
        www.a.shifen.com has IPv6 address 2409:8c54:870:29:0:ff:b05c:26bf
        [root@worker1 worker1]$

40：路由与防火墙

　　一：查看路由信息

　　　　ip网络的世界访问任何网络都要通过路由，只要跟你不在一个子网里面，需要通过路由器一步步出去---访问任何网站，路由告诉机器你要到什么地方

　　　　　　该走什么样的路，对于本机来说，就像一个房子·---房子哪个门，先走到哪里--

 

　　　　　　路由表记录了机器里面要到目的地--

 

　　　　netstat -r 或者route 或者ip route三种命令都可以打印路由表

查看路由表的信息：
destination       gateway                    genmask                  flages        mertric    ref  use     iface（interface）
目的地              网关                       子网掩码                  标志                                    eth0
192.168.79.0       *                          255.255.255.0           u                                      eth0
想到达的地址        不需要通过网关（直连的网络）   用来帮助判断是哪个子网的      up启用的记录                            指的通过哪个口出去（）    网络接口                            
                   网关下一站走的地方--中转      决定目的地网段的地址                                               要到底目的地要从这个网络接口出去
                                                                                                              如果eth0绑定的是第一个网卡，那么数据就从
                                                                                                                  第一块网卡出去
link-local保留的本地链路地址

default（缺省的，上面的路由信息都找不到的话，匹配不上记录，走那条路没查出来，最后走这个，其余的都通过这个网关，这就是缺省网关）
default			192.168.79.1	0.0.0.0		ug		0	0	0			etho	
　　　　　　　　　　　　　　网关地址，缺省网关

第一个目的地192.168.79.0网关是空的，其实在同一个网段，不需要路由的，直接以太网广播就可以把包传过去	如果我的目的ip不是192.168.79这个网段的，比如是192.168.78.0-----那么只能走default这个路由，先走网关192.168.79.1，
	ping 192.168.78.1那么数据现到79.1，底下怎么做就不管了，怎么处理报文由这个网关自己来负责传递---pc把包送到网关上去就行了
	default---特别关注，网关的意思，只要不是子网里面的，只要不是同网段的，必须通过default网关出去，不然访问不了----走外网都是走网关的

　　怎么决定目的地址和网络段进行匹配

判断目的地址是不是匹配路由记录--首先看这条记录的网段具体是什么，比如说192.168.79.0  和子网掩码255.255.255.0联合起来  
　　把ip地址的二进制数值和子网子网掩码二进制的数字进行与操作如下：
ip：    1100 0000 .1010 1000 .0100 1111 .0000 0000    （192.168.79.0）
mask：  1111 1111 .1111 1111 .1111 1111 .0000 0000    （255.255.255.0）
AND:    1100 0000 .1010 1000 .0100 1111 .0000 0000    （192.168.79.0）        
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　与操作得出的数值，就是网段正在的地址---与操作，1和别的数字的与操作结果都是其他数值，1与1=1 1与0=0
                                                      0和别的数字与的操作都是0  0与0=0 0与1=0-----结果就是192.168.79.0
                                                      如果子网掩码是255.255.254.0    那么就不同了，与出来的结果就是192.168.78.0了----这就是求网段的方式
                                                      假如目标地址是192.168.79.1，那么和255.255.255.0与的结果就是-192.168.79.0---网段还是192.168.79.0
                                                       判断给出的ip地址是不是跟路由表里面的数据处于同一个网段，只要目的地址和里面与的结果是一样的
                                                       那么就是同一个网段

　　表里面每一行都是一条路由的记录

　　查看路由信息信息---多网口

　　#netstat -r 或者route 或者ip route

 

　　两块网卡---接的实际阿里云虚拟主机的两个不同的接口，

　　二：添加，删除路由

添加、删除路由
    添加路由
        route add -net 192.57.66.0 netmask 255.255.255.0 gw 192.168.79.2 dev ethO                 #意思是访问192.57.66.0这网段的话通过网关192.168.79.2去访问
        route add default gw 192. 168. 79.2
        net-路由前面的网段    netmask-子网掩码    gw-网关         dev etho：通过网络接口    
    删除路由
        route del -net 192.57.66.0 netmask 255.255.255.0 gw 192.168.79.2 
        route del default gw 192.168.79.2

如需持久有效:写入/etc/rc.1ocal        命令加到这个文件的话，这个脚本是我们机器启动过程中到最后的时候快到启动块结束的时候操作系统会去执行这个脚本---会执行添加命令

history        查看历史命令

　　三：防火墙iptables（重点--比如装环境，比如web服务，起来了，进程也在跑了，就是防火墙没打开80端口会导致访问不了这个服务）

    什么是防火墙：通过防火墙来进行网络安全的控制--某一种层次的控制，可以限制网络包的流入和流出规则
                    比如说，可以限制什么协议的包，比如tcp协议的包能不能进来-----linux网络前面真实的强，根据规则决定数据包能不能进来
                    数据进来后，处理之后一些响应的信息出去也要经过防火墙，又根据规则数据能不能出去----两方面的限制
        协议（根据这几种规则进行设置，比如只让某些协议，只让tcp访问，udp不行，某些ip，某些端口进行访问和请求，比如只让ssh22端口进行访问，其他端口不行）、IP、 端口
            功能强大

    Linux下的防火墙功能-iptables

    查看防火墙设置
        iptables -L --line numbers            ：line numbers加这个为了让规则一行行看的很清楚，规则前面有标号，1，2，3
        [root@localhost ]# iptables -L
        Chain INPUT (policy ACCEPT)                    
        target    prot opt source    destination

    Chain：链的意思，三个Chain。三个链。里面分别放入不同的规则
        Chain OUTPUT    ：输出的，发出去的包遵循什么规则
        Chain INPUT        ：input链指代进来的包遵循的规则（比如只允许tcp包进来，加控制）
        Chain FORWARD    ：忽略--把Linux主机当路由器使用，可以包不给本机，给网络里面任意一台机器，可以发给其他机器
　　　　　　　　　　　　　　　　　　（很多限制机器FORWARD是空的，不发给我的包丢掉，不当路由器使用）

        缺省规则的设置 iptables -- policy INPUT ACCEPT

    启动、停止防火墙服务
        service network start/stop

    查看防护墙的命令也只能root用户才能使用
    
    如果没有配置三条链路，三条链路信息都是空的。没有一条任何规则可以和进来和出去的包匹配的，那么这时候使用缺省规则----缺省规则policy：policy ACCEPT
        三个都是policy ACCEPT缺省的，任何进来的包。转发的包出去的包我都允许，因为现在没有其他规则，一个规则都没匹配上那么所有的包都让他进来出去
        这个iptables结果这样的话代表所有的端口和所有的协议都是打开的，机器是开放的，任何包自由往来
    


防火墙iptables        (增加规则和删除规则)
    防火墙增加规则(rule)
        插入规则iptables -I chain [rulenum] [matches...] [target]      -I插入规则，插入的指定地方的前面，插入到哪个chain链的relenum哪个位置上+具体插什么样的规则
        追加规则iptables -A chain [rulenum] [matches...] [target]       -A 
        
        Target: ACCEPT DROP REJECT

    关闭ssh端：现在不允许ssh访问：
        iptables -I INPUT -p TCP-- dport 22 -j DROP      (-I insert 的意思)没写relenum插入位置（可以写1，2，3数字为准）那么就是插入到第一个规则，-p 指明协议   
                                                            dport指明目的端口22，
                                                           -j指明到什么动作 DROP：意思所有进来的包如果是tcp协议如果目的端口是22的话那么把包丢弃 ----关闭ssh服务

    开通ssh端。
        iptables -I INPUT -D tcp --dport 22 -j ACCEPT             (-I insert 的意思)
        iptables -I OUTPUT D tcp --dport 80 -j ACCEPT
        或者删除关闭的规则

    保存规则
        service iptables save    上面加入的规则这是临时有效的，如果想永久有效可以使用这条命令，


iptables -L --line numbers -n 打出数字，不加解释



防火墙删除规则（rule）
删除规则个数：iptables -D chain [relenum]
                iptables -D INPUT 5        (删除INPUT链里面的第五条规则)

    service iptables stop   ：这个是关闭防火墙命令
    service iptables start  ：开始防火墙
    如果ssh服务被关了又想重新开启：如下
        1：删除规则：                    +    -D+链名字 delete，删除，
                                iptables -D    INPUT 2        +链 链nunber    指明INPUT链里面的第二条规则删除
                                
        2：加一条允许的命令：    iptables -I INPUT -p TCP-- dport 22 -j ACCEPT    在前面加这条命令，允许ssh访问，加到最前面在DROP的前面，允许在过滤之前
                                规则链有优先级的，排最前面的优先生效，再通过ssh访问，ssh对应底层的报文一条条匹配，第一条匹配发现就可以匹配上了就不往下走了谁排前面谁优先
                                下面虽然丢，但是第一条指明收
        关闭防火墙            

        持久生效：service iptables save

　　四：NETSTART查看链接端口状态

    #netstat -a     /显示所有连接中的socket                unix本身协议一大堆，很多unix demain sockets链接很多
    #netstat -t     /显示TCP的连接状态                    
    #netstat -l     /显示处于listen状态下的socket
    #netstat -u     /显示UDP的连接状态
    #netstat -n     /显示端口数字而不是协议名
    #netstat -p     /显示建立连接的进程信息                显示哪个进程占据了端口（端口被哪个占用-----root用户才能使用搭配grep一起使用）

    >和grep一起使用
    
tcp（协议名称）  Recv-Q   local address（本机ip地址）     state（状态，listen监听状态，代表等着别人连接）

    Proto Recv-Q Send-Q Local Address               Foreign Address             State      
    tcp        0      0 *:sunrpc                    *:*                         LISTEN      
    tcp        0      0 *:ssh                       *:*                         LISTEN      
    tcp        0      0 localhost:ipp               *:*                         LISTEN      
    tcp        0      0 *:45208                     *:*                         LISTEN      
    tcp        0      0 localhost:smtp              *:*                         LISTEN      
    tcp        0     52 192.168.10.199:ssh          192.168.10.104:54556        ESTABLISHED 


ESTABLISHED (socket连接已经建立，代表已经有人连上了)        local address（连上了本地分配的地址192.168.79.111:22---本机的ip和端口 ）
    新的这又是一个socket，网络协议，监听之后有人连接上就分配一个新的socket跟他连接，新的socket绑定的是192.168.79.111:22这个地址，
    Foreign Address 远程的ip地址和端口号192.168.10.104:54556 ，这个远程的地址跟我服务器连接，就是xhell终端的所在的电脑外面的的地址
    
    协议，本机地址和和远程地址
    
    
    [root@worker1 ~]# netstat -t -n                 显示TCP的连接状态，缺省情况下显示连接好的。listen不显示    
    Active Internet connections (w/o servers)
    Proto Recv-Q Send-Q Local Address               Foreign Address             State      
    tcp        0      0 192.168.10.199:22           192.168.10.104:54556        ESTABLISHED 
    
    
    [root@worker1 ~]# netstat -tl -n                    显示tcp listen状态下的端口连接状态（-l显示listen状态下的）
    Active Internet connections (only servers)
    Proto Recv-Q Send-Q Local Address               Foreign Address             State      
    tcp        0      0 0.0.0.0:111                 0.0.0.0:*                   LISTEN      
    tcp        0      0 0.0.0.0:22                  0.0.0.0:*                   LISTEN      
    tcp        0      0 127.0.0.1:631               0.0.0.0:*                   LISTEN      
    tcp        0      0 0.0.0.0:45208               0.0.0.0:*                   LISTEN      
    tcp        0      0 127.0.0.1:25                0.0.0.0:*                   LISTEN      
    tcp        0      0 :::111                      :::*                        LISTEN      
    tcp        0      0 :::59221                    :::*                        LISTEN      
    tcp        0      0 :::22                       :::*                        LISTEN      
    tcp        0      0 ::1:631                     :::*                        LISTEN      
    tcp        0      0 ::1:25                      :::*                        LISTEN      
    
    
查看连接状态经常和grep一起使用。如下        grep过滤
    [root@worker1 ~]# netstat -an|grep ":22"            只显示和:22相关的东西，grep过滤
    tcp        0      0 0.0.0.0:22                  0.0.0.0:*                   LISTEN      
    tcp        0      0 192.168.10.199:22           192.168.10.104:54556        ESTABLISHED 
    tcp        0      0 :::22        
    
    
netstat -i        /显示网络接口状态信息    ifconfig也可也看
    [root@worker1 ~]# netstat -i
    Kernel Interface table
    Iface       MTU Met    RX-OK RX-ERR RX-DRP RX-OVR    TX-OK TX-ERR TX-DRP TX-OVR Flg
    eth0       1500   0   491919      4    175      0      537      0      0      0 BMRU
    lo        16436   0     2149      0      0      0     2149      0      0      0 LRU
    
网络数据包统计
    显示网络数据包统计详细信息    #netstat -s            显示的ip层的，三层，    4层：tcp，udp
    显示网络数据包统计信息        #ifconfig -s        这个查看的是数据链路层的包
    
    [root@worker1 ~]# netstat -s                
    Ip:
        48263 total packets received
        29937 with invalid addresses
        0 forwarded
        0 incoming packets discarded
        2618 incoming packets delivered
        2575 requests sent out
        1032 outgoing packets dropped
        2 fragments dropped after timeout
        351 reassemblies required
        129 packets reassembled ok
        2 packet reassembles failed

41：linux网络登录，拷贝，下载文件

　　一：LINUX上的远程登录

    使用Linux命令行ssh登录远程Linux机器（以前都是用xshell终端）（linux系统远程登录其他服务器，使用ssh服务连接）
    
    ◆演示:
        ssh user1@120.26.235.152            120.26.235.152要登陆的机器的ip，@ 　　user1使用什么用户登录，也可也不写user：ssh 120.26.235.152    ，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　不填以当前用户相同的用户名登录
                                                                                       一般是填的用户名的
        ssh userl@example.com                远程机器的域名也可也登录

    安全提示
        The authenticity of host' 127.0.0.1 (127. 0.0.1)’can't beestablished.
        RSA key fingerprint is
        01:6d:d3:fd:28:6d:7c:19:f5:68:d7:77:7f:af:d3:63.
        Are you sure you want to continue connecting (yes/no) ?
        第一次登录提示，提示我们这台机器之前没有登录过，有可能这台机器是一台危险的机器，弹出提示，---登的是之前从来没有登过的机器
        有可能是病毒机，告警告诉这台机器以前没有登录过，打印机器的信息，让你确认要不要登录-----输入yes  进行登录


LINUX上 的远程登录
◆Linux上的直接登录，使用场景
    工作机器就是Linux主机，使用不了xhell终端，
    远程Linux主机不能直接登录
    
    外企工作，很多机器都是跨国家的，访问的机器不能直接登录，没有对外ip，私网ip，


linux上远程登录
    以前的远程登录   telnet和ssh区别：telnet协议远程登录和访问中间传输的数据都是明文的，不加密传输的---早期telnet用的多        ssh加密传输
    ssh默认端口号22   telnet默认端口号：23
    

    以前的远程登录telnet
    不安全:一切(用户名密码)都是明文传输
    现在仍然有使用
    linux缺省已经不再启用，需要手工安装服务端、客户端（linux默认没有安装telnet，）    

　　二：LINUX主机之间拷贝文件-SCP，拷贝文件的

命令scp:底层也是通过ssh协议建立一个加密链接通道，在这上面传输我们想要传输的文件

Linux主机之间拷贝文件    scp和cp很像，scp多了个机器要远程登录的用户名和ip地址在前面
    scp this.txt jcy@120.26.235.152:/home/jcy                    单个    把this.txt这个文件拷贝到远程120.26.235.152这台机器的/home/jcy目录
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　需要加远程机器的 用户名@ip地址: 这种格式　　　　　　　　　　

   
    scp thisl.txt this2.txt jcy@120.26.235.152:/home/jcy        多个文件

    scp -r dir1 jcy@120.26.235.152:/home/jcy                    拷贝目录    + -r参数，这里-r需要放在前面

    scp jcy@120.26.235.152:/home/jcy/that.txt /home/jcy/abc        拷贝到本地

    如果不写用户名，则为本地用户（不带jcy@就会以当前用户名相同的用户登录远程机器）    
    
    
scp hello.sh jcy@120.111.111.111:/home/jcy                        hello.sh源文件    jcy目的主机想登陆的用户名   @   120.111.111.111目的主机的ip地址   
                                                               ：/home/jcy  拷贝到目的主机哪个目录(jcy )下
                                                               输入命令后会弹出让你输出远程机器的密码---输入密码正确就有传输的提示    
                                                               把本机文件拷贝到远程设备下
    

scp  jcy@120.111.111.111:/home/jcy/zzz    .              从远程把文件拷过来，把目标机器放在前面就行了    
                                                        把120.111.111.111远程主机的/home/jcy目录下的zzz文件包括到本地的相对路径  .(当前路径)
                                                                                    点击inter需要输入远程的密码，输入密码正确就下载下来了
    
    
    
命令scp:
Linux主机之间拷贝文件（注意覆盖问题---scp小心操作，靠的目标目录有同名文件就会被覆盖掉，还不会提示）
    scp this.txt jcy@120. 26.235.152:/home/jcy

    scp jcy@120.26.235.152:/home/jcy/that.txt  /home/jcy/abc

    覆盖问题
    注意权限
        [jcy@localhost ~]$         scp test.iso 120.26.235.152:/home/test.iso        假如远程登录的jcy对/home/目录没有写的权限就写不进去，命令gg

        jcy@120.26.235.152's password:
        sep: /home/test. iso: Permission denied

    ➢注意登录时的初始化脚本里面不要有输出到终端的语句    ：远程登录的初始化脚本（环境变量初始化脚本不要有echo语句输出到终端，不然就会拷贝失败）
    
    操作权限：远程机器以什么登录的，保证那个登录的用户要要权限操作目录：
        scp this.txt jcy@120. 26.235.152:/home/jcy    ：登录120. 26.235.152机器是以jcy用户登录的，拷贝到/home/jcy路径下，jcy用户对远程操作的目录有写的权限--不然gg
    
        读也是一样，从远程读一个文件，使用远程登录的用户要对读的文件要有读的权限 
    
    
    scp是通过ssh通道来传输文件的----scp执行执行命令远程拷贝的时候，scp创建一个ssh子进程，去连接到远程，通过ssh建立一个远程连接的通道
    然后scp命令再把文件读出来通过通道传递给远方-----通过ssh的（自动化的时候scp考文件打印shh错误理解原理）

　　三：WINDOWS和LINUX之间拷贝文件

    工具winscp:
    百度下载、安装

    操作演示
        创建远程登录连接
        拷贝
        远程创建、删除目录    
        
        左边本地目录，右边远程机器        这时候就可以互相拷贝文件，拖来拖去，拖拉就行
        winscp软件也可也右键在远程创建目录：新建--新建文件夹（输入文件名）   可以在远程创建文件和删除文件   删除选择文件删除就行----类似文件管理器

　　四：下载文件-wget搭建环境需要服务器从外面下载资源

    使用场景
        一般是公共的下载服务器
        Linux用户经常用来下载安装包等
        协议http、https、ftp                ---linux使用wget下载东西，一般下载安装包和镜像，centos镜像-----

        示例:
            wget http://tel.mirrors. 163.com/centos/timestamp.txt

        断点续传
            wget https://www.python.org/ftp/python/3.5. 2/python-3.5.2.cxe -c    
        
        
    从centos上下载文件：wget http://tel.mirrors.163.com/centos/timestamp.txt    文件服务上找到了
            
    找到文件：鼠标右击，复制链接地址：http://mirrors.163.com/centos/RPM-GPG-KEY-CentOS-4   然后使用wget下载
        wget http://mirrors.163.com/centos/RPM-GPG-KEY-CentOS-4        根据网址就可以下载

    wget断点续传---  -c  下载大文件，一半突然断了，从头开始下麻烦，命令最后加个  -c  参数就行，如果上次下载断了，还回到那个上次上传的目录里面输入  wget  -c就可以
        断点续传了----wget https://www.python.org/ftp/python/3.5. 2/python-3.5.2.cxe -c  ，接着上次传输的地方
        

    wget与scp的区别        都是拷文件
        目标机器是否知道用户密码的
        协议不同: ssh--http, ftp
        
        scp目标机器和linux是对等的关系，远程的一台linux主句，需要知道远程主机用户名和密码才能登录上去拷贝  ----ssh协议底层拷贝东西的
        wget 大部分不需要远程机器的用户名和密码，偶尔也需要，---专门用来下载文件的服务器    协议---http ，ftp，https

42：打包压缩与软件安装------搭建测试环境经常需要干

　　一：打包与压缩

    打包和压缩的区别
        打包是指把文件和目录的结构和内容拷贝到一个文件里
        压缩是指把文件经过一些算法变成体积上更小的文件，

    从Winzip说起
        一般是既打包也压缩
        可以不压缩，只打包

    经常做的Winzip压缩其实是既打包也压缩，两步并作一步，
        打包是指把文件和目录的结构和内容拷贝到一个文件里--比如文件夹下面一个目录地下的东西放到一个文件里面去----这个过程就是打包（内容放到一个文件）
                    把文件和目录都放到一个文件去这个过程就叫打包到文件里
        压缩：把文件通过压缩算法体积上变成更小的文件----文件变小

LINUX里的打包命令    tar命令
    tar cvf files.tar 123.txt 456.txt 789.txt                    打包-文件    files.tar打包成的文件，什么都放这个文件里    123.txt 456.txt 789.txt要打包的文件
    
    tar cvf files.tar dirl                                        打包-目录    dirl是一个目录，目录地下所有的子文件都打包

    tar tvf files.tar                                            查看包内容

    tar xvf files.tar -C dirI                                    解开包        C dirI指明包想解到dirI这个目录，不加-C 那么解包到当前路径下

    vf详细信息      c-create创建           t-查看            x--解开包

　　二：LINUX里的压缩命令GZIP

gzip命令
    压缩一个或多个文件
    
    gzip file1 file2            跟两个参数，命令执行完了当前路径下出现 file1.gz   file2.gz    同时原来的file1和file2不见了，只剩下两个.gz文件
    
    压缩完后，原来的文件会被替换为<name>.gz
    
    gzip-d file1.gz 解压                    d=deconprece --解压
    
    不能压缩目录                gzip    不能压缩目录，很多东西弄到一个文件里面去，目录，文件  需要使用tar先打包，然后使用gzip压缩
    
    与tar合用
    tar zcvf data.tar.gz filel dI                        打包并压缩            +z  = +压缩        
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　打包后最后一步压缩一下文件---最终出现的文件名：data.tar.gz   加了z最后会调用gzip压缩
                                                                   加了z之后扩展名需要加.gz  表明它用gzip压缩好的文件----不加也行，但还是要加，清晰
                                                                    data.tar.gz   ----tar包 ga压缩
     
    tar -zcVf data.tgz *.doc                            打包并压缩            *.doc        

    tar zxvf pics.tar.gz                                解压缩                先解压，然后得到打的包了，再解包　　先gzip把包解压缩，解压缩之后我再tar把包打开 
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　解压到当前目录

    tar ztvf data.tar.gz                                查看压缩包内容        t查看   不解压缩，不解包，只是查看


LINUX里的压缩命令BZIP2  -----gzip和BZIP2用法差不多，压缩算法不同
bzip2命令
    压缩一个或多个文件
    bzip2 filel file2                                压缩成file1.bz2  和file2.bz2两个压缩文件 
    压缩完后，原来的文件会被替换为<name>.bz2                        
    
    bzip2 -d filel.bz2                                    解压 -d

    不能压缩目录
    与tar合用，目录压缩要和tar合用，先把目录tar打包
    tar jcvf data.tar.bz2 filel d1            打包并压缩                j表示bzip2 ----先打包，打包完之后再bzip2压缩成bz2格式的压缩文件--和gzip一样的

    tar jxvf pics.tar.bz2 *.jpg *.png        解压缩                    pics.tar.bz2先解压然后再接压缩---展示到当前目录

    tar jtvf data.tar.bz2                    查看压缩包内容


    bzip2和gzip有什么区别：bzip2后来才使用的，压缩率更高，体积更新，但是软件运行起来占用的内存多一些，多几兆，现在无妨，内存动不动就几个g
                            gzip虽然压缩率没那么高，但是速度相对快压缩速度快
                            bzip2使用的更多，都还行

　　三：LINUX里的压缩命令ZIP

zip命令                        新的linux版本zip都内置了，老的没有，   像windows一样既打包也压缩，
    压缩打包一个或多个文件（可以是文件也可也是目录）
    zip zipName.zip file1 dir1
    unzip zipName.zip            解压

　　四：LINUX里可安装源码包的安装(安装代码包)

　　　　包文件是一个文件，文件是tar.gz  和tar.bz2 打包好的文件，里面包含了源代码，还包含了用来安装源代码--源代码变成可执行的东西  --c语言

　　　　　　c语言做成可执行程序需要编译成可执行二进制文件，需要执行很多步骤 1：编译   2：安装 

　　　　　　linux 版本很多，做二进制安装包麻烦，---所以提供源代码包，自己在环境里面编译安装

    什么是可安装源码包                        
    为什么需要从源码包安装
    以nginx的安装为例演示过程        nginx--http server ---性能高，网站服务器

                                wget--下载源代码包（二进制代码包）到本地，才能编译            tar.gz--压缩的包    
        
        tar zxvf nginx-1.8.1.tar.gz                      tar.gz文件 --需要把包解压，出现nginx-1.8.1目录在当前，打包的就是这个目录 ---cd到目录里面执行configure
                                                           解开--tar  -gzip   

        configure                                        cd 到目录  执行configure---编译安装的过程配置一些执行configure命令，这个命令执行后会检测当前环境是不是
                                                         适合来编译这个文件---检测

        make                                             make ---编译项目文件  make项目文件，一个个找出依赖关系，--编译成二进制文件

        make install                                    编辑成功后执行make install    ，把编译好的二进制文件拷贝到机器能找到的目录  /bin   或者usrer/local 
                                                        一般configure不加什么后缀一般拷贝到user/localbin目录下---path环境变量下的
                                                        敲命令可以找到的 ---找不到就需要加到path路径了，或者执行命令的适合路径写全了
                                                                                
    安装过程中经过发现依赖的包没有还需要装另外的包        

　　五：LINUX里RPM包安装软件

　　　　RPM类似windows上的安装包，包里面都是编译好的二进制文件，类似.exe文件---   安装工具也叫RPM------主流平台

    什么是RPM命令、RPM安装包
        Redhat发明的一种软件包安装工具和安装包格式
        目前大部分是编译好的，不包含源代码

    以dos2unix的安装为例演示过程
        wget ftp://rpmfind.net/linux/centos/6.8/os/i386/Packages/dos2unix-3.1-37.el6.i686.rpm
        
        安装命令：rpm -ivh +安装包的名字                          i=insetall
        
    ◆删除安装的软件
        [root@localhost sq]# rpm -qa|grep dos2unix            qa查找所有的rpm包     |grep dos2unix    查找包含了dos2unix这个关键字的行数  
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　把安装的包的名字显示出来了
        dos2unix-3.1-37.el6.i686                                        
        [root@localhost sq]# rpm -e dos2unix-3.1-37.e16.i686   删除是  rpm -e +查出的包名           --rpm安装的文件给删除了                                                                        
                                                                                    
                                                                                
带源代码的需要自己编译成二进制安装文件，    

　　六：LINUX里YUM安装软件 

　　　　更方便的安装方式  yum  ，RedHa包管理器和RPM的区别：底层还是RPM，把RPM包下载下来然后给再装，

　　　　　　现在安装不需要下载，指定名字就网上主动去寻找，找完之后自动下载安装，还能自动处理依赖关系

　　　　　　程序依赖另外一个程序，需要先装另外一个程序，---又要下载包，又要对应linux版本，麻烦----有了YUM，依赖关系自动处理，指定安装那个包

　　　　　　到对应服务器下载，如果发现安装的包还依赖另外一个包，自动下载依赖的包安装----自动

　　　　　　网上去下载安装：YUM怎么知道到网上那个地方下载的，---通过它自己的一系列配置，/etc/yum.conf下面--etc是配置文件

　　　　　　yum.conf这个文件是yum全局配置文件，指定了yum运行的特性，有一个设置叫repository section--指明那到哪些服务器下载rpm包，里面有服务器的网址

　　　　　　/etc/yum.conf--文件要自己写，可以自己设置，大部分时候在/etclyum.repos.d/*.repo这个下面，全局配置文件指明缺省了告诉yum到

　　　　　　/etclyum.repos.d/*.repo这个目录去找这些以.repo结尾的配置文件，这些配置文件指明了你要到哪些服务器上找安装包，依赖包

    什么是yum安装
        在Fedora和RedHat以及SUSE、CentOS中的软件包管理器
        基于RPM包管理，
        能够从指定的服务器自动下载RPM包并且安装，
        可以自动处理依赖性关系，并且一次安装所有依赖的软件包

    /etc/yum.conf
        main section
        repository sections, yum源

    /etclyum.repos.d/*.repo                                            
        mirrorlist                                                                                
                                                                                                                                                                   
    以dos2unix的安装为例演示过程   yum安装简单，就是包的查找配置文件很复杂

    安装：                [root@localhost]# yum install dos2unix

    删除：                [root@localhost]# yum remove dos2unix                        （依赖关系的包也能主动删除）

    列出当前已经安装的：    [root@localhost sq]# yum list installed (available)    
                            
                            yum list         查找yun已经安装的，和yum配置源。yum的配置文件可以安装的包全部列出来，数目很多，几千条，查已经安装的要加installed
                                                                                
                                                                                
                                                                                
    以安装mysq16.5为例
    根据安装民档在centos6.5安装mysq15.6安装步骤
        wget http://repo.mysql.com/mysql-community-release-el6-5.noarch.rpm
        
        rpm -ivh mysql-community-release-e16-5.noarch.rpm

        执行下面命令安装mysql server (也包括了命令行client) 和mysql devel

        yum install mysql-server
        
        yum install mysql-devel                                                                            
                                    

　　七：LINUX里apt-get安装软件 　　类似yum，寻找依赖关系，我们使用的centos

　　　　debian, ubuntu发行版的包管理工具

　　　　与红帽中的yum工具非常类似。

　　　　例: apt-get install mysql-server

　　八：tar命令+gzip实例操作：

1：tar命令+gzip
    [root@worker1 yuan]# tar cvf abc.tar xaa xab xac                三个文件打包成一个abc.tar文件
    xaa
    xab
    xac
    [root@worker1 yuan]# ls
    abc.tar  a.txt  b.txt  cccccccccccccccc  dog  dog_hard  out.log  pig  pig_soft  python  readadd.dat  readadd.py  toboth.py  xaa  xab  xac  xad xae  xaf  xag
    [root@worker1 yuan]# tar tvf abc.tar                             显示包里面的内容，不解包
    -rw-r--r-- root/root       119 2020-11-19 13:44 xaa
    -rw-r--r-- root/root       293 2020-11-19 13:44 xab
    -rw-r--r-- root/root       201 2020-11-19 13:44 xac
    [root@worker1 yuan]# mv abc.tar ../f1                            移动包到f1文件夹
    [root@worker1 yuan]# cd ../f1/
    [root@worker1 f1]# ls
    abc.tar
    [root@worker1 f1]# tar xvf abc.tar                                 解包，tar包文件还早没有删除
    xaa
    xab
    xac
    [root@worker1 f1]# ls
    abc.tar  xaa  xab  xac
                                                                                
    [root@worker1 f1]# gzip abc.tar                                 压缩abc.tar 这个包，也可也tar命令打包
    [root@worker1 f1]# ls
    abc.tar.gz  xaa  xab  xac

    [root@worker1 f1]# tar zcvf abc.tar.gz xaa xab xac                直接把文件打包和压缩，一步到位，这时候
    xaa
    xab
    xac
    [root@worker1 f1]# ls
    abc.tar.gz  xaa  xab  xac
    [root@worker1 f1]# tar ztvf abc.tar.gz                             查看压缩包里面的内容
    -rw-r--r-- root/root       119 2020-11-19 13:44 xaa
    -rw-r--r-- root/root       293 2020-11-19 13:44 xab
    -rw-r--r-- root/root       201 2020-11-19 13:44 xac
    [root@worker1 f1]# tar zxvf abc.tar.gz                             解压缩包
    xaa
    xab
    xac
    [root@worker1 f1]# ls
    abc.tar.gz  xaa  xab  xac

　　九：nginx bulid方式（make）安装

　　　　首先要知道nginx包在哪里，而且nginx这种方式安装需要root用户，启动需要root权限，通过makeinstall装的都是一些基础的东西，

　　　　很多用户都需要用的，放在公共的目录下面---root用户-----make  install源代码安装过程

    1：新建一个目录
    2:wget  下载
    3：解压
    4：进入目录里面三部曲
    5：configurre
    6：make
    7：make install
    
    export LANG=C          如果有乱码，设置字符集，通过修改环境变量（才能永久修改）
        
    [root@worker1 ~]# mkdir install                    新建一个目录
    [root@worker1 ~]# ls
    anaconda-ks.cfg  Desktop  Documents  Downloads  install  install.log  install.log.syslog  Music  out.log  Pictures  Public  Templates  Videos
    [root@worker1 ~]# cd install
    [root@worker1 install]# wget http://nginx.org/download/nginx-1.8.1.tar.gz            下载
    [root@worker1 install]# ls
    nginx-1.8.1.tar.gz                                                               下载了之后就能看到包了
    [root@worker1 install]# tar zxvf nginx-1.8.1.tar.gz                              把，tar.gz的压缩包解压
    [root@worker1 install]# ls
    nginx-1.8.1  nginx-1.8.1.tar.gz                                                 解压之后就能看到nginx-1.8.1文件夹（目录里放的被打包目录的内容）
    [root@worker1 install]# cd nginx-1.8.1                                          进到目录查看源代码安装包的路径
    [root@worker1 nginx-1.8.1]# ls
    auto  CHANGES  CHANGES.ru  conf  configure  contrib  html  LICENSE  man  README  src
    [root@worker1 nginx-1.8.1]# ./configure                                        ./configure    ，check失败---检测环境配置
    checking for OS
     + Linux 2.6.32-431.el6.i686 i686
    checking for C compiler ... not found

    ./configure: error: C compiler cc is not found

    [root@worker1 nginx-1.8.1]# ./configure
    checking for OS
     + Linux 2.6.32-431.el6.i686 i686
    checking for C compiler ... not found

    ./configure: error: C compiler cc is not found                              发现没有安装C / GCC编译器，安装好了之后执行./configure  如下
    [root@worker1 nginx-1.8.1]# ./configure --without-http_rewrite_module --without-http_gzip_module  
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　不使用http_rewrite_module和http_gzip_module 进行配置
                

    [root@worker1 nginx-1.8.1]# make
                                                                          配置好了没err之后执行make编译，根据刚才配置好的生成的配置文件去编译
                                                                          编译的时候一直打印cc大头的打印，cc大头的打印就是进行的编译操作，cc就是c代码的编译器
                                                                          编好了之后：没有err  ，最后打印make[1]: Leaving directory `/root/install/nginx-1.8.1'
                                                                           就是编译成功了

                                                                                        
    make install                                                         最后一步 make install  编译好的二进制文件和其他所需要的文件拷贝到它觉得合适的目录下去

    [root@worker1 nginx-1.8.1]# cd /usr/local/                            根据日志打印看到最终安装的目录到了：/usr/local/nginx
    [root@worker1 local]# ls
    bin  etc  games  include  lib  libexec  nginx  sbin  share  src
    [root@worker1 local]# cd nginx/
    [root@worker1 nginx]# ls
    conf  html  logs  sbin                                                                sbin就是nginx作为http浏览器的可执行文件
    [root@worker1 nginx]# cd sbin/
    [root@worker1 sbin]# ls
    nginx
    [root@worker1 sbin]# ./nginx                                                         nginx启动  ./nginx

    [root@worker1 sbin]# ps -ef|grep nginx                                                nginx执行没有什么输出，可以ps查看进程
    root      9024     1  0 11:11 ?        00:00:00 nginx: master process ./nginx
    nobody    9025  9024  0 11:11 ?        00:00:00 nginx: worker process
    root      9038  4610  0 11:12 pts/2    00:00:00 grep nginx
    
                                                                         如上就是进程启动，开了http服务器，可以通过80端口访问服务器信息，前提保证防火墙80打开的

    [root@worker1 sbin]# ./nginx -s stop                                                nginx关闭
    [root@worker1 sbin]# ps -ef|grep nginx
    root      9045  4610  0 11:15 pts/2    00:00:00 grep nginx

　　十：LINUX里RPM包安装软件dos2unix，这个工具把windows上的文本文件转成unix上的文本格式

　　　　windows换行符  对应两个字符/n   unix文本文件只要一个字符换行 n

    windows文件拷贝到unix里面二进制文件每行结尾多个字符--vi打开很怪异，    dos2unix处理文件，去符号
    1：知道安装包哪里下载        wget ftp://rpmfind.net/linux/centos/6.8/os/i386/Packages/dos2unix-3.1-37.el6.i686.rpm
    2：安装 rmp -ivh dos2unix-3.1-37.el6.i686.rpm            ivh i=install  vh=install过程中显示详细信息            这样就能安装完成
    3：dos2unix                                    就可以联想出来了，可以执行了
    4：dos2unix   111.txt   转换文件成unix文件，去掉多余的回车符
    5：rpm -qa|grep dos2unix            查看安装的包
    6：rpm -e dos2unix-3.1-37.el6.i686        卸载包，需要填写安装包的全名（不写全称也能卸载，匹配，最好还是写全称） 
    
    [root@worker1 install]# wget ftp://rpmfind.net/linux/centos/6.8/os/i386/Packages/dos2unix-3.1-37.el6.i686.rpm            本机无法访问下载
    --2020-11-21 11:26:33--  ftp://rpmfind.net/linux/centos/6.8/os/i386/Packages/dos2unix-3.1-37.el6.i686.rpm
               => “dos2unix-3.1-37.el6.i686.rpm”
    Resolving rpmfind.net... 195.220.108.108
    Connecting to rpmfind.net|195.220.108.108|:21... connected.
    Logging in as anonymous ... Logged in!
    ==> SYST ... done.    ==> PWD ... done.
    ==> TYPE I ... done.  ==> CWD (1) /linux/centos/6.8/os/i386/Packages ... 
    No such directory “linux/centos/6.8/os/i386/Packages”.

　　十一：yum 方式安装，

yum安装dos2unix
    yum install dos2unix
         * base: mirrors.aliyun.com
         * extras: mirrors.aliyun.com
         * updates: mirrors.aliyun.com
        打印是从上面的网址下载的，下载的时候会让输入y/n  来确认是否安装
        
        [root@worker1 install]# rpm -qa|grep dos2                    rpm查看安装的包，能找出来
        dos2unix-3.1-37.el6.i686
        [root@worker1 install]# 


    yum remove dos2unix
        然后输入y确认反安装，
    [root@worker1 install]# rpm -qa|grep dos2                        卸载后就查看不到包了
    [root@worker1 install]# 
                                                                                    
                                                                                
yum安装mysql  ，不确定指定版本，    yum install mysql-                                                                            
    [root@worker1 install]# rpm -qa|grep mysql                    查看到我的电脑安装了mysql5.1版本--默认
    mysql-libs-5.1.71-1.el6.i686

    [root@worker1 install]# wget http://repo.mysql.com/mysql-community-release-el6-5.noarch.rpm     下载了mysql-community-release-el6-5.noarch.rpm 
    --2020-11-21 11:51:22--  http://repo.mysql.com/mysql-community-release-el6-5.noarch.rpm
    Resolving repo.mysql.com... 23.45.161.11
    Connecting to repo.mysql.com|23.45.161.11|:80... connected.
    HTTP request sent, awaiting response... 200 OK
    Length: 5824 (5.7K) [application/x-redhat-package-manager]
    Saving to: “mysql-community-release-el6-5.noarch.rpm”

    100%[===============================================================================================================================>] 5,824       --.-K/s   in 0s      

    2020-11-21 11:51:23 (190 MB/s) - “mysql-community-release-el6-5.noarch.rpm” saved [5824/5824]

    [root@worker1 install]# ls
    mysql-community-release-el6-5.noarch.rpm  nginx-1.8.1  nginx-1.8.1.tar.gz
                                                                                
    [root@worker1 install]# rpm -ivh mysql-community-release-el6-5.noarch.rpm                   这个执行了之后在/etc/yum.repos.d/多出两个目录
    Preparing...                ########################################### [100%]
       1:mysql-community-release########################################### [100%]
       
    [root@worker1 install]# ls /etc/yum.repos.d/
    CentOS-Base.repo  CentOS-Debuginfo.repo  CentOS-Media.repo  CentOS-Vault.repo  mysql-community.repo  mysql-community-source.repo

    [root@worker1 install]# cat /etc/yum.repos.d/mysql-community.repo                      这两个文件里面配置了到哪里找mysql5.6版本的安装包
                                                                                           上面的两步都只是配置了源，yum源，到哪里装mysql 5.6的包
                                                                                            缺省目录下装的不是我们要的版本，缺省装的mysql5.1版本


    yum install mysql-server                                        安装mysql，

 43：linux系统监控

　　监控：cpu资源 内存资源，网络监控，磁盘io的监控 ----性能测试需要关注的

　　一：TOP命令

1：TOP命令
    top (table of processes) 命令的作用
        显示(unix like)系统的进程对系统资源(cpu、内存)的占用情况
        显示当前系统的整体资源使用情况

    使用场景
    性能测试的时候监控被测系统、测试工具的资源使用情况
    开发过程中查看软件运行时的系统资源占用情况
    查看系统硬件资源（查看电脑多少cpu，多少内存）                                                                                
                                                                                
                                                                                
top命令是不断刷新的，界面布局

    [root@worker1 install]# top
    top - 12:52:47 up 13:36,  3 users,  load average: 0.00, 0.02, 0.00                            top命令运行多出时间    up 13:36  
    Tasks: 145 total,   1 running, 144 sleeping,   0 stopped,   0 zombie                        Tasks显示系统中多少任务在跑，多少在运行，多少在休眠
    
    Cpu(s):  0.2%us,  0.1%sy,  0.0%ni, 99.6%id,  0.0%wa,  0.0%hi,  0.1%si,  0.0%st                cpu整体使用情况
            
    
    
    Mem:   1030464k total,   929168k used,   101296k free,    65260k buffers                    men内存整体使用情况
    
    
    
    Swap:  2064376k total,        0k used,  2064376k free,   665644k cached  Swap缓存的使用情况（类似windows虚拟内存，磁盘空间来当内存不够的时候临时存储到磁盘上去）
                                                                              当前急着加载到内存的信息加载到内存，内存中暂时不使用的存到磁盘上去
                                                                              存储空间给当前急着要使用的内存来用----所以Swap是磁盘用来存储临时内容的信息
                                                                               虚拟内存
    
      PID             USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                        pid进程id，每个进程的cpu，内存的使用1情况

     
     9910 root      20   0  2700 1020  776 R  1.8  0.1   0:00.06 top                                                                                                                                                 
        1 root      20   0  2900 1332 1112 S  0.0  0.1   0:01.69 init                                                                                                                                                
        2 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kthreadd                                                                                                                                            
        3 root      RT   0     0    0    0 S  0.0  0.0   0:00.00 migration/0                                                                                                                                         
        4 root      20   0     0    0    0 S  0.0  0.0   0:00.26 ksoftirqd/0                                                                                                                                         
        5 root      RT   0     0    0    0 S  0.0  0.0   0:00.00 migration/0                                                                                                                                         
        6 root      RT   0     0    0    0 S  0.0  0.0   0:00.59 watchdog/0                                                                                                                                          
        7 root      20   0     0    0    0 S  0.0  0.0   0:01.94 events/0                                                                                                                                            
        8 root      20   0     0    0    0 S  0.0  0.0   0:00.00 cgroup                                                                                                                                              
        9 root      20   0     0    0    0 S  0.0  0.0   0:00.00 khelper                                                                                                                                             
       10 root      20   0     0    0    0 S  0.0  0.0   0:00.00 netns                                                                                   
                                                                                    
                                                                                
top每隔固定时间刷新一下，刷新时间可以配置的，实时查看系统内存，cpu使用情况

　　二：查看CPU资源的使用情况

    什么是CPU资源使用?
        单核
        多核        
    
    cpu是给程序的代码在里面跑的，程序编译成可执行的二进制文件，加载到内存里面去，cpu去执行它，执行的代码占据cpu的资源，使用cpu的资源
    
    cpu：几核，几个脑袋---单核cpu同时只能执行一段代码，一个程序的一部分代码在里面运行，同时跑多个程序是并发运行，切换的很快看上去很多程序一起运行，某个时间点里只有一段进程的代码
        在跑，看上去像一起跑 ---每个时间片上运行谁的程序--就是谁在使用cpu的资源  --------
                                                                                

　　三：查看cpu资源的使用情况

整体情况：Cpu(s):  0.2%us,    0.1%sy,  0.0%ni, 99.6%id,          0.0%wa,  0.0%hi,  0.1%si,  0.0%st   cpu有多忙--就是us和sy两个加起来就是使用情况（cpu使用占用率）
            us用户进程                 id空闲            
            操作系统里面跑的            99.6的是时间
            代码分为用户空间            cpu是空闲状态
            还是系统空间，linux
            内核在系统空间跑的
            如果执行执行内核指令
            系统空间的指令占据cpu
            资源，命令本身执行的
            时候属于用户空间
            
    
每个cpu（核心）资源使用情况（按1切换）
    Cpu0  :  0.3%us,  0.3%sy,  0.0%ni, 99.0%id,  0.0%wa,  0.0%hi,  0.3%si,  0.0%st
    cpu1：

　　性能测试，前面资源占用连续一段时间百分之百了，基本上是不太正常的情况，可以某一瞬间达到百分之百---

　　　　　　不能长时间让cpu处于百分之百的状态，可能就是cpu处理不过来了
　　　　　　软件写的有问题，狂占cpu

　　查看CPU资源的使用情况
　　　　每个进程的CPU资源使用情况
　　　　注意是所有核的CPU资源相加，不是平均的CPU资源(所以有可能超过100%)

 

　　按CPU资源使用情况来排序进程：按Shift + f,然后按k选择CPU usage

PID                  USER       PR  NI  VIRT  RES  SHR             S         %CPU                     %MEM    TIME+              COMMAND  
进程对应的id      进程所属的                                            cpu占用率                                        对应命令，command输入的信息
                  用户
4366 root      20   0 12028 3392 2632 S  0.3  0.3   0:04.01 sshd 

top计算周期默认是几秒钟，输入top命令缺省的进程排序就是按照cpu占用率，谁占用多谁排前面，如果系统对应多核，那么0.3是对那个核的占用的
    不是对其中某一个核的占用，是当前时间段对所有的核的占用加起来1的结果，比如系统双核。第一个核心20%，第二个核心30%
    给这个进程显示50%--------有可能第一个cpu占55%，第二个cpu占用60%，那么加起来超过100%的占用率了，多核可以超过百分之100的，----多核系统很正常
    
    按Shift + f,然后出现列表然后按k选择CPU usage----按CPU资源使用情况来排序进程的操作
    
    占用率计算，假如3s统计一次，系统应用占时间1s，用户应用占时间1s，那么就是33%空闲，系统占用率33%，用户占用率33%
    
    假如多核系统看cpu每个核的占用率：按一下  1，切换查看
    
    top缺省按照cpu占用率来排序，不是按照占用率排序可：按Shift + f    会出现一个列表界面选择怎么排序的（可以对应按下k：cpu排序  N：内存使用排序）
                                        然后出现列表然后按k选择CPU usage

　　四：查看内存的使用

    一：整体的内存使用情况    
        Mem:   1030464k total,               929168k used,               101296k free,        65260k buffers        665644k cached    men内存整体使用情况
               系统可用内存多少k（1g）        多少已经被使用了            空闲可用的内存        

        已经使用的内存包含了：buffers内存和cached内存    ---buffers内存中用来缓存一部分的内存（用的很频繁）缓存的内存其实也是可用使用的内存
            系统缓存，打开word，第一次打开很慢，编辑完成后关了，再打开修改，第二次打开快狠多，原因就是因为操作系统使用认知，认为你刚刚使用的
            程序可能就是你频繁使用的程序，所以加载到内存之后关了，没有一下子从内存里面全部清除，很多资源缓存起来，第二次再打开很多资源不必要再次加载
            这样就快很多了---这一部分用来缓存的内存就是对应的cached的和baffers的--具体哪个缓存哪个，自学  
            把cached的和baffers看作缓存，这部分缓存其实可用的，可用腾出来给其他程序使用的，----所以pc真正能够使用的资源是：    free+缓存的资源
            
    二：每个（单个）进程的内存使用情况（virtual  vs resident）    %MEM
        
      PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                                                                                                            
    10091 root      20   0  2704 1132  880 R  0.3  0.1   0:02.88 top      
        
        %MEM百分比显示的，系统1g，1*0.1=10兆，占用了大概1兆
        VIRT：
        RES：resident，真正的占用内存，这个RES，他来占用的所以算出来大概1132kb 
        
        
    按照资源使用情况来排序进程    
        按shift -f  ，然后按    n    选择men usage
        
        
    
    三：查看内存资汇的使用情况free -m     -m看的更加清除，以m兆为单位，和
    
        [root@worker1 install]# free -m
                     total       used       free     shared    buffers     cached
        Mem:          1006        909         96          0         65        650
        -/+ buffers/cache:        193        812                                真正的使用的是969-65-650，真正剩余的是96+650+65 ----free -m直接算出来了
        Swap:         2015          0       2015
    
        第一行的used包含了buffers和cached
        第二行的used才是真正被使用掉的

　　五：网络监控

    netstat    命令 
        查看网络连接情况    netstat  -an    查看端口连接情况
        查看路由表            netstat  -r     查看路由表
        查看网络接口的统计（-i 参数）        查看收发了多少包
        


    tcpdump    抓包，监控包的            
        ◆类似于windows上的wireshark
        ◆使用场景
        ◆可以用来抓包，给wireshark看
            ◆tcpdump -n host 192 168.180.111                           根据主句（ip）抓包      -n改变现实信息比如ssh现实成22    抓下来的包不是很详细
            ◆tcpdump -n port 22                                        根据端口抓包，ssh 22
            ◆tcpdump -n "dst host 192.168.180.111 and dst port 22“     根据端口和主机连起来  dst=distinaon目标机器的意思，目标机器192.168.180.111，目标机器 
                                                                          抓的包是我这边发给对放主机192.168.180.111的机器，加dst这样写只抓过去的包，目标端口是22
                                                                          抓进来的也可也，写自己的ip和地址，我们这个主机192.168.180.111接收到的报文
                                                                                    
            ◆tcpdump -n port 80 w test.cap                             抓到的报文不是i显示再屏幕上，而是存到test.cap文件里面去---存下来给别人分析
            
            抓包希望来回都抓，指明端口和ip就行，不加dst，加了dst只抓出去的包了
    
    性能测试某个时间点网络关了---抓包分析，包抓下来存到文件，拷到windows机器用wireshink分析
    
实例：wget http://tel.mirrors.163.com/centos/6.8/isos/i386/0_README.txt      到网易服务器下载文件

    开两个窗口，一台请求，一台输入：tcpdump -n -vvv port 80        抓包 
    
    tcpdump -n -vvv port 80                        输入的v越多抓包信息越详细  v=详细
    tcpdump -n -vvv port 80 -w test.cap            抓包数据存到 test.cap  cap是wireshrik能够识别的格式  输入完后一直处于监听
        抓到包后打印：tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 65535 bytes            抓到了65535 bytes大小的数据


[root@worker1 install]# ls
mysql-community-release-el6-5.noarch.rpm  nginx-1.8.1  nginx-1.8.1.tar.gz  test.cap                      test.cap 抓到这个文件在linux主机root目录下

用winscp工具从linux中把文件拷贝到windows--用wireshirk打开，和wireshink关联-----查看内容

　　六：磁盘 io的分析　　　　iostat这个命令一般

    [root@worker1 install]# iostat -d -x 2                                            -d表示只想看磁盘的io信息  -x表示显示哪些列的描述        2-2S刷新一次
    Linux 2.6.32-431.el6.i686 (worker1)     11/21/2020     _i686_    (1 CPU)

    Device:         rrqm/s   wrqm/s     r/s     w/s   rsec/s   wsec/s avgrq-sz avgqu-sz   await  svctm  %util
    scd0              0.00     0.00    0.00    0.00     0.01     0.00     7.27     0.00    1.82   1.82   0.00
    sda               0.28     2.21    0.29    0.30    20.63    20.14    68.83     0.00    0.96   0.57   0.03
    dm-0              0.00     0.00    0.54    2.52    20.49    20.13    13.27     0.01    4.37   0.11   0.03
    dm-1              0.00     0.00    0.00    0.00     0.04     0.00     8.00     0.00    0.08   0.08   0.00
        
    rsec/s  每秒读的扇区数目，20就是读了20个扇区，一个扇区512个字节
    wsec/s    每秒钟写的扇区的字节数，
        这两个参数可以大概看出系统目前磁盘的io的吞吐量
                
    %util  磁盘的使用率，0.03当前周期里面真正繁忙的时间就是百分之3的时间，其他百分之97时间磁盘都是没有任何操作，空闲 -----    
        
    avgqu-sz    ：    
    
    iostat看磁盘吞吐量相关信息

44：linux常用的操作：

　　一：定时任务

为什么需要定时任务?        定时关机，定时备份，跑自动化的用例
◆Linux下面的定时任务
    at和cron
    区别
        at只能执行一次，
        cron周期性的执行    （比如每天都需要备份）
        
        
    
    at的用法                                            at如果终端关了，缺省执行的结果弄到文件里面去
        [root@worker1 bin]# at now + 5 minutes            5分钟后执行任务
        at> encho 'good'>good.log                        （写定时执行的命令）输出命令重定向到log日志
        at> <EOT>                                        ctrl+d退出了打印的字符    加到定时任务的队列
        
            时间格式：
            04：00 2019-03-17   2019/3/17的4点执行
            now + 5 minutes        5分钟之后执行
            5pm + 3days            三天后的下午5点执行，5pm就是当天五点
        
        执行备份操作，命令写在at里面，脚本提前准备好，总入口脚本写好，at执行写好的总入口的脚本，里面的总入口脚本再调用脚本------at=调用入口脚本（定时执行机器不能关闭）
     

        at的原理:
        输入命令之后命令，生成对应的shell脚本放在目录/var/spool/at/下面，脚本名字临时起的，可能是一串数字，at执行完了后台有个服务的  atd ---service at...就可以看到 
        atd服务，后台的进程，一直启在哪里，会去检查/var/spool/at/这个目录下面，如果有新的出现了，就会查询目录里面的时间点，到了时间后atd去执行------定时执行的任务
        atd去检查 执行

        查看任务列表
        [jcy@localhost ~]$ atq                            查询当前任务列表
        3 2016-12-03 08:45 a jcy
        注意: root用户能查看所有用户的任务而非root用户只能查看自己的任务
        
        删除任务atrm 3            atrm + 任务的序列号（先atq查询出任务序列号）

　　二：定时任务CRONTAB（周期性任务）

crontab的 用法
例如:
    [root@localhost ~]$crontab -e             #进入vi编辑器，临时产生的文件让去编辑，输入安排的定时任务

    进入vi编辑器，输入如下内容:表示在每天的午夜0:30运行backup命令
    30 0 * * * backup

    保存退出

    [root@localhost ~]# crontab -l                列出加入的定时任务

    30 0***backup    
        
    
    crontab格式说明
        *                *                *                *                *                    command    
        取值范围0-59    取值范围0-23    取值范围1-31    取值范围1-12    取值范围0-6            需要执行的命令
        分钟            小时            几号            月份            星期几

        所以：30 0 * * * backup：表示30分钟，0点 执行backup，写* 不管哪个月，不管星期几都不在乎，都执行
        ***** 五个星，代表每分钟都指向一次
    
     crontab的 用法
    时间间隔示例:
        实例1:每1分钟执行一次command
        命令:
            *****command

        实例2:每小时的第3和第15分钟执行命令:    可以逗号隔开，或的意思
            3,15****commandt
    
        实例3:在上午8点到11点的第3和第15分钟执行
        命令:
            3,15 8-11*** command

        实例4:每晚的21:30执行命令
        命令:
            30 21 *** command
    
     crontab的原理;
        生成对应的shell脚本放在目录/var/spool/cron/下面：输入命令vi编辑之后生成了对应的shell脚本放在/var/spool/cron/目录下，
　　　　　　　　跟当前的用户相对应的，产生/var/spool/cron/root这个文件
            产生crond服务，创建任务就是创建/var/spool/cron/root，文件里面就是vi编辑的内容，crond服务不断检查，
　　　　　　　　多了之后会把要把要执行的时间点检查这个文件，有没有变化，变了扫描
            解释，有哪些行要定时执行的任务，放在自己的任务列表----知道什么时候干什么事情
            
            
            比如
            [root@locallnost ~]# cat /var/spool/cron/root
            30 0***|s

        crond去检查执行
        
        删除任务
        输入crontab-e 编辑文件，vi编辑器，然后删除对应的任务的行，保存文件退出   ---crond会不断检查的，

　　三：系统时间的查看与设定

查看系统时间
    命令date

    [root@bogon -]# date

    [root@worker1 bin]# date
    Sat Nov 21 21:15:14 CST 2020

    格式化显示时间
    [root@bogon ~]# date +'%Y-%m-%d %H:%M:%S'                y显示年 -m月  d天  h时间 M分  s秒   -----格式符自己定义
    [root@worker1 bin]# date +'%Y-%m-%d %H:%M:%S'
    2020-11-21 21:17:34

设置系统时间
例如:
    #date -s 20161109                设定日期
    #date -s 21:05:50                设定时间
    #date -s '20161208 09:50'        设定日期和时间（同时设定）
    
    

查看LINUX版本信息
查看发行版本（linux很多组织和公司，发行版本千变万化，centos，redhat等）        ：安装包配合版本，包和版本信息吻合，
    
    cat /etc/issue:                                issue发出来的意思，系统文件告诉是哪个版本，有的版本可能没有issue
        [root@worker1 bin]# cat /etc/issue
        CentOS release 6.5 (Final)
        Kernel \r on an \m

    cat /etc/*release        
        [root@worker1 bin]# cat /etc/*release
        CentOS release 6.5 (Final)
        LSB_VERSION=base-4.0-ia32:base-4.0-noarch:core-4.0-ia32:core-4.0-noarch:graphics-4.0-ia32:graphics-4.0-noarch:printing-4.0-ia32:printing-4.0-noarch
        CentOS release 6.5 (Final)
        CentOS release 6.5 (Final)