精华内容
下载资源
问答
  • 2.3Linux并发程序设计[参考].pdf
  • Linux并发程序设计(1)——进程

    千次阅读 多人点赞 2020-08-07 17:47:42
    在实际设计程序中,可能这个程序不是单独的完成一个单一的功能,而是同时完成多个任务。例如QQ登录以后可以同时聊天、下载文件、听音乐等。要完成这么一个多任务的程序那么我们就需要会多进程、多线程相关知识来完成...

            在实际设计程序中,可能这个程序不是单独的完成一个单一的功能,而是同时完成多个任务。例如QQ登录以后可以同时聊天、下载文件、听音乐等。要完成这么一个多任务的程序那么我们就需要会多进程、多线程相关知识来完成一个多任务程序的设计。
    往期文章推荐:
           Shell函数的作用以及变量的作用域
           史上最全的Linux命令汇总(超全面!超详细!)收藏这一篇就够了!
    Alt

    进程的概念

           在了解进程之前我们需要了解什么是程序,程序就是存放在磁盘上的指令和数据的有序集合(文件),程序是静态的(程序编译好以后指令、数据等就不能再改变)。
           进程与程序是密切相关的,进程是操作系统为了执行一个程序分配资源的总称、是程序的一次执行过程,进程相当于程序来说是动态的,包括创建、调度、执行和消亡。当系统执行一个程序时,至少创建了一个进程

    进程内容

    在这里插入图片描述
           进程主要包括代码(正文)、用户程序、系统数据。系统数据有助于操作系统管理进程。系统数据段主要包括进程控制块(PCB Process Control Block)、CPU寄存器值、堆栈。

    系统数据段作用
    进程控制块(pcb)① 进程标识PID ② 进程用户 ③ 进程状态、优先级 ④文件描述符表
    寄存器程序计数器PC(program counter)该寄存器保存了程序下一个指令的地址
    堆栈C语言局部变量、函数的参数、返回值都是在栈上创建的

    进程类型

    • 交互进程:在Shell下启动。以在前台运行,也可以在后台运行。(后台运行给指令后加一个‘&’)
    • 批处理进程:与在终端无关,被提交到一个作业队列中以便执行
    • 守护进程:和终端没有关系,一直在后台运行

    进程的状态

    • 运行态:进程正在运行,或者准备运行
    • 等待态:进程在等待一个事件的发生某种系统资源(分为可中断和不可中断)
    • 停止态:进程被终止,收到信号后可继续运行
    • 死亡态:已终止的程序,但是pcb没有被释放
    • 进程状态图:

    Linux下进程的相关命令

    查看进程相关信息
    终端命令显示结果
    ps -ef进程所有者、进程号、父进程号、进程执行时间、程序对应名称
    ps aux相对于ps -ef还能够显示进程的当前状态(运行态、停止态、前台进程等)
    top可以查看进程动态信息(每隔3秒钟统计系统信息)能显示系统最消耗CPU资源的进程
    /proc目录查看进入该目录下可以查看进程的详细信息

    注意使用ps命令都可以配合管道命令进行筛选相关进程信息

    修改进程优先级
    命令作用
    nice按用户指定优先级运行进程
    renice改变正在运行进程的优先级

    示例:

    nice -n 2 ./test#将test进程的nice值设置为2
    
    renice -n 2 29070#将进程号为29070的nice值设置为2
    

    注意进程的nice值默认是0,范围为- 20~20,nice值越小则优先级越高。普通用户设置的nice值只能为0 ~ 20,且只能增加nice值

    前后台进程切换
    命令作用
    jobs查看后台进程(作业)
    bg将挂起的进程在后台运行
    fg把后台运行的进程放到前台运行

    进程相关函数

    创建进程——fork

    #include <unistd.h>
    pid_t fork(void);//pid_t 等价与有符号整型
    
    • 创建新的进程,失败返回-1
    • 创建成功时,父进程返回子进程的进程号,子进程返回0
    • 通过fork()的返回值来区分父子进程

    示例:

    #include<stdio.h>
    #include<unistd.h>
    
    int main()
    {
        pid_t pid;
        if((pid=fork())<0){
    	perror("fork");//创建失败,打印错误信息
    	return -1;
        }
        else if(pid==0){
    	printf("child prosess:my pid is %d\n",getpid());//创建子进程,返回子进程的pid号
        }
        else{
    	printf("parent process:my pid is %d\n",getpid());//打印父进程的进程号
        }
    }
    
    父子进程
    • 子进程继承了父进程的内容(几乎赋值了父进程的全部内容,但是pid、ppid不同)
    • 父子进程有独立的地址空间,互不影响
    • 若父进程先结束
      • 子进程成为孤儿进程,被init进程收养
      • 子进程变成后台进程
    • 若子进程先结束
      • 父进程如果没有及时回收,子进程变成僵尸进程

    注意:
           1. 子进程是从fork函数的下一条语句开始执行,并没有执行fork
           2. 内核先调用父进程就先执行父进程,先调用子进程就先执行子进程
           3. 父进程可以多次调用fork,子进程也可以调用fork创建孙进程(注意进程的回收)

    结束进程——exit/_exit/return

    #include <stdlib.h>
    #include <unistd.h>
    void exit(int status);//用stdlib.h头文件
    void _exit(int status);//用unistd.h头文件
    
    • 结束当前的进程并将status返回
    • exit结束后会刷新流的缓冲区
      示例:
    #include <stdio.h>
    #include <stdlib.h>
    int main(void)
    {
    	printf("this process will exit");//没有换行符只能写到标准输出流的缓冲区,不会在终端显示
    	exit(0);//结束进程,刷新缓冲区的流,因此上条语句会显示在终端上
    	printf("never be discovered");//不会被打印	
    }
    

    exec函数族

    作用

    • 进程调用exec函数族执行某个程序
    • 进程当前内容被指定程序替换
    • 实现父子进程执行不同程序
      • 父进程创建子进程
      • 父进程调用exec函数族
      • 父进程不受影响
    #include <unistd.h>
    int execl(const char *path,const *arg,...);//arg...传递给执行的程序的参数列表
    int execlp(const char *file,const char *arg,...);//arg...传递给执行的程序的参数列表
    
    int execv(const char *path,char *const argv[]);//arg...封装成指针数组的形式
    int execvp(const char*file,char *const argv[]);//arg...封装成指针数组的形式 
    
    • 成功时返回指定程序;失败时返回EOF
    • path执行的程序名称,包含路径
    • file执行程序的名称,在PATH中查找
    示例:
           执行ls命令,显示/etc目录下所有文件的详细信息
    方式1:execl
    if(execl("/bin/ls","ls","-a","-l","/etc",NULL)<0{//一定要以NULL结尾,并判断函数是否执行成功
    	perror("execl");
    }	
    
    方式2:execlp
    if(execl("ls","ls","-a","-l","/etc",NULL)<0{//会自动在PATH路劲搜索
    	perror("execl");
    }	
    方式3:execv
    char *arg[]={"ls","-a","-l","/etc",NULL};//将要传递的参数放在数组中
    if(execv("/bin/ls",arg)<0){
    	perror("execv");
    }
    方式3:execvp
    if(execvp("ls",arg)<0){
    	perror("execvp");//会自动在PATH路径中搜索
    }
    
    system函数
    #include <stdlib.h>
    int system(const char *command)
    
    • 成功时返回command的返回值;失败时返回EOF(自动创建一个子进程,子进程执行命令)
    • 当前进程(父进程)等待command执行结束后才继续执行。

    进程回收——wait/waitpid

    • 子进程结束时由父进程回收
    • 孤儿进程由init进程回收
    • 若孤儿进程没有回收会出现僵尸进程

    回收函数——wait:

    #include <unistd.h>
    pid_t wait(int *status);
    
    • 成功时返回回收子进程的进程号;失败时返回EOF
    • 若子进程没有结束,父进程一直阻塞
    • 若有多个子进程,那个进程先结束就先回收
    • status指定保存子进程返回值和结束方式的地址
    • status为NULL表示直接释放子进程PCB,不接收返回值

    示例:

    #include<stdio.h>
    #include<unistd.h>
    
    int main()
    {
        int status;//接收返回值以及返回方式
        pid_t pid;//接收fork的返回值
        if((pid=fork())<0){
            perror("fork");
            exit(-1);
        }
        else if(pid==0){
            sleep(1);//如果是子进程睡眠一秒
            exit(2);//退出子进程
        }
        else{
            wait(&status);//等待子进程结束
            printf("%x\n",status);//打印输出结果
        }
    }
    
    • 子进程通过exit/_exit/return返回某个值(0~255)
    • 父进程通过调用wait(&status)回收
    宏标识符作用
    WIFEXITED(status)判断子进程是否正常结束
    WEXITSTATUS(status)获得子进程的返回值
    WIFSIGNALED(status)判断子进程是否被信号结束
    WTERMSIG(status)获取结束子进程的信号类型

    回收函数——wait_pid:

    #include<unistd.h>
    pid_t waitpid(pid_t pid,int status,int option);
    
    • 成功时返回回收子进程的pid或0;失败(如:没有子线程)返回EOF
    • pid可用于指定回收那个子进程或任意子进程
    • status指定用于保存子进程的返回值和结束方式的地址
    • option指定回收方式,0(阻塞的方式,等待子进程结束)或WNOHANG(非阻塞)

    示例:

    waitpid(pid,&status,0);//指定进程的进程号,阻塞方式
    waitpid(pid,&status,WNOHABG);//子进程结束返回子进程的进程号,没有结束返回0
    waitpid(-1,&status,0);//-1表示回收任意一个子进程,等价于wait
    waitpid(-1,&status,WNOHANG);//非阻塞的方式回收任意进程
    

    守护进程

           守护进程(Daemon)是Linux三种类型之一,通常在系统启动时运行,系统结束时关闭,Linux系统中大量使用,很多服务程序就是以守护进程形式运行。
           Linux以会话(session)、进程组的方式管理进程,每个进程就属于一个进程组。而会话是一个或者多个进程组的集合。通常用户打开一个终端时,系统会创建一个临时会话,所有通过该终端运行的进程都属于这个会话。终端关闭时,所有进程会被结束。那么我们要使得守护进程与终端无关,当终端关闭的时候守护进程依旧可以运行。

    守护进程特点

    • 始终在后台运行
    • 独立于任何终端
    • 周期性的执行某种任务或等待处理特定事件

    守护进程的创建

    1. 创建子进程,父进程退出

    if(fork()>0){
    	exit(0);
    }
    
    • 子进程变成孤儿进程,被init进程收养
    • 子进程在后台运行,但是依旧和终端相关联

    2. 子进程创建新会话

    if(setsid()<0)//通过setsid创建一个新的会话
    {
    	exit(-1);
    }
    
    • 子进程成为新的会话组长
    • 子进程脱离原先的终端

    3. 更改当前工作目录

    chdir("/");
    chdir("/tmp");//所有用户可读可写可执行
    
    • 守护进程一直在后台运行,其工作目录不能被卸载
    • 重新设定当前工作目录cwd

    4. 重设文件权限掩码

    if(umask(0)<0){
    	exit(-1);
    }
    
    • 文件权限掩码设置为0
    • 只影响当前进程

    5. 关闭打开的文件描述符

    int i;
    for(i=0;i<getdtablesize();i++)//文件描述符最小就是0。getdtablesize()返回当前进程打开最大文件数
    {
    	close(i);
    }
    
    • 关闭所有从父进程继承的打开文件
    • 已脱离终端,stdin/stdout/stderr无法再使用

    示例:
           创建守护进程,没隔1秒将系统时间写入文件time.log

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <strings.h>
    #include <unistd.h>
    #include <time.h>
    
    int main()
    {
    	pid_t pid;
    	FILE *fp;
    	time_t t;
    	int i;
    
    	if((pid = fork())< 0)
    	{
    		perror("fork");
    		exit(-1);
    	}
    	if(pid > 0)
    	{
    		exit(0);
    	}
    	else if(pid == 0)
    	{
    		if(setsid()< 0)//创建一个新的会话
    		{
    			perror("setsod");
    			exit(-1);
    		}
    		else
    		{
    			chdir("/tmp");//tmp目录可读可写可执行
    			if(umask(0) < 0)//重设文件权限掩码
    			{
    				exit(-1);
    			}
    			else
    			{
    				for(i=0;i<getdtablesize();i++)
    				{
    					close(i);
    				}
    			}
    			while(1)
    			{
    				fp = fopen("time.log","a+");
    				time(&t);
    				fprintf(fp,"%s",ctime(&t));
    				fflush(fp);
    				sleep(1);
    			}
    		}
    	}
    }
    

           不积小流无以成江河,不积跬步无以至千里。而我想要成为万里羊,就必须坚持学习来获取更多知识,用知识来改变命运,用博客见证成长,用行动证明我在努力。
           如果我的博客对你有帮助、如果你喜欢我的博客内容,记得“点赞” “评论” “收藏”一键三连哦!听说点赞的人运气不会太差,每一天都会元气满满呦!如果实在要白嫖的话,那祝你开心每一天,欢迎常来我博客看看。
    在这里插入图片描述

    展开全文
  • 实验6 Linux进程并发程序设计 掌握Linux环境下的进程并发程序及管道应用程序的编写要点。
  • Linux并发程序设计(3)——Unix间通信方式

    千次阅读 多人点赞 2020-08-12 20:45:35
    但是在进程中不同的进程有不同的地址空间,那么两个进程之间如何进行通信就成了一个难题,实际中Linux有很多机制来实现两个进程间的通信。我们都知道Linux是从Unix发展来的,早期的Unix进程间通过无名管道(pipe)、...

            线程共享同一进程的地址空间,这个地址空间的代码和全局变量每个线程都可以访问,这样就使得线程的通信很容易。但是在进程中不同的进程有不同的地址空间,那么两个进程之间如何进行通信就成了一个难题,实际中Linux有很多机制来实现两个进程间的通信。
           我们都知道Linux是从Unix发展来的,早期的Unix进程间通过无名管道(pipe)、有名管道(fifo)、信号(signal)的方式进行通信。在System V中进程间通信又有共享内存(share memory)、消息队列(message queue)、信号灯级(semaphore set)的方式。在BSD Unix中进程间通信是通过套接字(socket)。以上的这些进程间通信的方式Linux都继承了下来。
    往期推荐:
           Linux并发程序设计(1)——进程
           Linux并发程序设计(2)——线程

    进程间通信概念

           每个进程各自有不同的用户地址空间,任何一个进程的全局变量在另一个进程中都看不到,所以进程之间要交换数据必须通过内核,在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信(IPC,InterProcess Communication)
    Alt

    进程间通信方式

    无名管道(pipe)

    无名管道特点:

    • 只能用于具有亲缘关系(父子进程、兄弟进程)的进程之间的通信
    • 管道是单工通信模式,具有固定的读端和写端;需要双方通信时,需要建立起两个管道。
    • 单独构成一种独立的文件系统:管道对于管道两端的进程而言,就是一个文件,但它不是普通的文件,它不属于某种文件系统,而是自立门户,单独构成一种文件系统,并且只存在与内存中。
    • 数据的读出和写入:一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾,并且每次都是从缓冲区的头部读出数据。

    无名管道的创建——pipe

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

           注意:无名管道虽然返回了两个文件描述符,但是无名管道不像普通文件具有路径,在文件系统中不可见,仅仅存在在内存中。并且无名管道是某个进程创建的,其他进程要想打开无名管道只能通过继承的方式打开其他进程创建的无名管道。因此,无名管道只能在用亲缘关系的进程间通信。
    在这里插入图片描述
           上图是父子进程通过无名管道的通信示意图,父进程创建无名管道,返回fd[0]fd[1]。虽然返回了两个文件描述符但是由于管道是一个单工的通信模式,因此一个进程只能访问一个文件描述符。例如:当父进程读管道时,就只能访问df[0],子进程只能写管道访问df[1]。
    示例:
           子进程1和子进程2分别往管道中写入字符串;父进程读取管道内容并打印。

    #include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<string.h>
    #include<sys/types.h>
    int main()
    {
        pid_t pid1,pid2;
        char buf[32];
        int pfd[2];
        if(pipe(pfd)<0){
            perror("pipe");
            exit(-1);
        }
        if((pid1=fork())<0){
            perror("fork");
            exit(-1);
        }
        else if(pid1==0)//子进程1
        {
            strcpy(buf,"I'm process1");
            write(pfd[1],buf,32);
            exit(0);
        }
        else
        {
            if((pid2=fork())<0){//子进程2
                perror("fork");
                exit(-1);
            }
            else if(pid2==0){
                sleep(1);
                strcpy(buf,"I'm process 2");
                write(pfd[1],buf,32);
                printf("%s\n",buf);
            }
        }
        return 0;
    }
    

           注意:无名管道创建时会返回两个文件描述符,普通的文件读取以后文件内容依旧存在,但是管道中的内容被读取以后内容就不存在

    无名管道的读写特性

    • 写端存在且管道中有数据时,read返回实际读取的字节数。当管道有数据时,读进程阻塞(直到管道中有数据)。
    • 写端不存在且管道中有数据时,read返回实际读取的字节数。当管道无数据时,read返回0。
    • 读端存在且管道有空间时,write返回实际写入的字节数。当管道无空间时,写进程阻塞。
    • 读端不存在不论管道是否有空间进程都会异常结束,会导致管道断裂系统不允许写一个读端不存在的进程

           根据管道的读写特性我们就可以获取管道的大小。通过循环向管道中写入数据,直到写进程阻塞,统计循环的次数就可以很容易计算出管道的大小。

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    int main()
    {
        int count=0,pfd[2];
        char buf[1024];
        if(pipe(pfd)<0)
        {
            perror("pipe");
            exit(-1);
        }
        while(1)
        {
            write(pdf[1],buf,1024);
            printf("wrote %dk byte\n",++count);
        }
        return 0;
    }
    

           通过运行以上程序发现,当count为64时不再打印数据,因此可以得出在Linux中管道的大小为64K。

    有名管道(fifo)

           无名管道,由于没有名字,只能用于亲缘关系的进程间通信。为了克服这个缺点,提出了有名管道(FIFO)。

           有名管道不同于匿名管道之处在于它提供了一个路径名与之关联,以有名管道的文件形式存在于文件系统中。这样即使与有名管道的创建进程不存在亲缘关系的进程,只要可以访问该路径,就能够彼此通过有名管道相互通信,因此,通过有名管道不相关的进程也能交换数据。
           值的注意的是,有名管道严格遵循先进先出(first in first out),对匿名管道及有名管道的读总是从开始处返回数据,对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。有名管道的名字存在于文件系统中,内容存放在内存中。

    有名管道特点:

    • 对应管道文件,可用于任意进程之间的通信
    • 打开管道时可以指定读写方式
    • 通过文件I/O操作,内容存放在内存中(读端和写端都关闭的时候,存放在内存中的数据就会被释放

    有名管道的创建——mkfifo

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

    示例:

           进程A:循环从键盘输入并写入有名管道myfifo,输入quit时退出。
           进程B:循环统计进程A每次写入myfifo的字符串的长度。

    create_fifo.c内容如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <fcntl.h>
    int main(void)
    {
        if(mkfifo("myfifo",06666)<0){
            perror("mkfifo");
            exit(-1);
        }
    
    }
    

    read_fifo.c内容如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <fcntl.h>
    #define N 32
    int main(void)
    {
        char buf[N];
        int fpd;
        if ((fpd = open("myfifo",O_WRONLY))<0)
        {
            perror("open");
            exit(-1);
        }
        printf("myfifo is opened\n");
        while(read(fpd,buf,N)>0){
            printf("thr length of string is %d\n",strlen(buf));
        }
        close(fpd);
        return 0;
    }
    

    write_fifo.c内容如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <fcntl.h>
    #define N 32
    int main(void)
    {
        char buf[N];
        int fpd;
        if ((fpd = open("myfifo",O_WRONLY))<0)
        {
            perror("open");
            exit(-1);
        }
        printf("myfifo is opened\n");
        while(1)
        {
            fgets(buf,N,stdin);
            if(strcmp(buf,"quit\n")==0)
            {
                break;
            }
            write(fpd,buf,N);
        }
        close(fpd);
        return 0;
    }
    

    注意:进程打开一个有名管道只有读端或者写端时会导致进程阻塞,只有两个都打开时程序才有意义。

    信号机制

           信号是在软件层次上对中断机制的一种模拟,是一种异步通信方式。Linux内核通过信号通知用户进程,不同的信号类型代表不同的事件。Linux中信号是对早期的unix信号机制进行了扩展。

    常用信号

    信号名含义默认操作
    SIGHUB该信号在用户终端关闭时产生,通常是发给和该终端关联的会话内所有进程终止
    SIGINT该信号在用户键入INTR字符(Ctrl+C)时产生,内核发送此信号到当前终端的所有前台进程终止
    SIGQUIT该信号和SIGINT类似,但由QUIT字符(通常是CTRL+\ \)来产生终止
    SIGILL该信号在一个进程企图执行一条非法指令时产生终止
    SIGSEV该信号在非法访问内存时产生,如野指针、缓冲区溢出终止
    SIGPIPE当进程向一个没有读端的管道中写书数据时产生,代表管道断裂终止
    SIGKILL该进程用来结束进程,并且不能被捕捉和忽略终止
    SIGSTOP该信号用于暂停进程,并且不能被捕捉和忽略暂停进程
    SIGTSTP该信号用于暂停进程,用户可以键入SUSP字符(通常是Ctrl-Z)发出这个信号暂停进程
    SIGXONT该信号让进程进入运行态继续运行
    SIGALRM该信号用于通知进程定时器时间已到终止
    SIGUSR1/2该信号保护给用户程序使用终止

    信号相关的命令kill/killall

    • kill [-signal] pid

      • 默认发送SIGTERM
      • -sig可指定信号
      • pid指定发送对象
    • killall [-u user | prog]

      • prog 指定进程名
      • user 指定用户名

    信号发送——kill/raise
    #include <unistd.h>
    #include <signal.h>
    int kill(pid_t pid,int sig);
    int raise(int sig);

    • 成功时返回0,失败时返回EOF
    • pid接收进程的进程号;0代表同组进程;-1代表所有进程
    • sig信号类型

    定时器函数——alarm/pause

    #include <unistd.h>
    #include <signal.h>
    int alarm(unsigned int seconds);
    
    • 成功时返回上个定时器的剩余时间,失败时返回EOF
    • seconds定时器的时间
    • 一个进程只能设定一个定时器,时间到时产生SIGALARM
    #include <unistd.h>
    #include <signal.h>
    int purse(void);
    
    • 进程一直阻塞,直到被信号中断
    • 被信号中断后返回-1,erron为EINTR
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    int main()
    {
    	alarm(3);//3秒后进程终止
    	pause();
    	printf("I have been waken up!\n");
    	return 0;
    }
    

           运行以上程序会发现并没有打赢printf里的内容,而是打印的是Alarm clock。这是因为3秒后定时器缺省导致进程结束进而无法继续向下执行。alarm经常用于实现超时检测

    设置信号响应方式——signal

    #include <unistd.h>
    #include <signal.h>
    void(*signal(int signo,void(*handler)(int)))(int);//第二个参数是一个函数指针,存放的是某个函数的入口地址
    
    • 成功时返回原先的信号处理函数,失败时返回SIG_ERR
    • signo要设置的信号类型
    • handler指定的信号处理函数:SIGDFL代表缺省方式;SIG_IGN代表忽略信号;
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <signal.h>
    void handler(int signo)
    {
    	if(signo==SIGINT)
    	{
    		printf("I have got SIGINT!\n");
    	}
    	if(signo==SIGQUIT)
    	{
    		printf("I have got SIGQUIT\n");
    	}
    }
    int main()
    {
    	signal(SIGINT,handler);
    	signal(SIGQUIT,handler);
    	while(1) pause();
    	return 0;
    }
    

           不积小流无以成江河,不积跬步无以至千里。而我想要成为万里羊,就必须坚持学习来获取更多知识,用知识来改变命运,用博客见证成长,用行动证明我在努力。
           如果我的博客对你有帮助、如果你喜欢我的博客内容,记得“点赞” “评论” “收藏”一键三连哦!听说点赞的人运气不会太差,每一天都会元气满满呦!如果实在要白嫖的话,那祝你开心每一天,欢迎常来我博客看看。
    在这里插入图片描述

    展开全文
  • #include<semaphore.h> int sem_post(sem_t *sem);//V操作
  • Linux操作系统与程序设计,一个并发回音服务器与客户端的设计。cpp文件和运行方式截图,包括测试截图都在里面

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 113,478
精华内容 45,391
关键字:

linux并发程序设计

linux 订阅