0Pricing
Scala for Backend Engineering & Functional Programming · 강의

Future와 Promise 입문

비동기 결과를 위한 `Future`와 결과 완료를 위한 `Promise`의 핵심 개념을 이해합니다.

Future와 Promise 입문은(는) CoddyKit의 무료 Scala for Backend Engineering & Functional Programming 강의입니다. 이것은 3개 중 1번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Scala for Backend Engineering & Functional Programming 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Scala for Backend Engineering & Functional Programming 강의에는 총 3개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Async Code: Why It Matters

In programming, tasks can run synchronously (one after another) or asynchronously (tasks can start without waiting for previous ones to finish).

Asynchronous programming is crucial for building responsive applications that don't freeze while waiting for slow operations like network requests or database queries.

The Problem with Blocking Calls

Imagine your program needs to fetch data from the internet. If this operation is blocking, your program will pause and do nothing else until the data arrives.

This can lead to a 'frozen' user interface or inefficient server-side applications. We need a way to perform these tasks in the background without halting the main flow.

Introducing Scala Futures

Scala's Future is a powerful tool for asynchronous programming. It represents a value that may not yet be available, but will be at some point in the future.

  • Think of it like ordering a coffee: you get a receipt (the Future) and can do other things while your coffee is being made.
  • When the coffee is ready, the receipt is 'completed' with your drink (the result).

Creating Your First Future

You can create a Future by wrapping a computation in Future { ... }. This computation will run on a separate thread.

An ExecutionContext is needed to schedule these tasks. We'll use a global one for simplicity.

import scala.concurrent.{Future, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}

object Main extends App {
  println("Starting computation...")

  val f: Future[Int] = Future {
    Thread.sleep(1000) // Simulate a long operation
    42
  }

  f.onComplete {
    case Success(value) => println(s"Result: $value")
    case Failure(e) => println(s"Error: ${e.getMessage}")
  }

  println("Computation started, continuing...")
  // Keep main thread alive for a bit to see Future's result
  Thread.sleep(2000)
}

Understanding ExecutionContext

An ExecutionContext is essentially a thread pool where asynchronous computations are run.

  • It manages how and when tasks are executed.
  • For quick examples, scala.concurrent.ExecutionContext.Implicits.global is often used, providing a default thread pool.
  • In real applications, you might configure specific thread pools for better control over resource usage.

Handling Future Results: onComplete

The onComplete method is used to define what happens when a Future finishes, whether it succeeds or fails.

It takes a function that operates on a scala.util.Try, which can be either Success(value) or Failure(exception).

import scala.concurrent.{Future, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}

object Main extends App {
  val futureSuccess = Future { 10 / 2 }
  val futureFailure = Future { 10 / 0 }

  futureSuccess.onComplete {
    case Success(result) => println(s"Success: $result")
    case Failure(e) => println(s"Error: ${e.getMessage}")
  }

  futureFailure.onComplete {
    case Success(result) => println(s"Success: $result")
    case Failure(e) => println(s"Error: ${e.getMessage}")
  }

  Thread.sleep(100) // Allow Futures to complete and print
}

Simplified Handlers: Success/Failure

For simpler cases, you can use onSuccess and onFailure to handle only successful results or only errors, respectively.

  • onSuccess takes a function for the successful value.
  • onFailure takes a function for the exception.
  • These are convenience methods built on top of onComplete.
