【3D技术宅公社】XR数字艺术论坛  XR技术讨论 XR互动电影 定格动画

 找回密码
 立即注册

QQ登录

只需一步,快速开始

调查问卷
论坛即将给大家带来全新的技术服务,面向三围图形学、游戏、动画的全新服务论坛升级为UTF8版本后,中文用户名和用户密码中有中文的都无法登陆,请发邮件到324007255(at)QQ.com联系手动修改密码

3D技术论坛将以计算机图形学为核心,面向教育 推出国内的三维教育引擎该项目在持续研发当中,感谢大家的关注。

查看: 6028|回复: 12

[转帖]第 1 章 多线程基础介绍

[复制链接]
发表于 2008-4-24 16:47:47 | 显示全部楼层 |阅读模式

多线程一词可以解释为多个控制线程多个控制流。虽然传统的 UNIX 进程包含单个控制线程,但多线程 (multithreading, MT) 会将一个进程分成许多执行线程,其中每个线程都可独立运行。

本章介绍了一些多线程的术语和概念及其所产生的益处。如果您已准备好开始使用多线程,请跳至第 2 章,基本线程编程

定义多线程术语

表 1–1 介绍了本书中所使用的一些术语。

表 1–1 多线程术语

术语

定义

Process(进程)

通过 fork(2) 系统调用创建的 UNIX 环境(如文件描述符和用户 ID 等),为运行程序而设置。

Thread(线程)

在进程上下文中执行的指令序列。

POSIX pthread

符合 POSIX 线程的线程接口。

Solaris thread(Solaris 线程)

不符合 POSIX 线程的 Sun MicrosystemsTM 线程接口,pthread 的前序节点。

single-threaded(单线程)

仅允许访问一个线程。

Multithreading(多线程)

允许访问两个或多个线程。

User-level or Application-level thread(用户级线程或应用程序级线程)

在用户空间(而非内核空间)中由线程调度例程管理的线程。

Lightweight process(轻量进程)

用来执行内核代码和系统调用的内核线程,又称作 LWP。从 Solaris 9 开始,每个线程都有一个专用的 LWP。

Bound thread(绑定线程)(过时的术语)

指的是在 Solaris 9 之前,和一个 LWP 永久绑定的用户级线程。从 Solaris 9 开始,每个线程都有一个专用的 LWP。

Unbound thread(非绑定线程)(过时的术语)

指的是在 Solaris 9 之前,无须和一个 LWP 绑定的用户级线程。从 Solaris 9 开始,每个线程都有一个专用的 LWP。

Attribute object(属性对象)

包含不透明数据类型和相关处理函数。这些数据类型和函数可以对 POSIX 线程一些可配置的方面,例如互斥锁 (mutex) 和条件变量,进行标准化。

Mutual exclusion lock(互斥锁)

用来锁定和解除锁定对共享数据访问的函数。

Condition variable(条件变量)

用来阻塞线程直到状态发生变化的函数。

Read-write lock(读写锁)

可用于对共享数据进行多次只读访问的函数,但是要修改共享数据则必须以独占方式访问。

Counting semaphore(计数信号量)

一种基于内存的同步机制。

Parallelism(并行性)

如果至少有两个线程正在同时执行,则会出现此情况。

Concurrency(并发性)

如果至少有两个线程正在进行,则会出现此情况。并发是一种更广义的并行性,其中可以包括分时这种形式的虚拟并行性。

 楼主| 发表于 2008-4-24 16:48:38 | 显示全部楼层

符合多线程标准

多线程编程的概念至少可以回溯到二十世纪六十年代。多线程编程在 UNIX 系统中的发展是从八十年代中期开始的。虽然对多线程的定义以及对支持多线程所需要的功能存在共识,但是用于实现多线程的接口有很大不同。

在过去的几年内,POSIX(Portable Operating System Interface,可移植操作系统接口)1003.4a 工作小组一直致力于制定多线程编程标准。现在,该标准已得到认可。

该《多线程编程指南》基于 POSIX 标准 IEEE Std 1003.1 1996 版(又称作 ISO/IEC 9945–1 第二版)。最新修订版的 POSIX 标准 IEEE Std 1003.1:2001(又称作 ISO/IEC 9945:2002 和单一 UNIX 规范版本 3)中也提供了这些功能。

特定于 Solaris 线程的主题将在第 8 章,Solaris 线程编程中进行介绍。

多线程的益处

本节简要介绍多线程的益处。

在代码中实现多线程具有以下益处:

  • 提高应用程序的响应

  • 更有效地使用多处理器

  • 改进程序结构

  • 占用较少的系统资源

提高应用程序的响应

可以对任何一个包含许多相互独立的活动的程序进行重新设计,以便将每个活动定义为一个线程。例如,多线程 GUI 的用户不必等待一个活动完成即可启动另一个活动。

有效使用多处理器

通常,要求并发线程的应用程序无需考虑可用处理器的数量。使用额外的处理器可以明显提高应用程序的性能。

具有高度并行性的数值算法和数值应用程序(如矩阵乘法)在多处理器上通过多个线程实现时,运行速度会快得多。

改进程序结构

许多应用程序都以更有效的方式构造为多个独立或半独立的执行单元,而非整块的单个线程。多线程程序比单线程程序更能适应用户需求的变化。

占用较少的系统资源

如果两个或多个进程通过共享内存访问公用数据,则使用这些进程的程序可以实现对多个线程的控制。

但是,每个进程都有一个完整的地址空间和操作环境状态。每个进程用于创建和维护大量状态信息的成本,与一个线程相比,无论是在时间上还是空间上代价都更高。

此外,进程间所固有的独立性使得程序员需要花费很多精力来处理不同进程间线程的通信或者同步这些线程的操作。

结合线程和 RPC(远程过程调用)

通过将多个线程和一个远程过程调用 (remote procedure call, RPC) 结合起来,可以充分利用无共享内存的多处理器(如工作站集合)。这种结合将工作站集合视为一个多处理器,从而使应用程序的分布变得相对容易些。

例如,一个线程可以创建多个子线程,每个子线程随后可以请求远程过程调用,从而调用另一个工作站上的过程。尽管初始线程此时仅创建了一些并行运行的线程,但是这种并行性会涉及到其他计算机。

多线程概念

本节介绍多线程的基本概念。

并发性和并行性

在单个处理器的多线程进程中,处理器可以在线程之间切换执行资源,从而执行并发。

在共享内存的多处理器环境内的同一个多线程进程中,进程中的每个线程都可以在一个单独的处理器上并发运行,从而执行并行。如果进程中的线程数不超过处理器的数目,则线程的支持系统和操作环境可确保每个线程在不同的处理器上执行。例如,在线程数和处理器数目相同的矩阵乘法中,每个线程和每个处理器都会计算一行结果。

多线程结构一览

传统的 UNIX 已支持多线程的概念。每个进程都包含一个线程,因此对多个进程进行编程即是对多个线程进行编程。但是,进程同时也是一个地址空间,因此创建进程会涉及到创建新的地址空间。

创建线程比创建新进程成本低,因为新创建的线程使用的是当前进程的地址空间。相对于在进程之间切换,在线程之间进行切换所需的时间更少,因为后者不包括地址空间之间的切换。

在进程内部的线程间通信很简单,因为这些线程会共享所有内容,特别是地址空间。所以,一个线程生成的数据可以立即用于其他所有线程。

在 Solaris 9 和较早的 Solaris 发行版中,支持多线程的接口是通过特定的子例程库实现的。这些子例程库包括用于 POSIX 线程的 libpthread 和用于 Solaris 线程的 libthread。多线程通过将内核级资源和用户级资源分离来提供灵活性。在当前的发行版中,对于这两组接口的多线程支持是由标准 C 库提供的。

用户级线程

线程是多线程编程中的主编程接口。线程仅在进程内部是可见的,进程内部的线程会共享诸如地址空间、打开的文件等所有进程资源。

用户级线程状态

以下状态对于每个线程是唯一的。

  • 线程 ID

  • 寄存器状态(包括 PC 和栈指针)

  • 信号掩码

  • 优先级

  • 线程专用存储

由于线程可共享进程指令和大多数进程数据,因此一个线程对共享数据进行的更改对进程内其他线程是可见的。一个线程需要与同一个进程内的其他线程交互时,该线程可以在不涉及操作系统的情况下进行此操作。


注 –

顾名思义,用户级线程不同于内核级线程,只有系统程序员才能处理内核级线程。由于本书面向应用程序程序员,因此将不讨论内核级线程。

线程调度

