1： Linux下进程的结构
Linux下一个进程在内存里有三部分的数据，就是"代码段"、"堆栈段"和"数据段"。这三个部分也是构成一个完整的执行序列的必要的部分。
代码段
顾名思义，就是存放了程序代码的数据，假如机器中有数个进程运行相同的一个程序，那么它们就可以使用相同的代码段。
堆栈段
存放的就是子程序的返回地址、子程序的参数以及程序的局部变量。
数据段
存放程序的全局变量，常数以及动态数据分配的数据空间（比如用malloc之类的函数取得的空间）。
系统如果同时运行数个相同的程序，它们之间就不能使用同一个堆栈段和数据段。
2 ：Linux下的进程控制
两个基本的操作用于创建和修改进程：
函数fork( )用来创建一个新的进程，该进程几乎是当前进程的一个完全拷贝；
函数族exec( )用来启动另外的进程以取代当前运行的进程。
2.1 fork( )
fork在英文中是"分叉"的意思。为什么取这个名字呢？因为一个进程在运行中，
如果使用了fork，就产生了另一个进程，于是进程就"分叉"了，所以这个名字取得
很形象。下面就看看如何具体使用fork，这段程序演示了使用fork的基本框架：
void main()
{
int i;
if ( fork() == 0 )
{ /* 子进程程序 */
for ( i = 1; i <1000; i ++ ) printf("This is child process/n");
}
else { /* 父进程程序*/
for ( i = 1; i <1000; i ++ ) printf("This is process process/n");
}
}
fork函数启动一个新的进程，这个进程几乎是当前进程的一个拷贝：子进程和父进程使用相同的
代码段；子进程复制父进程的堆栈段和数据段。这样，父进程的所有数据都可以
留给子进程，但是，子进程一旦开始运行，虽然它继承了父进程的一切数据，但
实际上数据却已经分开，相互之间不再有影响了，也就是说，它们之间不再共享
任何数据了。它们再要交互信息时，只有通过进程间通信来实现，这将是我们下
面的内容。既然它们如此相象，系统如何来区分它们呢？这是由函数的返回值来
决定的。对于父进程，fork函数返回了子程序的进程号，
而对于子程序，fork函数则返回零。
在程序设计中，父进程和子进程都要调用函数fork（）下面的代码，而我们就是利用fork（）函数对父子进程的不同返
回值用if...else...语句来实现让父子进程完成不同的功能，
2.2 exec( )函数族
在Linux中要使用exec函数族。系统调用execve（）对当前进程进行替换，替换者为一个指
定的程序，其参数包括文件名（filename）、参数列表（argv）以及环境变
量（envp）,在Linux中，它们分别是：execl，execlp，execle，execv，execve和execvp，下面我只以execl
为例，其它函数究竟与execlp有何区别，请通过manexec命令来了解它们的具体情况。
一个进程一旦调用exec类函数，它本身就"死亡"了，系统把代码段替
换成新的程序的代码，废弃原有的数据段和堆栈段，并为新程序分配新的数
据段与堆栈段，唯一留下的，就是进程号，也就是说，对系统而言，还是
同一个进程，不过已经是另一个程序了。（不过exec类函数中有的还允许继承环境变量之类的信息。）
那么如果我的程序想启动另一程序的执行但自己仍想继续运行的话
，怎么办呢？那就是结合fork与exec的使用。下面一段代码显示如何启动运行其它程序：
char command[256];
void main()
{
int rtn; /*子进程的返回数值*/
while(1)
{ /* 从终端读取要执行的命令 */
printf( ">" );
fgets( command, 256, stdin );
command[strlen(command)-1] = 0;
if ( fork() == 0 )
{ /* 子进程执行此命令 */
execlp( command, command );
/* 如果exec函数返回，表明没有正常执行命令，打印错误信息*/
perror( command );
exit( errorno );
} else
{ /* 父进程， 等待子进程结束，并打印子进程的返回值 */
wait ( &rtn );
printf( " child process return %d/n",. rtn );
}
}
}
system（）
system（）函数先调用fork（），然后再调用exec（）来执行用户的登录shell，通
过它来查找可执行文件的命令并分析参数，最后它么使用wait（）函
数族之一来等待子进程的结束。
popen（）函数。
函数popen（）和函数system（）相似，不同的是它调用pipe（）函数创建一个管道，通过它来完成程序
的标准输入和标准输出。这两个函数是为那些不太勤快的程序员设计的
，在效率和安全方面都有相当的缺陷，在可能的情况下，应该尽量避免。
3 Linux下的进程间通信
2.3.1 管道
管道是进程间通信中最古老的方式，它包括无名管道和有
名管道两种，前者用于父进程和子进程间的通信，后者用于运
行于同一台机器上的任意两个进程间的通信。
a；无名管道
无名管道由pipe（）函数创建：
#include
int pipe(int filedis[2])；
参数filedis返回两个文件描述符：filedes[0]为读而打
开，filedes[1]为写而打开。filedes[1]的输出是filedes[0]的
输入。下面的例子示范了如何在父进程和子进程间实现通信。
#define INPUT 0
#define OUTPUT 1
void 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");
/*子进程向父进程写数据，关闭管道的读端*/
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);
}
}
b；有名管道
在Linux系统下，有名管道可由两种方式创建：命令行方式mknod系
统调用和函数mkfifo。下面的两种途径都在当前目录下生成了一个名为myfifo的有名管道：
方式一：mkfifo("myfifo","rw");
方式二：mknod myfifo p
生成了有名管道后，就可以使用一般的文件I/O函数如open、close、
read、write等来对它进行操作。下面即是一个简单的例子，假设我们已经创建了一个名为myfifo的有名管道。
/* 进程一：读有名管道*/
#include
#include
void main()
{
FILE * in_file;
int count = 1;
char buf[80];
in_file = fopen("mypipe", "r");
if (in_file == NULL) {
printf("Error in fdopen./n");
exit(1);
}
while ((count = fread(buf, 1, 80, in_file)) > 0)
printf("received from pipe: %s/n", buf);
fclose(in_file);
}
/* 进程二：写有名管道*/
#include
#include
void main() {
FILE * out_file;
int count = 1;
char buf[80];
out_file = fopen("mypipe", "w");
if (out_file == NULL) {
printf("Error opening pipe.");
exit(1);
}
sprintf(buf,"this is test data for the named pipe example/n");
fwrite(buf, 1, 80, out_file);
fclose(out_file);
}
3.2 消息队列
消息队列用于运行于同一台机器上的进程间通信，它和管道很相似，事实上，
它是一种正逐渐被淘汰的通信方式，我们可以用流管道或者套接口的方式来
取代它，所以，我们对此方式也不再解释，也建议读者忽略这种方式。
2.3.3 共享内存
共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据
不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余
进程对这块内存区进行读写。
得到共享内存有两种方式：。
映射/dev/mem设备前一种方式不给系统带来额外的开销，但在现实中并不常用，
因为它控制存取的将是实际的物理内存，在Linux系统下，这只有通过
限制Linux系统存取的内存才可以做到，这当然不太实际。
和内存映像文件
常用的方式是通过shmXXX函数族来实现利用共享内存进行存储的。
首先要用的函数是shmget，它获得一个共享存储标识符。
#include
#include
#include
int shmget(key_t key, int size, int flag);
这个函数有点类似大家熟悉的malloc函数，系统按照请求分配size大
小的内存用作共享内存。Linux系统内核中每个IPC结构都有的一个非负整
数的标识符，这样对一个消息队列发送消息时只要引用标识符就可以了
。这个标识符是内核由IPC结构的关键字得到的，这个关键字，就是上面
第一个函数的key。数据类型key_t是在头文件sys/types.h中定义的，它
是一个长整形的数据。在我们后面的章节中，还会碰到这个关键字。
当共享内存创建后，其余进程可以调用shmat（）将其连接到自身的
地址空间中。
void *shmat(int shmid, void *addr, int flag);
shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了
以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的
实际地址，进程可以对此进程进行读写操作。
使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须
确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号
量被要来实现对共享存储数据存取的同步，另外，可以通过使用shmctl函数
设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。
3.3信号量
信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而
最主要的应用是前一节的共享内存方式的进程间通信。本质上，信号量是
一个计数器，它用来记录对某个资源（如共享内存）的存取状况。一般说来，为了获得共享资源，进程需要执行下列操作：
（1） 测试控制该资源的信号量。
（2） 若此信号量的值为正，则允许进行使用该资源。进程将进号量减1。
（3） 若此信号量为0，则该资源目前不可用，进程进入睡眠状态
，直至信号量值大于0，进程被唤醒，转入步骤（1）。
（4） 当进程不再使用一个信号量控制的资源时，信号量值加1
。如果此时有进程正在睡眠等待此信号量，则唤醒此进程。
维护信号量状态的是Linux内核操作系统而不是用户进程。我们
可以从头文件/usr/src/linux/include /linux /sem.h中看到内核用
来维护信号量状态的各个结构的定义。信号量是一个数据集合，用户
可以单独使用这一集合的每个元素。要调用的第一个函数是semget，用以获得一个信号量ID。
#include
#include
#include
int semget(key_t key, int nsems, int flag);
key是前面讲过的IPC结构的关键字，它将来决定是创建新的信号量集
合，还是引用一个现有的信号量集合。nsems是该集合中的信号量数。
如果是创建新集合（一般在服务器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将nsems指定为0。
semctl函数用来对信号量进行操作。
int semctl(int semid, int semnum, int cmd, union semun arg);
不同的操作是通过cmd参数来实现的，在头文件sem.h中定义了7种不同的操作，实际编程时可以参照使用。
semop函数自动执行信号量集合上的操作数组。
int semop(int semid, struct sembuf semoparray[], size_t nops);
semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。
下面，我们看一个具体的例子，它创建一个特定的IPC结构的
关键字和一个信号量，建立此信号量的索引，修改索引指向的信号量
的值，最后我们清除信号量。在下面的代码中，函数ftok生成我们上文所说的唯一的IPC关键字。
[cpp] view plaincopy
#include
#include
#include
#include
void main() {
key_t unique_key; /* 定义一个IPC关键字*/
int id;
struct sembuf lock_it;
union semun options;
int i;
unique_key = ftok(".", 'a'); /* 生成关键字，字符'a'是一个随机种子*/
/* 创建一个新的信号量集合*/
id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666);
printf("semaphore id=%d/n", id);
options.val = 1; /*设置变量值*/
semctl(id, 0, SETVAL, options); /*设置索引0的信号量*/
/*打印出信号量的值*/
i = semctl(id, 0, GETVAL, 0);
printf("value of semaphore at index 0 is %d/n", i);
/*下面重新设置信号量*/
lock_it.sem_num = 0; /*设置哪个信号量*/
lock_it.sem_op = -1; /*定义操作*/
lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/
if (semop(id, &lock_it, 1) == -1) {
printf("can not lock semaphore./n");
exit(1);
}
i = semctl(id, 0, GETVAL, 0);
printf("value of semaphore at index 0 is %d/n", i);
/*清除信号量*/
semctl(id, 0, IPC_RMID, 0);
}
3.4套接口
套接口（socket）编程是实现Linux系统和其他大多数操作系统中进
程间通信的主要方式之一。
阅读(579) | 评论(0) | 转发(0) |
