pthread小结

参考1 https://computing.llnl.gov/tutorials/pthreads/
参考2 http://man7.org/linux/man-pages/man7/pthreads.7.html

---

join

• int pthread_join(pthread_t, void**);阻塞调用线程，直至指定pthread_t线程终止
• 在同一个线程中重复调用join会致使错误
• 在建立线程的时候能够指定要建立的线程是否joinable，若是是，则能够join，不然(即detached)不能够。通常默认都是joinable
• POSIX指出线程should指定为joinable
• 若是肯定一个线程须要join，那么最好明确指定该线程joinable，经过以下四步：

1. Declare a pthread attribute variable of the pthread_attr_t data type
2. Initialize the attribute variable with pthread_attr_init()
3. Set the attribute detached status with pthread_attr_setdetachstate()
4. When done, free library resources used by the attribute with pthread_attr_destroy()

pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
for(t=0; t<NUM_THREADS; t++) {
   printf("Main: creating thread %ld\n", t);
   rc = pthread_create(&thread[t], &attr, BusyWork, (void *)t);  //一个attr能够给多个线程使用
   if (rc) {
      printf("ERROR; return code from pthread_create() is %d\n", rc);
      exit(-1);
      }
   }
pthread_attr_destroy(&attr);    //记得释放资源。create执行完以后就能够释放，而不用等待线程结束

• 若是肯定一个线程不须要joinable，那么应该明确考虑设置属性为detached

• 经过pthread_detach()来设置线程为不可join，即便它被建立的时候被设置为joinable。这个动做不可逆

  stack

• POSIX没有规定建立的线程的stack大小是多少，这是由implementation决定的
• pthread_attr_setstacksize能够用来设置须要的stack大小
• pthread_attr_getstackaddr和pthread_attr_setstackaddr能够用来设置stack须要放置到特定的内存区域

size_t stacksize;
pthread_attr_init(&attr);
pthread_attr_getstacksize (&attr, &stacksize);
printf("Default stack size = %li\n", stacksize);
size = 10000; //设置为10000bytes
pthread_attr_setstacksize (&attr, stacksize);
printf("set stack size = %li\n", stacksize);
pthread_create(&threads[t], &attr, dowork, (void *)t);

---

mutex

Creating and Destroying Mutexes

//destroy，成功则返回0
int pthread_mutex_destroy(pthread_mutex_t *mutex);
//动态初始化，成功则返回0. 若是attr为NULL，那么将使用默认属性，至关于PTHREAD_MUTEX_INITIALIZER
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
//使用默认参数静态初始化
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

//mutex属性
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
int pthread_mutexattr_init(pthread_mutexattr_t *attr);

• 被destroy的mutex可使用pthread_mutex_init从新初始化
• destroy一个处于lock状态的mutex，将会致使undefined行为
• 只有mutex能够用来执行synchronization，用它的copies来执行lock,unlock和trylock将致使undefined

• 不能够重复初始化已经初始化了的mutex

  Locking and Unlocking Mutexes

//若是别的线程已经lock，那会一直阻塞当前线程直至得到锁
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

mutex类型	性质
PTHREAD_MUTEX_NORMAL	对mutex的重复lock，即本线程已经lock了mutex，在没有unlock以前又尝试lock，将致使死锁行为；unlock一个没有被本线程lock或者没有被任何线程lock的mutex，将致使未定义行为
PTHREAD_MUTEX_ERRORCHECK	尝试重复lock一个mutex将不会死锁，而是返回一个错误值；unlock一个没有被本线程lock或者没有被任何线程lock的mutex，也会返回错误值
PTHREAD_MUTEX_RECURSIVE	mutex能够被重复lock。每次lock会增长相关计数，直至经过unlock使计数达到0时，才能够被别的线程lock；unlock一个没有被本线程lock或者没有被任何线程lock的mutex，也会返回错误值
PTHREAD_MUTEX_DEFAULT	重复lock会致使未定义行为（NORMAL中会致使死锁）；unlock一个没有被本线程lock或者没有被任何线程lock的mutex，也将致使未定义行为。 不过，在NDK的定义中，直接把PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL

• pthread_mutex_trylock与pthread_mutex_lock只有一点区别：若是当前mutex被任意线程lock，pthread_mutex_trylock都将会马上返回。若是mutex是PTHREAD_MUTEX_RECURSIVE的，且mutex已经被当前调用线程lock，pthread_mutex_trylock也一样会致使计数增一，并返回success。
• 若是正在等待lock的线程收到了一个signal，当其从signal handler返回以后，会继续等待lock，就和signal没有发生同样
• 除非使用了 thread priority scheduling，不然多个正在等待lock的线程得到lock的状况可能多少有点random
• 若是成功，这三个函数都是返回0，不然返回相应的error

---

Condition Variables

• mutex经过控制对数据的访问权限来达到同步；而condition variables则基于数据的值来控制同步
• 若是不使用condition variable，线程想要检查某个条件则只能经过轮询的方式，这将很是resource consuming，由于这期间线程将一直active。而使用condition variable则将在不使用轮询的状况下实现此目标

