UNIX环境高级编程读书笔记

第1章UNIX基础知识

每个程序都会有唯一的数字标识符，称为进程ID，进程ID总是一个非负整数

getpid会返回一个pid_t的数据类型，pid_t最大数据范围是长整型

fork对父进程返回新的子进程的ID（一个非负整数），对子进程返回0.因为fork创建一个进程，所以说它被调用一次，但返回两次（分别在父子进程中）

与进程相同，线程也用ID表示，但线程ID只在它所属的线程内起作用。一个进程中的线程ID在另一个进程中没有意义

用户ID和组ID：通常每一个用户都有唯一一个用户ID

信号：用于通知进程发生某种状态，进程有以下三种处理信号方式

• 忽略信号：对信号不做处理，假装看不见
• 按系统默认方式处理，对于除以0系统默认方式是终止进程
• 捕捉信号：捕捉响应的信号，进行函数处理。

文件描述符和文件指针区分
文件描述符：在linux系统中打开文件就会获得文件描述符，它是个很小的正整数。每个进程在PCB（Process Control Block）中保存着一份文件描述符表，文件描述符就是这个表的索引，每个表项都有一个指向已打开文件的指针。

文件指针：C语言中使用文件指针做为I/O的句柄。文件指针指向进程用户区中的一个被称为FILE结构的数据结构。FILE结构包括一个缓冲区和一个文件描述符。而文件描述符是文件描述符表的一个索引，因此从某种意义上说文件指针就是句柄的句柄（在Windows系统上，文件描述符被称作文件句柄）。

第三章文件I/O

文件描述符0与进程的标准输入关联，文件描述符1与进程输出相关联，文件描述符2与进程的标准错误输出相关联
open函数
lseek函数
write函数
read函数
dup2和dup函数都可以复制一个现有的文件描述符

#include <unistd.h>
int dup(int oldfd);
int dup2(int oldfd, int newfd);

dup函数用来复制参数oldfd所指的文件描述符。当复制成功是，返回最小的尚未被使用过的文件描述符，若有错误则返回-1.错误代码存入errno中返回的新文件描述符和参数oldfd指向同一个文件，这两个描述符共享同一个数据结构，共享所有的锁定，读写指针和各项全现或标志位。

dup2函数，dup2与dup区别是dup2可以用参数newfd指定新文件描述符的数值。若参数newfd已经被程序使用，则系统就会将newfd所指的文件关闭，若newfd等于oldfd，则返回newfd,而不关闭newfd所指的文件。dup2所复制的文件描述符与原来的文件描述符共享各种文件状态。共享所有的锁定，读写位置和各项权限或flags等。

funcl函数可以改变文件打开的属性

第八章进程控制

每个进程都有一个非负数整型表示的唯一进程ID
系统中有一些专用进程，ID为0的进程通常是调度进程，常常被称为交换进程。进程ID 1通常是init进程，init进程决不会终止，它是一个普通的用户进程，但它以一个超级用户特权运行。

  pid_t getpid(void); //返回值：调用进程的ID
   pid_t getppid(void);//返回值：调用进程的父进程ID
   uid_t getuid(void) //返回值：调用进程的实际用户ID
   uid_t geteuid(void) //返回值：调用进程的有效用户ID
   gid_t getgid(void) //返回值：调用进程的实际组ID
   gid_t getegid(void) //返回值：调用进程的有效组ID

进程控制块（pcb）中包含：进程标识pid 进程用户 进程状态、优先级 文件描述符表等信息

进程分类
交互进程：由一个shell启动的进程。交互进程既可以在前台运行，也可以在后台运行。
批处理进程：这种进程和终端没有联系，是一个进程序列。
监控进程（也称守护进程）：Linux系统启动时启动的进程，并在后台运行。

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h> 
#include<stdlib.h>
int globvar = 6;
char buf[] = "a write to stdout\n";
int main(){
    int var;
    pid_t pid;
    var = 88;
    if(write(STDOUT_FILENO,buf,sizeof(buf)-1) != sizeof(buf)-1){
        exit(1);
    }
    printf("before fork\n");
    if((pid = fork())< 0){
        perror("fork");
    }else if(pid == 0){
        globvar++;
        var++;
    }else{
        sleep(2);
    }
    printf("pid = %ld, glob = %d,var = %d\n",(long)getpid(),globvar,var);
    exit(0);
}

