Visual Studio 2005 有一个开源的Subversion插件，Ankhsvn  (http://ankhsvn.tigris.org/)，安装后，VS 2005中将内置Subversion的支持，可以直接在VS里面提交修改。我经常用它和TortoiseSVN 配合来使用Subversion，十分方便。

可是升级到Visual Studio 2008后，发现Ankhsvn没有集成进来，因为目前的Ankhsvn还不支持VS2008，据说下个版本才会支持VS 2008。

不过这不影响我们在Visual Studio 2008中使用Ankhsvn，我们可以自己动手修改注册表，将Ankhsvn集成进VS 2008。方法很简单。

1. 运行 regedit
2. 找到 HKLMSOFTWAREMicrosoftVisualStudio8.0AddinsAnkh
3. 右键点击它，选择导出，并指定一个文件保存。
4. 用记事本或者其他文本编辑器打开这个文件，将其中的VisualStudio8.0替换为VisualStudio9.0。
5. 最后，双击这个修改后的注册表文件，提示是否导入进系统注册表，选择是。
   

再次打开Visual Studio 2008后，就会发现Ankhsvn已经集成进系统了。

为了方便操作，我写了一个vbscript脚本来进行上述操作。使用很简单，将下面的脚本保存到一个文本文件，命名为ankh.vbs，然后双击该文件即可运行。运行后，重新打开Visual Studio 2008，就会发现Ankhsv已经集成进来了。

顺便再推荐几个常用的免费的插件：

[FREE VISUAL STUDIO ADD-INS]
http://searchwindevelopment.techtarget.com/originalContent/0,289142,sid8_gci1262570,00.html


需要提醒的是，注册表操作不慎可能会导致系统崩溃，因此请谨慎修改注册表。

Dim shell, filename, fso, file, content
Set shell = CreateObject("wscript.shell")
Set fso = CreateObject("Scripting.FileSystemObject")
filename = "ankh.reg"

shell.run "reg export HKLMSOFTWAREMicrosoftVisualStudio8.0AddinsAnkh " & filename, 1, True

Set file = fso.OpenTextFile(filename, 1, False, True)
content = file.ReadAll
content = Replace(content, "VisualStudio8.0", "VisualStudio9.0")
content = Replace(content, ".NET 2005", ".NET 2008")
file.Close()

Set file = fso.OpenTextFile(filename, 2, True)
file.Write content
file.Close()

shell.run "reg import " & filename, 1, true

fso.DeleteFile filename

另外：

5. 如果编译boost里面单独的模块，如regex

    进入boost_1_38_0\libs\regex\build

    执行bjam  bjam --toolset=msvc-6.0

    就会在boost_1_38_0\bin.v2\libs\regex\build\msvc-6.0\debug\threading-multi下面生成boost_regex-vc6-mt-gd-1_38_0.dll和boost_regex-vc6-mt-gd-1_38_0.lib库，可以给VC6.0使用。

Git --- The stupid content tracker, 傻瓜内容跟踪器。Linus 是这样给我们介绍 Git 的。

Git 是用于 Linux 内核开发的版本控制工具。与常用的版本控制工具 CVS, Subversion 等不同， 它采用了分布式版本库的方式，不必服务器端软件支持，使源代码的发布和交流极其方便。 Git 的速度很快，这对于诸如 Linux kernel 这样的大项目来说自然很重要。 Git 最为出色的是它的合并跟踪（merge tracing）能力。

实际上内核开发团队决定开始开发和使用 Git 来作为内核开发的版本控制系统的时候， 世界开源社群的反对声音不少，最大的理由是 Git 太艰涩难懂，从 Git 的内部工作机制来说，的确是这样。 但是随着开发的深入，Git 的正常使用都由一些友好的脚本命令来执行，使 Git 变得非常好用， 即使是用来管理我们自己的开发项目，Git 都是一个友好，有力的工具。 现在，越来越多的著名项目采用 Git 来管理项目开发，例如：wine, U-boot 等，详情看 http://www.kernel.org/git

作为开源自由原教旨主义项目，Git 没有对版本库的浏览和修改做任何的权限限制。 它只适用于 Linux / Unix 平台，没有 Windows 版本，目前也没有这样的开发计划。

本文将以 Git 官方文档 Tutorial， core-tutorial 和 Everyday GIT 作为蓝本翻译整理，但是暂时去掉了对 Git 内部工作机制的阐述， 力求简明扼要，并加入了作者使用 Git 的过程中的一些心得体会，注意事项，以及更多的例子。 建议你最好通过你所使用的 Unix / Linux 发行版的安装包来安装 Git, 你可以在线浏览本文 ，也可以通过下面的命令来得到本文最新的版本库，并且通过后面的学习用 Git 作为工具参加到本文的创作中来。

$ git-clone http://www.bitsun.com/git/gittutorcn.git

创建一个 Git 版本库是很容易的，只要用命令 git-init-db 就可以了。 现在我们来为本文的写作创建一个版本库：

$ mkdir gittutorcn
$ cd gittutorcn
$ git-init-db

为了简明起见，我们创建两个文件作为练习：

$ echo "Hello world" > hello
$ echo "Silly example" > example

我们再用 git-add 命令将这两个文件加入到版本库文件索引当中：

$ git-add hello example

git-add 实际上是个脚本命令，它是对 git 内核命令 git-update-index 的调用。 因此上面的命令和下面的命令其实是等价的：

$ git-update-index --add hello example

如果你要将某个文件从 git 的目录跟踪系统中清除出去，同样可以用 git-update-index 命令。例如：

$ git-update-index --force-remove foo.c

应该建立一个清晰的概念就是，git-add 和 git-update-index 只是刷新了 git 的跟踪信息，hello 和 example 这两个文件中的内容并没有提交到 git 的内容跟踪范畴之内。

既然我们刷新了 Git 的跟踪信息，现在我们看看版本库的状态：

$ git-status

我们能看到 git 的状态提示：

#
# Initial commit
#
#
# Updated but not checked in:
#   (will commit)
#
#       new file: example
#       new file: hello
#

提示信息告诉我们版本库中加入了两个新的文件，并且 git 提示我们提交这些文件， 我们可以通过 git-commit 命令来提交：

$ git-commit -m "Initial commit of gittutor reposistory"

git-diff 命令将比较当前的工作目录和版本库数据库中的差异。 现在我们编辑一些文件来体验一下 git 的跟踪功能。

$ echo "It's a new day for git" >> hello

我们再来比较一下，当前的工作目录和版本库中的数据的差别。

$ git-diff

差异将以典型的 patch 方式表示出来：

diff --git a/hello b/hello
index a5c1966..bd9212c 100644
--- a/hello
+++ b/hello
@@ -1 +1,2 @@
 Hello, world
+It's a new day for git

此时，我们可以再次使用组合命令 git-update-index 和 git-commit 将我们的工作提交到版本库中。

$ git-update-index hello
$ git-commit -m "new day for git"

实际上，如果要提交的文件都是已经纳入 git 版本库的文件，那么不必为这些文件都应用 git-update-index 命令之后再进行提交，下面的命令更简捷并且和上面的命令是等价的。

$ git-commit -a -m "new day for git"

直至现在为止，我们的项目版本库一直都是只有一个分支 master。 在 git 版本库中创建分支的成本几乎为零，所以，不必吝啬多创建几个分支。 下面列举一些常见的分支策略，仅供大家参考：

• 创建一个属于自己的个人工作分支，以避免对主分支 master 造成太多的干扰， 也方便与他人交流协作。

• 当进行高风险的工作时，创建一个试验性的分支，扔掉一个烂摊子总比收拾一个烂摊子好得多。

• 合并别人的工作的时候，最好是创建一个临时的分支，关于如何用临时分支合并别人的工作的技巧， 将会在后面讲述。

创建分支

下面的命令将创建我自己的工作分支，名叫 robin，并且将以后的工作转移到这个分支上开展。

$ git-branch robin
$ git-checkout robin

删除分支

要删除版本库中的某个分支，使用 git-branch -D 命令就可以了，例如：

$ git-branch -D branch-name

查看分支

运行下面的命令可以得到你当前工作目录的分支列表：

$ git-branch

如果你忘记了你现在工作在哪个分支上，运行下面的命令可以告诉你：

$ cat .git/HEAD 

既然我们为项目创建了不同的分支， 那么我们就要经常地将自己或者是别人在一个分支上的工作合并到其他的分支上去。 现在我们看看怎么将 robin 分支上的工作合并到 master 分支中。 现在转移我们当前的工作分支到 master，并且将 robin 分支上的工作合并进来。

$ git-checkout master
$ git-merge "Merge work in robin" HEAD robin

$ git-checkout master
$ git-pull . robin

但是，此时 git 会出现合并冲突提示：

Trying really trivial in-index merge...
fatal: Merge requires file-level merging
Nope.
Merging HEAD with d2659fcf690ec693c04c82b03202fc5530d50960
Merging:
1d2fa05b13b63e39f621d8ee911817df0662d9b7 Some fun


d2659fcf690ec693c04c82b03202fc5530d50960 some work
found 1 common ancestor(s):
3ecebc0cb4894a33208dfa7c7c6fc8b5f9da0eda a new day for git
Auto-merging hello
CONFLICT (content): Merge conflict in hello


Automatic merge failed; fix up by hand

git 的提示指出，在合并作用于文件 hello 的 'Some fun' 和 'some work' 这两个对象时有冲突， 具体通俗点说，就是在 master, robin 这两个分支中的 hello 文件的某些相同的行中的内容不一样。 我们需要手动解决这些冲突，现在先让我们看看现在的 hello 文件中的内容。

$ cat hello

此时的 hello 文件应是这样的，用过其他的版本控制系统的朋友应该很容易看出这个典型的冲突表示格式：

Hello World
It's a new day for git
<<<<<<< HEAD/hello
Play, play, play
=======
Work, work, work
>>>>>>> d2659fcf690ec693c04c82b03202fc5530d50960/hello

我们用编辑器将 hello 文件改为：

Hello World
It's a new day for git
Play, play, play
Work, work, work

现在可以将手动解决了冲突的文件提交了。

$ git-commit -i hello

以上是典型的两路合并（2-way merge）算法，绝大多数情况下已经够用。 但是还有更复杂的三路合并和多内容树合并的情况。详情可参看： git-read-tree， git-merge 等文档。

git-reset 命令就是为这样的任务准备的。 它将当前的工作分支的 头 定位到以前提交的任何版本中，它有三个重置的算法选项。

命令形式：

git-reset [--mixed | --soft | --hard] [<commit-ish>]

命令的选项：

--mixed

仅是重置索引的位置，而不改变你的工作树中的任何东西（即，文件中的所有变化都会被保留， 也不标记他们为待提交状态），并且提示什么内容还没有被更新了。这个是默认的选项。

--soft

既不触动索引的位置，也不改变工作树中的任何内容，我们只是要求这些内容成为一份好的内容 （之后才成为真正的提交内容）。 这个选项使你可以将已经提交的东西重新逆转至“已更新但未提交（Updated but not Check in）”的状态。 就像已经执行过 git-update-index 命令，但是还没有执行 git-commit 命令一样。

--hard

将工作树中的内容和头索引都切换至指定的版本位置中，也就是说自 <commit-ish> 之后的所有的跟踪内容和工作树中的内容都会全部丢失。 因此，这个选项要慎用，除非你已经非常确定你的确不想再看到那些东西了。

一个重要技巧－－逆转提交与恢复

可能有人会问，--soft 选项既不重置头索引的位置，也不改变工作树中的内容， 那么它有什么用呢？现在我们介绍一个 --soft 选项的使用技巧。 下面我们用例子来说明：

$ git-checkout master
$ git-checkout -b softreset
$ git-show-branch

这里我们创建了一个 master 的拷贝分支 softreset， 现在我们可以看到两个分支是在同一起跑线上的。

! [master] Merge branch 'robin'
 ! [robin] some work
  * [softreset] Merge branch 'robin'
---
- - [master] Merge branch 'robin'
+ * [master^] Some fun
++* [robin] some work

我们为 文件增加一些内容并提交。

$ echo "Botch, botch, botch" >> hello
$ git-commit -a -m "some botch"
$ git-show-branch

我们可以看到此时 softreset 比 master 推进了一个版本 "some botch" 。

! [master] Merge branch 'robin'
 ! [robin] some work
  * [softreset] some botch
---
  * [softreset] some botch
- - [master] Merge branch 'robin'
+ * [master^] Some fun
++* [robin] some work

现在让我们来考虑这样的一种情况，假如我们现在对刚刚提交的内容不满意， 那么我们再编辑项目的内容，再提交的话，那么 "some botch" 的内容就会留在版本库中了。 我们当然不希望将有明显问题的内容留在版本库中，这个时候 --soft 选项就很有用了。 为了深入了解 --soft 的机制，我们看看现在 softreset 分支的头和 ORIG_HEAD 保存的索引。

$ cat .git/refs/heads/softreset .git/ORIG_HEAD

结果如下：

5e7cf906233e052bdca8c598cad2cb5478f9540a
7bbd1370e2c667d955b6f6652bf8274efdc1fbd3

现在用 --soft 选项逆转刚才提交的内容：

git-reset --soft HEAD^

现在让我们再看看 .git/ORIG_HEAD 的中保存了什么？

$ cat .git/ORIG_HEAD

结果如下：

5e7cf906233e052bdca8c598cad2cb5478f9540a

看！现在的 .git/ORIG_HEAD 等于逆转前的 .git/refs/heads/softreset 。 也就是说，git-reset --soft HEAD^ 命令逆转了刚才提交的版本进度， 但是它将那次提交的对象的索引拷贝到了 .git/ORIG_HEAD 中。

我们再编辑 hello 文件成为下面的内容：

Hello World
It's a new day for git
Play, play, play
Work, work, work
Nice, nice, nice

我们甚至可以比较一下现在的工作树中的内容和被取消了的那次提交的内容有什么差异：

$ git-diff ORIG_HEAD

结果如下：

diff --git a/hello b/hello
index f978676..dd02c32 100644
--- a/hello
+++ b/hello
@@ -2,4 +2,4 @@ Hello World
 It's a new day for git
 Play, play, play
 Work, work, work
-Botch, botch, botch


+Nice, nice, nice

接着，我们可以恢复刚才被取消了的那次提交了。

$ git-commit -a -c ORIG_HEAD

注意，这个命令会打开默认的文本编辑器以编辑原来提交的版本日志信息，我们改为 "nice work" 。 大家可以自行用 git-show-branch 命令来查看一下现在的分支状态。 并且我们还可以不断地重复上述的步骤，一直修改到你对这个版本进度满意为止。

git-reset 命令还有很多的用途和技巧，请参考 git-reset ，以及 Everyday GIT with 20 commands or So 。

提取版本库中的数据

这是个很有用的小技巧，如果你对你现在的工作目录下的东西已经不耐烦了， 随时可以取出你提交过的东西覆盖掉当前的文件，譬如：

$ git-checkout -f foo.c

在 git 中，有两种类型的标签，“轻标签”和“署名标签”。

技术上说，一个“轻标签”和一个分支没有任何区别，只不过我们将它放在了 .git/refs/tags/ 目录， 而不是 heads 目录。因此，打一个“轻标签”再简单不过了。

$ git-tag my-first-tag

如果你打算针对某个commit ID来打标签，虽然该命令可以通过gitk里的右键菜单来实现，但是该命令对实际应用是很有帮助的。

$ git-tag mytag f0af6283824688f9d23426031734657661b54388

“署名标签”是一个真正的 git 对象，它不但包含指向你想标记的状态的指针，还有一个标记名和信息， 可选的 PGP 签名。你可以通过 -a 或者是 -s 选项来创建“署名标签”。

$ git-tag -s <tag-name>

通常的情况下，合并其他的人的工作的情况会比合并自己的分支的情况要多， 这在 git 中是非常容易的事情，和你运行 git-merge 命令没有什么区别。 事实上，远程合并的无非就是“抓取（fetch）一个远程的版本库中的工作到一个临时的标签中”， 然后再使用 git-merge 命令。

可以通过下面的命令来抓取远程版本库:

$ git-fetch <remote-repository>

根据不同的远程版本库所使用的通讯协议的路径来替代上面的 remoted-repository 就可以了。

Rsync

rsync://remote.machine/patch/to/repo.git/

SSH

remote.machine:/path/to/repo.git
or
ssh://remote.machine/patch/to/repo.git/

这是可以上传和下载的双向传输协议，当然，你要有通过 ssh 协议登录远程机器的权限。 它可以找出两端的机器提交过的对象集之中相互缺少了那些对象，从而得到需要传输的最小对象集。 这是最高效地交换两个版本库之间的对象的方式（在 git 兼容的所有传输协议当中）。

下面是个取得 SSH 远程版本库的命令例子：

$ git-fetch robin@192.168.1.168:/path/to/gittutorcn.git  (1)

(1) 这里 robin 是登录的用户名，192.168.1.168 是保存着主版本库的机器的 IP 地址。

Local directory

/path/to/repo.git/

本地目录的情况和 SSH 情况是一样的。

git Native

git://remote.machine/path/to/repo.git/

git 自然协议是设计来用于匿名下载的，它的工作方式类似于 SSH 协议的交换方式。

HTTP(S)

http://remote.machine/path/to/repo.git/

到这里可能有些朋友已经想到， 实际上，我们可以通过 Rsync, SSH 之类的双向传输方式来建立类似 CVS，SVN 这样的中心版本库模式的开发组织形式。

读过上一节之后，有的朋友可能要问，如果版本库是通过单向的下载协议发布的，如 HTTP， 我们就无法将工作上传到公共的版本库中。别人也不能访问我的机器来抓取我的工作，那怎么办呢？

不必担心，我们还有 email ！别忘了 git 本来就是为了管理 Linux 的内核开发而设计的。 所以，它非常适合像 Linux Kernel 这样的开发组织形式高度分散，严重依赖 email 来进行交流的项目。

下面模拟你参加到《Git 中文教程》的编写工作中来，看看我们可以怎么通过 email 进行工作交流。 你可以通过下面的命令下载这个项目的版本库。

$ git-clone http://www.bitsun.com/git/gittutorcn.git

你可以直接在 master 下开展工作，也可以创建你自己的工作分支。 当你对项目做了一定的工作，并提交到库中。我们用 git-show-branch 命令先看下库的状态。

* [master] your buddy's contribution
 ! [origin] degining of git-format-patch example
--
*  [master] your buddy's contribution
*+ [origin] degining of git-format-patch example

上面就假设你已经提交了一个叫 "your buddy's contribution" 的工作。 现在我们来看看怎么通过 email 来交流工作了。

$ git-fetch origin    (1)
$ git-rebase origin    (2)
$ git-format-patch origin     (3)

(1)更新 origin 分支，防止 origin 分支不是最新的公共版本，产生错误的补丁文件；
(2)将你在 master 上提交的工作迁移到新的源版本库的状态的基础上；


(3)生成补丁文件；

上面的几个命令，会在当前目录下生成一个大概名为 0001-your-buddy-s-contribution.txt 补丁文件, 建议你用文本工具查看一下这个文件的具体形式，然后将这个文件以附件的形式发送到项目维护者的邮箱： vortune@gmail.com

当项目的维护者收到你的邮件后，只需要用 git-am 命令，就可以将你的工作合并到项目中来。

$ git-checkout -b buddy-incomming
$ git-am /path/to/0001-your-buddy-s-contribution.txt

假设 Alice 在一部机器上自己的个人目录中创建了一个项目 /home/alice/project, Bob 想在同一部机器自己的个人目录中为这个项目做点什么。

Bob 首先这样开始：

$ git-clone /home/alice/project myrepo

这样就创建了一个保存着 Alice 的版本库的镜像的新目录 "myrepo"。 这个镜像保存着原始项目的起点和它的发展历程。

接着 Bob 对项目做了些更改并提交了这些更改：

(编辑一些文件)

$ git-commit -a 

(如果需要的话再重复这个步骤)

当他搞定之后，他告诉 Alice 将他的东西从 /home/bob/myrepo 中引入，她只需要这样：

$ cd /home/alice/project
$ git pull /home/bob/myrepo

这样就将 Bob 的版本库中的 "master" 分支的变化引入了。 Alice 也可以通过在 pull 命令的后面加入参数的方式来引入其他的分支。

在导入了 Bob 的工作之后，用 "git-whatchanged" 命令可以查看有什么信的提交对象。 如果这段时间里以来，Alice 也对项目做过自己的修改，当 Bob 的修改被合并进来的时候， 那么她需要手动修复所有的合并冲突。

谨慎的 Alice 在导入 Bob 的工作之前，希望先检查一下。 那么她可以先将 Bob 的工作导入到一个新创建的临时分支中， 以方便研究 Bob 的工作：

$ git fetch /home/bob/myrepo master:bob-incoming

这个命令将 Bob 的 master 分支的导入到名为 bob-incoming 的分支中（ 不同于 git-pull 命令，git-fetch 命令只是取得 Bob 的开发工作的拷贝， 而不是合并经来）。接着：

$ git whatchanged -p master..bob-incoming

这会列出 Bob 自取得 Alice 的 master 分支之后开始工作的所有变化。 检查过这些工作，并做过必须的调整之后， Alice 就可以将变化导入到她的 master 分支中：

$ git-checkout master
$git-pull . bob-incoming

最后的命令就是将 "bob-incoming" 分支的东西导入到 Alice 自己的版本库中的， 稍后，Bob 就可以通过下面的命令同步 Alice 的最新变化。

$ git-pull

注意不需为这个命令加入 Alice 的版本库的路径，因为当 Bob 克隆 Alice 的版本库的时候， git 已经将这个路径保存到 .git/remote/origin 文件中，它将会是所以的导入操作的默认路径。

Bob 可能已经注意到他并没有在他的版本库中创建过分支（但是分支已经存在了）：

$ git branch
* master
  origin

"origin" 分支，它是运行 "git-clone" 的时候自动创建的，他是 Alice 的 master 分支的原始镜像， Bob 应该永远不要向这个分支提交任何东西。

如果 Bob 以后决定在另外一部主机上开展工作，那么他仍然需要通过 SSH 协议从新克隆和导入（ Alice 的版本库）：

$ git-clone alice.org:/home/alice/project/ myrepo

我们可以使用 git 自然协议，或者是 rsync, http 等协议的任何一种，详情请参考 git-pull。

Git 同样可以建立类似 CVS 那样的开发模式，也就是所有开发者都向中心版本库提交工作的方式， 详情参考 git_push 和 git for CVS users 。

在前面，我们已经看到在 .git/objects/??/ 目录中保存着我们创建的每一个 git 对象。 这样的方式对于自动和安全地创建对象很有效，但是对于网络传输则不方便。 git 对象一旦创建了，就不能被改变，但有一个方法可以优化对象的存储，就是将他们“打包到一起”。

$ git repack

上面的命令让你做到这点，如果你一直是做着我们的例子过来的， 你现在大约会在 .git/objects/??/ 目录下积累了17个对象。 git-repack 会告诉你有几个对象被打包了， 并且将他们保存在 .git/objects/pack 目录当中。

如果你是个偏执狂，就运行一下 git-verity-pack 命令来检查一下有缺陷的包吧， 不过，其实你无须太多担心，我们的程序非常出色 ;-).

