pthread_mutex_lock的实现！！

最新推荐文章于 2023-08-07 16:20:54 发布
最新推荐文章于 2023-08-07 16:20:54 发布
阅读量2.5k 收藏
点赞数
分类专栏： ubuntu

threadexchangenulllockingfunctiondelay

找了好久的pthread_mutex_lock函数的实现原理，，现粘贴如下。。。


int
__pthread_mutex_lock (mutex)
     pthread_mutex_t *mutex;
{
  assert (sizeof (mutex->__size) >= sizeof (mutex->__data));

  int oldval;
  pid_t id = THREAD_GETMEM (THREAD_SELF, tid);

  int retval = 0;
  switch (__builtin_expect (mutex->__data.__kind, PTHREAD_MUTEX_TIMED_NP))
    {
      /* Recursive mutex.  */
    case PTHREAD_MUTEX_RECURSIVE_NP:
      /* Check whether we already hold the mutex.  */
      if (mutex->__data.__owner == id)
    {
      /* Just bump the counter.  */
      if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
        /* Overflow of the counter.  */
        return EAGAIN;

      ++mutex->__data.__count;

      return 0;
    }

      /* We have to get the mutex.  */
      LLL_MUTEX_LOCK (mutex->__data.__lock);

      assert (mutex->__data.__owner == 0);
      mutex->__data.__count = 1;
      break;

      /* Error checking mutex.  */
    case PTHREAD_MUTEX_ERRORCHECK_NP:
      /* Check whether we already hold the mutex.  */
      if (__builtin_expect (mutex->__data.__owner == id, 0))
    return EDEADLK;

      /* FALLTHROUGH */

    case PTHREAD_MUTEX_TIMED_NP:
    simple:
      /* Normal mutex.  */
      LLL_MUTEX_LOCK (mutex->__data.__lock);
      assert (mutex->__data.__owner == 0);
      break;

    case PTHREAD_MUTEX_ADAPTIVE_NP:
      if (! __is_smp)
    goto simple;

      if (LLL_MUTEX_TRYLOCK (mutex->__data.__lock) != 0)
    {
      int cnt = 0;
      int max_cnt = MIN (MAX_ADAPTIVE_COUNT,
                 mutex->__data.__spins * 2 + 10);
      do
        {
          if (cnt++ >= max_cnt)
        {
          LLL_MUTEX_LOCK (mutex->__data.__lock);
          break;
        }

#ifdef BUSY_WAIT_NOP
          BUSY_WAIT_NOP;
#endif
        }
      while (LLL_MUTEX_TRYLOCK (mutex->__data.__lock) != 0);

      mutex->__data.__spins += (cnt - mutex->__data.__spins) / 8;
    }
      assert (mutex->__data.__owner == 0);
      break;

    case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP:
    case PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP:
    case PTHREAD_MUTEX_ROBUST_NORMAL_NP:
    case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP:
      THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
             &mutex->__data.__list.__next);

      oldval = mutex->__data.__lock;
      do
    {
    again:
      if ((oldval & FUTEX_OWNER_DIED) != 0)
        {
          /* The previous owner died.  Try locking the mutex.  */
          int newval = id;
#ifdef NO_INCR
          newval |= FUTEX_WAITERS;
#else
          newval |= (oldval & FUTEX_WAITERS);
#endif

          newval
        = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
                               newval, oldval);

          if (newval != oldval)
        {
          oldval = newval;
          goto again;
        }

          /* We got the mutex.  */
          mutex->__data.__count = 1;
          /* But it is inconsistent unless marked otherwise.  */
          mutex->__data.__owner = PTHREAD_MUTEX_INCONSISTENT;

          ENQUEUE_MUTEX (mutex);
          THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

          /* Note that we deliberately exit here.  If we fall
         through to the end of the function __nusers would be
         incremented which is not correct because the old
         owner has to be discounted.  If we are not supposed
         to increment __nusers we actually have to decrement
         it here.  */
#ifdef NO_INCR
          --mutex->__data.__nusers;
#endif

          return EOWNERDEAD;
        }

      /* Check whether we already hold the mutex.  */
      if (__builtin_expect ((oldval & FUTEX_TID_MASK) == id, 0))
        {
          if (mutex->__data.__kind
          == PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP)
        {
          THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
                 NULL);
          return EDEADLK;
        }

          if (mutex->__data.__kind
          == PTHREAD_MUTEX_ROBUST_RECURSIVE_NP)
        {
          THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
                 NULL);

          /* Just bump the counter.  */
          if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
            /* Overflow of the counter.  */
            return EAGAIN;

          ++mutex->__data.__count;

          return 0;
        }
        }

      oldval = LLL_ROBUST_MUTEX_LOCK (mutex->__data.__lock, id);

      if (__builtin_expect (mutex->__data.__owner
                == PTHREAD_MUTEX_NOTRECOVERABLE, 0))
        {
          /* This mutex is now not recoverable.  */
          mutex->__data.__count = 0;
          lll_mutex_unlock (mutex->__data.__lock);
          THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
          return ENOTRECOVERABLE;
        }
    }
      while ((oldval & FUTEX_OWNER_DIED) != 0);

      mutex->__data.__count = 1;
      ENQUEUE_MUTEX (mutex);
      THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
      break;

    case PTHREAD_MUTEX_PI_RECURSIVE_NP:
    case PTHREAD_MUTEX_PI_ERRORCHECK_NP:
    case PTHREAD_MUTEX_PI_NORMAL_NP:
    case PTHREAD_MUTEX_PI_ADAPTIVE_NP:
    case PTHREAD_MUTEX_PI_ROBUST_RECURSIVE_NP:
    case PTHREAD_MUTEX_PI_ROBUST_ERRORCHECK_NP:
    case PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP:
    case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP:
      {
    int kind = mutex->__data.__kind & PTHREAD_MUTEX_KIND_MASK_NP;
    int robust = mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP;

    if (robust)
      /* Note: robust PI futexes are signaled by setting bit 0.  */
      THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
             (void *) (((uintptr_t) &mutex->__data.__list.__next)
                   | 1));

    oldval = mutex->__data.__lock;

    /* Check whether we already hold the mutex.  */
    if (__builtin_expect ((oldval & FUTEX_TID_MASK) == id, 0))
      {
        if (kind == PTHREAD_MUTEX_ERRORCHECK_NP)
          {
        THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
        return EDEADLK;
          }

        if (kind == PTHREAD_MUTEX_RECURSIVE_NP)
          {
        THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

        /* Just bump the counter.  */
        if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
          /* Overflow of the counter.  */
          return EAGAIN;

        ++mutex->__data.__count;

        return 0;
          }
      }

    int newval = id;
