pthread的各种同步机制

原文: http://casatwy.com/pthreadde-ge-chong-tong-bu-ji-zhi.html

虽然pthread的介绍我看过很多, 但是这篇文章介绍的最清楚了, 记在这里, 方便以后随时查阅

 

pthread的各种同步机制

Date  Thu 29 January 2015 Tags pthread




简述

 

pthread是POSIX标准的多线程库，UNIX、Linux上广泛使用，windows上也有对应的实现，所有的函数都是pthread打头，也就一百多个函数，不是很复杂。然而多线程编程被普遍认为复杂，主要是因为多线程给程序引入了一定的不可预知性，要控制这些不可预知性，就需要使用各种锁各种同步机制，不同的情况就应该使用不同的锁不同的机制。什么事情一旦放到多线程环境，要考虑的问题立刻就上升了好几个量级。多线程编程就像潘多拉魔盒，带来的好处不可胜数，然而工程师只要一不小心，就很容易让你的程序失去控制，所以你得用各种锁各种机制管住它。要解决好这些问题，工程师们就要充分了解这些锁机制，分析不同的场景，选择合适的解决方案。

处理方案不对的话，那能不能正确跑完程序就只好看运气啦～




预备

 

  1. 阅读这篇文章之前你最好有一些实际的pthread使用经验，因为这篇文章不是写给从零开始学习pthread的人的。
  2. 想要5分钟内立刻搞定多线程同步机制的人，觉得文章太长不看的人，这篇文章就不是写给你们看的。Mac请点左上角关闭，KDE和GNOME请点右上角关闭。
  3. 如果你经常困惑于各种锁和同步机制的方案，或者你想寻找比现有代码更优雅的方案来处理你遇到的多线程问题，那这篇文章就是写给你的。
  4. 如果你发现别人的多线程代码写得不对，但是勉强能跑，然后你找到他让他改的时候，跟他解释半天也不愿意改，那这篇文章就是写给他们的。




开始。




Mutex Lock 互斥锁

 

MUTual-EXclude Lock，互斥锁。 它是理解最容易，使用最广泛的一种同步机制。顾名思义，被这个锁保护的临界区就只允许一个线程进入，其它线程如果没有获得锁权限，那就只能在外面等着。

它使用得非常广泛，以至于大多数人谈到锁就是mutex。mutex是互斥锁，pthread里面还有很多锁，mutex只是其中一种。

 

相关宏和函数

    PTHREAD_MUTEX_INITIALIZER // 用于静态的mutex的初始化，采用默认的attr。比如: static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); // 用于动态的初始化 int pthread_mutex_destroy(pthread_mutex_t *mutex); // 把mutex锁干掉，并且释放所有它所占有的资源 int pthread_mutex_lock(pthread_mutex_t *mutex); // 请求锁，如果当前mutex已经被锁，那么这个线程就会卡在这儿，直到mutex被释放 int pthread_mutex_unlock(pthread_mutex_t *mutex); // 解锁 int pthread_mutex_trylock(pthread_mutex_t *mutex); // 尝试请求锁，如果当前mutex已经被锁或者不可用，这个函数就直接return了，不会把线程卡住



要注意的地方

 

关于mutex的初始化

 

mutex的初始化分两种，一种是用宏(PTHREAD_MUTEX_INITIALIZER)，一种是用函数(pthread_mutex_init)。 如果没有特殊的配置要求的话，使用宏比较好，因为它比较快。只有真的需要配置的时候，才需要用函数。也就是说，凡是pthread_mutex_init(&mutex, NULL)的地方都可以使用PTHREAD_MUTEX_INITIALIZER，因为在pthread_mutex_init这个函数里的实现其实也是用了PTHREAD_MUTEX_INITIALIZER：

 

    ///////////////////// pthread_src/include/pthread/pthread.h

    #define PTHREAD_MUTEX_INITIALIZER __PTHREAD_MUTEX_INITIALIZER ///////////////////// pthread_src/sysdeps/generic/bits/mutex.h # define __PTHREAD_MUTEX_INITIALIZER \ { __PTHREAD_SPIN_LOCK_INITIALIZER, __PTHREAD_SPIN_LOCK_INITIALIZER, 0, 0, 0, 0, 0, 0 } // mutex锁本质上是一个spin lock，空转锁，关于空转锁的东西在下面会提到。 ///////////////////// pthread_src/sysdeps/generic/pt-mutex-init.c int _pthread_mutex_init (pthread_mutex_t *mutex, const pthread_mutexattr_t *attr) { *mutex = (pthread_mutex_t) __PTHREAD_MUTEX_INITIALIZER; // 你看，这里其实用的也是宏。就这一句是初始化，下面都是在设置属性。 if (! attr || memcmp (attr, &__pthread_default_mutexattr, sizeof (*attr) == 0)) /* The default attributes. */ return 0; if (! mutex->attr || mutex->attr == __PTHREAD_ERRORCHECK_MUTEXATTR || mutex->attr == __PTHREAD_RECURSIVE_MUTEXATTR) mutex->attr = malloc (sizeof *attr); //pthread_mutex_destroy释放的就是这里的资源 if (! mutex->attr) return ENOMEM; *mutex->attr = *attr; return 0; }

但是业界有另一种说法是：早年的POSIX只支持在static变量上使用PTHREAD_MUTEX_INITIALIZER，所以PTHREAD_MUTEX_INITIALIZER尽量不要到处都用，所以使用的时候你得搞清楚你的pthread的实现版本是不是比较老的。



mutex锁不是万能灵药

 

基本上所有的问题都可以用互斥的方案去解决，大不了就是慢点儿，但不要不管什么情况都用互斥，都能采用这种方案不代表都适合采用这种方案。而且这里所说的慢不是说mutex的实现方案比较慢，而是互斥方案影响的面比较大，本来不需要通过互斥就能让线程进入临界区，但用了互斥方案之后，就使这样的线程不得不等待互斥锁的释放，所以就慢了。甚至有些场合用互斥就很蛋疼，比如多资源分配，线程步调通知等。 如果是读多写少的场合，就比较适合读写锁(reader/writter lock)，如果临界区比较短，就适合空转锁(pin lock)...这些我在后面都会说的，你可以翻到下面去看。

提到这个的原因是：大多数人学pthread学到mutex就结束了，然后不管什么都用mutex。那是不对的！！！



预防死锁

 

如果要进入一段临界区需要多个mutex锁，那么就很容易导致死锁，单个mutex锁是不会引发死锁的。要解决这个问题也很简单，只要申请锁的时候按照固定顺序，或者及时释放不需要的mutex锁就可以。这就对我们的代码有一定的要求，尤其是全局mutex锁的时候，更需要遵守一个约定。

如果是全局mutex锁，我习惯将它们写在同一个头文件里。一个模块的文件再多，都必须要有两个umbrella header file。一个是整个模块的伞，外界使用你的模块的时候，只要include这个头文件即可。另一个用于给模块的所有子模块去include，然后这个头文件里面就放一些公用的宏啊，配置啊啥的，全局mutex放在这里就最合适了。这两个文件不能是同一个，否则容易出循环include的问题。如果有人写模块不喜欢写这样的头文件的，那现在就要改了。

然后我的mutex锁的命名规则就是：作用_mutex_序号，比如LinkListMutex_mutex_1,OperationQueue_mutex_2，后面的序号在每次有新锁的时候，就都加一个1。如果有哪个临界区进入的时候需要获得多个mutex锁的，我就按照序号的顺序去进行加锁操作(pthread_mutex_lock)，这样就能够保证不会出现死锁了。



