package blatt12;

/*
   Runnable.run() - hier kommt die Implementierung rein, also das, was beim
                    Starten des Threads ausgeführt werden soll. Ruft man diese
                    Methode auf, wird sie einfach im aktuellen Thread ausgeführt
                    wie bisher. Rufe ich also in der main-Methode auf einem
                    Runnable die run()-Methode auf, wird diese einfach
                    sequentiell ausgeführt (eine ganz normale Methode also).
   Thread.run() -   ist vorgegeben und ruft ganz einfach r.run() auf dem
                    jeweiligen Runnable-Objekt r auf (vgl. oben). Ganz normale
                    sequentielle, nicht parallele Ausführung im aufrufenden
                    Thread (sofern r != null). Implementiere ich einen Thread
                    mittels Vererbung, so überschreibe ich die run-Methode der
                    Klasse Thread direkt. Trotzdem handelt es sich bis zu diesem
                    Punkt weiterhin um eine ganz normale, sequentielle Methode.
   Thread.start() - erzeugt einen neuen Thread und beauftragt diesen mit der
                    Ausführung der run()-Methode. Der neue erzeugte Thread kann
                    sich dann um die Ausführung kümmern, während der aktuelle
                    Thread einfach weiterarbeiten kann (parallel).
*/

/*
 * 1. Eigener Thread als Unterklasse von Thread.
 * Die Klasse Thread implementiert Runnable.
 */
class A extends Thread {
    @Override
    public void run() {
        System.out.println("A running");
    }
}

/**
 * 2. Eigene Klasse, die das Interface Runnable und daher eine run-Methode 
 * implementiert, die ein Thread dann ausführen kann.
 */
class B implements Runnable {
    @Override
    public void run() {
        System.out.println("B running");
    }
}

public class ThreadTest {

    public static void main(String[] args) {
        Thread t1 = new A();
        Thread t2 = new Thread(new B());
                
        t1.start();
        t2.start();
        
        //<editor-fold defaultstate="collapsed" desc="//Weitere Möglichkeit(en)">
        if (false) {
            // Klassen können genauso hier implementiert werden
            class C implements Runnable {
                @Override
                public void run() {
                    System.out.println("C running");
                }
            }

            Thread t3 = new Thread(new C());

            Thread t4 = new Thread(new Runnable(){
                @Override
                public void run() {
                    System.out.println("Unknown running");
                }
            });

            t3.start();
            t4.start();
        }
        //</editor-fold>
        
        System.out.println("Finished");
    }

}