为并发而生的 Erlang 已经存活了很多年，只是一直不温不火，阳春白雪。而Java平台上的Scala，在这两年迅速进入软件工业界的视野。尽管其Actor模型借鉴自Eralng，运行在JVM之上，不像Erlang那样纯粹、简单， 但得力于Java平台庞大的现有代码、庞大的程序员阵营和各企业组织的大规模现有投资，很多人都认为Scala会更加成功。即使热爱 Erlang 的 Yariv Sadan — 他在 Facebook 用 Erlang 开发 Facebook Chat ，也在其争论 Erlang 与 Scala 的博文 《Erlang vs. Scala》 的结尾写道：“ Regardless of these differences, though, I think that Scala has a good chance of being the more popular language of the two.” 这篇文章很精彩，后面的评论也很精彩，值得一读。 有趣的是，作者说有些人认为 Erlang来自外国 (作者应该是美国人，而Erlang来自瑞典) 是其未能成为主流语言的一个原因。(A few times, I’ve seen the following take on the relative mertis of Scala and Erlang: Erlang is great for concurrent programming and it has a great track record in its niche, but it’s unlikely to become mainstream because it’s foreign and it doesn’t have as many libraries as Java.)

去年跟风了解了 Golang，写过几个小程序。Golang的方式略有有些易于C/Java，但总的来说，还是非常像的，上手不难。尤其是喜欢C的人，要选择一门多核时代的语言去学习，Golang 是最合适的了。不过，我还没有弄透Golang对并发的支持为什么优于传统语言，是的，它的并发基于消息传递的，但到底是怎么实现的？又为何如此实现呢？

Erlang 给我的感受则完全不同，变量竟然是immutable的，= 竟然不是赋值符号，字符串是整形值，一个类型也没有 ， 刘姥姥进了大观园，完全是一个惊奇的世界。不过除了惊讶，我便很快喜欢它immutable的变量，也对久仰大名的 List Comprehension 感到异常惊喜。List Comprehension 跟 Map/Reduce的区别还是很明显的。 Erlang 真的是太惊艳了,学习它是必须的。毋庸置疑，它肯定会促使我改变思考事情的方式。

对于Scala，扫描了下它的文档。不过我更关心的是 Actor 和 CSP 。Scala 与 Erlang 的并发都源自 Actor模型，有Erlang就可以了解了。对于一个常跟Java打交道的程序员，Scala需要用了将来再现学就行。

我想要理解的是Erlang/Go与Java/C不同的并发模型，它们的内存模型有哪些异同。也许你会说减少了上下文切换，减少了CPU Cache丢失，减少系统内存开销，减少抢断带来的损失等等，但我想探寻的是它们具体是怎么做的呢？ 多核的变革已经来临，或许改进应该从计算机体系的顺序模型开始，硬件结构与软件模型一起改进（看看 Comuunications Of ACM 的 《Memory Models: A Case for Rethinking Parallel Languages and Hardware》)。 何况除了并发，Erlang 还有更多值得发掘的东西。

下面这是相关的几篇值得一读的好文：

• Memory Models: A Case for Rethinking Parallel Languages and Hardware
• Revisiting Coroutines
• Multi-Core and Massively Parallel Processors

———————————–
参考：

• The multicore crises: Scala vs. Erlang

Related posts:

1. Impdp/Expdp 之并行(Parallel)和压缩(Compression)
2. Arguments on Java & C++
3. Flex中的对象比较（相等性）

Someone has reported a possible memory leak related with Proxool connection pool. And we addressed the bug recently in our applications, which are Java backend applications that work with Oracle 11g through Oracle JDBC5 on IBM JDK 5 platform.

The finalize() method of the proxied OracleConnection instances are the root cause. OracleConnection classes have no explict finalize() method, but each proxied object has one generated by cglib. When such a proxied connection instance is being finalized, the stack should be as the figure shows. You can see Connection#isClosed() method is invoked, which is SYNCHRONIZED (the monitor is the connection object itself). Then the finalizer thread and the worker thread using the physical connection could block each other. Finally, the proxied connection objects in finalizing queue and all referenced objects couldn’t be garbage-collected. Sometimes Connections aren’t so busy – you are lucky – the heap could suspend or even decrease; but OOM is waiting for you at the end usually.

I gave a fix that avoid invoking Connection#isClosed() while finalizing. Actually, I changed the line 114 of WrappedConnection from

if (proxyConnection != null && proxyConnection.isReallyClosed()) {

to

if (proxyConnection != null && !concreteMethod.getName().equals(FINALIZE_METHOD) && proxyConnection.isReallyClosed()) {

The fix is proved to be effective in our serveral systems in production .

You can download the patch in the bug page in proxool bugtrack site.

Or you can download a compiled version of proxool-0.9.1.jar(WITHOUT WARRANT). (It’s comipled from proxool-0.9.1-source.zip)

Any questions please let me know by giving a comment.

Related posts:

1. Proxool导致的内存泄漏
2. JDBC和Ibatis中的Date,Time,Timestamp处理
3. 文件锁与进程互斥

0.9.1版本是proxool 的最新版本。我们有一个应用据称运行以来，就一直处于内存溢出的阴霾之中。追赶数据时的某些巨忙的系统可能会一天内死好些次，甚至达十几次。不得不采用一些监控脚本定时重启。去年12月我接手以来，也被这个问题困扰，最糟糕的时候甚至某些硬件设施很好的部署实例的多达50+GB的堆也能在一天之内吃光。

出错的原因很简单，proxool使用了cglib，它用WrappedConnection代理实际的Conneciton。在运行WrappedConnection的方法时，包括其finalize方法，都会调用Conneciton.isClosed()方法去判断是否真的需要执行某些操作。不幸的是Oracle JDBC中的这个方法是同步的，锁是连接对象本身。于是， Finalizer线程回收刚执行过的WrappedConnection对象时就总会与还在使用Connection的各个工作线程争用锁。

贴一张简单的图，你就懂了：

解决方案是在WrappedConnection.java的第114行，做一点小小的改动，在调用的方法为finalize方法时，不要去掉isClosed()方法。事实上，WrappedConnection#finalize()方法的调用与Connection根本没啥关系。Oracle JDBC本身没有实现finalize()方法，是cglib代理的对象自己生成了一个finalize()方法而已。
修改前的114行：

if (proxyConnection != null && proxyConnection.isReallyClosed()) {

修改后的114行：

if (proxyConnection != null && !concreteMethod.getName().equals(FINALIZE_METHOD) && proxyConnection.isReallyClosed()) {

点此查看sourceforge上的完整的WrappedConnection.java。

效果是很明显的。一方面，内存消耗明显降低。之前，所有的部署实例都会隔段时间就当掉，某些部署实例的52G的堆都会溢出！现在，系统再忙其堆大小也基本上在原来那个设得老大的Xms参数之下。 第二方面，吞吐量忽然提高了许多，没有烦人的回收线程（其优先级要高点）的干扰，当然应该要跑得更快些。

感兴趣的朋友可以下载我这里提供的jar包(-target 1.5)，(源码是直接从官网下的proxool-0.9.1-source.zip）。这个jar包也解决了ProxoolDataSource在Spring中作为bean配置时有三个属性(maximumConnectionLifetime,houseKeepingSleepTime,overloadWithoutRefusalLifetime)不能注入的问题。详细请看这篇博文。

下载 proxool-0.9.1

也可以应用patch自己编译一个。patch我上传到Bug页面了，请去那下载。

Related posts:

1. Memory leak caused by Proxool and the fix
2. J2EE/Oracle性能调优实录
3. 文件锁与进程互斥

房东的四层书架

自己又买了一个

放不下了，在电视柜旁堆了两摞

用《Communications of ACM》挡住了一些杂七杂八的东西。

No related posts.

什么时候Java序列化会发生冲突

Java的序列化，实际上序列化的是对象的内容，也即只包括域（含父类的域）。因此类中方法的变化不会对序列化造成影响，只有类的体系和属性会对序列化造成影响。主要的导致版本冲突的变化包括：

• 删除域
• 改变类继承体系，讲一个实例域修改为静态或将非瞬时（transient）域修改为瞬时域
• 修改域类型
• 修writeObject/readObject导致不兼容的修改
• 以及其他更多….

详细请参见官方文档。

我们的程序修改了一个属性的类型，导致新版本程序不能反序列化之前的数据。

使用Reflection解决版本冲突

最早我尝试使用动态类加载和反射(Reflection)，将旧版本的classes加入到类路径中，使用旧版本的classes将数据反序列化，再通过Reflection将值设置到新版本class的实例上，再将新版本的实例反序列化回Memcached中。伪代码如下：

//Add old classes to classpath and 
import ***.stat.***.service.impl.AAAContext;
 //return: new Instance of AAAContext;
 //param: serialized data of old instance AAAContext
 private byte[] getNewInstance(byte[] serializedData) throws Exception {
 
   //get the old instance by deserializing data 
   AAAContext oldObje = deserialize(serializedData);
 
   //load new classes from external jar files
   URLClassLoader clazzLoader ;
   Class aaaContextClazz;
   URL jarfile = new URL("jar", "","file:E:\\workshop\\new-lib.jar!/");
   URL jarfile1 = new URL("jar", "","file:E:\\workshop\\dependencies.jar!/");
   clazzLoader = new URLClassLoader(new URL[]{ jarfile, jarfile1}, null);
   aaaContextClazz = clazzLoader.loadClass("***.stat.***.service.impl.AAAContext");
   Object oldins = aaaContextClazz.newInstance();
 
   //get setters on the new clazz, MUST find every setter method by hand coding
   Method m[] = aaaContextClazz.getDeclaredMethods();
 
   m[0].invoke(ins, oldObject.getProp1());
   m[1].invoke(ins, oldObject.getProp2());
   .... ....
 
   //return the serialized data of new instance
   return serializeObj(ins);
}

其中比较特殊的是 “clazzLoader = new URLClassLoader(new URL[]{ jarfile, jarfile1}, null);” 这一行代码，因为Java类加载体系的继承方式，必须指定new URLClassLoader()的第二个参数为null，去掉parent加载器。在不指定该参数时，会使用当前类加载器作为parent加载器，于是则会先从当前的类加载器体系中去寻找，只能得到类路径（classpath）下的同名类。

这种方法因为要序列化的字段太多，实现起来不易，且需要老版本的各依赖包，工程人员实施起来麻烦，故转而采取了下面的方法。

使用内置的序列化措施解决冲突

花了点时间研究Java的序列化机制后，发现有更好的方法支持序列化数据的版本变化。其中最简单的就是添加readObject/writeObject方法，自定义实现序列化，完成新旧版本间的转换。主要有下面三步要做。

第一步：自定义要更新的字段

Java序列化机制容许我们指定哪些字段要序列化（官方文档）。将类型变化了的属性的序列化类型指定为旧版本中的类型(Long.class，新类型为String.class)，以兼容老版本的序列化信息。定义如下：

  //定义的序列化版本ID必须与新/旧的class一致
  private static final long serialVersionUID = 3495267477129405823L;
  private static final
  ObjectStreamField[] serialPersistentFields = {
	new ObjectStreamField("id", Long.class),
	new ObjectStreamField("aaa_BeginTime", Date.class),
	new ObjectStreamField("flag", Integer.class),
              //略去几十个
 
              //将类型变化了的属性的序列化类型为旧版本中的类型
              new ObjectStreamField("sess_parameter", Long.class)
 };

第二步：定义readObject方法

定义readObject方法，读取老版本的数据，并做新旧类型转换:

private void readObject(ObjectInputStream ois)
    throws ClassNotFoundException, IOException {
  // Read version one types
  ObjectInputStream.GetField fields =  ois.readFields();
 
  this.id = (Long)fields.get("id", null);
  this.aaa_BeginTime = (Date)fields.get("aaa_BeginTime", null);
  this.flag = (Integer)fields.get("flag", null);
  //略去几十个
 
  //按旧版本读取，在转化为新版本的类型
  Long old_param = (Long)fields.get("sess_parameter", null);
 
  this.sess_parameter = String.valueOf(old_param);
}

第三步，定义writeObject方法

定义writeObject方法，以新版本class的序列化格式得到新的序列化数据：

private void writeObject(ObjectOutputStream oos)
    throws IOException {
   PutField fields = oos.putFields();
  fields.put("id", this.id);
	fields.put("aaa_BeginTime", this.aaa_BeginTime);
	fields.put("RoamFlag", this.RoamFlag);
 
  //按新版本方式写入
  fields.put("sess_parameter", this.sess_parameter);
  oos.writeFields();
}

以这种方式，只需要新增一个类就完成了转化工作。 这个类不是新版本程序中的类，实际上只是用于中间转化操作的临时代码，它以旧版本class的序列化方式读取数据，再按新版本class的序列化方式输出数据。

教训

使用默认的Java序列化机制，会使得具体的类成为数据的schema，持久化的数据受限于类的实现细节。这带来了多方面的约束。所以，如果你用Java的原生序列化，起码应该制定一个合适的Schema，并清楚类的实现细节变化可能导致数据需要特别的迁移处理。我建议选择一种别的与类的实现细节无关的序列化方案。

参考资料

1. Java Serialization Specification (1.5)
2. Type Changes Affecting Serialization
3. Java序列化算法透析: 国人写的一篇Java序列化算法的分析，解析很透彻
4. The Java serialization algorithm revealed : 一篇英文的有关序列化机制的分析文章，与前一篇参考很接近。
5. Implementing Serializable : 简明扼要的概述了序列化机制
6. Advanced Serialization
7. Discover the secrets of the Java Serialization API
8. Dynamic Class Loading and Reloading in Java
   

   Related posts:

   1. Java中的Volatile关键字
   2. 理解Java虚拟机的加法运算
   3. 文件锁与进程互斥
   ]]> http://blog.xiping.me/2011/03/java-serialize-and-reflection.html/feed 0 http://blog.xiping.me/2011/03/break-gfw-on-android.html http://blog.xiping.me/2011/03/break-gfw-on-android.html#comments Tue, 08 Mar 2011 04:00:36 +0000 西坪 http://blog.xiping.me/?p=1019
9. Linux Command & Shell Tips (1)

./adb shell sqlite3 /DATA/DATA/com.google.android.providers.settings/DATABASES/settings.db
 “\”INSERT INTO system VALUES(99,’http_proxy’,’ [host_or_IP]:[port]‘);\”"

if ($_SERVER['REQUEST_METHOD'] == 'GET') {
       //......
} else {
        $curlInterface = curl_init();
        $headers[] = 'Connection: Keep-Alive';
        $headers[] = 'content-type: application/xml';
        $headers[] = 'User-Agent: Java0';
        curl_setopt_array($curlInterface, array(
                CURLOPT_URL => 'http://server4.operamini.com',
                CURLOPT_HTTPHEADER => $headers,
                CURLOPT_POST => 1,
                CURLOPT_POSTFIELDS => @file_get_contents('php://input'))
    );
        $result = curl_exec($curlInterface);
        curl_close($curlInterface);
        header('Content-Type: application/octet-stream');
        header('Cache-Control: priavte, no-cache');
        echo $result;
}

这个系统的性能的直观指标，就是每天能处理多少数据量。这个指标很不理想，速度很慢，拖后与现场数据生成的速度。调优的标准，就是每日处理量。

第一次优化: 提高JDBC的fetchSize

首先，分析系统各个环节的时间消耗，弄清瓶颈在哪里。

在进行了一些综合分析后，得出主要时间耗费在数据库的查询上。而从v$session_wait中查询，发现有很多 SQL*Net message from client 事件的等待，时间很长，有数百秒之多。 显然是客户端慢了。但是因为应用端是有连接池的，是不是空闲连接导致的呢？ 有一些怀疑。

接下来，在数据库上用 sqlplus 执行了相同的SQL，测量其时间其实是很快的，远远小于应用消耗在数据获取的时间。联系其上面提到的等待事件，事情变逐渐明朗： 网络传输慢了。

于是检查了代码，发现大批量的数据查询竟然没有提升fetchSize属性。在调整该属性为500以后，很快收到了正面反馈。处理速度提升了将近一倍。

回去在检查Oracle中的等待事件，发现已经降到200名以外了（是与其他应用共用数据库的）。

有关 sqlnet message from client 事件的分析，可以参考 Asktom 上的文章。 AskTom上的另一篇文章，则描述了类似于连接池等待，或者是在sqlplus中打开会话不操作也会导致该事件。所以在见到这个事件时还是需要仔细甄别一下的。

结论： 适当调整 FetchSize是很有必要的。Oracle JDBC默认的fetchSize为10。FetchSize的提升，一方面是减少了客户端与服务器之间的来回交互次数；另一方面，也会有效减少数据库服务器逻辑读的数量（记得是《Troubleshooting Oracle Performance》中有讲到）。

修改完成后，除了观测到 sqlnet message from client 事件消失外，发现 sys cpu 也有小幅增加。

第二次优化：减小锁定(lock)范围

但是，接下来的观测，证明这个速度还是不合意，达不到要求。于是继续分析。

仍然是分析其主要的时间消耗在什么地方。这次发现时间主要是消耗在程序对数据的处理过程中。数据的处理大部分都是在Java进程中的运算，处理过程中还可能调用到Memcached。是不是网络速度比较慢呢？尝试测试了一下网速，千兆网络的吞吐率在应用并发时还能挤出三分之一左右用来做测试文件的传输，用ping发现其latency也不算高。

在此前的观测中，发现应用服务器上的 user cpu 比较好，在30%～70%之间，主要是被JVM进程消耗了，系统负载在5.0左右。觉得有些奇怪的，因为一般这样的应用瓶颈都出在IO上。于是做了一次代码复查，很快发现有一个在方法签名上的synchronize 关键字。这个类是一个服务bean， 在spring中管理的。这时问题变得清晰起来，所有的处理任务线程都要在这里排队。这样正好符合了此前观测到的cpu现象。

改掉这个关键字，缩小锁定范围，速度又上升了将近一倍。user cpu很快降下来，系统负载也下来了，稍稍大于1。

此时，速度虽能勉强应付，但还是不够快。此时更多的时间消耗在数据的写回上面。处理速度提升了，写回阶段的压力便也迅速提升，每单位数据的写回时间有20%左右的上浮。于是，需要第三次优化，在数据写回方面提升速度。

第三次优化

(Update Apr 6th):
没心思再仔细写过程了，简略如下：
1) Oracle是多个系统共享的，数据写入成为瓶颈。在内存问题解决后，在本地内存中缓存结果，最后再集中提交，减少更新次数。数度大增2.5倍左右。
2) 将从数据库中的查询和在内存中的处理划分为两个线程并发处理，速度提高50-70%。
3) 然后，Memcached集群成为瓶颈，内网延迟成为问题。但此时速度已经足够快了，因此暂时搁置下一步优化。如果要继续提速，则可能在本地建立一个Memcached实例，或者在程序中使用一个足够大的LRU缓存以减少与Memcached交互的次数。

至此，数据后台处理速度完全达到并超过预期。

Related posts:

