IO 进程 24/12/16

……接上文

死锁

概念：

是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去

产生死锁的原因：

1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。

4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

注意：当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

条件变量

一般和互斥锁搭配使用，用来实现线程的同步

使用步骤

1. pthread_cond_init:初始化条件变量
2. pthread_cond_wait:阻塞等待条件产生，没有条件产生时阻塞，同时解锁，当有条件产生时，结束阻塞，同时上锁。
3. pthread_cond_signal:产生条件，不阻塞

pthread_cond_wait必须先执行，pthread_cond_signal才能执行，产生条件

1. 销毁条件变量

函数接口

int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
功能：初始化条件变量
参数：cond：是一个指向结构pthread_cond_t的指针
    restrict attr：是一个指向结构pthread_condattr_t的指针，一般设为NULL
返回值：成功：0 失败：非0
 
 
int pthread_cond_wait(pthread_cond_t *restrict cond,    pthread_mutex_t *restrict mutex);
功能：等待信号的产生
参数：restrict cond：要等待的条件
     restrict mutex：对应的锁
返回值：成功：0，失败：不为0
注：当没有条件产生时函数会阻塞，同时会将锁解开；如果等待到条件产生，函数会结束阻塞同时进行上锁。


int pthread_cond_signal(pthread_cond_t *cond);
功能：给条件变量发送信号
参数：cond：条件变量值
返回值：成功：0，失败：非0
注：必须等待pthread_cond_wait函数先执行，再产生条件才可以


int pthread_cond_destroy(pthread_cond_t *cond);
功能：将条件变量销毁
参数：cond：条件变量值
返回值：成功：0， 失败：非0

练习

利用条件变量和互斥锁实现同步操作

#include <stdio.h>
#include <pthread.h>
int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
pthread_mutex_t lock;
pthread_cond_t cond;
// 打印线程
void *myprint(void *arg)
{
    while (1)
    {

        pthread_mutex_lock(&lock);   //锁住资源
        pthread_cond_wait(&cond,&lock); //没有条件产生阻塞，解锁
        for (int i = 0; i < 10; i++)
        {
            printf("%d ",a[i]);
        }
        printf("\n");
        pthread_mutex_unlock(&lock);
    }
    
}
// 倒置线程
void *myrever(void *arg)
{
    int temp;
    while (1)
    {
        sleep(1);
        //上锁
        pthread_mutex_lock(&lock);
        for (int i = 0; i < 5; i++)
        {
            temp = a[i];
            a[i] = a[9 - i];
            a[9 - i] = temp;
        }
        //产生条件
        pthread_cond_signal(&cond);
        //解锁
        pthread_mutex_unlock(&lock);


    }
}
int main(int argc, char const *argv[])
{
    //初始化互斥锁
    if(pthread_mutex_init(&lock,NULL))
    {
        printf("init_mutex err\n");
        return -1;
    }
    //初始化条件变量
    if (pthread_cond_init(&cond,NULL))
    {
        printf("init_cond err\n");
        return -1;
    }
    // 创建两个线程
    pthread_t tid1, tid2;
    if (pthread_create(&tid1, NULL, myprint, NULL))
    {
        printf("err1\n");
        return -1;
    }
    if (pthread_create(&tid2, NULL, myrever, NULL))
    {
        printf("err2\n");
        return -1;
    }
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_mutex_destroy(&lock);
     pthread_cond_destroy(&cond);
    return 0;
}

Linux/Unix平台的通信方式发展

1.早期通信方式

2.AT&T的贝尔实验室，对Unix早期的进程间通信进行了改进和扩充，形成了“system V IPC”,其通信进程主要局限在单个计算机内。IPC：InterProcess Communication

1. BSD（加州大学伯克利分校的伯克利软件发布中心），跳过了只能在同一计算机通信的限制，形成了基于套接字（socket）的进程间通信机制。

进程间的通信方式

1. 早期的进程间的通信

无名管道（pipe） 有名管道（fifo） 信号（sem）

1. system V IPC对象

共享内存（share memory） 消息队列（message queue） 信号灯集（semaphore）

1. BSD

套接字（socket）

无名管道

无名管道原理图

无名管道的特点

1. 只能用于有亲缘关系之间的进程
2. 无名管道可以看成是一种特殊的文件，对于它的读写可以使用文件IO如read、write函数.
3. 无名管道是基于文件描述符的通信方式。当一个管道建立时，它会创建两个文件描述符fd[0]和fd[1]。其中fd[0]固定用于读管道，而fd[1]固定用于写管道。
4. 半双工的通信模式，具有固定的读端和写端

