<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0">
  <channel>
    <title>buaawhl</title>
    <description>Common programmer.
Powered by Open Source.
Aim to be architect, solution provider, best practice provider.
Like to contribute back to Open Source.

http://blog.csdn.net/buaawhl
http://buaawhl.blogdriver.com</description>
    <link>http://buaawhl.javaeye.com</link>
    <language>UTF-8</language>
    <copyright>Copyright 2003-2008, JavaEye.com</copyright>
    <docs>http://blogs.law.harvard.edu/tech/rss</docs>
    <generator>JavaEye - 做最棒的软件开发交流社区</generator>
      <item>
        <title>网上银行的安全操作设计探讨</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/215858" style="color:red;">http://buaawhl.javaeye.com/blog/215858</a>&nbsp;
          发表时间: 2008年07月17日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          各大银行基本上都有了网上银行。<br /><br />网上银行基本上都有USB证书方式。USB证书方式应该是必要的。<br /><br />中国银行的网银用了一种动态口令发生器。每隔一段时间变一次。比较好奇这是一种什么样的机制。<br />(1)服务器产生动态口令，发给动态口令发生器。这个需要无线通信。还需要加密。密闭屏蔽环境中无法使用。<br />(2)动态口令发生器自己带有生成逻辑，和服务器的生成逻辑一致。而且保持同步。这个比较难。主要是时间同步问题。<br /><br />总之，我感觉，动态口令方式，只应该作为辅助方式。<br /><br />USB证书保证了只有证书持有人才能够登录。其他人不能登录。<br />工商银行的登录，不需要USB证书。只有转钱的时候，才需要USB证书。这虽然一定程度上方便了查询。比如，几个可信任的亲友没有USB证书，也可以查看账户。<br />这种方式有一种比较邪恶的使用方式。比如，如果 A 知道 B 的银行帐号，并且知道 B 在使用网络银行。A 虽然不知道B的密码。但是 A 可以每天都用错误密码登录B的网银帐号。每次都可以锁住B的帐号24小时。这样，就会给 B 带来很大麻烦。<br />当然，B 可以报案。也许可以根据IP记录找到A。<br /><br />工行的一个出色之处，在于转账时候的验证码。工行的验证码越做越好。<br />验证码在银行账户的特殊颜色标志出来的数字，很难用程序识别。<br /><br />关于密码保护。软键盘是不错的。间谍软件只能通过截图和判断坐标的方式记录密码。<br />特殊的密码ActiveX控件也是不错的。间谍软件很难攻破特殊的ActiveX控件。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/215858#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Thu, 17 Jul 2008 16:43:02 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/215858</link>
        <guid>http://buaawhl.javaeye.com/blog/215858</guid>
      </item>
      <item>
        <title>谁说搞技术的没有幽默感？</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/213717" style="color:red;">http://buaawhl.javaeye.com/blog/213717</a>&nbsp;
          发表时间: 2008年07月10日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          前两天看到一个很幽默的技术贴，令我老怀大畅。<br />今天想重温一下，却找不到了。我慌了，别不是被隐藏了吧？<br />难道不明真相的围观群众连这点宽容度、幽默感都没有？<br />结果证明是我小人之心度君子之腹。那个贴没有被隐藏，只是沉底了。<br />不过，是金子总是会发光的。比如，今天我就把金子发掘了出来，让金子发光发热。<br /><br />http://www.javaeye.com/topic/212881<br /><br />经典在于回复上。<br /><br /><div class="quote_title">bruce_luo 写道</div><div class="quote_div">不错，我以前也写过一个代码生成器，但是我们老大说，你这一搞，其它程序员就要失业了，我就没有继续搞下去了!</div><br /><br /><br /><div class="quote_title">flashj 写道</div><div class="quote_div"><div class="quote_title">bruce_luo 写道</div><div class="quote_div">不错，我以前也写过一个代码生成器，但是我们老大说，你这一搞，其它程序员就要失业了，我就没有继续搞下去了!</div><br />你这一搞，我看不但其它程序员要失业了，国内的软件公司要倒掉一批了。</div><br /><br /><br /><div class="quote_title">Readonly 写道</div><div class="quote_div"><div class="quote_title">bruce_luo 写道</div><div class="quote_div">不错，我以前也写过一个代码生成器，但是我们老大说，你这一搞，其它程序员就要失业了，我就没有继续搞下去了!</div><br />偶代表这批没有失业的程序员深深地感谢您...</div>
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/213717#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Thu, 10 Jul 2008 23:07:44 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/213717</link>
        <guid>http://buaawhl.javaeye.com/blog/213717</guid>
      </item>
      <item>
        <title>全民大练级 -- 今天你评级了吗?</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/210741" style="color:red;">http://buaawhl.javaeye.com/blog/210741</a>&nbsp;
          发表时间: 2008年07月02日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          也许是网游逐渐渗入现实。<br />关于职业等级分类的文章越来越多，而人们也乐此不疲。<br />什么东西都能整出来个等级，什么学习力啦，程序员版本啦，等等。<br /><br />也许是因为现实世界太平等了（？），少了等级制度的乐趣。<br />另一个主要的可能是，分类分级能够满足人们的归属感，认同感。<br /><br />无论如何，这种现象证明了职称制度的前瞻性、先进性和优越性。值得大力推广。值得从公有制企事业推广到私有企业以及大众生活。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/210741#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Wed, 02 Jul 2008 18:49:45 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/210741</link>
        <guid>http://buaawhl.javaeye.com/blog/210741</guid>
      </item>
      <item>
        <title>Ruby Template &quot;Amrita&quot; 介绍</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/208027" style="color:red;">http://buaawhl.javaeye.com/blog/208027</a>&nbsp;
          发表时间: 2008年06月25日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          HTML模板 + 数据模型 = HTML输出<br /><br />http://amrita.sourceforge.jp/<br /><br />What is Amrita?<br /><br />Amrita is a a html/xhtml template library for Ruby. It makes html documents from a template and a model data.<br /><br /><img src="http://amrita.sourceforge.jp/concept.gif" /><br /><br />Example<br /><br />Amrita mixes a template and model data up to a html document naturally matching the id attribute of HTML element to model data.<br /><br /><pre name="code" class="java">
template
&lt;table border="1">
  &lt;tr>&lt;th>name&lt;/th>&lt;th>author&lt;/th>&lt;/tr>
  &lt;tr id="table1">
  &lt;td id="name">&lt;td id="author">
  &lt;/tr>
&lt;/table>

data
data = {
  :table1 => [
    { :name=>"Ruby", :author=>"matz" },
    { :name=>"perl", :author=>"Larry Wall" },
    { :name=>"python", :author=>"Guido van Rossum" },
  ]
}

template + data = output
&lt;table>
  &lt;tr>
  &lt;th>name&lt;/th>
  &lt;th>author&lt;/th>
  &lt;/tr>
  &lt;tr>
  &lt;td>Ruby&lt;/td>
  &lt;td>matz&lt;/td>
  &lt;/tr>
  &lt;tr>
  &lt;td>perl&lt;/td>
  .......
</pre><br /><br />工作方式类似于我以前做的template( fastm, domplus)。于是就关注了一下。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/208027#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Wed, 25 Jun 2008 21:49:28 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/208027</link>
        <guid>http://buaawhl.javaeye.com/blog/208027</guid>
      </item>
      <item>
        <title>《兰陵王》神木面具</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/203753" style="color:red;">http://buaawhl.javaeye.com/blog/203753</a>&nbsp;
          发表时间: 2008年06月15日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          <a href="http://ent.sina.com.cn/m/2006-12-22/23401382836.html" target="_blank">http://ent.sina.com.cn/m/2006-12-22/23401382836.html</a><br /><br /><div class="quote_title">引用</div><div class="quote_div"><br />远古时代，有一个以凤雀为图腾的部落。首领是一位美丽庄严的女人，她的独生子取名为兰陵。邻近的黑鹰部落经常入侵，凤雀族渴望一位真正的男人带兵出征，保卫部落的平安。长大成人的兰陵面容娇美如女孩，在战场上遭人奚落。不久，黑鹰俘虏了凤雀族的所有男人，为了保存他们，女首领牺牲了自己的贞操。兰陵自此痛恨自己的脸，他千方百计获得了一个神木雕成的面具，戴上它，兰陵所向无敌，为部落报仇雪耻。但面具从此也摘不下来了。兰陵的本性也日愈凶残，他甚至把深爱他的女子英英弄得奄奄一息。兰陵在母亲的咒语中被摘下了面具，但他醒来，仍是恶魔一般。族人群起剿之，幸而得到英英相救，但兰陵却误杀了英英。兰陵被愤怒之极的族人擒住，在众人的强烈要求下，首领架火烧面具，仍无济于事。神最后告诉首领，只有用人血洗面，魔力才会消失。女首领走上祭台，从容自刎，血喷三尺，面具也轰然倒下，一个新的王——兰陵王诞生了。兰陵背负着母亲的遗体，消失于天地间……<br /></div><br /><br />多年前，我看过这个电影，听不懂是什么语言，只能看字幕。<br />还是个不错的电影。<br />最有趣的情节是最后的一幕，兰陵王把面具戴在后脑勺上，吓退了敌人。然后把面具一扔，砸在一座山上。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/203753#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Sun, 15 Jun 2008 18:09:40 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/203753</link>
        <guid>http://buaawhl.javaeye.com/blog/203753</guid>
      </item>
      <item>
        <title>VBA竟然支持命名参数 -- 合并多个Excel workbooks为一个Excel文件</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/203273" style="color:red;">http://buaawhl.javaeye.com/blog/203273</a>&nbsp;
          发表时间: 2008年06月14日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          在网上找到这么一段 Excel 宏代码。<br />可以合并多个Excel Workbooks (即Excel文件) 合并成一个 Excel文件。<br /><br /><br />http://exceltips.vitalnews.com/Pages/T002409_Merging_Many_Workbooks.html<br /><br />Merging Many Workbooks<br /><br />Summary: Got a whole slew of workbooks that you need to merge together? You can do it manually, but it could take you all day. It’s much better to use a macro to do the merging, and you can be done in a few minutes. This tip explains how you can develop such a macro and how it could save you time. (This tip works with Microsoft Excel 97, Excel 2000, Excel 2002, and Excel 2003.)<br /> <br />Joydip Das ran into a problem merging quite a few workbooks together. The majority of the workbooks--about 200 of them, all in a single folder--each contain a single worksheet, but some contain more. The worksheets form each of these workbooks needs to be added to a single workbook.<br />The easiest way to do merges of this magnitude--particularly if you have to do it often--is with a macro. The following macro displays a dialog box asking you to select the files to merge. (You can select multiple workbooks by holding down the Ctrl key as you click each one.) It loops thru the list you select, opening each one and moving all its worksheets to the end of the workbook with the code.<br /><br /><pre name="code" class="java">
Sub CombineWorkbooks()


    Dim FilesToOpen
    Dim x As Integer

    On Error GoTo ErrHandler
    Application.ScreenUpdating = False

    FilesToOpen = Application.GetOpenFilename _
      (FileFilter:="Microsoft Excel Files (*.xls), *.xls", _
      MultiSelect:=True, Title:="Files to Merge")

    If TypeName(FilesToOpen) = "Boolean" Then
        MsgBox "No Files were selected"
        GoTo ExitHandler
    End If

    x = 1
    While x &lt;= UBound(FilesToOpen)
        Workbooks.Open FileName:=FilesToOpen(x)
        Sheets().Move After:=ThisWorkbook.Sheets _
          (ThisWorkbook.Sheets.Count)
        x = x + 1
    Wend

ExitHandler:
    Application.ScreenUpdating = True
    Exit Sub

ErrHandler:
    MsgBox Err.Description
    Resume ExitHandler
End Sub
</pre><br /><br />In the process of adding the worksheets to the end of the workbook, Excel will automatically append a (2), (3), etc. when duplicates worksheet names are detected. Any formulas in the book referring to other sheets will also be updated to reflect the new names.<br /><br />------------------------------<br /><br />上面的VBA代码中<br /><pre name="code" class="java">
    FilesToOpen = Application.GetOpenFilename _
      (FileFilter:="Microsoft Excel Files (*.xls), *.xls", _
      MultiSelect:=True, Title:="Files to Merge")

....
    Workbooks.Open FileName:=FilesToOpen(x)
