如何在java中重写thread.start（）方法？

我需要在java代码中实现thread.start（）方法。请通过一个重写thread.start（）方法的示例让我知道它是如何工作的？

您不应该这样做。相反，覆盖

如果不覆盖开始，则覆盖“运行”。您可以通过以下方式简单地实现线程：

new Thread() {
  public void run() {
    //your code here
  }
}.start();
//start will call the logic in your run method

实际上，您可以调用run（）来运行线程，而不是调用start（）来运行线程。但是有一点不同

假设您创建了两个线程：

Thread t1 = new Thread();
Thread t2 = new Thread();

案例1:如果您依次调用“t1.run（）”和“t2.run（）”，它们将开始同步运行t1和t2（顺序运行）

---

案例2：如果您依次调用“t1.start（）”和“t2.start（）”，它们将调用各自的run（）方法，并开始异步运行t1和t2（）。

同意Schildmeijer的观点，不要重写start，而是重写run（）

事实上，尽管start可以被重写（它不是final），但它调用本机start0方法，这反过来会导致VM调用run方法（实际上是从本机线程/进程的上下文）。本机start0方法具有私有访问权限，因此即使您重写了start，我也看不出您如何重现这种影响

调用start（）的客户机位于一个线程内（比如说，主线程），直到run方法完成了它的工作，才会产生另一个线程

---

看看Sun（ahem，Oracle）关于线程的教程，特别是关于的部分。

正如其他人所说，重写

Thread.start（）

不是实现这一点的方法。通常，我也不会重写

Thread.run（）

，而是使用

Runnable

如果必须决定在生成线程后运行哪个方法，可以执行以下操作：

final Runnable runnableA = ...;
final Runnable runnableB = ...;

Runnable r = new Runnable() {
    @Override
    public void run() {
        if (...) {
            runnableA.run();
        } else {
            runnableB.run();
        }
    }
}

Thread thread = new Thread(r);
thread.start();

如您所说，如果您有一个超类和一个子类，其中

run（）

方法被忽略，那么您可以依赖它，并自动调用适当的方法：

Runnable couldBeAOrB = ...;
Thread thread = new Thread(couldBeAOrB);
thread.start();

类工作者实现可运行的{

公开募捐{ 如果（“foo”）{ runFoo（）； }否则{ runBar（）； }}

私有void runFoo（）{ //什么}

私有void runBar（）{ //else}

}

我很确定，您不需要覆盖start方法

顺便说一下：看看java.util.concurrent.Callable

---

您可以像任何其他方法一样覆盖

启动

    Thread myThread = new Thread() {

        @Override
        public void start() {
            // do something in the actual (old) thread
            super.start();
        }

        @Override
        public void run() {
            // do something in a new thread if 'called' by super.start()
        }
    };

但是您必须调用

super.start（）

来创建新线程，并在新线程中调用

run（）

。原始的

start

具有一些您几乎无法模仿的魔力（本机代码）

如果直接从

start（）

（或任何其他方法）中调用

run（）

，它将作为普通方法在实际线程中执行，而不是在新线程中执行。如果不想在新线程中运行某些代码，则没有理由使用线程

您必须将决策逻辑放在

run（）

方法中，如果确实需要，可以使用构造函数中的某个变量集（或另一个方法，最终在

start

中）。我找不到需要这个变量的任何理由，它应该足以在

run（）

中测试条件，正如其他地方已经建议的那样

    class MyThread extends Thread {

        private final boolean flag;

        public MyThread(boolean someCondition) {
            flag = someCondition;
        }

    // alternative  
    //    @Override
    //    public synchronized void start() {
    //        flag = <<someCondition>>
    //        super.start();
    //    }

        @Override
        public void run() {
            if (flag) {
                // do something like super.run()
            } else {
                // do something else
            }
        }
    }

类MyThread扩展线程{
私有最终布尔标志；
公共MyThread（布尔条件）{
flag=someCondition；
}
//另类
//@覆盖
//公共同步的void start（）{
//标志=
//super.start（）；
//    }
@凌驾
公开募捐{
国际单项体育联合会（旗）{
//执行类似super.run（）的操作
}否则{
//做点别的
}
}
}

但是，如果你按照@Henning的建议去做，它将更容易理解和维护

---

它也是一个更面向对象的解决方案…

如果我们提供自己的start方法实现，那么它将像普通的方法调用一样工作，并且只在当前线程堆栈上工作。不会创建新线程。

是，可以覆盖start（）方法
但不应重写它，因为thread类中的实现具有创建新的可执行线程的代码，并且是专门的。

我们可以重写thread类的start/run方法，因为它不是最终的。但不建议重写start（）方法

---

当我们通过Bishal类的对象调用start（）方法时，将不会创建任何线程，所有函数仅由主线程完成。

为什么您认为需要重写它？请告诉我们为什么您不能在run（）中实现逻辑。我有两个run（）方法。我需要决定哪个run（）方法方法应该从特定的start（）方法调用。一个run（）方法在基类中，另一个在派生类中。在您的注释中，您说您有两个run方法？子类中的一个？它不知道在运行时调用哪个吗？可能有助于显示（示例）代码…我必须调用start方法中的逻辑。因此，请让我知道如何使用示例重写start（）方法。在run方法中调用您的逻辑。正如我在上面的评论中所说，.start（）将调用“run”方法中的逻辑，因此，您将代码放在run方法中，我向您保证在调用.start（）时会调用它。正如我在上面所评论的那样，我希望确保调用start（）方法中的特定run（）方法。在我的代码中有两个run（）方法，我希望在start（）方法中确定调用哪个run（）。但是，如果我想要一个线程，它将以两种不同的方式运行。根据不同的条件，有两个不同的run（）方法。然后我们应该用thread.start（）方法启动一个线程，这样我们应该有一个条件

class Bishal extends Thread { 
public void start() 
    { 
        System.out.println("Start Method"); 
    } 
public void run() 
    { 
        System.out.println("Run Method"); 
    } 
} class Main{ 
public static void main(String[] args) 
    { 
        Bishal thread = new Bishal(); 
        thread.start(); 
        System.out.println("Main Method"); 
    } 
}