1. 文件锁与进程互斥
2. JDBC和Ibatis中的Date,Time,Timestamp处理
3. Memory leak caused by Proxool and the fix

声明：本文翻译自Redis官方的MULTI/EXEC命令文档。翻译本文旨在传播更多信息，原著版权为Redis所有。转载请包含此声明。

WATCH key1 key2 ... keyN (Redis >= 2.1.0)
UNWATCH
MULTI
COMMAND_1 ...
COMMAND_2 ...
COMMAND_N ...
EXEC or DISCARD

MULTI, EXEC, DISCARD 和 WATCH 命令是Redis事务的基石。一个Redis事务允许一组Redis命令单步执行，并提供下面两个重要保证：

1. 一个事务中的所有命令串行执行。在事务的执行过程中不会为另一个客户端发起的请求提供服务。这保证了事务中的命令以原子操作的方式被执行。
2. 要么全部命令要么没有任何命令被处理。Exec命令触发事务中的所有命令的执行，所以如果一个在事务上下文中的客户端在调用MULTI（译注:貌似应该是EXEC，原文为MULTI）之前丢失了到服务器的链接，没有任何操作会被执行，而如果EXEC命令被调用了，所有的操作都会执行。一个例外是当AOF开启的时候：每个属于某个Redis事务的命令只要操作完成了的话就会记录在AOF中，所以如果Redis服务器崩溃或者被系统管理员以一种粗暴的方式杀死，可能只有部分操作被登记在AOF中。

从Redis 2.1.0开始，以类似于CAS（比较并设置）操作的乐观地锁定一组key的形式，在上面两种保证之外提供更进一步的保证也是可行的。这将在后文中详细阐述。

用法

通过MULTI命令进入一个事务。MULTI总是返回OK。然后用户可以发起多个命令。Redis将这些命令排队，而不是执行它们。一旦EXEC被调用，所有的命令都被执行。

调用DISCARD则将清空队列并退出事务。

下面是一个使用Ruby客户端的例子：

?> r.multi
=> "OK"
>> r.incr "foo"
=> "QUEUED"
>> r.incr "bar"
=> "QUEUED"
>> r.incr "bar"
=> "QUEUED"
>> r.exec
=> [1, 1, 2]

正如从上面的会话能看出来的那样，MULTI返回一个回复”数组”，每个元素都是事务中的某一个命令的回复，以命令排队时的顺序排列。

当一个Redis连接处于MULTI请求的上下文中时，所有的命令将用一个简单的字符串“QUEUED”回复，如果它们的语法和参数个数都正确的话。某些命令甚至被允许可在执行期间失败。

在协议层面上这更易于理解；在下面的例子中一个命令将在执行时失败，尽管它的语法是正确的：

Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
MULTI
+OK
SET a 3 
abc
+QUEUED
LPOP a
+QUEUED
EXEC
*2
+OK
-ERR Operation against a key holding the wrong kind of value

MULTI 返回一个两个元素的组合回复(bulk reply)，其中一个是 +OK码，另一个是 -ERR回复。这中情况下将由客户端库来选择一种合理的方式将错误提供给用户。

重要提示：即使在一个命令将会抛出错误时，队列中的所有其他的命令仍将被处理。在发现错误时，Redis不会停止命令的处理。

这是另一个例子，仍旧使用telnet的写协议，展示了语法错误会被尽可能快地报告：

MULTI
+OK
INCR a b c
-ERR wrong number of arguments for 'incr' command

这次由于语法错误，有问题的INCR命令根本不会被排队。

DISCARD

DISCARD用于放弃一个事务。没有命令将被执行，客户端的状态重新变回正常，在事务之外。这是个使用Ruby客户端的例子：

?> r.set("foo",1)
=> true
>> r.multi
=> "OK"
>> r.incr("foo")
=> "QUEUED"
>> r.discard
=> "OK"
>> r.get("foo")
=> "1"

基于WATCH的比较并设置(CAS)事务

WATCH(观察)用于给Redis事务提供CAS(比较并操作）行为。

调用了WATCH命令(WATCHed)的键将被监视以侦测针对键的修改。如果至少有一个监视的键在EXEC调用之前被修改，整个事务将被放弃，EXEC调用将会返回一个空对象(nil object)(一个Null Multi Bulk回复)来通知客户端事务失败了。

例如想象我们需要给一个键的值原子增一（我知道有INCR，让我们假设我们没有它）。

首先我们可能会像这样尝试:

val = GET mykey
val = val + 1
SET mykey $val

这只在一个给定时间内只有一个客户端做这个操作时可靠地工作。如果多个客户端将在大约同一时间内递增这个键，将会出现竞争条件(race condition)。例如客户端A和B将读到旧值，例如10。这个值将被这两个客户端递增到11，并最终设置这个键的值。于是最后的值将是11，而不是12。

多亏了WATCH，我们能够很好地解决这个问题：

WATCH mykey
val = GET mykey
val = val + 1
MULTI
SET mykey $val
EXEC

使用上面的代码，如果存在竞争条件并且另一个客户端在我们调用WATCH和EXEC之间修改了val的结果，事务将会失败。

我们只需要重复这个操作，寄希望于这次没有新的竞争。这种锁定形式叫做乐观锁定，并且在面对许多有多个客户端同时访问数目庞大的键的问题时，是一种十分强大的锁定形式，这种情况下冲突的可能性是很小的：通常操作不需要执行很多次。

WATCH的解释

那WATCH到底是什么呢？它是一个将使得EXEC受到约束的命令：我们要求Redis只在没有别的客户端修改任何一个被监视的键时执行事务。否则，根本就不会开始事务。（注意如果你监视(WATCH)一个瞬时的键，然后Redis在你监视了这个键后，将这个键过期(expire)了，EXEC仍将继续生效。更多信息）

WATCH可以被调用很多次。很简单地，所有的WATCH调用都将从调用时开始监视修改，直到EXEC被调用那一刻。

当EXEC被调用时，不管它是成功还是失败，所有的键都不再被监视。同样当一个客户连接被关闭时，所有的key不再被监视。

也可使用UNWATCH命令（没有参数）来清除被监视的键。有时这是有用的：因为可能我们需要执行一个事务来修改一些键，我们乐观锁定了这些键，但是在读取了这些键的当前内容后我们不想继续修改这些键了。这是我们只需要调用UNWATCH，于是这个连接就能够自由地用于新事务了。

WATCH用于实现ZPOP

一个很好的展示WATCH可被用于创建Redis不直接支持的新原子操作的例子是实现ZPOP，这是一个从有序集合(sorted set)中以原子方式弹出(pop)分数权值(score)较低的元素的命令。下面这是最简单的实现：

WATCH zset
ele = ZRANGE zset 0 0
MULTI
ZREM zset ele
EXEC

如果EXEC失败了(返回一个nil值)，我们只需要重复上面的操作。

返回值

多组合(Multi bulk)回复, 特别地:

一个MULTI/EXEC命令的返回值是一个多组合回复(multi bulk reply)，其中的每个元素是原子事务中的每个命令的返回值。

如果一个MULTI/EXEC事务因为监视命令(WATCH)检测到有键被修改了，返回一个空多组合回复(Null Multi Bulk reply)。

No related posts.

确实，volatile的语义不是那么常见。不是锁，但是它又拥有锁的部分特性（可见性，Java 5以后还有顺序保证）。如果不能正确理解，确实是个容易出错的地方。但是如果理解了用对了，仅就Java 5以及以后的版本而言，在目前阶段，volatile对性能上的提升还是有帮助的。

Volatile在Java中的语义以及历史

在维基百科上，对Java中的Volatile给了一个准确的定义^[6]：

• (In all versions of Java) There is a global ordering on the reads and writes to a volatile variable. This implies that every thread accessing a volatile field will read its current value before continuing, instead of (potentially) using a cached value. (However, there is no guarantee about the relative ordering of volatile reads and writes with regular reads and writes, meaning that it’s generally not a useful threading construct.)
• (In Java 5 or later) Volatile reads and writes establish a happens-before relationship, much like acquiring and releasing a mutex.

翻译过来就是：

• (在所有的Java版本中)对volatile变量上的读和写有一个全局排序。这暗示着每个线程访问一个volatile域时在往下运行之前将读到当前的值，而不是(有可能)使用一个缓存值。(然而，在volatie变量的读写与常规的读写之间的排序没有保证，意味着volatile通常不是一个有用的线程化的构造)
• (在Java5及之后版本中) Volatile读和写建立了一种happens-before关系，就像获取和释放一个互斥体。

在Java中，要正确地并发，必须在原子性、可见性和顺序性三个方面做出保证。在Java 5以前的版本中，volatile就已经实现了可见性，但是因为不能保证与普通变量读写之间的顺序，故而经常是没有用的。在Java 5以后的版本中，则额外保证了其与普通变量读写的顺序性。这里不是特别好懂，我们将javamx上的例子^{[3] [4]}改造一下：

public class MyBrokenFactory {
  private static volatile MyFactory instance;
  private int field1, field2 ...
 
  public static MyBrokenFactory getFactory() {
    // This is incorrect: don't do it at home, kids!
    if (instance == null) {
      synchronized (MyBrokenFactory.class) {
        if (instance == null)
          instance = new MyBrokenFactory();
      }
    }
    return instance;
  }
 
  private MyBrokenFactory() {
    field1 = ...
    field2 = ...
  }
}

上面的代码，在Java5以前，这个例子是不能正确工作的，因为volatile不保证对field1,field2的初始化（常规读写）一定在对volatile变量instance的写之前完成。但双检查锁本身并非volatile导致的，反而是Java 1.5的volatile让双检查锁能正确工作了。并行实验室将双检查锁不正确算在volatile的头上，有点冤了。

正是因为volatile在Java 5以前没有得到正确实现，更添加了不少复杂性。在Java 5之前，volatile基本没用处。

Volatile的实现机制分析

在Hotspot JVM中，
a) 在JVM层次，对volatile变量在线程本地工作区中不做缓存，对volatile的读写总是指向堆中的引用。可以视作在一个assign指令后总是跟着一个store指令^[5]。
b) 在机器码执行层次，通过内存屏障指令等迫使CPU不重排序，清除缓存，详细请参考《Memory Barriers and JVM Concurrency》的分析。

这与synchronized是有明显不同的，synchronized通常需要原子锁定，在SMP上要通过锁定总线等方式来实现，其代价在大多数平台上通常要比volatile高得多。

Performance

引入Volatile的主要目的，就是为了性能。我分下面几个方面来谈谈volatile在目前的Java平台中的作用。

直接性能比较

简单写了一个测试来比较一下volatile以及它的两种替代品 — 原子类型(atomic)和锁(此处指synchronized)。例子的代码改编自庄周梦蝶的slides《Java NIO trick and trap》中的SystemTimer（部分代码省略，完整源码在Github上）。这个测试只是一个例子，但其实在网络库里都要做定时，原理也大抵如此。

第一个版本如下：

package me.xiping.volitileverify;
public class SystemTimerV1 {
	private final static ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
	private static final long tickUnit = Long.parseLong(System.getProperty(
			"notify.systimer.tick", "50"));
	private static volatile long time = System.currentTimeMillis();
 
	private static class TimerTicker implements Runnable {
		public void run() {
			time = System.currentTimeMillis();
		}
	}
 
	public static long currentTimeMillis() {
		return time;
	}
 
	static {
		executor.scheduleAtFixedRate(new TimerTicker(), tickUnit, tickUnit,
				TimeUnit.MILLISECONDS);
		Runtime.getRuntime().addShutdownHook(new Thread() {
			@Override
			public void run() {
				executor.shutdown();
			}
		});
	}
}

代码的重点在于volatile修饰的time域。time是一个只有一个线程写，其他线程都是读的域，没有并发修改，这里要解决的就是可见性。这正是volatile最适合的场合。

第二个版本使用synchronize关键字，与版本V1的不同如下：

package me.xiping.volitileverify;
public class SystemTimerV2 {
	....
	private static long time = System.currentTimeMillis();
 
	private static class TimerTicker implements Runnable {
		public void run() {
			synchronized (SystemTimerV2.class) {
				time = System.currentTimeMillis();
			}
		}
	}
 
	public static synchronized long currentTimeMillis() {
		return time;
	}
	....
}

第二个版本使用Java的内部锁来同步，既保证了原子性，也保证了可见性。第三个版本则是使用AtomicLong来实现的，如下：

package me.xiping.volitileverify;
 
public class SystemTimerV3 {
	......
	private static AtomicLong time = new AtomicLong(System.currentTimeMillis());
 
	private static class TimerTicker implements Runnable {
		public void run() {
			time.set(System.currentTimeMillis());
		}
	}
 
	public static long currentTimeMillis() {
		return time.get();
	}
	.....
}

在我的本上(cpu: 2core; OS: win7/cygwin; java:1.6.0_13)运行100万次，其性能如上面右图一所示(单位:ms)。

运行1000万次性能如图二所示(注意纵坐标的值与图一不一样)。

结论：性能上的优越性是显而易见的。volatile比AtomicLong明细要快，相比于synchronized则有几倍几十倍的提高了。
（欢迎在不同平台下测试并在评论中给一个反馈，反馈时请包括处理器信息（平台，core数），OS和Java版本。源代码在这里。编译和运行需要Ant，具体指南请参考这里。）

[Update, Dec15th： 图片是用Google Chart API 生成的，在源代码中包含着两个自动执行测试并生成图片URL的脚本。脚本需运行在Bash环境下，Windows上需在Cygwin下运行。]

Mina/netty对volatile的利用

写博文时顺便统计了下volatile在一些性能比较重要的程序中的情况，我顺手统计了手边有的mina和netty两个项目的核心代码，数据如下：

其中，mina是2009-3-31日Subversion的trunk，如下：

$svn info
Path: .
URL: http://svn.apache.org/repos/asf/mina/trunk
Repository Root: http://svn.apache.org/repos/asf
Repository UUID: 13f79535-47bb-0310-9956-ffa450edef68
Revision: 761900
Node Kind: directory
Schedule: normal
Last Changed Author: jvermillard
Last Changed Rev: 760493
Last Changed Date: 2009-03-31 23:49:15 +0800 (Tue, 31 Mar 2009)

netty的版本信息是：

$git log
commit 1ffb1aea75c36def56b709bd0892b19df78d9249
Author: Trustin Lee <trustin@gmail.com>
Date:   Fri Nov 12 10:20:03 2010 +0900

从侧面证明了volatile其实是很重要的，在性能很重要的场合，应用还是比较多的。

结论

总而言之，相比与Atomic和synchronized，volatile在性能上还是有显著的优势。

不过，正如文章中开头讨论的那样，volatile的缺点也显而易见，需要开发者对volatile的应用需要对内存模型的理解，否则容易误解而造成错误。在并发程序中，其仅可用于JVM支持的几个基本类型(int,short,long,double,reference, etc.)，而这几个基本类型皆有对应的完整并发特性的包装原子类型(java.util.concurrent.atomic.*)，虽然其性能与volatile有些差距，但大部分情形下也可代替volatile（但用synchronized来代替volatile是很不划算的）。

1. 为什么在多核多线程程序中要慎用volatile关键字？
2. Sayonara volatile
3. Double-checked Locking (DCL) and how to fix it
4. Double-checked Locking (DCL) and how to fix it (ctd)
5. JVM specification#Threads and Locks
6. Volatile variable#Java
7. http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
8. Memory Barriers and JVM Concurrency

Related posts:

1. 解决Java序列化的版本冲突
2. 动态规划练习（一）: 求数列中连续数字之和的最大值
3. 细节背后：为什么线程协作之前必须先获得锁?

• Query: 使用Query过滤巨大表中要导出的数据。要注意的是指定query的语法，尤其是在shell下特殊字符的转义问题。
• Compression: 压缩数据。在11g中，有个compression选项，可以选择压缩 {ALL | DATA_ONLY | METADATA_ONLY | NONE}。在Oracle 11g中，不能像exp一样使用pipe给gzip的方式压缩了，要用gzip的话必须手动gzip。
• Parallel: 并行选项，在启用压缩时感觉效率有所提升。

下面是一个例子，使用 BLOCKS 方法的总估计: 2.159 GB，实际压缩后仅仅剩下 28M左右（因某些数据我通过Query限制了，压缩前实际大小可能在300M左右，且数据比较特殊）。 更具普遍性的压缩效果可参考这篇文章（需翻墙）。该文也比较了使用gzip与使用compression参数的压缩效果。

一个实际的例子，导出：

expdp dbaname/dbapwd DUMPFILE=expdumps%u.dmp DIRECTORY=DPUMP_DIR  TABLES='(T1,T2,T3)' 
\QUERY=T1:\"where mod\(ID,10\)=0\",T2:\"where mod\(ID,5\)=0\" PARALLEL=4 COMPRESSION=ALL

导入：

impdp dbaname/dbapwd DIRECTORY=dpump_dir1 DUMPFILE=expdumps%U.dmp

详细信息参考Oracle手册相关内容。

Related posts:

1. 2011, 掌握一门新语言：Erlang

1. 理解JDBC中的时间类型
2. MySQL与JDBC之间的类型映射
3. Oracle与JDBC之间的类型映射
4. Ibatis是怎么处理日期时间类型的
5. 注释
6. 参考资料

理解JDBC中的时间类型

java.sql包中包括三个类，Date, Time, 和 Timestamp，分别用来表示日期（无时间信息，eg: YYYY-MM-DD），时间（只处理时间，无日期部分, eg: HH:MM:SS）和时间戳（精确到纳秒级别）。在 它们都继承自java.util.Date。java.sql.Date和java.sql.Time都存有一个时间域，该时间域是精确到秒级别的，但是，他们只处理日期或者时间部分。在MySQL Connector/J(v5.1.13)的实现中可以看到，PrepareStatement#setDate 时会将时间重新format成”yyyy-MM-dd”格式。

因为历史遗留以及各种数据库本身的不同，各种JDBC实现中留下了格式各样的花招, 某些特殊场景下不遵照此情况可能也能工作，但不推荐这样做。

你必须根据你的实际需要来选择不同的类型，通常应该选用精确度与相应的数据库字段类型相比相同或者更高的JDBC类型。

除此以外，还可以使用java.uitl.Date类型来处理时间。java.util.Date类型是上面各个类型的父类型，JDBC的API大都可以使用。

除此以外，在JDK1.6之前版本的构造java.sql.{Date|Time|TimeStamp}对象时存在性能问题，尤其是在多线程环境下更严重。这个Bug在这里。其原因是java.util.Date的相关方法调用了TimeZone.getDefaultRef()，而此方法是同步方法^注1。

MySQL的JDBC类型映射

MySQL的DATETIME、TIMESTAMP两种字段类型的显著区别在于TIMESTAMP的取值在’1970-01-01 00:00:01′ UTC 和 ‘2038-01-19 03:14:07′ UTC之间。

MySQL在时间处理方面也有一个问题，当Datetimes类型的字段的值为0000-00-00时取值方法会得到下面的异常：

Cannot convert value '0000-00-00 00:00:00' from column xx to TIMESTAMP