</pre><br /><br />竟然大量使用了命名参数（如果我没有把VBA语法理解错误的话 -- 我对VBA语法不熟）。<br />Python支持命名参数。Ruby费了半天劲用 hashtable {} 模拟了命名参数。<br />想不到，VBA竟然早就支持了命名参数。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/203273#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Sat, 14 Jun 2008 17:42:47 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/203273</link>
        <guid>http://buaawhl.javaeye.com/blog/203273</guid>
      </item>
      <item>
        <title>老师就是学生的天-- 恩人意识，青天意识从娃娃抓起</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/200469" style="color:red;">http://buaawhl.javaeye.com/blog/200469</a>&nbsp;
          发表时间: 2008年06月05日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          <a href="http://news.sina.com.cn/s/2008-05-30/074515648616.shtml" target="_blank">http://news.sina.com.cn/s/2008-05-30/074515648616.shtml</a><br /><br /><div class="quote_title">引用</div><div class="quote_div"><br />选择了教师职业，就应该选择保护和关爱学生，光亚的孩子远离父母，危难之际，老师就是他们的天。范美忠的做法，无疑是让孩子们觉得地震来临、地动山摇的同时，天也塌了，今后这些孩子会对老师产生不信任感。<br /></div><br /><br />印象中。<br />上小学的时候，老师确实是天，担负着仲裁者和评价者的角色。“Down here, I'm God” &lt;matrix> 台词<br />中学时候，懂了一点事情，知道了老师作为成年人，也有自己的喜怒哀乐，也要受到来自更高级别的仲裁和评价。正所谓天外有天，人外有人。山外青山楼外楼。<br /><br />挣扎无效、无能为力感，导致人们追求精神寄托，希望天外飞仙带来正义和公正。我命由天不由我。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/200469#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Thu, 05 Jun 2008 12:48:08 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/200469</link>
        <guid>http://buaawhl.javaeye.com/blog/200469</guid>
      </item>
      <item>
        <title>地震后的心理创伤治疗和心理危机干预</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/193366" style="color:red;">http://buaawhl.javaeye.com/blog/193366</a>&nbsp;
          发表时间: 2008年05月15日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          唐山大地震的精神影响和心理治疗<br />http://www.xl5.com.cn/Html/QQgame/2007-1/2/01021559164.html<br /><br /><div class="quote_title">引用</div><div class="quote_div"><br />重大精神创伤需防治<br /><br />课题组在对地震孤儿的研究中发现，这一人群中出现频率较高的症状依次为：控制不住回想受打击的经历；遇到与创伤事件多少有些近似的场合或事件时产生明显的生理反应；极力不去想有关创伤性经验的事；避免参加能引起痛苦回忆的活动，或不到能引起痛苦回忆的地方去；过分的惊跳反应；反复发生“触景生情”式的精神痛苦；对未来失去憧憬，如很少思考或计划未来的学习、工作或婚姻等。<br /></div><br /><br /><div class="quote_title">引用</div><div class="quote_div"><br />什么是危机心理干预？<br /><br />心理学领域中，危机干预指对处在心理危机状态下的个人采取明确有效措施，使之最终战胜危机，重新适应生活。心理危机干预的主要目的有二，一是避免自伤或伤及他人，二是恢复心理平衡与动力。在海啸期间，有效的危机干预就是帮助人们获得生理心理上的安全感，缓解乃至稳定由危机引发的强烈的恐惧、震惊或悲伤的情绪，恢复心理的平衡状态，对自己近期的生活有所调整，并学习到应对危机有效的策略与健康的行为，增进心理健康。为了进行有效的危机心理干预，必须了解人们在危机状态下有哪些心理需要。在海啸期间，人们会更关心个人基本的生存问题，如环境是否安全、健康是否有保障等；会担心自己及所关心的人(如父母、亲戚、子女、朋友、老师)；会表现惊慌、无助、逃避、退化、恐惧等行为；想吐露自己对海啸突发事件的内心感受；渴望生活能够尽快安定，恢复到正常状态；希望得到他人情感的理解与支持等。这些心理需要为危机心理干预提供了依据。<br /></div><br /><br /><br />地震后的心理危机干预需要注意什么<br />http://blog.sina.com.cn/s/blog_3f0af67401009d45.html<br /><div class="quote_title">引用</div><div class="quote_div"><br /> 第一、媒体报道和社会宣传时，一定要谨慎，不要过于放大。<br /><br />    并不是所有的人经历过大灾难之后，都一定会留下心理阴影。有些人心理承受能力和调节能力比较强，随着时间的推移，他慢慢地就能自己度过这个难关。事实上大部分人都具有这种自我调节的能力，能够恢复自己内心的平静和平衡。对于一些受心理创伤比较严重，自我没有办法完全恢复的人，我们应该给予更多的关注和支持，帮助他们走出心灵困境。<br /><br />    <strong>第二、参与救助和救援的人，应该是受过训练的专业人员。<br /><br />    有些人满腔热情，没有专业的心理辅导技术和足够的心理准备，匆匆忙忙地就到第一线去了。结果却因为无法承受巨大灾害带来的压力，成了“二次创伤”的受害者。做心理应急干预的人，应该至少具备以下条件：接受过专业的心理危机干预、较强的心理承受能力（能够面对真实的灾难场景、血腥环境）、此刻自我心理健康（没有类似的心理创伤经验）。参与救助的人，自己也是人，一定要防止因为救人而造成救人者的伤害。</strong><br /><br />　　第三、心理危机干预需要时间和过程，绝不是一两天就能完成的。<br /><br />    根据灾难发生之后的时间推移，心理危机干预分为3天、7天、一个月等不同的阶段，各个阶段有不同的工作和辅导内容。心理治愈绝对不是一蹴而就的，需要在日常生活中给予受灾者具体的指导和关心，给他们鼓励，接纳并处理他们出现的一些烦躁和反社会的行为，这些都是需要救援者事先做好准备的。<br /><br />    第四、这次灾难对于普通人来说，也是一次宝贵的自我反思经验。<br /><br />    引发人们重新思考人生，评估生命的价值和意义，思考人生的问题。对于我们追求的价值和目标，重新考虑和权衡。我们活着到底是为了什么、如果明天就离开这个世界，我们能够做到没有遗憾？对父母、对爱人我们是否已经做到问心无愧？经历过这次灾难，我们每一个人都应该重新去思考这个问题，也许会有不同的答案。<br /><br />    这次突如其来的大地震，就像几年前的美国911一样，给人们带来恐慌、抑郁、挫败、无助等等很多负面的情绪。大地震带来的心理危机会在一定时间、一定范围内存在，我们需要时间，有组织、有计划地去开展心理危机干预工作，对受灾者开展心理咨询、心理辅导。<br /></div><br /><br />拿起画笔 伊朗地震灾区采取措施治疗儿童心理创伤<br />http://www.daifumd.com/_daifumd/blog/html/483/article_89489.html<br /><br /><div class="quote_title">引用</div><div class="quote_div"><br />减轻心理压力 <br /><br />    地震给灾区的儿童带来了巨大的心理创伤，面对变成废墟的家园和一具具被抬出的尸体，很多孩子一时难以承受，7岁的侯赛因就是其中之一。于是，他的父亲马赫达维把他带到“爱心帐篷”接受心理治疗。 <br /><br />    马赫达维的家庭在地震中失去了13名成员，他的儿子被惊吓得最厉害。地震刚结束时，当人们从废墟下挖出尸体时，他问道：“人们为什么一个接一个死去？上天为什么这样惩罚我们？”“我不知道该告诉他什么，而且你也藏不住尸体。”马赫达维说。 <br /><br />    “爱心帐篷”的心理医生阿夫沙尔说，地震过后，除了老人和妇女之外，儿童最容易受到伤害，侯赛因正是其中之一。“他们被地震吓呆了，现在还没有缓过来，他们不能理解目前发生的事情。在大概一个月的时间里，他们都不会相信这是真的，之后才会渐渐清楚这一切。因此我们把心理创伤最严重的孩子挑出来，让他们写写画画，这是一种减轻心理压力的方式。” <br /></div><br /><br />灾后心理重建-搜狐健康<br />http://health.sohu.com/s2008/bless/<br /><br /><div class="quote_title">引用</div><div class="quote_div"><br />面对如此重大灾难之后，您还可能出现以下反应<br /><br />·对自己经历的一切感到麻木与困惑。<br />·对幸免于难产生罪恶感。过份的为受害者悲伤、忧郁。<br />· 因心力交瘁、精疲力尽而觉得生气，例如对周围亲友、政府官员、媒体感到愤怒，甚至出现暴躁易怒的情形。<br />· 觉得自己可以做的更好、做得更多而产生罪恶感，怀疑自己是否已经尽力，有无充分帮助周围的人。 <br />· 由于身心极度疲劳，休息与睡眠的不足，此时容易产生生理上的不适感，例如晕眩、呼吸困难、胃痛、紧张、无法放松等。 <br />· 对于接受帮助觉得尴尬、难堪。<br /></div><br /><br /><div class="quote_title">引用</div><div class="quote_div"><br />害怕<br /><br />　　· 很担心灾难会再发生 · 害怕自己或亲人会受到伤害 · 害怕只剩下自己一个人 · 害怕自己崩溃或无法控制自己 无助感<br /><br />　　· 觉得人们是多么脆弱，不堪一击 · 不知道将来该怎么办，感觉前途茫茫 悲伤、罪恶感<br /><br />　　· 为亲人或其它人的死伤感到很难过、很悲痛 · 觉得没有人可以帮助我 · 恨自己没有能力救出家人 · 希望死的人是自己而不是亲人 · 因为比别人幸运而感觉罪恶 愤怒<br /><br />　　· 觉得上天怎么可以对我这么不公平 · 救灾的动作怎么那么慢 · 别人根本不知道我的需要 重复回忆<br /><br />　　· 一直想到逝去的亲人，心里觉得很空虚，无法想别的事 失望<br /><br />　　· 不断地期待奇迹出现，却一次一次地失望 希望<br /><br />　　· 期待重建家园，希望更好的生活将会到来<br /></div>
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/193366#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Thu, 15 May 2008 18:12:18 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/193366</link>
        <guid>http://buaawhl.javaeye.com/blog/193366</guid>
      </item>
      <item>
        <title>国家公园加强领土意识</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/181929" style="color:red;">http://buaawhl.javaeye.com/blog/181929</a>&nbsp;
          发表时间: 2008年04月11日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          我们为什么没有国家公园<br />http://popul.jqcq.com/extend/2006-05/1147740374.html<br /><br /><div class="quote_title">引用</div><div class="quote_div"><br />加拿大就是这样做的。在加拿大的温哥华岛，朋友带我们去看从太平洋到大西洋横穿加拿大的高速路的起点―― “零公里”处，这条路7000多公里长。我发现加拿大这条著名公路的两端都在海岛上，而不是终止在大陆两端，太平洋这边是温哥华岛，大西洋那边是纽芬兰岛。其实这种将横跨国土的高速路的两端，说成是在两个海岛上，并弄成旅游景点，意图无非是强化国家意识。<br /><br />强化国家意识的方法很多，其中重要举措之一是建立国家公园――在国土中选择自然景观瑰丽的地方，划分出来，直属国家管理。<br /><br />在加拿大我看到了许多国家公园。从太平洋到大西洋，从北冰洋到五大湖，尤其在表示国家领土界线的东西南北几个重要的关键点，都设立了国家公园。比如在东北部的巴芬岛上建立了奥尤伊图克国家公园，在北冰洋沿岸的埃尔斯米尔岛建立了埃尔斯米尔国家公园保留地。这些地方冰天雪地，但为了强调国家领土的完整、培育国家意识，加拿大不惜成本，建立国家公园。<br /><br />我们中国没有国家公园，只有国家级风景名胜区和自然保护区。但是他们显然都不是为了培养国家意识而设立的，其中一个强调的是游览，一个强调的是保护；一个是传统的皇家宫苑、士大夫园林、文人山水的思想延续，无非是将其中的皇族、士大夫、文人换成了市民；另一个的思想源头在前苏联，是他们最先建立起自然保护区。<br /></div><br /><br /><div class="quote_title">引用</div><div class="quote_div"><br />而且建立国家公园，培育国家意识对中国同样是重要的。<br /><br />中国是一个多民族的国家。强调国家意识是必要的。另外在西藏的墨脱以南、亚东、阿里，新疆的喀喇昆仑，黑龙江的乌苏里江，东海的钓鱼岛、南海的南沙等都是需要强调国家领土界线的地区，这些地区自然景观又十分壮丽，更有必要建立国家公园，强调领土的完整和国家的统一。<br /><br />遗憾的是我们中国人的国家意识并不强，省、市和县的意识倒很强烈，一些地方政府为了历史遗址的归属争夺得不可开交，许多地方的自然景观无比壮丽，但是“世界级的景观”，却是“乡镇级的管理”，许多世界级的景观成了地方政府的摇钱树，被糟蹋得一塌糊涂。<br /><br />其实我们应该用国家公园这种形式宣布：这些自然和历史留给我们的珍贵财富，不是属于哪个地方的，而是属于全国人民的。<br /></div><br /><br />注 : 本国的国家公园的好处在于,不需要签证.当然,票钱可能还是要交的.
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/181929#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Fri, 11 Apr 2008 19:58:46 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/181929</link>
        <guid>http://buaawhl.javaeye.com/blog/181929</guid>
      </item>
      <item>
        <title>脑筋..柔软性? flexibility? 灵活性? 头脑体操?</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/181018" style="color:red;">http://buaawhl.javaeye.com/blog/181018</a>&nbsp;
          发表时间: 2008年04月09日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          屡次看到"脑筋的柔软性"这个词组.<br />不知道这个词是怎么来的.<br />猜想一下,是不是从英文 flexibility (灵活性) 翻译过来的?
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/181018#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Wed, 09 Apr 2008 20:54:34 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/181018</link>
        <guid>http://buaawhl.javaeye.com/blog/181018</guid>
      </item>
      <item>
        <title>函数的副作用及其他</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/177402" style="color:red;">http://buaawhl.javaeye.com/blog/177402</a>&nbsp;
          发表时间: 2008年03月28日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          函数的副作用及其他<br />Pure Function、Impure Function、副作用、Referential Transparent<br /><br />纯函数（Pure Function）是这样一种函数——输入输出数据流全是显式（Explicit）的。<br />显式（Explicit）的意思是，函数与外界交换数据只有一个唯一渠道——参数和返回值；函数从函数外部接受的所有输入信息都通过参数传递到该函数内部；函数输出到函数外部的所有信息都通过返回值传递到该函数外部。<br />如果一个函数通过隐式（Implicit）方式，从外界获取数据，或者向外部输出数据，那么，该函数就不是Pure Function，叫作Impure Function。<br />隐式（Implicit）的意思是，函数通过参数和返回值以外的渠道，和外界进行数据交换。比如，读取全局变量，修改全局变量，都叫作以隐式的方式和外界进行数据交换；比如，利用I/O API（输入输出系统函数库）读取配置文件，或者输出到文件，打印到屏幕，都叫做隐式的方式和外界进行数据交换。<br />如果用社会现象来比喻，显式（Explicit）就是显规则，隐式（Implicit）就是潜规则。<br />Pure Function就是那种一根筋的理想主义者，绝不搞歪门邪道，没有什么灰色收入，数据入口和出口只有一条唯一途径——参数和返回值。只要卡住参数、返回值的出入口，就可以监控所有的数据流向。这对征税很有好处。比如一般的工薪阶层，只有工资一条收入渠道，扣税是银行直接代缴的。<br />Impure Function就不一样了，为了行事方便，大开后门，各种暗地手段无所不用其极，路子很宽很野。从函数签名（函数名，参数列表，返回值）定义上，你不知道Impure Function内部实现中有多少潜在的条数据交换的通路。监控Impure Function的数据流向是比较困难的。对Impure Function征税，也是比较困难的。只能期望灰色收入的人群自己申报。<br />下面举几个例子。<br /><br />f(x) { return x + 1 } <br />f(x)函数就是Pure Function。<br /><br />a = 0<br />q(x) {<br />  b = a<br />}<br />q(x) 访问了函数外部的变量。q(x)是Impure Function。<br /><br />p(x){<br />	print “hello”<br />}<br />p(x)通过I/O API输出了一个字符串。p(x)是Impure Function。<br /><br />c(x) {<br />  data = readConfig() // 读取配置文件<br />}<br />c(x)通过I/O API读取了配置文件。c(x)是Impure Function。<br /><br />Pure Function内部有隐式（Implicit）的数据流，这种情况叫做副作用（Side Effect）。我们可以把副作用想象为潜规则。上述的I/O，外部变量等，都可以归为副作用。因此，Pure Function的定义也可以写为，没有副作用的函数，叫做Pure Function。<br />I/O API可以看作是一种特殊的全局变量。文件、屏幕、数据库等输入输出结构可以看作是独立于运行环境之外的系统外全局变量，而不是应用程序自己定义的全局变量。<br />上述只讨论了一般的情况，还有一种特殊的情况，我们没有讨论。有些函数的参数是一种In/Out作用的参数，即函数可能改变参数里面的内容，把一些信息通过输入参数，夹带到外界。这种情况，严格来说，也是副作用。也是Impure Function。<br />比如下面的函数。<br />process(context) {<br />	a = context.getInfo()<br />	result = calculate( a )<br />	context.setResult( result )<br />}<br />这种情况下，context参数同时作为输入和输出渠道。严格意义上，这也叫作副作用。参数只作为输入，返回值只作为输出，这才符合严格的Pure Function定义。<br />一般情况下，Pure Function的参数应该是只读的。函数不应该改变参数内部的任何状态。<br />除此之外，还有一种特殊情况。比如，函数调用了获取系统时间的API。这种API是有状态的API，也可以看作是特殊的I/O API。这也是Impure Function。<br /><br />Pure Function有这么多限制，那么Pure Function到底有什么好处呢？难道就是监控数据流方便？还是征税方便？<br />我能想到的，Pure Function的好处主要有几点：<br />（1）无状态，Stateless。线程安全。不需要线程同步。<br />（2）Pure Function相互调用组装起来的函数，还是Pure Function。<br />（3）应用程序或者运行环境（Runtime）可以对Pure Function的运算结果进行缓存，运算加快速度。<br /><br />上述的好处（3）需要说明一下。Pure Function的输入、输出都是固定的。输入是同样的参数，输出结果一定是同样的结果。而Impure Function的副作用是无法用（参数、结果）缓存的。参见前面的例子。<br />没有副作用，也可以叫做Referential Transparent（引用透明）。<br />Referential Transparent的意思好像这样的。在一个范围内，一个变量或者表达式出现在多个地方，那么这些地方的值都是一样的，可以进行值替换。<br />比如，<br />f(x) {<br />  a = f(x)<br />  b = f(x)<br />}<br /><br />编译器或者运行环境发现程序里面出现了两次f(x)，就可以放心地用第一个f(x)的结果，代替另一个f(x)。（这是我的个人理解，不能确保就是如此。）<br /><br />---------------------------------------<br />副作用、状态、I/O、AOP、Monad<br /><br />Pure Function是无状态的。很好，很干净。清净琉璃体，玲珑剔透心。<br />Haskell就是这样一种理想主义的Pure Functional Language（纯函数式编程语言）。<br />但是，世界是复杂的，有很多潜规则，华丽的外表下有很多暗流在涌动。无状态的Pure Function不足以表达充满了状态和副作用的现实需求。<br />我们来看一看，哪些副作用是可以避免的，那些副作用是无法避免的。<br />首先，全局变量的副作用是很容易避免的。全局变量的读写，可以用参数和返回值代替。我们可以比较容易地消除代码中的全局变量。同样，参数里面放置返回值的情况，也可以很容易用返回值避免。<br />比较难以处理的情况是I/O的情况。一个应用系统总是需要输入输出的。如果一个应用系统只是在启动的时候，需要输入，在结束的时候，进行输出，那么还好处理一点。我们可以把I/O集中在系统的最外层处理，系统内部不需要处理任何I/O。但这只是一种良好的愿望。常见的应用系统都是交互式的，而且系统经常需要吐出一堆堆的log，经常需要重新接受用户的配置选项更改。<br />I/O又是一种非常特殊的全局变量。I/O设备（或者结构）独立于应用系统之外（比如，文件，网络，数据库系统）。应用系统很难在程序设计的层次上，用参数、返回值代替I/O API。<br />输出部分还是比较容易收集。我们可以把所有的输出都收集到一个巨大的List结构中，作为返回值，一层层返回到最外层。最外层统一把List中的数据全部输出到对应设备。<br />输入部分，就难办了。应用程序可能随时需要访问一下配置文件、数据库、系统时钟等设备。我们无法预料到程序内部什么时候需要读取什么样的设备和信息，我们无法提前准备这些输入信息作为参数。<br />怎么办呢？我们联想一下。AOP（Aspect Oriented Programming）最著名的例子就是Log（系统日志）。<br />在AOP中，函数出入口的Log等脏活累活都可以统一集中地交给几个Advice类处理。Advice类就是那种Interceptor、Filter、Proxy之类的东西。通常会有intercept、around等方法。<br />主体程序本身是高贵的，不需要处理Log。编译过程或者运行过程中，AOP系统负责把Advice类里面的Log处理代码夹杂到主体程序中，工作过程非常类似于计算机病毒感染的过程。<br />于是，进到AOP系统这个大染缸之前，主体程序还是冰清玉洁的；主体程序进入AOP系统，并从AOP系统出来之后，主题程序就已经被感染了，具有了Log等功能。<br />正如马克.吐温在&lt;竞选州长>中描述的。<br />“你忠实的朋友，过去是正派人，现在却成了伪证犯、小偷、拐尸犯、酒疯子、贿赂犯和讹诈犯的马克•吐温。”<br /><br />同样的思路，能否应用到Pure Function中呢？<br />比如，我们可以保持Pure Function的纯洁性，把IO这样的操作，移动到Advice（or Proxy）类里面。然后通过某种类似于AOP的机制，把两者绑定起来。<br />正如表面看上去，凯撒的归凯撒，上帝的归上帝，世俗王权和宗教神权互不干涉。但实际上，对于权力、金钱的渴望，通常会导致王权神权两种权力的冲突和勾结。<br />Haskell是Pure Functional Language。Haskell处理IO的方法之一叫作Monad。<br />Monad是一种臭名昭著的难以理解的东西。<br />Monad不是我所能理解的东西。我只能对Monad进行猜想。<br />我猜想，Monad是一种类似于Advice、Proxy的类型定义。<br />Monad是一种类型定义。可能和C++ Template有些相似。<br />Monad类型就是专门做IO杂事的特殊类型。除了Monad类型，其他的函数或者类型都是Pure。<br />如果一个Pure Function，需要输入输出，就必须被Monad包装。<br />我们可以想象几个IO Monad Proxy的例子。<br />InputProxy ( function ) {  // function 就是被截获的Pure Function<br />	a = readSomething // 读取输入设备<br />	f( a )<br />}<br /><br />OutputProxy( function) { // function 就是被截获的Pure Function<br />	b = function()<br />	print b<br />}<br /><br />在Monad Proxy中，（我猜想）应该只能存在一条输入输出语句。如上例所示。<br />如果要同时输入输出。那么就必须把上述的Monad Proxy串起来。<br />比如，先输入，再输出。应该这么写。OutputProxy( InputProxy ( function ) )<br />如果用嵌套函数的写法，应该写成这样。<br />OutputProxy() {<br />	b = InputProxy() {<br />		a = readSomething()<br />		function( a ) {<br />			// process a<br />		}<br />	}<br /><br />	print b<br />}<br /><br />为什么一定要保证一个函数中的输入输出语句只有一条？为什么一定要写成这样？<br />我猜想，这可能和Haskell的Referential Transparent的特性有关。Haskell支持Referential Transparent，支持同名变量或者同字符串表达式的任意替换。在一定程度上，Haskell程序的代码是顺序无关的。如果是Pure Function，编译器处理起来比较容易。<br />如果引入了和外界交换状态的输入输出语句，就必须强制代码的顺序性了。必须保证代码顺序执行。在Haskell中，要强制顺序，只能通过函数的一层层调用来保证。<br />正如前面所说的。Haskell中，<br />a = f(x)<br />b = g(x)<br />这种同一层的两次f(x)调用，不一定能够保证这两条语句的执行顺序。<br />要保证f在g之前执行，我们只能写成 g ( f (.. ) ) 的形式，才能保证 f 在 g 之前执行。<br /><br />Haskell的do语句可能就是把看起来是平级顺序语句转化成层层嵌套调用的语法糖。<br />比如，<br />do <br />readSomething<br />print something<br /><br />实际上会被翻译成函数调用的嵌套形式。<br />g() {<br />	readSomething<br />	f() {<br />		print something<br />	}<br />}<br /><br />Monad类型定义其实就是为了生成这样的函数调用嵌套结构。这个生成过程好像也叫作bind（绑定）。<br />bind就有点类似于AOP系统的那种夹杂绑定过程，把干净的东西和副作用揉合到一起。<br />注，上述只是猜想。<br />那些城里人动不动就搞些Category之类的名词吓唬我们乡下人。不讲人话，总是讲神话。<br />我希望，咱老百姓能够讲述自己的故事。不整那些神鬼莫测的名词，也照样能把话说清楚。<br />显然，这是一种奢望。至少我还说不清楚。话语权还是握在城里人的手里。<br /><br />参见<br />农民对城里人的抱怨<br />http://www.javaeye.com/topic/165962
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/177402#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Fri, 28 Mar 2008 19:48:14 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/177402</link>
        <guid>http://buaawhl.javaeye.com/blog/177402</guid>
      </item>
      <item>
        <title>Copy On Write Hash Map (线程同步相关)</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/174592" style="color:red;">http://buaawhl.javaeye.com/blog/174592</a>&nbsp;
          发表时间: 2008年03月21日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          本文是继前两篇文章之后的有一篇线程数据结构相关文章.<br /><br />线程同步<br />http://www.javaeye.com/topic/164905<br /><br />线程同步模型, 生产者/消费者, 读写同步,线程池,concurrent map<br />http://www.javaeye.com/topic/174591<br /><br /><br />我以前写过这个Fast Read Map 数据结构的文章.<br />但是那个时候, 理解得并不是那么透彻, 这里重新整理再发一遍.<br /><br />-------------------------<br /><br />Copy On Write Hash Map<br />我们在工作的过程中，经常遇到如下的需求：<br />用一个Map存放常用的Object，这个Map的并发读取的频率很高，而写入的频率很低，一般只在初始化、或重新装装载的时候写入。读写冲突虽然很少发生，不过一旦发生，Map的内部结构就可能乱掉，所以，我们不得不为Map加上同步锁。<br />我们可以采用Copy On Write的机制，来加强Map的读取速度。<br />Copy On Write是这样一种机制。当我们读取共享数据的时候，直接读取，不需要同步。当我们修改数据的时候，我们就把当前数据Copy一份副本，然后在这个副本上进行修改，完成之后，再用修改后的副本，替换掉原来的数据。这种方法就叫做Copy On Write。<br />Oracle等关系数据库的数据修改就采用Copy On Write的模式。Copy On Write模式对并发读取的支持很好，但是在并发修改的时候，会有版本冲突的问题。可能有多个线程同时修改同一份数据，那么就同时存在多个修改副本，这多个修改副本可能会相互覆盖，导致修改丢失。因此，Oracle等数据库通常会引入版本检查机制。即增加一个版本号字段，来检测是否存在并发修改。相似的版本控制机制存在于CVS、SVN等版本控制工具中。<br />在我们的Copy On Write Map中，我们只需要让新数据覆盖旧数据就可以了，因此不需要考虑版本控制的问题。这就大大简化了我们的实现。<br />基本思路就是让读和写操作分别在不同的Map上进行，每次写完之后，再把两个Map同步。代码如下：<br /><pre name="code" class="java">
/*
 * Copy On Write Map
 * 
 * Write is expensive.
 * Read is fast as pure HashMap.
 *
 * Note: extra info is removed for free use
 */
import java.lang.Compiler;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.HashMap;
import java.util.Collections;
 public class ReadWriteMap implements Map {
	protected volatile Map mapToRead = getNewMap();
 	// you can override it as new TreeMap();
	protected Map getNewMap(){
		return new HashMap();
	}
 	// copy mapToWrite to mapToRead
	protected Map copy(){
		Map newMap = getNewMap();
		newMap.putAll(mapToRead);
		return newMap;
	}
 
	// read methods
	public int size() {
		return mapToRead.size();
	}
	public boolean isEmpty() {
		return mapToRead.isEmpty();
	}
 
	public boolean containsKey(Object key) {
		return mapToRead.containsKey(key);
	}
 
	public boolean containsValue(Object value) {
		return mapToRead.containsValue(value);
	}
 
	public Collection values() {
		return mapToRead.values();
	}
 
	public Set entrySet() {
		return mapToRead.entrySet();
	}
 
	public Set keySet() {
		return mapToRead.keySet();
	}
 
	public Object get(Object key) {
		return mapToRead.get(key);
	}
 
	// write methods
	public synchronized void clear() {
		mapToRead = getNewMap();
	}
 
	public synchronized Object remove(Object key) {
		Map map = copy();
		Object o = map.remove(key);
		mapToRead = map;
		return o;
	}
 
	public synchronized Object put(Object key, Object value) {
		Map map = copy(); 
		Object o = map.put(key, value);
		mapToRead = map;
		return o;
	}
 
	public synchronized void putAll(Map t) {
		Map map = copy(); 
		map.putAll(t);
		mapToRead = map;
	}
}
</pre><br /> 这个Map读取的时候，和普通的HashMap一样快。<br />写的时候，先把内部Map复制一份，然后在这个备份上进行修改，改完之后，再让内部Map等于这个修改后的Map。这个方法是同步保护的，避免了同时写操作。可见，写的时候，开销相当大。尽量使用 putAll() method。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/174592#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Fri, 21 Mar 2008 18:19:54 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/174592</link>
        <guid>http://buaawhl.javaeye.com/blog/174592</guid>
      </item>
      <item>
        <title>线程同步模型, 生产者/消费者, 读写同步,线程池,concurrent map.</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/174591" style="color:red;">http://buaawhl.javaeye.com/blog/174591</a>&nbsp;
          发表时间: 2008年03月21日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          之前写了一篇线程同步的原理分析的文章.<br /><br />线程同步<br />http://www.javaeye.com/topic/164905<br /><br />看到大家的反馈,感到深受鼓励.<br />看来这种举例说明本质原理的浅显易懂的文章, 还是比较受欢迎的.<br />关于线程, 我以前也写过一些文章.只是写得不那么清楚易懂.<br />一是因为自己的理解也有限, 二是很难找到灵感,很难写出一个非常贴切的例子.<br /><br />应一些坛友的意见. 我这里继续发一些线程相关的内容. <br />内容的条理性和连贯性可能有些欠缺.<br /><br />-------------------------------------------------------------------------<br /><br />生产者/消费者模型<br /><br />有了信号量这个利器，我们就可以处理比较复杂的线程同步模型了。<br />首先，我们来看一个比较简单的生产者/消费者模型。还是以Java代码为例。<br /><br />public static final Object signal = new Object();<br />public static final char[] buf = new char[1024]; // 需要同步访问的共享资源<br /><br />// 生产者代码<br />… produce() {<br /><br />  for(… ) { // 循环执行<br /><br />  synchronized(signal){<br />      // 产生一些东西，放到 buf 共享资源中<br /><br />      signal.notify(); //然后通知消费者<br />      signal.wait(); // 然后自己进入signal待召队列<br />  }<br />  }<br />}<br /><br />// 消费者代码<br />… consume() { <br /><br />  for(… ) { // 循环执行<br /><br />  synchronized(signal){<br /><br />      signal.wait(); // 进入signal待召队列，等待生产者的通知<br /><br />      // 读取buf 共享资源里面的东西<br /><br />      signal.notify(); // 然后通知生产者<br />  }<br />  }<br />}<br /><br />上述的生产者/消费者模型的实现非常简单，只用了一个信号量signal。这只是一段示意代码。<br />实际上的生产者/消费者模型的实现可能非常复杂。可以引入buf已满或者已空的判断，可以引入更多的信号量，也可以引入一个环状的buf链。但那些都是性能优化方面的工作，基本的信号量工作方式还是不变的。<br />生产者/消费者模型是典型的Coroutine。而且，当消费者或者生产者线程进入待召队列的时候，当前的运行栈状态就暂时保存在系统当中，这种状况又是典型的Continuation。<br />因此，我们完全可以用信号量机制自己实现Coroutine和Continuation。其实，那些在语法层面上支持Coroutine和Continuation的语言，内部实现原理也是采用类似的信号量同步机制。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/174591#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Fri, 21 Mar 2008 18:15:07 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/174591</link>
        <guid>http://buaawhl.javaeye.com/blog/174591</guid>
      </item>
      <item>
        <title>未来社会形态猜想</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/171372" style="color:red;">http://buaawhl.javaeye.com/blog/171372</a>&nbsp;
          发表时间: 2008年03月14日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          <div class="quote_title">ray_linn 写道</div><div class="quote_div"><div class="quote_title">zbird 写道</div><div class="quote_div"><div class="quote_title">xyz20003 写道</div><div class="quote_div">可以哟，实现共产主义了，按需分配，想要什么就可以得到什么。</div><br />我觉得共产主义社会才真是人类的灾难。<br />按需分配，你需要的是什么？<br />人类是复杂的，并不是我要脸盆，给个脸盆，我要勺子给个勺子就能满足的。</div><br /><br />女人,好多女人.<br /><br />以前我们老师给我们论证XX主义为什么不可能实现,就是这么说的.<br /><br />我看上一个女人,你也看上同一个女人,你得到那个女人,我就得不到那个女人,我生气我愤怒...</div><br /><br />"得到"这个词还具有私有制"占有物"的痕迹.<br />共产主义社会的人们,可能早就摆脱了现在人类的趣味.<br />正如古代奴隶社会人们难以想象现代民主社会人民的生活方式,我们也很难想象未来社会的生活方式.<br />难以想象,也不妨想象一下.<br /><br />物质极大丰富的未来社会很可能实现.未来社会也许不存在一个统一分配资源的中心权力机构,只存在一些公共服务机构.<br />物质极大丰富之后,人们不再受到经济条件的制约,很可能也不再受到生物条件的制约--人类(尤其是女人)可能摆脱生育的桎梏.<br />婚姻可能会消亡.后代的制造也许会通过配子(卵子,精子).专一爱情可能会消亡.爱情会存在.<br />因为人们都富有了.择偶标准可能会变化.女择男主要标准不再是财产,而是身材,相貌,性格等.<br />最后导致的结果很可能是,人类会越来越漂亮. 不漂亮的人类可能会失去择偶权和生殖权.这将是人类基因库的一场灾难.<br />女人地位可能会提高, 高过男人. 因为<br />(1)女人的生育资源基因资源比男人宝贵. 女人一生中只有400个卵子.<br />(2)理性分析等工作可能大量被计算机人工智能代替, 男人的理性思维优势不再存在, 女人的感性思维大行其道.<br /><br />....等等.
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/171372#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Fri, 14 Mar 2008 13:08:47 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/171372</link>
        <guid>http://buaawhl.javaeye.com/blog/171372</guid>
      </item>
      <item>
        <title>无法用金钱替代的感情, 才是真正的人情? -- T1 语录摘录 兼 评述</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/170786" style="color:red;">http://buaawhl.javaeye.com/blog/170786</a>&nbsp;
          发表时间: 2008年03月13日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          人情的经济学分析 ( 加个题目 )<br /><br /><div class="quote_title">T1 写道</div><div class="quote_div"><br />经济越发达的地方,所谓的人情越是淡薄.很多所谓的人情,在经济不发达的地区往往充当了经济替代品的角色. <br />养儿防老，父慈子孝，为什么?因为在一个缺乏社会保障的会里,对于步入老年的人来说家庭伦理是唯一的依靠而不是社会福利. <br />两肋插刀，豪气干云，为什么?因为在一个缺乏信用认可监督机制的社会里，一个人的日常行为表现就成了他唯一的信用记号而不是银行的信用记录. <br /><br />在经济发达地区的人情淡薄,是因为这些以经济为功用的人情经历了市场机制的筛汰,人们找到了比他们更为合适更为高效的方式.换而言之,在经济发达地区那些被淡薄以后的人情,才是人与人之间必不可少,无法用金钱替代的感情.<br /><br />应该用可以数字化管理的货币来替代那些可以替代的部分.<br />比如说,我们习惯上为病榻上的父母端屎端尿,擦身喂饭可以算做是一种尽孝道的方式,有些人出自内心任劳任怨那当然是善举,但是有些人甚至可以说是大部分人都是硬着头皮不给人笑话，毕竟嫌脏怕臭是人之常情让你义务扫公厕通粪沟你也是不愿意的.但是如果你有了经济实力比如说懂得投资理财,那么你自然可以用货币把这些事情分包出去，请一个专职的护工甚至护士照顾你父母的起居和病痛.而你则可以陪伴父母在病床前配他们聊天,看电视,看着儿孙绕膝分享天伦之乐.<br />在这里人情淡薄了吗?没有,金钱淡薄的只是那些本不应该成为人情的"人情".这些所谓的"人情"在我们这样一个社会中的确起到了很大的作用,但是事实上正是这些所谓的"人情"才真正的冲淡了我们应该享受到的亲情.在我们父母这一辈为了谁赡养父母事情互相踢皮球搞得亲戚之间不来往,夫妻之间不和睦的事情付首皆是.为什么?最大的问题就是因为这些人情是经济性的而非感情性的.<br /></div><br /><br />总结,有钱人的人情, 才是真正的人情. 穷人的人情大部分都不是人情.<br /><br />--------------------------<br /><br />这个分析思路很对. 可以剔除很多 "经济基础上" 的 钱-情 交易.<br /><br />不过呢,分析的难度颇大.<br />人之所以为人,受环境的影响很大, 不仅受现在的环境影响, 而且受以前的环境影响. <br /><br />比如, T1的名帖, "身上这些病都是打野食那年头攒下的"<br /><br />人类的这点毛病都是从打猎那年头攒下的 (ZZ)<br />http://www.javaeye.com/topic/156729<br /><br />经济环境, 也是环境的一种. 很难剥离出来.<br />很多感情,人情, 甚至很多比较深刻的感情, 都是由于经济基础的缺失, 才产生出来的.<br />为民请命,大义凛然,都是在广大人民受到压迫的环境中,才能产生出来的崇高情怀. <br />农奴制的俄国, 产生了很多世界知名的文学家和音乐家. <br />(当然,我不赞成广大人民受压迫的社会, 那相当于牺牲大部分人,为小部分人提供舞台)<br /><br />人人平等自由的公平社会(假设有这样的社会), 可能只剩下快餐类的情绪.<br /><br />--------------------------<br /><br />人的感受能力和感受方面是不同的.<br />物质感受能力较强的,适合出国到发达国家.发达国家的普通家庭的生活水准,相当于国内中上家庭.可能还要高.<br />精神感受能力较强的,适合待在国内.因为国内有中文, 中国人,中国生活,中国文化等.<br /><br />--------------------------<br /><br />人们可以尽量享受现有资源. 而不是忽略现有资源,只看到现在没有的资源.<br />比如,人穷的时候, 可以多多体会两肋插刀，豪气干云的兄弟义气. 当然, 不能违法 (违法也不能说是我教唆的).<br />富了之后,可能就很难体会到这种兄弟义气了.
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/170786#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Thu, 13 Mar 2008 12:43:01 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/170786</link>
        <guid>http://buaawhl.javaeye.com/blog/170786</guid>
      </item>
      <item>
        <title>Google Sketchup 三维建模软件（含建筑装修摆设资源，包括 office）</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/166101" style="color:red;">http://buaawhl.javaeye.com/blog/166101</a>&nbsp;
          发表时间: 2008年02月29日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          <a href="http://sketchup.google.com/" target="_blank">http://sketchup.google.com/</a><br /><br />Google Sketchup 是我能找到的最好的免费三维建模软件。<br />操作简单。红绿蓝代表XYZ轴。渲染效果也还凑合。虽然比不上 3d Max 之类的那么好的效果，但是一般的室内外装修效果还是可以看出来的。桌椅摆放也很方便。<br /><br />很多人把自己的家居摆设，都晒在 Google Earth上。<br />网上有很多 Sketchup Model资源。<br />http://sketchup.google.com/3dwarehouse<br /><br />在Google 3D warehouse 搜索 Office，可以搜索到不少office摆设的资源。<br /><br />看到 potian 在征求 office 摆放的意见。就想起 Google Sketchup 资源。兹写此文。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/166101#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Fri, 29 Feb 2008 12:36:45 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/166101</link>
        <guid>http://buaawhl.javaeye.com/blog/166101</guid>
      </item>
      <item>
        <title>农民对城里人的抱怨 -- 读“语义与并行不可分,兼回qiezi的Blog”有感</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/165962" style="color:red;">http://buaawhl.javaeye.com/blog/165962</a>&nbsp;
          发表时间: 2008年02月28日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          农民对城里人的抱怨<br />http://tieba.baidu.com/f?kz=2454240<br />　　<br />　　俺们刚吃上肉，你们又吃菜了；<br />　　俺们刚娶上媳妇，你们又独身了；<br />　　俺们刚吃上糖，你们又尿糖了；<br />　　俺们刚用上白纸擦屁股，你们又用它擦嘴了。<br />　　俺们刚能歇会儿不用擦汗你们又去健身房、桑拿房流汗了；<br />　　俺们刚装上电话你们又改网上聊天了；<br />　　俺们刚能在电影院约会你们又改网恋了；<br />　　俺们刚学会搞对象叫爱情你们就喜欢同性恋了。<br />　　俺们刚娶上媳妇你们又开始包二奶了；<br />　　俺们刚吃饱穿暖你们又减肥露脐了。<br />　　俺们刚开始用老玉米喂猪你们又把它当成补品了；<br />　　俺们刚不用爬山寻草药卖了你们又开攀岩蹦极了；<br />　　俺们刚搬出山沟有地种了你们又钻进山洼找野趣了；<br />　　俺们刚住瓦房你们又要露营了。<br />　　俺们刚学会高考，你们都自学了。<br />　　俺们都结扎了你们又人工试管了。<br />　　俺们刚把青菜上的害虫灭掉你们又爱吃虫啃过的青菜了<br />　　俺们刚开始学会打麻将你们又开始赌球了<br />　　俺们刚通上电你们又兴烛光晚会了<br /><br />-----------------------------------------<br />语义与并行不可分,兼回qiezi的Blog<br />http://www.javaeye.com/topic/165930<br /><br />当然现在Ocmal社区出现了Jocaml，其并发效率超过了Erlang.不过Jocaml是基于pi-calculus和join-calculus的并发与现在所有的并发机制都不同，这又是另外一个很大的话题了。<br /><br />所以什么是样风格的并行是可以large scale的并行？这个问题的答案不完全基于语法上的,更重要的是基于语义和VM模型上的.其标准,我觉得Ulf Wiger 的这篇文章，http://erlang-china.org/news/erlang-style_concurrency.html，说的很明白了。虽然IO,Ruby的revactor,Stackless Python这些语言可以在语法上接近甚至超越Erlang,但是只要没有办法解决进程之间彻底独立不共享内存这一条就无法进行large scale的并行，勉强只能算是高性能的并发.<br /><br />---------------------------------------------<br /><br />俺们刚 C++, 你们又 Java 了。<br />俺们刚 Java, 你们又 Ruby 了。<br />俺们刚 Ruby, 你们又 ErLang 了。<br />俺们刚 ErLang, 你们又 JoCaml 了。<br /><br /><br />俺们刚听说啥叫电脑，你们又软件英雄了。<br />俺们刚软件个人英雄主义，你们又软件工程了。<br />俺们刚软件工程，你们又敏捷了。<br />俺们刚敏捷了，你们又不敏捷了。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/165962#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Thu, 28 Feb 2008 21:48:16 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/165962</link>
        <guid>http://buaawhl.javaeye.com/blog/165962</guid>
      </item>
      <item>
        <title>线程同步</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/164905" style="color:red;">http://buaawhl.javaeye.com/blog/164905</a>&nbsp;
          发表时间: 2008年02月25日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          线程同步<br />作者 : buaawhl<br /><br />我们可以在计算机上运行各种计算机软件程序。每一个运行的程序可能包括多个独立运行的线程（Thread）。<br />线程（Thread）是一份独立运行的程序，有自己专用的运行栈。线程有可能和其他线程共享一些资源，比如，内存，文件，数据库等。<br />当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢作一团。<br />同步这个词是从英文synchronize（使同时发生）翻译过来的。我也不明白为什么要用这个很容易引起误解的词。既然大家都这么用，咱们也就只好这么将就。<br />线程同步的真实意思和字面意思恰好相反。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。<br /><br />因此，关于线程同步，需要牢牢记住的第一点是：线程同步就是线程排队。同步就是排队。线程同步的目的就是避免线程“同步”执行。这可真是个无聊的绕口令。<br />关于线程同步，需要牢牢记住的第二点是 “共享”这两个字。只有共享资源的读写访问才需要同步。如果不是共享资源，那么就根本没有同步的必要。<br />关于线程同步，需要牢牢记住的第三点是，只有“变量”才需要同步访问。如果共享的资源是固定不变的，那么就相当于“常量”，线程同时读取常量也不需要同步。至少一个线程修改共享资源，这样的情况下，线程之间就需要同步。<br />关于线程同步，需要牢牢记住的第四点是：多个线程访问共享资源的代码有可能是同一份代码，也有可能是不同的代码；无论是否执行同一份代码，只要这些线程的代码访问同一份可变的共享资源，这些线程之间就需要同步。<br /><br />为了加深理解，下面举几个例子。<br />有两个采购员，他们的工作内容是相同的，都是遵循如下的步骤：<br />（1）到市场上去，寻找并购买有潜力的样品。<br />（2）回到公司，写报告。<br />这两个人的工作内容虽然一样，他们都需要购买样品，他们可能买到同样种类的样品，但是他们绝对不会购买到同一件样品，他们之间没有任何共享资源。所以，他们可以各自进行自己的工作，互不干扰。<br />这两个采购员就相当于两个线程；两个采购员遵循相同的工作步骤，相当于这两个线程执行同一段代码。<br /><br />下面给这两个采购员增加一个工作步骤。采购员需要根据公司的“布告栏”上面公布的信息，安排自己的工作计划。<br />这两个采购员有可能同时走到布告栏的前面，同时观看布告栏上的信息。这一点问题都没有。因为布告栏是只读的，这两个采购员谁都不会去修改布告栏上写的信息。<br /><br />下面增加一个角色。一个办公室行政人员这个时候，也走到了布告栏前面，准备修改布告栏上的信息。<br />如果行政人员先到达布告栏，并且正在修改布告栏的内容。两个采购员这个时候，恰好也到了。这两个采购员就必须等待行政人员完成修改之后，才能观看修改后的信息。<br />如果行政人员到达的时候，两个采购员已经在观看布告栏了。那么行政人员需要等待两个采购员把当前信息记录下来之后，才能够写上新的信息。<br />上述这两种情况，行政人员和采购员对布告栏的访问就需要进行同步。因为其中一个线程（行政人员）修改了共享资源（布告栏）。而且我们可以看到，行政人员的工作流程和采购员的工作流程（执行代码）完全不同，但是由于他们访问了同一份可变共享资源（布告栏），所以他们之间需要同步。<br /><br />同步锁<br /><br />前面讲了为什么要线程同步，下面我们就来看如何才能线程同步。<br />线程同步的基本实现思路还是比较容易理解的。我们可以给共享资源加一把锁，这把锁只有一把钥匙。哪个线程获取了这把钥匙，才有权利访问该共享资源。<br />生活中，我们也可能会遇到这样的例子。一些超市的外面提供了一些自动储物箱。每个储物箱都有一把锁，一把钥匙。人们可以使用那些带有钥匙的储物箱，把东西放到储物箱里面，把储物箱锁上，然后把钥匙拿走。这样，该储物箱就被锁住了，其他人不能再访问这个储物箱。（当然，真实的储物箱钥匙是可以被人拿走复制的，所以不要把贵重物品放在超市的储物箱里面。于是很多超市都采用了电子密码锁。）<br />线程同步锁这个模型看起来很直观。但是，还有一个严峻的问题没有解决，这个同步锁应该加在哪里？<br />当然是加在共享资源上了。反应快的读者一定会抢先回答。<br />没错，如果可能，我们当然尽量把同步锁加在共享资源上。一些比较完善的共享资源，比如，文件系统，数据库系统等，自身都提供了比较完善的同步锁机制。我们不用另外给这些资源加锁，这些资源自己就有锁。<br />但是，大部分情况下，我们在代码中访问的共享资源都是比较简单的共享对象。这些对象里面没有地方让我们加锁。<br />读者可能会提出建议：为什么不在每一个对象内部都增加一个新的区域，专门用来加锁呢？这种设计理论上当然也是可行的。问题在于，线程同步的情况并不是很普遍。如果因为这小概率事件，在所有对象内部都开辟一块锁空间，将会带来极大的空间浪费。得不偿失。<br />于是，现代的编程语言的设计思路都是把同步锁加在代码段上。确切的说，是把同步锁加在“访问共享资源的代码段”上。这一点一定要记住，同步锁是加在代码段上的。<br />同步锁加在代码段上，就很好地解决了上述的空间浪费问题。但是却增加了模型的复杂度，也增加了我们的理解难度。<br />现在我们就来仔细分析“同步锁加在代码段上”的线程同步模型。<br />首先，我们已经解决了同步锁加在哪里的问题。我们已经确定，同步锁不是加在共享资源上，而是加在访问共享资源的代码段上。<br />其次，我们要解决的问题是，我们应该在代码段上加什么样的锁。这个问题是重点中的重点。这是我们尤其要注意的问题：访问同一份共享资源的不同代码段，应该加上同一个同步锁；如果加的是不同的同步锁，那么根本就起不到同步的作用，没有任何意义。<br />这就是说，同步锁本身也一定是多个线程之间的共享对象。<br /><br />Java语言的synchronized关键字<br /><br />为了加深理解，举几个代码段同步的例子。<br />不同语言的同步锁模型都是一样的。只是表达方式有些不同。这里我们以当前最流行的Java语言为例。Java语言里面用synchronized关键字给代码段加锁。整个语法形式表现为<br />synchronized(同步锁) {<br />  // 访问共享资源，需要同步的代码段<br />}<br /><br />这里尤其要注意的就是，同步锁本身一定要是共享的对象。<br /><br />… f1() {<br /><br />Object lock1 = new Object(); // 产生一个同步锁<br /><br />synchronized(lock1){<br />  // 代码段 A<br />// 访问共享资源 resource1<br />// 需要同步<br />}<br />}<br /><br />上面这段代码没有任何意义。因为那个同步锁是在函数体内部产生的。每个线程调用这段代码的时候，都会产生一个新的同步锁。那么多个线程之间，使用的是不同的同步锁。根本达不到同步的目的。<br />同步代码一定要写成如下的形式，才有意义。<br /><br />public static final Object lock1 = new Object();<br /><br />… f1() {<br /><br />synchronized(lock1){ // lock1 是公用同步锁<br />  // 代码段 A<br />// 访问共享资源 resource1<br />// 需要同步<br />}<br /><br />你不一定要把同步锁声明为static或者public，但是你一定要保证相关的同步代码之间，一定要使用同一个同步锁。<br />讲到这里，你一定会好奇，这个同步锁到底是个什么东西。为什么随便声明一个Object对象，就可以作为同步锁？<br />在Java里面，同步锁的概念就是这样的。任何一个Object Reference都可以作为同步锁。我们可以把Object Reference理解为对象在内存分配系统中的内存地址。因此，要保证同步代码段之间使用的是同一个同步锁，我们就要保证这些同步代码段的synchronized关键字使用的是同一个Object Reference，同一个内存地址。这也是为什么我在前面的代码中声明lock1的时候，使用了final关键字，这就是为了保证lock1的Object Reference在整个系统运行过程中都保持不变。<br />一些求知欲强的读者可能想要继续深入了解synchronzied(同步锁)的实际运行机制。Java虚拟机规范中（你可以在google用“JVM Spec”等关键字进行搜索），有对synchronized关键字的详细解释。synchronized会编译成 monitor enter, … monitor exit之类的指令对。Monitor就是实际上的同步锁。每一个Object Reference在概念上都对应一个monitor。<br />这些实现细节问题，并不是理解同步锁模型的关键。我们继续看几个例子，加深对同步锁模型的理解。<br /><br />public static final Object lock1 = new Object();<br /><br />… f1() {<br /><br />synchronized(lock1){ // lock1 是公用同步锁<br />  // 代码段 A<br />// 访问共享资源 resource1<br />// 需要同步<br />}<br />}<br /><br />… f2() {<br /><br />synchronized(lock1){ // lock1 是公用同步锁<br />  // 代码段 B<br />// 访问共享资源 resource1<br />// 需要同步<br />}<br />}<br /><br />上述的代码中，代码段A和代码段B就是同步的。因为它们使用的是同一个同步锁lock1。<br />如果有10个线程同时执行代码段A，同时还有20个线程同时执行代码段B，那么这30个线程之间都是要进行同步的。<br />这30个线程都要竞争一个同步锁lock1。同一时刻，只有一个线程能够获得lock1的所有权，只有一个线程可以执行代码段A或者代码段B。其他竞争失败的线程只能暂停运行，进入到该同步锁的就绪（Ready）队列。<br />每一个同步锁下面都挂了几个线程队列，包括就绪（Ready）队列，待召（Waiting）队列等。比如，lock1对应的就绪队列就可以叫做lock1 - ready queue。每个队列里面都可能有多个暂停运行的线程。<br />注意，竞争同步锁失败的线程进入的是该同步锁的就绪（Ready）队列，而不是后面要讲述的待召队列（Waiting Queue，也可以翻译为等待队列）。就绪队列里面的线程总是时刻准备着竞争同步锁，时刻准备着运行。而待召队列里面的线程则只能一直等待，直到等到某个信号的通知之后，才能够转移到就绪队列中，准备运行。<br />成功获取同步锁的线程，执行完同步代码段之后，会释放同步锁。该同步锁的就绪队列中的其他线程就继续下一轮同步锁的竞争。成功者就可以继续运行，失败者还是要乖乖地待在就绪队列中。<br />因此，线程同步是非常耗费资源的一种操作。我们要尽量控制线程同步的代码段范围。同步的代码段范围越小越好。我们用一个名词“同步粒度”来表示同步代码段的范围。<br />同步粒度<br />在Java语言里面，我们可以直接把synchronized关键字直接加在函数的定义上。<br />比如。<br />… synchronized … f1() {<br />  // f1 代码段<br />}<br /><br />这段代码就等价于<br />… f1() {<br />  synchronized(this){ // 同步锁就是对象本身<br />    // f1 代码段<br />  }<br />}<br /><br />同样的原则适用于静态（static）函数<br />比如。<br />… static synchronized … f1() {<br />  // f1 代码段<br />}<br /><br />这段代码就等价于<br />…static … f1() {<br />  synchronized(Class.forName(…)){ // 同步锁是类定义本身<br />    // f1 代码段<br />  }<br />}<br /><br />但是，我们要尽量避免这种直接把synchronized加在函数定义上的偷懒做法。因为我们要控制同步粒度。同步的代码段越小越好。synchronized控制的范围越小越好。<br />我们不仅要在缩小同步代码段的长度上下功夫，我们同时还要注意细分同步锁。<br />比如，下面的代码<br /><br />public static final Object lock1 = new Object();<br /><br />… f1() {<br /><br />synchronized(lock1){ // lock1 是公用同步锁<br />  // 代码段 A<br />// 访问共享资源 resource1<br />// 需要同步<br />}<br />}<br /><br />… f2() {<br /><br />synchronized(lock1){ // lock1 是公用同步锁<br />  // 代码段 B<br />// 访问共享资源 resource1<br />// 需要同步<br />}<br />}<br /><br />… f3() {<br /><br />synchronized(lock1){ // lock1 是公用同步锁<br />  // 代码段 C<br />// 访问共享资源 resource2<br />// 需要同步<br />}<br />}<br /><br />… f4() {<br /><br />synchronized(lock1){ // lock1 是公用同步锁<br />  // 代码段 D<br />// 访问共享资源 resource2<br />// 需要同步<br />}<br />}<br /><br />上述的4段同步代码，使用同一个同步锁lock1。所有调用4段代码中任何一段代码的线程，都需要竞争同一个同步锁lock1。<br />我们仔细分析一下，发现这是没有必要的。<br />因为f1()的代码段A和f2()的代码段B访问的共享资源是resource1，f3()的代码段C和f4()的代码段D访问的共享资源是resource2，它们没有必要都竞争同一个同步锁lock1。我们可以增加一个同步锁lock2。f3()和f4()的代码可以修改为：<br />public static final Object lock2 = new Object();<br /><br />… f3() {<br /><br />synchronized(lock2){ // lock2 是公用同步锁<br />  // 代码段 C<br />// 访问共享资源 resource2<br />// 需要同步<br />}<br />}<br /><br />… f4() {<br /><br />synchronized(lock2){ // lock2 是公用同步锁<br />  // 代码段 D<br />// 访问共享资源 resource2<br />// 需要同步<br />}<br />}<br /><br />这样，f1()和f2()就会竞争lock1，而f3()和f4()就会竞争lock2。这样，分开来分别竞争两个锁，就可以大大较少同步锁竞争的概率，从而减少系统的开销。<br /><br />信号量<br /><br />同步锁模型只是最简单的同步模型。同一时刻，只有一个线程能够运行同步代码。<br />有的时候，我们希望处理更加复杂的同步模型，比如生产者/消费者模型、读写同步模型等。这种情况下，同步锁模型就不够用了。我们需要一个新的模型。这就是我们要讲述的信号量模型。<br />信号量模型的工作方式如下：线程在运行的过程中，可以主动停下来，等待某个信号量的通知；这时候，该线程就进入到该信号量的待召（Waiting）队列当中；等到通知之后，再继续运行。<br />很多语言里面，同步锁都由专门的对象表示，对象名通常叫Monitor。<br />同样，在很多语言中，信号量通常也有专门的对象名来表示，比如，Mutex，Semphore。<br />信号量模型要比同步锁模型复杂许多。一些系统中，信号量甚至可以跨进程进行同步。另外一些信号量甚至还有计数功能，能够控制同时运行的线程数。<br />我们没有必要考虑那么复杂的模型。所有那些复杂的模型，都是最基本的模型衍生出来的。只要掌握了最基本的信号量模型——“等待/通知”模型，复杂模型也就迎刃而解了。<br />我们还是以Java语言为例。Java语言里面的同步锁和信号量概念都非常模糊，没有专门的对象名词来表示同步锁和信号量，只有两个同步锁相关的关键字——volatile和synchronized。<br />这种模糊虽然导致概念不清，但同时也避免了Monitor、Mutex、Semphore等名词带来的种种误解。我们不必执着于名词之争，可以专注于理解实际的运行原理。<br />在Java语言里面，任何一个Object Reference都可以作为同步锁。同样的道理，任何一个Object Reference也可以作为信号量。<br />Object对象的wait()方法就是等待通知，Object对象的notify()方法就是发出通知。<br />具体调用方法为<br />（1）等待某个信号量的通知<br />public static final Object signal = new Object();<br /><br />… f1() {<br />synchronized(singal) { // 首先我们要获取这个信号量。这个信号量同时也是一个同步锁<br /><br />    // 只有成功获取了signal这个信号量兼同步锁之后，我们才可能进入这段代码<br />    signal.wait(); // 这里要放弃信号量。本线程要进入signal信号量的待召（Waiting）队列<br /><br />// 可怜。辛辛苦苦争取到手的信号量，就这么被放弃了<br /><br />    // 等到通知之后，从待召（Waiting）队列转到就绪（Ready）队列里面<br />// 转到了就绪队列中，离CPU核心近了一步，就有机会继续执行下面的代码了。<br />// 仍然需要把signal同步锁竞争到手，才能够真正继续执行下面的代码。命苦啊。<br />    …<br />}<br />}<br /><br />需要注意的是，上述代码中的signal.wait()的意思。signal.wait()很容易导致误解。signal.wait()的意思并不是说，signal开始wait，而是说，运行这段代码的当前线程开始wait这个signal对象，即进入signal对象的待召（Waiting）队列。<br /><br />（2）发出某个信号量的通知<br />… f2() {<br />synchronized(singal) { // 首先，我们同样要获取这个信号量。同时也是一个同步锁。<br /><br />    // 只有成功获取了signal这个信号量兼同步锁之后，我们才可能进入这段代码<br />signal.notify(); // 这里，我们通知signal的待召队列中的某个线程。<br /><br />// 如果某个线程等到了这个通知，那个线程就会转到就绪队列中<br />// 但是本线程仍然继续拥有signal这个同步锁，本线程仍然继续执行<br />// 嘿嘿，虽然本线程好心通知其他线程，<br />// 但是，本线程可没有那么高风亮节，放弃到手的同步锁<br />// 本线程继续执行下面的代码<br />    …<br />}<br />}<br /><br />需要注意的是，signal.notify()的意思。signal.notify()并不是通知signal这个对象本身。而是通知正在等待signal信号量的其他线程。<br /><br />以上就是Object的wait()和notify()的基本用法。<br />实际上，wait()还可以定义等待时间，当线程在某信号量的待召队列中，等到足够长的时间，就会等无可等，无需再等，自己就从待召队列转移到就绪队列中了。<br />另外，还有一个notifyAll()方法，表示通知待召队列里面的所有线程。<br />这些细节问题，并不对大局产生影响。<br /><br />绿色线程<br /><br />绿色线程（Green Thread）是一个相对于操作系统线程（Native Thread）的概念。<br />操作系统线程（Native Thread）的意思就是，程序里面的线程会真正映射到操作系统的线程，线程的运行和调度都是由操作系统控制的<br />绿色线程（Green Thread）的意思是，程序里面的线程不会真正映射到操作系统的线程，而是由语言运行平台自身来调度。<br />当前版本的Python语言的线程就可以映射到操作系统线程。当前版本的Ruby语言的线程就属于绿色线程，无法映射到操作系统的线程，因此Ruby语言的线程的运行速度比较慢。<br />难道说，绿色线程要比操作系统线程要慢吗？当然不是这样。事实上，情况可能正好相反。Ruby是一个特殊的例子。线程调度器并不是很成熟。<br />目前，线程的流行实现模型就是绿色线程。比如，stackless Python，就引入了更加轻量的绿色线程概念。在线程并发编程方面，无论是运行速度还是并发负载上，都优于Python。<br />另一个更著名的例子就是ErLang（爱立信公司开发的一种开源语言）。<br />ErLang的绿色线程概念非常彻底。ErLang的线程不叫Thread，而是叫做Process。这很容易和进程混淆起来。这里要注意区分一下。<br />ErLang Process之间根本就不需要同步。因为ErLang语言的所有变量都是final的，不允许变量的值发生任何变化。因此根本就不需要同步。<br />final变量的另一个好处就是，对象之间不可能出现交叉引用，不可能构成一种环状的关联，对象之间的关联都是单向的，树状的。因此，内存垃圾回收的算法效率也非常高。这就让ErLang能够达到Soft Real Time（软实时）的效果。这对于一门支持内存垃圾回收的语言来说，可不是一件容易的事情。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/164905#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Mon, 25 Feb 2008 22:32:04 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/164905</link>
        <guid>http://buaawhl.javaeye.com/blog/164905</guid>
      </item>
      <item>
        <title>&lt;诛仙&gt; 读后感</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/164898" style="color:red;">http://buaawhl.javaeye.com/blog/164898</a>&nbsp;
          发表时间: 2008年02月25日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          我喜欢看别人打游戏，尤其是游戏高手。<br />看着别人在游戏中如鱼得水，游刃有余，画面精彩绚丽，剧情也算有趣，我也尝试过投入其中，但是没走几步，就陷入到一个迷宫似的场景中，怎么也走不出来。<br />这才发现，不仅打斗游戏、战略游戏最操作技能要求高，RPG游戏的水也同样深。于是我放弃了自己操作主角建功立业的想法。<br />我对游戏的世界观（世界组成）、背景设定、故事剧情更加感兴趣。帝国时代，文明。里面的设定都很有意思。<br />虽然游戏本身具有更强的参与和互动，但是功能和效果却有限。而文字则没有这个限制，唯一的限制就是想象力，人有多大胆，字有多大产。我更喜欢阅读一些描述这一类世界的小说。描述的场景和情节可能更华丽，更出彩。<br /><br />&lt;诛仙>以前有人推荐过。看了个头，没有看下去。后来翻看一些网络游戏资料的时候，发现&lt;诛仙>已经改编成了网游。于是我就阅读了&lt;诛仙>。<br /><br />&lt;诛仙>的文笔很好。看起来舒服，不会让人感到某种烦躁的阅读障碍。里面的情感描写也不错。人物动物刻画也是栩栩如生。主角的师傅，师母，还有猴子，都是描写得非常成功的。至于男女主角的描写，怎么说呢。没啥好说的。后面再说吧。<br />里面有几个情节非常出彩，给我的印象很深。一个是青云观的描写，麒麟，仙山，气势宏大，令人心潮澎湃。一个是苗家的一场戏。外族进攻苗族，天狗报警那一段，悲壮，震撼，久久令人回味。还有一个情节是，主角最后发现，是救他们的和尚杀了全村人。也还是个不错的设计。虽然说，和尚的动机非常勉强。<br /><br />下面说说&lt;诛仙>的缺点。<br />最大的缺点就是，情节单调。极其单调。<br />为了表达男女之情，剧本里面反反复复出现这样的场景。男替女挡一剑，女替男挡一刀，男替女挡一斧，女替男挡一锤....<br />看得我差点得了焦虑症 -- 求求你，不要再来这个桥段了。但是用不了多久，不顾我的祈祷，这个桥段就会又一次出现。<br />刻画得比较别扭的人物，是那个非常具有现代特色的小师兄 -- 懒懒散散，喜欢看美女。这个人物出现在此类背景中，总有些不伦不类的感觉。<br />另外一个感觉是，情节驱动上，有些勉强。一些人物行为的动机不足，或者说，动机比较勉强，不足以驱动人物那么干。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/164898#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Mon, 25 Feb 2008 21:59:49 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/164898</link>
        <guid>http://buaawhl.javaeye.com/blog/164898</guid>
      </item>
      <item>
        <title>ErLang Map 函数的尾递归形式 / Final List</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/164639" style="color:red;">http://buaawhl.javaeye.com/blog/164639</a>&nbsp;
          发表时间: 2008年02月24日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          ErLang Map 函数的尾递归形式<br /><br />循环语句需要计数器变量控制循环次数，而计数器变量需要多次改变数值。ErLang语言不支持可以重复赋值的变量，因而也不支持循环语句。<br />ErLang程序员只能用递归表示循环。有些服务程序需要运行在在一个无穷循环中。<br />while true<br />	listen and respond to user request ….<br /><br />这种情况下，ErLang程序也要写成无穷递归的形式。在ErLang中，无穷递归必须写成尾递归（Tail Recursion）的形式。因为ErLang是栈语言，如果是非尾递归的递归形式，无穷递归必然引起运行栈的无限膨胀。<br /><br />下面我们来看一个非尾递归形式转化为尾递归的例子。<br />ErLang不支持循环语句，而是采用Map、Reduce等便利函数把递归形式简化为类似循环的形式。<br />map函数的定义为，用一个函数处理一个List中的每一个元素，并且产生每一个结果元素，这些结果元素构成一个新的List，作为返回值。<br />map函数的调用形式为：<br /><br />map( <br />%% 定义一个匿名函数，作为函数体。函数参数就是List中的每一个元素<br />fun(Item) -> <br />do something with Item<br />return a Result Item of processing the Item<br />end,<br /><br />List  %% 第二个参数List。表示要处理的源List。<br />)<br /><br />map函数的具体例子就不多说了。这是比较常见的函数调用。<br />我们来看map函数的实现。<br /><br />map(Visit, [] ) -> [] ;<br />map(Visit, [H | T]) -> [Vsit(H) | map(Visit, T)].<br /><br />我们看到，上述实现方法里面的递归调用，不是尾递归。<br />因此运行的过程中，运行栈不断地增长，长到头之后，运行栈再递减。<br />下面我们把map函数改写成尾递归形式。<br />由于ErLang的变量都是final的，不能重复赋值。因此我们只能够给List添加一个头，而不能添加尾。所以，我们要在最后把处理结果倒置一下。<br /><br />map(Visit, L) -> <br />R = process( Visit, L, [] ),<br />lists:reverse( R ).<br /><br />process( Visit, [], R ) -> R;<br />process( Visit, [H | T], R) -> <br />	RH = Visit( H ),<br />process(Visit, T, [RH | R]).<br /><br />我们看到，实际上，我们相当于用一个存放结果的R List代替了运行栈。每一次处理元素的结果都会放入到R这个List当中。<br />上述代码是尾递归形式，在运行过程，运行栈保持不变。当然，R这个结果List却在不断地增长。相当于自己用一个List代替了运行栈。只不过自己维护的这个List是在堆里面分配的，不受到运行栈大小的限制，只受到内存的限制。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/164639#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Sun, 24 Feb 2008 22:06:05 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/164639</link>
        <guid>http://buaawhl.javaeye.com/blog/164639</guid>
      </item>
      <item>
        <title>Yield in Python/Ruby - Iterator/Visitor</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/164636" style="color:red;">http://buaawhl.javaeye.com/blog/164636</a>&nbsp;
          发表时间: 2008年02月24日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          Yield in Python/Ruby - Iterator/Visitor<br /><br />首先，我们从Ruby的Iterator开始。Ruby程序员可以用yield关键字定义Iterator。例如，下面的abc()就是一个Iterator。<br /><br />def abc()<br />	yield “a”<br />	yield “b”<br />	yield “c”<br />end<br /><br />abc Iterator的调用方法如下：<br /><br /># block形式<br />abc do | ch |<br />	print ch<br />end<br /><br />或者<br /># closure形式<br />abc { | ch | print ch }<br /><br />从这个调用方式，我们可以看出，实际上，Ruby Iterator并不是真正的Iterator，而是一个Visitor。Yield其实只是一个占位符。上述Ruby Iterator代码的真实含义如下：<br /><br />def abc( visitor )<br />	visitor.visit( “a” )<br />	visitor.visit( “b” )<br />	visitor.visit( “c” )<br />end<br /><br />调用方法为<br /><br />class Printer<br />	def visit( ch )<br />		print ch<br />	end<br />end<br /><br />abc( Printer.new )<br /><br />我们看到，Ruby “Yield” Iterator只是一种虚拟Iterator，虽然貌似Iterator，其实却是Visitor。我们无法中途中断abc()的执行。只能从头到尾打印出abc。<br />Python “Yield” Iterator是真正的Iterator，例如：<br /><br />def abc() :<br />	yield “a”<br />	yield “b”<br />	yield “c”<br /><br />调用方法为<br /><br />for ch in abc()<br />	if ch == “b”<br />		break<br />	print ch<br /><br />我们看到，abc()确实返回了一个Iterator，而且我们可以中途中断程序，只打印出ab。<br />Python Iterator是采用coroutine实现的。<br />Coroutine表示几个协同工作的程序。比如，消费者/生产者，你走几步，我走几步；下棋对弈，你一步我一步。人们就很容易想到用Coroutine来实现Iterator。<br />这里面Iterator就是Coroutine里面的生产者Producer角色，数据提供者。所以，也叫做Generator。<br />每次Iterator程序就是等在那里，一旦用户（消费者Consumer角色）调用了iterator.next, Iterator就继续向下执行一步，然后把当前遇到的内部数据的Node放到一个消费者用户能够看到的公用的缓冲区（比如，直接放到消费者线程栈里面的局部变量）里面，然后自己就停下来（wait）。然后消费者用户就从缓冲区里面获得了那个Node。<br />这样Iterator就可以自顾自地进行递归运算，不需要自己管理一个栈，而是迫使计算机帮助它分配和管理运行栈。<br /><br />Python “Yield” Iterator可以实现无限数据的Iterator。<br />def infinite()<br />	n = 1<br />	while true<br />		yield n<br />		n = n + 1<br /><br />调用方法<br />for i in infinit()<br />	if i > 100<br />		break<br /><br />	print i
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/164636#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Sun, 24 Feb 2008 21:53:15 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/164636</link>
        <guid>http://buaawhl.javaeye.com/blog/164636</guid>
      </item>
      <item>
        <title>ErLang / Python Web 的类似CGI/FastCGI模式</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/164580" style="color:red;">http://buaawhl.javaeye.com/blog/164580</a>&nbsp;
          发表时间: 2008年02月24日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          ErLang Web<br /><br />ErLang语言从一开始，就是针对并发设计的。ErLang作为一个平台，在稳定性和实时性方面也有不俗的表现。不少人希望把ErLang应用在Web领域。<br />ErLang Inets里面包括HTTP Server、FTP Server等。ErLang的Web开发框架叫做YAWS（Yet Another Web Server）。如果说Inets相当于Apache HTTP Server的地位，那么YAWS就相当于Servlet Server的地位。<br />一些优秀的程序员为ErLang开发了ORM持久层、Template层等。但是，由于ErLang的几项缺点，使得ErLang在Web开发领域举步维艰。这些缺点包括：<br />（1）字符串处理能力弱。I/O（输入输出）能力也不强。<br />对于大量处理HTML的Web应用程序来说，这是一个致命缺陷。<br />（2）变量值只能赋值一次。不能修改。<br />这意味着，除了I/O（输入输出）之外，ErLang应用程序是无状态的，无副作用的。也意味着，我们难以在ErLang程序中用基本数据结构存放可以改变的状态。对于普通程序员来说，这种限制会带来编程的难度。这并不是不可逾越的障碍，只是需要思路上的转换。<br />（3）ErLang不支持循环，只能用递归表示循环。<br />对于普通程序员来说，这也是一个不小的挑战。程序员需要习惯Map、Reduce等函数，简化需要循环的编程。程序员还需要习惯于把大量的数据作为参数在各个层次之间函数调用传来传去，因为ErLang不支持成员变量。这一点有点类似于浏览器和服务器之间把状态信息传来传去，以保证服务器的无状态性（Stateless）。<br /><br />（2）（3）两个问题并不是不可逾越的鸿沟，只是一种编程模型上的转换。但是第一个问题是无法回避的问题。<br />人们想到了一种方法，把字符串处理工作交给其他语言（比如Python、Ruby、Perl等）来做。这种思路需要考虑的问题是，ErLang如何同其他语言进行交互通信？<br /><br />如果ErLang中存在Python、Ruby等语言的解释器，那就好了。这个思路有些强人所难了。ErLang最不擅长的就是处理字符串，更别说解释一门语言了。<br />如果Python、Ruby等语言可以直接编译为ErLang虚拟机指令，那也是个不错的选择。目前还没有这方面的项目出现。从实现难度上考虑，Python、Ruby里面的语法元素映射不容易为ErLang虚拟机指令，比如，类、对象、循环、变量多次赋值、环状数据结构等。<br />ErLang本身提供了Jinterface和erl_interface两种语言接口。Jinterface用来和Java程序通信，erl_interface用来和C语言程序通信。<br />Java可以通过JNI（Java Native Interface）调用C语言程序。C语言程序和Java程序运行在同一个进程中。<br />Jinterface和erl_interface的例子表明，ErLang和其他语言的交互模式和JNI不同。ErLang和其他语言程序各自运行在不同的ErLang Node当中。两个Node只能进行通信，而不能进行函数调用，顶多只能通过通信渠道进行远程函数调用（RPC）。<br />既然都是远程通信，Jinterface和erl_interface也没有什么特殊的。Python、Ruby等语言一样可以和ErLang进行通信。常见的通信手段比如Socket。<br />在一个ErLang Web应用程序中，ErLang和Python之间的通信过程可能如下：<br />ErLang Web应用程序收到HTTP Request，根据URL把处理过程转到一个handle函数中。<br />handle(Request … ) -><br />	Model = getModel(…), %% 根据参数获取数据<br /><br />	View = getView(… ), %%这里的View通常是一个Template文件名<br /><br />HTML = send( [Context, View] ) %% 经过通信渠道，发到Python语言程序中<br />%% HTML是一个Binary。ErLang输出HTML到浏览器<br />.<br /><br />Python语言从通信渠道收到数据流，解析出来Context和View，然后根据View读取一个Template文件，并且把Context和Template结合起来，产生HTML，发还给ErLang程序。<br />我们看到，这里面涉及到一次大数据量通信——Python把HTML发送到ErLang。这种时间空间效率是否能够忍受呢？我们能否做出改进呢？<br />ErLang和Python之间的这种通信过程，和CGI/FastCGI的工作方式很类似。都是跨进程传输HTML。我们来看CGI/FastCGI的模型。<br /><br />CGI输出重定向<br /><br />CGI的全称是Common Gateway Interface。CGI程序一般安装在一个支持CGI的HTTP Server中，比如Apache HTTP Server。<br />CGI程序和HTTP Server之间的流程和上述的ErLang/Python通信过程类似：<br />HTTP Server收到HTTP Request之后，根据URL把处理转到对应的CGI程序中。<br />CGI程序通过环境变量或者参数等渠道，获取HTTP Request等信息，查询数据库获取数据，然后产生HTML，输出到标准输出（STDOUT）。实际上是利用输入输出重定向（I/O Redirect）把HTML传回给HTTP Server。<br />如果操作系统不支持输入输出重定向，那么HTTP Server自己就需要分配一个缓冲区，存放CGI程序输出的HTML，然后，HTTP Server把缓冲区里面的HTML输出到浏览器。这个过程和上述的ErLang/Python通信情况差不多。<br />如果操作系统支持标准输入输出重定向，而且可以重新定向到Socket，那么CGI程序也许可以把HTML直接通过Socket写入浏览器端，而不需要把HTML发回到HTTP。不过，CGI程序一般都是把HTML重定向输出回服务器。<br /><br />字符串处理进程直接把结果写入浏览器Socket<br /><br />ErLang/Python通信和CGI/FastCGI模式的输出模式比较相似。<br />浏览器和Web Server建立Socket连接，Web Server把字符串处理工作交给另外一个进程的字符串处理程序，字符串处理程序把字符串处理结果传回到Web Server，最后由Web Server把HTML通过Socket传回给浏览器。<br />那么，字符串处理程序能否直接把HTML通过Socket发到浏览器呢？<br />这好像很难。虽然Socket句柄只是一个整数，但是进程间似乎不能共享Socket（和文件句柄）同级别的资源。<br /><br />我们知道，ErLang程序最终是通过Socket把HTML传给浏览器的。Sokect句柄是一个整数，我们能否把Socket句柄直接传给Python程序，然后让Python程序直接把HTML写到Socket里面，就相当于直接传输到浏览器里面。<br />在同一个进程中，多个线程可以共享进程的资源，包括Socket句柄，文件句柄等等。两个进程之间，就不能共享Socket句柄了。<br /><br />上述是我的思考。涉及到很多我不了解的领域。请大家指正。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/164580#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Sun, 24 Feb 2008 16:28:25 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/164580</link>
        <guid>http://buaawhl.javaeye.com/blog/164580</guid>
      </item>
      <item>
        <title>有在Stackless Python (or PyPy)上实现的开源Web Server吗？</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/164577" style="color:red;">http://buaawhl.javaeye.com/blog/164577</a>&nbsp;
          发表时间: 2008年02月24日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          也许 HTTP Server 的实现并不是很难。<br />很多语言的开发库都自带有内置的 HTTP Server。<br />Ruby开发框架 Cerise 也自带有一个Ruby开发的 Web Server。<br /><br />Python语言很早就有了虚拟机。<br />很多Python Web开发框架都带有一个内置的 Web Server。<br />这些 Web Server 都是基于 Python 语言开发的。<br />我没有发现一个基于 Stackless Python 开发的 Web Server。<br /><br />据说 Stackless Python 的并发性更好。理论上应该有不少基于 Stackless Python 的 Web Server。<br />也有这样一种可能，Python程序语言可以直接在 Stackless Python平台上直接编译运行。<br />Python 开发的 Web Server程序可能直接在 Stackless Python 上直接运行。<br />查看了 Stackless Python 的文档，Stackless Python 不仅实现上取消了运行栈，而且引入了新的线程协同关键字。整个线程模型都换了。API，关键字，使用方法都换了。<br /><br />还看到这样一种说法。PyPy 是 Stackless Python 的继承者。PyPy 好像是一种把 Python等动态语言翻译为 C 语言/底层语言的项目。<br />我对 Stackless Python, PyPy 了解有限。从网上信息分析不出个所以然。<br />想听听大家的意见。
          <br/>
          <span style="color:red;">
            <a href="http://buaawhl.javaeye.com/blog/164577#comments" style="color:red;">本文的讨论也很精彩，浏览讨论>></a>
          </span>
          <br/><br/><br/>
          <span style="color:#E28822;">JavaEye推荐</span>
          <br/>
          <ul class='adverts'><li><a href='/adverts/41' target='_blank'><span style="color:red;font-weight:bold;">北京: 千橡集团暨校内网诚聘软件研发工程师</span></a></li><li><a href='/adverts/42' target='_blank'><span style="color:red;font-weight:bold;">搜狐网站诚聘Java、PHP和C++工程师</span></a></li></ul>
          <br/><br/><br/>
          ]]>
        </description>
        <pubDate>Sun, 24 Feb 2008 15:58:08 +0800</pubDate>
        <link>http://buaawhl.javaeye.com/blog/164577</link>
        <guid>http://buaawhl.javaeye.com/blog/164577</guid>
      </item>
      <item>
        <title>网络游戏，拯救地球</title>
        <author>buaawhl</author>
        <description>
          <![CDATA[
          <br/>
          作者: <a href="http://buaawhl.javaeye.com">buaawhl</a>&nbsp;
          链接：<a href="http://buaawhl.javaeye.com/blog/164489" style="color:red;">http://buaawhl.javaeye.com/blog/164489</a>&nbsp;
          发表时间: 2008年02月23日
          <br/><br/>
          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          <br/><br/>
          网络游戏<br /><br />最受人们欢迎的软件，不是应用软件，而是娱乐软件。娱乐软件以多媒体软件和游戏软件为代表。影音娱乐软件带给人们的享受只是被动的接受，而游戏软件，尤其是网络游戏，则满足了人们的参与、互动的需求，这也是为什么越来越多的人沉迷于网络游戏的原因。<br />说起网络游戏的负面社会效应，那是罪行累累、罄竹难书：玩物丧志、不务正业、荒废学业、损害身体、分不清虚拟和现实的区别而引起暴力犯罪.....<br />不过从长远来看，从非常长远的未来看，网络游戏也有一定的社会积极效应。<br />到了共产主义社会，物质极大丰富，人们不再有为生存而赚钱的压力，也就自然不存在玩物丧志、不务正业的问题了。<br />那时候，人们闲得无聊，为了满足不断膨胀的各种野心和欲望，很可能做一些毁灭世界和拯救世界的游戏，正如好莱坞电影的主题。<br />有了网络游戏，就好办了。人们可以在虚拟世界中体验到现实生活中体会不到的生活，而不会破坏人类赖以生存的现实世界。<br />不说那么远的事情，就说现在，虚拟游戏也将对拯救地球资源具有重大的意义。可以说，拯救地球保护环境的重任，就交给网络游戏了。<br />为了满足自己的虚荣心（或者荣誉感），为了显示自己的物质财富，为了获得尊重和崇拜，人们进行大量的超过基本需求的物质消费和消耗，以奢侈浪费为荣，以贫穷节俭为耻。占人口比例20%的富有人口，消耗了80%的物质。<br />假如地球上所有人都富起来，都进行这样毫无节制的消费。那还得了？<br />聪明的人类自然能够想出解决方法。奢侈品消费、品牌消费就是一条解决之道。<br />富有人群进行物质消费的很大目的，是为了满足虚荣心，是为了显示自己的身份。别人只能买起一双鞋，我可以买起一千双鞋。但是，我不可能随身携带一千双鞋来展示自己的财富。最好的解决方法是，我的鞋上贴着一个价格标签，标签上写的价钱是普通鞋子的一千倍。这样我就用物品的质量代替了数量，同样可以展示自己的财富。<br />直接用价格标签显示物质财富，这种做法太俗了，太直白了。西方人和东方人一样讲究委婉曲折。奢侈品消费和品牌消费应运而生。人们可以通过购买名牌，来体现自己的财富。所谓名牌，就是一种隐性的价格标签。<br />隐性的价格标签，又引起了一个新的问题。我买了名牌，很多无知的人们却不认识，可能以为我买的是地摊货。那我不是白买了？锦衣昼行，天下人却不识货。这可怎么办呢？别着急，人们又引入了品味的概念。名牌就是品味，不懂名牌，就是没有品位。为了有品位，必须要知道名牌。经过这样漫长的一番贫下中农再教育，很多人都认识了名牌。这样，价格标签的问题，完美解决。<br />从拯救地球资源的角度来说，奢侈品功莫大焉。富人可以购买一辆宝马来展示自己的财富，而不需要买一百辆夏利来展示自己的财富。这大大减少了地球的物质浪费。<br />但是，仅有奢侈品经济，还是不足以拯救地球。想想看，如果所有人都富了起来，人人都买得起奢侈品，那奢侈品不就变成大白菜一样不值钱了？到时候，没有了质的差别，人们还是需要通过量的差别来体现自己的财富。你买10辆宝马，我就需要买100辆宝马超过你。同样会进入物质消耗的恶性竞争。<br />根本解决之道，还是网络游戏。网络游戏里面有虚拟装备、虚拟