如果是属于某个struct内部的mutex锁，那么也一样，只不过序号可以不必跟全局锁挂钩，也可以从1开始数。



还有另一种方案也非常有效，就是用pthread_mutex_trylock函数来申请加锁，这个函数在mutex锁不可用时，不像pthread_mutex_lock那样会等待。pthread_mutex_trylock在申请加锁失败时立刻就会返回错误:EBUSY(锁尚未解除)或者EINVAL(锁变量不可用)。一旦在trylock的时候有错误返回，那就把前面已经拿到的锁全部释放，然后过一段时间再来一遍。 当然也可以使用pthread_mutex_timedlock这个函数来申请加锁，这个函数跟pthread_mutex_trylock类似，不同的是，你可以传入一个时间参数，在申请加锁失败之后会阻塞一段时间等解锁，超时之后才返回错误。



这两种方案我更多会使用第一种，原因如下：

  • 一般情况下进入临界区需要加的锁数量不会太多，第一种方案能够hold住。如果多于2个，你就要考虑一下是否有些锁是可以合并的了。

第一种方案适合锁比较少的情况，因为这不会导致非常大的阻塞延时。但是当你要加的锁非常多，ABCDE，你加到D的时候阻塞了，然而其他线程可能只需要AB就可以运行，就也会因为AB已经被锁住而阻塞，这时候才会采用第二种方案。如果要加的锁本身就不多，只有AB两个，那么阻塞一下也还可以。

  • 第二种方案在面临阻塞的时候，要操作的事情太多。

当你把所有的锁都释放以后，你的当前线程的处理策略就会导致你的代码复杂度上升：当前线程总不能就此退出吧，你得找个地方把它放起来，让它去等待一段时间之后再去申请锁，如果有多个线程出现了这样的情况，你就需要一个线程池来存放这些等待解锁的线程。如果临界区是嵌套的，你在把这个线程挂起的时候，最好还要把外面的锁也释放掉，要不然也会容易导致死锁，这就需要你在一个地方记录当前线程使用锁的情况。这里要做的事情太多，复杂度比较大，容易出错。



所以总而言之，设计的时候尽量减少同一临界区所需要mutex锁的数量，然后采用第一种方案。如果确实有需求导致那么多mutex锁，那么就只能采用第二种方案了，然后老老实实写好周边代码。但是！umbrella header file和按照序号命名mutex锁是个非常好的习惯，可以允许你随着软件的发展而灵活采取第一第二种方案。

但是到了semaphore情况下的死锁处理方案时，上面两种方案就都不顶用了，后面我会说。另外，还有一种死锁是自己把自己锁死了，这个我在后面也会说。




Reader-Writter Lock 读写锁

 

前面mutex锁有个缺点，就是只要锁住了，不管其他线程要干什么，都不允许进入临界区。设想这样一种情况：临界区foo变量在被bar1线程读着，加了个mutex锁，bar2线程如果也要读foo变量，因为被bar1加了个互斥锁，那就不能读了。但事实情况是，读取数据不影响数据内容本身，所以即便被1个线程读着，另外一个线程也应该允许他去读。除非另外一个线程是写操作，为了避免数据不一致的问题，写线程就需要等读线程都结束了再写。

因此诞生了Reader-Writter Lock，有的地方也叫Shared-Exclusive Lock，共享锁。

Reader-Writter Lock的特性是这样的，当一个线程加了读锁访问临界区，另外一个线程也想访问临界区读取数据的时候，也可以加一个读锁，这样另外一个线程就能够成功进入临界区进行读操作了。此时读锁线程有两个。当第三个线程需要进行写操作时，它需要加一个写锁，这个写锁只有在读锁的拥有者为0时才有效。也就是等前两个读线程都释放读锁之后，第三个线程就能进去写了。总结一下就是，读写锁里，读锁能允许多个线程同时去读，但是写锁在同一时刻只允许一个线程去写。

这样更精细的控制，就能减少mutex导致的阻塞延迟时间。虽然用mutex也能起作用，但这种场合，明显读写锁更好嘛！



相关宏和函数

 

    PTHREAD_RWLOCK_INITIALIZER

    int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr); int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); int pthread_rwlock_timedrdlock_np(pthread_rwlock_t *rwlock, const struct timespec *deltatime); // 这个函数在Linux和Mac的man文档里都没有，新版的pthread.h里面也没有，旧版的能找到 int pthread_rwlock_timedwrlock_np(pthread_rwlock_t *rwlock, const struct timespec *deltatime); // 同上



要注意的地方

 

命名

 

跟上面提到的写muetx锁的约定一样，操作，类别，序号最好都要有。比如OperationQueue_rwlock_1。

 

认真区分使用场合，记得避免写线程饥饿

 

由于读写锁的性质，在默认情况下是很容易出现写线程饥饿的。因为它必须要等到所有读锁都释放之后，才能成功申请写锁。不过不同系统的实现版本对写线程的优先级实现不同。Solaris下面就是写线程优先，其他系统默认读线程优先。

比如在写线程阻塞的时候，有很多读线程是可以一个接一个地在那儿插队的(在默认情况下，只要有读锁在，写锁就无法申请，然而读锁可以一直申请成功，就导致所谓的插队现象)，那么写线程就不知道什么时候才能申请成功写锁了，然后它就饿死了。

为了控制写线程饥饿，必须要在创建读写锁的时候设置PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE，不要用PTHREAD_RWLOCK_PREFER_WRITER_NP啊，这个似乎没什么用，感觉应该是个bug，不要问我是怎么知道的。。。

 

////////////////////////////// /usr/include/pthread.h

/* Read-write lock types. */ #if defined __USE_UNIX98 || defined __USE_XOPEN2K enum { PTHREAD_RWLOCK_PREFER_READER_NP, PTHREAD_RWLOCK_PREFER_WRITER_NP, // 妈蛋，没用，一样reader优先 PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP };

总的来说，这样的锁建立之后一定要设置优先级，不然就容易出现写线程饥饿。而且读写锁适合读多写少的情况，如果读、写一样多，那这时候还是用mutex锁比较合理。




spin lock 空转锁

 

上面在给出mutex锁的实现代码的时候提到了这个spin lock，空转锁。它是互斥锁、读写锁的基础。在其它同步机制里condition variable、barrier等都有它的身影。

我先说一下其他锁申请加锁的过程，你就知道什么是spin lock了。

互斥锁和读写锁在申请加锁的时候，会使得线程阻塞，阻塞的过程又分两个阶段，第一阶段是会先空转，可以理解成跑一个while循环，不断地去申请锁，在空转一定时间之后，线程会进入waiting状态(对的，跟进程一样，线程也分很多状态)，此时线程就不占用CPU资源了，等锁可用的时候，这个线程会被唤醒。

为什么会有这两个阶段呢？主要还是出于效率因素。

 

  • 如果单纯在申请锁失败之后，立刻将线程状态挂起，会带来context切换的开销，但挂起之后就可以不占用CPU资源了，原属于这个线程的CPU时间就可以拿去做更加有意义的事情。假设锁在第一次申请失败之后就又可用了，那么短时间内进行context切换的开销就显得很没效率。

  • 如果单纯在申请锁失败之后，不断轮询申请加锁，那么可以在第一时间申请加锁成功，同时避免了context切换的开销，但是浪费了宝贵的CPU时间。假设锁在第一次申请失败之后，很久很久才能可用，那么CPU在这么长时间里都被这个线程拿来轮询了，也显得很没效率。

 

