并发编程之一：多进程

最新推荐文章于 2018-04-23 22:06:05 发布
最新推荐文章于 2018-04-23 22:06:05 发布
阅读量464 收藏
点赞数

 多进程编程的主要内容包括进程控制和进程间通信：

一、Linux下进程控制

        在传统的Unix环境下，有两个基本的操作用于创建和修改进程：

         fork()：用来创建一个新的进程，该进程几乎是当前进程的一个完全拷贝；

         exec函数族：用来启动外部程序以取代当前的进程（由于此类函数并不是只有一个，而是六个，所以统称exec函数族）。

下面分别介绍一下：

1、 fork函数

        fork在英文中是“分叉”的意思。为什么取这个名字呢？因为一个进程在运行中，如果使用了fork，就产生了另一个进程，于是进程就“分叉”了，所以这个名字取得很形象。下面来看一下它的格式：

? 

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);
    正确返回：在父进程中返回子进程的进程号，在子进程中返回0
    错误返回：-1

      使用fork函数后，系统就会在此时新建一个进程（称为子进程）并且拷贝原有进程（称为父进程）的上下文和数据（子进程和父进程使用相同的代码段；子进程复制父进程的堆栈段和数据段。），并且利用fork函数的不同返回值（＞0表示父进程，0表示子进程，－1表示出错）来标识。这样一来，子进程就会和父进程彼此独立运行，互不干扰。下面就看看如何具体使用fork，这段程序演示了使用fork的基本框架：

? 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
 
int main(void)
{
        pid_t pid=fork();
        if(pid==0)
        {
                int j ;
                for(j=0;j<10;j++)
                {
                        printf("child: %d\n",j);
                        sleep(1);
                }
        }
        else if (pid>0)
        {
                int i;
                for(i=0;i<10;i++)
                {
                        printf("parent: %d\n",i);
                        sleep(1);
                }
        }
        else
        {
                fprintf(stderr,"can't fork ,error %d\n",errno);
                exit(1);
        }
        printf("This is the end !\n");
        return 0;
}

    运行了这段代码，我想应该可以明白fork了吧。运行的时候可以查看进程(ps -aux)，会发现有两个一样的进程，运行结束后最后一句printf会运行两次，因为每个进程都会运行一次.中间的交替就是进程的调度了。

 

 2、exec函数族

       如果想运行外部程序就要用到exec函数族，这种函数一共有六个，它们分别是：

?/* 

 * 版权声明：转载时请以超链接形式标明文章原始出处和作者信息及本声明
 * http://tuhao.blogbus.com/logs/22833492.html
*/
 
extern char **environ;
 
int execl(const char* fullpath, const char* arg, ...);
int execlp(const char* file, const char* arg, ...);
int execle(const char* fullpath, const char* arg , ..., char* const envp[]);
int execv(const char* fullpath, char* const argv[]);
int execvp(const char* file, char* const argv[]);
int execve(const char* fullpath, const char* arg[] , char* const envp[]);
 
int execl(const char* fullpath, const char* arg, ....)
使用范例：execl(“/bin/ls”, ”ls”, ”-al”, NULL)
 
int execlp(const char* file, const char* arg, ....)
使用范例：execlp(“ls”, ”ls”, ”-al”, NULL)
 
int execle(const char* fullpath, const char* arg, ...., char* const envp[])
使用范例：execle(“/bin/ls”, ”ls”, ”-al”, NULL, environ)
 
int execv(const char * fullpath, char* const argv[])
使用范例：execle(“/bin/mkdir”, argv) // int main(int argc, char* argv[])
或
char* const p[] = {"a.out", "testDir", NULL};
execv("/bin/mkdir", p);
 
int execvp(const char* file, const char* arg, ....)
使用范例：execlp(“ls”, argv) // int main(int argc, char* argv[])
或
char* const p[] = {"a.out", "testDir", NULL};
execvp("mkdir", p);
 
int execve(const char* fullpath, const char* arg, ...., char* const envp[])
使用范例：execve(“/bin/ls”, argv, environ)
或
char* const p[] = {"a.out", "testDir", NULL};
execve("/bin/mkdir", p);

 下面一段代码显示如何配合fork函数启动运行其它程序：

? 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
 
