Scala for Backend Engineering & Functional Programming · Lekcja

Optymalizacja kodu współbieżnego

Poznaj zaawansowane techniki optymalizacji współbieżnych aplikacji Scala, w tym dostrajanie puli wątków i unikanie rywalizacji o zasoby.

Optymalizacja kodu współbieżnego to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.

Dlaczego optymalizować kod współbieżny?

Optymalizacja współbieżnego kodu Scala ma kluczowe znaczenie podczas tworzenia wydajnych i skalowalnych aplikacji. Chodzi o to, aby programy działały szybciej i jednocześnie obsługiwały większą liczbę zadań.

Przepustowość: Ile operacji można ukończyć w jednostce czasu?
Opóźnienie: Ile czasu zajmuje pojedyncza operacja?
Wykorzystanie zasobów: Czy rdzenie procesora i pamięć są używane efektywnie?

Nieprawidłowo zoptymalizowany kod współbieżny może prowadzić do wąskich gardeł, zakleszczeń i nieefektywnego wykorzystania zasobów, niwelując korzyści ze współbieżności.

Jak działają pule wątków

Pula wątków to zbiór wstępnie zainicjalizowanych wątków roboczych, które można ponownie wykorzystywać do wykonywania zadań. Zamiast tworzyć nowy wątek dla każdego zadania, co jest kosztowne, zadania są przekazywane do puli.

Zmniejsza to narzut związany z tworzeniem i usuwaniem wątków, poprawia responsywność oraz pomaga kontrolować liczbę aktywnych wątków, aby zapobiec wyczerpaniu zasobów.

Konfiguracja globalnej puli Scali

W języku Scala operacje asynchroniczne często korzystają z obiektu ExecutionContext. Domyślnie aplikacje Scala używają globalnego obiektu ExecutionContext, który zazwyczaj jest pulą ForkJoinPool.

Domyślną pulę można dostrajać za pomocą właściwości systemowych lub, częściej, definiując ustawienia dispatcherów w pliku application.conf (zwłaszcza w aplikacjach opartych na Akka). Pozwala to kontrolować liczbę wątków, zachowanie work-stealing oraz rozmiary kolejek.

Często dostrajaną opcją jest parallelism-factor, która skaluje rozmiar puli względem dostępnych rdzeni procesora.

Tworzenie niestandardowych obiektów ExecutionContext

Choć globalny obiekt ExecutionContext jest wygodny, często lepiej tworzyć niestandardowe pule wątków dla różnych rodzajów zadań. Przykładowo można użyć małej puli dla zadań ograniczonych przez procesor i większej dla zadań ograniczonych przez operacje wejścia-wyjścia.

Zapobiega to blokowaniu zadań ograniczonych przez procesor przez powolne operacje wejścia-wyjścia, poprawiając ogólną responsywność systemu. Oto sposób utworzenia prostego niestandardowego obiektu ExecutionContext:

import java.util.concurrent.{Executors, ExecutorService}
import scala.concurrent.ExecutionContext

object CustomPoolExample {
  def main(args: Array[String]): Unit = {
    // Create a fixed thread pool with 4 threads
    val customExecutor: ExecutorService =
      Executors.newFixedThreadPool(4)

    // Wrap it in a Scala ExecutionContext
    implicit val customEC: ExecutionContext =
      ExecutionContext.fromExecutor(customExecutor)

    println("Custom ExecutionContext created.")

    // Don't forget to shut down the executor!
    customExecutor.shutdown()
  }
}

Minimalizowanie rywalizacji o zasoby

Rywalizacja występuje, gdy wiele wątków próbuje jednocześnie uzyskać dostęp do współdzielonego zasobu (takiego jak zmienna, struktura danych lub połączenie z bazą danych), a jeden lub więcej wątków musi czekać.

Oczekiwanie to wprowadza opóźnienia i narzut, ponieważ wątki rywalizują o blokady i cykle procesora. Duża rywalizacja może znacznie obniżyć wydajność aplikacji współbieżnych, nawet gdy dostępnych jest wiele rdzeni procesora.

Strategie ograniczania rywalizacji są kluczowe dla uzyskania rzeczywistego paralelizmu.

Blokowanie drobnoziarniste

Zamiast używać pojedynczej blokady gruboziarnistej do ochrony całego obiektu lub dużego bloku kodu, blokowanie drobnoziarniste polega na użyciu mniejszych, bardziej szczegółowych blokad, które chronią tylko faktycznie modyfikowane części danych.

