DELPHI下的多线程程序设计

Posted 2023-05-17

参考技术A 我们知道 win 或winNT都是 多线程 的操作系统 在DELPHI ． 中 我们可以充分利用这一特性 编写出 多线程 的应用程序 　　对以往在DOS或 位windows下写程序的人来说 多线程 仍然是陌生的 但如同以前我们从DOS下的单任务过渡到windows ． 下的多任务 如今我们又必须过渡到 多线程 领域 毕竟计算机时代是在不断发展的 不过 幸运的是 在DELPHI ． 下进行多线程程序设计并不需要我们去学习庞大的WIN API函数 我们可以利用DELPHI下标准的多线程类TThread来完成我们的工作  　　TThread是一个abstract（抽象）类 也就是说 并不需要根据TThread来声明变量（而且根据TThread声明的变量也是完全无用） 我们要做的是把TThread作为基类 用继承的形式来生成子类 实际上 根据TThread来写多线程应用程序是非常容易的 　　下面就是一个基本的继承TThread生成的多线程类 　　QuerThrd．Pas 　　unitQuerThrd 　　interface 　　uses 　　Classes DBTables 　　type 　　TQueryThreadΚclass（TThread） 　　private 　　fQuery tQuery 　　protected 　　procedureExecute override 　　public 　　constructorCreate（Suspended Boolean Query TQuery） 　　end 　　implementation 　　constructor 　　TQueryThread．Create（Suspended Boolean Query TQuery） 　　begin 　　inheritedCreate（Suspended） 　　fQuery ΚQuery 　　FreeOnTerminate ΚTrue 　　end 　　procedureTQueryThread．Execute 　　begin 　　fQuery．Open 　　end 　　end． 　　在上面这个简单的例子中 我们构造了一个TThread的子类TQueryThread 用于在后台执行数据库查询 在该类的Create函数中 传递了两个参数Suspended和Query 其中Suspended用于控制线程的运行 如果Suspend为真 TQueryThread类的线程在建立后将立即被悬挂 一直到运行了Resume方法 该线程才会继续执行 Query参数用于接受一个已经存在的Query控件（在窗体中真正的Query控件）而使它在多线程的情况下运行 Execute是最重要的过程 它是类TQueryThread的执行部分 所有需要在这个多线程类中运行的语句都必须写在这个过程里 　　实际上构造自己的多线程类时 并不需要输入所有的这些代码 选择DELPHI的File菜单下的new选项 再选 TThreadObject 项目 DELPHI就会为你构造基本的程序模块 然后我们可以根据需要再做相应的修改 　　进程的执行 　　假设我们已经建立了一个窗体FORM 窗体中有我们将要使用的查询控件Query 那么我们在该单元的USES部分加入上面写的QuerThrd单元 　　procedureTForm ．Button Click（Sender TObject） 　　begin 　　｛建立一个运行的进程｝ 　　TQueryThread．Create（False Query ） 　　end 　　如果这个过程被执行 那么窗体中的查询控件Query 就会自动在多线程的环境下运行查询 注意TQueryThread类中只有Create而没有Free 动态建立类以后又忘记删除是我们常犯的错误之一 不过在这里由于我们指定了FreeOnTerminate（运行完即删除）为真 所以当Execute里的语句执行完后 TQueryThread类占据的内存控件将被自动释放 　　然而还有一个问题值得我们注意 由于同一时刻可以有多个线程同时运行 那么我们还必须解决好同步的问题 如果几个多线程程序之间没有任何关联 那么它们之间也不会有任何冲突 但实际上 可能同时运行几个多线程的数据库应用程序 由于需要共享相同的数据库资源 我们还需要为Query 增加一个Tsession控件 　　其实 虽然我们也许没有亲自使用过Session控件 但实际上 在所有的数据库访问时DELPHI都会自动建立一个临时的Session控件 使用完后又动态地删除掉它 在平常的数据库编程时 用不着我们亲自来操作 但在数据库多线程执行的情况下 为了不相互冲突 我们必须为每个数据库访问都定制自己的Session控件 这个步骤非常简单 我们只需要在窗体中增加一个Session控件 然后给它的属性 Sessionname 写一个任意的名字 并再在Query 的 Sessionname 中写一个相同的名字 这样我们的数据库程序就安全了 　　另一类需要解决同步问题的是那些对VCL资源进行操作的程序 这类的程序非常多 好在解决的方法也非常简单 　　我们可以看下面这样一个程序 　　unitBncThrd 　　interface 　　uses 　　WinProcs Classes Graphics ExtCtrls 　　type 　　TBounceThreadΚclass（TThread） 　　private 　　FShape TShape 　　FXSpeed Integer 　　FYSpeed Integer 　　procedureMoveShape 　　protected 　　procedureExecute override 　　public 　　constructorCreate（Suspended Boolean Shape TShape XSpeed YSpeed Integer） 　　propertyShape TShapereadFShape 　　end 　　implementation 　　procedureTBouad．MoveShape 　　var 　　MaxHeight MaxWidth Integer 　　begin 　　withFShapedo 　　begin 　　Left ΚLeft＋FXSpeed 　　Top ΚTop＋FYSpeed 　　if（LeftΙ ）or 　　（Left＋WidthΛParent．Width）then 　　FXSpeed ΚFXSpeed＊－ 　　if（TopΙ ）or 　　（Top＋HeightΛParent．Height）then 　　FYSpeed ΚFYSpeed＊－ end 　　end 　　procedureTBounceThread．Execute 　　begin 　　WhilenotTerminateddo 　　begin 　　Synchronize（MoveShape） 　　end 　　end 　　constructorTBounceThread．Create（Suspended Boolean Shape TShape XSpeed YSpeed Integer） 　　begin 　　inheritedCreate（Suspended） 　　FShape ΚShape 　　FXSpeed ΚXSpeed ｛X轴走向的速度｝ 　　FYSpeed ΚYSpeed ｛Y轴走向的速度｝ 　　FreeOnTerminate ΚTrue 　　end 　　end． 　　这是一个多线程的碰碰球游戏 你可以有多个不同的球 它们分属不同的线程 各自独立的在屏幕上碰撞 显然 由于多个球运行的显示会同时操作VCL资源 为了安全 我们在Execute过程中的执行部分加入了Synchronize（MoveShape）来调用MoveShape过程 实际上 在任何需要操作VCL资源的地方 例如窗体 位图 都应加入Synchronize调用 　　执行时我们可以新建一个程序 然后在USES部分加入以上的BncThrd单元 再在它的窗体FORM 上加入两个Shape控件Shape 和Shape Shape 可以是一个矩形而Shape 是一个圆 加入以下的代码就可以让矩形和圆动起来 　　procedureTForm ．Button Click（Sender TObject） 　　begin 　　TBounceThread．Create（False Shape ） 　　TBounceThread．Create（False Shape ） 　　end lishixinzhi/Article/program/Delphi/201311/25059

