生产者与消费者问题

由于系统中的进程存在并发问题并且为了能够让进程起到1+1>2的效果，因此进程间的同步和通信很重要。
 

                               并发--------------提高效率-------------产生矛盾（资源竞争）
                                1>并发：进程间资源共享的问题。竞争和同步
                                     “进程------资源---------进程”：间接关系（竞争）
                                 2>功能的互补合作：-----相互协作完成-------同步关系
                                      “进程---------------------进程”：直接关系（同步）
 临界资源（critical resource）：系统中一次只允许一个进程访问的资源。
 例如：ps | wc ,管道为临界资源
 临界区：并发执行的进程中访问临界资源的必须互斥执行的程序段叫作临界区
 例如：p1...............                                         p2..............
              c1 :a :=a+1;                                        c2:a=a+1;
                  print(a);                                               print(a);
              ................                                            ..............
           p3...............
            if  a<0 then
                a:=a+1
            else
                a:=a+1
             ..................
此时：a为临界资源，c1、c2、c3都访问了a，因此都是临界区需要对a进行互斥访问
进入临界区的原则：1、空则让进2、忙则等待、3、有限等待 4、让全等待 ----处于等待状态的进程需要放弃cpu
互斥问题的解决：
                        硬件：硬件指令和屏蔽中断
                         软件：编程解决、缺点：忙则等待
 因为cpu从一个进程的链接道另一个进程是由于时间中断（时间片到了），或者由其他中断引起
开关中断可以保证进程互斥进入临界资源。
信号量   c语言的描述
struct semaphore {
   int value;
  struct head_list *L;
};
struct semaphore  S;
信号量的使用：1>必须置一次且置一次初值
                        2>初值不能为负数
                        3>对于信号量，只允许之心wait、signal（PV）操作
PV操作为原语操作
P操作：
void wait_C (struct semaphore S )
{
    S.value = S.value-1;
    if(S.value < 0)
       block(S.L);//如果该资源已经被访问了，那么此进程自我阻塞，挂载在阻塞队列内部。
}
V操作：
void signal_C(struct semaphore S)
{
  S.value=S.vale-1;
  if(S.value >=0)
          wakeup(S.L);如果在阻塞队列中还有进程在等待，那么去唤醒
}
在V操作中S.value<0时绝对值表示 在等待队列还有多少进程在等待。

#include
#include
#include
#include
#include
#include
#include

#define MAXSHM 5  //定义缓冲区数组的下标变量个数

/*        定义3个信号量的内部标识  */

int fullid;
int emptyid;
int mutexid;

/* 主函数  */
int main()
{
 /*  定义2个共享内存的ID  */
 int arrayid;
 int getid;
 /*  定义共享内存虚拟地址  */
 int *array;
 int *get;
    /* 创建共享内存  */
 arrayid=shmget(IPC_PRIVATE,sizeof(int) *MAXSHN,IPC_CREAT|0666);
 getid=shmget(IPC_PRIVATE,sizeof(int),IPC_CREAT|0666);
    /*  初始化共享内存  */
 array=(int *) shmat(arrayid,0,0);
 get=(int *) shmat(getid,0,0);
 *get=0;
    /* 定义信号量数据结构 */
 struct sembuf  P,V;
 union semun arg;
    /* 创建信号量  */
 fullid=semget(IPC_PRIVATE,1,IPC_CREAT|0666);
 emptyid=semget(IPC_PRIVATE,1,IPC_CREAT|0666);
 mutexid=semget(IPC_PRIVATE,1,IPC_CREAT|0666);
    /*初始化信号量 */
 arg.val=0;            //初始时缓冲区中无数据
 if(semctl(fullid,0,SETVAL,arg)==-1)
  perror("semctl setval error");
 arg.val=MAXSHM;       //初始时缓冲区中有5个空闲的数组元素
 if(semctl(emptyid,0,SETVAL,arg)==-1)
  perror("semctl setval error");
 arg.val=1;            //初始时互斥信号为1，允许一个进程进入
 if(semctl(mutexid,0,SETVAL,arg)==-1)
        perror("semctl setval error");

    /* 初始化 P  V操作  */
 P.sem_num=0;
 P.sem_op=-1;
 P.sem_flg=SEM_UNDO;
    V.sem_num=0;
 V.sem_op=1;
 V.sem_flg=SEM_UNDO;

    /*   生产者进程  */
 if(fork()==0)
 {
  int i=0;
  int set=0;
  while(i<10)
  {
   semop(emptyid,&P,1);         //对 emptyid执行P操作
   semop(mutexid,&P,1);         //对 mutexid执行 P操作
   array[set%MAXSHM]=i+1;
   printf("Producer put number %d to No.%d\n",array[set%MAXSHM],set%MAXSHM);
   set++;                       //写计数加1
   semop(mutexid,&V,1);         //对mutexid执行 V 操作
   semop(fullid,&V,1);          //对fullid执行 V 操作
   i++;
  }
  sleep(3);                    //SLEEP 3秒，等待消费者进程执行完毕
  printf("Poducer if over\n");
  exit(0);
 }
 else
 {
  /*  消费者A进程  */
  if(fork()==0)
  {
   while(1)
   {
    if(*get==10)
     break;
    semop(fullid,&P,1);        //对fullid执行 P 操作
    semop(mutexid,&P,1);       //对mutexid执行 P 操作
    printf("The ConsumerA get number from No.%d\n",(*get)%MAXSHM);
    (*get)++;                   //读计数加1
    semop(mutexid,&V,1);        //对mutexid执行 V 操作
    semop(emptyid,&V,1);        //对fullid执行 V 操作
    sleep(1);
   }
   printf("ConsunerA is over\n");
   exit(0);
  }
  else
  {
     /*消费者B进程  */
   if(fork()==0)
   {
    while(1)
    {
     if(*get==10)
      break;
       semop(fullid,&P,1);       //对fullid执行 P 操作
    semop(mutexid,&P,1);      //对mutexid执行 P 操作
    printf("The ConsumerA get number from No.%d\n",(*get)%MAXSHM);
    (*get)++;                 //读计数加1
    semop(mutexid,&V,1);      //对mutexid执行 V 操作
    semop(emptyid,&V,1);      //对emptyid执行 V 操作
    sleep(1);
   }
   printf("ConsunerB is over\n");
   exit(0);
   }
  }
 }

 /*   父进程返回后回收3个子进程  */
 wait(0);
 wait(0);
 wait(0);
 
 /*  断开并撤消2个共享内存  */
 shmdt(array);
 shmctl(arrayid,IPC_RMID,0);
 shmctl(get);
 shmctl(getid,IPC_RMID,0);
 /*   撤消3个信号量集  */
 semctl(emptyid,IPC_RMID,0);
 semctl(fullid,IPC_RMID,0);
 semctl(mutexid,IPC_RMID,0);
 exit(0);
 }