于是就出现了两种方案结合的情况：在第一次申请加锁失败的时候，先不着急切换context，空转一段时间。如果锁在短时间内又可用了，那么就避免了context切换的开销，CPU浪费的时间也不多。空转一段时间之后发现还是不能申请加锁成功，那么就有很大概率在将来的不短的一段时间里面加锁也不成功，那么就把线程挂起，把轮询用的CPU时间释放出来给别的地方用。

所以spin lock就是这样的一个锁：它在第一次申请加锁失败的时候，会不断轮询，直到申请加锁成功为止，期间不会进行线程context的切换。互斥锁和读写锁基于spin lock又多做了超时检查和切换context的操作，如此而已。

 

这里是spin lock申请加锁的实现：

 

/////////////////////////////pthread_src/sysdeps/posix/pt-spin.c

/* Lock the spin lock object LOCK. If the lock is held by another  thread spin until it becomes available. */ int _pthread_spin_lock (__pthread_spinlock_t *lock) { int i; while (1) { for (i = 0; i < __pthread_spin_count; i++) { if (__pthread_spin_trylock (lock) == 0) return 0; } __sched_yield (); } }



相关宏和函数

 

我没在man里面找到spin lock相关的函数，但事实上外面还是能够使用的，下面是我在源代码里面挖到的原型：

 

////////////////////////////////pthread_src/pthread/pt-spin-inlines.c

/* Weak aliases for the spin lock functions. Note that  pthread_spin_lock is left out deliberately. We already provide an  implementation for it in pt-spin.c. */ weak_alias (__pthread_spin_destroy, pthread_spin_destroy); weak_alias (__pthread_spin_init, pthread_spin_init); weak_alias (__pthread_spin_trylock, pthread_spin_trylock); weak_alias (__pthread_spin_unlock, pthread_spin_unlock); /////////////////////////////////pthread_src/sysdeps/posix/pt-spin.c weak_alias (_pthread_spin_lock, pthread_spin_lock); /*-------------------------------------------------*/ PTHREAD_SPINLOCK_INITIALIZER int pthread_spin_init (__pthread_spinlock_t *__lock, int __pshared); int pthread_spin_destroy (__pthread_spinlock_t *__lock); int pthread_spin_trylock (__pthread_spinlock_t *__lock); int pthread_spin_unlock (__pthread_spinlock_t *__lock); int pthread_spin_lock (__pthread_spinlock_t *__lock); /*-------------------------------------------------*/



注意事项



还是要分清楚使用场合

 

了解了空转锁的特性，我们就发现这个锁其实非常适合临界区非常短的场合，或者实时性要求比较高的场合。

由于临界区短，线程需要等待的时间也短，即便轮询浪费CPU资源，也浪费不了多少，还省了context切换的开销。 由于实时性要求比较高，来不及等待context切换的时间，那就只能浪费CPU资源在那儿轮询了。

不过说实话，大部分情况你都不会直接用到空转锁，其他锁在申请不到加锁时也是会空转一定时间的，如果连这段时间都无法满足你的请求，那要么就是你扔的线程太多，或者你的临界区没你想象的那么短。




pthread_cleanup_push() & pthread_cleanup_pop()

 

线程是允许在退出的时候，调用一些回调方法的。如果你需要做类似的事情，那么就用以下这两种方法:

 

    void pthread_cleanup_push(void (*callback)(void *), void *arg); void pthread_cleanup_pop(int execute);

正如名字所暗示的，它背后有一个stack，你可以塞很多个callback函数进去，然后调用的时候按照先入后出的顺序调用这些callback。所以你在塞callback的时候，如果是关心调用顺序的，那就得注意这一点了。

但是！你塞进去的callback只有在以下情况下才会被调用：

 

  1. 线程通过pthread_exit()函数退出
  2. 线程被pthread_cancel()取消
  3. pthread_cleanup_pop(int execute)时，execute传了一个非0值

 

也就是说，如果你的线程函数是这么写的，那在线程结束的时候就不会调到你塞进去的那些callback了：

 

