IO进程、线程学习笔记

最新推荐文章于 2024-06-29 15:39:50 发布

嗯哈哈。

最新推荐文章于 2024-06-29 15:39:50 发布

阅读量54

点赞数

文章标签：学习笔记 c++

本文链接：https://blog.csdn.net/weixin_43729239/article/details/131739565

版权

【1】进程

1.概念

程序：编译好的可执行文件，存放在磁盘上的指令和数据的有序集合，是静态的，没有任何执行的概念

进程：独立的可调度的任务，是执行一个程序所分配资源的总称，是程序的一次执行过程，是动态的，包括创建、调度、执行和消亡

2、特点

1. 系统会为每一个进程分配0-4g的虚拟空间，0-3g(用户空间)是每个进程所独有的，3g-4g(内核空间)是所有进程共有的。
2. CPU调度进程时会给进程分配时间片(几毫秒~十几毫秒),当时间片用完后，cpu再进行其他进程的调度，实现进程的轮转，从而实现多任务的操作

3. 进程段

Linux中的进程包含三个段：
“数据段”存放的是全局变量、常数以及动态数据分配的数据空间(如malloc函数取得的空间)等。
“正文段”存放的是程序中的代码
“堆栈段”存放的是函数的返回地址、函数的参数以及程序中的局部变量

4. 进程分类

交互进程：该类进程是由shell控制和运行的。交互进程既可以在前台运行，也可以在后台运行。该类进程经常与用户进行交互，需要等待用户的输入，当接收到用户的输入后，该类进程会立刻响应，典型的交互式进程有：shell命令进程、文本编辑器等
批处理进程：该类进程不属于某个终端，它被提交到一个队列中以便顺序执行。
守护进程：该类进程在后台运行。它一般在Linux启动时开始执行，系统关闭时才结束。

5. 进程状态

1）运行态（TASK_RUNNING）：R
指正在被CPU运行或者就绪的状态。这样的进程被成为runnning进程。
2）睡眠态(等待态)：
可中断睡眠态（TASK_INTERRUPTIBLE）S：处于等待状态中的进程，一旦被该进程等待的资源被释放，那么该进程就会进入运行状态。
不可中断睡眠态（TASK_UNINTERRUPTIBLE）D：该状态的进程只能用wake_up()函数唤醒。
3）暂停态（TASK_STOPPED）:T
当进程收到信号SIGSTOP、SIGTSTP、SIGTTIN或SIGTTOU时就会进入暂停状态。可向其发送SIGCONT信号让进程转换到可运行状态。
4）死亡态：进程结束 X
5）僵尸态（TASK_ZOMBIE）：Z 当进程已经终止运行，但还占用系统资源，要避免僵尸态的产生

6. 进程状态切换图

进程创建后，进程进入就绪态，当CPU调度到此进程时进入运行态，当时间片用完时，此进程会进入就绪态，如果此进程正在执行一些IO操作(阻塞操作)会进入阻塞态，完成IO操作（阻塞结束）后又可进入就绪态，等待CPU的调度，当进程运行结束即进入结束态。

7. 函数接口

1.创建子进程

pid_t fork(void);
功能：创建子进程
返回值：
    成功：在父进程中：返回子进程的进程号 >0
         在子进程中：返回值为0
    失败：-1并设置errno

特点：

1）子进程几乎拷贝了父进程的全部内容。包括代码、数据、系统数据段中的pc值、栈中的数据、父进程中打开的文件等；但它们的PID、PPID是不同的。
2）父子进程有独立的地址空间，互不影响；当在相应的进程中改变全局变量、静态变量，都互不影响。
3）若父进程先结束，子进程成为孤儿进程，被init进程收养，子进程变成后台进程。
4）若子进程先结束，父进程如果没有及时回收，子进程变成僵尸进程（要避免僵尸进程产生）

总结：