（单工：只能单方向传输信息 （广播、电视）

半双工：在同一时刻，只能一个方向传输信息（对讲机）

全双工：可以双向同时传输信息（电话））

函数接口

int pipe(int fd[2])
功能：创建无名管道
参数：文件描述符 fd[0]：读端  fd[1]:写端
返回值：成功 0
      失败 -1
      
      
#include <stdio.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    int fd[2];
    //创建管道
    if (pipe(fd) < 0)
    {
        perror("pipe err");
        return -1;
    }
    //创建子进程
    
    return 0;
}

注意事项（读写特性）

1. 当管道中无数据时，读操作会阻塞；管道中无数据，将写端关闭，读操作会立即返回
2. 管道中装满（管道大小64K）数据 写阻塞，一旦有4k空间，写继续，直到写满为止

有名管道

特点

1. 有名管道可以使互不相关的两个进程互相通信。
2. 有名管道可以通过路径名来指出，并且在文件系统中可见，但内容存放在内存中。
3. 进程通过文件IO来操作有名管道
4. 有名管道遵循先进先出规则，不支持如lseek() 操作

函数接口

int mkfifo(const char *filename,mode_t mode);

`mkfifo()` 会在路径名指定的位置创建一个命名管道特殊文件。 `mode` 指定命名管道的权限。 通常会受到进程 umask 的影响：创建的文件的权限为 (`mode` & ~umask)。

功能：创建有名管道
参数：filename：有名管道文件名
       mode：权限
返回值：成功：0
       失败：-1，并设置errno号
       
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>

int main(int argc, char const *argv[])
{
    // 创建一个有名管道
    if (mkfifo("./fifo", 0666) < 0)
    {
        if (errno != EEXIST )
        {
            perror("fifo err");
            return -1;
        }
    }
    return 0;
}

注意事项（读写特性）

1. 可读可写，管道中没有数据会读阻塞。
2. 只写方式，写阻塞（open阻塞），一直到另一个进程把读打开。
3. 只读方式，读阻塞（open阻塞），一直到另一个进程把写打开。

练习

使用互不相干两个进程来完成cp功能

进程1

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>


int main(int argc, char const *argv[])
{
    char buf[32];
    ssize_t ret;
    // 创建有名管道
    if (mkfifo("./fifo",0666) < 0)
    {
        if (errno != 17)
        {
            perror("fifo err");
            return -1;
        }
    }
    printf("fifo ok\n");
    // 打开目标文件和管道文件
    int fd_src = open(argv[1], O_RDONLY);
    if (fd_src < 0)
    {
        perror("open fd_src err");
        return -1;
    }
    printf("原文件打开成功\n");
    int fd_fifo = open("./fifo", O_WRONLY);
    if (fd_fifo < 0)
    {
        perror("open fd_fifo err");
        return -1;
    }
    // 循环读写
    while (ret = read(fd_src,buf,32))
    {
        write(fd_fifo,buf,ret);
    }
    printf("复制成功\n");
    // 关闭文件描述符
    close(fd_src);
    close(fd_fifo);
    return 0;
}

进程2

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    char buf[32];
    ssize_t ret;
    //创建有名管道
    if (mkfifo("./fifo",0666) < 0)
    {
        if (errno != 17)
        {
            perror("fifo err");
            return -1;
        }
    }
    printf("fifo ok\n");
    //打开目标文件和管道文件
    int fd_dest = open(argv[1],O_WRONLY | O_CREAT | O_TRUNC,0666);
    if (fd_dest < 0)
    {
        perror("fd_dest err");
        return -1;
    }
    printf("目标文件打开成功\n");
    int fd_fifo = open("./fifo", O_RDONLY);
    if (fd_fifo < 0)
    {
        perror("open fd_fifo err");
        return -1;
    }
    //循环读写
    while (ret = read(fd_fifo,buf,32))
    {
        write(fd_dest,buf,ret);
    }
    printf("复制成功\n");
    //关闭文件描述符
    close(fd_dest);
    close(fd_fifo);
    return 0;
}

有名管道和无名管道的区别（面试题）

	无名管道	有名管道
