<2006年8月>
303112345
6789101112
13141516171819
20212223242526
272829303112
3456789

统计

  • 随笔 - 44
  • 文章 - 0
  • 评论 - 86
  • 引用 - 0

常用链接

留言簿(6)

随笔分类(31)

随笔档案(44)

Mining

最新随笔

搜索

  •  

最新评论

阅读排行榜

评论排行榜

Linux下C编程 进程通信 (IPC)

在Linux中存在下面几种进程间通信方式:

1.POSIX无名信号量
2.System V信号量
3.System V消息队列
4.System V共享内存
5.管道(FIFO)

--------------------------------------------------------------------------------
1。POSIX无名信号量
如果你学习过操作系统,那么肯定熟悉PV操作了.PV操作是原子操作.也就是操作是不可以中断的,在一定的时间内,只能够有一个进程的代码在CPU上面执行.在系统当中,有时候为了顺利的使用和保护共享资源,大家提出了信号的概念. 假设我们要使用一台打印机, 如果在同一时刻有两个进程在向打印机输出,那么最终的结果会是什么呢.为了处理这种情况,POSIX标准提出了有名信号量和无名信号量的概念,由于 Linux只实现了无名信号量,我们在这里就只是介绍无名信号量了. 信号量的使用主要是用来保护共享资源,使的资源在一个时刻只有一个进程所拥有.为此我们可以使用一个信号灯.当信号灯的值为某个值的时候,就表明此时资源不可以使用.否则就表>示可以使用. 为了提供效率,系统提供了下面几个函数 
POSIX的无名信号量的函数有以下几个:

int  sem_init(sem_t  * sem, int  pshared,unsigned  int  value);
int  sem_destroy(sem_t  * sem);
int  sem_wait(sem_t  * sem);
int  sem_trywait(sem_t  * sem);
int  sem_post(sem_t  * sem);
int  sem_getvalue(sem_t  * sem);

sem_init创建一个信号灯,并初始化其值为value.pshared决定了信号量能否在几个进程间共享.由于目前Linux还没有实现进程间共享信号灯,所以这个值只能够取0.
sem_destroy是用来删除信号灯的.
sem_wait调用将阻塞进程,直到信号灯的值大于0.这个函数返回的时候自动的将信号灯的值的件一.
sem_post和sem_wait相反,是将信号灯的内容加一同时发出信号唤醒等待的进程..
sem_trywait和sem_wait相同,不过不阻塞的,当信号灯的值为0的时候返回EAGAIN,表示以后重试.
sem_getvalue得到信号灯的值.
由于Linux不支持,我们没有办法用源程序解释了.


2。System V信号量
信号灯的主要用途是保护临界资源(在一个时刻只被一个进程所拥有). System V信号量的函数主要有下面几个.

key_t ftok( char   * pathname, char  proj);
int  semget(key_t key, int  nsems, int  semflg);
int  semctl( int  semid, int  semnum, int  cmd,union semun arg);
int  semop( int  semid, struct  sembuf  * spos, int  nspos);

struct  sembuf{
short  sem_num;  /*  使用那一个信号  */
short  sem_op;  /*  进行什么操作  */
short  sem_flg;  /*  操作的标志  */
};

ftok函数是根据pathname和proj来创建一个关键字.
semget创建一个信号量.成功时返回信号的ID,key是一个关键字,可以是用ftok创建的也可以是IPC_PRIVATE表明由系统选用一个关键字. nsems表明我们创建的信号个数.semflg是创建的权限标志,和我们创建一个文件的标志相同.
semctl对信号量进行一系列的控制.semid是要操作的信号标志,semnum是信号的个数,cmd是操作的命令.经常用的两个值是:SETVAL(设置信号量的值)和IPC_RMID(删除信号灯).arg是一个给cmd的参数.
semop是对信号进行操作的函数.semid是信号标志,spos是一个操作数组表明要进行什么操作,nspos表明数组的个数. 如果 sem_op大于0,那么操作将sem_op加入到信号量的值中,并唤醒等待信号增加的进程. 如果为0,当信号量的值是0的时候,函数返回,否则阻塞直到信号量的值为0. 如果小于0,函数判断信号量的值加上这个负值.如果结果为0唤醒等待信号量为0的进程,如果小与0函数阻塞.如果大于0,那么从信号量里面减去这个值并返回.

下面我们一以一个实例来说明这几个函数的使用方法.

#define  PERMS S_IRUSR|S_IWUSR
void  init_semaphore_struct( struct  sembuf  * sem, int  semnum, int  semop, int  semflg)
{
 
/*  初始话信号灯结构  */
 sem
-> sem_num = semnum;
 sem
-> sem_op = semop;
 sem
-> sem_flg = semflg;
}
int  del_semaphore( int  semid)
{
 
/*  信号灯并不随程序的结束而被删除,如果我们没删除的话(将1改为0)
 可以用ipcs命令查看到信号灯,用ipcrm可以删除信号灯的
 
*/
 
#if  1
 
return  semctl(semid, 0 ,IPC_RMID);
 
#endif
}