static void * thread_function(void *args) { ... ... ... ... return 0; // 线程退出时没有调用pthread_exit()退出，而是直接return，此时是不会调用栈内callback的 }

 

用exit()行不行？尼玛一调用这个整个进程就挂掉了～只要在任意线程调用exit()，整个进程就结束了，不要瞎搞。pthread_cleanup_push塞入的callback可以用来记录线程结束的点，活着打打日志啥的，一般不太会在这里执行业务逻辑。在线程结束之后如果要执行业务逻辑，一般用下面提到的pthread_join。



注意事项

callback函数是可以传参数的

 

对的，在pthread_cleanup_push函数中，第二个参数的值会作为callback函数的第一个参数，不要浪费了，拿来打打日志也不错。举个例子：

 

void callback(void *callback_arg) { printf("arg is : %s\n", (char *)callback_arg); } static void * thread_function(void *thread_arg) { ... pthread_cleanup_push(callback, "this is a queue thread, and was terminated."); ... pthread_exit((void *) 0); // 这句不调用，线程结束就不会调用你塞进去的callback函数。 return ((void *) 0); } int main () { ... ... error = pthread_create(&tid, NULL, thread_function, (void *)thread_arg) ... ... return 0; }

 

你也发现了，callback函数的参数是在线程函数里面设置的，所以拿来做业务也是可以的，不过一般都是拿来做清理的事情，很少会把它放到业务里面去做。



要保持callback栈平衡

 

有的时候我们并不一定要在线程结束的时候调用这些callback，那怎么办？直接return不就好了么，return的话，不就不调用callback了？

如果你真是这么想的，请去撞墙5分钟。

callback的调用栈一定要保持平衡，如果你不保持平衡就退出了线程，后面的结果是undefine的，有的系统就core dump了(比如Mac)，有的系统还就这么跑过去了一点反应也没有(这个是我猜的，没验证过，因为callback栈不平衡的结果是未定义的)。

所以遇到有时要调用有时又不需要的时候，这么写才是正确的姿势：

 

void callback1(void *callback_arg) { printf("arg is : %s\n", (char *)callback_arg); } void callback2(void *callback_arg) { printf("arg is : %s\n", (char *)callback_arg); } static void * thread_function(void *thread_arg) { ... pthread_cleanup_push(callback1, "this is callback 1."); pthread_cleanup_push(callback2, "this is callback 2."); ... if (thread_arg->should_callback) { pthread_exit((void *) result); } pthread_cleanup_pop(0); // 传递参数0，在pop的时候就不会调用对应的callback，如果传递非0值，pop的时候就会调用对应callback了。 pthread_cleanup_pop(0); // push了两次就pop两次,你要是只pop一次也可以，因为下面也有pthread_exit。这样一来就只会调用callback1，不会调用callback2了，因为callback2在栈顶被上面那句pop出去了。 pthread_exit((void *) result); // 所有的线程都应该用pthread_exit来结束，一方面是确保栈平衡，另一方面，也给别的线程join提供了方便 return ((void *) 0); } int main () { ... ... error = pthread_create(&tid, NULL, thread_function, (void *)thread_arg) ... ... return 0; }




pthread_join()

 

在线程结束的时候，我们能通过上面的pthread_cleanup_push塞入的callback方法知道，也能通过pthread_join这个方法知道。一般情况下，如果是出于业务的需要要知道线程何时结束的，都会采用pthread_join这个方法。

 

它适用这样的场景：

你有两个线程，B线程在做某些事情之前，必须要等待A线程把事情做完，然后才能接着做下去。这时候就可以用join。

 

原型:

 

    int pthread_join(pthread_t thread, void **value_ptr);

 

在B线程里调用这个方法，第一个参数传A线程的thread_id, 第二个参数你可以扔一个指针进去。当A线程调用pthread_exit(void *value_ptr)来结束的时候，A的value_ptr就会到pthread_join的value_ptr去，你可以理解成A把它计算出来的结果放到exit函数里面去，然后其他join的线程就能拿到这个数据了。

在B线程join了A线程之后，B线程会阻塞住，直到A线程跑完。A线程跑完之后，自动被detach，后续再要join的线程就会报EINVAL。



注意事项

 

新创建的线程默认是join属性，每一个join属性的线程都需要通过pthread_join来回收资源

 

  • 如果A线程已经跑完，但没被join过，此时B线程要去join A线程的时候，pthread_join是会立刻正确返回的，之后A线程就被detach了，占用的资源也会被释放。
  • 如果A线程已经跑完，后面没人join它，它占用的资源就会一直在哪儿，变成僵尸线程。

所以要么在创建线程的时候就把线程设置为detach的线程，这样线程跑完以后不用join，占用的资源自动回收。

要么不要忘记去join一下，把资源回收了，不要留僵尸。

 

注意传递的参数的内存生命周期

 

虽然线程和进程共享同一个进程资源，但如果在pthread_exit()里面你传递的指针指向的是栈内存，那么在结束之后，这片内存还是会被回收的，具体到使用的时候，不同的系统又是不同的方案了。

还有就是，一定要在获得value_ptr之后，检查一下value_ptr是否PTHREAD_CANCELED，因为如果你要等待的线程被cancel掉了，你拿到的就是这个数据。

 

多个线程join同一个线程

 

pthread_join是允许多个线程等待同一个线程的结束的。如果要一个线程等待多个线程的结束，那就需要用下面提到的条件变量了，或者barrier也行。

但是多个线程join同一个线程的时候，情况就比较多。多而已，不复杂。我们先建立一个约定：A线程是要被join的线程，BCDEF是要等待A线程结束的线程。下面说一下每种情况：

 

  • A线程正在运行，BCDEF线程发起对A的join，发起join结束后，A仍然在运行中

此时BCDEF线程都会被阻塞，等待A线程的结束。A线程结束之后，BCDEF都被唤醒，能够正常获得A线程通过pthread_exit()返回的数据。

 

  • A线程正在运行，BCDEF发起对A的join，BCD发起join成功后，A线程结束，然后EF发起join

此时BCD线程能够正常被唤醒，并完成任务，由于被join后A线程被detach，资源释放，后续EF再要发起join，就会EINVAL。

 

  • A线程正在运行，且运行结束。此时BCDEF发起对A的join。

此时谁先调用成功，谁就能完成任务，后续再要join的就都会EINVAL。一旦有一个线程join成功，A立刻被detach，资源释放，然后后面其他的线程就都不会join成功。



总的来说，只要线程运行结束，并且被detach了，后面再join就不行了，只要线程还在运行中，就能join。如果运行结束了，第一次被join之后，线程就被detach了，后续就不能join。当然了，如果线程本来就是detach属性的线程，那任何时候都无法被join。




Condition Variables 条件变量

 

pthread_join解决的是多个线程等待同一个线程的结束。条件变量能在合适的时候唤醒正在等待的线程。具体什么时候合适由你自己决定。它必须要跟互斥锁联合起来用。原因我会在注意事项里面讲。

场景：B线程和A线程之间有合作关系，当A线程完成某件事情之前，B线程会等待。当A线程完成某件事情之后，需要让B线程知道，然后B线程从等待状态中被唤醒，然后继续做自己要做的事情。

如果不用条件变量的话，也行。那就是搞个volatile变量，然后让其他线程不断轮询，一旦这个变量到了某个值，你就可以让线程继续了。如果有多个线程需要修改这个变量，那就再加个互斥锁或者读写锁。

但是！！！这做法太特么愚蠢了，还特别浪费CPU时间，所以还在用volatile变量标记线程状态的你们也真是够了！！！

大致的实现原理是：一个条件变量背后有一个池子，所有需要wait这个变量的线程都会进入这个池子。当有线程扔出这个条件变量的signal，系统就会把这个池子里面的线程挨个唤醒。



相关宏和函数

 

    PTHREAD_COND_INITIALIZER
    int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr); int pthread_cond_destroy(pthread_cond_t *cond); int pthread_cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread_cond_t *cond); int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex); int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);

 

补充一下，原则上pthread_cond_signal是只通知一个线程，pthread_cond_broadcast是用于通知很多线程。但POSIX标准也允许让pthread_cond_signal用于通知多个线程，不强制要求只允许通知一个线程。具体看各系统的实现。一般我都是用pthread_cond_broadcast。

另外，在调用pthread_cond_wait之前，必须要申请互斥锁，当线程通过pthread_cond_wait进入waiting状态时，会释放传入的互斥锁。

下面我先给一个条件变量的使用例子，然后再讲需要注意的点。

 

