Flume-NG中Transaction并发性探究

　　我们曾经在Flume-NG中的Channel与Transaction关系(原创)这篇文章中说了channel和Transaction的关系，但是在source和sink中都会使用Transaction，那么Transaction的并发性如何？

　　Transaction是介于channel和source、sink直接的一层缓存，为了安全性和可靠性source、sink不能直接访问channel，只能访问在他之上的Transaction，通过Transaction间接操作channel中的数据。

　　这节我们以memory channel和file channel来研究一下Flume-NG的Transaction并发性。

　　首先所有channel的父类都是BasicChannelSemantics，所有Transaction的父类都是BasicTransactionSemantics，mem channel中的Transaction是MemoryTransaction是内部私有类；file channel的Transaction是FileBackedTransaction。一般来说自己定义channel需要实现自己的Transaction。

　　我们在看源码时发现FileBackedTransaction不允许take和put同时操作，在其doCommit和doRollback方法中都有限制使得，究其原因是：。而mem channel的Transaction则没有诸多限制。

　　我们在source和sink中见到的getTransaction()获取的Transaction是同一个吗？如果不是并发性是怎么保证的？第一个很明显不是同一个，试想如果都是同一个，那么不同组件比如一个source和一个sink都会有Transaction.close操作，将会关闭事务，那关闭晚的还如何commit？我们再来看下getTransaction()代码：　　

 1   /**

 2    * <p>

 3    * Initializes the channel if it is not already, then checks to see

 4    * if there is an open transaction for this thread, creating a new

 5    * one via <code>createTransaction</code> if not.

 6    * @return the current <code>Transaction</code> object for the

 7    *     calling thread

 8    * </p>

 9    */

10   @Override

11   public Transaction getTransaction() {

12 

13     if (!initialized) {

14       synchronized (this) {

15         if (!initialized) {

16           initialize();

17           initialized = true;

18         }

19       }

20     }

21 

22     BasicTransactionSemantics transaction = currentTransaction.get();

23     if (transaction == null || transaction.getState().equals(

24             BasicTransactionSemantics.State.CLOSED)) {

25       transaction = createTransaction();

26       currentTransaction.set(transaction);

27     }

28     return transaction;

29   }

　　上面我们可以看出来，如果transaction还未初始化或者transaction的状态是CLOSED(就是执行了close()方法改了状态)，说明需要通过createTransaction()新建一个Transaction，createTransaction()这个方法在子类中实现的。我们来看看mem和file的createTransaction()方法的代码，先看mem的：

1 @Override

2   protected BasicTransactionSemantics createTransaction() {

3     return new MemoryTransaction(transCapacity, channelCounter);

4   }

　　直接就返回了自己的Transaction对象，在看file的createTransaction()方法的代码：

 1 @Override

 2   protected BasicTransactionSemantics createTransaction() {

 3     if(!open) {

 4       String msg = "Channel closed " + channelNameDescriptor;

 5       if(startupError != null) {

 6         msg += ". Due to " + startupError.getClass().getName() + ": " +

 7             startupError.getMessage();

 8         throw new IllegalStateException(msg, startupError);

 9       }

10       throw new IllegalStateException(msg);

11     }

12     FileBackedTransaction trans = transactions.get();

13     if(trans != null && !trans.isClosed()) {        //在这保证put和take只能一个时刻有一个

14       Preconditions.checkState(false,

15           "Thread has transaction which is still open: " +

16               trans.getStateAsString()  + channelNameDescriptor);

17     }

18     trans = new FileBackedTransaction(log, TransactionIDOracle.next(),

19         transactionCapacity, keepAlive, queueRemaining, getName(),

20         channelCounter);

21     transactions.set(trans);

22     return trans;

23   }

　　这个就比mem的复杂了点，毕竟代码多了不少。

　　在看上面的getTransaction()方法，如果已经创建了一个Transaction则会放入currentTransaction中，然后以后再调用getTransaction()就会通过currentTransaction返回currentTransaction.get()，这莫不是同一个Transaction吗？那就好像有点不对了，对吧，那到底是怎么回事呢？

