多个线程同时抢一把锁出现的问题与处理方式

1、线程锁的介绍

1.1 创建互斥锁：

       （1） 静态互斥锁初始化：pthread_mutex_t mutex_x= PTHREAD_MUTEX_INITIALIZER；

                    此句创建锁后，可以直接使用 pthread_mutex_lock(&mutex_x)和pthread_mutex_unlock(&mutex_x)给临界资源加锁

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

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

1.2 销毁锁：

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

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

1.3 设置互斥锁属性　　　

  1.3.1    不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同，有四个值可供选择：

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

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

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

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

       细节：在/usr/include/pthread.h里如果定义了

                  enum
                 {
                          PTHREAD_MUTEX_TIMED_NP,
                          PTHREAD_MUTEX_RECURSIVE_NP,
                          PTHREAD_MUTEX_ERRORCHECK_NP,
                          PTHREAD_MUTEX_ADAPTIVE_NP
                          #if defined __USE_UNIX98 || defined __USE_XOPEN2K8
                          ,
                          PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
                          PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
                          PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
                          PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
                          #endif
 

  1.3.2   使用实例

            pthread_mutexattr_t attr;                               //定义一个锁属性
            pthread_mutexattr_init(&attr);                       //初始化锁属性
            pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_ERRORCHECK);   //设置锁属性
            pthread_mutex_init(&lock, &attr);                  //将对应的锁设置为配置的属性
            pthread_mutexattr_destroy(&attr);                //销毁创建的锁属性

1.4 锁操作函数　

     （1）加锁：int pthread_mutex_lock(pthread_mutex_t *mutex)

     （2）解锁：int pthread_mutex_unlock(pthread_mutex_t *mutex)

     （3）测试加锁：int pthread_mutex_trylock(pthread_mutex_t *mutex)

 

2、多个线程抢锁，没有抢到锁的线程的两种处理方式

2.1 阻塞式等待 pthread_mutex_lock(pthread_mutex_t *mutex)

      （1）两个线程共用一个相同锁时，A程抢到了，必须等待A线程解锁后，B线程才能上锁，否则阻塞在上锁函数

2.2  非阻塞式  pthread_mutex_trylock(pthread_mutex_t *mutex)

      （1）在锁已经被占据时返回EBUSY，而不是挂起等待，这主要是看实际的项目需求，是否必须要等待处理

      （2）如下非阻塞式处理，返回值为EBUSY时，表示锁已经被使用，直接跳过处理，而不是等待，耽误其它函数执行
               ret = pthread_mutex_trylock(p_ctr_data_lock);
               if (0 == ret)

               {
                        //the lock isnt used 
                        //如果被锁定 
                        ... 
                        pthread_mutex_unlock(p_ctr_data_lock);
                }

                else if(EBUSY == ret)

                { 
                        //锁正在被使用;
                         ... 
                }
 

3、互斥锁与条件变量的使用（浅谈）

（1）使用实例模板
        pthread_mutex_t mutex;
        pthread_cond_t cond;
        void *func(void *arg)           // 子线程程序
        {

                 pthread_mutex_lock(&mutex);
                 pthread_cond_wait(&cond, &mutex);    //子线程阻塞并等待主线程发出信号
                  ……
                 pthread_mutex_unlock(&mutex);
                 pthread_exit(NULL);
       }
       int main(void)
       {
             int ret = -1;
             pthread_t th = -1;

             pthread_mutex_init(&mutex, NULL);
             pthread_cond_init(&cond, NULL);
             pthread_create(&th, NULL, func, NULL);
             while (1)
             {
                   scanf("%s", buf);                          //主线程处理等待scanf处理完后，发出condition信号
                   pthread_cond_signal(&cond);
             } 
            // 回收子线程
             printf("等待回收子线程\n");
             ret = pthread_join(th, NULL);
             pthread_mutex_destroy(&mutex);
             pthread_cond_destroy(&cond);
             return 0;
}

 

 

参考博客：https://blog.csdn.net/XiAoma123_1/article/details/78645802