怎么使用pthread

一 概述

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

例1:

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

#include &ltpthread.h&gt

void *pp(void *arg)

{

printf(”%s\n”, (char *)arg)

sleep(2)

}

return NULL

}

main()

{

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(&ampmutex)

fwrite(buffer, 1, strlen(buffer), file)

pthread_mutex_unlock(&ampmutex)

… …

四 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(&ampmut)

/**//* operate on x and y */

pthread_mutex_unlock(&ampmut)

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

{

pthread_once(&ampbuffer_key_once, buffer_key_alloc)

pthread_setspecific(buffer_key, malloc(100))

}

{

return (char *) pthread_getspecific(buffer_key)

}

{

pthread_key_create(&ampbuffer_key, buffer_destroy)

}

{

free(buf)

}

3. Thread.h——封装thread

用 pthread_t创建线程名字。然后pthread_create开辟线程。

具体使用。

比如有一个函数

void *hello（）

{

printf(”create pthread！\n”)；

}

，然后在main函数里面调用，

int main()

{

pthread_t a_thread；

pthread_create(&ampa_thread, NULL， (void *)hello, NULL)

}

这样就完成了hello()函数的创建和使用，接下来hello函数就会在一个线程中运行

多线程中系统中将要大量使用线程操作函数。

为了扩展和维护方便，将这些函数风和钻挂在一个类中，也符合oop的理念。

muduo是这样做的：

3。然后一类，用来控制线程的执行。相当于一个代理类的感觉。可以先初始化一个线程，等到合适的时候执行。

在 pthread.h 库中，但该库不是c的标准哭，所以在编译的时候需要在后面显式的加上 -lpthread 。

这是多线程的基础。

第一个参数是线程id， pthread_t 的结构体。传入后，由函数进行填充。

第二个参数是控制参数。可为空

第三个参数是一个函数指针（也就是函数名）。这个函数必须是 void *func(void *) ，它有一个参数是 void * 类型的。如果有多个参数没那么需要在放在一个结构体中。

第四个参数传入的参数指针或者结构体的指针。可为空

是一个结构体，可已通过 pthread_t pthread_self() 来返回当前线程的id。同时使用 int pthread_equal(pthread_t ,pthread_t) 来判断两个线程id是否相同，不同时返回0。

但是，这个结构体在多线程的时候有问题：不同进程中线程的线程id可能相同。所以不是作为判断线程相同的条件。

所以，常用 gettid() 来判断似乎否是同一个线程.

但是，标准c没有实现这个函数，所以需要使用系统调用。

同上使用上述函数来获取tid。

其中 SUS_gettid ,在 sys/syscall.h 中。

返回的值作为系统中线程中唯一的id。

其中，进程中唯一线程的pid_t和通过 getpid() 的返回值相同。

线程在函数执行结束以后，需要回收资源。

线程有两种状态 joinable 和 unjoinable 。

unjoinable 下，线程所使用的资源不会被释放，直到 joinable 。

第一个参数是线程id，第二个参数可以是函数的返回值，如果是 NULL 表示我们不关心函数的返回值。如果需要返回值，需要先创建对应的结构体，然后传入指针，让函数填充。

程序将会在该语句出堵塞，直到线程执行完毕返回。即使有很多该函数也会依次执行。

int pthread_atfork(void ( prepare)(void), void ( parent)(void), void (*child)(void))

执行该函数后，线程中函数运行结束后直接释放所消耗的资源。

pthread_atfork()在fork()之前调用，当调用fork时，内部创建子进程前在父进程中会调用prepare，内部创建子进程成功后，父进程会调用parent ，子进程会调用child。

以上就是关于怎么使用pthread全部的内容，如果了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！

更多相关资讯