学习笔记——操作系统_Linux互斥锁

本文章有部分属于个人理解，并从网页上摘抄了代码，包括：

http://www.linuxidc.com/Linux/2011-03/33227.htm

http://blog.csdn.net/chengfangang/article/details/7304617

http://blog.csdn.net/leo115/article/details/8037869（这篇Blog写的不错）

Linux的互斥锁

可以把互斥锁看作某种意义上的全局变量。在同一时刻只能有一个线程掌握某个互斥上的锁，拥有上锁状态的线程能够对共享资源进行操作。若其他线程希望上锁一个已经上锁了的互斥锁，则该线程就会挂起，直到上锁的线程释放掉互斥锁为止。可以说，这把互斥锁使得共享资源按序在各个线程中操作。

简单直接的互斥锁需要满足以下严格的语义环境：

• l 任意时刻拥有此互斥锁的任务不能超过一个
• l 互斥锁的拥有者才能解锁
• l 不允许多处解锁
• l 不允许嵌套锁
• l 互斥锁对象需要通过接口来初始化
• l 拥有锁期间，任务不能退出
• l 获得锁的内存区域不能随便被释放

互斥锁的操作主要包括以下几个步骤：

• 互斥锁初始化：pthread_mutex_init
• 互斥锁上锁：pthread_mutex_lock
• 互斥锁判断上锁：pthread_mutex_trylock
• 互斥锁解锁：pthread_mutex_unlock
• 消除互斥锁：pthread_mutex_destroy

其中，互斥锁可以分为快速互斥锁、递归互斥锁和检错互斥锁。这三种锁的区别主要在于其他未占有互斥锁的线程在希望得到互斥锁时的是否需要阻塞等待。

• 快速锁是指调用线程会阻塞直至拥有互斥锁的线程解锁为止。
• 递归互斥锁能够成功地返回并且增加调用线程在互斥上加锁的次数。
• 检错互斥锁则为快速互斥锁的非阻塞版本，它会立即返回并返回一个错误信息。

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr)//互斥锁初始化函数
mutexattr =  PTHREAD_MUTEX_INITIALIZER：创建快速互斥锁,快速锁是指调用线程会阻塞直至拥有互斥锁的线程解锁为止
PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP：创建递归函数传入值 Mutexattr 互斥锁,递归互斥锁能够成功地返回并且增加调用线程在互斥上加锁的次数
PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP：创建检错互斥锁,而检错互斥锁则为快速互斥锁的非阻塞版本.
    int pthread_mutex_lock(pthread_mutex_t *mutex,)    //互斥锁上锁
    int pthread_mutex_trylock(pthread_mutex_t *mutex,) //互斥锁判断上锁
    int pthread_mutex_unlock(pthread_mutex_t *mutex,)  //互斥锁接锁
    int pthread_mutex_destroy(pthread_mutex_t *mutex,) //消除互斥锁

//实例:
   /*mutex.c*/
   #include <stdio.h>
   #include <stdlib.h>
   #include <unistd.h>
   #include <pthread.h>
   #include <errno.h>
   pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
   int lock_var;
   time_t end_time;
   void pthread1(void *arg);
   void pthread2(void *arg);
   int main(int argc, char *argv[])
  {
    pthread_t id1,id2;
    pthread_t mon_th_id;
    int ret;
    end_time = time(NULL)+10;
   /*互斥锁初始化*/
     pthread_mutex_init(&mutex,NULL);
   /*创建两个线程*/
     ret=pthread_create(&id1,NULL,(void *)pthread1, NULL);
     if(ret!=0)
     perror("pthread cread1");
     ret=pthread_create(&id2,NULL,(void *)pthread2, NULL);
     if(ret!=0)
     perror("pthread cread2");
     pthread_join(id1,NULL);                                 
     pthread_join(id2,NULL);                                 
     exit(0);                                                
   }
                                                          
   void pthread1(void *arg)                                
   {                                                       
    int i;                                                  
    while(time(NULL) < end_time)
    {                           
    /*互斥锁上锁*/                                          
     if(pthread_mutex_lock(&mutex)!=0)
     {                      
      perror("pthread_mutex_lock");                           
     }                                                       
     else                                                    
     printf("pthread1:pthread1 lock the variable\n");        
     for(i=0;i<2;i++){                                       
     sleep(1);                                               
     lock_var++;                                             
     }                                                       
   /*互斥锁接锁*/                                          
     if(pthread_mutex_unlock(&mutex)!=0){                    
     perror("pthread_mutex_unlock");                         
     }                                                       
     else                                                    
     printf("pthread1:pthread1 unlock the variable\n");      
     sleep(1);                                               
    }                                                       
   }                                                       
   void pthread2(void *arg)                                
   {                                                       
    int nolock=0;                                           
    int ret;                                                
    while(time(NULL) < end_time)
    {                           
     /*测试互斥锁*/                                          
     ret=pthread_mutex_trylock(&mutex);                      
     if(ret==EBUSY)                                          
     printf("pthread2:the variable is locked by pthread1\n");
     else
     {   
      if(ret!=0)
      {                                                                                       
        perror("pthread_mutex_trylock");                  
        exit(1);                                          
       }                                                 
       else                                              
       printf("pthread2:pthread2 got lock.The variable is%d\n",lock_var);                                  
               /*互斥锁接锁*/                                    
       if(pthread_mutex_unlock(&mutex)!=0)
       {              
        perror("pthread_mutex_unlock");                   
       }                                                 
       else                                              
       printf("pthread2:pthread2 unlock the variable\n");
      }                                                 
     sleep(3);                                         
     }                                                 
    } 

更简单地去理解，互斥锁在执行过程中，需要对系统的某个资源进行加锁处理，而在这个过程中，必然需要涉及到原子操作，否则会出问题，所以互斥锁的具体处理还需要原子处理的支撑。在Linux中的原子操作在另一篇博客中撰写。