В чем разница между Thread start() и Runnable run()

Если вы просто вызываете run() непосредственно, он выполняется в вызывающем потоке, как и любой другой вызов метода. Thread.start() требуется на самом деле создать новый поток, так что runnable в run метод выполняется параллельно.

разница в том, что Thread.start() запускает поток, который называет run() метод, в то время как Runnable.run() просто называет run() метод в текущем потоке.

The разница это когда программа вызывает start() метод, a новая поток создается и код внутри run() выполнена новая поток в то время как если вы звоните run() метод непосредственно новые поток будет создан и код внутри run() будет выполняться в текущем потоке напрямую.

другое разница между start() и run() в потоке Java это то, что вы не может звоните start() два раза. После начала, Второй start() вызов бросит IllegalStateException в Java, в то время как вы можете называть run() метод несколько раз, так как это просто обычный метод.

на самом деле Thread.start() создает новый поток и имеет свой собственный сценарий выполнения.

Thread.start() называет run() метод асинхронно, который изменяет состояние нового потока на Runnable.

но Thread.run() не создает новый поток. Вместо этого он выполняет метод run в текущем запущенном потоке синхронно.

если вы используете Thread.run() тогда вы вообще не используете функции многопоточности.

вызов run() выполняется в вызывающем потоке, как и любой другой метод вызова. тогда как Thread.start() создает новый поток. вызов run() - это программная ошибка.

если у вас run() в основном методе, поток основного метода вызовет run метод вместо потока, который требуется запустить.

The start() метод создает новый поток и для которого run() метод должен быть сделано

Thread.start() код регистрирует поток с планировщиком и планировщик вызывает run() метод. Кроме того,Thread это класс В то время как Runnable - это интерфейс.

большинство из этих ответов пропускают общую картину, которая заключается в том, что, насколько это касается языка Java, больше нет разницы между t.start() и r.run() чем между любыми другими двумя методами.

они оба просто методы. Они оба бегут в потоке, который назвал их. Они оба делают то, для чего они были закодированы, а затем оба возвращаются, все еще в том же потоке, к своим абонентам.

самая большая разница в том, что большинство код t.start() и уроженца код, в большинстве случаев, код r.run() будет чистой Java. Но это не большая разница. Код есть код. Машинный код труднее найти и труднее понять, когда вы его найдете, но это все еще просто код, который говорит компьютеру, что делать.

так, что значит t.start() делать?

он создает новый собственный поток, он организует для этого потока вызов t.run(), а затем он говорит ОС, чтобы позволить запуск нового потока. Затем он возвращается.

и что значит r.run() сделать?

самое смешное, что человек, задающий этот вопрос человек, который написал. r.run() делает вы (т. е. разработчик, который его написал) разработал его для этого.

---

t.start() Это метод, который библиотека предоставляет для вашего кода, чтобы вызвать, когда вы хотите новый поток.

r.run() метод вы обеспечьте для библиотека называть на новый поток.

точки, что члены сделали все в порядке, так что я просто хочу добавить что-то. Дело в том, что JAVA не поддерживает множественное наследование. Но что, если вы хотите получить класс B из другого класса A, но вы можете получить только из одного класса. Теперь проблема заключается в том, как" вывести " из обоих классов: A и Thread. Поэтому вы можете использовать Runnable интерфейс.

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

public class B extends A implements Runnable{...

если вы сразу вызываете run() метод, вы не используете многопоточность с run() метод выполняется как часть вызывающего потока.

если вы называете start() метод в потоке, виртуальная машина Java вызовет метод run () и два потока будут выполняться одновременно - текущий поток (main() в вашем примере) и другой поток (Runnable r1 в вашем примере).

взгляните на исходный код start() метод нить класс

 /**
     * 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();

в приведенном выше коде вы не можете видеть вызов run() метод.

private native void start0() отвечает за вызов run() метод. JVM выполняет этот собственный метод.

Start () вызов метода run override метод потока расширенного класса и Runnable реализует интерфейс.

но при вызове run() он ищет метод run, но если класс реализует интерфейс Runnable, то он вызывает метод run () override 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 ");
    }
}

'

в первом случае вы просто вызываете run() метод r1 и r2 объекты.

во втором случае вы фактически создаете 2 новых потока!

start() будем называть run() в какой-то момент!

отдельные методы start() и run() в классе Thread предоставляют два способа создания потоковых программ. Метод start() начинает выполнение нового потока и вызывает метод run (). Метод start() возвращается немедленно, и новый поток обычно продолжается до тех пор, пока не вернется метод run ().

метод run() класса Thread ничего не делает, поэтому подклассы должны переопределить метод с кодом для выполнения во втором потоке. Если поток создается с помощью Аргумент Runnable, метод run() потока выполняет метод run() объекта Runnable в новом потоке вместо этого.

в зависимости от характера вашей потоковой программы, вызов метода Thread run() напрямую может дать тот же результат, что и вызов метода start (), но в последнем случае код фактически выполняется в новом потоке.