输出

如果去掉before fork的回车

或者不去掉回车但输出到文件里

原因：write函数是不带缓冲的。因为在fork之前调用write,所以其数据写到标准输出一次。但是，标准I/O函数库是带缓冲的。如果标准输出连到终端设备，则它是行缓冲；否则它是全缓冲的，当以交互方式运行程序时，只得到该printf输出的行一次，其原因是标准输出缓冲区有换行符冲洗，但是当将标准输出重定向一个文件时，却得到printf输出两行，其原因是，在fork之前调用一次printf一次，但当调用fork时，该行数据仍在缓冲区中，此时父进程和子进程各自有了带有该行内容的缓冲区。在exit之前的第二个printf将其数据追加到已有缓冲区中。当进程终止时，其缓冲区中的内容都被写到相应文件中。

关于上述缓冲区问题（原文）

什么是缓冲区

缓冲区又称为缓存，它是内存空间的一部分。也就是说，在内存空间中预留了一定的存储空间，这些存储空间用来缓冲输入或输出的数据，这部分预留的空间就叫做缓冲区。缓冲区根据其对应的是输入设备还是输出设备，分为输入缓冲区和输出缓冲区。

为什么要引入缓冲区

我们为什么要引入缓冲区呢？

比如我们从磁盘里取信息，我们先把读出的数据放在缓冲区，计算机再直接从缓冲区中取数据，等缓冲区的数据取完后再去磁盘中读取，这样就可以减少磁盘的读写次数，再加上计算机对缓冲区的操作大大快于对磁盘的操作，故应用缓冲区可大大提高计算机的运行速度。

又比如，我们使用打印机打印文档，由于打印机的打印速度相对较慢，我们先把文档输出到打印机相应的缓冲区，打印机再自行逐步打印，这时我们的CPU可以处理别的事情。现在您基本明白了吧，缓冲区就是一块内存区，它用在输入输出设备和CPU之间，用来缓存数据。它使得低速的输入输出设备和高速的CPU能够协调工作，避免低速的输入输出设备占用CPU，解放出CPU，使其能够高效率工作。

缓冲区的类型

缓冲区 分为三种类型：全缓冲、行缓冲和不带缓冲。

1、全缓冲

在这种情况下，当填满标准I/O缓存后才进行实际I/O操作。全缓冲的典型代表是对磁盘文件的读写。

2、行缓冲

在这种情况下，当在输入和输出中遇到换行符时，执行真正的I/O操作。这时，我们输入的字符先存放在缓冲区，等按下回车键换行时才进行实际的I/O操作。典型代表是键盘输入数据。

3、不带缓冲

也就是不进行缓冲，标准出错情况stderr是典型代表，这使得出错信息可以直接尽快地显示出来。
缓冲区的刷新

下列情况会引发缓冲区的刷新:

1、缓冲区满时；

2、执行flush语句；

3、执行endl语句；

4、关闭文件。

可见，缓冲区满或关闭文件时都会刷新缓冲区，进行真正的I/O操作。另外，在C++中，我们可以使用flush函数来刷新缓冲区（执行I/O操作并清空缓冲区），如：cout << flush; //将显存的内容立即输出到显示器上进行显示

endl控制符的作用是将光标移动到输出设备中下一行开头处，并且清空缓冲区。

cout < < endl;

相当于

cout < < ”\n”< < flush;

文件共享
如果父进程和子进程写同一描述符所指向的文件（假定所用文件描述符是在fork之前打开）
在fork之后处理文件描述符有以下两种情况：
1）父进程等待子进程完成。在这种情况下，父进程无需对其描述符做任何处理。当子进程终止后，它曾进行读、写操作的任一共享描述符的文件偏移量已做了相应更新。
2）父进程和子进程各自执行不同程序段。在这种情况下，在fork之后，父进程和子进程各自关闭它们不需要使用的文件描述符，这样就不会干扰对方使用的文件描述符。这种方法是网络服务进程经常使用的。
exit函数和_exit函数

void exit(int status)
void _exit(int status)

结束当前进程并将status返回
exit结束进程时会刷新（流）缓冲区

