原文地址： http://www.infoq.com/cn/news/2012/02/javascript-parallel-processing
Intel发布JavaScript扩展以支持并行运算
作者 Dionysios G. Synodinos 译者 王瑜珩 发布于 2012年2月11日

JavaScript，这个支撑Web的语言，在连移动设备都拥有并行运算能力的今天，还仍然以串行执行的方式存在。Intel实验室正在研究扩展JavaScipt，以便充分利用多核系统的运算能力，他们已经发布了一个相关的FireFox插件。

这个JavaScript的并行扩展代号为River Trail，是Intel实验室的一个项目，致力于在Web应用中利用Intel多核处理器和向量扩展运算能力。 River Trail将促使更多的计算密集型应用程序——如图片处理——出现在浏览器中。

Intel实验室的Stephan Herhut认为，与现有Web技术的集成是他们主要考虑的问题：

最让我激动的是，River Trail背后所使用的技术，可以与现有Web技术无缝集成。River Trail使用了一种简洁但强大的并行编程模型。我们花了很大力气来让这个扩展看起来尽量自然。我们的目标是让用户在使用River Trail构建Web应用时，与使用标准JavaScript时一样简单。而且，由于River Trail本身就在JavaScript中，可以更好的与HTML5 API结合。我们特别保证，River Trail与WebGL结合的非常好。WebGL是近期才被引入的OpenGL接口，用于在浏览器中渲染3D图像。我们有一个demo就是模拟超过4000个个体的物理行为，计算部分使用了Trail River，视觉图像部分则使用了WebGL。
River Trail使用确定性并行数据结构对JavaScript进行扩展，该结构在运行时会被转换为底层硬件抽象层指令。通过利用多核处理器和向量处理指令，River Trail可以大幅提升执行速度。

值得注意的是，River Trail还为JavaScript添加了ParallelArray这一数据结构。这是存储并行数组数据的只读数据结构，可以通过构造函数或调用ParallelArray原型上的方法来实例化。它的构造函数接受JavaScript普通数组，类型化数组或者可以生成这些数组的函数。例如，“new ParallelArray([1,2,3])”将创建一个存储1，2，3的ParallelArray实例。该数组的内容能够被 combine， filter，map，reduce等函数进行处理，而且是并行执行的。这些函数将会被编译成OpenCL，并使用JavaScript的子集。

现在就可以下载Firefox插件来体验River Trail。

原文地址： http://www.infoq.com/cn/news/2012/02/javascript-parallel-processing
查看英文原文：JavaScript Extension that Adds Parallel Processing Capabilities Unveiled by Intel http://www.infoq.com/news/2011/09/javascript-parallel-processing

Intel IPP和TBB能够给OpenCV带来性能上的很大提升，那么如何在编译OpenCV的时候讲其打开呢？

OpenCV轻松进阶初级篇（二）编译OpenCV中已经介绍了使用CMake工具来产生各种编译器的项目文件，那么是否可以通过它来Enabled这些Features呢？

非常的运气，在CMake的配置键值对中，我们找到了IPP和TBB的身影，如图1所示。

图1

编译步骤：

1）  使用CMake打开OpenCV的文件

2）  点击Configure按钮产生所有的键值对列表

3）  选择WITH_IPP和WITH_TBB选项，如图1红色边框所示。

4）  点击Generate按钮产生相关项目文件

Intel Media SDK现在使用新的名字规则了！如果按照以前版本的名字规则，那么它对应是Intel Media SDK3.0 Gold版本。网友可以从http://software.intel.com/en-us/articles/vcsource-tools-media-sdk/?cid=sw:mediadev004
下载到最新版本。

图1

下载步骤：

1）  在图1中，选择红色方框中的下拉菜单“Intel Media SDK 2012”。

2）  点击“Download“按钮

现在的Intel Media SDK 2012实现了双跨：

1）  跨硬件平台，在无Intel
GPU支持的系统中，也能实现视音频的编解码工作。

2）  跨软件平台，在windows
vista和windows 7上都能够运行，并且完整支持它们的32和64bits。

Intel Media SDK 2012不仅仅实现了高性能的视音频解码，它的APIs也为视音频开发者提供了便捷。更加可贵的是，它提供了免费的SDK下载包，对于视音频开发者来说，也是福音。

跟之前版本相比， MediaSDK 2012中比较大的变化：
（1）bin目录下预先编译的二进制库文件和可执行程序， 全部到samples\_bin下， 只保留了软件实现的库文件