哲学家就餐问题

   题目：有五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在桌上有五个碗和五只筷子，他们的生活

方式是思考和进餐。平时，一个哲学家进行思考，饥饿时就便试图去他们呢左右的筷子来就餐。只有在他拿到两

个筷子时才能就餐。

  分析：

       哲学家思考问题时，他旁边的筷子允许被别的哲学家拿起。因此，筷子为临界资源。

  实现：

      process i

           repate :

                 思考；

           p[c[i]];

           p[c[i+1]]mod 5;

           进食

           v[c[i]];

           v[c[i+1]]mod 5;

      unfail flase;

但是可能会产生死锁：一个哲学家只拿到一个筷子。

1>再加一个筷子

2>给个时间限定t，如果处于死锁状态且持续时间超过t，则该进程放弃自己拥有的资源，放入就需队列。

3>只允许其中4个哲学家先竞争。

4>在拥有坐筷子情况下，试着去判断右筷子是否空闲，如果空闲则拿起右筷子否则将左筷子释放。

 代码实现：

文件 local_eat.h

#ifndef _LOCAL_EAT_H
#define _LOCAL_EAT_H

#include
#include
#include
#include

#define MAX  5
pthread_mutex_t  mutex[MAX];
pthread_cond_t   cond[MAX];
char name[MAX][20] = {"laozi","makesi","engesi","xunzi","sugeladi"};

void* eating(void * counter);
#endif

文件phil.c

#include"local_eat.h"

void * eating(void *counter)
{
 

   int cnt = *((int*)counter);

    printf("%d :%s is thinking\n",cnt,name[cnt]);
    while(1) {
        pthread_mutex_lock(mutex+cnt);
        if(!pthread_mutex_trylock(mutex+((cnt+1)%MAX)))
            //pthread_cond_wait(cond+(cnt+1)%MAX,mutex+((cnt+1)%MAX));
            pthread_cond_wait(cond+cnt,mutex+cnt);
        printf("%d :%s is eating\n",cnt,name[cnt]);
        printf("%d :%s  has eat up\n",cnt,name[cnt]);
        pthread_mutex_unlock(mutex+cnt);
        pthread_mutex_unlock(mutex+((cnt+1)%MAX));
        //pthread_cond_signal(cond+((cnt+1)%MAX));
        pthread_cond_signal(cond+cnt);
        sleep(1);
    }
    return NULL;
}
int main()
{
    int index = 0;
    pthread_t pthread[MAX];

    for(index = 0; index < MAX;index++)
         pthread_mutex_init(mutex+index,NULL);
    for(index =0; index< MAX;index++)
         pthread_cond_init(cond+index,NULL);
    for(index=0;index         printf(" index = %d\n",index);
        pthread_create(pthread+index,NULL,(void*)eating,(void*)&index);
    }
   
    for(index = 0; index < MAX;index++)
         pthread_mutex_destroy(mutex+index);
    for(index =0; index< MAX;index++)
         pthread_cond_destroy(cond+index);
    return 0;
}