char command[256];
int main()
{
   int rtn; /*子进程的返回数值*/
   while(1) 
   {
        /* 从终端读取要执行的命令 */
        printf( ">" );
        fgets( command, 256, stdin );
        command[strlen(command)-1] = 0;
        if ( fork() == 0 ) {
            /* 子进程执行此命令 */
            execlp( command, command, NULL);
            /* 如果exec函数返回，表明没有正常执行命令，打印错误信息*/
            perror( command );
            exit(errno);
        }
        else {
            /* 父进程， 等待子进程结束，并打印子进程的返回值 */
            wait ( &rtn );
            printf( " child process return %d\n",rtn );
        }
    }
}

 二、Linux下的进程间通信

      创建一个新进程后，两个进程就会彼此独立运行，互不干扰，那么如果需要两个进程之间通信，该怎么办呢？在Unix/Linux下常用的进程间通信的方法有很多种，如管道、消息队列、共享内存、信号量、套接口等。下面我们以管道为例来介绍：

     管道是进程间通信中最古老的方式，它包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者用于运行于同一台机器上的任意两个进程间的通信。

1、（无名）管道

无名管道由pipe函数创建：

       #include <unistd.h>

       int pipe(int filedis[2]);

      参数filedis返回两个文件描述符：filedes[0]为读而打开；filedes[1]为写而打开。filedes[1]的输出是filedes[0]的输入。下面的例子示范了如何在父进程和子进程间实现通信。

#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
 
#define INPUT 0
#define OUTPUT 1
 
int main() 
{
    int file_descriptors[2];
    /*定义子进程号 */
    pid_t pid;
    char buf[256];
    int returned_count;
 
    /*创建无名管道*/
    pipe(file_descriptors);
     
    /*创建子进程*/
    if((pid = fork()) == -1) 
    {
        printf("Error in fork\n");
        exit(1);
    }
 
    /*执行子进程*/
    if(pid == 0) 
    {
        printf("in the spawned (child) process...\n");
 
        /*关闭管道的读端,并且将数据"test data"从写端写入*/
        close(file_descriptors[INPUT]);
        write(file_descriptors[OUTPUT], "test data", strlen("test data"));
        exit(0);
    }
    else
    {
        /*执行父进程*/
        printf("in the spawning (parent) process...\n");
 
        /*关闭管道的写端，父进程从管道读取子进程传来的数据*/
        close(file_descriptors[OUTPUT]);
        returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));
 
        printf("%d bytes of data received from spawned process: %s\n",
            returned_count, buf);
    }
}

2、有名管道     

在Linux系统下，有名管道可由两种方式创建：命令行方式mknod和函数mkfifo。下面的两种途径者在当前目录下生成了一个名为myfifo的有名管道：

              方式一：mknod myfifo p          //p－表示创建FIFO特殊文件

              方式二：mkfifo("myfifo", "rw")  //rw表示读、写两种权限

      生成了有名管道后，就可以使用一般的文件I/O函数如open、close、read、write等来对它进行操作。下面是一个简单的例子：

/*
 * fifo_read.c
 * 管道通信：有名管道
 * 无名管道只能用于具有亲缘关系的进程之间，而有名管道可以在互不相关的两个进程间
 * 实现彼此通信。要注意，FIFO严格按照先进先出的规则，对管道及FIFO的读总是从开始
 * 处返回数据，对它们的写则把数据添加到末尾，不支持lseek等文件定位操作。
 *
 * 有名管道的创建使用mkfifo()。创建成功后就可以使用open、read、write这些函数了。
 * 读管道部分
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
/*在这里设置打开管道文件的mode为只读形式*/
#define FIFOMODE (O_CREAT | O_RDWR | O_NONBLOCK)
#define OPENMODE (O_RDONLY | O_NONBLOCK)
#define FIFO_SERVER "myfifo"
 
int main(void)
{
        char buf[100];
        int fd;
        int readnum;
 
        /*创建有名管道，设置为可读写，无阻塞，如果不存在则按照指定权限创建*/
        if ((mkfifo(FIFO_SERVER, FIFOMODE) < 0) && (errno != EEXIST)) {
                printf("cannot create fifoserver\n");
                exit(1);
        }
 
        printf("Preparing for reading bytes... ...\n");
 
        /*打开有名管道，并设置非阻塞标志*/
        if ((fd = open(FIFO_SERVER, OPENMODE)) < 0) {
                perror("open");
                exit(1);
        }
 
        while (1) {
                /*初始化缓冲区*/
                bzero(buf, sizeof(buf));
                /*读取管道数据*/
                if ((readnum = read(fd, buf, sizeof(buf))) < 0) {
                        if (errno == EAGAIN) {
                                printf("no data yet\n");
                        }
                }
                /*如果读到数据则打印出来，如果没有数据，则忽略*/
                if (readnum != 0) {
                        buf[readnum] = '\0';
                        printf("read %s from FIFO_SERVER\n", buf);
                }
                sleep(1);
        }
 
        return 0;
}