void thread_waiting_for_condition_signal () { pthread_mutex_lock(&mutex); while (operation_queue == NULL) { pthread_cond_wait(&condition_variable_signal, &mutex); } /*********************************/ /* 做一些关于operation_queue的事 */ /*********************************/ pthread_mutex_unlock(&mutex); } void thread_prepare_queue () { pthread_mutex_lock(&mutex); /*********************************/ /* 做一些关于operation_queue的事 */ /*********************************/ pthread_cond_signal(&condition_variable_signal); // 事情做完了之后要扔信号给等待的线程告诉他们做完了 pthread_mutex_unlock(&mutex); /**************************/ /* 这里可以做一些别的事情 */ /**************************/ ... pthread_exit((void *) 0); }



要注意的地方

 

一定要跟mutex配合使用

 

    void thread_function_1 () { done = 1; pthread_cond_signal(&condition_variable_signal); } void thread_function_2 () { while (done == 0) { pthread_cond_wait(&condition_variable_signal, NULL); } }

 

这样行不行？当然不行。为什么不行？

 

这里涉及一个非常精巧的情况：在thread_function_2发现done＝0的时候，准备要进行下一步的wait操作。在具体开始下一步的wait操作之前，thread_function_1一口气完成了设置done，发送信号的事情。嗯，thread_function_2还没来得及waiting呢，thread_function_1就把信号发出去了，也没人接收这信号，thread_function_2继续执行waiting之后，就只能等待多戈了。



一定要检测你要操作的内容

 

    void thread_function_1 () { pthread_mutex_lock(&mutex); ... operation_queue = create_operation_queue(); ... pthread_cond_signal(&condition_variable_signal); pthread_mutex_unlock(&mutex); } void thread_function_2 () { pthread_mutex_lock(&mutex); ... pthread_cond_wait(&condition_variable_signal, &mutex); ... pthread_mutex_unlock(&mutex); }

 

这样行不行？当然不行。为什么不行？

 

比如thread_function_1一下子就跑完了，operation_queue也初始化好了，信号也扔出去了。这时候thread_function_2刚刚启动，由于它没有去先看一下operation_queue是否可用，直接就进入waiting状态。然而事实是operation_queue早已搞定，再也不会有人扔我已经搞定operation_queue啦的信号，thread_function_2也不知道operation_queue已经好了，就只能一直在那儿等待多戈了...



一定要用while来检测你要操作的内容而不是if

 

    void thread_function_1 () { pthread_mutex_lock(&mutex); done = 1; pthread_cond_signal(&condition_variable_signal); pthread_mutex_unlock(&mutex); } void thread_function_2 () { pthread_mutex_lock(&mutex); if (done == 0) { pthread_cond_wait(&condition_variable_signal, &mutex); } pthread_mutex_unlock(&mutex); }

 

这样行不行？大多数情况行，但是用while更加安全。

 

如果有别人写一个线程去把这个done搞成0了，期间没有申请mutex锁。

那么这时用if去判断的话，由于线程已经从wait状态唤醒，它会直接做下面的事情，而全然不知done的值已经变了。

如果这时用while去判断的话，在pthread_cond_wait解除wait状态之后，会再去while那边判断一次done的值，只有这次done的值对了，才不会进入wait。如果这期间done被别的不长眼的线程给改了，while补充的那一次判断就帮了你一把，能继续进入waiting。

不过这解决不了根本问题哈，如果那个不长眼的线程在while的第二次判断之后改了done，那还是要悲剧。根本方案还是要在改done的时候加mutex锁。

总而言之，用if也可以，毕竟不太容易出现不长眼的线程改done变量不申请加mutex锁的。用while的话就多了一次判断，安全了一点，即便有不长眼的线程干了这么龌龊的事情，也还能hold住。



扔信号的时候，在临界区里面扔，不要在临界区外扔

 

    void thread_function_1 () { pthread_mutex_lock(&mutex); done = 1; pthread_mutex_unlock(&mutex); pthread_cond_signal(&condition_variable_signal); } void thread_function_2 () { pthread_mutex_lock(&mutex); if (done == 0) { pthread_cond_wait(&condition_variable_signal, &mutex); } pthread_mutex_unlock(&mutex); }

 

这样行不行？当然不行。为什么不行？《Advanced Programming in the UNIX Enviroment 3 Edtion》这本书里也把扔信号的事儿放在临界区外面了呢。

 

不行就是不行，哪怕是圣经上这么写，也不行。哼。

 

就应该永远都在临界区里面扔条件信号，我画了一个高清图来解释这个事情，图比较大，可能要加载一段时间：

 

pthread的各种同步机制_第1张图片

 

看到了吧，1的情况就是在临界区外扔信号的坏处。由于在临界区外，其他线程要申请加mutex锁是可以成功的，然后这个线程要是改了你的敏感数据，你就只能去哭了...




semaphore 信号量

 

pthread库里面藏了一个semaphore，man手册里面似乎也找不到semaphore相关的函数。

semaphore事实上就是我们学《操作系统》的时候所说的PV操作。 你也可以把它理解成带有数量控制的互斥锁，当sem_init(&sem, 0, 1);时，他就是一个mutex锁了。

 

场景：比如有3台打印机，有5个线程要使用打印机，那么semaphore就会先记录好有3台，每成功被申请一次，就减1，减到0时，后面的申请就会被拒绝。

 

它也可以用mutex和条件变量来实现，但实际上还是用semaphore比较方便。



相关函数

 

    int sem_destroy(sem_t *sem); int sem_init(sem_t *sem, int pshared, unsigned int value); // 里的第二个参数是表示这个semaphore是否跨进程可见，Linux下还不支持这个，所以这个参数一般都传0 int sem_wait(sem_t *sem); // 如果sempahore的数值还够，那就semaphore数值减1，然后进入临界区。也就是传说中的P操作。 int sem_post(sem_t *sem); // 这个函数会给semphore的值加1，也就是V操作。 int sem_getvalue(sem_t *sem, int *valp); // 注意了，它把semaphore的值通过你传进去的指针告诉你，而不是用这个函数的返回值告诉你。

 

要注意的地方

 

semaphore下的死锁

 

mutex下的死锁比较好处理，因为mutex只会锁一个资源(当semaphore的值为1时，就是个mutex锁)，按照顺序来申请mutex锁就好了。但是到了semaphore这里，由于资源数量不止1个，死锁情况就显得比较复杂。

要想避免死锁，即便采用前面提到的方案：按照顺序加锁，一旦出现加锁失败，就释放所有资源。这招也行不通。假设这样一个情况，当前系统剩余资源情况如下：

 

剩余资源：      全部系统资源 A:3 A:10 B:2 B:10 C:4 C:10

 

此时有两个线程：t1, t2。

t1需要3个A，4个B，1个C t2需要2个A，2个B，2个C 根据当前剩余资源列表来看，t2可以得到执行，不会出现死锁。

 

假设我们采用旧方案：顺序申请加锁，加锁失败就释放。我们按照CPU时间来推演一个：

    1. t1申请3个A -> 成功 2. t2申请2个A -> 失败，等待 3. t1申请4个B -> 失败，等待，并释放3个A 4. t1申请3个A -> 成功 5. t2申请2个A -> 失败，等待 6. t1申请4个B -> 失败，等待，并释放3个A 7. t1申请3个A -> 成功 8. t2申请2个A -> 失败，等待 9. t1申请4个B -> 失败，等待，并释放3个A ...

 

发现没有，这时候t1和t2都得不到执行，但实际上系统的剩余资源是满足t2的要求的，但由于运气不好，抢资源抢不过t1，在有新的资源被释放之前，这俩线程就一直在那儿抢来抢去得不到执行了。

要解决这样的问题，就需要采用银行家算法，银行家算法描述起来很简单：获取所有候选线程的需求，随机取一个假设资源分配出去，看是否能够分配成功。如果不能，就换一个候选者，再进行资源分配。直到有线程满足需求为止。如果都不能满足，那就挂起所有线程，等待新的资源释放。

也就是可以理解成很多个人去贷款，银行家先假设你们都能按期还得起钱，按照你们的需求给你们派钱，不过这不是真的派出去了，只是先写在纸上，银行家一推算，卧槽，到后面会出现资金缺口，那就换一种派发方式，直到没有资金缺口为止。

说白了，你需要在你的程序里面建立一个资源分配者的角色，所有待分配资源的线程都去一个池子里排队，然后这个资源分配者一次只允许一个线程来请求资源，如果请求失败，就换下一个，如果池子里没有线程能够被满足需求，那就集体挂起，然后等有新的资源来了，就再把这些线程一个一个叫过来进行资源分配。




Barriers

 

Barrier可以理解成一个mile stone。当一个线程率先跑到mile stone的时候，就先等待。当其他线程都到位之后，再从等待状态唤醒，继续做后面的事情。

场景：超大数组排序的时候，可以采用多线程的方案来排序。比如开10个线程分别排这个超大数组的10个部分。必须要这10个线程都完成了各自的排序，你才能进行后续的归并操作。先完成的线程会挂起等待，直到所有线程都完成之后，才唤醒所有等待的线程。

前面有提到过条件变量和pthread_join，前者是在做完某件事情通知其他线程，后者是在线程结束之后让其他线程能够获得执行结果。如果有多个线程同时做一件事情，用上面这两者可以有次序地进行同步。另外，用semaphore也可以实现Barrier的功能。

但是我们已经有Barrier了好吗！你们能不要把代码搞那么复杂吗！



相关宏和函数

 

int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *restrict attr, unsigned count); int pthread_barrier_destroy(pthread_barrier_t *barrier); int pthread_barrier_wait(pthread_barrier_t *barrier);

 

pthread_barrier_wait在唤醒之后，会有两种返回值：0或者PTHREAD_BARRIER_SERIAL_THREAD，在众多线程中只会有一个线程在唤醒时得到PTHREAD_BARRIER_SERIAL_THREAD的返回，其他返回都是0。拿到PTHREAD_BARRIER_SERIAL_THREAD返回的，表示这是上天选择的主线程～

 

要注意的地方

 

其实Barrier很少被错用，因为本来也没几个函数。更多的情况是有人不知道有Barrier，然后用其他的方式实现了类似Barrier的功能。知道就好了。




