{ 0, 1, SEM_UNDO }

 

    void main()
    {
      int fd;
      int semid;
      int ret;
      struct sembuf sops;
      key_t key;
      key = ftok(“/home”,2);
      /*创建信号量*/
      semid = semget(key,1,IPC_CREAT);
      /*获取信号量*/
      sops.sem_num = 0;
      sops.sem_op = -1;
      sops.sem_flg = SEM_UNDO;
      ret = semop(semid,&sops,1);
      printf(“val = %dn”,ret);
      /*取走产品文件*/
      system(“cp ./product.txt ./ship/”);
     }

                                break;

//semaphore header file
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>

     信号量控制把同步进行任务完成

int main(){

 /* char c;
  c=getchar();
  while(c!=’q’)
     in=buf->in;
  sleep(10);*/
  for(i=0;i<8;i++)
  {
     printf(“n producer produce a product xn”);
     P(semid,1);
     P(semid,2);
     buf->buffer[buf->in]=’x’;
     printf(“n pid=%d put into
buffer[%d]n”,getpid(),buf->in);
     buf->in=(buf->in+1)%N;
     V(semid,0);
     v(semid,2);
     //c=getchar();
澳门新葡萄京所有网站,  }
}

    #include <stdlib.h>
    #include <sys/ipc.h>
    #include <sys/sem.h>
    #include <sys/types.h>
    #include <stdio.h>

============    进程2     ================

main(){
  key_t semkey=0x12;
  int i,pid;
  struct databuf*buf;
  initahm(&buf);
  semid=initsem(semkey);
  printf(“n ok n”);
  if((pid=fork())<0)  printf(“fork error!”);
  else if(pid==0)
       {
          fork();
          producer(semid,buf);
       }
       else
       {
          fork();
          consumer(semid,buf);
          waitpid(pid,NULL,0);
          remobj();
       }
}

  /******************************************/      

3.  进程3连接该信号量集,之后将该信号量集删除。

//system V header file
#include<sys/shm.h>
//#include<sys/ipc.h>
//#include<signal.h>
//#include<time.h>

二。生产力消费问题

    }

//
union semun{
  int val;
  struct semid_ds*buf;
  unsigned short *array;
};
union semun arg;

  (3)加入同步控制      

        printf(“semget1  create ok n”);

//
void consumer(int semid,struct databuf*buf){
   int out,i;
   printf(“n cokn”);
   /*char c;
   out=buf->out;*/
   for(i=0;i<8;i++)
   {
       P(semid,0);
       P(semid,2);
       buf->buffer[buf->out]=’x’;
       printf(“n pid=%d get x out from
buffer[%d]n”,getpid(),buf->out);
       buf->out=(buf->out+1)%N;
       V(semid,1);
       V(semid,2);
   }
}

  称为进程间的同步。

return 0;

                               from pac.c:33

  (1)问题描述      

终端1

//
int initsem(key_t semkey){
  int status=0,semid;
  if((semid=semget(semkey,3,SEMPERM|IPC_CREAT|IPC_EXCL))==-1)
  {
     if(errno==EEXIST)  printf(“semid eexist”);
  }
  else
  {
     printf(“semid=%d”,semid);
     arg.val=0;
     if((status=semctl(semid,0,SETVAL,arg))==-1)
        perror(“semctl setval full error!”);
     arg.val=N;
     if((status=semctl(semid,1,SETVAL,arg))==-1)
        perror(“semctl setval empty error!”);
     arg.val=1;
     if((status=semctl(semid,2,SETVAL,arg))==-1)
        perror(“semctl setval mutex error!”);
     if(semid==-1||status==-1)
     {
        perror(“initsem failed”);
        return(-1);
     }
  }
  return(semid);
}

信号量同步

============    进程3     ================

//
int P(int semid,int sem_n){
 // printf(“sem_n=%d”,sem_n);
  struct sembuf p_buf;
     p_buf.sem_num=sem_n;
     p_buf.sem_op=-1;
     p_buf.sem_flg=SEM_UNDO;
  if(semop(semid,&p_buf,1)==-1)
  {
      perror(“P(semid) failed”);
      exit(1);
  }
  return(0);
}

    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <sys/ipc.h>
    #include <sys/sem.h>

    int semid1;

          /user/included/bits/shm.h:40:two or more data types in
declaration of ‘_getpagesize’

一。核心概念

    int i;

#define N 5
//#define ERR ((struct databuf*)-1)

  进程同步核心概念:一组并发进程进行互相合作,互相等待,使得各进程按一定的顺序执行的过程

    }

//
struct databuf{
  int in;
  int out;
  char buffer[5];
}

  (2)问题程序化         

 printf(“semget  ok n”);

#define SEMPERM 0600
#define TRUE 1
#define FALSE 0

    void main()
    {
      int fd;
      int semid;
      struct sembuf sops;
      key_t key;
      key = ftok(“/home”,2);
      /*创建信号量*/
      semid = semget(key,1,IPC_CREAT);
      semctl(semid,0,SETVAL,0);
      /*创建产品-文件*/
      fd = open(“./product.txt”,O_RDWR|O_CREAT,0775);
      /*休息*/
      sleep(20);
      /*向产品文件里面填充内容*/
      write(fd,”the product is finished”,25);
      close(fd);
      /*释放信号量*/
      sops.sem_num = 0;
      sops.sem_op = 1;
      sops.sem_flg = SEM_UNDO;
      semop(semid,&sops,1);
      }

                                case EINTR:  //中断导致加锁失败

