linux知识点回顾

1.Linux对内存的结构描述
  1.1/proc/${pid}/  存放进程运行时候所有的信息(包括内存结构)
    任何程序的内存空间分成4个基本部分   
    代码区    全局栈区   堆  局部栈 
    进程查看  ps aue

2.理解程序的变量与内存空间的关系
    结论:
            1.内存分四个区.
            2.各种变量对应存放区
            3.堆栈是一种管理内存的数据结构.
            4.查看程序的内存地址.
3.理解malloc的工作的原理
                malloc使用一个数据结构(链表)维护分配空间
                链表的构成:分配的空间/上一个空间数据/下一个空间/空间大小等信息.
    对malloc分配的空间不要越界访问.因为容易破坏后台维护结构.导致malloc/free/calloc/realloc不正常工作.

    4.C++的new与malloc的关系
                    malloc    new new[] 
                    realloc   new()
                    calloc     new[]
                    free        delete  delete[]?
                结论:new的实现使用的是malloc来实现的.
                            区别:new使用malloc后,还要初始化空间.
                                基本类型,直接初始化成默认值.
                                UDT类型,调用指定的构造器
                         delete调用free实现.
                             delete负责调用析构器.然后在调用free
                new与new[]区别
                        new只调用一个构造器初始化.
                        new[]循环对每个区域调用构造器.
                delete 与delete[]
    5.函数调用栈空间的分配与释放         
                5.1.总结:
                        1.函数执行的时候有自己的临时栈.
                        2.函数的参数就在临时栈中.如果函数传递实参.则用来初始化临时参数变量.

                        3.通过积存器返回值.(使用返回值返回数据)
                        4.通过参数返回值.(参数 必须是指针)
                                    指针指向的区域必须事先分配.
                        5.如果参数返回指针.参数就是双指针.

                5.2.__stdcall __cdecl __fastcall
                        1.决定函数栈压栈的参数顺序. 
                        2.决定函数栈的清空方式
                        3.决定了函数的名字转换方式.
    2文件的属性

    1.属性的表达方式:绝对模式,字符模式
    0  0            0               0
        拥有者   组      其他用户
        0666
    2.文件的权限属性:
    读  写   执行
    粘附位权限  用户设置位权限  组设置位权限
                            0   0                   0      0       0
                        特殊权限                Owner      group   其他用户

                                s:
                                S
                                t
                                T
        2.1.  s设置位
                2:组设置位
                4:用户设置位
                    s对执行有效
                    无效的设置位使用S表示
    设置位向其他用户开放拥有者权限的权限.用户设置位
    设置位向其他用户开放组用户权限的权限.组用户设置位  
    设置位只对执行程序有意义(执行权限有意义)
    2.2.  t设置位
                        1:表示沾附位设置
                        t对写文件有意义
                        没有执行权限的沾附位使用T表示.
                        沾附的目的:防止有些权限的用户删除文件.

    程序在执行的时候到底拥有的是执行者用户的权限
                    还是文件拥有者的权限.
                        程序执行中有两个用户:
                                            实际用户
                                            有效用户                        
    总结:
    沾附位的作用: 防止其他有写权限用户删除文件
    设置位的作用: 向其他执行者开发组或者用户的权限.

    3、与进程创建有关的函数及其区别。
    int system(const char*filename);
        建立独立进程，拥有独立的代码空间,内存空间。等待新的进程执行完毕，system才返回.(阻塞)                             
    popen：创建子进程  在父子进程之间建立一个管道。
    exec系列函数: 替换当前进程的代码空间中的代码数据。
    pid_t  fork();   1.创建进程2.新进程的代码是什么:克隆父进程的代码而且克隆了执行的位置.3.在子进程不调用fork所以返回值=0;  4.父子进程同时执行。

    4进程
      1.父子进程的关系
        独立的两个程   互为父子关系；
    2.问题:
        2.1.父进程先结束?
            子进程就依托根进程init:孤儿进程
            孤儿进程没有任何危害.                         
        2.2.子进程先结束?
            子进程会成为僵死进程.
            僵死进程不占用内存,CPU.但在进程任务管理树占用一个节点.
        3  僵死进程造成进程名额资源浪费.
              所以处理僵死进程，僵死进程使用wait回收。
        4.父进程怎么知道子进程退出?
                    子进程结束通常会向父进程发送一个信号
                            SIGCHLD 
                5.父进程处理子进程退出信号
                        signal(int sig,void(*fun)(int));
                        向系统注册:只要sig信号发生,系统停止进程,并调用函数fun
                        当函数执行完毕,继续原来进程
                        5.1.实现处理函数
                        5.2.使用signal邦定信号与函数

    进程的数据交换,基于两种方式:
                内存:有序/无序:mmap
                文件:有序/无序:普通文件                   
    基于内核对象:文件.内存.队列

    5信号
    Shell 中是 kill –l  linux API中的 int kill(pid_t pid,int s)                   
    作用：通知其他进程响应。进程之间通信机制.             
    信号:接受信号的进程马上停止.调用信号处理函数.
        信号处理函数:  默认处理函数. 打印信号信息,退出进程.
                      用户处理函数. 
    可靠信号和非可靠信号    信号的屏蔽了解sigpending与 sigsuspend的使用.

    IPC:
        1.基于文件
                1.1.无序文件
                1.1.有序文件
                      1.1.1.管道
                        1.1.1.1.有名
                        1.1.1.2.匿名 
                      1.1.2.socket
        2.基于内存
                    2.1.无序内存
                            2.1.1.匿名内存
                            2.1.2.共享内存
                    2.2.有序内存
                            2.2.1.共享队列
        3.同步:基于内存IPC应用(共享内存数组) 
                信号量/信号灯

    管道文件
        1.创建管道mkfifo
            2.体会管道文件特点
        案例:                             
                fifoA               fifoB
                建立管道                        
                打开管道            打开管道
                写数据             读数据
                关闭管道            关闭管道
                删除管道

        建立管道文件:
                使用linux的指令mkfifo

        总结:
        1.read没有数据read阻塞,而且read后数据是被删除 2.数据有序
    3.打开的描述符号可以读写(two-way双工)  4.管道文件关闭后,数据不持久.
        5.管道的数据存储在内核缓冲中.
    在父子进程之间:打开文件描述后创建进程.  父子进程都有描述符号.   管道文件没有价值，
    所以在父子进程中引入一个没有名字的管道:匿名管道.
    结论:
    匿名管道只能使用在父子进程.
    基于文件的通信
            1.普通文件(io/mmap)
            2.有名管道文件
            3.匿名管道
            4.Socket
    基于内存的通信
    1.普通的父子进程之间的匿名内存共享影射        
    2.内核共享内存
        编程模型
                        2.1.创建共享内存，得到一个ID  shmget
                        2.2.把ID影射成虚拟地址(挂载)  shmat
                        2.3.使用虚拟地址访问内核共享内存 使用任何内存函数与运算符号                                                
                        2.4.卸载虚拟地址 shmdt
                        2.5.删除共享内存 shctl(修改/获取共享内存的属性)
    3内核共享队列(有序)
                    编程模型：
                            3.1.创建共享队列/得到队列msgget
                            3.2.使用队列（发送消息msgsnd/接收消息msgrcv）
                            3.3.删除队列msgctl
    网络
    2.      OSI七层                        TCP/IP
    应用层                         应用层
    表示层                  
    会话层                     
    传输层                         传输层
    网络层                         网络层
    数据链路层                     网络接口层
    物理层
    3.网络上用的是big endian（大端模式），所以有时候小端的计算机要字节序转换。
    4. Socket：
    服务器：                             客户端：
    1.创建socket（）                      1. .创建socket（）
    2.bind（）绑定IP、端口号到socket       2.设置IP，端口号
    3.设置允许最大连接  listen（）          3.connect（）连接服务器
    4.等待连接请求 accept（）              4.收发数据 write（），read（）
    5. 收发数据 read（），write（）         5.关闭网络连接
    6.关闭网络连接
    网络常用的命令：
     Ping    netstat    route   lsof
    2.TCP/UDP编程
                对等模型:AF_INET           SOCK_DGRAM       0:UDP
                C/S 模型:AF_INET      SOCK_STREAM     0:TCP






    2.1.UDP编程的数据特点
            UDP采用对等模型SOCK_DGRAM
            socket                           socket:socket
            绑定IP地址bind              连接目标(可选)        conncect
            read/recv/recvfrom               发送数据   write/send/sendto
                    关闭close 
        upd和tcp的区别
    tcp协议和udp协议的差别 
                        TCP             UDP 
    是否连接        面向连接        面向非连接 
    传输可靠性   可靠          不可靠 
    应用场合        传输大量数据  少量数据 
    速度          慢               快


    TCP服务器编程模式
            TCP的服务器端维护多个客户的网络文件描述符号.
            对服务器多个客户描述符号同时做读操作,是不可能.需要多任务模型完成.
            多任务模型?
            1.多进程
            2.IO的异步模式(select模式/poll模式)
            3.多线程模式     
            4.多进程池
            5.线程池


    TCP的服务器（在案例中使用浏览器作为客户程序）        
        socket建立服务器的文件描述符号缓冲
        bind把IP地址与端口设置到文件描述符号中
        listen负责根据客户连接的不同IP与端口，负责生成对应的文件描述符号及其信息
        accept一旦listen有新的描述符号产生就返回，否则阻塞。


    HTTP协议以及应用                                              
        1.HTTP协议版本HTTP1.0 HTTP1.1   
        2.HTTP是应用协议
        3.HTTP协议分成：
                    请求协议
                    响应协议
        4.请求协议的格式：
                请求行(请求方法 请求资源 协议版本)  
                请求体（请求头:请求值）
                空行
                数据(querystring:key=value&key=value)
        5.响应协议的格式
                响应行(协议版本 响应码 响应码的文本描述)
                响应体(响应头: 响应值)
                空行
                数据（普通数据/分块数据）

            1XX     正在处理
            2XX     响应成功200
            3XX     继续处理
            4XX     客户错误
            5XX     服务器错误
    多线程的库：
                            libpthread.so     -lpthread
    int pthread_join(
                                        pthread_t tid,//等待子线程结束
                                        void **re);//子线程结束的返回值
                        2.创建子线程后，主线程继续完成系统分配时间片。
                        3.子线程结束就是线程函数返回。
                        4.子线程与主线程有同等优先级别.
    结束线程             
            内部自动结束：（建议）
                return  返回值；(在线程函数中使用)
                void pthread_exit(void*);(在任何线程代码中使用)                       外部结束一个线程.                       
                    pthread_cancel(pthread_t)
    多线程的问题  数据脏 
    解决的办法：   互斥量（互斥锁）  mutex
    二.多线程同步
            互斥量/信号/条件量/信号量/读写锁
    1.sleep与信号                                  2.条件量
    pthread_kill向指定线程发送信号                  信号量类似  
    signal注册的是进程的信号处理函数.             2.1.定义条件量 
    pthread_kill+sigwait控制进程                 2.2.初始化条件量
            1.1.定义信号集合                      2.3.等待条件量   
            1.2.初始化信号集合                    2.4.其他线程修改条件量
            1.3.等待信号                           2.5.释放条件量
            1.4.其他线程发送信号    
            1.5.清空信号集合      
    调度算法：
    1.先来先服务
    2.短进程优先
    3.高优先级先调度（linux中-20-19，数字越小，优先级越高。Windows中想反）
    4.时间片轮转法

    死锁：A有一要二，B有二要一

    （IPC）进程间通信：目的：1.发数据。2.共享资源。3.通知事件。4.进程控制

    ping命令工作原理
    ping命令主要是用于检测网络的连通性。
    Ping命令发送一个ICMP请求报文给目的IP，然后目的IP回复一个ICMP报文。
    原理：网络上的机器都有唯一确定的IP地址，我们给目标IP地址发送一个数据包，对方就要返回一个同样大小的数据包，根据返回的数据包我们可以确定目标主机的存在，可以初步判断目标主机的操作系统等。
    因为ping命令是使用ICMP协议，所以没有端口号，但是有两个域：类型和代码。

    traceroute工作原理
    traceroute是利用ICMP及IP头部的TTL。首先，traceroute送出一个TTL是1的IP数据包（其实，每次送出的为3个40字节的包，包括源地址，目的地址和包发出的时间标签）到目的地，当路径上的第一个路由器收到IP数据包时，将TTL减1。此时，TTL变为0，所以将该路由器会将此IP数据包丢掉，并返回一个ICMP数据包（包括发IP包的源地址，IP包的所有内容及路由器的IP地址），当traceroute收到这个消息后，接着继续发生TTL为2的IP数据包给第二个路由器。以此类推，直到IP数据包达到最后一台路由器时，会返回一个ICMP echo reply的数据包。




    “多进程是立体交通系统，虽然造价高，上坡下坡多耗点油，但是不堵车。”
    -------这个适用场景是，各个进程之间通讯交互少，藕荷少，很适合多进程方式

    “多线程是平面交通系统，造价低，但红绿灯太多，老堵车。”
    -------这个原因是业务决定了，各模块间交互频繁，藕荷性高，适合多线程。