Jaka jest różnica między thread start () a Runnable run()

Jeśli wywołasz bezpośrednio run(), zostanie ono wykonane w wątku wywołującym, tak jak każde inne wywołanie metody. Thread.start() jest wymagane, aby utworzyć nowy wątek, tak aby Metoda run runnable była wykonywana równolegle.

Różnica polega na tym, że Thread.start() uruchamia wątek, który wywołuje metodę run(), podczas gdy Runnable.run() po prostu wywołuje metodę run() w bieżącym wątku.

Różnica polega na tym, że gdy program wywoła metodę start(), tworzony jest nowy wątek, A kod wewnątrz run() jest wykonywany w nowym wątku: podczas gdy jeśli wywołasz metodę run() bezpośrednio, żaden nowy wątek nie zostanie utworzony, a kod wewnątrz run() będzie wykonywany bezpośrednio w bieżącym wątku.

Inną różnicą między start() i run() w wątku Java jest to, że nie można dwukrotnie wywołać start(). Po uruchomieniu drugie wywołanie start() rzuci IllegalStateException w Javie, podczas gdy można wywołać metodę run() kilka czasy, odkąd to zwykła metoda.

Faktycznie Thread.start() tworzy nowy wątek i ma własny scenariusz wykonania.

Thread.start() wywołuje asynchronicznie metodę run(), która zmienia stan nowego wątku na Runnable.

Ale Thread.run() nie tworzy żadnego nowego wątku. Zamiast tego uruchamia metodę run w bieżącym wątku synchronicznie.

Jeśli używasz Thread.run(), to w ogóle nie używasz funkcji wielowątkowości.

Invoke run() jest wykonywane w wątku wywołującym, jak każde inne wywołanie metody. natomiast Thread.start() tworzy nowy wątek. wywołanie run() jest błędem programowym.

Jeśli wykonasz run() w metodzie main, wątek metody main wywoła metodę run zamiast wątku wymaganego do uruchomienia.

Metoda start() tworzy nowy wątek, dla którego należy wykonać metodę run()

t.start() jest metodą, którą biblioteka zapewnia wywołanie kodu, gdy chcesz utworzyć nowy wątek.

r.run() jest metodą, którą ty zapewniasz biblioteka do wywołania W nowy wątek.

Większość z tych odpowiedzi pomija szerszą perspektywę, która polega na tym, że jeśli chodzi o język Java, nie ma większej różnicy między t.start() a r.run() Niż pomiędzy jakimikolwiek innymi metodami.

Największa różnica polega na tym, że większość kodu t.start() to kod natywny , podczas gdy w większości przypadków kod r.run() będzie czystą Javą. Ale to nie jest wielka różnica. Kod to kod. Natywny kod jest trudniejszy do znalezienia i trudniejszy do zrozumienia, gdy go znajdziesz, ale nadal jest to tylko kod, który mówi komputer co robić.

Więc co robi t.start()?

Tworzy nowy natywny wątek, organizuje, aby ten wątek wywołał t.run(), a następnie mówi systemowi, aby pozwolił nowemu wątkowi działać. Potem wraca.

A co robi r.run()?

Thread.start() kod rejestruje wątek za pomocą schedulera, a scheduler wywołuje metodę run(). Ponadto, {[2] } jest klasą, podczas gdy {[3] } jest interfejsem.

Punkty, że członkowie wykonane są w porządku, więc chcę tylko dodać coś. Chodzi o to, że JAVA nie obsługuje wielu dziedziczeń. Ale co jest, jeśli chcesz czerpać klasę B z innej klasy A, ale możesz czerpać tylko z jednej klasy. Problem polega teraz na tym, jak "czerpać" z obu klas: A i Thread. Dlatego możesz użyć interfejsu Runnable.

public class ThreadTest{
   public void method(){
      Thread myThread = new Thread(new B());
      myThread.start;
   }
}

public class B extends A implements Runnable{...

Jeśli bezpośrednio wywołujesz metodę run(), nie używasz funkcji wielowątkowej, ponieważ metoda run() jest wykonywana jako część wątku wywołującego.

Jeśli wywołasz metodę start() w wątku, wirtualna maszyna Javy wywoła metodę run() i dwa wątki będą działać jednocześnie-bieżący wątek (main() w twoim przykładzie) i inny wątek (Runnable r1 w twoim przykładzie).

Spójrz na kod źródłowy metody start() w klasie Thread

