Linux总结

Linux第一天====================================================================================
一.基础命令
1.history 查看历史命令，此终端自安装至现在的所有。
2.命令解析器：
    1）shell. 针对Unix操作系统
    2）bash.  针对Linux操作系统
    3）工作方式： 用户在终端输入命令， 命令解析器搜索（通过环境变量中的路径）对应的路径，查找同名命令，如果找到了就执行该命令。

3.遍历历史命令：
    1)从当前位置往上： ctrl+p(方向键上也行);
    2)从当前位置向下： ctrl+n(方向键下也行);

4.光标移动：
    1）向前 ctrl+b;  2)向后 ctrl+f;  3)移动到行首 ctrl+a;  4）移动到行首 ctrl+e;

5.删除光标位置的字符：
    1）光标后面的字符(即光标盖住的那个字符)：ctrl+d;
    2) 光标前面的字符：ctrl+h;
    3) 删除光标前面的字符串: ctrl+u;
    4) 删除光标后面的字符串：ctrl+k;

二.Linux目录结构：
1. / 根目录：根目录下面的是系统文件，一般别动。
2. 终端下面的各种颜色代表不同的文件
    1).白色： 普通文件
    2）蓝色： 目录
    3）绿色： 可执行文件
    4）青色： 链接文件
    5）红色： 压缩文件
    6）黄色： 设备文件
    7）灰色： 其他文件

3.根目录下面各文件的内容： 
    1）bin: (binary)二进制文件，存放命令（系统命令，可执行的程序）
    
    2）etc: 系统或用户安装的软件用到的"配置文件";
        如：查看用户：etc/passwd （可以看到当前系统下的所有用户）用户登录时的用户名和密码也在该目录
    
    3) lib: Linux操作系统运行时使用的一些基本动态库（.so）。
    
    4）media：自动挂载外设，会将外设自动挂载到该目录下。
    
    5）mnt: 手动挂载目录。一般默认挂载到该目录。
    
    6）opt: 安装目录，一般是空的。
    
    7）root： 超级用户的家目录
    
    8）sbin： 超级用户运行时用到的命令（存放的地方）    
    9）usr(user software resource)： 用户软件资源目录；（1.当前用户安装的一些应用程序，2.一些库文件（如C 的标准库））。    
    10）boot: 开机启动项
    11) dev: 存放设备文件 
    12）home: Linux操作系统所有用户的家目录。
    13）tmp: 存放临时文件（每次系统重新启动，都会清空）
    
4.yyx@yyx-virtual-machine:/home$: 字符的意义
    1）$：表示普通用户；  #：表示超级用户
    2）@前的内容： 表示当前用户名；
    3）@后的内容，在冒号之前： 表示主机名。
    4）冒号后的内容： 表示当前所在的目录。

5.系统安装程序后缀
  ubuntu  系统安装程序后缀：.deb
  windows 系统安装程序后缀：.exe
  安卓      系统安装程序后缀：.gdb

6.Linux 七种文件类型
    1） d: 目录
    2）    -: 普通文件
    3） c: 字符设备
    4） b: 块设备
    5） p: 管道
    6） s: 套接字（实现局域网的传输 sorckt）
    7） l：符号链接

    在细分为：
        d, -, l;  （占用内存空间）
    伪文件：（不占用内存空间）
        c, b, p, s;
7.创建文件：
    1）touch 文件； 文件存在，就会更新文件的日期； 
                    文件不存在，就会创建文件。

8.创建嵌套目录：
    mkdir wbq/aa/bb    -p;（注意后面的参数-p,可以加在最后面，也可以加在紧随mkdir后面）    bb目录在aa目录里，aa在wbq目录里。
    pwd 查看当前用户所在的目录。


8.查看文件内容：
    1）cat+文件名：  文件内容显示在终端上
    2）more+ 文件名：只能向下翻。回车向下走一行，空格，显示下一页。
    3）less+ 文件名： 可以上下翻页
    4）head -行数 文件名（从文件头部数）
    5）tail -行数 文件名（从文件尾部数）

9.拷贝文件/目录
    cp 存在的文件 新文件（当拷贝文件时，需要有"读权限"）.
        1）如果新文件名不存在，就创建
        2）如果新文件名存在，就覆盖源文件（这里要注意，新文件名一般要写成不存在的，否则原来的内容就丢了）
    cp拷贝目录
        需要加参数 "-r";

10.创建软硬链接
    1）创建软连接：
        ln -s 创建软连接的源文件名  软链接名字
            1)使用相对路径创建的软连接，移动链接到不同的目录就不可以使用了。
            2）解决这种问题办法： 创建绝对路径的软连接。在原文件名前加上它的绝对路径。
    2）创建硬链接：
        ln 创建硬链接的源文件名  硬链接名字
            1）硬链接的文件不区分相对和绝对路径。
            2）硬链接文件不占用磁盘空间，一改全改（不管哪个，相当于程序的静态变量）

11.修改文件权限的方法（chmod）
    1）文字法 (r w x ) chmod 修改对象+(-)权限 文件名
        u 用户        g 用户组       o其他人        a所有人

    2）数字设定法： chmod 数字    文件名
        写权限 对应的数字      2
        读权限 对应的数字     4
        执行权限 对应的数子 1

12.修改文件所有者(chown)    
    1)修改文件的所属者：  chown 所有者 文件名（要使用超级用户权限）
    2)修改文件的所属组      chown  所有者：所属组  文件名
    3）修改文件所属组（第二种方法）： sudo chgrp 所属组 文件名；

13.文件的查找和检索
    1）根据文件的属性查找 find
        1）根据文件名  find 查找的路径 -name "查找的文件名"

        2）根据文件大小    find 查找的路径 -size 查找的大小
            大于：+； 小于：-；  等于：（不用写）
            如： find ~ -size +100k -size -100M    (查找大于100k小于100M的文件)
            注意： k 小写  M大写
            "~ 当前用户的家目录（或者宿主目录）"

        3）根据文件类型：find 查找的路径 -type 文件类型

    2）根据文件内容查找 grep
        1）grep -r "查找的内容" 查找的路径(可以和一些命令搭配)：find ./ -type f | grep 01.c;  "查找当前目录下，名字含有01.c的普通文件"

    3)locate 文件名；这个命令更快。直接搜索linux数据库，有索引，所以很快。
        但是缺点：如果数据库没有更新，会有内容找不到。不关机的情况下，linux默认每天半夜两点左右更新。

14.查看文件或目录属性        
    1）查看文件文件的字节数，字数， 行数； wc 文件名 参数
    2）参数：-c:  文件的字符数
             -l:  文件的行数（也可以用来喝一些命令搭配）; find ./ -type f | wc -l;  "查找当前目录下，普通文件的个数"。
             -w:  文件的字节数。    

15.查看指定命令所在的路径：
     which  命令；可以查看该命令所在的文件。（cd命令例外， 它被嵌入在系统中）

16.软件的安装和卸载：
    1.
        1）主流安装（在线）：
            1）sudo apt-get install 软件名    ：  安装
        2）主流卸载：
            1）sudo apt-get remove  软件名    ：  卸载
        3）更新软件列表
            1）sudo apt-get update ; （它的工作原理是：更新软件的下载地址。）更新完后再重新下载
        4）清空缓存：
            1) sudo apt-get clean ;    清空在线安装后的缓存
                缓存的路径：

    2.
           5）安装包程序安装：.deb后缀(安装包的名字)

        6）安装包安装的软件卸载：

17. U 盘的挂载和卸载
    1）挂载: mount 命令
        1）mount + 设备名 + 挂载的目录
        2）获取U盘设备名：
            sudo fdisk -l;
        3)显示中文：
            加上参数： -o iocharset utf8

18:  sd 闪盘（U盘）
     hd 移动硬盘
     fd 软盘；

19.压缩包管理（Linux）：
    1) 压缩格式：    "（只压缩不打包）"
        .gz格式: 
            压缩：   gzip 压缩的文件；
            缺点：   1. 压缩不保留原文件， 2.压缩的时候不能能打包。  3.不能压缩目录
            解压缩:     gunzip 压缩包名

        .bz2格式:
            压缩：   bzip2    压缩的文件；（如果想保留源文件；加参数 -k;  bzip2 压缩的文件 -k ）
            解压缩： bunzip2  压缩包名；
            缺点： 1.压缩的时候不能打包，  2.不能压缩目录

    2）常用的压缩工具："(只打包不压缩)"
         1)tar:打包。
            参数：j- （指定的压缩工具）
                  z- （指定的压缩工具）
                  c-  创建新的压缩文件
                  x-  从压缩文件中释放文件    
                  v-  详细报告压缩文件信息
                  f-  指定压缩文件的名字

        2)压缩语法：
            tar 参数 压缩包名称 原材料（参数，与压缩工具配合；zc. jc. ）
                1）zcvf
                tar zcvf test.tar.gz 需要压缩的文件 
                2) jcvf
                tar jcvf test.tar.bz2 需要压缩的文件

        3)解压缩：
            tar 参数 压缩包名
                语法：
                    .tar.gz后缀的压缩文件    tar zxvf test.tar.gz 
                    .tar.bz2后缀的压缩文件  tar jxvf test.tar.bz2

            解压缩到指定目录：
            (参数)    -C 指定的目录（路径）。
                    tar zxvf test.tar.gz  -C 路径
                    tar jxvf test.tar.bz2 -C 路径

    3) 非主流的压缩文件：rar
        1)安装软件： rar  (sudo apt-get install rar)
        
        2)压缩：
            1）rar a 压缩包名 原材料; （压缩包的名字不需要添加后缀）
                rar a test  需要压缩的文件
            2)-r 参数(压缩目录)： rar a test 需要压缩的文件 -r;
        
        3)解压缩：rar x 压缩包名
            rar x test.rar (知道那个的目录，可加可不加)；

    4）zip
        1）压缩：
            压缩目录（加参数 -r）;(zip （-r） 压缩包名 原材料）；包名不需要后缀
            zip test 需要压缩的文件；  zip -r test 需要压缩的目录 ；
        2）解压缩：
            unzip 压缩包名 (-d) 解压缩的目录（路径）
            unzip test.zip (解压在当前目录);   unzip test.zip -d 指定的目录

4）-的使用时机：

20.进程管理：
    1） who 当前登录操作系统的用户和终端设备编号
    2） tty
    3)  PID 进程的ID号。
    查看整个系统 的运行状况：ps
    4） ps aux | grep 查找的东西
    5）

21.手动杀死进程
    1）kill -9(SIGKILL) 进程PID；
    ２）查看kill的信号:　kill　-l;

22.查看环境变量：env
    1)环境变量的格式：key = value:value:value:……；

23.任务管理器： top
    1)关闭它： q 或者 ctrl +

24.网络管理：
    1）获取网络接口的信息：ifconfig
    2）测试与其他主机的连通性
        参数

    3）

三。用户管理
    1.添加用户：
        1) sudo adduser 
    2.添加用户组

    vi etc/passwd;       vi etc/group;

    3.切换用户：su； sudo su;这两个操作的区别
        1）普通用户
        2）超级用户
    4.修改用户密码：
        1.修改普通用户的密码
        sudo passwd 用户名
        2.修改超级用户的密码
        
    5.删除用户
        sudo deluser 用户名
    6.删除组：
    
    7.退出：

    命令：动词在后面
    脚本：动词在前面

四。常用服务器搭建：
    1.FTP服务器的搭建:
        1）它是：一款软件；用户来上传和下载文件。
        2）服务器端：
            a.安装软件：sudo 
            b.服务器端需要设置：

        3）重新启动服务，使配置生效
            sudo 

        4）客户端的操作
            1.实名用户登录：

            2.上传个下载文件（注意：只能操作文件，不能操作目录）

                1）缺点：
                    1）需要告诉对方服务器密码；
                    2）用户可以在服务器任意目录切换

            3.匿名用户登录：        
                必须指定匿名用户登录目录

五：lftp客户端的使用
    1.只是一个登录ftp 服务器的客户端
    2.使用前先安装： sudo apt-get install lftp
    3.登录ftp服务器
        1.lftp IP(服务器的IP)；
        2.login --- 匿名用户登录

    4.基本操作： 
    基本操作：    put, get;（与自带的ftp功能一样）  。
    上传多个文件： mput 文件名;
    下载多个文件： mget 文件名
    下载目录： mirror 目录名；
    上传目录： mirror -R 目录名；