一旦你已经对那些对象打包了，那么那些已经被打过包的原始的对象，就没有必要保留了。

$ git prune-packed

会帮你清楚他们。

如果你好奇的话，你可以在执行 git-prune-repacked 命令之前和之后， 都运行一下 find .git/objects -type f，这样你就能看到有多少没有打包的对象， 以及节省了多少磁盘空间。

如果你此时再次运行 git-repack，它就会说 "Nothing to pack"。 要是你继续开发，并且积累了一定数量的变迁，再运行 git-repack 将会创建一个新的包， 它会包含你自上次对库打包以来创建的对象。我们建议你尽快在初始化提交之后打包一下你的版本库（ 除非你现在的项目是个涂鸦式的草稿项目），并且在项目经历过一段很活跃的时期时， 再运行 git-repack 一下。

当一个版本库通过 git-push 和 git-pull 命令来同步源版本库中打包过的对像的时候， 通常保存到目标版本库中的是解包了的对象，除非你使用的是 rsync（远程同步协议）协议的传输方式。 正是这种容许你在两头的版本库中有不同的打包策略的方式，他意味着你也许在过一段时间之后， 需要在两头的版本库中都重新打包一下。

我们可以通过一个远程的版本库来利用他人的工作，但是，你如何准备一个自己的版本库来供其他人下载呢？ 你在自己的工作目录下进行工作，这样你的版本库就被作为.git的一个子目录放在你的工作树下。 你可以让其他人来远程的访问你的版本库，但是实际上这不是通常的做法。推荐的做法是创建一个公共的版本库， 让它可供其他人访问，并且，当你在你的工作目录下做了很好的改动时，你可以更新到公共的版本库中。这通常称为pushing。

从你的本地的（私有的）版本库中发布改动到你的远程的（公共的）版本库中需要远程机器上的写权限。你需要一个SSH的 帐号来运行一个简单的命令，git-receive-pack。 首先，你需要在远程机器上创建一个空的版本库来存放你的公共版本库。这个空版本库以后将通过pushing来保持更新。 显然，这个版本库之需要在开始的时候创建一次。

你本地的版本库的git目录通常是.git，但是你的公共版本库通常还要加上你的项目名，即.git。 让我们来为my-git创建这样一个版本库。首先，登入远程的机器，创建一个空目录（如果你选择HTTP作为发布方法， 这个空目录需要建在web server的根目录下面）：

$ mkdir my-git.git

然后运行git init-db命令将这个目录加入git版本库中，这里，因为这个版本库的名字不是通常的.git， 我们需要稍微改动一下命令：

$ GIT_DIR=my-git.git git-init-db

有很多种传输方式可以发布公共版本库。这里，要确认这个目录可以通过你选择的传输方式来被其他人访问。你也需要确认 你有git-receive-pack这个程序在$PATH这个路径下。

现在你的“公共的版本库”可以接受你的任何改动了。回到你的本地机上，运行命令：

$ git push :/path/to/my-git.git master

该命令将你的公共版本库和你当前的版本库中指定名称的分支头部同步（这里是master）。举一个实际的例子，你可以 这样来更新公共的git版本库。Kernel.org的镜像网络也这样来同步其他公共的可访问的机器：

$ git push master.kernel.org:/pub/scm/git/git.git/

通过 git 的分支功能，你可以非常容易地做到好像在同一时间进行许多“相关－或－无关”的工作一样。

我们已经通过前面的 "fun and work" 使用两个分支的例子，看到分支是怎么工作的。 这样的思想在多于两个的分支的时候也是一样的，比方说，你现在在 master 的头， 并有些新的代码在 master 中，另外还有两个互不相关的补丁分别在 "commit-fix" 和 "diff-fix" 两个分支中。

$ git show-branch
! [commit-fix] Fix commit message normalization.
 ! [diff-fix] Fix rename detection.
  * [master] Release candidate #1
---
 +  [diff-fix] Fix rename detection.
 +  [diff-fix~1] Better common substring algorithm.


+   [commit-fix] Fix commit message normalization.
  * [master] Release candidate #1
++* [diff-fix~2] Pretty-print messages.

两个补丁我们都测试好了，到这里，你想将他们俩合并起来， 于是你可以先合并 diff-fix ，然后再合并 commit-fix，像这样：

$ git merge 'Merge fix in diff-fix' master diff-fix
$ git merge 'Merge fix in commit-fix' master commit-fix

结果如下：

$ git show-branch
! [commit-fix] Fix commit message normalization.
 ! [diff-fix] Fix rename detection.
  * [master] Merge fix in commit-fix
---
  - [master] Merge fix in commit-fix
+ * [commit-fix] Fix commit message normalization.


  - [master~1] Merge fix in diff-fix
 +* [diff-fix] Fix rename detection.
 +* [diff-fix~1] Better common substring algorithm.
  * [master~2] Release candidate #1
++* [master~3] Pretty-print messages.

然而，当你确信你手头上的确是一堆互不相关的项目变化时，就没有任何理由将这堆东西一个个地合并（ 假如他们的先后顺序很重要，那么他们就不应该被定以为无关的变化）， 你可以一次性将那两个分支合并到当前的分支中，首先我们将我们刚刚做过的事情逆转一下， 我们需要通过将 master 分支重置到 master~2 位置的方法来将它逆转到合并那两个分支之前的状态。

$ git reset --hard master~2

你可以用 git-show-branch 来确认一下的确是回到了两次 git-merge 的状态了。 现在你可以用一行命令将那两个分支导入的方式来替代两次运行（ 也就是所谓的 炮制章鱼 -- making an Octopus）git-merge ：

$ git pull . commit-fix diff-fix
$ git show-branch
! [commit-fix] Fix commit message normalization.
 ! [diff-fix] Fix rename detection.
  * [master] Octopus merge of branches 'diff-fix' and 'commit-fix'


---
  - [master] Octopus merge of branches 'diff-fix' and 'commit-fix'
+ * [commit-fix] Fix commit message normalization.
 +* [diff-fix] Fix rename detection.
 +* [diff-fix~1] Better common substring algorithm.


  * [master~1] Release candidate #1
++* [master~2] Pretty-print messages.

注意那些不适合制作章鱼的场合，尽管你可以那样做。一只“章鱼”往往可以使项目的提交历史更具可读性， 前提是你在同一时间导入的两份以上的变更是互不关联的。 然而，如果你在合并任何分支的过程中出现合并冲突，并且需要手工解决的话， 那意味着这些分支当中有相互干涉的开发工作在进行，那么你就应该将这个两个冲突先合并， 并且记录下你是如何解决这个冲突，以及你首先处理他们的理由。（译者按：处理完冲突之后， 你就可以放心制作“章鱼”了） 否则的话将会造成项目的发展历史很难跟踪。

版本库的管理员可以用下面的工具来建立和维护版本库。

• git-daemon(1) 容许匿名下载版本库。

• git-shell(1) 面向中心版本库模式 的用户的类似 受限的 shell 的命令。

update hook howto 一个很好的管理中心版本库的例子。

例子

在 /pub/scm 上运行 git 守护进程

$ grep git /etc/inet.conf
git     stream  tcp     nowait  nobody \
  /usr/bin/git-daemon git-daemon --inetd --syslog --export-all /pub/scm

这个配置行应该在配置文件中用一行来写完。

仅给开发者 push/pull 的访问权限。

$ grep git /etc/passwd (1)
alice:x:1000:1000::/home/alice:/usr/bin/git-shell
bob:x:1001:1001::/home/bob:/usr/bin/git-shell
cindy:x:1002:1002::/home/cindy:/usr/bin/git-shell
david:x:1003:1003::/home/david:/usr/bin/git-shell


$ grep git /etc/shells (2)
/usr/bin/git-shell

 
(1) 将用户的登录 shell 设定为 /usr/bin/git-shell,
它除了运行 "git-push" 和 "git-pull" 不能做任何事。
这样用户就可以通过 ssh 来访问机器。
(2) 许多的发行版需要在 /etc/shells 配置文件中列明要用什么 shell 来作为登录 shell。

CVS - 模式的公共库。

$ grep git /etc/group (1)
git:x:9418:alice,bob,cindy,david
$ cd /home/devo.git
$ ls -l (2)
  lrwxrwxrwx   1 david git    17 Dec  4 22:40 HEAD -> refs/heads/master
  drwxrwsr-x   2 david git  4096 Dec  4 22:40 branches


  -rw-rw-r--   1 david git    84 Dec  4 22:40 config
  -rw-rw-r--   1 david git    58 Dec  4 22:40 description
  drwxrwsr-x   2 david git  4096 Dec  4 22:40 hooks
  -rw-rw-r--   1 david git 37504 Dec  4 22:40 index


  drwxrwsr-x   2 david git  4096 Dec  4 22:40 info
  drwxrwsr-x   4 david git  4096 Dec  4 22:40 objects
  drwxrwsr-x   4 david git  4096 Nov  7 14:58 refs
  drwxrwsr-x   2 david git  4096 Dec  4 22:40 remotes


$ ls -l hooks/update (3)
  -r-xr-xr-x   1 david git  3536 Dec  4 22:40 update
$ cat info/allowed-users (4)
refs/heads/master       alice\|cindy
refs/heads/doc-update   bob
refs/tags/v[0-9]*       david



(1) 将所有的开发人员都作为 git 组的成员。
(2) 并且给予他们公共版本库的写权限。
(3) 用一个在 Documentation/howto/ 中的 Carl 写的例子来实现版本库的分支控制策略。
(4) Alice 和 Cindy 可以提交入 master 分支，只有 Bob 能提交入 doc-update 分支，
David 则是发行经理只有他能创建并且 push 版本标签。

支持默协议传输的 HTTP 服务器。

dev$ git update-server-info (1)
dev$ ftp user@isp.example.com (2)
ftp> cp -r .git /home/user/myproject.git

(1) 保证 info/refs 和 object/info/packs 是最新的。


(2) 上传到你的 HTTP 服务器主机。

尽管 git 是一个正式项目发布系统，它却可以方便地将你的项目建立在松散的开发人员组织形式上。 Linux 内核的开发，就是按这样的模式进行的。在 Randy Dunlap 的著作中（"Merge to Mainline" 第17页） 就有很好的介绍（http://tinyurl.com/a2jdg）。

需要强调的是正真的非常规的开发组织形式， git 这种组织形式，意味着对于工作流程的约束，没有任何强迫性的原则。 你不必从唯一一个远程版本库中导入（工作目录）。

项目领导人（project lead）的工作推介

1. 在你自己的本地机器上准备好主版本库。你的所有工作都在这里完成。

2. 准备一个能让大家访问的公共版本库。

   如果其他人是通过默协议的方式（http）来导入版本库的，那么你有必要保持这个 默协议的友好性。 git-init-db 之后，复制自标准模板库的 $GIT_DIR/hooks/post-update 将包含一个对 git-update-server-info 的调用，但是 post-update 默认是不能唤起它自身的。 通过 chmod +x post-update 命令使能它。这样让 git-update-server-info 保证那些必要的文件是最新的。

3. 将你的主版本库推入公共版本库。

4. git-repack 公共版本库。这将建立一个包含初始化提交对象集的打包作为项目的起始线， 可能的话，执行一下 git-prune，要是你的公共库是通过 pull 操作来从你打包过的版本库中导入的。

5. 在你的主版本库中开展工作，这些工作可能是你自己的最项目的编辑， 可能是你由 email 收到的一个补丁，也可能是你从这个项目的“子系统负责人” 的公共库中导入的工作等等。

   你可以在任何你喜欢的时候重新打包你的这个私人的版本库。

6. 将项目的进度推入公共库中，并给大家公布一下。

7. 尽管一段时间以后，"git-repack" 公共库。并回到第5步继续工作。

项目的子系统负责人（subsystem maintainer）也有自己的公共库，工作流程大致如下：

1. 准被一个你自己的工作目录，它通过 git-clone 克隆自项目领导人的公共库。 原始的克隆地址（URL）将被保存在 .git/remotes/origin 中。

2. 准备一个可以给大家访问的公共库，就像项目领导人所做的那样。

3. 复制项目领导人的公共库中的打包文件到你的公共库中， 除非你的公共库和项目领导人的公共库是在同一部主机上。 以后你就可以通过 objects/info/alternates 文件的指向来 浏览它所指向的版本库了。

4. 将你的主版本库推入你的公共版本库，并运行 git-repack， 如果你的公共库是通过的公共库是通过 pull 来导入的数据的话， 再执行一下 git-prune 。

5. 在你的主版本库中开展工作。这些工作可能包括你自己的编辑，来自 email 的补丁， 从项目领导人，“下一级子项目负责人”的公共库哪里导入的工作等等。

   你可以在任何时候重新打包你的私人版本库。

6. 将你的变更推入公共库中，并且请“项目领导人”和“下级子系统负责人”导入这些变更。

7. 每隔一段时间之后，git-repack 公共库。回到第 5 步继续工作。

“一般开发人员”无须自己的公共库，大致的工作方式是：

1. 准备你的工作库，它应该用 git-clone 克隆自“项目领导人”的公共库（ 如果你只是开发子项目，那么就克隆“子项目负责人”的）。 克隆的源地址（URL）会被保存到 .git/remotes/origin 中。

2. 在你的个人版本库中的 master 分支中开展工作。

3. 每隔一段时间，向上游的版本库运行一下 git-fetch origin 。 这样只会做 git-pull 一半的操作，即只克隆不合并。 公共版本库的新的头就会被保存到 .git/refs/heads/origins 。

4. 用 git-cherry origin 命令，看一下你有什么补丁被接纳了。 并用 git-rebase origin 命令将你以往的变更迁移到最新的上游版本库的状态中。 （关于 git-rebase 命令，请参考 git-rebase）

5. 用 git-format-patch origin 生成 email 形式的补丁并发给上游的维护者。 回到第二步接着工作。

事实上，千万不要把开源软件想得那么神秘，比如在"InfoWorld2008最佳开源软件大奖"中:
WordPress(Blog搭建)
MediaWiki(Wiki搭建)
VNC(远程桌面)
Flex(Adobe的动画创建SDK)
Puppy Linux(超小体积的Linux系统)
Ubuntu(最受欢迎的桌面Linux系统)
MYSQL(优秀的开源数据库)
phpMyAdmin(MYSQL管理软件)
VirtualBox(虚拟机软件)
Audacity(超赞的音频编辑软件)
Blender(3D建模软件)
FireFox(这个还用说吗?)
GIMP(开源的Photoshop!)
OpenOffice(开源的办公软件)
PDFCreator(PDF创建)
TrueCrypt(非常好的加密软件)
WinMerge(文件比较合并)
这些我们耳熟能详的软件赫然在目。
此外，还有诸如Ophcrack（Windows密码恢复）、Wireshark(网络嗅探),inSSIDer(WIFI网络扫描软件),Prototype(JS基础框架)……等软件的实用和研究价值也非常高。

协同类软件、开发工具

网络应用、平台和中间件

应用软件、安全软件、存储软件

级别： 初级

Srinivasan S. Muthuswamy (smuthusw@in.ibm.com), 软件工程师, IBM Global Services Group
Kavitha Varadarajan (vkavitha@in.ibm.com), 软件工程师, IBM India Software Lab

2005 年 5 月 08 日

随着开发者将原本普遍的 Windows® 应用迁移到 Linux™ 平台，正在进行的向开源迁移的浪潮有可能引发极大的移植问题。这个由三部分构成的系列文章提供一个映射指南，并附有例子，能够简化从 Windows 到 Linux 的转变。第 1 部分介绍了进程和线程。

当前，很多全球商务和服务都正在趋于开源 —— 业界的所有主要参与者都在争取实现此目标。这一趋势催生了一个重要的迁移模式：为不同平台（Windows、OS2、Solaris 等）维持的现有产品将被移植到开放源代码的 Linux 平台。

很多应用程序在设计时并未考虑到需要将它们移植到 Linux。这有可能使移植成为一件痛苦的事情，但并非绝对如此。本系列文章的目的是，帮助您将涉及到 IPC 和线程原语的复杂应用程序从 Windows 迁移到 Linux。我们与您分享迁移这些关键应用程序的经验，包括要求线程同步的多线程应用程序以及要求进程间同步的多进程应用程序。

简言之，可以将此系列文章看作是一个映射文档 —— 它提供了与线程、进程和进程间通信元素（互斥体、信号量等等）相关的各种 Windows 调用到 Linux 调用的映射。我们将那些映射分为三个部分：

• 第 1 部分涉及的是进程和线程。
• 第 2 部分处理的是信号量与事件。
• 第 3 部分涵盖了信号量、关键区域和等待函数。

进程

Windows 中和 Linux 中的基本执行单位是不同的。在 Windows 中，线程是基本执行单位，进程是一个容纳线程的容器。

在 Linux 中，基本执行单位是进程。Windows API 所提供的功能可以直接映射到 Linux 系统调用：

表 1. 进程映射

"类别"一列（解释了本文中所使用的分类结构）表明了 Windows 结构是否 可映射 或者 与上下文相关：

• 如果可映射，则 Windows 结构可以映射到特定的 Linux 结构（需要仔细检查类型、参数、返回代码等）。Windows 和 Linux 结构都提供了类似的功能。
• 如果是与上下文相关，则 Linux 中可能有（也可能没有）相应于给定的 Windows 结构的结构，或者 Linux 可能有不只一个提供类似功能的结构。无论是哪种情况，都要根据应用程序上下文才能确定要使用哪个特定的 Linux 结构。

创建进程

在 Windows 中，您可以使用 CreateProcess() 来创建一个新的进程。 CreateProcess() 函数创建一个新的进程及其主线程，如下：

BOOL CreateProcess(
 LPCTSTR lpApplicationName,                  // name of executable module
  LPTSTR lpCommandLine,                      // command line string
  LPSECURITY_ATTRIBUTES lpProcessAttributes, // SD
  LPSECURITY_ATTRIBUTES lpThreadAttributes,  // SD
  BOOL bInheritHandles,                      // handle inheritance option
  DWORD dwCreationFlags,                     // creation flags
  LPVOID lpEnvironment,                      // new environment block
  LPCTSTR lpCurrentDirectory,                // current directory name
  LPSTARTUPINFO lpStartupInfo,               // startup information
  LPPROCESS_INFORMATION lpProcessInformation // process information
)