exec函数
用fork函数创建子进程后，子进程往往要调用一种exec函数用以执行另一个程序，当程序调用一种exec函数时，该进程执行的程序完全替代为新程序，而新程序则从其main函数开始执行。因为调用exec函数并不是创建新进程，所以前后的进程ID并未改变。exec只是用磁盘上的一个新程序替换了当前进程的正文段、数据段、堆段和栈段。
用fork函数可以创建新进程，用exec函数可以初始执行的新程序。exit函数和wait函数处理终止和等待终止。
exec函数与system函数功能类似

头文件：
#include <unistd.h>
原型：
int execl(const char *path, const char arg, … / (char *) NULL */);
int execle(const char *path, const char arg, … /, (char *) NULL, char * const envp[] */);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);
int execlp(const char *file, const char arg, … / (char *) NULL */);
参数：
path：要执行的程序路径。可以是绝对路径或者是相对路径。在execv、execve、execl和execle这4个函数中，使用带路径名的文件名作为参数。
file：要执行的程序名称。如果该参数中包含“/”字符，则视为路径名直接执行；否则视为单独的文件名，系统将根据PATH环境变量指定的路径顺序搜索指定的文件。
argv：命令行参数的矢量数组。
envp：带有该参数的exec函数可以在调用时指定一个环境变量数组。其他不带该参数的exec函数则使用调用进程的环境变量。
arg：程序的第0个参数，即程序名自身。相当于argv[O]。
…：命令行参数列表。调用相应程序时有多少命令行参数，就需要有多少个输入参数项。注意：在使用此类函数时，在所有命令行参数的最后应该增加一个空的参数项(NULL)，表明命令行参数结束。
返回值：一1表明调用exec失败，无返回表明调用成功。

孤儿进程
孤儿进程: 父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，称为init进程领养孤儿进程。

僵尸进程
僵尸进程: 进程终止，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸（Zombie）进程。
特别注意，僵尸进程是不能使用kill命令清除掉的。因为kill命令只是用来终止进程的，而僵尸进程已经终止。思考！用什么办法可清除掉僵尸进程呢？

wait函数和waitpid函数
wait函数

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait (int * status);
成功返回会后进程的pid

参数 status 是一个整形指针。如果status不是一个空指针,则终止进程的终止状态将存储在该指针所指向的内存单元中。如果不关心终止状态,可以将 status参数设置为NULL。
status 不是NULL时子进程的结束状态值会由参数 status 返回，而子进程的进程识别码作为函数返回值返回。

调用 wait 函数时,调用进程将会出现下面的情况:
· 如果其所有子进程都还在运行,则阻塞。
· 如果一个子进程已经终止,正等待父进程获取其终止状态,则获取该子进程的终止状态然后立即返回。
· 如果没有任何子进程,则立即出错返回。
如果执行成功则返回子进程识别码（PID），如果有错误发生则返回-1。失败原因存于errno 中。

如果子进程已经终止，并且是一个僵尸进程，则wait立即返回并取得该子进程的状态，否则wait使其调用者阻塞，直到一个子进程终止。如果调用者阻塞而且它有多个子进程，则在其某个子进程终止时，wait函数就立即返回。要想处理多个僵尸进程则调用多次wait函数
waitpid函数

#include<unistd.h>
pid_t waitpid(pid_t pid, int *status,int option);

·成功时返回回收的子进程的pid或0（代表子进程未结束）；失败返回EOF
·pid可用于指定回收哪个子进程或任意进程（-1）
·status指定用于保存子进程返回值或结束方式的地址
·option指定回收方式，0（阻塞）或WNOHANG（非阻塞）

进程间通信（IPC）
Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。
在进程间完成数据传递需要借助操作系统提供特殊的方法，如：文件、管道、信号、共享内存、消息队列、套接字、命名管道等。随着计算机的蓬勃发展，一些方法由于自身设计缺陷被淘汰或者弃用。现今常用的进程间通信方式有：
① 管道 (使用最简单)
② 信号 (开销最小)
③ 共享映射区 (无血缘关系)
④ 本地套接字 (最稳定)

第十章信号