POSIX 标准指定了三种调度策略:先入先出策略 (SCHED_FIFO)、循环策略 (SCHED_RR) 和自定义策略 (SCHED_OTHER)。SCHED_FIFO 是基于队列的调度程序,对于每个优先级都会使用不同的队列。SCHED_RR 与 FIFO 相似,不同的是前者的每个线程都有一个执行时间配额。

SCHED_FIFOSCHED_RR 是对 POSIX Realtime 的扩展。SCHED_OTHER 是缺省的调度策略。

有关 SCHED_OTHER 策略的信息,请参见LWP 和调度类

提供了两个调度范围:进程范围 (PTHREAD_SCOPE_PROCESS) 和系统范围 (PTHREAD_SCOPE_SYSTEM)。具有不同范围状态的线程可以在同一个系统甚至同一个进程中共存。进程范围只允许这种线程与同一进程中的其他线程争用资源,而系统范围则允许此类线程与系统内的其他所有线程争用资源。实际上,从 Solaris 9 发行版开始,系统就不再区分这两个范围。

线程取消

一个线程可以请求终止同一个进程中的其他任何线程。目标线程(要取消的线程)可以延后取消请求,并在该线程处理取消请求时执行特定于应用程序的清理操作。

通过 pthread 取消功能,可以对线程进行异步终止或延迟终止。异步取消可以随时发生,而延迟取消只能发生在所定义的点。延迟取消是缺省类型。

线程同步

使用同步功能,可以控制程序流并访问共享数据,从而并发执行多个线程。

共有四种同步模型:互斥锁、读写锁、条件变量和信号。

  • 互斥锁仅允许每次使用一个线程来执行特定的部分代码或者访问特定数据。

  • 读写锁允许对受保护的共享资源进行并发读取和独占写入。要修改资源,线程必须首先获取互斥写锁。只有释放所有的读锁之后,才允许使用互斥写锁。

  • 条件变量会一直阻塞线程,直到特定的条件为真。

  • 计数信号量通常用来协调对资源的访问。使用计数,可以限制访问某个信号的线程数量。达到指定的计数时,信号将阻塞。

使用 64 位体系结构

对于应用程序开发者,Solaris 64 位和 32 位环境的主要区别在于所使用的 C 语言数据类型的模型。64 位数据类型使用 LP64 模型,其中 long 和指针的宽度为 64 位,其他所有基础数据类型仍然与 32 位实现的数据类型相同。32 位数据类型使用 ILP32 模型,其中的 intlong 和指针宽度为 32 位。

以下简要概述了 64 位环境的主要特征以及使用该环境时的注意事项:

  • 大虚拟地址空间

    在 64 位环境中,进程的虚拟地址空间最高可达 64 位(即 18 EB)。目前,32 位进程的最大地址空间为 4 GB,较大的虚拟地址空间大约是其 40 亿倍。但是由于硬件限制,某些平台可能并不支持完整的 64 位地址空间。

    大地址空间增加了可创建的具有缺省栈大小的线程数。在 32 位和 64 位系统中,栈的大小分别为 1 MB 和 2 MB。 在 32 位和 64 位系统中,具有缺省栈大小的线程数分别是大约 2000 个和 80000 亿个。

  • 内核内存读取器

    内核是在内部使用 64 位数据结构的 LP64 对象。这意味着,使用 libkvm/dev/mem/dev/kmem 的现有 32 位应用程序不能正常工作,必须转换为 64 位程序。

  • /proc 限制

    使用 /proc 的 32 位程序可以查看 32 位进程,但是无法识别 64 位进程。用来描述进程的现有接口和数据结构不够大,因此无法包含 64 位值。对于此类程序,必须将其重新编译为 64 位程序,使其可同时适用于 32 位进程和 64 位进程。

  • 64 位库

    32 位库必须与 32 位应用程序进行链接,而 64 位库必须与 64 位应用程序进行链接。除已过时的库以外,所有的系统库都同时提供 32 位版本和 64 位版本。

  • 64 位运算

    64 位运算早已在以前的 32 位 Solaris 发行版中提供。现在,64 位实现提供了完整的 64 位计算机寄存器,用于进行整数运算和参数传递。

  • 大文件

    如果应用程序仅要求大文件支持,则可以保留 32 位并使用大文件接口。要充分利用 64 位功能,必须将应用程序转换为 64 位。

 楼主| 发表于 2008-4-24 16:49:17 | 显示全部楼层

第 2 章 基本线程编程

本章介绍 POSIX 线程的基本线程编程例程。本章介绍缺省线程(即,具有缺省属性值的线程),这是多线程编程中最常用的线程。本章还介绍如何创建和使用具有非缺省属性的线程。

本章介绍的 POSIX 例程具有与最初的 Solaris 多线程库相似的编程接口。

线程库

下面简要论述了特定任务及其相关手册页。

创建缺省线程

如果未指定属性对象,则该对象为 NULL,系统会创建具有以下属性的缺省线程:

  • 进程范围

  • 非分离

  • 缺省栈和缺省栈大小

  • 零优先级

还可以用 pthread_attr_init() 创建缺省属性对象,然后使用该属性对象来创建缺省线程。有关详细信息,请参见初始化属性一节。

pthread_create 语法

使用 pthread_create(3C) 可以向当前进程中添加新的受控线程。

int	pthread_create(pthread_t *tid, const pthread_attr_t *tattr,

    void*(*start_routine)(void *), void *arg);
#include <pthread.h>
		pthread_attr_t()
		tattr;

pthread_t tid;

extern void *start_routine(void *arg);

void *arg;

int ret; 



/* default behavior*/

ret = pthread_create(&tid, NULL, start_routine, arg);



/* initialized with default attributes */

ret = pthread_attr_init(&tattr);

/* default behavior specified*/

ret = pthread_create(&tid, &tattr, start_routine, arg);

使用具有必要状态行为的 attr 调用 pthread_create() 函数。 start_routine 是新线程最先执行的函数。当 start_routine 返回时,该线程将退出,其退出状态设置为由 start_routine 返回的值。请参见pthread_create 语法

pthread_create() 成功时,所创建线程的 ID 被存储在由 tid 指向的位置中。

使用 NULL 属性参数或缺省属性调用 pthread_create() 时,pthread_create() 会创建一个缺省线程。在对 tattr 进行初始化之后,该线程将获得缺省行为。

pthread_create 返回值

pthread_create() 在调用成功完成之后返回零。其他任何返回值都表示出现了错误。如果检测到以下任一情况,pthread_create() 将失败并返回相应的值。

EAGAIN

描述:

超出了系统限制,如创建的线程太多。

EINVAL

描述:

tattr 的值无效。

等待线程终止

pthread_join() 函数会一直阻塞调用线程,直到指定的线程终止。

pthread_join 语法

使用 pthread_join(3C) 等待线程终止。

int	pthread_join(thread_t tid, void **status);
#include <pthread.h>



pthread_t tid;

int ret;

void *status;



/* waiting to join thread "tid" with status */

ret = pthread_join(tid, &status);



/* waiting to join thread "tid" without status */

ret = pthread_join(tid, NULL); 

指定的线程必须位于当前的进程中,而且不得是分离线程。有关线程分离的信息,请参见设置分离状态

status 不是 NULL 时,status 指向某个位置,在 pthread_join() 成功返回时,将该位置设置为已终止线程的退出状态。

如果多个线程等待同一个线程终止,则所有等待线程将一直等到目标线程终止。然后,一个等待线程成功返回。其余的等待线程将失败并返回 ESRCH 错误。

pthread_join() 返回之后,应用程序可回收与已终止线程关联的任何数据存储空间。

pthread_join 返回值

调用成功完成后,pthread_join() 将返回零。其他任何返回值都表示出现了错误。如果检测到以下任一情况,pthread_join() 将失败并返回相应的值。

ESRCH

描述:

没有找到与给定的线程 ID 相对应的线程。

EDEADLK

描述:

将出现死锁,如一个线程等待其本身,或者线程 A 和线程 B 互相等待。

EINVAL

描述:

与给定的线程 ID 相对应的线程是分离线程。

pthread_join() 仅适用于非分离的目标线程。如果没有必要等待特定线程终止之后才进行其他处理,则应当将该线程分离。

简单线程的示例

示例 2–1 中,一个线程执行位于顶部的过程,该过程首先创建一个辅助线程来执行 fetch() 过程。fetch() 执行复杂的数据库查找操作,查找过程需要花费一些时间。

主线程将等待查找结果,但同时还执行其他操作。因此,主线程将执行其他活动,然后通过执行 pthread_join() 等待辅助线程。

