linux__mutex互斥锁___操作

mutex是死等锁，即pthread_mutex_lock(&mutex);这条语句在执行的后，做两步，1，先判断当前是否可以锁，如别的线程在锁住，这里就一直等待直到别的线程解锁为止。1，判断完后，开始锁住，防止别的线程使用。
如果不想在这里死等，可以采用pthread_mutex_trylock(&mutex);然后判断if(ret==EBUSY){被别的线程锁住，这里做相应的无法锁住的事情，如返回}

#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;
int sum;

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;
		sum=10;
		
		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)
		{
					pthread_mutex_lock(&mutex); //lock
						
					printf("pthread1: lock the variable\n");
					
					for(i=0;i<2;i++)
					{
						sleep(2);
					  lock_var++;
					}
				 pthread_mutex_unlock(&mutex); //unlock
				printf("pthread1:unlock the variable\n");
					sleep(1);
		}
}

void pthread2(void *arg)
{
			int nolock=0;
			int ret;
			while(time(NULL) < end_time)
			{
						
						ret=pthread_mutex_lock(&mutex);
						printf("pthread2:got lock.\n");
						
						pthread_mutex_unlock(&mutex);//unlock
						
						printf("pthread2:unlock the variable\n");
						sleep(1);
			}
}

转自：http://blog.csdn.net/wtz1985/article/details/3819052

一个进程中的多个线程是共享同一段资源的，由于线程对资源的竞争引出了锁。其中mutex是一种简单的加锁方法，这个互斥锁只有两种状态，那就是上锁和解锁，可以把互斥锁看作是某种意义上的全局变量。在某一时刻，只能有一个线程取得这个互斥上的锁，拥有上锁状态的线程可以对共享资源进行操作，而其他线程在该线程未解锁之前，够会被挂起，直到上锁的线程解开锁。可以这么说，互斥锁使得共享资源按序的在各个线程上操作。

互斥锁的操作主要包括互斥锁初始化、上锁、判断上锁、解锁、摧毁互斥锁。其中互斥锁可以分为快速互斥锁、递归互斥锁这检错互斥锁。这三种锁的区别主要在于其他未占有互斥锁的线程在希望得到互斥锁时是否需要等待挂起。快速锁是指调用线程会阻塞直到线程锁得到解锁为止。递归锁能够成功地返回并且增加调用线程在互斥上的加锁次数，比如一个链表在进行插入的操作时，可以进行查找的操作。检错锁则为快速互斥锁的非阻塞版本，它会立即返回并返回一个错误的信息。

1、函数简义。

（1）pthread_mutex_init

头文件：                  <pthread.h>

函数原型：               int pthread_mutex_init (pthread_mutex_t* mutex,

                                                                         const pthread_mutexattr_t* mutexattr);

函数传入值：            mutex:互斥锁。

                              mutexattr:PTHREAD_MUTEX_INITIALIZER:创建快速互斥锁。 

                                               PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP:创建递归互斥锁。

                                               PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP:创建检错互斥锁。

函数返回值：            成功：0

                              出错：-1 

（2）上锁函数：

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:互斥锁。

函数返回值：            同上。

2、互斥锁实现。

#include <stdio.h>  
#include <stdlib.h>  
#include <pthread.h>  
#include <errno.h>  
#include <unistd.h>  
  
#define  return_if_fail(p)  \
	if((p) == 0) \
		{ \
			printf("[%s]:func error!/n",__func__); \
			return; \
		}  \
   
typedef struct _PrivInfo  
{  
   pthread_mutex_t mutex;  
   int lock_var;  
   time_t end_time;  
}PrivInfo;  
  
static void info_init (PrivInfo* thiz);  
static void* pthread_func_1 (PrivInfo* thiz);  
static void* pthread_func_2 (PrivInfo* thiz);  
  
int main (int argc, char** argv)  
{  
   pthread_t pt_1 = 0;  
   pthread_t pt_2 = 0;  
   int ret = 0;  
   PrivInfo* thiz = NULL;  
  
   thiz = (PrivInfo*)malloc (sizeof (PrivInfo));  
   if (thiz == NULL)  
   {  
      return -1;  
   }  
  
   info_init(thiz);  
  
   ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);  
   if (ret != 0)  
   {  
     perror ("pthread_1_create:");  
   }  
     
   ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);  
   {  
     perror ("pthread_2_create:");  
   }  
  
   pthread_join (pt_1, NULL);  
   pthread_join (pt_2, NULL);  
  
   pthread_mutex_destroy (&thiz->mutex);  
     
   free (thiz);  
   thiz = NULL;  
  
   return 0;  
}  
  
static void info_init (PrivInfo* thiz)  
{  
   return_if_fail (thiz != NULL);  
  
   thiz->lock_var = 0;  
   thiz->end_time = time (NULL) + 10;  
  
   pthread_mutex_init (&thiz->mutex, NULL);  
  
   return;  
}  
  
static void* pthread_func_1 (PrivInfo* thiz)  
{  
   return_if_fail (thiz != NULL);  
  
   int i = 0;  
   int ret = 0;  
  
   while (time (NULL) < thiz->end_time)  
   {  
     ret  = pthread_mutex_lock (&thiz->mutex);  
     if (ret != 0)  
     {  
         perror ("[%s]pthread_mutex_lock");  
     }  
     else  
     {  
       printf ("pthread1:pthread1 lock the variable!\n");  
     }  
  
     for (i = 0; i < 2; i++)  
     {  
        sleep (1);  
        thiz->lock_var ++;  
     }  
  
     ret = pthread_mutex_unlock (&thiz->mutex);  
     if (ret != 0)  
     {  
        perror ("[%s]pthread_mutex_unlock");  
     }  
     else  
     {  
        printf ("pthread1: pthread1 unlock the variable.\n");  
     }       
   }  
  
   return;  
}  
  
static void* pthread_func_2 (PrivInfo* thiz)  
{  
   return_if_fail (thiz != NULL);  
  
   int ret = 0;  
     
   while (time (NULL) < thiz->end_time)  
   {  
      ret = pthread_mutex_trylock (&thiz->mutex);  
      if (ret == EBUSY)  
      {  
         printf ("pthread2:the variable is locked by thread1.\n");  
      }  
      else  
      {  
         if (ret != 0)  
         {  
             perror ("[%s]pthread2_mutex_trylock");   
         }  
         else  
         {  
            printf ("pthread2: pthread2 lock the variable.\n");  
         }           
        
  
         ret = pthread_mutex_unlock (&thiz->mutex);  
         if (ret != 0)  
         {  
           perror ("[%s]pthread_mutex_lock");  
         }  
      }
       sleep (3);    
    }  
}  

在上例的中，是对变量lock_var的读写进行加锁，线程一是对其进行写，在写的时候，线程二不能对其进行读。直到线程一解锁，线程二得到互斥锁，才能进行读。同样，在线程二进行读的时候，线程一不能进行写。