六： 查看掩码：命令 umask ;
        它的作用： 本地的掩码： 0002；本地创建的目录权限为 775； 满权限为 777； 可以看出实际权限 = 满权限-掩码
                                      本地创建的文件的权限为 664； 本地的目录权限 - 文件权限 = 111； 可以看出：文件默认不会给它执行权限。

        "目录必须有执行权限才能被打开。"
        ftp上传的文件默认权限为 700； 此时只有 ftp 用户可以操作，不合理；需要修改配置文件；anoy_umask=022; 这样ftp用户传输到服务器的文件权限就为 755了；
        目录权限与掩码的关系： 目录权限 = 777 - 掩码；
        文件权限与掩码的关系： 文件权限 = 777 - 掩码 - 111；

七：nfs网络共享服务器的搭建和使用
    1.nfs ===相当于windows的共享目录
    2.服务器端：
        1.安装服务器程序：sudo apt-get install nfs-kernel-server;
        2.创建一个共享目录：
            1）设置配置文件： /etc/exports;  添加一个共享的目录（绝对路径）和 ip 地址段和(权限)；
            2)权限： ro ----只读；    rw ----读写；             sync -----数据实时同步
            例如： /home/yyx/xuexi 192.168.22.*(rw,sync) 这个ip地址为：允许这个网段的用户挂载共享路径。
        3.重启服务：  sudo service nfs-kernel-server restart;

    3.客户端：
        1.通过挂载服务器共享目录的方式：
            sudo mount serverIP(服务器的Ip):共享的路径 挂载的路径;
        2.退出方式：
            与普通挂载一样。sudo umount 挂载的路径

八。ssh服务器的使用：（管理员才会使用）。
    1.作用： 远程登录程序;
    2.软件的安装： sudo apt-get install openssh-server;
    3.远程登陆：
        ssh 用户名@IP(要远程登录的用户名和它的IP)
    4.退出：logout。

九。超级拷贝
scp命令： 安装软件：sudo apt-get install openssh-server
    命令： scp-r （远程服务器用户名@IP（远程）：远程服务器的目录  拷贝到的本地目录）
        scp -r Robin@192.168.28.37:/home/Robin/share ~/test


"——————————————————————————————————————————————————————————————————————————————————————————————————————————————————"
FTP 服务器搭建和登录
1.先安装服务器： 命令： sudo apt-get install vsftpd
2.修改配置文件： 命令：sudo vi /etc/vsftpd.conf;
3.重启ftp服务： 命令： sudo service vsftpd restart;
4.此时只允许实名用户登录和操作，匿名用户只能登录。
5.匿名用户登陆设置：创建一个专属匿名用户根目录。
    1）修改配置文件：添上专属根目录
    2）重启ftp服务器
6.此时就都可以登录和使用了
7.用户登录：ftp IP(服务器的IP);
    1）匿名用户登录：用户名：anonymous；  密码：不需要
8.传输数据： put;  下载数据： get;
9.弊端：只能操作文件，不能操作目录。
"——————————————————————————————————————————————————————————————————————————————————————————————————————————————————"

"——————————————————————————————————————————————————————————————————————————————————————————————————————————————————"
lftp 客户端的使用；

"——————————————————————————————————————————————————————————————————————————————————————————————————————————————————"

十。 VI 的三种模式：
    1. 命令模式：
        h左 j下 k上 l下（左右在两端，上下在中间）；
    2. 文本模式：
    3. 末行模式：

    4.一些基本操作:
        1.光标移动到文件开头: gg;  光标移动到文件尾部: G；
        2.光标移动到行首：0； 光标移动到行尾: $;
        3.行跳转【如： 13行】： 13G；
        4.删除光标后的字：x; 删除光标前的一个字： X； 删除一个单词: dw;
        5.删除光标前本行的内容：d0; 删除光标后本行的内容： D；
        6.删除光标所在行： dd;   删除多行：  行数 + dd;
        7.撤销： u;  反撤销： ctr + r;
        8.复制：复制当前行：yy;  复制从当前行以下 n 行： n yy;  
        9.粘贴: 从光标所在位置下一行粘贴： p;  从光标当前行位置粘贴： P；

    5.可视模式：
        命令： v;    进入模式后，可以有选择的拷贝和删除（如只拷贝一行中的某些内容）

    6.查找操作：
        从光标位置向上查找：？+查找的内容；  从光标位置向下查找：/ + 查找的内容； n ----遍历操作
        查光标所在位置的内容： 命令 #；
    7.替换操作： 单字符替换：命令 r(再输入自己想输入的内容。)替换光标后的字符;

    8.创建新行：命令 o：当前光标所在行的下面；   命令 O：相反。
      删除光标当前行：S，然后进入文本模式；   删除光标前一个字符：s,然后进入文本模式;

    9.末行模式下的替换：
        1）先在命令模式下进行查找操作，然后在末行模式下替换。
        2）:s/查找的内容/替换的内容； 

    10.分屏操作：
        水平分屏：sp+文件名 ；    垂直分屏：vsp+文件名 ；     屏幕切换：ctr + ww;

    11.打日志： -D， -I； -g;  -Wall;  -O优化等级


"----------------------------------------------------------------------------------"
    12.生成静态库：
        1.命名格式：libxxx.a
        2.制作：
            1）生成 .o文件；gcc -c .c文件 -I（.c文件中使用的）头文件所在路径（自己编写的头文件）;
                如："gcc -c *.c -I ../include;"
                
            2）将生成的.o文件打包； ar rcs 静态库的名字 所有的.o文件
                    例如： "ar rcs libCalc.a *.o;"

                    查看打包后的静态库： nm 名字；
                           "nm libCalc.a;"

        3.静态库的使用："(-I 后面的路径可以加空格（版本高的，可加可不加），可以不加（版本低的）)"
            1）第一种方法；   gcc + 测试.c文件 -o 可执行程序的名称  -I头文件的路径 静态库的路径
              例如：gcc main.c -o app -I ./include lib/libcacal.a;
               2）第二种方法： gcc + 测试文件 -o 可执行程序名称 -I 头文件的路径 -L 静态库的路径 -l xxx(静态库的名字，掐头去尾（去掉lib 和 .a）);
               例如：gcc main.c -o app1 -I ./include -
               L ./lib -l cacal;
        4.静态库的优缺点：
            优点：  1）库被打包到可执行程序中，直接发布可执行即可使用。2）寻址方便，速度快
            
            缺点:   1)静态库的代码在编译时被载入可执行程序，所以静态库越大，可执行程序越大（这也导致了它的第一个优点）；
                    2）当静态库的改变了，可执行程序也必须重新编译。
                    3）每个使用静态库的进程都要将库编译到可执行文件中再加载到内存中，内存消耗严重。

        5.问题1：
    13.生成动态库：
        1.命名格式：libxxx.so
        2.制作：
            1）生成与位置无关的 .o; gcc -fPIC -c 编译的.c文件 -I （.c文件中）头文件的路径；
                例如： gcc -fPIC -c *.c -I ../include;

            2) 打包；gcc -shared -o 生成的动态库的名字 .o文件；
                gcc -shared -o libCalc.so *.o ;

        3.动态库的使用：gcc main.c -o 可执行程序的名字 -I (main.c中头文件路径) 动态库的路径+动态库的名字
                gcc main.c -o app2 -I ../include lib/libCalc.so;    "注意：这里面动态库的路径不加-L参数，生成的执行程序运行不起来"

        4. ldd + 可执行程序；
            查看程序执行时，调用的动态库。
        
        5.手动添加动态库的方法：
            1）临时添加：（测试的时候使用；）
            2）永久添加：（修改家目录的bashrc文件）
            3）修改配置文件的方式：修改动态链接器的配置文件
                更新动态链接器：
                查看链接器的路径：sudo ldconfig -v参数。

        6.动态库加载失败的原因：
            1）解决方案：
                a. (临时方案，用于程序测试)使用环境变量： LD_LIBRARY_PATH=动态库的路径；   然后倒入环境变量： export LD_LIBRARY_PATH
                b.（永久设置。）修改动态链接器的配置文件：
                c.（修改家目录的 .bashrc文件）；
        7.动态库的优缺点：
            优点：多进程共享一份库文件，节省内存，易于更新　。
            缺点：相较于静态库而言库函数访问略慢。
    14.使用静态库的参数操作动态库，看能否跑起来。（不能加静态库的操作参数）
    
"-----第四天-----------------------------------------------------------------------------"
    15. 其他命令：
        1) alias 当前命令="加强版的命令"；
            alias gcc='gcc -std=c99';    使gcc 的默认编译按照 c99 规范。（在家目录的bashrc配置文件中）;
        2)echo 取变量的值：echo $变量名；（取出变量的值）变量名前加 $;
            例如：echo $PATH;(取出环境变量的值)；
            "取最近的函数的返回值：  echo $? "
十一。windows中的动态库
    1.  xxx.dll(windows中的动态库名后缀)；
    2." 动态库与静态库发布时的区别："


十二。gdb 调试：
    1.得到包含调试信息的可执行性程序：
    gdb -g main.c -o app -I ../include ;

    2.运行调试程序：
        gdb 可执行程序名；
        
    3.命令: 
        1）执行命令：两种  start 一行一行执行，执行过程中可以添加其他参数调试。 
                        run  直接执行到程序结束。
        2）查看程序内容: l (什么都不加)；l + 行号； l + 函数名； l + 函数名:行号；

        3）加断点：b 行数 ； 查看断点信息：i  b;    删除断点：del b 断点编号

        4）继续执行程序：c ； c + 断点编号（跳到此段的位置）； 打印内容：p  变量名；  往下执行一步：n

        5）自动追踪变量的值：display + 变量名；查看追踪变量的编号：i display；  取消追踪： undisplay + 追踪变量编号

        6）跳出循环：1）设置变量的值：set var 变量名=值；
                     2）在循环的的外面设一个断点，跳到该断点。
        
        7）获取变量的类型：ptype 变量名；
        
        8）进入到函数体的内部：s ；跳到下一个断点： c 。
        
        9）跳出当前函数：finish；

        10）条件断点：b 17 if i == 10(当i等于 10 时 17 行打断点，注意：断点不能设在 for 循环的那行，不会停止);