（2）tools下增加了一个新的用于测试系统media SDK 能力的工具: mediaSDK system analyzer. 运行该程序会产生一个报告，包含当前系统支持的media SDK 的版本， 图形显卡的类型及驱动的版本， 系统安装的media SDK 开发包的情况等。

（3）增加了一个新的模块， igfx_s3dcontrol, 用于S3D 显示和编程， 其中包含了编程所用的头文件和库文件。

（4）sample_decode中增加了对JPEG图片和视屏墙的支持

如何设置您的NDK应用

本篇主要介绍NDK应用的开发步骤，调试流程已经如何为英特尔架构设置您的NDK应用。

相关文章

•1. 开发兼容英特尔架构的Android应用(一) 应用架构介绍

•2. 开发兼容英特尔架构的Android应用(二) NDK应用介绍

•3. 开发兼容英特尔架构的Android应用(三) 如何设置您的NDK应用

•1. NDK应用开发步骤

NDK应用的开发流程主要分为五个步骤：

•1、 准备好本地代码

•2、 编写makefile文件，mk文件

•3、 编译本地代码（需要添加X86支持选项）为库文件（so）

•4、 从Java端调用本地代码

•5、 用gdb来调试本地代码

通过以上五个步骤后，应用程序调用流程如下图所示：Android App通过Java Framework调用Java SDK API, 通过JNI调用本地库文件。

•2. 创建本地代码和编写makefile文件

在Android工程的jni文件夹下面创建本例中使用的本地代码hello-jni.c 以及Android.mk，代码如下图所示。 注意，在Android.mk文件中要添加X86的支持项。

•3. 编译本地代码（需要添加X86支持选项）为库文件（so）

进入工程所在目录，运行ndk-build来编译本地代码，运行效果如下次，会分别为ARM和X86生成相应的so文件，从java调用本地代码如下图红色标出所示。

•4. 调试流程

调试流程的要求以及调试过程如下图，需要注意的是在manifest文件中需要设置android:debuggable="true"； 然后使用ndk-gdb来调试即可。

本篇完。

相关文章

•1. 开发兼容英特尔架构的Android应用(一) 应用架构介绍

•2. 开发兼容英特尔架构的Android应用(二) NDK应用介绍

•3. 开发兼容英特尔架构的Android应用(三) 如何设置您的NDK应用

本篇主要介绍NDK应用的架构，运行机制以及代码结构。。

•1. 开发兼容英特尔架构的Android应用(一) 应用架构介绍

•2. 开发兼容英特尔架构的Android应用(二) NDK应用介绍

•3. 开发兼容英特尔架构的Android应用(三) 如何设置您的NDK应用

•1. NDK 介绍

NDK在安卓官方解释为：NDK(Native Development Kit) is a toolset that lets you embed components that make use of native code in your Android applications。是一个本地代码开发套件，通过JNI（Java Native Interface）Java本地接口机制来供Java代码调用。

•2. NDK 应用结构

一个典型的NDK 应用如下图所示，包含四个部分：Android Manifest，Dalvik Classes（Java代码），资源文件和JNI调用的本地库（so文件）。

•3. NDK 应用调用过程

NDK应用调用过程可以简单地用下面这张从网上摘录的图表示。所有的本地代码（C/C++）等等通过Android Makefile文件编译为动态库文件，Java Classes通过JNI接口去调用动态库。

•4. NDK API

Android NDK同样提供了一些本地的API供开发者调用，如libc，libm等等，如果你的库是来自于linux项目，那么将相应的库做一些移植工作即可，比如讲glib相应的参数移至libc下面等等。

•l libc (C library) headers

•l libm (math library) headers

•l JNI interface headers

•l libz (Zlib compression) headers

•l liblog (Android logging) header

•l OpenGL ES 1.1 and OpenGL ES 2.0 (3D graphics libraries) headers

•l libjnigraphics (Pixel buffer access) header (for Android 2.2 and above).

•l A Minimal set of headers for C++ support

•l OpenSL ES native audio libraries

•l Android native application APIS

本篇完。

相关文章

•1. 开发兼容英特尔架构的Android应用(一) 应用架构介绍

•2. 开发兼容英特尔架构的Android应用(二) NDK应用介绍

•3. 开发兼容英特尔架构的Android应用(三) 如何设置您的NDK应用

本系列博客将主要介绍Android应用架构，如何让开发兼容英特尔架构的Android应用，在接下来将重点介绍NDK应用的开发方式，以及如何让带有NDK的应用兼容英特尔架构。