1.fork之前的代码会被复制，但是不会再被执行一次，fork之后的代码会被复制，并且分别执行一遍
2.fork两个进程相互独立，子进程几乎拷贝了父进程的所有代码，但内存空间独立
3.fork之前打开的文件，fork之后拿到相同的文件描述符，操作同一个文件指针
2.回收进程资源wait waitpid

2.回收进程资源wait waitpid

pid_t wait(int *status);
功能：回收子进程资源(阻塞)
参数：status：子进程退出状态，不接受子进程状态设为NULL
返回值：成功：回收的子进程的进程号
        失败：-1
pid_t waitpid(pid_t pid, int *status, int options);
功能：回收子进程资源
参数：
    pid：>0     指定子进程进程号
         =-1   任意子进程
         =0    等待其组ID等于调用进程的组ID的任一子进程
         <-1   等待其组ID等于pid的绝对值的任一子进程
    status：子进程退出状态
    options：0：阻塞
        	WNOHANG：非阻塞
返回值：正常：结束的子进程的进程号
      当使用选项WNOHANG且没有子进程结束时：0
      出错：-1

例如：

3.结束进程

void exit(int status);
功能：结束进程，刷新缓存
参数：退出的状态
不返回。
void _exit(int status);
功能：结束进程，不刷新缓存
参数：status是一个整型的参数，可以利用这个参数传递进程结束时的状态。
    通常0表示正常结束；
其他的数值表示出现了错误，进程非正常结束

#include<stdio.h>
#include <unistd.h>     //fork头文件
#include <sys/types.h>
#include <sys/wait.h> //wait头文件
#include<stdlib.h>
void fun(int a,int b)
{
    printf("china\n");
    printf("a+b=%d\n",a+b);
    exit(0);        //结束进程，刷新缓存
   // _exit(0);     //结束进程，不刷新缓存

    return ;
}


int main(int argc, char const *argv[])
{
   
    pid_t pid=fork();   //fork之前的代码子进程会复制，但不会被执行
    if(pid<0)
    {
        perror("fork error");
    }
    else if (pid==0)    //在子进程中：返回值为0
    { 
        printf("hello\n");
        fun(3,4);
        sleep(3);
        printf("hahahahaha\n");
    }
    else     //父进程中：返回子进程的进程号 >0
    {
        printf("world\n");

        waitpid(-1,NULL,0); //通过 堵塞 回收任意子进程，当子进程回收完毕后，才能运行wait后面的代码     
        printf("ni hao\n");
    }
    
    


    return 0;
}

思考：return与exit的区别
exit：函数，不管在子函数还是主函数，都可以结束进程（进程的退出）
return：关键字，当子函数中有return时返回到函数调用位置，并不结束进程（函数的退出）

4.获取进程号

pid_t getpid(void);
功能：获取当前进程的进程号
pid_t getppid(void);
功能：获取当前进程的父进程号

#include<stdio.h>
#include <unistd.h>     //fork头文件
#include <sys/types.h>
   

int main(int argc, char const *argv[])
{
    
    pid_t pid=fork();   //fork之前的代码子进程会复制，但不会被执行
    if(pid<0)
    {
        perror("fork error");
    }
    else if (pid==0)    //在子进程中：返回值为0
    {
        //getpid获取自己的ID号  getppid获取父进程的ID号
        printf("in child  pid:%d ppid:%d\n",getpid(),getppid());    
        
    }
    else     //父进程中：返回子进程的进程号 >0
    {
        printf("in parent  pid:%d cpid:%d\n",getpid(),pid);
    }
    
    return 0;
}

8. 守护进程

1. 特点

守护进程是后台进程；生命周期比较长，从系统启动时开启，系统关闭时结束；它是脱离控制终端且周期执行的进程。

2. 步骤