十三. Makefile 文件编写;
    掌握内容：
        一个规则，两个函数，三个自动变量
    
    1.命名：makefile;  Makefile;
    2.用途：
        项目代码编译管理；节省编译项目的时间；
    3.Makefile 中的规则：
        目标：依赖;
            生成一个 app 执行程序；需要依赖的函数;
        命令：编译命令；
        
        标准格式："目标 : 依赖(依赖这个位置不一定非得有，有的时候是没有的。如下面的 make clean:)
                         命令"
    操作界面的：make 目标；==========》   
    4.工作原理：
        1）若想生成目标，检查规则中依赖的条件是否存在；如果不存在，寻找是否有规则用来生成该条件

        2）检查规则中目标是否需要被更新，必须检查它的所有依赖；依赖中有任何一个被更新，则目标必须被更新。（规则："依赖文件比目标时间晚，则需要被更新。"）

    5.Makefile编译版本："makefile中所有的函数都有返回值"
        1）版本1：

            缺点：效率低，每次修改任意一处，都需要编译所有的源文件。

        2）版本二：

            缺点：冗余。
            "app:main.o div.o mul.o sub.o            //第一个条件
                gcc main.o div.o mul.o sub.o -o app

            main.o:main.c                             //第一个条件的依赖条件生成
                gcc -c main.c
            div.o:div.c
                gcc -c div.c
            mul.o:mul.c
                gcc -c mul.c
            sub.o:sub.c
                gcc -c sub.c"

        3）版本三：（使用了变量）
            1.Makefile中的变量： 变量名=value
            
            2.Makefile中的自动变量：
                1）$@:    规则中的目标
                2）$<:    规则中的第一个依赖
                3) $^:    规则中的所有的依赖
            注意： 这三个只能在命令中使用。

            3.Makefile中自己维护的变量：
                CPPFLAGS=头文件的路径；

            缺点：相关的文件不能自动查找
            "代码：
                obj = main.o div.o mul.o sub.o          
                target = app3
                CPPFLAGS=-I ../aa/

                #第一条目标
                $(target):$(obj)
                    gcc $(obj) -o $(target)

                #第二条目标
                %.o : %.c
                    gcc -c $< $(CPPFLAGS)"


        4）    版本四：
            1.makefile 中的函数：
                1）所有的函数都有返回值
                2）wildcard---查找指定目录下指定类型的文件
                        "src = $(wildcard ./*.c);"
                   patsubst---匹配替换
                           obj = $(patsubst %.c,%.o,$(src))
            缺点： 功能不够强大
            "代码：
                src = $(wildcard ./*.c)
                target = app
                obj = $(patsubst %.c, %.o, $(src))
                CPPFLAGS = -I ./

                $(target):$(obj)
                    gcc $(obj) -o $(target)

                %.o:%.c
                    gcc -c $< $(CPPFLAGS)"

        5)  版本五：删除编写过程中的临时文件
            1.生成一个与终极目标无关的目标：clean
                make clean

            1.声明伪目标：.PHONY:变量的名；
                伪目标特点：makefile 不会检查目录下是否有这样的文件，也不会对它的时间做检查

            2.-的作用:、该命令如果错误，跳过该命令，继续执行下一条命令。
                clean：
                    -rm $(obj);        有提示：(当前命令无法执行时有提示)
              -f的作用：强制删除当前    
                    -rm -f $(obj);    无提示：(当前命令无法执行时无提示)
                "代码
                    src = $(wildcard ./*.c)
                    target = app
                    obj = $(patsubst %.c, %.o, $(src))
                    CPPFLAGS = -I ./

                    $(target):$(obj)
                        gcc $(obj) -o $(target)

                    %.o:%.c
                        gcc -c $< $(CPPFLAGS)
                    .PHONY:clean
                    clean:
                        -rm -f $(obj)"

        终极目标：第一条目标所依赖的规则；
        "每级目标时间比每级依赖时间晚。"        

十四。linux系统的 IO 函数：
    linux 每运行一个程序（进程），操作系统都会为其分配一个 0~4G 的虚拟内存空间（32位操作系统）。
    
    1.C库函数:
        1）fopen 函数返回值：一个文件指针(结构体)：（包含三个方面：1.文件描述符， 2.文件读写位置， 3.I/O缓冲区(内存地址)）；
            文件描述符：描述符表：相当于一个数组，大小为1024；
            一个进程最多打开1024个文件；

        2）缓冲区的数据往磁盘上写内容的三种情况：
            1.刷新缓冲区:(fflush)
            2.缓冲区已满；
            3.正常关闭文件(fclose);  或者：main函数中（return， exit）;
            "注意：标准C库函数 有缓冲区，而linux 系统函数 没有缓冲区 "；
        3）ELF（Linux下可执行程序的格式）:
            ELF中存放的是源代码，他有一个入口，main函数。主要分为三段：.bss(未初始化的全局变量)；.data(已初始化的全局变量)；    text(代码段) ；


        4) PCB：进程控制块；其中有一个文件描述表（其中存储文件描述符；一个文件占用一个文件描述符），是一个数组，有1024个大小；所以一个进程之内最多只能打开1024个文件。
            每打开一个新文件，则占用一个文件按描述符，而且使用的是空闲的最小的一个文件描述符。

    "代码区是栈模型"。



"-----第五天-----------------------------------------------------------------------------"
一.系统 I/O 函数：
    1.open() 函数当文件不存在时，创建文件，并为它指定权限；（函数的第二个参数，各种宏定义； 第三个参数：指定权限，与掩码的取反再按位与得出文件最后的权限）。;
        1）正常打开， 2）创建文件；  3）文件截断；
    2.文件截断：
    
    3. perror() 函数的使用：头文件stdio.h; 打印错误信息。;

    4. read() ;  size_t(无符号整型);   ssize_t(有符号整型);（UNIX 的类型）；

    5. linux系统函数的注意事项：需要判断函数的返回值。-1，失败；  
    
    6.Linux系统函数实现文件的拓展：
        第一步 lseek(fd, 1000, SEEK_END );
        第二步 write(fd, "a", 1);    (必须有一次写操作)。
        "拓展的部分为空洞文字；有空洞文字的文件叫空洞文件，作用： 提前占用磁盘空间，下载中的应用：防止下载一半，空间不够。"

    7.stat()函数： 
        1.off_t(unix 中的整型);
        2.应用（断点续传；）


    8.一些命令的穿透功能：如：vi; cat; （遇到软连接时）
        不穿透的：如： rm;    （遇到软连接时）

    9.chmod()

    10.chown()函数的参数查找；必须在配置文件中查找

    11.unlink()函数；（删除文件目录项，使之具备被释放的条件。）
        函数使用场景：实现能够自动删除临时文件；
        注意点：当文件在打开状态时：open()，并没有关闭；unlink，当close的文件的时候，会自动删除。
        "例如: 
            int fd = open("san.txt", O_RDWR);
            unlink("san,txt");  //删除文件，当前状态不会删除
            write(fd, buf1, 102);
            lseek();
            read(fd, buf, 200);
            close(fd);            //此时文件 san.txt 才会自动删除
                      "
    12.chdir:修改当前进程的路径
            int chdir(const char *path);  path:当前进程的名字。

    13.getcwd:获取当前进程的工作路径。char* getcwd(char* buf, size_t size);
        参数：buf--缓冲区，存储获取到的工作路径。
              size--缓冲区的最大容量。

    14.mkdir--创建目录： int mkdir(const char* pathname, mode_t mode );
        参数： pathname: 创建的目录名。  mode: 目录权限（8进制）。给出的权限经过换算之后才会得到最终权限。（mode & ~umask & 0777）    
        


    

"-----第六天-----------------------------------------------------------------------------"

1.版本控制：svn/git;

2.进程的概念：
    1）程序和进程；
        每个进程操作系统会为它分配 0-4G 的虚拟内存空间（32位操作系统）； 其中0-3G为用户内存空间，进程可以对它进行读写操作； 3G - 4G 为系统内核空间，进程没有读写权限。
        进程只能读写用户空间，没有权限读写内核空间（kernel）;
    2）内存页面的概念
        操作系统是按页来管理内存的；每个页有4096个字节。
        还可以设置页面属性：如char *str = "hello",字符串在只读数据段，此时只能读，不能写。

    3)进程的4种形态：0-3级； 0 级(内核态)，最高； 3级(用户态);最低。

    2）并发：
    3）单道程序设计/多道程序设计
    4）CPU/MMU
    5）PCB：结构体；其中有一个指针指向文件描述符表；文件描述符表中存储1024个指针；已经打开的文件结构体。
        每个进程有属于自己的PCB（进程的状态描述符）；但是多个进程只有一个内核区。
3.环境变量控制
    1)echo $名称；    查看该名称的环境变量。
    2)查看系统的环境变量： env;
    3)获取环境变量的值：char *getenv(const char* name);    获取键name环境变量的值。
    4)设置环境变量：int    setenv(const char *name, const char *value, int rewrite);    将环境变量name的值设置为 value。
                    如果环境变量 name 已存在；则 rewrite 非0，覆盖原来的环境变量；rewrite为0，则不覆盖原来的环境变量。
    5）删除环境变量： void unsetenv(const char *name) 删除 name    的定义;

    6)进程里可以设置自己的环境变量，避免设置在终端，影响他人。
4.环境控制原语：
    1）fork:
    2)wait/waitpid
    3)

5. printenv.c

6.进程的状态：4 种或 5 种，都对。 就绪， 运行， 睡眠， 停止。

7.CPU的组成状态： 运算器，寄存器，控制器，译码器。

    操作系统完成进程调度。（cpu进行时钟周期运算）
    cpu的分时复用功能，使进程看起来像多进程。
    在单核 cpu 上，同一时间只能有一个进程处于运行状态。那么多核 cpu，就可以有多个进程处于运行状态。
"8.子进程、父进程间的共享、不共享："
        共享： 1.宿主目录； 2.进程工作目录； 3.信号处理方式；  4.环境变量；
                5. 0-3G的用户空间（"读时共享，写时复制。"“特别是：全局变量”）  6.文件描述符（打开文件的结构体） 7.mmap建立的映射区。
        
        不共享：1.进程ID， 2.进程运行时间  3.闹钟；   4.未决信号集   5.PCB

8.进程原语：
    1）创建子进程。pid_t fork();    调用1次，返回两次；在父进程返回子进程的 PID, 在子进程返回0.
    2) fork()的工作进程：先调用 creat(),创建一个进程， 在调用 clone()，给子进程复制父进程的内容;
    3）pid = fork();    //此时父子进程就都出来了。
    4）pid_t getpid();  返回调用进程的PID号；
       pid_t getppid();    返回调用进程的父进程的PID号
       当在子进程中 getpid(),得到的值与 fork()父进程的返回值相等，都是这个子进程的id号
    5）父子进程：读时共享，写时复制。
    6）最大创建进程 个数;
9.    uid_t getuid(void);        //返回实际用户id；
    uid_t geteuid(void);     //返回有效用户id；
    "注意： 文件实际用户与有效用户在创建该文件的家目录下时，如果没有修改，此时是相通的。
            当文件被拷贝到root目录时，   "    
    设置用户id； chmod 04755;  4 是设置用户ID。  完后效果为 -rwsr-xr-x;  s表示设置了用户ID。
            作用：当执行此文件时，执行者有效用户ID变为此文件的所有者。
            设置用户组ID： chmod 06777; 6 是设置用户ID和组ID； 效果为： -rwsrwsrwx;

10. exec族函数的使用：
    1）功能： 去磁盘中加载另一个可执行程序，用它的代码段、数据段替换掉当前可执行程序的代码段、数据段；然后从后加载的这个程序退出，被替换的程序后续代码就不执行了。（换核不换壳，）
    2）一般情况下：与 fork() 函数联合使用;。  同时exec族函数不会创建新进程， 所以该程序的　ID　不会改变。

    3）函数的返回值： 成功没有返回值，运行完毕，自己退出。
                      失败返回 -1;
    4）exec族函数的规律： l(list)：命令行参数列表。  p(path): 搜索file时使用path变量。
                          v(vector):使用命令行参数数组。  e(environment):使用环境变量的数组，不使用进程原有的环境变量，设置新加载程序的环境变量;
    
    5）int execl(const char *path, const char *argc, ...); 
    例如：execl("./bin/ls", "ls", "-l", "-a", NULL);    这几个参数的作用：其中第一个参数："./bin/ls",命令的环境变量（即所在文件），不可以改变，必须完整正确；
        "ls"：占位参数，可以随便写，一般写成该命令。（不能缺失，如果缺失了，就会把后面的命令参数变为占位参数，输出结果会出错。） "-l","-a"该命令的参数。   NULL：卫兵，执行到这里时命令结束。

11. toupper():将小写字母变为大写。

12.僵尸进程，孤儿进程：
    1）概念：
        僵尸进程：子进程终止，父进程未回收，子进程残留资源（PCB）存放于内核，造成僵尸进程。
        孤儿进程：父进程先于子进程终止，则子进程成为孤儿进程，然后被init进程领养。

    1）S：睡眠状态；  Z：僵尸状态；
    2）僵尸进程的产生原因：用户空间释放，内核空间的PCB没有释放，等着父进程回收。（它消耗的是内核当中的内存资源）
            即：子进程退出，父进程没有回收子进程资源（PCB），则子进程变为僵尸进程。
    3）子进程的PCB（在内核空间）没有释放,是留给父进程回收用的。只有父进程回收后，僵尸进程才会消失。
    4）杀死僵尸进程的办法是杀掉它的父进程。

  孤儿进程：父进程先于子进程结束，则子进程变为孤儿进程，子进程的变为1号进程init进程，由1号进程领养。

  "僵尸进程比孤儿进程更危险， 因为它不会自动关；，而孤儿进程会由 1 号进程领养，当它执行完毕后，会被 1 号进程回收"。
  做开发时主要避免的是僵尸进程的产生。用 wait(); waitpid(); 来避免僵尸进程的产生。


13. pid_t wait(int* status);  （阻塞函数，等待回收子进程资源；如果没有子进程，返回-1）；
    1）返回值：回收的子进程的ID号，    wait(NULL);不关心子进程如何死亡，直接回收。
                                    wait(&st); 用st来保存子进程死亡时的状态。
    
    2）    父进程的ID与它的进程组ID相同；子进程的组ID与父进程的ID相同。
        kill -9 -父进程的ID(即组进程的ID)，这个进程组的所有进程都被杀死。"（注意 - 不能少）"

14.pid_t waitpid(pid_t pid, int *status, int options);    (设置非阻塞。)
    第一个参数 pid的值类型：    1） < -1; 回收指定进程组内的任意子进程。（因为父进程与子进程属于统一进程组，父进程与孙子进程属于不同的进程组，但是他们有血缘关系。）
                                    -1；回收任意子进程（只要有血缘关系就行。）
                                    0； 回收 当前调用 waitpid 一个进程组的所有子进程。
                                    > 0; 回收指定ID的子进程。
    第二个参数：保存子进程的推出状态。

    第三个参数：WNOHANG：如果没有子进程退出，立即返回。（实现了非阻塞的 wait）.

15. 阻塞函数：非阻塞函数：在文件open(O_NONBLOCK)的时设置宏；读常规文件不会出现阻塞，当读伪文件时会出现。
        例如：阻塞读终端； 管道； 网络；

    设置非阻塞后：应设置轮询。
        

"=========进程间的通信（IPC）==========================================================================================================="
一。IPC方法：Linux环境下，多个进程间的通信，需要通过内核，在内核中开辟一块缓冲区（赋予他用户权限）；进程1把数据从用户空间拷贝到内核缓冲区，
    进程2 把数据从内核缓冲区拷读走，内核提供的这种机制称为进程间的通信(IPC)。

    进程间的通信；四种方法：1.pipe管道 2.fifo有名管道,3.内存共享映射 4.Unix Domain Socket；
    管道（使用最简单）；信号（开销最小）；共享映射区（速度最快，效率最高）； 本地套接字（最稳定）；

二。pipe管道：
1.管道的特性：数据只能一个读，一个写，必须是一个方向。
            半双工：数据同一时刻只能有一个流向。即只能父进程写，子进程读； 或子进程写， 父进程读。
            全双工：数据同一时刻可以两个方向。
            单工：数据只能同一个方向流动。
            dup2(int oldfd, int newfd);        将第一个参数拷贝给第二个参数。
            1.其本质是一个伪文件（实为内核缓冲区）
            2.有两个文件描述符引用，一个读端，一个写端。
            3.规定数据从管道的写端流入，从读端流出。
  
  管道的原理：管道实为内核使用环形队列机制，借助内核缓冲区（4K）实现的。

  管道的局限性：1.数据不能自己写，自己读；
                  2.管道中的数据不能反复读取，一旦读走，管道中不再存在。
                  3.采用半双工通信方式，数据只能在单方向上流动。
                  4.只能在有血缘关系之间的进程使用管道。
                  5.只能进行单向通信，双向通信需要建立两个管道。

2. pipe()创建管道，用于有血缘关系之间的通信。（采用环形队列实现的）
    管道使用半双工通信； 创建完管道完后，确定通信方向：父写子读，或子写父读。
    如果想创建多条管道，一定要先pipe()，再fork(),使子进程得以继承管道。

    使用管道时的四种注意情况：
    1） 写段关闭，读端读完管道里的内容时；再次读，返回0，相当于读到文件末尾EOF；
    2）写端未关闭，写端无数据， 读端读完管道里的数据时，再次读，阻塞。
    3）读端关闭， 写段写管道，产生SIGPIPE信号，写进程默认情况下会终止进程。
    4）读端未读管道数据，当写段写满管道后，在此写，阻塞。
    5）使用管道，无须open，但需手动close。

    管道的缓冲区大小：1.函数的方法：fpathconf(int fd, int name);  第一个参数为管道描述符；第二个参数为情况标识符。
                        2.命令： ulimit -a;    查看系统 软硬件限制。

3.    总结：
    1.读管道：
        1.管道中有数据，read返回实际读到的字节数；
        2.管道中无数据，写端都被关闭，read返回 0，相当于读到文件末尾；
                        写端未关闭，read函数阻塞等待，（期待不久的将来会有数据到来，但此时会让出CPU资源）
    2.写管道：
        1.管道读端全部关闭；进程异常中止（返回一个终止信号）；
        2.管道读端未关闭：
            1）管道已写满，write阻塞等待

            2）管道未写满，write将数据写入，返回实际写入的字节数;


"==========================================================================="
4.设置非阻塞管道的两种办法：
    1）fcntl函数设置非阻塞管道；
        int flg = fcntl(fd, F_GETFD);
        flg |= O_NONBLOCK;
        fcntl(fd, F_SETFL, flg);
    2）打开文件时直接设置非阻塞；
        int fd = open("/dev/tty", O_RDWR | O_NONBLOCK);
当读取一个非阻塞文件，但是此时没有内容，会出错，错误码为EAGAIN;
5. read() 函数的返回值四种情况；由于非阻塞设置的存在.
    1.返回值 > 0; 读到的字节数
    2.返回值 < 0; 读到文件末尾
    3.返回值 == -1；但是errno != EAGAIN  或 EWOULDBLOCK
        if( ret == -1) {
        if(errno ==  EAGAIN)
        {
            说明文件被设置为非阻塞方式读取，此时数据没有到达。
        }
        else 
        {
            失败；
        }
    }
    4.返回值 == -1， 但是errno == EAGAIN  或 EWOULDBLOCK；
        说明此时文件被设置为非阻塞方式读取，数据还没有到达。
"========================================================================"
三. fifo有名管道：解决无血缘关系的进程通信;
    1.介绍：
        FIFO文件在磁盘上没有数据块，仅仅用来标识内核中的一条管道。各进程可以打开这个文件进行read/write，实际上是在写内核通道，这样就实现了进程间的通信。
    1.创建fifo的方法：
        1)在终端创建一个有名管道；（不常用）用命令；"mkfifo 管道名";
        2）在代码运行时创建一个有名管道；（常用）用函数；int mkfifo(const char*pathname, mode_t mode);成功返回 0，失败-1；

    2.利用fifo实现非血缘关系进程间通信
        1.进程使用 “同一个fifo” 完成进程间通信。
        2.一个进程以只读方式打开read端，一个程序以只写打开写段。
        3.一根管道可以打开多个读端，多个写段。（一个写段多个读端； 或 一个读端多个写段）；
    
    3.多种特殊情况：
        当一个写端多个读端时： 每个读端读取到的数据都不相同，因为从管道中读数据，读走之后，管道中的这个数据就不存在了；此时每个读端读到的所有内容合在一起为
                                管道写端写入的数据
        当多个写端一个读端时， 每个写端写入的数据都会被这个读端读取出来；此时管道读到的数据为所有写端写入的数据。
                            
四。mmap 内存映射：

        从磁盘映射到kernel区，同时kernel区这段内存（映射占用的）开放了用户区的权限；所以进程可以进行访问

1.文件是应用于进程间通信
    1）父子进程之间
        可以用文件进行通信；
    2）非血缘关系进程间通信
        可以用文件进行通信；
    
2.建立映射区，完成进程间通信             
    1）mmap函数；六个参数的不同意义

    2）注意事项
        1.open的时候可以创建一个新文件，但是用此文件创建映射区时，大小不能为0；(可以进行文件拓展后再用来创建映射)
            mmap使用的时候经常出现总线错误，通常是由于共享文件存储空间大小引起的。
            
        2.创建映射区的时候， 隐含着一次对文件的读操作；所以文件打开的方式只能为"读写；或读"。
          当 MAP_SHARED（对内存的修改将反应到磁盘空间）    时，要求 映射区的权限 <= 文件打开的权限。
          当 MAP_PRIVATE(对内存修改不会反应到磁盘空间)  时，此时则没有要求。（mmap中的权限是对内存的限制）;

        3.映射区创建完后关闭文件按描述符，对映射区没有影响。
        4."最后一个参数，偏移量必须是4K的整数倍。"
        5.munmap函数传入的地址一定要是mmap的返回地址。坚决杜绝对mmap函数的返回值进行++操作
        6.mmap创建映射区出错的概率非常高，必须进行出错判断。

    3）父子进程间的mmap（用户空间独立，内核去各进程共享。）
        1.先mmap创建映射区
        2.再fork()共享映射区内存首地址
        3.指定MAP_SHARED;（必须是 SHARED）；

    4）非血缘关系进程间通信
        1.使用“同一个文件”创建映射区
        2.两个进程，一个以read映射区，一个以write方式打开映射区；
        3.指定 MAP_SHARED;
        4）MAP_ANONYMOUS(匿名映射); 不可以用来通信
        5)/dev/zero(系统的伪文件); 不可以用来通信
    5）匿名映射
        linux 创建匿名映射：第四个参数添加 MAP_ANON或MAP__ANONYMOUS;(注意这个匿名宏，只有Linux操作系统可以使用)。

        UNIX(没有上述的匿名宏)。使用系统中的特殊文件（/dev/zero;(无限读，可以用来创建匿名映射)）

3.数据可以重复读取；（即多个读端读取一个写端，读取的内容相同，与fifo不同，取决于读取的数据）。



"====================进程间的通信（IPC）================================================================================================"

文件名最大为255字节(byte)；
"============================硬链接========================"
创建一个硬链接：
    1.dentry（包含文件名，文件属性）
    2.一个文件包含（三大块）：文件的名字； inode（指向文件属性） ；文件内容；
    3.
"============================硬链接========================"

strace 跟踪程序的运行时函数的系统调用；

"===信号========================================================================================================================"
一.信号的概念：
    1.本质：
        软中端；信号通过内核发送，内核处理的。
    2.特性：
        1）简单，2）不能携带大量信息； 3）满足某一条件
    3.信号机制：
        软中端；信号通过内核发送，内核处理的；通过软件的方法实现的，有较强的延迟性。
        
    3.四要素：
        1.信号编号， 2.信号名称， 3。默认处理动作，4.对应的事件。
        
        2.信号的默认处理动作（5种）：
            1.终止进程（term）；2.忽略（Ign:信号被处理丢弃）；3.终止进程并产生core文件(core);
            4.Stop(暂停)；  5.Cont (继续);

    4.名词称呼
        1.信号的状态：
            1.产生；
            2.未决：处于产生和递达中间，由于阻塞不能递达、处理。
            3.递达；信号递达后内核会立即处理。（也就是说，他俩经常绑定在一起，信号递达就代表这信号被处理。）
            4.处理：（信号必须递达）
                1.忽略处理（信号已经处理，丢弃操作）； 2.执行默认操作，  3.捕捉（不执行默认操作，来指定操作让其执行；）
            
        2.未决信号集：（pending）
            在PCB中，以位图的方式存在。
            记录信号是否被产生，并且被处理。 内核处理信号的依据。用户不能直接修改未决信号集。

        3.阻塞信号集/信号屏蔽字：（mask）
            在PCB中，以位图的方式存在。    mask影响pending；用户只可以通过mask来影响pending。
            记录信号是否被设置屏蔽。用户影响信号的依据。

        4. 1-31 号信号，常规信号（不支持排队）； 34-64 号信号，实时信号（支持排队）

        5.特殊信号：（两个）；
            9 号、 19 号信号；不允许捕捉，忽略，甚至不能设置屏蔽。

        6.产生段错误的方式（三种）；
            1.访问非访问区域。0x1000   printf();            mmu---没有映射该虚拟内存
            2.对只读区域进行写操作。 char* p = hello; p[1] = 'H';      mmu---映射的虚拟内存对应的物理内存权限不足。 0 内核权限； 3 用户权限
            3.内存溢出；  char buf[10];  buf[10] = '10'; buf[100] = '28';  mmu---没有映射该虚拟内存。

二.产生信号：
    1.常见的产生信号方法：
        1.按键产生：ctrl+c；
        2.系统调用：如kill
            kill(pid_t pid, int sig); 向指定进程或进程组发送指定信号;
                第一个参数： pid > 0; 向指定进程发送指定信号；    pid == 0; 向调用kill函数的进程组的所有进程发送该信号
                            pid == -1; 发送信号给系统中有权限的所有进程；  pid < -1; 发送信号给指定的进程组|pid|;
                第二个参数： 信号。（不同的平台环境下，信号的编号不同；但是信号的宏定义相同，所以一般使用宏名）。

            raise() 给当前进程发送指定信号;
            abort() 向当前进程发送SIGABRT信号;
        3.软件条件产生：如，定时器alarm;
            alarm:每个进程有且只有唯一一个定时器。
            返回值特殊：上次定时剩余的时间。定时（采用自然定时），与进程状态无关！！！，无论处于何种状态，都会计时。;
            取消闹钟: alarm(0);    实际执行时间 = 系统时间+用户时间+等待时间。
             定时的单位是：秒。
            setitimer(); 定时单位单位：微妙；
                三个参数：


        4.硬件异常产生：如，非法内存访问(段错误)；内存对齐出错(总线错误)；除0(浮点数除外)。

    
        5.命令产生：如kill命令

三。信号操作函数；
    1.信号集 set：            
        sigset_t   set;

        sigemptyset（&set）  清空集合  

        sigfillset（&set）  置1集合  

        sigaddset（&set， 待添加的信号名称） 添加信号到集合中

        sigdelset（&set， 待删除的信号名称） 删除信号到集合中

        sigismember（&set， 待判断的信号名称）判断信号是否在集合中  -- 》 1：在 0：不在； -1；错

    2.mask(信号屏蔽字/阻塞信号集)操作
        sigprocmask();用来屏蔽信号、解除信号；其本质是读取或修改进程的信号屏蔽字（PCB中）；
        "注意：屏蔽信号只是将信号处理延后执行（延至解除屏蔽）， 而忽略表示将信号丢弃。"
        参数：第一个参数 how 的取值：假设当前的信号屏蔽字为mask；
                1.SIG_BLOCK：当how设置为此时，set表示要屏蔽的信号。相当于mask= mask|set;
                2.SIG_UNBLOCK：当how 设置为此时，set 表示要解除的信号。相当于：mask = mask & ~set;
                3.SIG_SETMASK; 当how 设置为此时，set = mask;
            第二个参数： set 传入参数：用来操作mask的set集合。
            第三个参数： oldset 传出参数。记录旧有的mask状态。

    3.pending操作
        int sigpending(sigset_t *set);传出参数
        参数：获取未决信号集
        返回值：存在返回 1； 不存在返回 0；

四。信号捕捉
    1.signal：（注册信号的捕捉处理函数）
        参数：1.信号编号 2.捕捉后调用的执行函数（是一个函数指针。即回调函数）；
        返回值：捕捉的函数句柄。

    2.sigaction： 1)信号捕捉函数执行期间，本信号被自动屏蔽（取决于：sa_flags） 2)信号捕捉函数执行期间，信号多次产生，只记录一次。

     函数原型：int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
         参数解析： 1）第一个参数：信号名称或编号；要捕捉的信号。
                    2）第二个参数：新处理动作传入，是一个结构体。
                           1）sa_handler: 1）函数指针，捕捉信号后执行的回调函数；2） SIG_IGN 表示忽略； 3）SIG_DFL 表示执行默认操作。
                        2）sa_mask; 信号屏蔽字/阻塞信号集；捕捉函数执行期间的屏蔽字，此中的信号在捕捉函数执行期间自动屏蔽。
                        3）sa_flags: 1) 0; 表示：信号捕捉函数执行期间，要捕捉的信号被自动屏蔽（即第一个参数）。
                                    2）SA_SIGINFO: 选用sa_sigaction来指定捕捉函数；
                                    3）SA_INTERRUPT: 系统调用被信号中断后，不重启；
                                    4）SA_REATART: 系统调用被信号中断后，自动重启。
                                    5）SA_NODEFER: 在捕捉函数执行期间不自动屏蔽捕捉的信号；

                       4) sa_sigaction: 函数指针， 三个参数，void (*sa_sigaction)(int, siginfo_t*, void*);指定带参数的信号捕捉函数。
                    3)第三个参数：旧处理动作传出；
            返回值： 0 表示成功， -1 表示失败，并设置errno ;
    3.信号捕捉特性：
        1）捕捉函数执行期间，屏蔽字由sa_mask指定。
        2）捕捉函数执行期间，被捕捉的信号自动屏蔽； 由sa_flags = 0 决定;
        3)"捕捉函数执行期间，常规信号不支持排队，多次产生只记录一次。"    
        常规信号为：1-31 信号； 实时信号为 34-64 信号。
        详细过程：进程正常运行时，默认PCB中有一个信号屏蔽字，假定为☆，它决定了进程自动屏蔽哪些信号。当注册了某个信号捕捉函数，捕捉到该信号以后，
           要调用该函数。而该函数有可能执行很长时间，在这期间所屏蔽的信号不由☆来指定。而是用sa_mask来指定。调用完信号处理函数，再恢复为☆。
    
    4.信号内核实现捕捉函数思想：
        信号捕捉函数是 回调函数； 由内核在信号产生、递达之后负责回调。
        调用结束应该返回内核空间，再返回用户空间。

    5.内核实现信号捕捉的一般过程
        1）回调捕捉函数； 2）调用结束先返回内核。

        “注意：此处加图片：”
五。竟态条件（时序竟态）
    1.pause() 函数:主动造成进程挂起，等待信号唤醒。调用该系统调用的进程将处于阻塞状态（主动放弃CPU），知道有信号到达将其唤醒。
        int pause(void); 返回值：-1，并设置errno == EINTR;
        注意：
                1) 唤醒pause()函数的信号不能执行默认操作、忽略、屏蔽。原因：
                    1）如果信号的默认动作是终止进程，则进程终止，pause函数不会有机会被调用。
                    2）如果信号默认动作是忽略、屏蔽，则进程继续挂起，pause不会调用。
                2）如果信号的处理动作是捕捉，则【捕捉函数处理完后，pause被调用返回-1，并且errno == EINTR,表示被信号终端，即唤醒】；
                3）综上所诉：能唤醒pause()函数的信号，只能是被捕捉的信号；
                
    2.时序竟态：
        1.时序问题产生的原因： 1）系统负载严重； 2) 信号不可靠机制；

        2.解决时序问题：
            1）使用原子操作；将解除信号屏蔽与挂起等待合并成一个步骤。sigsuspend() 函数具有这个功能。在对时序要求严格的场合下都应用
                sigsuspend 替换 pause。"（解除信号屏蔽+挂起等待信号）----》原子操作---》sigsuspend()函数"
                int sigsuspend(const sigset_t *mask); 挂起等待信号。 
                    函数详解： 1）主动造成进程挂起,等待信号； 2）在这个函数调用期间屏蔽字由它的参数决定； 3）函数调用结束屏蔽字恢复为原值；4）原子操作
            2）提早预见，主动规避。这种错误，没法用gdb调试出来。

    3.全局变量的异步IO：
        存在的问题：
            1.多个进程对 同一 个全局变量进行写操作，存在问题。（如：信号回调函数中的全局变量和主函数中的全局变量为同1个，内核进程和主进程都对
                全局变量进行了写操作，非常容易出问题）。
            2.写操作时没有任何 同步 机制。（加锁机制）

            “注意：此处有代码，父子进程数数，代码1，主进程和内核对同一个全局变量进行写操作，出问题；
                                             代码2，全局变量只由主进程进行一次赋值操作后，主进程和内核进程对它的只读操作，没有出问题”

    4.可重入、不可重入函数：
        注意：
            1）不可重入函数：函数内部含有全局变量、静态变量，使用malloc、free；
            "2）信号捕捉函数应设计为可重入函数；（与上面的相反的就是可重入函数）。"
            3）信号处理程序调用的可重入的系统调用函数；可参阅 man 7 signal；
            4）没有包含在上述列表中的系统调用函数大多数是不可重入的，其原因是：
                a) 使用了静态数据结构，
                b) 调用了malloc 或free
                c) 是标准I/O函数 ；


六。SIGCHLD信号 -------IGN（该信号的默认动作是忽略）
    1.该信号的产生：
        1）子进程终止；
        2）子进程接收到SIGSTOP信号停止时；
        3）子进程处在停止态，接收到SIGCONT后唤醒时；
        综上所述：只要子进程的状态发生变化，会对父进程发出SIGCHLD信号，默认处理的动作是忽略。

    2.借助 SIGCHLD 子进程回收。
        1）wait()--------阻塞等待子进程结束；
        2）waitpid()--------设置不阻塞（第二个参数WNOHANG）。如果这样设置，要设置轮询，才能将子进程回收。
        3）信号捕捉---子进程回收；

    3.注意： 
        1)子进程继承了父进程的 信号处理动作和 信号屏蔽字(mask)，但并没有继承父进程的 未决信号集(sigpending)。
        2)注册信号捕捉函数的位置，和与其他进程发出信号的配合（必须在捕捉信号发出之前完成注册）。
        3）在捕捉函数中回收子进程（多个），一定要用循环，才可以做到，一次进入回收多个子进程；否则，会有子进程遗漏，未被回收，造成僵尸进程。

        “参考代码”

七。信号传参：
    1.int sigqueue(pid_t pid, int sig, const union sigval value); 成功返回0； 失败-1；
        sigqueue 向指定进程发送信号的同时携带参数（即它的第三个参数）；
        "注意：携带的数据。如果携带的是 地址：需注意，不同进程之间虚拟地址空间各自独立，将当前进程地址传递给另一进程没有实际意义"
    2.捕捉信号传参
        1）用该函数捕捉信号传递的数据： int sigaction(int signum, const struct sigaction* act, struct sigaction* oldact);    
        2）当注册信号捕捉函数，希望获得更多关于该信号的信息，不应使用 sa_handler, 而应使用 sa_sigaction。 但同时 sa_flags 必须指定SA_SIGINFO.
            siginfo_t 是一个成员十分丰富的结构体，携带者该信号的各种相关信息。
            
八。中断系统调用
    1.慢速系统调用（造成当前系统永久阻塞的）
        1）如read, write, wait, pause, sigsuspend, 都是慢速系统调用 ;
        2）概念： 可能使进程永远阻塞的一类系统调用；如果再阻塞期间收到一个信号，该系统调用被中断，不再继续执行；也可以通过设置，使其中断后再重新启动。
        3）特点：慢速系统调用被中断的相关行为，实际上就是pause的行为: 如read()
            1) 信号不能被屏蔽， 执行默认动作， 忽略；
            2）信号的处理方式必须被捕捉；    
            3）中断后返回-1， 设置errno为 EINTR(表示：“被信号终端”);

        4)设置sa_flags 参数来决定它终端后的行为：
                0           表示被捕捉的信号，在捕捉函数执行期间被自动屏蔽
                SA_NODEFER    表示被捕捉的信号，在捕捉函数执行期间不被自动屏蔽
                SA_INTERRURT 表示慢速系统调用，若被信号打断，不再重启
                SA_RESTART  表示慢速系统调用，若被信号打断，重启 
                SA_SIGINFO  表示捕捉函数是3参的sigaction,需指定为这个宏名

    2.其他系统调用：
        如Lgetpid(), fork();

十。终端
    1.字符终端(虚拟终端)，图形终端(伪终端)，网络终端(伪终端)。
    2.线路规程(line discipline)：
        像一个过滤器，对于某些特殊字符并不是让它直接通过，而是做特殊处理，比如ctrl+c,对应的字符并不会被用户程序read读到，而是被线路规程截获，
        解释称SIGINT信号发送给前台进程，通常会使该进程停止。线路规程应该过滤哪些字符和做哪些特殊处理是可以配置的。
    3.在终端设备（如键盘）上输入内容进入进程的顺序：
        终端设备--》终端设备驱动--》line discipline(线路规程过滤)---》系统调用（普通内容）---》用户进程
                                                                 ---》内核特殊字符（解释称信号）--》内核 前台进程。;
    4.一套伪终端由一个主设备(PTY Master)和一个从设备(PTY Slave)组成；主设备在概念上相当于键盘、显示器，只不过他不是一个真正的硬件而是一个内核模块；
        操作它的也不是用户，而是另外一个内核模块。        网络终端或图形终端窗口的shell进程以及它启动的其他进程都认为自己的控制终端是伪终端从设备。                

十一。进程组        
    pid_t getpgid(pid_t pid);            返回指定进程组的ID
    pid_t getpgrp(void);                 返回调用函数进程组的ID
    int setpgid(pid_t pid, pid_t pgid);    设置某个进程的进程组ID； 成功返回0；失败-1；
    1.当父进程创建子进程时，默认子进程与父进程属于同一进程组。其进程组ID＝＝父进程的ID。
    2.特性：
        1）进程组ID　＝＝　组长ID
        2）进程组的生命周期： 只要进程组中有一个进程存在，该进程组就存在，"与组长进程是否终止无关"。
                        进程组创建到最后一个进程离开（终止或转移到另一个进程组）。
    3.一个进程可以为自己或子进程设置进程组ID。
    
    4.修改一个进程的进程组ID需注意：
        １）如改变子进程为新的组，应在fork后，exec前。
        2）权限问题。非root用户只能改变自己和它创建的子进程的进程组。

十二。会话。
    pid_t getsid(pid_t pid);获取该进程的会话ID（如果查看当前进程的会话ID，参数为0就行。自己测试吧）。成功：返回会话ID； 失败：返回-1，并设置errno .
    pid_t setpid(void); 创建一个会话，以自己的ID为新会话的ID，同时也会成为一个新的进程组。 成功：返回调用进程的ID；失败，-1；
    １.会话：进程组的集合。
    创建会话应注意：
        1.创建会话的进程不能是进程组组长；同时创建的进程变成新会话首进程（即组长）。
        2.创建完后该进程成为新进程组的组长进程。
        3.需要有root权限；（ubauntu不需要）
        4.新会话丢弃原有的控制终端，该会话没有控制终端（也就无法与用户进行交互）。
        5.该调用进程是组长进程，则出错返回。（与1 相同）。
        6.新建会话时，先调用fork，父进程退出；子进程创建会话（调用setsid()函数）。
        
    "注意：子进程不会随着成为新的进程组组长，而其父进程发生改变。"


十三：守护进程：
    1.Daemon(精灵)进程，即守护进程。
        特征：  1.位于Linux后台，服务进程。
                2.独立于控制终端（即没有控制终端），周期性的执行某任务，等待某事件
                3.不受用户的注销、登录而终止；（注意：不是关机）。
                4.通常采用以d结尾的名字。
                
    2.创建守护进程的模型：
        1.创建子进程，父进程退出
            所有工作在子进程中进行，形式上脱离了控制终端。
        2.在子进程中创建新会话
            setsid()函数
            使子进程完全独立出来，脱离控制;

        3.改变当前目录为根目录;
            chdir()函数；
            目的：防止占用可卸载的文件系统。
            也可换成其他目录，只要该目录稳定，不会被卸载（当时卸载的优盘目录）;

        4.重设文件掩码;
            umask()函数：
            目的： 防止继承的文件创建屏蔽字拒绝某些权限；
                   增加守护进程的灵活性;

        5.关闭文件描述符
            继承的打开不会用到，浪费系统资源，无法卸载。

        6.执行守护进程核心工作

        7.设置守护进程退出。

"===信号========================================================================================================================"


"===线程========================================================================================================================"

一。线程概念
    1.什么是线程
        1）线程：LWP(light weight process):轻量级的进程，拥有独立的PCB，共享进程地址空间，Linux下线程是最小的执行单位。
        
    2.线程与进程的区别、联系
        进程独享地址空间；  线程共享。
        进程是最小的分配资源单位；  线程是最小的执行单位。
        各自有独立的PCB。

    3.内核实现线程的原理：
        1.创建线程与创建进程类似；调用底层函数clone();
        2.有不同的PCB，但线程共享进程地址空间---》PCB各线程持有相同页目录---》三级映射一致。
        3.以每个线程的LWP号， 作为内核分配执行单位的依据。
        4.线程的ID != LWP；
        5.线程是寄存器与栈的集合。

    3.线程之间共享、不共享那些东西
        共享：
            1）文件描述符； 2）信号的处理方式； 3）用户ID和组ID；
            4）工作目录位置； 5）.text/.data/.bss/.ordata/heap-----》用户空间（0-3G ，栈空间除外） ；
        不共享：    
            1）线程ID；　2）用户stack(栈空间);   3）内核stack(栈空间)；
            4）信号屏蔽字；        5）errno变量；      6） 线程优先级

    4.线程的优缺点
        优点： 
            1）线程间通信可以通过----全局变量 。（进程间不共享全局变量 --- mmap 映射）
            2）开销小，节省空间
            3）程序的并发性提高。

        缺点：
            1）第三方库函数pthread，稳定性差；
            2）gdb调试工具支持不好。
            3）信号支持好（一般不要在线程中使用信号）。


二。线程的控制原语：【重点】
    1.创建线程：
        int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
        参数一：    传出参数，创建的线程ID；
        参数二：    线程属性，一般采用默认的（用 NULL）。
        参数三：    子线程的操作函数。
        参数四：    子线程操作函数的参数。
        返回值： 成功：0 ； 失败：错误号;

    2.获取线程的ID
        pthread_t pthread_self(void);
        参数：无u；
        返回值:    成功：线程ID号。　　失败：无。

    3.将当前线程退出：
        void pthread_exit(void *retval);
        参数一：线程退出值（void*类型）； NULL：无退出值。
        返回值：无；
        对比：
            return　：　    返回到调用者那里去;
            exit() :        进将当前进程退出;
            pthread_exit();    将当前线程退出；

    4.阻塞等待子线程退出，获取退出状态。
        int pthread_join(pthread_t thread, void** retval);
        参数一：      回收的线程ID；
        参数二：    被回收线程退出值。（NULL 表示不关心线程退出值）
        返回值：    成功：0；  失败：错误号。

    5.实现线程分离：
        int pthread_detach(pthread_t thread);
        参数一：待分离的线程ID;
        返回值：成功：0； 失败：错误号。

    6.杀死（取消）线程。
        int pthread_cancel(pthread_t thread); 
        参数一：欲杀死的线程ID；
        返回值：成功：0； 失败：错误号。
        注意：调用该函数时，欲杀死的线程必须调用系统调用函数（如：write，printf）;以使线程进入内核，到达 记录点/取消点。
            或者调用检查函数（。。test）等会查一下；
        终止线程的方式：return；
                        pthread_exit();
                        pthread_cancel();

    7.比较两个线程
        int pthread_equal(pthread_t t1, pthread_t t2);
        参数一、二：比较的两个线程ID号。

    4.线程、进程控制原语对比；
            线程                               进程
        pthread_creadte();                         fork();
        pthread_self();                            getpid()---getppid()---getpgid()---getsid();
        pthread_join();                            wait()---waitpid();
        pthread_exit();                            exit()----return;
        pthread_cancel();                        kill();
        pthread_detach();---分离
        pthread_equal();----比较

三。NPTL
    pthread库版本；
    查看：getconf GNU_LIBPATHREAD_VERSION
    gcc编译指定 ---lpthread 选项。

四。线程的属性【扩展】
    可在创建线程之前设置修改其默认属性：
    pthread_attr_t 结构体内容：1）线程分离状态； 2）线程栈空间大小； 3）线程警戒区大小；  4）线程栈低地址；。。。。。

    1.属性初始化
        pthread_attr_init();
        参数：attr:（传出参数），待初始化的结构体。
        返回值：成功；0 ； 失败：错误号；

    2.销毁自设属性；
        pthread_attr_destroy(); 使用时机： 线程创建完毕。

    3.线程分离状态：
        1) int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); 获取线程分离状态。
            参数一：attr：线程属性结构体指针
            参数二：detachstate（传出参数）： PTHREAD_CREATE_DETACHED（分离）；PTHREAD_CREATE_JOINABLE（分离）;
            返回值：成功；0； 失败：错误号；
        2）int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);    设置线程分离状态。

    4.线程栈地址：
        int pthread_attr_getstack(pthread_attr_t *attr, void **stackaddr, size_t *stacksize);    获取线程栈地址
        参数一：attr:        线程属性结构体指针
        参数二：stackaddr:（传出）    获取线程栈地址
        参数三：stacksize:（传出）    获取线程栈大小。
        返回值：成功；0；失败：错误号。
        int pthread_attr_setstack(pthread_attr_t *attr,void *stackaddr, size_t stacksize); 设置线程栈地址

    5.线程栈大小
           int pthread_attr_getstacksize(pthread_attr_t *attr, size_t *stacksize);获取线程栈大小

        int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize); 设置线程栈大小
        参数一：attr:        线程属性结构体指针
        参数二：stacksize：    设置线程栈大小
        返回值：成功；0；失败：错误号。


五。线程使用注意事项
    1.退出线程应使用 pthread_exit();
    2.避免僵尸线程的产生：
        1）pthread_join(); 回收子线程。
        2）pthread_detach();分离线程。
        3）指定分离属性，再pthread_create();创建线程。
    3.线程共享进程地址空间：malloc和mmap内存可被其他线程释放。
    4.多线程中应避免使用fork()，除非马上exec；多线程fork()后,产生的进程中只含有调用fork函数的线程，其他线程均退出。
    5.线程主函数中，应该避免返回局部变量地址值。
    6.避免多线程和信号混用。



"===线程同步、进程同步========================================================================================================================"
一。同步、线程同步概念
    1.生活中的同步为： 同时起步，协调一致。
    2.线程中的同步为： 协同步调，指定访问数据的先后顺序。
    3.所有多个控制流，共同操作同一共享数据的场景，都需要同步机制。
    4.数据混乱的原因：（产生与时间有关的错误）
        1）资源共享（独享资源则不会）
        2）调度随机
        3）线程间缺乏必要的同步机制
            其中前两者不可改变，这是多线程并发得以实行的必要条件，那么就需要在线程间加上同步机制。

二。线程同步的方法
    1.互斥量（互斥锁：mutex）------》建议锁（协同锁）
        1）互斥量特征
            1)建议锁，不具有强制性。
            2）访问共享数据前，加锁，访问结束后立即解锁。
            3）线程不按规则访问数据依然可以成功（即不加锁访问）；但数据会混乱。

        2）一系列操作函数
            1）初始化互斥锁
                1）动态初始化：int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
                    pthread_mutex_t 互斥锁的类型，本质是一个结构体，只有 0 和 1 两个值。
                    参数一：互斥锁， 
                    参数二：互斥锁的类型（进行修改，可以在进程间使用。）
                    restrict：关键字；只用于限制指针：告诉编译器，所有修改该指针指向内存中的操作，只能通过本指针完成；
                                        不能通过本指针之外的其他变量和指针操作。
                2）静态初始化：pthead_mutex_t muetx = PTHREAD_MUTEX_INITIALIZER;

            2）加锁：
                int pthread_mutex_lock(pthread_mutex_t *mutex);
                可理解为将 mutex--;
                说明：尝试加锁，如果加锁不成功，线程阻塞，阻塞到持有该互斥量的其他线程解锁为止。
            3) 解锁：
                int pthread_mutex_unlock(pthread_mutex_t *mutex);
                可理解为将 mutex++;
                说明：主动解锁，同时将阻塞在该锁上的所有线程全部唤醒；至于哪个线程先被唤醒，取决于优先级、调度。默认：先阻塞、先唤醒。
            4)    尝试加锁
                int pthread_mutex_trylock(pthread_mutex_t *mutex);
                说明： lock加锁失败会阻塞，等待所释放；  trylock：加锁失败直接返回错误号，不阻塞；
            5）销毁互斥锁
                int pthread_mutex_destroy(pthread_mutex_t *mutex);
                说明：程序结束时，要销毁使用的互斥锁。
        "在访问共享资源前加锁，访问结束后立即解锁，锁的 粒度 越小越好。"

    2.死锁--------------------不是线程同步的一种方式，而是一种现象。
        1)死锁一。（对同一个互斥量加锁两次。）
            连续加锁，阻塞等待。
            示例：
    pthread_mutex_t mutex;                        //定义一个全局互斥锁变量。
    void *do_sth(void* arg)
    {
        srand((unsigned int) time(NULL));
        while(1)
        {
            pthread_mutex_lock(&mutex);            //子线程加锁
            printf("hello ");
            sleep(rand()%3);
            printf("world\n");
            pthread_mutex_unlock(&mutex);        //子线程解锁
        }

        pthread_exit(NULL);                            //结束子线程
    }
    int main(void)
    {
        pthread_t ptid;
        srand((unsigned int) time(NULL));                //随机数的种子
        pthread_mutex_init(&mutex, NULL);                //互斥锁动态初始化

        pthread_create(&ptid, NULL, do_sth, NULL);        //创建子线程
        while(1)
        {
            pthread_mutex_lock(&mutex);        //主控线程第一次对数据加锁

            printf("HELLO ");
            sleep(rand()%3);                //这个睡眠额度作用是：即使此时CPU空出来，但由于另一个线程没有拿到锁，还是无法进行输出。
            printf("WORLD\n");   
            pthread_mutex_lock(&mutex);     //死锁：对同一互斥量连续加锁两次/多次;造成线程阻塞。
            pthread_mutex_unlock(&mutex);   //数据操作完后立即解锁，使锁的粒度最小。
        }
        pthread_mutex_destroy(&mutex);        //程序结束，销毁使用的互斥锁。
        pthread_join(ptid, NULL);            //回收子线程。
         pthread_exit(NULL);                    //主控线程退出
    } 

        2）死锁二。（多个共享数据，多把锁。持有锁A的线程1请求锁B，持有锁B的线程2请求锁A）
                    更极端的情况：震荡。
                解决方法：    1.当无法获取所有锁的时候，放弃已经掌握的锁
                              2.规定 不同线程 获取 共享数据 的顺序（即规定获取锁的顺序）。

    //两组共享的数据及其配套锁
    typedef struct recond_m
    {
        int data_m;
        pthread_mutex_t mutex_m;
    }recond_m;

    typedef struct recond_n
    {
        int data_n;
        pthread_mutex_t mutex_n;
    }recond_n;

    recond_m data_1;                                    //定义的两个全局共享变量
    recond_n data_2;    
    void *do_sth(void* arg)                                //子线程执行逻辑
    {
        srand((unsigned int) time(NULL));                //随机数的种子
        while(1)
        {
            //加锁顺序： 先 data1, 再data2;
            pthread_mutex_lock(&data_1.mutex_m);
            data_1.data_m = 9;                            //对全局变量修改
            printf("zi xian data_m:%d\n ",data_1.data_m);
            pthread_mutex_lock(&data_2.mutex_n);        
            data_2.data_n = 9;
            printf("zi xian data_n:%d\n ",data_2.data_n);

            pthread_mutex_unlock(&data_2.mutex_n);        //解锁两个共享数据
            pthread_mutex_unlock(&data_1.mutex_m);
        }

        pthread_exit(NULL);
    }

    int main(void)
    {
        pthread_t ptid;
        srand((unsigned int) time(NULL));
        //动态初始化两把锁
        pthread_mutex_init(&data_1.mutex_m, NULL);
        pthread_mutex_init(&data_2.mutex_n, NULL);

        pthread_create(&ptid, NULL, do_sth, NULL);            //创建子线程
        while(1)
        {
            //主控线程 ： 先锁 data2; 再锁data1;
            pthread_mutex_lock(&data_2.mutex_n);
            data_2.data_n = 6;
            printf("zhu kong data_n:%d\n ",data_2.data_n);
            sleep(1);                                        //空出CPU资源，　子线程加锁。
            pthread_mutex_lock(&data_1.mutex_m);
            data_1.data_m = 9;
            printf("zhu kong data_m:%d\n ",data_1.data_m);

            pthread_mutex_unlock(&data_1.mutex_m);
            pthread_mutex_unlock(&data_2.mutex_n);
            
        }

        pthread_mutex_destroy(&data_1.mutex_m);
        pthread_mutex_destroy(&data_2.mutex_n);
        pthread_join(ptid, NULL);
        pthread_exit(NULL);
    }

    2.读写锁(读写锁只有一把)
        1）读写锁特性
            1.写独占，读共享。
            2.写锁的优先级高于读锁。
            "详解：三种情况"
                1）写模式加锁：解锁前，所有对该锁加锁的进程都会被阻塞。
                2）读模式加锁，解锁前，如果其他所有线程以读模式加锁会成功，以写模式加锁会失败。
                3）读模式加锁，解锁前，其它线程中既有写模式加锁，也有读模式加锁，所有线程阻塞；解锁后，优先满足写模式的加锁。

        2）一系列操作函数
            就不赘述了；和上述一样。
        3）使用场景：
            适合于对数据结构读的次数远大于写的次数。

        3）读写锁优点：
            当读线程 多于 写线程时，可以提高数据的访问效率。

    3.条件变量
        1）条件变量的特性
            1.条件变量本身不是锁，但是依然可以造成线程阻塞；通常与互斥锁配合使用。
            
        2）一系列操作函数(拿出其中的三个特殊函数)
            int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex); 
            说明：阻塞等待一个条件变量。隐喻着在此函数调用前，数据已完成加锁操作；pthread_mutex_lock(&mutex)。
            该函数有三步：
                1）阻塞等待条件 cond 满足;
                2) 条件未满足时，解锁已经获得的锁。
                3）当条件满足时，被唤醒，接触阻塞再次尝试加锁互斥量。为一个原子操作。

            int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
            说明：指定时间后尝试调用该函数。符合条件则运行；不符合条件，不阻塞，返回错误号。
            参数三：绝对时间。

            int pthread_cond_signal(pthread_cond_t *cond);
            唤醒至少一个阻塞在条件变量上的线程。（实际上也就只唤醒一个，但是man手册中，没有这样写）
            int pthread_cond_broadcast(pthread_cond_t *cond);
            唤醒全部阻塞在该条件变量上的线程。

        3）生产者、消费者模型
                生产者线程：
                消费者线程：
                公共区（共享资源）：
                对公共区添加条件变量，互斥锁，对数据加以保护。
        
        4）条件变量的优点：
            相较于直接使用互斥量，使用它只有当条件满足时，各线程才会竞争，提高了程序间的效率。

    4.信号量 -------》本质：结构体。
        1）特性：
                1.进化版的互斥锁。。（1-> N）;
                "2.信号量的初值，决定了占用信号量的线程的个数。    "
        2）一系列操作函数
            1）int sem_init(sem_t *sem, int pshared, unsigned int value);
                说明：初始化一个信号量
                参数一：信号量的指针。
                参数二：pshared 取0用于线程间,取非0 用于进程间.
                "参数三：信号量的初值。"
            2）int sem_destroy(sem_t *sem);
                说明：销毁一个信号量
            3）int sem_wait(sem_t *sem);        （类比pthread_mutex_lock()）;
                说明：信号量加锁--。
                详细：信号量大于0，则信号量--；  信号量等于0，则线程阻塞等待。
            4) int sem_post(sem_t *sem);        （类比pthread_mutex_unlock()）;
                说明：信号量解锁++；
                详细：信号量小于最大值，则信号量++；信号量等于最大值，则线程阻塞等待。
            5）int sem_trywait(sem_t *sem);
                说明：信号量尝试加锁，不阻塞。
            6）int sem_timedwait(sem_t *sem, const struct timespec *abc_timeout);
                说明：指定时间后尝试对信号量加锁，成功则运行，不成功，返回错误号，不阻塞。
                参数二：绝对时间。
                例子：定时1秒； time_t cur = time(NULL);    //获取当前时间。
                                struct timespec t_time;        //定义结构体变量
                                t_time.tv_sec = cur + 1;    //定时1秒
                                t_time.tv_nsec = 0;
                                sem_timedwait(&sem, &t_time);
                                
        3）生产者、消费者模型

三。进程间同步
    1.信号量
        1.
    2.互斥量(mutex)
        1.进程间也可以使用互斥锁，来达到同步的目的。但是在初始化之前，应该修改一下其属性。
        2.属性修改函数：
            pthread_mutexattr_t mattr 类型;        用于定义mutex锁的 属性。
            int pthread_mutexattr_init(pthread_mutexattr_t *mattr)  函数；    初始化一个mutex属性对象;
            int pthread_mutexattr_destroy(pthread_mutexattr_t *mattr)    函数；     销毁mutex属性对象，（非销毁锁）;
            int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);    修改mutex属性。
            参数二：pshared取值：
                线程锁：PTHREAD_PROCESS_PRIVATE （mutex 的默认属性即为线性锁，进程间私有）
                进程锁：PTHREAD_PROCESS_SHARED 

    3.文件锁
        int fcntl(int fildes, int cmd, ...);函数；
        参数一：文件描述符；
        参数二：
                F_SETLK(struct flock*) 设置文件锁 (trylock);;
                F_SETLKW(struct flock*)设置文件锁 (lock)W -->wait;
                F_GETLK(struct flock*) 获取文件锁  ;

        参数三：struct flock 结构体内容;
                1）l_type:  锁的类型： F_RDLCK(读锁);  F_WRLCK(写锁);  F_UNLCK(解锁);
                2）l_whence:偏移位置：SEEK_SET;  SEEK_CUR;  SEEK_END;
                3) l_start: 起始偏移：
                4) l_len:    长度 ； 0 表示整个文件加锁。
                5）l_pid;    持有该锁的进程ID；  仅限F_GETLK中使用。 


"===线程========================================================================================================================"


"===网络编程========================================================================================================================"


"===网络编程之理论基础========================================================================================================================"

一。协议概念
    1.协议：

    2.典型协议：
        传输层：     常见协议：TCP / UDP;
        应用层：     常见协议：HTTP; FTP;
        网络层：     常见协议：IP; ICMP; IGMP;
        网络接口层：常见协议：ARP; RARP;

        ARP协议:正向地址解析协议，通过已知的IP，寻找对应主机的MAC地址。
        RARP协议：反向地址转换协议，通过MAC地址确定IP地址。
        FTP :文件传输协议
        TCP :传输控制协议；是一种面向连接的、可靠的、基于字节流的传输层通信协议。
        UDP：用户控制协议，是OSI参考模型中一种无连接的传输层协议，提供面向事物的简单不可靠信息传送服务。
        IP：因特网互联协议
        HTTP：超文本传输协议，是互联网上应用最广泛的一种网络协议。
        ICMP：Internet控制报文协议，是TCP／Ip协议族的一个子协议，用于IP主机和路由器之间传递消息。
        IGMP：Internet组管理协议，运行在主机和组播路由器之间。

二。B/S ; C/S 模型结构【即网络应用层设计模式】
    1.C/S模型：（客户机/服务器模式）
        如：实际应用：QQ； 
        两个数据端：客户端（client）/服务器（server）; 
        该模型的优点：
                1.缓存数据到本机，提高通信效率。
                2.协议的选择灵活。-------自定义协议，或者对现有协议进行裁剪。
        该模型的缺点：
                1.对用户而言，安全性较低（因为在用户端安装了应用程序（即客户端））。
                2.开发量大。
                3.受操作平台限制。
        使用场景：
                1.当需要自定义协议
                2.对数据要求高。

    2.B/S模型：（浏览器/服务器模式）
        借助浏览器完成通信，用户不需要在主机上安装应用程序。如（当年的偷菜游戏，即网页游戏。）
        该模型的优点：
                1.不受操作平台限制；
                2.开发量小

        该模型的缺点：
                1.因为数据不能缓存到本地，所以大型的网络游戏不能使用。
                2.协议选择相对来说不太灵活。（浏览器的开发要求必须满足）。

        使用场景：
                1.对数据要求不太高，
                2.跨平台方便的


三。分层模型"【重点， 必须掌握】"
    1.OSI 七层模型
        物数网传会表应：【物理层、数据链路层、网络层、传输层、会话层、表示层、应用层。】

    2.TCP/IP 4层模型
        网网传应:【网络接口层（由物理层和数据链路层组成，也有人叫做数据链路层）、网络层、传输层 、应用层】。
        4层模型与7层模型，互相对应。
        网络接口层协议：ARP协议和RARP协议。        网络层协议：IP协议、ICMP协议、IGMP协议。
        传输层协议：TCP/UDP协议（主要是这两种）；   应用层协议：HTTP协议、 FTP协议。
        TCP 是一种面向连接的、可靠的协议，有点像打电话。也就是说TCP传输的双方首先要建立联接，之后由TCP协议保证数据收发的可靠性，数据包丢失重发。
        UDP是无连接的传输协议，不保证可靠性，有点像寄信。使用UDP协议的应用程序需要自己完成丢包重发、消息排序等工作。

四。协议格式
    1.数据包的封装【网络环境中数据通信过程】。
        1)（（（（（数据）应用层）传输层）网络层）数据链路层）； 
        数据包装完后，才可以在网络上进行传输;

        2）传输层及其以下由内核控制，应用层由用户控制。不同主机之间，数据在网络中的发送，应用层数据通过协议栈发到网络上时，每层协议都要加上一个数据首部，称为封装。

    2.以太网帧格式：
        ARP数据报格式；  借助 IP----》获取mac地址。
        目的地址，源地址，类型， 数据， CPC（校验码）。
        其中 源地址和目的地址是 网卡的硬件地址（即MAC地址），长度是48位；

        2）以太网帧中数据长度最小为46字节，最大为1500字节。


    2.IP段格式
        4位首部长度， 4位版本号， 16位总长度， 8位TTL（记录数据包的跳数）， 32位源IP， 32位目的IP。
        

    3.TCP数据包格式：（面向连接的，复杂）
        16位源端口号， 16位目的端口号。 4位首部长度，6位标志位； 16位窗口大小； 32位序号； 32位确认序号。

    4.UDP数据包格式     （无连接的）
        16位源端口号； 16位目的端口号。  最大包括：2^16 = 65535;
        端口号：在一台主机上唯一标识一个进程。    != pid; 应用与网络
        IP地址：在网络中唯一标识一台主机。
        IP地址+端口号； 在网络环境中唯一标识一个进程。------》socket

        HTTP 服务默认 TCP 协议的 80 端口； 
        FTP 服务默认 TCP协议的 21 端口；
        TFTP 协议默认 TCP协议的 69 端口。  
        
    5.NET映射机制：映射表
        1.私有IP：仅在局域网有效。        （允许重复）
        2.公网IP：在整个网络环境可见。    （不允许重复，即冲突）
        3.路由器内部，NAT映射表。借助私有IP和端口号 -------- 共有IP和标号。

    6.打洞机制：
        借助 公网服务器， 将两台私有IP的主机，直接相连，完成数据的直接传递。

五。TCP 的3次握手建立连接、4次握手断开连接。"【重点】"
    三次握手建立连接：
        主动发起连接一方，发送请求：SYN（请求建立连接）;  
        被动接受链接一方，回复：ACK(应答)，SYN（）;  
        主动发起链接一方，回复：ACK（应答，建立连接成功）；

    四次握手断开连接：
        主动关闭连接一方1： FIN
        被动关闭连接一方1： ACK
        主动关闭连接一方2： FIN
        被动关闭连接一方2： ACK

mss(最大报文长度):　与下面的MTU大小相关。
    
六。MTU概念
    MTU：最大传输单元。
        在以太网帧格式中为 1500 字节。
    （MTU - 数据报头）= mss ;
    
七。滑动窗口
    给对端提供一个发送数据的总上限值。---------》进行流量控制
    最大：65535；因为：在报头中占据16位。

八：TCP协议格式：
    16位源端口， 16位目的端口，32位序列号， 32位确认序列号， 16位窗口大小， 标志位（SYN, ACK, FIN）； 
    需要记住使用的就上面这些;
    
九。TCP状态转换图："【重点】"



十：2MSL
        1）查看：net 


十一。端口复用：

十二：半关闭：
        1）主动关闭链接一方，处于FIN_WAIT_2.  4次握手---完成两次。
        2）
"===UDP======================================"
1.UDP 协议格式
    主要针对不稳定的网络层，做传输行为。  TCP--完全弥补 97% ；UDP---完全不弥补。
    TCP 和UDP 优缺点:
        网络中TCP一次传输的多组数据路径是相同的（如果网络中的路由器没有发生变化）；
        网络中UDP一次传输的多组数据路径是不同的（导致：）。
        
        TCP：面向连接的可靠数据传输。－－－类比打电话
            优点：  1.数据传输可靠；；
                    2.稳定：数据内容稳定，流量稳定（mss, 滑动窗口），速率稳定(即线路稳定,在网络中经过相同的路由）。
            缺点：  1.效率低，开销大。
                    2.速度慢，（因为每次数据传输过去，需要对方回复）
            
            应用场景：重要文件、大文件。

        UDP：无连接的不可靠报文传递。-----类比发短信            
            优点：  1.速度快
                    2.实时性高，效率高。
            缺点：  1.数据传输不可靠。
                    2.稳定性差（每次传输的路径不一样）。

            应用场景：对实时性要求较高：视频聊天、视频电话、分屏广播。

        腾讯：开始：TCP ---后来TCP+UDP(做判断，看适合用哪种)；----后来UDP+应用层校验(不丢失数据包)--(这种方式需要自行开发应用层协议。)

2.UDP C/S 服务器模型
    比较差异
    TCP：　　三次握手建立连接－－－socket();bind(); accept();read();小写转大写；write();-----service端
                            -------socket(); connect();write(); read();
    UDP:    无需建立链接---socket(); bind(); recvfrom();

        UDP默认情况下支持 多路IO---高并发服务器。
        1.为了使支持情况更好，需要应用层自己封装校验；
        2.扩大接收端缓存区大小。使用 setsockopt();

    注意：send(), recv() 只能用于TCP链接的C/S模型。
    
3.UDP 广播

4.UDP 组播

"上课所用的分屏软件的设计思想："
server端：
    1)服务器端：截屏模块，截取本地屏幕数据。得到图片，（保证人眼的观看，需要1秒24帧）几M。
    2）降帧12帧；保证数据发送效率。
    3）选用适当的算法进行压缩。 几十KB
    4）为进一步提高效率，只将有变化、改动、坐标区域，截取，压缩，发送。

client端：
    1）每台接收的主机 有个客户端，使用和服务器端相同的端口。
    2）接收到数据后以相同的算法，逆方式解压缩。

5.本地套接字：
    IPC的一种方法：

6.常用的开源库（网络编程） 
    1.libevent
    2.libv
7.服务器压力测试开源库

8.使用软件：
    wareshark;

"===UDP======================================"




"===网络编程之理论基础========================================================================================================================"


"===网络编程之 socket(套接字) 编程========================================================================================================================"
    在网络通信中，socket通信时一定是成对出现的。 
    使用的时候必须要指定：IP和端口号 ；socket = IP+port(端口号)；

一。理论基础：
    1.网络字节序
        大端法：高位存低地址。
        小端法：高存高。（x86结构，即个人电脑；微软的主推）

        网络环境中：--------》网络字节序：大端法。
        本地环境中：--------》本机字节序：小端法。
        所以网络中传输的数据需要进行字节序转换。
        "一套操作函数：";
        uint32_t htonl(uint32_t hostlong); ----本地--转--网络-- 32； --->IP 地址

           uint16_t htons(uint16_t hostshort); ----本地--转--网络-- 16； --->port号（端口号）

           uint32_t ntohl(uint32_t netlong);  ----网络--转--本地--32；    

           uint16_t ntohs(uint16_t netshort);----网络--转--本地--16；

    2.IP地址转换
        因为本地的IP地址为字符串型，适合人类查看。
        网络上的IP为 unsigned int 型。
        str IP <-----> 网络字节序IP
        int inet_pton(int af, const char *src, void *det );
            af:      ipv4:AF_INET;
                  ipv6:AF_INET6;

            src:  网路字节序的IP地址；

            det:  用来储存转化后的IP地址。


        const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

            af:  ipv4: AF_INET;

                 ipv6: AF_INET6;

            src：网络字节序的IP地址。

            dst：用来存储转化后的IP地址。

            size： dst的大小。
            

    3.socketaddr地址结构
        定义变量： struct sockaddr_in  saddr;

        初始化：

               struct sockaddr_in {
               sa_family_t    sin_family; /* address family: AF_INET */
               in_port_t      sin_port;   /* port in network byte order */
               struct in_addr sin_addr;   /* internet address */
            };    