int  main( int  argc, char   ** argv)
{
 
char  buffer[MAX_CANON], * c;
 
int  i,n;
 
int  semid,semop_ret,status;
 pid_t childpid;
 
struct  sembuf semwait,semsignal;

 
if ((argc != 2 ) || ((n = atoi(argv[ 1 ])) < 1 ))
 {
  fprintf(stderr,
" Usage:%s number\n\a " ,argv[ 0 ]);
  exit(
1 );
 }
 
 
/*  使用IPC_PRIVATE 表示由系统选择一个关键字来创建   */
 
/*  创建以后信号灯的初始值为0  */
 
if ((semid = semget(IPC_PRIVATE, 1 ,PERMS)) ==- 1 )
 {
  fprintf(stderr,
" [%d]:Acess Semaphore Error:%s\n\a " ,
  getpid(),strerror(errno));
  exit(
1 );
 }

 
/*  semwait是要求资源的操作(-1)  */
 init_semaphore_struct(
& semwait, 0 , - 1 , 0 );

 
/*  semsignal是释放资源的操作(+1)  */
 init_semaphore_struct(
& semsignal, 0 , 1 , 0 );

 
/*  开始的时候有一个系统资源(一个标准错误输出)  */
 
if (semop(semid, & semsignal, 1 ) ==- 1 )
 {
  fprintf(stderr,
" [%d]:Increment Semaphore Error:%s\n\a " , getpid(), strerror(errno));
  
if (del_semaphore(semid) ==- 1 )
   fprintf(stderr,
" [%d]:Destroy Semaphore Error:%s\n\a " , getpid(), strerror(errno));
  exit(
1 );
 }

 
/*  创建一个进程链  */
 
for (i = 0 ;i < n;i ++ )
  
if (childpid = fork())  break ;

 sprintf(buffer,
" [i=%d]-->[Process=%d]-->[Parent=%d]-->[Child=%d]\n " , i,getpid(),getppid(),childpid);
 c
= buffer;

 
/*  这里要求资源,进入原子操作  */
 
while (((semop_ret = semop(semid, & semwait, 1 )) ==- 1 ) && (errno == EINTR));
 
if (semop_ret ==- 1 )
 {
  fprintf(stderr,
" [%d]:Decrement Semaphore Error:%s\n\a " ,
  getpid(),strerror(errno));
 }
 
else
 {
  
while ( * c != ' \0 ' )fputc( * c ++ ,stderr);
  
/*  原子操作完成,赶快释放资源  */
  
while (((semop_ret = semop(semid, & semsignal, 1 )) ==- 1 ) && (errno == EINTR));
  
if (semop_ret ==- 1 )
   fprintf(stderr,
" [%d]:Increment Semaphore Error:%s\n\a " , getpid(),strerror(errno));
 }

 
/*  不能够在其他进程反问信号灯的时候,我们删除了信号灯  */
 
while ((wait( & status) ==- 1 ) && (errno == EINTR));
 
/*  信号灯只能够被删除一次的  */
 
if (i == 1 )
  
if (del_semaphore(semid) ==- 1 )
 fprintf(stderr,
" [%d]:Destroy Semaphore Error:%s\n\a " , getpid(),strerror(errno));
 exit(
0 );
}


3。SystemV消息队列
为了便于进程之间通信,我们可以使用管道通信 SystemV也提供了一些函数来实现进程的通信.这就是消息队列.

int  msgget(key_t key, int  msgflg);
int  msgsnd( int  msgid, struct  msgbuf  * msgp, int  msgsz, int  msgflg);
int  msgrcv( int  msgid, struct  msgbuf  * msgp, int  msgsz,
long  msgtype, int  msgflg);
int  msgctl(Int msgid, int  cmd, struct  msqid_ds  * buf);

struct  msgbuf {
long  msgtype;    /*  消息类型  */
/*  其他数据类型  */
}

msgget函数和semget一样,返回一个消息队列的标志.
msgctl和semctl是对消息进行控制.
msgsnd和msgrcv函数是用来进行消息通讯的.msgid是接受或者发送的消息队列标志. msgp是接受或者发送的内容.msgsz是消息的大小. 结构msgbuf包含的内容是至少有一个为msgtype.其他的成分是用户定义的.对于发送函数msgflg指出缓冲区用完时候的操作.接受函数指出无消息时候的处理.一般为 0. 接收函数msgtype指出接收消息时候的操作.
如果msgtype=0,接收消息队列的第一个消息.大于0接收队列中消息类型等于这个值的第一个消息.小于0接收消息队列中小于或者等于 msgtype绝对值的所有消息中的最小一个消息. 我们以一个实例来解释进程通信.下面这个程序有server和client组成.先运行服务端后运行客户端.

服务端 server.c

#define    MSG_FILE "server.c"
#define    BUFFER 255
#define    PERM S_IRUSR|S_IWUSR

struct  msgtype {
long  mtype;
char  buffer[BUFFER + 1 ];
};