bInheritHandles 确定了子进程是否要继承父进程的句柄。lpApplicationName 和 lpCommandLine 给出了将要被启动的进程的名称与路径。lpEnvironment 定义了进程可使用的环境变量。

在 Linux 中，exec* 家族函数使用一个新的进程映像取代当前进程映像（如下所示）：

int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int  execle(const  char  *path,  const  char  *arg  , ..., char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);

exec* 的这些版本只是内核函数 execve() （int execve(const char *filename, char *const argv [], char *const envp[])）的各种调用接口。在这里，argv 是包含有参数 list 的指针，envp 是包含有环境变量列表（主要是 key=value 对）的指针。

它必须与 fork() 命令一起使用，所以父进程和子进程都在运行： pid_t fork(void)。fork() 会创建一个子进程，与父进程相比只是 PID 和 PPID 不同；实际上，资源利用设为 0。

默认情况下，exec() 继承父进程的组和用户 ID，这就使得它会依赖于父进程。可以使用以下方法来改变：

• 设置指定程序文件的 set-uid 和 set-gid 位
• 使用 setpgid() 和 setuid() 系统调用

CreateProcessAsUser() 函数与 CreateProcess() 类似，只是新进程是在用户通过 hToken 参数描述的安全上下文中运行。在 Linux 中，没有与此函数惟一对应的函数，但是可以使用下面的逻辑来实现对它的复制：

• 使用 fork() 创建一个具有新的 PID 的子进程
• 使用 setuid() 切换到那个新的 PID
• 使用 exec() 将现有进程改变为将要执行的进程

终止进程

在 Windows 中，您可以使用 TerminateProcess() 强制终止一个运行中的进程。

BOOL TerminateProcess(
  HANDLE hProcess, // handle to the process
  UINT uExitCode   // exit code for the process
);

这个函数终止运行中的进程及其相关线程。只是在非常极端的场合才会使用这个函数。

在 Linux 中，您可以使用 kill() 来强行杀死一个进程： int kill(pid_t pid, int sig)。这个系统调用会终止 id 为 PID 的进程。您也可以使用它向任何组或者进程发出信号。

使用等待函数

在子进程依赖于父进程的情况下，您可以在父进程中使用等待函数来等待子进程的终止。在 Windows 中，您可以使用 WaitForSingleObject() 函数调用来实现此功能。

您可以使用 WaitForMultipleObject() 函数来等待多个对象。

DWORD WaitForMultipleObjects(
  DWORD nCount,             // number of handles in array
  CONST HANDLE *lpHandles,  // object-handle array
  BOOL bWaitAll,            // wait option
  DWORD dwMilliseconds      // time-out interval
);

您可以向对象句柄数组（object-handle array）中填充很多需要等待的对象。根据 bWaitALL 选项，您既可以等待所有对象被信号通知，也可以等待其中任意一个被信号通知。

在这两个函数中，如果您想等待有限的一段时间，则可以在第二个参数中指定时间间隔。如果您想无限制等待，那么使用 INFINITE 作为 dwMilliseconds 的值。将 dwMilliseconds 设置为 0 则只是检测对象的状态并返回。

在 Linux 中，如果您希望无限期等待进程被杀死，则可以使用 waitpid()。在 Linux 中，使用 waitpid() 调用无法等待限定的时间。

在这段代码中：pid_t waitpid(pid_t pid, int *status, int options)，waitpid() 会无限期等待子进程的终止。在 Windows 和 Linux 中，等待函数会挂起当前进程的执行，直到它完成等待，不过，在 Windows 中可以选择在指定的时间后退出。使用 System V 信号量，您可以实现类似于 WaitForSingleObject() 和 WaitForMultipleObject() 的限时等待或者 NO WAIT 功能，在本系列的第 2 部分中将讨论此内容。本系列的第 3 部分将深入讨论等待函数。

退出进程

退出进程指的是优雅（graceful）地退出进程，并完成适当的清除工作。在 Windows 中，您可以使用 ExitProcess() 来执行此操作。

VOID ExitProcess(
  UINT uExitCode   // exit code for all threads
);

ExitProcess() 是在进程结束处执行的方法。这个函数能够干净地停止进程。包括调用所有链接到的动态链接库（DLL）的入口点函数，给出一个值，指出这个进程正在解除那个 DLL 的链接。

Linux 中与 ExitProcess() 相对应的是 exit()：void exit(int status);。

exit() 函数会令程序正常终止，并将 &0377 状态值返回给父进程。 C 语言标准规定了两个定义（EXIT_SUCCESS 和 EXIT_FAILURE），可以被传递到状态参数，以说明终止成功或者不成功。

环境变量

每个进程都拥有关联到它的一组环境，其中主要是 name=value 对，指明进程可以访问的各种环境变量。尽管我们可以在创建进程时指定环境，不过也有特定函数可以在进程创建后设置和获得环境变量。

在 Windows 中，您可以使用 GetEnvironmentVariable() 和 SetEnvironmentVariable() 来获得和设置环境变量。

DWORD GetEnvironmentVariable(
  LPCTSTR lpName,  // environment variable name
  LPTSTR lpBuffer, // buffer for variable value
  DWORD nSize      // size of buffer
);

如果成功，则此函数返回值缓存的大小，如果指定的名称并不是一个合法的环境变量名，则返回 0。 SetEnvironmentVariable() 函数为当前进程设置指定的环境变量的内容。

BOOL SetEnvironmentVariable(
  LPCTSTR lpName,  // environment variable name
  LPCTSTR lpValue  // new value for variable
);

如果函数成功，则返回值非零。如果函数失败，则返回值为零。

在 Linux 中，getenv() 和 setenv() 系统调用提供了相应的功能。

char *getenv(const char *name);
int setenv(const char *name, const char *value, int overwrite);

getenv() 函数会在环境列表中搜索与名称字符串相匹配的字符串。这个函数会返回一个指向环境中的值的指针，或者如果不匹配则返回 NULL。setenv() 函数将变量名和值添加到环境中，如果那个名称并不存在。如果环境中已经存在那个名称，而且如果 overwrite 非零，则它的值会被修改为 value。如果 overwrite 为零，则 name 的值不会被改变。如果成功，则 setenv() 会返回零，如果环境中空间不足，则返回 -1。

例子

下面的例子解释了我们在本节中讨论的内容。

清单 1. Windows 进程代码

				
//Sample Application that explain process concepts
//Parameters Declaration/Definition
int TimetoWait;
STARTUPINFO si;
PROCESS_INFORMATION pi;
LPTSTR lpszCurrValue,LPTSTR lpszVariable;
TCHAR tchBuf[BUFSIZE];
BOOL fSuccess;
if(argc > 2)
{
    printf("InvalidArgument");
    ExitProcess(1); //Failure
}
//Get and display an  environment variable PATH
lpszCurrValue = ((GetEnvironmentVariable("PATH",tchBuf, BUFSIZE) > 0) ? tchBuf : NULL);
lpszVariable = lpszCurrValue;
//Display the environment variable
while (*lpszVariable)
    putchar(*lpszVariable++);
putchar('\n');
//Initialise si and pi
ZeroMemory( &si, sizeof(si) );
si.cb = sizeof(si);
ZeroMemory( &pi, sizeof(pi) );
//Create a childProcess
if( !CreateProcess( NULL,             // No module name (use command line).
                    "SomeProcess",    // Command line.
                    NULL,             // Process handle not inheritable.
                    NULL,             // Thread handle not inheritable.
                    FALSE,            // Set handle inheritance to FALSE.
                    0,                // No creation flags.
                    NULL,             // Use parent's environment block.
                    NULL,             // Use parent's starting directory.
                    &si,              // Pointer to STARTUPINFO structure.
                    &pi )             // Pointer to PROCESS_INFORMATION structure.
                        )
{
    printf( "CreateProcess failed." );
}
// Wait until child process exits.
if(argc == 2)
{
    TIMEOUT = atoi(argv[1]);
    ret = WaitForSingleObject( pi.hProcess, TIMEOUT );
    if(ret == WAIT_TIMEOUT)
    {
        TerminateProcess(pi.hProcess);
    }
}
else
{
    WaitForSingleObject( pi.hProcess, INFINITE );
    ...
}
    ExitProcess(0); //Success

清单 2. 相应的 Linux 进程代码

				
#include <stdlib.h>
int main(int argc,char *argv[])
{
    //Parameters Declaration/Definition
    char PathName[255];
    char *Argptr[20];
    int rc;
    char *EnvValue,*lpszVariable;
    if(argc > 1)
    {
        printf(" Wrong parameters !!");
        exit(EXIT_FAILURE);
    }
    //Get and display an  environment variable PATH
    EnvValue = getenv("PATH");
    if(EnvValue == NULL)
    {
        printf("Invalid environment variable passed as param !!");
    }else
    {
        lpszVariable = EnvValue;
        while (*lpszVariable)
            putchar(*lpszVariable++);
        putchar('\n');
    }
    rc = fork(); //variable rc's value on success would be process ID in the parent
                 //process, and 0 in the child's thread of execution.
    switch(rc)
    {
        case -1:
            printf("Fork() function failed !!");
            ret = -1;
            break;
        case 0:
            printf("Child process...");
            setpgid(0,0);  //Change the parent grp ID to 0
        ret = execv(PathName,Argptr); // there are other flavours of exec available,
                                      // u can use any of them based on the arguments.
        if(ret == -1)
        {
            kill(getpid(),0);
        }
        break;
         default:
             // infinitely waits for child process to die
             Waitpid(rc,&status,WNOHANG);
             //Note RC will have PID returned since this is parent process.
             break;
    }
    exit(EXIT_SUCCESS);
}

回页首

线程

在 Windows 中，线程是基本的执行单位。在进程的上下文中会有一个或多个线程在运行。调度代码在内核中实现。没有单独的"调度器（scheduler）"模块或例程。

Linux 内核使用的是进程模型，而不是线程模型。Linux 内核提供了一个轻量级进程框架来创建线程；实际的线程在用户空间中实现。在 Linux 中有多种可用的线程库（LinuxThreads、NGPT、NPTL 等等）。本文中的资料基于 LinuxThreads 库，不过这里的资料也适用于 Red Hat 的 Native POSIX Threading Library（NPTL）。

本节描述 Windows 和 Linux 中的线程。内容涵盖了创建线程、设置其属性以及修改其优先级。

表 2. 线程映射

创建线程

在 Windows 中，您可以使用 CreateThread() 来创建线程，创建的线程在调用进程的虚拟地址空间中运行。

HANDLE CreateThread(
  LPSECURITY_ATTRIBUTES lpThreadAttributes,     // SD
  SIZE_T dwStackSize,                           // initial stack size
  LPTHREAD_START_ROUTINE lpStartAddress,        // thread function
  LPVOID lpParameter,                           // thread argument
  DWORD dwCreationFlags,                        // creation option
  LPDWORD lpThreadId                            // thread identifier
);

lpThreadAttributes 是指向线程属性的指针，决定了线程句柄是否能由子进程继承。

Linux 使用 pthread 库调用 pthread_create() 来派生线程：

int pthread_create (pthread_t *thread_id, pthread_attr_t *threadAttr,
                    void * (*start_address)(void *), void * arg);

注意：在 Windows 中，受可用虚拟内存的限制，一个进程可以创建的线程数目是有限的。默认情况下，每个线程有一兆栈空间。因此，您最多可以创建 2,028 个线程。如果您减小默认栈大小，那么可以创建更多线程。在 Linux 中，使用 ULIMIT -a（limits for all users）可以获得每个用户可以创建的线程的最大数目，可以使用 ULIMIT -u 来修改它，不过只有在登录时才可以这样做。 /usr/Include/limit.h 和 ulimit.h 下的头文件定义了这些内容。您可以修改它们并重新编译内核，以使其永久生效。对于 POSIX 线程限制而言，local_lim.h 中定义的 THREAD_THREADS_MAX 宏定义了数目的上限。

指定线程函数

CreateThread() 中的 lpStartAddress 参数是刚创建的线程要执行的函数的地址。

pthread_create() 库调用的 start_address 参数是刚创建的线程要执行的函数的地址。

传递给线程函数的参数

在 Windows 中，系统调用 CreateThread() 的参数 lpParameter 指定了要传递给刚创建的线程的参数。它指明了将要传递给新线程的数据条目的地址。

在 Linux 中，库调用 pthread_create() 的参数 arg 指定了将要传递给新线程的参数。

设置栈大小

在 Windows 中，CreateThread() 的参数 dwStackSize 是将要分配给新线程的以字节为单位的栈大小。栈大小应该是 4 KB 的非零整数倍，最小为 8 KB。

在 Linux 中，栈大小在线程属性对象中设置；也就是说，将类型为 pthread_attr_t 的参数 threadAttr 传递给库调用 pthread_create()。在设置任何属性之前，需要通过调用 pthread_attr_init() 来初始化这个对象。使用调用 pthread_attr_destroy() 来销毁属性对象：

int pthread_attr_init(pthread_attr_t *threadAttr);
int pthread_attr_destroy(pthread_attr_t *threadAttr);

注意，所有 pthread_attr_setxxxx 调用都有与 pthread_xxxx 调用（如果有）类似的功能，只是您只能在线程创建之前使用 pthread_attr_xxxx，来更新将要作为参数传递给 pthread_create 的属性对象。同时，您在创建线程之后的任意时候都可以使用 pthread_xxxx。

使用调用 pthread_attr_setstacksize() 来设置栈大小： int pthread_attr_setstacksize(pthread_attr_t *threadAttr, int stack_size);。

退出线程

在 Windows 中，系统调用 ExitThread() 会终止线程。 dwExitCode 是线程的返回值，另一个线程通过调用 GetExitCodeThread() 就可以得到它。

VOID ExitThread(
  DWORD dwExitCode   // exit code for this thread
);

Linux 中与此相对应的是库调用 pthread_exit()。 retval 是线程的返回值，可以在另一个线程中通过调用 pthread_join() 来获得它： int pthread_exit(void* retval);。

线程状态

在 Windows 中，没有保持关于线程终止的显式线程状态。不过，WaitForSingleObject() 让线程能够显式地等待进程中某个指定的或者非指定的线程终止。

在 Linux 中，默认以可连接（joinable）的状态创建线程。在可连接状态中，另一个线程可以同步这个线程的终止，使用函数 pthread_join() 来重新获得其终止代码。可连接的线程只有在被连接后才释放线程资源。

Windows 使用 WaitForSingleObject() 来等待某个线程终止：

DWORD WaitForSingleObject(
  HANDLE hHandle,
  DWORD dwMilliseconds
);

其中：

• hHandle 是指向线程句柄的指针。
• dwMilliseconds 是以毫秒为单位的超时值。如果这个值被设置为 INFINITE，则它会无限期地阻塞进行调用的线程/进程。

Linux 使用 pthread_join() 来完成同样的功能： int pthread_join(pthread_t *thread, void **thread_return);。

在分离的状态中，线程终止后线程资源会立即被释放。通过对线程属性对象调用 pthread_attr_setdetachstate() 可以设置分离状态： int pthread_attr_setdetachstate (pthread_attr_t *attr, int detachstate);。以可连接状态创建的线程，稍后可以被转为分离状态，方法是使用 pthread_detach() 调用：int pthread_detach (pthread_t id);。

改变优先级

在 Windows 中，线程的优先级由其进程的优先级等级以及进程优先级等级中的线程优先级层次决定。在 Linux 中，线程本身就是一个执行单位，有其自己的优先级。它与其进程的优先级没有依赖关系。

在 Windows 中，您可以使用 SetPriorityClass() 来设置特定进程的优先级等级：

BOOL SetPriorityClass(
  HANDLE hProcess,         // handle to the process
  DWORD dwPriorityClass    // Priority class
);

dwPriorityClass 是进程的优先级等级，它可以设置为下列值中的任意一个：

• IDLE_PRIORITY_CLASS
• BELOW_NORMAL_PRIORITY_CLASS
• NORMAL_PRIORITY_CLASS
• ABOVE_NORMAL_PRIORITY_CLASS
• HIGH_PRIORITY_CLASS
• REALTIME_PRIORITY_CLASS

一旦设置了进程的优先级等级，就可以使用 SetThreadPriority() 在进程的优先级等级内部设置线程的优先级层次：

BOOL SetThreadPriority(
  HANDLE hThread,
  int nPriority
);

nPriority 是线程的优先级值，它被设置为下列之一；

• THREAD_PRIORITY_ABOVE_NORMAL 将优先级设置为比优先级等级高 1 级。
• THREAD_PRIORITY_BELOW_NORMAL 将优先级设置为比优先级等级低 1 级。
• THREAD_PRIORITY_HIGHEST 将优先级设置为比优先级等级高 2 级。
• THREAD_PRIORITY_IDLE 为 IDLE_PRIORITY_CLASS、BELOW_NORMAL_PRIORITY_CLASS、NORMAL_PRIORITY_CLASS、ABOVE_NORMAL_PRIORITY_CLASS 或 HIGH_PRIORITY_CLASS 进程将基优先级设置 1，为 REALTIME_PRIORITY_CLASS 进程将基优先级设置为 16。
• THREAD_PRIORITY_LOWEST 将优先级设置为比优先级等级低 2 级。
• THREAD_PRIORITY_NORMAL 为优先级等级设置为普通优先级。
• THREAD_PRIORITY_TIME_CRITICAL 为 IDLE_PRIORITY_CLASS、BELOW_NORMAL_PRIORITY_CLASS、NORMAL_PRIORITY_CLASS、ABOVE_NORMAL_PRIORITY_CLASS 或 HIGH_PRIORITY_CLASS 进程将基优先级设置 15，为 REALTIME_PRIORITY_CLASS 进程将基优先级设置为 31。

回页首

进程和线程的例子

为了结束这一期文章，让我们来看下面类型的进程和线程的一些例子：

• 普通的或者常规的进程和线程
• 对时间要求严格的（time-critical）或者实时的进程和线程

普通的或常规的进程/线程

使用 Linux 系统调用 setpriority() 来设置或者修改普通进程和线程的优先级层次。参数的范围是 PRIO_PROCESS。将 id 设置为 0 来修改当前进程（或线程）的优先级。此外，delta 是优先级的值 —— 这一次是从 -20 到 20。另外，要注意在 Linux 中较低的 delta 值代表较高的优先级。所以，使用 +20 设置 IDLETIME 优先级，使用 0 设置 REGULAR 优先级。

在 Windows 中，常规线程的优先级的范围是从 1（较低的优先级）到 15（较高的优先级）。不过，在 Linux 中，普通非实时进程的优先级范围是从 -20（较高的）到 +20（较低的）。在使用之前必须对此进行映射： int setpriority(int scope, int id, int delta);。

对时间要求严格的和实时的进程和线程

您可以使用 Linux 系统调用 sched_setscheduler() 来修改正在运行的进程的调度优先级： int sched_setscheduler(pit_t pid, int policy, const struct sched_param *param);。

参数 policy 是调度策略。policy 的可能的值是 SCHED_OTHER （常规的非实时调度）、SCHED_RR（实时 round-robin 策略）和 SCHED_FIFO（实时 FIFO 策略）。

在此，param 是指向描述调度优先级结构体的指针。它的范围是 1 到 99，只用于实时策略。对于其他的（普通的非实时进程），它为零。

在 Linux 中，作为一个大家所熟知的调度策略，也可以通过使用系统调用 sched_setparam 来仅修改进程优先级： int sched_setparam(pit_t pid, const struct sched_param *param);。

LinuxThreads 库调用 pthread_setschedparam 是 sched_setscheduler 的线程版本，用于动态修改运行着的线程的调度优先级和策略： int pthread_setschedparam(pthread_t target_thread, int policy, const struct sched_param *param);。

参数 target_thread 告知线程要修改谁的优先级；param 指定了优先级。

LinuxThreads 库会调用 pthread_attr_setschedpolicy，并且您可以在线程被创建之前使用 pthread_attr_setschedparam 来设置线程属性对象的调度策略和优先级层次：

int pthread_attr_setschedpolicy(pthread attr_t *threadAttr, int policy);
int pthread_attr_setschedparam(pthread attr_t *threadAttr, const struct sched_param *param);

在 Windows 中，实时线程的优先级范围是从 16（较低的优先级）到 31（较高的优先级）。在 Linux 中，实时线程的优先级范围是从 99（较高的）到 1（较低的优先级）。在使用前必须对此进行映射。

例子

下面的清单阐述了本节中的概念。

清单 3. Windows 线程示例

				
				Main Thread
