多线程编程之：Linux线程编程

（3）函数使用。

以下实例中创建了3个线程，为了更好地描述线程之间的并行执行，让3个线程重用同一个执行函数。每个线程都有5次循环（可以看成5个小任务），每次循环之间会随机等待1～10s的时间，意义在于模拟每个任务的到达时间是随机的，并没有任何特定规律。

/* thread.c */

#include stdio.h>

#include stdlib.h>

#include pthread.h>

#define THREAD_NUMBER 3 /*线程数*/

#define REPEAT_NUMBER 5 /*每个线程中的小任务数*/

#define DELAY_TIME_LEVELS 10.0 /*小任务之间的最大时间间隔*/

void *thrd_func(void *arg)

{ /* 线程函数例程 */

int thrd_num = (int)arg;

int delay_time = 0;

int count = 0;

printf(Thread %d is startingn, thrd_num);

for (count = 0; count  REPEAT_NUMBER; count++)

{

delay_time = (int)(rand() * DELAY_TIME_LEVELS/(RAND_MAX)) + 1;

sleep(delay_time);

printf(tThread %d: job %d delay = %dn,

thrd_num, count, delay_time);

}

printf(Thread %d finishedn, thrd_num);

pthread_exit(NULL);

}

int main(void)

{

pthread_t thread[THREAD_NUMBER];

int no = 0, res;

void * thrd_ret;

srand(time(NULL));

for (no = 0; no  THREAD_NUMBER; no++)

{

/* 创建多线程 */

res = pthread_create(thread[no], NULL, thrd_func, (void*)no);

if (res != 0)

{

printf(Create thread %d failedn, no);

exit(res);

}

}

printf(Create treads successn Waiting for threads to finish...n);

for (no = 0; no  THREAD_NUMBER; no++)

{

/* 等待线程结束 */

res = pthread_join(thread[no], thrd_ret);

if (!res)

{

printf(Thread %d joinedn, no);

}

else

{

printf(Thread %d join failedn, no);

}

}

return 0;

}

以下是程序运行结果。可以看出每个线程的运行和结束是独立与并行的。

$ ./thread

Create treads success

Waiting for threads to finish...

Thread 0 is starting

Thread 1 is starting

Thread 2 is starting

Thread 1: job 0 delay = 6

Thread 2: job 0 delay = 6

Thread 0: job 0 delay = 9

Thread 1: job 1 delay = 6

Thread 2: job 1 delay = 8

Thread 0: job 1 delay = 8

Thread 2: job 2 delay = 3

Thread 0: job 2 delay = 3

Thread 2: job 3 delay = 3

Thread 2: job 4 delay = 1

Thread 2 finished

Thread 1: job 2 delay = 10

Thread 1: job 3 delay = 4

Thread 1: job 4 delay = 1

Thread 1 finished

Thread 0: job 3 delay = 9

Thread 0: job 4 delay = 2

Thread 0 finished

Thread 0 joined

Thread 1 joined

Thread 2 joined

9.2.2 线程之间的同步与互斥

由于线程共享进程的资源和地址空间，因此在对这些资源进行操作时，必须考虑到线程间资源访问的同步与互斥问题。这里主要介绍POSIX中两种线程同步机制，分别为互斥锁和信号量。这两个同步机制可以互相通过调用对方来实现，但互斥锁更适合用于同时可用的资源是惟一的情况；信号量更适合用于同时可用的资源为多个的情况。

1．互斥锁线程控制

（1）函数说明。

互斥锁是用一种简单的加锁方法来控制对共享资源的原子操作。这个互斥锁只有两种状态，也就是上锁和解锁，可以把互斥锁看作某种意义上的全局变量。在同一时刻只能有一个线程掌握某个互斥锁，拥有上锁状态的线程能够对共享资源进行操作。若其他线程希望上锁一个已经被上锁的互斥锁，则该线程就会挂起，直到上锁的线程释放掉互斥锁为止。可以说，这把互斥锁保证让每个线程对共享资源按顺序进行原子操作。

互斥锁机制主要包括下面的基本函数。

n 互斥锁初始化：pthread_mutex_init()

n 互斥锁上锁：pthread_mutex_lock()

n 互斥锁判断上锁：pthread_mutex_trylock()

n 互斥锁接锁：pthread_mutex_unlock()

n 消除互斥锁：pthread_mutex_destroy()

其中，互斥锁可以分为快速互斥锁、递归互斥锁和检错互斥锁。这3种锁的区别主要在于其他未占有互斥锁的线程在希望得到互斥锁时是否需要阻塞等待。快速锁是指调用线程会阻塞直至拥有互斥锁的线程解锁为止。递归互斥锁能够成功地返回，并且增加调用线程在互斥上加锁的次数，而检错互斥锁则为快速互斥锁的非阻塞版本，它会立即返回并返回一个错误信息。默认属性为快速互斥锁。

（2）函数格式。

表9.5列出了pthread_mutex_init()函数的语法要点。

表9.5 pthread_mutex_init()函数语法要点

表9.6列出了pthread_mutex_lock()等函数的语法要点。

表9.6 pthread_mutex_lock()等函数语法要点