错误:in file included from /user/include/sys/shm.h:31

#include <stdlib.h>

这是源码:
#include<errno.h>
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>

[root@localhost shiyan]# ./sem1   //运行进程1

//
void remobj(){
  if(shmctl(shmid,IPC_RMID,NULL)==-1)    printf(“shmctl”);
  if(semctl(semid,0,IPC_RMID,0)==-1)
  {
      if(errno==EIDRM)
        perror(“semctl remobj error EIDRM!”);
  }
}

#include <sys/sem.h>

void initshm(struct databuf**p){
  if((shmid=shmget(0x12,sizeof(struct
databuf*),0600|IPC_CREAT|IPC_EXCL))==-1)
     printf(“shmget”);
  if((*p=(struct databuf*)shmat(shmid,0,0))==((struct databuf*)-1))
     printf(“shmid=%d”,shmid);
}

    semid = semget((key_t)123,0,0);  //连接该信号集

//
void producer(int semid,struct databuf*buf){
  int in,i;
  printf(“n pokn”);

=========================================

//
int V(int semid,int sem_n)
{
  struct sembuf V_buf;
    V_buf.sem_num=sem_n;
    V_buf.sem_op=1;
    V_buf.sem_flg=SEM_UNDO;
  if(semop(semid,&V_buf,1)==-1)
  {
     perror(“V(semid) failed”);
     exit(1);
  }
  return(0);
}

int semid = -1;

static int shmid,semid;

    return 0;

                                default :  //其他加锁失败

[root@localhost shiyan]# gcc -g sem3.c -o sem3

  for(i = 0; i <= 2; i++) {  //信号量加锁操作

        printf(“semget  errnon”);

终端3

default

[root@localhost shiyan]#

#include <string.h>

[root@localhost shiyan]# ./sem3  //运行进程3

========================================

#include <stdio.h>

    }else{

    sleep(60);  //在休眠60秒的时候去运行进程3

=========================================

        return 1;

                        }

运行结果:      

semctl is ok  //该信号集删除成功

=========================================

    }

#include <stdio.h>

    int flg =-1;

      return 0;

       break;

int main(){

   if(semctl(semid, 0, IPC_RMID, 0) < 0) {  //删除该信号集

    int semid;

}

semget ok !

    semid1 = semget((key_t)123, 2, IPC_CREAT|0666); //创建信号量集,里面包含两个信号量

#include <string.h>

static struct sembuf    op_trylock[2] = {  //信号量加锁操作

}

         printf(“semctl is errno n”);

        printf(“semctl is okn”);

#include <string.h>

}else{

============    进程1     ================

       printf(“semop is okn”);

[root@localhost shiyan]# gcc -g sem1.c -o sem1

                                printf(“EINTR n”);

1.  进程1创建信号量集

                                printf(“EAGAIN  n”);

        printf(“semget1 create errnon”);

    usleep(10);

    if(semop(semid, op_trylock, 2) < 0) {

          休眠60秒,运行进程3,连接该信号量集,并将该信号量集删除。看看

    if (-1 == semid1) {

#include <sys/sem.h>

    semid = semget((key_t)123, 0,0);  //连接该信号量集

运行过程:利用进程1创建信号量集,利用进程2连接该信号量进行加锁操作,在

                                case EAGAIN:  //再试一次加锁

  return 1;

=============    信号量      =============

    }else{

        printf(“semop lock is errno, errno %d n”,errno);

[root@localhost shiyan]# gcc -g sem2.c -o sem2

};

[root@localhost shiyan]#

                                break;

       printf(“semget ok !n”);

semget  ok   //之后在休眠60秒的时候,去运行进程3

#include <sys/sem.h>

#include <stdio.h>

#include <errno.h>

}

#include <stdlib.h>

int main(){

  if(1==flg){

2.  进程2连接该信号量集,sleep(60)——休眠60秒,之后利用该信号量进行加锁

       在运行进程3,也可以将这么多都至于一个进程中处理。

          进程2在60秒之后进行的加锁操作————肯定失败,就是要验证这个

                                        return -2;

        { 0, 0, IPC_NOWAIT },

终端2

}

       printf(“semget errno !n”);

                                switch(errno) {

semget1  create ok

       flg = 1;

       要实现进程间通信的同步,就可以使用信号量。

  }

    if (-1 == semid) {

                                      printf(“default  n”);

    }else{

  }

追加: 当然可以在进程2中,加锁成功之后做一些操作,之后要删除该信号量集

semop lock is errno, errno 22 //休眠60秒之后,由于进程3将该信号量集删除,所以加锁失败

    }

    }else{

       return 1;

[root@localhost shiyan]# ./sem2  //运行进程2

    if(-1 == semid){

=========================================

         return -1;

#include <stdlib.h>

        return 1;