enum stackSize = 120 * 1024 ;
// create a thread normal and real time thread
DWORD  normalTId, realTID;
HANDLE normalTHandle, realTHandle;
normalTHandle = CreateThread(
                NULL,            // default security attributes
                stackSize,       // 120K
                NormalThread,    // thread function
                NULL,            // argument to thread function
                0,               // use default creation flags
                &normalTId);     // returns the thread identifier
// Set the priority class as "High priority"
SetPriorityClass(pHandle, HIGH_PRIORITY_CLASS);
normalTHandle = CreateThread(
                 NULL,            // default security attributes
                 stackSize,       // 120K
                 NormalThread,    // thread function
                 NULL,            // argument to thread function
                 0,               // use default creation flags
                &normalTId);     // returns the thread identifier
CloseHandle(threadHandle);
...
...
// Thread function
DWORD WINAPI NormalThread ( LPVOID lpParam )
{
    HANDLE tHandle,pHandle;
    pHandle = GetCurrentProcess();
    tHandle = GetCurrentThread();
    // Set the priority class as "High priority"
    SetPriorityClass(pHandle, HIGH_PRIORITY_CLASS);
    // increase the priority by 2 points above the priority class
    SetThreadPriority(tHandle,THREAD_PRIORITY_HIGHEST);
    // perform job at high priority
    ...
    ...
    ...
    // Reset the priority class as "Normal"
   SetPriorityClass(pHandle, NORMAL_PRIORITY_CLASS);
    // set the priority back to normal
    SetThreadPriority(tHandle,THREAD_PRIORITY_NORMAL);
    // Exit thread
    ExitThread(0);
}
// Thread function
DWORD WINAPI RealTimeThread ( LPVOID lpParam )
{
    HANDLE tHandle, pHandle ;
    pHandle = GetCurrentProcess();
    tHandle = GetCurrentThread  ();
    // Set the priority class as "Real time"
   SetPriorityClass(pHandle, REALTIME_PRIORITY_CLASS);
    // increase the priority by 2 points above the priority class
    SetThreadPriority(tHandle,THREAD_PRIORITY_HIGHEST);
    // do time critical work
    ...
    ...
    ...
    // Reset the priority class as "Normal"
   SetPriorityClass(pHandle, NORMAL_PRIORITY_CLASS);
    // Reset the priority back to normal
    SetThreadPriority(tHandle,THREAD_PRIORITY_NORMAL);
    ExitThread(0);
}

清单 4. Linux 相应的线程代码

				
static void * RegularThread (void *);
static void * CriticalThread (void *);
// Main Thread
       pthread_t thread1, thread2;  // thread identifiers
       pthread_attr_t threadAttr;
       struct sched_param param;  // scheduling priority
       // initialize the thread attribute
       pthread_attr_init(&threadAttr);
       // Set the stack size of the thread
       pthread_attr_setstacksize(&threadAttr, 120*1024);
       // Set thread to detached state. No need for pthread_join
       pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED);
       // Create the threads
       pthread_create(&thread1, &threadAttr, RegularThread, NULL);
       pthread_create(&thread2, &threadAttr, CriticalThread,NULL);
       // Destroy the thread attributes
       pthread_attr_destroy(&threadAttr);
       ...
       ...
  // Regular non-realtime Thread function
  static void * RegularThread (void *d)   {
       int priority = -18;
       // Increase the priority
       setpriority(PRIO_PROCESS, 0, priority);
       // perform high priority job
       ...
       ...
       // set the priority back to normal
       setpriority(PRIO_PROCESS, 0, 0);
       pthread_exit(NULL);
   }
   // Time Critical Realtime Thread function
   static void * CriticalThread (void *d) {
       // Increase the priority
        struct sched_param param;  // scheduling priority
        int policy = SCHED_RR;     // scheduling policy
        // Get the current thread id
        pthread_t thread_id = pthread_self();
        // To set the scheduling priority of the thread
        param.sched_priority = 90;
        pthread_setschedparam(thread_id, policy, &param);
        // Perform time critical task
        ...
        ...
        // set the priority back to normal
        param.sched_priority = 0;
        policy = 0;             // for normal threads
        pthread_setschedparam(thread_id, policy, &param);
        ....
        ....
        pthread_exit(NULL);
   }

回页首

结束语

本系列文章的第 1 部分已经给出了一个指南，能够帮助您将 Windows 进程和线程映射到 Linux 中的对应物。系列的第 2 部分介绍了同步对象和原语，首先是信号量和事件。第 3 部分介绍了互斥体、关键区域和等待函数。

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文。
  
  
• Bradford Nichols、Dick Buttlar 和 Jacqueline Proulx Farrel 所著的 Pthreads Programming 一书中的在线代码示例解释了本文中的概念。
  
  
• 不要忘记去查看 Linux Threads FAQ、 Linux Manpages Online 以及 LinuxThreads library，以获得关于特定调用以及在 Linux 中进行线程编程的更多细节。
  
  
• 要深入了解 Linux 中的线程编程，请阅读以下 developerWorks 文章："pthreads 的基本用法" （developerWorks，2004 年 1 月）和"POSIX threads explained" （developerWorks，2000 年 7 月）。
  
  
• developerWorks 系列文章 "将应用程序从 OS/2 移植到 Linux 上: 第 1 部分，线程、互斥锁、信号量" （developerWorks，2004 年 2 月）是了解迁移过程中哪些被映射的有益参考资料。
  
  
• 在 developerWorks Linux 专区 可以找到更多为 Linux 开发者准备的参考资料。
  
  
• 通过参与 developerWorks blogs 加入 developerWorks 社区。
  
  
• 在 Developer 的 Bookstore Linux 区购买 打折出售的 Linux 书籍。
  
  
• 订购免费的 SEK for Linux，这套 DVD （两张），包含了来自 DB2®、Lotus®、Rational®、 Tivoli® 和 WebSphere® 的最新的用于 Linux 的 IBM 试用软件。
  
  
• 使用可以直接从 developerWorks 下载的 IBM 试用软件 来改革您的下一个 Linux 开发项目。
  

作者简介

		Srinivasan S. Muthuswamy 是 IBM Global Services Group 的一位软件工程师。他于 2000 年加入 IBM，他所精通的编程语言涵盖了多种平台上（Linux、Windows、WebSphere、Lotus 等等）的脚本语言以及面向对象和面向过程的语言。他已经开发的解决方案包括 Linux 和 Windows 上的系统编程以及用于 J2EE 的 Web 解决方案。他在印度的 Coimbatore 国立科技大学（Government College of Technology）获得计算机工程学士学位，主要致力于集成和迁移。您可以通过 smuthusw@in.ibm.com 与他联系。

		从 2000 年 12 月起，Kavitha Varadarajan 一直在 IBM India Software Lab 担任软件工程师。她的工作经验包括 host-access 客户机产品（比如 PCOMM）和网络软件（比如通信服务器）的开发与支持。Varadarajan 拥有迁移项目的实践经验，其中涉及到了面向对象 IPC Windows 应用程序向 Linux 的移植。她拥有印度的 Tanjore 山姆哈工程大学（Shanmugha College of Engineering）的计算机科学与工程硕士学位。您可以通过 vkavitha@in.ibm.com 与她联系。

级别： 初级

Nam Keung (mailto:namkeung@us.ibm.com), 高级程序员, IBM　

2005 年 4 月 21 日

将您的 Win32 C/C++ 应用程序迁移到 POWER™ 上的 Linux™，并从信号（semaphore）应用程序接口（application program interface，API）的角度理解 Win32 到 Linux 的映射。Nam Keung 将通过详细的代码示例来为您描述这一过程。

介绍

本系列第三篇文章从信号的角度阐述了 Win32 C/++ 应用程序向 POWER 上的 Linux 的迁移。本系列的第 1 部分介绍了 Win32 API 映射，第 2 部分从互斥（mutex）API 的角度集中阐述了如何将 Win32 映射到 Linux。在继续阅读之前，建议您先去阅读本系列的第 1 部分和第 2 部分。

回页首

信号

信号是包含有一个正数的资源。信号允许进程通过一个单一的原子操作来测试和设置那个整数的值，以此实现同步。通常，信号的主要用途是同步某个线程与其他线程的动作。在多个进程竞争访问同一操作系统资源时，这也是协调或者同步那些行为的一种实用技术。

Linux 支持 Portable Operating System Interface（POSIX）信号以及 pthread 条件变量，以此来映射 Win32 信号 API。它们各有其优缺点。您应该基于应用程序的逻辑来判断使用哪种方法。在映射事件信号的过程中需要考虑的方面包括：

• 信号的类型：Win32 既支持有名称的事件信号，也支持无名称的事件信号。有名称的信号是在多个进程间共享的。Linux 不支持这种方案。本文中列出的一个进程间通信（Inter-Process Communication，IPC）消息队列示例代码将向您展示如何来解决此问题。
• 初始状态：在 Win32 中，信号可能会有初始值。在 Linux 中，POSIX 信号支持此功能，但 pthreads 不支持。在使用 pthreads 时您需要考虑到这一点。
• 超时：Win32 事件信号支持定时等待。在 Linux 中，POSIX 信号实现只支持不确定的等待（阻塞）。pthreads 实现既支持阻塞也支持超时。pthread_cond_timedwait() 调用能给出等待期间的超时的值，pthread_cond_wait() 则用于不确定的等待。
• 发信号：在 Win32 中，发出信号会唤醒等待那个信号的所有线程。在 Linux 中，POSIX 线程实现一次只唤醒一个线程。pthreads 实现的 pthread_cond_signal() 调用会唤醒一个线程，pthread_cond_broadcast() 调用会向所有等待那个信号的线程发出信号。

表 1. 信号映射表

回页首

条件变量

条件变量让开发者能够实现一个条件，在这个条件下线程执行然后被阻塞。Microsoft® Win32 接口本身不支持条件变量。为解决此缺憾，我使用 POSIX 条件变量模拟同步原语，并在一系列文章中对此进行了概述。在 Linux 中，它可以确保因某条件被阻塞的线程，当那个条件改变时，会被解除阻塞。它还允许您原子地（atomically）解除互斥的锁定，并等待条件变量，而不会有干涉其他线程的可能。不过，每个条件变量都应该伴有一个互斥。前面的表 1 给出了用于线程间同步的 pthread 条件变量。

回页首

创建信号

在 Win32 中，CreateSemaphore 函数可以创建一个有名称的或者无名称的信号对象。Linux 不支持有名称的信号。

清单 1. 创建信号

HANDLE CreateSemaphore (
	LPSECURITY_ATTRIBUTES	lpSemaphoreAttributes,
	LONG			lInitialCount,
	LONG			lMaximunCount,
	LPCTSTR			lpName
); 

在 Linux 中，sem_init() 调用会创建一个 POSIX 信号：


清单 2. POSIX 信号

                    
int sem_init(sem_t *sem, int pshared, unsigned int value

Linux 使用 pthread_condition_init 调用在当前进程内创建信号对象，在其中维持一个在零与最大值之间的计数值。每次有某个线程完成对信号的等待，这个计数值会减小，而每次当某个线程释放这个信号时，计数值增加。当计数值成为零时，信号对象的状态成为 non-signaled。


清单 3. 创建信号对象的 pthread_condition_init 调用

                    
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

清单 4. Win32 示例代码

                
HANDLE semHandle;
semHandle = CreateSemaphore(NULL, 0, 256000, NULL); 
     /* Default security descriptor     */
if( semHandle == (HANDLE) NULL)                     
     /* Semaphore object without a name */
{
     return RC_OBJECT_NOT_CREATED;
}

                
typedef struct 
{
	pthread_mutex_t	mutex;
	pthread_cond_t		condition;
	int			semCount;	
}sem_private_struct, *sem_private;
sem_private    token;
token = (sem_private) malloc(sizeof(sem_private_struct));
if(rc = pthread_mutex_init(&(token->mutex), NULL))
{
	free(token);
	return RC_OBJECT_NOT_CREATED;
}
if(rc = pthread_cond_init(&(token->condition), NULL))
{
	pthread_mutex_destroy( &(token->mutex) );
	free(token);
	return RC_OBJECT_NOT_CREATED;
}
token->semCount = 0;

回页首

销毁事件信号

Win32 使用 CloseHandle 来删除由 CreateSemaphore 所创建的信号对象。

清单 6. 销毁事件信号

BOOL CloseHandle (HANDLE hObject);

Linux POSIX 信号使用 sem_destroy() 来销毁无名称的信号。

清单 7. sem_destroy()

                
int sem_destroy(sem_t *sem);

在 Linux pthreads 中，使用 pthread_cond_destroy() 来销毁条件变量。


清单 8. pthread_cond_destroy()

                    
int pthread_cond_destroy(pthread_cond_t *cond);

清单 9. Win32 代码和相应的 Linux 代码

回页首

发布事件信号

在 Win32 中，ReleaseSemaphore 函数会令指定的信号对象的计数值增加指定数量。


清单 10. ReleaseSemaphore 函数

                    
BOOL ReleaseSemaphore(
	HANDLE hSemaphore,
	LONG 	lReleaseCount,
	LPLONG	lpPreviousCount
);

Linux POSIX 信号使用 sem_post() 来发布事件信号。这将唤醒阻塞于此信号的所有线程。


清单 11. sem_post()

                    
int sem_post(sem_t * sem);

在 Linux 中，pthread_cond_signal 会唤醒等待某个条件变更的某个线程。Linux 调用这个函数来为此对象所标识的信号发布一个事件完成信号。调用的线程增加那个信号的值。如果信号的值从零开始增加，而且 pthread_cond 中有任何线程被阻塞，那么请等待这个信号，因为其中一个会被唤醒。默认情况下，实现可以选择任意的正在等待的线程。


清单 12. pthread_cond_signal

                    
int pthread_cond_signal(pthread_cond_t *cond);

清单 13. Win32 代码和相应的 Linux 代码

回页首

等待事件信号

Win32 调用 WaitForSingleObject 函数来等待所需要的信号上事件的完成。当等待单一线程同步对象时，可以使用此方法。当对象被设置发出信号或者超时时间段结束时，这个方法会得到通知。如果时间间隔是 INFINITE，那么它就会无止境地等待下去。


清单 14. WaitForSingleObject 函数

                    
DWORD WaitForSingleObject(
	HANDLE hHANDLE,
	DWORD	dwMilliseconds
);

使用 WaitForMultipleObjects 函数来等待多个被通知的对象。在信号线程同步对象中，当计数器变为零时，对象是 non-signaled。


清单 15. WaitForMultipleObjects 函数

                    
DWORD WaitForMultipleObjects(
	DWORD	nCount,
	Const	HANDLE* lpHandles,
	BOOL	bWaitAll,
	DWORD	dwMilliseconds
);

Linux POSIX 信号使用 sem_wait() 来挂起发出调用的线程，直到信号拥有了非零的计数值。然后它自动地减少信号的计数值。


清单 16. sem_wait() 函数

                    
int sem_wait(sem_t * sem);

在 POSIX 信号中不能使用超时选项。不过，您可以通过在某个循环中执行非阻塞的 sem_trywait() 来完成此功能，它会计算超时的值。


清单 17. sem_trywait() 函数

                    
int sem_trywait(sem_t  * sem);

在 Linux 中，pthread_cond_wait() 会阻塞发出调用的线程。发出调用的线程会减小那个信号。如果当 pthread_cond_wait 被调用时信号是零，则 pthread_cond_wait() 就会阻塞，直到另一个线程增加了那个信号的值。


清单 18. pthread_cond_wait() 函数

                    
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t  *mutex);

pthread_cond_wait 函数首先释放相关联的 external_mutex of type pthread_mutex_t，当调用者检查条件表达式时必须持有它。

清单 19. Win32 代码和相应的 Linux 代码

如果您需要在指定的一段时间内阻塞发出调用的线程，那么请使用 pthread_cond_timewait 来阻塞它。调用这个方法来等待所需要信号上某个事件的完成，等待指定的一段时间。

清单 20. pthread_cond_timewait

                
	int pthread_cond_timewait(
	pthread_cond_t		*cond,
	pthread_mutex_t		*mutex,
	timespec		*tm
);			

回页首

POSIX 信号示例代码

清单 22 使用 POSIX 信号来实现线程 A 和 B 之间的同步：


清单 22. POSIX 信号示例代码

                    
sem_t sem; /* semaphore object */
int irc;   /* return code */
/* Initialize the semaphore - count is set to 1*/
irc = sem_init (sem, 0,1)
...
/* In Thread A */
/* Wait for event to be posted */
sem_wait (&sem);
/* Unblocks immediately as semaphore initial count was set to 1 */
 .......
/* Wait again for event to be posted */
sem_wait (&sem);
/* Blocks till event is posted */
/* In Thread B */
/* Post the semaphore */
...
irc = sem_post (&sem);
/* Destroy the semaphore */
irc = sem_destroy(&sem);

回页首

进程内信号示例代码

清单 23. Win32 进程内信号示例代码

                
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void thrdproc      (void   *data);  // the thread procedure (function) 
     to be executed
