yoklateknik mülakat
GelişimGeçmiş

Backend Rs Async Runtime Futures Mülakat Soruları

75 doğrulanmış Backend Rs Async Runtime Futures mülakat sorusu — cevaplarıyla çöz, açıklamalarıyla öğren, gerçek simülasyonda kendini test et.

Gerçek simülasyonu dene →

Örnek sorular

Rs Async Runtime FuturesZorluk 1
async fn work() {
    println!("work ran");
}

#[tokio::main]
async fn main() {
    let f = work();
    println!("created future");
    f.await;
}

Bu program ne yazdırır?
  • aÖnce work ran, sonra created future, gövde tam çağrı anında başlar
  • bÖnce created future, sonra work ran✓
  • cYalnız created future; future poll edilmeden düşürülür
  • dDerlenmez; bir future her zaman yaratıldığı yerde await edilmek zorundadır
Açıklama:Bir async fn çağrısı yalnızca bir future kurar, başka bir şey yapmaz. Gövde ancak future poll edilince, yani f.await noktasında çalışır. Bu yüzden main içindeki println! önce koşar, work ran sonra gelir. Rust 1.98 / tokio 1.x ile ölçüldü: created future satırı work ran satırından önce basılıyor.
Rs Async Runtime FuturesZorluk 1
async fn fetch() -> i32 { 1 }

fn main() {
    let x = fetch().await;
    println!("{x}");
}

Bu dosya derlendiğinde ne olur?
  • a1 basar; .await için örtük bir runtime yaratılır
  • bDerlenir, sonra çalışma zamanında there is no reactor running ile panic eder
  • cHiçbir şey basmaz; future hiç poll edilmeden düşürülür
  • dDerleme hatası E0728: async bağlam dışında await✓
Açıklama:.await yalnızca async bağlam içinde yazılabilen bir dil yapısıdır. Düz fn main senkron olduğu için rustc dosyayı daha runtime sorusu gündeme gelmeden E0728 ile reddeder. Senkron bir main içinden future sürmek için bir executor gerekir: #[tokio::main] ya da açık Runtime::block_on.
Rs Async Runtime FuturesZorluk 1
#[tokio::main] özniteliği bir async fn main'i fiilen neye dönüştürür?
  • aİşletim sisteminin yükleyicisinin asenkron sürdüğü özel bir giriş noktasına
  • bBir Runtime kurup asıl async gövde üzerinde block_on çağıran senkron bir fn main'e✓
  • cGövdeyi arka plan thread'ine spawn edip işletim sistemine hemen dönen bir fonksiyona
  • dDerleyicinin yerleşik executor'ına kaydedilen, ana thread'de poll edilen bir main'e
Açıklama:Rust'ta yerleşik executor yoktur ve async fn main derleyici tarafından E0752 ile reddedilir. Makro fonksiyonu sıradan senkron bir main'e çevirir: bir Runtime kurar (varsayılan multi-thread) ve asıl gövde üzerinde bloklar. İşletim sistemi ya da derleyici açısından özel bir yanı yoktur.
Rs Async Runtime FuturesZorluk 2
use std::time::Duration;

async fn a() {
    tokio::time::sleep(Duration::from_millis(50)).await;
    println!("a done");
}
async fn b() {
    tokio::time::sleep(Duration::from_millis(10)).await;
    println!("b done");
}

#[tokio::main]
async fn main() {
    tokio::join!(a(), b());
    println!("both");
}

Satırlar hangi sırayla görünür?
  • ab done, a done, both; iki sleep aynı anda koşar✓
  • ba done, b done, both; join! argümanlarını yazıldığı sırayla poll eder
  • cÖnce both, ardından a done ve b done belirsiz bir sırada
  • dDerleme başarısız: join! yalnız tokio::spawn'ın döndürdüğü JoinHandle'ları kabul eder
Açıklama:join! tüm future'larını aynı task üzerinde poll eder ve hepsi bitince tamamlanır. İki sleep aynı anda başlar; 10 ms'lik olan önce biter ve b done basılır, 50 ms sonra a done, en son both. Argüman sırası onları sıralı çalıştırmaz.
Rs Async Runtime FuturesZorluk 2
#[tokio::main]
async fn main() {
    let h = tokio::spawn(async { 5 });
    let v: i32 = h.await;
    println!("{v}");
}

Bu neden derlenmez?
  • atokio::spawn bir async move bloğu ister, düz async blok spawn edilemez
  • bJoinHandle<i32> await edilince Result<i32, JoinError> döner, bu yüzden çıplak i32 uyuşmaz✓
  • cJoinHandle doğrudan await edilemez; tokio::join!'e verilmesi gerekir
  • dSpawn edilen blok () döndürür; 5 ifadesinin sonunda noktalı virgül yok
Açıklama:Spawn edilen bir task panic edebilir ya da iptal edilebilir; bu yüzden JoinHandle<T> await edilince Result<T, JoinError> üretir. rustc E0308 (mismatched types) verir ve .expect(...) önerir. h.await.unwrap() yazmak ya da ? ile yaymak sorunu çözer. Blok 5 döndürür; yakalaması olmayan düz bir async blok da spawn edilebilir.
Rs Async Runtime FuturesZorluk 2
use std::time::Duration;

#[tokio::main]
async fn main() {
    let h = tokio::spawn(async {
        tokio::time::sleep(Duration::from_millis(20)).await;
        println!("task finished");
    });
    drop(h);
    tokio::time::sleep(Duration::from_millis(60)).await;
    println!("main done");
}

Ne yazdırılır?
  • aÖnce task finished, sonra main done; task koparılmış hâlde sürer✓
  • bYalnız main done; JoinHandle düşürülünce task iptal edilir
  • cYalnız main done; handle'ı kaybolan task bir daha asla poll edilmez
  • dPanic: JoinHandle düşürülmeden önce await ya da abort edilmek zorundadır
Açıklama:JoinHandle düşürülünce task koparılır (detach), runtime üzerinde çalışmaya devam eder. Ölçülen çıktı task finished, ardından main done. İptal için açık abort() çağrısı ya da runtime'ın tamamının düşürülmesi gerekir. Spawn edilmemiş bir future'ı düşürmekten kasıtlı olarak farklıdır; o gerçekten iptal eder.

Uzmanlığa göre

C#/.NET 450Go 450Java 450Node.js 450PHP 450Python 450Rust 450

Kıdeme göre

Backend JuniorBackend MidBackend Senior

Diğer alanlar

FrontendFullstackDevOps / CloudAI EngineerVeritabanıMobilGüvenlikQA / Test OtomasyonuData EngineerOyun GeliştirmeML Engineer

3750 soruluk Backend bankasında kendini sına.

Mülakata başla