linux 锁机制 pthread_mutex_t

来源：互联网发布：淘宝嘉年华报名入口编辑：程序博客网时间：2024/05/01 07:24

互斥锁机制用于线程之间同步访问哦！

互斥锁pthread_mutex_t的使用
1. 互斥锁创建
有两种方法创建互斥锁，静态方式和动态方式。POSIX定义了一个宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁，方法如下：

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;

在LinuxThreads实现中，pthread_mutex_t是一个结构，而PTHREAD_MUTEX_INITIALIZER则是一个结构常量。

　　动态方式是采用pthread_mutex_init()函数来初始化互斥锁，API定义如下：

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr)

其中mutexattr用于指定互斥锁属性（见下），如果为NULL则使用缺省属性。

　　pthread_mutex_destroy ()用于注销一个互斥锁，API定义如下：

int pthread_mutex_destroy(pthread_mutex_t *mutex)

销毁一个互斥锁即意味着释放它所占用的资源，且要求锁当前处于开放状态。由于在Linux中，互斥锁并不占用任何资源，因此LinuxThreads中的 pthread_mutex_destroy()除了检查锁状态以外（锁定状态则返回EBUSY）没有其他动作。

示例：

对于pthread_mutex_t类型的全局变量，只能用PTHREAD_MUTEX_INITIALIZER来初始化。

对于pthread_mutex_t类型的静态变量，使用pthread_mutex_init(pthread_mutex_t&, NULL)来初始化。

2．互斥锁属性

　　互斥锁的属性在创建锁的时候指定，在LinuxThreads实现中仅有一个锁类型属性，不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同。当前（glibc2.2.3,linuxthreads0.9）有四个值可供选择：

　　* PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。

　　* PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。

　　* PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。

　　* PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。

　　3．锁操作

　　锁操作主要包括加锁 pthread_mutex_lock()、解锁pthread_mutex_unlock()和测试加锁 pthread_mutex_trylock()三个，不论哪种类型的锁，都不可能被两个不同的线程同时得到，而必须等待解锁。对于普通锁和适应锁类型，解锁者可以是同进程内任何线程；而检错锁则必须由加锁者解锁才有效，否则返回EPERM；对于嵌套锁，文档和实现要求必须由加锁者解锁，但实验结果表明并没有这种限制，这个不同目前还没有得到解释。在同一进程中的线程，如果加锁后没有解锁，则任何其他线程都无法再获得锁。

　　int pthread_mutex_lock(pthread_mutex_t *mutex)

　　int pthread_mutex_unlock(pthread_mutex_t *mutex)

　　int pthread_mutex_trylock(pthread_mutex_t *mutex)

　　pthread_mutex_trylock()语义与pthread_mutex_lock()类似，不同的是在锁已经被占据时返回EBUSY而不是挂起等待。

4.其他

这个锁机制同时也不是异步信号安全的，也就是说，不应该在信号处理过程中使用互斥锁，否则容易造成死锁。POSIX 线程锁机制的Linux实现都不是取消点，因此，延迟取消类型的线程不会因收到取消信号而离开加锁等待。值得注意的是，如果线程在加锁后解锁前被取消，锁将永远保持锁定状态，因此如果在关键区段内有取消点存在，或者设置了异步取消类型，则必须在退出回调函数中解锁。

互斥锁属性使用互斥锁（互斥）可以使线程按顺序执行。通常，互斥锁通过确保一次只有一个线程执行代码的临界段来同步多个线程。互斥锁还可以保护单线程代码。

#include<stdlib.h>  
#include<stdio.h>  
#include<unistd.h>  
#include<pthread.h>  

typedef struct ct_sum  
{   int sum;  
    pthread_mutex_t lock;  
}ct_sum;  


void * add1(void * cnt)  
{       
     
    pthread_mutex_lock(&(((ct_sum*)cnt)->lock));  
    int i;  
   for( i=0;i<50;i++)
    { 
          printf("%d ",i);
         (*(ct_sum*)cnt).sum+=i;
    }
     printf("\n");
    pthread_mutex_unlock(&(((ct_sum*)cnt)->lock));  
    pthread_exit(NULL);  
    return 0;  
}  


void * add2(void *cnt)  
{       
    int i;  
    cnt= (ct_sum*)cnt;  
    pthread_mutex_lock(&(((ct_sum*)cnt)->lock));  
    for( i=50;i<101;i++)  
    { 
         printf("%d ",i);
        (*(ct_sum*)cnt).sum+=i;         
    } 
    printf("\n");
    pthread_mutex_unlock(&(((ct_sum*)cnt)->lock));  
    pthread_exit(NULL);  
    return 0;  
}  


int main(void)  
{   int i;  
    pthread_t ptid1,ptid2;  
    int sum=0;  
    ct_sum cnt;  
    pthread_mutex_init(&(cnt.lock),NULL);  
//这边我们使用了静态初始化哦！ 实际上linux在初始化后，是把初始化后的值写入到cnt.lock当中
//之后在要调用之时候，就是依照写入到cnt.lock的值来进行运算的
    cnt.sum=0;  
    pthread_create(&ptid1,NULL,add1,&cnt);  
    pthread_create(&ptid2,NULL,add2,&cnt);  
  
    pthread_mutex_lock(&(cnt.lock));  
    printf("sum %d\n",cnt.sum);  
    pthread_mutex_unlock(&(cnt.lock)); 
    pthread_join(ptid1,NULL);  
    pthread_join(ptid2,NULL);  
    pthread_mutex_destroy(&(cnt.lock));  
    return 0;  
}   
   

多运行几次，我们会发现sum的值是无能确定的，但0-45和50-100是连在一起，看到锁的作用了没呢哈哈。

互斥锁的一个明显缺点是它只有两种状态：锁定和非锁定。而条件变量通过允许线程阻塞和等待另一个线程放松信号的方法弥补了互斥锁的不足，它常和互斥锁一块使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件发生变化。一旦其他的某个线程改变了条件变量，它将通知相应的条件变量唤醒一个或多个正在被此条件阻塞的线程。这些线程将重新锁定互斥锁并重新测试条件是否满足。条件变量上的基本操作有两个。1.触发条件：当条件变为true时；2.等待条件：挂起线程直到其他线程触发条件。条件变量的数据类型是pthreead_cond_t,在使用前也需要初始化。