book.c

一个模拟图书经营系统的程序,在linux的gcc环境下编译的,利用了多线程的pthread.h函数,希望对大家在linux下编写程序有所借鉴!

   lack_p->next = lack_A;
   lack_A = lack_p;
   printf("/*%c %d %d*/\n", lack_p->store_id, lack_p->book_id, lack_p->lack_num);
  } 
  pthread_mutex_unlock(&mutex_lack_A);
 }
 if (press_id == 'B')
 {
  printf("/*Enroll into B*/\n");
  pthread_mutex_lock(&mutex_lack_B);
  if (lack_B->book_id == 0)
  {
   lack_p->next = lack_B->next;
   lack_B = lack_p;
   printf("/*%c %d %d*/\n", lack_p->store_id, lack_p->book_id, lack_p->lack_num);
  } 
  else
  {
   lack_p->next = lack_B;
   lack_B = lack_p;
   printf("/*%c %d %d*/\n", lack_p->store_id, lack_p->book_id, lack_p->lack_num);
  }
  pthread_mutex_unlock(&mutex_lack_B);
 }
 printf("/***%c %d %d*/\n", lack_p->store_id, lack_p->book_id, lack_p->lack_num);
 
 /********/
 p = (struct lack_info *)malloc(LEN_LACK);
 p = lack_A;
 printf("Lack_A:\n");
 while (p != NULL)
 {
  printf("/*%c %d %d*/\n", p->store_id, p->book_id, p->lack_num);
  p = p->next;
 }
 p = lack_B;
 printf("Lack_B:\n");
 while (p != NULL)
 {
  printf("/*%c %d %d*/\n", p->store_id, p->book_id, p->lack_num);
  p = p->next;
 }
 /*********/
 free(p);
 free(lack_p);
}

/*call_back*/
void call_back(char press_id, int book_id)
{
 struct lack_info *p;
 struct lack_info *head;
 struct lack_info *lack_p;
 struct lack_info *lack_p_last;
 pthread_mutex_t mutex_lack;
 int order(char, char, int, int);
 
 printf("/****Call Back...*****/\n"); 
 /************/
 p = (struct lack_info *)malloc(LEN_LACK);
 p = lack_A;
 printf("Lack_A:\n");
 while (p != NULL)
 {
 	
  printf("%d %d %d\n", p->store_id, p->book_id, p->lack_num);
  p = p->next;
 }
 
 p = lack_B;
 printf("Lack_B:\n");
 while (p != NULL)
 {
 	
  printf("/*%d %d %d*/\n", p->store_id, p->book_id, p->lack_num);
  p = p->next;
 }
 free(p);
 /***********/
 lack_p = (struct lack_info *)malloc(LEN_LACK);
 lack_p_last = (struct lack_info *)malloc(LEN_LACK);
 if (press_id == 'A')
 {
  head = lack_A;
  mutex_lack = mutex_lack_A; 
 }
 if (press_id == 'B')
 {
  head = lack_B;
  mutex_lack = mutex_lack_B;
 }
 lack_p = head;
 while (lack_p != NULL)
 {
  if (lack_p->book_id == book_id)
  {
   printf("/***************/\n");
   printf("/**store_id = %c**/\n", lack_p->store_id);
   printf("/**book_id = %d**/\n", lack_p->book_id);
   order(press_id, lack_p->store_id, book_id, lack_p->lack_num);
   printf("/***************/\n");
   pthread_mutex_lock(&mutex_lack);
   if (lack_p == head) head = lack_p->next;
   else lack_p_last->next = lack_p->next;
   pthread_mutex_unlock(&mutex_lack);
  }
  lack_p_last = lack_p;
  lack_p = lack_p->next; 
 }
 free(head);
 free(lack_p);
 free(lack_p_last);
 printf("/****End of Call Back*****/\n"); 
} 