进程调度kill函数可将任意信号发送给另一个进程或进程组。自然，对此有所限制：接受信号进程和发送信号进程所有者必须相同，或发送信号进程的所有者必须是超级用户。

第十一章线程

一个进程的所有信息对该进程的所有线程是共享的，包括可执行程序的代码、程序的全局内存和堆内存、堆内存、栈以及文件描述符
进程ID在整个系统中是唯一的，但线程ID不同，线程ID只有在它所属的进程上下文中才有意义
当主线程退出时，其它线程会被终止
线程可以通过调用pthread_self函数获取自身线程ID

#include<pthread.h>
pthread_t pthread_self(void);
返回值：调用线程的线程ID

线程创建

#include<pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
成功返回0，失败时返回错误码

thread 指向线程标识符(ID)的指针。
attr 用来设置线程属性,一般为NULL
start_routine 线程运行函数的起始地址。
arg 运行函数的参数。

#include<pthread.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>

void * func(void *arg){
    int i = *(int *)arg;
    sleep(i);
    printf("%d\n",i);
    return  NULL;
}

int main(){
    pthread_t tid;
    int ret,i;
    for(i = 0; i < 3; i++){
    //最后一个参数使用地址传递时，会发生什么问题呢
        if(pthread_create(&tid,NULL,func,(void *)&i)<0){
            perror("pthread_create");
            exit(i);
        }
    }
    sleep(5);
    return 0;
}

输出结果如下，原因在于因为是地址传递所以在执行func函数时，此时地址所存储的值为3

解决方法如下：

#include<pthread.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>

void * func(void *arg){
    int i = (int)arg;
    sleep(i);
    printf("%d\n",i);
    return  NULL;
}

int main(){
    pthread_t tid;
    int ret,i;
    for(i = 0; i < 3; i++){
    //使用值传递
        if(pthread_create(&tid,NULL,func,(void *)i)<0){
            perror("pthread_create");
            exit(i);
        }
    }
    sleep(5);
    return 0;
}

线程终止
如果进程中的任意线程调用exit、_Exit或者_exit，那么整个进程就会终止

#include <pthread.h>
void pthread_exit(void *retval);
retval可被其他线程通过pthread_join获取

线程通过调用pthread_exit函数终止执行，就如同进程在结束时调用exit函数一样。
在main线程中调用pthread_exit会起到只让main线程退出，但是保留进程资源，供其他由main创建的线程使用，直至所有线程都结束，但在其他线程中不会有这种效果

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);
成功返回0，失败时返回错误码

thread要回收的线程对象ID
*retval指接受线程thread的返回值

pthread_join()函数，以阻塞的方式等待thread指定的线程结束。当函数返回时，被等待线程的资源被收回。如果线程已经结束，那么该函数会立即返回。并且thread指定的线程必须是joinable的。

#include<pthread.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>

void * func(void *arg){
    pthread_exit((void *)1);
    return  NULL;
}

int main(){
    pthread_t tid;
    int *retval;
    pthread_create(&tid,NULL,func,NULL);
    pthread_join(tid,(void **)&retval);
    printf("retval = %d",retval);
    return 0;
}

pthread_join函数与pthread_exit函数区别
pthread_join一般是主线程来调用，用来等待子线程退出，因为是等待，所以是阻塞的，一般主线程会依次join所有它创建的子线程。
pthread_exit一般是子线程调用，用来结束当前线程。
子线程可以通过pthread_exit传递一个返回值，而主线程通过pthread_join获得该返回值，从而判断该子线程的退出是正常还是异常。

线程分离

#include <pthread.h>
int pthread_detach(pthread_t tid);
成功返回0，失败设置errno

线程分离状态：指该状态、线程主动与主控线程断开关系。线程结束后，其退出状态不由其他线程获取，而直接自己自动释放。网络和多线程服务器常用。
进程若有该机制，将不会产生僵尸进程，僵尸进程的产生主要由于进程死后，大部分资源被释放，一点残余资源仍存于系统中，导致内核认为进程依然存在。
也可使用pthread_create函数参数2（线程属性）来设置线程分离。
线程销毁

int pthread_attr_destroy(pthread_attr_t *attr);

销毁一个目标结构，并且使它在重新初始化之前不能重新使用。
杀死线程

