Clojure的transient集合-CSDN博客

下班后记一些有趣的东西。

这个话题是阿宝同学问我为什么clojure的PersistentVector的节点Node为什么要有个原子引用指向一个线程：

static class Node implements Serializable {
     // 记录的线程
     transient final AtomicReference < Thread > edit;
     final Object[] array;

    Node(AtomicReference < Thread > edit, Object[] array){
         this .edit = edit;
         this .array = array;
    }

    Node(AtomicReference < Thread > edit){
         this .edit = edit;
         this .array = new Object[ 32 ];
    }
}

    我还真不懂，没有细看过这部分代码，早上花点时间学习了下。
    PersistentVector的实现是另一个话题，这里不提。我们都知道clojure的数据结构是immutable的，修改任意一个数据结构都将生成一个新的数据结构，原来的不变。为了减少复制的开销，clojure的数据结构同时是persistent，所谓持久数据结构是将数据组织为树形的层次结构，修改的时候只是root改变，指向不同的节点，原有的节点仍然复用，从而避免了大量的数据复制，具体可以搜索下 ideal hash trees这篇paper， paper难懂，可以看看这篇blog。

    但是在创建PersistentVector的时候，从一堆现有的元素或者集合创建一个PersistentVector，如果每次都重新生成一个PersistentVector，未免太浪费，创建过程的性能会受到影响。我们完全可以假设创建PersistentVector这个过程肯定是线程安全的，没有必要每添加一个元素就重新生成一个PersistentVector，完全可以在同一个PersistentVector上修改。这就是TransientVector的意义所在。
    TransientVector就是一个可修改的Vector，调用它添加一个元素，删除一个元素，都是在同一个对象上进行，而不是生成新的对象。查看PersistentVector的创建：

static public PersistentVector create(ISeq items){
    TransientVector ret = EMPTY.asTransient();
     for (; items != null ; items = items.next())
        ret = ret.conj(items.first());
     return ret.persistent();
}

static public PersistentVector create(List items){
    TransientVector ret = EMPTY.asTransient();
     for (Object item : items)
        ret = ret.conj(item);
     return ret.persistent();
}

static public PersistentVector create(Object

items){
    TransientVector ret = EMPTY.asTransient();
     for (Object item : items)
        ret = ret.conj(item);
     return ret.persistent();
}

看到三个方法的第一步都是将EMPTY集合transient化，生成一个可修改的TransientVector：

TransientVector(PersistentVector v){
         this (v.cnt, v.shift, editableRoot(v.root), editableTail(v.tail));
    }

static Node editableRoot(Node node){
         return new Node( new AtomicReference < Thread > (Thread.currentThread()), node.array.clone());
    }

生成的时候记录了当前的线程在root节点。然后添加元素的时候直接调用TransientVector的conj方法，查看conj可以看到每次返回的都是this:

public TransientVector conj(Object val){
                 // 确保修改过程合法
        ensureEditable();
          // 忽略逻辑
         return this ;
    }

查看ensureEditable方法：

void ensureEditable(){
        Thread owner = root.edit.get();
         if (owner == Thread.currentThread())
             return ;
         if (owner != null )
             throw new IllegalAccessError( " Transient used by non-owner thread " );
         throw new IllegalAccessError( " Transient used after persistent! call " );
    }

终于看到Node中的edit引用的线程被使用了，判断当前修改的线程是否是使得集合transient化的线程，如果不是则抛出异常，这是为了保证对TransientVector的编辑是在同一个线程里，防止因为意外发布TransientVector引用引起的线程安全隐患。

知道了transient集合的用途，我们能在clojure中使用吗？完全没问题，clojure.core有个transient方法，可以将一个集合transient化：

(defn transient
[ ^ clojure.lang.IEditableCollection coll]
(.asTransient coll))

前提是这个集合是可编辑的，clojure的map、vector和set都是可编辑的。让我们确认下transient修改后的集合还是不是自身：

user => (def v1 [ 1 2 3 ])
# ' user/v1
user => (def v2 ( transient v1))
# ' user/v2
user => v2
# < TransientVector clojure.lang.PersistentVector$TransientVector@7eb366 >

定义了集合v1，v2是调用了transient之后的集合，查看v2，果然是一个 TransientVector。查看v2的元素个数是不是3个：

user => (.count v2)
3

没问题，注意，我们不能直接调用count函数，因为v2是个普通的java对象，我们必须使用dot操作符来调用java对象的方法。添加一个元素看看：

user => (def v3 (.conj v2 4 ))
# ' user/v3
user => v3
# < TransientVector clojure.lang.PersistentVector$TransientVector@7eb366 >

添加一个元素后形成集合v3，查看v3，跟v2是同一个对象 # < TransientVector clojure.lang.PersistentVector$TransientVector@7eb366 >
。证明了transient集合修改的是自身，而不是生成一个新集合。确认下4有加入v2和v3：