Thread in JAVA: Ciclo di Vita, Sincronizzazione e Concorrenza

 METODO 1: extends Thread - sconsigliato ma da sapere
class MioThread extends Thread {
    @Override
    public void run() {
        System.out.println("Sono " + Thread.currentThread().getName() + " - ID: " + Thread.currentThread().getId());
    }
}

 METODO 2: implements Runnable - quello che voglio io
class MioTask implements Runnable {
    private String nome;
    public MioTask(String nome){ this.nome = nome; }
    @Override
    public void run() {
        for(int i=1;i<=3;i++){
            System.out.println(nome + " -> " + i + " su " + Thread.currentThread().getName());
            try { Thread.sleep(500); } catch (InterruptedException e){ Thread.currentThread().interrupt(); }
        }
    }
}

public class MainThread {
    public static void main(String[] args) {
        // ERRORE CHE VEDO SEMPRE: chiamare run() invece di start()
        // MioThread t = new MioThread(); t.run(); // SBAGLIATO: resta nel main, non è un thread!

        // GIUSTO:
        Thread t1 = new MioThread();
        t1.setName("Downloader-1");
        t1.start(); // NEW -> RUNNABLE

        Thread t2 = new Thread(new MioTask("Calcolo-A"));
        t2.start();

        // METODO CHE USO IO: lambda + Runnable - pulito e moderno
        Thread t3 = new Thread(() -> {
            System.out.println("Task lambda su " + Thread.currentThread().getName());
        }, "Lambda-Worker");
        t3.start();

        System.out.println("Main continua, non aspetta. Stato t1: " + t1.getState());
    }
}

 Caso d'uso: 3 download paralleli senza bloccare main
import java.util.concurrent.atomic.AtomicInteger;

public class DownloadManager {
    static AtomicInteger completati = new AtomicInteger(0);

    static Runnable creaDownload(String url){
        return () -> {
            String threadName = Thread.currentThread().getName();
            System.out.println("["+threadName+"] Inizio download: " + url);
            try {
                // Simulo rete lenta -> TIMED_WAITING
                Thread.sleep((long)(Math.random()*2000 + 500));
            } catch (InterruptedException e){ return; }
            int tot = completati.incrementAndGet();
            System.out.println("["+threadName+"] Finito " + url + " - Totale: " + tot + "/3");
        };
    }

    public static void main(String[] args) throws InterruptedException {
        Thread d1 = new Thread(creaDownload("foto1.jpg"), "DL-1");
        Thread d2 = new Thread(creaDownload("video.mp4"), "DL-2");
        Thread d3 = new Thread(creaDownload("doc.pdf"), "DL-3");

        long start = System.currentTimeMillis();
        d1.start(); d2.start(); d3.start();

        // Main fa altro nel frattempo
        System.out.println("[MAIN] Interfaccia libera, posso muovere il mouse...");

        // Aspetto che finiscano -> WAITING
        d1.join(); d2.join(); d3.join();

        System.out.println("[MAIN] Tutti finiti in " + (System.currentTimeMillis()-start) + "ms vs 4500ms sequenziale");
    }
}

class ContoCorrente {
    private int saldo = 0;

    // VERSIONE SBAGLIATA - 10 studenti su 10 lo sbagliano al primo colpo
    // public void deposita(int v){ saldo += v; } // read-modify-write NON atomico!

    // VERSIONE GIUSTA 1: synchronized - monitor dell'oggetto
    public synchronized void depositaSync(int v){
        saldo += v; // ora atomico rispetto ad altri synchronized sullo stesso oggetto
    }

    // VERSIONE GIUSTA 2: blocco esplicito - quello che uso io quando devo spiegare
    private final Object lock = new Object();
    public void depositaLock(int v){
        synchronized(lock){
            saldo += v;
        }
    }

    // VERSIONE GIUSTA 3: moderna, senza lock
    // private AtomicInteger saldoAtom = new AtomicInteger(0);
    // saldoAtom.addAndGet(v);

    public int getSaldo(){ return saldo; }
}

public class TestRace {
    public static void main(String[] args) throws InterruptedException {
        ContoCorrente conto = new ContoCorrente();

        Runnable task = () -> {
            for(int i=0;i<10000;i++) conto.depositaSync(1);
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start(); t2.start();
        t1.join(); t2.join();

        // Se usi metodo non synchronized vedrai 18743, 19231... casuale!
        System.out.println("Saldo atteso 20000, reale: " + conto.getSaldo());
    }
}

public class DeadlockDemo {
    static final Object forchetta1 = new Object();
    static final Object forchetta2 = new Object();

    public static void main(String[] args) {
        Thread filosofo1 = new Thread(() -> {
            synchronized(forchetta1){
                System.out.println("Filosofo1 ha forchetta1, vuole forchetta2...");
                try{ Thread.sleep(100); } catch(Exception e){}
                synchronized(forchetta2){ // aspetta per sempre se l'altro ha forchetta2
                    System.out.println("Filosofo1 mangia");
                }
            }
        }, "Filosofo-1");

        Thread filosofo2 = new Thread(() -> {
            synchronized(forchetta2){ // ORDINE INVERSO -> DEADLOCK!
                System.out.println("Filosofo2 ha forchetta2, vuole forchetta1...");
                try{ Thread.sleep(100); } catch(Exception e){}
                synchronized(forchetta1){
                    System.out.println("Filosofo2 mangia");
                }
            }
        }, "Filosofo-2");

        filosofo1.start(); filosofo2.start();

        // Come lo trovo? jps + jstack PID -> vi dice "Found 1 deadlock"
        // Fix: sempre stesso ordine di lock!
    }
}

import java.util.concurrent.*;
import java.util.*;

public class ModernoConcorrente {

    // METODO CLASSICO CHE USO IN 4A: ExecutorService
    public static void demoExecutor() throws Exception {
        // Io ho pensato di fare così: 4 thread = numero core della vostra VM in lab
        ExecutorService pool = Executors.newFixedThreadPool(4);

        List<Future<Integer>> futures = new ArrayList<>();
        for(int i=0;i<8;i++){
            int taskId = i;
            Future<Integer> f = pool.submit(() -> {
                System.out.println("Task " + taskId + " su " + Thread.currentThread().getName());
                Thread.sleep(500);
                return taskId * taskId;
            });
            futures.add(f);
        }

        for(Future<Integer> f : futures){
            System.out.println("Risultato: " + f.get()); // WAITING finché pronto
        }

        pool.shutdown(); // IMPORTANTE: altrimenti JVM non termina!
    }

    // METODO 2024+ CHE VI CHIEDERANNO AL COLLOQUIO: Virtual Thread
    public static void demoVirtualThread() throws Exception {
        // Con Java 21+
        try (ExecutorService vPool = Executors.newVirtualThreadPerTaskExecutor()) {
            for(int i=0;i<1000;i++){
                int id = i;
                vPool.submit(() -> {
                    try{
                        Thread.sleep(100); // I/O simulato: qui il virtual thread si stacca dal carrier
                        if(id % 200 == 0) System.out.println("Virtual task " + id + " su " + Thread.currentThread());
                    } catch(InterruptedException e){ Thread.currentThread().interrupt(); }
                });
            }
        } // chiude automatico
        System.out.println("1000 virtual thread finiti senza 1GB di RAM");
    }

    public static void main(String[] args) throws Exception {
        System.out.println("--- Executor Classico ---");
        demoExecutor();
        System.out.println("\n--- Virtual Thread (Java 21+) ---");
        // demoVirtualThread(); // scommentate se avete JDK 21
    }
}