
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
uygulama türlerinde, bu katman en kolay olanıdır çünkü Spring Boot veya Ktor gibi çerçeveler tüm işi bizim için yapar.
Örneğin, Spring Boot ile Webflux'ta, bir controller (denetleyici) fonksiyonunun önüne sadece
suspend (askıyaalınabilir) modifikatörünü ekleyerek, Spring bu fonksiyonu bir coroutine içinde başlatır.
@Controller class UserController( private val tokenService: TokenService, // TokenService, kullanıcı kimlik doğrulaması için kullanılır private val userService: UserService, // UserService, kullanıcı verilerini yönetir ) { @GetMapping("/me") // "/me" endpoint'i, kullanıcının bilgilerini alır suspend fun findUser( @PathVariable userId: String, // URL yolundan kullanıcı ID'si alınır @RequestHeader("Authorization") authorization: String // Authorization başlığı alınır ): UserJson { val userId = tokenService.readUserId(authorization) // Token'dan kullanıcı ID'si okunur val user = userService.findUserById(userId) // Kullanıcı servisiyle kullanıcı bilgisi alınır return user.toJson() // Kullanıcı bilgisi JSON formatında döndürülür } }
CoroutineWorker sınıfını kullanabiliriz ve görevlerin ne yapması gerektiğini belirtmek için doWork metodunuimplement (uygulamak) ederiz. Bu metod bir
suspend fonksiyondur, bu yüzden kütüphane tarafından bir coroutine içindebaşlatılır, bu nedenle bunu kendimiz yapmamıza gerek yoktur.
class CoroutineDownloadWorker( context: Context, // Context, uygulamanın durum bilgilerini sağlar params: WorkerParameters // WorkerParametreleri, işin başlatılması için gerekli parametreleri içerir ) : CoroutineWorker( context, params ) { // CoroutineWorker sınıfından türetilir, bu sınıf coroutines ile çalışır // `doWork` fonksiyonu, yapılacak işlemi tanımlar ve bir `suspend` fonksiyondur override suspend fun doWork(): Result { val data = downloadSynchronously() // Veriyi senkron şekilde indirir saveData(data) // İndirilen veriyi kaydeder return Result.success() // İş başarıyla tamamlandığında başarı sonucu döndürülür } }
nesnesi üzerinde
launch kullanırız. Android'de, lifecycle-viewmodel-ktx sayesinde çoğu durumda viewModelScope veyalifecycleScope kullanabiliriz.class UserProfileViewModel( private val loadProfileUseCase: LoadProfileUseCase, // Profil verisini yüklemek için kullanılan işlev private val updateProfileUseCase: UpdateProfileUseCase, // Profil güncellemelerini işleyen işlev ) { private val _userProfile = MutableStateFlow<ProfileData?>(null) // Kullanıcı profili verisi val userProfile: StateFlow<ProfileData> = _userProfile // Kullanıcı profili akışı // ViewModel oluşturulduğunda çalışacak işlem fun onCreate() { viewModelScope.launch { // viewModelScope içinde coroutine başlatılır val userProfileData = loadProfileUseCase() // Profil verisi yüklenir _userProfile.value = userProfileData // Profil verisi StateFlow'a atanır // ... } } // Kullanıcı adının değiştiği durumda çalışacak işlem fun onNameChanged(newName: String) { viewModelScope.launch { // viewModelScope içinde coroutine başlatılır val newProfile = _userProfile.updateAndGet { // Kullanıcı profilini günceller it.copy(name = newName) // Yeni isimle profil verisini günceller } updateProfileUseCase(newProfile) // Güncellenen profil verisini kaydeder } } }
özel scope oluşturmanız ve bunu kullanarak bir coroutine başlatmanız gerekebilir.
class NotificationsSender( private val client: NotificationsClient, // Bildirimleri gönderen istemci private val notificationScope: CoroutineScope, // Kullanılacak özel coroutine kapsamı ) { // Bildirimleri göndermek için coroutine başlatılır fun sendNotifications(notifications: List<Notification>) { for (notification in notifications) { notificationScope.launch { // Her bildirim için yeni bir coroutine başlatılır client.send(notification) // Bildirim gönderilir } } } }
class LatestNewsViewModel( private val newsRepository: NewsRepository, // Haber verilerini sağlayan repository ) : BaseViewModel() { // BaseViewModel sınıfından türetilir private val _uiState = MutableStateFlow<NewsState>(LoadingNews) // UI durumu için StateFlow oluşturulur val uiState: StateFlow<NewsState> = _uiState // UI durumunu gözlemlemek için StateFlow döndürülür // ViewModel oluşturulduğunda haber verileri yüklenir fun onCreate() { scope.launch { // viewModelScope içinde coroutine başlatılır _uiState.value = NewsLoaded(newsRepository.getNews()) // Haber verileri yüklenir ve UI güncellenir } } }
val analyticsScope = CoroutineScope(SupervisorJob()) // SupervisorJob kullanılarak özel bir coroutine kapsamı oluşturulur
belirtebiliriz3Ayrıntılar için bkz. “Bir coroutine scope (iş kapsamı) oluşturma” bölümü. Dispatchers ve istisna işleyicileri hakkında bilgi için sırasıyla “İş Parçacığı Yöneticileri (Dispatchers)” ve “İstisna Yönetimi” bölümlerine bakınız.. Scope nesneleri aynı zamanda iptal edilebilir. Aslında, Android'de çoğu scope ya iptal edilir
ya da bazı koşullar altında çocuklarını iptal edebilir, ve "Bu işlemi çalıştırmak için hangi scope'u kullanmalıyım?"
sorusu genellikle "Bu işlem hangi koşullarda iptal edilmeli?" sorusuna indirgenebilir. View modelleri, scope'larını
temizlendiğinde iptal eder. Work manager'lar ise ilişkili görevler iptal edildiğinde scope'larını iptal eder.
// İptal ve istisna işleyicisi içeren Android örneği abstract class BaseViewModel : ViewModel() { private val _failure = Channel<Throwable>(Channel.UNLIMITED) // Hata kanalını tanımlar val failure: Flow<Throwable> = _failure.receiveAsFlow() // Hataları alacak bir flow oluşturur private val handler = CoroutineExceptionHandler { _, e -> // İstisna işleyicisi _failure.trySendBlocking(e) // Hata alındığında kanal üzerinden gönderilir } protected val viewModelScope = CoroutineScope( // ViewModel için özel bir coroutine scope oluşturulur Dispatchers.Main.immediate + SupervisorJob() + handler // Main thread ve SupervisorJob kullanılır ) override fun onCleared() { // ViewModel temizlendiğinde çalışır viewModelScope.coroutineContext.cancelChildren() // Tüm çocuk coroutineleri iptal eder } }
// Özelleştirilmiş istisna işleyicisiyle Spring örneği @Configuration class CoroutineScopeConfiguration { @Bean fun coroutineDispatcher(): CoroutineDispatcher = // CoroutineDispatcher'ı IO için sınırlı paralellik ile oluşturur Dispatchers.IO.limitedParallelism(50) @Bean fun coroutineExceptionHandler( monitoringService: MonitoringService, // İzleme servisi ile hata işleyici oluşturulur ) = CoroutineExceptionHandler { _, throwable -> monitoringService.reportError(throwable) // Hata meydana geldiğinde izleme servisi üzerinden raporlanır } @Bean fun coroutineScope( coroutineDispatcher: CoroutineDispatcher, // CoroutineDispatcher, önceki tanımla sağlanır coroutineExceptionHandler: CoroutineExceptionHandler, // İstisna işleyici, önceki tanımla sağlanır ) = CoroutineScope( // Özel bir CoroutineScope oluşturulur SupervisorJob() + // SupervisorJob, alt görevlerin kontrol edilmesini sağlar coroutineDispatcher + // Dispatcher, asenkron işlemler için belirlenir coroutineExceptionHandler // İstisna işleyici, hataları ele almak için eklenir ) }
runBlocking fonksiyonunu dakullanabiliriz. Bu fonksiyon, bir coroutine başlatır ve bu coroutine bitene kadar mevcut iş parçacığını (
thread) bloklar. Bu nedenle,
runBlocking yalnızca bir iş parçacığını bloklamak istediğimizde kullanılmalıdır.Kullanımının en yaygın iki nedeni şunlardır:
mainfonksiyonunu sarmak için. Bu,runBlocking'in doğru bir kullanım şeklidir çünkürunBlockingtarafından
başlatılan coroutine bitene kadar iş parçacığını bloklamak zorundayız.- Test fonksiyonlarını sarmak için. Bu durumda da test iş parçacığını bloklamamız gerekir, böylece test, coroutine
tamamlanana kadar çalışmaya devam eder.
import kotlinx.coroutines.runBlocking annotation class Test // Test fonksiyonlarını tanımlayan özel bir annotation (işaretleyici) sınıfı fun main(): Unit = runBlocking { // Main fonksiyonu bir coroutine içinde çalıştırılır // ... } class SomeTests { // Test sınıfı @Test // Test olarak işaretlenmiş bir fonksiyon fun someTest() = runBlocking { // Test fonksiyonu bir coroutine içinde çalıştırılır // ... } }
main fonksiyonunu coroutineScope veya testlerde runTestile askıya alabiliriz. Bu,
runBlocking kullanımından kaçınmamız gerektiği anlamına gelmez, bazı durumlardaihtiyaçlarımız için yeterli olabilir.
import kotlinx.coroutines.coroutineScope // coroutineScope fonksiyonunu import eder import kotlinx.coroutines.test.runTest // runTest fonksiyonunu testler için import eder annotation class Test // Test fonksiyonlarını işaretlemek için kullanılan annotation sınıfı suspend fun main(): Unit = coroutineScope { // Main fonksiyonu bir coroutine içinde çalıştırılır // ... } class SomeTests { // Test sınıfı @Test // Test olarak işaretlenmiş bir fonksiyon fun someTest() = runTest { // Test fonksiyonu runTest ile çalıştırılır // ... } }
runBlocking kullanımından kaçınmalıyız. Unutmayın ki runBlocking mevcut iş parçacığını (thread)bloklar, bu da Kotlin Coroutines'te kaçınılması gereken bir durumdur.
runBlocking'i yalnızca mevcut iş parçacığınıkasıtlı olarak bloklamak istediğinizde kullanın.
class NotificationsSender( private val client: NotificationsClient, // Bildirimleri gönderen istemci private val notificationScope: CoroutineScope, // Bildirim göndermek için kullanılan scope (kapsam) ) { @Measure // Fonksiyonun çalışma süresi ölçülür fun sendNotifications(notifications: List<Notification>) { val jobs = notifications.map { notification -> // Her bildirim için bir iş (job) başlatılır scope.launch { // Bildirim gönderme işlemi coroutine içinde başlatılır client.send(notification) } } // Burada iş parçacığını bloklarız // Tüm bildirimler gönderilene kadar, fonksiyonun çalışması ölçülecektir // Böylece fonksiyonun doğru çalışma süresi ölçümü yapılır runBlocking { jobs.joinAll() } // Tüm işlemlerin tamamlanmasını bekleriz } }
onEach içinde işleriz, flow'umuzu başka bir coroutineiçinde
launchIn kullanarak başlatırız, flow başladığında bir işlem yapmak için onStart kullanırız, flowtamamlandığında bir işlem yapmak için
onCompletion kullanırız ve istisnaları catch ile yakalarız. Eğer bir flowiçinde meydana gelebilecek tüm istisnaları yakalamak istiyorsak,
catch'i son sırada belirtmeliyiz4Ayrıntılar için bkz. “Flow Yaşam Döngüsü Fonksiyonları (Flow lifecycle functions)” bölümü..fun updateNews() { newsFlow() // Haberleri döndüren flow başlatılır .onStart { showProgressBar() } // Flow başlamadan önce progress bar (yükleme çubuğu) gösterilir .onCompletion { hideProgressBar() } // Flow tamamlandığında progress bar gizlenir .onEach { view.showNews(it) } // Her bir haber öğesi için view'ı günceller .catch { view.handleError(it) } // Herhangi bir hata oluşursa, hatayı view'da gösterir .launchIn(viewModelScope) // Flow, viewModelScope içinde başlatılır }
MutableStateFlow (değiştirilebilir StateFlow) türündeki özellikler içindeview model sınıflarında temsil etmek popülerdir5Ayrıntılar için bkz. “SharedFlow ve StateFlow” bölümü.. Bu özellikler, değişikliklerine göre view'ı güncelleyen
coroutineler tarafından gözlemlenir.
class NewsViewModel : BaseViewModel() { private val _loading = MutableStateFlow(false) // Yükleme durumu için StateFlow oluşturulur val loading: StateFlow<Boolean> = _loading // Yükleme durumu dışarıya okunabilir hale getirilir private val _news = MutableStateFlow(emptyList<News>()) // Haberler için StateFlow oluşturulur val news: StateFlow<List<News>> = _news // Haberler dışarıya okunabilir hale getirilir fun onCreate() { newsFlow() // Haber akışı başlatılır .onStart { _loading.value = true } // Akış başladığında yükleme durumu true yapılır .onCompletion { _loading.value = false } // Akış tamamlandığında yükleme durumu false yapılır .onEach { _news.value = it } // Her yeni haberle _news güncellenir .catch { _failure.value = it } // Hata durumunda _failure güncellenir .launchIn(viewModelScope) // Akış viewModelScope içinde çalıştırılır } } class LatestNewsActivity : AppCompatActivity() { @Inject val newsViewModel: NewsViewModel // ViewModel dependency injection ile eklenir override fun onCreate(savedInstanceState: Bundle?) { // ... launchOnStarted { // Akış başladığında çalışacak coroutine başlatılır newsViewModel.loading.collect { // loading StateFlow'u dinlenir progressBar.visbility = // Yükleme durumu progress bar'ı günceller if (it) View.VISIBLE else View.GONE } } launchOnStarted { // Akış başladığında çalışacak diğer coroutine başlatılır newsViewModel.news.collect { // news StateFlow'u dinlenir newsList.adapter = NewsAdapter(it) // Haberler listesine adapte edilir } } } }
stateIn metodunu kullanabiliriz.started parametresine bağlı olarak, bu flow başlangıçta hemen (eagerly) başlatılabilir (bu sınıf başlatıldığında),tembel bir şekilde (lazy) başlatılabilir (ilk eşzamanlı işlem (coroutine) verileri toplamaya başladığında) veya abone
olunduğu sürece (while subscribed) başlatılabilir6Tüm bu seçenekler için bkz. “SharedFlow ve StateFlow” bölümü, “shareIn” ve “stateIn” alt başlıkları..
class NewsViewModel : BaseViewModel() { private val _loading = MutableStateFlow(false) // Yükleme durumu için StateFlow oluşturulur val loading: StateFlow<Boolean> = _loading // Yükleme durumu dışarıya okunabilir hale getirilir val newsState: StateFlow<List<News>> = newsFlow() // Haberleri döndüren flow başlatılır .onStart { _loading.value = true } // Akış başladığında yükleme durumu true yapılır .onCompletion { _loading.value = false } // Akış tamamlandığında yükleme durumu false yapılır .catch { _failure.value = it } // Hata durumunda _failure güncellenir .stateIn( // StateFlow başlatılır scope = viewModelScope, // viewModelScope içinde çalıştırılır started = SharingStarted.Lazily, // Flow, ilk abone olunduğunda başlatılır initialValue = emptyList(), // Başlangıç değeri boş liste olarak atanır ) }
class LocationsViewModel( locationService: LocationService // LocationService kullanılarak locationService parametresi alınır ) : ViewModel() { private val location = locationService.observeLocations() // Locations akışını başlatır .map { it.toLocationsDisplay() } // Location verilerini LocationsDisplay formatına dönüştürür .stateIn( // StateFlow başlatılır scope = viewModelScope, // Flow, viewModelScope içinde çalıştırılır started = SharingStarted.Lazily, // Flow, ilk abone olunduğunda başlatılır initialValue = LocationsDisplay.Loading, // Başlangıç değeri Loading (yükleme) olarak atanır ) // ... }
olaylar veya güncellemeler için ise SharedFlow kullanılmalıdır.
class UserProfileViewModel { private val _userChanges = // Kullanıcı değişikliklerini tutan MutableSharedFlow oluşturulur MutableSharedFlow<UserChange>() val userChanges: SharedFlow<UserChange> = _userChanges // Değişiklikler SharedFlow olarak dışa açılır fun onCreate() { viewModelScope.launch { // viewModelScope içinde bir coroutine başlatılır userChanges.collect(::applyUserChange) // userChanges dinlenir ve applyUserChange fonksiyonu ile işlenir } } fun onNameChanged(newName: String) { // ... _userChanges.emit(NameChange(newName)) // İsim değişikliği ile yeni bir NameChange olayı yayımlanır } fun onPublicKeyChanged(newPublicKey: String) { // ... _userChanges.emit(PublicKeyChange(newPublicKey)) // PublicKey değişikliği ile yeni bir PublicKeyChange olayı yayımlanır } }
- 1.Ayrıntılar için bkz. “Bir coroutine scope (iş kapsamı) oluşturma” bölümü. ↩
- 2.SupervisorJob’un nasıl çalıştığını öğrenmek için bkz. “İstisna Yönetimi” bölümü. ↩
- 3.Ayrıntılar için bkz. “Bir coroutine scope (iş kapsamı) oluşturma” bölümü. Dispatchers ve istisna işleyicileri hakkında bilgi için sırasıyla “İş Parçacığı Yöneticileri (Dispatchers)” ve “İstisna Yönetimi” bölümlerine bakınız. ↩
- 4.Ayrıntılar için bkz. “Flow Yaşam Döngüsü Fonksiyonları (Flow lifecycle functions)” bölümü. ↩
- 5.Ayrıntılar için bkz. “SharedFlow ve StateFlow” bölümü. ↩
- 6.Tüm bu seçenekler için bkz. “SharedFlow ve StateFlow” bölümü, “shareIn” ve “stateIn” alt başlıkları. ↩