Akka源码分析-Extension

　　一个设计优秀的工具或框架，应该都有一个易用、强大的插件或扩展体系，akka也不例外。

　　akka的扩展方法非常简单，因为只涉及到两个组件：Extension、 ExtensionId。其中Extension在每个ActorSystem中只会加载一次，然后被akka管理。你可以在ActorSystem启动的时候以编程的方式加载，也可以通过配置的方式自动加载。由于Extension是在ActorSystem层面的扩展，所以需要开发者自己处理线程安全的问题。ExtensionId可以理解为Extension的一个唯一标志，ActorSystem会根据它来判断Extension是否被加载过，以确保Extension只能加载一次。

/**
 * The basic ActorSystem covers all that is needed for locally running actors,
 * using futures and so on. In addition, more features can hook into it and
 * thus become visible to actors et al by registering themselves as extensions.
 * This is accomplished by providing an extension—which is an object
 * implementing this trait—to `ActorSystem.registerExtension(...)` or by
 * specifying the corresponding option in the configuration passed to
 * ActorSystem, which will then instantiate (without arguments) each FQCN and
 * register the result.
 *
 * The extension itself can be created in any way desired and has full access
 * to the ActorSystem implementation.
 *
 * This trait is only a marker interface to signify an Akka Extension.
 */
trait Extension

　　上面是Extension的定义，可以看出它非常简单，简单到就是一个trait，没有任何字段和方法。也就是说我们实现的对akka的扩展可以是任意形式的类，而且会被保证加载一次，那么是如何保证只会加载一次的呢？ExtensionId也许可以回答这个问题。

/**
 * Identifies an Extension
 * Lookup of Extensions is done by object identity, so the Id must be the same wherever it's used,
 * otherwise you'll get the same extension loaded multiple times.
 */
trait ExtensionId[T <: Extension] {

  /**
   * Returns an instance of the extension identified by this ExtensionId instance.
   */
  def apply(system: ActorSystem): T = {
    java.util.Objects.requireNonNull(system, "system must not be null!").registerExtension(this)
  }

  /**
   * Returns an instance of the extension identified by this ExtensionId instance.
   * Java API
   * For extensions written in Scala that are to be used from Java also,
   * this method should be overridden to get correct return type.
   * {{{
   * override def get(system: ActorSystem): TheExtension = super.get(system)
   * }}}
   *
   */
  def get(system: ActorSystem): T = apply(system)

  /**
   * Is used by Akka to instantiate the Extension identified by this ExtensionId,
   * internal use only.
   */
  def createExtension(system: ExtendedActorSystem): T

  override final def hashCode: Int = System.identityHashCode(this)
  override final def equals(other: Any): Boolean = this eq other.asInstanceOf[AnyRef]
}

　　ExtensionId也很简单，首先这是一个trait，且有一个类型变量T，要求T是Extension的子类。其中有一个apply，通过system返回一个T的实例。createExtension没有实现。那需要继续深入registerExtension的代码。

  /**
   * Registers the provided extension and creates its payload, if this extension isn't already registered
   * This method has putIfAbsent-semantics, this method can potentially block, waiting for the initialization
   * of the payload, if is in the process of registration from another Thread of execution
   */
  def registerExtension[T <: Extension](ext: ExtensionId[T]): T

　　通过registerExtension的定义来看，官方注释写的也很清楚，它就是在注册一个extension，并且创建一个实例。如果这个extension已经注册过，就不再注册。

  @tailrec
  final def registerExtension[T <: Extension](ext: ExtensionId[T]): T = {
    findExtension(ext) match {
      case null ⇒ //Doesn't already exist, commence registration
        val inProcessOfRegistration = new CountDownLatch(1)
        extensions.putIfAbsent(ext, inProcessOfRegistration) match { // Signal that registration is in process
          case null ⇒ try { // Signal was successfully sent
            ext.createExtension(this) match { // Create and initialize the extension
              case null ⇒ throw new IllegalStateException(s"Extension instance created as 'null' for extension [$ext]")
              case instance ⇒
                extensions.replace(ext, inProcessOfRegistration, instance) //Replace our in process signal with the initialized extension
                instance //Profit!
            }
          } catch {
            case t: Throwable ⇒
              extensions.replace(ext, inProcessOfRegistration, t) //In case shit hits the fan, remove the inProcess signal
              throw t //Escalate to caller
          } finally {
            inProcessOfRegistration.countDown //Always notify listeners of the inProcess signal
          }
          case other ⇒ registerExtension(ext) //Someone else is in process of registering an extension for this Extension, retry
        }
      case existing ⇒ existing.asInstanceOf[T]
    }
  }

