Programowanie Współbieżne w Języku JAVA

Rozwiązanie — ScheduledExecutorService

import java.util.concurrent.*;

public class BonjourTask {
    public static void main(String[] args) throws Exception {
        ScheduledExecutorService executor =
            Executors.newScheduledThreadPool(1);
        final int[] count = {0};

        executor.scheduleAtFixedRate(() -> {
            System.out.println("Bonjour");
            count[0]++;
            if (count[0] >= 10) executor.shutdown();
        }, 0, 1, TimeUnit.SECONDS);
    }
}

sleep() traci precyzję bo nie uwzględnia czasu wykonania ciała pętli. scheduleAtFixedRate() uruchamia od momentu bazowego co dokładnie 1s.

Rozwiązanie — blok strzeżony (wait/notify)

public class MailBox {
    private boolean letterDelivered = false;
    private boolean letterReceived  = false;

    // Listonosz: wkłada list, czeka na potwierdzenie
    public synchronized void deliver() throws InterruptedException {
        letterDelivered = true;
        notifyAll();                      // budzi adresata
        while (!letterReceived) wait(); // czeka na potwierdzenie
        System.out.println("Listonosz: potwierdzono odbiór");
    }

    // Adresat: czeka na list, potwierdza odbiór
    public synchronized void receive() throws InterruptedException {
        while (!letterDelivered) wait(); // czeka na list
        letterReceived = true;
        notifyAll();                      // budzi listonosza
        System.out.println("Adresat: odebrałem list");
    }
}

Oryginalny kod (synchronized) → ReentrantLock

import java.util.concurrent.locks.*;

public class AClass {
    private final Lock lock = new ReentrantLock();

    public void method1() {
        lock.lock();
        try {
            System.out.println("instrukcja1");
        } finally {
            lock.unlock(); // zawsze w finally!
        }
    }

    public void method2() {
        lock.lock();
        try {
            System.out.println("instrukcja2");
        } finally {
            lock.unlock();
        }
    }
}

Jeden zamek dla obu metod — tak jak synchronized na this, method1 i method2 wzajemnie się blokują. Dwa osobne zamki byłyby BŁĘDEM — metody mogłyby działać równolegle, co nie jest równoważne oryginałowi.

public class Main {
    public static void main(String[] args) {
        Thread[] ref = new Thread[2];

        ref[0] = new Thread(() -> {
            try {
                Thread.sleep(1000);
                ref[1].interrupt();  // przerywa thread2
                Thread.sleep(5000);  // czeka — musi żyć żeby thread2 mógł go przerwać!
            } catch (InterruptedException e) {
                System.out.println("thread1 przerwany przez thread2");
            }
        });

        ref[1] = new Thread(() -> {
            try {
                Thread.sleep(2000);
                System.out.println("thread2: 2s upłynęły");
            } catch (InterruptedException e) {
                System.out.println("thread2 przerwany przed 2s");
                ref[0].interrupt();  // przerywa thread1
            }
        });

        ref[0].start();
        ref[1].start();
    }
}

Kluczowe: thread1 po przerwaniu thread2 musi dalej czekać (sleep), żeby był jeszcze żywy kiedy thread2 spróbuje go przerwać. Bez drugiego sleep → thread1 jest TERMINATED i interrupt() nic nie robi.