HANDLE   semHandle;
int
main( int argc, char **argv )
{
        HANDLE    *threadId1;
        HANDLE    *threadId2;
        int        hThrd;
        unsigned   stacksize;
        int	    arg1;
	if( argc < 2 )
		arg1 = 7;
	else
		arg1 = atoi( argv[1] );
	printf( "Intra Process Semaphor test.\n" );
	printf( "Start.\n" );
	semHandle = CreateSemaphore(NULL, 1, 65536, NULL);
        if( semHandle == (HANDLE) NULL)
	{
		printf("CreateSemaphore error: %d\n", GetLastError());
	}
	printf( "Semaphor created.\n" );
	
        if( stacksize < 8192 )
            stacksize = 8192;
        else
            stacksize = (stacksize/4096+1)*4096;
     
        hThrd = _beginthread( thrdproc, // Definition of a thread entry
                                  NULL,
                             stacksize,
                            "Thread 1");
        if (hThrd == -1)
            return RC_THREAD_NOT_CREATED);
        *threadId1 = (HANDLE) hThrd;
         hThrd = _beginthread( thrdproc, // Definition of a thread entry
                                   NULL,
                              stacksize,
                              "Thread 2");
         if (hThrd == -1)
            return RC_THREAD_NOT_CREATED);
         *threadId2 = (HANDLE) hThrd;
	 printf( "Main thread sleeps 5 sec.\n" );
         sleep(5);
         if( ! ReleaseSemaphore(semHandle, 1, NULL) )
		printf("ReleaseSemaphore error: %d\n", GetLastError());
         printf( "Semaphor released.\n" );
         printf( "Main thread sleeps %d sec.\n", arg1 );
	
         sleep (arg1);
       if( ! ReleaseSemaphore(semHandle, 1, NULL) )
		printf("ReleaseSemaphore error: %d\n", GetLastError());
 
	printf( "Semaphor released.\n" );
	printf( "Main thread sleeps %d sec.\n", arg1 );
	sleep (arg1);
        CloseHandle(semHandle);
	
	printf( "Semaphor deleted.\n" );
	printf( "Main thread sleeps 5 sec.\n" );
        
        sleep (5);
        printf( "Stop.\n" );
	return OK;
}
void
thread_proc( void *pParam )
{
 
 DWORD  retVal;
	printf( "\t%s created.\n", pParam );
	       
        retVal = WaitForSingleObject(semHandle, INFINITE);
        if (retVal == WAIT_FAILED)
               return RC_SEM_WAIT_ERROR;
	printf( "\tSemaphor blocked by %s. (%lx)\n", pParam, retVal);
	printf( "\t%s sleeps for 5 sec.\n", pParam );
	sleep(5);
	if( ! ReleaseSemaphore(semHandle, 1, NULL) )
                printf("ReleaseSemaphore error: %d\n", GetLastError());
	printf( "\tSemaphor released by %s.)\n", pParam);
}

                
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
void  thread_proc (void * data);
pthread_mutexattr_t     attr;
pthread_mutex_t         mutex;
typedef struct
{
        pthread_mutex_t         mutex;
        pthread_cond_t          condition;
        int                     semCount;
}sem_private_struct, *sem_private;
sem_private     token;
int main( int argc, char **argv )
{
        pthread_t             threadId1;
        pthread_t             threadId2;
        pthread_attr_t        pthread_attr;
        pthread_attr_t        pthread_attr2;
        int			arg1;
        int                   rc;
	if( argc < 2 )
		arg1 = 7;
	else
		arg1 = atoi( argv[1] );
      printf( "Intra Process Semaphor test.\n" );
      printf( "Start.\n" );
      token =(sem_private)  malloc (sizeof (sem_private_struct));        
     
      if(rc = pthread_mutex_init( &(token->mutex), NULL))
      {
                free(token);
                return 1;
      }
      if(rc = pthread_cond_init(&(token->condition), NULL))
      {
           printf( "pthread_condition ERROR.\n" );
           pthread_mutex_destroy( &(token->mutex) );
           free(token);
           return 1;
      }
      token->semCount = 0;
      printf( "Semaphor created.\n" );
      if (rc = pthread_attr_init(&pthread_attr))
      {
           printf( "pthread_attr_init ERROR.\n" );
           exit;
      }
      if (rc = pthread_attr_setstacksize(&pthread_attr, 120*1024))
      {
           printf( "pthread_attr_setstacksize ERROR.\n" );
           exit;
      }
      if (rc = pthread_create(&threadId1,
                           &pthread_attr,
            (void*(*)(void*))thread_proc, 
                               "Thread 1" ))
      {
           printf( "pthread_create ERROR.\n" );
           exit;
      }
      if (rc = pthread_attr_init(&pthread_attr2))
      {
           printf( "pthread_attr_init2 ERROR.\n" );
           exit;
      }
      if (rc = pthread_attr_setstacksize(&pthread_attr2, 120*1024))
      {
           printf( "pthread_attr_setstacksize2 ERROR.\n" );
           exit;
      }
      if (rc = pthread_create(&threadId2, 
                          &pthread_attr2,
            (void*(*)(void*))thread_proc,
                               "Thread 2" ))
      {
           printf( "pthread_CREATE ERROR2.\n" );
           exit ;  // EINVAL, ENOMEM
      }
	
      printf( "Main thread sleeps 5 sec.\n" );
      sleep( 5 );
      if (rc =  pthread_mutex_lock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR 1.\n" );
           return 1; 
      }
      token->semCount ++;
      if (rc = pthread_mutex_unlock&(token->mutex)))
      {
           printf( "pthread_mutex_unlock ERROR 1.\n" );
           return 1; 
      }
      if (rc = pthread_cond_signal(&(token->condition)))
      {
           printf( "pthread_cond_signal ERROR1.\n" );
           return 1; 
      }
      printf( "Semaphor released.\n" );
      printf( "Main thread sleeps %d sec.\n", arg1 );
      sleep( arg1 );
      if (rc =  pthread_mutex_lock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR.\n" );
           return 1; 
      }
      token->semCount ++;
      if (rc = pthread_mutex_unlock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR.\n" );
           return 1; 
      }
      if (rc = pthread_cond_signal(&(token->condition)))
      {
           printf( "pthread_cond_signal ERROR.\n" );
           return 1; 
      }
	
      printf( "Semaphor released.\n" );
      printf( "Main thread sleeps %d sec.\n", arg1 );
      sleep( arg1 );
      pthread_mutex_destroy(&(token->mutex));
      pthread_cond_destroy(&(token->condition));	
      printf( "Semaphor deleted.\n" );
      printf( "Main thread sleeps 5 sec.\n" );
      sleep( 5 );
      printf( "Stop.\n" );
      return 0;
}
void
thread_proc( void *pParam )
{
 int	rc;
      printf( "\t%s created.\n", pParam );
      if (token == (sem_private) NULL)
          return ;
      if (rc =  pthread_mutex_lock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR2.\n" );
           return ; 
      }
      while (token->semCount <= 0)
      {
                rc = pthread_cond_wait(&(token->condition), &(token->mutex));
                if (rc && errno != EINTR )
                        break;
      }
      if( rc )
      {
                pthread_mutex_unlock(&(token->mutex));
                printf( "pthread_mutex_unlock ERROR3.\n" );
                return; 
      }
      token->semCount--;
      if (rc = pthread_mutex_unlock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR.\n" );
           return ; 
      }
      printf( "\tSemaphor blocked by %s. (%lx)\n", pParam, rc );
      printf( "\t%s sleeps for 5 sec.\n", pParam );
      sleep( 5 );
      if (rc =  pthread_mutex_lock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR.\n" );
           return ; 
      }
      token->semCount ++;
      if (rc = pthread_mutex_unlock(&(token->mutex)))
      {
           printf( "pthread_mutex_unlock ERROR.\n" );
           return ; 
      }
      if (rc = pthread_cond_signal(&(token->condition)))
      {
           printf( "pthread_cond_signal ERROR.\n" );
           return ; 
      }
      printf( "\tSemaphor released by %s. (%lx)\n", pParam, rc );

回页首

进程间信号示例代码

清单 25. Win32 进程间信号示例代码，进程 1

                
#include <stdio.h>
#include <windows.h>
#define WAIT_FOR_ENTER  printf( "Press ENTER\n" );getchar()
int main()
{
       HANDLE		semaphore;
       int		nRet;
       DWORD          retVal;
       SECURITY_ATTRIBUTES		sec_attr;
	printf( "Inter Process Semaphore test - Process 1.\n" );
	printf( "Start.\n" );
	
	sec_attr.nLength              = sizeof( SECURITY_ATTRIBUTES );
	sec_attr.lpSecurityDescriptor = NULL;
	sec_attr.bInheritHandle       = TRUE;
	semaphore = CreateSemaphore( &sec_attr, 1, 65536, "456789" );
	if( semaphore == (HANDLE) NULL )
		return RC_OBJECT_NOT_CREATED;
       printf( "Semaphore created. (%lx)\n", nRet );
	
	WAIT_FOR_ENTER;
	
	if( ! ReleaseSemaphore(semaphore, 1, NULL) )
		return SEM_POST_ERROR;
      
       printf( "Semaphore Posted. \n");
	
	WAIT_FOR_ENTER;
	retVal = WaitForSingleObject (semaphore, INFINITE );
        if (retVal == WAIT_FAILED)
              return SEM_WAIT_ERROR;
  
	printf( "Wait for Semaphore. \n");
	
       WAIT_FOR_ENTER;
	       
       CloseHandle (semaphore);
	printf( "Semaphore deleted.\n" );
	printf( "Stop.\n" );
	return 0;
}

清单 26 给出了作为支持进程间共享的有名称信号示例的消息 IPC 代码。

清单 26. 相应的 Linux 进程间信号示例代码，进程 1

                
#include <stdio.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <errno.h>
#include <unistd.h>
#define WAIT_FOR_ENTER  printf( "Press ENTER\n" );getchar()
struct msgbuf {
        long mtype;         /* type of message */
        char mtext[1];      /* message text */
};
int main()
{
        key_t           msgKey;
        int             flag;
        struct msgbuf   buff;
        int             sem;
        int             nRet =0;
	printf( "Inter Process Semaphore test - Process 1.\n" );
	printf( "Start.\n" );
        
	flag = IPC_CREAT|IPC_EXCL;
      if( ( msgKey = (key_t) atol( "456789" ) ) <= 0 )
                return 1;
      flag |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
      sem  = (int) msgget( msgKey, flag );
      
      if (sem == -1)
             if( errno == EEXIST )
             {
                    flag &= ~IPC_EXCL;
                    sem = (int) msgget( msgKey, flag );
                    if (msgctl(sem, IPC_RMID, NULL ) != 0)
                            return 1;
                    sem = (int) msgget( msgKey, flag );
                    if (sem == -1)
                            return 1;
             }
             else
                    return 1;
      printf( "Semaphore created. \n" );
      WAIT_FOR_ENTER;
      buff.mtype = 123;
      if( msgsnd( sem, &buff, 1, 0 ) < 0 )
          return 1;
      printf( "Semaphore Posted. \n" );
	
      WAIT_FOR_ENTER;
      if( msgrcv( sem, &buff, 1, 0, 0 ) < 0 )
          return 1;
      printf( "Wait for Semaphore. \n" );
      WAIT_FOR_ENTER;
      msgctl(sem, 0, IPC_RMID );
      printf( "Semaphore deleted.\n" );
	printf( "Stop.\n" );
	return 0;
}

                
#include <stdio.h>
#include <windows.h>
int main()
{
	HANDLE	semaphore;
	DWORD   retVal;
	printf( "Inter Process Semaphore test - Process 2.\n" );
	printf( "Start.\n" );
	SECURITY_ATTRIBUTES		sec_attr;
       
       sec_attr.nLength              = sizeof( SECURITY_ATTRIBUTES );
       sec_attr.lpSecurityDescriptor = NULL;
       sec_attr.bInheritHandle       = TRUE;
	semaphore = CreateSemaphore( &sec_attr, 0, 65536, "456789" );
	if( semaphore == (HANDLE) NULL )
		return RC_OBJECT_NOT_CREATED;
	printf( "Semaphore opened. (%lx)\n", nRet );
	
	printf( "Try to wait for semaphore.\n" );
	
       while( ( retVal = WaitForSingleObject( semaphore, 250 ) ) == WAIT_TIMEOUT)
		printf( "Timeout. \n");
	
       printf( "Semaphore acquired. \n");
       printf( "Try to post the semaphore.\n" );
	       
       if( ! ReleaseSemaphore(semaphore, 1, NULL) )
	     return RC_SEM_POST_ERROR;
	
       printf( "Semaphore posted. \n");
	
	CloseHandle(semaphore);
	printf( "Semaphore closed. \n");
	printf( "Stop.\n" );
	return 0;
}

                
#include <stdio.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <errno.h>
#include <unistd.h>
#define RC_TIMEOUT = 3
struct msgbuf {
        long mtype;         /* type of message */
        char mtext[1];      /* message text */
};
int main()
{
        key_t           msgKey;
        int             flag=0;
        struct msgbuf   buff;
        int             sem;
        int             nRet =0;
	printf( "Inter Process Semaphore test - Process 2.\n" );
	printf( "Start.\n" );
      if( ( msgKey = (key_t) atol( "456789" ) ) <= 0 )
            return 1;
      flag |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
      sem = (int) msgget( msgKey, flag );
      if (sem == -1)
            if( errno == EEXIST )
            {
                   flag &= ~IPC_EXCL;
                   sem = (int) msgget( msgKey, flag );
                   if (msgctl(sem, IPC_RMID, NULL ) != 0)
                          return 1;
                   sem = (int) msgget( msgKey, flag );
                   if (sem == -1)
                           return 1;
            }
            else
                   return 1;
	printf( "Semaphore opened. (%lx)\n", nRet );
	if( nRet != 0 )
          return 0;
	printf( "Try to wait for semaphore.\n" );
	while( ( nRet = sem_shared_wait_timed( sem, 250 ) ) == 3) 
	
	printf( "Timeout. (%lx)\n", nRet );
	printf( "Semaphore acquired. (%lx)\n", nRet );
	printf( "Try to post the semaphore.\n" );
       buff.mtype = 123;
       if( msgsnd( sem, &buff, 1, 0 ) < 0 )
          return 1;
	printf( "Semaphore posted. (%lx)\n", nRet );
	if( nRet != 0 )
		return 0;
	printf( "Semaphore closed. (%lx)\n", nRet );
	printf( "Stop.\n" );
	return 0;
}
int sem_shared_wait_timed( int sem, unsigned long timelimit)
{
        struct msgbuf           buff;
        struct timeval          timeOut;
        int                     msg[1];
        int                     nRet=0;
        timeOut.tv_sec  = timelimit / 1000;
        timeOut.tv_usec = (timelimit % 1000) * 1000;
        msg[0] = sem;
        nRet = select( 0x1000, (fd_set *)msg, NULL, NULL, &timeOut );
        if(nRet == 0)
           return 3;
        if( msgrcv( sem, &buff, 1, 0, 0 ) < 0 )
              return 1;
}

回页首

结束语

本系列的第三篇文章从信号 API 的角度讲述了从 Win32 到 Linux 的映射，并给出了您可以引用的信号示例代码。线程化的、同步的系统所提出的挑战不仅是设计与实现，也包括了质量保证的所有阶段。当进行从 Win32 到 Linux 的迁移时，可以将这些文章做为参考。一定要去阅读本系列中以前的文章。

补充声明

Microsoft、Windows、Windows NT 和 Windows 徽标是 Microsoft Corporation 在美国和／或其他国家或地区的商标或注册商标。

Intel、Intel Inside（logos）、MMX 和 Pentium 是 Intel 公司在美国和／或其他国家或地区的商标。

UNIX 是 The Open Group 在美国和其他国家或地区的注册商标。

Linux 是 Linus Torvalds 在美国和／或其他国家或地区的商标。

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文。
  
  
• 一定要阅读本系列的前两篇文章："将 Win32 C/C++ 应用程序迁移到 POWER 上的 Linux，第 1 部分：进程、线程和共享内存服务"（developerWorks，2004 年 6 月）和"将 Win32 C/C++ 应用程序迁移到 POWER 上的 Linux，第 2 部分：互斥"（developerWorks，2005 年 2 月）。
  
  
• 如何在 POWER 上使用 IBM XL C/C++ Advanced Edition V7.0 for Linux：GCC 用户指南（developerWorks，2004 年 12 月）一文，可以帮助 Linux 开发者在基于 IBM® POWER 处理器的系统上迅速地从 GNU gcc 和 gcc-c++ 编译器迁移到 IBM XL C/C++ Advanced Edition V7.0。
  
  
• 访问 Virtual Innovation Center for Hardware 以获得 AIX® 开发支持。这是所有 pSeries AIX 开发的最主要参考资料。
  
  
• 访问 Developer Bookstore 以获得详尽的技术书籍列表，包括数百本 与 eServer 相关 的书籍。
  
  
• 还想要更多？developerWorks eServer 专区有许许多多报道性文章以及初级、中级和高级的 eServer 教程。
  
  
• 在 Linux on POWER 了解：ISV 和开发者如何评论 Linux on POWER、事件、Linux on iSeries、Linux on pSeries、Linux on BladeCenter，等等。
  
  
• 通过参与 developerWorks blogs 加入 developerWorks 社区。
  
  
• IBM® developerWorks 团队在全世界举办了许多 technical briefings，您可以免费参加。
  

关于作者

		Nam Keung 是 IBM 的一名高级程序员，他曾致力于 AIX 通信开发、AIX 多媒体、SOM/DSOM 开发和 Java 性能方面的工作。他目前的工作包括帮助独立软件提供商（Independent Software Vendors，ISV）进行应用程序设计、部署应用程序、性能调优和关于 pSeries 平台的教育。您可以通过 namkeung@us.ibm.com 与 Nam 联系。

Level: Advanced

Srinivasan S. Muthuswamy (smuthusw@in.ibm.com), Software Engineer, IBM
Kavitha Varadarajan (vkavitha@in.ibm.com), Software Engineer, IBM

25 Aug 2005

The wave of migration to open source in business has the potential to cause a tremendous porting traffic jam as developers move the pervasive Windows® applications to the Linux™ platform. In this three-part series, you get a mapping guide, complete with examples, to ease your transition from Windows to Linux. This part takes a look at mutexes, critical sections, and wait functions.

Today, many global businesses and services are going open source -- all the major corporate players in the industry are pushing for it. This trend has spurred a major migration exercise in which lots of existing products maintained for various platforms (Windows, OS2, Solaris, etc.) will be ported to open source Linux platforms.

Many applications are designed without considering the need to port them to Linux. This has the potential to be a porting nightmare, but it doesn't have to be. The goal of this series of articles is to help you migrate complex applications involving IPC and threading primitives from Windows to Linux. We will share our experiences in moving these critical Windows IPC applications, applications that include multithreaded apps that require thread syncronization and multiprocess apps that require interprocess syncronization.

In short, this series can be called a mapping document -- it provides mapping of various Windows calls to Linux calls related to threads, processes, and interprocess communication elements (mutexes, semaphores, etc.). To create easily digestible chunks, we've divided the series into three articles:

• Part 1 dealt with processes and threads.
• Part 2 handled semaphores and events.
• This part covers mutexes, critical sections, and wait functions.

Let's finish our Windows-to-Linux mapping guide by starting with mutexes.

Mutexes

A mutex (which stands for "mutual exclusion" lock) is a locking or synchronization object that allows multiple threads to synchronize access to shared resources. It is often used to ensure that shared variables are always seen by other threads in a consistent state.

In Windows, the mutexes are both named and un-named. The named mutex is shared between the threads of different process.

In Linux, the mutexes are shared only between the threads of the same process. To achieve the same functionality in Linux, a System V semaphore can be used (see Resources for a link to Part 2 of this series).

In Windows, wait functions are used to request the ownership of the mutex. There are different types of wait functions available -- the one we're using as an example is WaitForSingleObject().

The following points should be considered in the mapping process of a mutex:

• In Windows, a mutex can be named and un-named. A named mutex is shared across the process. In Linux, mutexes are shared only among the threads. System V semaphores can be used to provide the named mutex functionality in Linux.
• In Windows, a mutex can be owned during creation; this support is not available in Linux. To achieve the same in Linux, a mutex should be locked explicitly after creation.
• In Windows, timeout can be specified in the wait functions. In Linux, the timeout option is not available. This is handled in application logic.
• A Windows mutex is recursive by default. A Linux mutex needs to have recursion explicitly set. System V semaphores are not recursive.

Creating a mutex

In Windows, CreateMutex() is used to create or open a named or un-named mutex object. Named mutexes are mainly used to provide synchronization between processess: HANDLE CreateMutex (LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCTSTR lpName). In this code:

• lpMutexAttributes is a pointer to the structure that determines whether the handle can be inherited by the child process or not. If this attribute is null, the handle cannot be inherited.
• bInitialOwner is a boolean value and if this value is TRUE then the calling thread initially owns the mutex.
• lpName is a pointer to the name of the semaphore. If null, then un-named semaphore is created.

In Windows, OpenMutex() is used to open the named mutex. This function returns the handle of the mutex.

HANDLE OpenMutex(
  DWORD dwDesiredAccess,
  BOOL bInheritHandle,
  LPCTSTR lpName
)

In the code:

• dwDesiredAccess is the desired access for the user requesting for the mutex object.
• bInheritHandle is a flag and if true, related process can inherit the handle.
• lpName is the name of the mutex (and is case sensitive).

Notice in this code that the named mutex should have been created already.

In Linux, the pthread library call pthread_mutex_init() is used to create the mutex: int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr).

There are three kinds of mutexes in Linux, each type determined by what happens if a thread attempts to lock a mutex it already owns with pthread_mutex_lock():

• A fast mutex. While trying to lock the mutex using pthread_mutex_lock() the calling thread suspends forever.
• A recursive mutex. pthread_mutex_lock() returns immediately with a success return code. This is used as equivalent for a Windows mutex since it is recursive in nature.
• An error check mutex. pthread_mutex_lock() returns immediately with the error code EDEADLK.

The mutex kind can be set in two ways. The static way of setting is as follows:

/* Fast */
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;                    
/* Recursive */
pthread_mutex_t recmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;    
/* Errorcheck */
pthread_mutex_t errchkmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;

Another way of setting mutex kind is by using a mutex attribute object. To do this, pthread_mutexattr_init() is called to initialize the object followed by pthread_mutexattr_settype() which sets the kind of the mutex.

int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);

The parameter kind takes the following values:

• PTHREAD_MUTEX_FAST_NP
• PTHREAD_MUTEX_RECURSIVE_NP
• PTHREAD_MUTEX_ERRORCHECK_NP

The attribute can be destroyed using pthread_mutexattr_destroy(): int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);.

Setting the initial state of the mutex

In Linux the initial state of the mutex cannot be set using the pthread_mutex_init() call. This can be achieved by following steps:

1. Create a mutex using pthread_mutex_init().
2. Lock/acquire the mutex using pthread_mutex_lock().

Acquiring a mutex

In Windows wait funtions provide the facility to acquire the synchronization objects. There are different types of wait functions -- in this section we're using WaitForSingleObject(). This function takes the handle to the mutex object and waits until it is signaled or timeout occurs.

DWORD WaitForSingleObject(
  HANDLE hHandle,
  DWORD dwMilliseconds
);

In this code:

• hHandle is the pointer to the mutex handle.
• dwMilliseconds is the timeout value in milliseconds. If the value is INFINITE then it blocks the calling thread/process indefinitely.

In Linux, the pthread library call pthread_mutex_lock() / pthread_mutex_trylock() is used to acquire the mutex.

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);

pthread_mutex_lock() is a blocking call which means that if the mutex is already locked by another thread, pthread_mutex_lock() suspends the calling thread until the mutex is unlocked. On the other hand, pthread_mutex_trylock() returns immediately if the mutex is already locked by another thread. Remember that in Linux, the timeout option is not available. This can be achieved by issuing a non-blocking pthread_mutex_trylock() call along with a delay in a loop which counts the timeout value.

Releasing a mutex

In Windows the function ReleaseMutex() releases the ownership of the mutex and sets the mutex to the signaled state: BOOL ReleaseMutex(HANDLE hMutex). In this code, hMutex is the handle of the mutex.