使用场景	具有亲缘关系的进程间	不相关两个进程可以使用
特点	看做一种特殊文件，通过文件IO操作 固定读端fd[0]和写端fd[1] 不支持lseek操作，遵循先进先出	在文件系统中会存在管道文件，数据存放在内核空间 通过文件IO进行操作 不支持lseek操作，遵循先进先出
函数	pipe() 直接read、write	mkfifo() 先打开open，再读写read/write
读写特性	当管道中没有数据时，读阻塞，写端关闭，读立即返回 当管道写满数据时，写阻塞 读端关闭，往管道写数据导致管道破裂	可读可写，如果管道中没有数据，读阻塞 只写方式，写阻塞，一直到另一个进程把读打开 只读方式，读阻塞，一直到另一个进程把写打开

信号

信号的概念

1. 信号是在软件层次上对中断机制的一种模拟，是一种异步的通信方式。
2. 信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了哪些系统事件。
3. 如果该进程当前并未处于执行态，则该信号就由内核保存起来，直到该进程恢复执行再传递给它；如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞被取消时才被传递给进程。

信号的响应方式

1. 忽略信号：对信号不进行任何处理，但是有两个信号不能忽略：SIGKILL 和 SIGSTOP
2. 捕捉信号：定义信号处理函数，当信号发生时，执行相应的处理函数。但是有两个信号不能被捕捉：即SIGKILL及SIGSTOP。
3. 执行缺省操作：linux对每种信号都规定了默认操作

SIGINT：结束进程，对应快捷方式ctrl+c
SIGQUIT：退出信号，对应快捷方式ctrl+\
SIGKILL：结束进程，不能被忽略不能被捕捉
SIGALRM：闹钟信号，alarm函数设置定时，当到设定的时间时，内核会向进程发送此信号结束进程。
SIGTERM：结束终端进程，kill 使用时不加数字默认是此信号
SIGCHLD：子进程状态改变时给父进程发的信号
SIGSTOP：暂停进程，不能被忽略不能被捕捉
SIGTSTP：暂停信号，对应快捷方式ctrl+z

信号的种类

在Linux中，信号被分为不可靠信号和可靠信号，一共64种，可以通过kill -l命令来查看

• 不可靠信号：也称为非实时信号，不支持排队，信号可能会丢失，比如发送多次相同的信号，进程只能收到一次，信号值取值区间为1~31
• 可靠信号：也称为实时信号，支持排队，信号不会丢失，发多少次，就可以收到多少次，信号值取值区间为32~64

信号产生的方式有如下几种：

• 对于前台进程，用户可以输入特殊终端字符来发送，比如输入Ctrl+C
• 系统异常，比如浮点异常和非法内存段访问（段错误）
• 系统状态变化，比如alarm定时器到期时将引起SIGALRM信号
• 在终端运行kill命令或在程序中调用kill函数 kill -9 PID：杀死进程

nt kill(pid_t pid, int sig);
功能：信号发送
参数：pid：指定进程
   sig：要发送的信号
返回值：成功 0     
       失败 -1
       
int raise(int sig);
功能：进程向自己发送信号
参数：sig：信号
返回值：成功 0   
      失败 -1
      
int pause(void);
功能：用于将调用进程挂起，直到收到信号为止。

unsigned int alarm(unsigned int seconds)
功能：在进程中设置一个定时器
参数：seconds：定时时间，单位为秒
返回值：如果调用此alarm()前，进程中已经设置了闹钟时间，则
返回上一个闹钟时间的剩余时间，否则返回0。
注意：一个进程只能有一个闹钟时间。如果在调用alarm时
已设置过闹钟时间，则之前的闹钟时间被新值所代替


#include <stdio.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    printf("hello\n");
    printf("%d\n",alarm(3));
    printf("nihao\n");
    sleep(2);
    alarm(5);
    while (1);
    return 0;
}

信号处理函数

sighandler_t signal(int signum, sighandler_t handler);
功能：信号处理函数
参数：signum：要处理的信号
      handler：信号处理方式
            SIG_IGN：忽略信号
            SIG_DFL：执行默认操作
           handler：捕捉信号  void handler(int sig){} //函数名可以自定义
返回值：成功：设置之前的信号处理方式
      失败：-1
      
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
//信号处理函数
void handler(int sig)
{
    if (sig == SIGINT)
    {
        printf("ctrl C\n");
    }
    else if(sig == SIGTSTP)
    {
        printf("ctrl Z\n");
    }
}
int main(int argc, char const *argv[])
{
    //忽略信号
    //signal(SIGINT,SIG_IGN);
    //缺省
    //signal(2,SIG_DFL);
    //捕捉信号
    signal(SIGINT,handler);
    signal(SIGTSTP,handler);
    printf("hello\n");
    pause();
    printf("nihao\n");
    return 0;
}

                                                                                                                               未完待续……