二。C/S模型实现的 TCP 客户端服务器程序"【重点， 必须掌握】"
    socket----套接字：
        本质：内核缓冲区（发送，接收。）
        "进行通信的时候，是成对出现的。双向全双工"

    1.创建一个套接字：
           SOCK_DGRAM --------报式协议        UDP 协议
    protocol：0 流式默认： TCP
                报式默认： UDP
    返回值：成功则指向新创建的socket的文件描述符； 失败：返回-1，设置errno.

    2.int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);绑定服务器的：IP, port（端口号）；到套接字上。
        参一：sockfd ：socket文件描述符。
        参二：构造出IP地址+端口号；(sockaddr_in 类型)
        参三：地址的长度。

    3. int listen(int sockfd, int backlog); 设置同时向服务器发起三次连接的客户端数量（注意：不是客户端链接服务器的数量）  -- 10    ;
        参一：socket函数的返回值（即socket文件描述符）
        参二：数量上限。
        注意：这个函数的作用是：指定连接数的，而不是等待客户端连接的。

    4.int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);  阻塞等待客户端发起连接请求。
        参一：socket函数的返回值（即socket文件描述符）
        参二：addr:传出参数。返回客户端的地址结构（IP、port）。
        参三：addrlen:传入、传出参数。
        返回值：返回一个新的fd,指向客户端的套接字。

    5.int connect(int sockfd, const struct aockaddr *addr, socklen_t addrlen);
        参一：socket函数的返回值（即socket文件描述符）
        参二：传入参数，指定服务器端地址信息，含IP地址和端口号。
        参三：传入参数：地址的大小。
        返回值：成功；0；失败：-1。