1） 创建子进程，父进程退出
让子进程变成孤儿进程，成为后台进程；fork()
2） 在子进程中创建新会话
让子进程成为会话组组长，为了让子进程完全脱离终端；setsid()
3） 改变进程运行路径为根目录
原因进程运行的路径不能被删除或卸载；chdir("/")
4） 重设文件权限掩码
目的：增大进程创建文件时权限，提高灵活性；umask(0)
5） 关闭文件描述符
将不需要的文件关闭；close()

#include<stdio.h>
#include <unistd.h>     //fork头文件
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
   


int main(int argc, char const *argv[])
{
    /*1、创建子进程，父进程退出
    让子进程变成孤儿进程，成为后台进程；fork()*/

    pid_t pid=fork();   //fork之前的代码子进程会复制，但不会被执行
    if(pid<0)
    {
        perror("fork error");
        return -1;
    }
    else if (pid==0)    //在子进程中：返回值为0
    {
        /*
        2、在子进程中创建新会话
        让子进程成为会话组组长，为了让子进程完全脱离终端；setsid()
        */
        setsid();

        /* 
        3、改变进程运行路径为根目录
        原因进程运行的路径不能被删除或卸载；chdir("/")
        */
        chdir("/");

        /* 
        4、重设文件权限掩码
        目的：增大进程创建文件时权限，提高灵活性；umask(0)
        */
        umask(0);

        /*
        5、关闭文件描述符:将不需要的文件关闭；close()
        */
        for(int i=0;i<3;i++)
        {
            close(i);
        }
       
        while(1);   //让子进程成为孤儿
    }
    else     //父进程中：返回子进程的进程号 >0
    {
        exit(0); //让父进程退出
    }
    
    return 0;
}

练习：创建一个守护进程，循环间隔1s向文件中写入一串字符“hello”

#include<stdio.h>
#include <unistd.h>     //fork头文件
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>

int main(int argc, char const *argv[])
{
    //方法一：因为open写在了外面，所以可以使用当前路径
    int fd=open("./func",O_RDWR | O_CREAT | O_TRUNC,0666);
    if(fd<0)
    {
        perror("open fp error");
        return -1;
    }

    /*1、创建子进程，父进程退出
    让子进程变成孤儿进程，成为后台进程；fork()*/
    pid_t pid=fork();   //fork之前的代码子进程会复制，但不会被执行
    if(pid<0)
    {
        perror("fork error");
        return -1;
    }
    else if (pid==0)    //在子进程中：返回值为0
    {
        /*
        2、在子进程中创建新会话
        让子进程成为会话组组长，为了让子进程完全脱离终端；setsid()
        */
        setsid();

        /* 
        3、改变进程运行路径为根目录
        原因进程运行的路径不能被删除或卸载；chdir("/")
        */
        chdir("/");

        /* 
        4、重设文件权限掩码
        目的：增大进程创建文件时权限，提高灵活性；umask(0)
        */
        umask(0);

        /*
        5、关闭文件描述符:将不需要的文件关闭；close()
        */
        for(int i=0;i<3;i++)
        {
            close(i);
        }
        
        // //方法二：因为open写在了chdir("/")后面，所以要使用根目录下的路径
        // int fd=open("/temp/func",O_RDWR | O_CREAT | O_TRUNC,0666);
        // if(fd<0)
        // {
        //     printf("open fp error");
        //     return -1;
        // }

        while(1)   //让子进程成为孤儿
        {
            write(fd,"hello\n",6);
            sleep(1);
        }
    }
    else     //父进程中：返回子进程的进程号 >0
    {
        exit(0); //让父进程退出
    }
    
    close(fd);
    return 0;
}

练习一：通过父子进程完成对文件的拷贝(cp)，父进程从文件开始到文件的一半开始拷贝，子进程从文件的一半到文件末尾。要求：文件IO 命令行传参

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


