Thread-uri în Java — Thread, Runnable, ExecutorService

In this tutorial, you'll learn about Thread. We cover key concepts, practical examples, and best practices.

Thread-urile în Java permit execuția concurentă a codului, iar clasele Thread, Runnable și ExecutorService oferă mecanisme flexibile pentru crearea și gestionarea firelor de execuție în aplicații multi-threading.

The Problem

Operațiile lente (I/O, calcule grele) blochează întreaga aplicație. Acest quick-fix îți arată cum să creezi și să gestionezi thread-uri pentru execuție concurentă eficientă.

The Wrong Way

while (true) {
    String result = slowNetworkCall();  // blochează totul
    process(result);
}

The Right Way

import java.util.concurrent.*;

ExecutorService executor = Executors.newFixedThreadPool(4);

for (int i = 0; i < 10; i++) {
    executor.submit(() -> {
        String result = slowNetworkCall();
        process(result);
    });
}

executor.shutdown();

Step-by-Step Fix

1. Folosește Runnable pentru task-uri simple

Runnable task = () -> {
    System.out.println("Running in thread: " +
        Thread.currentThread().getName());
};
new Thread(task).start();

2. Folosește Callable pentru task-uri cu rezultat

Callable<Integer> task = () -> {
    return expensiveCalculation();
};
Future<Integer> future = executor.submit(task);
Integer result = future.get();  // așteaptă rezultatul

3. Gestionează thread pool-ul cu ExecutorService

ExecutorService exec = Executors.newFixedThreadPool(4);
exec.execute(runnable);               // Runnable, fără rezultat
Future<T> f = exec.submit(callable);  // Callable, cu rezultat
exec.shutdown();                       // nu mai acceptă task-uri noi
exec.awaitTermination(10, TimeUnit.SECONDS);

Prevention Tips

• Nu crea thread-uri manual cu new Thread() — folosește ExecutorService pentru reutilizare
• Folosește newCachedThreadPool() pentru task-uri scurte, newFixedThreadPool() pentru workload constant
• Întotdeauna oprește executorul cu shutdown() pentru a preveni memory leaks
• Folosește CompletableFuture pentru operații asincrone complexe

Common Mistakes

1. Crearea thread-urilor noi pentru fiecare task — overhead mare. Folosește thread pool.
2. Uitarea lui shutdown() — aplicația nu se termină, thread-urile rămân în viață.
3. Accesul la variabile partajate fără sincronizare — date corupte. Folosește synchronized sau Atomic* clase.

FAQ

Construit de dezvoltatorii Doda Browser, DodaZIP și Durga Antivirus Pro. Instrumentele DodaTech se integrează perfect cu Java pentru productivitate și securitate sporite.