将新线程的 pbe 参数作为栈参数进行传递。这个线程参数之所以能够作为栈参数传递,是因为主线程会等待辅助线程终止。不过,首选方法是使用 malloc 从堆分配存储,而不是传递指向线程栈存储的地址。如果将该参数作为地址传递到线程栈存储,则该地址可能无效或者在线程终止时会被重新分配。


示例 2–1 简单线程程序

void mainline (...)

{

        struct phonebookentry *pbe;

        pthread_attr_t tattr;

        pthread_t helper;

        void *status;



        pthread_create(&helper, NULL, fetch, &pbe);



            /* do something else for a while */



        pthread_join(helper, &status);

        /* it's now safe to use result */

}



void *fetch(struct phonebookentry *arg)

{

        struct phonebookentry *npbe;

        /* fetch value from a database */



        npbe = search (prog_name)

            if (npbe != NULL)

                *arg = *npbe;

        pthread_exit(0);

}   



struct phonebookentry {

        char name[64];

        char phonenumber[32];

        char flags[16];

}
 楼主| 发表于 2008-4-24 16:49:38 | 显示全部楼层

分离线程

pthread_detach(3C)pthread_join(3C) 的替代函数,可回收创建时 detachstate 属性设置为 PTHREAD_CREATE_JOINABLE 的线程的存储空间。

pthread_detach 语法

int	pthread_detach(thread_t tid);
#include <pthread.h>



pthread_t tid;

int ret;



/* detach thread tid */

ret = pthread_detach(tid); 

pthread_detach() 函数用于指示应用程序在线程 tid 终止时回收其存储空间。如果 tid 尚未终止,pthread_detach() 不会终止该线程。

pthread_detach 返回值

pthread_detach() 在调用成功完成之后返回零。其他任何返回值都表示出现了错误。如果检测到以下任一情况,pthread_detach() 将失败并返回相应的值。

EINVAL

描述:

tid 是分离线程。

ESRCH

描述:

tid 不是当前进程中有效的未分离的线程。

为线程特定数据创建键

单线程 C 程序有两类基本数据:局部数据和全局数据。对于多线程 C 程序,添加了第三类数据:线程特定数据。线程特定数据与全局数据非常相似,区别在于前者为线程专有。

线程特定数据基于每线程进行维护。TSD(特定于线程的数据)是定义和引用线程专用数据的唯一方法。每个线程特定数据项都与一个作用于进程内所有线程的键关联。通过使用 key,线程可以访问基于每线程进行维护的指针 (void *)。

pthread_key_create 语法

int	pthread_key_create(pthread_key_t *key,

    void (*destructor) (void *));
#include <pthread.h>



pthread_key_t key;

int ret;



/* key create without destructor */

ret = pthread_key_create(&key, NULL);



/* key create with destructor */

ret = pthread_key_create(&key, destructor); 

可以使用 pthread_key_create(3C) 分配用于标识进程中线程特定数据的。键对进程中的所有线程来说是全局的。创建线程特定数据时,所有线程最初都具有与该键关联的 NULL 值。

使用各个键之前,会针对其调用一次 pthread_key_create()。不存在对键(为进程中所有的线程所共享)的隐含同步。

创建键之后,每个线程都会将一个值绑定到该键。这些值特定于线程并且针对每个线程单独维护。如果创建该键时指定了 destructor 函数,则该线程终止时,系统会解除针对每线程的绑定。

pthread_key_create() 成功返回时,会将已分配的键存储在 key 指向的位置中。调用方必须确保对该键的存储和访问进行正确的同步。

使用可选的析构函数 destructor 可以释放过时的存储。如果某个键具有非 NULL destructor 函数,而线程具有一个与该键关联的非 NULL 值,则该线程退出时,系统将使用当前的相关值调用 destructor 函数。destructor 函数的调用顺序不确定。

pthread_key_create 返回值

pthread_key_create() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况,pthread_key_create() 将失败并返回相应的值。

EAGAIN

描述:

key 名称空间已经用完。

ENOMEM

描述:

此进程中虚拟内存不足,无法创建新键。

删除线程特定数据键

使用 pthread_key_delete(3C) 可以销毁现有线程特定数据键。由于键已经无效,因此将释放与该键关联的所有内存。引用无效键将返回错误。Solaris 线程中没有类似的函数。

pthread_key_delete 语法

int	pthread_key_delete(pthread_key_t key);
#include <pthread.h>



pthread_key_t key;

int ret;



/* key previously created */

ret = pthread_key_delete(key); 

如果已删除,则使用调用 pthread_setspecific()pthread_getspecific() 引用该键时,生成的结果将是不确定的。

程序员在调用删除函数之前必须释放所有线程特定资源。删除函数不会调用任何析构函数。反复调用 pthread_key_create()pthread_key_delete() 可能会产生问题。如果 pthread_key_delete() 将键标记为无效,而之后 key 的值不再被重用,那么反复调用它们就会出现问题。对于每个所需的键,应当只调用 pthread_key_create() 一次。

pthread_key_delete 返回值

pthread_key_delete() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下情况,pthread_key_delete() 将失败并返回相应的值。

EINVAL

描述:

key 的值无效。

设置线程特定数据

使用 pthread_setspecific(3C) 可以为指定线程特定数据键设置线程特定绑定。

pthread_setspecific 语法

int	pthread_setspecific(pthread_key_t key, const void *value);
#include <pthread.h>



pthread_key_t key;

void *value;

int ret;



/* key previously created */

ret = pthread_setspecific(key, value); 

pthread_setspecific 返回值

pthread_setspecific() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况,pthread_setspecific() 将失败并返回相应的值。

ENOMEM

描述:

虚拟内存不足。

EINVAL

描述:

key 无效。


注 –

设置新绑定时,pthread_setspecific() 不会释放其存储空间。必须释放现有绑定,否则会出现内存泄漏。


获取线程特定数据

请使用 pthread_getspecific(3C) 获取调用线程的绑定,并将该绑定存储在 value 指向的位置中。

pthread_getspecific 语法

void	*pthread_getspecific(pthread_key_t key);
#include <pthread.h>



pthread_key_t key;

void *value;



/* key previously created */

value = pthread_getspecific(key); 

pthread_getspecific 返回值

pthread_getspecific 不返回任何错误。

全局和专用线程特定数据的示例

示例 2–2 显示的代码是从多线程程序中摘录出来的。这段代码可以由任意数量的线程执行,但该代码引用了两个全局变量:errnomywindow。这些全局值实际上应当是对每个线程专用项的引用。


示例 2–2 线程特定数据-全局但专用

body() {

    ...



    while (write(fd, buffer, size) == -1) {

        if (errno != EINTR) {

            fprintf(mywindow, "%s\n", strerror(errno));

            exit(1);

        }

    }



    ...



}

errno 引用应该从线程所调用的例程获取系统错误,而从其他线程所调用的例程获取系统错误。因此,线程不同,引用 errno 所指向的存储位置也不同。

mywindow 变量指向一个 stdio (标准 IO)流,作为线程专属的流窗口。因此,与 errno 一样,线程不同,引用 mywindow 所指向的存储位置也不同。最终,这个引用指向不同的流窗口。唯一的区别在于系统负责处理 errno,而程序员必须处理对 mywindow 的引用。

下一个示例说明对 mywindow 的引用如何工作。预处理程序会将对 mywindow 的引用转换为对 _mywindow() 过程的调用。

此例程随后调用 pthread_getspecific()pthread_getspecific() 接收 mywindow_key 全局变量作为输入参数,以输出参数 win 返回该线程的窗口。


示例 2–3 将全局引用转化为专用引用

thread_key_t mywin_key;



FILE *_mywindow(void) {

    FILE *win;



    win = pthread_getspecific(mywin_key);

    return(win);

}



#define mywindow _mywindow()



void routine_uses_win( FILE *win) {

    ...

}



void thread_start(...) {

    ...

    make_mywin();

    ...

    routine_uses_win( mywindow )

    ...

}

mywin_key 变量标识一类变量,对于该类变量,每个线程都有其各自的专用副本。这些变量是线程特定数据。每个线程都调用 make_mywin() 以初始化其时限并安排其 mywindow 实例以引用线程特定数据。

调用此例程之后,此线程可以安全地引用 mywindow,调用 _mywindow() 之后,此线程将获得对其专用时限的引用。引用 mywindow 类似于直接引用线程专用数据。

示例 2–4 说明如何设置引用。


示例 2–4 初始化线程特定数据

void make_mywindow(void) {

    FILE **win;

    static pthread_once_t mykeycreated = PTHREAD_ONCE_INIT;



    pthread_once(&mykeycreated, mykeycreate);



    win = malloc(sizeof(*win));

    create_window(win, ...);



    pthread_setspecific(mywindow_key, win);

}