Notice that mutexes in Windows are basically recursive mutexes -- if the thread which already owns the mutex tries to acquire ownership again, the wait function returns without blocking and deadlock is avoided.

Linux uses pthread_mutex_unlock() to release/unlock the mutex: int pthread_mutex_unlock(pthread_mutex_t *mutex);.

The mutex functions are not asynchronous signal-safe and should not be called from a signal handler. In particular, calling pthread_mutex_lock or pthread_mutex_unlock from a signal handler may deadlock the calling thread.

Closing/destroying a mutex

In Windows, CloseHandle() is used to close or destroy the mutex object.

BOOL CloseHandle(
  HANDLE hObject
);

In the code, hObject is the pointer to the handle to the synchronization object.

In Linux, pthread_mutex_destroy() destroys a mutex object, freeing the resources it might hold. It also checks to determine whether the mutex is unlocked at that time: int pthread_mutex_destroy(pthread_mutex_t *mutex).

Named mutex

In Windows, named mutexes are mainly used between processes to achieve synchronization (to access the shared resource in a mutually exclusive manner). The mutex provided by the Linux threads libraries are limited to the threads of the same process. To achieve the same functionality between processes in Linux, a System V semaphore can be used.

System V semaphores are count variables. To achieve the same function as the Windows named mutex, the initial count of the semaphore is set to 0 using semctl() function. To acquire mutually exclusive access to the shared resource, semop() is used with sem_op value as -1. The calling process is blocked until mutually exclusive access is released. The creating process can acquire the mutually exclusive access by creating a semaphore with the initial count as 0 using semctl() function. After using the shared resource, the semaphore count can be set to 1 by using semop() function, allowing the other processes to access the shared resource. (See Resources for a link to the Part 2 section on semaphores.)

Examples

Following is code samples dealing with mutexes. Listings 13 and 14 show two scenarios each. In the first, a mutex is used without a specified timeout value. In the second, a mutex is used with a timeout value of two seconds.
Listing 1. Windows example for un-named mutex

HANDLE     hMutexWithNoTimeOut, hMutexWithTimeOut;
DWORD     dwRetCode;

// create a mutex
hMutexWithNoTimeOut = CreateMutex(
                     NULL,  // no security attriutes
                     FALSE, // initially not owned
                     NULL); // un named mutex so NULL

hMutexWithTimeOut = CreateMutex(
                     NULL,  // no security attriutes
                     FALSE, // initially not owned
                     NULL); // un named mutex so NULL

// acquire a mutex
dwRetCode = WaitForSingleObject(
                                hMutexWithNoTimeOut,  // Mutex handle
                                INFINITE);            // Infinite wait

if (dwRetCode == WAIT_OBJECT_0) {

    // success
    // access the shared resource
    .....

   // release mutex
   ReleaseMutex(hMutexWithNoTimeOut); // Mutex Handle

}

// case 2, using mutex with timeout specified.
dwRetCode = WaitForSingleObject(
                                hMutexWithTimeOut,
                                2000L); // 2 secs timeout

switch(dwRetCode) {
    case WAIT_OBJECT_0 :
        // success
        // access the shared resource
        .....

        // After using the shared resource, release the semaphore
        ReleaseMutex(hMutexWithTimeOut);
        ....

    break;

    case WAIT_TIMEOUT :
        // Handle the timeout case
        ...
    break;

    case WAIT_ABANDONED :
        // probe for abandoned mutex

    break;
}

....

// close all the mutex
CloseHandle(hMutexWithTimeout);
CloseHandle(hMutexWithNoTimeout);

#define TIMEOUT 200  // 2 Secs delay time
struct timespec delay;  // structure for providing timeout

pthread_mutexattr_t mutexattr;  // Mutex Attribute
pthread_mutex_t mutexWithNoTimeOut, mutexWithTimeOut; // Mutex variables

// Set the mutex as a recursive mutex
pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE_NP);

// Create the mutex with the attributes set
pthread_mutex_init(&mutexWithNoTimeOut, &mutexattr);
pthread_mutex_init(&mutexWithTimeOut, &mutexattr);

// destroy the attribute
pthread_mutexattr_destroy(&mutexattr)


// Lock/Acquire the mutex and access the shared resource
pthread_mutex_lock (&mutexWithNoTimeOut);

// access the shared resource
 .. ...

// Unlock the mutex
pthread_mutex_unlock (&mutexWithNoTimeOut);
 ...


// Case 2, Accessing share resource with time out value specified in the
// Mutex call

while (timeout < TIMEOUT ) {

   delay.tv_sec = 0;
   delay.tv_nsec = 1000000;  // 1 milli sec delay

    // Tries to acquire the mutex and access the shared resource,
    // if success, access the shared resource,
    // if the shared reosurce already in use, it tries every 1 milli sec
    // to acquire the resource
    // if it does not acquire the mutex within 2 secs delay,
    // then it is considered to be failed

    irc = pthread_mutex_trylock(&mutexWithTimeOut);
    if (!irc)  {

        // Acquire mutex success
        // Access the shared resource


        // Unlock the mutex and release the shared resource
        pthread_mutex_unlock (&mutexWithTimeOut);


      break;
    }
    else {
        // check whether somebody else has the mutex
        if (irc == EPERM ) {
            // Yes, Resource already in use so sleep
            nanosleep(&delay, NULL);
            timeout++ ;
        }
        else{
            // Handle error condition
        }
    }
}

// Close all the mutex
pthread_mutex_destroy (&mutexWithNoTimeOut);
pthread_mutex_destroy (&mutexWithTimeOut);

// Process 1
HANDLE     hMutex;
DWORD     dwRetCode;

// create a mutex
hMutex = CreateMutex(
                     NULL,  // no security attriutes
                     FALSE, // initially not owned
                     NULL); // un named mutex so NULL

// acquire a mutex
dwRetCode = WaitForSingleObject(
                                hMutex,  // Mutex handle
                                INFINITE);  // Infinite wait

if (dwRetCode == WAIT_OBJECT_0) {

    // success
    // access the shared resource
    .....

   // release mutex
   ReleaseMutex(hMutex); // Mutex Handle

}


// close the mutex
CloseHandle(hMutex);

// Process 2
HANDLE     hMutex;
DWORD     dwRetCode;

// Open the mutex created by the Process 1
hMutex = OpenMutex(
                   NULL,        // no security attriutes
                   NULL,        // handle cannot be inhereited
                   "testMuex"); // named mutex

// acquire a mutex
dwRetCode = WaitForSingleObject(
                                hMutex,     // Mutex handle
                                INFINITE);  // Infinite wait

if (dwRetCode == WAIT_OBJECT_0) {

    // success
    // access the shared resource
    .....

   // release mutex
   ReleaseMutex(hMutex); // Mutex Handle

}


// close the mutex
CloseHandle(hMutex);

// Process 1
#define TIMEOUT 200



int main()
{
    //Definition of variables
    key_t key;
    int semid;
    int Ret;
    int timeout = 0;
    struct sembuf operation[1] ;

    union semun
    {
        int val;
        struct semid_ds *buf;
        USHORT *array;
    } semctl_arg,ignored_argument;


    key = ftok(); //Generate a unique key or supply a value

    semid = semget(key, // a unique identifier to identify semaphore set
             1,  // number of semaphore in the semaphore set
        0666 | IPC_CREAT // permissions (rwxrwxrwx) on the new
                 //semaphore set and creation flag
                    );
    if(semid < 0)
    {
        printf("Create semaphore set failed ");
        Exit(1);
    }

    //Set Initial value for the resource
    semctl_arg.val = 1; //Setting semval to 1

    semctl(semid, 0, SETVAL, semctl_arg);


    //Wait for Zero

    while(timeout < TIMEOUT)
    {
        delay.tv_sec = 0;
        delay.tv_nsec = 1000000;  /* 1 milli sec */

        //Call Wait for Zero with IPC_NOWAIT option,so it will be
        // non blocking

        operation[0].sem_op = -1; //Wait
        operation[0].sem_num = subset;
        operation[0].sem_flg = IPC_NOWAIT;

        ret = semop(semid, operation,1);
        if(ret < 0)
        {
            /* check whether somebody else has the mutex */
            if (retCode == EPERM )
            {
                /* sleep for delay time */
                nanosleep(&delay, NULL);
                timeout++ ;
            }
            else
            {
                printf("ERROR while wait ");
                break;
            }
        }
        else
        {
            /*semaphore got triggered */
            break;
        }

    }

    //Close semaphore
    iRc = semctl(semid, 1, IPC_RMID , ignored_argument);

}

// Process 2
int main()
{
    int key = 0x20;   //Process 2 shd know key value in order to open the
                     // existing semaphore set
    struct sembuf operation[1] ;

    //Open semaphore
    semid = semget(key, 1, 0);

    operation[0].sem_op = 1; //Release the resource so Wait in process
                             // 1 will be triggered
    operation[0].sem_num = 0;
    operation[0].sem_flg = SEM_UNDO;

    //Release semaphore
    semop(semid, operation,1);
}

Back to top

Critical sections

In Windows, critical sections are synchronization objects that are similar to mutexes but with some limitations. The critical sections can only be used between threads of same process. A mutex uses timeout when requesting access to the mutex, but a critical section does not provide such feature -- it waits indefinitely.

The critical section uses the spin count. In the single-processor system, the spin count is ignored and initialized to 0, but in the multiprocessor system, the calling thread will spin dwSpinCount times before it actually waits for the critical section so that if the critical section becomes free during that time, the calling thread does not wait. Since the critical sections are used only between the threads of the same process, a pthreads mutex is used to achieve the same results on Linux systems.

Creating/initializing a critical section

In Windows, critical sections need to be initialized before the threads of same process can actually be used. InitializeCriticalSection() or InitializeCriticalSectionAndSpinCount() can be used to initialize the critical section.

void InitializeCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection
)

In this code, lpCriticalSection is a pointer to the handle to the critical section. In low memory situations, this function raises the STATUS_NO_MEMORY exception.

InitializeCriticalSectionAndSpinCount() is used to initialize and set the spin count.

BOOL InitializeCriticalSectionAndSpinCount(
  LPCRITICAL_SECTION lpCriticalSection,
  DWORD dwSpinCount
)

In this code:

• lpCriticalSection is a pointer to the handle of the critical section.
• dwSpinCount is the spin count for the critical section.

In Linux, pthread_mutex_init() is used to create or initialize the mutex object.

Entering/acquiring a critical section

In Windows, EnterCriticalSection() or TryEnterCriticalSection() is used to request the ownership of the critical section. If the critical section is already in use, EnterCriticalSection() will block the calling thread, but TryEnterCriticalSection() will attempt to enter the critical section without blocking the thread.

EnterCriticalSection() is used to enter the critical section:

void EnterCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection
);

In this code, lpCriticalSection is a pointer to the handle of the critical section.

The TryEnterCriticalSection() function attempts to enter a critical section without blocking. If the call is successful, the calling thread takes ownership of the critical section:

BOOL TryEnterCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection
)

In this code, lpCriticalSection is the pointer to the handle of the critical section.

In Linux, the same can be achieved using pthread_mutex_lock() which blocks the calling thread. pthread_mutex_trylock attempts to acquire the mutex without blocking the thread.

Leaving/releasing a critical section

In Windows, LeaveCriticalSection() is used to release the ownership of the critical section. LeaveCriticalSection() needs to be called as many times as the critical section is entered.void LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection )

In this code, lpCriticalSection is the pointer to the handle of the critical section.

In Linux, pthread_mutex_unlock() is used to release the ownership of the mutex object.

Deleting a critical section

In Windows, DeleteCriticalSection() is used to delete the critical section; once used, this critical section can no longer be used for synchronization.

void DeleteCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection
)

In this code, lpCriticalSection is a pointer to the handle of the critical section.

In Linux, pthread_mutex_destroy() is used to delete the mutex object.

Example

The following examples are very simple -- they present code snippets for accessing a shared resource using a critical section for mutual exclusion.
Listing 5. Windows critical section example

CRITICAL_SECTION csCriticalSection;

// Initialize a Critical Section
InitializeCriticalSection(
            &csCriticalSection); // Critical Section Object

// Enter a critical Section
EnterCriticalSection(
            &csCriticalSection); // Critical Section Object

// Access a shared resource



// Leave a Critical Section
LeaveCriticalSection(
            &csCriticalSection); // Critical Section Object


// Delete a Critical Section
DeleteCriticalSection(
            &csCriticalSection); // Critical Section Object

pthread_mutex_t mutex;           // Mutex
pthread_mutexattr_t mutexattr;   // Mutex attribute variable

// Set the mutex as a recursive mutex
pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE_NP);

// create the mutex with the attributes set
pthread_mutex_init(&mutex, &mutexattr);

//After initializing the mutex, the thread attribute can be destroyed
pthread_mutexattr_destroy(&mutexattr)


// Acquire the mutex to access the shared resource
pthread_mutex_lock (&mutex);

// access the shared resource
 ..

// Release the mutex  and release the access to shared resource
pthread_mutex_unlock (&mutex);
 ...

// Destroy / close the mutex
irc = pthread_mutex_destroy (&mutex);

Back to top

Wait functions

In Windows, the wait functions block the calling thread/process until the specified criteria is met -- in other words, they allow threads to block their own executions. The type of the wait function determines the set of wait criteria used. There are four types of wait functions:

• Single object (requires a handle to one synchronization object; returns when either the specified object is in the signaled state or the timeout interval elapses).
• Multiple object (enables the calling thread to specify an array containing one or more synchronization object handles; returns when either the state of any one of the specified objects is set to signaled or the states of all objects have been set to signaled or the timeout interval elapses).
• Alertable (the function can return when the specified conditions are met, but it can also return if the system queues an I/O completion routine or an APC for execution by the waiting thread).
• Registered (a multiple wait operation, when the specified conditions are met, the callback function is executed by a worker thread from the thread pool).

We won't be addressing alertable or registered wait functions in this series.

In Linux, wait functions are provided in the respective synchronization library itself (mutexes and semaphores have their own wait functions.)

The following points should be considered when mapping wait functions:

• Windows supports multiple object wait functionality. It allows passing in of multiple synchronization in the same wait function. In Linux, this functionality is not available. This logic needs to be implemented in the application logic.
• Windows supports alertable and registered waits; Linux provides only basic wait functionality. These features can be handled in the application logic for Linux.

Signaling and waiting

SignalObjectAndWait() is also an alertable wait function and it is different as it signals an object and waits on another object in an atomic manner.

DWORD SignalObjectAndWait(
  HANDLE hObjectToSignal,
  HANDLE hObjectToWaitOn,
  DWORD dwMilliseconds,
  BOOL bAlertable
)

In this code:

• hObjectToSignal is a pointer to the handle to the object to be signaled.
• hObjectToWaitOn is a pointer handle to the object for which the thread has to wait.
• dwMilliseconds is the time out specified in milliseconds.
• bAlertable is a flag and if this parameter is TRUE, then the wait function returns when the system queues an I/O completion routine or APC function and the thread calls the function. For this article we can ignore this flag

In Linux, the same functionality can be achieved by using System V semaphores. These semaphores provide function in which we can specify operation sets. To signal an object and wait for another synchronization object, we can create two operations sets -- one for signaling the object and other to wait on the specified object. The operations sets are performed in an atomic manner, meaning the semop() call succeeds if both the operations succeed; otherwise, it fails.

System V semaphores do not provide timeout functionality. This can be implemented in application logic as we discussed in Part 2 of this series by making semop() call with flag IPC_NOWAIT. By doing it this way, the calling thread or process is not blocked.

Examples

The following examples should illustrated the wait functions we've discussed.
Listing 7. Windows example for SignalObjectAndWait()

// Main thread
HANDLE hEventOne; // Global Variable
HANDLE hEventTwo; // Global Variable


// Thread 1
DWORD  dwRetCode;

// Create Event One
hEventOne = CreateEvent(
                     NULL,   // no security attributes
                     TRUE,   // Auto reset event
                     FALSE,  // initially set to non signaled state
                     NULL);  // un named event

// Create Event Two
hEventTwo = CreateEvent(
                     NULL,   // no security attributes
                     TRUE,   // Auto reset event
                     FALSE,  // initially set to non signaled state
                     NULL);  // un named event

// Signal hEventOne and Wait for the hEventTwo to be signaled
dwRetCode = SignalObjectAndWait(
                           hEventOne, // Object to be signaled
                           hEventTwo, // Object to wait on
                           INFINITE,  // Infinite wait
                           FALSE);    // Not alertable

  switch(dwRetCode) {
          case WAIT_OBJECT_O :
                   // Event is signaled
                   // go ahead and proceed the work


         default :
                   // Probe for error
  }




// Completed the job,
// now close the event handle
CloseHandle(hEventOne);
CloseHandle(hEventTwo);


// Thread 2
// Condition met for the event hEventTwo
// now set the event
SetEvent(
         hEventTwo);    // Event Handle

// Main thread
int key = 0x20;  // Semaphore key

// Thread 1
    struct sembuf operation[2] ;

    // Create 2 semaphores
    semid = semget(key, 2, 0666 | IPC_CREAT);


    operation[0].sem_op  = 1; //Release first resource
    operation[0].sem_num = 0;
    operation[0].sem_flg = SEM_UNDO;

    operation[0].sem_op  = -1; // Wait on the second resource
    operation[0].sem_num = 1;
    operation[0].sem_flg = SEM_UNDO;

    //Release semaphore 1 and wait on semaphore 2
    // note : thread is suspended until the semaphore 2 is released.
    semop(semid, operation, 2);

    // thread is released
    // delete the semaphore
    semctl(semid, 0, IPC_RMID , 0)


// Thread 2
    struct sembuf operation[1] ;

    // open semaphore
    mysemid = semget(key, 2, 0);

    operation[0].sem_op  = 1; // Release on the second resource
    operation[0].sem_num = 1;
    operation[0].sem_flg = SEM_UNDO;

    //Release semaphore 2
    semop(semid, operation, 1);

Waiting on an array

WaitForMultipleObjects() is the simplest function available in this type. This function takes an array on one or more synchronized objects as input and blocks the calling thread until any of the following criteria is met:

• Either any one or all of the specified objects are in the signaled state.
• The timeout interval elapses.

DWORD WaitForMultipleObjects(
  DWORD nCount,
  const HANDLE* lpHandles,
  BOOL bWaitAll,
  DWORD dwMilliseconds
)

In this code:

• nCount is the number of object handles in the array pointed to by lpHandles.
• lpHandles is a pointer to array of object handles.
• bWaitAll is a flag and if this parameter is TRUE, the function waits until all the objects are in signaled state.
• dwMilliseconds is the timeout value in milliseconds.

In Linux, the same functionality can be achieved by using additional logic in the code. In the context of threads, POSIX semaphores are used and in the context of processes, System V semaphores are used. In Windows, if the bWaitAll flag is FALSE, the thread/process is released if any one of the synchronization objects are signaled. Linux does not provide this functionality. This logic needs to be handled in the application logic.

Examples

Following are examples for multiple objects wait functions.
Listing 9. Windows example for any single object to be signaled

HANDLE     hEvents[2];
DWORD     i, dwRetCode;

// Create two event objects.

for (i = 0; i < 2; i++)
{
    hEvents[i] = CreateEvent(
        NULL,   // no security attributes
        FALSE,  // auto-reset event object
        FALSE,  // initial state is nonsignaled
        NULL);  // unnamed object

}

// The creating thread waits for other threads or processes
// to signal the event objects.

dwRetCode  = WaitForMultipleObjects(
                       2,           // number of objects in array
                       hEvents,     // array of objects
                       FALSE,       // wait for any
                       INFINITE);   // indefinite wait

// Return value indicates which event is signaled.

switch (dwEvent)
{
    // hEvent[0] was signaled.
    case WAIT_OBJECT_0 + 0:
        // Perform tasks required by this event.
        break;

    // hEvent[1] was signaled.
    case WAIT_OBJECT_0 + 1:
        // Perform tasks required by this event.
        break;

    // Return value is invalid.
    default:
        // probe for error
}

// Semaphore
sem_t semOne  ;
sem_t semTwo  ;
sem_t semMain ;

// Main thread
sem_init(semOne,0,0) ;
sem_init(semTwo,0,0) ;
sem_init(semMain,0,0) ;

// create 2 threads each one waits on one semaphore
// if signaled signals the main semaphore

sem_wait(&semMain);


// Thread 1
sem_wait(&semOne);
sem_post(&semMain);


// Thread 2
sem_wait(&semTwo);
sem_post(&semMain);

HANDLE     hEvents[2];
DWORD     i, dwRetCode;

// Create two event objects.

