[SCALA] 어떻게 스칼라에서 미래를 취소하려면?

어떻게 스칼라에서 미래를 취소하려면?

자바의 미래는 미래의 작업을 실행하는 스레드를 중단 할 수 있습니다 방법을 취소있다. 나는 자바 미래에 인터럽트 차단 호출을 래핑 예를 들어, 나중에 그것을 중단 할 수 있습니다.

스칼라 미래는 어떤 방법을 취소하지 않습니다 제공합니다. 나는 스칼라 미래의 인터럽트 차단 호출을 래핑 가정하자. 어떻게 그것을 방해 할 수 있습니까?

해결법

1. ==============================

   1.이것은 아직 선물 API의 일부가 아니라 미래의 확장으로 추가 할 수 있습니다.

   이것은 아직 선물 API의 일부가 아니라 미래의 확장으로 추가 할 수 있습니다.

   취소 할 미래와 사용자 정의 약속에서 오는 미래 - 해결 방법으로, 당신은이 선물을 포장하는 firstCompletedOf를 사용할 수 있습니다. 그런 다음 약속을하지 못해 이렇게 생성 된 미래를 취소 할 수 있습니다 :

   def cancellable[T](f: Future[T])(customCode: => Unit): (() => Unit, Future[T]) = {
     val p = Promise[T]
     val first = Future firstCompletedOf Seq(p.future, f)
     val cancellation: () => Unit = {
       () =>
         first onFailure { case e => customCode}
         p failure new Exception
     }
     (cancellation, first)
   }
   

   이제 당신은 "취소 해 래퍼"을 얻기 위해 향후에이를 호출 할 수 있습니다. 예 유스 케이스 :

   val f = callReturningAFuture()
   val (cancel, f1) = cancellable(f) {
     cancelTheCallReturningAFuture()
   }
   
   // somewhere else in code
   if (condition) cancel() else println(Await.result(f1))
   

   편집하다:

   취소에 대한 자세한 설명은 스칼라 책의 학습 병행 프로그래밍 제 4 장을 참조하십시오.

2. ==============================

   2.나는이 테스트를하지 않은, 그러나 이것은 파블로 프란시스코 페레스 히달고의 답변을 확장합니다. 대신 자바의 미래 대기 차단, 우리는 대신 중간 약속을 사용합니다.

   나는이 테스트를하지 않은, 그러나 이것은 파블로 프란시스코 페레스 히달고의 답변을 확장합니다. 대신 자바의 미래 대기 차단, 우리는 대신 중간 약속을 사용합니다.

   import java.util.concurrent.{Callable, FutureTask}
   import scala.concurrent.{ExecutionContext, Promise}
   import scala.util.Try
   
   class Cancellable[T](executionContext: ExecutionContext, todo: => T) {
     private val promise = Promise[T]()
   
     def future = promise.future
   
     private val jf: FutureTask[T] = new FutureTask[T](
       new Callable[T] {
         override def call(): T = todo
       }
     ) {
       override def done() = promise.complete(Try(get()))
     }
   
     def cancel(): Unit = jf.cancel(true)
   
     executionContext.execute(jf)
   }
   
   object Cancellable {
     def apply[T](todo: => T)(implicit executionContext: ExecutionContext): Cancellable[T] =
       new Cancellable[T](executionContext, todo)
   }
   

3. ==============================

   3.취소함으로써 당신이 격렬하게 미래를 방해하려는 것 같아요.

   취소함으로써 당신이 격렬하게 미래를 방해하려는 것 같아요.

   코드의 발견이 세그먼트 : https://gist.github.com/viktorklang/5409467

   몇 가지 검사를하고 잘 작동하는 것 같다!

   즐겨 :)

4. ==============================

   4.나는 자바 (7) 미래의 인터페이스와 그 구현을 이용하여 제공되는 구현의 복잡성을 줄일 수있다 생각합니다.

   나는 자바 (7) 미래의 인터페이스와 그 구현을 이용하여 제공되는 구현의 복잡성을 줄일 수있다 생각합니다.

   취소 가능은 취소 방법으로 취소 할 수있는 하나 인 자바의 미래를 구축 할 수 있습니다. 또 다른 미래가 완성 따라서 자체 상태에서 불변 관찰 인터페이스가되기위한 대기 할 수 있습니다 :

    class Cancellable[T](executionContext: ExecutionContext, todo: => T) {
   
      private val jf: FutureTask[T] = new FutureTask[T](
        new Callable[T] {
          override def call(): T = todo
        }
      )
   
      executionContext.execute(jf)
   
      implicit val _: ExecutionContext = executionContext
   
      val future: Future[T] = Future {
        jf.get
      }
   
      def cancel(): Unit = jf.cancel(true)
   
    }
   
    object Cancellable {
      def apply[T](todo: => T)(implicit executionContext: ExecutionContext): Cancellable[T] =
        new Cancellable[T](executionContext, todo)
    }
   

from https://stackoverflow.com/questions/16009837/how-to-cancel-future-in-scala by cc-by-sa and MIT license