void mykeycreate(void) {

    pthread_key_create(&mywindow_key, free_key);

}



void free_key(void *win) {

    free(win);

}

 楼主| 发表于 2008-4-24 16:50:32 | 显示全部楼层

首先,得到一个唯一的键值,mywin_key。此键用于标识线程特定数据类。第一个调用 make_mywin() 的线程最终会调用 pthread_key_create(),该函数将唯一的 key 赋给其第一个参数。第二个参数是 destructor 函数,用于在线程终止后将该线程的特定于该线程的数据项实例解除分配。

接下来为调用方的线程特定数据项的实例分配存储空间。获取已分配的存储空间,调用 create_window(),以便为该线程设置时限。win 指向为该时限分配的存储空间。最后,调用 pthread_setspecific(),将 win 与该键关联。

以后,每当线程调用 pthread_getspecific() 以传递全局 key,线程都会获得它在前一次调用 pthread_setspecific() 时设置的与该键关联的值)。

线程终止时,会调用在 pthread_key_create() 中设置的 destructor 函数。每个 destructor 函数仅在终止线程通过调用 pthread_setspecific()key 赋值之后才会被调用。

获取线程标识符

请使用 pthread_self(3C) 获取调用线程的 thread identifier

pthread_self 语法

pthread_t	 pthread_self(void);
#include <pthread.h>



pthread_t tid;



tid = pthread_self();

pthread_self 返回值

pthread_self() 返回调用线程的 thread identifier

比较线程 ID

请使用 pthread_equal(3C) 对两个线程的线程标识号进行比较。

pthread_equal 语法

int	 pthread_equal(pthread_t tid1, pthread_t tid2);
#include <pthread.h>



pthread_t tid1, tid2;

int ret;



ret = pthread_equal(tid1, tid2);

pthread_equal 返回值

如果 tid1tid2 相等,pthread_equal() 将返回非零值,否则将返回。如果 tid1tid2 是无效的线程标识号,则结果无法预测。

初始化线程

使用 pthread_once(3C),可以在首次调用 pthread_once 时调用初始化例程。以后调用 pthread_once() 将不起作用。

pthread_once 语法

int	 pthread_once(pthread_once_t *once_control,

    void (*init_routine)(void));
#include <pthread.h>



pthread_once_t once_control = PTHREAD_ONCE_INIT;

int ret;



ret = pthread_once(&once_control, init_routine);

once_control 参数用来确定是否已调用相关的初始化例程。

pthread_once 返回值

pthread_once() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下情况,pthread_once() 将失败并返回相应的值。

EINVAL

描述:

once_controlinit_routineNULL

停止执行线程

使用 sched_yield(3RT),可以使当前线程停止执行,以便执行另一个具有相同或更高优先级的线程。

sched_yield 语法

int	 sched_yield(void);
#include <sched.h>



int ret;



ret = sched_yield();

sched_yield 返回值

sched_yield() 在成功完成之后返回零。否则,返回 -1,并设置 errno 以指示错误状态。

ENOSYS

描述:

本实现不支持 sched_yield

设置线程的优先级

请使用 pthread_setschedparam(3C) 修改现有线程的优先级。此函数对于调度策略不起作用。

pthread_setschedparam 语法

int	 pthread_setschedparam(pthread_t tid, int policy,

    const struct sched_param *param);
#include <pthread.h>



pthread_t tid;

int ret;

struct sched_param param;

int priority;



/* sched_priority will be the priority of the thread */

sched_param.sched_priority = priority;

policy = SCHED_OTHER;



/* scheduling parameters of target thread */

ret = pthread_setschedparam(tid, policy, &param); 

pthread_setschedparam 返回值

pthread_setschedparam() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况,pthread_setschedparam() 函数将失败并返回相应的值。

EINVAL

描述:

所设置属性的值无效。

ENOTSUP

描述:

尝试将该属性设置为不受支持的值。

获取线程的优先级

pthread_getschedparam(3C) 可用来获取现有线程的优先级。

pthread_getschedparam 语法

int	 pthread_getschedparam(pthread_t tid, int policy,

    struct schedparam *param);
#include <pthread.h>



pthread_t tid;

sched_param param;

int priority;

int policy;

int ret;



/* scheduling parameters of target thread */

ret = pthread_getschedparam (tid, &policy, &param);



/* sched_priority contains the priority of the thread */

priority = param.sched_priority; 

pthread_getschedparam 返回值

pthread_getschedparam() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

ESRCH

描述:

tid 指定的值不引用现有的线程。

向线程发送信号

请使用 pthread_kill(3C) 向线程发送信号。

pthread_kill 语法

int	 pthread_kill(thread_t tid, int sig);
#include <pthread.h>

#include <signal.h>



int sig;

pthread_t tid;

int ret;



ret = pthread_kill(tid, sig);

pthread_kill() 将信号 sig 发送到由 tid 指定的线程。tid 所指定的线程必须与调用线程在同一个进程中。sig 参数必须来自 signal(5) 提供的列表。

如果 sig 为零,将执行错误检查,但并不实际发送信号。此错误检查可用来检查 tid 的有效性。

pthread_kill 返回值

pthread_kill() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况,pthread_kill() 将失败并返回相应的值。

EINVAL

描述:

sig 是无效的信号量。

ESRCH

描述:

当前的进程中找不到 tid

访问调用线程的信号掩码

请使用 pthread_sigmask(3C) 更改或检查调用线程的信号掩码。

pthread_sigmask 语法

int	pthread_sigmask(int how, const sigset_t *new, sigset_t *old);
#include <pthread.h>

#include <signal.h>



int ret;

sigset_t old, new;



ret = pthread_sigmask(SIG_SETMASK, &new, &old); /* set new mask */

ret = pthread_sigmask(SIG_BLOCK, &new, &old); /* blocking mask */

ret = pthread_sigmask(SIG_UNBLOCK, &new, &old); /* unblocking */

how 用来确定如何更改信号组。how 可以为以下值之一:

  • SIG_BLOCK。向当前的信号掩码中添加 new,其中 new 表示要阻塞的信号组。

  • SIG_UNBLOCK。从当前的信号掩码中删除 new,其中 new 表示要取消阻塞的信号组。

  • SIG_SETMASK。将当前的信号掩码替换为 new,其中 new 表示新的信号掩码。

new 的值为 NULL 时,how 的值没有意义,线程的信号掩码不发生变化。要查询当前已阻塞的信号,请将 NULL 值赋给 new 参数。

除非 old 变量为 NULL,否则 old 指向用来存储以前的信号掩码的空间。

pthread_sigmask 返回值

pthread_sigmask() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下情况,pthread_sigmask() 将失败并返回相应的值。

EINVAL

描述:

未定义 how 的值。

安全地 Fork

请参见解决方案: pthread_atfork中有关 pthread_atfork(3C) 的论述。

pthread_atfork 语法

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

    void (*child) (void) );

pthread_atfork 返回值

pthread_atfork() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下情况,pthread_atfork() 将失败并返回相应的值。

ENOMEM

描述:

表空间不足,无法记录 Fork 处理程序地址。

终止线程

请使用 pthread_exit(3C) 终止线程。

pthread_exit 语法

void	 pthread_exit(void *status);
#include <pthread.h>



void *status;



pthread_exit(status); /* exit with status */

pthread_exit() 函数可用来终止调用线程。将释放所有线程特定数据绑定。如果调用线程尚未分离,则线程 ID 和 status 指定的退出状态将保持不变,直到应用程序调用 pthread_join() 以等待该线程。否则,将忽略 status。线程 ID 可以立即回收。有关线程分离的信息,请参见设置分离状态

pthread_exit 返回值

调用线程将终止,退出状态设置为 status 的内容。

结束

线程可通过以下方法来终止执行:

  • 从线程的第一个(最外面的)过程返回,使线程启动例程。请参见 pthread_create

  • 调用 pthread_exit(),提供退出状态。

  • 使用 POSIX 取消函数执行终止操作。请参见 pthread_cancel()

线程的缺省行为是拖延,直到其他线程通过 "joining" 拖延线程确认其已死亡。此行为与非分离的缺省 pthread_create() 属性相同,请参见 pthread_detach。join 的结果是 joining 线程得到已终止线程的退出状态,已终止的线程将消失。

有一个重要的特殊情况,即当初始线程(即调用 main() 的线程)从 main() 调用返回时或调用 exit() 时,整个进程及其所有的线程将终止。因此,一定要确保初始线程不会从 main() 过早地返回。

请注意,如果主线程仅仅调用了 pthread_exit,则仅主线程本身终止。进程及进程内的其他线程将继续存在。所有线程都已终止时,进程也将终止。

取消线程