for (i = 0; i < 2; i++)
{
    hEvents[i] = CreateEvent(
        NULL,   // no security attributes
        FALSE,  // auto-reset event object
        FALSE,  // initial state is nonsignaled
        NULL);  // unnamed object

}

// The creating thread waits for other threads or processes
// to signal the event objects.

dwRetCode  = WaitForMultipleObjects(
  2,           // number of objects in array
  hEvents,     // array of objects
  TRUE,        // wait for both the objects to be signaled
  INFINITE);   // indefinite wait

// Return value indicates which event is signaled.

switch (dwEvent)
{
    // hEvent[0] and hEvent[1] were signaled.
    case WAIT_OBJECT_0 :
        // Perform tasks required by this event.

        break;

    // Return value is invalid.
    default:
        // probe for error
}

// Semaphore
sem_t semOne  ;
sem_t semTwo  ;
sem_t semMain ;
pthread_mutex_t mutMain = PTHREAD_MUTEX_INITIALIZER;

// Main thread
sem_init(semOne,0,0) ;
sem_init(semTwo,0,0) ;
sem_init(semMain,0,0) ;

// create 2 threads each one waits on one semaphore
// if signaled signals the main semaphore

sem_wait(&semMain);


// Thread 1
sem_wait(&semOne);

// lock the Mutex
pthread_mutex_lock(&mutMain);
count ++;
if(count == 2) {
     // semaphore semTwo is already signaled
     // so post the main semaphore
     sem_post(&semMain);
}
pthread_mutex_unlock(&mutMain);


// Thread 2
sem_wait(&semTwo);
// lock the Mutex
pthread_mutex_lock(&mutMain);
count ++;
if(count == 2) {
     // semaphore semOne is already signaled
     // so post the main semaphore
     sem_post(&semMain);
}
pthread_mutex_unlock(&mutMain);
 

// Main thread
int key = 0x20;  // Semaphore key

// Thread 1
    struct sembuf operation[2] ;

    // Create 2 semaphores
    semid = semget(key, 2, 0666 | IPC_CREAT);


    operation[0].sem_op  = -1; // Wait on first resource
    operation[0].sem_num = 0;
    operation[0].sem_flg = SEM_UNDO;

    operation[0].sem_op  = -1; // Wait on the second resource
    operation[0].sem_num = 1;
    operation[0].sem_flg = SEM_UNDO;

    // Wait on both the semaphores
    // Note : thread is suspended until both the semaphores are released.
    semop(semid, operation, 2);

    // thread is released
    // delete the semaphore
    semctl(semid, 0, IPC_RMID , 0)


// Thread 2
    struct sembuf operation[1] ;

    // open semaphore
    mysemid = semget(key, 2, 0);

    operation[0].sem_op  = 1; // Release on the second resource
    operation[0].sem_num = 1;
    operation[0].sem_flg = SEM_UNDO;

    //Release semaphore 2
    semop(semid, operation, 1);

// Thread 3
    struct sembuf operation[1] ;

    // open semaphore
    mysemid = semget(key, 2, 0);

    operation[0].sem_op  = 1; // Release on the first resource
    operation[0].sem_num = 0;
    operation[0].sem_flg = SEM_UNDO;

    //Release semaphore 1
    semop(semid, operation, 1);
 

Back to top

In conclusion

In this series, we've provided a guide to help map Windows processes to their functional counterparts in Linux.

In the first article we covered creating, terminating, and exiting a process; we've introduced wait functions (more about them in Part Three); and we've discussed environment variables. On the threads side, we've highlighted creation, parameter passing, specifying the function, setting the stack size, exiting, thread states, and changing priorities. And we addressed the differences in Windows and Linux of normal and time-critical threads and processes.

In the second article, we introduced synchronization objects, discussing semaphores -- creating, opening, acquiring, releasing, closing, and destroying them -- and event objects -- creating, opening, waiting on, signaling, resetting, closing, destroying, and named and un-named. In each section, we illustrated the difference between the functionality of each in Windows and in Linux.

In the last article of the series, we've defined and provided a mapping guide for mutexes, critical sections, and wait functions.

We hope this extensive mapping guide can lay the groundwork for your moving to Linux systems.

ResourcesLearn

• Read all the articles in this series, "Port Windows IPC apps to Linux" (developerWorks, Spring 2005).
  
  
• The online code examples in the book Pthreads Programming by Bradford Nichols, Dick Buttlar, and Jacqueline Proulx Farrel (O'Reilly, 1996) will illustrate the concepts in this article.
  
  
• Don't forget to check the Linux Threads FAQ, the Linux Manpages Online, and the LinuxThreads Library for specific calls and more details on programming with threads in Linux.
  
  
• Two previous IBM developerWorks Linux articles covered threads programming: Peter Seebach's Basic use of pthreads (developerWorks, January 2004) and Daniel Robbin's POSIX threads explained (developerWorks, July 2000).
  
  
• Refer to the MSDN library for more details on the Windows systems calls used in this article.
  
  
• A series of IBM developerWorks articles, Migrate your apps from OS/2 to Linux (developerWorks, February 2004) is a good reference to see what is mapped during migration.
  
  
• Find more resources for Linux developers in the developerWorks Linux zone.
  
  

• Order the SEK for Linux, a two-DVD set containing the latest IBM trial software for Linux from DB2®, Lotus®, Rational®, Tivoli®, and WebSphere®.
  
  
• Build your next development project on Linux with IBM trial software, available for download directly from developerWorks.
  
  
  

• Get involved in the developerWorks community by participating in developerWorks blogs.
  

About the authors

		Srinivasan S. Muthuswamy works as a Software Engineer for IBM Global Services Group. He joined IBM in 2000, and his expertise in programming reaches from scripting languages to object- and procedure-oriented languages on multiple platforms (Linux, Windows, WebSphere, Lotus, and so on). Muthuswamy has developed solutions ranging from system programming on Linux and Windows to Web solutions for J2EE. His primary focus is on integration and porting, and he holds a B.Eng. in Computer Engineering from the Government College of Technology, Coimbatore, India. You can contact him at <a href="mailto:smuthusw@in.ibm.com">smuthusw@in.ibm.com</a>.

		Kavitha Varadarajan has worked as a software Engineer in the IBM India Software Lab from December 2000. Her work experience involves development and support of host-access client products such as PCOMM and networking software like the communication server. Varadarajan has experience with a migration project that involves porting object-oriented IPC Windows applications to Linux. She holds a B.Eng. in Computer Science and Engineering from Shanmugha College of Engineering, Tanjore, India. She can be contacted at <a href="mailto:vkavitha@in.ibm.com">vkavitha@in.ibm.com</a>.

级别： 初级

Nam Keung (namkeung@us.ibm.com), 高级程序员
Chakarat Skawratananond (chakarat@us.ibm.com), pSeries Linux 技术顾问

2005 年 1 月 06 日

本文的内容是 Win32 API（特别是进程、线程和共享内存服务）到 POWER 上 Linux 的映射。本文可以帮助您确定哪种映射服务最适合您的需要。作者向您详细介绍了他在移植 Win32 C/C++ 应用程序时遇到的 API 映射。

概述

有很多方式可以将 Win32 C/C++ 应用程序移植和迁移到 pSeries 平台。您可以使用免费软件或者第三方工具来将 Win32 应用程序代码移到 Linux。在我们的方案中，我们决定使用一个可移植层来抽象系统 API 调用。可移植层将使我们的应用程序具有以下优势：

• 与硬件无关。
  • 与操作系统无关。
  • 与操作系统上版本与版本间的变化无关。
• 与操作系统 API 风格及错误代码无关。
• 能够统一地在对 OS 的调用中置入性能和 RAS 钩子（hook）。

由于 Windows 环境与 pSeries Linux 环境有很大区别，所以进行跨 UNIX 平台的移植比进行从 Win32 平台到 UNIX 平台的移植要容易得多。这是可以想到的，因为很多 UNIX 系统都使用共同的设计理念，在应用程序层有非常多的类似之处。不过，Win32 API 在移植到 Linux 时是受限的。本文剖析了由于 Linux 和 Win32 之间设计的不同而引发的问题。

回页首

初始化和终止

在 Win2K/NT 上，DLL 的初始化和终止入口点是 _DLL_InitTerm 函数。当每个新的进程获得对 DLL 的访问时，这个函数初始化 DLL 所必需的环境。当每个新的进程释放其对 DLL 的访问时，这个函数为那个环境终止 DLL。当您链接到那个 DLL 时，这个函数会自动地被调用。对应用程序而言，_DLL_InitTerm 函数中包含了另外一个初始化和终止例程。

在 Linux 上，GCC 有一个扩展，允许指定当可执行文件或者包含它的共享对象启动或停止时应该调用某个函数。语法是 __attribute__((constructor)) 或 __attribute__((destructor))。这些基本上与构造函数及析构函数相同，可以替代 glibc 库中的 _init 和 _fini 函数。

这些函数的 C 原型是：

void __attribute__ ((constructor)) app_init(void);
void __attribute__ ((destructor)) app_fini(void);

				Win32 sample
_DLL_InitTerm(HMODULE modhandle, DWORD fdwReason, LPVOID lpvReserved)
{	
    WSADATA			Data;	
    switch (fdwReason)	
    {		
        case DLL_PROCESS_ATTACH:		
        if (_CRT_init() == -1)			
           return 0L;               
          /* start with initialization code */		
          app_init();		
          break;	
    case DLL_PROCESS_DETACH:		
         /* Start with termination code*/               
         app_fini();		
         _CRT_term();		
         break;      
    …..	
    default:		
          /* unexpected flag value - return error indication */		
            return 0UL;	
    }	return 1UL;		/* success */
}
      

回页首

进程服务

Win32 进程模型没有与 fork() 和 exec() 直接相当的函数。在 Linux 中使用 fork() 调用总是会继承所有内容，与此不同， CreateProcess() 接收用于控制进程创建方面的显式参数，比如文件句柄继承。

CreateProcess API 创建一个包含有一个或多个在此进程的上下文中运行的线程的新进程，子进程与父进程之间没有关系。在 Windows NT/2000/XP 上，返回的进程 ID 是 Win32 进程 ID。在 Windows ME 上，返回的进程 ID 是除去了高位（high-order bit）的 Win32 进程 ID。当创建的进程终止时，所有与此进程相关的数据都从内存中删除。

为了在 Linux 中创建一个新的进程， fork() 系统调用会复制那个进程。新进程创建后，父进程和子进程的关系就会自动建立，子进程默认继承父进程的所有属性。Linux 使用一个不带任何参数的调用创建新的进程。 fork() 将子进程的进程 ID 返回给父进程，而不返回给子进程任何内容。

Win32 进程同时使用句柄和进程 ID 来标识，而 Linux 没有进程句柄。

进程映射表

创建进程服务

在 Win32 中， CreateProcess() 的第一个参数指定要运行的程序，第二个参数给出命令行参数。CreateProcess 将其他进程参数作为参数。倒数第二个参数是一个指向某个 STARTUPINFORMATION 结构体的指针，它为进程指定了标准的设备以及其他关于进程环境的启动信息。在将 STARTUPINFORMATION 结构体的地址传给 CreateProcess 以重定向进程的标准输入、标准输出和标准错误之前，您需要设置这个结构体的 hStdin、hStdout 和 hStderr 成员。最后一个参数是一个指向某个 PROCESSINFORMATION 结构体的指针，由被创建的进程为其添加内容。进程一旦启动，它将包含创建它的进程的句柄以及其他内容。

				Win32 example
PROCESS_INFORMATION    procInfo;
STARTUPINFO	        startupInfo;
typedef DWORD          processId;
char                   *exec_path_name
char                   *_cmd_line;
        GetStartupInfo( &startupInfo );     // You must fill in this structure
if( CreateProcess( exec_path_name,  // specify the executable program
                       _cmd_line,   // the command line arguments
                       NULL,       // ignored in Linux
                       NULL,       // ignored in Linux
                       TRUE,       // ignored in Linux
                       DETACHED_PROCESS | HIGH_PRIORITY_CLASS,
                       NULL,       // ignored in Linux
                       NULL,       // ignored in Linux
               &startupInfo,
                    &procInfo))
        *processId = procInfo.dwProcessId;
else
{
        *processId = 0;
          return RC_PROCESS_NOT_CREATED;
}	
      

在 Linux 中，进程 ID 是一个整数。Linux 中的搜索目录由 PATH 环境变量（exec_path_name）决定。 fork() 函数建立父进程的一个副本，包括父进程的数据空间、堆和栈。 execv() 子例程使用 exec_path_name 将调用进程当前环境传递给新的进程。

这个函数用一个由 exec_path_name 指定的新的进程映像替换当前的进程映像。新的映像构造自一个由 exec_path_name 指定的正规的、可执行的文件。由于调用的进程映像被新的进程映像所替换，所以没有任何返回。

				Equivalent Linux code
#include <stdlib.h>
#include <stdio.h>
int    processId;
char  *exec_path_name;
char  *	cmd_line ;
cmd_line = (char *) malloc(strlen(_cmd_line ) + 1 );
if(cmd_line == NULL)
         return RC_NOT_ENOUGH_MEMORY;
         	
strcpy(cmd_line, _cmd_line);
if( ( *processId = 
        fork() ) == 0 )		// Create child
 {	
         char		*pArg, *pPtr;
         char		*argv[WR_MAX_ARG + 1];
         int		 argc;
         if( ( pArg = strrchr( exec_path_name, '/' ) ) != NULL )
                pArg++;
         else
                pArg = exec_path_name;
         argv[0] = pArg;
         argc = 1;
         
         if( cmd_line != NULL && *cmd_line != '\0' )
         {
                  
               pArg = strtok_r(cmd_line, " ", &pPtr);
               
               while( pArg != NULL )
               {
                              argv[argc] = pArg;
                              argc++;
                              if( argc >= WR_MAX_ARG )
                              break;
                              pArg = strtok_r(NULL, " ", &pPtr);
                }
         }
         argv[argc] = NULL;
         
         execv(exec_path_name, argv);
         free(cmd_line);
         exit( -1 );
}
else if( *processId == -1 )
{
           *processId = 0;
           free(cmd_line);
           return RC_PROCESS_NOT_CREATED;
}
      

终止进程服务

在 Win32 进程中，父进程和子进程可能需要单独访问子进程所继承的由某个句柄标识的对象。父进程可以创建一个可访问而且可继承的副本句柄。Win32 示例代码使用下面的方法终止进程：

• 使用 OpenProcess 来获得指定进程的句柄。
• 使用 GetCurrentProcess 获得其自己的句柄。
• 使用 DuplicateHandle 来获得一个来自同一对象的句柄作为原始句柄。

如果函数成功，则使用 TerminateThread 函数来释放同一进程上的主线程。然后使用 TerminateThread 函数来无条件地使一个进程退出。它启动终止并立即返回。

				Win32 sample code
if( thread != (HANDLE) NULL )
{
    HANDLE	thread_dup;
    if( DuplicateHandle( OpenProcess(PROCESS_ALL_ACCESS, TRUE,  processId),
                                     thread,
                                     GetCurrentProcess(),
                                     &thread_dup,  //Output
                                     0,
                                     FALSE,
                                     DUPLICATE_SAME_ACCESS ))
      {
            TerminateThread( thread_dup, 0);
       }
}
TerminateProcess(
        OpenProcess(PROCESS_ALL_ACCESS, TRUE, 
        processId), 
   (UINT)0 );
      

在 Linux 中，使用 kill 子例程发送 SIGTERM 信号来终止特定进程（processId）。然后调用设置 WNOHANG 位的 waitpid 子例程。这将检查特定的进程并终止。

				Equivalent  Linux code
pid_t	nRet;
int	status;
kill( processId, SIGTERM );
nRet = waitpid( processId, &status, WNOHANG);  //Check specified
   process is terminated
      

进程依然存在服务

Win32 OpenProcess 返回特定进程（processId）的句柄。如果函数成功，则 GetExitCodeProcess 将获得特定进程的状态，并检查进程的状态是否是 STILL_ACTIVE。

				Win 32 sample
HANDLE      nProc;
DWORD       dwExitCode;
nProc = OpenProcess(PROCESS_ALL_ACCESS, TRUE, processId);
if ( nProc != NULL)
{
     GetExitCodeProcess( nProc, &dwExitCode );
     if (dwExitCode == STILL_ACTIVE )
            return RC_PROCESS_EXIST;
     else
            return RC_PROCESS_NOT_EXIST;
}
else
     return RC_PROCESS_NOT_EXIST;
      

在 Linux 中，使用 kill 子例程发送通过 Signal 参数指定的信号给由 Process 参数（processId）指定的特定进程。Signal 参数是一个 null 值，会执行错误检查，但不发送信号。

				Equivalent Linux code
if ( kill ( processId, 0 ) == -1 && errno == ESRCH ) // No process can 
                                       be found
                             // corresponding to processId
         return RC_PROCESS_NOT_EXIST;
else
        return RC_PROCESS_EXIST;
      

回页首

线程模型

线程 是系统分配 CPU 时间的基本单位；当等待调度时，每个线程保持信息来保存它的"上下文"。每个线程都可以执行程序代码的任何部分，并共享进程的全局变量。

构建于 clone() 系统调用之上的 LinuxThreads 是一个 pthreads 兼容线程系统。因为线程由内核来调度，所以 LinuxThreads 支持阻塞的 I/O 操作和多处理器。不过，每个线程实际上是一个 Linux 进程，所以一个程序可以拥有的线程数目受内核所允许的进程总数的限制。Linux 内核没有为线程同步提供系统调用。Linux Threads 库提供了另外的代码来支持对互斥和条件变量的操作（使用管道来阻塞线程）。

对有外加 LinuxThreads 的信号处理来说，每个线程都会继承信号处理器（如果派生这个线程的父进程注册了一个信号处理器的话。只有在 Linux Kernel 2.6 和更高版本中支持的新特性才会包含 POSIX 线程支持，比如 用于 Linux 的 Native POSIX Thread Library（NPTL）。

线程同步、等待函数、线程本地存储以及初始化和终止抽象是线程模型的重要部分。在这些之下，线程服务只负责：

• 新线程被创建，threadId 被返回。
• 通过调用 pthread_exit 函数可以终止当前的新线程。

线程映射表

线程创建

Win32 应用程序使用 C 运行期库，而不使用 Create_Thread API。使用了 _beginthread 和 _endthread 例程。这些例程会考虑任何可重入性（reentrancy）和内存不足问题、线程本地存储、初始化和终止抽象。

Linux 使用 pthread 库调用 pthread_create() 来派生一个线程。

threadId 作为一个输出参数返回。为创建一个新线程，要传递一组参数。当新线程被创建时，这些参数会执行一个函数。stacksize 用作新线程的栈的大小（以字节为单位），当新线程开始执行时，实际的参数被传递给函数。

指定线程程序（函数）

进行创建的线程必须指定要执行的新线程的启动函数的代码。启动地址是 threadproc 函数（带有一个单独的参数，即 threadparam）的名称。如果调用成功地创建了一个新线程，则返回 threadId。Win32 threadId 的类型定义是 HANDLE。Linux threadId 的类型定义是 pthread_t。

threadproc

要执行的线程程序（函数）。它接收一个单独的 void 参数。

threadparam

线程开始执行时传递给它的参数。

设置栈大小

在 Win32 中，线程的栈由进程的内存空间自动分配。系统根据需要增加栈的大小，并在线程终止时释放它。在 Linux 中，栈的大小在 pthread 属性对象中设置；pthread_attr_t 传递给库调用 pthread_create()。

				Win32 sample
int		hThrd;
DWORD          dwIDThread;
unsigned       stacksize;
void           *thrdparam; //parameter to be passed to the thread when it 
                                  //begins execution
HANDLE         *threadId;
if( stacksize < 8192 )
     stacksize = 8192;
else
     stacksize = (stacksize/4096+1)*4096;
     
     hThrd = _beginthread( thrdproc,    // Definition of a thread entry 
                                                                  //point
                                NULL,
                                stacksize,
                                thrdparam);
if (hThrd == -1)
     return RC_THREAD_NOT_CREATED);
     *threadId = (HANDLE) hThrd;
__________________________________________________________________     
                          
        Equivalent Linux code
                                                            
#include <pthread.h>
pthread_t   *threadId;
void         thrdproc  (void *data);  //the thread procedure (function) to 
                                               //be executed. 
                      //It receives a single void parameter
void        *thrdparam; //parameter to be passed to the thread when it 
                               //begins execution
pthread_attr_t  attr;
int             rc = 0;
if (thrdproc == NULL || threadId == NULL)
     	return RC_INVALID_PARAM);
     	
if (rc = pthread_attr_init(&attr))	
     return RC_THREAD_NOT_CREATED);  // EINVAL, ENOMEM
      
