跨平台线程库——pThread

基本接口介绍：

1.   pthread_create 

  #include <pthread.h>

   int pthread_create(pthread_t * thread, pthread_attr_t * attr, void * (*start_routine)(void *), void * arg);

   创建一个由调用线程控制的新的线程并发运行。新的线程使用start_routine作为实现体，并以arg作为第一个参数。
   新的线程可以通过调用pthread_exit显式结束，或者通过start_routine return来隐式结束。其中后者等价于调用pthread_exit并以start_routine 的返回值作为退出码。
      新线程的初始信号状态继承自他的创建线程，并且没有挂起的信号。pthread-win32暂时未实现信号量。
      attr参数指明新线程的属性，如果attr=NULL,则使用默认属性：新线程是joinable(not detached),和默认的调度策略(非实时)
     返回值：如果成功，新线程的指针会被存储到thread的参数中，并返回0。如果错误则一个非0的错误码返回。
      如果返回EAGAIN，没有足够的系统资源创建一个线程，或者已经存在大于PTHREAD_THREADS_MAX个活跃线程。

2. pthread_exit
   #include <pthread.h>

   void pthread_exit(void *retval);
   pthread_exit结束调用线程的执行.所有通过pthread_cleanup_push设置的清除句柄将会被反序执行(后进先出)。
 所以key值非空的线程特定数据Finalization functions被调用(参见pthread_key_create)。
  最后调用线程被终止。
  retval是这个线程结束的返回值，可以通过在别的线程中调用pthread_join来获取这个值。
   没有返回值。

3. pthread_join 
   #include <pthread.h>
   int pthread_join(pthread_t th, void **thread_return);    

   挂载一个在执行的线程直到该线程通过调用pthread_exit或者cancelled结束。（阻塞的方式等待指定的现成结束，释放线程资源）
   如果thread_return不为空，则线程th的返回值会保存到thread_return所指的区域。
   th的返回值是它给pthread_exit的参数，或者是pthread_canceled 如果是被cancelled的。
   被依附的线程th必须是joinable状态。一定不能是detached通过使用pthread_detach或者pthread_create中使用pthread_create_detached属性。
   当一个joinable线程结束时，他的资源(线程描述符和堆栈)不会被释放直到另一个线程对它执行pthread_join操作。
   如果成功，返回值存储在thread_return中，并返回0，否则返回错误码：
   ESRCH:找不到指定线程
   EINVAL:线程th是detached或者已经存在另一个线程在等待线程th结束
   EDEADLK:th的参数引用它自己(即线程不能join自身)

4.pthread_cancel   

  #include <pthread.h>

  int pthread_cancel(pthread_t thread);

  int pthread_setcancelstate(int state, int *oldstate);

  int pthread_setcanceltype(int type, int *oldtype);

  void pthread_testcancel(void);

   Cancellation是一种一个线程可以结束另一个线程执行的机制。更确切的说，一个线程可以发生Cancellation请求给另一个线程。
   根据线程的设置，收到请求的线程可以忽视这个请求，立即执行这个请求或者延迟到一个cancellation点执行。
   当一个线程执行Cancellation请求，相当于在那个点执行pthread_exit操作退出：所有cleanup句柄被反向调用，所有析构函数被调用结束线程并返回pthread_canceled.

5.pthread_cond   
   #include <pthread.h>

   pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

   int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);

   int pthread_cond_signal(pthread_cond_t *cond);

   int pthread_cond_broadcast(pthread_cond_t *cond);

   int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

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

   int pthread_cond_destroy(pthread_cond_t *cond);

   pthread_cond_init初始化条件变量，通过cond_attr，如果cond_attr是null则使用默认属性。也可以通过常量PTHREAD_COND_INITIALIZER静态初始化。
   pthread_cond_signal激活一个正在等待条件变量cond的线程。如果没有线程在等待则什么也不会发生，如果有多个线程在等待，则只能激活一个线程，带未指定是哪个线程(根据操作系统自己的调度策略选择)。
   pthread_cond_broadcast激活所有在等待条件变量cond的线程。
   pthread_cond_wait自动解锁mutex(pthread_unlock_mutex)等待条件变量cond发送。线程的执行被挂起不消耗cpu时间直到cond发送。在wait的入口mutex必须被锁住。
   在重新回到线程前，pthread_cond_wait会重新获得mutex(pthread_lock_mutex).解锁mutex和挂起是自动进行的。因此，如果所有线程在发送cond前都申请mutex的话，
   这种wait的内部实现机制能够保证在线程锁住mutex和线程wait之间不会有cond发送操作发送。
   pthread_cond_timedwait同pthread_cond_wait，只是多了个超时设置，如果超时，则重新获取mutex并且返回ETIMEDOUT，时间为绝对时间。
   pthread_cond_destroy销毁一个条件变量。必须没有线程在wait该条件变量。
   condition函数是异步信号不安全的，容易产生死锁，必须自己控制调用流程避免死锁。