这个问题的原因在于，MySQL中默认使用0000-00-00等来表示时间的特殊值（参见文档）。而在Java中，并没有一个合适的方式来表示这个时间(因为Java中时间轴上0是1970-01-01 00:00:00），早于这个时间的用负数表示，这个最小的负数在时间轴上是表示不出来的。Connector/J提供了一个属性zeroDateTimeBehavior来解决此问题。

• exception (the default), which throws an SQLException with an SQLState of S1009.（默认行为）
• convertToNull, which returns NULL instead of the date.
• round, which rounds the date to the nearest closest value which is 0001-01-01.

如下所示的jdbc连接将指定该行为转化为null值。

jdbc:mysql://localhost/myDatabase?zeroDateTimeBehavior=convertToNull

Oracle与JDBC之间的类型映射

Oracle数据库字段类型主要有DATE、TIMESTAMP。

在9i以后、11g以前的Oracle JDBC驱动中存在一个会丢失DATE类型字段的时间信息的bug，原因是其JDBC驱动将Oracle的Date类型处理为java.sql.Date类型，这就丢失了时间部分（看来对java.sql包下三种时间类型认识不足的问题还很普遍的）。关于这个问题，这篇帖子给出了不错的解释（墙外），此文中的方法适用于11g JDBC以前的各版本驱动。在11g JDBC驱动中，此问题已经解决了，Oracle 11g JDBC驱动的手册中也给出了解释^注2。

事实上，如果是使用Ibatis，pojo属性的类型设置为java.util.Date，确保 jdbcType不为 DATE或者TIME，则避免了这个bug。因为此时Ibatis会以java.sql.Timestamp来处理该字段。我专门对此做了验证，点此看测试项目源码。

Ibatis是怎么处理日期类型的

注意：本文皆基于ibatis 2.3.4.726源码分析。不过根据我初略观察，Ibatis3也适用，但请遇到问题时有所留意。

在此前工作中碰到Oracle中的Date字段会只剩下日期部分的数据，丢失了，Google发现一些人的解决方法是将JDBCType指定为datetime。有人甚至自己编写一个自定义的TypeHandler来解决这个问题。其实这完全是瞎猫撞上死耗子，那个datetime根本没意义，却歪打正着。一般的错误都是如下的配置（或者是pojo的属性为java.sql.Date类型）：

<sqlMap namespace="Info" >
  <resultMap id="Info" class="pojo.Info" >
    <result column="INFO_BEGINTIME" property="begin" jdbcType="DATE" />
    <result column="INFO_ENDTIME" property="end" jdbcType="DATE" />
  </resultMap>

此时不论你pojo.Info中的字段类型（或者的javaType属性）是java.util.Date还是java.sql.Date，最终都会丢失数据。实际上，在pojo.Info中的字段类型(或者javaType属性）为java.util.Date时，如果指定jdbcType为DATE或TIME（区分大小写），则将分别得到DateOnlyTypeHandler或TimeOnlyTypeHandler。如果你不指定jdbcType，或者指定一个错误的值，例如datetime，或者xxxx等，都会得到DateTypeHandler（日期时间都会处理）。

如果pojo.Info中的属性类型（或者配置中的javaType属性）是java.sql.Date，则选择处理handler类时不会使用jdbcType，而是根据属性类型得到SqlDateTypeHandler（只包含日期）。

在Ibatis的手册中，指出来jdbcType一般情况下是不用于判断处理方式的^注3。大部分情况下是依据javaType或者pojo属性类型来判断处理方式，在少部分无法根据pojo属性类型判断的情况下才使用。如果你用java.util.Date对应到MySQL，则就是这种少数情况之一。因为MySQL可以将多个数据库字段类型映射到java.util.Date，所以需要指定是DATE还是TIME（必须是大写），如果不指定则默认是完整的日期时间（此时按JDBC的timestamp操作）。

针对ibatis对时间的处理，我写了个测试，点此看测试代码。

对于Ibatis操作Date/Time/DateTime，总结如下：

• 将pojo的属性类型设置为java.sql.Date（或java.sql.Time, java.sql.Timestamp），此时会严格遵循这三种类型的语义。但此方法因存在前文中提到的性能问题，在JDK1.6以前的JDK版本中能少使用就少使用。
• 如果你想在pojo中使用java.util.Date， 则要注意：
  • 完整的日期时间，要确保jdbcType为空，或为DATE,TIME以外的值
  • 只需要时间，要指定jdbcType=”TIME”
  • 只需要日期，要指定jdbcType=”DATE”

注释

注释1：Use oracle.sql.DATE or oracle.sql.TIMESTAMP rather than
java.sql.Date or java.sql.Timestamp if you are using JDK 1.5 or earlier versions or require maximum performance. You may also use the oracle.sql data type if you want to read many date values or compute or display only a small percentage. Due to a bug in all versions of Java prior to JDK 1.6, construction of java.lang.Date and java.lang.Timestamp objects is slow, especially in multithreaded environments. This bug is fixed in JDK 1.6.

注释2：Mapping SQL DATE Data type to Java Oracle Database 8i and earlier versions did not support TIMESTAMP data, but Oracle DATE data used to have a time component as an extension to the SQL standard. So, Oracle Database 8i and earlier versions of JDBC drivers mapped oracle.sql.DATE to java.sql.Timestamp to preserve the time component. Starting with Oracle Database 9.0.1, TIMESTAMP support was included and 9i JDBC drivers started mapping oracle.sql.DATE to java.sql.Date. This mapping was incorrect as it truncated the time component of Oracle DATE data. To overcome this problem, Oracle Database 11.1 introduces a new flag mapDateToTimestamp. The default value of this flag is true, which means that by default the drivers will correctly map oracle.sql.DATE to java.sql.Timestamp, retaining the time information. If you still want the incorrect but 10g compatible oracle.sql.DATE to java.sql.Date mapping, then you can get it by setting the value of mapDateToTimestamp flag to false.

注释3：Ibatis 2的手册中给出的jdbcType属性的解释：属性jdbcType用于显式地指定给本属性（property）赋值的数据库字段的数据类型。对于某些特定的操作，如果不指定字段的数据类型，某些JDBC Driver无法识别字段的数据类型。一个很好的例子是PreparedStatement.setNull(int parameterIndex, int sqlType)方法，要求指定数据类型。如果不指定数据类型，某些Driver可能指定为Types.Other或Types.Null。但是，不能保证所有的Driver都表现一致。对于这种情况，SQL Map API允许使用parameterMap子元素parameter的jdbcType属性指定数据类型。
正常情况下，只有当字段可以为NULL时才需要jdbcType属性。另一需要指定jdbcType属性的情况是字段类型为日期时间类型的情况。因为Java只有一个Date类型（java.util.Date），而大多数SQL数据库有多个－通常至少有3种。因此，需要指定字段类型是DATE还是DATETIME。
属性jdbcType可以是JDBC Types类中定义的任意参数的字符串值。虽然如此，还是有某些类型不支持（即BLOB）。本节的稍后部分会说明架构支持的数据类型。
注意！大多数JDBC Driver只有在字段可以为NULL时需要指定jdbcType属性。因此，对于这些Driver，只是在字段可以为NULL时才需要指定type属性。
注意！当使用Oracle Driver时，如果没有给可以为NULL的字段指定jdbcType属性，当试图给这些字段赋值NULL时，会出现“Invalid column type”错误。

参考资料

• JSR-000221 JDBC 4.0
• Ibatis Developer Guide
• MySQL Connector/J

Related posts:

1. 解决Java序列化的版本冲突
2. DBCP连接池(一)：原理与基本配置
3. J2EE/Oracle性能调优实录

从客户端看速度有不错提升

未启用之前在Google Chrome中打开 本页，页面各部分内容的大小如下图：

请求速度如下图：

开启mod_pagespeed以后，页面各部分内容的大小如下图：

css减少约1K，js减少1.5K，图片没有太大变化。总体减少约2K。

请求速度如下图：

页面加载时间变化明显，document加载减少了480ms，css减少了6ms(提升比为25%)，图片减少了24ms(提升比为18%)，js脚本减少了6ms(提升比为25%)，整体加载时间减少了460ms(提升比为21%)。

从服务端看

用ab在本机测试服务器的性能，可能是因为机器资源有限，ab本身要消耗一些资源，而本机测试时传输阶段的性能提升可以不计，故整体提升作用不明显。另外，ab不会去获取外部连接的文件也会错过mod_pagespeed在css/js/jpg方面的许多优化工作。尽管如此，处理速度还是有一些提升。开启前，50%的请求需要609ms，开启后降到599ms；66%的请求需要641ms，开启后降到621ms。所有请求的处理时间的中位数从609ms降到599ms。

启用前数据如下：

blog@feihoo:~$ ab -n 1000 -c 3 blog.feihoo.com/
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
 
Document Path:          /
Document Length:        114025 bytes
 
Concurrency Level:      3
Time taken for tests:   209.315 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      114394000 bytes
HTML transferred:       114025000 bytes
Requests per second:    4.78 [#/sec] (mean)
Time per request:       627.946 [ms] (mean)
Time per request:       209.315 [ms] (mean, across all concurrent requests)
Transfer rate:          533.71 [Kbytes/sec] received
 
Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       0
Processing:   484  628 108.2    609    1763
Waiting:      224  288  57.5    284    1035
Total:        485  628 108.2    609    1763
 
Percentage of the requests served within a certain time (ms)
  50%    609
  66%    641
  75%    657
  80%    670
  90%    735
  95%    825
  98%    895
  99%    988
 100%   1763 (longest request)

启用后测试结果如下：

blog@feihoo:~$ ab -n 1000 -c 3 blog.feihoo.com/
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
 
Server Software:        Apache/2.2.11
Document Path:          /
Document Length:        114356 bytes
 
Concurrency Level:      3
Time taken for tests:   209.686 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      114755000 bytes
HTML transferred:       114356000 bytes
Requests per second:    4.77 [#/sec] (mean)
Time per request:       629.057 [ms] (mean)
Time per request:       209.686 [ms] (mean, across all concurrent requests)
Transfer rate:          534.44 [Kbytes/sec] received
 
Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.2      0       6
Processing:   511  628 216.0    599    3660
Waiting:      233  294 157.4    277    2984
Total:        511  628 216.0    599    3660
 
Percentage of the requests served within a certain time (ms)
  50%    599
  66%    621
  75%    635
  80%    643
  90%    664
  95%    694
  98%   1075
  99%   1641
 100%   3660 (longest request)

Related posts:

1. 在 Vista 上安装 Apache 2.2, PHP 5.2.6
2. Ubuntu 上安装buildix，PHP5， Apache2

但是对于某些比较稀疏的位图，其存储效率也会有一些问题。如果100万用户平均只有100个人在线，那另外的999,900个位就浪费掉了。例如在第1位有一个用户，第1,000,000位有个用户，需要1M个位来保存。既浪费了存储空间，也带来大量无用的运算。在前不久我们的应用中就有这种问题。未经压缩的位图保存到数据库中，结果大量的IO操作对数据库的性能造成较大影响。

因为稀疏的位图比较多，比较直接地就想去掉中间的这些空白位，于是就想这样表示：存储第一个位的值（0或1），接着将接下来的所有值相同的位的数目保存为一个整数，再保存接下来另的一类连续位的数目，依此类推。如：{0000 0000 1000 0000 0000 1100 0001 0000 …… } 保存为 0,7,1,11,2,5…。 如果是一百万个位，只有第一个和最后一个是1{10000 …. …. 1}，则保存为{1,999998,1}只需要三个整数就可以了！（注：实际上，早有人完整地将这种方法实现了，参考D-Gap Compression）

于是对比较稀疏的位图应用这种方法，由于大部分位图都是比较稀疏，90%以上的位图的体积最终缩小了10倍。在测试过程中，发现最终存储的是大量的小整数（小于1000）。这些小整数其实可以用更短的类型来表示，于是应用变长编码来处理。其原理是每一个字节的高位做标识，其余7位存储值。1标识从这个字节开始是一个新的整数，0表示是上一个字节的延续。则区间[1, 2^7 )中的整数占用一个字节，[2^7, 2^14)中的整数占用两个字节，依次类推。

最终，90%以上的位图体积压缩了30倍以上。

Related posts:

1. Impdp/Expdp 之并行(Parallel)和压缩(Compression)

基础技术

XML

XML，全称可扩展标记语言（Extensible Markup Language (XML) ）是在W3C制定的几个文档中定义的，用于将内容编码为机器可读的格式。

XML我们经常接触或者使用，其支持Unicode编码、严格完整的标记和错误处理等等，大家都知道。XML最早使用DTD来对XML的内容和格式进行定义和校验，后来W3C开发了新的模式语言XML Schema来取代DTD。于是，现在我们经常见到用来规范XML格式和内容的Xsd文档，DTD 已经逐渐淡出了。

XML的编程接口

XML作为一种数据格式，其设计目标中就包括了能够轻易地为各种编程语言提供接口。概括起来主要是下面这四个类型。

1. 面向流的API，例如 SAX 和 StAX。
2. 树遍历的API， 例如 DOM。
3. XML数据绑定，支持在程序语言的对象与XML文档之间自动转换。（JAXB）
4. 声明式转换语言，例如 XSLT 和 XQuery。

Sun公司给Java语言定义了一个将上面这数种编程接口（DOM/SAX/StAX）统一的API，JAXP（Java API for XML Processing），其目的是在Java平台上统一处理XML的接口。

Java平台中怎么处理XML

DOM和SAX

DOM的全称 Document Object Model（文档对象模型），是将XML在内存中组织为一个树形结构，并按照树形结构遍历和访问。不论是使用Dom4j，或者是Javascript里，经常看到Node/Element/Attribute这些东西，这就是使用DOM操作XML/XHTML等。DOM操作的最大缺点就是要将所有东西装到内存中，方便频繁查询、修改。一般的配置文件都比较小，使用DOM问题都不大。但是数据量很大的情况下，或者要处理的XML很多，那最好不用它。

SAX的全称是 Simple API for XML， 是基于流的方式来访问XML的。CSDN的这篇博文解释道：”SAX 解析器采用了基于事件的模型，它在解析 XML 文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX 对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时，SAX 这种扩展能力得到了更好的体现。但用 SAX 解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。”（该博文有转字样，不知道其出处是哪，没搜到）。

对于SAX/DOM相关的论述， 上面提到的CSDN的博文关于SAX，DOM，JAXP，JDOM，DOM4J的一些理解 有比较精彩的论述。

有关DOM/SAX两种处理接口在处理大量XML数据时的性能，Tinyfool的博文提供了一组数据为证。

Java平台这两种API的实现

在Java的类库中，Dom4j最早就是以DOM方式解析XML的。现在dom4j也支持其他方式解析XML，完整实现了DOM, SAX 和 JAXP。如果你使用Dom4j，在JDK5之前的JDK版本中则需要从JAXP的主页上下载相关的API包。

JDOM是另一个基于DOM模型处理XML的类库，但似乎已经不那么流行了。

Apache的xerces项目下有C++/Java/Perl三种语言的XML解析器。Apache Xerces2 Java 是Java语言的XML解析器。使用Apache xerces-J需要两个jar包，第一个是xml-apis.jar，其中包含了sax dom jaxp等接口的定义，另一个jar包是 xercesImpl.jar，包含各个接口的实现。以前的Xercers包中还包括一个xerces.jar，现在已经废弃了（参考这里）。

XML数据绑定

JAXB，全称是Java Architecture for XML Binding，是Java EE平台中处理XML与Java对象之间数据绑定的API。名如 jaxb1-impl.jar, jaxb1-impl-2.0.jar等的包，就是这个接口的相关产物。这个API也是JAXP的一部分，Xecers-j和dom4j都提供了实现。

Apache Xmlbeans 也提供了处理XML与Java对象间数据绑定的功能。

Java平台中的声明式转换语言

XSLT， 可扩展样式转换语言，常用于将信息内容与展现分离。在《企业应用架构模式》中将之作为表现层的一种模式做了介绍。使用XSLT，同一份内容，能够转换成HTML，文本文件，PDF，Postscript等等。处理XML的声明式转换语言还有从XML中查找节点的XPATH，用于从XML集合中查询数据的XQuery等。此前在Flex平台的项目中用过XPATH来处理界面，还是很方便的。

你可能看到过xalan.jar，有的项目里还必须有这个库。其实这是Apache的Xalan-Java的库，是一个XSLT处理库，实现了 JAXP中的javax.xml.transform接口。Xalan可将XML文档转换为HTML，文本文档或者其他XML格式。这个包依赖实现了SAX接口的相关包，所以必须与实现SAX接口的包一起使用。Xalan官方推荐的是Xercers（参考这里）。

另一个可以实现了XML的声明式转换相关接口的类库是Saxon项目的Java子项目。

结语

有关Java中这些XML处理方式，Apache这里有个FAQ可以参考一下，这个FAQ尝试回答为什么Java里有这么多XML处理的实现，接口和jar包。

总结这些东西好累，Java平台上处理XML实在是太累了。这大概也与XML被用得如此宽广有关。XML作为一种严格规范化的描述能力很强的数据格式，确实无处不在。虽然XML有时很臃肿，但基于XML的技术如XForm，Java API for XML-Based RPC (JAX-RPC)，XML-RPC等，很多很多。

（本文涉及内容较多较杂，我只是尝试做一个整理，如有谬误请不吝赐教）

Related posts:

1. DBCP连接池(一)：原理与基本配置
2. 解决Java序列化的版本冲突
3. 理解Java虚拟机的加法运算

一个人的成功，15%来自他的专业技术，75%来自于他的思维和性格，10%来自于机遇。

虽然下面Jeff Xiong做了一些批驳，但是某些情况下我大致同意上面这句话。一方面上面所指的成功因素的比例跟时间分配上的比例完全是不可比的，另一方面，专业技术的发展与性格和思维根本就是分不开的。但其实另外那75%里的思维和性格，同样决定了技术上是否能有所成绩。每个人的目标和志向不同，性格和习惯也不同，不是一句话能概括得了的。(Updated at Nov 30th)

No related posts.

Object （对象）教程

总结

由于orx是数据驱动的，我们只需要两行代码创建一个viewport（视口）和一个object。它们的所有属性都定义在配置文件（01_Object.ini）中。

Viewport关联到一个按照配置文件中的信息隐含创建的camera(摄像头)。在配置文件里，你还可以设置它们的大小，坐标，对象的颜色，缩放，旋转，动画，物理属性等等。你甚至无需增加一行代码就可以让任何的配置获得随机值。

在后面的一个示例中我们将看到如何使用一行代码生成复杂的object体系甚至整个 scene（场景）（所有的背景对象和普通对象）。

现在，你可以尝试取消01_Object.ini中某些行的注释，自己尝试一下，然后再继续学习这个教程。完整的选项列表请查看CreationTemplate.ini。

详细说明

创建一个object是相当简单的。不过，我们首先需确保已经加载了定义了所有object(对象)的属性的配置文件。我们还要通过viewport/camera组合显示创建好的object(对象)。

不要慌张！所有这些都很容易。

在这篇教程中，我们将加载一个位于父目录中的配置文件。正如你可能想到的，在所有的可执行程序都根据其构建类别（mingw, msvs2005, msvs2008, 等）位于各自的子目录的情况下，我们不打算在每个地方重复同样的配置文件。1)

在我们的例子中，加载配置文件使用类似下面这行代码的方式实现：
orxConfig_Load(”../01_Object.ini”);

然后我们创建viewport(视口)。注意 camera的创建是按照为这个viewport预置的配置信息自动完成的。
orxViewport_CreateFromConfig(”Viewport”);

我们差不多完成了。现在我们只需要创建 object！
orxObject_CreateFromConfig(”Object”);

就这样了！object(对象)已经创建，并且由于在camera的视觉平截体（frustum）内，将会被显示出来。
现在，因为我们使用Orx默认的启动器，我们需要申明我们的插件入口点（这里是我们的Init函数）。这可以使用一个宏很容易地实现。

orxSTATUS Init(){...}
orxPLUGIN_DECLARE_ENTRY_POINT(Init);

因为orx是数据驱动的，我们不需要手动加载任何数据，例如一个sprite（精灵）。一切都由数据管理器为我们搞定，它会确保sprites不在内存中重复并在其不再使用时自动释放的
如果你查看配置文件，在[Object]这一节，你将看到你可以设定所有的对象属性，例如 graphic (sprite)，锚点，颜色，透明度，物理属性，坐标，旋转，缩放，tiling(平铺)（重复），动画，视觉特效，等等。
不要担心，这一切都将在后面的教程中讲到。

现在我们拥有了一个object（对象），我们需要学习如何与之交互。这将我们带入第二个教程：clock.

资源

• 源代码: 01_Object.c
• 配置文件: 01_Object.ini

No related posts.

教程

本教程主要包含Orx的基础和高级教程。Orx 是一个开源、跨平台、轻量级、数据驱动的2D游戏引擎。

安装

这些教程演示了如何设置不同的编程环境(IDE)来运行orx1)。

• Microsoft Visual Studio (C++) for Windows: Tutorial / Download (Express version)
• CodeLite for Windows, Linux and Mac OS X: Tutorial / Download
• XCode for Mac OS X: Tutorial / Download

基础

本节将要介绍orx的基础知识。

你可以从这里下载Windows(mingw, msvs2005 & msvs2008). Linux 和 MacOS X下的可执行文件（包括项目文件，数据和源码）。

前九个基础教程（#1 – #9）使用默认的orx启动程序为基础(underlying layer)，这样易于快速测试/制作原型2。

它们被编译成运行时加载（在命令行3) 上 或配置文件中指定它们的名字）的动态连接库。

此外，下面的内容 4) 解释了哪些行为是由默认的orx.exe/orx 启动程序提供的。