•1. 开发兼容英特尔架构的Android应用(一) 应用架构介绍

•2. 开发兼容英特尔架构的Android应用(二) NDK应用介绍

•3. 开发兼容英特尔架构的Android应用(三) 如何设置您的NDK应用

•1. 首款英特尔架构手机概述

在2012年1月举办的国际消费电子展(CES)上，英特尔携手联想发布第一款Intel芯智能手机K800，据报道，联想资深副总裁暨移动网际网络与数字家庭部门总裁刘军表示，K800智能手机将于第二季在中国上市，内含新款Atom处理器的数款智能手机将于2012年陆续问世。此外，Intel还与摩托罗拉移动达成为期数年的移动领域战略合作协议，后者的智能手机将采用Intel的Atom处理器及Android平台。

作为英特尔架构的首款手机，K800一问世即引起围观，接下来将主要介绍Android应用架构，如何让开发兼容英特尔架构的Android应用，在第二篇中将重点介绍NDK应用的开发方式，以及如何让带有NDK的应用兼容英特尔架构。

•2. Android开发

Android开发总体分为三个层次：移植手机系统（底层），系统开发（中间层）和应用开发（上层）。

那么哪些工作是需要针对英特尔平台做适配的呢。我们从上图可以看到，只要在Android Runtime及Java虚拟机至上运行的程序，在英特尔平台上可以直接运行，无需适配。但是如果您的应用或者代码是运行在Java 虚拟机之外的，就需要针对英特尔平台做适配工作了。

•3. 移植手机系统（底层）

移植手机系统工作主要在于驱动的适配，如下图所示。如果您是从事此块工作的工程师，您的代码需要使用X86架构的编译器进行编译才可以在英特尔架构手机上面运行。如果程序中有汇编指令，同样需要做平台的适配工作，ARM的Neon指令需要转变为英特尔Atom架构的SSSE指令系统。

•4. 系统开发（中间层）

系统开发（中间层）工作主要包括：

•• 增加C或者C++本地库；

•• 将所需要的代码封装成JNI；

•• 定义Java层所需要的类（系统API）；

•• 结合Java类和JNI；

•• 应用程序调用Java类。

如下图所示。

在这一层开发的工程师只需要将第一步，增加C/C++代码库的部分添加进支持X86的库文件就可以。也就是在编译时，Android Makefile文件中添加：

APP_ABI := armeabi armeabi-v7a x86

代码即可。其他步骤相同。

•5. 应用开发

应用开发分为Java应用和NDK应用：

Java应用及运行在Java虚拟机之上的应用无需为英特尔平台做任何适配工作即可运行（屏幕尺寸适配仍然是必须的）。

NDK应用需要进行适配工作，在下篇中会详细介绍。

本篇完。

相关文章

•1. 开发兼容英特尔架构的Android应用(一) 应用架构介绍

•2. 开发兼容英特尔架构的Android应用(二) NDK应用介绍

•3. 开发兼容英特尔架构的Android应用(三) 如何设置您的NDK应用

1. User-mode Sampling and Tracing Analysis：

热点分析(Hotspots Analysis)，并行分析(Concurrency Analysis)，锁和等待分析(Locks and Waits Analysis)

2. Hardware event-based sampling analysis

一般性研究（General Exploration），内存带宽（Bandwidth），访问冲突（Access Contention），分支预测（Branch Analysis），存储访问（Memory Access），端口饱和（Port Saturation），等。

用户可以在amplxe-gui（图形界面）使用上述预定义的分析类型，结果产生在响应的报告。

当然用户也可以使用命令行（参阅此文）收集性能，结果也可以在命令行输出或导入工具的图形界面。使用命令行的好处是用户可以自定义自己的分析类型，如：

1. 热点分析中，自定义采样间隔，参阅此文
2. 自选的CPU事件计数器，参阅此文 

VTune™ Amplifier XE 定义了多种自己的输出格式，可以显示在工具的图形界面上。除此之外，工具还支持了gprof的输出格式。此种格式仅可以在命令行输出，不可以在图形界面上输出。

请看下面例子：

VTune的输出格式列出最热函数，而不是全部；gprof格式给出全部函数（即使占用CPU时间极少），且注重函数间调用关系