取消操作允许线程请求终止其所在进程中的任何其他线程。不希望或不需要对一组相关的线程执行进一步操作时,可以选择执行取消操作。

取消线程的一个示例是异步生成取消条件,例如,用户请求关闭或退出正在运行的应用程序。另一个示例是完成由许多线程执行的任务。其中的某个线程可能最终完成了该任务,而其他线程还在继续运行。由于正在运行的线程此时没有任何用处,因此应当取消这些线程。

 楼主| 发表于 2008-4-24 16:51:04 | 显示全部楼层

取消点

仅当取消操作安全时才应取消线程。pthreads 标准指定了几个取消点,其中包括:

  • 通过 pthread_testcancel 调用以编程方式建立线程取消点。

  • 线程等待 pthread_cond_waitpthread_cond_timedwait(3C) 中的特定条件出现。

  • sigwait(2) 阻塞的线程。

  • 一些标准的库调用。通常,这些调用包括线程可基于其阻塞的函数。有关列表,请参见 cancellation(5) 手册页。

缺省情况下将启用取消功能。有时,您可能希望应用程序禁用取消功能。如果禁用取消功能,则会导致延迟所有的取消请求,直到再次启用取消请求。

有关禁用取消功能的信息,请参见pthread_setcancelstate 语法

放置取消点

执行取消操作存在一定的危险。大多数危险都与完全恢复不变量和释放共享资源有关。取消线程时一定要格外小心,否则可能会使互斥保留为锁定状态,从而导致死锁。或者,已取消的线程可能保留已分配的内存区域,但是系统无法识别这一部分内存,从而无法释放它。

标准 C 库指定了一个取消接口用于以编程方式允许或禁止取消功能。该库定义的取消点是一组可能会执行取消操作的点。该库还允许定义取消处理程序的范围,以确保这些处理程序在预期的时间和位置运行。取消处理程序提供的清理服务可以将资源和状态恢复到与起点一致的状态。

必须对应用程序有一定的了解,才能放置取消点并执行取消处理程序。互斥肯定不是取消点,只应当在必要时使之保留尽可能短的时间。

请将异步取消区域限制在没有外部依赖性的序列,因为外部依赖性可能会产生挂起的资源或未解决的状态条件。在从某个备用的嵌套取消状态返回时,一定要小心地恢复取消状态。该接口提供便于进行恢复的功能:pthread_setcancelstate(3C) 在所引用的变量中保留当前的取消状态,pthread_setcanceltype(3C) 以同样的方式保留当前的取消类型。

在以下三种不同的情况下可能会执行取消操作:

  • 异步

  • 执行序列中按标准定义的各个点

  • 调用 pthread_testcancel()

缺省情况下,仅在 POSIX 标准可靠定义的点执行取消操作。

无论何时,都应注意资源和状态恢已复到与起点一致的状态。

取消线程

请使用 pthread_cancel(3C) 取消线程。

pthread_cancel 语法

int	pthread_cancel(pthread_t thread);
#include <pthread.h>



pthread_t thread;

int ret;



ret = pthread_cancel(thread);

取消请求的处理方式取决于目标线程的状态。状态由以下两个函数确定:pthread_setcancelstate(3C)pthread_setcanceltype(3C)

pthread_cancel 返回值

pthread_cancel() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

ESRCH

描述:

没有找到与给定线程 ID 相对应的线程。

启用或禁用取消功能

请使用 pthread_setcancelstate(3C) 启用或禁用线程取消功能。创建线程时,缺省情况下线程取消功能处于启用状态。

pthread_setcancelstate 语法

int	pthread_setcancelstate(int state, int *oldstate);
#include <pthread.h>



int oldstate;

int ret;



/* enabled */

ret = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);



/* disabled */

ret = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);

pthread_setcancelstate 返回值

pthread_setcancelstate() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下情况,pthread_setcancelstate() 函数将失败并返回相应的值。

EINVAL

描述:

状态不是 PTHREAD_CANCEL_ENABLEPTHREAD_CANCEL_DISABLE

设置取消类型

使用 pthread_setcanceltype(3C) 可以将取消类型设置为延迟或异步模式。

pthread_setcanceltype 语法

int	pthread_setcanceltype(int type, int *oldtype);
#include <pthread.h>



int oldtype;

int ret;



/* deferred mode */

ret = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype);



/* async mode*/

ret = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);

创建线程时,缺省情况下会将取消类型设置为延迟模式。在延迟模式下,只能在取消点取消线程。在异步模式下,可以在执行过程中的任意一点取消线程。因此建议不使用异步模式。

pthread_setcanceltype 返回值

pthread_setcanceltype() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

类型不是 PTHREAD_CANCEL_DEFERREDPTHREAD_CANCEL_ASYNCHRONOUS

创建取消点

请使用 pthread_testcancel(3C) 为线程建立取消点。

pthread_testcancel 语法

void pthread_testcancel(void);
#include <pthread.h>



pthread_testcancel(); 

当线程取消功能处于启用状态且取消类型设置为延迟模式时,pthread_testcancel() 函数有效。如果在取消功能处于禁用状态下调用 pthread_testcancel(),则该函数不起作用。

请务必仅在线程取消操作安全的序列中插入 pthread_testcancel()。除通过 pthread_testcancel() 调用以编程方式建立的取消点以外,pthread 标准还指定了几个取消点。有关更多详细信息,请参见取消点

pthread_testcancel 返回值

pthread_testcancel() 没有返回值。

将处理程序推送到栈上

使用清理处理程序,可以将状态恢复到与起点一致的状态,其中包括清理已分配的资源和恢复不变量。使用 pthread_cleanup_push(3C)pthread_cleanup_pop(3C) 函数可以管理清理处理程序。

在程序的同一词法域中可以推送和弹出清理处理程序。推送和弹出操作应当始终匹配,否则会生成编译器错误。

pthread_cleanup_push 语法

请使用 pthread_cleanup_push(3C) 将清理处理程序推送到清理栈 (LIFO)。

void pthread_cleanup_push(void(*routine)(void *), void *args);
#include <pthread.h>



/* push the handler "routine" on cleanup stack */

pthread_cleanup_push (routine, arg); 

pthread_cleanup_push 返回值

pthread_cleanup_push() 没有返回值。

从栈中弹出处理程序

请使用 pthread_cleanup_pop(3C) 从清理栈中弹出清理处理程序。

pthread_cleanup_pop 语法

void pthread_cleanup_pop(int execute);
#include <pthread.h>



/* pop the "func" out of cleanup stack and execute "func" */

pthread_cleanup_pop (1);



/* pop the "func" and DONT execute "func" */

pthread_cleanup_pop (0); 

如果弹出函数中的参数为非零值,则会从栈中删除该处理程序并执行该处理程序。如果该参数为零,则会弹出该处理程序,而不执行它。

线程显式或隐式调用 pthread_exit(3C) 时,或线程接受取消请求时,会使用非零参数有效地调用 pthread_cleanup_pop()

pthread_cleanup_pop 返回值

pthread_cleanup_pop() 没有返回值。

 楼主| 发表于 2008-4-24 16:51:53 | 显示全部楼层

第 3 章 线程属性

前面一章介绍了使用缺省属性创建线程的基本原理。本章论述如何在创建线程时设置属性。


注 –

只有 pthreads 使用属性和取消功能。本章中介绍的 API 仅适用于 POSIX 线程。除此之外,Solaris 线程和 pthreads功能大致是相同的。有关相似和不同之处的更多信息,请参见第 8 章,Solaris 线程编程


属性对象

通过设置属性,可以指定一种不同于缺省行为的行为。使用 pthread_create(3C) 创建线程时,或初始化同步变量时,可以指定属性对象。缺省值通常就足够了。

属性对象是不透明的,而且不能通过赋值直接进行修改。系统提供了一组函数,用于初始化、配置和销毁每种对象类型。

初始化和配置属性后,属性便具有进程范围的作用域。使用属性时最好的方法即是在程序执行早期一次配置好所有必需的状态规范。然后,根据需要引用相应的属性对象。

使用属性对象具有两个主要优点。

  • 使用属性对象可增加代码可移植性。

    即使支持的属性可能会在实现之间有所变化,但您不需要修改用于创建线程实体的函数调用。这些函数调用不需要进行修改,因为属性对象是隐藏在接口之后的。

    如果目标系统支持的属性在当前系统中不存在,则必须显式提供才能管理新的属性。管理这些属性是一项非常容易的移植任务,因为只需在明确定义的位置初始化属性对象一次即可。

  • 应用程序中的状态规范已被简化。

    例如,假设进程中可能存在多组线程。每组线程都提供单独的服务。每组线程都有各自的状态要求。

    在应用程序执行初期的某一时间,可以针对每组线程初始化线程属性对象。以后所有线程的创建都会引用已经为这类线程初始化的属性对象。初始化阶段是简单和局部的。将来就可以快速且可靠地进行任何修改。