三。服务器、客户端封装错误处理模块。
    
    封装思想：
        将系统调用进行 浅封装；
        简化程序逻辑 ------首字母大写-------可以直接从代码编写页面进入 man page。


    read返回值：

        > 0:   返回实际读到的字节数

        == 0:  到达文件末尾。或者管道对端关闭。或者套接字对端关闭。 

        < 0 （-1）:

            1. errno == EINTR  （ ECONNABORTED 网络中）

                慢速系统调用，被信号中断。 应该设置重启。

            2. errno == EAGIAN （或 EWOULDBLOCKED） 

                待读对象设置非阻塞读，并且此刻没有数据到达。 应该设置重新读取。

            3. error
                perror();  exit();
    readn

    readline


四。多进程并发服务器
    1. 流程： socket（） bind（）  listen（） accept（） read （）  write()  close();
        详解： 1.创建套接字；  2.定义地址变量，给他赋值IP、port； 3.监听客户端连接请求。  4.在循环阻塞等待链接客户端，一旦有客户端连接成功，就创建子进程。
                5.子进程负责与客户端通信； 6.父进程 继续阻塞等待客户端的链接； 同时注册信号，回收子进程。

    2. 子进程用来跟客户端通信。―― fork() 

    3. 父进程。 监听客户端连接请求。 注册信号捕捉函数，回收子进程。

    4. while (1 ) {

        fd = accept（）

        fork();  
       }