　　关键在于currentTransaction这个东西，我们看声明：private ThreadLocal<BasicTransactionSemantics> currentTransaction = new ThreadLocal<BasicTransactionSemantics>()是ThreadLocal的实例，可能有很多人不了解这个东西，其实我也不了解！！简单来说：ThreadLocal使得各线程能够保持各自独立的一个对象，ThreadLocal并不是一个Thread，而是Thread的局部变量，为解决多线程程序的并发问题提供了一种新的思路，详细请谷歌、百度之。ThreadLocal有一个ThreadLocalMap静态内部类，你可以简单理解为一个MAP，这个‘Map’为每个线程复制一个变量的‘拷贝’存储其中，这个“Map”的key是当前线程的ID，value就是set的变量，而get方法会依据当前线程ID从ThreadLocalMap中获取对应的变量，咱们这里就是Transaction。这下明白了吧，每个source和sink都会有单独的线程来驱动的，所以都有各自的Transaction，是不同的，因此也就可以并发了(针对memory channel)。

　　但是上面file的createTransaction()方法为什么是那样的？因为我们说了file的Transaction不能同时put和take(同一个Transaction一般只会做一个事就是put或者take)，也就是不存在并发性的，所以在file channel中的transactions也设置为了private final ThreadLocal<FileBackedTransaction> transactions =new ThreadLocal<FileBackedTransaction>()，由于channel也是单独的线程驱使，所以这个transactions中始终只存在一对值就是file channel的线程ID和创建的Transaction，如果不同sink或者source调用getTransaction()时会试图通过createTransaction()方法来创建新的Transaction但是file的createTransaction()方法由于已经有了一个Transaction，在其关闭之前是不会同意 再次创建的，所以就只能等待这个Transaction关闭了，因此也就保证了put和take不会同时存在了。也就没有并发性了，性能自然大受影响。

　　那file channel为什么不让put和take同时操作呢？这个问题很值得研究，一：put、take、commit、rollback都会获取log的共享锁，一旦获取其他就只能读，获取锁的目的就是这四个操作都要写入log文件；二，put操作并不会将写入log的event的指针放到queue中，而是在commit中才会放到queue中；三、take的操作会直接从queue中取数据，这时如果put已经commit就可以获取数据，如果没有则会返回null；四、由于四个操作都会获取log锁，导致实际上写达不到并发，而且这个log锁使得即使是写不同的数据文件也不可能，因为只有这一个锁，不是每个数据文件一个锁(数据文件的个数是动态的这个不好做)；五、若take和put同时操作会使得可能交替执行获取锁，此时可能put没commit而queue中无数据，take获取锁之后也没什么意义而且也是轮流不是并行，只会降低put和take的性能，比如put和take各自单独只需1s即可，但是这样可能需要2s甚至更长时间(take一直在等待put的commit)才能完成。综上不让put和take同时操作比较合理。

　　但是有没有更好的方案可以提高file的性能呢？因为file是基于文件的性能不可能很高，更为合理的办法是合理提高并发性，可以优化的一个方案是put、take、commit、rollback单独以文件存放，并设置相应的多个锁，但是文件的动态变化以及put和put、take和take、commit和commit、rollback和rollback之间的并发性又难以实现了，似乎只适合take和put的并发，这样貌似会使得file channel更复杂了，但是性能应该会提高一些，会不会得不偿失啊？

 

　　还有一个问题就是：file channel中的createTransaction()方法如果再次创建Transaction，而先前创建的并未关闭，会执行Preconditions.checkState(false,"Thread has transaction which is still open: " +trans.getStateAsString()+ channelNameDescriptor)会直接抛出异常，但是似乎日志中没有类似的异常啊，而且进程也并未中断，但是显然使用了file channel的flume，sink和source可以正常运行，这是怎么搞得？