在进程退出时需要注意属性对象。初始化对象时,将为该对象分配内存。必须将此内存返回给系统。pthreads 标准提供了用于销毁属性对象的函数调用。

初始化属性

请使用 pthread_attr_init(3C) 将对象属性初始化为其缺省值。存储空间是在执行期间由线程系统分配的。

pthread_attr_init 语法

int pthread_attr_init(pthread_attr_t *tattr);
#include <pthread.h>



pthread_attr_t tattr;

int ret;



/* initialize an attribute to the default value */

ret = pthread_attr_init(&tattr);

表 3–1 给出了属性 (tattr) 的缺省值。

表 3–1 tattr 的缺省属性值

属性

结果

scope

PTHREAD_SCOPE_PROCESS

新线程与进程中的其他线程发生竞争。

detachstate

PTHREAD_CREATE_JOINABLE

线程退出后,保留完成状态和线程 ID

stackaddr

NULL

新线程具有系统分配的栈地址。

stacksize

0

新线程具有系统定义的栈大小。

priority

0

新线程的优先级为 0。

inheritsched

PTHREAD_EXPLICIT_SCHED

新线程不继承父线程调度优先级。

schedpolicy

SCHED_OTHER

新线程对同步对象争用使用 Solaris 定义的固定优先级。线程将一直运行,直到被抢占或者直到线程阻塞或停止为止。

pthread_attr_init 返回值

pthread_attr_init() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

ENOMEM

描述:

如果未分配足够的内存来初始化线程属性对象,将返回该值。

销毁属性

请使用 pthread_attr_destroy(3C) 删除初始化期间分配的存储空间。属性对象将会无效。

pthread_attr_destroy 语法

int	pthread_attr_destroy(pthread_attr_t *tattr);
#include <pthread.h>



pthread_attr_t tattr;

int ret;



/* destroy an attribute */

ret = pthread_attr_destroy(&tattr); 

pthread_attr_destroy 返回值

pthread_attr_destroy() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

指示 tattr 的值无效。

设置分离状态

如果创建分离线程 (PTHREAD_CREATE_DETACHED),则该线程一退出,便可重用其线程 ID 和其他资源。如果调用线程不准备等待线程退出,请使用 pthread_attr_setdetachstate(3C)

pthread_attr_setdetachstate(3C) 语法

int	pthread_attr_setdetachstate(pthread_attr_t *tattr,int detachstate);
#include <pthread.h>



pthread_attr_t tattr;

int ret;



/* set the thread detach state */

ret = pthread_attr_setdetachstate(&tattr,PTHREAD_CREATE_DETACHED);

如果使用 PTHREAD_CREATE_JOINABLE 创建非分离线程,则假设应用程序将等待线程完成。也就是说,程序将对线程执行 pthread_join()

无论是创建分离线程还是非分离线程,在所有线程都退出之前,进程不会退出。有关从 main() 提前退出而导致的进程终止的讨论,请参见结束


注 –

如果未执行显式同步来防止新创建的分离线程失败,则在线程创建者从 pthread_create() 返回之前,可以将其线程 ID 重新分配给另一个新线程。


非分离线程在终止后,必须要有一个线程用 join 来等待它。否则,不会释放该线程的资源以供新线程使用,而这通常会导致内存泄漏。因此,如果不希望线程被等待,请将该线程作为分离线程来创建。


示例 3–1 创建分离线程

#include <pthread.h>



pthread_attr_t tattr;

pthread_t tid;

void *start_routine;

void arg

int ret;



/* initialized with default attributes */

ret = pthread_attr_init (&tattr);

ret = pthread_attr_setdetachstate (&tattr,PTHREAD_CREATE_DETACHED);

ret = pthread_create (&tid, &tattr, start_routine, arg);
	

pthread_attr_setdetachstate 返回值

pthread_attr_setdetachstate() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

指示 detachstatetattr 的值无效。

获取分离状态

请使用 pthread_attr_getdetachstate(3C) 检索线程创建状态(可以为分离或连接)。

pthread_attr_getdetachstate 语法

int	pthread_attr_getdetachstate(const pthread_attr_t *tattr,

    int *detachstate;
#include <pthread.h>



pthread_attr_t tattr;

int detachstate;

int ret;



/* get detachstate of thread */

ret = pthread_attr_getdetachstate (&tattr, &detachstate);

pthread_attr_getdetachstate 返回值

pthread_attr_getdetachstate() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

指示 detachstate 的值为 NULLtattr 无效。

设置栈溢出保护区大小

pthread_attr_setguardsize(3C) 可以设置 attr 对象的 guardsize

pthread_attr_setguardsize(3C) 语法

#include <pthread.h>



int pthread_attr_setguardsize(pthread_attr_t *attr, size_t  guardsize);

出于以下两个原因,为应用程序提供了 guardsize 属性:

  • 溢出保护可能会导致系统资源浪费。如果应用程序创建大量线程,并且已知这些线程永远不会溢出其栈,则可以关闭溢出保护区。通过关闭溢出保护区,可以节省系统资源。

  • 线程在栈上分配大型数据结构时,可能需要较大的溢出保护区来检测栈溢出。

guardsize 参数提供了对栈指针溢出的保护。如果创建线程的栈时使用了保护功能,则实现会在栈的溢出端分配额外内存。此额外内存的作用与缓冲区一样,可以防止栈指针的栈溢出。如果应用程序溢出到此缓冲区中,这个错误可能会导致 SIGSEGV 信号被发送给该线程。

如果 guardsize 为零,则不会为使用 attr 创建的线程提供溢出保护区。如果 guardsize 大于零,则会为每个使用 attr 创建的线程提供大小至少为 guardsize 字节的溢出保护区。缺省情况下,线程具有实现定义的非零溢出保护区。

允许合乎惯例的实现,将 guardsize 的值向上舍入为可配置的系统变量 PAGESIZE 的倍数。请参见 sys/mman.h 中的 PAGESIZE。如果实现将 guardsize 的值向上舍入为 PAGESIZE 的倍数,则以 guardsize(先前调用 pthread_attr_setguardsize() 时指定的溢出保护区大小)为单位存储对指定 attrpthread_attr_getguardsize() 的调用。

pthread_attr_setguardsize 返回值

如果出现以下情况,pthread_attr_setguardsize() 将失败:

EINVAL

描述:

参数 attr 无效,参数 guardsize 无效,或参数 guardsize 包含无效值。

获取栈溢出保护区大小

pthread_attr_getguardsize(3C) 可以获取 attr 对象的 guardsize

pthread_attr_getguardsize 语法

#include <pthread.h>



int pthread_attr_getguardsize(const pthread_attr_t *attr, 

										size_t  *guardsize);

允许一致的实现将 guardsize 中包含的值向上舍入为可配置系统变量 PAGESIZE 的倍数。请参见 sys/mman.h 中的 PAGESIZE。如果实现将 guardsize 的值向上舍入为 PAGESIZE 的倍数,则以 guardsize(先前调用 pthread_attr_setguardsize() 时指定的溢出保护区大小)为单位存储对指定 attrpthread_attr_getguardsize() 的调用。

pthread_attr_getguardsize 返回值

如果出现以下情况,pthread_attr_getguardsize() 将失败:

EINVAL

描述:

参数 attr 无效,参数 guardsize 无效,或参数 guardsize 包含无效值。

设置范围

请使用 pthread_attr_setscope(3C) 建立线程的争用范围(PTHREAD_SCOPE_SYSTEMPTHREAD_SCOPE_PROCESS)。 使用 PTHREAD_SCOPE_SYSTEM 时,此线程将与系统中的所有线程进行竞争。使用 PTHREAD_SCOPE_PROCESS 时,此线程将与进程中的其他线程进行竞争。


注 –

只有在给定进程中才能访问这两种线程类型。

 楼主| 发表于 2008-4-24 16:52:27 | 显示全部楼层

pthread_attr_setscope 语法

int	pthread_attr_setscope(pthread_attr_t *tattr,int scope);
#include <pthread.h>



pthread_attr_t tattr;

int ret;



/* bound thread */

ret = pthread_attr_setscope(&tattr, PTHREAD_SCOPE_SYSTEM);



/* unbound thread */

ret = pthread_attr_setscope(&tattr, PTHREAD_SCOPE_PROCESS);

本示例使用三个函数调用:用于初始化属性的调用、用于根据缺省属性设置所有变体的调用,以及用于创建 pthreads 的调用。

#include <pthread.h>



pthread_attr_t attr;

pthread_t tid;

void start_routine;

void arg;

int ret;



/* initialized with default attributes */

ret = pthread_attr_init (&tattr);



/* BOUND behavior */

ret =  pthread_attr_setscope(&tattr, PTHREAD_SCOPE_SYSTEM);

ret = pthread_create (&tid, &tattr, start_routine, arg);

pthread_attr_setscope 返回值

pthread_attr_setscope() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

尝试将 tattr 设置为无效的值。

获取范围

请使用 pthread_attr_getscope(3C) 检索线程范围。

pthread_attr_getscope 语法

int	pthread_attr_getscope(pthread_attr_t *tattr, int *scope);
#include <pthread.h>



pthread_attr_t tattr;

int scope;

int ret;



/* get scope of thread */

ret = pthread_attr_getscope(&tattr, &scope);

pthread_attr_getscope 返回值

pthread_attr_getscope() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

scope 的值为 NULLtattr 无效。

设置线程并行级别

针对标准符合性提供了 pthread_setconcurrency(3C)。应用程序使用 pthread_setconcurrency() 通知系统其所需的并发级别。对于 Solaris 9 发行版中引入的线程实现,此接口没有任何作用,所有可运行的线程都将被连接到 LWP。

pthread_setconcurrency 语法

#include <pthread.h>



int pthread_setconcurrency(int new_level);

pthread_setconcurrency 返回值

如果出现以下情况,pthread_setconcurrency() 将失败:

EINVAL

描述:

new_level 指定的值为负数。

EAGAIN

描述:

new_level 指定的值将导致系统资源不足。

获取线程并行级别

pthread_getconcurrency(3C) 返回先前调用 pthread_setconcurrency() 时设置的值。

pthread_getconcurrency 语法

#include <pthread.h>



int pthread_getconcurrency(void);

如果以前未调用 pthread_setconcurrency() 函数,则 pthread_getconcurrency() 将返回零。

pthread_getconcurrency 返回值

pthread_getconcurrency() 始终会返回先前调用 pthread_setconcurrency() 时设置的并发级别。如果从未调用 pthread_setconcurrency(),则 pthread_getconcurrency() 将返回零。

设置调度策略

请使用 pthread_attr_setschedpolicy(3C) 设置调度策略。POSIX 标准指定 SCHED_FIFO(先入先出)、SCHED_RR(循环)或 SCHED_OTHER(实现定义的方法)的调度策略属性。

pthread_attr_setschedpolicy(3C) 语法

int	pthread_attr_setschedpolicy(pthread_attr_t *tattr, int policy);
#include <pthread.h>



pthread_attr_t tattr;

int policy;

int ret;



/* set the scheduling policy to SCHED_OTHER */

ret = pthread_attr_setschedpolicy(&tattr, SCHED_OTHER);
  • SCHED_FIFO

    如果调用进程具有有效的用户 ID 0,则争用范围为系统 (PTHREAD_SCOPE_SYSTEM) 的先入先出线程属于实时 (RT) 调度类。如果这些线程未被优先级更高的线程抢占,则会继续处理该线程,直到该线程放弃或阻塞为止。对于具有进程争用范围 (PTHREAD_SCOPE_PROCESS)) 的线程或其调用进程没有有效用户 ID 0 的线程,请使用 SCHED_FIFOSCHED_FIFO 基于 TS 调度类。

  • SCHED_RR

    如果调用进程具有有效的用户 ID 0,则争用范围为系统 (PTHREAD_SCOPE_SYSTEM)) 的循环线程属于实时 (RT) 调度类。如果这些线程未被优先级更高的线程抢占,并且这些线程没有放弃或阻塞,则在系统确定的时间段内将一直执行这些线程。对于具有进程争用范围 (PTHREAD_SCOPE_PROCESS) 的线程,请使用 SCHED_RR(基于 TS 调度类)。此外,这些线程的调用进程没有有效的用户 ID 0

