如何设置您的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应用

下面是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);

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

事实上，这种想法完全是没有必要且不符合实际的，作为能和苹果iOS分庭抗礼的Android（各种意义上），当然也会有相当数量的游戏引擎存在。仅仅因为我们处于这个狭小的天地间，与外界接触不够，所以对它们的存在茫然不知罢了。

下面我就罗列出八款常见的Android游戏引擎，以供有需要者参考（收费，下载量过小，不公布源码，以及鄙人不知道（-_-）的引擎不在此列）。
1、Angle

Angle是一款专为Android平台设计的，敏捷且适合快速开发的2D游戏引擎，基于OpenGL ES技术开发。该引擎全部用Java代码编写，并且可以根据自己的需要替换里面的实现，缺陷在于文档不足，而且下载的代码中仅仅包含有少量的示例教程。

最低运行环境要求不详。

项目地址：http://code.google.com/p/angle/
2、Rokon

rokon是一款Android 2D游戏引擎，基于OpenGL ES技术开发，物理引擎为Box2D，因此能够实现一些较为复杂的物理效果，该项目最新版本为 2.0.3 (09/07/10)。总体来说，此引擎最大的优点在于其开发文档相当之完备，并且项目作者对反馈Bug的修正非常之神速，所以该框架的使用在目前也最为 广泛，有人干脆将它称为Cocos2d-iPhone引擎的Android版（业务逻辑和编码风格上也确实很像）。附带一提，国内某个需要注册会员才能下 载的Android游戏框架衍生于此框架，所以大家也不要刻板的认为收费便一定是好的，免费就一定不好。

最低运行环境要求为Android 1.5。

项目地址：http://code.google.com/p/rokon/

3、LGame

LGame是一款国人开发的Java游戏引擎，有Android及PC(J2SE)两个开发版本，目前最高版本同为0.2.6(31/07/10)。其底 层绘图器LGrpaphics封装有J2SE以及J2ME提供的全部Graphics API（PC版采用Graphics2D封装，Android版采用Canvas模拟实现），所以能够将J2SE或J2ME开发经验直接套用其中，两版本 间主要代码能够相互移植。Android版内置有Admob接口，可以不必配置XML直接硬编码Admob广告信息。

该引擎除了基本的音效、图形、物理、精灵等常用组件以外，也内置有Ioc、xml、http等常用Java组件的封装，代价是jar体积较为庞大，PC版 已突破1.2MB，Android版有所简化也在500KB左右。此外，该引擎还内置有按照1:1实现的J2ME精灵类及相关组件，可以将绝大多数 J2ME游戏平移到Android或PC版中。唯一遗憾的是，该项目作者是个极其懒惰的家伙，开发文档从去年说到今年依旧没有提供，只有游戏示例可供下 载。

最低运行环境要求为Android 1.1。

项目地址：http://code.google.com/p/loon-simple/

4、AndEngine

andengine同样是一款基于OpenGL ES技术的Android游戏引擎，物理引擎同样为Box2D（标配|||）。该框架性能普通，文档缺乏，但示例较为丰富。

下载地址（未直接提供jar下载，源码可通过svn提取）：http://code.google.com/p/andengine/

最低运行环境要求不详。

项目地址：http://code.google.com/p/rokon/
5、libgdx

libgdx是一款基于OpenGL ES技术开发的Android游戏引擎，支持Android平台下的2D游戏开发，物理引擎采用Box2D实现。单就性能角度来说，堪称是一款非常强大的 Android游戏引擎，但缺陷在于精灵类等相关组件在使用上不够简化，而且文档也较为匮乏。

最低运行环境要求不详。

项目地址：http://code.google.com/p/libgdx/
6、jPCT

jPCT是一款基于OpenGL技术开发的3D图形引擎(PC环境为标准OpenGL，Android为OpenGL ES)， 以Java语言为基础的，拥有功能强大的Java 3D解决方案。该引擎与LGame（此为2D游戏引擎）相类似，目前拥有PC(J2SE)以及Android两个开发版本。

jPCT的最大优势之一，就在于它惊人的向下兼容性。在PC环境中，jPCT甚至可以运行在JVM1.1环境之中，因为jPCT内部提供的图形渲染接口完 全符合所有的Java 1.1规范（就连已经消失的Microsoft VM乃至更古老的Netscape 4 VM也不例外）。

最低运行环境要求为Android 1.5。

项目地址：http://www.jpct.net/jpct-ae/
7、Alien3d

Alien3d是一款体积非常之小的Android 3D游戏引擎，基于OpenGL ES技术开发。为了压缩体积，它根据不同功能采用多jar方式发布（包括alien3d-engine.jar，alien3d- tiled.jar，alien3d-sprites.jar，alien3d-shapes.jar，alien3d- particles2d.jar，），事实上它的核心文件大约只有40KB，所有相关jar的总和也不足150KB。

最低运行环境要求为Android 1.5。

项目地址：http://code.google.com/p/alien3d/
8、Catcake

Catcake是一款跨平台的Java 3D图形引擎，目前支持PC(J2SE)及Android环境运行（已有iPhone版规划）。该引擎在易用性和运行性能上皆有出色的表现，支持常见的游戏开发功能，诸如精灵动画，音频处理和视频播放等。

最低运行环境要求为Android 1.6。

项目地址：http://code.google.com/p/catcake/

有五个哲学家，他们的生活方式是交替地进行思考和进餐。哲学家们公用一张圆桌，周围放有五把椅子，每人坐一把。在圆桌上有五个碗和五根筷子，当一个哲学家思考时，他不与其他人交谈，饥饿时便试图取用其左、右最靠近他的筷子，但他可能一根都拿不到。只有在他拿到两根筷子时，方能进餐，进餐完后，放下筷子又继续思考。