int main(int argc,char const *argv[])
{
    if(argc !=3)
    {
        printf("please argv[1] argv[2]\n");
        return -1;
    }
    ssize_t s=0;
    char buf[32]={0};  
    
    //1.打开文件
    int src=open(argv[1],O_RDONLY);
    if (src<0)
    {
        perror("open src errro");
        return -1;
    }
    int dest=open(argv[2],O_WRONLY | O_CREAT | O_TRUNC ,0666);
    if(dest<0)
    {
        perror("open dest error");
        return -1;
    }
    off_t off =lseek(src,0,SEEK_END) /2;

    //2.创建父子进程
    pid_t pid=fork();
    if(pid<0)
    {
        perror("fork error");
        return -1;
    }
    else if(pid == 0)  //子进程复制后半部分/移动文件指针
    {
        lseek(src,off,SEEK_SET);
        lseek(dest,off,SEEK_SET);   //循环读写
        while((s=read(src,buf,32))!=0)
        {
            write(dest,buf,s);
        }               
    }         
    else
    {
        //父进程复制前半部分
        wait(NULL);
        
        //移动指针
        lseek(src,0,SEEK_SET);
        lseek(dest,0,SEEK_SET);
        
        //循环读写
        while ( off > 0)
        {
            if ( off > 32)
            {
                s = read(src,buf,32);
            }
            else
            {
                s =read(src,buf,off);
            }
            write(dest,buf,s);
            off -=s;    //剩下要读的字符个数
        }
    }
    
    close(src);
    close(dest);
    return 0;
}

【2】线程

1.概念

是一个轻量级的进程，为了提高系统的性能引入线程
线程和进程都参与统一的调度。

2. 进程与线程的区别

共性：都为操作系统提供了并发执行能力
不同点：
调度和资源：线程是系统调度的最小单位，进程是资源分配的最小单位
地址空间方面：同一个进程创建的多个线程共享进程的资源；进程的地址空间相互独立
通信方面：线程通信相对简单，只需要通过全局变量可以实现，但是需要考虑临界资源访问的问题；进程通信比较复杂，需要借助进程间的通信机制(借助3g-4g内核空间)
安全性方面：线程安全性差一些，当进程结束时会导致所有线程退出；进程相对安全

3. 线程资源

共享的资源：可执行的指令、静态数据、进程中打开的文件描述符、信号处理函数、当前工作目录、用户ID、用户组ID
私有的资源：线程ID (TID)、PC(程序计数器)和相关寄存器、堆栈、错误号 (errno)、信号掩码和优先级、执行状态和属性

4. 函数接口

1. 创建线程pthread_create

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
                                void *(*start_routine) (void *), void *arg);
功能：创建线程
参数：thread：线程标识
            attr：线程属性， NULL：代表设置默认属性
            start_routine：函数名：代表线程函数
            arg：用来给前面函数传参
返回值：成功：0
              失败：错误码

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

//线程函数(是一个函数指针)
void *handler(void *arg)
{ 
    printf("in pthread\n");
    sleep(1);
    pthread_exit(0);    //用于退出线程的执行   可以传0或NULL
}

int main(int argc, char const *argv[])
{
    /*
    int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
    void *(*start_routine) (void *), void *arg);
    功能：创建线程
    参数：pthread_t *thread：线程ID
        const pthread_attr_t *attr：线程属性，可以先填写NULL
        void *(*start_routine) (void *)：线程函数。定义了一个函数指针，名字叫 start_routine，参数是void*(一个指针)，
                                        这个函数的返回值是void *(一个指针）。
        void *arg:线程参数,可以填写NULL
    编译时需要链接pthread库:gcc main.c -pthread
    */

    //创建线程
    pthread_t tid;
    if(pthread_create(&tid,NULL,handler,NULL)!=0)
    {
        perror("pthread error");
        return -1;
    }
    printf("in main\n");
    //while(1);   //不让进程结束

    //阻塞回收线程  用于等待一个指定的线程结束，阻塞函数
    //当进程结束时,可以通过回收线程,来运行线程中的代码
    pthread_join(tid,NULL); 

    return 0;
}

