Programowanie współbieżne - Java - pytanie

Cześć, sprawa jest następująca. Jutro mam kolosa z PW i było pytanie (rano pisała jedna z grup - ja mam jutro) : Która z metod tworzenia wątków jest bardziej elastyczna (dziedziczenie Thread vs Runnable) i wyjaśnij dlaczego. Wg. mnie Runnable( z tego co wiem, to Java nie dopuszcza dziedziczenia wielobazowego), ale jak zacznę od siebie pisać głupoty to on to zadanie skreśli i da 0, albo nawet ujemne. Dość ciężki prowadzący i proszę o pomoc Was - programistów o krótkie i dosadne wyjaśnienie, bym mógł to dobrze napisać. Pozdrawiam.

Porównywanie Thread i Runnable jest trochę bez sensu, ponieważ to jak porównywać koło i silnik - potrzebujemy obu aby nasz samochód się poruszał. Podobnie potrzebujemy obiektu klasy Thread aby uruchomić obiekt klasy Runnable.

No właśnie też się nad tym zastanawiałem, ale było takie pytanie w jednej z grup, to co ja na to poradzę. Pewnie chodzi o pisanie wątków przez implementację interfejsu Runnable czy przez dziedziczenia

Ja np. spotkałem się z takim podejściem Thread vs Runnable:

Drugi sposób tworzenia i uruchamiania wątków ma pewne zalety w stosunku do korzystania wyłącznie z klasy Thread (czyli omówionego wcześniej sposobu pierwszego):

niekiedy daje lepsze możliwości separowania kodu  (kod odpowiedzialny za pracę wątku może być wyraźnie wyodrębniony w klasie implementującej Runnable).
a w  niektórych okolicznościach  - mianowicie, gdy chcemy umieścić metodę run() w klasie, która dziedziczy jakąś inną klasę - jest jedynym możliwym sposobem.

Pytanie jest, która jest bardziej elastyczna, nie lepsza/wydajniejsza/whatever, dlatego moja odpowiedź to tworzenie Threadów podając Runnable jako argument.

Możemy podać Runnable w jaki sposób chcemy (lambdy, klasy anonimowe itd.), nawet możemy zrobić takie coś (z pewnością to nie jest dobre, no ale jest elastyczne):

...
Runnable runnable = null;

if(user.isLoggedIn())
    runnable = () -> user.logout();
else
    runnable = () -> user.logIn();

new Thread(runnable).start();

Tworząc klasę rozszerzającą Thread też można takie rzeczy robić, ale trzeba bardziej pokombinować.

Chodzi o takie konstrukcje:

    static void threads(){


        Thread myThread = new Thread()
        {
            @Override
            public void run()
            {
                System.out.println("Thread is working");
            }
        };

        myThread.start();
    }

Zamiast

        Runnable runnable = new Runnable()
        {
            @Override
            public void run()
            {
                System.out.println("Thread is processing Runnable");
            }
        };

        new Thread(runnable).start();

Preferowane jest drugie podejście ponieważ:
Jeżeli możemy implementować zamiast dziedziczyć to implementujemy - powodów jest sporo - np. wielodziedziczenie, rozdzielenie deklaracji od implementacji i pewnie masa innych, które mi teraz nie przychodzą do głowy :)
Implementacja Runnable jest jednoznacznie i wyłącznie odpowiedzialna za wyświetlenie komunikatu, a obiekt Thread za obsługę wielobieżności - (S)OLID
Można sobie wyobrazić odmienne implementacje Thread (np. rozrzucające zadania po całym klastrze obliczeniowym) - unikniemy konieczności przerabiania wszystkich miejsc w aplikacji.
Separacja pozwala nam np. na stworzenie puli wątków przetwarzających kolejne obiekty runnable.