01.#include
02.#include
03.
04.#define P(S) WaitForSingleObject(S, INFINITE) //P操作
05.#define V(S) ReleaseSemaphore(S, 1, NULL)
06.#define NUMBERS 5 //叉子个数
07.typedef HANDLE Semaphore; //信号量原型
08.Semaphore chopstick[5];
09.Semaphore mutex; //定义一个互斥量
10.Semaphore room;
11.char *philosophers[5] = {"哲学家1 ", "哲学家2 ", "哲学家3 ", "哲学家4 ", "哲学家5 "};
12.char *str[] = {"得到左手边的筷子", "得到右手边的筷子", "得到一双筷子，开始吃饭!", "饭吃完了，该开始思考问题了"};
13.
14.DWORD WINAPI philosopher(LPVOID lParam); //线程函数声明
15.void main()
16.{
17. HANDLE hThread[NUMBERS]; //线程句柄
18. DWORD ThreadID[NUMBERS]; //线程ID
19.
20. //初始化信号量
21. mutex = CreateSemaphore(NULL, 1, 1, "mutex");
22. if(!mutex)
23. cout<<"创建信号量失败"<<endl;
24. for (int i=0; i<5; i++)
25. {
26. chopstick[i] = CreateSemaphore(NULL, 1, 1, NULL);
27. if(!chopstick[i])
28. cout<<"创建信号量失败"<<endl;
29. }
30. for (i=0; i<NUMBERS; i++)
31. {
32. hThread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)philosopher, (LPVOID *)&i, 0, &ThreadID[i]);
33. if (!hThread[i])
34. {
35. cout<<"创建线程失败"<<endl;
36. }
37. WaitForSingleObject(hThread[i], 5000);
38. }
39.}
40.
41.DWORD WINAPI philosopher(LPVOID lParam)
42.{
43. int i = *(int *)lParam;
44. while (true)
45. {
46. P(mutex);
47. P(chopstick[i]);
48. cout<<philosophers[i]<<str[0]<<endl;
49. P(chopstick[(i+1)%5]);
50. cout<<philosophers[i]<<str[1]<<endl;
51. cout<<philosophers[i]<<str[2]<<endl;
52. V(chopstick[i]);
53. V(chopstick[(i+1)%5]);
54. cout<<philosophers[i]<<str[3]<<endl<<endl;
55. Sleep(1000); //整个吃饭过程大约一秒时间
56. V(mutex);
57. }
58. return 0;
59.}

core——定义了基本数据结构，包括最重要的Mat和一些其他的模块

imgproc——该模块包括了线性和非线性的图像滤波，图像的几何变换，颜色空间转换，直方图处理等等

video——该模块包括运动估计，背景分离，对象跟踪

calib3d——基本的多视角几何算法，单个立体摄像头标定，物体姿态估计，立体相似性算法，3D信息的重建

features2d——显著特征检测，描述，特征匹配

objdetect——物体检测和预定义好的分类器实例（比如人脸，眼睛，面部，人，车辆等等）

highgui——视频捕捉、图像和视频的编码解码、图形交互界面的接口

gpu——利用GPU对OpenCV模块进行加速算法

ml——机器学习模块（SVM，决策树，Boosting等等）

flann——Fast Library for Approximate Nearest Neighbors（FLANN）算法库

legacy——一些已经废弃的代码库，保留下来作为向下兼容

还有一些其他的模块，比如FLANN算法库、Google测试包、Python bingdings等等。

1. 配置电脑的环境变量（Path变量）（需要注销才能生效），这里需要注意网上的教程又让增加一个OPENCV变量，值为D:\Program Files\OpenCV2.3.1\build(你安装的路径中的build目录)

2. 添加包含文件和库文件，这个和前几个版本方法类似，都是去工具->选项->VC目录添加build目录下的include目录及其子目录和你电脑对应版本的lib目录（选择x86 or x64，vc9 or vc10）

下面是第一个实例：

新建一个空项目，添加源文件如下：
#include
#include
#include

waitKey(0); // Wait for a keystroke in the window
return 0;
}
这段程序可以在你安装目录下的samples\cpp\tutorial_code\introduction\display_image找到，编译后，将图片test.jpg放到opencvtest.exe相同的目录中去，利用cmd命令行进入的可执行文件所在的目录，
运行opencvtest test.jpg

则会显示一个图片，第一个程序成功。如图

如果遇到找不到tbb_debug.dll文件的问题，参考这里http://www.opencv.org.cn/forum/viewtopic.php?p=52223，只是我的环境是vs2008，大同小异。祝你成功！

接下来我觉得应该好好研究一下OpenCV里的doc文件夹下的教程和使用手册，我个人觉得《学习OpenCV》这本书已经远远跟不上OpenCV发展的速度了

sessionStorage.varName = “生成新变量”;
sessionStorage.varName = “变量操作”;
delete sessionStorage.varName;  //删除变量

另外一种是本地存储，当网页下次被打开的时候，你仍然可以访问上次打开该网页时存储的数据，比如本地存储的网站用户名就可以使用这种方式。
用法和基于会话的存储一样，只是前缀名改成了localStorage

localStorage.varName = “生成新变量”;
localStorage.varName = “变量操作”;
delete localStorage.varName;  //删除变量

从上面可以看出web storage其实也只是解决了轻量级的数据存储问题，如果是大量的数据查询，比如商品列表，还是得靠数据库,HTML5中有Web Database来支持这一操作，基本操作和SQL一致。
注1：现在的浏览器基本都支持多窗口了，一个窗口对应一个网页
注2：官方参考