/*reprint*/
void reprint(char press_id, int book_id, int book_num)
{
 FILE *fp;
 int reprint_sum;
 time_t time_reprint;
 struct book *press_p;
 pthread_mutex_t mutex_press;
 
 press_p = (struct book *)malloc(LEN);
 reprint_sum = book_num;
 if (book_num == MANEGE)
 {
  printf("Now need %d at least, please the administrator input the reprint book's sum :", book_num);
  scanf("%d", &reprint_sum);
 }
 if (press_id == 'A')
 {
  press_p = head_A;
  mutex_press = mutex_A;
 } 
 if (press_id == 'B')
 {
  press_p = head_B;
  mutex_press = mutex_B;
 } 
 while (press_p != NULL)
 {
  if (press_p->id == book_id)
  {
   pthread_mutex_lock(&mutex_press);
   press_p->num += reprint_sum;
   press_p->sign = REPRINT;
   time(&time_reprint);
   printf("/*Reprint book%d*/\n", book_id);
   pthread_mutex_unlock(&mutex_press);
   break;
  }
  press_p = press_p->next;
 }
 fp = fopen("book.txt", "a");
 pthread_mutex_lock(&mutex_book);
 fprintf(fp, "Press%c Reprint book%d %s %d remain %d at %s", press_id, book_id, press_p->sort, reprint_sum, press_p->num, ctime(&time_reprint));
 pthread_mutex_unlock(&mutex_book);   
 fclose(fp);
 fp = fopen("work.txt", "a");
 pthread_mutex_lock(&mutex_work);
 fprintf(fp, "Press%c Reprint book%d %s %d remain %d at %s", press_id, book_id, press_p->sort, reprint_sum, press_p->num, ctime(&time_reprint));
 pthread_mutex_unlock(&mutex_work);   
 fclose(fp);
 fp = fopen("work~.txt", "a");
 pthread_mutex_lock(&mutex_work_tmp);
 fprintf(fp, "Press%c Reprint book%d %s %d remain %d at %s", press_id, book_id, press_p->sort, reprint_sum, press_p->num, ctime(&time_reprint));
 pthread_mutex_unlock(&mutex_work_tmp);
 fclose(fp);
 /***********/
   press_p = head_A;
   while (press_p != NULL)
   {
    printf("-A-%d %d %s %d--\n", press_p->sign, press_p->id, press_p->sort, press_p->num);
    press_p = press_p->next;
   }
   press_p = head_B;
   while (press_p != NULL)
   {
    printf("-B-%d %d %s %d--\n", press_p->sign, press_p->id, press_p->sort, press_p->num);
    press_p = press_p->next;
   }
   /**************/
 free(press_p);
 
 call_back(press_id, book_id);
}

/*order*/
int order(char press_id, char store_id, int book_id, int book_num)
{
 FILE *fp;
 int lack_num;
 time_t time_order;
 struct book *press_p;
 struct book *store_p;
 pthread_mutex_t mutex_press;
 pthread_mutex_t mutex_store;
 
 printf("/*Order: %c %c %d %d*/\n", press_id, store_id, book_id, book_num);
 press_p = (struct book *)malloc(LEN);
 store_p = (struct book *)malloc(LEN);
 if (press_id == 'A') 
 {
  press_p = head_A;
  mutex_press = mutex_A;
 } 
 if (press_id == 'B')
 {
  press_p = head_B;
  mutex_press = mutex_B;
 } 
 switch (store_id)
 {
  case 'C': store_p = head_C; mutex_store = mutex_C; break;
  case 'D': store_p = head_D; mutex_store = mutex_D; break;
  case 'E': store_p = head_E; mutex_store = mutex_E; break;
  default: break;
 }
 while ((press_p->id) != book_id)
 {
  printf("%c-%d %d %s %d-\n", press_id, press_p->sign, press_p->id, press_p->sort, press_p->num);
  if (press_p->next == NULL)
  {
   free(press_p);
   free(store_p);
   return(ERROR);
  } 
  press_p = press_p->next;
 } 
 printf("%c-%d %d %s %d-\n", press_id, press_p->sign, press_p->id, press_p->sort, press_p->num);
 while ((store_p->id) != book_id)
 {
  if (store_p->next == NULL)
  {
   free(press_p);
   free(store_p);
   return(ERROR);
  } 
  store_p = store_p->next;
 } 
 if (press_p->num > 0)
 {
  printf("/*******Order...********/\n");
  pthread_mutex_lock(&mutex_press);
  if ((press_p->num) < book_num)
  {
   printf("/*****< of Order******/\n");
   lack_num = book_num-(press_p->num);
   pthread_mutex_lock(&mutex_store);
   store_p->num += press_p->num;
   pthread_mutex_unlock(&mutex_store); 
   press_p->num = 0;
   time(&time_order);
   pthread_mutex_unlock(&mutex_press);
   fp = fopen("work.txt", "a");
   pthread_mutex_lock(&mutex_work);
   fprintf(fp, "store%c order book%d %s %d from press%c remain %d at %s", store_id, book_id, press_p->sort, book_num-lack_num, press_id, store_p->num, ctime(&time_order));
   pthread_mutex_unlock(&mutex_work);   
   fclose(fp);
   fp = fopen("work~.txt", "a");
   pthread_mutex_lock(&mutex_work_tmp);
   fprintf(fp, "store%c order book%d %s %d from press%c remain %d at %s", store_id, book_id, press_p->sort, book_num-lack_num, press_id, store_p->num, ctime(&time_order));
   pthread_mutex_unlock(&mutex_work_tmp);
   fclose(fp);
   free(press_p);
   free(store_p);
   printf("/*****End of Order******/\n");
   return(lack_num);
  }else
  {
   printf("/*****>= of Order******/\n");
   press_p->num -= book_num;
   pthread_mutex_unlock(&mutex_press);
   pthread_mutex_lock(&mutex_store);
   store_p->num += book_num;
   pthread_mutex_unlock(&mutex_store);
   fp = fopen("work.txt", "a");
   pthread_mutex_lock(&mutex_work);
   fprintf(fp, "store%c order book%d %s %d from press%c remain %d at %s", store_id, book_id, press_p->sort, book_num, press_id, store_p->num, ctime(&time_order));
   pthread_mutex_unlock(&mutex_work);   
   fclose(fp);
   fp = fopen("work~.txt", "a");
   pthread_mutex_lock(&mutex_work_tmp);
   fprintf(fp, "store%c order book%d %s %d from press%c remain %d at %s", store_id, book_id, press_p->sort, book_num, press_id, store_p->num, ctime(&time_order));
   pthread_mutex_unlock(&mutex_work_tmp);
   fclose(fp);
   free(press_p);
   free(store_p);
   printf("/*****End of Order******/\n");
   return(0);
  }
 }
}

