Pthread 与 Linux

flyboy

Bricks with
GNU&LINUX
=====================
Pthread 与 Linux

    Pthread本来是一套用户级线程库, 但在Linux上实现时,
却使用了内核级线程
来完成, 这样的好处是, 可以充分的提高程序的并发性,
线程也可以象以前一样调用
read这样的函数, 而不必担心会由于阻赛影响其它的线程的运行.
但这样一来, linux的
线程就不是标准的了.
    下面结合Linux上的实现来谈一谈Pthread.
一 基本概念
---------
    Pthread是一套通用的线程库, 它广泛的被各种Unix所支持,
是由POSIX提出
的. 因此, 它具有很好的客移植性. 在Linux上,
由于它是通过内核级线程来实现的, 就
没有完全的实现它. 但从功能上来看, 它丝毫不逊色.
   
    先看一下下面的例子:
    /* ------ test.c ------- */
    #include
    void *pp(void *arg)
    {
        while (1) {
            printf("%sn",
(char *)arg);
            sleep(2);
        }
        return NULL;
    }
   
    main()
    {
        pthread_t pid;
        pthread_create(&pid, NULL, pp, "hello
world");
        while (1) {
            printf("I am main
threadn");
            sleep(1);
        }
    }
    gcc test.c -lpthread
    ./a.out
    I am main thread
    hello world
    I am main thread
    hello world
    ............
   
    在程序开始的时候, 系统创建了一个主线程, 又用pthread_create创建了一个新的
子线程, 这样, 两个线程同时运行, 向屏幕上打印东西.
   
    一个线程实际上就是一个函数, 创建后, 立即被执行,
当函数返回时该线程也就结束了.
下面这个函数用于创建一个新的线程:
int pthread_create (pthread_t *THREAD,
    pthread_attr_t * ATTR,
    void * (*START_ROUTINE)(void *),
        void * ARG);
第一个参数是一个pthread_t型的指针用于保存线程id.
以后对该线程的操作都要用id来标示.
第二个参数是一个pthread_attr_t的指针用于说明要创建的线程的属性,
使用NULL, 表示
要使用缺省的属性.
第三个参数指明了线程的如口, 是一个只有一个(void *)参数的函数.
第四个参数指明了要传到线程如口函数的参数.
这很简单, 上面的例子, 你也应该理解了.
象我在上面提过的一样, 使用Linux的线程不需要对考虑对其它线程的阻塞问题,
这样编程上就很
方便.
二 返回值
-------
    也应该看到了, 每一个线程的返回值是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_cont_wait 用于等待.
    为了解决竞争问题(即一个线程刚要去wait而另一个线程已经signal了),
它要与一个
    metux连用.
    看一看下面的例子:
    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
    #include
    void *pp(void *)
    {
        printf("ha ha");
        alarm(1);
    }
    void main_alarm(int i)
    {
        printf("Main gotn");
        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);
    取得信号量的值.
ttp://free.prohosting.com/~bricks/linux/program/pthread.htm　


本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u/2108/showart_5613.html