五。多线程并发服务器
    
    1. socket（） bind（）  listen（） accept（） read （）  write()  close();
        详解：1.创建套接字； 2.定义地址变量，给他赋值IP、port； 3。监听客户端连接请求；  4.在循环中，主控线程阻塞等待客户端的链接，一旦有客户端连接成功，就创建子线程，同时分离或专门用一个子线程回收剩余的子线程。
                5.主控线程负责 继续阻塞等待客户端连接， 6.子线程负责与客户端通信。

    2. 子线程用来跟客户端通信。―― pthread_create();

    3. 主线程。  监听客户端连接请求。 子线程1 ：pthread_join（）； pthread_detach();---修改线程。

    4. 客户端通信---小写--大写： 子线程的主控函数。

六：多路I／O转接

    １.select【*】
        1）一组函数

        2）监听、转换，实现方法、思想

        3）建立流程： socket()  setsockopt()  bing()  listen()  fd_set集合的赋值  select()  FD_ISSET()
            accept()   符合条件的描述符通信。

    2.poll
        1）一组函数
        2）监听、转换，实现方法、思想
        3）区别poll、select比较，优缺点；

    3.epoll【**】
        1）一组函数
        2）监听、转换，实现方法、思想
        3）区别poll、select、epoll比较，优缺点；;