SCHED_FIFOSCHED_RR 在 POSIX 标准中是可选的,而且仅用于实时线程。

有关调度的论述,请参见线程调度一节。

pthread_attr_setschedpolicy 返回值

pthread_attr_setschedpolicy() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况,该函数将失败并返回对应的值。

EINVAL

描述:

尝试将 tattr 设置为无效的值。

ENOTSUP

描述:

尝试将该属性设置为不受支持的值。

获取调度策略

请使用 pthread_attr_getschedpolicy(3C) 检索调度策略。

pthread_attr_getschedpolicy 语法

int	pthread_attr_getschedpolicy(pthread_attr_t *tattr, int *policy);
#include <pthread.h>



pthread_attr_t tattr;

int policy;

int ret;



/* get scheduling policy of thread */

ret = pthread_attr_getschedpolicy (&tattr, &policy); 

pthread_attr_getschedpolicy 返回值

pthread_attr_getschedpolicy() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

参数 policyNULLtattr 无效。

设置继承的调度策略

请使用 pthread_attr_setinheritsched(3C) 设置继承的调度策略。

pthread_attr_setinheritsched 语法

int	pthread_attr_setinheritsched(pthread_attr_t *tattr, int inherit);
#include <pthread.h>



pthread_attr_t tattr;

int inherit;

int ret;



/* use the current scheduling policy */

ret = pthread_attr_setinheritsched(&tattr, PTHREAD_EXPLICIT_SCHED);

inheritPTHREAD_INHERIT_SCHED 表示新建的线程将继承创建者线程中定义的调度策略。将忽略在 pthread_create() 调用中定义的所有调度属性。如果使用缺省值 PTHREAD_EXPLICIT_SCHED,则将使用 pthread_create() 调用中的属性。

pthread_attr_setinheritsched 返回值

pthread_attr_setinheritsched() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况,该函数将失败并返回对应的值。

EINVAL

描述:

尝试将 tattr 设置为无效的值。

ENOTSUP

描述:

尝试将属性设置为不受支持的值。

获取继承的调度策略

pthread_attr_getinheritsched(3C) 将返回由 pthread_attr_setinheritsched() 设置的调度策略。

pthread_attr_getinheritsched 语法

int	pthread_attr_getinheritsched(pthread_attr_t *tattr, int *inherit);
#include <pthread.h>



pthread_attr_t tattr;

int inherit;

int ret;



/* get scheduling policy and priority of the creating thread */

ret = pthread_attr_getinheritsched (&tattr, &inherit); 

pthread_attr_getinheritsched 返回值

pthread_attr_getinheritsched() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

参数 inheritNULLtattr 无效。

设置调度参数

pthread_attr_setschedparam(3C) 可以设置调度参数。

pthread_attr_setschedparam 语法

int	pthread_attr_setschedparam(pthread_attr_t *tattr,

    const struct sched_param *param);
#include <pthread.h>



pthread_attr_t tattr;

int newprio;

sched_param param;

newprio = 30;



/* set the priority; others are unchanged */

param.sched_priority = newprio;



/* set the new scheduling param */

ret = pthread_attr_setschedparam (&tattr, &param); 

调度参数是在 param 结构中定义的。仅支持优先级参数。新创建的线程使用此优先级运行。

pthread_attr_setschedparam 返回值

pthread_attr_setschedparam() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

param 的值为 NULLtattr 无效。

可以采用两种方式之一来管理 pthreads 优先级:

  • 创建子线程之前,可以设置优先级属性

  • 可以更改父线程的优先级,然后再将该优先级改回来

获取调度参数

pthread_attr_getschedparam(3C) 将返回由 pthread_attr_setschedparam() 定义的调度参数。

pthread_attr_getschedparam 语法

int	pthread_attr_getschedparam(pthread_attr_t *tattr,

    const struct sched_param *param);
#include <pthread.h>



pthread_attr_t attr;

struct sched_param param;

int ret;



/* get the existing scheduling param */

ret = pthread_attr_getschedparam (&tattr, &param);

使用指定的优先级创建线程

创建线程之前,可以设置优先级属性。将使用在 sched_param 结构中指定的新优先级创建子线程。此结构还包含其他调度信息。

创建子线程时建议执行以下操作:

  • 获取现有参数

  • 更改优先级

  • 创建子线程

  • 恢复原始优先级

创建具有优先级的线程的示例

示例 3–2 给出了使用不同于其父线程优先级的优先级创建子线程的示例。

 楼主| 发表于 2008-4-24 16:53:18 | 显示全部楼层
示例 3–2 创建具有优先级的线程

#include <pthread.h>

#include <sched.h>



pthread_attr_t tattr;

pthread_t tid;

int ret;

int newprio = 20;

sched_param param;



/* initialized with default attributes */