这是一个基础的C教程。
由于我们在本教程中使用默认的可执行文件，下面的代码将以插件的方式加载和执行。

另外，一些基础设施有主执行文件为我们处理。
首先，它会加载所有可用的插件和模块。如果你只 需要其中的一些，最好编写你自己的可执行文件而不是插件。这部分包含在后面的教程中。

主执行文件还处理下面这些键盘输入：

* F11 是纵向对齐切换
* Escape 退出
* F12 截屏
* 退格键(Backspace) 重新载入全部配置文件

如果有 orxSYSTEM_EVENT_CLOSE事件发生，程序也会退出。

不过，如果使用 orx作为传统库构建你自己的可执行文件当然也是可以的（也很容易做到）。在教程 #10(使用C++编写) 和 教程 #11 (使用 C编写)。教程 #10 还演示了如何使用orx编写C++代码5)。 同样地，你可以用任何可与C连接的语言编写程序。

在将来的发布中将会为某些常见语言提供封装。如果你想编写这种封装库，为orx做贡献，请通过论坛联系我们。

当前提供的基础教程列表：

1. [C] object
2. [C] clock
3. [C] frame
4. [C] animation
5. [C] viewport & camera
6. [C] sound & music
7. [C] fx
8. [C] physics
9. [C] scrolling
10. [C++] stand alone & localization
11. [C] spawner & shader

社区

下面这些教程由社区创建，它们是了解如何使用 orx的不错的资源，可以在这里寻找到对一些简单问题的解答。

• Grey’s tutorials（英文版）

1) 所有的IDE都是免费可以从英特网上下载的。
2) one line for the whole initialization, no main function to write, no loop to handle
用一行代码完成初始化，不需要写main函数， 没有循环要处理
3) 另提供了 .bat/.sh 脚本方便启动所有示例
4) 你将在在所有教程的源文件的开始处看到这些内容
5) Orx本身使用C编写

Related posts:

1. [译] Orx教程：1. object
2. 虚拟机中Host与Guest文件共享

一、集中目标

专注目标。凡是工作效率高的时间段里，工作目标都很明确。每天一上班，心里就想明白了今天要干什么，每天下班时，想想今天都实现了什么，有什么目标还没有实现。尽管每天早上来了先看看股票新闻，中午饭后看看股票新闻，偶尔下午还打个盹什么的，但工作的时候确实格外专注，丝毫也不会走神。

分离与当前无关的任务/问题。专注目标不是那么容易做到的。印象中以前工作中经常会碰到的问题是工作中遇到的问题。一方面可能得益于基本功的增强，最近虽然也遇到了一些问题，但是都能够通过简单阅读或查找文档，或浏览问题相关的库的源码解决； 另一方面，遇到的问题我总是避繁就简，首先倾向于寻找简单可用可靠的方案，并将心中的疑虑记录下来，集中成一个列表，工作之外翻翻书，系统思考和学习，而不会因为这个问题而叉开思路对相关的内容研究一番。总之，专注当前的任务，把新问题记录下来，回头再专心攻克。

例如我第一次用ibatis，遇到了一些表可以用集合和映射来加强Pojo的OO功能，但是我并不熟悉ibatis的这些特性，并且使用简单的方案也是可行的，于是就直接使用简便方案(在我看来，ibatis主要是将SQL集中起来管理、简化SQL操纵，对OO不感冒)。

工作列表。不论是开发还是设计，一个文本格式的位于源代码存储系统下的待办工作列表与IDE中的TODO项一起构成了专注目标的重要工具。工作目标分解是基本工作步骤，记录工作中产生的新的问题（任务），这样，子问题越来越多，项目中要干的事情越来越丰富。经常性地调整当前工作任务列表，根据重要性对这些任务进行划分。每天都干掉一些问题，经常想着那些最重要的问题。

简单但有迹可寻的设计材料。在思考和工作的过程中，一方面，项目的过程通常比较长，另一方面经验相对丰富的人手头总是有多个事情在并行进行。当时间太长记不清出了或者是切换任务时，经常要查看此前的代码和设计，易于修改以及有历史记录的设计材料对于保持设计思路的完整十分有意义。（设计材料还应该包括重要的图）

正式准确可以依靠的需求文档。这一条无论怎么说都不过分，遇到需求不确定的地方，就去查需求文档。如果没有，就请能够回答的人来回答，委托给他，先去做别的。细想在上一家公司，经常要承担多种角色，甚至连需求也经常没人给一个最终决策，设计开发的时候在模棱两可的需求之间做决定，很烦心。对于一个设计/开发人员而言，需求人员在需求问题方面就是绝对的权威。如果有些建议，可以建议，但一切均以需求/产品人员为准。

单元测试。另一有助于集中精力编码的就是单元测试。单元测试让我集中精力实现当前的功能，需要依赖的其他功能，我总是先生成一个接口，让当前的功能通过测试后再专心去实现该接口。一天下来，一个一个的测试点亮了绿色，一个一个的接口被实现，整天都是十分惬意的。单元测试的另外一个收益就是放心地去重构吧，放心地去做新的特性吧。

二、简化问题的能力

无论是在广义的工作方法/工作态度上，还是在针对具体问题的设计/实现上，我认为最重要的个人能力就是化繁为简了。化繁为简是所有工作方法/软件设计的核心。将那些可以砍掉的工作砍掉（最多做个记录），做到尽可能地经济，尽可能地简单。

从工作方法和态度上来讲，真正需要去做的工作才值得去做，大力砍掉那些不应该在当前工作中处理的事情。例如不必要的优化，不必要的扩展性，不必要的性能，不必要的功能，可以不要的技术，不必要的流程，不必要的文档，统统砍掉，一切可以没有的全都不能有。

工作中也可能遇到非关键的难题，通常绕过它们，使用更简单的方案就是了。纠缠于这些不重要的难题，最容易浪费时间。例如，eclipse忽然坏掉了，最好的方法是重装一个; 又如以前我经常自己建一个持续集成服务器，现在我直接养成每次写完代码手工跑一遍的习惯（前提是够用）。简化你的工作！简化！

从设计/实现来讲，最好的方案就是最简单直接、一眼就能看懂的方案。记得刚到一个新的环境，有一个统计任务，既要用到数据库也要用缓存，我做了精细的设计来保证最终一致性，状态流程都很完整，并且使用线程池来并发运行分批处理，最后再合并。虽然控制得很完美很精细，但是流程和结构都很复杂。上头根据此前的项目经验给出了一个更简单的例子，直接将各个任务划分为多个线程，分开存储，到了该统计的时候，冻结数据在所有的分区上做统计。状态砍掉一半，流程缩减一半。

事实上，作为简单直接的一个附带效应，最简单直接的方式，通常性能也最好。

简化问题的能力，是一个人的核心能力。

三、基本功

基本功的内容十分复杂。首先，对整个计算机体系的理解，对操作系统/虚拟机/数据库本质的理解，对语言基础类和库的理解，我觉得是核心基本功。

第二项基本功，就是学习能力。 通过快速阅读核心文档理解核心思想，然后其他的东西总是能从文档中查到就行。细枝末节的东西，即学即用，学过就忘可也。

第三项基本功，就是文档、资料的搜索和收集。

要想在工作中如行云流水，另外一个方面就是避开暂时还不熟悉的技术和工具，不熟悉的东西很难用好，更难用顺畅。尤其是那些纠结复杂、华而不实的技术，不要去碰。这属于简化能力的范畴。

四、工具

选择工具的核心标准，就是简单朴素可信赖。

文本格式的设计，加上易于修改的图。 我喜欢用一个简单的文本格式来记录设计，随时修改，随时查阅。而附上几幅简单直接的图，经常能够更简单直接地表达更多的内容。

简单的可信赖的工具。我曾经将很长的时间用来构建Maven的环境上，用Maven管理依赖，尤其是跟Eclipse协作时，经常出现诡异。现在我用ant，或者只用Maven，maven不与eclipse纠缠在一起。如果一个工具出几次诡异现象，那就干脆丢掉它。

版本管理工具。 不仅仅源码要由版本管理，整个项目过程的所有知识，全部用版本管理系统管理起来，集中存放。现在我用subversion和git。

Related posts:

1. 设计与开发的五条原则

例如，我经常使用VMWare的共享文件夹特性来在Host与Guest之间交换数据，共享文件。 但是在OpenSUSE下，却没有找到合适的方法。最终，不得不求助于Samba。 Samba在OpenSUSE上的安装是很方便的，基本上遵照 How To Samba With openSuse 10.3 And Windows XP 的指导，三两步就完成了。 完毕以后，在Windows XP 下映射一个盘符到 \\GUEST_HOSTNAME\users 就完成了。我完全关闭了Guest上的防火墙，有防火墙反而可能招致麻烦。

而在OpenSUSE上访问Windows XP也很简单，基本上遵照 SDB:Access to Windows Shares 的 Manual Procedure 部分，将Windows XP共享目录加入到 /etc/fstab 中：

  1 /dev/sda1            swap                 swap       defaults              0 0
  2 /dev/sda2            /                    ext4       acl,user_xattr        1 1
  3 /dev/sda3            /home                ext4       acl,user_xattr        1 2
  4 proc                 /proc                proc       defaults              0 0
  5 sysfs                /sys                 sysfs      noauto                0 0
  6 debugfs              /sys/kernel/debug    debugfs    noauto                0 0
  7 usbfs                /proc/bus/usb        usbfs      noauto                0 0
  8 devpts               /dev/pts             devpts     mode=0620,gid=5       0 0
  9 //x.x.x.x/work   /mnt/windows    cifs  auto,uid=liuz,gid=users,umask=0002,iocharset=utf8,credentials=/etc/winpasswd 0 0

别忘了保护你的密码文件：

chmod 600 /etc/winpassword

特殊之处，是指定了一个 uid=liuz， 将文件的所有者指定为liuz这个用户，方便增删改等操作。有关 uid,gid,umask等的解释如下： (来源)

uid与gid
uid即user identifer，gid即group identifer。设置所有文件的所有者和群组。gid=64，即权限为所有者可读、写，不能执行，群组用户可读、不能写、执行。
umask
umask即user mask，即用户屏蔽。umask=007，即所有文件的权限中，屏蔽其它使用者的读、写、执行权限。

总结

总结一下我使用的这三种方法：

• 1) 使用VMware提供的共享文件夹功能。
• 2) 使用Samba为Windows Host OS 共享Linux Guest OS文件系统。
• 3) 在Linux Guest OS中mount Host OS （Windows系统）的共享文件夹。

Related posts:

1. 我的VPS使用经验

因为特别的原因，需要从Memcached中导出所有的数据。因为Memcached对数据的遍历是明确不支持的，所以必须想歪门邪道的方法。

现在网络上主要有两种思路，一种是通过Memcached提供的stats cachedump命令导出，例如下面这些网址：

• dump all keys from memcached
• Dumping MemcacheD Content (Keys) with PHP
• Robbin的文章

以上文章都利用这个命令导出了部分数据。但事实上，cachedump的输出会限制在 2*1024*1024=2M 字节的长度内（Memecahed source: items.c, func: do_item_cachedump），其导出的格式如下所示：

ITEM key990017 [1 b; 1270394155 s]
ITEM key990016 [1 b; 1270394155 s]
ITEM key990015 [1 b; 1270394155 s]
ITEM key990014 [1 b; 1270394155 s]

即使不计算key的长度，每一条数据至少要占掉近三十个字节，2M最多到几万项数据。对于Item数量很大的情况下，这种方法并不能导出全部数据。

下面的地址佐证了这些观点。

• 官方邮件列表上的解释
• 上面提到的文章 memcache dump and load 的读者也在评论中进行了分析

第二种思路来自 Twitter infrastructure team 的 Evan Weaver 的 peeping into memcached , 利用 linux 的 ptrace 系统调用导出memcached进程中数据，分析这些数据得到memcached的所有Key。

但是这种方式有其限制的，一方面，编译Memcached时必须编译入调试信息 （参见link）； 另一方面，在分析时对内存消耗太大。我们对一个只使用了64M内存、含有76万左右数据项的Memcached进程进行分析，在完成23万左右数据项时，分析进程占用内存的达到1040M，导致虚拟机内存用满，关闭了该进程。

因为我们现在运行的memcached是不带编译符号的，所以放弃了第二种方式。 第一种方式，则只能考虑怎么将slabs中的数据分批导出来。 Memcached 支持一个可选的 slabs reassign 命令，可以将一个slab内的数据项移动到其他slab。但这个命令必须在编译 memcached 时加入该特性。

最后，还是利用了第一种方法，每一次导出一批数据以后就从memcached中删除这一批数据，直到全部导出为止。 虽然这种办法很土，但是还是能够应付一次性数据迁移。 当然这是不得以而为之，明智的做法还是在一开始就不要将需要持久化的数据持久化到其他服务中，而不是只存放于memcached中。

Related posts:

1. Flex中的对象比较（相等性）

约一年多前开始使用 vpslink 的 Xen VPS，前不久因为实在是没什么事情做，只放了一个博客，觉得有点不值得，就搬到了 Tektonic 上的 OpenVZ VPS。Tektonic的OpenVZ性能也还可以，但很快就发现网速实在是不行。于是试用了一下fsckvps，速度还不错的，可惜服务不好，尤其是上次事故以后，客服响应很差。另外，发现OpenVZ的虚拟机运行java基本是不可行的，甚至 ant/maven 编译个程序都不行。只能将某些能够修改JVM参数的程序手工做好设置（-Xmx480M）才能运行。

Linode

于是开始试用在中国颇为有名的 linode，我比较穷，选择了最便宜的 Linode 360，$19.95/M。 听 blogkid 的 博文 选择了 Fremont 的机房。输入信用卡，vps 很快开通。但是ssh一上去，感觉上很卡，测试了一下速度，速度才 几 K/S。受不了了，在本地测试了一下，发现blogkid 推荐的两个机房（Fremont, Newark）的速度都不行。倒是 Dellas 机房的速度很快，北京联通1M宽带能到140K左右。

于是发了个ticket给linode，很快就回信了，让我重新登录控制面板。果然，控制面板上有了自动迁移机房的按钮。于是开始迁移，速度很慢。第二天早上起来发现迁移完了。试用了一下，速度确实不错。不过很快又遇到了问题，做一个hive的测试，因为内存太少，数据一大进程一多，实在是受不了啊……

于是退了 Linode，申请退款。

Fsckvps + AWS

最后决定采用Fsckvps+AWS的方案。fsckvps 的价格很便宜，虽然fsckvps最近刚刚出过事情，但是我只有一个博客，数据是每天自动备份的。何况 fsckvps 的网速实在是快（北京联通1M能到180K/S，性价比相当不错，我不到 $10/M（年付）就能拿到 512M （burst 1024M)的内存。 Fsckvps的vps的网速实在是不错，在Google Webmaster Tools中，显示我这个博客的速度faster than %92 of sites：

On average, pages in your site take 1.1 seconds to load (updated on Mar 15, 2010). This is faster than 92% of sites.

但是 fsckvps 的虚拟机是 OpenVZ的，你不能用swap，所以基本上不要指望运行吃内存太猛的程序了，在64位平台上，1024M内存的vps连java –version都跑不了。要在这样的内存比较少的VPS上跑Java，必须对堆内存的大小予以限制，因为默认情况下会根据物理内存去申请一定比例的内存，这很可能超出vps的限制（虽然物理机器的内存可能不小，但是每一个vps内存是有配额的）。

export EC2_JVM_ARGS="-Xms128m -Xmx128m"
export ANT_OPTS="-Xms128m -Xmx256m"
export MAVEN_OPTS="-Xms128m -Xmx256m"

事实上，给Maven和Ant限制这么小的内存，导致它们基本失去作用。大部分Java程序的编译都会因为内存超出限额而编译失败。对于基于OpenVZ的VPS，其内存配额在/proc/user_beancounters中，可以用下面的脚本来计算你能用多少内存

for v in vmguarpages privvmpages; do expr `cat /proc/user_beancounters |grep $v |awk -F' ' '{print $4}'` / 256;done

于是我将其他不需要在线的应用，挪到AWS去跑了。

我最后的方案就变成了 FsckVps + AWS. 一个月算起来也不到12$，而且AWS的服务器组集群都行，想咋搞就咋搞。从Fsckvps上操控AWS，实在是太爽了。

总结：

