Linux多线程二

 互斥锁和条件变量

 

// //模拟黄牛抢票，100张票，共有四个黄牛在抢票
// #include <stdio.h>
// #include <errno.h>
// #include <unistd.h>
// #include <stdlib.h>
// #include <pthread.h>

// int ticket = 100;
// pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//定义初始化锁

// void* thr_start(void* arg){
//     while(1){
//         pthread_mutex_lock(&mutex);
//         if(ticket > 0){
//             usleep(1);
//             printf("yellow bull : %d----get ticket : %d\n",(int)arg,ticket);
//             ticket--;
//         }else{
//             pthread_mutex_unlock(&mutex);
//             pthread_exit(NULL);
//         }
//         pthread_mutex_unlock(&mutex);
//     }
//     return NULL;
// }

// int main(int argc, char* argv[]){
//     pthread_t tid[4];
//     int i = 0,ret;
    
//     pthread_mutex_init(&mutex,NULL);
//     for(;i < 4; ++i){
//         ret = pthread_create(&tid[i],NULL,thr_start,(void*)i);
//         printf("jj=%d\n",i);
//         //pthread_join(tid[i],NULL);
//         if(ret != 0){
//             printf("yellow bull no exit!");
//             return -1;
//         }
//     }
//     for(i = 0;i < 4;++i){
//         pthread_join(tid[i],NULL);
//         printf("jyyyj=%d\n",i);
//     }
//     pthread_mutex_destroy(&mutex);
// 	return 0;
// }


 //模拟一个skr与cxk使用比赛舞台的Demo                                  
  #include <stdio.h>    
  #include <pthread.h>    
  #include <unistd.h>    
  #include <errno.h>    
  #include <stdlib.h>    
      
  int have_stage = 1;    
      
  pthread_cond_t skr;    
  pthread_cond_t cxk;    
  pthread_mutex_t mutex;    
      
  void* thr_skr(void* arg){//skr此时要上台dancing    
    while(1){    
      pthread_mutex_lock(&mutex);    
      //若此时舞台有人用，那么skr进行等待    
      while(have_stage == 1){    
        pthread_cond_wait(&skr,&mutex);    //满足条件，线程等待。会自动释放锁
      }    
      //舞台被人使用了，此时0；因为之前1，代表可以使用    
      printf("skr~~ is freestyle!!!\n");    
      sleep(1);    
      //跳完舞后舞台空了出来    
      have_stage += 1;    
      //有舞台了，叫cxk来使用    
      pthread_cond_signal(&cxk);    
      pthread_mutex_unlock(&mutex);
    }
    return NULL;
  }
  
  void* thr_cxk(void* arg){
    while(1){
      pthread_mutex_lock(&mutex);
      //没有舞台，那么在这里等待
      while(have_stage == 0){
        pthread_cond_wait(&cxk,&mutex);
      }
      //有了舞台就是可以唱跳rap篮球了。。
      printf("cxk~~ is singing,dancing,playing rapping and basketball!!\n");
      sleep(1);
      have_stage -= 1;
      //跳完还想跳。。因此叫skr快跳完换他跳。。
      pthread_mutex_unlock(&mutex);
      pthread_cond_signal(&skr);//唤醒skr，
    }
    return NULL;
  }  
    int main(int argc,char * argv[]){
    pthread_t tid1,tid2;
    int ret;
      
    pthread_cond_init(&skr,NULL);
    pthread_cond_init(&cxk,NULL);
    pthread_mutex_init(&mutex,NULL);

    int i = 0;
    //for(i = 0;i < 2;i++){
      ret = pthread_create(&tid1,NULL,thr_skr,NULL);
      if(ret != 0){
        printf("skr error");
        return -1;
      }
    //}
    //for(i = 0;i < 2; i++){
      ret = pthread_create(&tid2,NULL,thr_cxk,NULL);
      if(ret != 0){
        printf("cxk error");
        return -1;
      }
    //}
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
  
    pthread_cond_destroy(&skr);
    pthread_cond_destroy(&cxk);
    pthread_mutex_destroy(&mutex);
    return 0;
  } 

 

 信号量

/*#########################################################
多线程开发的最基本概念主要包含四点：线程，互斥锁，条件变量、读写锁。
其中，线程操作又分线程的创建，退出，等待 3 种。
互斥锁则包括 4 种操作，分别是创建，销毁，加锁和解锁。
条件操作有 5 种操作：创建，销毁，触发，广播和等待
##########################################################*/

// #include <stdio.h>
// #include <pthread.h>
// #include <unistd.h>
// #include <string.h>

 
// void print_message_func(void *ptr);
 
