Blaise Barney, Lawrence Livermore National Laboratory
- 摘要
- 译者序
- Pthreads 概述
- Pthreads API编译多线程程序
- 线程管理
- 互斥量（Mutex Variables）
- 条件变量（Condition Variable）
- 没有覆盖的主题
- Pthread 库API参考
- 参考资料
在多处理器共享内存的架构中（如：对称多处理系统SMP），线程可以用于实现程序的并行性。历史上硬件销售商实现了各种私有版本的多线程库，使得软件开发者不得不关心它的移植性。对于UNIX系统，IEEE POSIX 1003.1标准定义了一个C语言多线程编程接口。依附于该标准的实现被称为POSIX theads 或 Pthreads。
该教程介绍了Pthreads的概念、动机和设计思想。内容包含了Pthreads API主要的三大类函数：线程管理（Thread Managment）、互斥量（Mutex Variables）和条件变量（Condition Variables）。向刚开始学习Pthreads的程序员提供了演示例程。
适于：刚开始学习使用线程实现并行程序设计；对于C并行程序设计有基本了解。不熟悉并行程序设计的可以参考EC3500: Introduction To Parallel Computing。
| 概述 |
- 技术上，线程可以定义为：可以被操作系统调度的独立的指令流。但是这是什么意思呢？
- 对于软件开发者，在主程序中运行的“函数过程”可以很好的描述线程的概念。
- 进一步，想象下主程序（a.out）包含了许多函数，操作系统可以调度这些函数，使之同时或者（和）独立的执行。这就描述了“多线程”程序。
- 怎样完成的呢？
- 在理解线程之前，应先对UNIX进程（process）有所了解。进程被操作系统创建，需要相当多的“额外开销”。进程包含了程序的资源和执行状态信息。如下：
- 进程ID，进程group ID，用户ID和group ID
- 环境
- 工作目录
- 程序指令
- 寄存器
- 栈
- 堆
- 文件描述符
- 信号动作（Signal actions）
- 共享库
- 进程间通信工具（如：消息队列，管道，信号量或共享内存）
| | |
| UNIX PROCESS | THREADS WITHIN A UNIX PROCESS |
- 线程使用并存在于进程资源中，还可以被操作系统调用并独立地运行，这主要是因为线程仅仅复制必要的资源以使自己得以存在并执行。
- 独立的控制流得以实现是因为线程维持着自己的：
- 堆栈指针
- 寄存器
- 调度属性（如：策略或优先级）
- 待定的和阻塞的信号集合（Set of pending and blocked signals）
- 线程专用数据（TSD：Thread Specific Data.）
- 因此，在UNIX环境下线程：
- 存在于进程，使用进程资源
- 拥有自己独立的控制流，只要父进程存在并且操作系统支持
- 只复制必可以使得独立调度的必要资源
- 可以和其他线程独立（或非独立的）地共享进程资源
- 当父进程结束时结束，或者相关类似的
- 是“轻型的”，因为大部分额外开销已经在进程创建时完成了
- 因为在同一个进程中的线程共享资源：
- 一个线程对系统资源（如关闭一个文件）的改变对所有其它线程是可以见的
- 两个同样值的指针指向相同的数据
- 读写同一个内存位置是可能的，因此需要成员显式地使用同步
| Pthreads 概述 |
- 历史上，硬件销售商实现了私有版本的多线程库。这些实现在本质上各自不同，使得程序员难于开发可移植的应用程序。
- 为了使用线程所提供的强大优点，需要一个标准的程序接口。对于UNIX系统，IEEE POSIX 1003.1c（1995）标准制订了这一标准接口。依赖于该标准的实现就称为POSIX threads 或者Pthreads。现在多数硬件销售商也提供Pthreads，附加于私有的API。
- Pthreads 被定义为一些C语言类型和函数调用，用pthread.h头（包含）文件和线程库实现。这个库可以是其它库的一部分，如libc。
| Pthreads 概述 |
- 使用Pthreads的主要动机是提高潜在程序的性能。
- 当与创建和管理进程的花费相比，线程可以使用操作系统较少的开销，管理线程需要较少的系统资源。
例如，下表比较了fork()函数和pthread_create()函数所用的时间。计时反应了50,000个进程/线程的创建，使用时间工具实现，单位是秒，没有优化标志。
备注：不要期待系统和用户时间加起来就是真实时间，因为这些SMP系统有多个CPU同时工作。这些都是近似值。
| 平台 | fork() | pthread_create() | ||||
| real | user | sys | real | user | sys | |
| AMD 2.4 GHz Opteron (8cpus/node) | 41.07 | 60.08 | 9.01 | 0.66 | 0.19 | 0.43 |
| IBM 1.9 GHz POWER5 p5-575 (8cpus/node) | 64.24 | 30.78 | 27.68 | 1.75 | 0.69 | 1.10 |
| IBM 1.5 GHz POWER4 (8cpus/node) | 104.05 | 48.64 | 47.21 | 2.01 | 1.00 | 1.52 |
| INTEL 2.4 GHz Xeon (2 cpus/node) | 54.95 | 1.54 | 20.78 | 1.64 | 0.67 | 0.90 |
| INTEL 1.4 GHz Itanium2 (4 cpus/node) | 54.54 | 1.07 | 22.22 | 2.03 | 1.26 | 0.67 |
- 在同一个进程中的所有线程共享同样的地址空间。较于进程间的通信，在许多情况下线程间的通信效率比较高，且易于使用。
- 较于没有使用线程的程序，使用线程的应用程序有潜在的性能增益和实际的优点：
- CPU使用I/O交叠工作：例如，一个程序可能有一个需要较长时间的I/O操作，当一个线程等待I/O系统调用完成时，CPU可以被其它线程使用。
- 优先/实时调度：比较重要的任务可以被调度，替换或者中断较低优先级的任务。
- 异步事件处理：频率和持续时间不确定的任务可以交错。例如，web服务器可以同时为前一个请求传输数据和管理新请求。
- 考虑在SMP架构上使用Pthreads的主要动机是获的最优的性能。特别的，如果一个程序使用MPI在节点通信，使用Pthreads可以使得节点数据传输得到显著提高。
- 例如：
- MPI库经常用共享内存实现节点任务通信，这至少需要一次内存复制操作（进程到进程）。
- Pthreads没有中间的内存复制，因为线程和一个进程共享同样的地址空间。没有数据传输。变成cache-to-CPU或memory-to-CPU的带宽（最坏情况），速度是相当的快。
- 比较如下：
| Platform | MPI Shared Memory Bandwidth | Pthreads Worst Case |
| AMD 2.4 GHz Opteron | 1.2 | 5.3 |
| IBM 1.9 GHz POWER5 p5-575 | 4.1 | 16 |
| IBM 1.5 GHz POWER4 | 2.1 | 4 |
| Intel 1.4 GHz Xeon | 0.3 | 4.3 |
| Intel 1.4 GHz Itanium 2 | 1.8 | 6.4 |
| Pthreads 概述 |
并行编程:
- 在现代多CPU机器上，pthread非常适于并行编程。可以用于并行程序设计的，也可以用于pthread程序设计。
- 并行程序要考虑许多，如下：
- 用什么并行程序设计模型？
- 问题划分
- 加载平衡（Load balancing）
- 通信
- 数据依赖
- 同步和竞争条件
- 内存问题
- I/O问题
- 程序复杂度
- 程序员的努力/花费/时间
- ...
- 包含这些主题超出本教程的范围，有兴趣的读者可以快速浏览下“Introduction to Parallel Computing”教程。
- 大体上，为了使用Pthreads的优点，必须将任务组织程离散的，独立的，可以并发执行的。例如，如果routine1和routine2可以互换，相互交叉和（或者）重叠，他们就可以线程化。
- 拥有下述特性的程序可以使用pthreads：
- 工作可以被多个任务同时执行，或者数据可以同时被多个任务操作。
- 阻塞与潜在的长时间I/O等待。
- 在某些地方使用很多CPU循环而其他地方没有。
- 对异步事件必须响应。
- 一些工作比其他的重要（优先级中断）。
- Pthreads 也可以用于串行程序，模拟并行执行。很好例子就是经典的web浏览器，对于多数人，运行于单CPU的桌面/膝上机器，许多东西可以同时“显示”出来。
- 使用线程编程的几种常见模型：
- 管理者/工作者（Manager/worker）：一个单线程，作为管理器将工作分配给其它线程（工作者），典型的，管理器处理所有输入和分配工作给其它任务。至少两种形式的manager/worker模型比较常用：静态worker池和动态worker池。
- 管道（Pipeline）：任务可以被划分为一系列子操作，每一个被串行处理，但是不同的线程并发处理。汽车装配线可以很好的描述这个模型。
- Peer: 和manager/worker模型相似，但是主线程在创建了其它线程后，自己也参与工作。
共享内存模型（Shared Memory Model）:
- 所有线程可以访问全局，共享内存
- 线程也有自己私有的数据
- 程序员负责对全局共享数据的同步存取（保护）
线程安全（Thread-safeness）:
- 线程安全：简短的说，指程序可以同时执行多个线程却不会“破坏“共享数据或者产生“竞争”条件的能力。
- 例如：假设你的程序创建了几个线程，每一个调用相同的库函数：
- 这个库函数存取/修改了一个全局结构或内存中的位置。
- 当每个线程调用这个函数时，可能同时去修改这个全局结构活内存位置。
- 如果函数没有使用同步机制去阻止数据破坏，这时，就不是线程安全的了。
- 如果你不是100%确定外部库函数是线程安全的，自己负责所可能引发的问题。
- 建议：小心使用库或者对象，当不能明确确定是否是线程安全的。若有疑虑，假设其不是线程安全的直到得以证明。可以通过不断地使用不确定的函数找出问题所在。
- Pthreads API在ANSI/IEEE POSIX 1003.1 – 1995标准中定义。不像MPI，该标准不是免费的，必须向IEEE购买。
- Pthreads API中的函数可以非正式的划分为三大类：
- 线程管理（Thread management）: 第一类函数直接用于线程：创建（creating），分离（detaching），连接（joining）等等。包含了用于设置和查询线程属性（可连接，调度属性等）的函数。
- 互斥量（Mutexes）: 第二类函数是用于线程同步的，称为互斥量（mutexes），是"mutual exclusion"的缩写。Mutex函数提供了创建，销毁，锁定和解锁互斥量的功能。同时还包括了一些用于设定或修改互斥量属性的函数。
- 条件变量（Condition variables）：第三类函数处理共享一个互斥量的线程间的通信，基于程序员指定的条件。这类函数包括指定的条件变量的创建，销毁，等待和受信（signal）。设置查询条件变量属性的函数也包含其中。
- 命名约定：线程库中的所有标识符都以pthread开头
| Routine Prefix | Functional Group |
| pthread_ | 线程本身和各种相关函数 |
| pthread_attr_ | 线程属性对象 |
| pthread_mutex_ | 互斥量 |
| pthread_mutexattr_ | 互斥量属性对象 |
| pthread_cond_ | 条件变量 |
| pthread_condattr_ | 条件变量属性对象 |
| pthread_key_ | 线程数据键（Thread-specific data keys） |
- 在API的设计中充满了不透明对象的概念，基本调用可以创建或修改不透明对象。不透明的对象可以被一些属性函数调用修改。
- Pthread API包含了60多个函数。该教程仅限于一部分（对于刚开始学习Pthread的程序是非常有用的）。
- 为了可移植性，使用Pthread库时，pthread.h头文件必须在每个源文件中包含。
- 现行POSIX标准仅定义了C语言的使用。Fortran程序员可以嵌入C函数调用使用，有些Fortran编译器（像IBM AIX Fortran）可能提供了Fortran pthreads API。
- 关于Pthreads有些比较优秀的书籍。其中一些在该教程的参考一节列出。
- 下表列出了一些编译使用了pthreads库程序的命令：
| Compiler / Platform | Compiler Command | Description |
| IBM | xlc_r / cc_r | C (ANSI / non-ANSI) |
| xlC_r | C++ | |
| xlf_r -qnosave | Fortran - using IBM's Pthreads API (non-portable) | |
| INTEL | icc -pthread | C |
| icpc -pthread | C++ | |
| PathScale | pathcc -pthread | C |
| pathCC -pthread | C++ | |
| PGI | pgcc -lpthread | C |
| pgCC -lpthread | C++ | |
| GNU | gcc -pthread | GNU C |
| g++ -pthread | GNU C++ |
函数：
| pthread_create (thread,attr,start_routine,arg) pthread_exit (status) pthread_attr_init (attr) pthread_attr_destroy (attr) |
创建线程:
- 最初，main函数包含了一个缺省的线程。其它线程则需要程序员显式地创建。
- pthread_create 创建一个新线程并使之运行起来。该函数可以在程序的任何地方调用。
- pthread_create参数：
- thread：返回一个不透明的，唯一的新线程标识符。
- attr：不透明的线程属性对象。可以指定一个线程属性对象，或者NULL为缺省值。
- start_routine：线程将会执行一次的C函数。
- arg: 传递给start_routine单个参数，传递时必须转换成指向void的指针类型。没有参数传递时，可设置为NULL。
- 一个进程可以创建的线程最大数量取决于系统实现。
- 一旦创建，线程就称为peers，可以创建其它线程。线程之间没有指定的结构和依赖关系。
|
|
| Q：一个线程被创建后，怎么知道操作系统何时调度该线程使之运行？ A：除非使用了Pthreads的调度机制，否则线程何时何地被执行取决于操作系统的实现。强壮的程序应该不依赖于线程执行的顺序。 |
线程属性:
- 线程被创建时会带有默认的属性。其中的一些属性可以被程序员用线程属性对象来修改。
- pthread_attr_init 和 pthread_attr_destroy用于初始化/销毁先成属性对象。
- 其它的一些函数用于查询和设置线程属性对象的指定属性。
- 一些属性下面将会讨论。
结束终止:
- 结束线程的方法有一下几种：
- 线程从主线程（main函数的初始线程）返回。
- 线程调用了pthread_exit函数。
- 其它线程使用 pthread_cancel函数结束线程。
- 调用exec或者exit函数，整个进程结束。
- pthread_exit用于显式退出线程。典型地，pthread_exit()函数在线程完成工作时，不在需要时候被调用，退出线程。
- 如果main()在其他线程创建前用pthread_exit()退出了，其他线程将会继续执行。否则，他们会随着main的结束而终止。
- 程序员可以可选择的指定终止状态，当任何线程连接（join）该线程时，该状态就返回给连接（join）该线程的线程。
- 清理：pthread_exit()函数并不会关闭文件，任何在线程中打开的文件将会一直处于打开状态，知道线程结束。
- 讨论：对于正常退出，可以免于调用pthread_exit()。当然，除非你想返回一个返回值。然而，在main中，有一个问题，就是当main结束时，其它线程还没有被创建。如果此时没有显式的调用pthread_exit()，当main结束时，进程（和所有线程）都会终止。可以在main中调用pthread_exit()，此时尽管在main中已经没有可执行的代码了，进程和所有线程将保持存活状态，。
例子: Pthread 创建和终止
- 该例用pthread_create()创建了5个线程。每一个线程都会打印一条“Hello World”的消息，然后调用pthread_exit()终止线程。
| Example Code - Pthread Creation and Termination #include <pthread.h> #include <stdio.h> #define NUM_THREADS 5
void *PrintHello(void *threadid) { int tid; tid = (int)threadid; printf("Hello World! It's me, thread #%d!/n", tid); pthread_exit(NULL); }
int main (int argc, char *argv[]) { pthread_t threads[NUM_THREADS]; int rc, t; for(t=0; t<NUM_THREADS; t++){ printf("In main: creating thread %d/n", t); rc = pthread_create(&threads[t], NULL, PrintHello, (void *)t); if (rc){ printf("ERROR; return code from pthread_create() is %d/n", rc); exit(-1); } } pthread_exit(NULL); }
|
| 线程管理 |
- pthread_create()函数允许程序员想线程的start routine传递一个参数。当多个参数需要被传递时，可以通过定义一个结构体包含所有要传的参数，然后用pthread_create()传递一个指向改结构体的指针，来打破传递参数的个数的限制。
- 所有参数都应该传引用传递并转化成（void*）。
|
|
| Q：怎样安全地向一个新创建的线程传递数据？ A：确保所传递的数据是线程安全的（不能被其他线程修改）。下面三个例子演示了那个应该和那个不应该。 |
| Example 1 - Thread Argument Passing 下面的代码片段演示了如何向一个线程传递一个简单的整数。主线程为每一个线程使用一个唯一的数据结构，确保每个线程传递的参数是完整的。 int *taskids[NUM_THREADS];
for(t=0; t<NUM_THREADS; t++) { taskids[t] = (int *) malloc(sizeof(int)); *taskids[t] = t; printf("Creating thread %d/n", t); rc = pthread_create(&threads[t], NULL, PrintHello, (void *) taskids[t]); ... }
|
| Example 2 - Thread Argument Passing 例子展示了用结构体向线程设置/传递参数。每个线程获得一个唯一的结构体实例。 struct thread_data{ int thread_id; int sum; char *message; };
struct thread_data thread_data_array[NUM_THREADS];
void *PrintHello(void *threadarg) { struct thread_data *my_data; ... my_data = (struct thread_data *) threadarg; taskid = my_data->thread_id; sum = my_data->sum; hello_msg = my_data->message; ... }
int main (int argc, char *argv[]) { ... thread_data_array[t].thread_id = t; thread_data_array[t].sum = sum; thread_data_array[t].message = messages[t]; rc = pthread_create(&threads[t], NULL, PrintHello, (void *) &thread_data_array[t]); ... }
|
| Example 3 - Thread Argument Passing (Incorrect) 例子演示了错误地传递参数。循环会在线程访问传递的参数前改变传递给线程的地址的内容。 int rc, t;
for(t=0; t<NUM_THREADS; t++) { printf("Creating thread %d/n", t); rc = pthread_create(&threads[t], NULL, PrintHello, (void *) &t); ... }
|
| 线程管理 |
函数:
| pthread_join (threadid,status) pthread_detach (threadid,status) pthread_attr_setdetachstate (attr,detachstate) pthread_attr_getdetachstate (attr,detachstate) |
连接:
- “连接”是一种在线程间完成同步的方法。例如：
- pthread_join()函数阻赛调用线程知道threadid所指定的线程终止。
- 如果在目标线程中调用pthread_exit()，程序员可以在主线程中获得目标线程的终止状态。
- 连接线程只能用pthread_join()连接一次。若多次调用就会发生逻辑错误。
- 两种同步方法，互斥量（mutexes）和条件变量（condition variables），稍后讨论。
可连接（Joinable or Not）?
- 当一个线程被创建，它有一个属性定义了它是可连接的（joinable）还是分离的（detached）。只有是可连接的线程才能被连接（joined），若果创建的线程是分离的，则不能连接。
- POSIX标准的最终草案指定了线程必须创建成可连接的。然而，并非所有实现都遵循此约定。
- 使用pthread_create()的attr参数可以显式的创建可连接或分离的线程，典型四步如下：
- 声明一个pthread_attr_t数据类型的线程属性变量
- 用 pthread_attr_init()初始化改属性变量
- 用pthread_attr_setdetachstate()设置可分离状态属性
- 完了后，用pthread_attr_destroy()释放属性所占用的库资源
分离（Detaching）：
- pthread_detach()可以显式用于分离线程，尽管创建时是可连接的。
- 没有与pthread_detach()功能相反的函数
建议：
- 若线程需要连接，考虑创建时显式设置为可连接的。因为并非所有创建线程的实现都是将线程创建为可连接的。
- 若事先知道线程从不需要连接，考虑创建线程时将其设置为可分离状态。一些系统资源可能需要释放。
例子: Pthread Joining
| Example Code - Pthread Joining 这个例子演示了用Pthread join函数去等待线程终止。因为有些实现并不是默认创建线程是可连接状态，例子中显式地将其创建为可连接的。 #include <pthread.h> #include <stdio.h> #define NUM_THREADS 3
void *BusyWork(void *null) { int i; double result=0.0; for (i=0; i<1000000; i++) { result = result + (double)random(); } printf("result = %e/n",result); pthread_exit((void *) 0); }
int main (int argc, char *argv[]) { pthread_t thread[NUM_THREADS]; pthread_attr_t attr; int rc, t; void *status;
/* Initialize and set thread detached attribute */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
for(t=0; t<NUM_THREADS; t++) { printf("Creating thread %d/n", t); rc = pthread_create(&thread[t], &attr, BusyWork, NULL); if (rc) { printf("ERROR; return code from pthread_create() is %d/n", rc); exit(-1); } }
/* Free attribute and wait for the other threads */ pthread_attr_destroy(&attr); for(t=0; t<NUM_THREADS; t++) { rc = pthread_join(thread[t], &status); if (rc) { printf("ERROR; return code from pthread_join() is %d/n", rc); exit(-1); } printf("Completed join with thread %d status= %ld/n",t, (long)status); }
pthread_exit(NULL); }
|
| 线程管理 |
函数:
| pthread_attr_getstacksize (attr, stacksize) pthread_attr_setstacksize (attr, stacksize) pthread_attr_getstackaddr (attr, stackaddr) pthread_attr_setstackaddr (attr, stackaddr) |
防止栈问题:
- POSIX标准并没有指定线程栈的大小，依赖于实现并随实现变化。
- 很容易超出默认的栈大小，常见结果：程序终止或者数据损坏。
- 安全和可移植的程序应该不依赖于默认的栈限制，但是取而代之的是用pthread_attr_setstacksize分配足够的栈大小。
- pthread_attr_getstackaddr和pthread_attr_setstackaddr函数可以被程序用于将栈设置在指定的内存区域。
在LC上的一些实际例子:
- 默认栈大小经常变化很大，最大值也变化很大，可能会依赖于每个节点的线程数目。
| Node | #CPUs | Memory (GB) | Default Size |
| AMD Opteron | 8 | 16 | 2,097,152 |
| Intel IA64 | 4 | 8 | 33,554,432 |
| Intel IA32 | 2 | 4 | 2,097,152 |
| IBM Power5 | 8 | 32 | 196,608 |
| IBM Power4 | 8 | 16 | 196,608 |
| IBM Power3 | 16 | 16 | 98,304 |
例子: 栈管理
| Example Code - Stack Management 这个例子演示了如何去查询和设定线程栈大小。 #include <pthread.h> #include <stdio.h> #define NTHREADS 4 #define N 1000 #define MEGEXTRA 1000000
pthread_attr_t attr;
void *dowork(void *threadid) { double A[N][N]; int i,j,tid; size_t mystacksize;
tid = (int)threadid; pthread_attr_getstacksize (&attr, &mystacksize); printf("Thread %d: stack size = %li bytes /n", tid, mystacksize); for (i=0; i<N; i++) for (j=0; j<N; j++) A[i][j] = ((i*j)/3.452) + (N-i); pthread_exit(NULL); }
int main(int argc, char *argv[]) { pthread_t threads[NTHREADS]; size_t stacksize; int rc, t;
pthread_attr_init(&attr); pthread_attr_getstacksize (&attr, &stacksize); printf("Default stack size = %li/n", stacksize); stacksize = sizeof(double)*N*N+MEGEXTRA; printf("Amount of stack needed per thread = %li/n",stacksize); pthread_attr_setstacksize (&attr, stacksize); printf("Creating threads with stack size = %li bytes/n",stacksize); for(t=0; t<NTHREADS; t++){ rc = pthread_create(&threads[t], &attr, dowork, (void *)t); if (rc){ printf("ERROR; return code from pthread_create() is %d/n", rc); exit(-1); } } printf("Created %d threads./n", t); pthread_exit(NULL); } |
| 线程管理 |
| pthread_self () pthread_equal (thread1,thread2) |
- pthread_self返回调用该函数的线程的唯一，系统分配的线程ID。
- pthread_equal比较两个线程ID,若不同返回0，否则返回非0值。
- 注意这两个函数中的线程ID对象是不透明的，不是轻易能检查的。因为线程ID是不透明的对象，所以C语言的==操作符不能用于比较两个线程ID。
| pthread_once (once_control, init_routine) |
- pthread_once 在一个进程中仅执行一次init_routine。任何线程第一次调用该函数会执行给定的init_routine，不带参数，任何后续调用都没有效果。
- init_routine函数一般是初始化的程序
- once_control参数是一个同步结构体，需要在调用pthread_once前初始化。例如：
pthread_once_t once_control = PTHREAD_ONCE_INIT;
- 互斥量（Mutex）是“mutual exclusion”的缩写。互斥量是实现线程同步，和保护同时写共享数据的主要方法
- 互斥量对共享数据的保护就像一把锁。在Pthreads中，任何时候仅有一个线程可以锁定互斥量，因此，当多个线程尝试去锁定该互斥量时仅有一个会成功。直到锁定互斥量的线程解锁互斥量后，其他线程才可以去锁定互斥量。线程必须轮着访问受保护数据。
- 互斥量可以防止“竞争”条件。下面的例子是一个银行事务处理时发生了竞争条件：
| Thread 1 | Thread 2 | Balance |
| Read balance: $1000 |
| $1000 |
|
| Read balance: $1000 | $1000 |
|
| Deposit $200 | $1000 |
| Deposit $200 |
| $1000 |
| Update balance $1000+$200 |
| $1200 |
|
| Update balance $1000+$200 | $1200 |
- 上面的例子，当一个线程使用共享数据资源时，应该用一个互斥量去锁定“Balance”。
- 一个拥有互斥量的线程经常用于更新全局变量。确保了多个线程更新同样的变量以安全的方式运行，最终的结果和一个线程处理的结果是相同的。这个更新的变量属于一个“临界区（critical section）”。
- 使用互斥量的典型顺序如下：
- 创建和初始一个互斥量
- 多个线程尝试去锁定该互斥量
- 仅有一个线程可以成功锁定改互斥量
- 锁定成功的线程做一些处理
- 线程解锁该互斥量
- 另外一个线程获得互斥量，重复上述过程
- 最后销毁互斥量
- 当多个线程竞争同一个互斥量时，失败的线程会阻塞在lock调用处。可以用“trylock”替换“lock”，则失败时不会阻塞。
- 当保护共享数据时，程序员有责任去确认是否需要使用互斥量。如，若四个线程会更新同样的数据，但仅有一个线程用了互斥量，则数据可能会损坏。
| 互斥量（Mutex Variables） |
函数：
| pthread_mutex_init (mutex,attr) pthread_mutex_destroy (mutex) pthread_mutexattr_init (attr) pthread_mutexattr_destroy (attr) |
用法：
- 互斥量必须用类型pthread_mutex_t类型声明，在使用前必须初始化，这里有两种方法可以初始化互斥量：
- 声明时静态地，如：
pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER; - 动态地用pthread_mutex_init()函数，这种方法允许设定互斥量的属性对象attr。
- 声明时静态地，如：
互斥量初始化后是解锁的。
- attr对象用于设置互斥量对象的属性，使用时必须声明为pthread_mutextattr_t类型，默认值可以是NULL。Pthreads标准定义了三种可选的互斥量属性：
-
- 协议（Protocol）： 指定了协议用于阻止互斥量的优先级改变
- 优先级上限（Prioceiling）：指定互斥量的优先级上限
- 进程共享（Process-shared）：指定进程共享互斥量
注意所有实现都提供了这三个可先的互斥量属性。
- pthread_mutexattr_init()和pthread_mutexattr_destroy()函数分别用于创建和销毁互斥量属性对象。
- pthread_mutex_destroy()应该用于释放不需要再使用的互斥量对象。
| 互斥量（Mutex Variables） |
函数：
| pthread_mutex_lock (mutex) pthread_mutex_trylock (mutex) pthread_mutex_unlock (mutex) |
用法：
- 线程用pthread_mutex_lock()函数去锁定指定的mutex变量，若该mutex已经被另外一个线程锁定了，该调用将会阻塞线程直到mutex被解锁。
- pthread_mutex_trylock() will attempt to lock a mutex. However, if the mutex is already locked, the routine will return immediately with a "busy" error code. This routine may be useful in
- pthread_mutex_trylock()尝试着去锁定一个互斥量，然而，若互斥量已被锁定，程序会立刻返回并返回一个忙错误值。该函数在优先级改变情况下阻止死锁是非常有用的。
- 线程可以用pthread_mutex_unlock()解锁自己占用的互斥量。在一个线程完成对保护数据的使用，而其它线程要获得互斥量在保护数据上工作时，可以调用该函数。若有一下情形则会发生错误：
- 互斥量已经被解锁
- 互斥量被另一个线程占用
- 互斥量并没有多么“神奇”的，实际上，它们就是参与的线程的“君子约定”。写代码时要确信正确地锁定，解锁互斥量。下面演示了一种逻辑错误：
· Thread 1 Thread 2 Thread 3
· Lock Lock
· A = 2 A = A+1 A = A*B
· Unlock Unlock
|
|
| Q：有多个线程等待同一个锁定的互斥量，当互斥量被解锁后，那个线程会第一个锁定互斥量？ A：除非线程使用了优先级调度机制，否则，线程会被系统调度器去分配，那个线程会第一个锁定互斥量是随机的。 |
例子：使用互斥量
| Example Code - Using Mutexes 例程演示了线程使用互斥量处理一个点积（dot product）计算。主数据通过一个可全局访问的数据结构被所有线程使用，每个线程处理数据的不同部分，主线程等待其他线程完成计算并输出结果。 #include <pthread.h> #include <stdio.h> #include <malloc.h>
/* The following structure contains the necessary information to allow the function "dotprod" to access its input data and place its output into the structure. */
typedef struct { double *a; double *b; double sum; int veclen; } DOTDATA;
/* Define globally accessible variables and a mutex */
#define NUMTHRDS 4 #define VECLEN 100 DOTDATA dotstr; pthread_t callThd[NUMTHRDS]; pthread_mutex_t mutexsum;
/* The function dotprod is activated when the thread is created. All input to this routine is obtained from a structure of type DOTDATA and all output from this function is written into this structure. The benefit of this approach is apparent for the multi-threaded program: when a thread is created we pass a single argument to the activated function - typically this argument is a thread number. All the other information required by the function is accessed from the globally accessible structure. */
void *dotprod(void *arg) {
/* Define and use local variables for convenience */
int i, start, end, offset, len ; double mysum, *x, *y; offset = (int)arg;
len = dotstr.veclen; start = offset*len; end = start + len; x = dotstr.a; y = dotstr.b;
/* Perform the dot product and assign result to the appropriate variable in the structure. */
mysum = 0; for (i=start; i<end ; i++) { mysum += (x[i] * y[i]); }
/* Lock a mutex prior to updating the value in the shared structure, and unlock it upon updating. */ pthread_mutex_lock (&mutexsum); dotstr.sum += mysum; pthread_mutex_unlock (&mutexsum);
pthread_exit((void*) 0); }
/* The main program creates threads which do all the work and then print out result upon completion. Before creating the threads, the input data is created. Since all threads update a shared structure, we need a mutex for mutual exclusion. The main thread needs to wait for all threads to complete, it waits for each one of the threads. We specify a thread attribute value that allow the main thread to join with the threads it creates. Note also that we free up handles when they are no longer needed. */
int main (int argc, char *argv[]) { int i; double *a, *b; void *status; pthread_attr_t attr;
/* Assign storage and initialize values */ a = (double*) malloc (NUMTHRDS*VECLEN*sizeof(double)); b = (double*) malloc (NUMTHRDS*VECLEN*sizeof(double));
for (i=0; i<VECLEN*NUMTHRDS; i++) { a[i]=1.0; b[i]=a[i]; }
dotstr.veclen = VECLEN; dotstr.a = a; dotstr.b = b; dotstr.sum=0;
pthread_mutex_init(&mutexsum, NULL);
/* Create threads to perform the dotproduct */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
for(i=0; i<NUMTHRDS; i++) { /* Each thread works on a different set of data. The offset is specified by 'i'. The size of the data for each thread is indicated by VECLEN. */ pthread_create( &callThd[i], &attr, dotprod, (void *)i); }
pthread_attr_destroy(&attr);
/* Wait on the other threads */ for(i=0; i<NUMTHRDS; i++) { pthread_join( callThd[i], &status); }
/* After joining, print out the results and cleanup */ printf ("Sum = %f /n", dotstr.sum); free (a); free (b); pthread_mutex_destroy(&mutexsum); pthread_exit(NULL); } Serial version |
- 条件变量提供了另一种同步的方式。互斥量通过控制对数据的访问实现了同步，而条件变量允许根据实际的数据值来实现同步。
- 没有条件变量，程序员就必须使用线程去轮询（可能在临界区），查看条件是否满足。这样比较消耗资源，因为线程连续繁忙工作。条件变量是一种可以实现这种轮询的方式。
- 条件变量往往和互斥一起使用
- 使用条件变量的代表性顺序如下：
| 主线程（Main Thread） o 声明和初始化需要同步的全局数据/变量（如“count”） o 生命和初始化一个条件变量对象 o 声明和初始化一个相关的互斥量 o 创建工作线程A和B | |
| Thread A o 工作，一直到一定的条件满足（如“count”等于一个指定的值） o 锁定相关互斥量并检查全局变量的值 o 调用pthread_cond_wait()阻塞等待Thread-B的信号。注意pthread_cond_wait()能够自动地并且原子地解锁相关的互斥量，以至于它可以被Thread-B使用。 o 当收到信号，唤醒线程，互斥量被自动，原子地锁定。 o 显式解锁互斥量 o 继续 | Thread B o 工作 o 锁定相关互斥量 o 改变Thread-A所等待的全局变量 o 检查全局变量的值，若达到需要的条件，像Thread-A发信号。 o 解锁互斥量 o 继续 |
| Main Thread Join / Continue | |
| 条件变量（Condition Variables） |
Routines:
| pthread_cond_init (condition,attr) pthread_cond_destroy (condition) pthread_condattr_init (attr) pthread_condattr_destroy (attr) |
Usage:
- 条件变量必须声明为pthread_cond_t类型，必须在使用前初始化。有两种方式可以初始条件变量：
- 声明时静态地。如：
pthread_cond_t myconvar = PTHREAD_COND_INITIALIZER; - 用pthread_cond_init()函数动态地。创建的条件变量ID通过condition参数返回给调用线程。该方式允许设置条件变量对象的属性，attr。
- 声明时静态地。如：
- 可选的attr对象用于设定条件变量的属性。仅有一个属性被定义：线程共享（process-shared），可以使条件变量被其它进程中的线程看到。若要使用属性对象，必须定义为pthread_condattr_t类型（可以指定为NULL设为默认）。
注意所有实现都提供了线程共享属性。
- pthread_condattr_init()和pthread_condattr_destroy()用于创建和销毁条件变量属性对象。
- 条件变量不需要再使用时，应用pthread_cond_destroy()释放条件变量。
| 条件变量（Condition Variables） |
在条件变量上等待（Waiting）和发送信号（Signaling）
函数：
| pthread_cond_wait (condition,mutex) pthread_cond_signal (condition) pthread_cond_broadcast (condition) |
用法：
- pthread_cond_wait()阻塞调用线程直到指定的条件受信（signaled）。该函数应该在互斥量锁定时调用，当在等待时会自动解锁互斥量。在信号被发送，线程被激活后，互斥量会自动被锁定，当线程结束时，由程序员负责解锁互斥量。
- pthread_cond_signal()函数用于向其他等待在条件变量上的线程发送信号（激活其它线程）。应该在互斥量被锁定后调用。
- 若不止一个线程阻塞在条件变量上，则应用pthread_cond_broadcast()向其它所以线程发生信号。
- 在调用pthread_cond_wait()前调用pthread_cond_signal()会发生逻辑错误。
|
| 使用这些函数时适当的锁定和解锁相关的互斥量是非常重要的。如：
|
例子：使用条件变量
| Example Code - Using Condition Variables 例子演示了使用Pthreads条件变量的几个函数。主程序创建了三个线程，两个线程工作，根系“count”变量。第三个线程等待count变量值达到指定的值。 #include <pthread.h> #include <stdio.h>
#define NUM_THREADS 3 #define TCOUNT 10 #define COUNT_LIMIT 12
int count = 0; int thread_ids[3] = {0,1,2}; pthread_mutex_t count_mutex; pthread_cond_t count_threshold_cv;
void *inc_count(void *idp) { int j,i; double result=0.0; int *my_id = idp;
for (i=0; i<TCOUNT; i++) { pthread_mutex_lock(&count_mutex); count++;
/* Check the value of count and signal waiting thread when condition is reached. Note that this occurs while mutex is locked. */ if (count == COUNT_LIMIT) { pthread_cond_signal(&count_threshold_cv); printf("inc_count(): thread %d, count = %d Threshold reached./n", *my_id, count); } printf("inc_count(): thread %d, count = %d, unlocking mutex/n", *my_id, count); pthread_mutex_unlock(&count_mutex);
/* Do some work so threads can alternate on mutex lock */ for (j=0; j<1000; j++) result = result + (double)random(); } pthread_exit(NULL); }
void *watch_count(void *idp) { int *my_id = idp;
printf("Starting watch_count(): thread %d/n", *my_id);
/* Lock mutex and wait for signal. Note that the pthread_cond_wait routine will automatically and atomically unlock mutex while it waits. Also, note that if COUNT_LIMIT is reached before this routine is run by the waiting thread, the loop will be skipped to prevent pthread_cond_wait from never returning. */ pthread_mutex_lock(&count_mutex); if (count<COUNT_LIMIT) { pthread_cond_wait(&count_threshold_cv, &count_mutex); printf("watch_count(): thread %d Condition signal received./n", *my_id); } pthread_mutex_unlock(&count_mutex); pthread_exit(NULL); }
int main (int argc, char *argv[]) { int i, rc; pthread_t threads[3]; pthread_attr_t attr;
/* Initialize mutex and condition variable objects */ pthread_mutex_init(&count_mutex, NULL); pthread_cond_init (&count_threshold_cv, NULL);
/* For portability, explicitly create threads in a joinable state */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_create(&threads[0], &attr, inc_count, (void *)&thread_ids[0]); pthread_create(&threads[1], &attr, inc_count, (void *)&thread_ids[1]); pthread_create(&threads[2], &attr, watch_count, (void *)&thread_ids[2]);
/* Wait for all threads to complete */ for (i=0; i<NUM_THREADS; i++) { pthread_join(threads[i], NULL); } printf ("Main(): Waited on %d threads. Done./n", NUM_THREADS);
/* Clean up and exit */ pthread_attr_destroy(&attr); pthread_mutex_destroy(&count_mutex); pthread_cond_destroy(&count_threshold_cv); pthread_exit(NULL);
}
|
Pthread API的几个特性在该教程中并没有包含。把它们列在下面：
- 线程调度
- 线程如何调度的实现往往是不同的，在大多数情况下，默认的机制是可以胜任的。
- Pthreads API提供了显式设定线程调度策略和优先级的函数，它们可以重载默认机制。
- API不需要实现去支持这些特性
- Keys：线程数据（TSD）
- 互斥量的Protocol属性和优先级管理
- 跨进程的条件变量共享
- Thread Cancellation
- 取消线程（Thread Cancellation ）
- 多线程和信号（Threads and Signals）
| Pthread Functions | |
| Thread Management | |
| Thread-Specific Data | |
| Thread Cancellation | |
| pthread_getcancelstate | |
| Thread Scheduling | |
| Signals | |
| Pthread Attribute Functions | |
| Basic Management | |
| Detachable or Joinable | |
| Specifying Stack Information | |
| Thread Scheduling Attributes | |
| Mutex Functions | |
| Mutex Management | |
| Priority Management | |
| Mutex Attribute Functions | |
| Basic Management | |
| Sharing | |
| Protocol Attributes | |
| Priority Management | |
| Condition Variable Functions | |
| Basic Management | |
| Condition Variable Attribute Functions | |
| Basic Management | |
| Sharing | |
- Author: Blaise Barney, Livermore Computing.
- "Pthreads Programming". B. Nichols et al. O'Reilly and Associates.
- "Threads Primer". B. Lewis and D. Berg. Prentice Hall
- "Programming With POSIX Threads". D. Butenhof. Addison Wesley
www.awl.com/cseng/titles/0-201-63392-2 - "Programming With Threads". S. Kleiman et al. Prentice Hall
- 本篇及其英文原文: http://download.csdn.net/source/992256
- Programing with POSIX thread(强烈推荐): http://download.csdn.net/source/992239
- Pthread Primer(强烈推荐): http://download.csdn.net/source/992213
author: david(Heaven.Hell.Or@gmail.com)
code page:http://code.google.com/p/heavenhell/
* PthreaddCond.cpp
*
* Created on: Nov 11, 2013
* Author: zsf
*/
简单的生产者消费者模型
#include <stdio.h>
#include <pthread.h>
#define MAXSIZE 1024
struct Data {
char buf;
pthread_cond_t full;
pthread_cond_t empty;
pthread_mutex_t lock;
int writeops, readops;
};
struct Data data;
void init(struct Data *data) {
pthread_cond_init(&data->full, NULL);
pthread_cond_init(&data->empty, NULL);
pthread_mutex_init(&data->lock, NULL);
data->readops = 0;
data->writeops = 0;
}
void put(struct Data *data, int num) {
pthread_mutex_lock(&data->lock);
while (data->writeops != 0) {
printf("wait empty
");
pthread_cond_wait(&data->empty, &data->lock);
}
data->buf = num;
data->writeops++;
pthread_cond_signal(&data->full);
pthread_mutex_unlock(&data->lock);
}
int get(struct Data *data) {
int num;
pthread_mutex_lock(&data->lock);
while (data->writeops == 0) {
printf("wait full
");
pthread_cond_wait(&data->full, &data->lock);
}
num = data->buf;
data->writeops--;
pthread_cond_signal(&data->empty);
pthread_mutex_unlock(&data->lock);
return num;
}
void *product(void *) {
for (int i = 0; i < 10; i++) {
put(&data, i);
printf("put -->%d", i);
}
put(&data,-1);
printf("product over
");
return NULL;
}
void *consumer(void *) {
int ret;
while (1) {
ret = get(&data);
if(ret==-1)break;
printf("get -->%d
", ret);
}
printf("consumer stop
");
return NULL;
}
int main() {
pthread_t pthread[2];
void *interval;
int tmp;
tmp = pthread_create(&pthread[0], NULL, product, NULL);
tmp = pthread_create(&pthread[1], NULL, consumer, NULL);
pthread_join(pthread[0], &interval);
pthread_join(pthread[1], &interval);
return 0;
}
/*