int pthread_cancel(pthread_t thread);
#include<pthread.h>
发送终止信号给thread线程，如果成功则返回0，否则为非0值。发送成功并不意味着thread会终止。

一个线程可以调用pthread_cancel终止同一进程中的另一个线程，但是值得强调的是：同一进程的线程间，pthread_cancel向另一线程发终止信号。系统并不会马上关闭被取消线程，只有在被取消线程下次系统调用时，才会真正结束线程.
线程属性设置
线程属性使用pthread_attr_t结构表示，该结构在被处理前需要对其进行初始化，在使用结束后需要销毁该结构体。可以通过pthread_attr_init()函数进行初始化，pthread_attr_destroy()函数进行销毁。
注意：应先初始化线程属性，再pthread_create创建线程。
初始化线程属性

int pthread_attr_init( pthread_attr_t *attr );
成功：0，失败错误号

typedef struct
{
int detachstate; // 线程的分离状态
int schedpolicy; // 线程调度策略
structsched_param schedparam; // 线程的调度参数
int inheritsched; // 线程的继承性
int scope; // 线程的作用域
size_t guardsize; // 线程栈末尾的警戒缓冲区大小
int stackaddr_set; // 线程的栈设置
void* stackaddr; // 线程栈的位置
size_t stacksize; // 线程栈的大小
} pthread_attr_t;

线程同步

同步机制
同步指的是多任务按照约定的先后顺序相互配合完成一件事
常见同步机制：信号量

互斥机制

临界资源：一次允许一个任务（进程、线程）访问的共享资源
临界区：访问临界区的代码
互斥机制：互斥锁：任务访问临界资源前申请锁，访问完后释放锁

互斥锁

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
如成功返回0，否则，返回错误编号
要用默认属性初始化互斥量，只需把attr设为NULL。
mutex指向要初始化的互斥锁对象
pthread_mutex_t 类型，其本质是一个结构体，为简化理解，应用时可忽略其实现可忽略其实现细节，简单当成整数看待

互斥变量用pthread_mutex_t数据类型表示，在使用互斥变量以前，必须首先对它进行初始化，可以调用pthread_mutex_init函数进行初始化，如果动态分配互斥量（例如，通过malloc函数），在释放内存前需要调用pthread_mutex_destroy

对互斥量进行加锁，需要调用pthread_mutex_lock,如果互斥量已经上锁，调用线程将阻塞直到互斥量被解锁。对互斥量解锁，需要调用pthread_mutex_unlock

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值：若成功返回0，否则返回错误编号
mutex指向要初始化的互斥锁对象
如果无法获取锁，任务阻塞

#include<pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);
若成功返回0，否则返回错误编号
mutex代表要释放的锁
执行完临界区要及时释放锁

读写锁

前面介绍的互斥量加锁要么是锁状态，要么就是不加锁状态。而且只有一次只有一个线程可以对其加锁。这样的目的是为了防止变量被不同的线程修改。但是如果有线程只是想读而不会去写的话，这有不会导致变量被修改。但是如果是互斥量加锁，则读写都没有办法。这种场景不能使用互斥量，必须使用读写锁。

读写锁可以有3种状态：

1 读模式下加锁状态
2 写模式下加锁状态
3 不加锁状态

读写锁有3个特征:

1.当读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞
2.当读写锁在读加锁状态时，再以读模式对它加锁的线程都能得到访问权，但以写模式加锁的线程将会被阻塞
3.当读写锁在读加锁状态时，如果有线程试图以写模式加锁，读写锁通常会阻塞随后的读模式加锁
一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。当读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权。但是任何希望以写模式对此锁进行加锁的线程都会阻塞。直到所有的线程释放它们的读锁为止。

读写锁非常适合于对数据结构读的次数大于写的情况。当读写锁在写模式下时，它所保护的数据结构就可以被安全地修改，因为一次只有一个线程可以在写模式下拥有这个锁。
读写锁也叫做共享互斥锁。当读写锁是读模式锁住的，就可以说是以共享模式锁住的。当它是写模式锁住的时候，就可以说成是以互斥模式锁住的。

Int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
Int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
Int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
Int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
Int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

条件变量

条件变量本身不是锁，但它也可以造成线程阻塞，通常与互斥锁配合使用。给多线程提供一个会和的场所。