2. 退出线程 pthread_exit

int  pthread_exit(void *value_ptr) 
功能：用于退出线程的执行
参数：value_ptr：线程退出时返回的值（任意类型）
返回值：成功 ： 0
        失败：errno

3. 回收线程pthread_join

int  pthread_join(pthread_t thread,  void **value_ptr) 
功能：用于等待一个指定的线程结束，阻塞函数
参数：thread：创建的线程对象
        value_ptr：指针*value_ptr指向线程返回的参数
返回值：成功 ： 0
       失败：errno

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

//线程函数(是一个函数指针)
void *handler(void *arg)
{ 
    printf("in pthread\n");
    sleep(1);
    pthread_exit(0);    //用于退出线程的执行   可以传0或NULL
}

int main(int argc, char const *argv[])
{

    //创建线程
    pthread_t tid;
    if(pthread_create(&tid,NULL,handler,NULL)!=0)
    {
        perror("pthread error");
        return -1;
    }
    printf("in main\n");
   
    //阻塞回收线程  用于等待一个指定的线程结束，阻塞函数
    //当进程结束时,可以通过回收线程,来运行线程中的代码
    pthread_join(tid,NULL); 

    return 0;
}

练习：通过线程实现数据的交互，主线程循环从终端输入，线程函数将数据循环输出，当输入quit结束程序。（20）

提示：1.线程通信全局变量

2. 标志位（flag），实现输入一次，打印一次

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

/*
练习：通过线程实现数据的交互，主线程循环从终端输入，线程函数将数据循环输出，当输入quit结束程序。
提示：1.线程通信全局变量
	 2.标志位（flag），实现输入一次，打印一次
*/

char buf[32]={0};
int flag=0;

//线程函数循环输出数据
void *handler(void *arg)
{  
    while(1)
    {
        if(flag==1)
        {
            
            fputs(buf,stdout);
            
            // //未处理\n
            // if(!strcmp(buf,"quit\n"))
            // {
            //     break;
            // } 

            // //处理\n
            if(!strcmp(buf,"quit"))
            {
                break;
            }
            flag=0;
        }
    } 
    pthread_exit(0);    //用于退出线程的执行   可以传0或NULL
}


int main(int argc, char const *argv[])
{
    //主线程循环从终端输入数据
    pthread_t tid;
    if(pthread_create(&tid,NULL,handler,NULL)!=0)
    {
        perror("pthread_create error");
        return -1;
    }

    while(1)
    {
        fgets(buf,32,stdin);
        flag=1; 

        // //未处理\n
        // if(!strcmp(buf,"quit\n"))
        // {
        //     break;
        // }

        //处理\n
        if (buf[strlen(buf)-1]=='\n')
        {
            buf[strlen(buf)-1]='\0';
        }
        if(!strcmp(buf,"quit"))
        {
            break;
        }      
    }
    pthread_join(tid,NULL);
    return 0;
}

【3】同步

1. 概念：

同步(synchronization)指的是多个任务(线程)按照约定的顺序相互配合完成一件事情

2. 同步机制

1. 信号量

1. 基础

通过信号量实现线程间同步。
信号量：通过信号量实现同步操作；由信号量来决定线程是继续运行还是阻塞等待
信号量代表某一类资源，其值表示系统中该资源的数量，信号量值>0，表示有资源可以用，可以申请到资源，继续执行程序，信号量值<=0，表示没有资源可以用，无法申请到资源，阻塞。
信号量是一个受保护的变量，只能通过三种操作来访问：初始化sem_init、Ｐ操作(申请资源)sem_wait、Ｖ操作(释放资源)sem_post

2. 函数

1. sem_init：初始化

int  sem_init(sem_t *sem,  int pshared,  unsigned int value)  
功能：初始化信号量   
参数：sem：初始化的信号量对象
    pshared：信号量共享的范围(0: 线程间使用   非0:1进程间使用)
    value：信号量初值
