POSIX thread (pthread) 多线程编程简介

转载自:POSIX thread (pthread) 简介

一 概述

      Pthread是一套通用的线程库, 它广泛的被各种Unix所支持, 是由POSIX提出的. 因此, 它具有很好的可移植性. 

例1:

     /**/
    #include 
< pthread.h >
    
void   * pp( void   * arg)
    
{
        
while  ( 1 {
            printf(
" %s/n " , ( char   * )arg);
            sleep(
2 );
        }

        
return  NULL;
    }

    
    main()
    
{
        pthread_t pid;
        pthread_create(
& pid, NULL, pp,  " hello world " );
        
while  ( 1 {
            printf(
" I am main thread/n " );
            sleep(
1 );
        }

    }


执行:
    gcc test.c -lpthread
    ./a.out

输出:
    I am main thread
    hello world
    I am main thread
    hello world
    ............

二 返回值

    也应该看到了, 每一个线程的返回值是void *.
    有两种方法返回:
        1 return pointer;
        2 pthread_exit(pointer);
    这两种方法是一样的.

    那么, 其他的线程是如何得到这个返回值的呢?
    用这个函数:
    int pthread_join(pthread_t TH, void **thread_RETURN);
   
    一个线程有两种状态, joinable 即系统保留线程的返回值, 直到有另外一个线程将它取走. detach系统不保留返回值.

    下面的函数用于detach:
    int pthread_detach (pthread_t TH);
   
    pthread_t pthread_self(); 可以返回自己的id. 通常, 我们用下列的语句来detach自己:
        pthread_detach(pthread_self());


三 Mutex 

    Mutex用于解决互斥问题. 一个Mutex是一个互斥装置, 用于保护临界区和共享内存. 它有两种状态locked, unlocked. 它不能同时被两个线程所拥有.

    下面的函数用于处理Mutex:

    初始化一个Mutex
    int pthread_mutex_init (pthread_mutex_t *MUTEX, const pthread_mutexattr_t *MUTEXATTR);
    锁定一个Mutex
    int pthread_mutex_lock (pthread_mutex_t *mutex));
    试图锁定一个Mutex
    int pthread_mutex_trylock (pthread_mutex_t *MUTEX);
    结锁一个Mutex
    int pthread_mutex_unlock (pthread_mutex_t *MUTEX);
    销毁一个Mutext
    int pthread_mutex_destroy (pthread_mutex_t *MUTEX);

    它的锁一共有三种: "fast", "recursive", or "error checking"
    进行lock操作时:
    如处于unlock状态, lock它, 即排斥占有。

    在被其他线程lock的时候,
    挂起当前线程, 直到被其他线程unlock

    在已经被自己lock的时候,
    "fast"                   挂起当前线程.
    "resursive"           成功并立刻返回当前被锁定的次数
    "error checking"  立刻返回EDEADLK
   
    进行unlock操作时:
    解锁.
    "fast"              唤醒第一个被锁定的线程
    "recursive"      减少lock数(这个数仅仅是被自己lock的, 不关其它线程的) 当lock数等于零的
                          时候, 才被unlock并唤醒第一个被锁定的线程.
    "error check"  会检查是不是自己lock的, 如果不是返回EPERM. 如果是唤 醒第一个被锁定的线程,

    通常, 我们用一些静态变量来初始化mutex.
    "fast" `PTHREAD_MUTEX_INITIALIZER'
    "recursive" `PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP'
    "error check" `PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP'

    注意: _NP 表示no portable不可移植

    例如:
        // "fast" type mutex
        pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
        ... ...
        pthread_mutext_lock(&mutex);
        fwrite(buffer, 1, strlen(buffer), file);
        pthread_mutex_unlock(&mutex);
        ... ...

四 Condition Variable (条件变量) 

    也是一种用于同步的device. 允许一个进程将自己挂起等待一个条件变量被改变状态.
    有下列几个函数:

    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);

    我想看看名字就可以知道它们的用途了. 通常我们也使用静态变量来初始化一个条件变量.
    Example:
    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
   
    pthread_cond_signal 用于唤醒一个被锁定的线程.
    pthread_cond_broadcast 用于唤醒所有被锁定的线程.
    pthread_cond_wait 用于等待.

    为了解决竞争问题(即一个线程刚要去wait而另一个线程已经signal了), 它要与一个mutex连用.

    看一看下面的例子:

int  x,y;
pthread_mutex_t mut 
=  PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond 
=  PTHREAD_COND_INITIALIZER;

// Waiting until X is greater than Y is performed as follows:

pthread_mutex_lock(
& mut);
while  (x  <=  y)  {
    pthread_cond_wait(
& cond,  & mut);
}

/*  operate on x and y  */
pthread_mutex_unlock(
& mut);


    pthread_cond_wait的执行过程如下:
    1. 首先, 它unlock the mutex, then 挂起当前的线程.
    2. 当被唤醒的时候, 它会lock the mutex.

    这样就保证了这是一个临界区.

五 Thread-Specific Data (TSD)

    说白了就是线程中使用的静态变量. 大家可以很容易的理解为什么使用静态变量函数不是线程安全的(也就是它们一定要很小心的在线程中使用).
   
    而使用静态变量又是很方便的, 这就产生了 thread-specific data. 可以把它理解为一个指针数组, 但对于每个线程来说是唯一的.

    Example:
        int func()
        {
            char *p;
            p = strdup(thread-specific-data[1]);
            ... ...
        }
   
        void *pthread-1(void *arg)
        {
            ... ...
            func()
            ... ...
        }

        void *pthread-2(void *arg)
        {
            ... ...
            func()
            ... ...
        }

    不同的线程调用func产生的结果是不同的. 这只是个例子.

    int pthread_key_create(pthread_key_t *KEY, void (*destr_function) (void *));
    int pthread_key_delete(pthread_key_t KEY);
    int pthread_setspecific(pthread_key_t KEY, const void *POINTER);
    void * pthread_getspecific(pthread_key_t KEY);
   
    TSD可以看成是一个void *的数组.
    注意: pthread_key_delete只是释放key占用的空间, 你仍然需要释放那个void *.
   
    为了加深你的理解, 看一看下面的例子吧:

/*  Key for the thread-specific buffer  */
static  pthread_key_t buffer_key;

/*  Once-only initialisation of the key  */
static  pthread_once_t buffer_key_once  =  PTHREAD_ONCE_INIT;

/*  Allocate the thread-specific buffer  */
void  buffer_alloc( void )
{
pthread_once(
& buffer_key_once, buffer_key_alloc);
pthread_setspecific(buffer_key, malloc(
100 ));
}


/*  Return the thread-specific buffer  */
char   *  get_buffer( void )
{
return  ( char   * ) pthread_getspecific(buffer_key);
}


/*  Allocate the key  */
static   void  buffer_key_alloc()
{
pthread_key_create(
& buffer_key, buffer_destroy);
}


/*  Free the thread-specific buffer  */
static   void  buffer_destroy( void   *  buf)
{
free(buf);
}


六. 信号处理

    在线程中的信号处理是这个样子, 所有的线程共享一组, 信号处理函数. 而每一个线程有自己的信号掩码.

    下面是用于处理线程信号的函数:
    int pthread_sigmask (int HOW, const sigset_t *NEWMASK, sigset_t *OLDMASK);
    int pthread_kill (pthread_t THREAD, int SIGNO);
    int sigwait (const sigset_t *SET, int *SIG);            

    可以使用sigaction来安装信号处理函数.

    看一看下面的程序:
    #include <stdio.h>
    #include <pthread.h>
    void *pp(void *)
    {
        printf("ha ha");
        alarm(1);
    }
    void main_alarm(int i)
    {
        printf("Main got/n");
        alarm(3);
    }

    main()
    {
        pthread_t pid;
        struct sigaction aa;
        sigset_t sigt;

        sigfillset(&sigt);
        aa.sa_handler = mainalarm;
        aa.sa_mask = sigt;
        aa.sa_flags = 0;
        sigaction(SIGALRM, &aa, NULL);

        pthread_create(&pid, NULL, pp, NULL);
        while(1);
        return 0;
    }

七. 放弃 (Cancellation)

    这是一种机制: 一个线程可以结束另一个线程. 精确的说, 一个线程可以向另一个线程发送 cancellation 请求. 另一个线程根据其设置, 可以忽略掉该请求, 也可以在到达一个cancellation点时, 来处理它。
    
    当一个线程处理一个cancellaction请求时, pthread_exit 一个一个的调用 cleanup handlers. 所谓的一个cancellation点是在这些地方, 线程会处理cancellation请求. POSIX中的函数: pthread_join,pthread_cond_wait,pthread_cond_timewait,pthread_testcancel,sem_wait,sigwait 都是cancellation点. 下面的这些系统函数也是cancellation点:
    accept open sendmsg
    close pause sendto
    connect read system
    fcntl recv tcdrain
    fsync recvfrom wait
    lseek recvmsg waitpid
    msync send write
    nanosleep
   
    其它的一些函数如果调用了上面的函数, 那么, 它们也是cancellation点.
    int pthread_setcancelstate (int STATE, int *OLDSTATE);
    用于允许或禁止处理cancellation,
    STATE可以是:PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_DISABLE

    int pthread_setcanceltype (int TYPE, int *OLDTYPE);
    设置如何处理cancellation, 异步的还是推迟的.
    TYPE可以是:PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_DEFERRED
    void pthread_testcancel (VOID);

八. 清理函数 (Cleanup Handlers)

    这是一些函数, 它们会被pthread_exit按顺序调用. 它们以栈风格被管理.
    这种机制的目的是希望在退出前释放掉一些占用的资源.

    例如: 我们使用了一个MUTEX, 但希望在cancellation时能unlock它.

    pthread_cleanup_push(pthread_mutex_unlock, (void *)&mut);
    pthread_mutex_lock(&mut);
    /* do some work */
    pthread_mutex_unlock(&mut);
    pthread_cleanip_pop(0);

    注意:
        在异步处理过程中, 一个cancellation可以发生在pthread_cleaup_push 和pthread_mutex_lock之间. 这中情况是很糟糕的。所以,异步的cancellation 是很难用的。

    void pthread_cleanup_push (void (*ROUTINE) (void *), void *ARG);
    void pthread_cleanup_pop (int EXECUTE);

    如果EXECUTE不等于0, 则在出栈后,会被执行一次。

九. 信号量 (Semaphores)
    
    Semaphores是线程间共享的资源计数器。
    基本的信号量操作为: 原子的增加信号量, 原子的减少信号量, 等待直到信号量的值为非零。

    在POSIX中, 信号量有一个最大值, 宏SEM_VALUE_MAX定义了该值。在GNU的LIBC中, 该值等于INT_MAX (太大了)。

    下面是相关的函数:
   
    int sem_init (sem_t *SEM, int PSHARED, unsigned int VALUE);
    初始化一个信号量, 其值为VALUE, PSHARED指明它是不是共享的.
    0 表示local, 非0表示是全局的.
   
    int sem_destroy (sem_t * SEM);
    释放掉相关的资源.
   
    int sem_wait (sem_t * SEM);
    等待直到SEM的值为非零.

    int sem_trywait (sem_t * SEM);

    int sem_post (sem_t * SEM);
    将信号量加1.

    int sem_getvalue (sem_t * SEM, int * SVAL);
    取得信号量的值.

 十 APIs

int
pthread_create(
               pthread_t 
* tid ,                              //  用于返回新创建线程的线程号.
                const  pthread_attr_t  * attr ,    
               
void * ( * start_routine)( void * ) ,   // start_routine 是线程函数指针,
                                                                       
// 线程从这个函数开始独立地运行。
                void   * arg                                        // arg 是传递给线程函数的参数。
               );

// 由于start_routine 是一个指向参数类型为void*,返回值为void* 的指针,
// 所以如果需要传递或返回多个参数时,可以使用强制类型转化。

void
pthread_exit(
             
void *  value_ptr
             );

//  参数value_ptr 是一个指向返回状态值的指针。

int
pthread_join(
             pthread_t tid , 
             
void   ** status
             );

//  参数tid 是希望等待的线程的线程号,status 是指向线程返回值的
// 指针,线程的返回值就是pthread_exit 中的value_ptr 参数,或者 是return
// 语句中的返回值。该函数可用于线程间的同步。

int
pthread_mutex_init(
                   pthread_mutex_t 
* mutex,
                   
const  pthread_mutex_attr_t *  attr
                   );

//  该函数初始化一个互斥体变量,如果参数attr 为NULL,则互斥
// 体变量mutex 使用默认的属性。

int
pthread_mutex_lock(
                   pthread_mutex_t 
* mutex
                   );

//  该函数用来锁住互斥体变量。如果参数mutex 所指的互斥体已经
//  被锁住了,那么发出调用的线程将被阻塞直到其他线程对mutex 解锁。

int
pthread_mutex_trylock(
                      pthread_t 
* mutex
                      );

//  该函数用来锁住mutex 所指定的互斥体,但不阻塞。如果该互斥
// 体已经被上锁,该调用不会阻塞等待,而会返回一个错误代码。

int
pthread_mutex_unlock(
                     pthread_mutex_t 
* mutex
                     );

//  该函数用来对一个互斥体解锁。如果当前线程拥有参数mutex 所
//  指定的互斥体,该调用将该互斥体解锁。

int
pthread_mutex_destroy (
                       pthread_mutex_t 
* mutex
                       );

//  该函数用来释放分配给参数mutex 的资源。调用成功时返回值为
// 0,否则返回一个非0 的错误代码。


int
pthread_cond_init(
                  pthread_cond_t 
* cond, 
                  
const  pthread_cond_attr_t * attr
                  );

//  该函数按参数attr指定的属性创建一个条件变量。调用成功返回,
//  并将条件变量ID 赋值给参数cond,否则返回错误代码。

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

//  该函数调用为参数mutex 指定的互斥体解锁,等待一个事件(由
// 参数cond 指定的条件变量)发生。调用该函数的线程被阻塞直到有其他
// 线程调用pthread_cond_signal 或 pthread_cond_broadcast 函数置相应的条
// 件变量,而且获得mutex 互斥体时才解除阻塞。


int
pthread_cond_timewait(
                      pthread_cond_t 
* cond , 
                      pthread_mutex_t
* mutex , 
                      
const   struct  timespec  * abstime
                      );
//  该函数与pthread_cond_wait 不同的是当系统时间到达 abstime 参
// 数指定的时间时,被阻塞线程也可以被唤起继续执行。

int
pthread_cond_broadcast(
                       pthread_cond_t 
* cond
                       );
//  该函数用来对所有等待参数cond所指定的条件变量的线程解除阻
//  塞,调用成功返回0,否则返回错误代码。

int
pthread_cond_signal(
                    pthread_cond_t 
* cond
                    );

//  该函数的作用是解除一个等待参数cond所指定的条件变量的线程
//  的阻塞状态。当有多个线程挂起等待该条件变量,也只唤醒一个线程。

int
pthread_cond_destroy(
                     pthread_cond_t 
* cond
                     );
//  该函数的作用是释放一个条件变量。释放为条件变量cond 所分配的
//  资源。调用成功返回值为0,否则返回错误代码。

int
pthread_key_create(
                   pthread_key_t key , 
                   
void ( * destructor( void * ))
                   );

//  该函数创建一个键值,该键值映射到一个专有数据结构体上。如
// 果第二个参数不是NULL,这个键值被删除时将调用这个函数指针来释放
// 数据空间。

int
pthread_key_delete(
                   pthread_key_t 
* key
                   );
                   
//  该函数用于删除一个由pthread_key_create 函数调用创建的TSD
// 键。调用成功返回值为0,否则返回错误代码。

int
pthread_setspecific(
                    pthread_key_t key , 
                    
const   void (value)
                    );

//  该函数设置一个线程专有数据的值,赋给由pthread_key_create 创
//  建的TSD键,调用成功返回值为0,否则返回错误代码。


void   *
pthread_getspecific(
                    pthread_key_t 
* key
                    );

//  该函数获得绑定到指定TSD 键上的值。调用成功,返回给定参数
// key 所对应的数据。如果没有数据连接到该TSD 键,则返回NULL。

int
pthread_once(
             pthread_once_t
*  once_control, 
             
void ( * init_routine)( void )
             );

// 该函数的作用是确保init_routine指向的函数,在调用 pthread_once
// 的线程中只被运行一次。once_control 指向一个静态或全局的变量。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值