 /**
     * Causes this thread to begin execution; the Java Virtual Machine
     * calls the <code>run</code> method of this thread.
     * <p>
     * The result is that two threads are running concurrently: the
     * current thread (which returns from the call to the
     * <code>start</code> method) and the other thread (which executes its
     * <code>run</code> method).
     * <p>
     * It is never legal to start a thread more than once.
     * In particular, a thread may not be restarted once it has completed
     * execution.
     *
     * @exception  IllegalThreadStateException  if the thread was already
     *               started.
     * @see        #run()
     * @see        #stop()
     */
    public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
        start0();
        if (stopBeforeStart) {
            stop0(throwableFromStop);
        }
    }

    private native void start0();

W powyższym kodzie nie możesz patrz wywołanie do metody run().

private native void start0() jest odpowiedzialny za wywołanie metody run(). JVM wykonuje tę natywną metodę.

W pierwszym przypadku wywołujesz tylko metodę run() obiektów r1 i r2.

W drugim przypadku tworzysz 2 nowe wątki!

start() zadzwoni run() w pewnym momencie!

Metoda Run: - jest abstrakcyjną metodą pierwotnie utworzoną w interfejsie Runnable i nadpisaną w klasie Thread, a także podklasach Thread (jako że Thread implementuje Runnable w swoim kodzie źródłowym) i wszelkich innych klasach implementujących interfejs Runnable. - Służy do załadowania wątku (obiektu runnable) z zadaniem, które ma wykonać w ten sposób można nadpisać go do napisania tego zadania.

Metoda startu: - jest zdefiniowana w klasie Thread. Gdy metoda start jest wywoływana na Obiekt wątku 1- wywołuje wewnętrznie natywną (nonjava) metodę o nazwie start0 ();.

Start0 (); Metoda: jest odpowiedzialny za niskie przetwarzanie (tworzenie stosu dla wątku i przydzielanie wątku w kolejce procesora) w tym momencie mamy wątek w stanie Ready / Runnable.

2- w momencie, gdy scheduler wątku decyduje, że wątek wchodzi w rdzeń PROCESORA (priorytet wątku, a także algorytm harmonogramowania OS), metoda run jest wywoływana na Obiekt Runnable (niezależnie od tego, czy jest to bieżący obiekt runnable thread, czy obiekt runnable przekazany do konstruktora wątku) tutaj wątek wchodzi w stan działania i zaczyna wykonywać swoje zadanie (metoda run)

Oddzielne metody start() I run() w klasie Thread zapewniają dwa sposoby tworzenia programów wątkowych. Metoda start() rozpoczyna wykonywanie nowego wątku i wywołuje metodę run (). Metoda start() powraca natychmiast, a nowy wątek normalnie trwa, dopóki metoda run() nie powróci.

Metoda run() klasy wątku nic nie robi, więc podklasy powinny nadpisać metodę kodem do wykonania w drugim wątku. Jeśli wątek jest utworzony z Runnable argument, metoda run () wątku wykonuje zamiast tego metodę run() obiektu Runnable w nowym wątku.

W zależności od charakteru programu z wątkiem, wywołanie metody run () wątku bezpośrednio może dać taki sam wynik jak wywołanie metody start (), ale w tym drugim przypadku kod jest faktycznie wykonywany w nowym wątku.

Start () wywołanie metody run override metoda rozszerzonej klasy wątku i implementuje interfejs Runnable.

Ale wywołując run() szuka metody run, ale jeśli implementuje interfejs Runnable, to wywołuje run () nadpisuje metodę Runnable.

Ex.:

`

public class Main1
{
A a=new A();
B b=new B();
a.run();//This call run() of Thread because run() of Thread only call when class 
        //implements with Runnable not when class extends Thread.
b.run();//This not run anything because no run method found in class B but it 
        //didn't show any error.

a.start();//this call run() of Thread
b.start();//this call run() of Thread
}

class A implements Runnable{
@Override
    public void run() {
            System.out.println("A ");
    }
}

class B extends Thread {

    @Override
    public void run() {
            System.out.println("B ");
    }
}

`