#ifdef NO_INCR
    newval |= FUTEX_WAITERS;
#endif
    oldval = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
                              newval, 0);

    if (oldval != 0)
      {
        /* The mutex is locked.  The kernel will now take care of
           everything.  */
        INTERNAL_SYSCALL_DECL (__err);
        int e = INTERNAL_SYSCALL (futex, __err, 4, &mutex->__data.__lock,
                      FUTEX_LOCK_PI, 1, 0);

        if (INTERNAL_SYSCALL_ERROR_P (e, __err)
        && (INTERNAL_SYSCALL_ERRNO (e, __err) == ESRCH
            || INTERNAL_SYSCALL_ERRNO (e, __err) == EDEADLK))
          {
        assert (INTERNAL_SYSCALL_ERRNO (e, __err) != EDEADLK
            || (kind != PTHREAD_MUTEX_ERRORCHECK_NP
                && kind != PTHREAD_MUTEX_RECURSIVE_NP));
        /* ESRCH can happen only for non-robust PI mutexes where
           the owner of the lock died.  */
        assert (INTERNAL_SYSCALL_ERRNO (e, __err) != ESRCH || !robust);

        /* Delay the thread indefinitely.  */
        while (1)
          pause_not_cancel ();
          }

        oldval = mutex->__data.__lock;

        assert (robust || (oldval & FUTEX_OWNER_DIED) == 0);
      }

    if (__builtin_expect (oldval & FUTEX_OWNER_DIED, 0))
      {
        atomic_and (&mutex->__data.__lock, ~FUTEX_OWNER_DIED);

        /* We got the mutex.  */
        mutex->__data.__count = 1;
        /* But it is inconsistent unless marked otherwise.  */
        mutex->__data.__owner = PTHREAD_MUTEX_INCONSISTENT;

        ENQUEUE_MUTEX_PI (mutex);
        THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

        /* Note that we deliberately exit here.  If we fall
           through to the end of the function __nusers would be
           incremented which is not correct because the old owner
           has to be discounted.  If we are not supposed to
           increment __nusers we actually have to decrement it here.  */
#ifdef NO_INCR
        --mutex->__data.__nusers;
#endif

        return EOWNERDEAD;
      }

    if (robust
        && __builtin_expect (mutex->__data.__owner
                 == PTHREAD_MUTEX_NOTRECOVERABLE, 0))
      {
        /* This mutex is now not recoverable.  */
        mutex->__data.__count = 0;

        INTERNAL_SYSCALL_DECL (__err);
        INTERNAL_SYSCALL (futex, __err, 4, &mutex->__data.__lock,
                  FUTEX_UNLOCK_PI, 0, 0);

        THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
        return ENOTRECOVERABLE;
      }

    mutex->__data.__count = 1;
    if (robust)
      {
        ENQUEUE_MUTEX_PI (mutex);
        THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
      }
      }
      break;

    case PTHREAD_MUTEX_PP_RECURSIVE_NP:
    case PTHREAD_MUTEX_PP_ERRORCHECK_NP:
    case PTHREAD_MUTEX_PP_NORMAL_NP:
    case PTHREAD_MUTEX_PP_ADAPTIVE_NP:
      {
    int kind = mutex->__data.__kind & PTHREAD_MUTEX_KIND_MASK_NP;

    oldval = mutex->__data.__lock;

    /* Check whether we already hold the mutex.  */
    if (mutex->__data.__owner == id)
      {
        if (kind == PTHREAD_MUTEX_ERRORCHECK_NP)
          return EDEADLK;

        if (kind == PTHREAD_MUTEX_RECURSIVE_NP)
          {
        /* Just bump the counter.  */
        if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
          /* Overflow of the counter.  */
          return EAGAIN;

        ++mutex->__data.__count;

        return 0;
          }
      }

    int oldprio = -1, ceilval;
    do
      {
        int ceiling = (oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK)
              >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;

        if (__pthread_current_priority () > ceiling)
          {
        if (oldprio != -1)
          __pthread_tpp_change_priority (oldprio, -1);
        return EINVAL;
          }

        retval = __pthread_tpp_change_priority (oldprio, ceiling);
        if (retval)
          return retval;

        ceilval = ceiling << PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
        oldprio = ceiling;

        oldval
          = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
#ifdef NO_INCR
                             ceilval | 2,
#else
                             ceilval | 1,
#endif
                             ceilval);

        if (oldval == ceilval)
          break;

        do
          {
        oldval
          = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
                             ceilval | 2,
                             ceilval | 1);

        if ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval)
          break;

        if (oldval != ceilval)
          lll_futex_wait (&mutex->__data.__lock, ceilval | 2);
          }
        while (atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
                            ceilval | 2, ceilval)
           != ceilval);
      }
    while ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval);

    assert (mutex->__data.__owner == 0);
    mutex->__data.__count = 1;
      }
      break;

    default:
      /* Correct code cannot set any other type.  */
      return EINVAL;
    }

  /* Record the ownership.  */
  mutex->__data.__owner = id;