返回值：成功 0
      失败 -1

2. PV操作：sem_wait sem_post

int  sem_wait(sem_t *sem)  
功能：申请资源  P操作 
参数：sem：信号量对象
返回值：成功 0
      失败 -1
注：此函数执行过程，当信号量的值大于0时，表示有资源可以用，则继续执行，同时对信号量减1；当信号量的值等于0时，表示没有资源可以使用，函数阻塞
int  sem_post(sem_t *sem)   
功能：释放资源  V操作      
参数：sem：信号量对象
返回值：成功 0
      失败 -1
注：释放一次信号量的值加1，函数不阻塞

练习：通过线程实现数据的交互，主线程循环从终端输入，线程函数将数据循环输出，当输入quit结束程序。
提示：1.线程通信全局变量
2.通过信号量sem，实现输入一次，打印一次

#include<stdio.h>
#include <semaphore.h>

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

/*
练习：通过线程实现数据的交互，主线程循环从终端输入，线程函数将数据循环输出，当输入quit结束程序。
提示：1.线程通信全局变量
	 2.通过信号量sem，实现输入一次，打印一次
*/

char buf[32]={0};
sem_t sem;

//线程函数循环输出数据
void *handler(void *arg)
{  
    while(1)
    {
        sem_wait(&sem); //申请-1
           
        if(!strcmp(buf,"quit"))
        {
            break;
        }    
        printf("buf:%s",buf);
    } 
    pthread_exit(0);    //用于退出线程的执行   可以传0或NULL
}


int main(int argc, char const *argv[])
{
    //主线程循环从终端输入数据
    pthread_t tid;

    //信号量初始化
    if(sem_init(&sem,0,0))
    {
        perror("sem error");
        return -1;
    }
  
    if(pthread_create(&tid,NULL,handler,NULL)!=0)
    {
        perror("pthread_create error");
        return -1;
    }

    while(1)
    {
        fgets(buf,32,stdin);
        //处理\n
        if (buf[strlen(buf)-1]=='\n')
        {
            buf[strlen(buf)-1]='\0';
        }

        sem_post(&sem);     //释放+1
        if(!strcmp(buf,"quit"))
        {
            break;
        }      
    }
    pthread_join(tid,NULL);
    return 0;
}

练习：通过两个线程实现数组倒置，线程一用于循环倒置，线程二用于循环打印。用信号量实现同步，交换完成一次，打印一次

int a[10] = {0,1,2,3,4,5,6,7,8,9};

#include <stdio.h>
#include <semaphore.h>

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

/*
练习：通过两个线程实现数组倒置，线程一用于循环倒置，线程二用于循环打印。用信号量实现同步，交换完成一次，打印一次
int a[10] = {0,1,2,3,4,5,6,7,8,9};
*/

int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
sem_t sem1, sem2;

//倒置
void *invert(void *arg)
{
    int temp;
    while (1)
    {
        sem_wait(&sem2); //申请资源 -1
        for (int i = 0; i < 5; i++)
        {
            temp = a[i];
            a[i] = a[9 - i];
            a[9 - i] = temp;
        }
        sem_post(&sem1); //释放资源 +1
    }
}

//输出
void *myprintf(void *arg)
{
    while (1)
    {
        sem_wait(&sem1); //申请资源 -1
        for (int i = 0; i < 10; i++)
        {
            printf("%d ", a[i]);
        }
        sem_post(&sem2); //释放资源 -1
        printf("\n");
        sleep(1);
    }
}

int main(int argc, char const *argv[])
{
    //初始化信号量
    if (sem_init(&sem1, 0, 0)) //倒置
    {
        perror("sem1 error");
    }

    if (sem_init(&sem2, 0, 1)) //输出
    {
        perror("sem2 error");
    }

    //创建线程
    pthread_t tid1; //倒置
    if (pthread_create(&tid1, NULL, invert, NULL))
    {
        perror("tid1 error");
    }

    pthread_t tid2; //输出
    if (pthread_create(&tid2, NULL, myprintf, NULL))
    {
        perror("tid2 error");
    }

    //阻塞回收线程
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
}