　　我们来看看registerExtension的具体实现，它首先通过findExtension查找对应的ExtensionId是否已经注册，如果已经注册，则直接返回找到的结果，否则就进行创建。在case null分支中，有一个CountDownLatch。我们有必要简要介绍一下这个类的作用和使用方法。

“CountDownLatch典型用法1：某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为n new CountDownLatch(n) ，每当一个任务线程执行完毕，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await() 的线程就会被唤醒”

　　也就是说registerExtension是会保证线程安全的，以保证Extension只被加载一次。extensions会通过putIfAbsent方法插入ExtensionId与inProcessOfRegistration的键值对，当然了extensions是一个ConcurrentHashMap。如果key不存在，即第一次注册的时候，则把键值对插入并返回null。所以第一次注册会命中case null，然后把当前ActorSystem传给createExtension方法创建Extension实例。如果创建成功，就会替换extensions中ExtensionId对应的value为新创建的Extension实例（替换之前是inProcessOfRegistration这个CountDownLatch），最后执行countDown，计数器变成0。如果创建失败呢？会抛出一个IllegalStateException异常或其他异常，收到异常后，会把ExtensionId对应的value变成对应的Throwable信息。那么如果putIfAbsent插入失败呢，也就是ExtensionId已经有对应的value了，会递归执行registerExtension重新注册，既然有值了为啥还要重新注册呢？因为对应的值有三种情况：Extension实例、Throwable、CountDownLatch。所以需要重新注册。

　　另外CountDownLatch一定会有await，那么啥时候await呢。别急，还有findExtension没有分析呢。

 /**
   * Returns any extension registered to the specified Extension or returns null if not registered
   */
  @tailrec
  private def findExtension[T <: Extension](ext: ExtensionId[T]): T = extensions.get(ext) match {
    case c: CountDownLatch ⇒
      c.await(); findExtension(ext) //Registration in process, await completion and retry
    case t: Throwable ⇒ throw t //Initialization failed, throw same again
    case other ⇒
      other.asInstanceOf[T] //could be a T or null, in which case we return the null as T
  }

　　很显然，findExtension会对查询到的结果进行判断，如果是CountDownLatch就调用await进行等待，等待其他线程的registerExtension执行完毕，然后递归调用findExtension；如果其他线程注册完了返回异常，则此处也简单的抛出异常；如果返回其他类型的数据，则把它转化成T的一个实例，也就是我们自定义的Extension，那如果返回null呢？那就返回null喽。

　　至此registerExtension分析完毕，它以线程安全的方式保证Extension被加载一次，也就是createExtension方法只被调用一次。那么如何根据ActorSystem创建我们自定义的Extension就非常灵活了。

　　我们来看一下官网的例子。

class CountExtensionImpl extends Extension {
  //Since this Extension is a shared instance
  // per ActorSystem we need to be threadsafe
  private val counter = new AtomicLong(0)

  //This is the operation this Extension provides
  def increment() = counter.incrementAndGet()
}

　　上面是我们自定义的一个Extension，它非常简单，就是一个计数器，且increment()保证线程安全。

object CountExtension
  extends ExtensionId[CountExtensionImpl]
  with ExtensionIdProvider {
  //The lookup method is required by ExtensionIdProvider,
  // so we return ourselves here, this allows us
  // to configure our extension to be loaded when
  // the ActorSystem starts up
  override def lookup = CountExtension

  //This method will be called by Akka
  // to instantiate our Extension
  override def createExtension(system: ExtendedActorSystem) = new CountExtensionImpl

  /**
   * Java API: retrieve the Count extension for the given system.
   */
  override def get(system: ActorSystem): CountExtensionImpl = super.get(system)
}

　　上面是一个ExtensionId，还继承了ExtensionIdProvider，ExtensionIdProvider源码如下，其实就是用来查找ExtensionId的，这样就能够通过配置文件自动加载了。

/**
 * To be able to load an ExtensionId from the configuration,
 * a class that implements ExtensionIdProvider must be specified.
 * The lookup method should return the canonical reference to the extension.
 */
trait ExtensionIdProvider {
  /**
   * Returns the canonical ExtensionId for this Extension
   */
  def lookup(): ExtensionId[_ <: Extension]
}

　　可以看出createExtension就是new了一个CountExtensionImpl，没有把ExtendedActorSystem传给CountExtensionImpl。其实在稍微复杂点的Extension里面是可以接收ExtendedActorSystem参数的，有了对ExtendedActorSystem的引用，我们就可以调用ExtendedActorSystem的所有公开的方法。如果你要问我ExtendedActorSystem都有哪些公开的方法或者说，有了ExtendedActorSystem可以做什么，我是拒绝回答的。有了ExtendedActorSystem你还不是想干啥就干啥？哈哈。

akka-extensions

CountDownLatch的简单理解