Clojure
的并发（一） Ref和STM
Clojure
的并发（二）Write Skew分析
Clojure
的并发（三）Atom、缓存和性能
Clojure
的并发（四）Agent深入分析和Actor
Clojure
的并发（五）binding和let
Clojure的并发（六）Agent可以改进的地方
Clojure的并发（七）pmap、pvalues和pcalls
Clojure的并发（八）future、promise和线程
五、binding和let
前面几节已经介绍了Ref、Atom和Agent，其中Ref用于同步协调多个状态变量，Atom只能用于同步独立的状态变量，而Agent则是允许异步的状态更新。这里将介绍下binding，用于线程内的状态的管理。
1、binding和let:
当你使用def定义一个var，并传递一个初始值给它，这个初始值就称为这个var的root binding。这个root binding可以被所有线程共享，例如：
user=> (def foo 1)
#'user/foo
那么对于变量foo来说，1是它的root binding，这个值对于所有线程可见，REPL的主线程可见：
user=> foo
1
启动一个独立线程查看下foo的值：
user=> (.start (Thread. #(println foo)))
nil
1
可以看到，1这个值对于所有线程都是可见的。
但是，利用binding宏可以给var创建一个thread-local级别的binding：
(binding [bindings] & body)
binding的范围是动态的，binding只对于持有它的线程是可见的，直到线程执行超过binding的范围为止，binding对于其他线程是不可见的。
user=> (binding [foo 2] foo)
2
粗看起来，binding和let非常相似，两者的调用方式近乎一致：
user=> (let [foo 2] foo)
2
从一个例子可以看出两者的不同，定义一个print-foo函数，用于打印foo变量：
user=> (defn print-foo [] (println foo))
#'user/print-foo
foo不是从参数传入的，而是直接从当前context寻找的，因此foo需要预先定义。分别通过let和binding来调用print-foo:
user=> (let [foo 2] (print-foo))
1
nil
可以看到，print-foo仍然打印的是初始值1，而不是let绑定的2。如果用binding:
user=> (binding [foo 2] (print-foo))
2
nil
print-foo这时候打印的就是binding绑定的2。这是为什么呢？这是由于let的绑定是静态的，
它并不是改变变量foo的值，而是用一个词法作用域的foo“遮蔽”了外部的foo的值。但是print-foo却是
查找变量foo的值，因此let的绑定对它来说是没有意义的，尝试利用set!去修改let的foo:
user=> (let [foo 2] (set! foo 3))
java.lang.IllegalArgumentException: Invalid assignment target (NO_SOURCE_FILE:12)
Clojure告诉你,let中的foo不是一个有效的赋值目标
，foo是不可变的值。set!可以修改binding的变量：
user=> (binding [foo 2] (set! foo 3) (print-foo))
3
nil
2、Binding的妙用：
Binding可以用于实现类似AOP编程这样的效果，例如我们有个fib函数用于计算阶乘：
user=> (defn fib [n]
(loop [ n n r 1]
(if (= n 1)
r
(recur (dec n) (* n r)))))
然后有个call-fibs函数调用fib函数计算两个数的阶乘之和：
user=> (defn call-fibs [a b]
(+ (fib a) (fib b)))
#'user/call-fibs
user=> (call-fibs 3 3)
12
现在我们有这么个需求，希望使用memoize来加速fib函数，我们不希望修改fib函数，因为这个函数可能其他地方用到，其他地方不需要加速，而我们希望仅仅在调用call-fibs的时候加速下fib的执行，这时候可以利用binding来动态绑定新的fib函数：
user=> (binding [fib (memoize fib)]
(call-fibs 9 10))
3991680
在没有改变fib定义的情况下，只是执行call-fibs的时候动态改变了原fib函数的行为，这不是跟AOP很相似吗？
但是这样做已经让call-fibs这个函数
不再是一个“纯函数”，所谓“纯函数”是指一个函数对于相同的参数输入永远返回相同的结果，但是由于binding可以动态隐式地改变函数的行为，导致相同的参数可能返回不同的结果，例如这里可以将fib绑定为一个返回平方值的函数，那么call-fibs对于相同的参数输入产生的值就改变了，取决于当前的context，这其实是引入了副作用。因此对于binding的这种使用方式要相当慎重。这其实有点类似Ruby中的open class做monkey patch，你可以随时随地地改变对象的行为，但是你要承担相应的后果。
3、binding和let的实现上的区别：
前面已经提到，let其实是词法作用域的对变量的“遮蔽”，它并非重新绑定变量值，而binding则是在变量的root binding之外在线程的ThreadLocal内存储了一个绑定值，
变量值的查找顺序是先查看ThreadLocal有没有值，有的话优先返回，没有则返回root binding。下面将从Clojure源码角度分析。
变量在clojure是存储为Var对象，它的内部包括：
//这是变量的ThreadLocal值存储的地方
static ThreadLocal<Frame> dvals = new ThreadLocal<Frame>(){
protected Frame initialValue(){
return new Frame();
}
};
volatile Object root; //这是root binding
public final Symbol sym; //变量的符号
public final Namespace ns; //变量的namespace
通过def定义一个变量，相当于生成一个Var对象，并将root设置为初始值。
先看下let表达式生成的字节码：
(let [foo 3] foo)
字节码：
public class user$eval__4349 extends clojure/lang/AFunction {
// compiled from: NO_SOURCE_FILE
// debug info: SMAP
eval__4349.java
Clojure
*S Clojure
*F
+ 1 NO_SOURCE_FILE
NO_SOURCE_PATH
*L
0#1,1:0
*E
// access flags 25
public final static Ljava/lang/Object; const__0
// access flags 9
public static <clinit>()V
L0
LINENUMBER 2 L0
ICONST_3
INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
PUTSTATIC user$eval__4349.const__0 : Ljava/lang/Object;
RETURN
MAXSTACK = 0
MAXLOCALS = 0
// access flags 1
public <init>()V
L0
LINENUMBER 2 L0
L1
ALOAD 0
INVOKESPECIAL clojure/lang/AFunction.<init> ()V
L2
RETURN
MAXSTACK = 0
MAXLOCALS = 0
// access flags 1
public invoke()Ljava/lang/Object; throws java/lang/Exception
L0
LINENUMBER 2 L0
GETSTATIC user$eval__4349.const__0 : Ljava/lang/Object;
ASTORE 1
L1
ALOAD 1
L2
LOCALVARIABLE foo Ljava/lang/Object; L1 L2 1
L3
LOCALVARIABLE this Ljava/lang/Object; L0 L3 0
ARETURN
MAXSTACK = 0
MAXLOCALS = 0
}
可以看到foo并没有形成一个Var对象，而仅仅是将3存储为静态变量，最后返回foo的时候，也只是取出静态变量，直接返回，没有涉及到变量的查找。let在编译的时候，将binding作为编译的context静态地编译body的字节码，body中用到的foo编译的时候就确定了，没有任何动态性可言。
再看同样的表达式替换成binding宏，因为binding只能重新绑定已有的变量，所以需要先定义foo:
user=> (def foo 100)
#'user/foo
user=> (binding [foo 3] foo)
binding是一个宏，展开之后等价于：
(let []
(push-thread-bindings (hash-map (var foo) 3))
(try
foo
(finally
(pop-thread-bindings))))
首先是将binding的绑定列表转化为一个hash-map，其中key为变量foo，值为3。函数push-thread-bindings:
(defn push-thread-bindings
[bindings]
(clojure.lang.Var/pushThreadBindings bindings))
其实是调用Var.pushThreadBindings这个静态方法：
public static void pushThreadBindings(Associative bindings){
Frame f = dvals.get();
Associative bmap = f.bindings;
for(ISeq bs = bindings.seq(); bs != null; bs = bs.next())
{
IMapEntry e = (IMapEntry) bs.first();
Var v = (Var) e.key();
v.validate(v.getValidator(), e.val());
v.count.incrementAndGet();
bmap = bmap.assoc(v, new Box(e.val()));
}
dvals.set(new Frame(bindings, bmap, f));
}
pushThreadBindings是将绑定关系放入一个
新的frame(新的context)，并存入ThreadLocal变量dvals。
pop-thread-bindings函数相反，弹出一个Frame，它实际调用的是Var.popThreadBindings静态方法：
public static void popThreadBindings(){
Frame f = dvals.get();
if(f.prev == null)
throw new IllegalStateException("Pop without matching push");
for(ISeq bs = RT.keys(f.frameBindings); bs != null; bs = bs.next())
{
Var v = (Var) bs.first();
v.count.decrementAndGet();
}
dvals.set(f.prev);
}
在执行宏的body表达式，也就是取foo值的时候，实际调用的是Var.deref静态方法取变量值：
final public Object deref(){
//先从ThreadLocal找
Box b = getThreadBinding();
if(b != null)
return b.val;
//如果有定义初始值，返回root binding
if(hasRoot())
return root;
throw new IllegalStateException(String.format("Var %s/%s is unbound.", ns, sym));
}
看到是先尝试从ThreadLocal找：
final Box getThreadBinding(){
if(count.get() > 0)
{
IMapEntry e = dvals.get().bindings.entryAt(this);
if(e != null)
return (Box) e.val();
}
return null;
}
找不到，如果有初始值就返回初始的root binding，否则抛出异常：Var user/foo is unbound.
binding表达式最后生成的字节码，做的就是上面描述的这些函数调用，有兴趣地可以自行分析。