[linux/program] 互斥量上锁解锁

#include

int pthread_mutex_lock( pthread_mutex_t *mutex ) ;
这个方法是用来锁定互斥量，如果该互斥量变量已经被其他的线程锁定，
那么当前调用该方法的线程将会陷入阻塞状态直到互斥量被解锁

int pthread_mutex_trylock ( pthread_mutex_t *mutex ) ;
如果当前系统资源有限，线程长期阻塞会消耗系统中的资源，此方法就是为了防止
线程因长期得不到互斥量而陷入阻塞而设计出的，是当前执行该方法的线程试探性的
获取互斥量，如果获取不到这立即返回而不陷入阻塞，而是返回 EBUSY 的变量用来
表示当前的互斥量被其他的线程占用

int pthread_mutex_unlock ( pthread_mutex_t *mutex ) ;
该方法用于将锁定的互斥量进行解锁

---

下面的代码是通过互斥量来保护数据结构对象 , 使用到的方法有：
1. int pthread_mutex_lock( pthread_mutex_t *mutex ) ;
2. int pthread_mutex_unlock ( pthread_mutex_t *mutex ) ;

---

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

struct foo
{
    int f_count ;
    pthread_mutex_t f_lock ;
    int f_id ;
} ; // 定义结构体，将互斥量与互斥量保护的变量通过结构体的方式进行关联

/**
foo_alloc 方法是用来根据传入的 id 数值创建 foo 结构体变量，
为其分配空间，并且进行简单的初始化，最后将指向该创建好的 foo 变量对象
以返回值的方式进行返回
struct foo 变量中有一个互斥量的变量字段 -- f_lock
在 foo_alloc 方法中 连通 struct foo 变量都是通过 malloc 方法从堆空间
中动态划分的空间，所以该 f_lock 字段是需要通过 pthread_mutex_init
这一动态初始化 pthread_mutex_t 变量的方法来初始化，而不是使用宏变量
PTHREAD_MUTEX_INITIALIZER
*/
struct foo *
    foo_alloc ( int id ) /* allocate the object */
    {
        struct foo *fp ;
        if ( ( fp = malloc ( sizeof ( struct foo ) ) ) != NULL )
        {
            fp->f_count = 1 ;
            fp->f_id = id ;
            if ( pthread_mutex_init ( &fp->f_lock , NULL ) != 0 )
            {
                free ( fp ) ;
                return (NULL) ;
            }

            /* continue initialization */
        }
        return (fp) ;
    }
/**
foo_hold :
这个方法是通过传入的 struct foo 指针来互斥的对指针所指向的变量中的
f_count 变量进行增加计数操作
在多个线程都想针对同一个 struct foo 中的 f_count 字段进行增加计数操作的时候，
只有能够获得互斥锁的线程才能够具有对该变量进行改写的机会，
其余没有获得互斥锁的线程都会被归入到该互斥锁的阻塞队列中
*/
void foo_hold ( struct foo *fp ) /* add a reference to the object */
{
    pthread_mutex_lock ( &fp->f_lock ) ;
    fp->f_count++ ;
    pthread_mutex_unlock (&fp->f_lock ) ;
}

/**
foo_rele :
这个方法是对传入指向 struct foo 变量的指针中的 f_count 变量字段进行检查，

1. 如果该数值在进行自减操作之后等于 1 说明当前线程是最后一个引用该变量的线程，
最后的使用者负责将加在该 struct foo 变量上面的互斥锁进行解除
对于互斥量而言，当有互斥量被其他线程引用的时候进行销毁会引发错误
只有确保没有线程使用该互斥量的时对其销毁并释放空间才可以，
所以当 --fp->f_count == 0 的时候，说明当前引用的线程为最后一个，在调用
pthread_mutex_unlock 释放最后一个线程对该互斥量的占用之后，可以安全将其销毁 ；

2.当然，如果 --fp->f_count != 0 则说明，除了当前线程仍然还有其余线程占用或是
试图占用该互斥锁，销毁线程的操作则是不允许的
*/
void foo_rele ( struct foo *fp ) /* release a reference to the object */
{
    pthread_mutex_lock ( &fp->f_lock ) ;
    if ( --fp->f_count == 0 )
    {
        // this is the last reference
        pthread_mutex_unlock ( &fp->f_lock ) ;
        pthread_mutex_destory ( &fp->f_lock ) ;
        free ( fp ) ;
    }
    else
    {
        pthread_mutex_unlock ( &fp->f_lock ) ;
    }
}

---

在线程 A 与线程 B 运行的时候分别申请两个互斥量 m1 m2，在线程 A 运行的时候申请了互斥量 m1 所保护的资源 x1,
同时还需要申请使用被线程 B 所申请的互斥量 m2 所保护的资源 x2 ；
线程 B 在运行的时候首先申请了互斥量 m2 所保护的资源，同时还需要申请被线程 A 运行的时候申请的互斥量 m1 所保护的资源
x1 , 线程 B  就会陷入互斥量 m1 的阻塞， 而线程 A 也同时陷入了互斥量 m2 的阻塞。 
这就是的死锁，为了防止死锁的发生，通常可以使用 pthread_mutex_trylock 

在线程 A 运行申请互斥量 m1 之后，此时互斥量 m2 也被线程 B 申请占用。
如果线程 A 使用 pthread_mutex_trylock 来申请占用互斥量 m2 的话，则会因为互斥量已经被占用而立即返回
出错提示返回值 : EBUSY, 该宏变量数值来提示互斥量 m2 已经被其他的线程占用。通过这种方法线程就不会进入
到互斥量 m2 的阻塞队列。同理，线程 B 也不会进入到线程 A 占用的互斥量 m1 的阻塞队列，从而放置了死锁 

---

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

struct foo
{
    int f_count ;
    pthread_mutex_t f_lock ;
    int f_id ;
} ;

struct foo * foo_alloc ( int id )
{
    struct foo *fp ;
    if ( ( fp = malloc ( sizeof ( struct foo ) ) ) != NULL )
    {
        fp->f_count = 1 ;
        fp->f_id = id ;

        if ( pthread_mutex_init ( &fp->f_lock , NULL ) != 0 )
        {
            free ( fp ) ;
            return ( NULL ) ;
        }
    }

    return fp ;
}

void foo_try_hold ( struct foo *fp )  // 与上述方法所不同的是，在多个线程共同争夺同一个互斥锁变量的时候，没有获得
                                      // 到互斥锁的线程并不会陷入到该互斥锁的阻塞队列中，而是立即返回 ，这就是 trylock 与lock 的不同
{
     // try to get the mutex , if can not get means someone else
     // are occupying the mutex
     if ( pthread_mutex_trylock ( &fp->f_lock ) != 0 )
     {
        printf ( "failed to get mutex \n " ) ;
        return ;
     }
     else
     {
         fp->f_count++ ;
         pthread_mutex_unlock ( &fp->f_lock ) ;
     }
}

void foo_rele ( struct foo *fp )
{
     if ( pthread_mutex_trylock ( &fp->f_lock ) != 0 )
     {
        pritnf ( "failed to get mutex lock \n" ) ;
        return ;
     }
     else
     {
        if ( --fp->f_count == 0 )
        {
            // this is the last reference
            pthread_mutex_unlock ( &fp->f_lock ) ;
            pthread_mutex_destory ( &fp->f_lock ) ;
        }
        else
        {
            pthread_mutex_unlock ( &fp->f_lock ) ;
        }
     }
}

end