?
? 

/*
 * fifo_wirte.c
 * 管道通信：有名管道
 * 无名管道只能用于具有亲缘关系的进程之间，而有名管道可以在互不相关的两个进程间
 * 实现彼此通信。要注意，FIFO严格按照先进先出的规则，对管道及FIFO的读总是从开始
 * 处返回数据，对它们的写则把数据添加到末尾，不支持lseek等文件定位操作。
 *
 * 有名管道的创建使用mkfifo()。创建成功后就可以使用open、read、write这些函数了。
 * 写管道部分
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
 
/*特别注意写管道时，设置打开管道文件的格式必须为可写*/
#define FIFO_SERVER "myfifo"
#define OPENMODE (O_WRONLY | O_NONBLOCK)
 
int main(int argc, char **argv)
{
        int fd;
        int nwrite;
 
        /*打开管道文件，可写非阻塞*/
        if ((fd = open(FIFO_SERVER, OPENMODE)) < 0) {
                perror("open");
                exit(1);
        }
 
        /*如果没有在命令行中写入参数，那么要重新运行程序*/
        if (argc == 1) {
                printf("Please send something\n");
                exit(1);
        }
 
        /*向管道文件中写入数据，在这里要用strlen，如果用sizeof，则只是4个字节的指针长度*/
        if ((nwrite = write(fd, argv[1], strlen(argv[1]))) < 0) {
                if (errno == EAGAIN) {
                        printf("The FIFO has not been read yet.Please try later\n");
                }
        }
        else {
                printf("write %s to FIFO\n", argv[1]);
        }
 
        return 0;
}

     测试过程，开两个窗口，先打开fifo_read，然后打开fifo_write写入数据，观察情况。

参考网址：http://www.linuxdiyf.com/viewarticle.php?id=6195