pthread_cond_init(&cond, NULL); /* 动态初始化条件变量 /
pthread_cond_wait(&cond); / 等待条件变量触发 /
pthread_cond_timedwait(&cond); / 超时等待条件变量触发 /
pthread_cond_signal(&cond); / 激活一个等待该条件的线程，单播 /
pthread_cond_broadcast(&cond); / 激活所有等待该条件的线程，广播 /
pthread_cond_destroy(&cond); / 销毁条件变量 */

信号量

信号量代表一类资源，其值表示系统中的该资源的数量
信号量是一个受保护的变量，只能通过三种操作来访问
1.初始化
2.p操作（申请资源）
3.v操作（释放资源）

信号量初始化

#include<semaphore.h>
int sem_init(sem_t *sem,int pshared,unsigned int val);

成功时返回0，失败时EOF
sem 指向要初始化的信号量对象
pshared 代表使用范围，1-进程间 0-线程间
val 信号量初值

信号量的P/V操作

#include<semaphore.h>
int sem_wait(sem_t *sem) //P操作
int sem_post(sem_t *sem) //V操作

成功时返回0，失败时返回EOF
sem指向要操作的信号量对象

进程间通信
无名管道（pipe）
有名管道（fifo）
信号（signal）
共享内存（share memory）
消息队列（message queue）
信号灯集（semaphere set）
套接字（socket）
前面六种用于本地进程通信，套接字更多用于网络间通信

无名管道
无名管道特点：
1.只能用于具有亲缘关系的进程进行通信·
2.单工的通信模式，具有固定的读端和写端

#include<unistd.h>
int pipe( int pfd[2]);
成功返回0，失败返回EOF
pfd包含两个元素的整形数组，用来保存文件描述符
pfd[0]用于读管道，pfd[1]用于写管道

通过打开两个管道来创建一个双向管道
管道是阻塞性的，当进程从管道中读取数据，若没有数据，进程会阻塞
当一个进程往管道中不断地写入数据，但是没有进程去读取数据，此时只要管道是没有满是可以的，但若管道放满数据的，则会报错
读写特性
当读一个写端已经被关闭的管道时，在所有数据被读取后，read 返回 0，以表示到达了文件尾部。
如果写一个读端已被关闭的管道，则产生信号 SIGPIPE，如果忽略该信号或捕捉该信号并从处理程序返回，则 write 返回 -1，同时 errno 设置为 EPIPE
当管道只有写端没有读端时，会发生管道断裂（进程被信号结束）

有名管道
有名管道特点：
1.对应管道文件，可用于任意进程之间进行通信
2.打开管道时可指定读写方式
3.通过文件I/O操作，内容存在内存中

有名管道创建

#include<unistd.h>
#include<funcl.h>
int mkfifo(const char *path,mode_t mode);
成功返回0，失败返回EOF
path创建有名管道的路径
mode管道文件的权限如0666

当读端或写端只存在一方时，open函数会阻塞

信号机制
信号是软件层次上对中断机制的一种模拟，是一种异步的通信方式
linxu内核通过信号通知用户进程，不同的信号类型代表不同事件
进程对信号有不同的响应方式
1.缺省方式
2.忽略信号
3.捕捉信号
常用信号：


信号相关命令
kill /killall
发送信号-kill/raise

#include<unistd.h>
#include<signal.h>
int kill(pid_t pid,int sig);
int raise(int sig);

kill函数成功时返回0，失败时返回EOF
kill函数pid接受进程的进程号，0代表同组进程，-1代表所有进程
sig信号类型
raise只给在自己发信号

信号相关函数

int alarm(unsigned int seconds);
成功时返回上一个定时器的剩余时间，失败返回EOF
seconds定时器时间
一个进程中只能有一个定时器，时间到时产生SIGALRM

int pause(void);
进程一直阻塞，直到被信号中断
被信号中断后返回-1，errno为EINTR

设置信号响应方式-signal

#include<unistd.h>
#include<signal.h>
void(*signal(int signo,void(*hander)(int)))(int);
成功时返回原来的信号处理函数，失败时返回SIG_ERR
signo要设置的信号类型
hander指定的信号处理函数：SIG_DFL代表缺省方式，SIG_IGN代表忽略信号；

