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的简单理解

posted @ 2018-08-02 09:26 gabry.wu 阅读(...) 评论(...) 编辑 收藏

打赏