import scala.concurrent.{Future, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global

object Main extends App {
  val futureValue = Future { "Hello, Scala!" }

  futureValue.onSuccess { case msg => println(s"Got message: $msg") }
  futureValue.onFailure { case e => println(s"Oops, an error: ${e.getMessage}") }

  val futureError = Future { throw new RuntimeException("Something broke!") }

  futureError.onSuccess { case msg => println(s"Got message: $msg") }
  futureError.onFailure { case e => println(s"Oops, an error: ${e.getMessage}") }

  Thread.sleep(100) // Allow Futures to complete and print
}

What is a Scala Promise?

While a Future is a read-only placeholder for a result, a Promise is a write-once container that can be completed with a value or an exception.

  • A Promise is used to complete a Future.
  • You create a Promise, get its associated Future, and then complete the Promise when the result is ready.

Fulfilling a Promise

You can complete a Promise using its success() or failure() methods. Once a Promise is completed, its associated Future will also complete.

Attempting to complete a Promise more than once will result in an error.

import scala.concurrent.{Future, Promise, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}

object Main extends App {
  val p = Promise[String]() // Create a Promise that will hold a String
  val f: Future[String] = p.future // Get the Future associated with the Promise

  f.onComplete {
    case Success(value) => println(s"Future completed with: '$value'")
    case Failure(e) => println(s"Future failed with: ${e.getMessage}")
  }

  // Simulate an async operation completing the promise
  Future {
    Thread.sleep(500)
    p.success("Data fetched successfully!") // Complete the Promise
  }

  println("Promise created, waiting for completion...")
  Thread.sleep(1000) // Keep main thread alive to see Future's result
}

Futures and Promises Together

Future and Promise often work hand-in-hand. A common pattern is to use a Promise when you need to manually control the completion of a Future, perhaps from an external system or an older, callback-based API.

This allows you to wrap non-Future-based asynchronous operations into the Future model, making them compatible with Future-based code.

import scala.concurrent.{Future, Promise, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}

object Main extends App {
  def performLongTask(data: String): Future[String] = {
    val p = Promise[String]()
    // Simulate an external system or callback-based API
    Future {
      Thread.sleep(700)
      if (data == "fail") p.failure(new Exception("Task failed!"))
      else p.success(s"Processed: $data")
    }
    p.future // Return the Future that will be completed by the Promise
  }

  val task1 = performLongTask("input data")
  task1.onComplete { case Success(res) => println(s"Task 1: $res") case Failure(e) => println(s"Task 1: ${e.getMessage}") }

  val task2 = performLongTask("fail")
  task2.onComplete { case Success(res) => println(s"Task 2: $res") case Failure(e) => println(s"Task 2: ${e.getMessage}") }

  Thread.sleep(1500) // Keep main thread alive for results
}

Quick Check: Future vs. Promise

Which of the following statements correctly describe the roles of Future and Promise in Scala?

Recap: Futures & Promises

Great job! In this lesson, you've learned the fundamentals of asynchronous programming in Scala:

  • Future: A placeholder for a result that will eventually be available.
  • Promise: A write-once container used to manually complete a Future.
  • ExecutionContext: Schedules the execution of asynchronous tasks.
  • How to handle Future results using onComplete, onSuccess, and onFailure.

These concepts are building blocks for more complex asynchronous patterns!

자주 묻는 질문

“Future와 Promise 입문” 강의는 무료인가요?

네 — “Future와 Promise 입문” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Scala for Backend Engineering & Functional Programming 강의 전체를 잠금 해제할 수 있습니다. Scala for Backend Engineering & Functional Programming 강의에는 총 3개의 강의가 포함되어 있습니다.

“Future와 Promise 입문”에서 뭘 배우나요?

비동기 결과를 위한 `Future`와 결과 완료를 위한 `Promise`의 핵심 개념을 이해합니다. 브라우저에서 직접 실행하는 실습 코드로 Scala for Backend Engineering & Functional Programming을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Scala for Backend Engineering & Functional Programming을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Scala for Backend Engineering & Functional Programming은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 3개 중 1번째 강의입니다.

“Future와 Promise 입문” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 Scala for Backend Engineering & Functional Programming 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 Scala for Backend Engineering & Functional Programming 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

  1. Future와 Promise 입문
  2. 비동기 연산 조합
  3. Future의 오류 처리
← Scala for Backend Engineering & Functional Programming(으)로 돌아가기