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

转载自：POSIX thread
(pthread) 简介

一 概述

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

例1:





/**/
/*
------ test.c -------
*/



#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 指向一个静态或全局的变量。



==================

相关链接：

pthread之线程堆栈

Linux下pthread线程库介绍

Pthread 介绍