http://clojure.org/vars

变量和全局环境

Clojure是个很实用的语言，偶尔需要将维护和改变数据的值。她提供了4种不同的方式来操作变量：Vars, Refs, Agents, 和Atoms。Vars机制是是指向一个可改变的数据的位置，你可以为每个线程动态的绑定（制定一个新的存储位置）一个新值。Vars可以初始化根绑定(不是必须的)，绑定的值对于所有线程都是共享的，但却别的线程就不能重新绑定。因此，要么Var可以为每个线程绑定值，要么使用根绑定。

下面的special form def 创建了一个Var，如果Var不存在和没有给初始化，var就是不绑定的（不允许创建非动态的Var，必须显式指定根绑定）：

user=> (def x)
#'user/x
user=> x
java.lang.IllegalStateException: Var user/x is unbound.

为根值初始化（如果存在，就被再次绑定）

user=> (def x 1)
#'user/x
user=> x
1
 

默认情况下(定义的时候初始化了根绑定），Vars是静态的(static)，但是，建立动态Var的定义可以通过元数据标记的方式，然后在线程用时通过binding来指定。

user=> (def ^:dynamic x 1)

user=> (def ^:dynamic y 1)

user=> (+ x y)

2

user=> (binding [x 2 y 3]

         (+ x y))

5

user=> (+ x y)

2

binding被创建后其他线程是是不可见的。创建的binding可以被赋值，也就是在没有离开调用堆栈之前可以被上下文访问。可以在一块代码之前设置matadata标签:dynamic来指定:

user=> (def ^:dynamic x 1)

#'user/x

user=> (meta #'x)

{:ns #<Namespace user>, :name x, :dynamic true, :line 30, :file "NO_SOURCE_PATH"}

user=> (binding [x 2] (println x))

2

nil

user=> x

1

user=>

如果你想让函数编译为static的，并且指定返回值，可以看下面的例子(速度提升不少，关键的调用函数可以采用这种方式加速)：

 (defn fib [n]   (if (<= n 1)

    1

    (+ (fib (dec n)) (fib (- n 2)))))

#'user/fib

 (defn ^:static fib2 ^long [^long n]

  (if (<= n 1)

    1

    (+ (fib2 (dec n)) (fib2 (- n 2)))))

#'user/fib2

user=> (time (fib 38))

"Elapsed time: 1831.113 msecs"

63245986

user=> (time (fib2 38))

"Elapsed time: 328.715 msecs"

63245986

user=> (meta (var fib))

{:arglists ([n]), :ns #<Namespace user>, :name fib, :line 1, :file "NO_SOURCE_PATH"}

user=> (meta (var fib2))

{:arglists ([n]), :ns #<Namespace user>, :name fib2, :static true, :line 4, :file "NO_SOURCE_PATH"}

user=>

在上下文中可能需要重定义静态变量，从Clojure1.3开始提供with-redefs和with-redefs-fn这两个宏来修改。

定义函数的defn也是Vars的存储方式，也可以在运行时被重定义。这也为aop编程带来很多方便，例如：你可以封装一个类似logging函数给调用的上下文或者或者线程。

(set! var-symbol expr)

将Vars指定为special form

当地一个操作符为symbol的时候，它必须是全局变量。当前线程绑定的值就是后面的expr，也就是说必须是Thread-local的才可以，否则将会抛出一个使用set!来设定根绑定变量的错误。变量的表达式expr必须有返回值。

注意，你不能赋值给一个函数的参数或者本地绑定，只能是java的字段Vars Refs和Agents，因为这些数据在Clojure里可不变的。

使用set为java字段设置值，可以查看 Java Interop.

Interning

命名空间维护了每个Var对象的全局符号映射。如果使用def定义变量没有在当前的命名空间找到该符号，就创建一个，否则使用现有的。创建或者寻找的过程被称作interning。这就意味着，除非Var对象取消映射，否则Var对象每次被查询，所以请在循环中千万不要引用Var的全局变量，否则将非常慢，通过let或者binding让全局变量取消映射来提高速度。命名空间在Evaluation中构建了全局环境，编译器也把所有free symbols当做Vars来解析了。

可以使用阅读宏(Reader)#’来得到Var对象的内部的值。

Non-interned的类型的变量

可以通过with-local-vars来创建non-interned类型的变量，在free symbol解析的时候将不会被发现，这些值只能被手工的访问，但是也可以用作当前线程的变量。

user=> (defn factorial [x]

         (with-local-vars [acc 1, cnt x]

           (while (> @cnt 0)

             (var-set acc (* @acc @cnt))

             (var-set cnt (dec @cnt)))

           @acc))

#'user/factorial

user=> (factorial 7)

5040

有朋友把Java和Clojure的一些代码片段放在Clojure Google group里比较，并提到Java的性能要比Clojure快太多了，疑问到底Clojure能不能赶上Java?

在我的一个开源项目clj-starcraft中，关于java的性能问题，实际上也是我始终面对的，在我写这篇文章的时，我的Clojure代码还是慢了Java代码6倍(Clojure花了70秒解析了1050个文件，Java则只有12秒)

然而，70秒对过去的速度而言不算太糟糕，在刚开始的时候，竟然花了10分钟来分析1050个文件。甚至比我用Python实现的还要慢。

感谢Java的profiler和热情的Clojure朋友，下面列出了我在提升Clojure性能方面的一些tips:

(set! *warn-on-reflection* true)

这恐怕是最重要的一个提升：打开这个设置将会警告你在任何一处用到Java反射API的方法和属性。如你所想，直接调用永远比反射要快，不管哪里Clojure都会你不能解析这个方法，你需要自己用type hint方式来避免反射调用。关于使用type hint，Clojure官方站点给了一个如何使用和提速的例子。

修复所有关于*warn-on-reflection* 的编译警告后，我的clj-starcraft从10分钟降到了3分半。

强制设置数据类型

Clojure可以使用Java的基础数据类型，无论何时在循环的时候，坚决考虑将你的值强制转换成基础类型，这将大幅提高你的性能。基础数据类型在Clojure官方网站有例子和如何进行强制转换来提高性能。

使用二元运算符

Clojure可以在一行里面支持多个表达式，但对于运算操作符，只有在两个的时候才被inlined，如果你发现自己的运算符已经超过了两个，或许该考虑重写你的代码让操作符显示的成为两个。下面请看两者之间的比较：

user> (time (dotimes [_ 1e7] (+ 2 4 5)))

"Elapsed time: 1200.703487 msecs"

user> (time (dotimes [_ 1e7] (+ 2 (+ 4 5))))

"Elapsed time: 241.716554 msecs"

使用==代替=

使用==比较数字来代替=，提升性能那是相当明显：

user> (time (dotimes [i 1e7] (= i i)))

"Elapsed time: 230.797482 msecs"

user> (time (dotimes [i 1e7] (== i i)))

"Elapsed time: 5.143681 msecs"

避免vectors的destructing binding

在一段循环种，如果你想为了提升可读性从vector中传出值，考虑下标访问来代替destructing binding。虽然代码看起来更清晰，但却非常慢。

user> (let [v [1 2 3]]

        (time

         (dotimes [_ 1e7]

           (let [[a b c] v]

             a b c))))

"Elapsed time: 537.239895 msecs"

user> (let [v [1 2 3]]

        (time

         (dotimes [_ 1e7]

           (let [a (v 0)

                 b (v 1)

                 c (v 2)]

             a b c))))

"Elapsed time: 12.072122 msecs"

优先使用本地变量

如果你需要在循环中查询一个值，你或许需要考虑使用本地变量(通过let定义)来代替全局变量。看下两者的时间对比：

user> (time

       (do

         (def x 1)

         (dotimes [_ 1e8]

           x)))

"Elapsed time: 372.373304 msecs"

user> (time

       (let [x 1]

         (dotimes [_ 1e8]

           x)))

"Elapsed time: 3.479041 msecs"

如果你想使用本地变量来提升性能，可以考虑下面比较土的式的方式来避免全局变量：

(let [local-x x]

  (defn my-fn [a b c]

    ...))

使用profiler工具：

JVM有两个profiler工具， -Xprof和-Xrunhprof，找到程序瓶颈而不是瞎猜。

最后说明：

你已经注意到，在这些性能提升中，通过调用百万量的执行来提升了几百毫秒的性能。所以，不到万不得已需要提升性能的时候，没必要让你的代码看起来不够清晰。

原文地址: http://gnuvince.wordpress.com/2009/05/11/clojure-performance-tips/

最后补充：可以通过指定编译为static方法来提高性能：