#ifndef NO_INCR
  ++mutex->__data.__nusers;
#endif

  return retval;
}
#ifndef __pthread_mutex_lock
strong_alias (__pthread_mutex_lock, pthread_mutex_lock)
strong_alias (__pthread_mutex_lock, __pthread_mutex_lock_internal)
#endif

猜你在找
zlog使用手册
s3c2440 GPIO 转
在一个10M的文本文件中搜索指定字符串
Linux锁机制
c语言日志工具-zlog的使用
src="http://blog.csdn.net/common/ad.html?t=4&containerId=ad_cen&frmId=ad_frm_0" style="border-width: 0px; overflow: hidden; width: 984px; height: 90px;" scrolling="no" id="ad_frm_0" frameborder="0">
查看评论
1楼 xudong4877 2011-09-05 16:21发表 [回复]
看似简单的一个函数，实现起来如此复杂，不禁让我感叹前辈们的伟大。
您还没有登录,请 [登录]或 [注册]
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
src="http://blog.csdn.net/common/ad.html?t=5&containerId=ad_bot&frmId=ad_frm_1" style="border-width: 0px; overflow: hidden; width: 984px; height: 0px;" scrolling="no" id="ad_frm_1" frameborder="0">
核心技术类目
全部主题 Hadoop AWS 移动游戏 Java Android iOS Swift 智能硬件 Docker OpenStack VPN Spark ERP IE10 Eclipse CRM JavaScript 数据库 Ubuntu NFC WAP jQuery BI HTML5 Spring Apache .NET API HTML SDK IIS Fedora XML LBS Unity Splashtop UML components Windows Mobile Rails QEMU KDE Cassandra CloudStack FTC coremail OPhone CouchBase 云计算 iOS6 Rackspace Web App SpringSide Maemo Compuware 大数据 aptech Perl Tornado Ruby Hibernate ThinkPHP HBase Pure Solr Angular Cloud Foundry Redis Scala Django Bootstrap
  • 个人资料
    • 访问：45275次
    • 积分：573
    • 等级：
    • 排名：千里之外
    • 原创：10篇
    • 转载：10篇
    • 译文：0篇
    • 评论：7条
