akka-stream是多线程non-blocking模式的，一般来说，运算任务提交到另外线程后这个线程就会在当前程序控制之外*运行了。任何时候如果需要终止运行中的数据流就必须采用一种任务柄（handler）方式来控制在其它线程内运行的任务。这个handler可以在提交运算任务时获取。akka-stream提供了KillSwitch trait来支持这项功能：
/**
* A [[KillSwitch]] allows completion of [[Graph]]s from the outside by completing [[Graph]]s of [[FlowShape]] linked
* to the switch. Depending on whether the [[KillSwitch]] is a [[UniqueKillSwitch]] or a [[SharedKillSwitch]] one or
* multiple streams might be linked with the switch. For details see the documentation of the concrete subclasses of
* this interface.
*/
//#kill-switch
trait KillSwitch {
/**
* After calling [[KillSwitch#shutdown()]] the linked [[Graph]]s of [[FlowShape]] are completed normally.
*/
def shutdown(): Unit
/**
* After calling [[KillSwitch#abort()]] the linked [[Graph]]s of [[FlowShape]] are failed.
*/
def abort(ex: Throwable): Unit
}
//#kill-switch
可以想象：我们必须把这个KillSwitch放在一个流图中间，所以它是一种FlowShape的，这可以从KillSwitch的构建器代码里可以看得到：
object KillSwitches {
/**
* Creates a new [[SharedKillSwitch]] with the given name that can be used to control the completion of multiple
* streams from the outside simultaneously.
*
* @see SharedKillSwitch
*/
def shared(name: String): SharedKillSwitch = new SharedKillSwitch(name)
/**
* Creates a new [[Graph]] of [[FlowShape]] that materializes to an external switch that allows external completion
* of that unique materialization. Different materializations result in different, independent switches.
*
* For a Bidi version see [[KillSwitch#singleBidi]]
*/
def single[T]: Graph[FlowShape[T, T], UniqueKillSwitch] =
UniqueKillSwitchStage.asInstanceOf[Graph[FlowShape[T, T], UniqueKillSwitch]]
/**
* Creates a new [[Graph]] of [[FlowShape]] that materializes to an external switch that allows external completion
* of that unique materialization. Different materializations result in different, independent switches.
*
* For a Flow version see [[KillSwitch#single]]
*/
def singleBidi[T1, T2]: Graph[BidiShape[T1, T1, T2, T2], UniqueKillSwitch] =
UniqueBidiKillSwitchStage.asInstanceOf[Graph[BidiShape[T1, T1, T2, T2], UniqueKillSwitch]]
...}
akka-stream提供了single,shared,singleBidi三种KillSwitch的构建方式，它们的形状都是FlowShape。KillSwitches.single返回结果类型是Graph[FlowShape[T,T],UniqueKillSwitch]。因为我们需要获取这个KillSwitch的控制柄，所以要用viaMat来可运算化（materialize）这个Graph，然后后选择右边的类型UniqueKillSwitch。这个类型可以控制一个可运算化FlowShape的Graph，如下：
val source = Source(Stream.from(,)).delay(.second,DelayOverflowStrategy.backpressure)
val sink = Sink.foreach(println)
val killSwitch = source.viaMat(KillSwitches.single)(Keep.right).to(sink).run() scala.io.StdIn.readLine()
killSwitch.shutdown()
println("terminated!")
actorSys.terminate()
当然，也可以用异常方式中断运行：
killSwitch.abort(new RuntimeException("boom!"))
source是一个不停顿每秒发出一个数字的数据源。如上所述：必须把KillSwitch放在source和sink中间形成数据流完整链状。运算这个数据流时返回了handle killSwitch，我们可以使用这个killSwitch来shutdown或abort数据流运算。
KillSwitches.shared构建了一个SharedKillSwitch类型。这个类型可以被用来控制多个FlowShape Graph的终止运算。SharedKillSwitch类型里的flow方法可以返回终止运算的控制柄handler：
/**
* Returns a typed Flow of a requested type that will be linked to this [[SharedKillSwitch]] instance. By invoking
* [[SharedKillSwitch#shutdown()]] or [[SharedKillSwitch#abort()]] all running instances of all provided [[Graph]]s by this
* switch will be stopped normally or failed.
*
* @tparam T Type of the elements the Flow will forward
* @return A reusable [[Graph]] that is linked with the switch. The materialized value provided is this switch itself.
*/
def flow[T]: Graph[FlowShape[T, T], SharedKillSwitch] = _flow.asInstanceOf[Graph[FlowShape[T, T], SharedKillSwitch]]
用flow构建的SharedKillSwitch实例就像immutable对象，我们可以在多个数据流中插入SharedKillSwitch，然后用这一个共享的handler去终止使用了这个SharedKillSwitch的数据流运算。下面是SharedKillSwitch的使用示范：
val sharedKillSwitch = KillSwitches.shared("multi-ks")
val source2 = Source(Stream.from()).delay(.second,DelayOverflowStrategy.backpressure)
source2.via(sharedKillSwitch.flow).to(sink).run()
source.via(sharedKillSwitch.flow).to(sink).run()
scala.io.StdIn.readLine()
killSwitch.shutdown()
sharedKillSwitch.shutdown()
注意：我们先构建了一个SharedKillSwitch实例，然后在source2,source数据通道中间加入了这个实例。因为我们已经获取了sharedKillSwitch控制柄，所以不必理会返回结果，直接用via和to来连接上下游节点（默认为Keep.left）。
还有一个KillSwitches.singleBidi类型，这种KillSwitch是用来终止双流向数据流运算的。我们将在下篇讨论里介绍。
下面是本次示范的源代码：
import akka.stream.scaladsl._
import akka.stream._
import akka.actor._
import scala.concurrent.duration._
object KillSwitchDemo extends App {
implicit val actorSys = ActorSystem("sys")
implicit val ec = actorSys.dispatcher
implicit val mat = ActorMaterializer(
ActorMaterializerSettings(actorSys)
.withInputBuffer(,)
) val source = Source(Stream.from(,)).delay(.second,DelayOverflowStrategy.backpressure)
val sink = Sink.foreach(println)
val killSwitch = source.viaMat(KillSwitches.single)(Keep.right).to(sink).run() val sharedKillSwitch = KillSwitches.shared("multi-ks")
val source2 = Source(Stream.from()).delay(.second,DelayOverflowStrategy.backpressure) source2.via(sharedKillSwitch.flow).to(sink).run()
source.via(sharedKillSwitch.flow).to(sink).run() scala.io.StdIn.readLine()
killSwitch.shutdown()
sharedKillSwitch.shutdown()
println("terminated!")
actorSys.terminate() }