6.semaphore

 #include <semaphore.h>

 int sem_init(sem_t *sem, int pshared, unsigned int value);

 int sem_wait(sem_t * sem);

 int sem_timedwait(sem_t * sem, const struct timespec *abstime);

 int sem_trywait(sem_t * sem);

 int sem_post(sem_t * sem);

 int sem_post_multiple(sem_t * sem, int number);

 int sem_getvalue(sem_t * sem, int * sval);

 int sem_destroy(sem_t * sem);

 sem_init:初始化信号量，pshared表示该信号量是否只属于当前进程(pshared==0)，如果pshared不为0则表示可以在进程间共享。value表示该信号量的初始值。
  sem_wait:如果信号量的值大于0，则自动减1并立即返回。否则线程挂起直到sem_post或sem_post_multiple增加信号量的值。
  sem_timedwait:同sem_wait,只是多了个超时设置，如果超时，首先将全局变量errno设为ETIMEDOUT，然后返回-1.
  sem_trywait:如果信号量的值大于0，将信号量减1并立即返回，否则将全局变量errno设为ETIMEDOUT，然后返回-1。sem_trywait不会阻塞。
  sem_post:释放一个正在等待该信号量的线程，或者将该信号量+1.
  sem_post_multiple:释放多个正在等待的线程。如果当前等待的线程数n小于number,则释放n个线程，并且该信号量的值增加(number - n).
  sem_get_value:返回信号量的值。在pthread-win32实现中，正值表示当前信号量的值，负值的绝对值表示当前正在等待该信号量的线程数。虽然在POSIX不需要这么表示，但是也是同样含义。


  信号量(sem)与条件变量(cond)的主要差别在于，条件变量等待必须在发送之前，否则容易出现死锁，而信号量等待可以在发送之后执行。一句话概括信号量对于操作的时序没有要求。

几个测试程序：
1.

#include <QCoreApplication>#include <iostream>#include "pthread.h"pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;pthread_cond_t cond = PTHREAD_COND_INITIALIZER;void *Func1(void *);void *Func2(void *);int i = 1;int main(int argc, char *argv[]){    QCoreApplication a(argc, argv);#ifdef WIN32#ifdef PTW32_STATIC_LIB    pthread_win32_process_attach_np();    pthread_win32_thread_attach_np();#endif#endif    pthread_t thread1;    pthread_t thread2;    pthread_create(&thread1,NULL,Func1,(void*)NULL);    pthread_create(&thread2,NULL,Func2,(void*)NULL);    pthread_join(thread2,NULL);    pthread_mutex_destroy(&mutex);    pthread_cond_destroy(&cond);#ifdef WIN32#ifdef PTW32_STATIC_LIB    pthread_win32_process_detach_np();    pthread_win32_thread_detach_np();#endif#endif    system("Pause");    return a.exec();}void *Func1(void *junk){    for(i = 1;i <= 9;i++)    {        if(i%3==0)        {            pthread_mutex_lock(&mutex);            pthread_cond_signal(&cond);            pthread_mutex_unlock(&mutex);        }        else        {            std::cout << "thread1: " << i << std::endl;        }    }    return NULL;}void *Func2(void *junk){    while(i<9)    {        if(i%3!=0)        {            pthread_mutex_lock(&mutex);            pthread_cond_wait(&cond,&mutex);            pthread_mutex_unlock(&mutex);        }        else        {            std::cout << "thread2: " << i << std::endl;        }    }    return NULL;}

2.

