yoklateknik mülakat
GelişimGeçmiş

Java Backend Mülakat Soruları

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

Gerçek simülasyonu dene →

Örnek sorular

Java ConcurrencyZorluk 1
İster class Worker extends Thread ister class Worker implements Runnable yazın, thread'in çalıştıracağı kodu tek bir metodu override/implement ederek tanımlarsınız. Hangisi?
  • astart()
  • bcall()
  • crun()✓
  • dexecute()
Açıklama:İster Thread'den türetilsin ister Runnable implement edilsin, thread'in işi run() içinde tanımlanır. start() ise yeni bir OS thread'i başlatır ve içeride run()'ı çağırır; 'işi başlatmak' için doğrudan run() çağrılmamalıdır.
Java ConcurrencyZorluk 2
class DemoThread extends Thread {
    public void run() {
        System.out.println("run: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        DemoThread t = new DemoThread();
        t.run();
        System.out.println("main: " + Thread.currentThread().getName());
    }
}

İlk satırda thread adı olarak ne yazdırılır?
  • amain✓
  • bYeni bir thread adı, örn. Thread-0
  • cÇalışma zamanında IllegalThreadStateException fırlatır
  • dnull, çünkü thread hiç başlatılmadı
Açıklama:t.run() çağrısı doğrudan sıradan bir metot çağrısıdır — yeni bir thread oluşmaz. Bu yüzden run() içindeki Thread.currentThread() hâlâ kendisini çağıran thread'i, yani main'i işaret eder ve 'main' yazdırılır. Sadece t.start() gerçekten yeni bir thread başlatır.
Java ConcurrencyZorluk 2
class Counter {
    private int count = 0;
    public void increment() { count++; }
    public int get() { return count; }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Runnable task = () -> {
            for (int i = 0; i < 100_000; i++) counter.increment();
        };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println(counter.get());
    }
}

Sonuçta yazdırılan değer için ne söylenebilir?
  • aHer zaman tam olarak 200000 yazdırır, istisnasız
  • bConcurrentModificationException fırlatır
  • cHer zaman tam olarak 100000 yazdırır, her çalıştırmada
  • dKesin bir değer garanti edilmez — count++ yarışa girdiği için kayıp güncellemeler yüzünden 200000'den az çıkabilir✓
Açıklama:count++ atomik olmayan, oku-değiştir-yaz şeklinde birleşik bir işlemdir. İki thread senkronizasyon olmadan eşzamanlı çalıştığında güncellemeler iç içe geçip kaybolabilir; bu yüzden belirli bir sonuç garanti edilmez — kayıp güncellemeler yüzünden 200000'den az çıkabilir.
Java ConcurrencyZorluk 2
Callable<V> ile Runnable'ı doğru ayıran ifade hangisidir?
  • aCallable yalnızca Thread ile kullanılabilir, ExecutorService ile asla kullanılamaz
  • bCallable'ın call()'ı değer döndürebilir ve checked exception bildirebilir; run() ikisini de yapamaz✓
  • cGerçek bir fark yoktur; ikisi derleyici tarafından birbirinin yerine kullanılır
  • dRunnable, run() ile değer döndürebilir ama Callable asla döndüremez
Açıklama:Callable<V>.call() V tipinde bir değer döndürebilir ve checked exception fırlatabilir. Runnable.run() ise void döner ve checked exception bildiremez. Bu yüzden sonuç veya checked exception iletilmesi gerektiğinde ExecutorService.submit() ile Callable kullanılır.
Java ConcurrencyZorluk 2
public class Printer {
    public synchronized void printTicket(int id) {
        System.out.print("[" + id);
        System.out.println("]");
    }
}

İki thread, AYNI Printer nesnesi üzerinde farklı id'lerle sürekli printTicket() çağırıyor. synchronized burada neyi garanti eder?
  • aİki thread daha yüksek verim için printTicket()'ı gerçekten paralel çalıştırır
  • bDeğiştirilen alan ayrıca volatile olarak işaretlenmedikçe hiçbir etkisi yoktur
  • cHer printTicket() çağrısı, başka thread girmeden önce tek bir birim olarak biter✓
  • did'lerin kesinlikle artan sayısal sırayla yazdırılacağını garanti eder
Açıklama:synchronized bir instance metodu, çalışmadan önce this nesnesinin monitörünü alır ve çıkışta serbest bırakır; bu yüzden aynı nesne üzerindeki eşzamanlı çağrılar sıralı hale gelir — biri tamamen bitmeden diğeri başlamaz. id sırası veya paralellik hakkında bir garanti vermez.
Java ConcurrencyZorluk 1
ExecutorService pool = Executors.newFixedThreadPool(2);
pool.submit(() -> System.out.println("task 1"));
pool.submit(() -> System.out.println("task 2"));
pool.shutdown();

pool.shutdown() burada ne yapar?
  • aÇalışmakta olan iki görevi hemen ve zorla sonlandırır
  • bJVM'in kendisi sonlanana kadar çağıran thread'i süresiz bloklar
  • cİki görevi hiç çalıştırmadan sessizce havuzdan kaldırır
  • dYeni görev gönderimlerini reddeder ama zaten gönderilmiş görevlerin bitmesine izin verir✓
Açıklama:ExecutorService.shutdown() düzenli bir kapatma başlatır: önceden gönderilen görevler çalıştırılır ama yeni görev kabul edilmez. Çalışan görevleri kesmez ve çağıran thread'i bloklamaz.

Kıdeme göre

Backend JuniorBackend MidBackend Senior

Diğer alanlar

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

3300 soruluk Backend bankasında kendini sına.

Mülakata başla