Citronnelle2
关注
专栏目录
Python并发编程详解：多线程与多进程及其应用场景
10-11
内容概要：本文深入探讨了Python中的并发编程概念，特别是多线程与多进程的应用及其在不同负载情况下的优劣。通过对I/O密集型和CPU密集型任务的对比分析以及GIL（全局解释器锁）所带来的影响，介绍了具体实例，帮助...
python并发编程多进程之守护进程原理解析
12-31
如果我们有两个任务需要并发执行，那么开一个主进程和一个子进程分别去执行就ok了，如果子进程的任务在主进程任务结束后，就没有存在的必要了，那么该子进程应该在开启前就被设置成守护进程。主进程代码运行
linux 应用程序里面调用shell
weixin_33994444的博客
03-27 183
在Linux的应用程序里面调用我的shell(这玩意功能实在太强大)的办法有很多种一般来说有fork()、exec*()、pipe、system（）其中又以system（） 调用很少方便，现在加以说明。 #include&lt;stdlio.h&gt; #include&lt;stdlib.h&gt; int main() {    system(...
Scale总结
ang639
09-02 1064
技术的发展永远跟不上人的想象。 CPU，内存，硬盘虽然一直在迅速发展，但是单体的力量毕竟有限，远远达不到海量用户，规模化业务，大数据业务特点的需要。因此我们需要更多的计算，内存，存储资源一起工作来满足我们的需要。这就是scale. Scale的基础：松耦合，独立性，方
Linux系统调用--进程管理(1)
11-27 280
Linux系统调用--进程管理(1) 本文介绍了Linux下的进程概念，并着重讲解了与Linux进程管理相关的4个重要系统调用getpid,fork,exit和_exit，辅助一些例程说明了它们的特点和使用方法。 　　 　　 　　关于进程的一些必要知识 　　 　　 　　先看一下进程在大学课本里的标准定义：“进程是可并发执行的程序在一个数据集合上的运行过程。”这个定义非常严谨，而且难懂...
Linux C 程序执行 shell 命令并获取返回结果的方法
热门推荐
程序员「阿基米东」的编程之旅
11-29 3万+
据说有统计数据表明，代码的缺陷率是一定的，与所使用的语言无关。Linux提供了很多的实用工具和脚本，在程序中调用工具和脚本，无疑可以简化程序，从而降低代码的缺陷数目。Linux shell 脚本也是一个强大的工具，我们可以根据需要编制脚本，然后在程序中调用自定义脚本。 　　《Unix 编程艺术》中有一句话“一行 Shell 脚本胜过万行 C”。那么在 Linux 编程中，C 程序如何调用 shel
Linux下多进程编程
weixin_34255793的博客
11-28 370
1 引言 　　 对于没有接触过Unix/Linux操作系统的人来说，fork是最难理解的概念之一：它执行一次却返回两个值。fork函数是Unix系统最杰出的成就之一，它是七十年代UNIX早期的开发者经过长期在理论和实践上的艰苦探索后取得的成果，一方面，它使操作系统在进程管理上付出了最小的代价，另一方面，又为程序员提供了一个简洁明了的多进程方法。与DOS和早期的Windows不同，Unix/Lin...
【python内功修炼002】：并发编程之多进程实例
01-20
文章目录1、multiprocessing模块...alive方法4、守护进程5、僵尸进程和孤儿进程5.1 僵尸进程概念5.2 孤儿进程概念6、进程互斥锁7、队列 (Queue)7.1 队列介绍7.2 基本FIFO队列7.3 LIFO队列7.4 队列的一些常用方法 1、m
Linux多进程编程(转)
weixin_30768661的博客
07-26 76
Linux多进程编程 /* 本文修改自：http://linux.chinaunix.net/techdoc/develop/2007/07/20/963167.shtml *欢迎访问： 新星湾(http://www.xinxingwan.com/) */ 1 Linux下进程的结构 　　 Linux下一个进...
linux下通过命令启动多个终端执行相应的命令和程序
zcc_0015的专栏
06-12 1万+
linux命令启动多个终端 终端自动执行命令 shell编程 c语言执行linux命令
Linux下Fork与Exec使用(转)
llystar的专栏
08-14 130
一、引言 　　对于没有接触过Unix/Linux操作系统的人来说，fork是最难理解的概念之一：它执 行一次却返回两个值。fork函数是Unix系统最杰出的成就之一，它是七十年代UNIX早期的开发者经过长期在理论和实践上的艰苦探索后取得的成果，一 方面，它使操作系统在进程管理上付出了最小的代价，另一方面，又为程序员提供了一个简洁明了的多进程方法。与DOS和早期的Windows不 同，Unix/...
为什么需要使用并发编程？什么时候适合使用并发编程技术？
小凡的专栏
09-09 3853
并发编程又叫多线程编程。 在程序中，往往有很多很耗时的工作，比如上传文件、下载文件、跟客户聊天需要长时间建立连接。这种时候，一个线程是服务不了多个用户的，会产生因为资源独占产生的等待问题。 例如：编写一个耗时的单线程程序： 　　新建一个基于对话框的应用程序SingleThread，在主对话框IDD_SINGLETHREAD_DIALOG添加一个按钮，ID为IDC_SLEEP_SIX_SECOND，
linux 下fork函数和exec 函数的区别
yuyin86的专栏
02-14 1809
2.2 Linux下的进程控制 在传统的Unix环境下，有两个基本的操作用于创建和修改进程：函数fork( )用来创建一个新的进程，该进程几乎是当前进程的一个完全拷贝；函数族exec( )用来启动另外的进程以取代当前运行的进程。Linux的进程控制和传统的Unix进程控制基本一致，只在一些细节的地方有些区别，例如在Linux系统中调用vfork和fork完全相同，而在有些版本的Unix系统中，v
c语言调用shell命令_exec
狼的足迹
04-11 9260
方法一： #include int system(const char *string); 方法二： exec( )函数族  下面我们来看看一个进程如何来启动另一个程序的执行。在Linux中要使用exec函数族。系统调用execve（）对当前进程进行替换，替换者为一个指定的程序，其参数包括文件名（filename）、参数列表（argv）以及环境变量（envp）。exec函数族当然不止一个
python中子进程不支持input()函数输入
yang9315的博客
04-23 3362
错误的源代码：import socket import threading import multiprocessing # 创建socket serve_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) serve_socket.bind(('', 8086)) serve_socket.listen(128) link_soc...
多进程并发编程
上官宏竹的专栏
09-17 538
exit()函数用于终止调用进程。关闭所有子进程打开的描述符，向父进程发送SIGCHLD信号，并返回状态。 父进程可通过调用wait()或waitpid()函数获得子进程的终止信息。{ if(listen(listenfd,BACKLOG)== -1){ perror("listen() error\n"); exit(1); } len=s
【LSTM回归预测】基于emd结合长短记忆神经网络lstm实现风速回归预测附Matlab源码.rar
最新发布
10-28
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Python并发编程：多线程与多进程实战
"Python并发编程涉及多线程和多进程，旨在提高程序的执行效率。并发的概念起源于铁路调度，现在广泛应用于计算机系统。线程是一个指令流，是操作系统调度的基本单位，可共享内存并通信。Python主要使用用户级线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值