Linux程序设计入门--消息管理
%A 前言:Linux下的进程通信(IPC)
%A Linux下的进程通信(IPC)
%A POSIX无名信号量
%A System V信号量
%A System V消息队列
%A System V共享内存
%A 1。POSIX无名信号量 如果你学习过操作系统,那么肯定熟悉PV操作了.PV操作是原子
%A 操作.也就是操作是不可以中断的,在一定的时间内,只能够有一个进程的代码在CPU上面
%A 执行.在系统当中,有时候为了顺利的使用和保护共享资源,大家提出了信号的概念. 假设
%A 我们要使用一台打印机,如果在同一时刻有两个进程在向打印机输出,那么最终的结果会
%A 是什么呢.为了处理这种情况,POSIX标准提出了有名信号量和无名信号量的概念,由于Li
%A nux只实现了无名信号量,我们在这里就只是介绍无名信号量了. 信号量的使用主要是用
%A 来保护共享资源,使的资源在一个时刻只有一个进程所拥有.为此我们可以使用一个信号
%A 灯.当信号灯的值为某个值的时候,就表明此时资源不可以使用.否则就表>示可以使用.
%A 为了提供效率,系统提供了下面几个函数
%A POSIX的无名信号量的函数有以下几个:
%A ＃i nclude <semaphore.h>
%A int sem_init(sem_t *sem,int pshared,unsigned int value);
%A int sem_destroy(sem_t *sem);
%A int sem_wait(sem_t *sem);
%A int sem_trywait(sem_t *sem);
%A int sem_post(sem_t *sem);
%A int sem_getvalue(sem_t *sem);
%A sem_init创建一个信号灯,并初始化其值为value.pshared决定了信号量能否在几个进程
%A 间共享.由于目前Linux还没有实现进程间共享信号灯,所以这个值只能够取0. sem_dest
%A roy是用来删除信号灯的.sem_wait调用将阻塞进程,直到信号灯的值大于0.这个函数返回
%A 的时候自动的将信号灯的值的件一.sem_post和sem_wait相反,是将信号灯的内容加一同
%A 时发出信号唤醒等待的进程..sem_trywait和sem_wait相同,不过不阻塞的,当信号灯的值
%A 为0的时候返回EAGAIN,表示以后重试.sem_getvalue得到信号灯的值.
%A 由于Linux不支持,我们没有办法用源程序解释了.
%A 这几个函数的使用相当简单的.比如我们有一个程序要向一个系统打印机打印两页.我们
%A 首先创建一个信号灯,并使其初始值为1,表示我们有一个资源可用.然后一个进程调用se
%A m_wait由于这个时候信号灯的值为1,所以这个函数返回,打印机开始打印了,同时信号灯
%A 的值为0 了. 如果第二个进程要打印,调用sem_wait时候,由于信号灯的值为0,资源不可
%A 用,于是被阻塞了.当第一个进程打印完成以后,调用sem_post信号灯的值为1了,这个时候
%A 系统通知第二个进程,于是第二个进程的sem_wait返回.第二个进程开始打印了.
%A 不过我们可以使用线程来解决这个问题的.我们会在后面解释什么是线程的.编译包含上
%A 面这几个函数的程序要加上 -lrt选贤,以连接librt.so库
%A 2。System V信号量 为了解决上面哪个问题,我们也可以使用System V信号量.很幸运的
%A 是Linux实现了System V信号量.这样我们就可以用实例来解释了. System V信号量的函
%A 数主要有下面几个.
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/ipc.h>
%A ＃i nclude <sys/sem.h>
%A key_t ftok(char *pathname,char proj);
%A int semget(key_t key,int nsems,int semflg);
%A int semctl(int semid,int semnum,int cmd,union semun arg);
%A int semop(int semid,struct sembuf *spos,int nspos);
%A struct sembuf {
%A short sem_num; /* 使用那一个信号 */
%A short sem_op; /* 进行什么操作 */
%A short sem_flg; /* 操作的标志 */
%A };
%A ftok函数是根据pathname和proj来创建一个关键字.semget创建一个信号量.成功时返回
%A 信号的ID,key是一个关键字,可以是用ftok创建的也可以是IPC_PRIVATE表明由系统选用
%A 一个关键字. nsems表明我们创建的信号个数.semflg是创建的权限标志,和我们创建一个
%A 文件的标志相同.
%A semctl对信号量进行一系列的控制.semid是要操作的信号标志,semnum是信号的个数,cm
%A d是操作的命令.经常用的两个值是:SETVAL(设置信号量的值)和IPC_RMID(删除信号灯).
%A arg是一个给cmd的参数.
%A semop是对信号进行操作的函数.semid是信号标志,spos是一个操作数组表明要进行什么
%A 操作,nspos表明数组的个数. 如果sem_op大于0,那么操作将sem_op加入到信号量的值中
%A ,并唤醒等待信号增加的进程. 如果为0,当信号量的值是0的时候,函数返回,否则阻塞直
%A 到信号量的值为0. 如果小于0,函数判断信号量的值加上这个负值.如果结果为0唤醒等待
%A 信号量为0的进程,如果小与0函数阻塞.如果大于0,那么从信号量里面减去这个值并返回
%A ..
%A 下面我们一以一个实例来说明这几个函数的使用方法.这个程序用标准错误输出来代替我
%A 们用的打印机.
%A ＃i nclude <stdio.h>
%A ＃i nclude <unistd.h>
%A ＃i nclude <limits.h>
%A ＃i nclude <errno.h>
%A ＃i nclude <string.h>
%A ＃i nclude <stdlib.h>
%A ＃i nclude <sys/stat.h>
%A ＃i nclude <sys/wait.h>
%A ＃i nclude <sys/ipc.h>
%A ＃i nclude <sys/sem.h>
%A #define PERMS S_IRUSR|S_IWUSR
%A void init_semaphore_struct(struct sembuf *sem,int semnum,
%A int semop,int semflg)
%A {
%A /* 初始话信号灯结构 */
%A sem->sem_num=semnum;
%A sem->sem_op=semop;
%A sem->sem_flg=semflg;
%A }
%A int del_semaphore(int semid)
%A {
%A /* 信号灯并不随程序的结束而被删除,如果我们没删除的话(将1改为0)
%A 可以用ipcs命令查看到信号灯,用ipcrm可以删除信号灯的
%A */
%A #if 1
%A return semctl(semid,0,IPC_RMID);
%A #endif
%A }
%A int main(int argc,char **argv)
%A {
%A char buffer[MAX_CANON],*c;
%A int i,n;
%A int semid,semop_ret,status;
%A pid_t childpid;
%A struct sembuf semwait,semsignal;
%A if((argc!=2)||((n=atoi(argv[1]))<1))
%A {
%A fprintf(stderr,"Usage:%s number\n\a",argv[0]);
%A exit(1);
%A }
%A /* 使用IPC_PRIVATE 表示由系统选择一个关键字来创建 */
%A /* 创建以后信号灯的初始值为0 */
%A if((semid=semget(IPC_PRIVATE,1,PERMS))==-1)
%A {
%A fprintf(stderr,"[%d]:Acess Semaphore Error:%s\n\a",
%A getpid(),strerror(errno));
%A exit(1);
%A }
%A /* semwait是要求资源的操作(-1) */
%A init_semaphore_struct(&semwait,0,-1,0);
%A /* semsignal是释放资源的操作(+1) */
%A init_semaphore_struct(&semsignal,0,1,0);
%A /* 开始的时候有一个系统资源(一个标准错误输出) */
%A if(semop(semid,&semsignal,1)==-1)
%A {
%A fprintf(stderr,"[%d]:Increment Semaphore Error:%s\n\a",
%A getpid(),strerror(errno));
%A if(del_semaphore(semid)==-1)
%A fprintf(stderr,"[%d]:Destroy Semaphore Error:%s\n\a",
%A getpid(),strerror(errno));
%A exit(1);
%A }
%A /* 创建一个进程链 */
%A for(i=0;i<n;i++)
%A if(childpid=fork()) break;
%A sprintf(buffer,"[i=%d]-->[Process=%d]-->[Parent=%d]-->[Child=%d]\n",
%A i,getpid(),getppid(),childpid);
%A c=buffer;
%A /* 这里要求资源,进入原子操作 */
%A while(((semop_ret=semop(semid,&semwait,1))==-1)&&(errno==EINTR));
%A if(semop_ret==-1)
%A {
%A fprintf(stderr,"[%d]:Decrement Semaphore Error:%s\n\a",
%A getpid(),strerror(errno));
%A }
%A else
%A {
%A while(*c!=‘‘)fputc(*c++,stderr);
%A /* 原子操作完成,赶快释放资源 */
%A while(((semop_ret=semop(semid,&semsignal,1))==-1)&&(errno==EINTR));
%A if(semop_ret==-1)
%A fprintf(stderr,"[%d]:Increment Semaphore Error:%s\n\a",
%A getpid(),strerror(errno));
%A }
%A /* 不能够在其他进程反问信号灯的时候,我们删除了信号灯 */
%A while((wait(&status)==-1)&&(errno==EINTR));
%A /* 信号灯只能够被删除一次的 */
%A if(i==1)
%A if(del_semaphore(semid)==-1)
%A fprintf(stderr,"[%d]:Destroy Semaphore Error:%s\n\a",
%A getpid(),strerror(errno));
%A exit(0);
%A }
%A 信号灯的主要用途是保护临界资源(在一个时刻只被一个进程所拥有).
%A 3。SystemV消息队列 为了便于进程之间通信,我们可以使用管道通信 SystemV也提供了
%A 一些函数来实现进程的通信.这就是消息队列.
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/ipc.h>
%A ＃i nclude <sys/msg.h>
%A int msgget(key_t key,int msgflg);
%A int msgsnd(int msgid,struct msgbuf *msgp,int msgsz,int msgflg);
%A int msgrcv(int msgid,struct msgbuf *msgp,int msgsz,
%A long msgtype,int msgflg);
%A int msgctl(Int msgid,int cmd,struct msqid_ds *buf);
%A
%A struct msgbuf {
%A long msgtype; /* 消息类型 */
%A ....... /* 其他数据类型 */
%A }
%A msgget函数和semget一样,返回一个消息队列的标志.msgctl和semctl是对消息进行控制
%A .. msgsnd和msgrcv函数是用来进行消息通讯的.msgid是接受或者发送的消息队列标志.
%A msgp是接受或者发送的内容.msgsz是消息的大小. 结构msgbuf包含的内容是至少有一个
%A 为msgtype.其他的成分是用户定义的.对于发送函数msgflg指出缓冲区用完时候的操作.
%A 接受函数指出无消息时候的处理.一般为0. 接收函数msgtype指出接收消息时候的操作.
%A
%A 如果msgtype=0,接收消息队列的第一个消息.大于0接收队列中消息类型等于这个值的第
%A 一个消息.小于0接收消息队列中小于或者等于msgtype绝对值的所有消息中的最小一个消
%A 息. 我们以一个实例来解释进程通信.下面这个程序有server和client组成.先运行服务
%A 端后运行客户端.
%A 服务端 server.c
%A ＃i nclude <stdio.h>
%A ＃i nclude <string.h>
%A ＃i nclude <stdlib.h>
%A ＃i nclude <errno.h>
%A ＃i nclude <unistd.h>
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/ipc.h>
%A ＃i nclude <sys/stat.h>
%A ＃i nclude <sys/msg.h>
%A #define MSG_FILE "server.c"
%A #define BUFFER 255
%A #define PERM S_IRUSR|S_IWUSR
%A struct msgtype {
%A long mtype;
%A char buffer[BUFFER+1];
%A };
%A int main()
%A {
%A struct msgtype msg;
%A key_t key;
%A int msgid;
%A if((key=ftok(MSG_FILE,‘a‘))==-1)
%A {
%A fprintf(stderr,"Creat Key Error:%s\a\n",strerror(errno));
%A exit(1);
%A }
%A if((msgid=msgget(key,PERM|IPC_CREAT|IPC_EXCL))==-1)
%A {
%A fprintf(stderr,"Creat Message Error:%s\a\n",strerror(errno));
%A exit(1);
%A }
%A while(1)
%A {
%A msgrcv(msgid,&msg,sizeof(struct msgtype),1,0);
%A fprintf(stderr,"Server Receive:%s\n",msg.buffer);
%A msg.mtype=2;
%A msgsnd(msgid,&msg,sizeof(struct msgtype),0);
%A }
%A exit(0);
%A }
%A ----------------------------------------------------------------------------
%A ----
%A 客户端(client.c)
%A ＃i nclude <stdio.h>
%A ＃i nclude <string.h>
%A ＃i nclude <stdlib.h>
%A ＃i nclude <errno.h>
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/ipc.h>
%A ＃i nclude <sys/msg.h>
%A ＃i nclude <sys/stat.h>
%A #define MSG_FILE "server.c"
%A #define BUFFER 255
%A #define PERM S_IRUSR|S_IWUSR
%A struct msgtype {
%A long mtype;
%A char buffer[BUFFER+1];
%A };
%A int main(int argc,char **argv)
%A {
%A struct msgtype msg;
%A key_t key;
%A int msgid;
%A if(argc!=2)
%A {
%A fprintf(stderr,"Usage:%s string\n\a",argv[0]);
%A exit(1);
%A }
%A if((key=ftok(MSG_FILE,‘a‘))==-1)
%A {
%A fprintf(stderr,"Creat Key Error:%s\a\n",strerror(errno));
%A exit(1);
%A }
%A if((msgid=msgget(key,PERM))==-1)
%A {
%A fprintf(stderr,"Creat Message Error:%s\a\n",strerror(errno));
%A exit(1);
%A }
%A msg.mtype=1;
%A strncpy(msg.buffer,argv[1],BUFFER);
%A msgsnd(msgid,&msg,sizeof(struct msgtype),0);
%A memset(&msg,‘‘,sizeof(struct msgtype));
%A msgrcv(msgid,&msg,sizeof(struct msgtype),2,0);
%A fprintf(stderr,"Client receive:%s\n",msg.buffer);
%A exit(0);
%A }
%A 注意服务端创建的消息队列最后没有删除,我们要使用ipcrm命令来删除的.
%A 4。SystemV共享内存 还有一个进程通信的方法是使用共享内存.SystemV提供了以下几个
%A 函数以实现共享内存.
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/ipc.h>
%A ＃i nclude <sys/shm.h>
%A int shmget(key_t key,int size,int shmflg);
%A void *shmat(int shmid,const void *shmaddr,int shmflg);
%A int shmdt(const void *shmaddr);
%A int shmctl(int shmid,int cmd,struct shmid_ds *buf);
%A shmget和shmctl没有什么好解释的.size是共享内存的大小. shmat是用来连接共享内存
%A 的.shmdt是用来断开共享内存的.不要被共享内存词语吓倒,共享内存其实很容易实现和
%A 使用的.shmaddr,shmflg我们只要用0代替就可以了.在使用一个共享内存之前我们调用s
%A hmat得到共享内存的开始地址,使用结束以后我们使用shmdt断开这个内存.
%A ＃i nclude <stdio.h>
%A ＃i nclude <string.h>
%A ＃i nclude <errno.h>
%A ＃i nclude <unistd.h>
%A ＃i nclude <sys/stat.h>
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/ipc.h>
%A ＃i nclude <sys/shm.h>
%A #define PERM S_IRUSR|S_IWUSR
%A int main(int argc,char **argv)
%A {
%A int shmid;
%A char *p_addr,*c_addr;
%A if(argc!=2)
%A {
%A fprintf(stderr,"Usage:%s\n\a",argv[0]);
%A exit(1);
%A }
%A if((shmid=shmget(IPC_PRIVATE,1024,PERM))==-1)
%A {
%A fprintf(stderr,"Create Share Memory Error:%s\n\a",strerror(errno));
%A exit(1);
%A }
%A if(fork())
%A {
%A p_addr=shmat(shmid,0,0);
%A memset(p_addr,‘‘,1024);
%A strncpy(p_addr,argv[1],1024);
%A exit(0);
%A }
%A else
%A {
%A c_addr=shmat(shmid,0,0);
%A printf("Client get %s",c_addr);
%A exit(0);
%A }
%A }
%A 这个程序是父进程将参数写入到共享内存,然后子进程把内容读出来.最后我们要使用ip
%A crm释放资源的.先用ipcs找出ID然后用ipcrm shm ID删除.
%A 后记:
%A 进程通信(IPC)是网络程序的基础,在很多的网络程序当中会大量的使用进程通信的概念
%A 和知识.其实进程通信是一件非常复杂的事情,我在这里只是简单的介绍了一下.如果你想
%A 学习进程通信的详细知识,最好的办法是自己不断的写程序和看联机手册.现在网络上有
%A 了很多的知识可以去参考.可惜我看到的很多都是英文编写的.如果你找到了有中文的版
%A 本请尽快告诉我.谢谢!
%A
%A 7)Linux程序设计入门--线程操作
%A 前言:Linux下线程的创建
%A 介绍在Linux下线程的创建和基本的使用. Linux下的线程是一个非常复杂的问题,由
%A 于我对线程的学习不时很好,我在这里只是简单的介绍线程的创建和基本的使用,关于线
%A 程的高级使用(如线程的属性,线程的互斥,线程的同步等等问题)可以参考我后面给出的
%A 资料. 现在关于线程的资料在网络上可以找到许多英文资料,后面我罗列了许多链接,对
%A 线程的高级属性感兴趣的话可以参考一下. 等到我对线程的了解比较深刻的时候,我回来
%A 完成这篇文章.如果您对线程了解的详尽我也非常高兴能够由您来完善.
%A 先介绍什么是线程.我们编写的程序大多数可以看成是单线程的.就是程序是按照一定的
%A 顺序来执行.如果我们使用线程的话,程序就会在我们创建线成的地方分叉,变成两个"程
%A 序"在执行.粗略的看来好象和子进程差不多的,其实不然.子进程是通过拷贝父进程的地
%A 址空间来执行的.而线程是通过共享程序代码来执行的,讲的通俗一点就是线程的相同的
%A 代码会被执行几次.使用线程的好处是可以节省资源,由于线程是通过共享代码的,所以没
%A 有进程调度那么复杂.
%A 线程的创建和使用
%A 线程的创建是用下面的几个函数来实现的.
%A ＃i nclude <pthread.h>
%A int pthread_create(pthread_t *thread,pthread_attr_t *attr,
%A void *(*start_routine)(void *),void *arg);
%A void pthread_exit(void *retval);
%A int pthread_join(pthread *thread,void **thread_return);
%A pthread_create创建一个线程,thread是用来表明创建线程的ID,attr指出线程创建时候
%A 的属性,我们用NULL来表明使用缺省属性.start_routine函数指针是线程创建成功后开始
%A 执行的函数,arg是这个函数的唯一一个参数.表明传递给start_routine的参数. pthrea
%A d_exit函数和exit函数类似用来退出线程.这个函数结束线程,释放函数的资源,并在最后
%A 阻塞,直到其他线程使用pthread_join函数等待它.然后将*retval的值传递给**thread_
%A return.由于这个函数释放所以的函数资源,所以retval不能够指向函数的局部变量. pt
%A hread_join和wait调用一样用来等待指定的线程. 下面我们使用一个实例来解释一下使
%A 用方法.在实践中,我们经常要备份一些文件.下面这个程序可以实现当前目录下的所有文
%A 件备份.备份后的后缀名为bak
%A ＃i nclude <stdio.h>
%A ＃i nclude <unistd.h>
%A ＃i nclude <stdlib.h>
%A ＃i nclude <string.h>
%A ＃i nclude <errno.h>
%A ＃i nclude <pthread.h>
%A ＃i nclude <dirent.h>
%A ＃i nclude <fcntl.h>
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/stat.h>
%A ＃i nclude <sys/time.h>
%A #define BUFFER 512
%A struct copy_file {
%A int infile;
%A int outfile;
%A };
%A void *copy(void *arg)
%A {
%A int infile,outfile;
%A int bytes_read,bytes_write,*bytes_copy_p;
%A char buffer[BUFFER],*buffer_p;
%A struct copy_file *file=(struct copy_file *)arg;
%A infile=file->infile;
%A outfile=file->outfile;
%A /* 因为线程退出时,所有的变量空间都要被释放,所以我们只好自己分配内存了 */
%A if((bytes_copy_p=(int *)malloc(sizeof(int)))==NULL) pthread_exit(NULL);
%A bytes_read=bytes_write=0;
%A *bytes_copy_p=0;
%A /* 还记得怎么拷贝文件吗 */
%A while((bytes_read=read(infile,buffer,BUFFER))!=0)
%A {
%A if((bytes_read==-1)&&(errno!=EINTR))break;
%A else if(bytes_read>0)
%A {
%A buffer_p=buffer;
%A while((bytes_write=write(outfile,buffer_p,bytes_read))!=0)
%A {
%A if((bytes_write==-1)&&(errno!=EINTR))break;
%A else if(bytes_write==bytes_read)break;
%A else if(bytes_write>0)
%A {
%A buffer_p+=bytes_write;
%A bytes_read-=bytes_write;
%A }
%A }
%A if(bytes_write==-1)break;
%A *bytes_copy_p+=bytes_read;
%A }
%A }
%A close(infile);
%A close(outfile);
%A pthread_exit(bytes_copy_p);
%A }
%A int main(int argc,char **argv)
%A {
%A pthread_t *thread;
%A struct copy_file *file;
%A int byte_copy,*byte_copy_p,num,i,j;
%A char filename[BUFFER];
%A struct dirent **namelist;
%A struct stat filestat;
%A /* 得到当前路径下面所有的文件(包含目录)的个数 */
%A if((num=scandir(".",&namelist,0,alphasort))<0)
%A {
%A fprintf(stderr,"Get File Num Error:%s\n\a",strerror(errno));
%A exit(1)
%A
%A
%A
%A