关于attr



thread


创建thread的时候是可以设置attr的：detachstate、guardsize、stackaddr、stacksize。一般情况下我都是采取默认的设置。只有在我非常确定这个线程不需要跟其他线程协作的时候，我会把detachstate设置为PTHREAD_CREATE_DETACHED。



mutex

 

创建mutex的时候也是可以设置attr的：process-shared、robust、type。一般情况下尽量不要出现跨进程的锁共享，万一有个相关进程被酒杀(kill 9)了，而且死之前它抱着锁没放，你后面的事情就麻烦了，基本无解。process-shared和robust就是跟跨进程有关。

关于type，我强烈建议显式设置为PTHREAD_MUTEX_ERRORCHECK。在Linux下，默认的type是PTHREAD_MUTEX_NORMAL。这在下面这种情况下会导致死锁：

 

void thread_function() { pthread_mutex_lock(&mutex); foo(); pthread_mutex_unlock(&mutex); } void foo() { pthread_mutex_lock(&mutex); pthread_mutex_unlock(&mutex); }

 

上面的代码看着很正常是吧？但由于在调用foo之前，mutex已经被锁住了，于是foo就停在那边等待thread_function释放mutex。但是！thread_function必须要等foo跑完才能解锁，然后现在foo被卡住了。。。

如果type设置为PTHREAD_MUTEX_ERRORCHECK，那在foo里面的pthread_mutex_lock就会返回EDEADLK。如果你要求执行foo的时候一定要处于mutex的临界区，那就要这么判断。

如果type设置为PTHREAD_MUTEX_RECURSIVE，也不会产生死锁，但不建议用这个。PTHREAD_MUTEX_RECURSIVE使用的场景其实很少，我一时半会儿也想不到哪个场景不得不采用PTHREAD_MUTEX_RECURSIVE。

嗯，其他应该没什么了吧。




总结

 

这篇文章主要讲了pthread的各种同步机制相关的东西：mutex、reader-writter、spin、cleanup callbacks、join、condition variable、semaphore、barrier。其中cleanup callbacks不算是同步机制，但是我看到也有人拿这个作为同步机制的一部分写在程序中，这是不对的！所以我才写了一下这个。

文章很长，相信你们看到这里也不容易，看完了这篇文章，你对多线程编程的同步机制应该可以说比较了解了。但我还要说的是，多线程编程的复杂点不仅仅在于同步机制，例如多线程跟系统信号的协作、多线程创建进程后的协作和控制、多线程和I/O之间的协作和控制、函数的可重入性等，我看我什么时候有时间再写这些内容了。

 