这里的signo代表当前进程收到的进程类型

System V IPC
IPC对象包含：共享内存、消息队列和信号灯集
每个IPC对象有唯一的ID
IPC对象创建后一直存在，直至被显式地删除
每个IPC对象有一个关联的KEY，如果KEY是0代表是私有地
ipcs查看/ipcrm删除

#include<sys/types.h>
#include<sys/ipc.h>
key_t ftok(const char *path,int proj_id);
成功时返回合法的KEY值，失败时返回EOF
path存在且可访问的文件路径
proj_id用于生成key的数字，不能是0

共享内存
linux中的两种共享内存。一种是我们的IPC通信System V版本的共享内存，另外的一种就是我们今天提到的存储映射I/O（mmap函数）。
共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝
共享内存在内核空间创建，可被进程映射到用户空间访问，使用灵活
由于多个进程可同时访问共享内存，因此需要同步和互斥机制配合使用
1.shm
共享内存使用步骤
1.创建/打开共享内存
2.映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问
3.读写共享内存
4.撤销共享内存映射
5.删除共享内存对象

共享内存创建-shmget

#include<sys/ipc.h>
#include<sys/shm.h>
int shmget(key_t key,int size,int shmflg);
成功时返回共享内存的ID，失败时返回EOF
key和共享内存关联的key，IPC_PRIVATE或ftok生成
shmflg共享内存标志位IPC_CREAT|0666
size共享内存大小

共享内存映射-shmat

#include<sys/ipc.h>
#include<sys/shm.h>
void shmat(int shmid,const void shmaddr,int shmflg);
成功时返回映射后的地址，失败返回（void*）-1
shmid要映射的共享内存id
shmaddr映射后的地址，NULL表示由系统自动映射
shmflg标志位0表示可读写，SHM_RDONLY表示只读

共享内存撤销映射-shmdt

#include<sys/ipc.h>
#include<sys/shm.h>
int shmdt(void * shmaddr);
成功时返回0，失败时返回EOF
不使用共享内存时 撤销映射·
进程结束时自动撤销

共享内存控制-shmctl

#include<sys/ipc.h>
#include<sys/shm.h>
int shmctl(int shmid,int cmd, struct shmid_ds *buf);
成功返回0，失败返回EOF
shmid要操作的共享内存id
cmd要执行操作，IPC_STAT IPC_SET IPC_RMID
buf 保存或设置 共享内存属性的地址

共享内存-注意事项
每块共享内存大小有限制
共享内存删除时间点
shmctl(shmid,IPC_RMID,NULL)添加删除标记
nattach变成0时真正删除
2.mmap
存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据，就相当于读文件中的相应字节。于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。
使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。

mmap函数

#include <sys/mman.h>
void *mmap(void *adrr, size_t length, int prot, int flags, int fd, off_t offset);
返回：成功：返回创建的映射区首地址；失败：MAP_FAILED宏
参数：
addr: 建立映射区的首地址，由Linux内核指定。使用时，直接传递NULL
length： 欲创建映射区的大小
prot： 映射区权限PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE
flags： 标志位参数(常用于设定更新物理区域、设置共享、创建匿名映射区)
MAP_SHARED: 会将映射区所做的操作反映到物理设备（磁盘）上。
MAP_PRIVATE: 映射区所做的修改不会反映到物理设备。
fd： 用来建立映射区的文件描述符
offset： 映射文件的偏移(4k的整数倍)

munmap函数

munmap函数
同malloc函数申请内存空间类似的，mmap建立的映射区在使用结束后也应调用类似free 的函数来释放。
int munmap(void *addr, size_t length); 成功：0； 失败：-1

#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>

int main(void)
{
    int fd = open("./test.txt", O_RDWR);
    char *p;
    int i;

    struct stat sbuf;
    stat("./test.txt", &sbuf);
    int len = sbuf.st_size;
    printf("len = %d\n", len);
    
    p = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
    if (p == MAP_FAILED) {
        perror("mmap error");
        exit(1);
    }

    strcpy(p, "hehehe");  //写数据
    for (i = 0; i < len; i++) {
        printf("%c", p[i]);
    }
    printf("\n");

    munmap(p, len);//释放映射
    close(fd);

    return 0;
}

