Android Süreçler ve Yönetimi

Android’de Thread ve Handler, çoklu iş parçacığı (multithreading) yönetiminde birlikte kullanılan iki temel yapıdır.

Android’de UI (kullanıcı arayüzü) işlemleri sadece ana thread’de (UI thread) yapılabilir. Arka plan işlemleri (ağ isteği, veritabanı işlemi, dosya okuma/yazma) için ayrı thread’ler açmanız gerekir. Ancak bu thread’ler UI’ı doğrudan güncelleyemez.

Handler, farklı thread’ler arasında mesaj ve runnable nesneleri göndermenizi/işlemenizi sağlayan bir mekanizmadır. Genellikle bir arka plan thread’inden UI thread’ine veri göndermek için kullanılır.

public class MainActivity extends AppCompatActivity {
    
    // UI thread'de oluşturulan Handler
    private Handler uiHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            // Bu kod UI thread'de çalışır
            switch (msg.what) {
                case 1:
                    String data = msg.getData().getString("key");
                    textView.setText(data);
                    break;
            }
        }
    };
    
    private void startBackgroundWork() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // Bu kod arka plan thread'inde çalışır
                String result = doHeavyWork();
                
                // UI'ı güncellemek için Handler'a mesaj gönder
                Message message = new Message();
                message.what = 1;
                Bundle bundle = new Bundle();
                bundle.putString("key", result);
                message.setData(bundle);
                uiHandler.sendMessage(message);
            }
        }).start();
    }
}

public class MainActivity extends AppCompatActivity {
    
    private Handler uiHandler = new Handler(Looper.getMainLooper());
    
    private void startBackgroundWork() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // Arka plan işlemi
                String result = doHeavyWork();
                
                // UI güncellemesini UI thread'e post et
                uiHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        // Bu kod UI thread'de çalışır
                        textView.setText(result);
                    }
                });
            }
        }).start();
    }
}

HandlerThread, kendi message queue’su ve looper’ı olan bir thread’dir. Uzun ömürlü arka plan işlemleri için idealdir.

public class MyActivity extends AppCompatActivity {
    
    private Handler backgroundHandler;
    private HandlerThread backgroundThread;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        // HandlerThread oluştur ve başlat
        backgroundThread = new HandlerThread("MyBackgroundThread");
        backgroundThread.start();
        
        // Bu Handler arka plan thread'inde çalışır
        backgroundHandler = new Handler(backgroundThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                // Bu kod BACKGROUND thread'inde çalışır
                switch (msg.what) {
                    case 1:
                        doHeavyWork();
                        break;
                }
            }
        };
    }
    
    private void startBackgroundTask() {
        // Arka plan thread'ine mesaj gönder
        backgroundHandler.sendEmptyMessage(1);
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // Thread'i temizle
        backgroundThread.quitSafely();
    }
}

Looper, bir thread’in mesaj kuyruğunu (message queue) işleten döngüdür. Her thread’in bir looper’ı olmayabilir.

• UI Thread: Otomatik olarak bir Looper’a sahiptir
• Normal Thread: Varsayılan olarak Looper’ı yoktur

// Kendi Looper'ı olan thread oluşturma
class LooperThread extends Thread {
    public Handler mHandler;
    
    @Override
    public void run() {
        // Looper'ı hazırla
        Looper.prepare();
        
        // Handler'ı oluştur
        mHandler = new Handler(Looper.myLooper()) {
            @Override
            public void handleMessage(Message msg) {
                // Mesajları işle
            }
        };
        
        // Döngüyü başlat
        Looper.loop();
    }
}

Handler ile gecikmeli işlemler de yapabilirsiniz:

// 3 saniye sonra çalışacak işlem
uiHandler.postDelayed(new Runnable() {
    @Override
    public void run() {
        // Gecikmeli işlem
        textView.setText("3 saniye geçti");
    }
}, 3000);

// Zamanlayıcıyı iptal etme
uiHandler.removeCallbacksAndMessages(null);

Günümüz Android geliştirmesinde, raw Thread + Handler yerine coroutines tercih edilir:

lifecycleScope.launch(Dispatchers.IO) {
    val result = doHeavyWork()
    withContext(Dispatchers.Main) {
        textView.text = result
    }
}

Bileşen	Görevi	Çalıştığı Thread
Thread	Arka plan işlemini çalıştırır	Kendi thread’i
Handler	Mesaj/runnable gönderir ve işler	Oluşturulduğu thread
Looper	Mesaj kuyruğunu işletir	Bulunduğu thread
Message	Veri taşıyan nesne	–
Runnable	Çalıştırılacak kod bloğu	Handler’ın thread’i