int  main()
{
    
struct  msgtype msg;
    key_t key;
    
int  msgid;

    
if ((key = ftok(MSG_FILE, ' a ' )) ==- 1 )
    {
        fprintf(stderr,
" Creat Key Error:%s\a\n " ,strerror(errno));
        exit(
1 );
    }

    
if ((msgid = msgget(key,PERM | IPC_CREAT | IPC_EXCL)) ==- 1 )
    {
        fprintf(stderr,
" Creat Message  Error:%s\a\n " ,strerror(errno));
        exit(
1 );
    }

    
while ( 1 )
    {
        msgrcv(msgid,
& msg, sizeof ( struct  msgtype), 1 , 0 );
        fprintf(stderr,
" Server Receive:%s\n " ,msg.buffer);
        msg.mtype
= 2 ;
        msgsnd(msgid,
& msg, sizeof ( struct  msgtype), 0 );
    }
    exit(
0 );
}


--------------------------------------------------------------------------------

客户端(client.c)

#define    MSG_FILE "server.c"
#define    BUFFER 255
#define    PERM S_IRUSR|S_IWUSR

struct  msgtype {
long  mtype;
char  buffer[BUFFER + 1 ];
};

int  main( int  argc, char   ** argv)
{
 
struct  msgtype msg;
 key_t key;
 
int  msgid;

 
if (argc != 2 )
 {
  fprintf(stderr,
" Usage:%s string\n\a " ,argv[ 0 ]);
  exit(
1 );
 }

 
if ((key = ftok(MSG_FILE, ' a ' )) ==- 1 )
 {
  fprintf(stderr,
" Creat Key Error:%s\a\n " ,strerror(errno));
  exit(
1 );
 }

 
if ((msgid = msgget(key,PERM)) ==- 1 )
 {
  fprintf(stderr,
" Creat Message  Error:%s\a\n " ,strerror(errno));
  exit(
1 );
 }

 msg.mtype
= 1 ;
 strncpy(msg.buffer,argv[
1 ],BUFFER);
 msgsnd(msgid,
& msg, sizeof ( struct  msgtype), 0 ); 
 memset(
& msg, ' \0 ' , sizeof ( struct  msgtype));
 msgrcv(msgid,
& msg, sizeof ( struct  msgtype), 2 , 0 );
 fprintf(stderr,
" Client receive:%s\n " ,msg.buffer);
 exit(
0 );
}  

注意服务端创建的消息队列最后没有删除,我们要使用ipcrm命令来删除的.
4。SystemV共享内存
还有一个进程通信的方法是使用共享内存.SystemV提供了以下几个函数以实现共享内存.

int  shmget(key_t key, int  size, int  shmflg);
void   * shmat( int  shmid, const   void   * shmaddr, int  shmflg);
int  shmdt( const   void   * shmaddr);
int  shmctl( int  shmid, int  cmd, struct  shmid_ds  * buf);

shmget和shmctl没有什么好解释的.size是共享内存的大小.
shmat是用来连接共享内存的.shmdt是用来断开共享内存的.
shmaddr,shmflg我们只要用0代替就可以了.在使用一个共享内存之前我们调用 shmat得到共享内存的开始地址,使用结束以后我们使用shmdt断开这个内存. 

#define  PERM S_IRUSR|S_IWUSR
int  main( int  argc, char   ** argv)
{
 
 
int  shmid;
 
char   * p_addr, * c_addr;
 
if (argc != 2 )
 {
  fprintf(stderr,
" Usage:%s\n\a " ,argv[ 0 ]);
  exit(
1 );
 }

 
if ((shmid = shmget(IPC_PRIVATE, 1024 ,PERM)) ==- 1 )
 {
  fprintf(stderr,
" Create Share Memory Error:%s\n\a " ,strerror(errno));
  exit(
1 );
 }
 
if (fork())
 {
  p_addr
= shmat(shmid, 0 , 0 );
  memset(p_addr,
' \0 ' , 1024 );
  strncpy(p_addr,argv[
1 ], 1024 );
  exit(
0 );
 }
 
else
 {
  c_addr
= shmat(shmid, 0 , 0 );
  printf(
" Client get %s " ,c_addr);
  exit(
0 );
 } 


这个程序是父进程将参数写入到共享内存,然后子进程把内容读出来.最后我们要使用ipcrm释放资源的.先用ipcs找出ID然后用ipcrm shm ID删除. 

5、管道(FIFO)
管道有无名管道和有名管道两种,无名管道一般在父子进程中使用。
无名管道的使用方法一般是:
#include <unistd.h>
int pipe(int filedes[2]);
filedes[
0]用于读出数据,读取时必须关闭写入端,即close(filedes[1]);
filedes[
1]用于写入数据,写入时必须关闭读取端,即close(filedes[0])。

无名管道的使用方法是:
#include <sys/types.h>
#include 
<sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);

读写管道与读写文件的操作相同。



posted on 2006-08-04 18:05 泡泡牛 阅读(3384) 评论(1)  编辑 收藏 引用

评论

# re: Linux下C编程 进程通信 (IPC) 2009-03-04 11:18 fuck

你的代码有错误!
ipc 信号量的代码里,应该是i=0时才能删除sem资源
  回复  更多评论    

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理