Pozwala to różnym wątkom jednocześnie uzyskiwać dostęp do różnych części obiektu, znacznie ograniczając rywalizację. Zwiększa jednak także złożoność oraz ryzyko zakleszczeń, jeśli mechanizm nie jest odpowiednio zarządzany.

class Counter {
  private var value = 0
  private val lock = new Object() // A specific lock for 'value'

  def increment(): Unit = lock.synchronized {
    value += 1
  }

  def get(): Int = lock.synchronized {
    value
  }
}

object FineGrainedLocking {
  def main(args: Array[String]): Unit = {
    val counter = new Counter()
    println(s"Initial counter value: ${counter.get()}")
    counter.increment()
    println(s"Incremented value: ${counter.get()}")
  }
}

Operacje atomowe na rzecz wydajności

Struktury danych bez blokad używają niskopoziomowych operacji atomowych (takich jak Compare-And-Swap, CAS) do aktualizowania współdzielonych zmiennych bez jawnych blokad. Eliminuje to narzut i potencjalną rywalizację związaną z tradycyjnymi mechanizmami blokowania.

Scala wykorzystuje do tego pakiet Java java.util.concurrent.atomic. Klasy takie jak AtomicInteger, AtomicLong i AtomicReference zapewniają atomowe aktualizacje, dzięki czemu idealnie sprawdzają się w scenariuszach o dużej rywalizacji.

import java.util.concurrent.atomic.AtomicInteger

object AtomicCounterExample {
  def main(args: Array[String]): Unit = {
    val atomicCounter = new AtomicInteger(0)

    // Increment the counter atomically
    atomicCounter.incrementAndGet()
    println(s"Atomic counter after increment: ${atomicCounter.get()}")

    // Another atomic operation: add 5
    atomicCounter.addAndGet(5)
    println(s"Atomic counter after adding 5: ${atomicCounter.get()}")
  }
}

Dokładny pomiar wydajności

Aby naprawdę ocenić skuteczność optymalizacji współbieżności, trzeba dokładnie ją zmierzyć. Proste mierzenie czasu za pomocą System.nanoTime() często nie wystarcza w przypadku kodu współbieżnego ze względu na optymalizacje JVM, okresy rozgrzewania oraz przełączanie kontekstu.

Profesjonalne narzędzia do benchmarków, takie jak JMH (Java Microbenchmark Harness), są przeznaczone do tego celu. Obsługują rozgrzewanie JVM, eliminowanie martwego kodu i analizę statystyczną, zapewniając wiarygodne metryki wydajności algorytmów współbieżnych.

Należy skupić się na metrykach takich jak liczba operacji na sekundę (przepustowość) oraz średni czas wykonania (opóźnienie) przy różnym obciążeniu.

Sprawdź optymalizację współbieżności

Które z poniższych strategii skutecznie optymalizują aplikacje Scala działające współbieżnie i ograniczają rywalizację?

Podsumowanie: lepsza wydajność współbieżności

W tej lekcji omówiliśmy zaawansowane techniki optymalizacji współbieżnych aplikacji Scala:

Poznali Państwo znaczenie dostrajania puli wątków, w tym konfigurowania domyślnego obiektu ExecutionContext Scali oraz tworzenia niestandardowych pul dla określonych rodzajów zadań.
Omówiliśmy strategie unikania rywalizacji, takie jak ograniczanie zakresu blokad za pomocą blokowania drobnoziarnistego.
Zobaczyli Państwo, jak struktury danych bez blokad, a zwłaszcza zmienne atomowe, mogą zapewniać wydajne aktualizacje współdzielonego stanu przy niewielkim narzucie.

Proszę pamiętać, aby zawsze mierzyć wpływ optymalizacji za pomocą odpowiednich narzędzi do benchmarków i upewniać się, że przynoszą one rzeczywisty wzrost wydajności!

Często zadawane pytania

Czy lekcja „Optymalizacja kodu współbieżnego” jest bezpłatna?

Tak — pełny tekst „Optymalizacja kodu współbieżnego” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.

Co nauczysz się w „Optymalizacja kodu współbieżnego”?

Poznaj zaawansowane techniki optymalizacji współbieżnych aplikacji Scala, w tym dostrajanie puli wątków i unikanie rywalizacji o zasoby. Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.

Ile czasu zajmuje lekcja „Optymalizacja kodu współbieżnego”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Scala for Backend Engineering & Functional Programming