mengfanteng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
打通用户态程序和内核系列之二：pthread_mutex_lock的实现
cbiqlux89468585的博客
09-01 743
一个很容混淆的地方是，误以为用户程序锁API的实现和接口，最终也会调用内核相关的锁操作提供的API。 应用程序锁API接口 主要的API有：pthread_mutex_lock; 相关说明如下： NAME pthread_mutex_lock -- lock a mutex SYNOPSIS #include <pthread.h> int ...
__pthread_mutex_lock_full: assertion ‘e != esrch || !robust‘ failed
最新发布
weiliang_Handan的博客
05-30 309
这个错误信息通常与多线程环境中的互斥锁（mutex）有关。具体来说，它提示程序在尝试锁定互斥锁时遇到了断言失败，可能是由于线程或互斥锁状态不匹配引起的。
pthread_mutex_lock
linking530的专栏
08-22 1917
pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_trylock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex);      描述 pthread_mutex_lock()函数锁住由mutex指定的mute
pthread_mutex
12-17
POSIX线程，也称为pthreads，是跨平台的线程API，其中`pthread_mutex`是核心的同步机制之一，用于实现线程间的互斥访问。本文将深入探讨`pthread_mutex`在Linux环境下的使用，以及它在多线程同步中的作用。 首先，...
pthread_cond_wait() 用法深入分析
09-05
pthread_mutex_lock(&mtx); data_ready = 1; pthread_cond_signal(&cond); // 通知消费者数据已准备好 pthread_mutex_unlock(&mtx); } // 消费者线程 void* consumer(void* arg) { while (1) { pthread_mutex...
pthread_pthread_
10-01
- **互斥量（Mutex）**：`pthread_mutex_t`是互斥锁类型，通过`pthread_mutex_init()`初始化，`pthread_mutex_lock()`锁定，`pthread_mutex_unlock()`解锁，确保同一时间只有一个线程访问临界区。 - **条件变量...
pthreads_pthread_
09-30
4. `pthread_mutex_t` 和 `pthread_mutex_init() / pthread_mutex_lock() / pthread_mutex_unlock() / pthread_mutex_destroy()`：互斥锁，用于保证同一时刻只有一个线程访问特定资源，防止数据竞争。 5. `pthread_...
lock_mutex.rar_Linux/Unix编程_Unix_Linux_
08-12
pthread_mutex_lock(&mutex); // 访问共享资源的代码 pthread_mutex_unlock(&mutex); ``` 3. **解锁互斥锁**：访问完共享资源后，线程应该通过调用`pthread_mutex_unlock()`函数释放锁，以便其他等待的线程可以继续...
Pthread锁机制
kobejayandy的专栏
01-04 3776
Pthreads提供了多种锁机制：         (1) Mutex（互斥量）：pthread_mutex_***                 sleep-waiting, 上下文切换         (2) Spin lock（自旋锁）：pthread_spin_***                busy-waiting         (3) Condition Varia
pthread_mutex_lock函数
weixin_45066931的博客
08-07 5203
pthread_mutex_lock函数是一个线程同步函数，用于对互斥锁进行加锁操作。它阻塞调用线程，直到可以获得互斥锁为止。如果互斥锁已经被其他线程锁定，则调用线程将被阻塞，直到互斥锁被解锁。指向的互斥锁已经被其他线程锁定，则调用线程将被阻塞，直到互斥锁被解锁。指向的互斥锁当前没有被锁定，则调用线程将获得锁，并继续执行。该函数返回值为0表示成功加锁，非零值表示失败。函数来释放锁，以避免死锁的情况发生。是一个指向互斥锁变量的指针。
pthread_mutex_lock 相关
QQ839787886的博客
07-30 631
互斥量(mutex)就是一把锁。 多个线程只有一把锁一个钥匙，谁上的锁就只有谁能开锁。当一个线程要访问一个共享变量时，先用锁把变量锁住，然后再操作，操作完了之后再释放掉锁，完成。 当另一个线程也要访问这个变量时，发现这个变量被锁住了，无法访问，它就会一直等待，直到锁没了，它再给这个变量上个锁，然后使用，使用完了释放锁，以此进行。 这个即使有多个线程同时访问这个变量，也好象是对这个变量的操作...
thread学习
08-29 369
pthread_t用于声明线程ID pthread_mutex_t 互斥锁 pthread_cond_t PTHREAD_MUTEX_INITIALIZER静态初始化互斥锁 PTHREAD_COND_INITIALIZER静态初始化变量 Linux串口—struct termios结构体
关于pthread_mutex_lock使用
热门推荐
无专精则不能成，无涉猎则不能通
04-08 1万+
关于pthread_mutex_lock使用 关于pthread_mutex_lock常用函数如下： #include <pthread.h> int pthread_mutex_destroy(pthread_mutex_t *mutex); int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_...
pthread的pthread_mutex_lock 的使用
走在左边
02-25 982
参考http://haoningabc.iteye.com/blog/1709157 在c中多线程，打印数据互相不影响的例子 关键点在pthread_mutex_lock 无锁的情况 testptread.c [code="java"] #include #include #include #include "pthread.h" void * process(voi...
pthread_mutex_timedlock
09-14
pthread_mutex_timedlock与pthread_mutex_lock的区别是在达到超时时间时的处理方式。pthread_mutex_timedlock会在达到超时时间时返回错误码ETIMEOUT，并不会对互斥量进行加锁；而pthread_mutex_lock则会阻塞线程，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值