# amplxe-cl -collect-with runss -knob interval=8 -knob collectSamplesMode=stack -- ./primes.icc
Determining primes from 1 - 100000
Found 9592 primes
Using result path `/home/peter/problem_report/r000runss'
Executing actions 75 % Generating a report
Summary
-------

Elapsed Time:  0.883
CPU Time:      2.080
Executing actions 100 % done               

# amplxe-cl -report hotspots
Using result path `/home/peter/problem_report/r000runss'
Executing actions 75 % Generating a report
Function    Module      CPU Time
----------  ----------  --------
findPrimes  primes.icc  2.080
Executing actions 100 % done                                                   

# amplxe-cl -report gprof-cc
Using result path `/home/peter/problem_report/r000runss'
Executing actions 75 % Generating a report
Index  % CPU Time:Total  CPU Time:Self  Children  Name           Index
-----  ----------------  -------------  --------  -------------  -----
[0]    100.0             0.0            2.08      clone          [0]
                         0              2.080      start_thread  [1]

                         0              2.080      clone         [0]
[1]    100.0             0.0            2.08      start_thread   [1]
                         2.080          2.080      findPrimes    [2]

                         2.080          2.080      start_thread  [1]
[2]    100.0             2.08           0.0       findPrimes     [2]

[3]    0.0               0.0            0.0       _start         [3]
                         0              0          main          [4]

                         0              0          _start        [3]
[4]    0.0               0.0            0.0       main           [4]

Index by function name

Index  Function
-----  ------------
[3]    _start
[0]    clone
[2]    findPrimes
[4]    main
[1]    start_thread
Executing actions 100 % done

下面是Maze迷宫的坐标计算
01.// maze level data
02.private static int[] mMazeData;

这个一维数组存放所有的tile的类型
01.// maze tile size and dimension
02.private final static int TILE_SIZE = 16;
03.private final static int MAZE_COLS = 20;
04.private final static int MAZE_ROWS = 26;

01.// tile types
02.public final static int PATH_TILE = 0;
03.public final static int VOID_TILE = 1;//death area
04.public final static int EXIT_TILE = 2;//the target
而这个坐标的读取是通过从文件读取的，当然也可以通过写几个数组的形式，但是以文件的形式的话就不需要修改代码就可以实现软件的修改是一种比在代码中写几个大的数组要好的形式。

01./**
02. * Load specified maze level.
03. *
04. * @param activity
05. * Activity controlled the maze, we use this load the level data
06. * @param newLevel
07. * Maze level to be loaded.
08. */
09. void load(Activity activity, int newLevel) {
10. // maze data is stored in the assets folder as level1.txt, level2.txt
11. // etc....
12. String mLevel = "level" + newLevel + ".txt";
13.
14. InputStream is = null;
15.
16. try {
17. // construct our maze data array.
18. mMazeData = new int[MAZE_ROWS * MAZE_COLS];
19. // attempt to load maze data.
20. is = activity.getAssets().open(mLevel);
21.
22. // we need to loop through the input stream and load each tile for
23. // the current maze.
24. for (int i = 0; i < mMazeData.length; i++) {
25. // data is stored in unicode so we need to convert it.
26. mMazeData[i] = Character.getNumericValue(is.read());
27.
28. // skip the "," and white space in our human readable file.
29. is.read();
30. is.read();
31. }
32. } catch (Exception e) {
33. Log.i("Maze", "load exception: " + e);
34. } finally {
35. closeStream(is);
36. }
37. }
mMazeData数组存放了每个tile是什么类型的，MAZE_ROWS一共有多少行，MAZE_COLS一共多少列，TILE_SIZE每个tile的宽度，这样就可以在界面上画出来整个界面的布局

01./**
02. * Draw the maze.
03. *
04. * @param canvas
05. * Canvas object to draw too.
06. * @param paint
07. * Paint object used to draw with.
08. */
09. public void draw(Canvas canvas, Paint paint) {
10. // loop through our maze and draw each tile individually.
11. for (int i = 0; i 0)
22. mLocation = mCellRow * MAZE_COLS;
23.
24. // add the column location.
25. mLocation += mCellCol;
26.
27. return mMazeData[mLocation];
28. }
/**
* Determine which cell the marble currently occupies.
*
* @param x
* Current x co-ordinate of marble on the screen.
* @param y
* Current y co-ordinate of marble on the screen.
* @return The actual cell occupied by the marble.
*/
public int getCellType(int x, int y) {
// convert the x,y co-ordinate into row and col values.
int mCellCol = x / TILE_SIZE;
int mCellRow = y / TILE_SIZE;

// location is the row,col coordinate converted so we know where in the
// maze array to look.
int mLocation = 0;

// if we are beyond the 1st row need to multiple by the number of
// columns.
if (mCellRow > 0)
mLocation = mCellRow * MAZE_COLS;

// add the column location.
mLocation += mCellCol;

return mMazeData[mLocation];
}下面是Marble小球的坐标计算

01.// marble attributes
02.// x,y are private because we need boundary checking on any new values to
03.// make sure they are valid.
04.private int mX = 0;
05.private int mY = 0;
06.private int mRadius = 8;
07.private int mColor = Color.WHITE;
08.private int mLives = 5;

在AmazedView中的onDraw()调用gameTick()的时候会更新小球Marble的坐标：

01./**
02. * Called from gameTick(), update marble x,y based on latest values obtained
03. * from the Accelerometer sensor. AccelX and accelY are values received from
04. * the accelerometer, higher values represent the device tilted at a more
05. * acute angle.
06. */
07. public void updateMarble() {
08. // we CAN give ourselves a buffer to stop the marble from rolling even
09. // though we think the device is "flat".
10. if (mAccelX > mSensorBuffer || mAccelX mSensorBuffer || mAccelY 0) {
19. // user still has some lives remaining, restart the level.
20. mMarble.death();
21. mMarble.init();
22. mWarning = true;
23. } else {
24. // user has no more lives left, end of game.
25. mEndTime = System.currentTimeMillis();
26. mTotalTime += mEndTime - mStartTime;
27. switchGameState(GAME_OVER);
28. }
29.
30. } else if (mMaze.getCellType(mMarble.getX(), mMarble.getY()) == mMaze.EXIT_TILE) {
31. // user has reached the exit tiles, prepare the next level.
32. mEndTime = System.currentTimeMillis();
33. mTotalTime += mEndTime - mStartTime;
34. initLevel();
35. }
36. }

在Marble中更新小球坐标：

01./**
02. * Attempt to update the marble with a new x value, boundary checking
03. * enabled to make sure the new co-ordinate is valid.
04. *
05. * @param newX
06. * Incremental value to add onto current x co-ordinate.
07. */
08. public void updateX(float newX) {
09. mX += newX;
10.
11. // boundary checking, don't want the marble rolling off-screen.
12. if (mX + mRadius >= mView.getWidth())
13. mX = mView.getWidth() - mRadius;
14. else if (mX - mRadius < 0)
15. mX = mRadius;
16. }

if-else中是对左右边界的处理，同样的是对上下边界的处理。

WIN 98/NT/2000/XP 是个多任务操作系统，也就是：一个进程可以划分为多个线程，每个线程轮流占用CPU 运行时间和资源，或者说，把CPU 时间划成片，每个片分给不同的线程，这样，每个线程轮流的“挂起”和“唤醒”，由于时间片很小，给人的感觉是同时运行的。
多线程带来如下好处：（自己阅读）
1）避免瓶颈；
2）并行操作；
3）提高效率；
在多线程中，通过优先级管理，可以使重要的程序优先操作，提高了任务管理的灵活性。
另一方面，在多CPU 系统中，可以把不同的线程在不同的CPU 中执行，真正做到同时处理多任务（Win 98 只是模拟的，而Win/NT/2000是真正的多CPU同时操作）。

多线程的两个概念：

1）进程：也称任务，程序载入内存，并分配资源，称为“一个进程”。
注意：进程本身并不一定要正在执行。进程由以下几部分组成：
a>一个私有的地址空间，它是进程可以使用的一组虚拟内存地址空间；
b>程序的相关代码、数据源；
c>系统资源，比如操作系统同步对象等；
d>至少包含一个线程（主线程）；

2）线程：是程序的执行单位（线程本身并不包括程序代码，真正拥有代码的是进程），每个进程至少包括一个线程，称为主线程，一个进程如果有多个线程，就可以共享同一进程的资源，并可以并发执行。
线程是进程的一个执行单元，是操作系统分配CPU 时间的基本实体，线程主要由如下两部分组成：
a>数据结构；
b>CPU 寄存器和堆栈；
一个进程中的线程，可以独立运行，也可以控制另一个线程的运行。

请注意：
多线程不能滥用，书上提到了多线程的几个缺点（自阅）。

1-2 Tthread 对象

虽然Windows 提供了比较多的多线程设计的API 函数，但是直接使用API 函数一方面极其不方便，而且使用不当还容易出错。为解决这个问题，Borland 公司率先推出了一种Tthread 对象，来解决多线程设计上的困难，简化了多线程问题的处理。
应该注意，Tthread 对象是没有实例的，它和界面的交流，主要依靠主窗体（主VCL线程），这和其他对象使用上有些区别。

一、Tthread 对象的主要方法

构造线程：

constructor Create(CreateSuspended:boolean)

其中：CreateSuspended=true 构造但不唤醒
false 构造的同时即唤醒

也可以用如下方法

inheried Create(CreateSuspended:boolean)

挂起线程：

suspend

（把线程挂起的次数加一）

唤醒线程：

resume

（注意：注意这个属性是把线程挂起的次数减一，当次数为0 时，即唤醒。也就是说，线程挂起多少次，唤醒也需要多少次。同时挂起的时候将保持线程的地址指针不变，所以线程挂起后再唤醒，将从挂起的地方开始运行）

析构（清除线程所占用的内存）：

destroy

终止线程（后面会具体讨论）:

Terminate

二、线程应用的简单例子：

下面通过一个例子说明上述方法的应用。我们知道，循环是独占性最强的运行方式之一，现在希望建立两个线程对象，实现循环的并行运行。具体方法如下：

File---New---Thread Object

这就自动在主Form中建立了一个线程单元（在对话框里写上线程名字），默认的名字是Unit2。同样方法建立第二个线程单元Unit3。

要注意的是：Unit2和Unit3中有一个给定的过程：

procedure Object.Execute;
begin

end;

其中的程序是线程唤醒后自动执行的程序，也可以在里面调用其他自定义的过程和函数。这个过程的结束，意味着线程程序的结束。
为了构造线程，在interface的Type区，定义一个构造过程：

type
Object = class(TThread) //自动给出的，也可以直接改

private

protected

procedure Execute; override;

public
constructor create; //自己写的

并且在implementation区域写上：

constructor Object.create;
begin
inherited create(true);
end

其中Object 为线程对象的名字。所以这么写，是希望在主Form中调用这个构造过程。
Create()的参数用True，表明构造出的线程为挂起状态。
注意一下，在同一个线程对象里，如果两次构造，将产生两个独立的线程，不但运行是独立的，而且使用线程的局部变量也是独立的。但这里为了简化问题，还是建立了两个独立的线程对象，而且两个循环数
是不同的，在并行运算时容易判断出是两个不同的程序在运行。

假定我们给两个线程对象起的名字是：

mymath1
mymath2

这样在Unit1，应该作如下声明：

implementation

{$R *.DFM}

uses unit2,unit3;

var thread1:mymath1;
thread2:mymath2;

这样在主线程，将可以通过这两个线程变量调用对应的线程方法。

在主线程区构造线程的方法是：

thread1:=mymath1.create;
thread2:=mymath2.create;

挂起：

thread1.suspend;
thread2.suspend;

唤醒：

thread1.resume;
thread2.resume;

析构：

thread1.destroy;
thread2.destroy;

这里需要说明的是，由于线程单元需要调用Form的Edit控件（对象），可以采用两种方法：

1）在线程单元定义一个TEdit对象，例如

edit4:Tedit;

在Execute过程内直接引用

但在Unit1中一定要在FormCreate过程里作一个赋值：

procedure TForm1.FormCreate(Sender: TObject);
begin
thread1.edit4:=edit1;
end;

这样，就把第一线程的edit4与Form上的edit1联系来。

2）在第二个线程中首先声明调用Unti1，也就是要加上
Uses Unit1;

这样就可以在该线程单元直接调用主Form的控件了，比如在Unit3中可以写：

form1.edit2.text:=inttostr(i)

了解了这些基本规则，就可以写出比较复杂的多线程程序了。
还有一点要说明的，默认生成的线程单元，调用的单元只有一个：

Uses Classes;

这样，往往很多函数和对象在线程单元里不能使用，所以在必要时，应该根据需要User相应的单元，这个例程为了简单，把大部分常用的单元都拷过去了，这并不是推荐的办法，因为这样一来会使程序的垃圾过
多，所以，一般要用什么拷什么。

三、常用的API 函数

在处理多线程问题的时候,也经常用到Windows提供的API 函数，需要说明的是，Tthread 对象内部封装的方法，其实主要也是调用API 函数，但是，考虑更全面，更安全。而直接调用API 函数，往往会因为运用不当，出现一些不应有的错误。所以，我个人以为，只要用Tthread 对象的方法能解决的，就不要直接调用API 函数，API 函数只应该在用在Tthread 对象方法解决不了的时候。
例如Tthread 对象方法内部调用API 函数的时候，一般使用推荐的默认值，但需要更精细的控制时，就可以直接使用API 函数。
其实，Tthread 对象方法已经受到了大多数程序设计者的认可，比如，原来VB是不具备直接处理多线程的能力的，但是，现在VB.Net就宣称，它具备了简单处理多线程问题的能力，这就很说明问题。
下面简单介绍几种API 函数，为了清晰方便，这里着重在于说明，函数正确的描述可以自己阅读书上的例子和手册：
构建线程：

CreateThread(参数1，--安全属性（一般=Nil，默认安全属性）

参数2，--线程堆栈尺寸（一般=0，与主线程相同长度，而且可以根据需要自动变化）
参数3，--指向函数名指针，@函数名，这个参数十分重要，不正确将无法调用成功。
参数4，--用户需要向线程传递的参数，是一个指向结构的指针，不需传递参数时，为Nil。
参数5）--传入与线程有关的一些参数，例如：
CREATE_SUSPENDED 创建一个挂起的线程；
0 创建后立即激活。

书上有这个函数应用的十分清晰的例子，可以自己阅读。
一般并不推荐使用 CreateTheard函数，而推荐使用RTL 库里的System单元中定义的 BeginTheard函数，因为这除了能创建一个线程和一个入口函数以外，还增加了几项保护措施，具体的请参阅书上的第10页说明。

对应suspend（挂起）和resume（唤醒）的两个API 函数为：

Function SuspendThread(hThread:Thandle):DWORD;

Function ResumeThread（hThread:Thandle):DWORD;

其中，Thandle被要求控制线程的句柄，函数调用成功，返回挂起的次数，调用不成功。则返回0xFFFFFFFF。

四、线程的终止和退出：

1)自动退出：

一个线程从Execute()过程中退出，即意味着线程的终止，此时将调用Windows的ExitThread()函数来清除线程所占用的堆栈。
如果线程对象的 FreeOnTerminate 属性设为True，则线程对象将自动删除，并释放线程所占用的资源。
这是消除线程对象最简单的办法。

2)受控退出：

利用线程对象的Terminate属性，可以由进程或者由其他线程控制线程的退出。只需要简单的调用该线程的Terminate方法，并设直线程对象的Terminate属性为True。
在线程中，应该不断监视Terminate的值，一旦发现为True，则退出，例如在Execute()过程中可以这样写：

While not Terminate do
begin
........
end;

3)退出的API 函数：

关于线程退出的API 函数声明如下：code

Function TerminateThread(hThread:Thandle;dwExitCode:DWORD);

不过，这个函数会使代码立刻终止，而不管程序中有没有

try....finally

机制，可能会导致错误，不到万不得已，最好不要使用。

4) 利用挂起线程的方法（suspend）

利用挂起线程的suspend方法，后面跟个Free，也可以释放线程，
例如：

thread1.suspend; //挂起
thread2.free; //释放

书上有相应的例子。

五、线程的优先级：

在多线程的情况下，一般要根据线程执行任务的重要性，给线程适当的优先级，一般如果量的线程同时申请CPU 时间，优先级高的线程优先。

在Windows下，给线程的优先级分为30级，而Delphi中Tthread 对象相对简单的把优先级分为七级。也就是在Tthread中声明了一个枚举类型TTthreadPriority:

type

TTthreadPriority(tpidle,tpLowest,tpLower,tpNormal,
tpHight,tpHighest,tpTimecrital)

分别对应的是最低（系统空闲时有效，-15），较低（-2），低（-1），正常（普通0），高（1），较高（2），最高（15）。

其中tpidle和tpTimecrital有些特殊，具体情况请阅读书上有关内容。

设置优先级可使用thread对象的priority属性：

threadObject.priority:=Tthreadpriority(级别);

这里给出了一个演示多线程优先级的实例：

1-3 在数据库中使用多线程

一）使用ADO模式

由于Delphi 6.0的ADO 数据源控件内置了多线程能力，所以，在ADO模式下，使用多线程不需要做更多的工作。用两个ADOTable控件，分别连到两个数据库，并且分别通过DataSource控件，与数据帮定控件联系就可以了，这样就可以实现前后台处理数据库问题。

二）使用BDE模式和Tseeion对象

如果需要使用BDE 模式，那么多线程使用数据库，就要考虑Session的问题。在单线程时，每个数据源的建立就自动生成一个Session，这是这个数据源私有的关于数据库信息的文件。但多线程时，必须统一管理，所以在BDE 中专门提供了一个Tsession对象，它可以同时管理不同的Databas数据源对象。
Databas数据源可以接受来自不同数据平台的数据库。

数据库1---databas(2)----table(Qurey)(3)---datasource
| |
| |
|--------- Tsession(1)
| |
| |
数据库2---databas(2)----table(Qurey)(3)---datasource

方法：
1）Tsession
属性：SessionName=名（自起）
Active=true （激活）
2）Database（可以有多个）
属性：SessionName=Tsession名
Dataname=名（自起，作为Table的标识）
AliasName=数据库别名
Connected=True （激活）
3）Table或Qurey
属性：SessionName=Tsession名（不要用默认值）
DatabaseName=如果前面起了名，这里就会出现Database
的名字。
Tablename=表名
Active=true （激活）
以后比如加入Datasoucre和其他一样，这样就可以构造两个前后台处理的数据库管理系统了。

2-4 多线程的同步机制

同步机制，实际上是事件驱动机制，意思是让线程平时处于“休眠”状态，除非发生某个事件才触发。
例如一个拷贝文件，拷贝线程完成一个程序块后，再唤醒进程条线程做一个格的填充。
研究多线程的同步机制的必要性在于，多线程同步工作时，如果同时调用相同的资源，就可能会出现问题，一般读出是不会有问题的，但是，如果写入（全局变量、数据库），就会发生冲突，甚至产生死
锁和竞争问题。

一、使用Synchronize方法

这个方法用于访问VCL 主线程所管理的资源，其方法的应用是：
第一步：把访问主窗口（或主窗口控件资源）的代码放到线程的一个方法中；
第二步：是在线程对象的Execute方法中，通过Synchronize方法使用该方法。
实例：
procedure Theater.Execute;
begin
Synchronize(update);
end;

procedure Theater.update;
begin
.........
end;

这里通过 Synchronize使线程方法update同步。

二、使用VCL类的Look方法

在Delphi的IDE提供的构件中，有一些对象内部提供了线程的同步机制，工作线程可以直接使用这些控件，比如：Tfont，Tpen，TBitmap，TMetafile，Ticon等。另外，一个很重要的控件对象叫TCanvas，提供了一个Lock方法用于线程的同步，当一个线程使用此控件对象的时候，首先调用这个对象的Lock方法，然后对这个控件进行操作，完毕后再调用Unlock方法，释放对控间的控制权。
例如：
CanversObject.look;
try
画图
finally
CanversObject.unlock;
end;
{使用这个保护机制,保证不论有没有异常，unlock都会被执行否则很可能会发生死锁。在多线程设计的时候，应该很注意发生死锁的问题}

三、Waitfor方法
当一个线程应该等待另一个线程结束时，可以调用Waitfor方法。这个方法属于等待线程对象，Waitfor方法的原型如下:

Function Waitfor(Const Astring:string):string;

比如在前面最基本的线程的例子中，唤醒线程的语句中加上

thread1.resume;
thread1.waitfor;
thread2.resume;

那么所有的线程都必须等待thread1运行完毕后才能运行，其中包括主线程，可以预想，由于thread1调用了主窗体的Edit控件，那么，在thread1运行中间，Edie1也不会显示。
这就告诉我们，这样的代码是不能作为主线程的一部分的，如果与主窗体连接的线程内等待另一个线程结束，而另一个线程又要等待访问用户界面，就可能是程序陷于死锁。
这点在应用的时候要谨慎。

四、利用Windows的API 实现同步

Windows API函数提供了很多同步技术，下面简要介绍。

1）临界区

使用线程的时候，遇到的一个基本的问题，就是多个线程访问同一个对象，比如访问相同的文件、DLL、相同的通讯资源，特别是数据库的访问，当多个线程对同一数据库字段写入的时候，其结果会出
现不确定性。
临界区用于解决这个问题，它可以保证线程使用敏感数据的时候，阻赛其他的线程访问名干数据，使用时首先要初始化，其声明一个TRTLCriticalSection类型的变量：

var
CS:TRTLCriticalSection;

初始化：

initializeCriticalSection(cs);

独占

EnterCriticalSection(cs);

解除独占

LeaveCriticalSection(CS);

使用临界区是比较方便而且概念比较清晰的的线程同步机制，应用比较广泛。
请注意，临界区只能在一个进程内使用，首先要标记出把数据作为临界区操作的那些代码，在这部分代码执行前，计算机首先要查看一下全局记录，已确定是否有其它线程在临界区中，同时也要查看这个临界区是否和第一个临界区相关，也就是说同一个程序中可能会有几个不同的临界区，然后计算机再决定运行策略。