if (rc = pthread_attr_setstacksize(&attr, stacksize))
     return RC_THREAD_NOT_CREATED);   // EINVAL, ENOSYS
     
if (rc = pthread_create(threadId, &attr, (void*(*)(void*))thrdproc, 
   thrdparam))
     return RC_THREAD_NOT_CREATED);      // EINVAL, EAGAIN
      

终止线程服务

在 Win32 中，一个线程可以使用 TerminateThread 函数终止另一个线程。不过，线程的栈和其他资源将不会被收回。如果线程终止自己，则这样是可取的。在 Linux 中，pthread_cancel 可以终止由具体的 threadId 所标识的线程的执行。

线程状态

在 Linux 中，线程默认创建为可合并（joinable）状态。另一个线程可以使用 pthread_join() 同步线程的终止并重新获得终止代码。可合并线程的线程资源只有在其被合并后才被释放。

Win32 使用 WaitForSingleObject() 来等待线程终止。

Linux 使用 pthread_join 完成同样的事情。

结束当前线程服务的执行

在 Win32 中，使用 _endthread() 来结束当前线程的执行。在 Linux 中，推荐使用 pthread_exit() 来退出一个线程，以避免显式地调用 exit 例程。在 Linux 中，线程的返回值是 retval，可以由另一个线程调用 pthread_join() 来获得它。

获得当前线程 ID 服务

在 Win32 进程中，GetCurrentThreadId 函数获得进行调用的线程的线程标识符。Linux 使用 pthread_self() 函数来返回进行调用的线程的 ID。

sleep 服务用于 Win32 Sleep 函数的时间段的单位是毫秒，可以是 INFINITE，在这种情况下线程将永远不会再重新开始。 Linux sleep 函数类似于 Sleep，但是时间段以秒来计。要获得毫秒级的精度，则使用 nanosleep 函数来提供同样的服务。

Win32 SleepEx 函数挂起 当前线程，直到下面事件之一发生：

• 一个 I/O 完成回调函数被调用。
• 一个异步过程调用（asynchronous procedure call，APC）排队到此线程。
• 最小超时时间间隔已经过去。

Linux 使用 sched_yield 完成同样的事情。

回页首

共享内存服务

共享内存允许多个进程将它们的部分虚地址映射到一个公用的内存区域。任何进程都可以向共享内存区域写入数据，并且数据可以由其他进程读取或修改。共享内存用于实现进程间通信媒介。不过，共享内存不为使用它的进程提供任何访问控制。使用共享内存时通常会同时使用"锁"。

一个典型的使用情形是：

1. 某个服务器创建了一个共享内存区域，并建立了一个共享的锁对象。
2. 某个客户机连接到服务器所创建的共享内存区域。
3. 客户机和服务器双方都可以使用共享的锁对象来获得对共享内存区域的访问。
4. 客户机和服务器可以查询共享内存区域的位置。

共享内存映射表

创建共享内存资源

Win32 通过共享的内存映射文件来创建共享内存资源。Linux 使用 shmget/mmap 函数通过直接将文件数据合并入内存来访问文件。内存区域是已知的作为共享内存的段。

文件和数据也可以在多个进程和线程之间共享。不过，这需要进程或线程之间同步，由应用程序来处理。

如果资源已经存在，则 CreateFileMapping() 重新初始化共享资源对于进程的约定。如果没有足够的空闲内存来处理错误的共享资源，此调用可能会失败。 OpenFileMapping() 需要共享资源必须已经存在；这个调用只是请求对它的访问。

在 Win32 中，CreateFileMapping 不允许您增加文件大小，但是在 Linux 中不是这样。在 Linux 中，如果资源已经存在，它将被重新初始化。它可能被销毁并重新创建。Linux 创建可以通过名称访问的共享内存。 open() 系统调用确定映射是否可读或可写。传递给 mmap() 的参数必须不能与 open() 时请求的访问相冲突。 mmap() 需要为映射提供文件的大小（字节数）。

对 32-位内核而言，有 4GB 虚地址空间。最前的 1 GB 用于设备驱动程序。最后 1 GB 用于内核数据结构。中间的 2GB 可以用于共享内存。当前，POWER 上的 Linux 允许内核使用 4GB 虚地址空间，允许用户应用程序使用最多 4GB 虚地址空间。

映射内存访问保护位

要获得 Linux 共享内存的分配，您可以查看 /proc/sys/kernel 目录下的 shmmax、shmmin 和 shmall。

在 Linux 上增加共享内存的一个示例：

echo 524288000 > /proc/sys/kernel/shmmax

下面是创建共享内存资源的 Win32 示例代码，以及相对应的 Linux nmap 实现。

				Win32 sample code
typedef struct
 {
   // This receives a pointer within the current process at which the 
   // shared memory is located.
   // The same shared memory may reside at different addresses in other
   // processes which share it.
       void *	location;
       HANDLE	hFileMapping;
}mem_shared_struct, *mem_shared, *token;
mem_shared_struct   *token;
if ((*token = (mem_shared) malloc(sizeof(mem_shared_struct))) == NULL)     
     return RC_NOT_ENOUGH_MEMORY;
     
if (newmode == new_shared_create)
   (*token)->hFileMapping = CreateFileMapping((HANDLE) 0xFFFFFFFF, NULL,
                 PAGE_READWRITE,
                 0,
                (DWORD) size,
                 (LPSTR) name);
 else
      (*token)->hFileMapping = OpenFileMapping(FILE_MAP_ALL_ACCESS,
                 FALSE,
                 (LPSTR) name);
if ((*token)->hFileMapping == NULL)
{
      free( *token );
      return RC_SHM_NOT_CREATED );
}
(*token)->location = MapViewOfFile((*token)->hFileMapping,
                                      FILE_MAP_READ | FILE_MAP_WRITE, 
                                      0, 0, 0);
if ((*token)->location == NULL)
{
      CloseHandle((*token)->hFileMapping);
            free(*token);
            return RC_OBJECT_NOT_CREATED;
}
____________________________________________________________________
                     
        Equivalent Linux code
                                  
typedef struct
{    	
      void    *location;
      int	 nFileDes;	
      cs_size	 nSize;	
      char	 *pFileName;
}mem_shared_struct, *mem_shared, token;
mode_t	mode=0;
int	flag=0;
int	i, ch='\0';
char   name_buff[128];
if (newmode == new_shared_create)
                  flag = O_CREAT;
else if (newmode != new_shared_attach)	
                  return RC_INVALID_PARAM;
                  
if ((*token = (mem_shared) malloc(sizeof(mem_shared_struct))) == NULL)
               return RC_NOT_ENOUGH_MEMORY;
               
strcpy(name_buff, "/tmp/" );
strcat(name_buff, name );
if(((*token)->pFileName = malloc(strlen(name_buff)+1)) == NULL )
{     
      free(*token);
      return RC_NOT_ENOUGH_MEMORY;
}
mode |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
flag |= O_RDWR;
if(newmode == new_shared_create)    
      remove(name_buff);
      
if(((*token)->nFileDes = open(name_buff, flag, mode)) < 0)
{    
      free((*token)->pFileName);
      free(*token);
      return RC_OBJECT_NOT_CREATED;
}
if(newmode == new_shared_create)
{    
      lseek((*token)->nFileDes, size - 1, SEEK_SET);
      write((*token)->nFileDes, &ch, 1);
}
if(lseek((*token)->nFileDes, 0, SEEK_END) < size)
{	
         free((*token)->pFileName);
         free(*token);
         return RC_MEMSIZE_ERROR;
}
(*token)->location = mmap( 0, size,
                  PROT_READ | PROT_WRITE,
                  MAP_VARIABLE | MAP_SHARED, 
                      (*token)->nFileDes,
                                  0);
                                  
if((int)((*token)->location) == -1)
{   
       free((*token)->pFileName);
       free(*token);    
       return RC_OBJECT_NOT_CREATED;
}
(*token)->nSize = size;strcpy((*token)->pFileName, name_buff);
      

删除共享内存资源

为销毁共享内存资源，munmap 子例程要取消被映射文件区域的映射。munmap 子例程只是取消对 mmap 子例程的调用而创建的区域的映射。如果某个区域内的一个地址被 mmap 子例程取消映射，并且那个区域后来未被再次映射，那么任何对那个地址的引用将导致给进程发出一个 SIGSEGV 信号。

回页首

结束语

本文介绍了关于初始化和终止、进程、线程及共享内存服务从 Win32 API 到 POWER 上 Linux 的映射。这绝对没有涵盖所有的 API 映射，而且读者只能将此信息用作将 Win32 C/C++ 应用程序迁移到 POWER Linux 的一个参考。

特别声明

IBM、eServer 和 pSeries 是 IBM Corporation 在美国和／或其它国家或地区的商标。

UNIX 是 The Open Group 在美国和其它国家或地区的注册商标。

Microsoft 和 Windows 是 Microsoft Corporation 在美国和／或其它国家或地区的商标或注册商标。

所有其他商标和注册商标是它们相应公司的财产。

此出版物/说明是在美国完成的。IBM 可能不在其他国家或地区提供在此讨论的产品、程序、服务或特性，而且信息可能会不加声明地加以修改。有关您当前所在区域的产品、程序、服务和特性的信息，请向您当地的 IBM 代表咨询。任何对 IBM 产品、程序、服务或者特性的引用并非意在明示或暗示只能使用 IBM 的产品、程序、服务或者特性。只要不侵犯 IBM 的知识产权，任何同等功能的产品、程序、服务或特性，都可以代替 IBM 产品、程序、服务或特性。

涉及非 IBM 产品的信息可从这些产品的供应商、其出版说明或其他可公开获得的资料中获取，并不构成 IBM 对此产品的认可。非 IBM 价目及性能数字资源取自可公开获得的信息，包括供应商的声明和供应商的全球主页。 IBM 没有对这些产品进行测试，也无法确认其性能的精确性、兼容性或任何其他关于非 IBM 产品的声明。有关非 IBM 产品性能的问题应当向这些产品的供应商提出。

有关非 IBM 产品性能的问题应当向这些产品的供应商提出。IBM 公司可能已拥有或正在申请与本说明中描述的内容有关的各项专利。提供本说明并未授予用户使用这些专利的任何许可。您可以用书面方式将许可查询寄往： IBM Director of Licensing IBM Corporation North Castle Drive Armonk, NY 10504-1785 U.S.A。所有关于 IBM 未来方向或意向的声明都可随时更改或收回，而不另行通知，它们仅仅表示了目标和意愿而已。联系您本地的 IBM 办公人员或者 IBM 授权的转销商，以获得特定的 Statement of General Direction 的全文。

本说明中所包含的信息没有提交给任何正式的 IBM 测试，而只是"按原样"发布。虽然 IBM 可能为了其在特定条件下的精确性而已经对每个条目进行了检查，但不保证在其他地方可以获得相同的或者类似的结果。使用此信息或者实现这里所描述的任何技术是客户的责任，取决于客户评价并集成它们到客户的操作环境的能力。尝试为他们自己的环境而修改这些技术的客户，这样做所带来的风险由他们自行承担。

参考资料

1. 您可以参阅本文在 developerWorks 全球站点上的 英文原文。

作者简介

		Nam Keung 是一名高级程序员，他曾致力于 AIX 通信开发、AIX 多媒体、SOM/DSOM 开发和 Java 性能方面的工作。他目前的工作包括帮助 ISV 进行应用程序设计、部署应用程序、性能调优和关于 pSeries 平台的教育。他从 1987 年起就是 IBM 的程序员了。您可以通过 namkeung@us.ibm.com 与 Nam 联系。

		Chakarat Skawratananond 是 IBM eServer Solutions Enablement 组织的一名技术顾问，在那里，他帮助独立软件开发商在 IBM pSeries 平台上使用他们的用于 AIX 5L 和 Linux 的应用程序。您可以通过 chakarat@us.ibm.com 与他联系。

级别： 初级

Srinivasan S. Muthuswamy (smuthusw@in.ibm.com), 软件工程师, IBM Global Services Group
Kavitha Varadarajan (vkavitha@in.ibm.com), 软件工程师, IBM India Software Lab

2005 年 6 月 27 日

随着开发人员将一些普及的 Windows® 应用程序迁移到 Linux™ 平台，企业中正在进行的向开放源码迁移的浪潮有可能引发极大的移植问题。这个由三部分组成的系列文章提供了一个映射指南，并附有一些例子，以简化从 Windows 到 Linux 的转移。本文是系列文章的第 2 部分，将介绍两种同步对象类型：信号量和事件。

当前，很多全球商务和服务都正在走向开源 —— 业界的所有主要参与者都在争取实现此目标。这一趋势催生了一个重要的迁移模式：为不同平台（Windows、OS2、Solaris 等）维持的许多现有产品都将被移植到开放源码的 Linux 平台。

很多应用程序在设计时并未考虑到需要将它们移植到 Linux。这有可能使移植成为一件痛苦的事情，但并非绝对如此。本系列文章的目的是，帮助您将涉及到 IPC 和线程原语的复杂应用程序从 Windows 迁移到 Linux。我们与您分享迁移这些关键应用程序的经验，其中包括要求线程同步的多线程应用程序以及要求进程间同步的多进程应用程序。

简言之，可以将此系列文章看作是一个映射文档 —— 它提供了与线程、进程和进程间通信元素（互斥、信号量等等）相关的各种 Windows 调用到 Linux 调用的映射。我们将那些映射分为三部分：

• 在 第 1 部分 中，我们已经对进程和线程进行了讨论。
• 本文将介绍信号量和事件。
• 第 3 部分将介绍互斥、临界区和等待函数。

在本文中，我们将从同步技术入手，继续从 Windows 到 Linux 的映射指导。

同步

在 Windows 上，同步是使用等待函数中的同步对象来实现的。同步对象可以有两种状态：有信号（signaled）状态和无信号（non-signaled）状态。当在一个等待函数中使用同步对象时，等待函数就会阻塞调用线程，直到同步对象的状态被设置为有信号为止。

下面是在 Windows 上可以使用的一些同步对象：

• 事件（Event）
• 信号量（Semaphore）
• 互斥（Mutexe）
• 临界区（Critical section）

在 Linux 中，可以使用不同的同步原语。Windows 与 Linux 的不同之处在于每个原语都有自己的等待函数（所谓等待函数就是用来修改同步原语状态的函数）；在 Windows 中，有一些通用的等待函数来实现相同的目的。以下是 Linux 上可以使用的一些同步原语：

• 信号量（Semaphore）
• 条件变量（Conditional variable）
• 互斥（Mutexe）

通过使用上面列出的这些原语，各种库都可以用于 Linux 之上，以提供同步机制。

表 1. 同步映射

回页首

信号量

Windows 信号量是一些计数器变量，允许有限个线程/进程访问共享资源。Linux POSIX 信号量也是一些计数器变量，可以用来在 Linux 上实现 Windows 上的信号量功能。

在对进程进行映射时，我们需要考虑以下问题：

• 信号量的类型： Windows 提供了有名（named）信号量和无名（unnamed）信号量。有名信号量可以在进程之间进行同步。在 Linux 上，在相同进程的不同线程之间，则只使用 POSIX 信号量。在进程之间，可以使用 System V 信号量。
• 等待函数中的超时： 当在一个等待函数中使用时，可以为 Windows 信号量对象指定超时值。在 Linux 中，并没有提供这种功能，只能通过应用程序逻辑处理超时的问题。

表 2. 信号量映射

创建信号量

在 Windows 中，可以使用 CreateSemaphore() 创建或打开一个有名或无名的信号量。

HANDLE CreateSemaphore(
  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
  LONG lInitialCount,
  LONG lMaximumCount,
  LPCTSTR lpName
);

在这段代码中：

• lpSemaphoreAttributes 是一个指向安全性属性的指针。如果这个指针为空，那么这个信号量就不能被继承。
• lInitialCount 是该信号量的初始值。
• lMaximumCount 是该信号量的最大值，该值必须大于 0。
• lpName 是信号量的名称。如果该值为 NULL，那么这个信号量就只能在相同进程的不同线程之间共享。否则，就可以在不同的进程之间进行共享。

这个函数创建信号量，并返回这个信号量的句柄。它还将初始值设置为调用中指定的值。这样就可以允许有限个线程来访问某个共享资源。

在 Linux 中，可以使用 sem_init() 来创建一个无名的 POSIX 信号量，这个调用可以在相同进程的线程之间使用。它还会对信号量计数器进行初始化：int sem_init(sem_t *sem, int pshared, unsigned int value)。在这段代码中：

• value（信号量计数器)是这个信号量的初始值。
• pshared 可以忽略，因为在目前的实现中，POSIX 信号量还不能在进程之间进行共享。

这里要注意的是，最大值基于 demaphore.h 头文件中定义的 SEM_VALUE_MAX。

在 Linux 中，semget() 用于创建 System V 信号量，它可以在不同集成的线程之间使用。可以用它来实现与 Windows 中有名信号量相同的功能。这个函数返回一个信号量集标识符，它与一个参数的键值关联在一起。当创建一个新信号量集时，对于与 semid_ds 数据结构关联在一起的信号量，semget() 要负责将它们进行初始化，方法如下：

• sem_perm.cuid 和 sem_perm.uid 被设置为调用进程的有效用户 ID。
• sem_perm.cgid 和 sem_perm.gid 被设置为调用进程的有效组 ID。
• sem_perm.mode 的低 9 位被设置为 semflg 的低 9 位。
• sem_nsems 被设置为 nsems 的值。
• sem_otime 被设置为 0。
• sem_ctime 被设置为当前时间。

用来创建 System V 信号量使用的代码是：int semget(key_t key, int nsems, int semflg)。下面是对这段代码的一些解释：

• key 是一个惟一的标识符，不同的进程使用它来标识这个信号量集。我们可以使用 ftok() 生成一个惟一的键值。IPC_PRIVATE 是一个特殊的 key_t 值；当使用 IPC_PRIVATE 作为 key 时，这个系统调用就会只使用 semflg 的低 9 位，但却忽略其他内容，从而新创建一个信号量集（在成功时）。
• nsems 是这个信号量集中信号量的数量。
• semflg 是这个新信号量集的权限。要新创建一个信号量集，您可以将使用 IPC_CREAT 来设置位操作或访问权限。如果具有该 key 值的信号量集已经存在，那么 IPC_CREAT/IPC_EXCL 标记就会失败。

注意，在 System V 信号量中，key 被用来惟一标识信号量；在 Windows 中，信号量是使用一个名称来标识的。

为了对信号量集数据结构进行初始化，可以使用 IPC_SET 命令来调用 semctl() 系统调用。将 arg.buf 所指向的 semid_ds 数据结构的某些成员的值写入信号量集数据结构中，同时更新这个结构的 sem_ctime member 的值。用户提供的这个 arg.buf 所指向的 semid_ds 结构如下所示：

• sem_perm.uid
• sem_perm.gid
• sem_perm.mode （只有最低 9 位有效）

调用进程的有效用户 ID 应该是超级用户，或者至少应该与这个信号量集的创建者或所有者匹配： int semctl(int semid, int semnum, int cmd = IPC_SET, ...)。在这段代码中：

• semid 是信号量集的标识符。
• semnum 是信号量子集偏移量（从 0 到 nsems -1，其中 n 是这个信号量集中子集的个数）。这个命令会被忽略。
• cmd 是命令；它使用 IPC_SET 来设置信号量的值。
• args 是这个信号量集数据结构中要通过 IPC_SET 来更新的值（在这个例子中会有解释）。

最大计数器的值是根据在头文件中定义的 SEMVMX 来决定的。

打开信号量

在 Windows 中，我们使用 OpenSemaphore() 来打开某个指定信号量。只有在两个进程之间共享信号量时，才需要使用信号量。在成功打开信号量之后，这个函数就会返回这个信号量的句柄，这样就可以在后续的调用中使用它了。

HANDLE OpenSemaphore(
  DWORD dwDesiredAccess,
  BOOL bInheritHandle,
  LPCTSTR lpName
)

在这段代码中：

• dwDesiredAccess 是针对该信号量对象所请求的访问权。
• bInheritHandle 是用来控制这个信号量句柄是否可继承的标记。如果该值为 TRUE，那么这个句柄可以被继承。
• lpName 是这个信号量的名称。

在 Linux 中，可以调用相同的 semget() 来打开某个信号量，不过此时 semflg 的值为 0：int semget(key,nsems,0)。在这段代码中：

• key 应该指向想要打开的信号量集的 key 值。
• 为了打开一个已经存在的信号量，可以将 nsems 和标记设置为 0。semflg 值是在返回信号量集标识符之前对访问权限进行验证时设置的。

获取信号量