ret = pthread_attr_init (&tattr);



/* safe to get existing scheduling param */

ret = pthread_attr_getschedparam (&tattr, &param);



/* set the priority; others are unchanged */

param.sched_priority = newprio;



/* setting the new scheduling param */

ret = pthread_attr_setschedparam (&tattr, &param);



/* with new priority specified */

ret = pthread_create (&tid, &tattr, func, arg); 

pthread_attr_getschedparam 返回值

pthread_attr_getschedparam() 成功完成后将返回零。其他任何返回值都表示出现了错误。 如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

param 的值为 NULLtattr 无效。

设置栈大小

pthread_attr_setstacksize(3C) 可以设置线程栈大小。

pthread_attr_setstacksize 语法

int	pthread_attr_setstacksize(pthread_attr_t *tattr,

                               size_t size);
#include <pthread.h>



pthread_attr_t tattr;

size_t size;

int ret;



size = (PTHREAD_STACK_MIN + 0x4000);



/* setting a new size */

ret = pthread_attr_setstacksize(&tattr, size);

stacksize 属性定义系统分配的栈大小(以字节为单位)。size 不应小于系统定义的最小栈大小。有关更多信息,请参见关于栈

size 包含新线程使用的栈的字节数。如果 size 为零,则使用缺省大小。在大多数情况下,零值最适合。

PTHREAD_STACK_MIN 是启动线程所需的栈空间量。此栈空间没有考虑执行应用程序代码所需的线程例程要求。

pthread_attr_setstacksize 返回值

pthread_attr_setstacksize() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

size 值小于 PTHREAD_STACK_MIN,或超出了系统强加的限制,或者 tattr 无效。

获取栈大小

pthread_attr_getstacksize(3C) 将返回由 pthread_attr_setstacksize() 设置的栈大小。

pthread_attr_getstacksize 语法

int	pthread_attr_getstacksize(pthread_attr_t *tattr, 

                               size_t *size);
#include <pthread.h>



pthread_attr_t tattr;

size_t size;

int ret;



/* getting the stack size */

ret = pthread_attr_getstacksize(&tattr, &size);

pthread_attr_getstacksize 返回值

pthread_attr_getstacksize() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

tattr 无效。

关于栈

通常,线程栈是从页边界开始的。任何指定的大小都被向上舍入到下一个页边界。不具备访问权限的页将被附加到栈的溢出端。大多数栈溢出都会导致将 SIGSEGV 信号发送到违例线程。将直接使用调用方分配的线程栈,而不进行修改。

指定栈时,还应使用 PTHREAD_CREATE_JOINABLE 创建线程。在该线程的 pthread_join(3C) 调用返回之前,不会释放该栈。在该线程终止之前,不会释放该线程的栈。了解这类线程是否已终止的唯一可靠方式是使用 pthread_join(3C)

为线程分配栈空间

一般情况下,不需要为线程分配栈空间。系统会为每个线程的栈分配 1 MB(对于 32 位系统)或 2 MB(对于 64 位系统)的虚拟内存,而不保留任何交换空间。系统将使用 mmap()MAP_NORESERVE 选项来进行分配。

系统创建的每个线程栈都具有红色区域。系统通过将页附加到栈的溢出端来创建红色区域,从而捕获栈溢出。此类页无效,而且会导致内存(访问时)故障。红色区域将被附加到所有自动分配的栈,无论大小是由应用程序指定,还是使用缺省大小。


注 –

对于库调用和动态链接,运行时栈要求有所变化。应绝对确定,指定的栈满足库调用和动态链接的运行时要求。


极少数情况下需要指定栈和/或栈大小。甚至专家也很难了解是否指定了正确的大小。甚至符合 ABI 标准的程序也不能静态确定其栈大小。栈大小取决于执行中特定运行时环境的需要。

生成自己的栈

指定线程栈大小时,必须考虑被调用函数以及每个要调用的后续函数的分配需求。需要考虑的因素应包括调用序列需求、局部变量和信息结构。

有时,您需要与缺省栈略有不同的栈。典型的情况是,线程需要的栈大小大于缺省栈大小。而不太典型的情况是,缺省大小太大。您可能正在使用不足的虚拟内存创建数千个线程,进而处理数千个缺省线程栈所需的数千兆字节的栈空间。

对栈的最大大小的限制通常较为明显,但对其最小大小的限制如何呢?必须存在足够的栈空间来处理推入栈的所有栈帧,及其局部变量等。

要获取对栈大小的绝对最小限制,请调用宏 PTHREAD_STACK_MINPTHREAD_STACK_MIN 宏将针对执行 NULL 过程的线程返回所需的栈空间量。有用的线程所需的栈大小大于最小栈大小,因此缩小栈大小时应非常谨慎。

#include <pthread.h>



pthread_attr_t tattr;

pthread_t tid;

int ret;



size_t size = PTHREAD_STACK_MIN + 0x4000;



/* initialized with default attributes */

ret = pthread_attr_init(&tattr);



/* setting the size of the stack also */

ret = pthread_attr_setstacksize(&tattr, size);



/* only size specified in tattr*/

ret = pthread_create(&tid, &tattr, start_routine, arg); 

设置栈地址和大小

pthread_attr_setstack(3C) 可以设置线程栈地址和大小。

pthread_attr_setstack(3C) 语法

int	pthread_attr_setstack(pthread_attr_t *tattr,void *stackaddr,

                           size_t stacksize);
#include <pthread.h>



pthread_attr_t tattr;

void *base;

size_t size;

int ret;



base = (void *) malloc(PTHREAD_STACK_MIN + 0x4000);



/* setting a new address and size */

ret = pthread_attr_setstack(&tattr, base,PTHREAD_STACK_MIN + 0x4000);

stackaddr 属性定义线程栈的基准(低位地址)。stacksize 属性指定栈的大小。如果将 stackaddr 设置为非空值,而不是缺省的 NULL,则系统将在该地址初始化栈,假设大小为 stacksize

base 包含新线程使用的栈的地址。如果 baseNULL,则 pthread_create(3C) 将为大小至少为 stacksize 字节的新线程分配栈。

pthread_attr_setstack(3C) 返回值

pthread_attr_setstack() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

basetattr 的值不正确。stacksize 的值小于 PTHREAD_STACK_MIN

以下示例说明如何使用自定义栈地址和大小来创建线程。

#include <pthread.h>



pthread_attr_t tattr;

pthread_t tid;

int ret;

void *stackbase;

size_t size;



/* initialized with default attributes */

ret = pthread_attr_init(&tattr);



/* setting the base address and size of the stack */

ret = pthread_attr_setstack(&tattr, stackbase,size);



/* address and size specified */

ret = pthread_create(&tid, &tattr, func, arg);

获取栈地址和大小

pthread_attr_getstack(3C) 将返回由 pthread_attr_setstack() 设置的线程栈地址和大小。

pthread_attr_getstack 语法

int	pthread_attr_getstack(pthread_attr_t *tattr,void * *stackaddr,

                           size_t *stacksize);
#include <pthread.h>



pthread_attr_t tattr;

void *base;

size_t size;

int ret;



/* getting a stack address and size */

ret = pthread_attr_getstackaddr (&tattr, &base, &size); 

pthread_attr_getstack 返回值

pthread_attr_getstackaddr() 成功完成后将返回零。其他任何返回值都表示出现了错误。如果出现以下情况,该函数将失败并返回对应的值。

EINVAL

描述:

tattr 的值不正确。

 楼主| 发表于 2008-4-24 16:56:04 | 显示全部楼层

后面的内容,不想转贴了...大家去原网站看吧!

http://docs.sun.com/app/docs/doc/819-7051/sync-83092?l=zh&q=dtrace&a=view

发表于 2009-4-18 16:38:12 | 显示全部楼层
这两天才开始接触多线程
但是不是用鼯鼠的方法
我查MSDN 它提高了一个貌似更简单安全的方法--AfxBeginThread

如果愿意,可以在应用程序中创建其他线程。如果在处理后台任务或维护任务时不希望用户等待这些任务完成,则可能需要创建其他线程。MFC 应用程序中的所有线程都由 CWinThread 对象表示。大多数情况下,甚至不必显式创建这些对象,而只需调用框架 Helper 函数 AfxBeginThread,该函数将为您创建 CWinThread 对象。

而加锁的方法是用CRITICAL_SECTION的对象cs
EnterCriticalSection(&cs); 和 LeaveCriticalSection(&cs);

当然你要初始化和记得销毁cs
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|3D数字艺术论坛 ( 沪ICP备14023054号 )

GMT+8, 2025-5-14 12:01

Powered by Discuz! X3.4

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表