你可能感兴趣的:(pthread)

  • pthread_create/join函数学习 Miqiuha javajvm开发语言
    转自：https://blog.csdn.net/wushuomin/article/details/80051295，chatgpt1.pthread_createintpthread_create(pthread_t*thread,constpthread_attr_t*attr,void*(*start_routine)(void*),void*arg);它的功能是创建线程（实际上就是确定调
  • ./nptl/pthread_mutex_lock.c:81: __pthread_mutex_lock: Assertion `mutex->__data.__owner == 0' failed 五山口老法师
    #include#include#include#include#include#includeusingnamespacestd;pthread_cond_ttaxiarrive=PTHREAD_COND_INITIALIZER;//intpci=pthread_cond_init(&taxiarrive,NULL);pthread_mutex_tmenarrive=PTHREAD_MUTEX_
  • ThreadLocal内存如何释放 风吹吹2 javajava
    是ThreadLocal是web中线程中存储变量传送数据的神奇，因为web中每个请求都一个是线程，所以可以理解为一次请求到结束都是可以在ThreadLocal中存储获取的（不包括异步、响应式webflux)，因为他们整个请求不是在同一线程#ThreadLocal那么原理是什么#在Thread里有个threadLocals字段，类型为ThreadLocal.ThreadLocalMapThreadL
  • webserver(1) yundan1fengqing 服务器网络c++
    WebServer(1)主要内容+技术重难点一、代码+注释，可以运行通过(初始版1)locker.h多线程必须加锁操作#ifndefLOCKER_H#defineLOCKER_H#include#include#include//线程同步机制封装类//互斥锁类classlocker{public:locker(){if(pthread_mutex_init(&m_mutex,NULL)!=0){t
  • 鸿蒙轻内核M核源码分析系列二十 Newlib C OpenHarmony_小贾 HarmonyOS鸿蒙开发OpenHarmonyharmonyosc语言移动开发鸿蒙内核鸿蒙开发openharmony开发语言
    LiteOS-M内核LibC实现有2种，可以根据需求进行二选一，分别是musllibC和newlibc。本文先学习下NewlibC的实现代码。文中所涉及的源码，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取。使用MuslC库的时候，内核提供了基于LOS_XXX适配实现pthread、mqeue、fs、semaphore、time等模块
  • c语言函数传递结构体指针,注意使用结构体指针给函数传递参数。 荣耀张大仙mkq0~ c语言函数传递结构体指针
    该楼层疑似违规已被系统折叠隐藏此楼查看此楼为了增加参数调用的灵活性，可以利用结构体指针传递多个不同的参数进入C语言函数体。最著名的例子就是用Win32APIHANDLECreateThread(LPSECURITY_ATTRIBUTESlpThreadAttributes,DWORDdwStackSize,LPTHREAD_START_ROUTINElpStartAddress,LPVOIDlpP
  • java多线程:模拟ThreadLocal ╭╯Erica 并发编程java多线程
    ThreadLocal存储的变量，同一线程下可见，不同线程不可见packagecom.tuyrk.chapter10;importjava.util.HashMap;importjava.util.Map;/***模拟ThreadLocal**/publicclassThreadLocalSimulator{privatefinalMapstorage=newHashMapthreadLocal=
  • 9 自研rgbd相机基于rk3566之qt框架开发rgbd融合线程 三十度角阳光的问候 qtqt-creator双目rgbd点云融合tof瑞芯微
    qt框架开发rgbd融合线程rgbd线程功能及处理流程1rgbd线程分为如下几个功能：2rgbd线程的处理流程如下：rgbd线程qt程序详解1接收界面启动停止信号。2qt线程运行点云与颜色帧对齐rgbd线程程序示例1线程头文件：pthread_tof.h2线程源文件：pthread_tof.cpprgbd线程功能及处理流程1rgbd线程分为如下几个功能：1创建与声明rgbtof的共享内存。2同时接
  • 9 自研rgbd相机基于rk3566之qt框架开发rgb图像处理线程 三十度角阳光的问候 qt图像处理qt-creatorv4l2rk3566多线程
    qt框架开发rgb图像处理线程rgb线程功能及处理流程1rgb线程分为如下几个功能：2rgb线程的处理流程如下：rgb线程qt程序详解1接收界面启动停止信号。2qt线程运行rgb线程程序示例1线程头文件：pthread_33d_sc2310.h2线程源文件：pthread_33d_sc2310.cpprgb线程功能及处理流程1rgb线程分为如下几个功能：1v4l2采图部分，将v4l2采图功能放到q
  • ffmpeg+nvidia 编码错误 嵌入梦想 工具视频编解码
    ffmpegversiongit-2021-12-31-6b7e4deCopyright(c)2000-2021theFFmpegdevelopersbuiltwithgcc7(Ubuntu7.5.0-3ubuntu1~18.04)configuration:--pkg-config-flags=--static--extra-libs='-lpthread-lm'--ld=g++--enable
  • Linux系统编程（10）线程资源回收和互斥锁 流殇258 java开发语言
    一、pthread_cancel函数pthread_cancel函数用于请求取消一个线程。当调用pthread_cancel时，它会向指定的线程发送一个取消请求。#includeintpthread_cancel(pthread_tthread);thread：要发送取消请求的线程标识符。成功时，返回0。失败时，返回一个错误号二、pthread_detach函数pthread_detach用于将线
  • 多线程 reboot_q
    线程一个进程要想执行任务,就必须开启线程.一个线程同一时间只能执行一个任务(线程内部是串行的).多线程CPU通过操控多个线程切换,并行执行任务!提高效率;线程开销,耗性能,发热耗电;主线程UI线程,刷新UI界面,处理点击事件;防止线程阻塞.FirstHeaderSecondHeaderpthreadCNSThreadOCGCDCNSOperationC线程的状态runnable,running,b
  • POSIX线程（pthread库）介绍及使用方法 AI+程序员在路上 嵌入式软件开发linux系列开发语言c语言linux
    一.概述1.POXIS介绍POXIS是一种操作系统接口标准，全称为“可移植操作系统接口”。它最初由IEEE组织制定，目的是为了使不同的操作系统之间可以互相兼容。POSIX标准定义了一系列API（应用程序接口）和命令行工具，这些API和工具规定了操作系统应该提供哪些功能，并规定了这些功能的调用方式和行为。POSIX标准包含多个部分，主要涵盖了文件管理、进程控制、用户权限、系统调用等方面。跨平台特性：
  • C语言中的多线程编程：POSIX线程库（Pthreads）入门与实战（一） JJJ69 学习C语言吧开发语言c语言
    目录一、引言背景介绍文章目的与读者定位二、夽线程基础概念线程与进程的关系并发与并行的区别多线程的优势与挑战三、POSIX线程库（Pthreads）简介POSIX标准与Pthreads规范Pthreads的兼容性与移植性总结一、引言背景介绍随着计算机硬件技术的飞速发展，多核处理器已经成为现代计算设备的标准配置。这种架构变革使得单个处理器芯片能够容纳多个执行核心，从而显著提升了并行计算能力。面对这样的
  • C语言中pthread或Windows API在多线程编程中的基本应用 IAKSH c语言
    文章目录多线程概述掌握多线程需要学习什么？使用pthread.h实现多线程使用WindowsAPI实现多线程使用threads.h实现多线程参考资料警告由于我懒得写完，而且懂的也不是很多，本文不会深入各个多线程库，不会涉及具体的高并发，原子操作等复杂内容，本文仅描述了C语言中多线程技术的基本使用方法~~，适合新人。~~由于threads.h与pthread.h定位冲突且资料较少，我没有对threa
  • C语言使用pthread多线程编程(windows系统) 安静平和 C/C++CPThread库多线程
    我们进行多线程编程，可以有多种选择，可以使用WindowsAPI，如果你在使用GTK，也可以使用GTK实现了的线程库，如果你想让你的程序有更多的移植性你最好是选择POSIX中的Pthread函数库，我的程序是在Linux下写的，所以我使用了Pthread库运行之前需要做一些配置：1.下载PTHREAD的WINDOWS开发包pthreads-w32-2-4-0-release.exe（任何一个版本均
  • 在C语言中使用POSIX线程库（pthread）实现多线程编程 杨咩咩ing c语言java开发语言信息与通信
    在现代编程中，多线程技术是一种常见的方式来提高程序性能和响应速度。多线程可以让程序在同一时间执行多个任务，从而更好地利用CPU资源。在C语言中，我们可以使用POSIX线程库（pthread）来创建和管理线程。本文将详细介绍如何在C语言中使用pthread库实现多线程编程。目录什么是线程？什么是POSIX线程（pthread）库？常用的pthread库函数有哪些？1.线程管理函数2.线程同步函数结论
  • 操作系统原子操作 zzt_is_me 算法linux
    原子操作所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。type__sync_fetch_and_add(type*ptr,typevalue);//+type__sync_fetch_and_sub(type*ptr,typevalu
  • 操作系统创建线程 zzt_is_me 开发语言linux
    创建线程intpthread_create(pthread_t*thread,          constpthread_attr_t*attr,          void*(*start_routine)(void*),          void*arg);​thread    -线程ID，输出型参数。我们目前使用的Linux中pthread_t即unsignedlongintattr  
  • 向线程传参来打印结构体中的内容及线程资源竞争 小leexie code c语言vim
    #include#include#include#include#includetypedefstructlxj{inta;intb;}lxj;void*fun(void*arg){lxj*p=(lxj*)arg;printf("%d\n",p->a);printf("%d\n",p->b);pthread_exit(NULL);}intmain(intargc,charconst*argv[])
  • C/C++语法｜pthread线程库的使用 Che3rry #C/C++c语言c++java
    笔记主要内容来自爱编程的大柄–线程爱编程的大柄–线程同步在进入代码实践之前，我们应该搞清楚。线程是成语的最小执行单位，进程是操作系统中最小的资源分配单位。这样的话我们可以理解以下两点：同一地址空间中的多个线程独有的是：每个线程都有属于自己的栈区和寄存器（内核中管理的），寄存器主要记录的就是上下文共享的是：.text、.rodata、.data、.heap、.bss、文件描述符关于线程个数的确定：文
  • C语言pthread互斥锁(mutex)和可重入锁(递归锁recursive)的演示 嫦娥妹妹等等我 开发语言c语言
    实验理论参考:1一旦共享资源被互斥锁锁定,则其余线程想访问共享资源必须等待，直到锁被释放2使用normal属性的互斥锁,一旦发生重入逻辑,则阻塞,成为死锁需要将属性改为recursive成为可重入的,递归的代码功能:1命令行传参1model=1演示异步未上锁之乱序演示count在数据竞态（RaceCondition）下的错误值2命令行传参2model=2演示使用互斥锁后线程的执行顺序演示count
  • 【Linux】线程同步 YoungMLet Linux系统linuxjava服务器运维c++开发语言
    线程同步一、条件变量1.同步概念2.条件变量概念3.条件变量接口（1）pthread_cond_init()（2）pthread_cond_destroy()（3）pthread_cond_wait()（4）pthread_cond_signal()（5）pthread_cond_broadcast()（6）使用接口二、生产者消费者模式1.概念2.生产者消费者模式优点3.基于BlockingQue
  • TCP/IP C 语言实现单个客户端和服务端 TCP 通信 a1309602336 tcp/ipc语言网络协议
    这是多线程服务端#include#include#include#include#include#pragmacomment(lib,"ws2_32.lib")#pragmawarning(disable:4996)//客户端结构体typedefstructThreadNode{intindex;pthread_t*Thread;SOCKETClient;structThreadNode*next
  • IOS开发进阶学习资料(提升必备) the_cleaner ios
    最近整理了下IOS学习资料，包含了入门、进阶、性能优化、面试和学习书籍，算是比较全面的，在这里分享给大家，希望对大家有用。先晒出IOS学习路线图，大家照着图谱修炼。学习社区objc中国learnIOSRayWenderlichNSHipsterWeiWang唐巧的博客cocoachina入门系列Casa的PThread多线程课程从零开发一款ios手把手带你构建类今日头条的AppSwift编程从入门
  • 最新IOS开发学习资料整理(进阶必备) henhenha ios
    最近整理了下IOS学习资料，包含了入门、进阶、性能优化、面试和学习书籍，算是比较全面的，在这里分享给大家，希望对大家有用。先晒出IOS学习路线图，大家照着图谱修炼。学习社区objc中国learnIOSRayWenderlichNSHipsterWeiWang唐巧的博客cocoachina入门系列Casa的PThread多线程课程从零开发一款ios手把手带你构建类今日头条的AppSwift编程从入门
  • 【lesson53】线程控制 (unstoppable) linuxLinux线程控制C++
    文章目录线程控制线程控制线程创建代码：运行代码：强调一点，线程和进程不一样，进程有父进程的概念，但在线程组里面，所有的线程都是对等关系。错误检查:传统的一些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指示错误。pthreads函数出错时不会设置全局变量errno（而大部分其他POSIX函数会这样做）。而是将错误代码通过返回值返回pthreads同样也提供了线程内的errno变量
  • 【Linux】线程概念和线程控制 YoungMLet Linux系统linuxjava运维c++服务器开发语言
    线程概念一、理解线程1.Linux中的线程2.重新定义线程和进程3.进程地址空间之页表4.线程和进程切换5.线程的优点6.线程的缺点7.线程异常8.线程用途9.线程和进程二、线程控制1.pthread线程库（1）pthread_create()（2）pthread_join()（3）pthread_exit()（4）pthread_cancel()（5）简单使用pthread库2.理解线程库（1）
  • 线程的取消和互斥 炸酱面。 c语言
    线程的取消intpthread_cancel(pthread_tthread);注意：线程的取消要有取消点才可以，不是说取消就取消，线程的取消点主要是阻塞的系统调用（前面sleep就是一个阻塞的系统调用）如果没有取消点，手动设置一个把上图中sleep函数替换成这个一样可以取消voidpthread_testcancel(void);//设置取消点的函数设置取消使能或禁止intpthread_set
  • E xx: xxxx:xx ERR thread 0x536753929472 setscheduler failed Operation not permitted Halo_fu linux编程Androidlinuxandroid
    通过sched_setscheduler设置线程优先级时，发生了“setschedulerfailedOperationnotpermitted”错误。intret=sched_setscheduler(pthread_gettid_np((pthread_t)pHandle),SCHED_RR,&prio);解决方法在进程启动参数中追加下记内容：capabilitiesSYS_NICEinit.
  • redis学习笔记——不仅仅是存取数据 Everyday都不同 returnSourceexpire/delincr/lpush数据库分区redis
    最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷）   1、关于JedisPool.returnSource(Jedis jeids)   这个方法是从red
  • SQL性能优化-持续更新中。。。。。。 atongyeye oraclesql
    1 通过ROWID访问表--索引 你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 2 共享SQL语句--相同的sql放入缓存 3 选择最有效率的表
  • [JAVA语言]JAVA虚拟机对底层硬件的操控还不完善 comsci JAVA虚拟机
         如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？ 那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ &n
  • lvs- real 男人50 LVS
    #!/bin/bash # # Script to start LVS DR real server. # description: LVS DR real server # #.  /etc/rc.d/init.d/functions VIP=10.10.6.252 host='/bin/hostname' case "$1" in sta
  • 生成公钥和私钥 oloz DSA安全加密
    package com.msserver.core.util; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; public class SecurityUtil {
  • UIView 中加入的cocos2d，背景透明 374016526 cocos2dglClearColor
    要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
  • mysql常用命令 香水浓 mysql
    连接数据库 mysql -u troy -ptroy 备份表 mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 恢复表（与恢复数据库命令相同） mysql -u troy -ptroy mm_database < user.sql 备份数据库 mysqldump -u troy -ptroy
  • 我的架构经验系列文章 - 后端架构 - 系统层面 agevs JavaScriptjquerycsshtml5
    系统层面： 高可用性 所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
  • 利用ant进行远程tomcat部署 aijuans tomcat
    在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 1.配置tomcat的用户角色
  • 获取复利总收入 baalwolf 获取
           public static void main(String args[]){         int money=200;         int year=1;         double rate=0.1; &
  • eclipse.ini解释 BigBird2012 eclipse
    大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 Overview 1、Eclipse.ini的作用 Eclipse startup is controlled by th
  • AngularJS实现分页功能 bijian1013 JavaScriptAngularJS分页
            对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。   &nbs
  • [Maven学习笔记三]Maven archetype bit1129 ArcheType
    archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等.   mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式，   mvn archetype   1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
  • 【Java命令三】jps bit1129 Java命令
    jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看   [hadoop@hadoop bin]$ jps -help usage: jps [-help] jps [-q] [-mlvV] [<hostid>] Definitions: <hostid>: <hostname>[:
  • ZABBIX2.2 2.4 等各版本之间的兼容性 ronin47
    zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点 客户端AGENT兼容 zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
  • unity 3d还是cocos2dx哪个适合游戏？ brotherlamp unity自学unity教程unity视频unity资料unity
    unity 3d还是cocos2dx哪个适合游戏？ 问：unity 3d还是cocos2dx哪个适合游戏？ 答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2，
  • 百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序 bylijinnan java算法面试百度招聘
    import java.util.Arrays; /** * 最早是在陈利人老师的微博看到这道题： * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K * 设计一个排序算法。It should be faster than O(n*lgn)。
  • 获取checkbox复选框的值 chiangfai checkbox
    <title>CheckBox</title> <script type = "text/javascript"> doGetVal: function doGetVal() { //var fruitName = document.getElementById("apple").value;//根据
  • MySQLdb用户指南 chenchao051 mysqldb
    原网页被墙，放这里备用。 MySQLdb User's Guide Contents Introduction Installation _mysql MySQL C API translation MySQL C API function mapping Some _mysql examples MySQLdb
  • HIVE 窗口及分析函数 daizj hive窗口函数分析函数
    窗口函数应用场景： （1）用于分区排序 （2）动态Group By （3）Top N （4）累计计算 （5）层次查询 一、分析函数 用于等级、百分点、n分片等。 函数             说明 RANK()     &nbs
  • PHP ZipArchive 实现压缩解压Zip文件 dcj3sjt126com PHPzip
    PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。 一、解压缩zip文件 01 02 03 04 05 06 07 08 09 10 11
  • 精彩英语贺词 dcj3sjt126com 英语
    I'm always here              我会一直在这里支持你                &nb
  • 基于Java注解的Spring的IoC功能 e200702084 javaspringbeanIOCOffice
                                      
  • java模拟post请求 geeksun java
    一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。 此处用HttpComponents的httpclient来完成使命。 import org.apache.http.HttpEntity ; import org.apache.http.HttpRespon
  • Swift语法之 ---- ?和!区别 hongtoushizi ?swift!
    转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html   Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错： var stringValue : String //
  • centos7安装jdk1.7 jisonami jdkcentos
    安装JDK1.7 步骤1、解压tar包在当前目录 [root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 步骤2：配置环境变量 在etc/profile文件下添加 export JAVA_HOME=/usr/java/jdk1.7.0_75 export CLASSPATH=/usr/java/jdk1.7.0_75/lib
  • 数据源架构模式之数据映射器 home198979 PHP架构数据映射器datamapper
    前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。   一、概念 数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 &nb
  • 在Python中使用MYSQL pda158 mysqlpython
    缘由 　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到 数据库中。 　　了解到 Python在这方面有优势，便选用之。 　　由于我有台 server上面安装有 mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里 记录一下，大家共勉。 　　 python中mysql的调用 　　 百度之后能够通过MySQLdb进行数据库操作。
  • 单例模式 hxl1988_0311 java单例设计模式单件
    package com.sosop.designpattern.singleton; /* * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点 * * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件 * * 必须考虑到并发情况下创建了多个实例对象 * */ /** * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
  • 27种迹象显示你应该辞掉程序员的工作 vipshichg 工作
    1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他