• condition variable 常常和mutex一块儿使用

  Creating and Destroying Condition Variables

int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int pthread_condattr_destroy(pthread_condattr_t *attr);
int pthread_condattr_init(pthread_condattr_t *attr);

• destory正由某个线程用于block的cv将致使未定义行为
• 只有cv本身可以用于同步，任何基于它的copies调用pthread_cond_wait(), pthread_cond_timedwait(), pthread_cond_signal(), pthread_cond_broadcast(), pthread_cond_destroy()都会产生未定义行为
• 初始化一个已经初始化的cv会致使未定义行为；已经destory的cv能够再次初始化；

Waiting and Signaling on Condition Variables

通常使用流程：

int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, 
                            const struct timespec *restrict abstime);
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

• 这两个函数将致使调用线程block on the condition variable, 而且须要传入一个由调用线程lock了的mutex，不然致使未定义行为
• 若是在wait以前，没有明确lock对应mutex，可能并不会致使block
• 这两个函数会原子的unlock the mutex，而且致使调用线程block on the condition variable。这里的原子的意味着：只要其余线程lock了这个mutex，那么这个线程对pthread_cond_broadcast()或pthread_cond_signal()的调用都会产生调用wait的线程已经blocked on the condition variable的效果。
• 只要这两个函数返回，那么调用线程就已经lock了这个mutex
• 虚假唤醒Spurious wakeups 可能会产生，并且这并不违反标准，因此，即便调用线程被唤醒，也不意味着对某个值作出某种保证，应该再次确认条件是否真的知足了。同时，考虑到线程之间的竞争，pthread_cond_timedwait因为超时返回以后，条件也可能已经知足。总之。任什么时候候wait返回，都须要从新评估条件是否知足，这点很是重要
• 一旦线程waits on the condition variable，那么这个cv就和相应的mutex绑定了，在wait返回以前，不能再使用另外的mutex来调用wait，这会致使未定义行为
• condition wait是一个cancellation point。未明白
• 假设一个因为wait调用而block线程因为被canceled而unblocked，这个不会consume任何condition signal。
• pthread_cond_timedwait()和pthread_cond_wait()是equivalent的，除了：当signaled或者broadcasted超过指定时间，pthread_cond_timedwait()就会返回返回error。同时，cv还能够支持 Clock Selection，选择不一样的Clock来measure指定的时间
• 当cv wait期间，一个signal产生了，那么cv可能会继续wait就像没有中断同样，或者这会造成一个spurious wakeup，返回0.
  推荐使用while循环替代if语句来检查当前条件是否真的知足，有以下三点好处：

1. 若是有多个线程都是在wait相同过的wake up signal，那么当其余任意一个被waked up以后，他们都有可能更改条件值，而致使条件不知足
2. 线程可能会由于程序bug而收到一个signal
3. Pthreads library被允许产生虚假唤醒，并且这并不违反标准

int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);

• 当多于一个线程在wait的时候，应该使用pthread_cond_broadcast()
• 在signal以前，应该先lock对应mutex，而后在signal以后，应该unlock对应mutex。若是忘记了unlock，那么相应的wait线程会继续blocked，由于他们没法得到lock

---

结束线程

有：

• pthread_cancel
  
• pthread_exit
  

• pthread_kill
  参考https://www.cnblogs.com/biyeymyhjob/archive/2012/10/11/2720377.html
  ---

  其余函数

  pthread_self

  pthread_t pthread_self(void);返回调用线程的thread id

  pthread_equal

  int pthread_equal(pthread_t t1, pthread_t t2);比较两个ID是否相等，若是相等则返回not-zero value，不相等则返回0。因为pthread_t结果opaque，因此不该该用==来比较

  pthread_once

  int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));：在进程中，任何首次调用这个函数的线程，在pthread_once_t once_control = PTHREAD_ONCE_INIT的时候，会调用init_routine程序。而且当此函数返回的时候，init_routine已经执行完了（这里没有说init_routine会阻塞调用线程，可能考虑的是，当线程A已经调用init_routine，而另一个线程B也调用了pthread_once，那么是否B也会等待A调用的init_routine执行完毕？）。若是成功完成，则pthread_once返回0。若是once_control参数不是PTHREAD_ONCE_INIT，那么行为将是undefined。在LinuxThreads中：

在LinuxThreads中，实际"一次性函数"的执行状态有三种：NEVER（0）、IN_PROGRESS（1）、DONE （2），若是once初值设为1，则因为全部pthread_once()都必须等待其中一个激发"已执行一次"信号，所以全部pthread_once ()都会陷入永久的等待中；若是设为2，则表示该函数已执行过一次，从而全部pthread_once()都会当即返回0。

这个函数在当没法编辑进程的main函数，好比写一个库的时候，就颇有用。
TODO:若是多个线程使用的init_routine不相同怎么办？或者好比本身开发库，可是user的main中已经使用不一样的init_routine调用了pthread_once，那么会是什么结果？