• 1) Linode 的网速，以我家（北京网通1M）来看，Dellas 的网速是最快的。 1M 能够保持在120K以上，平均在 140K 左右。 其他三个中心的速度并不快。当然网速的问题，不同的时间，不同的宽带差别可能很大。Linode的服务相当不错，控制面板相当智能化，退款也爽快
• 2）fsckvps 性价比最高，网速最快（在Atlanta机房，达到140~180K/S，相当稳定）。
• 3）最终的策略是 fsckvps + AWS, 没有多少在线应用的穷人的选择。

Related posts:

1. 虚拟机中Host与Guest文件共享
2. Ubuntu 上安装buildix，PHP5， Apache2

连接池扼要

JDBC是一套通用的Java语言与多种数据库（文件）通讯的标准API。大部分针对数据库服务器（例如Oracle, MySQL等等）的JDBC实现都是基于TCP/IP连接的客户端-服务器端通讯方式。

当我们需要执行一个数据库操作时，有下面三步：

1. 客户端与服务器之间建立一个数据库连接
2. 执行某种数据库操作
3. 断开连接

如果每次处理都要走上面的三步，则应用程序与数据库服务器都要将大量的时间和资源消耗在数据连接的断开与建立上。对于某些数据库系统，一个数据库连接就是一个进程，而且数据库连接通常要占用不少资源，如排序区/Join区等等。对于并发较大的系统，建立一次连接然后缓存起来连续使用，直到程序结束等情况下再释放连接，就能够将系统资源集中在对数据库操作的处理上，从而大大提高性能。通常情况下将数据连接的建立和断开委托给一种能够数据库连接池的组件或服务进行管理。而DBCP, C3p0, Proxool等都是常用的开源的连接池组件。

就好像A公司在郊外，他们公司附近没有出租车。如果A公司有人要出去办事，他必须打电话给出租公司订车，用完车后他还要付账报销。 这样每个人出去一趟都必须订车、退车和报销。员工的很多时间白白花费在这上面了。于是A公司跟出租车公司定了一个合同，出租车公司给了他们一个车队。要用车随时去楼下找车队就可以了，用完了也不必结帐，A公司统一跟出租车公司订车和结帐。这个车队就好比连接池，由公司（应用程序）来统一向出租车公司（数据库服务器）订车（建立连接）和退车（关闭连接）。

DBCP的配置参数以及背后的原理

Commons-dbcp连接池的配置参数比较多，也比较复杂，主要分为

• Jdbc连接参数（username, password, url, driverClassName, connectionProperties ）
• 事务处理参数 （defaultAutoCommit, defaultReadOnly, defaultTransactionIsolation, defaultCatalog）
• 连接池参数（详见下文）
• 连接池中链接存活性测试参数（详见下文）
• 预处理查询池化参数（poolPreparedStatements, maxOpenPreparedStatements）
• 丢弃失效链接相关参数（详见下文）以及一个控制是否可以正常情况下处于访问连接池包装下的底层JDBC链接参数（accessToUnderlyingConnectionAllowed）

其中Jdbc链接参数、事务处理都跟连接池关系不大，另预处理查询池化参数本文不详细叙述。有关commons-dbcp的详细参数配置信息请参考官方文档。

连接池的配置