// int main()
// {
//     int tmp1,tmp2;
//     void *retival;
//     pthread_t thread1,thread2;
//     char *message1 = "thread1";
//     char *message2 = "thread2";
 
//     int ret_thread1,ret_thread2;
//     ret_thread1 = pthread_create(&thread1,NULL,(void *)&print_message_func,(void *)message1);
 
//     if(ret_thread1 == 0)
//         printf("create thread 1 true\n");
//     else
//         printf("create thread 1 false\n");
 
//     tmp1 = pthread_join(thread1,&retival);
//     printf("thread 1 return value (tmp1) is %d\n",tmp1);
 
//     if(tmp1 != 0)
//         printf("cannot join with thread 1\n");
 
//     ret_thread2 = pthread_create(&thread2,NULL,(void *)&print_message_func,(void *)message2);
 
//     if(ret_thread2 == 0)
//         printf("create thread 2 true\n");
//     else
//         printf("create thread 2 false\n");
 
//     tmp2 = pthread_join(thread2,&retival);
//     printf("thread 2 return value (tmp2) is %d\n",tmp2);
//     if(tmp2 != 0)
//         printf("cannot join with thread 2\n");
// }
 
// void print_message_func(void *ptr)
// {
//     for(int i=0;i<5;++i)
//     {
//         printf("%s:%d\n",(char *)ptr,i); //强制类型转换
//     }
// }

// #include <stdio.h>
// #include <stdlib.h>
// #include <pthread.h>
 
// int sharei = 0;
// void increase_num(void);

// pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//初始化锁位解锁状态
 
// int main()
// {
//   int ret;
//   pthread_t thread1,thread2,thread3;
//   ret = pthread_create(&thread1,NULL,(void *)&increase_num,NULL);
//   ret = pthread_create(&thread2,NULL,(void *)&increase_num,NULL);
//   ret = pthread_create(&thread3,NULL,(void *)&increase_num,NULL);
 
//   pthread_join(thread1,NULL);
//   pthread_join(thread2,NULL);
//   pthread_join(thread3,NULL);
 
//   printf("sharei = %d\n",sharei);
 
//   return 0;
// }
 
// void increase_num(void)
// {
//   long i,tmp;
//   for(i =0;i<=10000;++i)
//   {

//       if(pthread_mutex_lock(&mutex) !=0)//（阻塞加锁）访问临界区加锁操作
//       {
//           perror("pthread_mutex_lock");
//           exit(EXIT_FAILURE);
//       }

//     tmp = sharei;
//     tmp = tmp + 1;
//     sharei = tmp;

//       if(pthread_mutex_unlock(&mutex) !=0)//访问临界区解锁操作
//       {
//           perror("pthread_mutex_unclock");
//           exit(EXIT_FAILURE);
//       }
//   }
// }

/*#########################################################################

int sem_init(sem_t * sem, int pshared, unsigned int value);初始化信号量
    - 成功返回0，失败返回-1；
    - 参数sem：表示指向信号结构的指针。
    - 参数pshared：不是0 的时候该信号量在进程间共享，否则只能在当前进程的所有线程间共享。
    - 参数value：信号量的初始值。

int sem_wait(sem_t *sem); 信号量减一操作，有线程申请资源
    - 成功返回0，否则返回-1
    - 参数sem：指向一个信号量的指针

int sem_post(sem_t *sem); 信号量加一操作，有线程释放资源
    - 成功返回0，否则返回-1
    - 参数sem：指向一个信号量指针

int sem_destroy(sem_t *sem); 销毁信号量。
    - 成功返回0，否则返回-1
    - 参数sem：指向一个信号量的指针。

########################################################################*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
 
#define MAXSIZE 10
 
int stack[MAXSIZE];
 
int size =0;
sem_t sem;
 
 void privide_data(void)
 {
   int i;
   for(i =0;i<MAXSIZE;++i)
   {
     stack[i] = i;
     printf("%d\n",stack[i]);
     sem_post(&sem);//信号量加1，释放资源
     //printf("%d",stack[i]);
   }
 }
 
void handle_data(void)
{
  int i;
  while((i = size ++) <MAXSIZE)
  {
    sem_wait(&sem);//信号量减一，申请资源
    printf("cross : %d X %d = %d \n",stack[i],stack[i],stack[i] * stack[i]);
    sleep(1);
  }
}
 
int main()
{
  pthread_t privider,handler;
  sem_init(&sem,0,0);
  pthread_create(&privider,NULL,(void *)&privide_data,NULL);
  pthread_create(&handler,NULL,(void *)&handle_data,NULL);
  pthread_join(privider,NULL);
  //pthread_join(handler,NULL);
  sem_destroy(&sem);
 
  return 0;
}