七。epoll多路IO转接模型
    1.设置突破1024文件描述符限制
    2.epoll操作函数
        epoll_create();
        epoll_ctl();
        epoll_wait();
    3.epoll实现多路IO转接模型；
八.epoll


"===网络编程之 socket 编程========================================================================================================================"


"===网络编程========================================================================================================================"

 

　AF_INET 和 PF_INET 的区别：

　
　　在写网络程序的时候，建立TCP socket：
   sock = socket(PF_INET, SOCK_STREAM, 0);
然后在绑定本地地址或连接远程地址时需要初始化sockaddr_in结构，其中指定address family时一般设置为AF_INET，即使用IP。
相关头文件中的定义：AF = Address Family
                    PF = Protocol Family
                    AF_INET = PF_INET
在windows中的Winsock2.h中，
                    #define AF_INET 0
                    #define PF_INET AF_INET
所以在windows中AF_INET与PF_INET完全一样. 

    而在Unix/Linux系统中，在不同的版本中这两者有微小差别.对于BSD,是AF,对于POSIX是PF.
    理论上建立socket时是指定协议，应该用PF_xxxx，设置地址时应该用AF_xxxx。当然AF_INET和PF_INET的值是相同的，混用也不会有太大的问题。也就是说你socket时候用PF_xxxx，设置的时候用AF_xxxx也是没关系的，这点随便找个TCPIP例子就可以验证出来了。如下，不论是AF_INET还是PF_INET都是可行的，只不过这样子的话，有点不符合规范。
[cpp] view plaincopy 
/* 服务器端开始建立socket描述符 */  
/ if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)   
if((sockfd=socket(PF_INET,SOCK_STREAM,0))==-1)   
{  
fprintf(stderr,"Socket error:%s\n\a",strerror(errno));  
exit(1);  
}  
  
/* 服务器端填充 sockaddr结构 */   
bzero(&server_addr,sizeof(struct sockaddr_in));  
server_addr.sin_family=AF_INET;  
//server_addr.sin_family=PF_INET;  
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);  
server_addr.sin_port=htons(portnumber);  


 在函数socketpair与socket的domain参数中有AF_UNIX,AF_LOCAL,AF_INET,PF_UNIX,PF_LOCAL,PF_INET.
 这几个参数有AF_UNIX=AF_LOCAL, PF_UNIX=PF_LOCAL, AF_LOCAL=PF_LOCAL, AF_INET=PF_INET.
 但是对于socketpair与socket的domain参数,使用PF_LOCAL系列,
 而在初始化套接口地址结构时,则使用AF_LOCAL.
 例如:
     z = socket(PF_LOCAL, SOCK_STREAM, 0);
     adr_unix.sin_family = AF_LOCAL;