POSIX 多线程程序设计

POSIX 多线程程序设计

目录表 

1. 摘要  
2. 译者序
3. Pthreads 概述  
   1. 什么是线程?  
   2. 什么是Pthreads?  
   3. 为什么使用Pthreads?  
   4. 使用线程设计程序  
4. Pthreads API编译多线程程序  
5. 线程管理  
   1. 创建和终止线程  
   2. 向线程传递参数  
   3. 连接（Joining）和分离（ Detaching）线程  
   4. 栈管理  
   5. 其它函数  
6. 互斥量（Mutex Variables）  
   1. 互斥量概述  
   2. 创建和销毁互斥量  
   3. 锁定（Locking）和解锁（Unlocking）互斥量  
7. 条件变量（Condition Variable）  
   1. 条件变量概述 
   2. 创建和销毁条件变量  
   3. 等待（Waiting）和发送信号（Signaling）  
8. 没有覆盖的主题  
9. Pthread 库API参考  
10. 参考资料  

摘要

在多处理器共享内存的架构中（如：对称多处理系统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。

 

Pthreads 概述

什么是线程? 

 

• 技术上，线程可以定义为：可以被操作系统调度的独立的指令流。但是这是什么意思呢？ 
• 对于软件开发者，在主程序中运行的“函数过程”可以很好的描述线程的概念。 
• 进一步，想象下主程序（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 概述

什么是 Pthreads? 

• 历史上，硬件销售商实现了私有版本的多线程库。这些实现在本质上各自不同，使得程序员难于开发可移植的应用程序。 
• 为了使用线程所提供的强大优点，需要一个标准的程序接口。对于UNIX系统，IEEE POSIX 1003.1c（1995）标准制订了这一标准接口。依赖于该标准的实现就称为POSIX threads 或者Pthreads。现在多数硬件销售商也提供Pthreads，附加于私有的API。 
• Pthreads 被定义为一些C语言类型和函数调用，用pthread.h头（包含）文件和线程库实现。这个库可以是其它库的一部分，如libc。 

 

Pthreads 概述

为什么使用 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

fork_vs_thread.txt  

• 在同一个进程中的所有线程共享同样的地址空间。较于进程间的通信，在许多情况下线程间的通信效率比较高，且易于使用。 
• 较于没有使用线程的程序，使用线程的应用程序有潜在的性能增益和实际的优点： 
  • 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 (GB/sec)	Pthreads Worst Case Memory-to-CPU Bandwidth  (GB/sec)
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

 

• Pthreads API在ANSI/IEEE POSIX 1003.1 – 1995标准中定义。不像MPI，该标准不是免费的，必须向IEEE购买。 
• Pthreads API中的函数可以非正式的划分为三大类： 
  1. 线程管理（Thread management）: 第一类函数直接用于线程：创建（creating），分离（detaching），连接（joining）等等。包含了用于设置和查询线程属性（可连接，调度属性等）的函数。 
  2. 互斥量（Mutexes）: 第二类函数是用于线程同步的，称为互斥量（mutexes），是"mutual exclusion"的缩写。Mutex函数提供了创建，销毁，锁定和解锁互斥量的功能。同时还包括了一些用于设定或修改互斥量属性的函数。 
  3. 条件变量（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  AIX	xlc_r  /  cc_r	C (ANSI  /  non-ANSI)
	xlC_r	C++
	xlf_r -qnosave xlf90_r -qnosave	Fortran - using IBM's Pthreads API (non-portable)
INTEL Linux	icc -pthread	C
	icpc -pthread	C++
PathScale Linux	pathcc -pthread	C
	pathCC -pthread	C++
PGI Linux	pgcc -lpthread	C
	pgCC -lpthread	C++
GNU Linux, AIX	gcc -pthread	GNU C
	g++ -pthread	GNU C++

 

线程管理（Thread Management）

创建和结束线程 

函数：  

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

 

线程管理

连接（Joining）和分离（Detaching）线程 

函数:  

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参数可以显式的创建可连接或分离的线程，典型四步如下： 
  1. 声明一个pthread_attr_t数据类型的线程属性变量 
  2. 用 pthread_attr_init()初始化改属性变量 
  3. 用pthread_attr_setdetachstate()设置可分离状态属性 
  4. 完了后，用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 Architecture	#CPUs	Memory (GB)	Default Size (bytes)
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 Variables）

概述 

• 互斥量（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类型声明，在使用前必须初始化，这里有两种方法可以初始化互斥量： 
  1. 声明时静态地，如：
     pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;  
  2. 动态地用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）

锁定和解锁互斥量 

函数：<