再用车队来比喻，出租车公司每提供一辆车给A公司，A公司肯定要付出一定费用。这时候维持车队的大小就很重要了，在项目少用车少的时候，车队肯定要减少，不然很多空闲车辆也要付出成本；在项目多用车多的时候，肯定要扩大车队，不然车不够用，车队忙不过来。A公司可以简单地设地两个阀值来动态调节车队中空闲的车辆数目以满足动态需求，一个是最小空闲车辆数(最小空空闲连接数（minIdle），当剩余的空车数目小于该数目时，A公司就向出租车公司请求加入新车。 一个是最大空闲车辆数（maxIdle），当剩余的车大于该数目时，就将刚刚用用完的车还给出租车公司从而减少车队数量。

另外，这家出租车公司可能要为多个客户服务，要考虑能够提供给A公司的最大的车数量，不能超过某个数量(maxActive)。所以A公司想出租车申请新车时首先要看下当前正在用的车辆数目是否超过了这个最大数目，如果没有超过那就直接申请新车，否则可以让申请者（应用程序中执行请求的线程）等待 (maxWait<=0, 无限等待; maxWait>0 当等待时间超过 maxWait时，失败）。

在连接池中，这几个参数是十分重要的，官方的说明如下，是我们调节系统性能时需要认真考虑的值。

实际上，Dbcp 依赖于 commons-pool 来存储连接对象。 BasicDataSource默认使用GenericObjectPool来管理连接对象。除了请求的线程会在请求和返回连接过程中影响池中连接实例外，另有一个跑着GenericObjectPool.Evictor类型 (implements Runnable) 的实例的线程，也会影响池中的数据库连接。

请继续阅读下一篇：《DBCP连接池（二）：Commons-pool的设计》

Related posts:

1. 有关 sum与limit组合使用时的问题
2. 细节背后：为什么线程协作之前必须先获得锁?
3. JDBC和Ibatis中的Date,Time,Timestamp处理

• 火烧圆明园是无法避免的？ （看过这个问题你会明白第二次鸦片战争中中方对于战争的起因、过程和结果都负有重要责任）
• (义和团)是爱国壮举还是摧残文明和反人道的罪行 （看过这个问题，你会明白义和团的罪恶和八国联军侵占北京不只是对方的责任。 两国交战不杀来使在中国历史上早已认知，要是随意杀死对方的民众就更不应该了，这一段历史教科书里对史实的篡改实在是太糟糕了。在我们记恨南京屠杀时，也想想我们的清政府和义和团所犯下的杀戮。）

初中历史教科书图片(本图片不代表袁伟时文章中批判的教材,袁文可能指的是别的版本）

再引一段吧：

19、20世纪中国人干了不少“无法无天”的事，义和团事件是其中的典型。值得重视的是不但至今有人把野蛮的行为说成是“革命”，而且到了20世纪90年代，有人竟把主张遵守现行国际条约的观点视为应该严加批判的卖国投降观点！

这篇文章或许是因为其真实而对国人的思想产生强大的震撼，直接导致了刊登该文的杂志主编被撤职，杂志停刊。

2006年1月11日“中国青年报”的《冰点》周刊因刊出袁伟时文章《现代化与历史教科书》[2]，因而导致暂时停刊，并引致主编李大同及副主编卢跃刚撤职。3月1日《冰点》复刊，刊登张海鹏的《反帝反封建是近代中国历史的主题》文章批驳上文，并拒刊袁伟时《为何、何时、如何反帝反封建》文章。（来源：维基百科）

也许有的读者会质疑袁伟时的观点，那太好了，希望有人出来反驳一下，真理越辩越明。

下面给出两个版本的链接，内容大致是一样的，只是青年报的版本用语可能更谨慎些。同时放在这里是为了降低因墙影响不能阅读的概率。

文章链接：

• 现代化与中国的历史教科书问题（版本一，中国青年报）
• 现代化与中国的历史教科书问题 （ 五柳村 ）

No related posts.

后来我把我们家人对于卓依婷的热爱，以及她已经离世等等都告诉了老婆。才知道她也是喜欢卓依婷的歌的。不过这两天听了三四个人演唱的《小城故事》，觉得都和原唱有一定的差距。而卓依婷估计唱这个歌的时候年纪还很小，歌声有些区别也是可以理解的。

于是我顺便Google了一下有关卓依婷的资料，没想到发现搜索提示框里排名第二的是”卓依婷之死“，于是搜索进去，结果大吃一惊，原来她并没有去世。各种消息都是以讹传讹吧。老婆说，他应该把这个消息告诉我舅舅和叔叔，他们也应该会感到高兴的，因为可以买新专辑了 。

她只是中间休息了两年（她81年出生，我想休息一下学学东西也是好的），但是2001年复出后没有很特别的成果，加上个人低调等原因，有关她的消息不是特别多。可能这些年努力也不容易，她之前给人民的主要印象还是年少时的作品，如今好些年了，要转变也不是一个容易的事情。祝她顺利。

顺便去看了看她的博客，觉得很平易近人，有一种很亲切的感觉。

另外，她现在签约优格音乐文化有限公司，暂时不知道该公司的更多资料。她还开通了官方网站。

No related posts.

使用Socket实现进程互斥

因为Java服务器套接字都是基于系统的socket接口实现的，而socket接口会保证一个套接字端点在整个系统中是唯一的，所以只需要在应用启动时监听一个端口，就可以让系统不同时启动。虽然方法比较土，但是也能用。

try {
	ServerSocket ss = new ServerSocket(3030);
}catch (Exception e) {
	logger.error("Cannot start", e.printStackTrace());
	System.exit();
}

使用文件锁在进程间同步

另一个实现Java进程间互斥的方法，就是文件锁。不过与上面使用套接字不同，使用文件锁还可以实现更高级的互斥/协作。完全可以用文件锁来实现不同Java进程之间的同步，基本思路与在线程之间使用读写锁同步相似。

JDK本身直接支持文件锁，在FileChannel下有几个与文件锁有关的方法，可以打开一个FileLock对象。当调用FileLock#release()方法，或者Channel关闭，或者JVM退出时都会释放该锁。文件锁是JVM全局的，与Java内部的锁/线程等无关，是进程之间的竞争关系。如果你不想发生意外你的程序挂起，那就应该用FileChannel#trylock，而不是直接使用FileChannel#lock()，这样在不能加锁时可以休眠一段时间再等等，或者超时退出。

文件锁像读写锁一样，可以是加共享锁，也可以加独占锁，还可以给锁定限制范围。这是操作系统本身提供的功能，JDK在操作系统层面上做了封装。在Linux下，其实就是调用fcntl来设置相关的状态。如下面的代码，会给文件加独占锁，如果再起新的进程，进程就会打开文件失败退出。

     char* lockfile;
      int lockfd;
      struct flock lock;
      time_t t;   
 
      if ((lockfd = open(lockfile, O_RDWR)) == -1) {
          fprintf(stdout, "open file %s fail: %s \n", lockfile, strerror(errno));
          exit(1);
      }
 
      t = time(NULL);
 
      lock.l_type = F_WRLCK;
      lock.l_start = 0;
      lock.l_len = 0;
      lock.l_whence = SEEK_SET;
      if (fcntl(lockfd, F_SETLKW, &lock) == -1) {
          fprintf(stdout, "lock file %s fail: %s \n", lockfile, strerror(errno));
      }
      fprintf(stdout, "lock file %s success(%d): %ld \n", lockfile, (int)getpid(), time(NULL)-t);
      sleep(30);

Related posts:

1. J2EE/Oracle性能调优实录
2. 解决Java序列化的版本冲突
3. 细节背后：为什么线程协作之前必须先获得锁?

Update(2010-3-18): 小怡凡在各界爱心人士的帮助下终于踏上了去往美国医疗的路程。详情在拯救小怡凡主页上。 还要担心手术会怎样，真心祈愿她早日康复！

从小怡凡的主页上了解到：第一，如果要孩子一定要让自己身体健康、强壮；第二，如果孩子有不好，要提早治疗，找几家医院或许能相互参考。

2010年1月19日亚历山大医生带回来怡帆的血样检测及影像分析结果，排除了由DNA变异导致的先天性肺疾病， 确切的病症是”肺细胞代谢缺陷”，肺间质形成脂肪蛋白阻碍氧气进入血液交换，这正是肺部影像一直呈现毛玻璃状的真正原因， 由此导致左心室向肺部加速血液输送，形成“肺动脉高压”。北京市儿童医院2006年对怡帆实施过两次“肺灌洗”， 灌洗液培养结果未见蛋白成分，后归结于“肺纤维化”。几年来，未能及时对症治疗和控制肺间质的脂肪蛋白生长， 错过了治疗及手术修复的最佳时机，目前必须通过全肺移植来救治。

由于我的工作性质以及之前努力工作却忽视了身体，我有些担心我家小宝贝，祈祷他/她在妈妈肚子里健康孕育、成长！
===============================================================================

下面是一个患病需要高昂费用去救助的孩子，他的爸爸妈妈只有一年多点的时间来筹集500,000$，人民币是350万。病情越来越严重了，时间快到了，可是却还不一定能够攒足这笔费用。我老婆看了小孩的照片和故事，心疼不已。我看着也心疼。只可惜我经济状况也不好，只能提供一点捐款。在这里贴下小怡帆的照片，希望过往的人们看到，伸出援助之手。在为小怡帆祈祷的同时，也祈愿天下的小孩子都健康活泼。

很感谢您能抽时间了解怡帆的事情，怡帆是我四岁的女儿，患有肺动脉高压，需要二十四小时吸氧来维持呼吸， 北京儿童医院诊断为肺纤维化，国内无法医治。在和睦家医院亚历山大医生的全力帮助下， 怡帆有机会去美国德州儿童医院接受心肺移植手术，费用十分昂贵，作为孩子的父母， 我们没有足够的时间来积累这笔费用，为此，和睦家基金会帮助我们建立了怡帆基金，寻求社会的帮助， 请您抽出少量的时间浏览www.yifanfund.com和 www.help-yifan.org， 同时将这个网站告诉您周围的朋友，并恳请提供一些帮助来挽救这个孩子。谢谢！

上面的话来自怡帆的父亲，我们的朋友潘俊廷。

详细请去救助小怡帆的主页。

No related posts.

cp /usr/share/vim/vimcurrent/vimrc_example.vim  /usr/share/vim/vimrc

~/.vimrc: Keep it simple!

" 设置文件编码检测类型及支持格式
 set fencs=utf-8,ucs-bom,gb18030,gbk,gb2312,cp936
 
 "显示行号
 set nu!
 
 " 中文帮助
 if version > 603
 set helplang=cn
 endi
 
 " 设置代码自动缩进
 :set cindent
 
 """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 " cscope setting (from http://easwy.com/blog/archives/advanced-vim-skills-cscope/)
 """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 if has("cscope")
   set csprg=/usr/bin/cscope
   set csto=1
   set cst
   set nocsverb
   " add any database in current directory
   if filereadable("cscope.out")
       cs add cscope.out
   endif
   set csverb
 endif
 
 nmap <C-@>s :cs find s <C-R>=expand("<cword>")<CR><CR>
 nmap <C-@>g :cs find g <C-R>=expand("<cword>")<CR><CR>
 nmap <C-@>c :cs find c <C-R>=expand("<cword>")<CR><CR>
 nmap <C-@>t :cs find t <C-R>=expand("<cword>")<CR><CR>
 nmap <C-@>e :cs find e <C-R>=expand("<cword>")<CR><CR>
 nmap <C-@>f :cs find f <C-R>=expand("<cfile>")<CR><CR>
 nmap <C-@>i :cs find i ^<C-R>=expand("<cfile>")<CR>$<CR>
 nmap <C-@>d :cs find d <C-R>=expand("<cword>")<CR><CR>

Related posts:

1. Vim 快捷键
2. My Ubuntu Installation log

(Hadoop)There are some places where Java is sub-optimal. In particular, at scale, there will be considerable memory pressure in the Namenode of the DFS. Java is a poor choice for this type of memory hungry application. Another place where the use of Java is sub-optimal is the post-map sorting in preparation for the reduce phase. This is CPU-intensive and involves the type of CPU work that Java is not good at.

There are a bunch comments on the Wiki Page. Someone gave another views. A guy gave two links to support Java is not so bad.

Some interesting comparative articles.

http://www.ddj.com/cpp/184401976?pgno=1
http://www.idiom.com/~zilla/Computer/javaCbenchmark.html

Related posts:

1. Memory leak caused by Proxool and the fix
2. Reliability, Availability, and Scalability
3. JDBC和Ibatis中的Date,Time,Timestamp处理

第一步，从官方下载 Ubuntu-desktop。

第二步，在VMWare上安装，并安装VMWare-tools。 在ubuntu-desktop-9.10上，不像以前需要手工安装一些包，安装linux头文件，这次一路回车就搞定了。

到这里系统就算安装完毕，发现已经用去了8G硬盘的 37%。

第三步，安装我需要的各种软件。

0. 设置source.list，我使用 mirrors.163.com.
设置网卡：

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
address 192.168.1.126
netmask 255.255.255.0
gateway 192.168.1.1

#auto eth0
#iface eth0 inet dhcp

1. 安装 vim/ctags/cscope, 设置颜色，缩进等。 The details are noted at Here.

• install: sudo apt-get install vim
• Install Chinese vim help: download from http://vimcdoc.sourceforge.net/, tar and enter the directory, execute

• sudo ./vimcdoc.sh -i

• sudo apt-get install exuberant-ctags cscope

2. 安装 JDK/C++工具:

sudo apt-get install sun-java6-jdk sun-java6-source
sudo apt-get install build-essential

3. 安装manuals:

sudo apt-get install manpages-dev

sudo apt-get install manpages-posix manpages-posix-dev

sudo apt-get install libstdc++6-4.2-doc

4. 安装版本工具 Subversion 和 Git:

sudo apt-get install subversion subversion-tools git-doc git-core

5. Configure SSH server:

sudo apt-get install openssh-server

.
6. Install LAMP server by tasksel, and configure;
7. 中文支持。我安装系统时用的是英文，因此 LANG=’en_US.UTF-8′。中文输入遵循下面三步骤即可：

8. 安装 CHM 格式文档查看工具 kchmviewer.

sudo apt-get install kchmviewer

但是 kchmviewer 在查看 boost中文文档页时出现了编码错误。当然这不一定就是kchmviewer有问题，也可能是boost中文文档本身的兼容性等。于是另外安装了chmsee， chmsee的另外一个优点就是安装时体积很小，下载过程中才下了几百K。当然也可能是因为我提前把其他需要的库都已经装上了…
9. ruby gems:

sudo apt-get install rubygems1.9.1

10. 声音问题的解决：这里

Related posts:

1. Ubuntu 上安装buildix，PHP5， Apache2
2. 阿里巴巴收购万网与Vmware收购SpringSource: 布局云计算

第一条原则，首先弄清你的问题是什么。这一条规则无论怎么强调都不过分。

在《Programming Pearls》第二版的开篇，Jon Bentley 讲的就是，首先弄清你的问题是什么！ 在你没有详细、明确地定义好你的问题之前，你所做的大部分工作只产出废物。这些年，最头疼的事情，就是经常搞了一大堆东西，累死累活，甚至加班加点，最后总才发现很多事情偏离了目标。但这样的事情，总是在周围一遍一遍地发生。

一个工程师，如果在接到一个问题时首先不是尽可能挖到细致的资料，定义问题，并向了解问题的人去反馈，详细讨论问题的定义。虽然问题定义不是那么容易，但不首先定义好问题，那就是不合格的工程师。

还有很多原则，大抵都是这个原则的派生品。

第二条规则， 弄清你要干什么，以及哪些先干，哪些后干，哪些根本就不需要干。

说白了，就是把问题分解，列个表，排个先后顺序。这是大部分程序员最蹩脚的部分。高效的本质不是捧着ThoughtWorks那本《卓有成效的程序员》，而是我这条原则。我对Joel的书里印象最深刻的就是有关用Excel列任务列表的部分。

这条仍然是如此重要，以致于著名的YAGNI, (You ain’t gonna need it ）仅仅是一条推论而已。

当然，区分的标准是什么？It depends. 但是最重要的参照是，怎么做你能获得最大产出？也许你会在所谓的扩展性、适应需求变化与可工作的代码，用户的需求之间抉择。 最重要的还是可工作的代码，能够按时 ship the beta!

记住，先列出来要干什么；然后分清先后顺序，然后淘汰那些可以不干的。

第三条规则，KISS。 Keep It Simple Stupid。
用郭靖和杨过来比喻，代码要像郭靖一样用最简单直接的方式强壮地工作，不需要太多的波折。你的程序要是像杨过的人生那么复杂、聪明，早死翘翘了。 你的程序要简单强壮地干活，思想越简单越好，功能和特性越少越好。

这一条对于设计是至关重要的，浮躁的程序员们经常要在架构设计中引入模式、分层，又或者是绚丽的Ajax效果之类，完全是无知下的自虐。我也是好些年后才明白这条道理，直到后来开始使用Unix下的那些让无数人着迷的工具，才真真地看到了这条规则的巨大威力。

要特别澄清一下，KISS 与你的程序是否好用，是否易于复用，不但不矛盾，而且是相辅相成的。你要知道的只是你的程序应该做什么，然后努力做好。借用《Programming Pearls》开篇里法国作家兼飞机设计师的话：“设计者确定其设计已经达到了完美的标准不是不能再增加任何东西,而是不能再减少任何东西”。又如Chuck Yeager将军（第一个超音速飞行的人）赞扬一架飞机的机械系统时的用词是“结构简单、部件很少、易于维护、非常坚固”。

第四条规则，一键集成和适当的自动化测试。

这条不多说了，在有条件的情况下做会受益非浅。

其他还有一些很有名的原则，例如 DRY （Don’t Repeat Yourself)， 也许是因为一开始我就懂得了这个道理（尤记得大学的时候把ASP代码提取函数，封装Head和Foot，将写HTML Table的封装成方法来根据不同的数据集打印，好傻。），感触没那么深。

六年了，好快。

(Update 2009-12-23)
第五条： 一定需要且只需要数页简单明了的设计说明书。

这个设计说明最好不用word，最好是放在源代码下的html或者txt格式。简单粗线条的UML最适宜用在这种地方。当然设计文档也可以放在别的地方。

P.S.
用原则这个词，是为了强调重要性。遣词或有问题，慎自斟酌之。

Related posts:

1. 程序员提高工作效率的方法

昨天偶然在这个页面上看到 ssh-user-config 命令，试了试，就成功了！各位设置不成功的同学，考虑使用下这个命令，然后一路回车确认即可。

另一篇重要的参考文章：这里。

顺便记录下在探索 SSH使用公钥登录过程中学到的几个sshd相关的命令：

# debug more information 
ssh  -vvv  localhost
 
#start services
net start sshd
#or
cygrunsrv  --start  sshd
 
#login command for user name that has space
ssh  Mickey\  mouse@127.0.0.1
 
#copy publickey to remote host ( 或使用 ssh-copy-id, e.g ssh-copy-id -i ~/.ssh/id_dsa.pub user@host ）
king@king:~$ cat .ssh/id_dsa.pub | ssh master "cat - >> ~/.ssh/authorized_keys"
#copy publickey from remote host
king@king:~$  ssh master "cat .ssh/id_dsa.pub" | cat - >> ~/.ssh/authorized_keys"

在某些情况下，必须使用代理登录SSH服务器。connect.c is the simple relaying command to make network connection via SOCKS and https proxy. It is mainly intended to be used as proxy command of OpenSSH. You can make SSH session beyond the firewall with this command.

在Windows下，只需要下载connect.exe到c:/windows，然后在 ~/.ssh/config中添加如下配置：

ProxyCommand connect -S x.x.x.x:x %h %p

connect.c 还支持 https 代理，真不赖。

Related posts:

1. 在Android上走出天朝局域网
2. Maybe Another Choice for QQ?
3. Ubuntu 上安装buildix，PHP5， Apache2

1. 有一家人父亲、母亲和儿子、女儿，当父亲和女儿独处或者母亲和儿子独处时，父亲（母亲）就会骂女儿（儿子）。现在他们要过一条河，河上有一条船，船一次只能容纳两人,并只能由大人驾船。问他们应该怎么过河才能保证女儿和儿子都不会被骂。

完全是推理分析能力，采用试错法。答案有两种，其中一种是母亲先送女儿过河，然后目前回来接父亲过河，然后父亲回去接儿子过河。

2. 我三个筐子，一个装苹果，一个装橙子，一个装苹果和橙子。你看不到筐子里的东东，而标签都贴错了，你只能任选一个筐子，拿一个水果出来，然后把标签都改正过来，怎么拿?

根据条件要一次确定最多的结果，肯定应该去挑选标签为苹果和橙子的框，选出的水果就决定了这个框的真实标签，然后决定了另外一个标签称是该水果的框里的是混合物，剩余一个自然清楚了。

3. 屋子里有三盏灯，屋外有三个开关，屋外看不到屋里。你在屋外可以任意设置三个开关，然后进屋一次，就要说出哪个开关控制哪盏灯。

? 题目似乎不太清楚。

4. 12个小球，其中有一个是坏球。有一架天平。需要你用最少的称次数来确定哪个小球是坏的并且它到底是轻还是重。

答案是3次。这是一个涉及到概率的问题，需要用概率的方法来选择。详细请参考 刘未鹏的博客 。
对于类似于此种问题， 有其特殊的规律。

• 第一，是天平有三种输出的可能，所以应该让最终的结果均分称三等分。分得越严格，最有利于最终结果。
• 第二，分组时，还应该要保证天平输出三种结果的几率是均等的。

这种方式通过构造最佳决策树来解决问题。在刘未鹏的文章中，还提到有人用信息论的方式来讨论此问题。

No related posts.

十年后一春日绍兴城外沈园中，陆游来此赏春，偶遇唐婉与赵士程也来此春游。 虽遇然不得诉怀，唐婉派人送来一些酒菜，以示默默关怀，然后与夫离去。陆游伤心之余，在园墙上题下《钗头凤》：

红酥手，黄藤酒，满城春色宫墙柳。
东风恶，欢情薄，一怀愁绪，几年离索。
错！错！错！
春如旧，人空瘦，泪痕红邑鲛绡透。
桃花落，闲池阁。山盟虽在，锦书难托。
莫！莫！莫！

唐婉后以另一首《钗头凤》作答：

世情薄，人情恶，雨送黄昏花易落。
晓风干，泪痕残，欲笺心事，独语斜阑。
难！难！难！
人成各，今非昨，病魂常似秋千索。
角声寒，夜阑珊。怕人寻问，咽泪装欢。
瞒！瞒！瞒！

而后不久，唐婉忧郁而辞世。史载：「未几，怏怏而卒」。

陆游去世前一年，再来沈园，又题下：
「沈家园里花如锦，半是当年识放翁；也信美人终作土，不堪幽梦太匆匆」

好一个「也信美人终作土，不堪幽梦太匆匆」，其中何等苦辛！

参考：

百度知道：谁能够提供陆游及唐婉的，《钗头凤》这两首词？
沈园
钗头凤 陆游与唐婉

Related posts:

1. 孔雀东南飞，五里一徘徊

序曰：汉末建安中，庐江府小吏焦仲卿妻刘氏，为仲卿母所遣，自誓不嫁。其家逼之，乃投水而死。仲卿闻之，亦自缢于庭树。时人伤之，为诗云尔。
孔雀东南飞，五里一徘徊。
　　“十三能织素，十四学裁衣。十五弹箜篌，十六诵诗书。十七为君妇，心中常苦悲。君既为府吏，守节情不移。贱妾留空房，相见常日稀。鸡鸣入机织，夜夜不得息。三日断五匹，大人故嫌迟。非为织作迟，君家妇难为！妾不堪驱使，徒留无所施。便可白公姥，及时相遣归。”
　　府吏得闻之，堂上启阿母：“儿已薄禄相，幸复得此妇。结发同枕席，黄泉共为友。共事二三年，始尔未为久。女行无偏斜，何意致不厚。”
　　阿母谓府吏：“何乃太区区！此妇无礼节，举动自专由。吾意久怀忿，汝岂得自由！东家有贤女，自名秦罗敷。可怜体无比，阿母为汝求。便可速遣之，遣去慎莫留！”
　　府吏长跪告：“伏惟启阿母。今若遣此妇，终老不复取！”
　　阿母得闻之，槌床便大怒：“小子无所畏，何敢助妇语！吾已失恩义，会不相从许！”
　　府吏默无声，再拜还入户。举言谓新妇，哽咽不能语：“我自不驱卿，逼迫有阿母。卿但暂还家，吾今且报府。不久当归还，还必相迎取。以此下心意，慎勿违吾语。”
　　新妇谓府吏：“勿复重纷纭。往昔初阳岁，谢家来贵门。奉事循公姥，进止敢自专？昼夜勤作息，伶俜萦苦辛。谓言无罪过，供养卒大恩；仍更被驱遣，何言复来还！妾有绣腰襦，葳蕤自生光；红罗复斗帐，四角垂香囊；箱帘六七十，绿碧青丝绳，物物各自异，种种在其中。人贱物亦鄙，不足迎后人，留待作遗施，于今无会因。时时为安慰，久久莫相忘！”
　　鸡鸣外欲曙，新妇起严妆。著我绣夹裙，事事四五通。足下蹑丝履，头上玳瑁光。腰若流纨素，耳著明月珰。指如削葱根，口如含朱丹。纤纤作细步，精妙世无双。
　　上堂拜阿母，阿母怒不止。“昔作女儿时，生小出野里。本自无教训，兼愧贵家子。受母钱帛多，不堪母驱使。今日还家去，念母劳家里。”却与小姑别，泪落连珠子。“新妇初来时，小姑始扶床；今日被驱遣，小姑如我长。勤心养公姥，好自相扶将。初七及下九，嬉戏莫相忘。”出门登车去，涕落百余行。
　　府吏马在前，新妇车在后。隐隐何甸甸，俱会大道口。下马入车中，低头共耳语：“誓不相隔卿，且暂还家去。吾今且赴府，不久当还归。誓天不相负！”
　　新妇谓府吏：“感君区区怀！君既若见录，不久望君来。君当作磐石，妾当作蒲苇。蒲苇纫如丝，磐石无转移。我有亲父兄，性行暴如雷，恐不任我意，逆以煎我怀。”举手长劳劳，二情同依依 。
　　入门上家堂，进退无颜仪。阿母大拊掌，不图子自归：“十三教汝织，十四能裁衣，十五弹箜篌，十六知礼仪，十七遣汝嫁，谓言无誓违。汝今何罪过，不迎而自归？”兰芝惭阿母：“儿实无罪过。”阿母大悲摧。
　　还家十余日，县令遣媒来。云有第三郎，窈窕世无双。年始十八九，便言多令才。
　　阿母谓阿女：“汝可去应之。”
　　阿女含泪答：“兰芝初还时，府吏见丁宁，结誓不别离。今日违情义，恐此事非奇。自可断来信，徐徐更谓之。”
　　阿母白媒人：“贫贱有此女，始适还家门。不堪吏人妇，岂合令郎君？幸可广问讯，不得便相许。”
　　媒人去数日，寻遣丞请还，说有兰家女，承籍有宦官。云有第五郎，娇逸未有婚。遣丞为媒人，主簿通语言。直说太守家，有此令郎君，既欲结大义，故遣来贵门。
　　阿母谢媒人：“女子先有誓，老姥岂敢言！”
　　阿兄得闻之，怅然心中烦。举言谓阿妹：“作计何不量！先嫁得府吏，后嫁得郎君。否泰如天地，足以荣汝身。不嫁义郎体，其往欲何云？”
　　兰芝仰头答：“理实如兄言。谢家事夫婿，中道还兄门。处分适兄意，那得自任专！虽与府吏要，渠会永无缘。登即相许和，便可作婚姻。”
　　媒人下床去。诺诺复尔尔。还部白府君：“下官奉使命，言谈大有缘。”府君得闻之，心中大欢喜。视历复开书，便利此月内，六合正相应。良吉三十日，今已二十七，卿可去成婚。交语速装束，络绎如浮云。青雀白鹄舫，四角龙子幡。婀娜随风转，金车玉作轮。踯躅青骢马，流苏金镂鞍。赍钱三百万，皆用青丝穿。杂彩三百匹，交广市鲑珍。从人四五百，郁郁登郡门。
　　阿母谓阿女：“适得府君书，明日来迎汝。何不作衣裳？莫令事不举！”
　　阿女默无声，手巾掩口啼，泪落便如泻。移我琉璃榻，出置前窗下。左手持刀尺，右手执绫罗。朝成绣夹裙，晚成单罗衫。晻晻日欲暝，愁思出门啼。
　　府吏闻此变，因求假暂归。未至二三里，摧藏马悲哀。新妇识马声，蹑履相逢迎。怅然遥相望，知是故人来。举手拍马鞍，嗟叹使心伤：“自君别我后，人事不可量。果不如先愿，又非君所详。我有亲父母，逼迫兼弟兄。以我应他人，君还何所望！”
　　府吏谓新妇：“贺卿得高迁！磐石方且厚，可以卒千年；蒲苇一时纫，便作旦夕间。卿当日胜贵，吾独向黄泉！”
　　新妇谓府吏：“何意出此言！同是被逼迫，君尔妾亦然。黄泉下相见，勿违今日言！”执手分道去，各各还家门。生人作死别，恨恨那可论？念与世间辞，千万不复全！
　　府吏还家去，上堂拜阿母：“今日大风寒，寒风摧树木，严霜结庭兰。儿今日冥冥，令母在后单。故作不良计，勿复怨鬼神！命如南山石，四体康且直！”
　　阿母得闻之，零泪应声落：“汝是大家子，仕宦于台阁。慎勿为妇死，贵贱情何薄！东家有贤女，窈窕艳城郭，阿母为汝求，便复在旦夕。”
　　府吏再拜还，长叹空房中，作计乃尔立。转头向户里，渐见愁煎迫。
　　其日牛马嘶，新妇入青庐。奄奄黄昏后，寂寂人定初。我命绝今日，魂去尸长留！揽裙脱丝履，举身赴清池。
　　府吏闻此事，心知长别离。徘徊庭树下，自挂东南枝。
　　两家求合葬，合葬华山傍。东西植松柏，左右种梧桐。枝枝相覆盖，叶叶相交通。中有双飞鸟，自名为鸳鸯。仰头相向鸣，夜夜达五更。行人驻足听，寡妇起彷徨。多谢后世人，戒之慎勿忘。

下面为来自百度百科上的部分精妙评述，引录如下。更多精妙请参考：百度百科》孔雀东南飞

全诗“共一千七百八十五字，古今第一首长诗也。淋淋漓漓，反反复复，杂述十数人口中语，而各肖其声音面目，岂非化工之笔”（《古诗源》卷四，沈德潜按语）。在贯穿全篇的对话中，可以看到，刘兰芝对仲卿、对焦母、对小姑、对自己的哥哥和母亲讲话时的态度与语气各不相同，正是在这种不同中可以感受到她那勤劳、善良、备受压迫而又富于反抗精神的外柔内刚的个性。同样的，在焦仲卿各种不同场合的话语中，也可以感受到他那忠于爱情、明辨是非但又迫于母亲威逼的诚正而软弱、但又有发展的性格。

在整篇诗中，类似上述的动作刻划还有一些，笔墨虽不多，却极精粹。兰芝死时，一无反顾，“揽裙脱丝履，举身赴清池”；仲卿死时，顾念老母，“徘徊庭树下，自挂东南枝”，这些不同的动作细节，都切合各自的性格与处境。同样是母亲，焦母“捶床便大怒”的泼辣，刘母见兰芝回家时惊异而“大拊掌”的温和，对性格的描绘来说寥寥几笔已极传神。抒情性穿插较之动作刻划更少，但也是成功之笔“举手长劳劳，二情同依依”，兰芝和仲卿第一次分手时，作者情不自禁的感叹，增添了悲剧气氛。“生人作死别，恨恨那可论”，这画龙点睛的穿插，更激起了人们对焦、刘遭遇的同情。即使那教训式的全诗结尾，也带有浓重的抒情意味，充满了作者的同情与期望。

Related posts:

1. 钗头凤

对于斐波那契这一类问题，因为特征过于鲜明，可以一看题目就套上，用的联想的思维方式就解决了。不过如果是在不熟悉此类问题时，首先是根据题目估计可用演绎推理来解决，然后尝试 f(1), f(2), f(3) = f(2)+f(1) 之类的推理。 演绎/推理确实是一项十分重要的解题方法，尤其是在对问题领域不熟悉的时候。

延伸阅读：

1. 刘未鹏：知其所以然地学习（以算法为例）

Related posts:

1. 农夫养牛问题

TopLanguage 上我的发言：我的发言是8次，应该是正确的，但是还没有找出数学上的理由。

TopLanguage上一个较早的讨论：这个讨论是相对比较意义的，有人说：

其实这个就是kth smallest element的算法，MIT 的 Introduction to Algorithms 里有详细的分析。

参见：http://videolectures.net/mit6046jf05_demaine_lec06/

还有人说：

这个问题应该是磁盘排序的问题的变种吧    在不能计时的情况下   我觉得n * n 匹马 m 条跑道起码需要 

两个Blog文章：http://fayaa.com/tiku/view/91/  （有篇评论值得研究，说到是8场）

http://blog.solrex.cn/articles/25-horses-problem.html#comment-1738 （我对他的做法做了评论）

Related posts:

1. 算法解题思考过程[总结]

题目来自CSDN论坛里的讨论，很多网友给出了他们的意见。

其实这个问题要求线性时间条件下，通常会让我们想到桶排序；接着关键是考虑怎么减少桶排序中对桶中各数的排序即可想到解决方法。我的算法如下：

1. 主要是先找出最大的数与最小的数，然后构造一个n个桶，桶的下标与数的关系为： index = (v[i]-min)/(max-min/n).
2. 遍历数列，将数值插入到对应的桶中。每个桶最多保留最小和最大的两个元素，不需要多余的数。
3. 遍历所有的桶，记录每个桶之间有多少个空桶到数据flags中，并求出最大连续空桶数 maxGap。
4. 最后遍历flags数组，对于空桶数 >= maxGap -1 的元素，计算从前面的最近的不为空的桶中的大元素与当前桶中的最小元素的差，最终找出最大差。

主算法：

max,min ← GetMaxAndMin (v)
 
bucks[n];
 
for i = 0 to n-1
     buckNo ← get buck no:  (v[i]-min) / (max-min/n)  //计算桶下标（如果不为整数，取较小的数的绝对值）
     if buck[ buckNo ] is empty: insert v[i]
     if buck[buckNo].length == 1 : //insert v[i] 与原来的数构成正序关系
     if buck[buckNo].length == 2 : //与原来的2元素按正序关系排列，去掉中间的数，仍然是2个元素
 
// 标记每个不为空的桶元素之前有多少个空桶
flags[n]; //记录每个桶之前的空桶数目
maxgaps = 0;
tempgaps = 0;
for i ← FindFirstNotEmptyBuck (bucks) to n-1
         if buck[i] is empty then
              tempgaps ++
         else
             flags[i] ← tempgaps;
             maxgaps ← GetMax (tempgaps, maxgaps)
             tempgaps = 0;
// 计算最大的相邻的最大值
maxNeighbor == null;
for i ← 0 to n-1
    if maxgaps - flag[i] < 2 then
       maxNeighbor ← GetMax(COMPUTE_MAX(bucks,i,flag[i]), maxNeighbor)
return maxNeighbor

COMPUTE_MAX(bucks,i,gap) :
    //常数级别，取头或取尾
    return GetMinEle(bucks, i) - getMaxEle(bucks, i - gap -1)
<pre lang="c">GetMaxAndMin (v):
max, min, i
n ← v.length
if n%2 == 0 then
     if V[1] &gt; V[0] then
          max ← V[1]; min ← V[0];
     else
          max ← V[0]; min ← V[1];
     i = 2;
else
     max = min = V[0];
     i = 1;
 
for i to n-2
    if v[i+1] &gt; v[i] then
        min ←GetMin(min, v[i]);
        max ← GetMax(max, v[i+1])
   else
        min ←GetMin(min, v[i+1]);
        max ← GetMax(max, v[i])
   i++; //每次取两个数
 
return (max,min)

FindFirstNotEmptyBuck (bucks)
for i ← 0 to n-1
     if tempgapstart == -1 then
         if buck[i] is empty then
             break
         else
              continue;
return i;

Related posts:

1. 动态规划练习（一）: 求数列中连续数字之和的最大值

问题： 一个农夫养了一头牛，三年后，这头牛每年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢？

这个问题的数学模型是类似于斐波那契（Fibonacci）数列，其计算式为：

F(n) = 1 , n<3

或

F(n) = F(n-3) + F(n-1) , n >=3

十年后是28头牛。实现算法时该贴提到了两种实现方式，一种是用过程的方法实现该数列，另一种是面向对象的方法实现。第二种方法确实更好一些，但是原帖实现似乎并不理想。

Related posts:

1. 算法解题思考过程[总结]

2009年9月28日，阿里巴巴收购了万网。

这两则消息的背后的秘密，不言而喻，都是为了布局云计算，没有其他秘密。

SpringSource是一家从事企业应用服务基础技术服务的公司，其 Spring Framework 在全世界Java EE应用中举足轻重,其 Spring DM Server 是一款模块化Java EE应用服务器。Vmware的这笔收购，目的是为了整合SpringSource 在企业服务方面的资源，结合自己在 IAAS方面的优势，组建PAAS云计算服务平台。

万网是中国内地一家领先的互联网应用服务提供商，在主机服务、域名服务方面具有强大优势。其在互联网基础设施方面的市场和技术实力都是阿里巴巴布局云计算所急需的。 阿里巴巴在2009年9月9日刚刚宣布成立一家新的子公司——阿里巴巴云计算子公司。阿里巴巴在云计算方面的工作开始正式启航。阿里巴巴是迄今为止中国内地第一家真正进入云计算行业的公司。

No related posts.

How to build another simple, strong, easy to control by user himself/herself, no money-accquired function and cheap system to give another choice? As my imagine,

1st, Openness. Everyone can build new function for himself and who likes the function. Users build the system by themselves.
2nd, Users make decision. Everything is controlled by the users community. Even if whether the project should continue or stop.
3rd, No business goal. The main system may supported by users’ denotation.
4th, Distributed and reliable. Maybe it would like tor, eMule? Most computation is executed on the volunteers’ machine. The center server may serve a index.
5th, Secured and spam-free.

To build that system, the road map may like below:

1st, a few architects build the start-up system and open it to more developers.
2nd, many volunteers compose of a support community, and it broadcast by itself.

It must be the source that everything is controlled by users, made by users.

Related posts:

1. 在 Vista 上安装 Apache 2.2, PHP 5.2.6

给你n个数a[1], a[2], …, a[n]，(0[1]。

这个题目看上去与动态规划很类似，在于其解的特点。设数列的前 n 个数的最大值为 F(n)，则：

证明从略。

代码如下：

package com.feihoo.test;
 
public class MaxSequenceValue {
 
	static int[] nums = { 2, 4, -3, 9, 30, -30, 20, 0, 34, -2, -45, 12, -8, 11 };
 
	public static void main(String[] args) {
		int minLen = 2;
		int maxLen = 4;
 
		int[] m = new int[nums.length];
		m[minLen - 1] = 0;
 
		for (int i = minLen; i < nums.length; i++)
			compute(i, m, minLen, maxLen);
 
		int largest = m[minLen];
		for (int i = minLen + 1; i < nums.length; i++)
			if (largest < m[i])
				largest = m[i];
 
		System.out.println(largest);
	}
 
	private static void compute(int n, int[] m, int minLen, int maxLen) {
		m[n] = m[n - 1];
		for (int len = minLen; len < maxLen && n - len >= 0; len++) {
			int re = nums[n];
			for (int i = n - 1; i > n - len; i--)
				re += nums[i];
			if (m[n] < re)
				m[n] = re;
		}
	}
}

参考：

1. 来源： 动态规划习题

No related posts.

short tmp = 0;
为什么tmp = tmp +1;错误但 tmp ++;却正确.

理解这个问题，先要理解实现计算的基本原理。Java虚拟机是一种进程虚拟机，它负责解释和执行字节码，跟直接运行在硬件上运行汇编指令是有区别的。普通的机器语言可以直接操作寄存器完成计算，寄存器能够表示的最小单位是字节。而Java的计算是基于栈的，并规定其基本操作单位是一个字。字的实际大小是有虚拟机的设计者来决定的，虚拟机规范只是规定一个字长要能够放下一个 byte、short、 int、 char、float等类型。所以byte、short、char的运算都像 int 一样是在以字为单位来计算的，尽管它本身比字还要小。

此时我们不难理解，tmp+1会得到一个int。根据Java的类型语义，可以向上转型，不会自动向下转型。所以 tmp = tmp+1语法错误， 关键在 = 符号这里。那为什么 tmp++就是正确的呢？ 因为++ 只有一个操作数，不涉及转型的问题， 不像 = 符号。简单比对下二者生成的字节码。

	short a = 2;
	a++;

生成的字节码如下，其中的第5行指令执行了自动转型，i2s指定是int类型的数据转换为short类型的数据。

  0:   iconst_2
  1:   istore_1
  2:   iload_1
  3:   iconst_1
  4:   iadd
  5:   i2s
  6:   istore_1
  7:   return

我们在看看 int c = a+b 生成的字节码：

	short a = 2;
	short b = 111;
	int c = a + b;

生成字节码如下：

   0:   iconst_2
   1:   istore_1
   2:   bipush  111 #压栈111
   4:   istore_2
   5:   iload_1  #加载a到栈
   6:   iload_2  #加载b到栈
   7:   iadd  
   8:   istore_3  #将计算结果存到局部变量c中
   9:   return

该文中提到的另一个错误：

short c = a + b

其实是一个原理，尽管a,b,c 都是short， 但是 a+b 实际上得到了是int， 于是不能自动转型为 short 给 c。

No related posts.

当我们执行下面的代码时，线程会抛出异常java.lang.IllegalMonitorStateException: current thread not owner。

public class WaitNotifyCompilerCode {
	private String aString = "Hello World!";
 
	public static void main(String[] args) {
		System.out.println("Execute start ....");
		final WaitNotifyCompilerCode w = new WaitNotifyCompilerCode();
		w.wait1SecAndPrintString();
		System.out.println("Execute end ....");
	}
 
	public void wait1SecAndPrintString() {
		try {
			this.wait(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(aString);
	}
 
}

异常栈的信息如下：

Exception in thread "main" java.lang.IllegalMonitorStateException: current thread not owner
	at java.lang.Object.wait(Native Method)
	at com.feihoo.test.waitnotify.WaitNotifyCompilerCode.wait1SecAndPrintString(WaitNotifyCompilerCode.java:35)
	at com.feihoo.test.waitnotify.WaitNotifyCompilerCode.main(WaitNotifyCompilerCode.java:27)

深入查看 OpenJDK的源码，找到 Object.wait() 函数本地代码：

JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
  JVMWrapper("JVM_MonitorWait");
  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
  assert(obj->is_instance() || obj->is_array(), "JVM_MonitorWait must apply to an object");
  JavaThreadInObjectWaitState jtiows(thread, ms != 0);
  if (JvmtiExport::should_post_monitor_wait()) {
    JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms);
  }
  ObjectSynchronizer::wait(obj, ms, CHECK);
JVM_END

重点看倒数第二行，调用的函数如下面的代码：

// NOTE: must use heavy weight monitor to handle wait()
void ObjectSynchronizer::wait(Handle obj, jlong millis, TRAPS) {
  if (UseBiasedLocking) {
    BiasedLocking::revoke_and_rebias(obj, false, THREAD);
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
  }
  if (millis < 0) {
    TEVENT (wait - throw IAX) ;
    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
  }
  ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj());
  DTRACE_MONITOR_WAIT_PROBE(monitor, obj(), THREAD, millis);
  monitor->wait(millis, true, THREAD);

而上面的代码中最后一行的函数里，在做实际操作之前调用了下面的宏：

// A macro is used below because there may already be a pending
// exception which should not abort the execution of the routines
// which use this (which is why we don't put this into check_slow and
// call it with a CHECK argument).
 
#define CHECK_OWNER()                                                             \
  do {                                                                            \
    if (THREAD != _owner) {                                                       \
      if (THREAD->is_lock_owned((address) _owner)) {                              \
        _owner = THREAD ;  /* Convert from basiclock addr to Thread addr */       \
        _recursions = 0;                                                          \
        OwnerIsThread = 1 ;                                                       \
      } else {                                                                    \
        TEVENT (Throw IMSX) ;                                                     \
        THROW(vmSymbols::java_lang_IllegalMonitorStateException());               \
      }                                                                           \
    }                                                                             \
  } while (false)

Related posts:

1. 动态规划练习（一）: 求数列中连续数字之和的最大值
2. Java中的Volatile关键字
3. 文件锁与进程互斥

In general, reliability (systemic def.) is the ability of a person or system to perform and maintain its functions in routine circumstances, as well as hostile or unexpected circumstances.

The IEEE defines it as “. . . the ability of a system or component to perform its required functions under stated conditions for a specified period of time.”

On the page, it also tells:

Reliability may refer to:
Data reliability, a property of some disk arrays in computer storage

Availability, according to Wikipedia:

In telecommunications and reliability theory, the term availability has the following meanings:

1. The degree to which a system, subsystem, or equipment is operable and in a committable state at the start of a mission, when the mission is called for at an unknown, i.e., a random, time. Simply put, availability is the proportion of time a system is in a functioning condition.

Note 1: The conditions determining operability and committability must be specified.

Note 2: Expressed mathematically, availability is 1 minus the unavailability.

2. The ratio of (a) the total time a functional unit is capable of being used during a given interval to (b) the length of the interval.

Note 1: An example of availability is 100/168 if the unit is capable of being used for 100 hours in a week.

Note 2: Typical availability objectives are specified either in decimal fractions, such as 0.9998, or sometimes in a logarithmic unit called nines, which corresponds roughly to a number of nines following the decimal point, such as “five nines” for 0.99999 reliability.

There is another page about High Avaliability on Wikipedia:

High availability is a system design protocol and associated implementation that ensures a certain degree of operational continuity during a given measurement period.

Users want their systems, for example wrist watches, hospitals, airplanes or computers, to be ready to serve them at all times. Availability refers to the ability of the user community to access the system, whether to submit new work, update or alter existing work, or collect the results of previous work. If a user cannot access the system, it is said to be unavailable. Generally, the term downtime is used to refer to periods when a system is unavailable.

Scalability, according to Wikipedia:

In telecommunications and software engineering, scalability is a desirable property of a system, a network, or a process, which indicates its ability to either handle growing amounts of work in a graceful manner or to be readily enlarged.

Methods of adding more resources for a particular application fall into two broad categories: Scale Up (Vertically) and Scale Out (Horizontally). Scale Out could be the better choices in many larger situations.

References:

1. System Reliability and Availability
2. Reliability and Availability Basics

Related posts:

1. 设计与开发的五条原则

1. “开-闭”原则（Open-Closed Principle，或者OCP）：Software entities should be open for extension,but closed for modification.
2. 里氏代换原则（Liskov Subsitution Principle，或者LSP）    任何基类出现的地方，子类一定可以出现。
3. 依赖倒转原则（Dependency Inversion Principle，或者DIP）    要依赖于抽象，不要依赖于实现。
4. 接口隔离原则（Interface Segregation Principle，或者ISP）    应当为客户端提供尽可能小的单独的接口，而不要提供大的总接口。
5. 组合/聚合复用原则（Composition/Aggregation Principle，或者CARP）    要尽量使用合成/聚合，而不是继承关系达到复用的目的。
6. 迪米特法则（Law of Demeter，或者LoD）    一个软件实体应当与尽可能少的其他实体发生相互作用。
7. 单一职责原则（Single Responsibility Principle，或者SRP）  要使每一个软件实体只负责一种职责的实现。

Related posts:

1. Flex中的对象比较（相等性）

<2009-5-14 下午05时29分20秒 CST> <Warning> <Deployer> <BEA-149004> <Failures were detected while initiating Deploy task for application receive.>
<2009-5-14 下午05时29分20秒 CST> <Error> <Deployer> <BEA-149201> <Failed to complete the deployment task with ID 0 for the application receive.
weblogic.management.ApplicationException:
Exception:weblogic.management.ApplicationException: prepare failed for receive
Module: receive Error: Could not load receive: java.lang.StringIndexOutOfBoundsException: String index out of range: -1
 
at weblogic.management.deploy.slave.SlaveDeployer$ActivateTask.createContainer(SlaveDeployer.java:2398)
at weblogic.management.deploy.slave.SlaveDeployer$ActivateTask.prepare(SlaveDeployer.java:2310)
at weblogic.management.deploy.slave.SlaveDeployer.processPrepareTask(SlaveDeployer.java:866)
at weblogic.management.deploy.slave.SlaveDeployer.prepareDelta(SlaveDeployer.java:594)
at weblogic.management.deploy.slave.SlaveDeployer.prepareUpdate(SlaveDeployer.java:508)
at weblogic.drs.internal.SlaveCallbackHandler$1.execute(SlaveCallbackHandler.java:25)
at weblogic.kernel.ExecuteThread.execute(ExecuteThread.java:219)
at weblogic.kernel.ExecuteThread.run(ExecuteThread.java:178)
--------------- nested within: ------------------
weblogic.management.ManagementException:  - with nested exception:
[weblogic.management.ApplicationException:
Exception:weblogic.management.ApplicationException: prepare failed for receive
Module: receive Error: Could not load receive: java.lang.StringIndexOutOfBoundsException: String index out of range: -1
]
at weblogic.management.deploy.slave.SlaveDeployer$ActivateTask.prepare(SlaveDeployer.java:2327)
at weblogic.management.deploy.slave.SlaveDeployer.processPrepareTask(SlaveDeployer.java:866)
at weblogic.management.deploy.slave.SlaveDeployer.prepareDelta(SlaveDeployer.java:594)
at weblogic.management.deploy.slave.SlaveDeployer.prepareUpdate(SlaveDeployer.java:508)
at weblogic.drs.internal.SlaveCallbackHandler$1.execute(SlaveCallbackHandler.java:25)
at weblogic.kernel.ExecuteThread.execute(ExecuteThread.java:219)
at weblogic.kernel.ExecuteThread.run(ExecuteThread.java:178)

错误原因是Spring 2.5.5 与Weblogic 81之间不兼容造成的。
详细看这里

Doc: Deployment error on Weblogic 8.1 SP1/SP2 due to manifest issues – upgrade to SP6 required

Related posts:

1. 在 Vista 上安装 Apache 2.2, PHP 5.2.6
2. 细节背后：为什么线程协作之前必须先获得锁?
3. Ubuntu 上安装buildix，PHP5， Apache2

Some best resource about vim usage:

• Bram Moolenaar:Seven habits of effective text editing: Good guide not just for vim usage. Some tips are copied from this.

General tips

• Ctrl-N: auto completion
• Position the cursor on the name of the function in your file and type [I: Vim will show a list of all matches for the function name in included files.

Search & Replace

这里有篇介绍文章：VIM下,在文件及目录中查找字符串的方法 。例如： vimgrep /登录/g **/*.html

查找的结果会显示在 QuickList 列表中。对于Quicklist 的操纵，参考下面的文章 打造自己的VIM: QuickFix 編譯視窗 。 这篇文章还介绍了打造快捷键，因为我的Vim使用的版本比较多，而且直接切换到Qucik List然后使用行移动也很方便的，所以就不配置这些快捷键。 更详细的参考见官方手册 Quickfix 或者 :help quickfix

替换 

可以在 vim 中查看帮助 :help argdo

示例：

:args **/*.htm

:argdo %s/旧/新/ge  |  update

Move around quickly

• Use % to jump from an open brace to its matching closing brace. Or from a "#if" to the matching "#endif". Actually, % can jump to many different matching items. It is very useful to check if () and {} constructs are balanced properly.
• Use [{ to jump back to the "{" at the start of the current code block.
• Use gd to jump from the use of a variable to its local declaration.
• * command to search for other places
• CTRL-], CTRL-t with ctags/cscope

整页翻页 ctrl-f ctrl-b
f就是forword b就是backward

翻半页
ctrl-d ctlr-u
d=down u=up

滚一行
ctrl-e ctrl-y

zz 让光标所杂的行居屏幕中央
zt 让光标所杂的行居屏幕最上一行 t=top
zb 让光标所杂的行居屏幕最下一行 b=bottom

Highlight and increment search set:
set hls is

Block Operation (Delete a column):

• start mode with Ctrl-v
• specify a motion, e.g. G (to the end of the file), or use up / down keys
• for the selected block specify an action, e.g. ‘d’ for delete

Split Window

set splitright “put the new split window in the right)

(some content cited from The Vim/Cscope tutorial)

• move between windows via ‘CTRL-W w’ (or CTRL-W arrow key, or CTRL-W h/j/k/l for left/up/down/right),
• close a window via ‘CTRL-W c’ (or good old ‘:q’),
• make the current window the only one via ‘CTRL-W o’,
• split a window into two via ‘CTRL-W s’ (or ‘CTRL-W v’ for a vertical split),
• open a file in a new window via ‘:spl[it] filename’,
• close a window ‘CTRL-W c’

cscope & ctags

The most completed tutorial I got from Internet:
The Vim/Cscope tutorial

We can use ctags to navigate the java code by placing the cursor on a class or method and hitting CTRL-]. To jump back and forwards just use CTRL-O and CTRL-I. Type :jumps command to view the jump lists.

Cscope also can works well with other languages likes Java and C++. All we need to do is explicit specify the special file lists in the cscope.files or the command line.

Related posts:

1. My Vimrc File
2. Linux Command & Shell Tips (1)
3. My Ubuntu Installation log

1. The problem of ftp url:
在写一个自动备份的脚本时发现，如果 username 中有 @ 符号时，使用 curl ftp://username:password@host/file 是不行的。这可能是 ftp url 地址格式的一个瑕疵。具体参考 Google Group上的一个讨论 （对于该讨论的正确性本人没有特别考证， 根据作者的观点，在整个URL中出现 “:”、”/”、”@” 都是不可行的。如果您发现此论断有问题请留言）。 还好 curl 可以使用 -n 指定使用 ~/.netrc 中的登录标识。

2. 直接使用 sed 命令批量替换文件中的内容

sed -i 's/\/var\/svn/d:\/data\/svn/g' `grep /var/svn -rl ./*/conf/trac.ini`

sed 命令还有很多用法，可惜平时用得不多，经常忘记了要查资料。

3. 使用 find 命令批量操作 Trac 项目同步SVN

find -maxdepth 1 -mindepth 1  -type d -print -exec trac-admin {} resync \;

对仅仅处理当前目录下的子目录的限定方法比较笨，也许有更好的方法。

find命令是最难用的，再提供一个统计代码行总数的例子。

$ find stat5.1projects/ ! -path '*.common/*' -a ! -path '*bin*' -a ! -path '*st
at.statuser*' -a \( -name *.java -or -name *.sql -or -name *.xml \) | xargs wc
-l
</pre lang="bash">
然后直接通过Shell计算出平均每天的代码行：
<pre lang="bash">
echo $((8888/22))

4. tar error message.

Removing leading `/’ from member names

It’s really annoying when it present in a crontab script. That is why (refer from here):

what do you want suggestions about? tar archives don’t contain absolute paths, only relative ones. this is correct behaviour, as the alternative is really nasty and illogical. this is the same way that other compression programs like winzip work. when you untar somethign you provide an destination directory, which implicity is ‘/’ in your case… but it should be explicit for logical operation

The resolution is using relative path. e.g.

cd /var/www
tar -cf /home/user/backup/wp-backup.tar web
# NOT below
# cd /home/user/backup
# tar -cf wp-backup.tar /var/www/web

5. svn: Delete unversioned files

svn status --no-ignore | grep '^[I?]' | sed 's/^[I?]//' | xargs rm -rf

Here are more frequent ask questions on subversion.

6. 防火墙后面的git通过代理访问：
设置GIT_PROXY_COMMAND系统变量即可。具体参考：Using Git with a SOCKS proxy

7. Ubuntu添加sudo用户:
Edit file /etc/sudoers, add line:

bob  ALL=(ALL) ALL

参考：http://www.linuxhomenetworking.com/wiki/index.php/Quick_HOWTO_:_Ch09_:_Linux_Users_and_Sudo

8. Unix timestamp 与 readable date 之间的转换：
shell:

date -d @1232144092 #timestamp to date

date –date=’1970-01-01 1000000000 sec GMT’

date -d today +%s #date to stamp

Perl:

date -d today +%s | perl -e 'print localtime(<>)."\n"' # to readable time

gawk:

date -d today +%s | gawk 'END{print strftime("%c",$1)}' # to readable time

9. AWK调用shell命令做一些计算

cat $f | awk '! /^NAI/ {cmd="date +%k%M -d @"$3; cmd | getline d; close(cmd); if (d>2357)print d}'

多行时可循环读取：

cmd_= ("cat "naiIdMappingFile);
while (cmd_ | getline d ) {
        split(d, naiIds," ");
        naiIdMaps[naiIds[1]" "]=naiIds[2];
}
close(cmd_)

其中要提醒一下的是，一定要记得 close() 的调用，不然很快会耗光文件描述符。

10. Perl 跟bash脚本配合，逐行对文件执行某些操作：

cat $f | perl -ane '$F[1] =~ s/\D+(\d+)\D+(\d+)\D+(\d+)/$1 $2/g; @cols = split(" ",$F[1]); $F[2] =~ s/\D+(\d+)\D+(\d+)\D+(\d+)/$3/g;print " @F ". scalar($F[2]-$cols[1]) ." \n";';

Related posts:

1. JDBC和Ibatis中的Date,Time,Timestamp处理

阅读和背诵无法使你学会英文思维，只有创造和使用才能学会！

华尔街的作业好多。有的作业难度也不小。 我最重要的是完成 Student Manual，尤其是 Listen exercise 。

No related posts.

下面是我从Flex的参考手册中找出来的一些东西。

Equality operators

The equality operators take two operands, compare their values, and return a Boolean value. All the equality operators, as listed in the following table, have equal precedence:

The IUID interface defines the interface for objects that must have Unique Identifiers (UIDs) to uniquely identify the object. UIDs do not need to be universally unique for most uses in Flex. One exception is for messages send by data services.

Data providers and the uid property

Flex data provider controls use a unique identifier (UID) to track data items. Flex can automatically create and manage UIDs. However, there are circumstances when you must supply your own uid property by implementing the IUID interface, and there are circumstances when supplying your own uid property improves processing efficiency.

Because the Object and Array classes are dynamic, you normally do not do anything special for data objects whose items belong to these classes. However, you should consider implementing the IUID if your data object items belong to custom classes that you define.

Note: When Flex creates a UID for an object, such as an item in an ArrayCollection, it adds the UID as an mx_internal_uid property of the item. Flex creates mx_internal_uid properties for any objects that are dynamic and do not have bindable properties. To avoid having Flex create mx_internal_uid properties, the object class should do any of the following things: have at least one property with a [Bindable] metadata tag; implement the IUID interface; or have a uid property with a value.

If Flex must consider two or more different objects to be identical, the objects must implement the IUID interface so that you can assign the same uid value to multiple objects. A typical case where you must implement the IUID interface is an application that uses paged collections. As the cursor moves through the collection, a particular item might be pulled down from the server and released from memory repeatedly. Every time the item is pulled into memory, a new object is created to represent the item. If you need to compare items for equality, Flex should consider all objects that represent the same item to be the same “thing.”

More common than the case where you must implement the IUID interface is the case where you can improve processing efficiency by doing so. As a general rule, you do not implement the IUID interface if the data provider elements are members of dynamic classes. Flex can automatically create a uid property for these classes. There is still some inefficiency, however, so you might consider implementing the IUID interface if processing efficiency is particularly important.

In all other cases, Flex uses the Dictionary mechanism to manage the uid, which might not be as efficient as supplying your own UID.

Related posts:

1. 导出Memcached中的全部数据
2. JDBC和Ibatis中的Date,Time,Timestamp处理
3. 解决Java序列化的版本冲突

和同事在一起吃晚饭的时候，聊起了公司里的加班现象。该同事是刚到公司三个月，他说自从来了以后，每天如果能够在七点下班那就要高兴不已。在这短短的时间里，明显的感觉到身体有了一些的变化，感受到身体上的损害和痛苦。基本上，每天都是紧张的去做事，但还是做不完，还是要加班。不仅工作日的晚上要加班，连周末也经常不得不去公司–如果想正常完成各项工作的话。

除了加不完的班，另外就是经常有突发性的任务忽然需要去处理。他说有一天六点多，要下班的时候，忽然PM告知他明天要去演示，要求他立即搭建演示环境，因为他明天要去见客户，要给客户演示。这下，搞得他不得不忙到很晚，快十一点时，拖着疲惫的身体回家。这样的事情，真的不少。

仔细观察我们公司的加班文化，发现同是在一个公司的研发部门，有的组加班相对要少一些，有的组加班相对要多一些。第一个原因，我想可能跟领导的风格有关系。有的部门领导自己是个工作狂，所以开发计划也比较紧密。有点部门领导比较重视生活点，正常平衡工作与生活，所以相对来说员工也会轻松一些。第二个原因，可能确实是不同的组，其任务量、效率都有不同。任务较重或者效率较低的组自然要加班了。

加班文化的重要原因肯定跟项目经理有关。人都是需要生活的，不只是需要工作。如果长期工作，而忽视了生活，员工怎么能够在公司里愉快的工作呢？ 不能愉快的工作，对公司有怨言（即使嘴上不说） ，怎么能够好好的工作呢？怎么心甘情愿地做忠诚负责的员工呢？ 我想有能力的员工，又想要平衡好生活与工作的关系的员工，肯定会对领导的强制或者是项目计划的强制产生内心的逆反（即使没有强烈到激化冲突），并进而去选择一个更好的工作环境。所以，我觉得好的项目经理的一项重要素质就是在重视工作的同时，也应该努力帮助员工愉快地工作。

然而，话说回来，项目经理也有自己的难处。

需求多变就是一个关键的难题，但是解决这个问题的方法，有时候也不是项目经理就能够解决的。不过我建议项目经理不应该因为需求多变就把这种多变的需求直接传导到员工头上去。这样，无非是多让员工做一些无意义的事情，最终带来项目成本的增加，还要求员工付出身心牺牲，最终却没有任何意义。管理和控制需求作为降低项目成本提高项目收益的重要内容，我觉得是项目经理的重要工作之一，绝对不应该因为客户比较刁蛮就丢弃了这部分工作内容。

工作过多而资源紧缺也是一个常见的问题。因此经常导致了在制定计划时不能够客观。有的情况下是忽略了一些在计划中需要处理的潜在工作，有的情况下是尽最大限度地去缩减对任务的资源支出。无论哪种方式，这个计划都没有尽可能地去贴近实际情况，这个项目计划的执行过程怎么能够不出问题呢？项目的计划怎么能够执行呢？掩耳盗铃的方式，并不可取。我觉得正确的方法，应该是制定计划时定时不过多超额定量，或者争取更多的资源。

突发事件是项目经理的另一个要经常面对的难题。例如上问提到的忽然要求搭建演示环境的事情。这完全是在项目经理的工作表里面没有的事情，忽然跑出来，如无必要那徒然疲劳下属。 如果当这项工作确实是需要的，那么项目经理应该要提前通知，让手下有所准备，或者确实处于突然，则应该给一定的时间，这样做出来的东西也有保证。如果感觉这项工作内容较多，需要手下去突击完成，从而采取这种突发事件让手下加班的方法，那更不应该。如果确实内容较多，那么要考虑下是不是值得去做这些任务，是不是可以将这项内容适当删减。即使让手下是加班时间突击完成了这件事情，但这些确实已经是项目中的成本。员工的加班尽管不付钱，但是确实是项目成本。员工付出了时间和健康。尽管PM没有付钱，但是却一定付出了威信和下属的信任。项目经理应该努力让所有的事情都是可控的，对于不可控的事情，也要努力去削弱项目中突发事件的影响。

做一个好的项目经理，要尊重、爱惜自己的手下。 在某一个项目里，PM最需要负责的也许不是手下，但是在很多项目构成的长期工作中，PM最需要负责的正是手下的员工。没有他们，PM什么都成不了。

No related posts.

Apache 2.2  下载完后安装，倒是很顺利，最后 http://localhost, 显示 It works.

一开始，打算以 Module 形式安装 PHP，安装后显示 缺少不少库，并且不能显示 phpinfo.php。

于是改成以 CGI 形式重新安装，配置如下：
ScriptAlias /php/ "D:/software/PHP/"
AddType application/x-httpd-php .php
# For PHP 5
Action application/x-httpd-php "/php/php-cgi.exe"


打开网址，什么也访问不了：
You don’t have permission to access / on this server.
通过如下设置解决：
DocumentRoot “D:/programdata/Apachehtdocs”

Options FollowSymLinks
AllowOverride All
Order Allow,Deny
Allow from all
Satisfy all

然后就一直显示：
You don’t have permission to access /php/php-cgi.exe/phpinfo.php on this server.
在后台 error.log:
[error] [client 127.0.0.1] client denied by server configuration: D:/software/PHP/php-cgi.exe

最后，增加如下设置，解决了问题：

Options Indexes FollowSymLinks
AllowOverride None
Order allow,deny
Allow from all

解决了问题。但是，后台又出现了一个问题：
[Sun Oct 12 22:36:57 2008] [error] [client 127.0.0.1] PHP Fatal error: require_once() [function.require]: Failed opening required ‘SAM/php_sam.php’ (include_path=’.;C:\\php5\\pear’) in sam_factory on line 1

这个问题的解决，参考 [RESOLVED] PHP Install Problem – SAM Error   我只是简单地安装PHP时，只选择 MySQL扩展。

Related posts:

1. Ubuntu 上安装buildix，PHP5， Apache2
2. Google Apache modpagespeed 测试
3. Weblogic 81Sp3

如果选择继续，安装了php5和libapache2-mod-php5，则会导致buildix卸载，如果重新安装 buildix，安装过程中会出现下面的错误，原因大概是libapache-mod-php5被buildix自动卸载了。

liuzhr@suowan-master:/etc/apache2/sites-enabled$ sudo /etc/init.d/apache2 restart
* Restarting web server apache2
* We failed to correctly shutdown apache, so we're now killing all running apache processes. This is almost certainly suboptimal, so please make sure your system is working as you'd expect now!
apache2: Syntax error on line 183 of /etc/apache2/apache2.conf: Syntax error on line 1 of /etc/apache2/mods-enabled/php5.load: Cannot load /usr/lib/apache2/modules/libphp5.so into server: /usr/lib/apache2/modules/libphp5.so: cannot open shared object file: No such file or directory。


原因应该是 buildix 依赖于  apache2-mpm-worker, 而目前的 php5只能运行单线程的apache2，这样就必须使用  apache2-mpm-prefork。
使用  apt-cache show buildix 一看，果然buildix依赖于 apache2-mpm-worker。看来必须放弃将 buildix与目前的 php5(Module方式) 在一起安装的方法。

于是只能选择使用 cgi 的方式来安装。参考这篇文章：Installing Apache2 and PHP5 using mod_fcgid 。配置的过程中发生了一些错误（you don’t have permission to access ‘/index.php’），似乎是因为下面的配置中，AllowOverride ，FCGIWrapper ，AddHandler 或者 Options +ExecCGI 的顺序导致的。没有时间仔细研究这个问题，高手看到请指教。

<directory>
Options Indexes FollowSymLinks MultiViews
AllowOverride All
FCGIWrapper /usr/lib/cgi-bin/php5 .php
AddHandler fcgid-script .php
Options +ExecCGI
Order allow,deny
allow from all
# This directive allows us to have apache2's default start page
# in /apache2-default/, but still have / go to the right place
#RedirectMatch ^/$ /apache2-default/
</directory>


php5 目前不能使用 apache2-mpm-worker 模块是因为不支持多线程的apache2。 PHP如此说：Why shouldn’t I use Apache2 with a threaded MPM in a production environment? 

有关 apt-get 的命令，参考这里：https://help.ubuntu.com/community/AptGet/Howto

有关 Ubuntu上的LAMP，参考：ApacheMySQLPHP

Related posts:

1. 在 Vista 上安装 Apache 2.2, PHP 5.2.6
2. My Ubuntu Installation log
3. Google Apache modpagespeed 测试

select sum(a) from test_table order by b desc limit 1,2

这个句子，在MySQL 和 Sqlite3下，如此 sum得到的是 Empty Set

而 select sum(a) from test_table order by b desc limit 0,2 则返回全部记录的a字段的合计，limit不起作用。

但是去掉sum函数的话， select a from test_table order by b desc limit 1,2 能够选择出需要的行。

为什么？ 来自 MySQL 官方站点论坛的解释：

The LIMIT clause affects only the number of rows returned, and this query in fact only returns one row. You might want to try something like this:

SELECT sum(quantity)
FROM (SELECT quantity
FROM stock_card
LIMIT 0,2
) AS subquery;

Related posts:

1. [译] Orx教程：0.Basic
2. 算法解题思考过程[总结]
3. Vim 快捷键

我回复道：

我早算过了，如果不能把爸爸妈妈接到北京来，我基本上一年见父母一次吧。就像我爸爸说的，他由于打工待遇微薄，春节时人潮太多，工厂放假又少，以前一般要两年才能回家见爷爷一次。现在爷爷八十多了，还是只能一年见一次。想起这些怎么不心里戚戚然。
啊，咱们公司的年假，是最好的一项福利待遇了。我喜欢。

原文如下：

近日，一些网友在一起聊自己的父母。有网友表示：以前总觉得孝敬爸妈的机会还很多，可仔细一算，爸妈能再活二十年，我每年平均回去一两次，跟他们在一起最多就30来次；假若他们只能再活十年，跟他们见面的机会就只有十多次了。

我们曾经对网上的“晒客”们有过非议，认为他们很无聊。“晒工资”自己的工资也涨不了，“晒隐私”你没有那些明星多。可当我看到“父母年迈我们还能见多少面”的帖子时，竟然被深深地打动了。

这是一个令人感到心酸的话题。“父母年迈我们还能见多少面”就像是一根针插进我们感情的胸口，触动我们那麻木的神经，每个人都会感到沉重和自 责。当我们用“多少”这个词儿来标注与父母见面的次数时，才发现这份感情原来是那么的宝贵，而我们却无情的挥霍。“多少”不是多而是少，我们与父母见面的 次数实在是太少了。

面对年迈的父母，我们或许还没有来得及去想这样一个沉重的话题。因为我们一直以为自己还是个孩子。我们的内心深处是不希望父母老去的，希望他们永远年轻，而人生百年又有谁能避免呢？

曾几何时，我们自以为自己已经长大，不再需要父母的呵护；曾几何时，我们厌倦了父母的唠叨，听不进老人的规劝；曾几何时，我们来去匆匆，把家 当作了客栈。而只有当我们静下心来，认真地思考“我们还能见年迈的父母多少面”这样的问题时，才发现自己依然是年幼无知。虽然我们已然是别人的父亲或母 亲。

古代说“父母在，不远游。”可现代社会又有几人能与父母长相厮守，床前尽孝呢？对于在远方的游子，一年也许就有在春节时，才能回家见上父母一 面。即使生活在一个城市，真正与父母在一起的时间又有多少呢？我们嘴上喊着“忙，没时间，加班……”，可宁愿在家上网聊天，出门与朋友喝酒。我们有几个人 还记得父母的生日，会记得上次回家是几月几号，我们多久没和父母聊天了？而还有一些自诩为“月光一族”的朋友，竟然还跟年迈的父母伸手要钱。

不要责怪这位网友的残酷，他用自己的冷静告诉了我们这样一个现实的问题。珍惜和父母在一起的时间吧，不要嫌弃父母的唠叨，多同他们聊聊天；不要嫌弃父母的土气，常回家看看；不要忘了父母的养育，让他们有一个祥和的晚年。

与那些“晒工资”、“晒隐私”、“晒家庭”的晒客相比，我们真应该为这位网友叫好，因为他教会了我们如何珍惜，如何不丢弃孝敬老人这样的传统美德。

No related posts.

今天参加了Sun的2007北京科技日。这是我第一次参加类似的会议，感觉很有意思。

No related posts.