线程操作简介

一 创建

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

二 结束

每一个线程的返回值是void *.
有两种方法返回:
1 return pointer;
2 pthread_exit(pointer);

其他的线程是如何得到这个返回值的呢?
用这个函数:
int pthread_join(pthread_t TH, void **thread_RETURN);
pthread_join使一个线程等待另一个线程结束。

thread_t：等待退出线程的线程号。
void **：退出线程的返回值。

一个线程有两种状态, joinable 即系统保留线程的返回值, 直到有另外
一个线程将它取走. detach系统不保留返回值.

有一些线程自己来清理退出的状态，他们也不愿意主线程调用pthread_join来等待他们。我们将这一类线程的属性称为detached。如果我们在

调用pthread_create()函数的时候将属性设置为NULL，则表明我们希望所创建的线 程采用默认的属性，也就是jionable。如果需要将属性设置

为detached，则参考下面的例子

#include <stdio.h>
#include <pthread.h>

void * start_run(void * arg)
{
//do some work
}

int main()
{
pthread_t thread_id;

pthread_attr_t attr;

pthread_attr_init(&attr);

pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

pthread_create(&thread_id,&attr,start_run,NULL);

pthread_attr_destroy(&attr);
sleep(5);
exit(0);
}

在线程设置为joinable后，可以调用pthread_detach()使之成为detached。但是相反的操作则不可以。还有，如果线程已经调用pthread_join

()后，则再调用pthread_detach()则不会有任何效果。
线程结束：

线程的被动结束分为两种，一种是异步终结，另外一种是同步终结。异步终结就是当其他线程调用 pthread_cancel的时候，线程就立刻被结束

。而同步终结则不会立刻终结，它会继续运行，直到到达下一个结束点（cancellation point）。当一个线程被按照默认的创建方式创建，那

么它的属性是同步终结。
线程可以通过自身执行结束来结束，也可以通过调用pthread_exit()来结束线程的执行。另外，线程甲可以被线程乙被动结束。这个通过调用

pthread_cancel()来达到目的。

int pthread_cancel(pthread_t thread);
函数调用成功返回0。

当然，线程也不是被动的被别人结束。它可以通过设置自身的属性来决定如何结束。

通过调用pthread_setcanceltype()来设置终结状态。

int pthread_setcanceltype(int type, int *oldtype);

那么前面提到的结束点又是如何设置了？最常用的创建终结点就是调用pthread_testcancel()的地方。该函数除了检查同步终结时的状态，其

他什么也不做。

上面一个函数是用来设置终结状态的。还可以通过下面的函数来设置终结类型，即该线程可不可以被终结：

int pthread_setcancelstate(int state, int *oldstate);
state：终结状态，可以为PTHREAD_CANCEL_DISABLE或者PTHREAD_CANCEL_ENABLE。具体什么含义大家可以通过单词意思即可明白。

最后说一下线程的本质。其实在Linux中，新建的线程并不是在原先的进程中，而是系统通过 一个系统调用clone()。该系统copy了一个和原先

进程完全一样的进程，并在这个进程中执行线程函数。不过这个copy过程和fork不一样。 copy后的进程和原先的进程共享了所有的变量，运行

环境。这样，原先进程中的变量变动在copy后的进程中便能体现出来

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

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. 允许一个进程将自己挂起等待一个条件变量被改变状态.
条件变量的初始化：
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);

为了解决竞争问题(即一个线程刚要去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 <= 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
#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
thread_cond_timewait
pthread_testcancel
sem_wait
sigwait 都是cancellation点.
下面的这些系统函数也是cancellation点:
accept
fcntl
open
read
write
lseek
close
send
sendmsg
sendto
connect
recv
recvfrom
recvmsg
system
tcdrain
fsync
msync
pause
wait
waitpid
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);
取得信号量的值.

下面的函数用于detach:
int pthread_detach (pthread_t TH);

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