/*C_auto_order*/
void C_auto_order(void)
{
 struct book *store_p;
 int book_num;
 int order_result;
  
 while (1)
 {
  sleep(AUTO_ORDER_DELAY);
  store_p = (struct book *)malloc(LEN);
  store_p = head_C;
  while (store_p != NULL)
  {
   if (store_p->num == 0)
   {
    if (strcmp(store_p->sort, "science  ") == 0) book_num = BOOK_SUM_MAX;
    else book_num = BOOK_SUM_MIN;
    order_result = order('A', 'C', store_p->id, book_num);
    printf("%d\n", order_result);
    switch(order_result)
    {
     case -1: order_result = order('B', 'C', store_p->id, book_num);
             printf("%d\n", order_result);
			 if (order_result > 0)
             {
              printf("/*****Enroll B*********/\n");
              enroll('B', 'C', store_p->id, order_result);
			  if (order_result <= LACK_CTRL) reprint('B', store_p->id, LACK_CTRL);
              else reprint('B', store_p->id, MANEGE);
			 }
             break;
     case  0: break;
     default : printf("/*****Enroll A*********/\n");
   	     enroll('A', 'C', store_p->id, order_result);
	     if (order_result <= LACK_CTRL) reprint('A', store_p->id, LACK_CTRL);
             else reprint('A', store_p->id, MANEGE);
             break;
    }
   }
   store_p = store_p->next;
  }
  free(store_p);
 }
}

/*D_auto_order*/
void D_auto_order(void)
{
 struct book *store_p;
 int book_num;
 int order_result;
  
 while (1)
 {
  sleep(AUTO_ORDER_DELAY);
  store_p = (struct book *)malloc(LEN);
  store_p = head_D;
  while (store_p != NULL)
  {
   if (store_p->num == 0)
   {
    if (strcmp(store_p->sort, "forigen  ") == 0) book_num = BOOK_SUM_MAX;
    else book_num = BOOK_SUM_MIN;
    order_result = order('A', 'D', store_p->id, book_num);
    switch(order_result)
    {
     case -1: order_result = order('B', 'D', store_p->id, book_num);
             if (order_result != 0)
             {
              enroll('A', 'D', store_p->id, order_result);
	      if (order_result <= LACK_CTRL) reprint('B', store_p->id, LACK_CTRL);
              else reprint('B', store_p->id, MANEGE);
			 }
             break;
     case  0: break;
     default : enroll('A', 'D', store_p->id, order_result);
	     if (order_result <= LACK_CTRL) reprint('A', store_p->id, LACK_CTRL);
             else reprint('A', store_p->id, MANEGE);
             break;
    }
   }
   store_p = store_p->next;
  }
  free(store_p);
 }
}

/*E_auto_order*/
void E_auto_order(void)
{
 struct book *store_p;
 int book_num;
 int order_result;
  
 book_num = BOOK_SUM_MIN;
 while (1)
 {
  sleep(AUTO_ORDER_DELAY);
  store_p = (struct book *)malloc(LEN);
  store_p = head_E;
  while (store_p != NULL)
  {
   if (store_p->num == 0)
   {
    order_result = order('A', 'E', store_p->id, book_num);
    switch(order_result)
    {
     case -1: order_result = order('B', 'E', store_p->id, book_num);
             if (order_result != 0)
             {