注意：使用mmap时务必注意以下事项：

1. 创建映射区的过程中，隐含着一次对映射文件的读操作。
2. 当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。
3. 映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。
4. 特别注意，当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际大小！！ mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。
5. munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
6. 如果文件偏移量必须为4K的整数倍
7. mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。

mmap父子进程通信
父子等有血缘关系的进程之间也可以通过mmap建立的映射区来完成数据通信。但相应的要在创建映射区的时候指定对应的标志位参数flags：
MAP_PRIVATE: (私有映射) 父子进程各自独占映射区；
MAP_SHARED: (共享映射) 父子进程共享映射区；
结论：父子进程共享：1. 打开的文件 2. mmap建立的映射区(但必须要使用MAP_SHARED)
匿名映射
通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要open一个temp文件，创建好了再unlink、close掉，比较麻烦。 可以直接使用匿名映射来代替。其实Linux系统给我们提供了创建匿名映射区的方法，无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定。
使用MAP_ANONYMOUS (或MAP_ANON)， 如:
int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
“4"随意举例，该位置表大小，可依实际需要填写。
需注意的是，MAP_ANONYMOUS和MAP_ANON这两个宏是Linux操作系统特有的宏。在类Unix系统中如无该宏定义，可使用如下两步来完成匿名映射区的建立。
① fd = open(”/dev/zero", O_RDWR);
② p = mmap(NULL, size, PROT_READ|PROT_WRITE, MMAP_SHARED, fd, 0);
mmap无血缘关系进程间通信
实质上mmap是内核借助文件帮我们创建了一个映射区，多个进程之间利用该映射区完成数据传递。由于内核空间多进程共享，因此无血缘关系的进程间也可以使用mmap来完成通信。只要设置相应的标志位参数flags即可。若想实现共享，当然应该使用MAP_SHARED了。

网络编程

socket简介
socket
是一种编程接口
是一种特殊的文件描述符
并不局限于TCP/IP协议
面向 连接
无连接

socket类型

IP地址
IP地址分为IPV4（32位）和IPV6（128位）
端口号（16位1~65535）
为区分一台主机接收到的数据包应该转交给哪个进程来进行处理，使用端口号来区分
保留端口号：1~1023（FTP：21,SSH:22,HTTP:80,HTTPS:469）
字节序
字节序是指不同的CPU访问内存中的多字节数据时候，存在大小端问题
如CPU访问的是字符串 ，则不存在大小端问题
网络传输采用大端模式

本地字节序和网络字节序


套接字
创建套接字──socket()

int socket(int family, int type, int proto); //使用socket需要引入头文件 #include <sys/socket.h>

一般情况下，第三个参数直接选择默认值0即可，会根据前两个参数匹配默认的协议。
成功时返回文件描述符，失败返回-1，设置errno

绑定套接字──bind()

int bind(int sockfd , struct sockaddr *my_addr , int addrlen)

sockfd : 由 socket调用 返回的套接字描述符
my_addr : 一个指向与协议对应的地址结构的指针。使用时需要讲指向特定协议地址结构的指针转换位指向 sockaddr 类型的指针。
addrlen : sockaddr结构的长度
bind 函数成功时返回0，失败时返回-1

typedef uint32_t in_addr_t;　　//32位无符号整数，用于表示网络地址
struct in_addr{
in_addr_t s_addr;　　//32位 ipv4 地址
}
typedef uint16_t in_port_t;　　//16位无符号整数，用于表示端口号
struct sockaddr_in{
uint8_t sin_len;　　　　　　//结构长度，8位无符号整数
sa_family_t sin_family;　　//套接字地址族
in_port_t sin_port;　　　　//16位 TCP 或 UDP 端口号
struct in_addr sin_addr;　　//32位 ipv4 地址
char sin_zero[8];　　　　//暂时不用。总置为0
}

其他

linxu的七种文件类型
d 目录文件;
l 符号链接;
s 套接字文件；
b 块设备文件,二进制文件；
c 字符设备文件；
p 命名管道文件；
- 普通文件。
标准输入、标准输出与标准错误输出
宏定义：STDIN_FILENO、STDOUT_FILENO、STDERR_FILENO