【4】互斥锁

1. 概念

临界资源：一次仅允许一个进程所使用的资源
临界区：指的是一个访问共享资源的程序片段
互斥：多个线程在访问临界资源时，同一时间只能一个线程访问
互斥锁：通过互斥锁可以实现互斥机制，主要用来保护临界资源，每个临界资源都由一个互斥锁来保护，线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止。

2.函数接口

pthread_mutex_init、pthread_mutex_lock、pthread_mutex_unlock、pthread_mutex_destroy

int  pthread_mutex_init(pthread_mutex_t  *mutex, pthread_mutexattr_t *attr)  
功能：初始化互斥锁  
参数：mutex：互斥锁
    attr:  互斥锁属性  //  NULL表示缺省属性
返回值：成功 0
      失败 -1
int  pthread_mutex_lock(pthread_mutex_t *mutex)   
功能：申请互斥锁     
参数：mutex：互斥锁
返回值：成功 0
      失败 -1
注：和pthread_mutex_trylock区别：pthread_mutex_lock是阻塞的；pthread_mutex_trylock不阻塞，如果申请不到锁会立刻返回
int  pthread_mutex_unlock(pthread_mutex_t *mutex)   
功能：释放互斥锁     
参数：mutex：互斥锁
返回值：成功 0
      失败 -1
int  pthread_mutex_destroy(pthread_mutex_t  *mutex)  
功能：销毁互斥锁     
参数：mutex：互斥锁

死锁

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

死锁产生的四个必要条件：

1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。
注意：当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

【5】条件变量

1. 步骤

pthread_cond_init:初始化
pthread_cond_wait：//阻塞等待条件产生，没有条件产生时阻塞，同时解锁，当条件产生时结束阻塞，再次上锁（pthread_mutex_lock(); //上锁）
pthread_cond_wait(cond, lock); //如果没有条件产生时，解锁，当等待到条件产生时，上锁
pthread_cond_signal：产生条件，不阻塞
注意：pthread_cond_wait先执行，pthread_cond_signal再产生条件

2. 函数

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

练习：通过两个线程实现数组倒置，线程一用于循环倒置，线程二用于循环打印。用锁+条件变量实现同步，交换完成一次，打印一次
int a[10] = {0,1,2,3,4,5,6,7,8,9};

#include<stdio.h>
#include<semaphore.h>
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<string.h>

/*
练习：通过两个线程实现数组倒置，线程一用于循环倒置，线程二用于循环打印。用锁+条件实现同步，交换完成一次，打印一次
int a[10] = {0,1,2,3,4,5,6,7,8,9};
*/

//锁+条件变量完美使用倒置
int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
pthread_mutex_t lock;   //锁
pthread_cond_t cond;    //条件变量

//倒置
void *invert(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_mutex_unlock(&lock);  

        //产生条件变量
        pthread_cond_signal(&cond);
    }
}

//输出
void *myprintf(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);
    }
}

int main(int argc, char const *argv[])
{
    //初始化锁
    pthread_mutex_init(&lock,NULL);

    //初始化条件变量
    pthread_cond_init(&cond,NULL);

    //创建线程
    pthread_t tid1; //倒置
    if (pthread_create(&tid1, NULL, invert, NULL))
    {
        perror("tid1 error");
    }

    pthread_t tid2; //输出
    if (pthread_create(&tid2, NULL, myprintf, NULL))
    {
        perror("tid2 error");
    }

    //阻塞回收线程
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    //销毁锁
    pthread_mutex_destroy(&lock);       //回收线程之后才可以销毁锁
    //销毁条件变量
    pthread_cond_destroy(&cond);       //回收线程之后才可以销毁条件变量

    
    return 0;
}