#include <stdio.h>#include <Windows.h>#include "pthread.h"#include <ctype.h>typedef struct arg_set{    char *fname;    int count;    int tid;}ARG_SET;bool bWait = false;ARG_SET *mailbox = NULL;pthread_mutex_t read_lock = PTHREAD_MUTEX_INITIALIZER;pthread_mutex_t write_lock = PTHREAD_MUTEX_INITIALIZER;pthread_cond_t read_cond = PTHREAD_COND_INITIALIZER;pthread_cond_t write_cond = PTHREAD_COND_INITIALIZER;void main(int ac, char *av[]){    pthread_win32_process_attach_np();    pthread_win32_thread_attach_np();    pthread_t t1, t2, t3;    ARG_SET args1, args2, args3;    void *count_words(void *);    int reports_in = 0;    int total_words = 0;    if (4 != ac)    {        printf("usage: %s file1 file2 file3\n", av[0]);        return;    }        args1.fname = av[1];    args1.count = 0;    args1.tid = 1;    pthread_create(&t1, NULL, count_words, (void *)&args1);    args2.fname = av[2];    args2.count = 0;    args2.tid = 2;    pthread_create(&t2, NULL, count_words, (void *)&args2);    args3.fname = av[3];    args3.count = 0;    args3.tid = 3;    pthread_create(&t3, NULL, count_words, (void *)&args3);    while(reports_in < 3)    {        printf("MAIN: waiting for flag to go up\n");        pthread_mutex_lock(&read_lock);        bWait = true;        pthread_cond_wait(&read_cond, &read_lock);        bWait = false;        pthread_mutex_unlock(&read_lock);        printf("MAIN: wow! flag was raised, I have the lock\n");        printf("MAIN: %7d: %s\n", mailbox->count, mailbox->fname);        total_words += mailbox->count;        Sleep(10);        printf("MAIN: Ok, I've read the thread %d mail\n", mailbox->tid);                pthread_mutex_lock(&write_lock);        pthread_cond_signal(&write_cond);        pthread_mutex_unlock(&write_lock);        printf("MAIN: raising write flag\n");        reports_in++;    }    printf("%7d: total words\n", total_words);    pthread_mutex_destroy(&read_lock);    pthread_mutex_destroy(&write_lock);    pthread_cond_destroy(&read_cond);    pthread_cond_destroy(&write_cond);    pthread_win32_thread_detach_np();    pthread_win32_process_detach_np();    system("pause");}void *count_words(void *a){    ARG_SET *args = (ARG_SET*)a;    FILE *fp;    int c, prevc = '\0';    if (NULL != (fp = fopen(args->fname, "r")))    {        while((c = getc(fp)) != EOF)        {            if (!isalnum(c) && isalnum(prevc))            {                args->count++;            }            prevc = c;        }        fclose(fp);    }    else    {        perror(args->fname);    }    printf("COUNT %d: waiting to get lock\n", args->tid);                pthread_mutex_lock(&write_lock);      if (NULL != mailbox)    {        printf("COUNT %d: oops..mailbox not empty. wait for signal\n", args->tid);        pthread_cond_wait(&write_cond, &write_lock);    }    printf("COUNT %d: OK, I can write mail\n", args->tid);    mailbox = args;          while (!bWait)    {        Sleep(1);            }    pthread_mutex_lock(&read_lock);     pthread_cond_signal(&read_cond);    /* raise the flag */    pthread_mutex_unlock(&read_lock);     printf("COUNT %d: raising read flag\n", args->tid);    pthread_mutex_unlock(&write_lock);    /* release the mailbox */    printf("COUNT %d: unlocking box\n", args->tid);        return NULL;}

3.

#include <stdio.h>#include <Windows.h>#include "pthread.h"#include "semaphore.h"#include <ctype.h>typedef struct arg_set{    char *fname;    int count;    int tid;}ARG_SET;ARG_SET *mailbox = NULL;static sem_t sem_write;static sem_t sem_read;void main(int ac, char *av[]){    pthread_win32_process_attach_np();    pthread_win32_thread_attach_np();    pthread_t t1, t2, t3;    ARG_SET args1, args2, args3;    void *count_words(void *);    int reports_in = 0;    int total_words = 0;    if (4 != ac)    {        printf("usage: %s file1 file2 file3\n", av[0]);        return;    }    if (-1 == sem_init(&sem_read, 0 , 1)        || -1 == sem_init(&sem_write, 0, 0))    {        return;    }    args1.fname = av[1];    args1.count = 0;    args1.tid = 1;    pthread_create(&t1, NULL, count_words, (void *) &args1);        args2.fname = av[2];    args2.count = 0;    args2.tid = 2;    pthread_create(&t2, NULL, count_words, (void *) &args2);        args3.fname = av[3];    args3.count = 0;    args3.tid = 3;    pthread_create(&t3, NULL, count_words, (void *) &args3);    while(reports_in < 3)    {        printf("MAIN: waiting for sub thread write\n");        sem_wait(&sem_write);        printf("MAIN: %7d: %s\n", mailbox->count, mailbox->fname);        total_words += mailbox->count;        if ( mailbox == &args1)             pthread_join(t1,NULL);        if ( mailbox == &args2)             pthread_join(t2,NULL);        if ( mailbox == &args3)             pthread_join(t3,NULL);                mailbox = NULL;        printf("MAIN: Ok,I have read the mail\n");        sem_post(&sem_read);          reports_in++;    }       printf("%7d: total words\n", total_words);    sem_destroy(&sem_read);    sem_destroy(&sem_write);    pthread_win32_thread_detach_np();    pthread_win32_process_detach_np();    system("pause");}void *count_words(void *a){    struct arg_set *args = (arg_set *)a;    /* cast arg back to correct type */    FILE *fp;    int  c, prevc = '\0';         if ( (fp = fopen(args->fname, "r")) != NULL )    {         while( ( c = getc(fp)) != EOF )         {               if ( !isalnum(c) && isalnum(prevc) )               {                    args->count++;               }               prevc = c;         }         fclose(fp);     } else           perror(args->fname);     printf("COUNT %d: waiting for main thread read the mail\n", args->tid);     sem_wait(&sem_read);     printf("COUNT %d:OK,I can write mail\n", args->tid);     mailbox = args;            /* put ptr to our args there */     printf("COUNT %d: Finished writting\n", args->tid);     sem_post(&sem_write);     return NULL;}

http://www.cppblog.com/saha/articles/189802.html